@sema-agent/core 7.16.0 → 7.17.1

package/dist/core/task-registry-monitor.d.ts

@@ -1,7 +1,7 @@
 import type { TaskNotificationPayload } from "./task-notification.js";
 import { type RegistryCore, type RegisterMonitorInput, type MonitorTaskHandle, type UnifiedTaskResult } from "./task-registry-shared.js";
 export declare function registerMonitorLane(core: RegistryCore, input: RegisterMonitorInput): string;
-/** RB-239: ONE absorption arithmetic for a monitor poll — env-side-loss accounting
+/** ONE absorption arithmetic for a monitor poll — env-side-loss accounting
  *  (RB-238), the spool roll (registry memory bound) and the completed-line split — shared by the
  *  watcher tick and the stop-time final drain. A hand-copied twin in stopMonitor is how half-fixes
  *  happen: any change to the roll/line rules must reach both consumers through this method. Returns
@@ -12,7 +12,7 @@ export declare function absorbMonitorPollLane(handle: MonitorTaskHandle, v: {
     truncated?: boolean;
     bytesDroppedBeforeCursor?: number;
 }): string[];
-/** RB-239: the swallow-guarded event sink, shared by the watcher's emits and the stop-time drain. */
+/** The swallow-guarded event sink, shared by the watcher's emits and the stop-time drain. */
 export declare function emitMonitorEventLane(handle: MonitorTaskHandle, n: TaskNotificationPayload): void;
 /** The monitor watcher tick loop. Same zombie-proofing discipline as {@link startBashWatcher}
  *  (re-entrancy guard / stop on eviction / stop on vanished shell / stop on a throwing adapter),

package/dist/core/task-registry-shared.d.ts

@@ -22,7 +22,7 @@ export type SemaTaskStatus = "pending" | "running" | "parked" | "completed" | "f
 export type TaskRetrievalStatus = "success" | "not_ready" | "timeout";
 export interface UnifiedTaskOutput {
     task_id: string;
-    /** RB-92 (2026-07-25, red probe): `"unknown"` is a DECLARED member here, not a stray literal. A
+    /** `"unknown"` is a DECLARED member here, not a stray literal. A
      *  not-found lookup has no task kind to report, and the TaskStop envelope's `task_type` is required by
      *  the client schema — so the wrapper was already emitting `"unknown"` while the type said it could
      *  only be a `SemaTaskType`. Declaring it keeps the two honest with each other, and keeps `SemaTaskType`
@@ -40,7 +40,11 @@ export interface UnifiedTaskOutput {
     code?: string;
     /** RB-386② — machine-readable failure code on a FAILED background_agent row's poll
      *  details (the child's TaskResult.errorCode taxonomy — brain codes / `limit.*` / `budget.*` …).
-     *  Additive; absent on non-failed rows, on rows whose failure carried no code, and on other lanes. */
+     *  Additive; absent on non-failed rows, on rows whose failure carried no code, and on other lanes.
+     *  The same key also carries a failed WORKFLOW run's `WorkflowRun.errorCode` (
+     *  `workflow.*` for the orchestration's own refusals / a failed child's terminal code), populated
+     *  by `formatWorkflowRun`: one field name for "why this poll answer is a failure", whichever lane
+     *  minted the failure. */
     errorCode?: string;
     /** RB-386② — retryability verdict for a FAILED background_agent row, derived at settle time by the
      *  same classifier the sync sub-agent report's `error_kind (retryable: …)` line uses. Additive. */
@@ -146,7 +150,7 @@ export interface BackgroundBashTaskHandle extends SemaTaskHandle {
      *  `mirrorFailed` records that at least one append to the advertised output FILE failed — the terminal
      *  frame then discloses the file as incomplete instead of letting the launch receipt's "full output is
      *  appended there" promise stand over a silently partial file. */
-    /** RB-238: `droppedBytes`/`dropUnknown` account ENV-SIDE tail-buffer eviction disclosed by
+    /** `droppedBytes`/`dropUnknown` account ENV-SIDE tail-buffer eviction disclosed by
      *  the poll (`bytesDroppedBeforeCursor`/`truncated`) — a loss upstream of (and distinct from) the
      *  registry's own `rolledChars` memory bound. Bytes counted here never reached the spool at all. */
     spool?: {
@@ -182,7 +186,7 @@ export interface WorkflowTaskHandle extends SemaTaskHandle {
     store?: WorkflowRunStore;
     /** B-1 (live leg) — see {@link RegisterWorkflowInput.originatingSessionId}. */
     originatingSessionId?: string;
-    /** RB-215: design/129 session-lifetime discipline, extended to workflow — the
+    /** Design/129 session-lifetime discipline, extended to workflow — the
      *  ONE background kind that never had it (`background_bash`/`monitor`/`background_agent` all do).
      *  Unlike those three (task-scoped BY DEFAULT, `sessionScoped` an explicit opt-in via
      *  `TaskSpec.backgroundScope`), a workflow is unconditionally session-anchored — `originatingSessionId`
@@ -198,7 +202,7 @@ export interface WorkflowTaskHandle extends SemaTaskHandle {
     sessionScoped?: true;
     /** See {@link RegisterWorkflowInput.onServedTerminal}. Cleared after the single fire. */
     onServedTerminal?: () => void;
-    /** 复审 r2 MAJOR: the bounded return value, captured on the done-hook so the STORE-LESS in-memory lane's
+    /** The bounded return value, captured on the done-hook so the STORE-LESS in-memory lane's
      *  terminal poll can hand it over too (the launch note promises it; without a store there was no result). */
     result?: string;
     /** T2A-8: the failure reason (bounded + redacted), captured on the done-hook's rejection so a store-less
@@ -232,7 +236,7 @@ export interface BackgroundAgentTaskHandle extends SemaTaskHandle {
     type: "background_agent";
     /** design/115 P3: aborting this cancels the child run (TaskStop / parent teardown). */
     abort: AbortController;
-    /** RB-236 — lineage axes, declared (registration always spread them into the handle; readers used
+    /** Lineage axes, declared (registration always spread them into the handle; readers used
      *  to cast). `rootSessionId` feeds {@link canAccess}'s root-session arm; the other two stay
      *  read-only lineage metadata on the live face (no parentSessionId access arm — see the arm's
      *  comment for why). The register side clamps `parentTaskId`. */
@@ -313,7 +317,7 @@ export interface BackgroundAgentTaskHandle extends SemaTaskHandle {
     /** Terminal snapshot (bounded, {@link BG_AGENT_RESULT_MAX} in subagent.ts) — served by TaskOutput
      *  once the child finishes. */
     result?: string;
-    /** RB-205-B: the FULL result (bounded only by the defensive {@link BG_AGENT_RESULT_FULL_MAX} ceiling
+    /** The FULL result (bounded only by the defensive {@link BG_AGENT_RESULT_FULL_MAX} ceiling
      *  in subagent.ts), set ONLY when it differs from `result` — same shape as {@link WorkflowRun.resultFull}
      *  (workflow.ts NH-1). Before this field existed, the settle call sites pre-sliced `child.result` to
      *  ~2-4K chars with no disclosure — clipTaskOutput's own file-pointer/offload-friendly design at the
@@ -350,7 +354,7 @@ export interface BackgroundAgentTaskHandle extends SemaTaskHandle {
      *  overloaded/timeout/network ⇒ true, logic ⇒ false). Stored rather than re-derived so the core
      *  poll lane never has to import the agents-domain classifier (no new domain cycle). */
     errorRetryable?: boolean;
-    /** RB-405 — the coarse classification KIND beside `errorRetryable`
+    /** The coarse classification KIND beside `errorRetryable`
      *  (classifySubagentError's error_kind ∈ rate_limit/overloaded/timeout/network/logic), threaded
      *  from the same settle mint point and stored for the same no-domain-cycle reason as its sibling.
      *  Rendered on the FAILED row's poll TEXT face as the `(error_kind: …, retryable: …)` clause —
@@ -421,7 +425,7 @@ export interface MonitorTaskHandle extends SemaTaskHandle {
     lineBuf: string;
     /** Per-batch monotonic counter → unique notification dedup keys (see task-notification.ts). */
     seq: number;
-    /** RB-334 (CC `PCo`/`TIs` 220:403278-403321): the TWO-LEVEL event-storm control's state.
+    /** The TWO-LEVEL event-storm control's state.
      *  Level 1 = a token bucket (`stormTokens` out of `stormBurst`, refilled one per
      *  `stormRefillIntervalMs`): a batch that cannot consume a token is SUPPRESSED (its lines stay in the
      *  re-readable spool) and counted in `suppressedBatches`; the next batch that DOES consume one first
@@ -452,7 +456,7 @@ export interface MonitorTaskHandle extends SemaTaskHandle {
     deadlineAt?: number;
     timeoutMs?: number;
     watcher?: unknown;
-    /** RB-239: a watcher tick is suspended on its pollBackground await RIGHT NOW. The stop-time
+    /** A watcher tick is suspended on its pollBackground await RIGHT NOW. The stop-time
      *  final drain must skip its own poll then (that in-flight tick already consumed the env cursor — and a
      *  never-resolving adapter must not pin TaskStop). Set/cleared in lockstep with the tick's re-entrancy
      *  guard. */
@@ -486,7 +490,7 @@ export interface MonitorTaskHandle extends SemaTaskHandle {
     /** design/158 S2 — cumulative chars (UTF-16 code units, `string.length`) handed to `store.put`
      *  across every segment this handle has spilled so far (both streams combined) — the per-handle
      *  disk-cap accounting ({@link import("./task-registry-monitor.js")} reads `MONITOR_SPILL_CAP_CHARS`
-     *  against this). RB-396-b: the field used to be named `spillBytesUsed` while the ledger counted
+     *  against this). The field used to be named `spillBytesUsed` while the ledger counted
      *  chars — renamed to the axis it really measures (see the constant's own doc for why chars). */
     spillCharsUsed?: number;
     /** design/158 S2 — the per-handle spill cap (`MONITOR_SPILL_CAP_CHARS`) was reached; further
@@ -518,10 +522,10 @@ export interface RegisterMonitorInput extends TaskAccess {
     timers?: MonitorTimers;
     /** Batch window (ms, default 200): lines arriving within one tick coalesce into one notification. */
     batchWindowMs?: number;
-    /** RB-334: the SUSTAINED batch rate the storm bucket refills at (default 50/min). Exceeding it is
+    /** The SUSTAINED batch rate the storm bucket refills at (default 50/min). Exceeding it is
      *  suppression, not death — see `stormBurst` and MONITOR_STORM_KILL_AFTER_MS. */
     maxBatchesPerMinute?: number;
-    /** RB-334: burst capacity of the storm bucket (default MONITOR_STORM_BURST = CC's 10). */
+    /** Burst capacity of the storm bucket (default MONITOR_STORM_BURST = CC's 10). */
     stormBurst?: number;
     now?: number;
     /** design/158 S2 (RB-364 半) — the offload store a rolled-off spool middle spills to (see
@@ -563,23 +567,23 @@ export declare const MONITOR_BATCH_WINDOW_MS = 200;
 export declare const MONITOR_DEFAULT_TIMEOUT_MS = 300000;
 export declare const MONITOR_MAX_TIMEOUT_MS = 3600000;
 export declare const MONITOR_MAX_BATCHES_PER_MINUTE = 50;
-/** RB-334 (CC `bIs` 220:403421): burst capacity of the storm token bucket — how many batches may fire
+/** Burst capacity of the storm token bucket — how many batches may fire
  *  back-to-back before the SUPPRESSION level engages. CC value, adopted verbatim. */
 export declare const MONITOR_STORM_BURST = 10;
-/** RB-334 (CC `FN_` 220:403423): how long a monitor must stay CONTINUOUSLY over budget before the
+/** How long a monitor must stay CONTINUOUSLY over budget before the
  *  second level (kill) fires. CC value, adopted verbatim. */
 export declare const MONITOR_STORM_KILL_AFTER_MS = 30000;
-/** RB-334 (CC `bdd` 220:403427): the partial-line accumulator bound. sema's `lineBuf` had NO bound —
+/** The partial-line accumulator bound. sema's `lineBuf` had NO bound —
  *  a monitored process emitting megabytes without a single newline grew it without limit (the spool's
  *  own roll never covered it). Keep the TAIL (the newest bytes are the ones a watch is about). */
 export declare const MONITOR_LINE_BUF_CAP = 1048576;
-/** RB-239: the monitor event-result clip, shared by the watcher's batch/terminal emits and
+/** The monitor event-result clip, shared by the watcher's batch/terminal emits and
  *  the stop-time drain emit (one clip, one truncation wording). */
 export declare function clipMonitorEvent(s: string): string;
-/** RB-334 (CC `DCo` leg): per-line clip applied to the `lines[]` a batch carries. Spool untouched. */
+/** Per-line clip applied to the `lines[]` a batch carries. Spool untouched. */
 export declare function clipMonitorLine(s: string): string;
 /**
- * RB-335 (CC `rFs` 220:507725-507743, all six branches verbatim): the ONE terminal-notification summary
+ * The ONE terminal-notification summary
  * HEAD for a background command / monitor watch. Every terminal frame in the bash and monitor lanes
  * composes its summary as `terminalTaskSummary(...)` plus this lane's own honest detail clause — the
  * pre-RB-335 code had six hand-written phrasings whose comment claimed "no CC sample for those faces"
@@ -619,14 +623,14 @@ export declare function rollSpoolText(spool: {
  *  matching the pre-S2 loss shape for whatever is dropped PAST the cap. Exported so the boundary is a
  *  testable contract, not a buried literal.
  *
- *  RB-396-b (回溯复查批, [c209-C] R2 C4① char/byte 同名异轴族): the constant used to be named
+ *  The constant used to be named
  *  `..._BYTES` while the ledger added `dropped.length` — chars, up to ~3× fewer than UTF-8 bytes on
  *  multibyte content. CHARS is the axis kept (name changed, arithmetic untouched) because it is the
  *  offload store family's own coordinate (`InMemoryToolResultStore.maxTotalChars` evicts by
  *  `content.length`; `ToolResultSlice.totalChars`) and the spool's `rolledChars` axis — one unit
  *  end-to-end; a `Buffer.byteLength` ledger here would sit crosswise to the store's own cap. */
 export declare const MONITOR_SPILL_CAP_CHARS: number;
-/** RB-238: fold one poll's env-side-loss disclosure into the spool's account. The env's
+/** Fold one poll's env-side-loss disclosure into the spool's account. The env's
  *  tail buffer evicts its HEAD under pressure (node-execution-env 8MB bound) — those bytes are gone
  *  before any watcher ever saw them, which is a different loss than the registry-side `rolledChars`
  *  middle-drop. `bytesDroppedBeforeCursor` only counts bytes dropped before an unconsumed cursor, so
@@ -645,7 +649,7 @@ export declare function accountDroppedBytes(spool: {
     truncated?: boolean;
     bytesDroppedBeforeCursor?: number;
 }): void;
-/** RB-238 — the POLL-FACE wording for env-side loss (the terminal/event-frame wording is
+/** The POLL-FACE wording for env-side loss (the terminal/event-frame wording is
  *  {@link droppedGapNote}'s; the two faces differ by design and always have). One function so the two
  *  quantified/unquantified branches cannot drift between the three legs that render it: the monitor
  *  re-readable spool, the bash re-readable spool, and the bash blocked wait. Trailing newline included
@@ -686,7 +690,7 @@ export interface SpoolBodyOptions {
     /** A full banner line (own trailing newline) rendered after the drop note, or "". */
     drainNote: string;
 }
-/** RB-238/RB-239/RB-240 — the ONE renderer for a re-readable spool's TaskOutput body,
+/** The ONE renderer for a re-readable spool's TaskOutput body,
  *  shared by the monitor lane (pollMonitorLane) and the bash spool lane (pollBackgroundBash).
  *
  *  Both faces were hand-copied twins carrying three real disclosure bugs' worth of wording (env-side
@@ -700,19 +704,19 @@ export interface SpoolBodyOptions {
  *  wording ("accumulated char(s) dropped from the middle during the blocked wait"), an intentional
  *  divergence — it shares {@link accountDroppedBytes} + {@link spoolDropNote}, not this. */
 export declare function renderSpoolBody(spool: RenderableSpool, opts: SpoolBodyOptions): string;
-/** RB-238: the honesty suffix for frames over a spool with env-side loss. Empty when nothing dropped. */
+/** The honesty suffix for frames over a spool with env-side loss. Empty when nothing dropped. */
 export declare function droppedGapNote(spool: {
     droppedBytes?: number;
     dropUnknown?: true;
 }): string;
-/** RB-238: the event-stream disclosure rides the FIRST batch after a loss is observed (once-latch —
+/** The event-stream disclosure rides the FIRST batch after a loss is observed (once-latch —
  *  a chatty watch must not repeat the note on every batch; terminal frames disclose unconditionally). */
 export declare function firstDropNote(spool: {
     droppedBytes?: number;
     dropUnknown?: true;
     dropNotified?: true;
 }): string;
-/** RB-244: ONE wording for "you stopped nothing" across every already-terminal stop face —
+/** ONE wording for "you stopped nothing" across every already-terminal stop face —
  *  the in-process bash/monitor/agent arms and the durable-row fallback previously split: the durable
  *  arm answered honestly while the in-process arms claimed `Terminated <id>.` over work that finished
  *  (or was killed) on its own. CC 220 refuses the call outright (`Task X is not running (status: …)`,
@@ -781,7 +785,7 @@ export declare function editDistance(a: string, b: string): number;
 /** CC `htr` shape (206:519814-519827): candidates within Levenshtein ≤2 (length-diff ≤2 pre-filter),
  *  best-first; the single best is the "Did you mean" suggestion (`htr(e, keys, 1)[0]`, 206:575196). */
 export declare function closestName(query: string, candidates: Iterable<string>): string | undefined;
-/** Ruled 2026-07-22: DEFAULT-DENY on BOTH axes — the old predicate skipped
+/** DEFAULT-DENY on BOTH axes — the old predicate skipped
  *  a missing axis (owner-less handle = readable by everyone in scope; scope-less handle = readable
  *  across scopes), splitting polarity with `canAccessAgentRecord` and re-opening the session-axis
  *  class cli/server just swept. Registration now REQUIRES both axes ({@link assertOwnership}), so a
@@ -822,7 +826,7 @@ export interface ParkedClaimTicket {
     reservedRev: number;
     row: import("./background-agent-store.js").BackgroundAgentRecord;
 }
-/** P1-3 独立复审第三轮(已修) — sibling of {@link mintCompletionId} for a caller that must compute the
+/** Sibling of {@link mintCompletionId} for a caller that must compute the
  *  value BEFORE it is safe to commit (a CAS not yet known to win): fill-once with an EXTERNALLY-chosen
  *  value instead of generating a fresh one. Exists because `rollbackParkedClaim`'s original fix minted
  *  directly onto the live handle before its durable CAS was confirmed — a losing CAS then left a

package/dist/core/task-registry-shared.js

@@ -2,8 +2,8 @@ import { uuidv7 } from "../internal/harness.js";
 import { summarizeWorkflowRun } from "./workflow-run-store.js";
 import { delimitUntrusted } from "./untrusted-text.js";
 import { boundedRedactedSummary } from "./untrusted-egress.js";
-import { clipWithFilePointer } from "./tool-errors.js";
-import { announceEnvKnob } from "./env-knob-announce.js";
+import { clipWithFilePointer, OUTPUT_BUDGET_MIN_CHARS } from "./tool-errors.js";
+import { resolveEnvBudget } from "./env-budget.js";
 export function mintCompletionId(target) {
     if (target.completionId === undefined)
         target.completionId = uuidv7();
@@ -60,18 +60,8 @@ export function terminalTaskSummary(kind, label, status, exitCode) {
 }
 const TASK_OUTPUT_DEFAULT_CHARS = 32_000;
 export const TASK_OUTPUT_MAX_CHARS = 160_000;
-const TASK_OUTPUT_MIN_CHARS = 512;
 function taskMaxOutputChars() {
-    const rawEnv = process.env.TASK_MAX_OUTPUT_LENGTH;
-    if (rawEnv === undefined || rawEnv.trim() === "")
-        return TASK_OUTPUT_DEFAULT_CHARS;
-    const raw = rawEnv.trim();
-    const n = /^\d+$/.test(raw) ? parseInt(raw, 10) : Number.NaN;
-    if (!Number.isFinite(n) || n <= 0) {
-        announceEnvKnob(`TASK_MAX_OUTPUT_LENGTH=${rawEnv} was ignored — it is not a positive whole number of characters. Using ${TASK_OUTPUT_DEFAULT_CHARS} instead.`);
-        return TASK_OUTPUT_DEFAULT_CHARS;
-    }
-    return Math.min(Math.max(n, TASK_OUTPUT_MIN_CHARS), TASK_OUTPUT_MAX_CHARS);
+    return resolveEnvBudget(process.env.TASK_MAX_OUTPUT_LENGTH, { name: "TASK_MAX_OUTPUT_LENGTH", unit: "characters", default: TASK_OUTPUT_DEFAULT_CHARS, min: OUTPUT_BUDGET_MIN_CHARS, max: TASK_OUTPUT_MAX_CHARS });
 }
 export function clipTaskOutput(s, fullOutputPath) {
     return clipWithFilePointer(s, taskMaxOutputChars(), fullOutputPath);
@@ -269,6 +259,7 @@ export function formatWorkflowRun(run) {
             status: run.status,
             retrieval_status: "success",
             ...(run.completionId !== undefined ? { completionId: run.completionId } : {}),
+            ...(run.errorCode !== undefined ? { errorCode: run.errorCode } : {}),
             details: summary,
         },
     };

package/dist/core/task-registry.d.ts

@@ -53,7 +53,7 @@ export interface TaskPollOptions {
     timeoutMs?: number;
     /** Abort signal — a blocked wait must stop when the tool call is cancelled. */
     signal?: AbortSignal;
-    /** RB-220 — mirrors {@link import("./types.js").TaskSpec.oneShot} (see {@link TaskToolOptions.oneShot}
+    /** Mirrors {@link import("./types.js").TaskSpec.oneShot} (see {@link TaskToolOptions.oneShot}
      *  for the full contract): forwarded to the background_agent lane's still-running poll body so it
      *  does not teach "you will be notified" when this run has no later turn to receive one. */
     oneShot?: boolean;
@@ -88,7 +88,7 @@ export interface TaskToolOptions extends TaskAccess {
      *  historical wording); prepare-task passes the real wiring state. */
     notificationWired?: boolean;
     /**
-     * RB-220 — mirrors {@link import("./types.js").TaskSpec.oneShot}: this run has no later turn for an
+     * Mirrors {@link import("./types.js").TaskSpec.oneShot}: this run has no later turn for an
      * async background notification to land in (a headless `-p` process exits once the turn ends).
      * Threaded into the background_agent lane's non-blocking/blocked-timeout "still running" poll body
      * (see {@link import("./task-registry-agent.js").pollBackgroundAgentLane}), which otherwise taught
@@ -122,7 +122,7 @@ export interface AccessibleTaskRow {
     parentTaskId?: string;
     parentSessionId?: string;
     rootSessionId?: string;
-    /** RB-478 — the row's registration instant (the original spawn time for a first-cycle row): the
+    /** The row's registration instant (the original spawn time for a first-cycle row): the
      *  revive projection needs it so a revive frame's `startedAt` anchors the ROW, not the wake call. */
     createdAt?: number;
 }
@@ -139,11 +139,11 @@ export declare class TaskRegistry {
      *  (cap overflow dropped the watcher; the owner's tasks may still be running — the subscriber must
      *  NOT treat this as quiescence). */
     private bgQuiescenceWatchers;
-    /** RB-463 — one host-callback isolation scope for this registry's five notification seams (reap terminal
+    /** One host-callback isolation scope for this registry's five notification seams (reap terminal
      *  notifier, session-reap hooks, quiescence fire + cap-overflow eviction, terminal-once send). Same swallow
      *  as the five hand-written try/catches it replaced, now counted per site and readable for diagnostics. */
     private readonly notifier;
-    /** RB-473 — the read face for this registry's CONTAINED host-callback failures (site → count).
+    /** The read face for this registry's CONTAINED host-callback failures (site → count).
      *  The registry has no deployment error sink of its own to disclose to (it is process-global,
      *  constructed before any RunnerDeps exists), so readability IS its disclosure grade: a deployment
      *  that suspects a broken observer polls this instead of grepping for silence. Empty on the
@@ -241,7 +241,7 @@ export declare class TaskRegistry {
         agentStore: import("./background-agent-store.js").BackgroundAgentStore;
     }, ticket: ParkedClaimTicket): Promise<boolean>;
     finalizeParkedResume(id: string): void;
-    /** RB-425: `outcome.cycle` names the revive cycle this settle speaks for (absent = 0 = the original
+    /** `outcome.cycle` names the revive cycle this settle speaks for (absent = 0 = the original
      *  spawn cycle). A spawn leg never passes it; a caller that settles by LIFECYCLE AUTHORITY (reap /
      *  session release — "whatever is running under this row dies") passes the row's current cycle. See
      *  {@link settleBackgroundAgentLane} for why a stale stamp must be a no-op. */
@@ -283,7 +283,7 @@ export declare class TaskRegistry {
         suggestion?: string;
     };
     markRetainedContinuation(id: string): void;
-    /** #258 — the row's current stop-cycle counter, read by the spawn lanes right after registering to
+    /** The row's current stop-cycle counter, read by the spawn lanes right after registering to
      *  thread into the child's `RunInternals.cycleSeq`; see {@link backgroundAgentCycleSeqLane}. */
     backgroundAgentCycleSeq(id: string): number | undefined;
     /** Subagent transcript persistence (delegation entry caps) — one delegation tree's ACTIVE
@@ -399,7 +399,7 @@ export declare class TaskRegistry {
      *  watcher/stop lanes mark and read it too); workflow cancellation is out of scope. */
     markStopSource(id: string, source: StopSource): void;
     /**
-     * RB-164 — attribute an ENV-LEVEL blanket sweep before it runs.
+     * Attribute an ENV-LEVEL blanket sweep before it runs.
      *
      * The incident: a user's `run_in_background` Bash died mid-run reporting `stopped-by:"system"` with a
      * zero-byte output file, and diagnosing it took a cross-repo investigation with a timeline argument.

package/dist/core/task-result.d.ts

@@ -35,7 +35,7 @@ import type { NestedUsage } from "./tool-spec.js";
  */
 export type TaskStatus = "completed" | "blocked" | "failed" | "suspended" | "needs_review";
 /**
- * RB-439-a — one remote-workspace lifecycle failure, reported as data on {@link TaskResult.remoteEnvFailures}.
+ * One remote-workspace lifecycle failure, reported as data on {@link TaskResult.remoteEnvFailures}.
  * See that field for why the eleven-code taxonomy needed a structured channel to reach a caller at all.
  */
 export interface RemoteEnvFailureNote {
@@ -127,7 +127,7 @@ export type EffectiveMemoryScopes = {
 export interface TaskResult {
     taskId: string;
     /**
-     * #499 — the ENGINE-minted identity of THIS run (uuidv7), minted once at the top of prepare and
+     * The ENGINE-minted identity of THIS run (uuidv7), minted once at the top of prepare and
      * never rewritten. The third id of the trio, and the only one the engine owns:
      *  - {@link taskId} — the HOST's task identity, or (when the host named none) the session id: it is
      *    `spec.taskId ?? sessionId` and therefore answers the SAME value for every run of one session;
@@ -168,7 +168,7 @@ export interface TaskResult {
      *  requested ref. A mid-run degradation is observed separately (see the degraded-model fields). */
     model?: string;
     /**
-     * #327 — the leg's effective REASONING resolution: the result-face twin of {@link model} for the thinking
+     * The leg's effective REASONING resolution: the result-face twin of {@link model} for the thinking
      * knob. How the requested tier resolved against the serving model's real capability
      * (`requested`/`effective`/`graded`/`clamped`/`format`/`endpoint`, plus `dropped:true` when a
      * non-reasoning model dropped the request entirely — field semantics on
@@ -230,7 +230,7 @@ export interface TaskResult {
      */
     salvagedOutput?: string;
     /**
-     * RB-439-a — the remote-workspace lifecycle failures this run hit, as DATA. The seam declares eleven
+     * The remote-workspace lifecycle failures this run hit, as DATA. The seam declares eleven
      * distinct `RemoteExecutionErrorCode`s, but every one of them used to reach the caller as the same
      * thing: a `suspendVM` refusal was swallowed into the `onError` side channel and the result read
      * `limits.max_turns_exceeded` (identical for a transient auth blip and a permanently-unsupported adapter), while
@@ -430,34 +430,34 @@ export interface TaskResult {
      */
     haltedOnUserRejection?: true;
     /**
-     * design/373 (#504) — present (`true`) exactly when a {@link TaskStream.halt} was ACCEPTED while
-     * this run was live: the person issued the bare user interrupt (the CC Esc form — cut the
-     * in-flight turn, stop at that boundary, wait for their next input). The ruled terminal form is
-     * completed-with-marker, this seat being the marker: `status` is `"completed"` on the ordinary
-     * path (a clean, resumable ending — nothing failed, nothing is suspended, the session continues
-     * via the ordinary next-run front door), and this field is what tells a person-stopped ending
-     * apart from a natural finish — same reading discipline as {@link haltedOnUserRejection}, its
-     * sibling seat ("stopped by the user, awaiting their direction", never "the task finished its
-     * work"). `result` is whatever the model had produced before the halt (possibly empty — a halt
-     * can land before any output; the run then completes empty rather than failing). Pass-through on
-     * EVERY terminal the run still reaches (a halt ACCEPTED first that then raced a real
-     * failure/limit truthfully says a person also stopped it), and — the stated honest window — on
-     * a natural completion the halt arrived too late to prevent (past the loop's final commit
-     * point): the fact reported is the ACCEPTED HALT, and the transcript says how far the model
-     * got. First-writer-wins against the run's abort (the `interrupt()` attribution law, the same
-     * gate): a halt landing AFTER the abort signal already fired neither cut nor stopped anything —
-     * that ending belongs to the abort, and this seat stays ABSENT rather than signing someone
-     * else's stop with the halt caller's name. Absent everywhere else; never `false`.
-     *
-     * design/384 slice 2 (TRANSITIONAL narrowing): a `"suspended"` / `"needs_review"` terminal does
-     * NOT carry this seat even when a halt was accepted — those statuses mean a durable park WON its
-     * race with the halt (the row is committed and redeemable; the run is waiting to continue), and
-     * "stopped by the person" beside "waiting to resume" was a self-contradictory pair. The halt's
-     * own receipt (`{turnCut}`) and the `task.turn_interrupted` notice still stand — a seat WAS cut.
-     * Transitional: once halt-boundary source accounting lands (slice 3), the boundary-CONSUMED
-     * suspension arms flip to signing (a probe pinning today's suppressed shape goes red then, by
-     * design). The pass-through law is untouched for every OTHER terminal: a halt racing a real
-     * failure/limit — including one that outranks a committed park — still signs.
+     * Present (`true`) exactly when a {@link TaskStream.halt}
+     * (the bare user interrupt, the CC Esc form — cut the in-flight turn, stop at that boundary, wait
+     * for the person's next input) was CONSUMED by this run: the engine's own record says the run
+     * ended FOR it. The attribution law, one sentence: signed ⇔ the halt's cut settled a turn (the loop
+     * reported the interrupt settlement it took for the seat the halt aborted — stream shape, batch
+     * shape, or the recovery lane's arms) OR the halt's stop request was among the sources a boundary
+     * consult stopped the loop for (the pre-turn guard that refuses the next turn — the birth-window
+     * halt included — or the post-turn consult). The MINTER states the fact; the result assembly reads
+     * it and never infers causation from the final's shape (a brain minting its own `aborted` final
+     * beside a late halt reads as the failure it is) nor from the verb's acceptance.
+     *
+     * The ruled terminal form is completed-with-marker, this seat being the marker: `status` is
+     * `"completed"` on the ordinary path (a clean, resumable ending — the session continues via the
+     * ordinary next-run front door), and this field is what tells a person-stopped ending apart from a
+     * natural finish — same reading discipline as {@link haltedOnUserRejection}, its sibling seat
+     * ("stopped by the user, awaiting their direction", never "the task finished its work"). `result` is
+     * whatever the model had produced before the halt (possibly empty). Rides EVERY terminal a
+     * consumed halt reaches — a halt whose cut settled a turn and then raced a real failure/limit, or
+     * whose boundary stop coincided with a review/resource park (`needs_review` / `suspended`),
+     * truthfully says a person also stopped it (the slice-2 status-keyed suppression is retired).
+     *
+     * ABSENT (never `false`) whenever the halt was not consumed, however it was answered: a halt
+     * landing after the run's abort already fired (first-writer-wins, the `interrupt()` attribution
+     * law — that ending belongs to the abort); a halt accepted while the run was already ending for its
+     * own reason (a natural completion past the loop's final commit point, a brain's own terminal, a
+     * durable approval park whose commit won the race and whose abort then owned the ending); a
+     * steer-now cut (its stamp is `steer`). In every such case the halt's trace is its verb receipt plus
+     * one `task.halt_unconsumed` notice — the seat is never signed on a guess.
      */
     haltedByUser?: true;
     /**
@@ -475,7 +475,7 @@ export interface TaskResult {
         toolCallId: string;
     }>;
     /**
-     * #481 — HOST-SUPPLIED: the approval plane's report that this leg ended with human approvals still
+     * HOST-SUPPLIED: the approval plane's report that this leg ended with human approvals still
      * OUTSTANDING (the ask identities it is holding, and when the OLDEST of them was created).
      *
      * **Who writes it, and why not the engine.** Core mints no ask identity — an ask id belongs to the
@@ -502,7 +502,7 @@ export interface TaskResult {
         oldestCreatedAtMs: number;
     };
     /**
-     * #485 — HOST-SUPPLIED: how long this leg spent BLOCKED on human approvals, in ms, as the deployment's
+     * HOST-SUPPLIED: how long this leg spent BLOCKED on human approvals, in ms, as the deployment's
      * approval plane measured it. Same writer and same absence contract as {@link pendingApproval}: the
      * approval clock belongs to whoever holds the ask, so the figure is SINGLE-SOURCED there and core neither
      * estimates it nor accumulates it (two sides publishing two numbers for one wait is the drift this seat
@@ -521,7 +521,7 @@ export interface TaskResult {
      */
     approvalWaitedMs?: number;
     /**
-     * #240 (design/199 v1.1) — the READ-face this leg's read surfaces actually judged under, as an
+     * The READ-face this leg's read surfaces actually judged under, as an
      * engine-filled OBSERVATION (never a knob: writing it on a spec does nothing). It is the run's ONE
      * resolved face — the same value the hands toolkit enforced and the delegation carriers rode — with
      * the hands-less resume pin folded in (a row resumed on a hands-less worker still reports the
@@ -543,7 +543,7 @@ export interface TaskResult {
      */
     effectiveReadFace?: import("../tools/fs/read-face.js").ReadFace;
     /**
-     * #240 (design/199 v1.1) — the sensitive-path deny ADDITIONS in force on this leg beyond the
+     * The sensitive-path deny ADDITIONS in force on this leg beyond the
      * built-in table, normalized (deployment ∪ task ∪ checkpoint-frozen seed), as an engine-filled
      * OBSERVATION. "In force" = judged by this leg's own read surfaces where they mounted, and carried
      * to its delegation subtree either way (a hands-less resume leg reports the entries its children
@@ -638,7 +638,7 @@ export interface TaskResult {
         /** The cache-INCLUSIVE prompt total across the task's turns — `promptTokens + cachedTokens +
          *  cacheWriteTokens + cacheWriteTokensLong`, matching OTel `gen_ai.usage.input_tokens`. This is the
          *  quantity cost is computed from, the denominator of `cacheHitRate`, and the figure to use for
-         *  "how much context did this task present" (window/budget views). RB-457-a: `promptTokens` carried
+         *  "how much context did this task present" (window/budget views). `promptTokens` carried
          *  this value up to 2.13.x; it now carries the cache MISS count and this field is its own
          *  accumulator rather than an alias. Optional BY DESIGN, like every usage field on this stats
          *  face: undefined means the gateway reported no usage (and pre-3.0.0 persisted rows never had

package/dist/core/task-spec.d.ts

@@ -447,7 +447,7 @@ export interface TaskSpec {
      */
     toolMaterializeStrategy?: "swap" | "static";
     /**
-     * RB-400-a — the inline-pin counterpart of {@link deferTools} (same wire-name addressing, opposite
+     * The inline-pin counterpart of {@link deferTools} (same wire-name addressing, opposite
      * direction; CC 220 `alwaysLoad` 对位): names listed here are NEVER deferred — not by
      * `ToolSpec.defer`, not by the MCP constant-defer arm (besides the server's own
      * `_meta["anthropic/alwaysLoad"]` declaration this list is the only channel that keeps a chosen
@@ -475,7 +475,7 @@ export interface TaskSpec {
      */
     restoreGatedTools?: string[] | true;
     /**
-     * RB-403 — whether a schema-VALID call on a still-deferred tool runs the real tool directly
+     * Whether a schema-VALID call on a still-deferred tool runs the real tool directly
      * (activating it as a side effect). Default `true`, matching the upstream posture where the
      * defer gate is shape validation, not activation state (a deferred tool called with correct
      * arguments succeeds; activation only controls whether the model has SEEN the schema). Set
@@ -1237,7 +1237,7 @@ export interface TaskSpec {
          */
         todoReminderMode?: "baseline" | "off";
         /**
-         * RB-313 — `tool_search_usage_reminder` (CC 2.1.220 producer `Nop` @608915, renderer @626269): the
+         * `tool_search_usage_reminder` (CC 2.1.220 producer `Nop` @608915, renderer @626269): the
          * REVERSE nudge for delayed tool disclosure. When tools are deferred (design/36), a model that has
          * gone N turns without calling `ToolSearch` and still has unloaded schemas is told they exist and
          * how to load them, so "this capability does not exist, I will build a workaround" stops being the
@@ -1276,7 +1276,7 @@ export interface TaskSpec {
          */
         budgetUsd?: true;
         /**
-         * RB-318 (ruled 2026-08-26) — `total_tokens_reminder` (CC 2.1.245 producer `MPs`, renderer `Oje`):
+         * `total_tokens_reminder` (CC 2.1.245 producer `MPs`, renderer `Oje`):
          * the TOKEN twin of {@link budgetUsd}. One line per collected boundary,
          * `<total_tokens>N tokens left</total_tokens>`, CC-verbatim bytes.
          *
@@ -1312,7 +1312,7 @@ export interface TaskSpec {
          */
         totalTokensReminder?: boolean;
         /**
-         * RB-318 — which arm of the readout, CC 2.1.245's closed set (`off` / `infinite` / `fixed` /
+         * Which arm of the readout, CC 2.1.245's closed set (`off` / `infinite` / `fixed` /
          * `countdown` / `padded-countdown`); absent ⇒ CC's own default `"padded-countdown"`.
          *
          *  - `countdown` — remaining = ceiling − spend, raw.

package/dist/core/task-stream.d.ts

@@ -54,7 +54,7 @@ export interface TaskStream extends AsyncIterable<TaskEvent> {
      *    (the parked leg's `appendPendingSteer` refuses it identically). Re-issue under a fresh id.
      *  - **Bad value ⇒ typed throw** `steering.invalid_content`, never a silent fallback to "no id": the
      *    value domain is the parked leg's (a non-empty string of at most `MAX_STEER_INPUT_ID_CHARS`
-     *    characters, and never the reserved `LEGACY_PENDING_STEER_INPUT_ID`), so one key is accepted or
+     *    characters), so one key is accepted or
      *    refused the same way on both legs. Validated before the liveness check, like the parked leg's.
      *  - **Liveness outranks the key**: once the run's loop-liveness latch has flipped (the same signal
      *    the injection path stops polling on) a replay is refused `steering.not_running` like any other
@@ -349,22 +349,27 @@ export interface TaskStream extends AsyncIterable<TaskEvent> {
      * per-run. AUTHORITY (steer-lane law): holding this stream IS the capability — a deployment
      * relaying this verb owns its own gate (relay IS authorization; it cancels in-flight tool work
      * and ends the run's forward progress). No text ⇒ the `userPromptSubmit` screen has no domain
-     * here (nothing enters the model). Honest window, stated: a halt accepted in the run's last
-     * moments (past the loop's final commit point) finds the run completing naturally — the result
-     * then reports the natural completion WITH the `haltedByUser` seat (the person did press stop
-     * while it finished; the transcript says how far the model got). Typed refusals: the
+     * here (nothing enters the model). The late window, stated: a halt accepted
+     * in the run's last moments (past the loop's final commit point) finds the run completing
+     * naturally — nothing is cut and no boundary stops for it, so the result reports the natural
+     * completion WITHOUT the `haltedByUser` seat and the engine mints `task.halt_unconsumed` (the
+     * verb receipt and that notice are the halt's whole trace; the seat is signed from consumption,
+     * never from acceptance — see {@link TaskResult.haltedByUser}). Typed refusals: the
      * steer-family `steering.not_running` once the task has finished (teardown included); a halt
      * issued BEFORE the run's first prompt polls the same bounded birth window as {@link steer} and
      * then stops the run before its first model turn (an empty, cleanly-halted completed run).
      *
-     * **Receipt tension, stated (design/384 slice 2):** `{turnCut:true}` and the
+     * **Receipt tension, stated:** `{turnCut:true}` and the
      * `task.turn_interrupted` notice assert facts about the CUT — a seat was cut, no new model turn
      * starts — and both stay true even when the gate's durable leg still collects to `suspended`:
-     * a park whose store commit was already in flight (or committed) when the cut landed WINS the
-     * fence race, the row is redeemable, and the result then reads `status:"suspended"` WITHOUT
-     * {@link TaskResult.haltedByUser} (the transitional narrowing documented on that seat). A cut
-     * observed BEFORE the commit makes the park concede instead — no row, no card, and the ordinary
-     * halted ending.
+     * an approval park whose store commit was already in flight (or committed) when the cut landed
+     * WINS the fence race, the row is redeemable, the park's own abort then owns the ending, and the
+     * result reads `status:"suspended"` WITHOUT {@link TaskResult.haltedByUser} — the halt cut a seat
+     * but consumed nothing (no interrupt settlement took its cut, no boundary stopped for it), which
+     * `task.halt_unconsumed` discloses. A cut observed BEFORE the commit makes the park concede
+     * instead — no row, no card, and the ordinary halted ending. A BOUNDARY park (review / resource
+     * slice) beside a consumed halt is the other way round: the terminal is the park's, and the seat
+     * IS signed — a person also stopped it.
      */
     halt(): Promise<{
         turnCut: boolean;

package/dist/core/tool-catalog-entries.d.ts

@@ -32,6 +32,7 @@ export declare const TASK_UPDATE_TOOL_NAME = "TaskUpdate";
 export declare const TASK_LIST_TOOL_NAME = "TaskList";
 export declare const TODO_WRITE_TOOL_NAME = "TodoWrite";
 export declare const REFRESH_MCP_TOOLS_TOOL_NAME = "RefreshMcpTools";
+export declare const ARTIFACT_TOOL_NAME = "Artifact";
 /**
  * Every row. Order is documentation order (hands → delegation → scaffolds → memory → scheduler → host
  * scenarios); nothing reads the order.