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

package/lib/types/host-ledger.d.ts

@@ -1,5 +1,6 @@
-import { type ExecutionOutcome, type ExecutionRecord, type TaskRecord } from './core/tasks.ts';
+import { type ExecutionOutcome, type ExecutionRecord, type ScheduleMode, type TaskRecord } from './core/tasks.ts';
 import { type TaskBoardAction, type TaskBoardSchedulerSnapshot } from './protocol.ts';
+import { type ExecutionVerification } from './core/verification.ts';
 import { type TaskPermission } from './core/handover.ts';
 export interface LedgerState {
     revision: number;
@@ -34,7 +35,10 @@ export interface OpenExecutionReference {
 /** Minimal value copy used by the Host scheduler. */
 export interface DueScheduleReference {
     readonly taskId: string;
-    readonly cron: string;
+    /** Whether this due rule is a recurring cron rule or a single planned instant. */
+    readonly mode: ScheduleMode;
+    /** Cron expression of a recurring rule; absent on a one-shot. */
+    readonly cron?: string;
     /** Zone this rule's wall clock is read in. */
     readonly timeZone: string;
     readonly nextRunAt: number;
@@ -43,6 +47,24 @@ export interface DueScheduleReference {
 export interface LedgerRuntimeView {
     readonly armedSchedules: number;
     readonly openExecutions: readonly OpenExecutionReference[];
+    /**
+     * Session ids of every open execution, including the ones
+     * {@link openExecutions} skips because their own outcome is already
+     * recorded. A caller that asks whether the board still observes any session
+     * must use this list: a deferred cascade parent is settled by its members,
+     * but it is still an open execution.
+     */
+    readonly openSessionIds: readonly string[];
+    /**
+     * Whether this document holds anything the session roster can still decide:
+     * an open execution that needs inspecting, or a card in the running column
+     * whose verdict may arrive from a settle this process never saw.
+     *
+     * A board with no running card, no open execution and no armed schedule has
+     * no use for the roster at all, which is what lets the Host poll stand down
+     * instead of re-reading every persisted session forever.
+     */
+    readonly needsSessionState: boolean;
 }
 /**
  * Best-effort single-letter process state ('R','S','D','Z',...) or undefined
@@ -89,8 +111,14 @@ export declare class HostTaskLedger {
     readonly lockFile: string;
     /** 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;
+    /**
+     * 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;
     /**
      * Deployment subtask depth limit (1..3): the lineage gate every write obeys.
      * The settings card edits it live, so {@link setMaxSubtaskDepth} mutates it
@@ -98,7 +126,7 @@ export declare class HostTaskLedger {
      */
     private depthLimit;
     constructor(dir?: string, now?: () => number, options?: {
-        sessionDefaultPermission?: TaskPermission;
+        sessionDefaultPermission?: TaskPermission | (() => TaskPermission);
         maxSubtaskDepth?: number;
     });
     /** Current subtask depth limit (1..3). */
@@ -118,7 +146,7 @@ export declare class HostTaskLedger {
     };
     state(): LedgerState;
     /**
-     * Runtime-only projection for the 5 s Host poll. It copies just primitive
+     * Runtime-only projection for the Host poll. It copies just primitive
      * identifiers and timestamps, never the complete task/execution history or
      * an authoritative mutable object from the ledger.
      */
@@ -145,9 +173,45 @@ export declare class HostTaskLedger {
     /**
      * Open the cascade one due schedule triggers: an empty array means nothing
      * ran (already running, or a participant whose elevated permission is still
-     * unconfirmed), and the rule rolls to its next occurrence either way.
+     * unconfirmed, a one-shot whose instant was missed, or an exhausted budget),
+     * and the rule's own state says which.
+     *
+     * The run budget is enforced HERE, inside the single ledger writer: a rule
+     * whose counter already reached its cap is stopped instead of opened, so no
+     * restart, repeated timer fire or re-arm can overrun it.
+     * @param taskId - the task whose rule came due.
+     * @param triggeredAt - the instant the occurrence came due.
+     * @returns the executions this occurrence opened.
+     */
+    openScheduled(taskId: string, triggeredAt: number): OpenedRun[];
+    /**
+     * Record a due occurrence that opened no execution: roll a recurring rule to
+     * its next occurrence (budget untouched), or stop it when there is none. A
+     * one-shot has no second occurrence, so it always stops here with the reason.
+     */
+    private skipOccurrence;
+    /** Apply a schedule-occurrence transition and persist it atomically. */
+    private progressSchedule;
+    /**
+     * Refund the one scheduled run an occurrence consumed before its launch
+     * failed without creating a session (see
+     * {@link applyScheduleRefund}). Called by the service on the failed-launch
+     * path only; a manual run and a launch that did reach a session are never
+     * refunded. A no-op for a task with no rule, so a failed cascade member does
+     * not touch anything.
+     * @param taskId - the task whose occurrence is being refunded.
+     * @param now - clock instant (ms epoch).
+     */
+    refundScheduledOccurrence(taskId: string, now: number): void;
+    /**
+     * Boot / resume recovery: skip every occurrence that came due while the board
+     * was not running through it. A recurring rule rolls to its next future
+     * target; a one-shot whose instant has passed is stopped as missed, because
+     * there is no later occurrence left to run. Rendering the missed occurrence
+     * is deliberately not attempted: the ACL of a card that fired hours ago is
+     * stale, and the board's own recovery contract is "missed triggers are
+     * skipped, never replayed".
      */
-    openScheduled(taskId: string, nextRunAt: number | undefined, triggeredAt: number): OpenedRun[];
     skipMissed(now: number): void;
     setScheduler(patch: Partial<TaskBoardSchedulerSnapshot>): void;
     /**
@@ -158,16 +222,29 @@ export declare class HostTaskLedger {
      */
     settle(taskId: string, executionId: string, outcome: ExecutionOutcome, error?: string): void;
     attachSession(taskId: string, executionId: string, sessionId: string): void;
+    allTasks(): readonly TaskRecord[];
+    getTask(id: string): TaskRecord | undefined;
+    saveTaskRecord(task: TaskRecord): void;
     private apply;
+    /**
+     * Whether a creation-time schedule request is usable. A one-shot must carry
+     * a whole-millisecond instant in the future; a recurring rule must carry a
+     * valid expression with a reachable occurrence and, when capped, a positive
+     * whole run budget. An unusable zone is refused rather than reinterpreted as
+     * the Host zone.
+     */
+    private validScheduleRequest;
     /**
      * The binding that makes a run illegal, if any.
      *
      * 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.
      */
@@ -190,7 +267,9 @@ export declare class HostTaskLedger {
      * @param now - clock instant (ms epoch).
      * @param initiator - the DSH session that asked for the run (audit only).
      * @param rerun - true to reset the root to 'todo' before starting it.
-     * @param nextRunAt - when set, the root's schedule also rolls forward.
+     * @param progress - when set, this run was a due occurrence and the root's
+     *   rule is advanced (counter, next target, stop/skip record) in the same
+     *   atomic commit that opened the executions.
      */
     private startCascade;
     /**
@@ -236,10 +315,18 @@ export declare class HostTaskLedger {
      * @returns whether the document changed.
      */
     private closeTeamMembers;
+    /**
+     * Re-align every armed rule at load/import. A recurring rule is recomputed
+     * from the current instant; a one-shot is armed at its planned instant when
+     * that is still in the future, and stopped as missed once it has passed
+     * (there is no later occurrence to run). A recurring rule recomputed past an
+     * occurrence records the skip, so the board can show that a fire was passed
+     * over rather than silently rewinding.
+     */
     private repairSchedules;
     private reconcileInterruptedStarts;
     /**
-     * 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.
@@ -250,8 +337,40 @@ export declare 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;
+    /**
+     * 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;
+    /**
+     * 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;
     private load;
     private normalizeDocument;
     /** Quarantine an unreadable document and start from an empty ledger. */

package/lib/types/host-runner.d.ts

@@ -3,7 +3,10 @@ import type { SessionSummary } from '@deepseek-ai/dsh-api-session-controller/typ
 import type { CommandResult } from '@deepseek-ai/dsh-commands/types';
 import type { Workspace } from '@deepseek-ai/dsh-workspace/types';
 import type { 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[];
 }
@@ -75,15 +78,16 @@ export interface PromptContext {
     /** True when those members run as teammates inside this session (Team Lead). */
     team?: boolean;
     /**
-     * Scheduled-run provenance: the instant the cron rule actually fired and the
-     * IANA zone its wall clock was read in. Present only for a cron-triggered
-     * run, so the model can resolve an unqualified date in the run's own terms
-     * instead of guessing from the Host clock (issue #1722).
+     * Scheduled-run provenance: the instant the rule actually fired, its kind,
+     * and the IANA zone its wall clock was read in. Present only for a
+     * timer-triggered run, so the model can resolve an unqualified date in the
+     * run's own terms instead of guessing from the Host clock (issue #1722).
      */
     schedule?: {
         triggeredAt: number;
         timeZone: string;
-        cron: string;
+        mode: 'cron' | 'once';
+        cron?: string;
     };
 }
 /**
@@ -118,6 +122,14 @@ export declare class HostExecutionRunner {
     });
     private invoke;
     private stream;
+    /**
+     * 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;
     /**
      * Launch one execution. Without `options.reuseSessionId` a fresh session is
      * created, renamed, pinned, and prompted (the historical contract). With it,
@@ -131,6 +143,20 @@ export declare class HostExecutionRunner {
     launch(task: TaskRecord, options?: {
         reuseSessionId?: string;
         promptContext?: PromptContext;
+        onSession?: (sessionId: string) => void;
+        onGoalArmed?: (armed: boolean) => void;
+        /**
+         * GLOBAL native /goal switch, resolved by the caller ONCE per execution and
+         * carried here so the decision is frozen for this launch.
+         *
+         * Frozen deliberately: a settings edit made while the run is in flight must
+         * not arm, disarm or otherwise change the goal/acceptance contract of a run
+         * already running. Absent means off — the default for every deployment that
+         * never touched the switch, including cards written before the option
+         * existed. A plain single turn is what an off switch produces; the task-level
+         * `goalRun` still applies on top of it (both must ASK for a goal).
+         */
+        goalEnabled?: boolean;
     }): Promise<string>;
     /**
      * Fail closed when a reused session records a different Agent preset than
@@ -153,6 +179,15 @@ export declare class HostExecutionRunner {
      * the same permission/model pins before the prompt.
      */
     private pinAndPrompt;
+    /**
+     * 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.
+     */
+    modelCatalog(): Promise<unknown>;
     /**
      * Arm dsh's built-in goal on the session. The task prompt is queued FIRST, so
      * the session's first turn carries the instruction verbatim; `/goal
@@ -160,11 +195,21 @@ export declare class HostExecutionRunner {
      * dsh's goal-round driver keeps starting continuation rounds until the agent
      * marks it complete (see {@link goalVerdict} for how the run settles).
      *
-     * Opt-out: a task whose `goalRun` is an explicit false runs one plain turn.
+     * Two switches gate the arming, and BOTH must ask for it:
+     * - the GLOBAL native-/goal switch (`goalEnabled`, default OFF), frozen when
+     *   this execution started; and
+     * - the task's own `goalRun` (absent means off, only an explicit true opts
+     *   the card into a goal run).
+     *
      * A refusal (no command dispatcher, no `/goal` command in this cohort, an
-     * objective the command rejects) is reported and the run continues as that
-     * plain turn: the task was asked to run, and a missing goal mode must not
-     * lose the work.
+     * objective the command rejects) is reported and the run continues as a plain
+     * turn: the task was asked to run, and a missing goal mode must not lose the
+     * work.
+     * @param sessionId - the session to arm in.
+     * @param task - the task being run.
+     * @param context - the run's prompt context.
+     * @param goalEnabled - the GLOBAL switch, frozen for this execution.
+     * @returns whether `/goal` was really armed.
      */
     private armGoal;
     /**

package/lib/types/host-service.d.ts

@@ -3,6 +3,10 @@ import { HostTaskLedger } from './host-ledger.ts';
 import { HostExecutionRunner, type SessionCommandDispatcher, type TaskBoardWorkspaceRegistry } from './host-runner.ts';
 import { PowerInhibitor } from './power-inhibitor.ts';
 import { 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 { ScheduleMode } from './core/tasks.ts';
+import { 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. */
 export interface TeamSpawnInput {
@@ -31,6 +35,30 @@ export interface TeamSpawnResult {
 export interface TaskBoardTeamDispatcher {
     spawn(input: TeamSpawnInput): Promise<TeamSpawnResult>;
 }
+/**
+ * Why an enforced goal execution settled failed while its acceptance DID run:
+ * attempts were recorded and none of them passed. The judge answered about the
+ * work and the work did not pass.
+ */
+export declare const NO_MATCHING_PASS_VERIFICATION_REASON = "goal \u9A8C\u6536\uFF1A\u672C\u6B21\u6267\u884C\u6CA1\u6709\u5339\u914D\u7684\u9A8C\u6536\u901A\u8FC7\u8BB0\u5F55\uFF08\u9A8C\u6536\u672A\u8FD0\u884C\u3001\u672A\u901A\u8FC7\u6216\u62A5\u544A\u6765\u81EA\u5176\u4ED6\u6267\u884C\uFF09\uFF0C\u6309\u672A\u9A8C\u6536\u5224\u5931\u8D25\u3002";
+/**
+ * Why an enforced goal execution settled failed with ZERO acceptance records:
+ * the gate was never opened, so the judge never ran and nothing was ever judged
+ * (issue #1837). The root cause is a session that declared completion in prose
+ * instead of calling `update_goal(action: complete)` — a tool-adherence problem,
+ * NOT a quality verdict on the delivery — so this reason says so and keeps the
+ * two investigation directions apart.
+ */
+export declare const NEVER_INVOKED_VERIFICATION_REASON = "goal \u9A8C\u6536\u672A\u89E6\u53D1\uFF1A\u672C\u6B21\u6267\u884C\u6CA1\u6709\u4EFB\u4F55\u9A8C\u6536\u8BB0\u5F55\uFF0C\u9A8C\u6536\u95E8\u4ECE\u672A\u6253\u5F00\u2014\u2014\u6267\u884C\u4F1A\u8BDD\u6CA1\u6709\u8C03\u7528 update_goal(action: complete) \u6765\u5B8C\u6210\u76EE\u6807\uFF08\u5E38\u89C1\u4E8E\u53EA\u5728\u56DE\u590D\u91CC\u5BA3\u544A\u5B8C\u6210\uFF09\u3002\u8FD9\u4E0D\u662F\u8D28\u91CF\u5224\u8D1F\uFF1A\u4EA4\u4ED8\u4ECE\u672A\u88AB\u88C1\u5224\u8BC4\u4F30\u3002";
+/**
+ * Why an enforced goal execution settled failed while its ONLY acceptance
+ * records are INVALID: the judge answered but could not locate its own
+ * rejection, so the board stopped calling it. This is NOT an evidence-backed
+ * quality veto — the requirement is explicit that such a run must not be
+ * described as one — but the execution still has no matching pass, so it ends
+ * for lack of one, and the reason names that precisely.
+ */
+export declare const INVALID_ONLY_VERIFICATION_REASON = "goal \u9A8C\u6536\u65E0\u6548\uFF1A\u672C\u6B21\u6267\u884C\u53EA\u8BB0\u5F55\u4E86\u65E0\u6548\u9A8C\u6536\uFF08\u88C1\u5224\u672A\u80FD\u7ED9\u51FA\u4E0E\u4EFB\u52A1\u8981\u6C42\u5BF9\u5E94\u3001\u4E14\u53EF\u5B9A\u4F4D\u5230\u672C\u6B21\u8BC1\u636E\u7684\u5426\u51B3\u4F9D\u636E\uFF09\uFF0C\u770B\u677F\u5DF2\u505C\u6B62\u8C03\u7528\u88C1\u5224\u3002\u8FD9**\u4E0D\u662F**\u6709\u8BC1\u636E\u7684\u8D28\u91CF\u5224\u8D1F\uFF1A\u9A8C\u6536\u672C\u8EAB\u4E0D\u53EF\u7528\uFF0C\u672C\u6B21\u8FD0\u884C\u56E0\u6CA1\u6709\u5339\u914D\u7684\u901A\u8FC7\u8BB0\u5F55\u800C\u7ED3\u675F\u3002\u8BF7\u68C0\u67E5\u9A8C\u6536\u73AF\u5883\u4E0E\u8BC1\u636E\u53EF\u89C1\u6027\uFF0C\u6216\u7528 task_board_manage(action=reset-verification) \u6E05\u9664\u8BB0\u5F55\u7684\u65E0\u6548\u9A8C\u6536\u540E\u91CD\u65B0\u5B8C\u6210\u76EE\u6807\u3002";
 /**
  * Provenance of one cron-triggered cascade: when the rule fired and the zone
  * its wall clock was read in. Passed into every launched prompt of that run so
@@ -39,7 +67,10 @@ export interface TaskBoardTeamDispatcher {
 export interface ScheduledRunContext {
     triggeredAt: number;
     timeZone: string;
-    cron: string;
+    /** Whether this fire came from a recurring rule or a single planned instant. */
+    mode: ScheduleMode;
+    /** Cron expression of a recurring rule; absent on a one-shot. */
+    cron?: string;
 }
 /**
  * The native timer face the Host arms through. The cordis `timer` service
@@ -59,6 +90,12 @@ export declare class TaskBoardHostService {
     private readonly listeners;
     /** The one recurring timer: the session-roster poll. */
     private pollTimer;
+    /** Cadence of the roster poll, in seconds (a settings field; see the config schema). */
+    private sessionPollSeconds;
+    /** Pending delay that follows a failed poll pass, if one is armed. */
+    private pollBackoffTimer;
+    /** Consecutive failed poll passes; doubles the next retry delay. */
+    private consecutivePollFailures;
     /** The armed schedule timer, if a trigger is pending. */
     private scheduleTimer;
     /** The instant the armed schedule timer targets (ms epoch), for resume detection. */
@@ -66,13 +103,6 @@ export declare class TaskBoardHostService {
     private disposed;
     private pollInFlight;
     private active;
-    /**
-     * Ids the last roster poll saw as present and idle; undefined while the
-     * roster is unknown. Session reuse (issue #1419) requires this positive
-     * evidence, so a launch before the first successful poll mints a fresh
-     * conversation instead of prompting into a session it cannot see.
-     */
-    private idleSessionIds;
     /**
      * Consecutive unreadable-history polls per open execution (see
      * {@link noteUnreadableInspection}). Cleared as soon as an inspection
@@ -80,28 +110,124 @@ export declare class TaskBoardHostService {
      */
     private readonly unreadablePolls;
     private preventIdleSleep;
+    private readonly verificationSettings;
+    private readonly verificationCatalog;
     private readonly team;
     private readonly timers;
+    /** Live reader of the global native-/goal switch; frozen per execution. */
+    private readonly goalRunEnabled;
     private lastPowerJson;
     private readonly now;
+    /** The deployment's workspaces, consulted to resolve a card that pins none. */
+    private readonly workspaceRegistry;
+    /**
+     * 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;
         power?: PowerInhibitor;
         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 GLOBAL native /goal switch (a volatile config read). Read ONCE per
+         * execution, at launch, and carried by value from then on: a settings edit
+         * made while a run is in flight must not arm, disarm or otherwise change the
+         * goal/acceptance contract of that run. Absent means OFF, which is the
+         * default for every deployment that never configured it.
+         */
+        goalRunEnabled?: () => boolean;
+        /**
+         * 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>;
     });
     start(): void;
-    setConfiguration(active: boolean, preventIdleSleep: boolean): void;
+    /**
+     * Apply the live configuration. The roster cadence is re-read on every
+     * commit, so a settings edit takes effect without a restart; the poll is
+     * scheduled at the new cadence immediately rather than waiting out the old
+     * interval.
+     * @param active - the board's master switch.
+     * @param preventIdleSleep - whether the board holds an idle-sleep assertion.
+     * @param sessionPollSeconds - roster-poll cadence in seconds (clamped).
+     */
+    setConfiguration(active: boolean, preventIdleSleep: boolean, sessionPollSeconds?: number): void;
     snapshot(): TaskBoardSnapshot;
+    /**
+     * Admit one external provider. Idempotent by extension id; the returned
+     * disposer releases it (its stored data stays).
+     */
+    registerExtension(extension: TaskBoardExtension): () => void;
+    /**
+     * 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.
+     */
+    verificationOptions(): Promise<{
+        settings: VerificationSettings;
+        contract: VerificationContract;
+        catalog: ModelCatalogView;
+    }>;
     /** SSE frame payload; deliberately skips the tasks deep-clone of {@link snapshot}. */
     eventPayload(): TaskBoardEventPayload;
     subscribe(listener: () => void): () => void;
-    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;
+    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 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;
+    /** Route one provider action and answer the resulting board snapshot. */
+    private handleExtensionAction;
+    /** Current task id -> status map, for change detection around a mutation. */
+    private statusMap;
+    /** Emit a status change for every task whose column moved, isolated per callback. */
+    private emitStatusChanges;
     dispose(): void;
     private launch;
     private scheduleTeammate;
@@ -113,7 +239,32 @@ export declare class TaskBoardHostService {
      * Lead's cascade verdict.
      */
     private spawnTeammate;
+    /**
+     * One roster pass, and whether it could read the session tree.
+     *
+     * The board reads the DSH session roster only while it has something the
+     * roster can decide: an execution to inspect, or a card parked in the running
+     * column whose verdict may arrive from a settle this process never saw. That
+     * gate is what removes the cost the reporter measured — `session/list`
+     * rebuilds every persisted session row (string conversion, object allocation,
+     * a stat per record), and an idle board with no tasks was paying it every few
+     * seconds forever.
+     * @returns whether the roster was readable (an idle pass counts as readable).
+     */
     private pollSessions;
+    /**
+     * The session a run may continue in, for a card that opted into reuse
+     * (issue #1419). Reuse requires positive evidence that the previous session
+     * is present and idle, and that evidence must be read for THIS launch: an
+     * idle board no longer polls, so a roster cached from an earlier pass could
+     * be hours old — either refusing a session that has been idle all along, or
+     * prompting into one that started running since. A card that did not opt in
+     * reads no roster at all, and a read that fails mints a fresh conversation
+     * exactly as an unknown roster always did.
+     * @param task - the task about to run.
+     * @returns the session id to continue in, or undefined for a fresh session.
+     */
+    private reuseSessionFor;
     /** Reuse the session list this poll already fetched: one list RPC per tick, not 1 + E. */
     private reconcileExecutions;
     /**
@@ -125,6 +276,31 @@ export declare 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;
+    /**
+     * Remove one execution's acceptance-only detail after it PASSED and settled.
+     *
+     * Deliberately narrow: only the acceptance mechanism's own per-attempt
+     * material (findings, invalid diagnostics, the bulky judge side) is removed,
+     * and only for THIS execution, keyed by its own id in the ledger it belongs
+     * to. No user file, task artifact, raw session history or other execution's
+     * record is read or written. Idempotent by the record's own state, and it
+     * clearly never touches a run that did not pass (the caller's guard) — a
+     * failed or invalid execution keeps everything a repair or a review needs.
+     * @param taskId - the task whose execution settled.
+     * @param executionId - the settled execution.
+     */
+    private cleanupAcceptanceDetail;
+    /**
+     * Catch-up pass: clean the acceptance detail of every execution that PASSED
+     * and settled but whose cleanup did not finish (a crash, a failed write, a
+     * Host killed mid-cleanup).
+     *
+     * The same bounds as any other cleanup apply — only a real pass record on a
+     * settled execution is touched — so this can never delete material belonging
+     * to an execution that did not pass, and never a user file.
+     */
+    private cleanupPendingAcceptanceDetail;
     private noteUnreadableInspection;
     /** Drop the armed schedule timer and forget its target. */
     private clearScheduleTimer;
@@ -161,8 +337,26 @@ export declare class TaskBoardHostService {
      * session instead, once that session exists.
      */
     private dispatchRuns;
+    /**
+     * 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;
     private scheduleLaunch;
     private schedulePoll;
+    /**
+     * Count one failed pass and arm the retry that follows it.
+     *
+     * A session tree that is down is retried on a doubling delay instead of
+     * hammering it on the fixed cadence: the heartbeat would otherwise repeat
+     * every failure — and every retry inside {@link HostExecutionRunner.listRunning}
+     * — at exactly the interval the reporter measured.
+     */
+    private notePollFailure;
+    /** Arm the retry that follows a failed pass, doubling up to the ceiling. */
+    private armPollBackoff;
+    /** Drop a pending retry; the next regular tick takes over. */
+    private clearPollBackoff;
     /**
      * Re-arm from the ledger's current targets. Callers that just changed a
      * schedule (the host routes, the agent tools) invoke this after the write