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

package/src/host-runner.ts

@@ -3,9 +3,13 @@ import type { SessionAddress, SessionHistoryRecord, SessionListValue, SessionPag
 import type { CommandResult } from '@deepseek-ai/dsh-commands/types'
 import type { Workspace } from '@deepseek-ai/dsh-workspace/types'
 import { teammateName } from './core/subtask.ts'
+import { mostRecentWorkspaceId } from './core/workspace-target.ts'
 import type { TaskPermission, TaskRecord } from './core/tasks.ts'
 
-/** Host services needed to validate a task's workspace before creating a session. */
+/**
+ * Host services needed to validate a task's workspace before creating a
+ * session, and to resolve the workspace an unpinned card runs in.
+ */
 export interface TaskBoardWorkspaceRegistry {
   list(): readonly Workspace[]
 }
@@ -298,6 +302,8 @@ function nonCompletedTurnEnd(data: unknown): string | undefined {
  */
 function invokeWireArgs(namespace: string, method: string, request: Record<string, unknown>): Record<string, unknown> {
   if (namespace === 'agentPresets' && method === 'list') return {}
+  // session/modelCatalog declares zero parameters, so its args must be {}.
+  if (namespace === 'session' && method === 'modelCatalog') return {}
   if (namespace === 'session' && method === 'list') return { _request: request }
   return { request }
 }
@@ -328,6 +334,18 @@ export class HostExecutionRunner {
     return this.gateway.stream({ namespace, method, args: { request }, ...(signal === undefined ? {} : { signal }) })
   }
 
+  /**
+   * The workspace an unpinned run lands in: the deployment's most recently used
+   * one. Undefined when the deployment serves no workspace registry or has
+   * registered none yet; the launch then keeps the "let the Host decide" shape,
+   * which is the only remaining path to the Host's own working directory.
+   * @returns the workspace id to create the session in, when one is known.
+   */
+  private recentWorkspaceId(): string | undefined {
+    if (this.workspaceRegistry === undefined) return undefined
+    return mostRecentWorkspaceId(this.workspaceRegistry.list())
+  }
+
   /**
    * Launch one execution. Without `options.reuseSessionId` a fresh session is
    * created, renamed, pinned, and prompted (the historical contract). With it,
@@ -338,10 +356,14 @@ export class HostExecutionRunner {
    * @param options - optional session to continue in.
    * @returns the session id the execution runs in.
    */
-  async launch(task: TaskRecord, options: { reuseSessionId?: string; promptContext?: PromptContext } = {}): Promise<string> {
+  async launch(task: TaskRecord, options: { reuseSessionId?: string; promptContext?: PromptContext; onSession?: (sessionId: string) => void; onGoalArmed?: (armed: boolean) => void } = {}): Promise<string> {
     // A handover bundle overrides the legacy pin fields: the bundle is the
-    // authoritative execution triplet for a continuation card (issue #5).
-    const workspaceId = task.handover?.workspaceId ?? task.workspaceId
+    // authoritative execution triplet for a continuation card (issue #5). A
+    // card that pins nothing is resolved to the deployment's most recently used
+    // workspace instead of being left to `session.create`, whose own fallback is
+    // the Host process working directory (the desktop app's profile directory) —
+    // never the project the user was in when the card was written.
+    const workspaceId = task.handover?.workspaceId ?? task.workspaceId ?? this.recentWorkspaceId()
     const mode = task.handover?.mode ?? task.mode
     const permission = task.handover?.permission ?? task.permission
 
@@ -369,8 +391,12 @@ export class HostExecutionRunner {
         // whose session was composed from a different preset now fails closed
         // instead of silently running under the wrong composition, matching
         // the fresh branch's `agentPreset` assertion (issue #1708).
+        // Report the session before anything is queued into it, so the board
+        // can bind the execution first and a completion claim can never arrive
+        // at the gate without its binding.
+        options.onSession?.(reused)
         await this.assertReusedPreset(reused, mode)
-        await this.pinAndPrompt(reused, task, permission, options.promptContext)
+        await this.pinAndPrompt(reused, task, permission, options.promptContext, options.onGoalArmed)
       } catch (error) {
         throw new SessionLaunchError(reused, error)
       }
@@ -381,9 +407,10 @@ export class HostExecutionRunner {
       ...(mode === undefined ? {} : { agentPreset: mode }),
     }) as { sessionId: ExecutionSessionId }
     const sessionId = created.sessionId
+    options.onSession?.(sessionId)
     try {
       await this.invoke('session', 'rename', { sessionId, title: task.title })
-      await this.pinAndPrompt(sessionId, task, permission, options.promptContext)
+      await this.pinAndPrompt(sessionId, task, permission, options.promptContext, options.onGoalArmed)
     } catch (error) {
       throw new SessionLaunchError(sessionId, error)
     }
@@ -428,6 +455,7 @@ export class HostExecutionRunner {
     task: TaskRecord,
     permission: TaskPermission | undefined,
     context: PromptContext = {},
+    onGoalArmed?: (armed: boolean) => void,
   ): Promise<void> {
     if (permission !== undefined) {
       if (this.commands === undefined) throw new Error('permission command dispatcher is unavailable')
@@ -456,7 +484,25 @@ export class HostExecutionRunner {
       mode: 'queue' as const,
       content: [{ type: 'text' as const, text: promptText(task, context) }],
     })
-    await this.armGoal(sessionId, task, context)
+    const armed = await this.armGoal(sessionId, task, context)
+    onGoalArmed?.(armed)
+  }
+
+  /**
+   * Read the host's model catalog: the default route an unconfigured session
+   * starts at, and each provider's models with the reasoning metadata its
+   * adapter exposes. The acceptance settings card and the frozen contract both
+   * resolve against it, so "inherit host" means the host's own configuration
+   * rather than a session's or a card's pinned model.
+   * @returns the raw catalog value, or undefined when this cohort serves none.
+   */
+  async modelCatalog(): Promise<unknown> {
+    try {
+      return await this.invoke('session', 'modelCatalog', {})
+    } catch (error) {
+      console.warn('[dsh-task-board] session/modelCatalog failed; the acceptance settings fall back to the configured route', error)
+      return undefined
+    }
   }
 
   /**
@@ -472,11 +518,11 @@ export class HostExecutionRunner {
    * plain turn: the task was asked to run, and a missing goal mode must not
    * lose the work.
    */
-  private async armGoal(sessionId: ExecutionSessionId, task: TaskRecord, context: PromptContext): Promise<void> {
-    if (task.goalRun === false) return
+  private async armGoal(sessionId: ExecutionSessionId, task: TaskRecord, context: PromptContext): Promise<boolean> {
+    if (task.goalRun === false) return false
     if (this.commands === undefined) {
       console.warn('[dsh-task-board] no command dispatcher is available; task ' + task.id + ' runs without /goal')
-      return
+      return false
     }
     try {
       const command = await this.commands.execute(
@@ -486,13 +532,16 @@ export class HostExecutionRunner {
       )
       if (command === undefined) {
         console.warn('[dsh-task-board] /goal was not acknowledged for session ' + sessionId + '; the run continues as a plain turn')
-        return
+        return false
       }
       if (command.kind !== 'success') {
         console.warn('[dsh-task-board] /goal was refused for session ' + sessionId + ': ' + (command.text ?? 'no reason reported') + '; the run continues as a plain turn')
+        return false
       }
+      return true
     } catch (error) {
       console.warn('[dsh-task-board] could not arm /goal on session ' + sessionId + '; the run continues as a plain turn', error)
+      return false
     }
   }
 

package/src/host-service.ts

@@ -4,8 +4,13 @@ import { reusableSessionId } from './core/session-reuse.ts'
 import { HostTaskLedger, type OpenedRun, type OpenExecutionReference } from './host-ledger.ts'
 import { HostExecutionRunner, SessionLaunchError, promptText, type SessionCommandDispatcher, type SessionSummary, type TaskBoardWorkspaceRegistry } from './host-runner.ts'
 import { teammateName } from './core/subtask.ts'
+import { workspaceOwningSession } from './core/workspace-target.ts'
 import { PowerInhibitor } from './power-inhibitor.ts'
 import { TASK_BOARD_SCHEMA_VERSION, type TaskBoardAction, type TaskBoardEventPayload, type TaskBoardSnapshot } from './protocol.ts'
+import { TaskBoardExtensionRegistry } from './host/extension-registry.ts'
+import type { TaskBoardExtension } from './core/extension.ts'
+import type { ExecutionOutcome, TaskStatus } from './core/tasks.ts'
+import { passedAttempt, resolveContract, verificationRequired, type ExecutionVerification, type ModelCatalogView, type VerificationContract, type VerificationSettings } from './core/verification.ts'
 import type { TaskPermission } from './core/handover.ts'
 
 /** One teammate the Host asks the Agent Teams service to spawn for a team run. */
@@ -129,10 +134,20 @@ export class TaskBoardHostService {
    */
   private readonly unreadablePolls = new Map<string, number>()
   private preventIdleSleep = false
+  private readonly verificationSettings: () => VerificationSettings
+  private readonly verificationCatalog: () => Promise<ModelCatalogView | undefined>
   private readonly team: TaskBoardTeamDispatcher | undefined
   private readonly timers: HostTimerFace
   private lastPowerJson = ''
   private readonly now: () => number
+  /** The deployment's workspaces, consulted to resolve a card that pins none. */
+  private readonly workspaceRegistry: TaskBoardWorkspaceRegistry | undefined
+  /**
+   * External provider extensions. The board owns task lifecycle and execution;
+   * a provider observes them through the registry's capability face and never
+   * reaches into the ledger itself.
+   */
+  readonly extensions: TaskBoardExtensionRegistry
 
   constructor(gateway: TypertGateway, options: {
     ledger?: HostTaskLedger
@@ -140,20 +155,42 @@ export class TaskBoardHostService {
     now?: () => number
     commandDispatcher?: SessionCommandDispatcher
     workspaceRegistry?: TaskBoardWorkspaceRegistry
-    sessionDefaultPermission?: TaskPermission
+    /**
+     * Permission baseline of the confirmation gate: a fixed value, or a live
+     * resolver the board re-reads so a Host Settings change needs no remount.
+     */
+    sessionDefaultPermission?: TaskPermission | (() => TaskPermission)
     maxSubtaskDepth?: number
     team?: TaskBoardTeamDispatcher
     timers?: HostTimerFace
+    /**
+     * Live acceptance settings (volatile config reads). Absent keeps goal
+     * acceptance OFF for every execution this service opens, which is what a
+     * programmatic mount without the settings domain gets.
+     */
+    verificationSettings?: () => VerificationSettings
+    /** The host model catalog the acceptance contract resolves its route from. */
+    verificationCatalog?: () => Promise<ModelCatalogView | undefined>
   } = {}) {
     this.ledger = options.ledger ?? new HostTaskLedger(undefined, undefined, {
       sessionDefaultPermission: options.sessionDefaultPermission,
       maxSubtaskDepth: options.maxSubtaskDepth,
     })
     this.runner = new HostExecutionRunner(gateway, options.commandDispatcher, options.workspaceRegistry)
+    this.workspaceRegistry = options.workspaceRegistry
     this.team = options.team
     this.timers = options.timers ?? PROCESS_TIMERS
     this.power = options.power ?? new PowerInhibitor()
     this.now = options.now ?? Date.now
+    this.verificationSettings = options.verificationSettings ?? (() => ({ enabled: false, model: '', reasoningEffort: '' }))
+    this.verificationCatalog = options.verificationCatalog ?? (async () => undefined)
+    this.extensions = new TaskBoardExtensionRegistry({
+      ledger: this.ledger,
+      // Capability writes go through the board's own action path, so every
+      // board gate (content freeze, running lock, permission gate) still holds.
+      apply: (action, initiator) => this.applyBoardAction(crypto.randomUUID(), action, initiator),
+      now: this.now,
+    })
     installStreamErrorGuards()
     this.ledger.subscribe(() => {
       this.syncPowerReasons()
@@ -195,6 +232,9 @@ export class TaskBoardHostService {
       })
     }
     this.power.setEnabled(active && preventIdleSleep)
+    // Providers follow the board's master switch: the registry stops their
+    // provider-side work and hides their seats without clearing any data.
+    this.extensions.setEnabled(active)
     if (resumed) {
       this.schedulePoll()
       this.recoverSchedule()
@@ -208,6 +248,7 @@ export class TaskBoardHostService {
 
   snapshot(): TaskBoardSnapshot {
     const state = this.ledger.state()
+    const published = this.extensions.published()
     return {
       schemaVersion: TASK_BOARD_SCHEMA_VERSION,
       revision: state.revision,
@@ -217,6 +258,38 @@ export class TaskBoardHostService {
       sessionDefaultPermission: this.ledger.sessionDefaultPermission,
       maxSubtaskDepth: this.ledger.maxSubtaskDepth,
       teamRunAvailable: this.team !== undefined,
+      ...(Object.keys(published).length === 0 ? {} : { extensions: published }),
+    }
+  }
+
+  /**
+   * Admit one external provider. Idempotent by extension id; the returned
+   * disposer releases it (its stored data stays).
+   */
+  registerExtension(extension: TaskBoardExtension): () => void {
+    return this.extensions.registerExtension(extension)
+  }
+
+  /**
+   * The acceptance configuration the settings card displays: the live settings,
+   * the contract they resolve to, and the host catalog the choices come from.
+   *
+   * The card shows the RESOLVED route, not the raw configuration, so "inherit
+   * host" reads as the concrete model and reasoning level the next execution
+   * will actually freeze, including any recorded effort fallback.
+   * @returns the resolved acceptance options.
+   */
+  async verificationOptions(): Promise<{
+    settings: VerificationSettings
+    contract: VerificationContract
+    catalog: ModelCatalogView
+  }> {
+    const settings = this.verificationSettings()
+    const catalog = await this.verificationCatalog()
+    return {
+      settings,
+      contract: resolveContract(settings, catalog),
+      catalog: catalog ?? { groups: [] },
     }
   }
 
@@ -231,8 +304,55 @@ export class TaskBoardHostService {
     return () => { this.listeners.delete(listener) }
   }
 
-  apply(requestId: string, action: TaskBoardAction, initiator?: string): TaskBoardSnapshot {
+  /**
+   * Give a root card created without a workspace pin the workspace its creator
+   * is in.
+   *
+   * An agent's `task_board_create` arrives with the calling session, and the
+   * GUI submits the session the main view shows, so the card lands where the
+   * work was asked for instead of where the Host process happens to run. A card
+   * that names a workspace keeps it, and a subtask keeps inheriting its lineage
+   * (the runner walks the ancestor chain for that).
+   *
+   * The initiator is client-asserted, so it only chooses among workspaces the
+   * deployment already knows: it can neither register one nor reach outside the
+   * list the user sees.
+   * @param action - the action about to be applied.
+   * @param initiator - the session that issued the action, when one was asserted.
+   * @returns the action, with an inherited workspace on a root creation.
+   */
+  private withInheritedWorkspace(action: TaskBoardAction, initiator?: string): TaskBoardAction {
+    if (action.kind !== 'create' || initiator === undefined || initiator === '') return action
+    const input = action.input
+    // A subtask inherits its lineage instead, and an explicit pin is the user's.
+    if ((input.parentId ?? '').trim() !== '') return action
+    if ((input.workspaceId ?? '').trim() !== '') return action
+    const workspaceId = workspaceOwningSession(this.workspaceRegistry?.list() ?? [], initiator)
+    if (workspaceId === undefined) return action
+    return { ...action, input: { ...input, workspaceId } }
+  }
+
+  apply(requestId: string, action: Extract<TaskBoardAction, { kind: 'extension-action' }>, initiator?: string): Promise<TaskBoardSnapshot>
+  apply(requestId: string, action: Exclude<TaskBoardAction, { kind: 'extension-action' }>, initiator?: string): TaskBoardSnapshot
+  apply(requestId: string, action: TaskBoardAction, initiator?: string): TaskBoardSnapshot | Promise<TaskBoardSnapshot>
+  apply(requestId: string, action: TaskBoardAction, initiator?: string): TaskBoardSnapshot | Promise<TaskBoardSnapshot> {
     if (!this.active) throw new Error('task board is disabled')
+    // Provider actions never touch the ledger directly: the registry routes the
+    // action to the owning extension, whose own capability calls come back
+    // through applyBoardAction and every board gate below.
+    if (action.kind === 'extension-action') {
+      return this.handleExtensionAction(action)
+    }
+    return this.applyBoardAction(requestId, action, initiator)
+  }
+
+  /**
+   * Apply one board-owned action with every gate intact. Provider capability
+   * calls and the same-origin wire both land here, so the two surfaces can
+   * never disagree about a card.
+   */
+  private applyBoardAction(requestId: string, action: Exclude<TaskBoardAction, { kind: 'extension-action' }>, initiator?: string): TaskBoardSnapshot {
+    const before = this.statusMap()
     // Fail closed before the ledger opens anything: a card opted into team
     // execution cannot run in a deployment that serves no Agent Teams service,
     // and silently degrading it to a plain cascade would misreport the work.
@@ -240,12 +360,14 @@ export class TaskBoardHostService {
       const task = this.ledger.state().tasks.find(item => item.id === action.taskId)
       if (task?.teamRun === true) throw new Error('Agent Teams is unavailable in this deployment')
     }
-    const result = this.ledger.applyRequest(requestId, action, initiator)
+    const result = this.ledger.applyRequest(requestId, this.withInheritedWorkspace(action, initiator), initiator)
     if (result.runs !== undefined) this.dispatchRuns(result.runs)
     // A committed schedule write (create / update / toggle / delete) moves the
     // nearest trigger; re-arm on every action so a newly enabled schedule fires
     // at its own instant without waiting for the previous target to elapse.
     if (SCHEDULE_WRITE_ACTIONS.has(action.kind)) this.refreshSchedule()
+    this.emitStatusChanges(before, initiator)
+    if (action.kind === 'delete') this.extensions.emitTaskDeleted({ taskId: action.taskId })
     return {
       schemaVersion: TASK_BOARD_SCHEMA_VERSION,
       revision: result.state.revision,
@@ -255,8 +377,39 @@ export class TaskBoardHostService {
     }
   }
 
+  /** Route one provider action and answer the resulting board snapshot. */
+  private async handleExtensionAction(action: Extract<TaskBoardAction, { kind: 'extension-action' }>): Promise<TaskBoardSnapshot> {
+    await this.extensions.handleAction({
+      extensionId: action.extensionId,
+      action: action.action,
+      ...(action.taskId === undefined ? {} : { taskId: action.taskId }),
+      ...(action.payload === undefined ? {} : { payload: action.payload }),
+    })
+    return this.snapshot()
+  }
+
+  /** Current task id -> status map, for change detection around a mutation. */
+  private statusMap(): Map<string, TaskStatus> {
+    return new Map(this.ledger.allTasks().map(task => [task.id, task.status]))
+  }
+
+  /** Emit a status change for every task whose column moved, isolated per callback. */
+  private emitStatusChanges(before: Map<string, TaskStatus>, initiator?: string): void {
+    for (const task of this.ledger.allTasks()) {
+      const previous = before.get(task.id)
+      if (previous === undefined || previous === task.status) continue
+      this.extensions.emitStatusChanged({
+        taskId: task.id,
+        status: task.status,
+        previous,
+        ...(initiator === undefined || initiator === '' ? {} : { initiator }),
+      })
+    }
+  }
+
   dispose(): void {
     this.disposed = true
+    this.extensions.dispose()
     this.clearScheduleTimer()
     this.pollTimer?.()
     this.pollTimer = undefined
@@ -286,17 +439,48 @@ export class TaskBoardHostService {
         ...(team ? { team: true } : {}),
         ...(schedule === undefined ? {} : { schedule }),
       }
+      // Freeze this execution's acceptance contract BEFORE the session is
+      // prompted: a settings change made while the run is in flight must not
+      // retrofit the rule that will judge it. A card that opted out resolves the
+      // same contract from an OFF switch: the board-wide switch decides the
+      // default, the card decides this execution, and both are read here.
+      const settings = this.verificationSettings()
+      // The card's opt-out is a DISTINCT reason, not the board switch: the
+      // report must be able to say which of the two turned the gate off.
+      const skippedBy: ExecutionVerification['applicability'] = opened.task.skipVerification === true ? 'skipped' : 'disabled'
+      const contract = resolveContract(
+        { ...settings, enabled: settings.enabled && opened.task.skipVerification !== true },
+        await this.verificationCatalog(),
+      )
+      const initial: ExecutionVerification = {
+        contract,
+        attempts: [],
+        applicability: team ? 'team-member' : !contract.enabled ? skippedBy : 'goal-unavailable',
+      }
+      this.ledger.setVerification(opened.task.id, opened.execution.id, initial)
+      let attached: string | undefined
       const sessionId = await this.runner.launch(opened.task, {
         ...(reuseSessionId === undefined ? {} : { reuseSessionId }),
         ...(promptContext === undefined ? {} : { promptContext }),
+        // Bind the session to the execution before the prompt is queued, so the
+        // completion gate can never observe the agent without its binding.
+        onSession: (id) => {
+          attached = id
+          this.ledger.attachSession(opened.task.id, opened.execution.id, id)
+        },
+        onGoalArmed: (armed) => {
+          this.setApplicability(opened.task.id, opened.execution.id, team
+            ? 'team-member'
+            : !contract.enabled ? skippedBy : armed ? 'enforced' : 'goal-unavailable')
+        },
       })
-      this.ledger.attachSession(opened.task.id, opened.execution.id, sessionId)
+      if (attached === undefined) this.ledger.attachSession(opened.task.id, opened.execution.id, sessionId)
       if (team) for (const teammate of others) this.scheduleTeammate(teammate, sessionId)
     } catch (error) {
       if (error instanceof SessionLaunchError) {
         this.ledger.attachSession(opened.task.id, opened.execution.id, error.sessionId)
       }
-      this.ledger.settle(opened.task.id, opened.execution.id, 'failed', error instanceof Error ? error.message : String(error))
+      this.settleAndNotify(opened.task.id, opened.execution.id, 'failed', error instanceof Error ? error.message : String(error))
     }
   }
 
@@ -316,7 +500,7 @@ export class TaskBoardHostService {
   private async spawnTeammate(opened: OpenedRun, leadSessionId: string): Promise<void> {
     const team = this.team
     if (team === undefined) {
-      this.ledger.settle(opened.task.id, opened.execution.id, 'failed', 'Agent Teams is unavailable in this deployment')
+      this.settleAndNotify(opened.task.id, opened.execution.id, 'failed', 'Agent Teams is unavailable in this deployment')
       return
     }
     try {
@@ -327,12 +511,12 @@ export class TaskBoardHostService {
         prompt: promptText(opened.task),
       })
       if (member.sessionId === undefined || member.sessionId === '') {
-        this.ledger.settle(opened.task.id, opened.execution.id, 'failed', member.error ?? 'teammate provisioning failed')
+        this.settleAndNotify(opened.task.id, opened.execution.id, 'failed', member.error ?? 'teammate provisioning failed')
         return
       }
       this.ledger.attachSession(opened.task.id, opened.execution.id, member.sessionId)
     } catch (error) {
-      this.ledger.settle(opened.task.id, opened.execution.id, 'failed', error instanceof Error ? error.message : String(error))
+      this.settleAndNotify(opened.task.id, opened.execution.id, 'failed', error instanceof Error ? error.message : String(error))
     }
   }
 
@@ -354,7 +538,9 @@ export class TaskBoardHostService {
     // Fold whatever the board can already decide before spending inspection
     // RPCs: a team run whose Lead recorded its verdict, and any lineage whose
     // members are all settled. Idempotent, so an already folded board is free.
+    const foldedBefore = this.statusMap()
     this.ledger.finalizeReadyRuns()
+    this.emitStatusChanges(foldedBefore)
     // Read after the RPC so executions attached while it was in flight are
     // included in this pass, matching the former full-state snapshot timing.
     const runtime = this.ledger.runtimeView()
@@ -375,6 +561,16 @@ export class TaskBoardHostService {
   ): Promise<void> {
     for (const execution of executions) {
       if (execution.sessionId === undefined) continue
+      const record = this.ledger.getTask(execution.taskId)?.executions.find(entry => entry.id === execution.executionId)
+      const verification = record?.verification
+      // A cycle the gate already closed is decided here, without another
+      // inspection: the goal may still be active (or un-blockable) exactly
+      // because the acceptance failed, and the card must not stay in the
+      // running column waiting for a verdict that is already recorded.
+      if (verification?.failedReason !== undefined) {
+        this.settleAndNotify(execution.taskId, execution.executionId, 'failed', verification.failedReason)
+        continue
+      }
       try {
         // A team member's turn is read even while the roster calls its session
         // running: a durable teammate never goes idle for good.
@@ -387,7 +583,20 @@ export class TaskBoardHostService {
           continue
         }
         this.unreadablePolls.delete(execution.executionId)
-        this.ledger.settle(execution.taskId, execution.executionId, result.outcome, 'error' in result ? result.error : undefined)
+        // Forced acceptance: the old fallback paths — a completed turn, a
+        // paused goal, an unreadable projection, a manual settle — must never
+        // be mistaken for a verified success. Only a matching pass record
+        // settles this execution as succeeded.
+        if (result.outcome === 'succeeded' && verificationRequired(verification) && passedAttempt(verification) === undefined) {
+          this.settleAndNotify(
+            execution.taskId,
+            execution.executionId,
+            'failed',
+            'goal 验收：本次执行没有匹配的验收通过记录（验收未运行、未通过或报告来自其他执行），按未验收判失败。',
+          )
+          continue
+        }
+        this.settleAndNotify(execution.taskId, execution.executionId, result.outcome, 'error' in result ? result.error : undefined)
       } catch {
         // A transient inspection failure never settles a running execution.
       }
@@ -407,6 +616,28 @@ export class TaskBoardHostService {
    * ancestor of it — in the running column with no way out. The first poll of
    * each streak is logged, so the Host log names the session.
    */
+  private settleAndNotify(taskId: string, executionId: string, outcome: ExecutionOutcome, error?: string): void {
+    const before = this.ledger.getTask(taskId)
+    if (before?.executions.find(entry => entry.id === executionId)?.endedAt !== undefined) {
+      // Already settled: the ledger would no-op, and re-emitting would report
+      // the same settlement twice.
+      this.ledger.settle(taskId, executionId, outcome, error)
+      return
+    }
+    const previousStatus = before?.status
+    this.ledger.settle(taskId, executionId, outcome, error)
+    const task = this.ledger.getTask(taskId)
+    if (task !== undefined && previousStatus !== undefined && previousStatus !== task.status) {
+      this.extensions.emitStatusChanged({ taskId, status: task.status, previous: previousStatus })
+    }
+    this.extensions.emitExecutionSettled({
+      taskId,
+      executionId,
+      outcome,
+      ...(error === undefined ? {} : { error }),
+    })
+  }
+
   private noteUnreadableInspection(execution: OpenExecutionReference, reason: string | undefined): void {
     const polls = (this.unreadablePolls.get(execution.executionId) ?? 0) + 1
     this.unreadablePolls.set(execution.executionId, polls)
@@ -417,7 +648,7 @@ export class TaskBoardHostService {
     }
     if (polls < UNREADABLE_SETTLE_POLLS) return
     this.unreadablePolls.delete(execution.executionId)
-    this.ledger.settle(
+    this.settleAndNotify(
       execution.taskId,
       execution.executionId,
       'failed',
@@ -484,6 +715,7 @@ export class TaskBoardHostService {
       this.recoverSchedule()
       return
     }
+    const before = this.statusMap()
     for (const schedule of this.ledger.dueSchedules(now)) {
       const next = nextRunAtMs(schedule.cron, schedule.nextRunAt, schedule.timeZone)
       this.dispatchRuns(
@@ -491,6 +723,7 @@ export class TaskBoardHostService {
         { triggeredAt: now, timeZone: schedule.timeZone, cron: schedule.cron },
       )
     }
+    this.emitStatusChanges(before)
     // The launched run (or the rolled-forward target) moved every due schedule,
     // so the next nearest target has to be recomputed from the ledger.
     this.armSchedule()
@@ -517,6 +750,16 @@ export class TaskBoardHostService {
     }
   }
 
+  /**
+   * Move one execution's applicability without touching its frozen contract or
+   * its recorded attempts (used when the run's goal form becomes known).
+   */
+  private setApplicability(taskId: string, executionId: string, applicability: ExecutionVerification['applicability']): void {
+    const verification = this.ledger.getTask(taskId)?.executions.find(entry => entry.id === executionId)?.verification
+    if (verification === undefined || verification.applicability === applicability) return
+    this.ledger.setVerification(taskId, executionId, { ...verification, applicability })
+  }
+
   private scheduleLaunch(opened: OpenedRun, others: readonly OpenedRun[] = [], schedule?: ScheduledRunContext): void {
     void this.launch(opened, others, schedule).catch(error => {
       safeConsoleError('[dsh-task-board] execution launch settlement failed', error)