@sqdr2/dsh-fusion 0.0.0-stage → 0.3.2

package/src/host/native-worker.ts

@@ -0,0 +1,215 @@
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import { ReasoningEffortId } from '@deepseek-ai/dsh-llm'
+import type { MessageId } from '@deepseek-ai/dsh-llm'
+import { SessionId } from '@deepseek-ai/dsh-session'
+import type {} from '@deepseek-ai/dsh-subagent'
+import type { PhysicalRoute } from '../contracts.js'
+import { requireSubagentMethod } from './subagent-seam.js'
+
+export interface NativeWorkerRequest {
+  readonly childId: string
+  readonly label: string
+  /** Model-authored brief from the Lead's native tool call. */
+  readonly brief: string
+  readonly route: PhysicalRoute
+  /** 0.2.0 startContinuable persona. 0.2.1 rejects it; the role scope carries the prompt. */
+  readonly persona: string
+  /** 0.2.0 start-time tool ceiling. 0.2.1 rejects toolFilter; the role scope narrows tools. */
+  readonly allowedTools: readonly string[]
+}
+
+export interface NativeWorkerAcceptance {
+  readonly childId: string
+  readonly messageId: MessageId
+}
+
+interface WorkerStartRequest {
+  readonly parent: Agent
+  readonly prompt: readonly { readonly type: 'text'; readonly text: string }[]
+  readonly agentOptions: { readonly provider: string; readonly model: string; readonly reasoningEffort?: ReturnType<typeof ReasoningEffortId> }
+  readonly maxDepth: number
+  readonly persona?: string
+  readonly toolFilter?: { readonly allow: readonly string[] }
+}
+
+interface StartedWorker {
+  readonly childId: string
+  readonly messageId?: MessageId
+}
+
+/** Structural view of the two DSH subagent seams. Only the branch that exists is called. */
+interface SubagentSeam {
+  startActivation?(spec: {
+    readonly provider: string
+    readonly label: string
+    readonly childId: ReturnType<typeof SessionId>
+    readonly delivery: 'parent'
+    readonly request: WorkerStartRequest
+    readonly signal: AbortSignal
+  }): Promise<StartedWorker>
+  startContinuable?(spec: {
+    readonly provider: string
+    readonly label: string
+    readonly childId: ReturnType<typeof SessionId>
+    readonly request: WorkerStartRequest
+    readonly signal: AbortSignal
+  }): Promise<StartedWorker>
+  drainChildren?(parent: Agent, childIds: readonly ReturnType<typeof SessionId>[]): Promise<void>
+  drainContinuableChildren?(parent: Agent, childIds: readonly ReturnType<typeof SessionId>[]): Promise<void>
+}
+
+/** Version-pinned public API adapter. It never calls an LLM adapter or runs a shell itself. */
+export class NativeWorkerTransport {
+  readonly #flushed = new WeakMap<Agent, number>()
+  constructor(private readonly ctx: Context, private readonly provider = 'spawn') {}
+
+  assertAvailable(): void {
+    const provider = this.ctx.subagents.getProvider(this.provider)
+    if (!provider?.prepareContinuable || provider.inheritsParentContext !== false) {
+      throw new Error(`Fusion requires an independent continuable provider: ${this.provider}`)
+    }
+  }
+
+  /** Caller durably reserves the child and operation before entering this method. */
+  async start(parent: Agent, request: NativeWorkerRequest, signal: AbortSignal): Promise<NativeWorkerAcceptance> {
+    this.assertAvailable()
+    signal.throwIfAborted()
+    if (this.ctx.agents.get(SessionId(request.childId))) throw new Error('Reserved Worker already exists; reconcile before retrying')
+    const prompt = [{ type: 'text' as const, text: request.brief }]
+    const agentOptions = {
+      provider: request.route.provider,
+      model: request.route.model,
+      ...(request.route.reasoningEffort === undefined ? {} : { reasoningEffort: ReasoningEffortId(request.route.reasoningEffort) }),
+    }
+    const maxDepth = (parent.session.header.delegationDepth ?? 0) + 1
+    const childId = SessionId(request.childId)
+    // `startActivation` is the 0.2.1 name. `delivery: 'parent'` keeps the 0.2.0
+    // settlement: it reaches the Lead's inbox, which this transport reconciles
+    // from the session log. 0.2.1 rejects `persona` and `toolFilter`; the
+    // `fusion-role` section and NativeFusionScopes own both, and the scope is
+    // installed at `agent/created` before the child's first request.
+    // Otherwise this is 0.2.0 `startContinuable`, persona and toolFilter included.
+    const subagents = this.ctx.subagents as SubagentSeam
+    const start = requireSubagentMethod(subagents, 'startActivation', 'startContinuable')
+    const accepted = start === 'startActivation'
+      ? await subagents.startActivation!({
+        provider: this.provider, label: request.label, childId, delivery: 'parent',
+        request: { parent, prompt, agentOptions, maxDepth }, signal,
+      })
+      : await subagents.startContinuable!({
+        provider: this.provider, label: request.label, childId,
+        request: { parent, prompt, persona: request.persona, agentOptions, toolFilter: { allow: [...request.allowedTools] }, maxDepth },
+        signal,
+      })
+    if (accepted.childId !== request.childId) throw new Error('Native Worker identity changed during creation')
+    if (!accepted.messageId) throw new Error('Native Worker start did not accept an initial message')
+    return { childId: accepted.childId, messageId: accepted.messageId }
+  }
+
+  /** Only Lead-authored feedback is sent through this public model-message API. */
+  async continue(parent: Agent, childId: string, feedback: string, signal: AbortSignal): Promise<NativeWorkerAcceptance> {
+    signal.throwIfAborted()
+    const messageId = await this.ctx.subagents.sendMessage(
+      parent, SessionId(childId), [{ type: 'text', text: feedback }], { signal },
+    )
+    return { childId, messageId }
+  }
+
+  /**
+   * Replace an in-flight generation through public cancellation, then deliver
+   * to the same durable child. The caller must first exclude live/unknown
+   * effectful tools. Otherwise use continue(), which steers at a step boundary.
+   */
+  async interruptAndContinue(parent: Agent, childId: string, feedback: string, signal: AbortSignal): Promise<NativeWorkerAcceptance> {
+    signal.throwIfAborted()
+    await this.stop(parent, childId)
+    signal.throwIfAborted()
+    return this.continue(parent, childId, feedback, signal)
+  }
+
+  /** Interrupt acceptance is insufficient: wait for the exact native Agent to settle and flush. */
+  settle(parent: Agent, childId: string, signal: AbortSignal): Promise<Agent>
+  /** Yield a blocking tool to native user steering without canceling or releasing the Worker. */
+  settle(parent: Agent, childId: string, signal: AbortSignal, yieldToSteering: true): Promise<Agent | undefined>
+  async settle(parent: Agent, childId: string, signal: AbortSignal, yieldToSteering = false): Promise<Agent | undefined> {
+    const child = this.#requireChild(parent, childId)
+    let interruptError: unknown
+    let removeSteering = () => {}
+    const interrupt = () => {
+      try { this.ctx.subagents.interrupt(child.id, { kind: 'ancestor', agent: parent }) }
+      catch (error) { interruptError = error }
+    }
+    signal.addEventListener('abort', interrupt, { once: true })
+    if (signal.aborted) interrupt()
+    try {
+      if (yieldToSteering && !signal.aborted) {
+        const steering = new Promise<true>(resolve => {
+          const check = () => {
+            // Queue/next-turn and plugin context keep their native semantics.
+            if (parent.inbox.nextStep.some(message => message.source.kind === 'user')) resolve(true)
+          }
+          removeSteering = parent.ctx.on('agent/inbox/inserted', ({ agent }) => { if (agent === parent) check() })
+          check() // A message may already have arrived during delegation setup.
+        })
+        const yielded = await Promise.race([child.whenIdle().then(() => false), steering])
+        // Cancellation still owns full settlement; an already idle Worker can
+        // be flushed normally. The Lead alone authors any revised Worker brief.
+        if (yielded && !signal.aborted && child.status !== 'idle') return undefined
+      }
+      await child.whenIdle()
+      if (interruptError) throw interruptError
+      if (this.ctx.agents.get(child.id) !== child) throw new Error('Worker residency changed; quiescence requires reconciliation')
+      await this.#flushSettled(child)
+      return child
+    } finally { removeSteering(); signal.removeEventListener('abort', interrupt) }
+  }
+
+  async stop(parent: Agent, childId: string): Promise<Agent> {
+    const child = this.#requireChild(parent, childId)
+    // Native continuation teardown may already be closing this idle handle.
+    // Reuse only our exact prior quiescence+flush proof at the unchanged log seq.
+    if (child.status === 'idle' && this.#flushed.get(child) === (child.session.snapshotEvents().at(-1)?.seq ?? 0)) return child
+    this.ctx.subagents.interrupt(child.id, { kind: 'ancestor', agent: parent })
+    await child.whenIdle()
+    if (this.ctx.agents.get(child.id) !== child) throw new Error('Worker residency changed during stop')
+    await this.#flushSettled(child)
+    return child
+  }
+
+  /**
+   * 0.2.1 natural settlement flushes the child, then closes the persistence
+   * handle. A stop that loses that race must not treat the closed handle as a
+   * lost log. Any other flush failure still means the log is not durable.
+   */
+  async #flushSettled(child: Agent): Promise<void> {
+    try {
+      if (!await this.ctx.sessions.flush(child.session)) throw new Error('Worker log persistence unavailable')
+    } catch (error) {
+      if (!(error instanceof Error) || error.name !== 'SessionHandleClosedError') throw error
+      return
+    }
+    this.#flushed.set(child, child.session.snapshotEvents().at(-1)?.seq ?? 0)
+  }
+
+  /** Native release owns quiescence, persistence and handle disposal across HMR. */
+  async release(parent: Agent, childId: string): Promise<void> {
+    const child = this.ctx.agents.get(SessionId(childId))
+    if (child && child.session.header.parentSession !== parent.id) throw new Error('Cannot release another Lead’s child')
+    // 0.2.1 calls this `drainChildren`. 0.2.0 calls it `drainContinuableChildren`.
+    const subagents = this.ctx.subagents as SubagentSeam
+    const drain = requireSubagentMethod(subagents, 'drainChildren', 'drainContinuableChildren')
+    const ids = [SessionId(childId)]
+    if (drain === 'drainChildren') await subagents.drainChildren!(parent, ids)
+    else await subagents.drainContinuableChildren!(parent, ids)
+    if (this.ctx.agents.get(SessionId(childId))) throw new Error('Native Worker release did not prove absence')
+  }
+
+  #requireChild(parent: Agent, childId: string): Agent {
+    const child = this.ctx.agents.get(SessionId(childId))
+    if (!child || child.session.header.parentSession !== parent.id) {
+      throw new Error('Worker is absent or is not this Lead’s child; reconcile its persisted session')
+    }
+    return child
+  }
+}

package/src/host/native-workflow.ts

@@ -0,0 +1,103 @@
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
+import type { ToolExecution, ToolExecutionResult } from '@deepseek-ai/dsh-tools'
+import { digestOf } from '../digest.js'
+import type { Role } from '../contracts.js'
+import type { SqliteFusionStore } from '../task/sqlite-store.js'
+import type { SessionBinding } from './bindings.js'
+import { isShellTool } from './shell.js'
+import { FUSION_SOURCE_KIND } from '../message-source.js'
+
+export const enforcedWorkflow = (binding: SessionBinding) => binding.profile.workflowPolicy === 'enforced-v1' || binding.profile.workflowPolicy === 'enforced-v2' || binding.profile.workflowPolicy === 'enforced-v3'
+/** v3 keeps every v2 mechanism and adds role separation (see native-role-sandbox). */
+export const adaptiveWorkflow = (binding: SessionBinding) => binding.profile.workflowPolicy === 'enforced-v2' || binding.profile.workflowPolicy === 'enforced-v3'
+
+export interface ProgressWindow {
+  schemaVersion: 1
+  milestone: string
+  recent: string[]
+  tinyRead?: { path: string; count: number }
+}
+export interface ProgressObservation {
+  milestone: string
+  fingerprint?: string
+  tinyPath?: string
+  role: Role
+}
+
+/** Results, not model explanations, drive this bounded and persistable detector. */
+export function advanceProgress(previous: ProgressWindow | undefined, observation: ProgressObservation): { window: ProgressWindow; stalled: boolean } {
+  const prior = previous?.milestone === observation.milestone ? previous : undefined
+  const recent = [...(prior?.recent ?? []), observation.fingerprint ?? ''].slice(-8)
+  const tinyRead = observation.tinyPath ? { path: observation.tinyPath,
+    count: prior?.tinyRead?.path === observation.tinyPath ? prior.tinyRead.count + 1 : 1 } : undefined
+  return { window: { schemaVersion: 1, milestone: observation.milestone, recent, ...(tinyRead ? { tinyRead } : {}) },
+    stalled: Boolean(observation.fingerprint && recent.filter(item => item === observation.fingerprint).length >= 3
+      || tinyRead && tinyRead.count >= (observation.role === 'lead' ? 12 : 32)) }
+}
+
+/** Only public execution results and durable task facts enter the workflow controller. */
+export class NativeWorkflow {
+  constructor(readonly store: SqliteFusionStore) {}
+
+  milestone(binding: SessionBinding): string {
+    const state = this.store.load(binding.taskId)!
+    const runtime = this.store.readDocument(`runtime:${binding.taskId}`)?.value as { briefRevision?: number; submitted?: unknown; takeover?: boolean } | undefined
+    const control = adaptiveWorkflow(binding) ? this.store.readDocument(`model-control:${binding.sessionId}`)?.value as { recoveryEpoch?: number } | undefined : undefined
+    return digestOf({ order: state.currentWorkOrder?.id, revision: state.currentWorkOrder?.revision,
+      brief: runtime?.briefRevision, submitted: runtime?.submitted, takeover: runtime?.takeover,
+      phase: state.phase, report: state.validatedReport, review: state.reviewResult,
+      ...(adaptiveWorkflow(binding) ? { recoveryEpoch: control?.recoveryEpoch ?? 0 } : {}) })
+  }
+
+  observe(exec: Readonly<ToolExecution>, result: Readonly<ToolExecutionResult>, binding: SessionBinding, role: Role, read: boolean): boolean {
+    // Required recovery pagination and a live job wait must neither spend nor erase the window.
+    if (exec.name === 'fusion_read_state' || exec.name === 'job_output') return false
+    const id = `workflow-progress:${binding.taskId}:${exec.agent!.id}`, row = this.store.readDocument(id)
+    const shell = isShellTool(exec.name) && !result.isError ? result.value as { exitCode?: unknown } : undefined
+    const failed = result.isError || typeof shell?.exitCode === 'number' && shell.exitCode !== 0
+    const args = exec.arguments as { file_path?: string; path?: string; limit?: number }
+    const fingerprint = failed || read || exec.name.startsWith('fusion_')
+      ? digestOf({ name: exec.name, args: exec.arguments, error: result.isError, content: result.content }) : undefined
+    // Advancing through a file is real progress, however inefficient. Frozen v1
+    // retains its old slicing detector; v2 only interrupts repeated outcomes.
+    const tinyPath = !adaptiveWorkflow(binding) && !failed && exec.name === 'read' && typeof args.limit === 'number' && args.limit <= 2
+      ? args.file_path ?? args.path : undefined
+    const next = advanceProgress(row?.value as ProgressWindow | undefined, {
+      milestone: this.milestone(binding), fingerprint, tinyPath, role,
+    })
+    this.store.writeDocument(id, row?.revision ?? 0, next.window)
+    return next.stalled
+  }
+
+  /** One local replanning opportunity, not an immediate request for user intervention. */
+  repairProgress(agent: Agent, binding: SessionBinding, role: Role): boolean {
+    if (!adaptiveWorkflow(binding)) return false
+    const id = `workflow-replan:${binding.taskId}:${agent.id}:${this.milestone(binding)}`
+    if (this.store.readDocument(id)) return false
+    this.store.writeDocument(id, 0, { schemaVersion: 1, role, at: new Date().toISOString() })
+    const progressId = `workflow-progress:${binding.taskId}:${agent.id}`, row = this.store.readDocument(progressId)
+    this.store.writeDocument(progressId, row?.revision ?? 0, { schemaVersion: 1, milestone: this.milestone(binding), recent: [] })
+    agent.send(createUserMessage({ source: { kind: FUSION_SOURCE_KIND, form: 'notice', summary: 'Fusion 检测到重复结果，正在调整执行方式' },
+      content: [{ type: 'text', text: 'The runtime detected repeated unchanged tool results. Use the evidence already collected and change the approach instead of repeating those calls. Continue the current task; delegate broad work if useful. Another unchanged cycle will pause this role without discarding progress.' }] }), 'next-step', false)
+    return true
+  }
+
+  denyEffect(binding: SessionBinding): string {
+    const id = `workflow-effect-denied:${binding.taskId}`
+    if (!this.store.readDocument(id)) this.store.writeDocument(id, 0, { schemaVersion: 1, taskId: binding.taskId })
+    return 'FUSION_LEAD_READ_ONLY: execution belongs to the Sidekick. Use fusion_delegate for workspace changes or commands; fusion_explore for investigation. Lead takeover requires a current implementation report and a recorded rework review.'
+  }
+
+  deniedEffect(binding: SessionBinding): boolean { return Boolean(this.store.readDocument(`workflow-effect-denied:${binding.taskId}`)) }
+
+  /** At most one repair generation per role and durable milestone, surviving reloads. */
+  repairStop(agent: Agent, binding: SessionBinding, role: Role, instruction: string): boolean {
+    const id = `workflow-stop:${binding.taskId}:${agent.id}:${this.milestone(binding)}`
+    if (this.store.readDocument(id)) return false
+    this.store.writeDocument(id, 0, { schemaVersion: 1, role, at: new Date().toISOString() })
+    agent.send(createUserMessage({ source: { kind: FUSION_SOURCE_KIND, form: 'notice', summary: 'Fusion 工作流尚未完成' },
+      content: [{ type: 'text', text: instruction }] }), 'next-step', false)
+    return true
+  }
+}

package/src/host/route-transport.ts

@@ -0,0 +1,54 @@
+import type { Context } from '@deepseek-ai/cordis'
+import type {} from '@deepseek-ai/dsh-tools'
+
+/**
+ * Provider routes that run their OWN agent loop instead of answering one model
+ * call. Their adapter can only hand a tool call back to this Host under its own
+ * transport name, so a caller-driven tool ceiling that lists only the caller's
+ * own tools advertises names the route can never emit.
+ *
+ * `antigravity` is dsh-agy-link: `agy` executes the bridged call inside its own
+ * loop, and the adapter reports that step as `agy_tool`, which this Host replays
+ * as a native card. Fusion's Worker is exactly such a caller — its ceiling was
+ * `workerTools` + `fusion_*`, so the delegation ran as prose and the Host
+ * (correctly) diagnosed `WORKER_TOOLS_UNREACHABLE`.
+ */
+const ROUTE_TRANSPORT: Readonly<Record<string, string>> = { antigravity: 'agy_tool' }
+
+/** Every transport a bridge route may report a step through. */
+const ROUTE_TRANSPORT_NAMES: ReadonlySet<string> = new Set(Object.values(ROUTE_TRANSPORT))
+
+/** The transport name this provider route needs, registered or not. */
+export function routeTransportName(provider: string): string | undefined {
+  return ROUTE_TRANSPORT[provider]
+}
+
+/**
+ * Whether `name` is a bridge-route transport. Such a tool only replays a step
+ * the route already executed in its own loop: it is presentation, not an effect
+ * this Host authorizes, bills or holds a write lease for.
+ */
+export function isRouteTransportName(name: string): boolean {
+  return ROUTE_TRANSPORT_NAMES.has(name)
+}
+
+/**
+ * The transport this route needs AND this Host can actually accept. An
+ * unregistered name is skipped, because a call naming it is rejected as
+ * `unknown tool` — the adapter must never invent one either.
+ *
+ * The lookup is the GLOBAL view on purpose. A bridge registers its transport at
+ * the host layer, while an agent scope's own restriction hides inherited tools:
+ * reading through the Worker's restricted scope would report "absent" on the
+ * very next refresh and shrink the ceiling that had just been widened.
+ */
+export function registeredRouteTransport(ctx: Context, provider: string): string | undefined {
+  const name = routeTransportName(provider)
+  if (name === undefined) return undefined
+  return ctx.tools.get(name) === undefined ? undefined : name
+}
+
+/** Add the route's transport to a capability ceiling without duplicating a configured entry. */
+export function withRouteTransport(ceiling: readonly string[], transport: string | undefined): readonly string[] {
+  return transport === undefined || ceiling.includes(transport) ? ceiling : [...ceiling, transport]
+}

package/src/host/settings.ts

@@ -0,0 +1,93 @@
+import { bi } from '../bilingual.js'
+import type { PairProfile, PhysicalRoute } from '../contracts.js'
+import { keepaliveChoice } from '../profile/keepalive.js'
+import { compactorChoice } from '../profile/compactor.js'
+import { isFusionProvider } from '../identity.js'
+
+export interface PairChoice {
+  lead: PhysicalRoute
+  worker: PhysicalRoute
+  outputTokens?: Partial<Record<'lead' | 'worker', number>>
+  cacheKeepalive?: PairProfile['cacheKeepalive']
+  compactor?: PairProfile['compactor']
+}
+export interface SettingsCatalog {
+  groups: readonly { id: string; name: string; models: readonly {
+    id: string; name: string; reasoning?: { efforts: readonly { id: string; name: string }[]; defaultEffort?: string }
+  }[] }[]
+}
+
+/** Saved Lead route from a raw settings or profile document, or undefined when unconfigured or pointed at Fusion itself. */
+export function savedLeadRoute(value: unknown): { provider: string; model: string } | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined
+  const route = (value as Record<string, unknown>).lead
+  if (!route || typeof route !== 'object' || Array.isArray(route)) return undefined
+  const provider = (route as Record<string, unknown>).provider, model = (route as Record<string, unknown>).model
+  if (typeof provider !== 'string' || typeof model !== 'string' || isFusionProvider(provider)) return undefined
+  return { provider, model }
+}
+
+/** Configuration chooses registered physical models; it cannot create adapters. */
+export function validatePairChoice(value: unknown, catalog: SettingsCatalog): PairChoice {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(bi('请选择 Lead 和 Worker', 'Choose a Lead and a Sidekick'))
+  const raw = value as Record<string, unknown>
+  const route = (role: string, candidate: unknown): PhysicalRoute => {
+    const item = candidate as Record<string, unknown> | undefined
+    if (!item || typeof item.provider !== 'string' || typeof item.model !== 'string') throw new Error(bi(`请选择 ${role} 模型`, `Choose the ${role} model`))
+    if (isFusionProvider(item.provider)) throw new Error(bi('Fusion 必须选择真实模型', 'Fusion needs real models, not Fusion itself'))
+    const group = catalog.groups.find(group => group.id === item.provider)
+    const model = group?.models.find(model => model.id === item.model)
+    if (!model) throw new Error(bi(`${role} 模型已不可用，请刷新后重选`, `The ${role} model is no longer available; refresh and choose again`))
+    if (item.reasoningEffort !== undefined && (typeof item.reasoningEffort !== 'string'
+      || !model.reasoning?.efforts.some(effort => effort.id === item.reasoningEffort))) {
+      throw new Error(bi(`${role} 不支持所选推理强度`, `${role} does not support the selected reasoning level`))
+    }
+    return { provider: item.provider, model: item.model,
+      ...(item.reasoningEffort === undefined ? {} : { reasoningEffort: item.reasoningEffort as string }) }
+  }
+  const cacheKeepalive = keepaliveChoice(raw.cacheKeepalive)
+  const compactor = compactorChoice(raw.compactor)
+  let outputTokens: PairChoice['outputTokens']
+  if (raw.outputTokens !== undefined) {
+    const value = raw.outputTokens
+    if (!value || typeof value !== 'object' || Array.isArray(value)
+      || Object.entries(value).some(([role, tokens]) => !['lead', 'worker'].includes(role)
+        || !Number.isSafeInteger(tokens) || Number(tokens) < 1 || Number(tokens) > 128_000)) {
+      throw new Error(bi('每次响应上限必须是 1–128000 的整数 Token 数', 'The per-response limit must be an integer of 1–128000 tokens'))
+    }
+    outputTokens = { ...value } as PairChoice['outputTokens']
+  }
+  return { lead: route('lead', raw.lead), worker: route('worker', raw.worker),
+    ...(outputTokens === undefined ? {} : { outputTokens }),
+    ...(cacheKeepalive === undefined ? {} : { cacheKeepalive }),
+    ...(compactor === undefined ? {} : { compactor: { ...compactor, route: route('压缩 · Compaction', compactor.route) } }) }
+}
+
+/** New sessions can opt into this Worker cap. Frozen sessions keep their saved profile. */
+export const WORKER_IMPLEMENTATION_OUTPUT_TOKENS = 128_000
+
+export function profileFromChoice(pair: PairChoice): Record<string, unknown> {
+  const { outputTokens, ...routes } = pair
+  const version = outputTokens?.worker === WORKER_IMPLEMENTATION_OUTPUT_TOKENS ? '0.1.0-worker-128k' : '0.1.0-faithful'
+  return { schemaVersion: 1, id: 'fusion-auto', version, enabled: true, quality: 'experimental',
+    ...routes, workerUpgradePath: [], dataPolicyId: 'native-host-workspace-policy', evidenceCampaignIds: [],
+    ...(outputTokens === undefined ? {} : { context: Object.fromEntries(Object.entries(outputTokens)
+      .map(([role, reserveOutputTokens]) => [role, { reserveOutputTokens }])) }) }
+}
+
+/** Product defaults; explicit legacy/benchmark profiles retain their old contract. */
+export function modelProfileFromChoice(pair: PairChoice): Record<string, unknown> {
+  const { outputTokens: _output, ...native } = pair
+  return { ...profileFromChoice(native), version: '0.2.0-enforced-v3', interactionMode: 'model-like', workflowPolicy: 'enforced-v3' }
+}
+
+/** Keep existing default settings stable; expose explicit larger/smaller limits on reload. */
+export function choiceFromProfile(profile: PairProfile): PairChoice {
+  const outputTokens = Object.fromEntries((['lead', 'worker'] as const)
+    .filter(role => profile.context[role].reserveOutputTokens !== 8_000)
+    .map(role => [role, profile.context[role].reserveOutputTokens]))
+  return { lead: profile.lead, worker: profile.worker,
+    ...(profile.interactionMode !== 'model-like' && Object.keys(outputTokens).length ? { outputTokens } : {}),
+    ...(profile.compactor === undefined ? {} : { compactor: profile.compactor }),
+    ...(profile.cacheKeepalive === undefined ? {} : { cacheKeepalive: profile.cacheKeepalive }) }
+}

package/src/host/shell.ts

@@ -0,0 +1,13 @@
+/**
+ * The native shell tool the Host mounts on this platform. cordis.patch.yml
+ * disables tool-bash on win32 and mounts tool-pwsh instead; elsewhere the
+ * bash tool is the native shell. Safety gates must apply to whichever shell
+ * tool issued the call, so checks use {@link isShellTool}, while defaults
+ * and probes use {@link nativeShellTool} — the tool that actually exists.
+ */
+export const nativeShellTool: 'bash' | 'pwsh' = process.platform === 'win32' ? 'pwsh' : 'bash'
+
+export const isShellTool = (name: string): name is 'bash' | 'pwsh' => name === 'bash' || name === 'pwsh'
+
+/** Command text the prompt layer names for the platform's native shell. */
+export const nativeShellDescription = process.platform === 'win32' ? 'pwsh' : 'bash'

package/src/host/status.ts

@@ -0,0 +1,112 @@
+import { readModelControl } from './native-model-control.js'
+import type { TaskState } from '../task/state.js'
+import type { SqliteFusionStore } from '../task/sqlite-store.js'
+import type { StatusIndex } from '../task/status-index.js'
+import type { FusionStatus } from '../status.js'
+import { BindingRepository } from './bindings.js'
+
+/** English copies of the stage and detail texts; the client shows them when DSH runs in English. */
+const EN: Record<string, string> = {
+  '正在停止': 'Stopping', '正在等待已启动的操作收尾。': 'Waiting for started operations to finish.',
+  '等待检查': 'Needs inspection', '请先核对中断的操作，再使用 /fusion recover 提交检查记录。': 'Check the interrupted operations, then record the inspection with /fusion recover.',
+  '已取消': 'Cancelled', '等待确认': 'Waiting for approval', '请在 DSH 的权限提示中处理待确认操作。': 'Handle the pending approval in DSH\'s permission prompt.',
+  '等待额度': 'Waiting for quota', '请前往设置 → Fusion 查看额度，处理后使用 /fusion resume。': 'See Settings → Fusion for the quota, then use /fusion resume.',
+  '已暂停': 'Paused', '使用 /fusion status 查看状态，确认后可用 /fusion resume 继续。': 'Check /fusion status, then continue with /fusion resume.',
+  '完成': 'Done', '验证': 'Verifying',
+  'Worker 模型服务提示额度已耗尽，当前任务和文件已保留。恢复额度后发送消息继续。': 'The Sidekick provider reported exhausted quota; the task and files are kept. Send a message to continue once quota is back.',
+  '等待反馈': 'Needs your input', 'Worker 已达到本任务的执行次数上限，现有结果已保留。请查看会话中的未完成说明。': 'The Sidekick reached this task\'s step limit; its results are kept. See the unfinished notes in the conversation.',
+  '就绪': 'Ready', '探索尚未完成，请查看会话中的阻塞说明；补充信息后会继续原 Worker。': 'Exploration is unfinished: see the blocker in the conversation; the same Sidekick continues once you add the information.',
+  '分析': 'Analysing', '执行': 'Working', '修改': 'Revising', '审查': 'Reviewing',
+  '请处理 DSH 的待确认操作。': 'Handle the pending DSH approval.', '请查看会话中的问题或阻塞说明。': 'See the question or blocker in the conversation.',
+  '请前往设置 → Fusion 查看调用额度。': 'See Settings → Fusion for the request quota.', '请查看 /fusion status 并核对中断的操作。': 'Check /fusion status and the interrupted operations.',
+  '确认任务状态后，使用 /fusion resume 继续。': 'Confirm the task state, then continue with /fusion resume.',
+  '未完成': 'Unfinished', '请查看会话中的错误和 /fusion status。': 'See the error in the conversation and /fusion status.',
+  '完成状态尚未确认，请查看 /fusion status。': 'Completion is unconfirmed; see /fusion status.',
+  '需要调整做法': 'Needs a different approach', '等待模型': 'Waiting for the model',
+  '继续消息的投递结果尚未确认。检查会话后使用 /fusion recover 提交检查记录。': 'Delivery of the continuation is unconfirmed. Check the conversation, then use /fusion recover.',
+}
+const english = (text: string | null | undefined) => text == null ? text : EN[text] ?? text
+
+export function taskStage(state: TaskState, checking: boolean, workerStepLimitReached = false, workerQuotaExhausted = false): Pick<NonNullable<FusionStatus['task']>, 'stage' | 'detail' | 'attention'> {
+  const control = state.control
+  const value = (stage: string, detail: string | null = null, attention = false) => ({ stage, detail, attention })
+  if (control.mode === 'stop-requested') return value('正在停止', '正在等待已启动的操作收尾。', true)
+  if (control.recovering || control.outcomeUnknown) return value('等待检查', '请先核对中断的操作，再使用 /fusion recover 提交检查记录。', true)
+  if (control.mode === 'cancelled') return value('已取消')
+  if (control.pendingApprovalIds.length) return value('等待确认', '请在 DSH 的权限提示中处理待确认操作。', true)
+  if (control.budgetBlocked) return value('等待额度', '请前往设置 → Fusion 查看额度，处理后使用 /fusion resume。', true)
+  if (control.mode === 'paused') return value('已暂停', '使用 /fusion status 查看状态，确认后可用 /fusion resume 继续。', true)
+  if (control.mode === 'completed' && state.phase === 'COMPLETED') return value('完成')
+  if (checking) return value('验证')
+  if (workerQuotaExhausted && ['WORKER_RUNNING', 'REWORK', 'PLANNING', 'NEEDS_DECISION'].includes(state.phase)) {
+    return value('等待额度', 'Worker 模型服务提示额度已耗尽，当前任务和文件已保留。恢复额度后发送消息继续。', true)
+  }
+  if (workerStepLimitReached && ['WORKER_RUNNING', 'REWORK', 'PLANNING', 'NEEDS_DECISION'].includes(state.phase)) {
+    return value('等待反馈', 'Worker 已达到本任务的执行次数上限，现有结果已保留。请查看会话中的未完成说明。', true)
+  }
+  switch (state.phase) {
+    case 'READY': return value('就绪')
+    case 'PLANNING': return state.currentWorkOrder?.mode === 'explore' && state.exploration && state.exploration.status !== 'completed'
+      ? value('等待反馈', '探索尚未完成，请查看会话中的阻塞说明；补充信息后会继续原 Worker。', true) : value('分析')
+    case 'DIRECT': case 'WORKER_RUNNING': return value('执行')
+    case 'REWORK': return value('修改')
+    case 'REVIEWING': return value('审查')
+    case 'WAITING_APPROVAL': return value('等待确认', '请处理 DSH 的待确认操作。', true)
+    case 'WAITING_USER': case 'NEEDS_DECISION': return value('等待反馈', '请查看会话中的问题或阻塞说明。', true)
+    case 'WAITING_BUDGET': return value('等待额度', '请前往设置 → Fusion 查看调用额度。', true)
+    case 'RECOVERING': return value('等待检查', '请查看 /fusion status 并核对中断的操作。', true)
+    case 'PAUSED': return value('已暂停', '确认任务状态后，使用 /fusion resume 继续。', true)
+    case 'STOPPING': return value('正在停止', null, true)
+    case 'FAILED': return value('未完成', '请查看会话中的错误和 /fusion status。', true)
+    case 'CANCELLED': return value('已取消')
+    case 'COMPLETED': return value('等待检查', '完成状态尚未确认，请查看 /fusion status。', true)
+  }
+}
+
+/** Reads existing durable facts only. Polling never constructs a runtime or calls a model. */
+export function readFusionStatus(store: SqliteFusionStore, sessionId: string): FusionStatus {
+  return store.statusSnapshot(index => readStatus(store, sessionId, index))
+}
+
+export function readFusionStatusAsync(store: SqliteFusionStore, sessionId: string, signal?: AbortSignal): Promise<FusionStatus> {
+  return store.statusSnapshotAsync(index => readStatus(store, sessionId, index), signal)
+}
+
+function readStatus(store: SqliteFusionStore, sessionId: string, index: StatusIndex): FusionStatus {
+  const binding = new BindingRepository(store).read(sessionId)?.binding
+  const base: FusionStatus = { schemaVersion: 1, sessionId, selected: Boolean(binding?.selected), observedAt: new Date().toISOString() }
+  if (!binding?.selected) return base
+  const taskId = binding.taskId, state = store.load(taskId)
+  if (!state || state.parent !== sessionId || state.profileDigest !== binding.profile.digest) throw new Error('Fusion 任务记录不一致，请检查存档')
+  const { checking, ...facts } = index.read(taskId)
+  const runtime = store.readDocument(`runtime:${taskId}`)?.value as { schemaVersion?: number; taskId?: string;
+    workerStepStop?: { workOrderId?: string; requests: number; limit: number };
+    workerFailure?: { workOrderId?: string; childId?: string; category?: string } } | undefined
+  const stop = runtime?.workerStepStop
+  const workerStepLimitReached = runtime?.schemaVersion === 1 && runtime.taskId === taskId && Boolean(stop
+    && state.currentWorkOrder && stop.workOrderId === state.currentWorkOrder.id && stop.limit > 0 && stop.requests >= stop.limit)
+  const failure = runtime?.workerFailure
+  const workerQuotaExhausted = runtime?.schemaVersion === 1 && runtime.taskId === taskId && Boolean(failure
+    && state.currentWorkOrder && failure.workOrderId === state.currentWorkOrder.id && failure.childId === state.acceptedChild
+    && failure.category === 'quota-exhausted')
+  const modelControl = readModelControl(store, binding)
+  const waiting = modelControl && Object.entries(modelControl.waits).filter(([, wait]) => wait?.taskId === taskId)
+  const modelStage = waiting?.length && state.control.mode !== 'completed' && state.control.mode !== 'cancelled' && !state.control.budgetBlocked && !checking && !state.control.recovering && !state.control.outcomeUnknown && !state.control.pendingApprovalIds.length
+    ? { stage: waiting.some(([, wait]) => ['NO_PROGRESS', 'WORKFLOW_INCOMPLETE'].includes(wait!.code)) ? '需要调整做法' : '等待模型',
+      detail: `${waiting.map(([role]) => role === 'lead' ? 'Lead' : 'Sidekick').join('、')} 已暂停。请查看原因后继续。`,
+      detailEn: `${waiting.map(([role]) => role === 'lead' ? 'Lead' : 'Sidekick').join(' and ')} paused. See the reason, then continue.`, attention: true } : {}
+  const pendingDelivery = modelControl?.operation && ['prepared', 'dispatching'].includes(modelControl.operation.state)
+    ? { stage: '等待检查', detail: '继续消息的投递结果尚未确认。检查会话后使用 /fusion recover 提交检查记录。', attention: true } : {}
+  const stage = { ...taskStage(state, checking, workerStepLimitReached, workerQuotaExhausted), ...modelStage, ...pendingDelivery }
+  return { ...base, task: { id: taskId, revision: state.revision, ...stage, stageEn: english(stage.stage)!,
+    detailEn: 'detailEn' in stage && stage.detailEn ? stage.detailEn : english(stage.detail) ?? null, ...(modelControl ? { modelControl } : {}), verification: state.verification,
+    workerId: state.acceptedChild ?? binding.workerId ?? null,
+    models: { lead: modelControl?.routes.lead ?? binding.profile.lead, worker: modelControl?.routes.worker ?? binding.profile.worker, compactor: binding.profile.compactor?.route ?? null },
+    ...facts,
+    automatedChecks: Array.isArray((runtime as { checks?: unknown[] } | undefined)?.checks) && runtime?.taskId === taskId
+      ? (runtime as { checks: unknown[] }).checks.length : null,
+    pendingApprovals: state.control.pendingApprovalIds.length,
+    recovering: state.control.recovering,
+    outcomeUnknown: state.control.outcomeUnknown,
+  } }
+}

package/src/host/subagent-seam.ts

@@ -0,0 +1,20 @@
+/**
+ * Runtime detection for the DSH subagent seam.
+ * 0.2.1-rc.2 renamed continuable start/drain and removed `ctx.subagents.start`.
+ * 0.2.0-rc.2 still has the old names. Callers branch on the function that is
+ * actually present. They do not read a version string.
+ */
+
+export const supportedDshVersions = '0.2.0-rc.2 and 0.2.1-rc.2'
+
+export function hasStartActivation(subagents: object): boolean {
+  return typeof (subagents as { startActivation?: unknown }).startActivation === 'function'
+}
+
+/** Prefer `primary` (the 0.2.1 name) when both exist. */
+export function requireSubagentMethod(subagents: object, primary: string, fallback: string): string {
+  const api = subagents as Record<string, unknown>
+  if (typeof api[primary] === 'function') return primary
+  if (typeof api[fallback] === 'function') return fallback
+  throw new Error(`Fusion supports DeepSeek Harness ${supportedDshVersions}; this host has neither subagents.${primary} nor subagents.${fallback}`)
+}