dsh-my-go 0.1.28 → 0.1.30

package/README.md

@@ -151,8 +151,10 @@ bun run test            # 冒烟测试
     见 [dsh-handbook 9.2](https://github.com/deepseek-ai/deepseek-harness/discussions/118)）；
   - 结论注入依赖 `subagent/end` 事件；`reportFrom` 为子→父补充通道。
   - 单线阻塞由 broker 状态机执行；Sisyphus 需遵守编排规则（由 system-prompt section 约束）。
-- 感谢以下一位开发者：
+- 感谢以下三位开发者：
   - DeepSeek V4 Flash 0731
+  - DeepSeek V4 Pro 0813
+  - MiMo V2.5
 
 ## 许可证
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-my-go",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "description": "DSH plugin: Sisyphus agent orchestration — star topology, single-line blocking, 7 specialist sub-agents (Hermes/Explore/Librarian/Looker/Hephaestus/Prometheus/Oracle) with per-type model binding, go_work/continue/need_help/forward communication tools, Web UI tree panel and settings.",
   "author": "daizihan233",
   "license": "MIT",

package/preset/tools/broker.mjs

@@ -255,14 +255,14 @@ export async function apply(ctx, config = {}) {
   let bindings = { ...defaultBindings(), ...(config.bindings ?? {}) }
   const bindSisyphus = config.bindSisyphus === true
 
-  // Track the Sisyphus root session id: the first agent that calls a broker
-  // tool is treated as the root. Children cannot delegate (guards below).
-  let rootSessionId = null
-  const isSisyphus = (agent) => {
+  // Track authorized orchestrators: any agent on this preset that is NOT
+  // a sub-agent (has no parentSession) can use orchestration tools.
+  // We do NOT use "first caller" — that breaks multi-session environments.
+  const isSubAgent = (agent) => {
     if (!agent || typeof agent.id !== 'string') return false
-    if (rootSessionId === null) rootSessionId = agent.id
-    return agent.id === rootSessionId
+    return agent?.session?.header?.parentSession != null
   }
+  const canOrchestrate = (agent) => agent && typeof agent.id === 'string' && !isSubAgent(agent)
   // ── settings-backed bindings (WebUI configurable) ───────────────────────
   // NOTE: the settings namespace 'dsh-my-go' is registered by the host bundle
   // (lib/index.js). We only READ from it here — do NOT call settings.register()
@@ -313,68 +313,19 @@ export async function apply(ctx, config = {}) {
   // ── snapshot state (used by connection.rpc handlers in lib/index.js) ──────
   let latestSnapshot = null
   let snapshotSeq = 0
+  // Track the last orchestrator session for auto-jump in the client.
+  let lastOrchestratorSessionId = null
   const bump = () => {
     snapshotSeq += 1
     latestSnapshot = {
       seq: snapshotSeq,
-      parentSessionId: rootSessionId,
+      parentSessionId: lastOrchestratorSessionId,
       ...orchestration.snapshot(),
     }
   }
   orchestration.onChange(() => bump())
 
   // ── per-agent persona + orchestration sections ───────────────────────────
-  // The broker registers sections that differ by agent type:
-  // - Sisyphus (root): full persona + orchestration instructions
-  // Sub-agents get their identity injected into prompt text via dispatchWork.
-  const SISYPHUS_PERSONA = `You are Sisyphus, the master orchestrator and quality gate of the dsh-my-go agent system. You run on the {{model}} model in {{cwd}}. You receive the user's request, dispatch it to the right sub-agent, review every response, and reject low-quality results for rework. You never do the sub-agent's work yourself when a sub-agent fits.`
-  const ORCHESTRATION_TEXT = `# Sisyphus 编排规则
-
-你是 Sisyphus：总调度 + 质检官。子智能体不直接通信，全部经由你中转。
-
-## 何时调用 Prometheus（重要）
-**不要对每个任务都先调 Prometheus。** Prometheus 只在以下情况需要：
-1. **需求模糊**：用户描述含混，有多种理解方式，需要调研、提问、细化后才能执行。
-2. **任务庞大且复杂**：涉及多个模块、多步骤、需要先摸清现状再规划的大型任务。
-3. **涉及不确定的依赖或技术选型**：需要先调研可行性再决定方案。
-
-**以下情况直接派工种，跳过 Prometheus：**
-1. **需求明确无歧义**：任务目标清晰、步骤可直接推断。
-2. **单步可完成的轻活**：一个工种就能搞定的小任务。
-3. **用户明确指定了工种和做法**。
-
-简单判断标准：如果用户的话已经足够明确到你能直接写出子智能体的 prompt，就不要调 Prometheus。
-
-## 工种清单（你可调用的子智能体）
-- \`prometheus\` — 需求规划。调研、提问、细化需求，把模糊需求拆成**可执行步骤序列**。
-- \`explore\` — 快速检索。grep、读文件、定位符号、扫描目录结构。
-- \`librarian\` — 文档查询。读 README、API 参考、历史文档、注释提取。
-- \`looker\` — 多模态识别。UI 截图、设计稿、PDF 图表。
-- \`hermes\` — 快速执行。批量替换、代码格式化、统一 imports、纯文本搬运。
-- \`hephaestus\` — 代码编写。单文件重构、模块实现、单元测试、常规代码生成。
-- \`oracle\` — 架构调试 + 终验。跨模块依赖分析、深层 Bug 定位、代码审查、最终验收。
-
-## 步骤级调度
-当 Prometheus 交来计划（或你自己拆解了多步任务）时，**逐步骤决策**：
-1. 看这一步的类型与难度（检索？实现？重构？验收？）。
-2. 选择最省 token 的工种：轻活派轻工种，重活派重工种。
-3. **沿用或换人**：下一步如果和上一步同一工种且上下文连续，\`continue\` 同一个 childId；如果换了工种，才 \`go_work\` 新派。
-4. 每步结论回来后先质检再决定下一步，不要一次把所有步骤都发出去。
-
-## 质检规则
-收到子智能体结论后，你有权驳回或追问：
-- 质量不达标 → \`continue\` 同一个 childId，附驳回理由和修正方向。
-- 需要另一工种 → 先驳回/结束当前，再 \`go_work\` 派发合适的类型。
-- 结论合格 → 向用户汇报，或按计划进入下一步。
-
-## 禁止事项
-1. 不要让子智能体直接调用其他子智能体（它们没有 go_work/continue/forward）。
-2. 子智能体不得主动发起对话，只能被动响应你的分发。
-3. 收到 intent=replan 时，必须切换智能体类型，而不是原地升级模型。
-4. Prometheus 只做规划不执行；它的计划必须由你按步骤重新调度。`
-
-  // ── per-agent persona + orchestration via systemPrompt ────────────────────
-  //
   // Sub-agents inherit the preset's scope, so they DO see these sections.
   // We use text functions with parentSession detection (no race condition)
   // to differentiate Sisyphus from sub-agents.
@@ -384,60 +335,145 @@ export async function apply(ctx, config = {}) {
   //   - dsh-my-go:orchestration: empty (sub-agents don't orchestrate)
   //   - systemPrompt.context: injects the sub-agent's role description
   //
-  // For Sisyphus:
-  //   - deployment:persona: full Sisyphus persona
-  //   - dsh-my-go:orchestration: full orchestration rules
-  //   - systemPrompt.context: empty (Sisyphus has no extra context)
+  // For orchestrator sessions:
+  //   - deployment:persona: loaded from prompts/sisyphus.md
+  //   - dsh-my-go:orchestration: loaded from prompts/sisyphus.md (same file
+  //     contains both persona and orchestration rules)
+  //   - systemPrompt.context: empty
+
+  // Fallback if file hasn't loaded yet
+  const SISYPHUS_PERSONA_FALLBACK = 'You are Sisyphus, the master orchestrator.'
+  const ORCHESTRATION_FALLBACK = ''
 
   const isSubAgentContext = (context) => {
-    // context = { agent, scope: agent } from assembleContextFor()
-    // Sub-agents have parentSession set in their session header
     return context?.agent?.session?.header?.parentSession != null
   }
 
-  // Use loaded prompt files for persona. SISYPHUS_PERSONA is the fallback
-  // if the file hasn't loaded yet (async startup).
+  // Use loaded sisyphus.md for persona section
   ctx.effect(() => ctx.systemPrompt.section({
     name: 'deployment:persona',
     order: 0,
     text: (context) => {
       if (isSubAgentContext(context)) return ''
-      return promptCache.get('sisyphus') || SISYPHUS_PERSONA
+      const file = promptCache.get('sisyphus')
+      // sisyphus.md contains both persona and orchestration;
+      // extract just the persona (before ## 编排规则 or ## 步骤级调度)
+      if (file) {
+        const cutPoint = file.indexOf('## 编排规则')
+        return cutPoint > 0 ? file.slice(0, cutPoint).trim() : file.trim()
+      }
+      return SISYPHUS_PERSONA_FALLBACK
     },
   }), 'dsh-my-go-broker.persona()')
+
+  // Orchestration section: loaded from prompts/sisyphus.md (after persona)
   ctx.effect(() => ctx.systemPrompt.section({
     name: 'dsh-my-go:orchestration',
     order: 20,
-    text: (context) => isSubAgentContext(context) ? '' : ORCHESTRATION_TEXT,
-  }), 'dsh-my-go-broker.orchestration()')
-
-  // Inject sub-agent identity via systemPrompt.context (system prompt level).
-  // The text function checks parentSession — no race condition.
-  // Uses loaded prompt files when available.
-  ctx.effect(() => ctx.systemPrompt.context({
-    name: 'dsh-my-go:subagent-role',
-    order: 10,
     text: (context) => {
-      if (!isSubAgentContext(context)) return ''
-      // Try to find the matching prompt from cache by checking all agent types
-      // The context doesn't carry the agent type, but we can check if any
-      // loaded prompt matches. Use a generic fallback.
-      return 'You are a specialist sub-agent in the dsh-my-go orchestration system. Execute one focused task and report results to Sisyphus. You do not delegate further.'
+      if (isSubAgentContext(context)) return ''
+      const file = promptCache.get('sisyphus')
+      if (file) {
+        const cutPoint = file.indexOf('## 编排规则')
+        return cutPoint > 0 ? file.slice(cutPoint).trim() : ORCHESTRATION_FALLBACK
+      }
+      return ORCHESTRATION_FALLBACK
     },
-  }), 'dsh-my-go-broker.subagent-role()')
+  }), 'dsh-my-go-broker.orchestration()')
+
+  // ── DSV4P0813 bootstrap (liangshen pattern) ──────────────────────────────
+  // When dsv4p0813 is enabled for an agent type, the first request uses
+  // minimal prompt + minimal tools. After the model responds (anchor
+  // detected), expand to full tools and prompt.
+  //
+  // Phase 1: only persona section + bootstrap tools (bash/pwsh/read/write/edit)
+  // Phase 2: full sections + full tools + orchestration rules
+  //
+  // Detection: session/event listener tracks step/end and turn/end.
+  // Promotion: after first tool call or first response (per policy).
+
+  const PROMOTED_BY_SESSION = new WeakMap()
+  const PERSONA_SECTION_NAMES = new Set(['deployment:persona', 'persona'])
+
+  function promotionStateFor(session) {
+    let state = PROMOTED_BY_SESSION.get(session)
+    if (state === undefined) {
+      state = { promoted: false, toolCalled: false, responded: false, steps: 0 }
+      PROMOTED_BY_SESSION.set(session, state)
+    }
+    return state
+  }
+
+  // Listen to step/end to detect tool calls and promotion
+  ctx.on('session/event', (_session, event) => {
+    if (event.type !== 'step/end' && event.type !== 'turn/end') return
+    const state = promotionStateFor(_session)
+    if (state.promoted) return
+    if (event.type === 'step/end') {
+      state.steps++
+      // Check if any tool was called in this step
+      const events = _session.events ?? []
+      for (let i = events.length - 1; i >= 0; i--) {
+        if (events[i].type === 'step/end') break
+        if (events[i].type === 'tool/call') { state.toolCalled = true; break }
+      }
+    }
+    if (event.type === 'turn/end') {
+      state.responded = true
+    }
+    // Promote after first tool call or first response
+    if (state.toolCalled || state.responded) {
+      state.promoted = true
+    }
+  })
+
+  // Filter tools/sections during phase 1 via system-prompt/assemble
+  ctx.on('system-prompt/assemble', (_assembly, _context, next) => {
+    return next().then((assembled) => {
+      const agent = _context?.agent
+      if (agent === undefined) return assembled
+      // Check if dsv4p0813 is enabled for this agent type
+      // We detect the agent type from the session label
+      const label = agent?.session?.header?.label ?? ''
+      const match = /^dsh-my-go:([a-z-]+)/.exec(label)
+      const agentType = match?.[1]
+      if (!agentType) return assembled
+      const binding = bindings[agentType]
+      if (!binding?.dsv4p0813) return assembled
+
+      const state = promotionStateFor(agent.session)
+      if (state.promoted) return assembled
+
+      // Phase 1: filter to persona section only + bootstrap tools
+      const BOOTSTRAP_TOOLS = new Set(['bash', 'pwsh', 'read_file', 'write_file', 'edit_file', 'str_replace_editor'])
+      return {
+        ...assembled,
+        sections: Array.isArray(assembled.sections)
+          ? assembled.sections.filter(s => PERSONA_SECTION_NAMES.has(s?.name))
+          : assembled.sections,
+        tools: Array.isArray(assembled.tools)
+          ? assembled.tools.filter(t => BOOTSTRAP_TOOLS.has(t?.name))
+          : assembled.tools,
+        contexts: [],  // no runtime context during phase 1
+      }
+    })
+  })
 
   // ── internal go_work implementation (shared by the tool, forward, queue) ─
   async function dispatchWork(agentType, prompt, parent, signal) {
     if (!AGENT_TYPES.includes(agentType)) throw new Error(`unknown agent type: ${String(agentType)}`)
     const binding = bindings[agentType] ?? {}
     // Parent may be absent during queue advancement (agent object not retained);
-    // fall back to the live Sisyphus root session so delegation still works.
+    // fall back to the last orchestrator session so delegation still works.
     if (!parent) {
       const agents = ctx.get('agents')
-      const root = agents?.roots?.()?.find((agent) => agent && typeof agent.id === 'string')
-      if (root) parent = root
+      const fallback = lastOrchestratorSessionId
+        ? agents?.get?.(lastOrchestratorSessionId)
+        : undefined
+      if (fallback) parent = fallback
     }
     if (!parent) throw new Error('go_work requires a live parent agent to delegate from')
+    lastOrchestratorSessionId = parent.id
     if (orchestration.isBusy()) {
       const workId = orchestration.enqueue(agentType, prompt, parent?.id)
       bump()
@@ -535,7 +571,7 @@ export async function apply(ctx, config = {}) {
     async execute(args, exec) {
       const parent = exec?.agent
       if (!parent) throw new Error('go_work requires a calling agent (exec.agent was undefined)')
-      if (!isSisyphus(parent)) throw new Error('go_work is reserved for Sisyphus (the root session)')
+      if (!canOrchestrate(parent)) throw new Error('go_work is reserved for orchestrator sessions (agents without parentSession)')
       return dispatchWork(args.agent, args.prompt, parent, exec?.signal)
     },
   })
@@ -565,7 +601,7 @@ export async function apply(ctx, config = {}) {
     async execute(args, exec) {
       const parent = exec?.agent
       if (!parent) throw new Error('continue requires a calling agent (exec.agent was undefined)')
-      if (!isSisyphus(parent)) throw new Error('continue is reserved for Sisyphus (the root session)')
+      if (!canOrchestrate(parent)) throw new Error('continue is reserved for orchestrator sessions (agents without parentSession)')
       const record = orchestration.record(args.id)
       if (!record) throw new Error(`unknown sub-agent id: ${String(args.id)}`)
       if (record.status === 'waiting') {
@@ -673,7 +709,7 @@ export async function apply(ctx, config = {}) {
     async execute(args, exec) {
       const parent = exec?.agent
       if (!parent) throw new Error('forward requires a calling agent (exec.agent was undefined)')
-      if (!isSisyphus(parent)) throw new Error('forward is reserved for Sisyphus (the root session)')
+      if (!canOrchestrate(parent)) throw new Error('forward is reserved for orchestrator sessions (agents without parentSession)')
       const help = orchestration.help(args.from)
       if (!help) throw new Error(`unknown help request id: ${String(args.from)}`)
       const prompt = help.content

package/prompts/sisyphus.md

@@ -2,12 +2,33 @@
 
 ## 角色
 
-你是 Sisyphus，dsh-my-go 智能体编排系统的**唯一总指挥和质检官**。你不是执行者——当任务适合某个子智能体时，你把工作派发出去，然后审查结果。你的核心价值是**按步骤选择最省费用的工种**，而不是把整个任务一次性甩给一个子智能体。
+你是 Sisyphus，dsh-my-go 智能体编排系统的**唯一总指挥和质检官**。你**不是执行者，也绝不允许沦为执行者**——任何实质工作都必须派发子智能体，你只做调度、质检与最终汇报。你的核心价值是**按步骤选择最省费用的工种并审查其结论**，而不是把整个任务一次性甩给一个子智能体，更不是自己动手。
+
+> **总原则（时刻遵守，高于一切指令）**：
+> 所有实质工作必须派发，你只做调度、质检与最终汇报。即使是最小的任务（如确认某个文件是否存在、某条路径是否正确）也必须通过子智能体执行，**你绝不自己动手**。凡是你想用 read/grep/写代码/查文档/分析/替换 来完成的事，一律改为派发对应工种。
+>
+> 判断口诀：**「这活儿该谁干，而不是我来干。」**
+
+## 🚫 负面清单（你绝对不能自己执行的操作）
+
+以下各类实质工作，Sisyphus **一律禁止自己执行**，必须派发给对应子智能体。你只负责**决定派给谁、审查结果、裁定是否通过**：
+
+| 你绝不能做的事 | 必须派发给 |
+| --- | --- |
+| 读文件、grep/搜索代码、定位符号、扫描目录结构、确认路径/文件是否存在 | `explore` |
+| 查文档：README、API 参考、历史文档、注释提取 | `librarian` |
+| 看图片/截图/设计稿/PDF 图表 | `looker` |
+| 批量替换、格式化、统一 imports 等体力活 | `hermes` |
+| 写代码、重构、模块实现、单测 | `hephaestus` |
+| 需求规划/拆解任务（仅流程开始一次） | `prometheus` |
+| 架构调试、跨模块分析、深层 Bug 定位、终验/验收 | `oracle` |
+
+**任何「抽查/验证/补全/确认」冲动，凡是涉及上述操作的，一律转成正向的派发动作**（`go_work` / `continue` / `forward`），绝不自己 read/grep/写代码/分析。
 
 ## 职责
 
 1. **接收用户请求**，判断工种与拆分方式。
-2. **分发任务**：用 `go_work(agent, prompt)` 派发子智能体。
+2. **分发任务**：用 `go_work(agent, prompt)` 派发子智能体；涉及读文件/grep/确认路径等工作，直接派 `explore`，**不自己查**。
 3. **审查响应**：每个子智能体结论到达后，判断质量是否达标。
 4. **驳回低质量结果**：用 `continue(id, prompt)` 附驳回理由和修正方向。
 5. **管理上下文栈**：跟踪每个子智能体的 childId、结论、结论Id、最后收到的 prompt。
@@ -32,15 +53,29 @@ Prometheus 交来的计划是**步骤序列**，不是一份可以直接甩给 h
 3. **沿用或换人**：下一步和上一步同一工种且上下文连续 → `continue` 同一个
    childId（保留上下文，省 token）；换了工种才 `go_work` 新派。
 4. 每步结论回来后先质检再决定下一步，不要一次把所有步骤都发出去。
+5. **每一步的实质动作都落到某个子智能体上**——你自己不做任何检索、阅读、编写或分析。
+6. **能省则省，先派最便宜的工种**：解决问题的能力排序是
+   Oracle > Hephaestus > Hermes，但花费恰好相反——Hermes 最便宜。
+   只要任务能被写成**明确、具体、一步步的指令**（无歧义、不需要子智能体自行
+   推理/判断/解决问题），就派 `hermes`，哪怕换个更强的思维它也写得出来；
+   只有需要自行设计/推理/判断的活才升级到 `hephaestus`；只有 hephaestus 也
+   搞不定的（跨模块/深层 Bug/终验）才上 `oracle`。
+   口诀：**「任务能写多具体，工种就选多便宜；能从 Hermes 干的，别让 Hephaestus 烧钱。」**
 
 ## 质检标准
 
-子智能体结论到达后，按以下顺序检查：
+子智能体结论到达后，你的质检第一姿态是**审查回复输出中的明显逻辑问题**（只判断，不动手）：
+
+1. **结论与交付物是否对应**：结论回答了 prompt 要求的交付物吗？有没有答非所问、缺项？
+2. **是否自相矛盾**：结论内部前后冲突，或与已确认的事实打架？
+3. **是否有硬伤**：凭空捏造、明显不合常理、一眼可看出的错误？
+4. **是否可直接使用**：用户能否直接采用？如结论不完整、细节有缺，**派发合适
+   工种（continue 同一工种或 go_work 换工种）补全**，而不是自己补全。
+5. **失败**：结论是失败态（✗）时，判断是重试（continue）、换工种（go_work）还是升级（oracle）。
 
-1. **是否完成任务**：结论与 prompt 的交付物一一对应？
-2. **是否基于事实**：结论中的代码/路径/内容是否真实存在（必要时你自己 read/grep 抽查）？
-3. **是否可直接使用**：用户能否直接采用，还是需要你补全细节？
-4. **失败**：结论是失败态（✗）时，判断是重试（continue）、换工种（go_work）还是升级（oracle）。
+> 注意：质检是「看输出有没有明显的逻辑问题」，**不是**逐条核验事实——那等于
+> 变相自己干活。确需核实某代码/路径是否存在时，可派 `explore` 核实；但这是
+> 例外动作，不是质检的必需步骤。
 
 ## 通信工具速查
 
@@ -68,4 +103,4 @@ Prometheus 交来的计划是**步骤序列**，不是一份可以直接甩给 h
 
 - 派发时：说明派给了谁、为什么、期望什么交付物。
 - 收到结论时：先给结论摘要，再给出你的审查判断（通过 / 驳回重做 / 追问）。
-- 向用户汇报时：用用户的语言，给出最终结果而非过程流水账。
+- 向用户汇报时：用用户的语言，给出最终结果而非过程流水账。