@sqdr2/dsh-fusion 0.0.0-stage → 0.3.2

package/src/benchmark/naive.ts

@@ -0,0 +1,216 @@
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import { ReasoningEffortId } from '@deepseek-ai/dsh-llm'
+import type { SessionId } from '@deepseek-ai/dsh-session'
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import { hasStartActivation, requireSubagentMethod } from '../host/subagent-seam.js'
+import type { PairProfile } from '../contracts.js'
+import { digestOf } from '../digest.js'
+import type { SqliteFusionStore } from '../task/sqlite-store.js'
+import { isShellTool, nativeShellTool } from '../host/shell.js'
+
+/** A declared benchmark treatment, never installed in product sessions. */
+export const naivePrompts = {
+  lead: 'Complete the user task. You may work directly or use naive_delegate for a bounded implementation or test task. Every delegation starts a fresh independent Worker, which sees only your brief and the shared workspace. Include the relevant requirements and constraints in that brief. Inspect the returned result, correct defects or delegate again as needed, and run relevant tests before finishing. Delegation and direct commands run sequentially under the same total allowance.',
+  worker: 'Complete the delegated task using the native tools. Inspect the code, implement the requested changes and run relevant tests. Preserve existing acceptance tests. Return a concise account of changes, verification and unresolved limitations. This is a fresh independent session; you have no earlier Worker conversation.',
+}
+
+export interface NaiveDelegation {
+  ordinal: number
+  callId: string
+  briefDigest: string
+  startedAt: string
+  endedAt: string | null
+  childSessionId: string | null
+  parentSessionId: string
+  state: 'starting' | 'running' | 'settled' | 'failed'
+  stopReason: string | null
+  disposed: boolean
+  failure: string | null
+}
+
+interface NaiveResult { readonly stopReason: string; readonly output: readonly { readonly type: string; readonly text?: string }[] }
+interface NaiveChild {
+  readonly childId: SessionId
+  readonly result: Promise<NaiveResult>
+  dispose(): Promise<void>
+  /** Set only for the 0.2.0 `SubagentRun`. Absent means read the child from `ctx.agents`. */
+  readonly localAgent?: Agent
+  readonly readChild: 'localAgent' | 'registry'
+}
+interface NaiveSubagents {
+  startActivation?(spec: {
+    readonly provider: string
+    readonly label: string
+    readonly delivery: 'caller'
+    readonly request: {
+      readonly parent: Agent
+      readonly prompt: readonly { readonly type: 'text'; readonly text: string }[]
+      readonly agentOptions: object
+      readonly maxDepth: number
+    }
+    readonly signal: AbortSignal
+  }): Promise<{ readonly childId: SessionId; readonly result: Promise<NaiveResult>; dispose(): Promise<void> }>
+  start?(provider: string, request: {
+    readonly parent: Agent
+    readonly label: string
+    readonly prompt: readonly { readonly type: 'text'; readonly text: string }[]
+    readonly persona: string
+    readonly signal: AbortSignal
+    readonly agentOptions: object
+    readonly toolFilter: { readonly allow: readonly string[] }
+    readonly maxDepth: number
+  }): Promise<{ readonly id: SessionId; readonly localAgent: Agent | undefined; readonly result: Promise<NaiveResult>; dispose(): Promise<void> }>
+}
+
+/** Simple sequential coordinator using the native single-activation child lifecycle. */
+export class NaiveCoordinator {
+  readonly delegations: NaiveDelegation[] = []
+  readonly #dispose: (() => void)[] = []
+  readonly #operations = new Set<Promise<string>>()
+  readonly #controllers = new Set<AbortController>()
+  #delegating = false
+  #writer: symbol | undefined
+  #closed = false
+  #cleanupFailure: unknown
+
+  constructor(readonly ctx: Context, readonly parent: Agent, readonly store: SqliteFusionStore,
+    readonly profile: PairProfile, readonly workerMaxTokens: number, readonly tools: readonly string[] = [nativeShellTool]) {
+    const provider = ctx.subagents.getProvider('spawn')
+    if (!provider || provider.inheritsParentContext !== false) throw new Error('Naive requires a fresh-context native spawn provider')
+    // 0.2.1 removed `persona` and `toolFilter` and rejects them. A benchmark
+    // baseline must not depend on a user-configured Agent Preset, so on that
+    // seam the Worker prompt and the declared tool set are applied at
+    // `agent/created`, before the child's first request. 0.2.0 still receives
+    // both on `start`, and this hook stays off so that path is unchanged.
+    if (hasStartActivation(ctx.subagents)) {
+      this.#dispose.push(ctx.on('agent/created', ({ agent }) => {
+        if (agent.session.header.parentSession !== parent.id) return undefined
+        agent.ctx.tools.restrict({ allow: [...this.tools] })
+        agent.ctx.systemPrompt.section({ name: 'naive-benchmark-worker', order: 90, text: naivePrompts.worker })
+        return undefined
+      }))
+    }
+    this.#dispose.push(parent.ctx.systemPrompt.section({ name: 'naive-benchmark', order: 90, text: naivePrompts.lead }))
+    // Deny overlap even if an external caller bypasses the native sibling
+    // scheduler. The declared tool remains exclusive under that scheduler.
+    this.#dispose.push(ctx.on('tools/execute', async (exec, next) => {
+      if (!exec.agent || !this.owns(exec.agent)) return next()
+      this.assertReady()
+      if (!isShellTool(exec.name)) return next()
+      if (this.#writer || this.#delegating && exec.agent === parent) throw new Error('Naive requires one native writer at a time')
+      this.#writer = exec.token
+      try { return await next() }
+      finally { if (this.#writer === exec.token) this.#writer = undefined }
+    }, { prepend: true }))
+    this.#dispose.push(parent.ctx.tools.register(defineTool({
+      name: 'naive_delegate',
+      description: 'Run one fresh independent Worker on a complete task brief. Wait for its result and dispose it. A subsequent delegation starts a new Worker without prior chat history. Use sequentially with other tools.',
+      parameters: { brief: { type: 'string', required: true } },
+      output: { schema: { type: 'string' }, render: (_args, text) => [{ type: 'text', text }] },
+      execute: async (args, exec) => {
+        if (exec.agent !== parent || this.#closed || this.#delegating || this.#writer) throw new Error('Naive delegation requires an idle exclusive Lead tool slot')
+        const operation = this.#delegate(args.brief, exec.callId, exec.signal)
+        this.#operations.add(operation)
+        try { return await operation }
+        finally { this.#operations.delete(operation) }
+      },
+    })))
+  }
+
+  owns(agent: Agent): boolean {
+    return agent === this.parent || agent.session.header.parentSession === this.parent.id
+  }
+
+  assertReady(): void {
+    if (this.#closed) throw new Error('Naive benchmark is closing')
+    if (this.#cleanupFailure) throw new Error(`Naive recording or cleanup failed: ${String(this.#cleanupFailure)}`)
+  }
+
+  async #delegate(brief: string, callId: string, signal: AbortSignal): Promise<string> {
+    if (!brief.trim()) throw new Error('A nonempty Worker brief is required')
+    signal.throwIfAborted()
+    this.#delegating = true
+    const controller = new AbortController()
+    this.#controllers.add(controller)
+    const row: NaiveDelegation = { ordinal: this.delegations.length + 1, callId, briefDigest: digestOf(brief),
+      startedAt: new Date().toISOString(), endedAt: null, childSessionId: null, parentSessionId: this.parent.id,
+      state: 'starting', stopReason: null, disposed: false, failure: null }
+    this.delegations.push(row)
+    const key = `naive-delegation:${this.parent.id}:${row.ordinal}`
+    let revision = 0, started: NaiveChild | undefined
+    const persist = () => { revision = this.store.writeDocument(key, revision, { ...row }) }
+    try {
+      persist()
+      const route = this.profile.worker
+      const prompt = [{ type: 'text' as const, text: brief }]
+      const agentOptions = { provider: route.provider, model: route.model,
+        ...(route.reasoningEffort ? { reasoningEffort: ReasoningEffortId(route.reasoningEffort) } : {}),
+        maxTokens: this.workerMaxTokens }
+      const maxDepth = (this.parent.session.header.delegationDepth ?? 0) + 1
+      const runSignal = AbortSignal.any([signal, controller.signal])
+      const subagents = this.ctx.subagents as NaiveSubagents
+      // 0.2.1: `startActivation` with `delivery: 'caller'` returns the result to
+      // the calling tool and does not push it into the Lead inbox. 0.2.0: the
+      // one-shot `start`, with persona and toolFilter still on the request.
+      const start = requireSubagentMethod(subagents, 'startActivation', 'start')
+      if (start === 'startActivation') {
+        const activation = await subagents.startActivation!({
+          provider: 'spawn', label: `Naive Worker ${row.ordinal}`, delivery: 'caller',
+          request: { parent: this.parent, prompt, agentOptions, maxDepth }, signal: runSignal,
+        })
+        started = { childId: activation.childId, result: activation.result, dispose: () => activation.dispose(), readChild: 'registry' }
+      } else {
+        const run = await subagents.start!('spawn', {
+          parent: this.parent, label: `Naive Worker ${row.ordinal}`, prompt, persona: naivePrompts.worker,
+          signal: runSignal, agentOptions, toolFilter: { allow: [...this.tools] }, maxDepth,
+        })
+        started = { childId: run.id, result: run.result, dispose: () => run.dispose(), localAgent: run.localAgent, readChild: 'localAgent' }
+      }
+      // A later validation/journal failure still owns disposal. Observe an
+      // infrastructure rejection immediately, before those checks can throw;
+      // the normal await below retains the actual rejection as the outcome.
+      void started.result.catch(() => undefined)
+      // 0.2.0 published the child on `SubagentRun.localAgent`. 0.2.1 removed
+      // that field; the same Agent is `ctx.agents.get(childId)`.
+      const child = started.readChild === 'localAgent' ? started.localAgent : this.ctx.agents.get(started.childId)
+      if (!child || child.session.header.parentSession !== this.parent.id) throw new Error('Naive requires an owned native child')
+      if (this.delegations.some(other => other !== row && other.childSessionId === started!.childId)) throw new Error('Naive child identity was reused')
+      row.childSessionId = started.childId
+      row.state = 'running'
+      persist()
+      const result = await started.result
+      row.stopReason = result.stopReason
+      row.state = 'settled'
+      persist()
+      if (result.stopReason !== 'completed') throw new Error(`Naive Worker ended ${result.stopReason}; its output is incomplete`)
+      return JSON.stringify({ childSessionId: started.childId, stopReason: result.stopReason, output: result.output })
+    } catch (error) {
+      row.state = 'failed'
+      row.failure = String(error)
+      throw error
+    } finally {
+      try {
+        if (started) {
+          await started.dispose()
+          if (this.ctx.agents.get(started.childId)) throw new Error('Naive child remained resident after disposal')
+          row.disposed = true
+        }
+        row.endedAt = new Date().toISOString()
+        persist()
+      } catch (error) { this.#cleanupFailure = error; throw error }
+      finally { this.#controllers.delete(controller); this.#delegating = false }
+    }
+  }
+
+  async close(): Promise<void> {
+    this.#closed = true
+    for (const controller of this.#controllers) controller.abort(new Error('Naive benchmark closing'))
+    await Promise.allSettled([...this.#operations])
+    for (const dispose of this.#dispose.reverse()) dispose()
+    if (this.#cleanupFailure) throw this.#cleanupFailure
+    if (this.#writer || this.#delegating || this.delegations.some(row => row.childSessionId && !row.disposed)) {
+      throw new Error('Naive child/tool quiescence unproven')
+    }
+  }
+}

package/src/benchmark/native-run.ts

@@ -0,0 +1,215 @@
+import { randomUUID } from 'node:crypto'
+import { mkdirSync, realpathSync, writeFileSync } from 'node:fs'
+import { isAbsolute, join, relative, resolve, sep } from 'node:path'
+import type { Context } from '@deepseek-ai/cordis'
+import { installModelSelection } from '@deepseek-ai/dsh-agent'
+import { createUserMessage, isAgentLoopRequest, ReasoningEffortId } from '@deepseek-ai/dsh-llm'
+import { SessionId, type Session } from '@deepseek-ai/dsh-session'
+import { TaskId } from '../contracts.js'
+import type { PhysicalRoute } from '../contracts.js'
+import { digestOf } from '../digest.js'
+import { FusionCoordinator } from '../host/coordinator.js'
+import { NativeRequestBudget } from '../host/native-budget.js'
+import { nativeRequestAgent } from '../host/native-request.js'
+import { observeNativeUsage } from '../host/native-usage.js'
+import type { NativeUsageRecord } from '../host/native-usage.js'
+import { nativeShellTool } from '../host/shell.js'
+import { snapshotWorkspace } from '../host/workspace.js'
+import type { ResolvedProfile } from '../profile/resolve.js'
+import { profileRoutes } from '../profile/compactor.js'
+import { SqliteFusionStore } from '../task/sqlite-store.js'
+import { NaiveCoordinator, naivePrompts } from './naive.js'
+import { resolveBenchmarkOutputLimits, type BenchmarkOutputLimits } from './output-limits.js'
+
+export interface NativeBenchmarkOptions {
+  runId: string
+  variant: 'lead_only' | 'worker_only' | 'worker_selfreview' | 'naive' | 'fusion'
+  dataKind: 'real' | 'synthetic'
+  /** Version read by the trusted launcher from the loaded artifact's metadata. */
+  engineVersion?: string
+  workspace: string
+  /** Fresh directory, outside the candidate's filesystem. Never reused. */
+  output: string
+  prompt: string
+  profile: ResolvedProfile
+  /** Required for real runs: exact public model limits frozen before the attempt. */
+  outputLimits?: BenchmarkOutputLimits
+  /** One campaign-wide ledger, so attempts cannot reset the approved limit. */
+  budget: NativeRequestBudget
+  maxRequests: number
+  timeoutMs: number
+}
+
+// This is an explicit benchmark treatment, not a change to the Fusion prompt.
+// The same Worker, tools, deadline and allowance cover both native turns.
+const selfReviewPrompt = `Perform a second self-review of your work against the original user request. Inspect the current implementation, look for defects or missed requirements, fix any you find, and run the relevant tests. Preserve the existing acceptance tests. Use the remaining allowance for this same attempt; no additional budget has been granted. Finish with the result of this review and any unresolved limitations.`
+
+/**
+ * Run one fresh attempt through the same native AgentLoop and FusionCoordinator
+ * as the product. The caller composes public Host services and a sandboxed shell;
+ * this function does not implement another LLM/tool loop or grade candidate code.
+ */
+export async function runNativeBenchmark(ctx: Context, options: NativeBenchmarkOptions) {
+  if (!/^[a-zA-Z0-9._-]{1,120}$/.test(options.runId)) throw new Error('Invalid run id')
+  if (!['lead_only', 'worker_only', 'worker_selfreview', 'naive', 'fusion'].includes(options.variant)
+    || !['real', 'synthetic'].includes(options.dataKind)) throw new Error('Invalid benchmark mode')
+  if (!options.prompt.trim() || !Number.isSafeInteger(options.maxRequests) || options.maxRequests < 1
+    || !Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1) throw new Error('Bounded attempt limits required')
+  if (options.dataKind === 'real' && !options.outputLimits) throw new Error('Real attempts require preregistered role output limits')
+  const { profile, prompts } = options.profile
+  const benchmarkTools = [nativeShellTool, 'read', 'glob', 'grep']
+  for (const name of benchmarkTools) {
+    if (!ctx.tools.get(name)) throw new Error(`Native benchmark requires the ${name} tool before any model request`)
+  }
+  if (!profile.enabled) throw new Error('Disabled benchmark profile')
+  const workspace = realpathSync(options.workspace)
+  const inWorkspace = (path: string) => {
+    const rel = relative(workspace, resolve(path))
+    return rel === '' || !(rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+  }
+  if (inWorkspace(options.output) || inWorkspace(options.budget.store.filename)
+    || options.budget.authorizationFile && inWorkspace(options.budget.authorizationFile)) {
+    throw new Error('Benchmark controller state and authorization must be outside the candidate workspace')
+  }
+  const selfReview = options.variant === 'worker_selfreview'
+  const role = options.variant === 'worker_only' || selfReview ? 'worker' : 'lead'
+  const route = profile[role]
+  const nativeRoute = { provider: route.provider, model: route.model,
+    ...(route.reasoningEffort ? { reasoningEffort: ReasoningEffortId(route.reasoningEffort) } : {}) }
+  options.budget.check(options.variant === 'fusion' ? profileRoutes(profile)
+    : options.variant === 'naive' ? [profile.lead, profile.worker] : [route])
+  const outputLimits = await resolveBenchmarkOutputLimits(ctx, profile)
+  if (options.outputLimits && digestOf(options.outputLimits) !== digestOf(outputLimits)) {
+    throw new Error('Frozen role output limits changed; preregister the new conditions before model calls')
+  }
+  // mkdir without recursive prevents overwriting any earlier attempt evidence.
+  mkdirSync(options.output, { mode: 0o700 })
+  const before = snapshotWorkspace(workspace)
+  const store = new SqliteFusionStore(join(options.output, 'fusion.sqlite'))
+  const soloTask = TaskId(`benchmark-${options.runId}`)
+  const startedAt = new Date().toISOString(), started = performance.now()
+  let requests = 0, timedOut = false, failure: string | null = null
+  let coordinator: FusionCoordinator | undefined
+  let naive: NaiveCoordinator | undefined
+  let stopUsage: (() => void) | undefined
+  let stopGuard: (() => void) | undefined
+  let stopSessions: (() => void) | undefined
+  let timer: ReturnType<typeof setTimeout> | undefined
+  let workerSession: Session | undefined
+  const childSessions = new Map<string, Session>()
+  const phases: Array<{ stage: 'implementation' | 'self_review'; completed: boolean; nativeRequests: number; endReason: unknown }> = []
+  const reserve = (actual: PhysicalRoute, maxTokens: number) => {
+    if (requests >= options.maxRequests) throw new Error('Attempt native request limit exhausted')
+    options.budget.reserve(actual, maxTokens)
+    requests++
+  }
+  let parent
+  try {
+    parent = (await ctx.agents.create({ sessionId: SessionId(`bench-${options.runId}-${randomUUID()}`),
+      meta: { cwd: workspace }, agentOptions: { ...nativeRoute, maxTokens: outputLimits.roles[role].maxTokens } })).agent
+    installModelSelection(parent.ctx, { current: nativeRoute, assembled: undefined })
+  } catch (error) { store.close(); throw error }
+  let taskId = soloTask
+  try {
+    // The native parent turn can drain its child before whenIdle returns. Keep
+    // public Session references from creation, including restored generations.
+    stopSessions = ctx.on('session/created', session => {
+      if (session.header.parentSession === parent.id) childSessions.set(session.id, session)
+    })
+    if (options.variant === 'fusion') {
+      coordinator = new FusionCoordinator(ctx, store, { profile: options.profile, workerTools: benchmarkTools,
+        leaseRoot: join(options.output, 'leases'), maxWorkerSteps: options.maxRequests, commandMaxSeconds: 60,
+        authorizeRequest: (_agent, binding) => { options.budget.check(profileRoutes(binding.profile)) },
+        reserveRequest: request => reserve(request, request.maxTokens ?? 0) })
+      await coordinator.select(parent)
+      taskId = coordinator.bindings.read(parent.id)!.binding.taskId
+    } else {
+      if (options.variant === 'naive') naive = new NaiveCoordinator(ctx, parent, store, profile, outputLimits.roles.worker.maxTokens, benchmarkTools)
+      stopUsage = observeNativeUsage(ctx, store, agent => agent === parent ? { taskId, role }
+        : naive?.owns(agent) ? { taskId, role: 'worker' } : undefined)
+    }
+    stopGuard = ctx.on('llm/stream', async function* (request, next) {
+      const agent = nativeRequestAgent(ctx, request)
+      if (!agent || (coordinator ? !coordinator.owner(agent) : naive ? !naive.owns(agent) : agent !== parent)) {
+        throw new Error('Benchmark refuses unowned auxiliary model calls')
+      }
+      naive?.assertReady()
+      if (isAgentLoopRequest(request) && request.purpose === undefined) {
+        const requestRole = coordinator?.owner(agent)?.role ?? (agent === parent ? role : 'worker')
+        const frozen = outputLimits.roles[requestRole]
+        if (request.provider !== frozen.provider || request.model !== frozen.model || request.maxTokens !== frozen.maxTokens) {
+          throw new Error(`Benchmark ${requestRole} request diverged from frozen role output limits`)
+        }
+      }
+      if (!coordinator) reserve(request, request.maxTokens ?? 0)
+      yield* next()
+    }, { prepend: true })
+    const frozen = { schemaVersion: 1, runId: options.runId, variant: options.variant, dataKind: options.dataKind,
+      startedAt, pluginVersion: options.engineVersion ?? 'unknown', profile, promptsDigest: digestOf(prompts), taskPromptDigest: digestOf(options.prompt),
+      initialSnapshot: before, maxRequests: options.maxRequests, timeoutMs: options.timeoutMs, outputLimits,
+      protocol: { requiredStages: selfReview ? ['implementation', 'self_review'] : ['implementation'],
+        selfReviewPromptDigest: selfReview ? digestOf(selfReviewPrompt) : null,
+        ...(naive ? { delegationMode: 'fresh-one-shot', rolePromptsDigest: digestOf(naivePrompts),
+          completionRule: 'parent-completed-and-children-quiescent' } : {}) },
+      tools: benchmarkTools, readToolSemantics: 'readonly-command-vm-python-regex-fnmatch-v1',
+      commandNetwork: 'caller-must-attest', authorizationId: options.budget.check([route]).authorizationId }
+    writeFileSync(join(options.output, 'manifest.json'), JSON.stringify(frozen, null, 2), { mode: 0o600, flag: 'wx' })
+    timer = setTimeout(() => {
+      timedOut = true
+      parent.cancel({ kind: 'hook', reason: 'Benchmark attempt deadline' })
+      for (const childId of childSessions.keys()) ctx.agents.get(SessionId(childId))?.cancel({ kind: 'hook', reason: 'Benchmark attempt deadline' })
+    }, options.timeoutMs)
+    const turn = async (stage: 'implementation' | 'self_review', text: string) => {
+      const start = parent.session.snapshotEvents().length
+      const requestsBefore = requests
+      parent.followup(createUserMessage({ content: [{ type: 'text', text }], source: { kind: 'user' } }))
+      await parent.whenIdle()
+      const end = parent.session.snapshotEvents().slice(start).findLast(event => event.type === 'turn/end')
+      const endReason = end?.type === 'turn/end' ? end.data.reason : null
+      phases.push({ stage, completed: endReason?.kind === 'completed', nativeRequests: requests - requestsBefore, endReason })
+    }
+    await turn('implementation', options.prompt)
+    if (selfReview && phases[0]?.completed && !timedOut) await turn('self_review', selfReviewPrompt)
+  } catch (error) { failure = String(error) }
+  finally {
+    if (timer) clearTimeout(timer)
+    // Native release removes the Agent handle. Read the retained public
+    // Session only after close proves quiescence, including final events.
+    const childId = coordinator?.bindings.read(parent.id)?.binding.workerId
+    workerSession = childId ? childSessions.get(childId) : undefined
+    // Await the persistent child and native tools before declaring a snapshot.
+    try { await coordinator?.close(); await naive?.close() }
+    catch (error) { store.close(); throw error }
+    finally { stopGuard?.(); stopUsage?.(); stopSessions?.() }
+  }
+  try {
+    const state = coordinator?.state(taskId)
+    const events = parent.session.snapshotEvents()
+    const end = events.findLast(event => event.type === 'turn/end')
+    const endReason = end?.type === 'turn/end' ? end.data.reason : null
+    const protocolComplete = !timedOut && !failure && endReason?.kind === 'completed'
+      && phases.length === (selfReview ? 2 : 1) && phases.every(phase => phase.completed)
+      && (state ? state.phase === 'COMPLETED' && state.verification === 'verified' && !state.outcomeUnknown : true)
+    const usage = store.listDocumentIds(`usage:${taskId}:`).map(id => store.readDocument(id)!.value as NativeUsageRecord)
+    const delivered = snapshotWorkspace(workspace)
+    const workers = naive ? [...childSessions.values()] : workerSession ? [workerSession] : []
+    const workerSessions = workers.map((session, index) => ({ sessionId: session.id,
+      parentSessionId: session.header.parentSession, eventsFile: naive ? `worker-events-${String(index + 1).padStart(3, '0')}.json` : 'worker-events.json' }))
+    const result = { schemaVersion: 1, runId: options.runId, variant: options.variant, dataKind: options.dataKind,
+      startedAt, endedAt: new Date().toISOString(), wallSeconds: (performance.now() - started) / 1000,
+      parentSessionId: parent.id, workerSessionId: coordinator?.bindings.read(parent.id)?.binding.workerId ?? null,
+      taskId, nativeRequests: requests, protocolComplete, artifactPass: null,
+      workerParentSessionId: workerSession?.header.parentSession ?? null,
+      workerSessions, ...(naive ? { naiveDelegations: naive.delegations } : {}),
+      status: timedOut ? 'timeout' : protocolComplete ? 'completed' : 'failed', failure, endReason, phases,
+      deliveredSnapshot: delivered, fusionState: state ?? null, usage,
+      actualBilledUsd: null, apiEquivalentUsd: null, upstreamHttpCalls: null }
+    writeFileSync(join(options.output, 'parent-events.json'), JSON.stringify(events, null, 2), { mode: 0o600, flag: 'wx' })
+    workers.forEach((session, index) => writeFileSync(join(options.output, workerSessions[index]!.eventsFile),
+      JSON.stringify(session.snapshotEvents(), null, 2), { mode: 0o600, flag: 'wx' }))
+    writeFileSync(join(options.output, 'result.json'), JSON.stringify(result, null, 2), { mode: 0o600, flag: 'wx' })
+    return result
+  } finally { store.close() }
+}
+
+export { NativeRequestBudget }

package/src/benchmark/output-limits.ts

@@ -0,0 +1,33 @@
+import type { Context } from '@deepseek-ai/cordis'
+import type { PairProfile, Role } from '../contracts.js'
+import { requestOutputReservation } from '../context/guard.js'
+import { resolveModelOutputLimits } from '../host/model-output.js'
+
+export interface BenchmarkOutputLimits {
+  policy: 'role-route-auto-v1'
+  roles: Record<Role, {
+    provider: string
+    model: string
+    contextWindow: number
+    adapterDefault: number | null
+    testedCap: number | null
+    fallback: number
+    maxTokens: number
+  }>
+}
+
+/** Run before preregistration, then compare the exact snapshot before spending.
+ * Every treatment uses the same role's automatic product allowance; the profile
+ * reservation is a fallback, not a universal per-request cap.
+ */
+export async function resolveBenchmarkOutputLimits(ctx: Context, profile: PairProfile): Promise<BenchmarkOutputLimits> {
+  const roles = {} as BenchmarkOutputLimits['roles']
+  for (const role of ['lead', 'worker'] as const) {
+    const { provider, model } = profile[role]
+    const { contextWindow, defaultMaxTokens, testedOutputCap } = await resolveModelOutputLimits(ctx, provider, model)
+    const fallback = profile.context[role].reserveOutputTokens
+    roles[role] = { provider, model, contextWindow, adapterDefault: defaultMaxTokens ?? null, testedCap: testedOutputCap ?? null,
+      fallback, maxTokens: requestOutputReservation(contextWindow, undefined, defaultMaxTokens, testedOutputCap, fallback) }
+  }
+  return { policy: 'role-route-auto-v1', roles }
+}

package/src/bilingual.ts

@@ -0,0 +1,2 @@
+/** Host-side messages reach the UI and the command line as text; they carry both languages. */
+export const bi = (zh: string, en: string) => `${zh} / ${en}`

package/src/client/ActivityRows.tsx

@@ -0,0 +1,59 @@
+import { useState } from 'react'
+import { DiffBlock, TerminalBlock } from '@deepseek-ai/dsh-client-ui-primitives'
+import { activityDiffs } from './activity-model.js'
+import { tr, useLang, type Lang } from './i18n.js'
+import type { ActivityRow } from './activity-model.js'
+
+const labelsFor = (lang: Lang) => ({ codeLabel: tr(lang, '代码', 'Code'), wrapLabel: tr(lang, '自动换行', 'Wrap'), unwrapLabel: tr(lang, '取消自动换行', 'No wrap'),
+  copy: tr(lang, '复制', 'Copy'), copied: tr(lang, '已复制', 'Copied'), collapseAria: tr(lang, '收起内容', 'Collapse'), collapse: tr(lang, '收起', 'Collapse'),
+  expandAria: (n: number) => tr(lang, `展开其余 ${n} 行`, `Show ${n} more lines`), expand: (n: number) => tr(lang, `展开其余 ${n} 行`, `Show ${n} more lines`) })
+// `commandLine` is required by TerminalBlockLabels on DSH 0.2.1 and ignored on 0.2.0.
+const terminalLabelsFor = (lang: Lang) => ({ ...labelsFor(lang), commandLine: (n: number) => tr(lang, `命令行第 ${n} 行`, `command line ${n}`),
+  signal: (s: string) => tr(lang, `信号 ${s}`, `signal ${s}`), exitCode: (n: number) => tr(lang, `退出码 ${n}`, `exit code ${n}`),
+  running: tr(lang, '执行中', 'Running'), failed: tr(lang, '执行失败', 'Failed'), done: tr(lang, '已返回', 'Done'), noOutput: tr(lang, '无输出', 'No output'), noExitCode: tr(lang, '未记录退出码', 'No exit code') })
+const titleFor = (lang: Lang): Record<string, string> => ({ bash: tr(lang, '终端', 'Terminal'), pwsh: tr(lang, '终端', 'Terminal'), read: tr(lang, '读取', 'Read'), write: tr(lang, '写入', 'Write'), edit: tr(lang, '编辑', 'Edit'),
+  glob: tr(lang, '查找文件', 'Find files'), grep: tr(lang, '搜索', 'Search'), job_output: tr(lang, '命令输出', 'Command output'), job_kill: tr(lang, '停止命令', 'Stop command'), str_replace_editor: tr(lang, '编辑', 'Edit') })
+
+export function ActivityCard({ row, done, cwd, openFile }: {
+  row: ActivityRow; done: boolean; cwd?: string; openFile(path: string): void
+}) {
+  const lang = useLang()
+  const [open, setOpen] = useState(false)
+  let args: Record<string, unknown> = {}
+  try { const parsed: unknown = JSON.parse(row.call.data.arguments); if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) args = parsed as Record<string, unknown> } catch { /* Raw call remains inspectable below. */ }
+  const result = row.result?.data.message
+  const output = result?.content.flatMap(part => part.type === 'text' ? [part.text] : []).join('\n') ?? ''
+  const path = typeof args.file_path === 'string' ? args.file_path : typeof args.path === 'string' ? args.path : undefined
+  const command = typeof args.command === 'string' ? args.command : undefined
+  const exit = /\n\[exit code: (\d+)\]\s*$/.exec(output)
+  const failed = result?.isError || (exit && Number(exit[1]) !== 0)
+  const diffs = activityDiffs(row)
+  const label = titleFor(lang)[row.call.data.name] ?? row.call.data.name
+  const summary = path ?? (typeof args.description === 'string' ? args.description : command)
+    ?? (typeof args.pattern === 'string' ? args.pattern : label)
+  const status = failed ? tr(lang, '失败', 'Failed') : !row.result ? (done ? tr(lang, '结果未记录', 'No result recorded') : tr(lang, '执行中', 'Running')) : ''
+  return <div className="fusion-activity-row" data-fusion-tool={row.call.data.name} data-fusion-call={row.id}>
+    <button type="button" aria-expanded={open} onClick={() => setOpen(!open)} className="fusion-activity-toggle">
+      <span aria-hidden>{open ? '⌄' : '›'}</span><span>{label}</span>
+      <span className="fusion-activity-summary">{summary}</span>
+      {status && <small role="status" data-failed={Boolean(failed)}>{status}</small>}
+    </button>
+    {open && <div className="fusion-activity-body">
+      {path && <button type="button" className="fusion-activity-file" onClick={() => openFile(path)}>{tr(lang, '打开', 'Open')} {path}</button>}
+      {diffs.length ? <DiffBlock diffs={diffs} labels={labelsFor(lang)} maxLines={16} />
+        : (row.call.data.name === 'bash' || row.call.data.name === 'pwsh') && command ? <TerminalBlock command={command} cwd={cwd} output={output}
+          running={!row.result && !done} exitCode={exit ? Number(exit[1]) : undefined} labels={terminalLabelsFor(lang)} />
+          : <pre>{output || (row.result ? tr(lang, '已返回，无文本输出。', 'Returned without text output.') : row.call.data.arguments)}</pre>}
+    </div>}
+  </div>
+}
+
+export const activityStyles = `
+.fusion-activity-row{font-size:13px;line-height:1.5;margin:4px 0;min-width:0;color:var(--dsw-alias-label-secondary)}
+.fusion-activity-toggle{display:flex;align-items:center;gap:8px;width:100%;padding:6px 0;background:none;border:0;color:inherit;text-align:left;cursor:pointer;font:inherit}
+.fusion-activity-toggle:focus-visible,.fusion-activity-file:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:2px}
+.fusion-activity-summary{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-primary)}
+.fusion-activity-toggle small{white-space:nowrap}.fusion-activity-toggle small[data-failed=true]{color:var(--dsw-alias-state-error-primary)}
+.fusion-activity-body{padding:4px 0 10px;overflow:hidden}.fusion-activity-body pre{white-space:pre-wrap;overflow-wrap:anywhere;max-height:360px;overflow:auto;font-size:12px}
+.fusion-activity-file{font:inherit;border:0;background:none;color:var(--dsw-alias-brand-primary);padding:0 0 6px;cursor:pointer}
+`