前言
在tch第二届中,cairn以图架构ak了全部题目,后来的artex以双图架构拿下了百度agent比赛的第一并且在实战中有不错的成绩,他们都有一个东西—图,这是什么,我们为什么需要他,仅仅是成绩好,我们就去使用吗,是不是过于草率了呢
什么是DAG
很早看过一个说法,当 LLM 学会了”思考”,谁来教它”编排”?
DAG
DAG(有向无环图)是一个满足以下两个条件的有向图:
- 有向性:每条边有明确的方向(从 A 到 B,而非 A-B)
- 无环性:不存在从某个节点出发沿着有向边能回到自身的路径
无环的重要性:如果存在环(A→B→C→A),系统就会陷入死锁——A 等 B 完成,B 等 C 完成,C 等 A 完成,谁也动不了。
我们来个更硬核点的形式,其实一个DAG任务被定义为四元组
- ,是任务节点集合
- ,是有向边集合,表示依赖
- ,节点权重函数(估计执行时间)
- ,是边上的数据传递描述
关键约束
- 无环性:
- 依赖完备:,如果 有前驱,必须前驱完成了才能去执行
- 数据一致性:的输入数据类型和所有的前驱数据类型匹配
那么除了DAG还有什么呢,比如:chain、FSM、BT等等,这里就不展开介绍和对比了,这里说一下DAG的优势和缺点
优势:
- 天然并行:如果没有前置节点就即刻执行
- 拓扑排序:有明确的执行顺序保证
- 可组合:子 DAG 可以作为大 DAG 的节点
- 可验证:环检测、依赖完备性都是多项式时间可解
局限:
- 无法原生表达循环:需要迭代、重试时需要外部实现
- 原生静态:现在可以用动态DAG弥补了
AGENT任务规划的问题
任务拆解
我们在派发一个渗透任务时,一般会给多个url或者是域名,agent拿到后会去主动探测,但是当url很多的时候,他会探测后集体获取js、响应等后主观判断哪个是薄弱资产,然后就去打这个目标
这种方法显然是不合理的,那聪明的你会去派发subagent,让他们每个都认领一部分目标,然后再去打。
那如果我们想更进一步呢?这就是 Agent 任务规划的核心挑战——将用户的一句话转化为一个可执行的 DAG。
问题定义:
- 给定自然语言任务描述 ,生成任务 DAG ,使 满足了 的要求
PS: 这也就是一些所谓的GOAL什么的目标定义什么的
任务粒度问题
在一个很大很大的DAG任务中,我们通常会有几十个节点,那么每个节点中包含是数据是庞大的,我们需要清洗、约定节点展示内容等等的方法去规定粒度选择
一般来说原则很简单:
- 独立性:节点应该有明确的输入/输出,不依赖内部状态
- 可重试:节点失败后可以独立重试,不需要从头开始
- 可并行:不同节点可以分配给不同的执行器
- 有意义:节点对应一个人类可以理解的逻辑步骤
PS: 当然了,在渗透任务中,我们还可以加入更多的原则,比如目标、测试点等等
依赖类型与建模
DAG 中的依赖不只是简单的”A 完成才能做 B”。实际场景中的依赖类型更丰富
| 依赖类型 | 含义 | DAG 表达 | 示例 |
|---|---|---|---|
| 硬依赖 | A 必须成功完成后 B 才能开始 | 有向边 A→B | 端口爆破->web测试 |
| 软依赖 | A 完成后 B 可以开始,但 B 不一定需要 A 的输出 | 有向边(可选标记) | 建议参考 → 生成方案 |
| 条件依赖 | A 的结果决定 B 是否执行 | 条件边 | 检查 → [如果失败] → 修复 |
| 数据依赖 | B 需要 A 的输出作为输入 | 有向边 + 数据标注 | 查询DB → 格式化结果 |
| 资源依赖 | A 和 B 不能同时使用同一资源 | 互斥约束(DAG 外) | 写同一文件 |
在渗透agent的研发中,我们往往在使用上面的每一种(),其中条件依赖最为复杂
条件依赖的 DAG 建模:
条件依赖是最复杂的——它意味着 DAG 的结构在运行时才能确定,就像渗透中我们不断获取到信息,每个信息都不同且在不断的更新,那么我们下一个节点该生成什么样的内容呢?
[检查输入] / \ (valid) (invalid) / \[处理数据] [请求修正] \ / \ / [继续流程]实现方法
- 动态 DAG:运行时根据中间结果动态添加/删除节点和边,这也是常用的方法
- 静态 DAG + 条件边:运行前确定完整的图,条件边标记执行谓词
构建DAG
人话->DAG
其实就是让LLM懂你想干什么,该输出什么样结构化的DAG
单步生成:直接让llm输出完整的DAG
按照如下模板生成dag{ "id": "B03-02", "block": "B03", "fingerprint": "src/repo/orders.ts/findById-no-tenant-predicate", "title": "Order lookup accepts any order id without tenant scoping", "category": "tenant", "severity": "high", "confidence": "high", "status": "confirmed", "locations": [ { "file": "src/api/orders.ts", "line": 88, "symbol": "getOrder" }, { "file": "src/repo/orders.ts", "line": 41, "symbol": "findById" } ], "flow": "req.params.orderId -> getOrder() -> ordersRepo.findById(id) (no tenant predicate) -> row returned", "impact": "Any authenticated user can read any other tenant's order, including billing address and totals", "preconditions": ["authenticated session", "knows or can enumerate an order id"], "evidence": [ { "file": "src/api/orders.ts", "line": 88, "quote": "const order = await ordersRepo.findById(req.params.orderId)" }, { "file": "src/repo/orders.ts", "line": 41, "quote": "return db.select().from(orders).where(eq(orders.id, id))" } ], "repro": "Authenticate as tenant A, GET /api/orders/<id-owned-by-tenant-B>", "existing_mitigations": "authMiddleware applies to /api/*; no tenant predicate anywhere on this path", "needs_runtime": true, "runtime_question": "Does a tenant-A session receive a 200 with tenant-B order data?", "blocked_on": null, "duplicate_of": null, "verification": { "evidence_review": "supported", "cross_audit": "confirmed", "runtime": "confirmed", "arbitration": null }, "remediation": "Scope the repository query by the session tenant id; add a tenant predicate at the repo layer, not the handler", "notes": ""}渐进生成:先分解为子任务,再逐步细化依赖
PROGRESSIVE_PROMPTS = [ # 第一步:识别主要阶段 """将任务 "{task}" 分解为 3-5 个主要阶段,每个阶段一个简短描述。输出 JSON 数组。""",
# 第二步:细化每个阶段 """将阶段 "{phase}" 细化为具体步骤,每个步骤应是一个可独立执行的操作。输出 JSON 数组。""",
# 第三步:建立依赖 """以下是一组任务步骤,请分析它们之间的依赖关系,哪些必须先完成,哪些可以并行? 步骤:{steps} 输出依赖边列表。""",
# 第四步:验证 DAG """验证以下 DAG 是否合理: - 是否有环? - 依赖是否多余? - 粒度是否合适? DAG:{dag_json} 如果有问题,请修正。""",]后者的优势在于准确性、可控性会更高
同时因为难免的bug存在,我们通常还会检测DAG的合法性,比如孤立节点、是否成环、数据类型是否统一等等
动态 DAG
静态 DAG 要求执行前确定完整的图结构,但 Agent 面对的任务往往需要运行时动态调整:
- 某个步骤的结果决定了后续步骤的数量(如:查询返回 N 条记录,每条需要处理)
- 某个步骤的失败需要插入修复步骤
- 用户中途修改了需求
模式一:条件边
class ConditionalEdge: """条件边:运行时决定是否激活"""
def __init__(self, source, target, condition_fn): self.source = source self.target = target self.condition_fn = condition_fn
def should_activate(self, context): return self.condition_fn(context)
# 示例:检查通过 → 部署;检查失败 → 修复 → 重新检查check_deploy_edge = ConditionalEdge( source="检查", target="部署", condition_fn=lambda ctx: ctx["检查结果"] == "通过")
check_fix_edge = ConditionalEdge( source="检查", target="修复", condition_fn=lambda ctx: ctx["检查结果"] == "失败")模式二:扇出/扇入
class MapReduceNode: """扇出-扇入节点:动态创建子任务"""
def __init__(self, map_fn, reduce_fn): self.map_fn = map_fn # 生成子任务 self.reduce_fn = reduce_fn # 聚合结果
def execute(self, inputs): # 1. 扇出:根据输入动态创建子任务 sub_tasks = self.map_fn(inputs)
# 2. 并行执行子任务 results = parallel_execute(sub_tasks)
# 3. 扇入:聚合结果 return self.reduce_fn(results)
# 示例:批量处理用户数据batch_processor = MapReduceNode( map_fn=lambda users: [ProcessUser(u) for u in users], # 动态创建 N 个子任务 reduce_fn=lambda results: aggregate(results) # 聚合所有结果)模式三:自适应 DAG
class AdaptiveDAG: """自适应 DAG:运行时动态修改图结构"""
def __init__(self, initial_dag=None): self.dag = initial_dag or DAG() self.completed = set() self.results = {}
def on_node_complete(self, node, result): """节点完成时的回调:根据结果动态调整 DAG""" self.completed.add(node) self.results[node.id] = result
# 根据结果动态添加节点 if node.type == 'ANALYSIS' and result['has_anomalies']: # 发现异常 → 添加深度分析节点 for anomaly in result['anomalies']: new_node = TaskNode( id=f"investigate_{anomaly.id}", name=f"调查异常: {anomaly.type}", type="INVESTIGATION" ) self.dag.add_node(new_node) self.dag.add_edge(node.id, new_node.id) # 新节点完成后还需要生成报告 report_node = TaskNode( id=f"report_{anomaly.id}", name=f"异常报告: {anomaly.type}", type="REPORT" ) self.dag.add_node(report_node) self.dag.add_edge(new_node.id, report_node.id)
def on_node_failure(self, node, error): """节点失败时的回调:插入修复步骤""" retry_node = TaskNode( id=f"retry_{node.id}", name=f"重试: {node.name}", type=node.type, config=node.config, max_retries=3 ) self.dag.add_node(retry_node)
# 重定向依赖:原节点的后继指向重试节点 for succ in list(self.dag.successors(node.id)): self.dag.remove_edge(node.id, succ) self.dag.add_edge(retry_node.id, succ)
# 重试节点依赖原节点的输入 for pred in self.dag.predecessors(node.id): self.dag.add_edge(pred, retry_node.id)执行模式&DAG
你知道的,现在有Plan-then-Execute和ReAct两种主流执行模式,在使用dag的情况下,他们也会有不同的效果
前者
用户请求 → LLM 生成 DAG → 调度器执行 DAG → 返回结果
优势:全局最优规划,可并行,可预估时间
劣势:规划可能与实际不符,无法灵活应对意外
后者
用户请求 → [思考 → 行动 → 观察] 循环 → 返回结果
优势:灵活,可实时调整
劣势:线性执行,无法并行,容易陷入局部最优
但是我们在自己写agent的时候,往往都是两者一起的
用户请求 → LLM 生成初始 DAG → 执行 DAG(支持并行) ↓ 遇到意外 → ReAct 模式处理 → 更新 DAG → 继续执行
class HybridPlanner: """Plan-then-Execute + ReAct 混合模式"""
def __init__(self, llm, dag_scheduler): self.llm = llm self.scheduler = dag_scheduler
def execute(self, task): # Phase 1: Plan — 生成初始 DAG dag = self._plan_to_dag(task)
# Phase 2: Execute — 带异常处理的 DAG 执行 while not self.scheduler.is_complete(dag): try: results = self.scheduler.step(dag) # 执行一批并行任务 except UnexpectedResultError as e: # Phase 3: ReAct — 异常处理 react_result = self._react_handle(e, dag)
if react_result.action == 'MODIFY_DAG': dag = react_result.modified_dag elif react_result.action == 'REPLAN': dag = self._plan_to_dag(task, context=react_result.context) elif react_result.action == 'ABORT': return ExecutionResult(status='FAILED', error=e)
return ExecutionResult(status='SUCCESS', results=self.scheduler.results)
def _react_handle(self, error, dag): """ReAct 模式处理异常""" thought = self.llm.reason( f"执行 DAG 时遇到异常: {error}\n" f"当前 DAG 状态: {dag.status()}\n" f"请分析原因并决定下一步行动。" ) action = self.llm.decide(thought) return action这样的好处是,DAG提供了并行能力,ReAct提供了更加灵活的处理方法,两者结合就是攻守兼备了
主流DAG
现在的方法很多比如 Apache Airflow 和 LangGraph
Airflow 的 DAG 模型
看看抽象层面
from airflow import DAGfrom airflow.operators.python import PythonOperatorfrom datetime import timedelta
with DAG( dag_id='agent_task_pipeline', default_args={ 'retries': 3, 'retry_delay': timedelta(minutes=5), }, schedule_interval=None, # 手动触发) as dag:
# 定义任务节点 fetch_data = PythonOperator( task_id='fetch_data', python_callable=fetch_from_api, )
clean_data = PythonOperator( task_id='clean_data', python_callable=clean_dataset, )
train_model = PythonOperator( task_id='train_model', python_callable=train_ml_model, )
evaluate = PythonOperator( task_id='evaluate', python_callable=evaluate_model, )
# 定义依赖(DAG 边) fetch_data >> clean_data >> train_model >> evaluateAirflow 的核心设计理念:
- DAG 即代码:用 Python 代码定义,可版本控制
- 静态优先:DAG 结构在解析时确定,运行时不可变
- 重试与回填:失败任务自动重试,支持历史回填
- 传感器(Sensor):等待外部条件的特殊节点
里面的 传感器 就可以拿出来当用户输入的东西,包括渗透的时候临时添加资产什么的,并且重试和回填机制是Agent容错的基础
LangGraph 的状态图模型
LangGraph 是专门为 LLM Agent 设计的图引擎,其核心创新是将状态引入 DAG
from langgraph.graph import StateGraph, END
# 定义状态类型class AgentState(TypedDict): messages: list[BaseMessage] next_action: str documents: list[Document]
# 构建状态图workflow = StateGraph(AgentState)
# 添加节点workflow.add_node("researcher", research_node)workflow.add_node("writer", writer_node)workflow.add_node("reviewer", review_node)
# 添加条件边workflow.add_conditional_edges( "reviewer", should_continue, { "continue": "writer", # 修改后重新审校 "end": END, # 审校通过,结束 })
# 添加普通边workflow.add_edge("researcher", "writer")workflow.add_edge("writer", "reviewer")
# 设置入口workflow.set_entry_point("researcher")
# 编译app = workflow.compile()两者之间对比一下,你就可以发现,后者是在动态性和状态上加入了能力,并且你可以发现,后者在一定程度上并不是一个合规的DAG?因为他是支持循环边的,用状态图扩展了 DAG 的表达力——循环不再是”结构性循环”,而是”迭代性循环”,每次循环的状态不同。
DAG的代价
在选择 DAG 策略时,需要考虑 LLM 调用的代价:
单次 LLM 调用成本:
其中 是 token 数, 是每千 token 价格。
DAG 执行总成本:
关键优化:
- 减少不必要的 LLM 调用(用确定性步骤替代)
- 压缩上下文传播(不要把整个中间结果都传给下游)
- 增加并行度以减少时间成本(但可能增加 token 成本)
后面的就是多agent之间的协作、测试、前端可视化还有交互式 DAG 编辑
在渗透中
哎嘿嘿嘿嘿,这才是正文啊xd
在前面的章节中,我们看了dag的规划和执行,但是在渗透中,我们的图是什么样的呢?
在实际渗透中,我们的往往只知道目标、目的,比如
对 *.xxx.com 进行渗透测试,目的是rce
其中过程全部未知,而这些就是我们需要构建的DAG,而在这个过程中,我们会不断的追加边和节点
其实这部分很多文章都分析了一些项目,我感觉没有必要一直写了,无非是所谓的 fact+origin+goal 然后去不断的优化修改,所做的也就是把更多有意义的东西写入,然后改变调度时思考的情况,比如是在单节点结束后就thinking然后生成下一个边还是怎么样,过度的分析反倒是没有意义了,这里我们看看压缩机制
DAG中的压缩
在tch2中绿盟ai小分队用了rtk作为压缩处理方法,并且用其他的agent进行简单的提炼,想以此方法让上下文压缩的精度损失最低
在cairn和artex两个项目中,都以dag为主,看看他们的处理方法吧
cairn
其实在我眼里,前者的处理因为比赛的原因没有仔细打磨的,在docs/specs/server-protocol.md里面写了
描述文本应是探索结论的提炼,而非原始数据。当原始输出较大时(如扫描结果),描述应包含关键洞见和原始数据的文件引用,例如:"nmap 全端口扫描发现 22/80/443/8080 开放,80 和 8080 均为 HTTP 服务,详细结果见 /tmp/scans/nmap_192.168.1.10.xml"。这保证图保持轻量,同时原始数据仍可追溯。这是单节点去写入fact的方法,并且保存成yaml,并且conclude阶段强制只写本次增量,不重复图上已有的,不写长数据块
感觉处理比较好的点是cairn/src/cairn/dispatcher/config.py里面定义了
class ReasonTaskConfig(BaseModel): timeout: int = Field(gt=0) max_intents: int = Field(gt=0, default=3)也就是每轮最多三个意图,相比于artex,我更感觉这样是合理的,可以让整个链路稳定的向下走,并且token消耗也可以把握住
因为dag的不断扩充,一些信息会被稀释掉,所以他也写了
除了人工补充的策略提示,Hint 也适合用于消费者之间传递**态势评估**。随着图增长,大量已排除的方向会稀释有效信息。消费者在完成一轮探索后,可将对当前局势的判断写为 Hint(如"SSH 和 SQL 注入方向均已排除,攻击面集中在文件上传功能"),帮助后续消费者快速定位重点,降低每轮读图的认知成本。你可以发现这个开源项目并没有很多的细节处理,不知道闭源的是不是处理完了,下面看看后者
artex
假设图会膨胀,我们需要的就不止是一个静态的只能写入的图了
写入层面
在worker.go里面写了
const workerDefaultTmpl = `你是一个网络安全平台授权渗透测试系统的"执行者"(work agent)。你领到【一条意图】(一句话探索方向),唯一职责:**完成这一条意图、把发现写回知识图谱、然后停止返回。**
**边界(红线)**:1. **只做你领到的这一条意图**。**探本意图时若瞥见本意图之外值得深挖的线索**(报错泄露的路径、可能与其它资产联动的点、疑似另一条利用链的入口),**在 fact 的 summary 里点一句交给规划者**。2. 初次受阻(payload 被过滤 / 404 / 注入无回显)不代表已探透——把本意图的所有绕过手段走完再输出结论;3. 只在授权范围内操作。系统提示顶部若附【操作约束】,那是最高优先级红线:每条命令/探测执行前先自检,违反即不做(哪怕它落在你领到的意图里)。
**边发现边写回**(写进图才算数,脑子/文字里的不算;每得一个结果立刻写,别攒到最后被步数耗尽丢掉)。三种写回,别串图:- **新资产/资源 → insert_assets(资产图)**:子域 / service / endpoint / 指纹 / 凭据 等一切资产【本身】。**这里只登记资产;探索结论/判断不写这里,用 record_fact。**- **探索结论/事实 → record_fact(探索图,传 intent_id)**:都用它。**多个观察汇总成【一条】事实**(summary 一句总结 + detail写对总结的拓展,依靠真实的执行过程),不要一个属性一条、一意图通常只一条,拆碎会让图谱无限膨胀——**默认就写一条,能并进 detail 的都并进去**;仅当确有【彼此完全独立、无法归并】的结论时才用 facts 数组分条,这是极少数例外,不是常规。**只写增量**:只记这次【新得到】的,别把已有事实换措辞重记(只印证已有、无新增就不必记)。**只写真实看到的**:给 evidence(一行:命令+最能证明的一两行输出,简洁,细节在 detail)、标 confidence(observed=直接看到 / inferred=据现象推断)。- **确认漏洞 → report_finding(探索图,含 PoC,传 intent_id)**:**只有你本次真实触发过、拿到可复现证据(请求/响应或命令输出)才用**。严禁把"版本/指纹匹配到 CVE""参数看起来可注入""外部漏洞库/更新日志/代码 diff 推断"当已确认,也不要用查 CVE 库或对比补丁版本替代实际触发。触发不了但有嫌疑 → 用 record_fact 记一条 inferred 事实(嫌疑点+为何未触发)交规划者,别硬记成 finding。
完成本意图后用一句话总结你做了什么、写回了哪些事实。`这就是图的写法,默认写一条,只写增量,原始数据不进图也不进/tmp
func artifactSpec(dir string) string { return "\n\n**中间产物输出规约**:脚本、payload、抓到的响应体、临时数据等一切中间产物,**一律写到本任务工作目录 " + dir + "**(相对路径即写在这里,也可用该绝对路径)——**不要写 /tmp、不要用其它绝对路径**。"}图上引用都是通过索引,并且说明了先查流量,不要重复curl等操作,其实这里因为要搜索等操作,token消耗不一定会减少(),只能说会更快,不过这里也许可以处理一下搜索分词等方法
读取时窗口
在tools.go里面写了
// graphOverviewData computes the distilled situational snapshot shared by the// graph_overview tool and the planner's wake-up prompt (which pre-injects it so// the model needn't spend a turn calling the tool — every plan round starts with// an empty context and always needs this first).func (t *ToolSet) graphOverviewData() map[string]any { out := map[string]any{} // goals summary folded in so the planner needn't call list_goals each round. goals, _ := t.ts.ListByKind(db.KindGoal, 100) gsum := make([]map[string]any, 0, len(goals)) for _, g := range goals { var p map[string]any _ = json.Unmarshal(g.Payload, &p) gsum = append(gsum, map[string]any{"id": g.ID, "state": g.State, "text": p["text"]}) } out["goals"] = gsum // hints: 人类/主 agent 通过 add_hint 挂上图的战略提示;folded in so the // planner reads them every round when generating intents (否则只写不读). hints, _ := t.ts.ListByKind(db.KindHint, 50) hsum := make([]map[string]any, 0, len(hints)) for _, h := range hints { var p map[string]any _ = json.Unmarshal(h.Payload, &p) hint := map[string]any{"id": h.ID, "state": h.State, "text": p["text"]} if findingTrafficBindingEnabled() && p["traffic_refs"] != nil { hint["traffic_refs"] = p["traffic_refs"] } hsum = append(hsum, hint) } out["hints"] = hsum // lineage from the exploration edges: an intent's parents (what it // derived_from — possibly several facts combined) and its yields (the // facts/findings it produced). factFrom maps a fact → the intent that // produced it. This is the relationship layer the flat lists lacked. edges, _ := t.ts.Edges(5000) parentsOf := map[int64][]int64{} yieldsOf := map[int64][]int64{} factFrom := map[int64]int64{} for _, e := range edges { switch e.Rel { case db.RelDerivedFrom, db.RelSpawns: // upstream: derived_from (fact/finding/intent→intent) or spawns (origin fact→goal, legacy begin→intent) parentsOf[e.To] = append(parentsOf[e.To], e.From)...代码太长了放出来要死了(,这里主要是限制了读取的窗口数,在后面的注释里面写了很多设计上的意图,这里就不一直写了,其实看看哪里就知道了。总之是在防止agent上下文爆炸
事件注入
在planner.go里面写了
// renderTriggers spells out the change(s) that fired this round: for a finished// worker — which intent + its output conclusion; for a finding — which intent +// what was found. Empty for time/heartbeat wakes. Reads the store (best-effort;// a blank field never blocks the round).func renderTriggers(ts *db.ExplorationStore, evs []TriggerEvent) string { if len(evs) == 0 || ts == nil { return "" } var b strings.Builder b.WriteString("\n\n【本次触发本轮的实际变动(先看这里,再决定是否补方向)】:") for _, ev := range evs { switch ev.Kind { case "goal": if len(ev.Goals) == 1 { b.WriteString(fmt.Sprintf("\n- 人(主 agent)新增了一个目标:%s —— 新的待达成目标,请据此补充探索方向(若尚无对应意图)。", ev.Goals[0])) } else { b.WriteString(fmt.Sprintf("\n- 人(主 agent)新增了 %d 个目标:%s —— 均为新的待达成目标,请逐一为尚无对应意图的目标补充探索方向。", len(ev.Goals), strings.Join(ev.Goals, ";"))) } case "hint": if len(ev.Hints) == 1 { b.WriteString(fmt.Sprintf("\n- 人(主 agent)新增了一条战略提示:%s —— 已挂到探索图上,请据此调整/补充探索方向(若尚无对应意图)。", ev.Hints[0])) } else { b.WriteString(fmt.Sprintf("\n- 人(主 agent)新增了 %d 条战略提示:%s —— 均已挂到探索图上,请逐一据此调整/补充探索方向。", len(ev.Hints), strings.Join(ev.Hints, ";"))) } case "goal_deleted": b.WriteString(fmt.Sprintf("\n- 人删除了该目标:%s —— 该目标已移除,请据此重判剩余目标/方向(不必再为它派意图)。", ev.Detail)) case "goal_edited": b.WriteString(fmt.Sprintf("\n- 人修改了目标,由「%s」变为「%s」—— 请据新目标调整探索方向(原方向若已不适用请停派)。", ev.OldGoal, ev.NewGoal)) case "finding": b.WriteString(fmt.Sprintf("\n- 意图 #%d(%s)的 worker 报告了一个 finding:%s", ev.IntentID, intentSummary(ts, ev.IntentID), ev.Detail)) case "cancelled": // 意图内容优先用删除时捕获的 Summary(真删除后节点已不存在,intentSummary 查不到)。 sm := ev.Summary if sm == "" { sm = intentSummary(ts, ev.IntentID) } b.WriteString(fmt.Sprintf("\n- 意图 #%d 由用户删除,意图内容是:%s、删除原因是:%s。该意图已删除(不再执行);请据此重新规划。", ev.IntentID, sm, ev.Detail)) default: // "done" b.WriteString(fmt.Sprintf("\n- 意图 #%d(%s)的 worker 结束,输出结论:%s", ev.IntentID, intentSummary(ts, ev.IntentID), workerOutput(ts, ev.IntentID))) if fids := factIDsYielded(ts, ev.IntentID); fids != "" { b.WriteString(fmt.Sprintf(";本意图新产生的事实 id:%s ", fids)) } } } b.WriteString("\n(完整细节可 node_detail / get_worker_output / list_findings 再查。)") return b.String()}主要内容是不要扫描全部图,并且worker结论截800字,感觉这里有点搞()
折叠
写入纪律和读取窗口说到底都是节流,真正让图变小的是折叠。这些手段其实都隐含承认了一件事:图只会越来越大,少写少读只是延迟爆炸,那就得接受有些节点这辈子不会被看第二眼,让它们以摘要的形式活着就好
判冷的算法在coldgraph.go里面
// hotSet computes the hot nodes (§2 rule 1+2): a node is hot iff it can reach a // live intent by going downstream (it is an ancestor of a live intent), OR it is // a live intent, OR it is a direct child of a live intent (rule 1: an open/ // running intent's freshly produced facts stay hot). Everything else is cold- // eligible. "Any live branch keeps the whole chain hot" falls out of ancestor // marking. Iterative (no recursion) to tolerate deep chains and cycles. func (g *coldGraph) hotSet() map[int64]bool { hot := map[int64]bool{} var stack []int64 for _, n := range g.nodes { if isLiveIntent(n) { stack = append(stack, n.ID) } } // Walk upstream from every live intent, marking all ancestors hot. for len(stack) > 0 { id := stack[len(stack)-1] stack = stack[:len(stack)-1] if hot[id] { continue } hot[id] = true stack = append(stack, g.parents[id]...) } // A live intent's direct children (its fresh facts) stay hot (rule 1). for _, n := range g.nodes { if isLiveIntent(n) { for _, c := range g.children[n.ID] { hot[c] = true } } } return hot }注意判冷不按时间、按图上的位置:从每个活跃意图沿上游把所有祖先标热,活跃意图刚产出的 fact 也算热。所以一个三天前的节点只要还是某个活跃意图的前置,它就永远热;反过来一个刚写入的 fact 如果没有任何活跃分支引用它,连续冷够 6 个规划轮次(R=6 防抖)才是折叠候选。防抖记的是第一次变冷的轮次而不是最后一次活跃,复活才清零——“冷了多久”的信息不会丢。能被折叠的只有 fact 和已结算的intent,finding/goal/hint 永远不折
而压缩本体是一次独立的 LLM 调用,用prompt注入压缩的,主要的核心是在有损压缩里保住DAG语义
被折叠的成员如果重新被新意图引用怎么办呢?在tools.go里面写了
covered, _ := t.ts.CoveredMembers() // Render-time hot set (ancestor of a live intent / fact under a live intent). // §6 revival check: a covered member that revived (now hot) must NOT stay folded // — hidden() only folds a member out when it is covered AND still cold. Computed // every round (cheap for real graph sizes); nil map degrades safely. var hotAtRender map[int64]bool if cg, _, err := loadColdGraph(t.ts); err == nil { hotAtRender = cg.hotSet() } hidden := func(id int64) bool { _, c := covered[id]; return c && !hotAtRender[id] }注意折叠不是删除,只是可见性。
其他的就不仔细分析了,主要就是分析DAG里面的处理
总结
难道真的没有比DAG更适合渗透环境的东西了吗???也许有一天,我们会研究出来一个比DAG更好、更轻、更省钱的东西呢??
部分信息可能已经过时