comisai 1.0.44 → 1.0.46

package/node_modules/@comis/skills/dist/tools/builtin/terminal-driver/terminal-tmux-backend.js

@@ -1,15 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
  * terminal-tmux-backend -- the THIRD worker backend (node-pty | pipe | tmux),
- * required for milestone-length runs (OPS-05, spec §4.6 "Recovery").
+ * required for milestone-length runs (recovery across a worker/daemon restart).
  *
  * A worker crash loses an in-process (node-pty / pipe) PTY. The tmux backend owns the
  * driven child inside a DETERMINISTICALLY-named tmux session (`comis-<sessionId>`) so the
  * tmux SERVER outlives the worker/daemon: a restart RE-ATTACHES (`tmux has-session` →
  * `tmux attach`) rather than re-creating, and a human can `tmux attach -t comis-<id>` to
  * take over. The deterministic name + has-session-then-attach is the load-bearing survival
- * mechanism (RESEARCH Pitfall 6 — a random/UUID name is un-recoverable and leaks an
- * un-reapable session; T-124-23).
+ * mechanism (a random/UUID name is un-recoverable and leaks an un-reapable session).
  *
  * DRIVABILITY (the read/drive model — corrected 2026-06-16). The backend drives the
  * session by ATTACHING a real **node-pty** running `tmux attach -t comis-<id>`. That pty IS
@@ -24,7 +23,7 @@
  * path. The session is configured `status off` (no chrome in reads) + `prefix None` (no
  * Ctrl-b interception of driven keystrokes) so the attach behaves as a transparent pipe.
  *
- * JAIL NESTING (T-124-24 — no unjailed path). The driven child STILL runs inside the bwrap
+ * JAIL NESTING (no unjailed path). The driven child STILL runs inside the bwrap
  * jail: `attachBackend` hands this backend the already-composed plan command (`{bin,argv}` =
  * `bwrap [scope] -- <child> …`), and the backend runs `tmux new-session -d -s comis-<id> --
  * bwrap [scope] -- <child>`. tmux is the OUTERMOST process by DESIGN (not bwrap): the
@@ -32,7 +31,7 @@
  * wrapper. The attach pty is just a viewing/driving client — the driven child stays jailed
  * inside the tmux session.
  *
- * Architecture invariants (binding — AGENTS.md / 124 house style):
+ * Architecture invariants (binding — AGENTS.md):
  *   - NO module-global mutable state: the per-session attach pty + closure state live inside
  *     the factory — two `createTmuxBackend` instances never share state.
  *   - PURE command builders: `tmuxSessionName` + the `buildTmux*Argv` set are free functions
@@ -41,7 +40,7 @@
  *   - Infra-free + DEPENDENCY-free: value-imports NOTHING (only types). The one-shot tmux
  *     runner AND the attach-pty spawner are INJECTED ({@link TmuxBackendDeps}) so the logic
  *     is provable on macOS without a live tmux server — never `@comis/infra` /
- *     `@comis/observability` (SEC-07; the infra-runtime-scope architecture gate NAMES this file).
+ *     `@comis/observability` (the infra-runtime-scope architecture gate NAMES this file).
  *
  * @module
  */
@@ -49,7 +48,7 @@
  * Derive the DETERMINISTIC tmux session name from a worker sessionId. Stable +
  * recoverable: the same sessionId always maps to `comis-<sessionId>`, so a
  * worker/daemon restart re-attaches by name rather than re-creating under a fresh
- * (un-recoverable) name. This is the OPS-05 survival key (RESEARCH Pitfall 6).
+ * (un-recoverable) name. This is the survival key.
  */
 export function tmuxSessionName(sessionId) {
     return `comis-${sessionId}`;
@@ -58,7 +57,7 @@ export function tmuxSessionName(sessionId) {
 // Pure command builders
 // ---------------------------------------------------------------------------
 /**
- * The `tmux -S <socket> …` prefix shared by EVERY command builder. DUR-01 survival: the
+ * The `tmux -S <socket> …` prefix shared by EVERY command builder. Survival: the
  * socket MUST be an explicit, STABLE path under the data dir — NOT tmux's default
  * `$TMUX_TMPDIR|/tmp/tmux-<uid>/default`. systemd `PrivateTmp=yes` gives each daemon START
  * a FRESH private /tmp, so a /tmp socket is UNREACHABLE from the restarted daemon and
@@ -122,7 +121,7 @@ export function buildTmuxSetOptionArgv(opts) {
     return [...tmuxSocketHead(opts.tmuxPath, opts.socketPath), "set-option", "-t", opts.name, opts.option, opts.value];
 }
 /**
- * Create a tmux backend handle for a session. On construction it makes the OPS-05 survival
+ * Create a tmux backend handle for a session. On construction it makes the survival
  * decision ONCE: `hasSession(comis-<id>)` ? ATTACH (the session survived a restart) : CREATE
  * (`new-session -d`) then ATTACH. It configures the session for transparent driving
  * (`status off` + `prefix None`), then spawns the node-pty `tmux attach` that IS the
@@ -132,19 +131,19 @@ export function buildTmuxSetOptionArgv(opts) {
  * NEVER an unconditional `new-session`: re-creating an existing session would discard the
  * surviving session's state (the whole point of tmux survival).
  *
- * BL-01 (165-REVIEW): with `forceAttachOnly:true` (the recover-on-boot re-attach path) a
+ * With `forceAttachOnly:true` (the recover-on-boot re-attach path) a
  * GONE session (`hasSession` false) returns `undefined` instead of creating — the caller
  * (the worker's `reattach` handler) then replies `ok:false`, NEVER a fresh CLI.
  */
 export function createTmuxBackend(deps) {
     const { sessionId, bin, argv, cols, rows, tmuxPath, socketPath, hasSession, runOneShot, spawnAttachPty, forceAttachOnly } = deps;
     const name = tmuxSessionName(sessionId);
-    // The OPS-05 decision (RESEARCH Pitfall 6), made ONCE at construction.
+    // The survival decision, made ONCE at construction.
     const exists = hasSession(name);
     if (!exists) {
-        // BL-01: attach-only (recover-on-boot) + the session is gone → re-attach is impossible.
+        // Attach-only (recover-on-boot) + the session is gone → re-attach is impossible.
         // Return undefined so the worker replies ok:false (the registry flips lost) — NEVER a
-        // fresh new-session (a double-drive, I10).
+        // fresh new-session (a double-drive).
         if (forceAttachOnly === true)
             return undefined;
         // Fresh session: create it DETACHED (the tmux server owns the PTY so it outlives this worker).

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

@@ -1,14 +1,13 @@
 /**
- * Historically the terminal-driver "stub" surface. After Phase 120 the four
- * interaction tools (`send_text` / `send_key` / `wait` / `resize`) were promoted to
- * real factories in `terminal-tools.ts`, leaving `terminal_session_status` as the
- * lone deferred tool. Phase 124-06 promotes `status` too: its real, classifier-backed,
- * owner-scoped implementation lives in `terminal-status-tool.ts` (a new module, so the
- * body does not push `terminal-tools.ts` over the 800-line cap).
+ * The terminal-driver "stub" surface. The four interaction tools (`send_text` /
+ * `send_key` / `wait` / `resize`) are real factories in `terminal-tools.ts`, and
+ * `terminal_session_status` has a real, classifier-backed, owner-scoped implementation
+ * in `terminal-status-tool.ts` (a separate module, so the body does not push
+ * `terminal-tools.ts` over the 800-line cap).
  *
- * This file now re-exports that real factory so the barrel's import path
- * (`./terminal-tools-stubs.js`) and the public surface are unchanged — the lone
- * deferred terminal-driver tool is now fully implemented (no deferred-reject body).
+ * This file re-exports that real factory so the barrel's import path
+ * (`./terminal-tools-stubs.js`) and the public surface are unchanged — every
+ * terminal-driver tool is fully implemented (no deferred-reject body).
  *
  * @module
  */

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

@@ -1,15 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Historically the terminal-driver "stub" surface. After Phase 120 the four
- * interaction tools (`send_text` / `send_key` / `wait` / `resize`) were promoted to
- * real factories in `terminal-tools.ts`, leaving `terminal_session_status` as the
- * lone deferred tool. Phase 124-06 promotes `status` too: its real, classifier-backed,
- * owner-scoped implementation lives in `terminal-status-tool.ts` (a new module, so the
- * body does not push `terminal-tools.ts` over the 800-line cap).
+ * The terminal-driver "stub" surface. The four interaction tools (`send_text` /
+ * `send_key` / `wait` / `resize`) are real factories in `terminal-tools.ts`, and
+ * `terminal_session_status` has a real, classifier-backed, owner-scoped implementation
+ * in `terminal-status-tool.ts` (a separate module, so the body does not push
+ * `terminal-tools.ts` over the 800-line cap).
  *
- * This file now re-exports that real factory so the barrel's import path
- * (`./terminal-tools-stubs.js`) and the public surface are unchanged — the lone
- * deferred terminal-driver tool is now fully implemented (no deferred-reject body).
+ * This file re-exports that real factory so the barrel's import path
+ * (`./terminal-tools-stubs.js`) and the public surface are unchanged — every
+ * terminal-driver tool is fully implemented (no deferred-reject body).
  *
  * @module
  */

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

@@ -1,14 +1,14 @@
 /**
- * The eight terminal-driver AgentTool factories (spec §5): `terminal_session_create` / `_read` /
+ * The eight terminal-driver AgentTool factories: `terminal_session_create` / `_read` /
  * `_list` / `_kill` + `_send_text` / `_send_key` / `_resize` / `_wait` (`terminal_session_status`
  * is the lone stub → `terminal-tools-stubs.ts`). `create` gates the substrate: (1) ALLOWLIST
  * (`matchAllowEntry` rejects a non-matching binary `permission_denied`; realpath + optional hash
  * pin); (2) FAIL-CLOSED (`undefined` `detectProvider()` rejects rather than spawn unsandboxed);
  * (3) CANONICALIZE (`buildDirectSpawn` is the SOLE realpath + `argsPrefix` site); (4) OBSERVABILITY
  * (success → INFO `terminal:session_state`; failure → WARN `terminal:spawn_failed`). The other seven
- * thinly delegate to the injected, ALREADY-GATED registry: `read` digests the screen (READ-01)
+ * thinly delegate to the injected, ALREADY-GATED registry: `read` digests the screen
  * before redact+wrap; `wait`'s `isComplete:false` emits ONE content-free `terminal:drive_promoted`
- * on a qualifying wait (DRIVE-02). Daemon-side in `@comis/skills`: INJECTED logger + bus + `nowMs`.
+ * on a qualifying wait. Daemon-side in `@comis/skills`: INJECTED logger + bus + `nowMs`.
  *
  * @module
  */
@@ -107,13 +107,13 @@ export interface TerminalToolDeps {
     /** The owning agent id — stamped onto every emitted event. */
     readonly agentId: string;
     /**
-     * DRIVE-02 (164-04): the operator-resolved promotion policy (`drive.mode`), supplied by the
+     * The operator-resolved promotion policy (`drive.mode`), supplied by the
      * daemon (`buildTerminalSharedDeps` reads `config.drive.mode`); the skills layer never reads
      * config (layer purity). The wait tool feeds it to `shouldPromoteDrive`. Default `"auto"`.
      */
     readonly driveMode?: DriveMode;
     /**
-     * READ-01 (164-06): the operator-resolved read mode (`drive.readMode`), supplied by the
+     * The operator-resolved read mode (`drive.readMode`), supplied by the
      * daemon like {@link driveMode}. The read tool feeds it to `boundedReadDigest`. Default
      * `"digest"` (the bounded current screen) — `diff`/`full` honored when supplied.
      */
@@ -223,6 +223,6 @@ export declare function createTerminalSessionResizeTool(deps: TerminalToolDeps):
  * `terminal_session_wait` — a bounded in-turn settle on idle/text/exit. Returns the registry
  * `WaitResult` VERBATIM (on timeout the load-bearing `isComplete:false` survives; NEVER
  * coerced), logs DEBUG, and on a qualifying wait (the `shouldPromoteDrive` predicate) emits
- * ONE content-free `terminal:drive_promoted` (DRIVE-02; the daemon dispatcher dedupes to one).
+ * ONE content-free `terminal:drive_promoted` (the daemon dispatcher dedupes to one).
  */
 export declare function createTerminalSessionWaitTool(deps: TerminalToolDeps): AgentTool<typeof WaitParams>;

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

@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * The eight terminal-driver AgentTool factories (spec §5): `terminal_session_create` / `_read` /
+ * The eight terminal-driver AgentTool factories: `terminal_session_create` / `_read` /
  * `_list` / `_kill` + `_send_text` / `_send_key` / `_resize` / `_wait` (`terminal_session_status`
  * is the lone stub → `terminal-tools-stubs.ts`). `create` gates the substrate: (1) ALLOWLIST
  * (`matchAllowEntry` rejects a non-matching binary `permission_denied`; realpath + optional hash
  * pin); (2) FAIL-CLOSED (`undefined` `detectProvider()` rejects rather than spawn unsandboxed);
  * (3) CANONICALIZE (`buildDirectSpawn` is the SOLE realpath + `argsPrefix` site); (4) OBSERVABILITY
  * (success → INFO `terminal:session_state`; failure → WARN `terminal:spawn_failed`). The other seven
- * thinly delegate to the injected, ALREADY-GATED registry: `read` digests the screen (READ-01)
+ * thinly delegate to the injected, ALREADY-GATED registry: `read` digests the screen
  * before redact+wrap; `wait`'s `isComplete:false` emits ONE content-free `terminal:drive_promoted`
- * on a qualifying wait (DRIVE-02). Daemon-side in `@comis/skills`: INJECTED logger + bus + `nowMs`.
+ * on a qualifying wait. Daemon-side in `@comis/skills`: INJECTED logger + bus + `nowMs`.
  *
  * @module
  */
@@ -22,10 +22,10 @@ import { matchAllowEntry, buildDirectSpawn, allowedCommandNames } from "./allowl
 import { enforceSendCapsThenAudit, readDimension } from "./terminal-send-guards.js";
 import { DEFAULT_SCROLLBACK, } from "./terminal-session-registry.js";
 import { withCompleteNote } from "./terminal-wait-reply.js";
-// Defaults (spec §5)
+// Defaults
 const DEFAULT_COLS = 120;
 const DEFAULT_ROWS = 40;
-// Parameter schemas (spec §5 — the final signatures)
+// Parameter schemas (the final signatures)
 const CreateParams = Type.Object({
     allowId: Type.String({ description: "Allowlist entry id to spawn under" }),
     command: Type.String({ description: "The binary to drive (an absolute/relative path; canonical-matched)" }),
@@ -52,7 +52,7 @@ const KillParams = Type.Object({
     sessionId: Type.String({ description: "Session to terminate" }),
     signal: Type.Optional(Type.String({ description: "Signal to send (default SIGTERM)" })),
 });
-// The four interaction-tool schemas (spec §5 — relocated from the stubs file when
+// The four interaction-tool schemas (relocated from the stubs file when
 // these tools became real). The surface is unchanged; only the behaviour landed.
 const SendTextParams = Type.Object({
     sessionId: Type.String({ description: "Session to send text to" }),
@@ -160,7 +160,7 @@ export function createTerminalSessionCreateTool(deps) {
             if (!provider) {
                 throwToolError("permission_denied", "no sandbox provider available; refusing unsandboxed terminal (fail-closed)", { hint: "install a sandbox runtime (e.g. bubblewrap on Linux) so sessions can be confined" });
             }
-            // (2b) CONSENT GATE (§3.7). A high-risk entry (`approveOnCreate`)
+            // (2b) CONSENT GATE. A high-risk entry (`approveOnCreate`)
             // pauses for the OPERATOR — not the prompt-injectable agent — BEFORE any
             // spawn. Mirrors the exec-tool precedent (exec-shared.ts:410-438): identity
             // from tryGetContext() with the documented fallbacks; params are SECRET-FREE
@@ -219,7 +219,7 @@ export function createTerminalSessionCreateTool(deps) {
                     // the workspace + sanitizes project → <agent-workspace>/projects/<slug>, auto-created).
                     ...(cwd !== undefined ? { cwd } : {}),
                     ...(project !== undefined ? { project } : {}),
-                    ...(deps.durable ? { durable: true } : {}), // FINDING-B: drive.durable → req.durable → the registry derives the tmux name + selects the tmux backend.
+                    ...(deps.durable ? { durable: true } : {}), // drive.durable → req.durable → the registry derives the tmux name + selects the tmux backend.
                 }, 
                 // Stamp the origin so this session is visible ONLY to its owner.
                 resolveOwner(deps));
@@ -281,7 +281,7 @@ export function createTerminalSessionReadTool(deps) {
         // 4-arg execute: read is read-only (owner-scoped); the digest bounds the result.
         async execute(_id, params, _signal, _onUpdate) {
             const sessionId = readString(params, "sessionId") ?? "";
-            // Forward the render params to the worker (spec §5 defaults: format=text, scrollback=0,
+            // Forward the render params to the worker (defaults: format=text, scrollback=0,
             // includeAltBuffer=true; the TypeBox closed Union already validated `format`).
             const format = readString(params, "format") ?? "text";
             const scrollback = readInt(params, "scrollback", 0);
@@ -292,11 +292,11 @@ export function createTerminalSessionReadTool(deps) {
                 scrollback,
                 includeAltBuffer,
             });
-            // READ-01: bound the screen to a digest (current screen / changed rows / full) BEFORE
+            // Bound the screen to a digest (current screen / changed rows / full) BEFORE
             // the redact+wrap — an over-cap read is clipped with a truncations breadcrumb, never a
-            // silent trim (I7). digest.screen (not view.screen) flows into the §3.6 defense below.
+            // silent trim. digest.screen (not view.screen) flows into the redact/wrap defense below.
             const digest = boundedReadDigest(view, deps.readMode ?? "digest", READ_DIGEST_BYTE_CAP);
-            // §3.6: the screen is a PROMPT-INJECTION vector. REDACT secret-shaped values FIRST (a
+            // The screen is a PROMPT-INJECTION vector. REDACT secret-shaped values FIRST (a
             // leaked token never reaches the agent/the wrap), THEN wrap as untrusted external content.
             const { text: redacted, redactions } = scrubSecretsFromText(digest.screen);
             const wrappedScreen = wrapExternalContent(redacted, { source: "unknown" });
@@ -459,7 +459,7 @@ export function createTerminalSessionResizeTool(deps) {
  * `terminal_session_wait` — a bounded in-turn settle on idle/text/exit. Returns the registry
  * `WaitResult` VERBATIM (on timeout the load-bearing `isComplete:false` survives; NEVER
  * coerced), logs DEBUG, and on a qualifying wait (the `shouldPromoteDrive` predicate) emits
- * ONE content-free `terminal:drive_promoted` (DRIVE-02; the daemon dispatcher dedupes to one).
+ * ONE content-free `terminal:drive_promoted` (the daemon dispatcher dedupes to one).
  */
 export function createTerminalSessionWaitTool(deps) {
     return {
@@ -491,33 +491,33 @@ export function createTerminalSessionWaitTool(deps) {
                 isComplete: out.isComplete,
                 step: "wait",
             }, "terminal session settle resolved");
-            // DRIVE-02 (164-04): on a qualifying wait, emit ONE content-free terminal:drive_promoted
+            // On a qualifying wait, emit ONE content-free terminal:drive_promoted
             // (the daemon dispatcher dedupes to one notify). `out` is UNCHANGED. The skills layer is
             // STATELESS (emits per-qualifying-wait); the predicate decides, the helper emits. reason
-            // is the WHY enum, never the screen (I3).
-            // DELIVER-02: resolve the EFFECTIVE mode — an explicit `drive.mode` wins; absent, a DURABLE
+            // is the WHY enum, never the screen.
+            // Resolve the EFFECTIVE mode — an explicit `drive.mode` wins; absent, a DURABLE
             // drive (the default long backgrounded drive) → `detached` (promote at the first wait → the
             // backstop tracks it → a completion notification fires when the CLI idles), a pty one-shot →
-            // `auto` (inline, I1). Closes the gap where a short durable build whose wait resolved `idle`
+            // `auto` (inline). Closes the gap where a short durable build whose wait resolved `idle`
             // (claude paused, never a `producing` timeout) never promoted → was untracked → no completion.
             const driveMode = resolveDriveMode(deps.driveMode, deps.durable === true);
-            // LOOP-CLOSURE (webhook-claude-cli-tdd): gate promotion on whether the agent ever DELIVERED a
+            // Gate promotion on whether the agent ever DELIVERED a
             // task to this drive (a delivered send_text since create). A never-tasked detached durable
             // drive must NOT background at its first (gate/idle) wait — that strands a work-less terminal
             // and persists a wake-state that resurrects on the next boot. Owner-scoped read; absent ⇒ false.
             const waitHandle = deps.registry.get(sessionId, owner);
             const everTasked = waitHandle?.everSentText === true;
             if (shouldPromoteDrive(out, driveMode, everTasked)) {
-                emitDrivePromoted({ emit: deps.eventBus.emit.bind(deps.eventBus), info: deps.logger.info.bind(deps.logger), nowMs: deps.nowMs }, sessionId, deps.agentId, // REAL agent, not the userId owner-key — daemon routes journal + drive-owner by agentId (live VPS 260616)
+                emitDrivePromoted({ emit: deps.eventBus.emit.bind(deps.eventBus), info: deps.logger.info.bind(deps.logger), nowMs: deps.nowMs }, sessionId, deps.agentId, // REAL agent, not the userId owner-key — daemon routes journal + drive-owner by agentId
                 driveMode === "detached" ? "mode_detached" : "producing");
             }
-            // LOOP-CLOSURE recovery (webhook-claude-cli-tdd-20260701): the agent is waiting on a LIVE drive
+            // The agent is waiting on a LIVE drive
             // it NEVER tasked (handle exists, no delivered send_text yet) — the dominant flub. Attach a JIT
             // task-not-delivered directive so it delivers the task (or fails honestly) instead of reading the
             // idle result as "nothing to do". A MISSING handle (gone/unknown session) is NOT this case — the
             // gate requires the handle to exist, so a byte-identical result for every non-flub path holds.
             const neverTaskedLiveDrive = waitHandle !== undefined && !everTasked;
-            return jsonResult(withCompleteNote(out, neverTaskedLiveDrive)); // FINDING-3 + loop-closure note (registry `out` unchanged)
+            return jsonResult(withCompleteNote(out, neverTaskedLiveDrive)); // settle-scope + never-tasked note (registry `out` unchanged)
         },
     };
 }

package/node_modules/@comis/skills/dist/tools/builtin/terminal-driver/terminal-wait-reply.d.ts

@@ -5,28 +5,28 @@
  * so the mapping is a TESTED unit. The worker's reply rides an IPC frame and is therefore
  * bug-/attacker-influenceable, so {@link mapWaitReply} validates every field and DEFAULTS
  * oddities to the safe not-complete shape — it NEVER coerces `isComplete` to `true` (a
- * false `true` would convince the P5 attention model the work is done and strand a live
- * session). T1.1: it passes the `producing` diagnostic + the branched `hint` THROUGH so a
+ * false `true` would convince the attention model the work is done and strand a live
+ * session). It passes the `producing` diagnostic + the branched `hint` THROUGH so a
  * not-complete timeout explains itself to the caller instead of reading as a failure.
  *
  * @module
  */
 import type { SettleResult } from "./terminal-settle.js";
 /**
- * The settle snapshot returned by `wait` (spec §5) — the `{matched,isComplete,reason}`
- * core + the post-settle `{screen,cursor}` view + the T1.1 diagnostics.
+ * The settle snapshot returned by `wait` — the `{matched,isComplete,reason}`
+ * core + the post-settle `{screen,cursor}` view + the not-complete-timeout diagnostics.
  */
 export interface WaitResult {
     matched: boolean;
     isComplete: boolean;
     reason: SettleResult["reason"];
     /**
-     * T1.1: on a not-complete `reason:"timeout"`, whether the program was STILL producing
+     * On a not-complete `reason:"timeout"`, whether the program was STILL producing
      * output when the budget elapsed (`true` ⇒ keep waiting; `false` ⇒ idle — inspect
      * screen/status). Absent for the complete reasons (idle/text/exit).
      */
     producing?: boolean;
-    /** T1.1: the branched, actionable hint for a not-complete timeout (see `settleHint`). */
+    /** The branched, actionable hint for a not-complete timeout (see `settleHint`). */
     hint?: string;
     screen: string;
     cursor: {
@@ -35,9 +35,9 @@ export interface WaitResult {
     };
 }
 /**
- * FINDING-3 (live VPS 2026-06-17): the driving model OVER-READS a settle-complete wait result's
- * `isComplete:true` as "my whole task is done" and ENDS the turn — dropping later requested steps
- * after a build settles (reproduced: "build X then run /status" → built, then stopped; clean
+ * The driving model can OVER-READ a settle-complete wait result's
+ * `isComplete:true` as "my whole task is done" and END the turn — dropping later requested steps
+ * after a build settles (observed: "build X then run /status" → built, then stopped; clean
  * `finishReason:"stop"`, no cap/abort). `isComplete` is SETTLE-scoped (the driven CLI's output
  * settled), NOT task-scoped. {@link withCompleteNote} attaches this model-facing note on the
  * COMPLETE path so the driver finishes only when the whole request is handled. The registry
@@ -46,27 +46,28 @@ export interface WaitResult {
  */
 export declare const WAIT_COMPLETE_NOTE = "isComplete here means the terminal SETTLED (the driven CLI finished its current output) \u2014 it does NOT mean your overall task is done. If the user's request has remaining steps (more commands, edits, or a follow-up like a slash command), continue with them now; finish only when the whole request is handled.";
 /**
- * LOOP-CLOSURE recovery (webhook-claude-cli-tdd-20260701, `WEBHOOK-CLAUDE-AGENT-DRIVE-RELIABILITY`):
- * the dominant flub is the agent WAITING on a drive it NEVER tasked — it creates the session, clears
- * the trust gate with `send_key`, then `wait`s BEFORE ever `send_text`-ing the task (the SKILL.md §3
- * order violation). The wait resolves idle and the agent reads "nothing to do" → ends the turn or,
- * on an unattended (webhook/cron) origin with no human to prompt it, hallucinates "I don't have a
- * task from you yet". `cb57b96d` stops that never-tasked drive from BACKGROUNDING (no stranded
- * resurrec-able wake-state); this note closes the other half — a JIT, deterministic tool-result
- * directive delivered at the exact mistake site (stronger than the static SKILL.md nudge, which the
- * flub survives) that steers the agent to deliver the task now OR fail honestly. Origin-independent:
- * waiting on an un-tasked drive is always premature. Supersedes {@link WAIT_COMPLETE_NOTE} — a
- * "your task isn't finished" note is moot when no task was ever delivered.
+ * Never-tasked-drive recovery: the dominant flub is the agent WAITING on a drive it
+ * NEVER tasked — it creates the session, clears the trust gate with `send_key`, then
+ * `wait`s BEFORE ever `send_text`-ing the task (the SKILL.md order violation). The wait
+ * resolves idle and the agent reads "nothing to do" → ends the turn or, on an unattended
+ * (webhook/cron) origin with no human to prompt it, hallucinates "I don't have a task
+ * from you yet". A separate guard stops that never-tasked drive from BACKGROUNDING (no
+ * stranded resurrec-able wake-state); this note closes the other half — a JIT,
+ * deterministic tool-result directive delivered at the exact mistake site (stronger than
+ * the static SKILL.md nudge, which the flub survives) that steers the agent to deliver
+ * the task now OR fail honestly. Origin-independent: waiting on an un-tasked drive is
+ * always premature. Supersedes {@link WAIT_COMPLETE_NOTE} — a "your task isn't finished"
+ * note is moot when no task was ever delivered.
  */
 export declare const WAIT_TASK_NOT_DELIVERED_NOTE = "You have NOT delivered a task to this session yet (no send_text since it launched), so waiting will not make progress \u2014 the terminal is idle because it has nothing to do, NOT because your work is finished. Your task is in THIS conversation; do NOT report that you have no task or that the message came through empty. Send the full task now with send_text + Enter, THEN wait/poll to completion. If you genuinely cannot proceed (e.g. the CLI needs re-authentication), report the failure honestly \u2014 never claim a success you did not verify.";
 /**
  * Attach the model-facing wait note. Two guards, in priority order (model-facing JSON only; the
  * registry {@link WaitResult} / daemon contract is UNCHANGED):
- *   1. `neverTaskedLiveDrive` (LOOP-CLOSURE recovery) → {@link WAIT_TASK_NOT_DELIVERED_NOTE}: the
+ *   1. `neverTaskedLiveDrive` → {@link WAIT_TASK_NOT_DELIVERED_NOTE}: the
  *      agent is waiting on a LIVE drive it never tasked — steer it to deliver the task or fail
  *      honestly (supersedes the complete-note). Set only for a drive whose handle exists AND has
  *      `everSentText===false` (a gone/absent handle is NOT this case — see the wait tool).
- *   2. else `isComplete` (FINDING-3 scope guard) → {@link WAIT_COMPLETE_NOTE}: don't over-read a
+ *   2. else `isComplete` (the settle-scope guard) → {@link WAIT_COMPLETE_NOTE}: don't over-read a
  *      SETTLE-complete wait as "task done".
  * A not-complete, tasked result is returned unchanged (the driver keeps waiting). `neverTaskedLiveDrive`
  * defaults `false` so every existing caller is byte-identical to today (only the wait tool passes it).
@@ -76,7 +77,7 @@ export declare function withCompleteNote(out: WaitResult, neverTaskedLiveDrive?:
 };
 /**
  * The honest not-complete shape for a wedged/absent worker — NEVER `isComplete:true`.
- * Carries a T1.1 hint so the caller reads it as "the worker did not reply" (the session
+ * Carries a hint so the caller reads it as "the worker did not reply" (the session
  * may still be running) rather than "the program produced nothing".
  */
 export declare function degradedWaitResult(): WaitResult;

package/node_modules/@comis/skills/dist/tools/builtin/terminal-driver/terminal-wait-reply.js

@@ -6,16 +6,16 @@
  * so the mapping is a TESTED unit. The worker's reply rides an IPC frame and is therefore
  * bug-/attacker-influenceable, so {@link mapWaitReply} validates every field and DEFAULTS
  * oddities to the safe not-complete shape — it NEVER coerces `isComplete` to `true` (a
- * false `true` would convince the P5 attention model the work is done and strand a live
- * session). T1.1: it passes the `producing` diagnostic + the branched `hint` THROUGH so a
+ * false `true` would convince the attention model the work is done and strand a live
+ * session). It passes the `producing` diagnostic + the branched `hint` THROUGH so a
  * not-complete timeout explains itself to the caller instead of reading as a failure.
  *
  * @module
  */
 /**
- * FINDING-3 (live VPS 2026-06-17): the driving model OVER-READS a settle-complete wait result's
- * `isComplete:true` as "my whole task is done" and ENDS the turn — dropping later requested steps
- * after a build settles (reproduced: "build X then run /status" → built, then stopped; clean
+ * The driving model can OVER-READ a settle-complete wait result's
+ * `isComplete:true` as "my whole task is done" and END the turn — dropping later requested steps
+ * after a build settles (observed: "build X then run /status" → built, then stopped; clean
  * `finishReason:"stop"`, no cap/abort). `isComplete` is SETTLE-scoped (the driven CLI's output
  * settled), NOT task-scoped. {@link withCompleteNote} attaches this model-facing note on the
  * COMPLETE path so the driver finishes only when the whole request is handled. The registry
@@ -24,27 +24,28 @@
  */
 export const WAIT_COMPLETE_NOTE = "isComplete here means the terminal SETTLED (the driven CLI finished its current output) — it does NOT mean your overall task is done. If the user's request has remaining steps (more commands, edits, or a follow-up like a slash command), continue with them now; finish only when the whole request is handled.";
 /**
- * LOOP-CLOSURE recovery (webhook-claude-cli-tdd-20260701, `WEBHOOK-CLAUDE-AGENT-DRIVE-RELIABILITY`):
- * the dominant flub is the agent WAITING on a drive it NEVER tasked — it creates the session, clears
- * the trust gate with `send_key`, then `wait`s BEFORE ever `send_text`-ing the task (the SKILL.md §3
- * order violation). The wait resolves idle and the agent reads "nothing to do" → ends the turn or,
- * on an unattended (webhook/cron) origin with no human to prompt it, hallucinates "I don't have a
- * task from you yet". `cb57b96d` stops that never-tasked drive from BACKGROUNDING (no stranded
- * resurrec-able wake-state); this note closes the other half — a JIT, deterministic tool-result
- * directive delivered at the exact mistake site (stronger than the static SKILL.md nudge, which the
- * flub survives) that steers the agent to deliver the task now OR fail honestly. Origin-independent:
- * waiting on an un-tasked drive is always premature. Supersedes {@link WAIT_COMPLETE_NOTE} — a
- * "your task isn't finished" note is moot when no task was ever delivered.
+ * Never-tasked-drive recovery: the dominant flub is the agent WAITING on a drive it
+ * NEVER tasked — it creates the session, clears the trust gate with `send_key`, then
+ * `wait`s BEFORE ever `send_text`-ing the task (the SKILL.md order violation). The wait
+ * resolves idle and the agent reads "nothing to do" → ends the turn or, on an unattended
+ * (webhook/cron) origin with no human to prompt it, hallucinates "I don't have a task
+ * from you yet". A separate guard stops that never-tasked drive from BACKGROUNDING (no
+ * stranded resurrec-able wake-state); this note closes the other half — a JIT,
+ * deterministic tool-result directive delivered at the exact mistake site (stronger than
+ * the static SKILL.md nudge, which the flub survives) that steers the agent to deliver
+ * the task now OR fail honestly. Origin-independent: waiting on an un-tasked drive is
+ * always premature. Supersedes {@link WAIT_COMPLETE_NOTE} — a "your task isn't finished"
+ * note is moot when no task was ever delivered.
  */
 export const WAIT_TASK_NOT_DELIVERED_NOTE = "You have NOT delivered a task to this session yet (no send_text since it launched), so waiting will not make progress — the terminal is idle because it has nothing to do, NOT because your work is finished. Your task is in THIS conversation; do NOT report that you have no task or that the message came through empty. Send the full task now with send_text + Enter, THEN wait/poll to completion. If you genuinely cannot proceed (e.g. the CLI needs re-authentication), report the failure honestly — never claim a success you did not verify.";
 /**
  * Attach the model-facing wait note. Two guards, in priority order (model-facing JSON only; the
  * registry {@link WaitResult} / daemon contract is UNCHANGED):
- *   1. `neverTaskedLiveDrive` (LOOP-CLOSURE recovery) → {@link WAIT_TASK_NOT_DELIVERED_NOTE}: the
+ *   1. `neverTaskedLiveDrive` → {@link WAIT_TASK_NOT_DELIVERED_NOTE}: the
  *      agent is waiting on a LIVE drive it never tasked — steer it to deliver the task or fail
  *      honestly (supersedes the complete-note). Set only for a drive whose handle exists AND has
  *      `everSentText===false` (a gone/absent handle is NOT this case — see the wait tool).
- *   2. else `isComplete` (FINDING-3 scope guard) → {@link WAIT_COMPLETE_NOTE}: don't over-read a
+ *   2. else `isComplete` (the settle-scope guard) → {@link WAIT_COMPLETE_NOTE}: don't over-read a
  *      SETTLE-complete wait as "task done".
  * A not-complete, tasked result is returned unchanged (the driver keeps waiting). `neverTaskedLiveDrive`
  * defaults `false` so every existing caller is byte-identical to today (only the wait tool passes it).
@@ -56,7 +57,7 @@ export function withCompleteNote(out, neverTaskedLiveDrive = false) {
 }
 /**
  * The honest not-complete shape for a wedged/absent worker — NEVER `isComplete:true`.
- * Carries a T1.1 hint so the caller reads it as "the worker did not reply" (the session
+ * Carries a hint so the caller reads it as "the worker did not reply" (the session
  * may still be running) rather than "the program produced nothing".
  */
 export function degradedWaitResult() {

package/node_modules/@comis/skills/dist/tools/builtin/terminal-driver/terminal-worker-backend-attach.d.ts

@@ -1,8 +1,8 @@
 /**
  * terminal-worker-backend-attach -- the worker's PTY-vs-pipe backend-attach glue plus
  * its two exclusive ring/exit primitives, extracted from `terminal-worker-entry.ts` so
- * that file keeps headroom under the 800-line architecture cap before the P5 attention
- * wiring lands (the fd3 emitter call is added to the worker in Wave 2 / 124-05).
+ * that file keeps headroom under the 800-line architecture cap before the attention
+ * wiring lands (the fd3 emitter call is added to the worker later).
  *
  * BEHAVIOR-NEUTRAL: this is pure code movement. {@link attachBackend} performs the EXACT
  * same wiring `handleCreate` did inline (try `loadPty()` → on success wire the node-pty
@@ -35,21 +35,21 @@ interface BackendSpawnPlan {
  * subscribers. The emu write chains onto {@link SessionState.writeFlush} (serialized,
  * @xterm-PARSE-backed) so `handleRead` awaits it before serializing a settled frame.
  *
- * Exported so the worker can hand the SAME primitive to other call sites if needed; in P0 its
+ * Exported so the worker can hand the SAME primitive to other call sites if needed; today its
  * only callers are the backend stream handlers in {@link attachBackend}.
  */
 export declare function appendRing(state: SessionState, chunk: string): void;
 /**
  * Flip a session to not-alive + notify the settle's exit subscribers (onExit half) so a pending
  * `wait`/settle resolves `exit`. ALSO disposes the `listed-hosts` egress materialization ONCE
- * (socket cleanup, 122-06) — nulling the handle first so a second exit signal (close AND error)
+ * (socket cleanup) — nulling the handle first so a second exit signal (close AND error)
  * cannot double-dispose. `logger` is passed in (the worker's injected structural logger) so this
  * module stays infra-free.
  */
 export declare function markExited(state: SessionState, logger: WorkerLogger, exitCode?: number): void;
 /** Explicit dependencies for {@link attachBackend} — the closure locals `handleCreate` used, passed as params (no module-global state, no hidden closure). */
 export interface AttachBackendArgs {
-    /** The composed spawn plan (`{bin,argv,env}`) — the frame's `{bin,argv}` after the 122-06 bwrap composer. */
+    /** The composed spawn plan (`{bin,argv,env}`) — the frame's `{bin,argv}` after the bwrap composer. */
     plan: BackendSpawnPlan;
     /** Terminal columns for the PTY winsize. */
     cols: number;
@@ -57,7 +57,7 @@ export interface AttachBackendArgs {
     rows: number;
     /** The closure-local per-session record this backend feeds (ring + liveness + the `pty`/`pipe` handle). */
     state: SessionState;
-    /** Load node-pty (the worker's injected `deps.loadPty`); a throw → the pipe backend, `degraded` (TR-08). */
+    /** Load node-pty (the worker's injected `deps.loadPty`); a throw → the pipe backend, `degraded`. */
     loadPty: () => PtyModuleLike;
     /** Spawn the pipe-backend child (the worker's resolved `spawnPipe`). */
     spawnPipe: (bin: string, argv: string[], opts: {
@@ -66,14 +66,14 @@ export interface AttachBackendArgs {
     /** Structural worker logger (the worker's injected logger) — threaded to {@link markExited}. */
     logger: WorkerLogger;
     /**
-     * 124-08 (OPS-05): the requested backend off the create frame. `"tmux"` selects the
+     * The requested backend off the create frame. `"tmux"` selects the
      * tmux named-session backend (survival) WHEN {@link loadTmux} is wired; absent/`"pty"`
      * falls to the existing node-pty → pipe path. The daemon threads this from the
-     * allow-entry `backend` field (124-09); until then it is `undefined` (default pty/pipe).
+     * allow-entry `backend` field; until then it is `undefined` (default pty/pipe).
      */
     requestedBackend?: WorkerBackend;
     /**
-     * 124-08 (OPS-05): the tmux-backend loader (the worker's injected `deps.loadTmux`). The
+     * The tmux-backend loader (the worker's injected `deps.loadTmux`). The
      * 3rd option behind the same {@link FakePtyLike} seam as node-pty | pipe. Used ONLY when
      * the create frame requests `backend:"tmux"`; absent ⇒ the request silently falls back to
      * the pty/pipe path (a worker built without the tmux loader cannot drive a tmux session).
@@ -82,7 +82,7 @@ export interface AttachBackendArgs {
     /** The worker sessionId — the tmux backend derives its DETERMINISTIC `comis-<id>` name from it (survival). */
     sessionId: string;
     /**
-     * BL-01 (165-REVIEW): RE-ATTACH ONLY (recover-on-boot). When `true` the tmux branch
+     * RE-ATTACH ONLY (recover-on-boot). When `true` the tmux branch
      * calls {@link TmuxBackendLike.reattach} (attach to an EXISTING session by name; a GONE
      * session yields `undefined` → NOTHING is attached, NEVER a fresh `new-session`) instead
      * of {@link TmuxBackendLike.spawn} — and there is NO pty/pipe fallback (a re-attach with
@@ -91,7 +91,7 @@ export interface AttachBackendArgs {
      * this path (the surviving pane is read, never re-spawned).
      */
     attachOnly?: boolean;
-    /** RECUR-03: on the `attachOnly` re-attach, the surviving session's OWN per-boot `-S` socket
+    /** On the `attachOnly` re-attach, the surviving session's OWN per-boot `-S` socket
      *  (from its descriptor) — forwarded to {@link TmuxBackendLike.reattach} so it targets THAT
      *  server, not this boot's. Absent ⇒ the worker's legacy single-socket default. */
     tmuxSocket?: string;
@@ -109,7 +109,7 @@ export interface AttachBackendArgs {
  *     set `state.pipe`.
  *
  * Returns `true` when a backend was attached (the create path ALWAYS attaches one) and
- * `false` ONLY on the BL-01 `attachOnly` re-attach of a gone session (or no tmux backend)
+ * `false` ONLY on the `attachOnly` re-attach of a gone session (or no tmux backend)
  * — the caller (`handleReattach`) maps `false` to a worker `ok:false` reply.
  */
 export declare function attachBackend(args: AttachBackendArgs): boolean;