@mars.liu/dsh-cybernetics 0.2.0 → 0.7.8

package/src/controller.ts

@@ -22,6 +22,8 @@ export interface RoundResult {
   verdict?: unknown
   triage?: unknown
   failed?: string
+  /** Execution substrate used for this round (v0.6 audit). */
+  executor?: 'ephemeral' | 'persistent'
 }
 
 /** LLM target overrides for one sub-agent role; workflow `agent()` opts subset. */
@@ -30,6 +32,24 @@ export interface RoleSpec {
   model?: string
 }
 
+/**
+ * Parse a flat agent-model field ("provider/model" or a bare "model" name)
+ * into a workflow `agent()` override. Empty/whitespace/undefined → undefined,
+ * which the caller must treat as「与 session agent 一致」(no override handed
+ * to the round script — the workflow inherits the calling model).
+ */
+export function parseAgentModelSpec(value?: string): RoleSpec | undefined {
+  const raw = (value ?? '').trim()
+  if (!raw) return undefined
+  const slash = raw.indexOf('/')
+  if (slash > 0 && slash < raw.length - 1) {
+    const provider = raw.slice(0, slash).trim()
+    const model = raw.slice(slash + 1).trim()
+    if (provider && model) return { provider, model }
+  }
+  return { model: raw }
+}
+
 /** Per-role sub-agent configuration: 'default'/'verify'/'triage' plus named task roles. */
 export interface RolesConfig {
   default?: RoleSpec
@@ -70,9 +90,122 @@ export interface LoopState {
   role: string
   /** Detailed per-round work order extracted by the calling model; passed to the task agent verbatim. */
   brief?: string
-  /** Lifecycle: running (a round in flight) / paused / met (verify passed, awaits user) / cancelled. */
-  status?: 'running' | 'paused' | 'met' | 'cancelled'
+  /** Round depth: 'quick' = task agent only (lightweight analysis); 'full' = task→verify→triage (default). */
+  depth?: 'quick' | 'full'
+  /** Execution substrate: 'ephemeral' (workflow subagents, default) or 'persistent' (Agent Teams teammate). */
+  executor?: 'ephemeral' | 'persistent'
+  /** Persistent teammate name, set on the first persistent round and reused afterwards. */
+  memberName?: string
+  /**
+   * Lifecycle: running (a round in flight) / paused / met (verify passed, awaits
+   * user) / cancelled / superseded (a revision created a successor goal; this
+   * goal keeps its final state and is never driven again).
+   */
+  status?: 'running' | 'paused' | 'met' | 'cancelled' | 'superseded'
   paused?: { reason: ResumableReason; note: string }
+  /**
+   * Append-only goal lineage (v0.6, user 2026-11-02): a revision never edits the
+   * objective in place — it creates a NEW goal, and the old one keeps its final
+   * state. `parentGoalId` = the goal this one was revised from.
+   */
+  parentGoalId?: string
+  /** Set on a superseded goal: the id of the successor that replaced it. */
+  supersededBy?: string
+  /**
+   * In-place revision log kept for wire compatibility (pre-append-only shape).
+   * v0.6 append-only model: a revision creates a successor goal instead, so new
+   * revisions are recorded as `parentGoalId`/`supersededBy` plus the
+   * `.cybernetics/revisions-<newGoalId>.jsonl` audit line, and this stays empty.
+   */
+  revisions?: Array<{ version: number; reason: string; at: number }>
+}
+
+/** One `revise` transition as written to `.cybernetics/revisions-<newGoalId>.jsonl`. */
+export interface GoalRevisionRecord {
+  /** Superseded goal id. */
+  from: string
+  /** Newly created successor goal id. */
+  to: string
+  /** Why the goal changed (required on the `revise` action). */
+  reason: string
+  /** Epoch milliseconds of the revision. */
+  at: number
+  /**
+   * v0.7: how the old goal's in-flight round was handled, and why. Present on
+   * every revision so the audit trail records the decision basis, not just the
+   * outcome — see `decideAbort` for the decision tree.
+   */
+  abort?: { abort: boolean; mode: 'auto' | 'explicit'; basis: string }
+}
+
+/**
+ * Whether `revise` aborts the old goal's in-flight task agent round, and on
+ * what grounds. Pure — the caller supplies the "is a round in flight" fact
+ * from its own `running` map (no new orchestration mechanism; this reads the
+ * state the controller already maintains).
+ *
+ * Decision tree (v0.7 all-goals mode; `abortPrevious` explicitly passed keeps
+ * the v0.6 manual semantics):
+ * 1. `abortPrevious` given explicitly → honor it verbatim (mode 'explicit').
+ * 2. Old goal has NO round in flight → no abort, start the successor directly.
+ * 3. Old round in flight AND the revision rewrites the goal itself (a new
+ *    `objective`, or a different `depth`) → the old round is working toward a
+ *    target that no longer exists — contradictory goals / write-domain
+ *    conflict → abort it (the cancel path) so it cannot interleave writes.
+ * 4. Old round in flight, correction only (new brief / title / role on the
+ *    same objective) → the old work is still valuable and its result can be
+ *    reused → let the round finish naturally, no abort.
+ */
+export interface AbortDecision {
+  abort: boolean
+  mode: 'auto' | 'explicit'
+  basis: string
+}
+
+export function decideAbort(
+  previous: LoopState,
+  roundInFlight: boolean,
+  args: { abortPrevious?: boolean; objective?: string; depth?: 'quick' | 'full' },
+): AbortDecision {
+  if (args.abortPrevious !== undefined) {
+    return {
+      abort: args.abortPrevious,
+      mode: 'explicit',
+      basis: args.abortPrevious
+        ? '调用方显式要求中止旧轮（abortPrevious: true，复用 cancel 路径）'
+        : '调用方显式要求保留旧轮（abortPrevious: false，跑完自然结束）',
+    }
+  }
+  if (!roundInFlight) {
+    return { abort: false, mode: 'auto', basis: '旧 task agent 无在跑轮（查 goal 板 running 状态），直接启动新 goal，无需中止' }
+  }
+  const retargets = args.objective !== undefined || (args.depth !== undefined && args.depth !== (previous.depth ?? 'full'))
+  if (retargets) {
+    return {
+      abort: true,
+      mode: 'auto',
+      basis: '旧轮在跑且修订改写了目标本身（objective/depth 变化，目标矛盾/写域冲突）——自动中止旧轮，避免旧任务继续写入已被取代的方向',
+    }
+  }
+  return {
+    abort: false,
+    mode: 'auto',
+    basis: '旧轮在跑但任务目标未变（仅 brief/title/role 修正，旧工作仍可复用/可并行）——等待旧轮自然结束，结果由新 goal 继承',
+  }
+}
+
+/** Input for the append-only goal creation path. */
+export interface GoalSeed {
+  goalId: string
+  title?: string
+  /** Overrides the inherited objective when present. */
+  objective?: string
+  /** Goal this one was revised from (lineage link). */
+  parentGoalId?: string
+  depth?: 'quick' | 'full'
+  executor?: 'ephemeral' | 'persistent'
+  role?: string
+  subgoal?: string
 }
 
 /** Append one round's structured result to the per-workspace audit log. */
@@ -85,6 +218,60 @@ async function writeRoundLog(root: string, goalId: string | undefined, round: nu
   await writeFile(join(root, STATE_DIR, `round-${slug}-${round}.json`), JSON.stringify(result, null, 2))
 }
 
+/**
+ * Append one revision line to `.cybernetics/revisions-<newGoalId>.jsonl`.
+ * One line per transition, so a revision chain is readable (and greppable)
+ * without reconstructing it from per-goal fields. The directory is created
+ * lazily; the caller treats a write failure as non-fatal (see `revise`).
+ */
+export async function writeRevisionLog(root: string, newGoalId: string, record: GoalRevisionRecord): Promise<string> {
+  await mkdir(join(root, STATE_DIR), { recursive: true })
+  const slug = newGoalId.replace(/[^a-zA-Z0-9._-]/g, '_')
+  const file = join(root, STATE_DIR, `revisions-${slug}.jsonl`)
+  await writeFile(file, `${JSON.stringify(record)}\n`, { flag: 'a' })
+  return file
+}
+
+/**
+ * Build the successor goal of an append-only revision. Everything the old goal
+ * owned that is not per-round state — title, objective, depth, executor, role —
+ * is inherited unless a seed field overrides it; the new goal starts at round 0
+ * and carries `parentGoalId`. Pure: it neither mutates nor registers anything.
+ */
+export function createGoal(previous: LoopState | undefined, seed: GoalSeed): LoopState {
+  const objective = seed.objective ?? previous?.objective ?? previous?.title ?? ''
+  const title = seed.title ?? previous?.title ?? objective.split('\n')[0].slice(0, 60)
+  const goal: LoopState = {
+    goalId: seed.goalId,
+    title,
+    objective,
+    round: 0,
+    doneSummary: '',
+    subgoal: seed.subgoal ?? (objective.length > 0 ? objective : title),
+    role: seed.role ?? previous?.role ?? 'default',
+    status: 'running',
+  }
+  const depth = seed.depth ?? previous?.depth
+  if (depth !== undefined) goal.depth = depth
+  const executor = seed.executor ?? previous?.executor
+  if (executor !== undefined) goal.executor = executor
+  const parentGoalId = seed.parentGoalId ?? previous?.goalId
+  if (parentGoalId !== undefined) goal.parentGoalId = parentGoalId
+  return goal
+}
+
+/**
+ * Freeze a goal as superseded by a successor. Mutates the loop in place (the
+ * registry holds the same object); the paused marker is dropped so the view
+ * does not mix "awaiting human" with "replaced".
+ */
+export function supersedeGoal(previous: LoopState, newGoalId: string): LoopState {
+  previous.status = 'superseded'
+  previous.supersededBy = newGoalId
+  previous.paused = undefined
+  return previous
+}
+
 /**
  * Start one round's workflow run without awaiting it. Returns the round
  * number and the live run; the caller either awaits `run.result` itself
@@ -109,6 +296,7 @@ export async function startRound(
       state: { round, doneSummary: state.doneSummary },
       subgoal: state.subgoal,
       brief: state.brief,
+      depth: state.depth ?? 'full',
       role: state.role,
       roles: config.roles ?? {},
     },
@@ -137,7 +325,9 @@ export async function foldRound(
   } else {
     result = settled.value as RoundResult
   }
-  await writeRoundLog(root, state.goalId, round, result)
+  // v0.6 audit: record which substrate ran the round.
+  const logged: RoundResult = { ...result, executor: state.executor ?? 'ephemeral' }
+  await writeRoundLog(root, state.goalId, round, logged)
   return { result, decision: decide(result, state, config) }
 }
 

package/src/executor.ts

@@ -0,0 +1,414 @@
+/**
+ * Round executors (v0.6): the substrate that runs one goal round's task work.
+ *
+ * Two substrates, one contract. `WorkflowExecutor` is the v0.5 path: the
+ * controller starts `workflows/round.js` through the agent's workflowEngine and
+ * the whole task→verify→triage loop runs as ephemeral subagents. `TeamExecutor`
+ * replaces only the TASK agent with a persistent Agent Teams teammate
+ * (context:'fresh' — identity persists, conversation history does not), while
+ * verify/triage stay ephemeral workflow agents fed with the teammate's report
+ * (`args.taskReport`) so verification never inherits the task narrative.
+ *
+ * Capture seam: a teammate's final output for one turn is delivered by the
+ * host as `subagent/end` (info.id = the child session id, info.lastAssistantMessage
+ * = ContentBlock[] — the host's `SubagentRunEndInfo` field; the legacy `output`
+ * shape is still accepted as a fallback). The event can settle before
+ * `spawnTeammate` resolves, so the listener is installed before the first spawn
+ * and every settled child is buffered by id until consumed.
+ *
+ * Soft integration: the Agent Teams service is probed at call time through
+ * `agentTeamsOf()`. Two seams, in priority order:
+ *
+ * 1. `ctx.reflect.get('agentTeams')` — Cordis' reflection read ("Read a
+ *    service from the store without the inject requirement") returns the
+ *    service value or `undefined` and needs no `inject` declaration. This is
+ *    the correct seam for a soft/optional integration: it neither pends boot
+ *    nor throws when nothing provides the service.
+ * 2. `ctx.agentTeams` — an exception-safe fallback for older hosts and for
+ *    hand-built test contexts that have no `reflect` seam. Cordis' context
+ *    proxy THROWS on an un-injected service property ("cannot get property
+ *    ... without inject"), which would surface as an internal proxy error, so
+ *    the read is wrapped.
+ *
+ * Whichever seam answers, "not available" is reported as `undefined`: a
+ * session without Agent Teams keeps working with executor 'ephemeral';
+ * requesting 'persistent' there fails with a pointed, structured error
+ * (pointing at ephemeral) instead of a Cordis proxy exception or a hang.
+ * @module dsh-cybernetics/executor
+ */
+
+import type { ControllerConfig, LoopState, RoundResult } from './controller.ts'
+
+/** Everything one round needs from the goal board (a plain snapshot). */
+export interface TeamRoundInput {
+  goalId: string
+  title?: string
+  objective: string
+  round: number
+  subgoal: string
+  brief?: string
+  depth: 'quick' | 'full'
+  doneSummary: string
+}
+
+/** Run-like handle shared by both executors' consumers. */
+export interface TeamRunHandle {
+  round: number
+  memberName: string
+  result: Promise<{ stopReason: string; value?: unknown; error?: unknown }>
+  cancel(reason?: string): void
+  dispose(): Promise<void>
+}
+
+/**
+ * Read a service through Cordis' reflection seam, if this context has one.
+ *
+ * `ctx.reflect.get(name)` is the documented read that bypasses the `inject`
+ * requirement (vendor/cordis/src/reflect.ts): it returns the service value, or
+ * `undefined` when no fiber currently provides it. It is deliberately called
+ * with the default `strict = true`, so only an ACTIVE provider counts — a
+ * service that is mid-teardown must not be handed to an executor.
+ *
+ * Contexts without a reflection seam (older hosts, plain test doubles) have no
+ * `reflect` at all; a malformed or throwing seam is treated the same way.
+ * Every failure mode means "no answer from this seam", never an error.
+ */
+function reflectedService(ctx: unknown, name: string): unknown {
+  try {
+    const reflect = (ctx as { reflect?: { get?: (name: string) => unknown } } | undefined)?.reflect
+    if (reflect === undefined || reflect === null || typeof reflect.get !== 'function') return undefined
+    return reflect.get(name)
+  } catch {
+    // Un-audited reflection implementation: soft integration ⇒ no answer.
+    return undefined
+  }
+}
+
+/**
+ * Read the Agent Teams service without tripping Cordis' proxy guard.
+ *
+ * The reflection seam is tried first — it answers "available" and "absent"
+ * without an `inject`, which is what a soft integration needs. The property
+ * read is only the compatibility fallback: Cordis' context proxy throws
+ * `cannot get property "X" without inject` for a service that was not injected,
+ * so "not available" must be reported as `undefined`, not as a proxy error.
+ * Returns `any` on purpose — the service shape is only known to the host that
+ * mounts it.
+ */
+export function agentTeamsOf(ctx: unknown): any {
+  const reflected = reflectedService(ctx, 'agentTeams')
+  if (reflected !== undefined) return reflected
+  try {
+    return (ctx as { agentTeams?: unknown } | undefined)?.agentTeams
+  } catch {
+    // Un-injected service: Cordis threw. Soft integration ⇒ unavailable.
+    return undefined
+  }
+}
+
+/** Whether this context can host persistent (teammate) executors. */
+export function teamExecutorAvailable(ctx: unknown): boolean {
+  const teams = agentTeamsOf(ctx) as { spawnTeammate?: unknown } | undefined
+  return teams !== undefined && typeof teams.spawnTeammate === 'function'
+}
+
+/** The pointed, structured error for a persistent round without Agent Teams. */
+export function teamExecutorUnavailableError(): Error {
+  return new Error(
+    'cybernetics: executor "persistent" needs Agent Teams (agentTeams) in this session — ' +
+    'the service is not injected here; fall back to executor "ephemeral" for this goal',
+  )
+}
+
+/** ContentBlock text join (the host's output blocks are already text-only here). */
+function outputText(output: unknown): string {
+  if (!Array.isArray(output)) return ''
+  const parts: string[] = []
+  for (const block of output) {
+    if (block !== null && typeof block === 'object' && (block as { type?: string }).type === 'text') {
+      const text = (block as { text?: unknown }).text
+      if (typeof text === 'string' && text.length > 0) parts.push(text)
+    }
+  }
+  return parts.join('\n')
+}
+
+/**
+ * Parse the task agent's output contract: the final message ends with one
+ * single-line JSON object `{"done": true|false, "summary": "...", ...}`.
+ * Missing/invalid marker → not done (the controller then continues or pauses
+ * instead of pretending a turn succeeded).
+ */
+export function parseTaskOutput(text: string): { done: boolean; summary: string; evidence: string } {
+  const marker = /\{[^{}]*"done"\s*:[^{}]*\}/gu
+  let match: RegExpExecArray | null = null
+  for (let m = marker.exec(text); m !== null; m = marker.exec(text)) match = m
+  if (match !== null) {
+    try {
+      const parsed = JSON.parse(match[0]) as { done?: unknown; summary?: unknown; evidence?: unknown }
+      if (typeof parsed.done === 'boolean') {
+        return {
+          done: parsed.done,
+          summary: typeof parsed.summary === 'string' && parsed.summary.length > 0 ? parsed.summary : text.slice(0, 2000),
+          evidence: typeof parsed.evidence === 'string' && parsed.evidence.length > 0 ? parsed.evidence : text,
+        }
+      }
+    } catch {
+      // fall through to the not-done default
+    }
+  }
+  return { done: false, summary: text.slice(0, 2000), evidence: text }
+}
+
+/** The work order a persistent task agent receives on its first round. */
+export function buildWorkOrder(input: TeamRoundInput, roles: ControllerConfig['roles']): string {
+  const lines = [
+    '你是一名持久 task agent（teammate）：你不继承任何会话历史，本委托书是你获得的全部任务信息；',
+    '你在本轮结束后保持存活，后续会收到「委托书修订」，那些消息是同一 goal 的增量要求。',
+    '',
+    '【本轮委托书】',
+    `目标：${input.objective}`,
+    `本轮子目标：${input.subgoal}`,
+    ...(input.brief && input.brief.trim().length > 0 ? ['', input.brief] : []),
+    ...(input.doneSummary && input.doneSummary.trim().length > 0 ? ['', '【既往轮次摘要（不要重做，可依赖其产物）】', input.doneSummary] : []),
+    '',
+    '【执行纪律】',
+    '- 你不是在写计划：必须实际调用工具完成工作，并给出可复现的证据。',
+    '- 完成判定必须可验证：每项交付附上证据（命令输出、文件路径、查询结果）。',
+    '- 被环境阻塞时如实停止，不要编造结果。',
+    '',
+    '【输出契约（必须遵守）】',
+    '你的最终回复必须是结构化的，并且最后一行必须是单行 JSON：',
+    '{"done": true|false, "summary": "一句话结果摘要", "evidence": "证据说明"}',
+    'done 只在交付物确实完成且可验证时为 true。',
+  ]
+  return lines.join('\n')
+}
+
+/** Per-context capture state: buffered child outputs + waiters. */
+interface CaptureState {
+  buffer: Map<string, unknown[]>
+  waiters: Map<string, Array<{ resolve: (value: unknown) => void; live: boolean }>>
+}
+
+const captures = new WeakMap<object, CaptureState>()
+const installed = new WeakSet<object>()
+
+function captureState(ctx: object): CaptureState {
+  let state = captures.get(ctx)
+  if (state === undefined) {
+    state = { buffer: new Map(), waiters: new Map() }
+    captures.set(ctx, state)
+  }
+  if (!installed.has(ctx)) {
+    installed.add(ctx)
+    ;(ctx as { on?: (event: string, fn: (info: unknown) => void) => (() => void) | void }).on?.('subagent/end', (info: unknown) => {
+      const id = (info as { id?: unknown })?.id
+      if (typeof id !== 'string') return
+      const pending = state!.waiters.get(id)
+      while (pending !== undefined && pending.length > 0) {
+        const waiter = pending.shift()!
+        if (waiter.live) { waiter.resolve(info); return }
+      }
+      const queue = state!.buffer.get(id) ?? []
+      queue.push(info)
+      state!.buffer.set(id, queue)
+    })
+  }
+  return state
+}
+
+/**
+ * Consume the next settled output for one child id (buffer first). The
+ * returned dispose() marks the waiter dead and resolves it, so a cancelled
+ * round can never steal the next turn's subagent/end from its successor.
+ */
+function nextSettled(ctx: object, childId: string): { promise: Promise<unknown>; dispose: () => void } {
+  const state = captureState(ctx)
+  const buffered = state.buffer.get(childId)
+  if (buffered !== undefined && buffered.length > 0) {
+    const value = buffered.shift()!
+    return { promise: Promise.resolve(value), dispose: () => {} }
+  }
+  let waiter: { resolve: (value: unknown) => void; live: boolean }
+  const promise = new Promise<unknown>((resolve) => {
+    waiter = { resolve, live: true }
+    const queue = state.waiters.get(childId) ?? []
+    queue.push(waiter)
+    state.waiters.set(childId, queue)
+  })
+  return {
+    promise,
+    dispose: () => {
+      waiter!.live = false
+      waiter!.resolve(undefined)
+    },
+  }
+}
+
+/**
+ * Start one persistent round: spawn the teammate on the goal's first round,
+ * otherwise steer a brief amendment into the same member; await its settled
+ * output; then either derive the verdict (quick) or run verify+triage through
+ * round.js with the report as `taskReport` (full).
+ */
+export async function startTeamRound(
+  ctx: any,
+  parent: any,
+  state: LoopState,
+  config: ControllerConfig,
+  signal?: AbortSignal,
+): Promise<TeamRunHandle> {
+  const input: TeamRoundInput = {
+    goalId: state.goalId ?? 'cyb',
+    title: state.title,
+    objective: state.objective ?? '',
+    round: state.round + 1,
+    subgoal: state.subgoal,
+    brief: state.brief,
+    depth: state.depth === 'quick' ? 'quick' : 'full',
+    doneSummary: state.doneSummary,
+  }
+  const workOrder = buildWorkOrder(input, config.roles)
+  // Soft integration probe (same accessor as teamExecutorAvailable): a missing
+  // service is a structured, actionable failure — the caller/protocol falls
+  // back to executor 'ephemeral' — never a Cordis proxy exception.
+  const teams = agentTeamsOf(ctx)
+  if (teams === undefined || typeof teams.spawnTeammate !== 'function') {
+    throw teamExecutorUnavailableError()
+  }
+  // Install the subagent/end listener BEFORE the first spawn: a teammate can
+  // settle before spawnTeammate resolves, and the buffered output must not be
+  // lost. (Registration is idempotent per ctx.)
+  captureState(ctx as object)
+  const memberName = state.memberName ?? `cyb-${input.goalId.replace(/^cyb-/, '')}`
+
+  let cancelled = false
+  let resolveCancel: (() => void) | undefined
+  let disposeWait: (() => void) | undefined
+  const cancelGate = new Promise<void>((resolve) => { resolveCancel = resolve })
+
+  const roundPromise = (async (): Promise<{ stopReason: string; value?: unknown; error?: unknown }> => {
+    try {
+      let childId: string
+      if (state.memberName === undefined) {
+        const spawned = await teams.spawnTeammate(parent, {
+          name: memberName,
+          description: (input.title ?? input.subgoal).slice(0, 200),
+          prompt: [{ type: 'text', text: workOrder }],
+          context: 'fresh',
+          provider: 'spawn',
+          signal: signal ?? new AbortController().signal,
+        })
+        childId = String(spawned?.member?.id ?? '')
+        state.memberName = memberName
+        if (childId.length === 0) throw new Error('TeamExecutor: spawnTeammate returned no member id')
+      } else {
+        await teams.sendMessage(parent, {
+          target: state.memberName,
+          content: [{ type: 'text', text: `【委托书修订（第 ${input.round} 轮）】\n本轮子目标：${input.subgoal}\n${state.brief ?? '（承接上一轮的委托书与已验证结果）'}` }],
+          signal: signal ?? new AbortController().signal,
+        })
+        childId = ''
+      }
+      // For round 2+ we need the child id: listMembers resolves the durable member.
+      if (childId.length === 0) {
+        const members = teams.listMembers(parent) as Array<{ name?: string; id?: string }>
+        childId = String(members.find((m) => m.name === state.memberName)?.id ?? '')
+        if (childId.length === 0) throw new Error(`TeamExecutor: teammate "${state.memberName}" not found in the roster`)
+      }
+      if (cancelled) return { stopReason: 'cancelled', error: 'interrupted by session agent' }
+
+      const wait = nextSettled(ctx, childId)
+      disposeWait = wait.dispose
+      const info = await wait.promise
+      disposeWait = undefined
+      if (cancelled) return { stopReason: 'cancelled', error: 'interrupted by session agent' }
+      // The host's SubagentRunEndInfo carries the child's final output as
+      // `lastAssistantMessage` (ContentBlock[]) — NOT `output`, which does not
+      // exist on that payload. Reading the wrong field silently produced an
+      // empty report, so read the real field first and keep `output` only as a
+      // compatibility fallback for older/test shapes; an empty real field also
+      // falls through instead of shadowing usable legacy text.
+      const settledInfo = info as { lastAssistantMessage?: unknown; output?: unknown } | undefined
+      const text = outputText(settledInfo?.lastAssistantMessage) || outputText(settledInfo?.output)
+      const parsed = parseTaskOutput(text)
+      const report = {
+        summary: parsed.summary,
+        done: parsed.done,
+        artifacts: [],
+        evidence: parsed.evidence,
+        nextStepThoughts: [],
+      }
+      if (input.depth === 'quick') {
+        const result: RoundResult = {
+          round: input.round,
+          report,
+          verdict: {
+            met: parsed.done,
+            quick: true,
+            criteria: [],
+            gaps: parsed.done ? [] : ['task agent 未报告 done=true（quick 轮无 verify，详见 report）'],
+            goalItselfQuestionable: false,
+          },
+          triage: { auto: [], defer: [], reject: [], human: [] },
+        }
+        return { stopReason: 'completed', value: result }
+      }
+      // full depth: verify + triage stay ephemeral and independent of the
+      // teammate's narrative — they receive the report as a data input.
+      const engine = ctx.agentPresets?.serviceFor(parent, 'workflowEngine')
+      if (!engine) throw new Error('TeamExecutor: workflowEngine unavailable for verify/triage')
+      const run = engine.start({
+        script: await (await import('node:fs/promises')).readFile(config.roundScriptPath, 'utf8'),
+        meta: { name: 'cybernetics-verify', description: `verify round ${input.round}: ${input.subgoal}` },
+        args: {
+          goal: { objective: input.objective },
+          state: { round: input.round, doneSummary: input.doneSummary },
+          subgoal: input.subgoal,
+          brief: state.brief,
+          depth: 'full',
+          role: state.role,
+          roles: config.roles ?? {},
+          taskReport: report,
+        },
+        parent,
+        signal,
+      })
+      try {
+        const settled = await run.result
+        if (settled.stopReason !== 'completed') {
+          return { stopReason: 'completed', value: { round: input.round, failed: `verify run ${settled.stopReason}${settled.error ? `: ${settled.error}` : ''}` } }
+        }
+        return { stopReason: 'completed', value: settled.value }
+      } finally {
+        await run.dispose()
+      }
+    } catch (error) {
+      return { stopReason: 'error', error: error instanceof Error ? error.message : String(error) }
+    }
+  })()
+
+  const result = Promise.race([
+    roundPromise,
+    cancelGate.then(() => ({ stopReason: 'cancelled', error: 'interrupted by session agent' })),
+  ])
+
+  return {
+    round: input.round,
+    memberName,
+    result,
+    cancel(_reason?: string) {
+      cancelled = true
+      // Drop this round's waiter first: a cancelled round must not consume the
+      // next turn's subagent/end (it would hang the successor round).
+      disposeWait?.()
+      disposeWait = undefined
+      resolveCancel?.()
+      try { teams.interrupt(parent, state.memberName ?? memberName) } catch { /* best effort */ }
+    },
+    async dispose() {
+      // The member persists across rounds by design; nothing to release here.
+    },
+  }
+}