@linxin666/dsh-client-ui-task-board 0.4.4 → 0.4.5

package/src/host/workspace-evidence.ts

@@ -0,0 +1,176 @@
+/**
+ * Host-observed workspace changes, as acceptance evidence.
+ *
+ * The judge must not take the agent's word for what changed on disk: a patch
+ * that was never applied, or a file edited again afterwards, looks identical to
+ * a real edit when only the tool-call arguments are read. The DSH host records
+ * what a turn actually changed and serves it through the optional
+ * @@workspaceChanges@@ service, so that observation is offered next to the
+ * trajectory instead of being trusted from the transcript.
+ *
+ * The service is described STRUCTURALLY and resolved optionally: a deployment
+ * that serves none (or a cohort whose shape differs) degrades to "no extra
+ * evidence" and never breaks an acceptance that has already spent judge budget.
+ */
+import { createHash } from 'node:crypto'
+
+/** The subset of the host change service this module drives. */
+export interface WorkspaceChangeSource {
+  summary(sessionId: string, seq: number): unknown
+  diff(sessionId: string, seq: number, index: number, signal: AbortSignal): Promise<unknown>
+}
+
+/** One session event, as the host log carries it. */
+interface RawEvent {
+  type?: unknown
+  seq?: unknown
+}
+
+/** How many changed files one evidence block renders. */
+export const MAX_WORKSPACE_FILES = 8
+/** Character ceiling for the whole rendered block. */
+export const WORKSPACE_EVIDENCE_MAX_CHARS = 24_000
+/** Character ceiling for one file's rendered comparison. */
+export const WORKSPACE_EVIDENCE_MAX_FILE_CHARS = 6_000
+
+/**
+ * Resolve the optional host change service from a context-like object.
+ * @param ctx - anything exposing @@get(name)@@.
+ * @returns the service, or undefined when this deployment serves none.
+ */
+export function probeWorkspaceChanges(ctx: { get(name: string): unknown }): WorkspaceChangeSource | undefined {
+  let service: unknown
+  try {
+    service = ctx.get('workspaceChanges')
+  } catch {
+    return undefined
+  }
+  if (typeof service !== 'object' || service === null) return undefined
+  const candidate = service as { summary?: unknown; diff?: unknown }
+  if (typeof candidate.summary !== 'function' || typeof candidate.diff !== 'function') return undefined
+  return service as WorkspaceChangeSource
+}
+
+/** Read a finite number, else 0. */
+function count(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0
+}
+
+/** Read a string, else ''. */
+function text(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+/** Bound one text to a character budget, keeping the head. */
+function bound(value: string, maxChars: number): string {
+  if (value.length <= maxChars) return value
+  const notice = '\n[Truncated ' + (value.length - maxChars) + ' characters]'
+  if (notice.length >= maxChars) return value.slice(0, maxChars)
+  return value.slice(0, maxChars - notice.length) + notice
+}
+
+/** The sequence of the newest change event inside the reviewed window. */
+export function latestChangeEvent(events: readonly RawEvent[]): { seq: number; turn?: number } | undefined {
+  let latest: { seq: number; turn?: number } | undefined
+  for (const event of events) {
+    if (event.type !== 'workspace/changes') continue
+    if (typeof event.seq !== 'number') continue
+    if (latest === undefined || event.seq >= latest.seq) latest = { seq: event.seq }
+  }
+  return latest
+}
+
+/** Render one file's comparison from whatever shape the service answered. */
+function renderDiff(value: unknown, maxChars: number): string {
+  if (typeof value !== 'object' || value === null) return '[no comparison available]'
+  const diff = value as Record<string, unknown>
+  if (diff.binary === true || text(diff.kind) === 'binary') return '[binary file]'
+  if (diff.oversized === true) return '[file too large to compare]'
+  const patch = text(diff.patch)
+  if (patch !== '') return bound(patch, maxChars)
+  const hunks = Array.isArray(diff.hunks) ? diff.hunks : []
+  const lines: string[] = []
+  for (const entry of hunks) {
+    if (typeof entry !== 'object' || entry === null) continue
+    const hunk = entry as Record<string, unknown>
+    lines.push('@@ -' + count(hunk.oldStart) + ',' + count(hunk.oldLines) + ' +' + count(hunk.newStart) + ',' + count(hunk.newLines) + ' @@')
+    const body = Array.isArray(hunk.lines) ? hunk.lines : []
+    for (const line of body) {
+      if (typeof line === 'string') lines.push(line)
+      else if (typeof line === 'object' && line !== null) {
+        const row = line as Record<string, unknown>
+        const marker = text(row.kind) === 'add' ? '+' : text(row.kind) === 'delete' ? '-' : ' '
+        lines.push(marker + text(row.text))
+      }
+    }
+  }
+  return lines.length === 0 ? '' : bound(lines.join('\n'), maxChars)
+}
+
+/**
+ * Render the host's own record of what the reviewed window changed.
+ *
+ * Bounded twice — at most {@link MAX_WORKSPACE_FILES} files, and a shared
+ * character budget split across them — so one enormous generated file cannot
+ * crowd out every other change. Every failure degrades to less evidence (or an
+ * empty block) instead of an error, because the acceptance being prepared must
+ * still reach a verdict.
+ * @param events - session events already bounded to the execution's window.
+ * @param sessionId - the session whose changes these are.
+ * @param source - the probed host service.
+ * @param options - budget, cancellation and the diagnostic sink.
+ * @returns the rendered block plus how many files it shows.
+ */
+export async function renderWorkspaceEvidence(
+  events: readonly RawEvent[],
+  sessionId: string,
+  source: WorkspaceChangeSource,
+  options: { signal: AbortSignal; warn?: (message: string) => void; maxChars?: number },
+): Promise<{ text: string; files: number; hash: string }> {
+  const warn = options.warn ?? ((): void => {})
+  const maxChars = options.maxChars ?? WORKSPACE_EVIDENCE_MAX_CHARS
+  try {
+    const event = latestChangeEvent(events)
+    if (event === undefined) return { text: '', files: 0, hash: '' }
+    const summary = source.summary(sessionId, event.seq)
+    if (typeof summary !== 'object' || summary === null) return { text: '', files: 0, hash: '' }
+    const view = summary as Record<string, unknown>
+    const listed = (Array.isArray(view.files) ? view.files : [])
+      .map((file, index) => ({ file, index }))
+      .filter((entry): entry is { file: Record<string, unknown>, index: number } => typeof entry.file === 'object' && entry.file !== null)
+    if (listed.length === 0) return { text: '', files: 0, hash: '' }
+    const shown = listed.slice(0, MAX_WORKSPACE_FILES)
+    const added = count(view.added)
+    const deleted = count(view.deleted)
+    const header = 'Host-recorded workspace changes'
+      + (typeof view.turn === 'number' ? ' for turn ' + view.turn : '')
+      + ': ' + listed.length + ' changed file(s)'
+      + (added > 0 || deleted > 0 ? ' (+' + added + '/-' + deleted + ' lines)' : '')
+      + (listed.length > shown.length ? '; showing the first ' + shown.length : '')
+      + '.\nObserved by the DSH host from the workspace itself, not reported by the agent.'
+    const perFile = Math.max(1, Math.min(WORKSPACE_EVIDENCE_MAX_FILE_CHARS, Math.floor((maxChars - header.length) / shown.length) - 40))
+    const sections: string[] = []
+    for (const entry of shown) {
+      const path = text(entry.file.path) !== '' ? text(entry.file.path) : text(entry.file.display) !== '' ? text(entry.file.display) : 'file'
+      const fileAdded = count(entry.file.added)
+      const fileDeleted = count(entry.file.deleted)
+      let comparison = ''
+      try {
+        comparison = renderDiff(await source.diff(sessionId, event.seq, entry.index, options.signal), perFile)
+      } catch (error) {
+        comparison = '[comparison unavailable]'
+        warn('task-board workspace evidence unavailable for one file: ' + (error instanceof Error ? error.message : String(error)))
+      }
+      sections.push('- ' + path + (fileAdded > 0 || fileDeleted > 0 ? ' (+' + fileAdded + '/-' + fileDeleted + ')' : '') + '\n' + comparison)
+    }
+    const rendered = bound([header, ...sections].join('\n'), maxChars)
+    return {
+      text: rendered,
+      files: shown.length,
+      hash: createHash('sha256').update(rendered).digest('hex'),
+    }
+  } catch (error) {
+    warn('task-board workspace evidence unavailable: ' + (error instanceof Error ? error.message : String(error)))
+    return { text: '', files: 0, hash: '' }
+  }
+}

package/src/host-ai.ts

@@ -9,7 +9,8 @@
  * stripped, the first JSON object wins, and an unusable reply falls back to
  * the user's own words instead of an empty form.
  */
-import { createUserMessage, type GenerateOptions, type LlmRuntime } from '@deepseek-ai/dsh-llm'
+import { createUserMessage, type LlmRuntime } from '@deepseek-ai/dsh-llm'
+import { openOneShotStream } from './host/llm-dispatch.ts'
 import type { TaskBoardParseDraft, TaskBoardParseRequest } from './protocol.ts'
 
 /** How long one parse may take before the Host gives up on the model. */
@@ -127,15 +128,20 @@ export async function parseTaskDraft(
   const abortFromCaller = (): void => { timeout.abort() }
   signal?.addEventListener('abort', abortFromCaller, { once: true })
   try {
-    const options: GenerateOptions = {
-      provider: route.provider,
-      model: route.model,
-      system: SYSTEM_PROMPT,
-      messages: [createUserMessage({ content: [{ type: 'text', text }], source: { kind: 'user' } })],
-      signal: timeout.signal,
-    }
+    // Same registration-bound dispatch as the acceptance judge: the public
+    // `llm.stream()` is a mutable instance property a third-party provider
+    // plugin may replace with its `llm/stream` listener signature.
+    const stream = await openOneShotStream(
+      llm,
+      { provider: route.provider, model: route.model },
+      {
+        system: SYSTEM_PROMPT,
+        messages: [createUserMessage({ content: [{ type: 'text', text }], source: { kind: 'user' } })],
+        signal: timeout.signal,
+      },
+    )
     let reply = ''
-    for await (const chunk of llm.stream(options)) {
+    for await (const chunk of stream) {
       if (chunk.type === 'text-delta') reply += chunk.text
     }
     return draftFromReply(reply, text)

package/src/host-ledger.ts

@@ -5,7 +5,7 @@ import { dirname, join } from 'node:path'
 import { dshHome } from './dsh-home.ts'
 import { isValidCron, isValidTimeZone, nextRunAtMs, resolveHostTimeZone } from './core/schedule.ts'
 import { isTaskRecord, parseLedger } from './core/store.ts'
-import { canMoveManually, retainRecentExecutions, settleExecution, startExecution, withStatus, type ExecutionOutcome, type ExecutionRecord, type TaskRecord } from './core/tasks.ts'
+import { canMoveManually, hasOpenExecution, retainRecentExecutions, settleExecution, startExecution, withStatus, type ExecutionOutcome, type ExecutionRecord, type TaskRecord } from './core/tasks.ts'
 import {
   DEFAULT_SUBTASK_DEPTH,
   cascadeTargets,
@@ -20,9 +20,11 @@ import { applyCreateTask } from './core/use-cases/task-create.ts'
 import { applyDeleteTask } from './core/use-cases/task-delete.ts'
 import { applySetSchedule, applyScheduleNextRun } from './core/use-cases/task-schedule.ts'
 import { applySetParent } from './core/use-cases/task-parent.ts'
+import { applyDeleteTag, applyRenameTag } from './core/use-cases/task-tag.ts'
 import { applyUpdateTask, canEditTaskContent, hasContentPatch } from './core/use-cases/task-update.ts'
-import { TASK_BOARD_LEGACY_SCHEMA_VERSION, TASK_BOARD_OLDER_SCHEMA_VERSION, TASK_BOARD_SCHEMA_VERSION, type TaskBoardAction, type TaskBoardSchedulerSnapshot } from './protocol.ts'
-import { DEFAULT_SESSION_PERMISSION, requiresPermissionConfirmation, type TaskPermission } from './core/handover.ts'
+import { TASK_BOARD_MIGRATABLE_SCHEMA_VERSIONS, TASK_BOARD_SCHEMA_VERSION, type TaskBoardAction, type TaskBoardSchedulerSnapshot } from './protocol.ts'
+import type { ExecutionVerification } from './core/verification.ts'
+import { DEFAULT_SESSION_PERMISSION, effectivePermission, permissionCarriedBy, requiresPermissionConfirmation, type TaskPermission } from './core/handover.ts'
 
 interface PersistedScheduler extends TaskBoardSchedulerSnapshot {
   importedSources?: string[]
@@ -57,7 +59,7 @@ function bindingRefusalMessage(
   surface: 'run' | 'schedule',
 ): string {
   if (refusal.kind === 'subtask-pin') {
-    return `team run cannot honor the permission binding of subtask "${refusal.title}": a teammate runs inside the Lead session; clear that card's permission or run the tree without Agent Team`
+    return `team run cannot honor the permission binding of subtask "${refusal.title}": a teammate runs inside the Lead session and inherits its permission, which that pin exceeds; clear the card's permission or run the tree without Agent Team`
   }
   if (surface === 'schedule') return `task "${refusal.title}" has an unconfirmed above-default permission`
   if (refusal.kind === 'root') {
@@ -127,10 +129,6 @@ function cloneTasks(tasks: readonly TaskRecord[]): TaskRecord[] {
   return JSON.parse(JSON.stringify(tasks)) as TaskRecord[]
 }
 
-function hasOpenExecution(task: TaskRecord): boolean {
-  return task.executions.some(execution => execution.endedAt === undefined)
-}
-
 /**
  * Process states that are dead but still occupy the PID table: `Z` (zombie)
  * and `X` (dead, being reaped). `process.kill(pid, 0)` reports such PIDs as
@@ -341,7 +339,17 @@ function mergeTask(a: TaskRecord, b: TaskRecord): TaskRecord {
     const previous = byId.get(entry.id)
     byId.set(entry.id, previous === undefined ? entry : betterExecution(previous, entry))
   }
-  const executions = [...byId.values()].sort((x, y) => x.startedAt - y.startedAt)
+  // Acceptance evidence is the one field "betterExecution" cannot choose: a
+  // browser half that also wrote this execution carries no attempts, and taking
+  // its copy would erase the Host's verdict. The copy with the most recorded
+  // attempts wins, and one execution's verdict is never copied onto another.
+  const executions = [...byId.values()].sort((x, y) => x.startedAt - y.startedAt).map(entry => {
+    if (entry.verification !== undefined) return entry
+    const richer = [...a.executions, ...b.executions]
+      .filter(other => other.id === entry.id && other.verification !== undefined)
+      .sort((x, y) => (y.verification?.attempts.length ?? 0) - (x.verification?.attempts.length ?? 0))[0]
+    return richer?.verification === undefined ? entry : { ...entry, verification: richer.verification }
+  })
   return { ...newer, executions: retainRecentExecutions(executions) }
 }
 
@@ -416,8 +424,18 @@ export class HostTaskLedger {
   /** Small sidecar for the 30 s scheduler heartbeat (lastTickAt only). */
   readonly schedulerFile: string
 
-  /** Session-default permission the confirmation gate compares against. */
-  readonly sessionDefaultPermission: TaskPermission
+  /** Resolves the baseline the confirmation gate compares a binding against. */
+  private readonly sessionDefault: () => TaskPermission
+
+  /**
+   * Session-default permission the confirmation gate compares against. Read
+   * through the resolver on every use, so a baseline that follows the Host's
+   * own default preset tracks a Settings change made while the board runs.
+   */
+  get sessionDefaultPermission(): TaskPermission {
+    return this.sessionDefault()
+  }
+
   /**
    * Deployment subtask depth limit (1..3): the lineage gate every write obeys.
    * The settings card edits it live, so {@link setMaxSubtaskDepth} mutates it
@@ -425,8 +443,10 @@ export class HostTaskLedger {
    */
   private depthLimit: number
 
-  constructor(dir: string = join(dshHome(), 'task-board'), private readonly now: () => number = Date.now, options: { sessionDefaultPermission?: TaskPermission; maxSubtaskDepth?: number } = {}) {
-    this.sessionDefaultPermission = options.sessionDefaultPermission ?? DEFAULT_SESSION_PERMISSION
+  constructor(dir: string = join(dshHome(), 'task-board'), private readonly now: () => number = Date.now, options: { sessionDefaultPermission?: TaskPermission | (() => TaskPermission); maxSubtaskDepth?: number } = {}) {
+    // Resolved before the load/repair passes below: they can evaluate the gate.
+    const baseline = options.sessionDefaultPermission
+    this.sessionDefault = typeof baseline === 'function' ? baseline : () => baseline ?? DEFAULT_SESSION_PERMISSION
     this.depthLimit = normalizeSubtaskDepth(options.maxSubtaskDepth ?? DEFAULT_SUBTASK_DEPTH)
     mkdirSync(dir, { recursive: true })
     this.file = join(dir, 'ledger-v2.json')
@@ -644,7 +664,7 @@ export class HostTaskLedger {
       rollForward()
       return []
     }
-    if (task.status === 'running' || hasOpenExecution(task)) {
+    if (hasOpenExecution(task)) {
       rollForward()
       return []
     }
@@ -736,6 +756,24 @@ export class HostTaskLedger {
     this.commit()
   }
 
+  allTasks(): readonly TaskRecord[] {
+    return this.document.tasks
+  }
+
+  getTask(id: string): TaskRecord | undefined {
+    return this.document.tasks.find(item => item.id === id)
+  }
+
+  saveTaskRecord(task: TaskRecord): void {
+    const exists = this.document.tasks.some(item => item.id === task.id)
+    if (exists) {
+      this.document.tasks = this.document.tasks.map(item => item.id === task.id ? task : item)
+    } else {
+      this.document.tasks = [...this.document.tasks, task]
+    }
+    this.commit()
+  }
+
   private apply(action: TaskBoardAction, initiator?: string): { state: LedgerState; runs?: OpenedRun[] } {
     const now = this.now()
     let runs: OpenedRun[] | undefined
@@ -801,7 +839,7 @@ export class HostTaskLedger {
       case 'delete': {
         const task = this.document.tasks.find(task => task.id === action.taskId)
         if (task === undefined) throw new Error('task not found')
-        if (task.status === 'running' || hasOpenExecution(task)) throw new Error('running task cannot be deleted')
+        if (hasOpenExecution(task)) throw new Error('running task cannot be deleted')
         // Subtasks keep their link: deleting the parent would leave dangling
         // children, so the user detaches or deletes them explicitly first.
         if (this.document.tasks.some(item => item.parentId === action.taskId)) {
@@ -820,7 +858,10 @@ export class HostTaskLedger {
         const task = this.document.tasks.find(item => item.id === action.taskId)
         if (task === undefined) throw new Error('task not found')
         if (task.archivedAt !== undefined) throw new Error('archived task is read-only')
-        if (task.status === 'running' || hasOpenExecution(task)) throw new Error('running task cannot be moved')
+        // The lock belongs to an open execution, not to the column: a card
+        // parked in 'running' by hand has no session and stays movable, while
+        // a card the runner is executing cannot be moved out from under it.
+        if (hasOpenExecution(task)) throw new Error('running task cannot be moved')
         if (!canMoveManually(task.status, action.status)) throw new Error('invalid manual status')
         this.document.tasks = this.document.tasks.map(item => item.id === action.taskId ? withStatus(item, action.status, now) : item)
         break
@@ -876,6 +917,18 @@ export class HostTaskLedger {
           : item)
         break
       }
+      case 'rename-tag': {
+        const result = applyRenameTag(this.document.tasks, action.from, action.to, now)
+        if (result.error !== undefined) throw new Error(result.error)
+        if (result.changed) this.document.tasks = [...result.tasks]
+        break
+      }
+      case 'delete-tag': {
+        const result = applyDeleteTag(this.document.tasks, action.name, now)
+        if (result.error !== undefined) throw new Error(result.error)
+        if (result.changed) this.document.tasks = [...result.tasks]
+        break
+      }
       case 'set-schedule': {
         const task = this.document.tasks.find(task => task.id === action.taskId)
         if (task?.archivedAt !== undefined) throw new Error('archived task is read-only')
@@ -888,7 +941,7 @@ export class HostTaskLedger {
       case 'run': {
         const task = this.document.tasks.find(item => item.id === action.taskId)
         if (task?.archivedAt !== undefined) throw new Error('archived task is read-only')
-        if (task === undefined || task.status === 'running' || hasOpenExecution(task)) throw new Error('task is already running or missing')
+        if (task === undefined || hasOpenExecution(task)) throw new Error('task is already running or missing')
         // The confirmation gate judges the RESOLVED binding: a subtask that
         // inherits an elevated permission from its parent is exactly as
         // unconfirmed as the parent would be without its own stamp.
@@ -909,10 +962,12 @@ export class HostTaskLedger {
    *
    * A plain cascade launches one session per participant, so every participant
    * carries its own resolved binding and each one gates the run. A team run
-   * launches only the Lead session: the Lead's binding gates it, while a
-   * subtask's OWN above-default pin cannot be applied to a teammate and is
-   * refused instead of being silently dropped (an inherited binding is the
-   * Lead's own and stays allowed once the Lead is confirmed).
+   * launches only the Lead session: the Lead's binding gates it, and a
+   * teammate inherits that session's permission, so a subtask's OWN pin is
+   * refused exactly when the Lead session does not already carry it — the
+   * teammate could never be given that authority, and dropping the pin
+   * silently would misreport the work (an inherited binding is the Lead's own
+   * and stays allowed once the Lead is confirmed).
    * @param root - the task being run.
    * @returns the first refusal, or undefined when the run may start.
    */
@@ -923,12 +978,17 @@ export class HostTaskLedger {
       if (lead !== undefined && requiresPermissionConfirmation(lead, this.sessionDefaultPermission)) {
         return { kind: 'root', title: lead.title }
       }
-      // The raw record carries the subtask's OWN binding: the resolved
-      // participant above already folded the inherited one into its permission.
+      // The Lead session runs at the Lead's own binding, or at the deployment
+      // default when it pins none; a teammate inherits that permission and
+      // cannot be narrowed below it, so it carries a subtask pin when it is
+      // already at least as wide. The raw record carries the subtask's OWN
+      // binding: the resolved participant above already folded an inherited one
+      // into its permission.
+      const leadPermission = effectivePermission(lead ?? root) ?? this.sessionDefaultPermission
       const pinned = participants.find(participant => {
         if (participant.id === root.id) return false
         const raw = this.document.tasks.find(task => task.id === participant.id)
-        return raw !== undefined && requiresPermissionConfirmation(raw, this.sessionDefaultPermission)
+        return raw !== undefined && !permissionCarriedBy(leadPermission, effectivePermission(raw))
       })
       return pinned === undefined ? undefined : { kind: 'subtask-pin', title: pinned.title }
     }
@@ -947,14 +1007,13 @@ export class HostTaskLedger {
     return cascadeTargets(this.document.tasks, rootId, this.maxSubtaskDepth)
       .map(participant => resolveExecutionTargets(participant, this.document.tasks, this.maxSubtaskDepth))
       .filter(participant => participant.archivedAt === undefined
-        && participant.status !== 'running'
         && !hasOpenExecution(participant))
   }
 
   /** Whether a task or any of its subtasks still has an open execution. */
   private subtreeHasOpenExecution(id: string): boolean {
     return cascadeTargets(this.document.tasks, id, this.maxSubtaskDepth)
-      .some(task => task.status === 'running' || hasOpenExecution(task))
+      .some(task => hasOpenExecution(task))
   }
 
   /**
@@ -979,7 +1038,7 @@ export class HostTaskLedger {
     const runs: OpenedRun[] = []
     for (const task of cascadeTargets(before, root.id, this.maxSubtaskDepth)) {
       if (task.archivedAt !== undefined) continue
-      if (task.status === 'running' || hasOpenExecution(task)) continue
+      if (hasOpenExecution(task)) continue
       const base = rerun && task.id === root.id ? withStatus(task, 'todo', now) : task
       const opened = startExecution(base, now, crypto.randomUUID(), initiator, groupId)
       started.set(task.id, opened.task)
@@ -1147,7 +1206,6 @@ export class HostTaskLedger {
     let changed = false
     const interrupted: Array<{ taskId: string; runGroupId: string | undefined }> = []
     this.document.tasks = this.document.tasks.map(task => {
-      if (task.status !== 'running') return task
       const execution = task.executions.at(-1)
       if (execution === undefined || execution.endedAt !== undefined || execution.sessionId !== undefined) return task
       changed = true
@@ -1166,7 +1224,7 @@ export class HostTaskLedger {
   }
 
   /**
-   * Field-preserving migration of a pre-v4 document. It first proves every task
+   * Field-preserving migration of an older document. It first proves every task
    * row is structurally valid, so a document that would silently drop or coerce
    * rows fails loudly instead (no quarantined-empty restart), and then reuses
    * the current normalization.
@@ -1177,6 +1235,11 @@ export class HostTaskLedger {
    * (the stored `nextRunAt` already encodes the old zone), but the rule stops
    * following a later `TZ` change, which is what made an existing schedule
    * silently move when the Host's zone changed.
+   *
+   * v5 adds the per-execution acceptance block. The migration deliberately does
+   * NOT stamp one: an execution opened before v5 keeps no contract, so it
+   * settles on its own historical verdict and no in-flight run is retroactively
+   * judged by a gate that was never armed for it.
    */
   private migrateLegacyDocument(parsed: ParsedLedgerDocument): LedgerDocument {
     if (!Array.isArray(parsed.tasks) || !parsed.tasks.every(row => isTaskRecord(row))) {
@@ -1194,6 +1257,54 @@ export class HostTaskLedger {
     return this.normalizeDocument({ ...parsed, tasks: rows as TaskRecord[] })
   }
 
+  /**
+   * Find the still-open execution that ran in one session, with its task.
+   *
+   * The completion gate keys on the session id its tool call arrives from: the
+   * execution record is the only object binding a session to a card, and an
+   * already-settled execution is deliberately not returned (a session the board
+   * no longer owns must not be gated).
+   * @param sessionId - the DSH session the tool call runs in.
+   * @returns the open execution and its task, or undefined.
+   */
+  findOpenExecutionBySession(sessionId: string): { task: TaskRecord; execution: ExecutionRecord } | undefined {
+    if (sessionId === '') return undefined
+    for (const task of this.document.tasks) {
+      for (const execution of task.executions) {
+        if (execution.endedAt !== undefined) continue
+        if (execution.sessionId === sessionId) return { task, execution }
+      }
+    }
+    return undefined
+  }
+
+  /**
+   * Replace one execution's acceptance block (creating it when absent).
+   *
+   * A no-op when the serialized value is unchanged, so a coarse caller that
+   * re-writes the same state never bumps the ledger revision. A settled
+   * execution keeps its record: the report of a finished cycle must survive,
+   * and only the board's own settlement moves the card.
+   * @param taskId - the task owning the execution.
+   * @param executionId - the execution to update.
+   * @param verification - the new block.
+   * @returns true when the ledger changed.
+   */
+  setVerification(taskId: string, executionId: string, verification: ExecutionVerification): boolean {
+    const now = this.now()
+    const task = this.document.tasks.find(item => item.id === taskId)
+    const execution = task?.executions.find(entry => entry.id === executionId)
+    if (task === undefined || execution === undefined) return false
+    if (JSON.stringify(execution.verification ?? null) === JSON.stringify(verification)) return false
+    this.document.tasks = this.document.tasks.map(item => item.id !== taskId ? item : {
+      ...item,
+      updatedAt: now,
+      executions: item.executions.map(entry => entry.id === executionId ? { ...entry, verification } : entry),
+    })
+    this.commit()
+    return true
+  }
+
   private load(dir: string): LedgerDocument {
     const existed = existsSync(this.file)
     // schemaVersion stays unknown-typed here: on-disk documents may be v2 or
@@ -1204,8 +1315,8 @@ export class HostTaskLedger {
     } catch (error) {
       return this.recoverCorrupt(dir, existed, error)
     }
-    if (parsed.schemaVersion === TASK_BOARD_LEGACY_SCHEMA_VERSION
-      || parsed.schemaVersion === TASK_BOARD_OLDER_SCHEMA_VERSION) {
+    if (typeof parsed.schemaVersion === 'number'
+      && TASK_BOARD_MIGRATABLE_SCHEMA_VERSIONS.includes(parsed.schemaVersion)) {
       try {
         return this.migrateLegacyDocument(parsed)
       } catch (error) {
@@ -1426,4 +1537,4 @@ export class HostTaskLedger {
     }
     throw new Error(`task-board ledger lock could not be acquired: ${this.lockFile}`)
   }
-}
+}

package/src/host-routes.ts

@@ -208,7 +208,7 @@ export function makeTaskBoardRoutes(
         if (parsed.action.kind !== 'import' && Buffer.byteLength(body.raw) > ACTION_LIMIT) {
           return writeJson(res, 413, { ok: false, error: 'body-too-large' }, { 'cache-control': 'no-store' })
         }
-        writeJson(res, 200, service.apply(parsed.requestId, parsed.action, parsed.initiator), { 'cache-control': 'no-store' })
+        writeJson(res, 200, await service.apply(parsed.requestId, parsed.action, parsed.initiator), { 'cache-control': 'no-store' })
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error)
         writeJson(res, message === 'body-too-large' ? 413 : 400, { ok: false, error: message }, { 'cache-control': 'no-store' })
@@ -289,5 +289,18 @@ export function makeTaskBoardRoutes(
       }
     },
   }
-  return [state, action, events, parse]
+  const verification: WebRoute = {
+    kind: 'exact',
+    path: `${TASK_BOARD_API_PREFIX}/verification`,
+    handler: async (req, res): Promise<void> => {
+      if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'method-not-allowed' }, { 'cache-control': 'no-store' })
+      if (!guard(req, res)) return
+      try {
+        writeJson(res, 200, await service.verificationOptions(), { 'cache-control': 'no-store' })
+      } catch (error) {
+        writeJson(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) }, { 'cache-control': 'no-store' })
+      }
+    },
+  }
+  return [state, action, events, parse, verification]
 }