comisai 1.0.45 → 1.0.46

package/node_modules/@comis/skills/dist/tools/builtin/terminal-driver/terminal-drive-journal.d.ts

@@ -1,6 +1,5 @@
 /**
- * The pure bounded content-free drive-state journal (DRIVE-01; design §4 Phase B,
- * CONTEXT §7.1.6).
+ * The pure bounded content-free drive-state journal.
  *
  * A *promoted* drive's woken turns are near-stateless: read screen digest + journal →
  * decide → act → update journal. The journal is that drive's CROSS-WAKE MEMORY — a
@@ -12,13 +11,13 @@
  *
  * This module is the SHAPE + the pure (de)serialize/append/trim ONLY. The daemon-side
  * in-memory holder (the closure-local `Map<sessionId, DriveJournal>` the wake dispatcher
- * reads/updates) is plan 06; the durable persistence beside `terminal-workspace.ts` is
- * Phase 165 (DUR-02) — which is exactly why this shape is cleanly serializable now and
+ * reads/updates) and the durable persistence beside `terminal-workspace.ts` live
+ * elsewhere — which is exactly why this shape is cleanly serializable and
  * {@link deserializeJournal} is defensive enough to read a corrupted-after-crash file.
  * NO fs write happens here.
  *
  * The three load-bearing properties:
- *   - BOUNDED (I7, Pitfall 3; MR-03): {@link appendAnswered}/{@link appendStep} oldest-trim
+ *   - BOUNDED: {@link appendAnswered}/{@link appendStep} oldest-trim
  *     at {@link CAP_ANSWERED}/{@link CAP_STEPS} (the array-COUNT bound) AND clip each entry
  *     to {@link TAG_MAX} bytes (the per-entry SIZE bound). An over-cap drop OR an over-size
  *     clamp increments the run-total `truncations` breadcrumb — NEVER a silent unbounded
@@ -27,12 +26,12 @@
  *     hands a multi-kilobyte tag, or a corrupted-after-crash file, is clamped on the way in),
  *     not merely by the live caller passing short tags. After 10_000 appends each array is
  *     still ≤ its cap and each entry ≤ {@link TAG_MAX} bytes.
- *   - CONTENT-FREE (I3): the journal stores enums/ids/counts/durations + normalized
+ *   - CONTENT-FREE: the journal stores enums/ids/counts/durations + normalized
  *     prompt/step TAGS + a (caller-supplied, already-redacted) one-line `lastScreenDigest`
  *     ONLY — never raw TUI bytes, command output, secrets, or keystrokes. The caller (the
- *     woken-turn driver, plan 06) runs `scrubSecretsFromText` before handing a tag/digest
+ *     woken-turn driver) runs `scrubSecretsFromText` before handing a tag/digest
  *     in; this module treats every tag as an OPAQUE short string and never re-expands it.
- *   - TOTAL (de)serialize (the DUR-02 recovery contract): {@link serializeJournal} →
+ *   - TOTAL (de)serialize (the crash-recovery contract): {@link serializeJournal} →
  *     {@link deserializeJournal} round-trips; a malformed/partial persisted object yields
  *     a SAFE default journal and NEVER throws — mirroring the {@link mapWaitReply}
  *     discipline (terminal-wait-reply.ts:60-84): read each field, default oddities to the
@@ -40,9 +39,9 @@
  *
  * `lastClassification` is the SHIPPED classifier state union
  * ({@link ClassifierState}, terminal-classifier.ts:75) — this module does NOT invent a
- * new state (I8).
+ * new state.
  *
- * Architecture invariants (binding — AGENTS.md / 124 house style, mirrors
+ * Architecture invariants (binding — AGENTS.md; mirrors
  * `terminal-loop-guard.ts` / `terminal-dialog-detector.ts`):
  *   - PURE: free functions, NOT a factory. NO module-global mutable state. NO clock/timer
  *     reads — `elapsedMs` is a content-free number the CALLER derives from its own
@@ -69,12 +68,12 @@ export declare const CAP_ANSWERED = 64;
 /**
  * Max retained `stepsTried` tags. Same oldest-trim + breadcrumb discipline as
  * {@link CAP_ANSWERED}. Short enum/tag steps (e.g. `"ran:build"`), never raw command
- * output (I3).
+ * output.
  */
 export declare const CAP_STEPS = 64;
 /**
  * Max BYTE size of a SINGLE stored entry — a tag (`answeredPrompts`/`stepsTried`), the
- * `objective`, or `lastScreenDigest` (MR-03 / I7). The caps above bound the array COUNT;
+ * `objective`, or `lastScreenDigest`. The caps above bound the array COUNT;
  * this bounds the size of EACH entry, so the serialized-journal-size guarantee (the
  * module's "size is a function of the caps" claim) holds REGARDLESS of caller convention
  * — a future caller that hands a multi-kilobyte tag, or a corrupted-after-crash file with
@@ -89,22 +88,22 @@ export declare const TAG_MAX = 256;
 /**
  * A promoted drive's bounded, content-free cross-wake memory. Every field is an
  * enum / id / count / duration / normalized tag / a redacted one-liner — NEVER raw TUI
- * bytes, command output, secrets, or keystrokes (I3). This is the resume substrate
- * Phase 165 (DUR-02) persists durably; keep it cleanly serializable.
+ * bytes, command output, secrets, or keystrokes. This is the resume substrate
+ * the durability layer persists; keep it cleanly serializable.
  */
 export interface DriveJournal {
     /** A short content-free label for the drive (NOT raw TUI bytes). */
     objective: string;
-    /** The last classifier verdict — the SHIPPED state union (I8 — never an invented state). */
+    /** The last classifier verdict — the SHIPPED state union (never an invented state). */
     lastClassification: ClassifierState;
     /**
-     * A REDACTED one-line digest of the last rendered screen (READ-01 / plan 03 produces
-     * it; the caller runs `scrubSecretsFromText` before it lands here). Never the grid.
+     * A REDACTED one-line digest of the last rendered screen (`terminal-read-digest.ts`
+     * produces it; the caller runs `scrubSecretsFromText` before it lands here). Never the grid.
      */
     lastScreenDigest: string;
-    /** Normalized prompt-hashes/tags already answered (no raw prompt text). Capped (I7). */
+    /** Normalized prompt-hashes/tags already answered (no raw prompt text). Capped. */
     answeredPrompts: string[];
-    /** Enum/short-tag steps already tried (no raw command output). Capped (I7). */
+    /** Enum/short-tag steps already tried (no raw command output). Capped. */
     stepsTried: string[];
     /** Total wall-time the drive has run, in ms (a content-free number the caller derives). */
     elapsedMs: number;
@@ -113,9 +112,9 @@ export interface DriveJournal {
     /** Accumulated spend across the drive, in USD. */
     costUsd: number;
     /**
-     * I7 breadcrumb — the run-total count of tag entries dropped by oldest-trim across
-     * BOTH arrays. A non-zero value means the drive exceeded a cap; it is NEVER a silent
-     * drop.
+     * The truncation breadcrumb — the run-total count of tag entries dropped by oldest-trim
+     * across BOTH arrays. A non-zero value means the drive exceeded a cap; it is NEVER a
+     * silent drop.
      */
     truncations: number;
 }
@@ -129,7 +128,7 @@ export declare function emptyJournal(objective: string): DriveJournal;
 /**
  * Append a normalized prompt tag to `answeredPrompts`, oldest-trimming at
  * {@link CAP_ANSWERED} and incrementing `truncations` by the drop count. Returns a NEW
- * journal (immutable). The caller supplies an already-normalized/redacted tag (I3); this
+ * journal (immutable). The caller supplies an already-normalized/redacted tag; this
  * function stores it opaquely and never re-expands it.
  */
 export declare function appendAnswered(j: DriveJournal, promptTag: string): DriveJournal;
@@ -146,14 +145,14 @@ export declare function appendStep(j: DriveJournal, stepTag: string): DriveJourn
  * clone. Never throws.
  */
 export declare function updateJournal(j: DriveJournal, patch: Partial<Pick<DriveJournal, "lastClassification" | "lastScreenDigest" | "elapsedMs" | "interactions" | "costUsd">>): DriveJournal;
-/** Serialize a journal to a JSON string. Pure; no fs write (Phase 165 persists it). */
+/** Serialize a journal to a JSON string. Pure; no fs write (the durability layer persists it). */
 export declare function serializeJournal(j: DriveJournal): string;
 /**
  * Defensively map a persisted/parsed value to a {@link DriveJournal}. Mirrors
  * {@link mapWaitReply}: read each field, DEFAULT oddities to the SAFE value, never throw,
  * never coerce a malformed array to garbage. Accepts either a JSON string (which it
- * parses, defaulting to `{}` on invalid JSON) or an already-parsed value (DUR-02, Phase
- * 165, may hand a parsed object). This is the read-side of the durable resume contract:
+ * parses, defaulting to `{}` on invalid JSON) or an already-parsed value (the durable
+ * recover-on-boot path may hand a parsed object). This is the read-side of the durable resume contract:
  * a corrupted-after-crash journal file yields a safe default journal, never an exception.
  */
 export declare function deserializeJournal(raw: string | unknown): DriveJournal;

package/node_modules/@comis/skills/dist/tools/builtin/terminal-driver/terminal-drive-journal.js

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * The pure bounded content-free drive-state journal (DRIVE-01; design §4 Phase B,
- * CONTEXT §7.1.6).
+ * The pure bounded content-free drive-state journal.
  *
  * A *promoted* drive's woken turns are near-stateless: read screen digest + journal →
  * decide → act → update journal. The journal is that drive's CROSS-WAKE MEMORY — a
@@ -13,13 +12,13 @@
  *
  * This module is the SHAPE + the pure (de)serialize/append/trim ONLY. The daemon-side
  * in-memory holder (the closure-local `Map<sessionId, DriveJournal>` the wake dispatcher
- * reads/updates) is plan 06; the durable persistence beside `terminal-workspace.ts` is
- * Phase 165 (DUR-02) — which is exactly why this shape is cleanly serializable now and
+ * reads/updates) and the durable persistence beside `terminal-workspace.ts` live
+ * elsewhere — which is exactly why this shape is cleanly serializable and
  * {@link deserializeJournal} is defensive enough to read a corrupted-after-crash file.
  * NO fs write happens here.
  *
  * The three load-bearing properties:
- *   - BOUNDED (I7, Pitfall 3; MR-03): {@link appendAnswered}/{@link appendStep} oldest-trim
+ *   - BOUNDED: {@link appendAnswered}/{@link appendStep} oldest-trim
  *     at {@link CAP_ANSWERED}/{@link CAP_STEPS} (the array-COUNT bound) AND clip each entry
  *     to {@link TAG_MAX} bytes (the per-entry SIZE bound). An over-cap drop OR an over-size
  *     clamp increments the run-total `truncations` breadcrumb — NEVER a silent unbounded
@@ -28,12 +27,12 @@
  *     hands a multi-kilobyte tag, or a corrupted-after-crash file, is clamped on the way in),
  *     not merely by the live caller passing short tags. After 10_000 appends each array is
  *     still ≤ its cap and each entry ≤ {@link TAG_MAX} bytes.
- *   - CONTENT-FREE (I3): the journal stores enums/ids/counts/durations + normalized
+ *   - CONTENT-FREE: the journal stores enums/ids/counts/durations + normalized
  *     prompt/step TAGS + a (caller-supplied, already-redacted) one-line `lastScreenDigest`
  *     ONLY — never raw TUI bytes, command output, secrets, or keystrokes. The caller (the
- *     woken-turn driver, plan 06) runs `scrubSecretsFromText` before handing a tag/digest
+ *     woken-turn driver) runs `scrubSecretsFromText` before handing a tag/digest
  *     in; this module treats every tag as an OPAQUE short string and never re-expands it.
- *   - TOTAL (de)serialize (the DUR-02 recovery contract): {@link serializeJournal} →
+ *   - TOTAL (de)serialize (the crash-recovery contract): {@link serializeJournal} →
  *     {@link deserializeJournal} round-trips; a malformed/partial persisted object yields
  *     a SAFE default journal and NEVER throws — mirroring the {@link mapWaitReply}
  *     discipline (terminal-wait-reply.ts:60-84): read each field, default oddities to the
@@ -41,9 +40,9 @@
  *
  * `lastClassification` is the SHIPPED classifier state union
  * ({@link ClassifierState}, terminal-classifier.ts:75) — this module does NOT invent a
- * new state (I8).
+ * new state.
  *
- * Architecture invariants (binding — AGENTS.md / 124 house style, mirrors
+ * Architecture invariants (binding — AGENTS.md; mirrors
  * `terminal-loop-guard.ts` / `terminal-dialog-detector.ts`):
  *   - PURE: free functions, NOT a factory. NO module-global mutable state. NO clock/timer
  *     reads — `elapsedMs` is a content-free number the CALLER derives from its own
@@ -59,7 +58,7 @@
  * @module
  */
 // ---------------------------------------------------------------------------
-// Caps (I7) — documented constants, like terminal-loop-guard's window/max.
+// Caps — documented constants, like terminal-loop-guard's window/max.
 // ---------------------------------------------------------------------------
 /**
  * Max retained `answeredPrompts` tags. Over-cap appends oldest-trim and bump the
@@ -72,12 +71,12 @@ export const CAP_ANSWERED = 64;
 /**
  * Max retained `stepsTried` tags. Same oldest-trim + breadcrumb discipline as
  * {@link CAP_ANSWERED}. Short enum/tag steps (e.g. `"ran:build"`), never raw command
- * output (I3).
+ * output.
  */
 export const CAP_STEPS = 64;
 /**
  * Max BYTE size of a SINGLE stored entry — a tag (`answeredPrompts`/`stepsTried`), the
- * `objective`, or `lastScreenDigest` (MR-03 / I7). The caps above bound the array COUNT;
+ * `objective`, or `lastScreenDigest`. The caps above bound the array COUNT;
  * this bounds the size of EACH entry, so the serialized-journal-size guarantee (the
  * module's "size is a function of the caps" claim) holds REGARDLESS of caller convention
  * — a future caller that hands a multi-kilobyte tag, or a corrupted-after-crash file with
@@ -89,7 +88,7 @@ export const CAP_STEPS = 64;
  * (never a silent full-size keep), mirroring `DIGEST_EXCERPT_MAX` in `terminal-read-digest.ts`.
  */
 export const TAG_MAX = 256;
-/** The safe default classification for a fresh / unreadable journal (I8 — a shipped state). */
+/** The safe default classification for a fresh / unreadable journal (a shipped state). */
 const DEFAULT_CLASSIFICATION = "working";
 /**
  * Clip a string to at most {@link TAG_MAX} BYTES on a UTF-8 char boundary (never a split
@@ -124,7 +123,7 @@ function clipField(value) {
  */
 export function emptyJournal(objective) {
     return {
-        // MR-03: clamp the objective to the per-entry byte bound (a degenerate/over-long
+        // Clamp the objective to the per-entry byte bound (a degenerate/over-long
         // objective cannot blow the serialized-size guarantee).
         objective: clipField(typeof objective === "string" ? objective : ""),
         lastClassification: DEFAULT_CLASSIFICATION,
@@ -139,10 +138,10 @@ export function emptyJournal(objective) {
 }
 /**
  * Append a tag to a capped array, oldest-trimming at `cap` (the COUNT bound) AND clipping
- * the appended tag to {@link TAG_MAX} bytes (the per-entry SIZE bound, MR-03). Returns
+ * the appended tag to {@link TAG_MAX} bytes (the per-entry SIZE bound). Returns
  * `{ next, dropped }` where `dropped` is the count of entries removed by oldest-trim PLUS
  * 1 if the appended tag was byte-clamped — so a clamp, like a drop, lands on the
- * `truncations` breadcrumb (never a silent full-size keep, I7). Pure — never mutates `arr`.
+ * `truncations` breadcrumb (never a silent full-size keep). Pure — never mutates `arr`.
  * Models terminal-loop-guard's bounded ring, but reports the drop/clamp count.
  */
 function appendCapped(arr, tag, cap) {
@@ -159,7 +158,7 @@ function appendCapped(arr, tag, cap) {
 /**
  * Append a normalized prompt tag to `answeredPrompts`, oldest-trimming at
  * {@link CAP_ANSWERED} and incrementing `truncations` by the drop count. Returns a NEW
- * journal (immutable). The caller supplies an already-normalized/redacted tag (I3); this
+ * journal (immutable). The caller supplies an already-normalized/redacted tag; this
  * function stores it opaquely and never re-expands it.
  */
 export function appendAnswered(j, promptTag) {
@@ -185,7 +184,7 @@ export function updateJournal(j, patch) {
     return {
         ...j,
         ...(patch.lastClassification !== undefined ? { lastClassification: patch.lastClassification } : {}),
-        // MR-03: clamp the digest to the per-entry byte bound (the caller hands an ≤80-char
+        // Clamp the digest to the per-entry byte bound (the caller hands an ≤80-char
         // redacted one-liner today; clip a pathological digest so the size guarantee holds).
         ...(typeof patch.lastScreenDigest === "string" ? { lastScreenDigest: clipField(patch.lastScreenDigest) } : {}),
         ...(typeof patch.elapsedMs === "number" ? { elapsedMs: patch.elapsedMs } : {}),
@@ -194,9 +193,9 @@ export function updateJournal(j, patch) {
     };
 }
 // ---------------------------------------------------------------------------
-// (De)serialize (the DUR-02-ready shape) — pure, total, defensive.
+// (De)serialize (the durable-persistence-ready shape) — pure, total, defensive.
 // ---------------------------------------------------------------------------
-/** Serialize a journal to a JSON string. Pure; no fs write (Phase 165 persists it). */
+/** Serialize a journal to a JSON string. Pure; no fs write (the durability layer persists it). */
 export function serializeJournal(j) {
     return JSON.stringify(j);
 }
@@ -207,7 +206,7 @@ function numberOr(v, fallback) {
 /**
  * Read a value as an array of STRINGS, dropping non-string entries (never coerced to
  * `"[object Object]"`), then oldest-trim to `cap` (a corrupted-large persisted array
- * cannot blow the count cap) AND clip each entry to {@link TAG_MAX} bytes (MR-03 — a
+ * cannot blow the count cap) AND clip each entry to {@link TAG_MAX} bytes (a
  * corrupted-after-crash file with long entries cannot blow the per-entry byte bound).
  * A non-array yields `[]`.
  */
@@ -217,7 +216,7 @@ function stringArrayCapped(v, cap) {
     const strings = v.filter((e) => typeof e === "string").map(clipField);
     return strings.length > cap ? strings.slice(strings.length - cap) : strings;
 }
-/** True iff `v` is one of the SHIPPED classifier states (I8). */
+/** True iff `v` is one of the SHIPPED classifier states. */
 function isClassifierState(v) {
     return v === "working" || v === "awaiting-input" || v === "exited" || v === "stuck";
 }
@@ -225,8 +224,8 @@ function isClassifierState(v) {
  * Defensively map a persisted/parsed value to a {@link DriveJournal}. Mirrors
  * {@link mapWaitReply}: read each field, DEFAULT oddities to the SAFE value, never throw,
  * never coerce a malformed array to garbage. Accepts either a JSON string (which it
- * parses, defaulting to `{}` on invalid JSON) or an already-parsed value (DUR-02, Phase
- * 165, may hand a parsed object). This is the read-side of the durable resume contract:
+ * parses, defaulting to `{}` on invalid JSON) or an already-parsed value (the durable
+ * recover-on-boot path may hand a parsed object). This is the read-side of the durable resume contract:
  * a corrupted-after-crash journal file yields a safe default journal, never an exception.
  */
 export function deserializeJournal(raw) {
@@ -244,7 +243,7 @@ export function deserializeJournal(raw) {
         ? parsed
         : {};
     return {
-        // MR-03: clip the scalar string fields too — a corrupted file with a multi-kilobyte
+        // Clip the scalar string fields too — a corrupted file with a multi-kilobyte
         // objective/digest is clamped to the per-entry byte bound on read.
         objective: clipField(typeof r.objective === "string" ? r.objective : ""),
         lastClassification: isClassifierState(r.lastClassification) ? r.lastClassification : DEFAULT_CLASSIFICATION,

package/node_modules/@comis/skills/dist/tools/builtin/terminal-driver/terminal-drive-outcome.d.ts

@@ -1,42 +1,42 @@
 /**
- * The pure NOTIFY-01 wake-outcome map (design §4 Phase D; CONTEXT I4/I6/I9).
+ * The pure wake-outcome map.
  *
  * Two pure decisions over a settled wake + the drive context, lifted out of the
- * woken-turn driver so every I-invariant is RED-pinnable without a live CLI (and the
+ * woken-turn driver so every invariant is pinnable without a live CLI (and the
  * TIGHT-capped wake holder never absorbs the logic):
  *
  *   - {@link decideWakeAction}(classifier, decision) → "escalate" | "answer" | "wait":
- *     the THREE-WAY, in PRIORITY order. The escalate-always SEC-12 gate already won
+ *     the THREE-WAY, in PRIORITY order. The escalate-always gate already won
  *     INSIDE {@link decideAutoAnswer} (terminal-auto-answer.ts) — this fn only READS the
- *     verdict and NEVER re-derives or overrides the gate (I4/I8: the single source of the
- *     SEC-12 gate stays terminal-auto-answer.ts). A safe-pattern `answer` is silent; a
- *     `working`/low-confidence frame waits, never a synthesized outcome (I6).
+ *     verdict and NEVER re-derives or overrides the gate (the single source of the
+ *     escalate-always gate stays terminal-auto-answer.ts). A safe-pattern `answer` is
+ *     silent; a `working`/low-confidence frame waits, never a synthesized outcome.
  *
  *   - {@link mapTerminalOutcome}(i) → "done" | "needs-you" | "failed" | undefined: the
  *     user-facing terminal outcome, in PRIORITY order (failure > escalation > done > the
- *     uninteresting middle). `undefined` = no notification. This is where the `failed`
- *     OUTCOME deferred from Phase 165 LANDS — derived from the SHIPPED `lost` +
- *     unrecoverable-reason / a named cap-eviction (I9), NEVER from a healthy long/quiet
- *     drive, and NEVER a fabricated `done` (I6).
+ *     uninteresting middle). `undefined` = no notification. The `failed`
+ *     OUTCOME is derived from the SHIPPED `lost` +
+ *     unrecoverable-reason / a named cap-eviction, NEVER from a healthy long/quiet
+ *     drive, and NEVER a fabricated `done`.
  *
  * The escalation reason union ({@link EscalationReason}) is the LOCAL closed copy of the
  * daemon-side `terminal:escalated` reason union (events-terminal.ts) — defined here, NOT
  * imported, so this skills sibling stays daemon-free (the skills ↛ daemon boundary).
  *
- * Architecture invariants (binding — AGENTS.md / 124 house style, mirrors the pure
+ * Architecture invariants (binding — AGENTS.md; mirrors the pure
  * siblings `terminal-drive-promote.ts` `shouldPromoteDrive` and `terminal-spend-ceiling.ts`
  * `checkSpendCeiling`):
  *   - PURE: free functions, NOT a factory. NO clock/timer reads, NO module-global mutable
  *     state, NO I/O. A frame/context → a value response.
  *   - TOTAL / NEVER throws: every input (including a degenerate one) yields a value; the
  *     SAFE direction is `wait` / `undefined` — a forged/garbage input never fabricates a
- *     `done` (I6) or a spurious `failed` (I9). Neither mutates its argument.
+ *     `done` or a spurious `failed`. Neither mutates its argument.
  *   - Infra-free: value-imports NOTHING at runtime (no node builtins needed) + type-only
  *     `ClassifierState` / `AutoAnswerDecision` / `EvictReason` — no platform runtime
  *     packages, no observability egress (the globals + infra-runtime-scope gates; this
  *     file names none of them, and worker ↛ infra/observability/daemon).
  *
- * State ownership: these are the DECISION only. The daemon wake-notify wiring (plan 03) is
+ * State ownership: these are the DECISION only. The daemon wake-notify wiring is
  * their first consumer — it derives the outcome at the `onStateChange`/`onEvicted`/escalate
  * seams, gates the non-escalation ones by `drive.notify` ({@link shouldNotifyOutcome}), and
  * emits via the channel seam. No state is held here.
@@ -55,25 +55,26 @@ import type { EvictReason } from "./terminal-reaper.js";
 export type EscalationReason = "destructive" | "approval" | "auth_login" | "loop_detected" | "hop_limit" | "stuck" | "no_safe_match";
 /**
  * The content-free inputs {@link mapTerminalOutcome} reads — all already on the SHIPPED
- * `terminal:*` events (I3 by construction). The daemon wiring (plan 03) assembles these
+ * `terminal:*` events (content-free by construction). The daemon wiring assembles these
  * from the state transition + the auto-answer/escalation verdict + the durable/cap context.
  */
 export interface OutcomeInputs {
-    /** The SHIPPED classifier state (terminal-classifier.ts) — never an invented state (I8). */
+    /** The SHIPPED classifier state (terminal-classifier.ts) — never an invented state. */
     classifier: ClassifierState;
     /**
      * An explicit `terminal_session_wait` completion match (the `WaitResult.reason`
      * `"text"`/`"exit"`) — the high-confidence `done` source SECONDARY to a clean `exited`
-     * transition (A2-resolved: exited is PRIMARY). Absent for a non-matched wait.
+     * transition (exited is PRIMARY). Absent for a non-matched wait.
      */
     waitMatch?: "text" | "exit" | undefined;
-    /** A `needs-you` signal (a `terminal:escalated` reason) — present iff an escalation fired (I4). */
+    /** A `needs-you` signal (a `terminal:escalated` reason) — present iff an escalation fired. */
     escalation?: EscalationReason | undefined;
     /**
-     * Present ONLY for a GENUINE death (I9/I10): a durable-journal-preserved unrecoverable
+     * Present ONLY for a GENUINE death: a durable-journal-preserved unrecoverable
      * `lost` OR a NAMED deliberate cap-eviction. ABSENT for a transient worker-crash
-     * `lost`→respawn (NOT failed) AND for a healthy long/quiet drive (the I9 invariant — a
-     * merely-long/merely-quiet drive never sets `failure`, so it never maps to `failed`).
+     * `lost`→respawn (NOT failed) AND for a healthy long/quiet drive (the no-false-death
+     * invariant — a merely-long/merely-quiet drive never sets `failure`, so it never maps
+     * to `failed`).
      */
     failure?: {
         kind: "unrecoverable";
@@ -84,7 +85,7 @@ export interface OutcomeInputs {
     } | undefined;
 }
 /**
- * Decide the per-wake action — the THREE-WAY, in PRIORITY order (I4 escalate-always already
+ * Decide the per-wake action — the THREE-WAY, in PRIORITY order (escalate-always already
  * enforced INSIDE {@link decideAutoAnswer}; this NEVER weakens or re-derives it).
  *
  * Pure + total — never throws. Reads only the verdict's `action` (the `classifier` is
@@ -93,17 +94,17 @@ export interface OutcomeInputs {
  *
  * @param classifier - The SHIPPED classifier state of the settled frame.
  * @param decision - The verdict from {@link decideAutoAnswer} (escalate-always already won).
- * @returns `"escalate"` (→ needs-you), `"answer"` (silent), or `"wait"` (silent, I6).
+ * @returns `"escalate"` (→ needs-you), `"answer"` (silent), or `"wait"` (silent).
  */
 export declare function decideWakeAction(classifier: ClassifierState, decision: AutoAnswerDecision): "escalate" | "answer" | "wait";
 /**
  * Map a settled wake + the drive context to the user-facing terminal outcome — in PRIORITY
- * order: `failure` (I9) > `escalation` (I4) > `done` (I6) > the uninteresting middle.
+ * order: `failure` > `escalation` > `done` > the uninteresting middle.
  *
  * Pure + total — never throws; a degenerate input yields `undefined` (no notification, the
  * SAFE direction). NEVER fabricates `done` (only a high-confidence `exited` or an explicit
  * `forText`/`forExit` match) and NEVER reports a healthy long/quiet drive as `failed` (a
- * merely-long/quiet drive has no `failure` set → never `failed`, the I9 RED-pin).
+ * merely-long/quiet drive has no `failure` set → never `failed`).
  *
  * @param i - The content-free {@link OutcomeInputs}.
  * @returns `"done"` | `"needs-you"` | `"failed"` | `undefined` (the silent middle).

package/node_modules/@comis/skills/dist/tools/builtin/terminal-driver/terminal-drive-outcome.js

@@ -1,43 +1,43 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * The pure NOTIFY-01 wake-outcome map (design §4 Phase D; CONTEXT I4/I6/I9).
+ * The pure wake-outcome map.
  *
  * Two pure decisions over a settled wake + the drive context, lifted out of the
- * woken-turn driver so every I-invariant is RED-pinnable without a live CLI (and the
+ * woken-turn driver so every invariant is pinnable without a live CLI (and the
  * TIGHT-capped wake holder never absorbs the logic):
  *
  *   - {@link decideWakeAction}(classifier, decision) → "escalate" | "answer" | "wait":
- *     the THREE-WAY, in PRIORITY order. The escalate-always SEC-12 gate already won
+ *     the THREE-WAY, in PRIORITY order. The escalate-always gate already won
  *     INSIDE {@link decideAutoAnswer} (terminal-auto-answer.ts) — this fn only READS the
- *     verdict and NEVER re-derives or overrides the gate (I4/I8: the single source of the
- *     SEC-12 gate stays terminal-auto-answer.ts). A safe-pattern `answer` is silent; a
- *     `working`/low-confidence frame waits, never a synthesized outcome (I6).
+ *     verdict and NEVER re-derives or overrides the gate (the single source of the
+ *     escalate-always gate stays terminal-auto-answer.ts). A safe-pattern `answer` is
+ *     silent; a `working`/low-confidence frame waits, never a synthesized outcome.
  *
  *   - {@link mapTerminalOutcome}(i) → "done" | "needs-you" | "failed" | undefined: the
  *     user-facing terminal outcome, in PRIORITY order (failure > escalation > done > the
- *     uninteresting middle). `undefined` = no notification. This is where the `failed`
- *     OUTCOME deferred from Phase 165 LANDS — derived from the SHIPPED `lost` +
- *     unrecoverable-reason / a named cap-eviction (I9), NEVER from a healthy long/quiet
- *     drive, and NEVER a fabricated `done` (I6).
+ *     uninteresting middle). `undefined` = no notification. The `failed`
+ *     OUTCOME is derived from the SHIPPED `lost` +
+ *     unrecoverable-reason / a named cap-eviction, NEVER from a healthy long/quiet
+ *     drive, and NEVER a fabricated `done`.
  *
  * The escalation reason union ({@link EscalationReason}) is the LOCAL closed copy of the
  * daemon-side `terminal:escalated` reason union (events-terminal.ts) — defined here, NOT
  * imported, so this skills sibling stays daemon-free (the skills ↛ daemon boundary).
  *
- * Architecture invariants (binding — AGENTS.md / 124 house style, mirrors the pure
+ * Architecture invariants (binding — AGENTS.md; mirrors the pure
  * siblings `terminal-drive-promote.ts` `shouldPromoteDrive` and `terminal-spend-ceiling.ts`
  * `checkSpendCeiling`):
  *   - PURE: free functions, NOT a factory. NO clock/timer reads, NO module-global mutable
  *     state, NO I/O. A frame/context → a value response.
  *   - TOTAL / NEVER throws: every input (including a degenerate one) yields a value; the
  *     SAFE direction is `wait` / `undefined` — a forged/garbage input never fabricates a
- *     `done` (I6) or a spurious `failed` (I9). Neither mutates its argument.
+ *     `done` or a spurious `failed`. Neither mutates its argument.
  *   - Infra-free: value-imports NOTHING at runtime (no node builtins needed) + type-only
  *     `ClassifierState` / `AutoAnswerDecision` / `EvictReason` — no platform runtime
  *     packages, no observability egress (the globals + infra-runtime-scope gates; this
  *     file names none of them, and worker ↛ infra/observability/daemon).
  *
- * State ownership: these are the DECISION only. The daemon wake-notify wiring (plan 03) is
+ * State ownership: these are the DECISION only. The daemon wake-notify wiring is
  * their first consumer — it derives the outcome at the `onStateChange`/`onEvicted`/escalate
  * seams, gates the non-escalation ones by `drive.notify` ({@link shouldNotifyOutcome}), and
  * emits via the channel seam. No state is held here.
@@ -45,7 +45,7 @@
  * @module
  */
 /**
- * Decide the per-wake action — the THREE-WAY, in PRIORITY order (I4 escalate-always already
+ * Decide the per-wake action — the THREE-WAY, in PRIORITY order (escalate-always already
  * enforced INSIDE {@link decideAutoAnswer}; this NEVER weakens or re-derives it).
  *
  * Pure + total — never throws. Reads only the verdict's `action` (the `classifier` is
@@ -54,18 +54,18 @@
  *
  * @param classifier - The SHIPPED classifier state of the settled frame.
  * @param decision - The verdict from {@link decideAutoAnswer} (escalate-always already won).
- * @returns `"escalate"` (→ needs-you), `"answer"` (silent), or `"wait"` (silent, I6).
+ * @returns `"escalate"` (→ needs-you), `"answer"` (silent), or `"wait"` (silent).
  */
 export function decideWakeAction(classifier, decision) {
-    // 1. escalate-to-user WINS (I4): the auto-answer policy already ran escalate-always
-    //    FIRST. We only READ the verdict — re-deriving the gate here would risk an I4
-    //    regression (the single source stays terminal-auto-answer.ts, I8).
+    // 1. escalate-to-user WINS: the auto-answer policy already ran escalate-always
+    //    FIRST. We only READ the verdict — re-deriving the gate here would risk weakening
+    //    it (the single source stays terminal-auto-answer.ts).
     if (decision.action === "escalate")
         return "escalate";
     // 2. answer-autonomously-and-silent (a safe operator hintPattern matched).
     if (decision.action === "answer")
         return "answer";
-    // 3. keep-waiting-and-silent (working / low-confidence — never a synthesized outcome, I6).
+    // 3. keep-waiting-and-silent (working / low-confidence — never a synthesized outcome).
     //    `classifier` is intentionally not branched on: a non-escalate/non-answer verdict is
     //    always a wait, whatever the frame state.
     void classifier;
@@ -73,27 +73,27 @@ export function decideWakeAction(classifier, decision) {
 }
 /**
  * Map a settled wake + the drive context to the user-facing terminal outcome — in PRIORITY
- * order: `failure` (I9) > `escalation` (I4) > `done` (I6) > the uninteresting middle.
+ * order: `failure` > `escalation` > `done` > the uninteresting middle.
  *
  * Pure + total — never throws; a degenerate input yields `undefined` (no notification, the
  * SAFE direction). NEVER fabricates `done` (only a high-confidence `exited` or an explicit
  * `forText`/`forExit` match) and NEVER reports a healthy long/quiet drive as `failed` (a
- * merely-long/quiet drive has no `failure` set → never `failed`, the I9 RED-pin).
+ * merely-long/quiet drive has no `failure` set → never `failed`).
  *
  * @param i - The content-free {@link OutcomeInputs}.
  * @returns `"done"` | `"needs-you"` | `"failed"` | `undefined` (the silent middle).
  */
 export function mapTerminalOutcome(i) {
-    // 1. failed: ONLY a genuine death (I9). A merely-long/quiet drive has no `failure` set,
-    //    so it never reaches here with a `failed` — the I9 invariant is structural.
+    // 1. failed: ONLY a genuine death. A merely-long/quiet drive has no `failure` set,
+    //    so it never reaches here with a `failed` — the no-false-death invariant is structural.
     if (i.failure !== undefined)
         return "failed";
-    // 2. needs-you: an escalation IS a terminal outcome (I4) — outranks done, fires even
+    // 2. needs-you: an escalation IS a terminal outcome — outranks done, fires even
     //    under notify:"terminal" (the gate that lets it through "none" is shouldNotifyOutcome).
     if (i.escalation !== undefined)
         return "needs-you";
     // 3. done: ONLY a high-confidence `exited` transition OR an explicit forText/forExit
-    //    match (I6 — never on awaiting-input/working/stuck/medium-confidence).
+    //    match (never on awaiting-input/working/stuck/medium-confidence).
     if (i.classifier === "exited" || i.waitMatch !== undefined)
         return "done";
     // 4. the uninteresting middle (working / awaiting safe-answer / low-confidence) — silent.