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

package/lib/types/core/controller.d.ts

@@ -13,6 +13,7 @@
  */
 import type { TaskStore } from './store.ts';
 import { type NewTaskInput, type TaskRecord, type TaskStatus } from './tasks.ts';
+import { type SetSchedulePatch } from './use-cases/task-schedule.ts';
 import { type TaskUpdatePatch } from './use-cases/task-update.ts';
 import type { TaskBoardAction, TaskBoardEventPayload, TaskBoardParseDraft, TaskBoardParseRequest, TaskBoardSnapshot } from '../protocol.ts';
 import type { TaskBoardExtensionActionRequest, TaskBoardVisibilityPredicate } from './extension.ts';
@@ -99,6 +100,17 @@ export interface ExecutionModelOption {
     name?: string;
     label?: string;
     provider?: string;
+    /**
+     * Reasoning metadata the adapter declares for this exact route. An effort
+     * picker is offered only while `supported`, and its choices are `efforts` —
+     * the ids the target model really accepts, so the UI never offers (or keeps)
+     * a level the model would reject. Absent means the deployment published no
+     * capability for this model; the card value is then left untouched.
+     */
+    reasoning?: {
+        supported: boolean;
+        efforts?: readonly string[];
+    };
 }
 /** The execution-target option sets the UI feeds into the controller. */
 export interface ExecutionOptionsSnapshot {
@@ -111,7 +123,7 @@ export interface ExecutionOptionsSnapshot {
  * (revision/scheduler/power); a full snapshot also carries the deployment
  * constants the UI reads (session default permission, subtask depth).
  */
-export type HostMirror = Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission' | 'maxSubtaskDepth' | 'teamRunAvailable' | 'extensions'>;
+export type HostMirror = Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission' | 'maxSubtaskDepth' | 'teamRunAvailable' | 'goalRunEnabled' | 'cardDefaults' | 'extensions'>;
 /** Immutable controller snapshot for UI subscriptions. */
 export interface ControllerSnapshot {
     tasks: readonly TaskRecord[];
@@ -186,6 +198,19 @@ export declare class BoardController {
     isHostBacked(): boolean;
     /** Retry initial migration/state synchronization after an explicit Host error. */
     retryHostSync(): Promise<boolean>;
+    /**
+     * Re-read the authoritative Host snapshot.
+     *
+     * The board's volatile deployment configuration — the new-card defaults among
+     * it — is republished the moment the settings document is written, but the SSE
+     * frame that republish emits carries the value as of BEFORE the write (the
+     * loader hands the update to the fiber while the new document is not yet
+     * visible to it), so a mirror that followed frames alone would stay one edit
+     * behind and the create dialog would prefill from the previous defaults for
+     * the rest of the session. The surface that owns the write asks for the
+     * snapshot again instead of trusting the frame.
+     */
+    refreshHostState(): void;
     /**
      * Show the board. The layout owns which panel the center column renders, so
      * the state flip and the panel selection travel together here; a composition
@@ -287,19 +312,17 @@ export declare class BoardController {
      */
     deleteTag(name: string): Promise<boolean>;
     /**
-     * Update a task's schedule rule. A blank or invalid cron expression is
-     * rejected (returns false, state untouched). When the rule ends up enabled
-     * the next run instant is computed immediately; a disabled rule carries no
-     * next-run instant. Delegates the domain transition to the schedule use case.
+     * Update a task's schedule rule. An unusable plan (blank or invalid cron, a
+     * one-shot with no future instant, a non-positive run cap) is rejected
+     * (returns false, state untouched). When the rule ends up enabled the next
+     * run instant is computed immediately — a one-shot's next instant IS its
+     * planned instant — and a disabled rule carries none. Delegates the domain
+     * transition to the schedule use case.
      * @param id - the task to schedule.
      * @param patch - fields to change (absent fields keep their current value).
-     * @returns true when applied, false when rejected (invalid cron / unknown task).
+     * @returns true when applied, false when rejected (unknown task / unusable plan).
      */
-    setSchedule(id: string, patch: {
-        enabled?: boolean;
-        cron?: string;
-        timeZone?: string | null;
-    }): boolean;
+    setSchedule(id: string, patch: SetSchedulePatch): boolean;
     /**
      * Legacy pure-controller seam retained for migration-focused tests. The
      * production browser never rolls schedules; the Host ledger owns them.
@@ -360,12 +383,13 @@ export declare class BoardController {
      */
     private mirrorDepth;
     /**
-     * Project a Host snapshot onto the browser's mirror. SSE frames and partial
-     * snapshots carry only the volatile subset (revision/scheduler/power), so the
-     * deployment constants the UI reads — the session-default permission the
-     * confirmation banner compares against and the subtask depth limit — are
-     * carried over from the last full snapshot instead of being dropped by a
-     * heartbeat frame.
+     * Project a Host snapshot onto the browser's mirror. Every snapshot the
+     * transport serves is a full document (bootstrap/state/action all answer
+     * `TaskBoardHostService.snapshot()`), so the deployment constants the UI reads
+     * — the session-default permission the confirmation banner compares against,
+     * the subtask depth limit, the platform switches and the extensions a provider
+     * published — are taken as published, carried over only where the snapshot
+     * itself omits the key.
      */
     private mirrorOf;
     private refreshRemote;

package/lib/types/core/launch-width.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Run-launch admission width: the one bound on how many sessions this board
+ * starts at the same time.
+ *
+ * One board action opens a whole subtree, and a team run hands every member of
+ * it to the Lead at once, so without a bound the Host asks DSH for dozens of
+ * sessions in a single tick. The repository's own measured guidance caps heavy
+ * implementation subagents at three (docs/multi-agent-resources.md) and no
+ * runtime mechanism enforced it; this setting is that mechanism.
+ *
+ * The bounds and the default live here rather than in either half, exactly like
+ * the roster cadence: the settings card validates a draft against the same
+ * range the Host clamps a hand-edited configuration to, and a programmatic
+ * mount that names no width gets the default.
+ *
+ * @module dsh-task-board/core/launch-width
+ */
+/** Width used when neither the settings document nor the mount names one. */
+export declare const DEFAULT_RUN_LAUNCH_WIDTH = 3;
+/** Narrowest accepted width: one launch at a time. */
+export declare const RUN_LAUNCH_WIDTH_MIN = 1;
+/** Widest accepted width. */
+export declare const RUN_LAUNCH_WIDTH_MAX = 16;
+/**
+ * Clamp a configured width into the supported range. A value the schema would
+ * refuse (non-finite, below the floor, above the ceiling) still leaves the
+ * board launching: an out-of-range setting never stalls a run.
+ * @param width - configured width, or undefined for the default.
+ * @returns the effective width.
+ */
+export declare function normalizeRunLaunchWidth(width: number | undefined): number;

package/lib/types/core/poll-cadence.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Roster-poll cadence: the one recurring Host timer the board holds.
+ *
+ * The cadence is a user setting (seconds), so the bounds and the seconds to
+ * milliseconds conversion live here rather than in either half: the settings
+ * card validates a draft against the same range the Host clamps a hand-edited
+ * configuration to, and a programmatic mount that passes no cadence gets the
+ * default.
+ *
+ * @module dsh-task-board/core/poll-cadence
+ */
+/** Cadence used when neither the settings document nor the mount names one. */
+export declare const DEFAULT_SESSION_POLL_SECONDS = 5;
+/** Shortest accepted cadence: a faster poll only burns CPU on the Host. */
+export declare const SESSION_POLL_MIN_SECONDS = 1;
+/** Longest accepted cadence, five minutes. */
+export declare const SESSION_POLL_MAX_SECONDS = 300;
+/**
+ * Clamp a configured cadence into the supported range. A value the schema
+ * would refuse (non-finite, below the floor, above the ceiling) still leaves
+ * the board polling: an out-of-range setting never disables the timer.
+ * @param seconds - configured cadence in seconds, or undefined for the default.
+ * @returns the effective cadence in seconds.
+ */
+export declare function normalizeSessionPollSeconds(seconds: number | undefined): number;
+/**
+ * The cadence in the milliseconds the Host timer face takes.
+ * @param seconds - configured cadence in seconds, or undefined for the default.
+ * @returns the effective cadence in milliseconds.
+ */
+export declare function sessionPollMs(seconds: number | undefined): number;

package/lib/types/core/reasoning-effort.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Which reasoning effort one execution may actually send.
+ *
+ * The rule lives here, in one pure place, so the launch path cannot drift from
+ * what the picker promises: an effort is sent ONLY for the exact model route
+ * whose adapter declares that id. An unsupported value is dropped rather than
+ * passed through — the Host validates the selection against the same
+ * capability (`resolveCallConfig` rejects an unsupported effort) and the whole
+ * model selection would fail with it. An absent effort stays absent: the SDK
+ * then materializes the model's own default, which is exactly what "inherit
+ * the model" means.
+ *
+ * A card that pins a bare model id also gets its provider resolved here: the
+ * session wire contract requires `provider` (ModelSelection), so the catalog is
+ * the only place that can complete the documented `provider/model` or model-id
+ * pin.
+ */
+import type { CatalogModel, ModelCatalogView } from './verification.ts';
+/** One execution route an effort resolves against: `provider/model`, or a bare model id. */
+export interface ReasoningRoute {
+    provider?: string;
+    model: string;
+}
+/** The catalog entry a route names, once the catalog can complete it. */
+export interface DeclaredReasoningRoute {
+    provider: string;
+    model: string;
+    /** The adapter's reasoning metadata; absent when it exposes none. */
+    reasoning?: CatalogModel['reasoning'];
+}
+/** What one card's effort resolves to for one route. */
+export interface ReasoningEffortDecision {
+    /** The effort to send; absent means "send none". */
+    effort?: string;
+    /** The card's own value when it will NOT be sent. */
+    dropped?: string;
+}
+/** Trim one optional effort: blank text means "not set", like every other pinned target. */
+export declare function normalizeReasoningEffort(value: string | undefined): string | undefined;
+/**
+ * Complete one route through the host catalog: a qualified route must match its
+ * provider group, and a bare model id matches the first group carrying it —
+ * which is the provider the request then names.
+ * @param catalog - the host model catalog, when this deployment serves one.
+ * @param route - the route as the card pins it.
+ * @returns the completed route with its reasoning metadata, or undefined when
+ *   the catalog declares no such model.
+ */
+export declare function declaredRoute(catalog: ModelCatalogView | undefined, route: ReasoningRoute): DeclaredReasoningRoute | undefined;
+/**
+ * Resolve the effort one execution sends.
+ * @param requested - the card's stored effort (absent or blank = inherit).
+ * @param catalog - the host model catalog, when this deployment serves one.
+ * @param route - the route the execution will actually run at.
+ * @returns the effort to send, or the dropped value that will not be sent.
+ */
+export declare function resolveReasoningEffort(requested: string | undefined, catalog: ModelCatalogView | undefined, route: ReasoningRoute | undefined): ReasoningEffortDecision;

package/lib/types/core/subtask.d.ts

@@ -76,11 +76,32 @@ export interface ParentLinkCheck {
 export declare function checkParentLink(tasks: readonly TaskRecord[], childId: string, parentId: string | null, maxSubtaskDepth: number, lineage?: LineageIndex): ParentLinkCheck;
 /**
  * The tasks one run request opens executions for: the requested task first,
- * then its on-board descendants within the configured depth. Archived tasks
- * never run; a participant that already has an open execution is skipped by
- * the caller, which cannot start it twice.
+ * then its on-board descendants within the configured depth. This is the
+ * SHAPE of a cascade — every walk that must see the whole tree (settlement,
+ * archive/restore, the running lock) reads it. The run path filters it with
+ * {@link joinsCascadeRun}: archived tasks never run, a participant that already
+ * has an open execution is skipped by the caller, which cannot start it twice,
+ * and a finished descendant is left alone.
  */
 export declare function cascadeTargets(tasks: readonly TaskRecord[], rootId: string, maxSubtaskDepth: number): TaskRecord[];
+/**
+ * Whether a cascade member takes part in a new run.
+ *
+ * The task the user ran is always a member: the request names that card, and
+ * the operator asked for it to run whatever its column says. A descendant does
+ * not join once it sits in the `done` column — its work is finished, so running
+ * the parent again is a run of the parent, never a second execution of work
+ * that is already done. The rule keys on the column alone, so it covers both a
+ * subtask that ran and one an operator moved to done by hand, and it holds for
+ * every trigger: a manual run, a re-run, and a due occurrence of a schedule.
+ * A card whose own schedule is enabled settles back into `todo`, so a scheduled
+ * subtask stays a participant; to make a finished one run again, move it back
+ * to `todo` or run it on its own.
+ * @param task - the candidate member.
+ * @param rootId - the task the run request named.
+ * @returns false when this member is left alone by the run.
+ */
+export declare function joinsCascadeRun(task: TaskRecord, rootId: string): boolean;
 /** One still-open execution belonging to a cascade run group. */
 export interface OpenCascadeChild {
     taskId: string;
@@ -114,11 +135,12 @@ export declare function effectiveTaskPermission(task: TaskRecord): TaskRecord['p
 /**
  * Resolve the execution targets a (sub)task actually runs with: its own value
  * wins, and an unset target inherits the nearest ancestor up to the root.
- * Workspace, agent preset and model inherit the ancestor's PIN only — a
- * handover bundle is a per-card continuation artefact and is never inherited.
- * The permission inherits the ancestor's EFFECTIVE binding, and its human
- * confirmation travels with it, so a subtask of an already-confirmed elevated
- * card is runnable while a subtask's own unconfirmed binding stays gated.
+ * Workspace, agent preset, model and reasoning effort inherit the ancestor's
+ * PIN only — a handover bundle is a per-card continuation artefact and is never
+ * inherited. The permission inherits the ancestor's EFFECTIVE binding, and its
+ * human confirmation travels with it, so a subtask of an already-confirmed
+ * elevated card is runnable while a subtask's own unconfirmed binding stays
+ * gated.
  */
 /**
  * The immutable teammate name for one team-mode member. Teammate names are

package/lib/types/core/tasks.d.ts

@@ -34,8 +34,23 @@ export interface ExecutionRecord {
      * Session id of the DSH session that issued the run/rerun action (issue #6
      * audit origin). Client-asserted, not a trust boundary; absent when the run
      * was triggered by cron (source unknown).
+     *
+     * On an EXTERNAL record (issue #1826) this names the agent that completed the
+     * work outside the Host instead, which is what makes the history readable.
      */
     initiatedBy?: string;
+    /**
+     * True when this outcome was recorded from outside the Host by
+     * `record-external-outcome` rather than observed from a DSH session
+     * (issue #1826).
+     *
+     * The board never manufactures one of these itself: every Host-side path
+     * (`run`, `settle`, cascade folding, restart recovery) writes an execution
+     * without it, so `external` is the single field separating work this Host ran
+     * from work an outside agent reported. Such a record never carries a
+     * `sessionId` and never claims a verdict the Host observed.
+     */
+    external?: boolean;
     /** Freeze instant captured from the card snapshot when the run opened. */
     frozenAt?: number;
     /** Freeze source session captured from the card snapshot when the run opened. */
@@ -76,17 +91,69 @@ export declare const EXECUTION_HISTORY_LIMIT = 20;
  * cannot start a new run while one is still open.
  */
 export declare function retainRecentExecutions(executions: readonly ExecutionRecord[]): ExecutionRecord[];
+/**
+ * How a rule produces its triggers: a recurring cron rule, or one single
+ * planned instant. The distinction is stored rather than inferred so a
+ * one-shot is never represented as a date-restricted cron expression.
+ */
+export type ScheduleMode = 'cron' | 'once';
+/**
+ * Why a due occurrence produced no run, or why a rule stopped on its own.
+ *
+ * These are stable codes, not display text: the board renders them through its
+ * locale dictionary, so the ledger never carries a translated string.
+ */
+export type ScheduleStopReason = 
+/** The single planned instant produced its run. */
+'fired'
+/** The recurring rule reached its run budget. */
+ | 'limit'
+/** The plan has no reachable instant any more (an impossible cron). */
+ | 'no-target'
+/** The instant passed while the board was not running through it. */
+ | 'missed'
+/** The task already had an open execution, so this occurrence was skipped. */
+ | 'busy'
+/** An above-default permission was still unconfirmed, so this occurrence was skipped. */
+ | 'permission'
+/**
+ * A scheduled launch failed before any session existed, so the occurrence
+ * created no execution and its run was refunded rather than spent.
+ */
+ | 'launch-failed';
+/** Every stop reason this build understands; the repair and wire gates share it. */
+export declare const SCHEDULE_STOP_REASONS: readonly ScheduleStopReason[];
 /**
  * A scheduled-run rule attached to a task. The Host scheduler triggers the
  * task when `nextRunAt` is due and persists the rule in the Host ledger.
+ *
+ * A rule is either `cron` (the historical shape: a 5-field expression with an
+ * explicit IANA zone, optionally capped by `maxRuns`) or `once` (one planned
+ * instant, `at`, with an implicit budget of one run). Both modes count the
+ * executions the scheduler actually started in `runCount`; a rule that reaches
+ * its budget stops itself in the ledger (`enabled: false` + `endedReason`)
+ * instead of relying on the execution agent to disable it.
  */
 export interface ScheduleRule {
     /** Whether the schedule is armed. */
     enabled: boolean;
-    /** 5-field cron expression: `分 时 日 月 周`. */
-    cron: string;
     /**
-     * IANA zone the cron wall clock is read in (issue #1722). Absent means the
+     * Which kind of plan this rule carries. A rule loaded from a ledger written
+     * before the field existed normalizes to `cron` (its `cron` is the plan).
+     */
+    mode: ScheduleMode;
+    /**
+     * 5-field cron expression: `分 时 日 月 周`. Present on a `cron` rule and
+     * absent on a `once` rule.
+     */
+    cron?: string;
+    /**
+     * The instant a `once` rule executes (ms epoch). Kept after the run so the
+     * detail view can still show the planned time once the rule has ended.
+     */
+    at?: number;
+    /**
+     * IANA zone the wall clock is read in (issue #1722). Absent means the
      * Host process zone, which is what a rule written before zones were
      * persisted keeps using; the Host stamps its own zone at ledger migration so
      * a later `TZ` change cannot silently move an existing rule.
@@ -96,7 +163,51 @@ export interface ScheduleRule {
     nextRunAt: number | undefined;
     /** Instant of the latest scheduled trigger (ms epoch). */
     lastTriggeredAt: number | undefined;
+    /**
+     * Scheduled executions the Host has created under this rule. This is the
+     * run budget's counter: it counts executions that were successfully opened
+     * (whatever their later outcome), never completions, and a manual run never
+     * touches it. A skipped occurrence (busy / permission / missed / no target)
+     * creates no execution and therefore consumes nothing.
+     */
+    runCount: number;
+    /**
+     * Maximum scheduled executions for a `cron` rule; absent means unlimited
+     * (the historical behavior). A `once` rule has an implicit budget of one and
+     * stores no `maxRuns`.
+     */
+    maxRuns?: number;
+    /** Instant the rule stopped itself (ms epoch); absent while it may still fire. */
+    endedAt?: number;
+    /** Why the rule stopped itself; present with `endedAt`. */
+    endedReason?: ScheduleStopReason;
+    /** Instant of the latest occurrence that produced no run. */
+    skippedAt?: number;
+    /** Why that occurrence produced no run; present with `skippedAt`. */
+    skippedReason?: ScheduleStopReason;
 }
+/**
+ * The rule's total run budget: one for a one-shot, the stored cap for a
+ * recurring rule, and undefined when the rule is unlimited.
+ * @param rule - the schedule rule.
+ * @returns the budget, or undefined for an uncapped rule.
+ */
+export declare function scheduleRunBudget(rule: ScheduleRule): number | undefined;
+/**
+ * Whether a rule has no runs left. The scheduler refuses to open another
+ * execution for an exhausted rule, which is what makes the budget terminal
+ * regardless of restarts or repeated timer fires.
+ * @param rule - the schedule rule.
+ * @returns true when the run budget is spent.
+ */
+export declare function scheduleExhausted(rule: ScheduleRule): boolean;
+/**
+ * The instant a rule plans to fire next, for display, whatever its mode: the
+ * planned `at` of a one-shot, or the stored `nextRunAt` of a recurring rule.
+ * @param rule - the schedule rule.
+ * @returns the planned instant, or undefined when the rule carries none.
+ */
+export declare function schedulePlannedAt(rule: ScheduleRule): number | undefined;
 /**
  * Frozen context snapshot carried by a continuation card (issue #4): the
  * goal/progress/next text (already sanitized by the freeze gates) plus the
@@ -214,6 +325,15 @@ export interface TaskRecord {
      * absent falls back to the host default (agent-default-model).
      */
     model?: string;
+    /**
+     * Reasoning effort pinned for that execution route (an adapter-owned id such
+     * as "high"). Absent (or blank) means INHERIT: the session runs at the
+     * model's own default level, exactly as a card written before the field
+     * existed does. The launch sends the value only when the target model's
+     * adapter declares that exact id, so switching a card to a model without
+     * that level never pushes an invalid selection (see core/reasoning-effort.ts).
+     */
+    reasoningEffort?: string;
     /**
      * Whether later executions continue in the previous execution's session
      * (issue #1419) instead of minting a fresh conversation per run. Absent or
@@ -236,9 +356,11 @@ export interface TaskRecord {
      * armed with the composed execution prompt as its objective. The session then
      * keeps working automatic continuation rounds until the agent marks the goal
      * complete, and this board settles the execution on the goal's own end
-     * instead of at the first turn end. Absent means ON — the option is checked
-     * by default, so only an explicit `false` runs the task as a single plain
-     * turn. A session whose `/goal` command is refused still runs the prompt.
+     * instead of at the first turn end. Absent means OFF — the option is
+     * unchecked by default, so only an explicit `true` joins the goal run and
+     * every card that never touched it (including every card written before the
+     * field existed) runs one plain turn. A session whose `/goal` command is
+     * refused still runs the prompt.
      */
     goalRun?: boolean;
     /**
@@ -333,13 +455,23 @@ export interface NewTaskInput {
     permission?: TaskPermission;
     /** Optional pinned model for the execution session; absent = host default. */
     model?: string;
+    /** Optional reasoning effort for that model route; empty/absent = the model's own default. */
+    reasoningEffort?: string;
+    /**
+     * Opt in to the deployment's new-card defaults: a target this input leaves
+     * out is filled from the configured default (agent preset, permission, model
+     * and the level bound to that model). Absent means the create stores exactly
+     * what it was given, which is what the extension provider's own create path
+     * and the legacy import rely on.
+     */
+    applyCardDefaults?: boolean;
     /** Reuse the previous execution's session for later runs (issue #1419). */
     reuseSession?: boolean;
     /** Run the subtree as an Agent Team (Team Lead session plus one teammate per direct subtask). */
     teamRun?: boolean;
     /**
-     * Start the execution with dsh's built-in `/goal`. Absent/true keeps the
-     * default (goal run); an explicit false requests a single plain turn.
+     * Start the execution with dsh's built-in `/goal`. Absent means the default
+     * (one plain turn); only an explicit true joins the goal run.
      */
     goalRun?: boolean;
     /**
@@ -348,15 +480,21 @@ export interface NewTaskInput {
      */
     skipVerification?: boolean;
     /**
-     * Optional scheduled-run rule requested at creation time (the new-task
-     * dialog): an enable flag, a 5-field cron expression, and the IANA zone its
-     * wall clock is read in (absent means the Host zone). The create use case
-     * arms it only when enabled and the expression is valid.
+     * Optional scheduling rule requested at creation time (the new-task
+     * dialog): an enable flag, the kind of plan (a recurring 5-field cron
+     * expression, or one planned instant for a one-shot), an optional run cap,
+     * and the IANA zone its wall clock is read in (absent means the Host zone).
+     * The create use case arms it only when enabled and the plan is valid.
      */
     schedule?: {
         enabled: boolean;
-        cron: string;
+        mode?: ScheduleMode;
+        cron?: string;
+        /** Planned instant of a one-shot rule (ms epoch). */
+        at?: number;
         timeZone?: string;
+        /** Run cap of a recurring rule; absent means unlimited. */
+        maxRuns?: number;
     };
     /**
      * Optional frozen context snapshot (goal/progress/next, sanitized by the
@@ -448,7 +586,8 @@ export declare function withStatus(task: TaskRecord, status: TaskStatus, now: nu
  * Merge a schedule patch into a task's schedule rule (creating it when
  * absent), with a fresh updatedAt. Keys present in the patch overwrite the
  * current value — including explicit `undefined`, which clears a field (used
- * to disarm `nextRunAt`); absent keys keep their current value.
+ * to disarm `nextRunAt` or to drop an ended/skip record); absent keys keep
+ * their current value.
  */
 export declare function withSchedule(task: TaskRecord, patch: Partial<ScheduleRule>, now: number): TaskRecord;
 /**
@@ -461,6 +600,16 @@ export declare function startExecution(task: TaskRecord, now: number, executionI
     task: TaskRecord;
     execution: ExecutionRecord;
 };
+/**
+ * The column a settled outcome puts a card in. The ONE derivation shared by
+ * every settlement path (issue #1826): a Host-run execution and an outcome an
+ * outside agent reported both land in the same column from the same rule, so
+ * the column never becomes a second, independent piece of state.
+ @param task - the card being settled.
+ @param outcome - the settled outcome.
+ @returns the status the card shows afterwards.
+ */
+export declare function settledStatus(task: TaskRecord, outcome: ExecutionOutcome): TaskStatus;
 /**
  * Settle a running execution: record the outcome and move the task into the
  * matching column. No-op (returns the input task) when the execution is not

package/lib/types/core/use-cases/task-create.d.ts

@@ -1,3 +1,4 @@
+import { type CardDefaults } from '../card-defaults.ts';
 import { type NewTaskInput, type TaskRecord } from '../tasks.ts';
 /** Result of a create transition: the new task (when accepted) + the next ledger. */
 export interface CreateTaskResult {
@@ -13,15 +14,19 @@ export interface CreateTaskResult {
  * appended ledger, or the unchanged ledger when the title is blank or the
  * requested parent link is refused.
  *
- * A subtask inherits the execution targets its parent already pins (workspace,
- * agent preset, permission, model) unless the form supplied its own; the
- * parent human permission confirmation travels with an inherited permission,
- * so a subtask of an already-confirmed elevated card is runnable at once.
+ * The execution targets resolve through {@link resolveCardTargets}: what the
+ * caller sent wins, then the parent's own pins, then - only when the caller
+ * opted in with `applyCardDefaults` - the deployment's configured new-card
+ * defaults. Without the flag the resolution sees no defaults at all, which is
+ * exactly the inline parent inheritance this path has always applied. The
+ * workspace is not part of that resolution: a subtask still takes the parent's
+ * workspace, and the defaults never name one.
  * @param tasks - current ledger.
  * @param input - raw user input (title/description/prompt + optional schedule/parent).
  * @param now - clock instant (ms epoch).
  * @param id - minted task id.
  * @param maxSubtaskDepth - deployment subtask depth limit.
  * @param hostTimeZone - zone a rule that stores no zone of its own follows.
+ * @param cardDefaults - the deployment's new-card defaults, read live at creation.
  */
-export declare function applyCreateTask(tasks: readonly TaskRecord[], input: NewTaskInput, now: number, id: string, maxSubtaskDepth?: number, hostTimeZone?: string): CreateTaskResult;
+export declare function applyCreateTask(tasks: readonly TaskRecord[], input: NewTaskInput, now: number, id: string, maxSubtaskDepth?: number, hostTimeZone?: string, cardDefaults?: CardDefaults): CreateTaskResult;