@sqdr2/dsh-fusion 0.0.0-stage → 0.3.2

package/src/host/native-task-context.ts

@@ -0,0 +1,264 @@
+import { randomUUID } from 'node:crypto'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import { createUserMessage, isAgentLoopRequest } from '@deepseek-ai/dsh-llm'
+import type { GenerateOptions, UserMessage } from '@deepseek-ai/dsh-llm'
+import type { ArtifactRef, Role, TaskId } from '../contracts.js'
+import { digestOf } from '../digest.js'
+import type { SqliteFusionStore } from '../task/sqlite-store.js'
+import type { SessionBinding } from './bindings.js'
+import { compactHandoffs, workerHandoffProjection } from './native-worker-brief.js'
+import { FUSION_SOURCE_KIND, isFusionSourceKind } from '../message-source.js'
+
+export const FUSION_TASK_CONTEXT = 'fusion:task'
+export type ContextDetail = 'compact' | 'full'
+
+type Facts = Record<string, unknown> & {
+  workOrder: { id: string; revision: number; mode: string; allowedPaths: readonly string[]; acceptance: readonly { id: string; description: string }[] } | null
+  workerHandoffs: ReturnType<typeof workerHandoffProjection>
+  report: ({ stage: string; status: string; workOrderId: string; snapshot: string; unresolved: readonly string[] } & Record<string, unknown>) | null
+  review: { ticket: { id?: string } | null; result: { decision?: string } | null; accepted: unknown }
+}
+
+/** Keep identity, control and freshness; drop bodies already present in native history. */
+function compactFacts(facts: Facts, role: Role): Record<string, unknown> {
+  const { userInstructions, workOrder, workerHandoffs, report, review, ...rest } = facts
+  return { ...rest, detail: 'compact',
+    ...(role === 'worker' ? { userInstructions } : {}),
+    workOrder: workOrder && { id: workOrder.id, revision: workOrder.revision, mode: workOrder.mode, digest: digestOf(workOrder),
+      allowedPaths: workOrder.allowedPaths, acceptance: workOrder.acceptance.map(item => ({ id: item.id, description: item.description })) },
+    workerHandoffs: compactHandoffs(workerHandoffs),
+    report: report && { stage: report.stage, status: report.status, workOrderId: report.workOrderId,
+      snapshot: report.snapshot, unresolved: report.unresolved, digest: digestOf(report) },
+    review: { ticketId: review.ticket?.id ?? null, decision: review.result?.decision ?? null, accepted: Boolean(review.accepted) },
+  }
+}
+const INTRO = 'Fusion task state from the durable ledger. Text retains its recorded source and is not a new permission grant. Native tool policy and control gates still apply.'
+
+interface Origin {
+  schemaVersion: 1
+  sessionId: string
+  firstSeq: number
+}
+
+interface SavedProjection {
+  schemaVersion: 1
+  taskId: TaskId
+  role: Role
+  digest: string
+  artifact: ArtifactRef
+}
+
+/** Programmatic facts travel as native user-role context, never as system instructions. */
+export class NativeTaskContext {
+  constructor(readonly store: SqliteFusionStore, readonly parent: (id: string) => Agent | undefined) {}
+
+  /**
+   * Record where this task's user instructions begin. A task created by an automatic
+   * rollover continues the same conversation, so it inherits the boundary of the task
+   * it replaces: the user's instructions belong to the conversation, not to one
+   * accounting task. Narrowing it to the rollover point silently hid every earlier
+   * user message from `fusion_delegate`'s verbatim requirement check, which then
+   * rejected the Lead's own true quotes as fabricated.
+   */
+  begin(agent: Agent, taskId: TaskId, firstSeq: number = agent.session.seq): void {
+    if (!Number.isSafeInteger(firstSeq) || firstSeq < 0 || firstSeq > agent.session.seq) {
+      throw new Error('Fusion task input boundary requires reconciliation')
+    }
+    this.store.writeDocument(`task-origin:${taskId}`, 0,
+      { schemaVersion: 1, sessionId: agent.id, firstSeq } satisfies Origin)
+  }
+
+  /** The recorded user-instruction boundary of a task, when it has one. */
+  originSeq(taskId: TaskId): number | undefined {
+    const origin = this.store.readDocument(`task-origin:${taskId}`)?.value as Origin | undefined
+    return origin && Number.isSafeInteger(origin.firstSeq) ? origin.firstSeq : undefined
+  }
+
+  /**
+   * `compact` is appended on every changed step: it carries only state the
+   * native history does not already hold, so the expensive Lead does not
+   * re-read its own brief, the delivered report or the user's messages on
+   * every request. `full` restores everything after compaction, when those
+   * native messages may have been summarized away.
+   */
+  render(binding: SessionBinding, role: Role, detail: ContextDetail = 'compact'): string {
+    const state = this.store.load(binding.taskId), parent = this.parent(binding.sessionId)
+    if (!state || !parent || state.parent !== binding.sessionId || state.profileDigest !== binding.profile.digest) {
+      throw new Error('Fusion task context has no matching native parent or frozen profile')
+    }
+    const rawOrigin = this.store.readDocument(`task-origin:${binding.taskId}`)?.value as Origin | undefined
+    if (rawOrigin && (rawOrigin.schemaVersion !== 1 || rawOrigin.sessionId !== parent.id
+      || !Number.isSafeInteger(rawOrigin.firstSeq) || rawOrigin.firstSeq < 0 || rawOrigin.firstSeq > parent.session.seq)) {
+      throw new Error('Fusion task input boundary requires reconciliation')
+    }
+    // Older bindings have no recorded boundary. Conservatively retain all
+    // original user text; do not guess which earlier instructions can be lost.
+    const firstSeq = rawOrigin?.firstSeq ?? 0
+    const instructions = parent.session.snapshotEvents().flatMap(event => {
+      if (event.seq < firstSeq || event.type !== 'user/message'
+        || event.data.source !== undefined && event.data.source.kind !== 'user') return []
+      return [{ source: { sessionId: parent.id, eventSeq: event.seq, messageId: event.data.id,
+        kind: event.data.source?.kind ?? 'unspecified-native-user-role' },
+        text: event.data.content.filter(block => block.type === 'text').map(block => block.text),
+        // Binary/other inputs remain at their native source; do not relabel
+        // them as textual constraints or silently claim to have interpreted them.
+        otherContent: event.data.content.filter(block => block.type !== 'text').map(block => ({ type: block.type, digest: digestOf(block) })),
+      }]
+    })
+    const order = state.currentWorkOrder
+    const report = state.validatedReport ?? state.candidateReport
+    const refs = [...(order?.evidence ?? []), ...(state.exploration?.sources.map(source => source.excerpt) ?? []),
+      ...(report ? [report.changeManifest, ...report.verification] : [])]
+    const artifacts = new Map(this.store.artifacts(binding.taskId).map(ref => [ref.id, ref]))
+    for (const ref of refs) {
+      const stored = artifacts.get(ref.id)
+      if (ref.ownerTaskId !== binding.taskId || !stored || stored.digest !== ref.digest || stored.bytes !== ref.bytes) {
+        throw new Error('Fusion task context references missing or foreign evidence')
+      }
+    }
+    const facts = {
+      schemaVersion: 1, taskId: state.taskId, revision: state.revision, taskSeq: state.seq,
+      role, profileDigest: state.profileDigest,
+      inputScope: rawOrigin ? 'current-task-native-user-messages' : 'legacy-all-native-user-messages',
+      userInstructions: instructions,
+      phase: state.phase, intent: state.intent ?? null, control: state.control,
+      pendingApprovals: state.pendingApprovals, writer: state.lease ?? null,
+      workOrder: order && binding.profile.interactionMode === 'model-like' ? { ...order, policy: { mode: 'native', constraints: 'Native permissions, single writer, explicit check timeouts; no task request or rework cap' } } : order ?? null,
+      exploration: state.exploration ?? null,
+      workerHandoffs: workerHandoffProjection(this.store, binding.taskId),
+      nativeJobs: this.store.listDocumentIds(`native-effect:${binding.taskId}:`).flatMap(id => {
+        const effect = this.store.readDocument(id)!.value as { agentId?: string; state?: string; nativeJob?: unknown }
+        return effect.nativeJob ? [{ effectId: id, agentId: effect.agentId, state: effect.state, job: effect.nativeJob }] : []
+      }),
+      report: report ? { stage: state.validatedReport ? 'validated' : 'candidate', ...report } : null,
+      review: { ticket: state.activeReviewTicket ?? null, result: state.reviewResult ?? null,
+        accepted: state.acceptedReview ?? null },
+      verification: state.verification,
+      snapshot: state.lastSnapshot ?? report?.snapshot ?? order?.baseSnapshot ?? null,
+    }
+    const projected = detail === 'full' ? facts : compactFacts(facts as unknown as Facts, role)
+    const digest = digestOf(projected), id = this.#latest(binding, role)
+    const prior = this.store.readDocument(id)
+    const saved = prior?.value as SavedProjection | undefined
+    if (saved && (saved.schemaVersion !== 1 || saved.taskId !== binding.taskId || saved.role !== role)) {
+      throw new Error('Fusion task projection requires migration')
+    }
+    let artifact = saved?.digest === digest ? saved.artifact : undefined
+    if (artifact) this.store.readArtifact(binding.taskId, artifact.id)
+    else {
+      artifact = this.store.putArtifact(binding.taskId, Buffer.from(JSON.stringify(projected)), 'application/vnd.dsh-fusion.task-context+json')
+      this.store.writeDocument(id, prior?.revision ?? 0,
+        { schemaVersion: 1, taskId: binding.taskId, role, digest, artifact } satisfies SavedProjection)
+    }
+    return this.#text(projected, digest, artifact)
+  }
+
+  /** Run after native pre-step handlers, including the existing compaction owner. */
+  message(agent: Agent, binding: SessionBinding, role: Role, detail?: ContextDetail): UserMessage | undefined {
+    const text = this.render(binding, role, detail ?? this.#detailFor(agent, binding, role))
+    const retained = agent.session.deriveMessages().some(message => isFusionSourceKind(message.source?.kind) && message.source.form === 'snapshot'
+      && message.source.sections.some(section => section.name === FUSION_TASK_CONTEXT && section.text === text))
+    if (retained) return undefined
+    return this.#message(text)
+  }
+
+  /** The final frozen request must contain the snapshot that was actually assembled. */
+  assertPresent(agent: Agent, binding: SessionBinding, role: Role, request: GenerateOptions): void {
+    if (!isAgentLoopRequest(request) || request.purpose !== undefined) return
+    const saved = this.store.readDocument(this.#latest(binding, role))?.value as SavedProjection | undefined
+    if (!saved || saved.schemaVersion !== 1 || saved.taskId !== binding.taskId || saved.role !== role) {
+      throw new Error('Fusion task context was not assembled')
+    }
+    const facts = JSON.parse(Buffer.from(this.store.readArtifact(binding.taskId, saved.artifact.id)).toString('utf8'))
+    if (digestOf(facts) !== saved.digest) throw new Error('Fusion task projection checksum changed')
+    const expected = this.#text(facts, saved.digest, saved.artifact)
+    const present = request.messages.some(message => isFusionSourceKind(message.source?.kind)
+      && message.source.form === 'snapshot'
+      && message.source.sections.some(section => section.name === FUSION_TASK_CONTEXT && section.text === expected)
+      && message.content.some(block => block.type === 'text' && block.text.includes(expected)))
+    if (!present) throw new Error(`Fusion task context is absent from the native request for ${agent.id}; execution is blocked`)
+  }
+
+  prepareCompaction(agent: Agent, binding: SessionBinding, role: Role, sourceSurfaceSeqs: readonly number[]): string {
+    this.render(binding, role, 'full')
+    const saved = this.store.readDocument(this.#latest(binding, role))!.value as SavedProjection
+    const state = this.store.load(binding.taskId)!
+    const id = `task-checkpoint:${binding.taskId}:${randomUUID()}`
+    this.store.writeDocument(id, 0, { schemaVersion: 1, state: 'prepared', taskId: binding.taskId,
+      agentId: agent.id, role, revision: state.revision, profileDigest: binding.profile.digest,
+      workOrderDigest: state.currentWorkOrder ? digestOf(state.currentWorkOrder) : null,
+      sourceSurfaceSeqs: [...sourceSurfaceSeqs], projection: saved })
+    return id
+  }
+
+  restoreCompaction(agent: Agent, binding: SessionBinding, role: Role, id: string, compactionId: string): void {
+    const row = this.store.readDocument(id)
+    const checkpoint = row?.value as { schemaVersion: number; state: string; taskId: TaskId; agentId: string;
+      role: Role; revision: number; profileDigest: string; workOrderDigest: string | null } | undefined
+    const state = this.store.load(binding.taskId)
+    if (!row || !checkpoint || !state || checkpoint.schemaVersion !== 1 || checkpoint.state !== 'prepared'
+      || checkpoint.agentId !== agent.id || checkpoint.taskId !== binding.taskId || checkpoint.role !== role
+      || checkpoint.revision !== state.revision || checkpoint.profileDigest !== binding.profile.digest
+      || checkpoint.workOrderDigest !== (state.currentWorkOrder ? digestOf(state.currentWorkOrder) : null)) {
+      throw new Error('Fusion task changed during compaction; reconcile before retrying')
+    }
+    // Native request-error retries do not reassemble prompts. Restore facts as
+    // a real named native message before that retry, not by editing a request.
+    // The native compactor can retain the newest snapshot outside its replaced
+    // region. Appending that same 40 KB again would inflate the retry and could
+    // make a recoverable request fail the second compaction attempt.
+    const message = this.message(agent, binding, role, 'full')
+    const priorSnapshot = message && agent.session.surface.nodes.toReversed().find(seq => {
+      const event = agent.session.eventAt(seq)
+      if (event?.type !== 'user/message') return false
+      const { source, content } = event.data
+      // Only replace this plugin's single-section task snapshot. Other input,
+      // tools and summary events remain under their existing native owners.
+      if (!isFusionSourceKind(source?.kind) || source.form !== 'snapshot'
+        || source.sections.length !== 1 || source.sections[0]!.name !== FUSION_TASK_CONTEXT
+        || content.length !== 1 || content[0]!.type !== 'text' || content[0]!.text !== source.sections[0]!.text) return false
+      try {
+        const facts = JSON.parse(source.sections[0]!.text.slice(source.sections[0]!.text.indexOf('\n') + 1)).facts
+        return facts.taskId === binding.taskId && facts.role === role
+      } catch { return false }
+    })
+    const event = message && agent.session.append('user/message', message, priorSnapshot !== undefined
+      ? { surfaceOp: { op: 'replace', startSeq: priorSnapshot, endSeq: priorSnapshot }, sourceEventSeqs: [priorSnapshot] }
+      : { surfaceOp: 'append' })
+    this.store.writeDocument(id, row.revision, { ...checkpoint, state: 'committed', compactionId,
+      restoredEventSeq: event?.seq ?? null, reusedExistingSnapshot: message === undefined,
+      replacedSnapshotSeq: priorSnapshot ?? null,
+      restoredProjection: this.store.readDocument(this.#latest(binding, role))!.value })
+  }
+
+  /**
+   * Compact snapshots rely on native history for briefs, reports and user text.
+   * Any compaction, including one the Host or the user started, may summarize
+   * those away, so the first snapshot after it (and a task's first) is full.
+   */
+  #detailFor(agent: Agent, binding: SessionBinding, role: Role): ContextDetail {
+    let lastFull = -1, lastCompaction = -1
+    for (const event of agent.session.snapshotEvents()) {
+      if (event.type === 'compaction/end') lastCompaction = event.seq
+      if (event.type !== 'user/message' || !isFusionSourceKind(event.data.source?.kind)
+        || event.data.source.form !== 'snapshot') continue
+      for (const section of event.data.source.sections) {
+        if (section.name !== FUSION_TASK_CONTEXT) continue
+        try {
+          const facts = JSON.parse(section.text.slice(section.text.indexOf('\n') + 1)).facts
+          if (facts.taskId === binding.taskId && facts.role === role && facts.detail !== 'compact') lastFull = event.seq
+        } catch { /* foreign or legacy text: not a full snapshot for this task */ }
+      }
+    }
+    return lastFull < 0 || lastCompaction > lastFull ? 'full' : 'compact'
+  }
+
+  #latest(binding: SessionBinding, role: Role): string { return `task-context:${binding.taskId}:${role}` }
+  #message(text: string): UserMessage {
+    return createUserMessage({ content: [{ type: 'text', text }],
+      source: { kind: FUSION_SOURCE_KIND, form: 'snapshot', sections: [{ name: FUSION_TASK_CONTEXT, text }] } })
+  }
+  #text(facts: unknown, digest: string, artifact: ArtifactRef): string {
+    return `${INTRO}\n${JSON.stringify({ facts, digest, sourceArtifact: artifact })}`
+  }
+}

package/src/host/native-usage.ts

@@ -0,0 +1,121 @@
+import { usageSummary } from './history.js'
+import { randomUUID } from 'node:crypto'
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { StreamChunk, TokenUsage } from '@deepseek-ai/dsh-llm'
+import type { Role, TaskId } from '../contracts.js'
+import { digestOf } from '../digest.js'
+import { ingestDurable, known, newLedger, unknown } from '../usage/ledger.js'
+import type { CanonicalBill, UsageLedgerV2 } from '../usage/ledger.js'
+import type { SqliteFusionStore } from '../task/sqlite-store.js'
+import { nativeRequestAgent } from './native-request.js'
+import type { NativeAuxiliaryRequests } from './native-auxiliary.js'
+
+export interface UsageOwner { readonly taskId: TaskId; readonly role: Role }
+
+/**
+ * DSH counters are disjoint; missing provider fields retain unknown applicability.
+ *
+ * A counter is known only when the provider reported a real finite number.
+ * Gateways that omit completion_tokens_details send reasoningTokens as null
+ * (seen on some claude-opus-5.5 routes). known(null) throws INVALID_TOKEN_COUNT
+ * inside the llm/stream hook and aborts the turn, so null and NaN stay unknown.
+ */
+export function billFromNativeUsage(usage: TokenUsage | undefined): CanonicalBill {
+  const count = (value: number | undefined | null) =>
+    value === undefined || value === null || !Number.isFinite(value) ? unknown() : known(value)
+  const reasoningTokens = count(usage?.reasoningTokens)
+  return {
+    uncachedInput: count(usage?.inputTokens), cacheRead: count(usage?.cacheReadTokens), output: count(usage?.outputTokens),
+    cacheWrite: usage?.cacheWriteTokens === undefined || usage.cacheWriteTokens === null
+      || !Number.isFinite(usage.cacheWriteTokens) ? { kind: 'unknown' }
+      : { kind: 'aggregate', rateKey: 'provider-cache-write-rate-unknown', tokens: known(usage.cacheWriteTokens) },
+    reasoning: reasoningTokens.state === 'known'
+      ? { kind: 'separate', tokens: reasoningTokens }
+      : { kind: 'unknown', tokens: unknown() },
+  }
+}
+
+export interface NativeUsageRecord {
+  schemaVersion: 1
+  taskId: TaskId
+  sessionId: string
+  role: Role
+  purpose: 'conversation' | 'compaction' | 'session-title' | 'cache-keepalive'
+  /** Effective request envelope; Host compaction markers can retain their pre-routing cap. */
+  maxOutputTokens: number | null
+  reasoningEffort?: string
+  auxiliary?: { seriesId: string; iteration: number }
+  nativeInvocationId: string
+  startedAt: string
+  endedAt: string | null
+  /** Entering a Host stream is observable; the adapter's HTTP retry count is not. */
+  nativeStreamInvocations: 1
+  upstreamHttpCalls: null
+  outcome: 'entered' | 'stop' | 'tool-calls' | 'max-tokens' | 'aborted' | 'error' | 'unknown'
+  ledger: UsageLedgerV2
+  actualSubscriptionChargeUsd: null
+  apiEquivalentCostUsd: null
+}
+
+/** Read-only stream observer. It neither changes requests nor orchestrates agents. */
+export function observeNativeUsage(
+  ctx: Context, store: SqliteFusionStore, ownerOf: (agent: Agent) => UsageOwner | undefined,
+  auxiliary?: NativeAuxiliaryRequests,
+): () => void {
+  return ctx.on('llm/stream', async function* (options, next): AsyncIterable<StreamChunk> {
+    const agent = nativeRequestAgent(ctx, options)
+    const owner = agent && ownerOf(agent)
+    if (!owner || !agent) { yield* next(); return }
+    const extra = auxiliary?.get(options)
+    const id = `native:${randomUUID()}`
+    const key = { provider: options.provider, model: options.model, requestId: id, attemptId: id,
+      contractDigest: digestOf({ host: '0.1.5-rc.2', input: 'disjoint', reasoning: 'unknown', missing: 'unknown' }) }
+    let ledger = newLedger(key)
+    let revision = 0, summaryRevision = 0
+    let sequence = 0
+    let lastUsage: TokenUsage | undefined
+    const record: NativeUsageRecord = {
+      schemaVersion: 1, taskId: owner.taskId, sessionId: agent.id, role: owner.role, purpose: extra?.purpose ?? options.purpose ?? 'conversation', nativeInvocationId: id,
+      maxOutputTokens: options.maxTokens ?? null,
+      ...(options.reasoningEffort === undefined ? {} : { reasoningEffort: options.reasoningEffort }),
+      ...(extra ? { auxiliary: { seriesId: extra.seriesId, iteration: extra.iteration } } : {}),
+      startedAt: new Date().toISOString(), endedAt: null, nativeStreamInvocations: 1, upstreamHttpCalls: null,
+      outcome: 'entered', ledger, actualSubscriptionChargeUsd: null, apiEquivalentCostUsd: null,
+    }
+    const persist = () => {
+      const value = { ...record, ledger }
+      ;[revision, summaryRevision] = store.writeDocuments([
+        { id: `usage:${owner.taskId}:${id}`, expectedRevision: revision, value },
+        { id: `usage-index:${owner.taskId}:${id}`, expectedRevision: summaryRevision, value: usageSummary(value) },
+      ]) as [number, number]
+    }
+    persist()
+    try {
+      for await (const chunk of next()) {
+        if (chunk.type === 'usage') {
+          lastUsage = chunk.usage
+          ledger = ingestDurable(ledger, { id: `${id}:${++sequence}`, key, sequence, mode: 'snapshot', bill: billFromNativeUsage(lastUsage) })
+          persist()
+        }
+        if (chunk.type === 'finish') {
+          const kind = chunk.reason.kind
+          record.outcome = ['stop', 'tool-calls', 'max-tokens', 'aborted', 'error'].includes(kind)
+            ? kind as NativeUsageRecord['outcome'] : 'unknown'
+          record.endedAt = new Date().toISOString()
+          if (['stop', 'tool-calls', 'max-tokens'].includes(kind) && lastUsage) {
+            ledger = ingestDurable(ledger, { id: `${id}:final`, key, sequence: ++sequence, mode: 'final', bill: billFromNativeUsage(lastUsage) })
+          }
+          persist()
+        }
+        yield chunk
+      }
+    } finally {
+      if (record.endedAt === null) {
+        record.outcome = options.signal?.aborted ? 'aborted' : 'unknown'
+        record.endedAt = new Date().toISOString()
+        persist()
+      }
+    }
+  })
+}

package/src/host/native-worker-brief.ts

@@ -0,0 +1,122 @@
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { ToolExecution } from '@deepseek-ai/dsh-tools'
+import { isAgentLoopRequest } from '@deepseek-ai/dsh-llm'
+import type { GenerateOptions } from '@deepseek-ai/dsh-llm'
+import type { TaskId } from '../contracts.js'
+import { digestOf } from '../digest.js'
+import type { SqliteFusionStore } from '../task/sqlite-store.js'
+import { recentHandoffSuffix } from '../context/handoff.js'
+import { isFusionSourceKind } from '../message-source.js'
+
+/** Durable Lead-authored refinements survive native compaction and request races. */
+export function workerBriefs(store: SqliteFusionStore, taskId: TaskId) {
+  const revision = (store.readDocument(`runtime:${taskId}`)?.value as { briefRevision?: number } | undefined)?.briefRevision ?? 0
+  if (!Number.isSafeInteger(revision) || revision < 0) throw new Error('Worker brief revision requires reconciliation')
+  const rows = store.listDocumentIds(`worker-delivery:${taskId}:`).flatMap(id => {
+    const row = store.readDocument(id)!.value as { schemaVersion: number; taskId: string; workOrderId?: string; briefRevision: number; payloadRef: string; causeId: string; state: string }
+    if (row.workOrderId && row.workOrderId !== store.load(taskId)?.currentWorkOrder?.id) return []
+    if (row.state === 'not-applied-after-interruption') return []
+    if (row.briefRevision > revision) return [] // prepared before the runtime committed it
+    if (row.schemaVersion !== 1 || row.taskId !== taskId || !Number.isSafeInteger(row.briefRevision)
+      || row.briefRevision < 1 || !row.payloadRef || !row.causeId) throw new Error('Worker brief journal requires reconciliation')
+    return [{ revision: row.briefRevision, deliveryId: id, source: 'lead-tool-feedback' as const, nativeCallId: row.causeId, payloadRef: row.payloadRef,
+      feedback: Buffer.from(store.readArtifact(taskId, row.payloadRef)).toString('utf8') }]
+  }).sort((left, right) => left.revision - right.revision)
+  if (rows.length !== revision || rows.some((row, index) => row.revision !== index + 1)) throw new Error('Worker brief history is missing or conflicting')
+  return rows
+}
+
+/**
+ * Pin a bounded projection, including the first handoff, on both native roles.
+ * The complete owned outbox, journal and artifact bytes remain durable. Original
+ * user input and the frozen work order are retained separately by NativeTaskContext.
+ */
+export function workerHandoffProjection(store: SqliteFusionStore, taskId: TaskId) {
+  const state = store.load(taskId)
+  if (!state) throw new Error('Worker handoff task is missing')
+  const records: { revision: number; source: 'lead-tool-handoff' | 'lead-tool-feedback';
+    sourceId: string; payloadRef: string; content: string }[] = []
+  const order = state.currentWorkOrder
+  if (order) {
+    const rows = store.outbox(taskId).filter(row => row.kind === 'native-worker' && row.operationId === order.operationId)
+    const row = rows[0], childId = state.acceptedChild ?? state.reservedChild
+    if (rows.length !== 1 || !row || row.taskId !== taskId || !childId || row.reservedChild !== childId || !row.payloadRef) {
+      throw new Error('Initial Worker handoff requires reconciliation')
+    }
+    records.push({ revision: 0, source: 'lead-tool-handoff', sourceId: row.operationId,
+      payloadRef: row.payloadRef, content: Buffer.from(store.readArtifact(taskId, row.payloadRef)).toString('utf8') })
+  }
+  const briefs = workerBriefs(store, taskId)
+  for (const brief of briefs) records.push({ revision: brief.revision, source: brief.source,
+    sourceId: brief.deliveryId, payloadRef: brief.payloadRef, content: brief.feedback })
+  return { schemaVersion: 1 as const, ...recentHandoffSuffix(records),
+    latestBriefRevision: briefs.at(-1)?.revision ?? 0, historyDigest: digestOf(records) }
+}
+
+/** Brief bodies already arrive as native messages; the snapshot pins only their identity and digests. */
+export function compactHandoffs(projection: ReturnType<typeof workerHandoffProjection>) {
+  const { records, ...rest } = projection
+  return { ...rest, records: records.map(({ content, ...record }) => ({ ...record, contentDigest: digestOf(content) })) }
+}
+
+export function assertWorkerBriefRequest(store: SqliteFusionStore, taskId: TaskId, request: GenerateOptions): void {
+  if (!isAgentLoopRequest(request) || request.purpose !== undefined) return
+  const expected = workerHandoffProjection(store, taskId)
+  if (!expected.totalRecords) return
+  const present = request.messages.some(message => isFusionSourceKind(message.source?.kind) && message.source.form === 'snapshot'
+    && message.source.sections.some(section => {
+      if (section.name !== 'fusion:task') return false
+      try {
+        const seen = digestOf(JSON.parse(section.text.slice(section.text.indexOf('\n') + 1)).facts.workerHandoffs)
+        return seen === digestOf(expected) || seen === digestOf(compactHandoffs(expected))
+      } catch { return false }
+    }))
+  if (!present) throw new Error('Worker request predates the latest Lead brief; do not dispatch a stale generation')
+}
+
+/** Bind model-generated tools to the brief that their exact native request saw. */
+export function captureWorkerBrief(store: SqliteFusionStore, taskId: TaskId, agent: Agent, turn: number, step: number, revision: number): void {
+  const id = `worker-request:${agent.id}:${turn}:${step}`
+  const value = { schemaVersion: 1, taskId, sessionId: agent.id, turn, step, briefRevision: revision,
+    workOrderId: store.load(taskId)?.currentWorkOrder?.id }
+  const prior = store.readDocument(id)
+  if (prior) {
+    if (digestOf(prior.value) !== digestOf(value)) throw new Error('Worker request was already bound to another brief')
+    return
+  }
+  store.writeDocument(id, 0, value)
+}
+
+/**
+ * Bind one non-read Worker tool to the brief its own request saw.
+ *
+ * A native call is identified by `rootCallId`, which is the id of the block the
+ * assistant message emitted. A bridge route (Antigravity's `agy`) instead runs
+ * the call inside its OWN loop and reports the step through its transport, so
+ * the bridged dispatch carries a bridge-local call id that never appears in this
+ * session (`agy-mcp-N`). Refusing it as "no native request" refused the one tool
+ * a bridge Worker exists to call — `fusion_submit_result` — and stranded the
+ * task (session-1d65b1d0). Such a call is still owned by a native request: it
+ * is dispatched synchronously while the transport call runs, so the enclosing
+ * assistant message is the one that emitted the transport. `transport` carries
+ * that name only for a role whose route really is a bridge.
+ */
+export function workerToolBriefProblem(store: SqliteFusionStore, taskId: TaskId, exec: ToolExecution, revision: number,
+  transport?: string): string | undefined {
+  const events = exec.agent?.session.snapshotEvents()
+  const native = events?.findLast(event => event.type === 'assistant/message'
+    && event.data.message.content.some(block => block.type === 'tool-call' && block.id === exec.rootCallId))
+  const message = native ?? (transport === undefined ? undefined
+    : events?.findLast(event => event.type === 'assistant/message'
+      && event.data.message.content.some(block => block.type === 'tool-call' && block.name === transport)))
+  if (!message || message.type !== 'assistant/message' || message.data.interrupted) return 'Worker tool requires a complete native model request'
+  const row = store.readDocument(`worker-request:${exec.agent!.id}:${message.data.turn}:${message.data.step}`)?.value as {
+    schemaVersion?: number; taskId?: string; sessionId?: string; turn?: number; step?: number; briefRevision?: number; workOrderId?: string
+  } | undefined
+  if (row?.schemaVersion !== 1 || row.taskId !== taskId || row.sessionId !== exec.agent!.id
+    || row.turn !== message.data.turn || row.step !== message.data.step) return 'Worker tool has no captured brief identity'
+  if (row.briefRevision !== revision) return 'A newer Lead brief superseded this request; process it before further tools or a report'
+  const order = store.load(taskId)?.currentWorkOrder
+  if (row.workOrderId !== order?.id && (row.workOrderId || order?.mode)) return 'A newer work order superseded this request; process its plan before further tools'
+  return undefined
+}

package/src/host/native-worker-notices.ts

@@ -0,0 +1,72 @@
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
+import type { UserMessage } from '@deepseek-ai/dsh-llm'
+import type {} from '@deepseek-ai/dsh-subagent'
+import type { ArtifactRef, TaskId } from '../contracts.js'
+import { digestOf } from '../digest.js'
+import type { SqliteFusionStore } from '../task/sqlite-store.js'
+import type { SessionBinding } from './bindings.js'
+import { workerSettlementGuidance } from './worker-terminal.js'
+import { FUSION_SOURCE_KIND } from '../message-source.js'
+
+interface NoticeProjection {
+  schemaVersion: 1
+  taskId: TaskId
+  parentId: string
+  childId: string
+  originalMessageId: string
+  originalDigest: string
+  artifact: ArtifactRef
+  message: UserMessage
+}
+
+/** Reduce only our Worker's runtime closing notice, never its structured report. */
+export class NativeWorkerNotices {
+  constructor(readonly store: SqliteFusionStore) {}
+
+  project(agent: Agent, binding: SessionBinding, original: UserMessage): UserMessage {
+    const source = original.source
+    if (agent.id !== binding.sessionId || source?.kind !== 'subagent-settled') return original
+    const child = this.store.readDocument(`child:${source.senderSessionId}`)?.value as { parent?: string; taskId?: TaskId } | undefined
+    const task = child?.taskId && this.store.load(child.taskId)
+    if (child?.parent !== agent.id || !task || task.parent !== String(agent.id)
+      || (task.acceptedChild !== String(source.senderSessionId) && task.reservedChild !== String(source.senderSessionId))) return original
+
+    const originalDigest = digestOf(original)
+    const id = `worker-notice:${binding.taskId}:${digestOf({ parent: agent.id, message: original.id })}`
+    const saved = this.store.readDocument(id)?.value as NoticeProjection | undefined
+    if (saved) {
+      if (saved.schemaVersion !== 1 || saved.taskId !== binding.taskId || saved.parentId !== agent.id
+        || saved.childId !== source.senderSessionId || saved.originalDigest !== originalDigest) {
+        throw new Error('Fusion Worker notice identity requires reconciliation')
+      }
+      this.store.readArtifact(binding.taskId, saved.artifact.id)
+      return saved.message
+    }
+    // Keep the entire original, including failure detail and closing blocks,
+    // available through owned evidence. This projection claims no task success.
+    const artifact = this.store.putArtifact(binding.taskId, Buffer.from(JSON.stringify(original)), 'application/vnd.dsh-fusion.worker-notice+json')
+    const submitted = Boolean((this.store.readDocument(`runtime:${binding.taskId}`)?.value as { submitted?: unknown } | undefined)?.submitted)
+    const message = createUserMessage({ source: { kind: FUSION_SOURCE_KIND, form: 'notice', summary: source.summary },
+      content: [{ type: 'text', text: `${source.summary}\n${workerSettlementGuidance(submitted)} Closing transcript is archived rather than repeated here. For missing failure details use fusion_read_evidence with id ${artifact.id}.\n${JSON.stringify({ childId: source.senderSessionId, originalMessageId: original.id, artifact })}` }] })
+    this.store.writeDocument(id, 0, { schemaVersion: 1, taskId: binding.taskId, parentId: agent.id,
+      childId: source.senderSessionId, originalMessageId: original.id, originalDigest, artifact, message } satisfies NoticeProjection)
+    return message
+  }
+
+  /** Replace retained legacy notices before the native compactor reads history.
+   * Public surface replacement preserves the original append-only event and
+   * cites it. Already compacted prose cannot be safely reverse-transformed.
+   */
+  projectHistory(agent: Agent, binding: SessionBinding): void {
+    for (const seq of [...agent.session.surface.nodes]) {
+      const event = agent.session.eventAt(seq)
+      if (event?.type !== 'user/message') continue
+      const message = this.project(agent, binding, event.data)
+      if (message === event.data) continue
+      agent.session.append('user/message', message, {
+        surfaceOp: { op: 'replace', startSeq: seq, endSeq: seq }, sourceEventSeqs: [seq],
+      })
+    }
+  }
+}