@rynx-ai/runtime 0.1.0 → 0.1.9

package/dist/claude/native-hook-main.js

@@ -1,20 +1,9 @@
 #!/usr/bin/env node
-/**
- * Standalone Claude Code hook entrypoint (built to `dist/claude/native-hook-main.js`,
- * invoked as `node native-hook-main.js --bridge-dir <dir> [permission-request]`).
- * Claude spawns it per hook event; it reads the hook payload on stdin and:
- *   - default (observer: SessionStart / Stop / StopFailure) → append it to the
- *     session's `hooks.jsonl` for the forwarder to tail.
- *   - `permission-request` → POST the payload to the daemon and RELAY the
- *     server's verdict JSON to stdout (the `{hookSpecificOutput:{decision:{…}}}`
- *     Claude reads to allow/deny). Blocks until the web user answers (Claude's
- *     hook `timeout` is a day). On any failure it writes nothing → Claude falls
- *     back to its own TUI permission prompt.
- *
- * Dependency-light (native-bridge + node builtins) so the per-event subprocess
- * stays cheap. Never exits non-zero — a crashing hook must not wedge Claude.
- */
-import { readPermissionHookConfig, recordHookEvent } from "./native-bridge.js";
+/** Standalone Claude hook adapter. Observer hooks append framing events; blocking
+ * interaction hooks rendezvous with the runner through the session bridge. */
+import { createHash, randomUUID } from "node:crypto";
+import { claimInteractionResult, recordInteractionAck, recordHookEvent, recordInteractionRequest, removeClaimedInteractionResult, removeInteractionLease, touchInteractionLease, } from "./native-bridge.js";
+import { boundInteractionRequest, redactInteractionResolution, } from "../interactions.js";
 function argValue(argv, flag) {
     const i = argv.indexOf(flag);
     return i >= 0 && i + 1 < argv.length ? argv[i + 1] : undefined;
@@ -25,29 +14,243 @@ async function readStdin() {
         chunks.push(chunk);
     return Buffer.concat(chunks).toString("utf8");
 }
-async function relayPermission(bridgeDir, payload) {
-    const cfg = readPermissionHookConfig(bridgeDir);
-    if (!cfg)
-        return; // no server configured → empty stdout → claude's own TUI prompt
-    const url = `${cfg.serverUrl.replace(/\/+$/, "")}/api/sessions/${encodeURIComponent(cfg.sessionId)}/hooks/permission-request`;
-    try {
-        const resp = await fetch(url, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(payload),
-        });
-        const text = await resp.text();
-        if (resp.ok && text) {
-            await new Promise((resolve) => process.stdout.write(text, () => resolve()));
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function asString(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function interactionId(payload) {
+    // PermissionRequest does not carry a tool_use_id. A per-process nonce keeps
+    // repeated or concurrent identical prompts from collapsing into one bridge id.
+    const invocationId = asString(payload.tool_use_id) ?? randomUUID();
+    const identity = JSON.stringify([
+        payload.session_id,
+        payload.transcript_path,
+        payload.hook_event_name,
+        invocationId,
+        payload.tool_name,
+        payload.tool_input,
+    ]);
+    return `claude_${createHash("sha256").update(identity).digest("hex").slice(0, 32)}`;
+}
+function questionRequest(id, toolInput) {
+    const questions = Array.isArray(toolInput.questions)
+        ? toolInput.questions.map(asRecord).filter((question) => Boolean(question))
+        : [];
+    const fields = questions.map((question, index) => {
+        const options = Array.isArray(question.options)
+            ? question.options.map(asRecord).filter((option) => Boolean(option))
+            : [];
+        const label = asString(question.question) ?? `Question ${index + 1}`;
+        const description = asString(question.header);
+        if (options.length > 0) {
+            return {
+                id: `q${index}`,
+                type: "select",
+                label,
+                ...(description ? { description } : {}),
+                required: true,
+                multiple: question.multiSelect === true,
+                allowOther: true,
+                options: options.map((option) => {
+                    const value = asString(option.label) ?? "";
+                    const optionDescription = asString(option.description);
+                    return {
+                        value,
+                        label: value,
+                        ...(optionDescription ? { description: optionDescription } : {}),
+                    };
+                }),
+            };
+        }
+        return {
+            id: `q${index}`,
+            type: "text",
+            label,
+            ...(description ? { description } : {}),
+            required: true,
+        };
+    });
+    return {
+        interactionId: id,
+        kind: "question",
+        title: questions.length === 1
+            ? asString(questions[0]?.header) ?? "Input required"
+            : "Input required",
+        fields,
+        actions: [{ id: "submit", label: "Submit", style: "primary", requiresAnswers: true }],
+        context: { toolName: "AskUserQuestion" },
+        createdAt: Date.now(),
+    };
+}
+function permissionSuggestions(payload) {
+    return Array.isArray(payload.permission_suggestions)
+        ? payload.permission_suggestions
+            .map(asRecord)
+            .filter((suggestion) => Boolean(suggestion))
+        : [];
+}
+function permissionSuggestionLabel(suggestion, index, total) {
+    const rules = Array.isArray(suggestion.rules)
+        ? suggestion.rules.map(asRecord).filter((rule) => Boolean(rule))
+        : [];
+    const firstRule = rules[0];
+    const toolName = asString(firstRule?.toolName);
+    const ruleContent = asString(firstRule?.ruleContent);
+    const directories = Array.isArray(suggestion.directories)
+        ? suggestion.directories.filter((value) => typeof value === "string" && value.length > 0)
+        : [];
+    const mode = asString(suggestion.mode);
+    let target;
+    if (toolName === "Read")
+        target = ruleContent ? `reading from ${ruleContent}` : "reading files";
+    else if (toolName === "Write")
+        target = ruleContent ? `writing to ${ruleContent}` : "writing files";
+    else if (toolName === "Edit")
+        target = ruleContent ? `editing ${ruleContent}` : "editing files";
+    else if (toolName === "Bash")
+        target = ruleContent ? `running ${ruleContent}` : "running Bash commands";
+    else if (toolName)
+        target = ruleContent ? `using ${toolName}(${ruleContent})` : `using ${toolName}`;
+    else if (directories.length > 0)
+        target = `accessing ${directories[0]}`;
+    else if (mode)
+        target = `using ${mode} permission mode`;
+    else
+        target = "this permission";
+    const extraCount = Math.max(0, rules.length - 1) + Math.max(0, directories.length - 1);
+    const suffix = extraCount > 0 ? ` and ${extraCount} more` : "";
+    const compactTarget = [...`${target}${suffix}`].length > 120
+        ? `${[...`${target}${suffix}`].slice(0, 119).join("")}…`
+        : `${target}${suffix}`;
+    const destination = asString(suggestion.destination);
+    const scope = destination === "session" ? " in this session" : "";
+    const label = `Allow, and don’t ask again for ${compactTarget}${scope}`;
+    return total > 1 ? `${label} (${index + 1})` : label;
+}
+function permissionSuggestionActionId(index) {
+    return `allow_suggestion_${index}`;
+}
+function permissionRequest(id, payload, toolInput) {
+    const toolName = asString(payload.tool_name) ?? "tool";
+    const command = asString(toolInput.command) ?? asString(toolInput.file_path);
+    const cwd = asString(payload.cwd);
+    const suggestions = permissionSuggestions(payload);
+    return {
+        interactionId: id,
+        kind: "permission",
+        title: `Allow ${toolName}?`,
+        fields: [],
+        actions: [
+            { id: "allow", label: "Allow once", style: "primary", requiresAnswers: false },
+            ...suggestions.map((suggestion, index) => ({
+                id: permissionSuggestionActionId(index),
+                label: permissionSuggestionLabel(suggestion, index, suggestions.length),
+                requiresAnswers: false,
+            })),
+            { id: "deny", label: "Deny", style: "danger", requiresAnswers: false },
+        ],
+        context: {
+            toolName,
+            ...(command ? { command } : {}),
+            ...(cwd ? { cwd } : {}),
+        },
+        createdAt: Date.now(),
+    };
+}
+async function waitForResult(bridgeDir, id) {
+    let lastLeaseAt = 0;
+    for (;;) {
+        const now = Date.now();
+        if (now - lastLeaseAt >= 1_000) {
+            touchInteractionLease(bridgeDir, id);
+            lastLeaseAt = now;
         }
+        const result = claimInteractionResult(bridgeDir, id);
+        if (result)
+            return result;
+        await new Promise((resolve) => setTimeout(resolve, 100));
     }
-    catch {
-        // Server unreachable / hung → empty stdout → claude falls back to its TUI prompt.
+}
+function answerText(value) {
+    return Array.isArray(value) ? value.join(", ") : value ?? "";
+}
+function nativeVerdict(hookKind, payload, result) {
+    const toolInput = asRecord(payload.tool_input) ?? {};
+    const toolName = asString(payload.tool_name) ?? "tool";
+    if (result.status === "cancelled") {
+        const reason = result.reason ?? "Interaction cancelled";
+        return hookKind === "pre_tool_use"
+            ? {
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "deny",
+                    permissionDecisionReason: reason,
+                },
+            }
+            : {
+                hookSpecificOutput: {
+                    hookEventName: "PermissionRequest",
+                    decision: { behavior: "deny", message: reason },
+                },
+            };
+    }
+    const resolution = result.resolution;
+    if (toolName === "AskUserQuestion") {
+        const questions = Array.isArray(toolInput.questions)
+            ? toolInput.questions.map(asRecord).filter((question) => Boolean(question))
+            : [];
+        const answers = {};
+        questions.forEach((question, index) => {
+            const text = asString(question.question) ?? `Question ${index + 1}`;
+            answers[text] = answerText(resolution.answers?.[`q${index}`]);
+        });
+        const updatedInput = { ...toolInput, answers };
+        return hookKind === "pre_tool_use"
+            ? {
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "allow",
+                    updatedInput,
+                },
+            }
+            : {
+                hookSpecificOutput: {
+                    hookEventName: "PermissionRequest",
+                    decision: { behavior: "allow", updatedInput },
+                },
+            };
     }
+    const suggestions = permissionSuggestions(payload);
+    const suggestionMatch = /^allow_suggestion_(\d+)$/.exec(resolution.actionId);
+    const suggestionIndex = suggestionMatch ? Number(suggestionMatch[1]) : -1;
+    const selectedSuggestion = Number.isSafeInteger(suggestionIndex)
+        ? suggestions[suggestionIndex]
+        : undefined;
+    return {
+        hookSpecificOutput: {
+            hookEventName: "PermissionRequest",
+            decision: {
+                behavior: resolution.actionId === "allow" || selectedSuggestion ? "allow" : "deny",
+                ...(selectedSuggestion ? { updatedPermissions: [selectedSuggestion] } : {}),
+            },
+        },
+    };
+}
+async function writeStdout(value) {
+    await new Promise((resolve) => process.stdout.write(JSON.stringify(value), () => resolve()));
 }
 async function main() {
     const argv = process.argv.slice(2);
-    const isPermission = argv[0] === "permission-request";
+    const mode = argv[0];
+    const hookKind = mode === "permission-request"
+        ? "permission"
+        : mode === "ask-user-question"
+            ? "pre_tool_use"
+            : undefined;
     const bridgeDir = argValue(argv, "--bridge-dir");
     if (!bridgeDir)
         return;
@@ -55,20 +258,69 @@ async function main() {
     let payload;
     try {
         const parsed = JSON.parse(raw || "{}");
-        payload = parsed && typeof parsed === "object" ? parsed : {};
+        payload = asRecord(parsed) ?? {};
     }
     catch {
-        return; // malformed hook payload — don't block claude
+        return;
     }
-    if (isPermission) {
-        await relayPermission(bridgeDir, payload);
+    if (!hookKind) {
+        try {
+            recordHookEvent(bridgeDir, payload);
+        }
+        catch {
+            // Observer hooks are best effort.
+        }
         return;
     }
+    const id = interactionId(payload);
+    const toolInput = asRecord(payload.tool_input) ?? {};
+    const request = asString(payload.tool_name) === "AskUserQuestion"
+        ? questionRequest(id, toolInput)
+        : permissionRequest(id, payload, toolInput);
     try {
-        recordHookEvent(bridgeDir, payload);
+        const bounded = boundInteractionRequest(request);
+        if (!bounded.ok) {
+            await writeStdout(nativeVerdict(hookKind, payload, {
+                status: "cancelled",
+                reason: bounded.reason,
+            }));
+            return;
+        }
+        touchInteractionLease(bridgeDir, id);
+        try {
+            recordInteractionRequest(bridgeDir, {
+                interactionId: id,
+                hookKind,
+                waiterPid: process.pid,
+                request: bounded.request,
+            });
+            const result = await waitForResult(bridgeDir, id);
+            const verdict = nativeVerdict(hookKind, payload, result);
+            // Claiming the response is the interaction commit point: it records what
+            // the user answered, while the later tool/Turn events record whether Claude
+            // could act on it. ACK before stdout is required because Claude may reap a
+            // command hook immediately after consuming its verdict.
+            recordInteractionAck(bridgeDir, result.status === "resolved"
+                ? {
+                    interactionId: id,
+                    status: "resolved",
+                    resolution: redactInteractionResolution(bounded.request, result.resolution),
+                }
+                : {
+                    interactionId: id,
+                    status: "cancelled",
+                    ...(result.reason ? { reason: result.reason } : {}),
+                });
+            removeClaimedInteractionResult(bridgeDir, id);
+            await writeStdout(verdict);
+        }
+        finally {
+            removeInteractionLease(bridgeDir, id);
+            removeClaimedInteractionResult(bridgeDir, id);
+        }
     }
     catch {
-        // Best-effort: a failed append must not fail the hook (would wedge claude).
+        // Empty stdout lets Claude fall back to its native UI instead of wedging.
     }
 }
 void main();

package/dist/claude/native-hooks.d.ts

@@ -16,8 +16,9 @@ export interface ClaudeHookSettings {
 export interface BuildClaudeHookSettingsOptions {
     /** The session's bridge dir (all hook subprocesses target it). */
     bridgeDir: string;
-    /** Register the blocking PermissionRequest hook (approvals → web). */
-    permission?: boolean;
+    /** Claude permission mode. bypassPermissions needs a PreToolUse question hook
+     * because PermissionRequest is intentionally skipped by Claude. */
+    permissionMode?: string;
     /** Register the MessageDisplay hook (live assistant-text streaming). */
     messageDisplay?: boolean;
     /** Register the statusLine command (context_window + cost capture). */

package/dist/claude/native-hooks.js

@@ -2,14 +2,14 @@
  * Build the Claude Code `--settings` JSON that registers rynx's claude-native
  * hooks. Each hook is a `command` that runs a standalone node entrypoint
  * ({@link ./native-hook-main.ts}) against the session's bridge dir; the
- * subprocess appends the hook payload to `hooks.jsonl` (observer) or POSTs to
- * the daemon and relays the verdict (PermissionRequest).
+ * subprocess appends observer events or blocks on the bridge's generic
+ * interaction result. It never calls or depends on the Control Plane.
  *
- * Registered here (the core turn-framing + approval subset; mirrors omnigent's
+ * Registered here (the core turn-framing + approval subset; mirrors reference implementation's
  * `build_hook_settings`):
  *   - `SessionStart`         → discovery (transcript_path + claude session id)
  *   - `Stop` / `StopFailure` → turn close (idle / failed)
- *   - `PermissionRequest`    → approvals (only when a serverUrl is provided)
+ *   - `PermissionRequest`    → questions and approvals
  *
  * Turn OPEN is transcript-driven (the `role:user` record), so `UserPromptSubmit`
  * is intentionally NOT registered. `MessageDisplay` (streaming) and `statusLine`
@@ -18,7 +18,7 @@
 import { fileURLToPath } from "node:url";
 /** Claude waits this long (seconds) for the PermissionRequest hook's verdict — a
  *  full day is effectively wait-forever for an interactive approval, matching
- *  omnigent (its default ~60s command-hook timeout would kill the long-poll). */
+ *  reference implementation (its default ~60s command-hook timeout would kill the long-poll). */
 const PERMISSION_HOOK_TIMEOUT_S = 86_400;
 /** Absolute path to the built standalone hook entrypoint (sibling `.js`). */
 export function resolveHookEntryPath() {
@@ -49,7 +49,16 @@ export function buildClaudeHookSettings(options) {
         Stop: [{ hooks: [observerHook] }],
         StopFailure: [{ hooks: [observerHook] }],
     };
-    if (options.permission) {
+    if (options.permissionMode === "bypassPermissions") {
+        const ask = shJoin([node, entry, "ask-user-question", "--bridge-dir", options.bridgeDir]);
+        hooks.PreToolUse = [
+            {
+                matcher: "AskUserQuestion",
+                hooks: [{ type: "command", command: ask, timeout: PERMISSION_HOOK_TIMEOUT_S }],
+            },
+        ];
+    }
+    else {
         const permission = shJoin([node, entry, "permission-request", "--bridge-dir", options.bridgeDir]);
         hooks.PermissionRequest = [
             { hooks: [{ type: "command", command: permission, timeout: PERMISSION_HOOK_TIMEOUT_S }] },

package/dist/claude/native-integration.d.ts

@@ -1,4 +1,5 @@
-import type { AgentEvent, TerminalCommandData, TodoItem } from "@rynx-ai/core";
+import type { AgentEvent, SessionInteractionResolution, TerminalCommandData, TodoItem } from "@rynx-ai/core";
+import type { ResolveInteractionResult, RuntimeInteractionEvent } from "../interactions.js";
 /** Mirror sink — the same shape as `CodexForwarderSink` so the host reuses one
  *  per-turn normalizer wiring for both runtimes. */
 export interface ClaudeForwarderSink {
@@ -14,6 +15,9 @@ export interface ClaudeForwarderSink {
     onTodos(todos: TodoItem[]): void;
     /** One mapped event within the current turn. */
     onEvent(event: AgentEvent): void;
+    /** A provider-neutral question/permission requested or settled while this
+     *  Turn remains active. */
+    onInteraction(event: RuntimeInteractionEvent): void;
     /** The current turn finished (a new user prompt, or the inactivity backstop).
      *  `usage` carries the latest statusLine context/cost snapshot, when captured. */
     onTurnEnd(usage?: Record<string, unknown>): void;
@@ -51,6 +55,10 @@ export interface ClaudeLiveSessionOptions {
      *  flush still join the turn (Stop and the flush race). */
     stopGraceMs?: number;
     now?: () => number;
+    /** Process-liveness probe for the blocking native hook (test override). */
+    isProcessAlive?: (pid: number) => boolean;
+    /** Native lease timestamp reader (test override). */
+    interactionLeaseUpdatedAt?: (interactionId: string) => number | undefined;
 }
 export declare class ClaudeLiveSession {
     private readonly bridgeDir;
@@ -59,9 +67,13 @@ export declare class ClaudeLiveSession {
     private readonly idleCloseMs;
     private readonly stopGraceMs;
     private readonly now;
+    private readonly isProcessAlive;
+    private readonly leaseUpdatedAt;
     private started;
     private stopped;
     private hooksOffset;
+    private interactionsOffset;
+    private interactionAcksOffset;
     private transcriptOffset;
     /** Secondary dedup: source ids (record uuids) already forwarded, so a re-read
      *  (fingerprint reset / mid-poll death) doesn't re-emit. Persisted in the
@@ -76,11 +88,29 @@ export declare class ClaudeLiveSession {
     private readonly seenClaudeSessionIds;
     private turnOpen;
     private currentTurnId?;
+    /** The Turn opened from a pre-transcript interaction. Its unique provisional
+     * id keeps responses distinct until the real prompt uuid can be adopted. */
+    private syntheticTurn;
     private lastActivityAt;
     /** When the Stop hook fired (null = not yet) — drives the grace-period close. */
     private stopPendingAt;
     /** Open tool-call ids (start seen, end not yet) — suppresses the idle backstop. */
     private readonly openToolIds;
+    /** Blocking native questions/permissions. Their hook subprocess is still
+     *  executing, so the Turn remains running and cannot be idle-closed. */
+    private readonly pendingInteractions;
+    private readonly settledInteractions;
+    /** Claimed response files may still contain the provider-bound, unredacted
+     * answer. Keep tracking them after canonical settlement until ACK/hook cleanup. */
+    private readonly claimedInteractions;
+    private readonly scheduledClaimScrubs;
+    /** Stop is flushed after interactions in the same poll, preventing a
+     *  request+Stop race from briefly reporting this executing Turn as idle. */
+    private stopSignalPending;
+    /** StopFailure is likewise flushed after interactions. A blocking hook can
+     *  append its request immediately before the failure hook lands; closing here
+     *  would let the later interaction poll reopen an already-failed Turn. */
+    private turnFailurePending;
     /** Sub-agent (Task) ids already forwarded — a Task tool_result is processed once. */
     private readonly seenSubagents;
     /** The agent's task list, keyed by task id in creation order (claude
@@ -97,7 +127,7 @@ export declare class ClaudeLiveSession {
     private readonly seenMessageIds;
     constructor(opts: ClaudeLiveSessionOptions);
     /**
-     * Restore the durable forwarder cursor for `transcriptPath` (omnigent's
+     * Restore the durable forwarder cursor for `transcriptPath` (reference implementation's
      * `_validated_transcript_state`). A cursor for a DIFFERENT file is ignored (a new
      * session starts at 0). A matching cursor whose fingerprint still validates
      * resumes at its `byteOffset`; a MISMATCH (the file was truncated/replaced) skips
@@ -111,12 +141,22 @@ export declare class ClaudeLiveSession {
     isReady(): boolean;
     start(): void;
     stop(): void;
+    /** Phase two of runner shutdown. The caller must stop the Claude terminal
+     * first so no hook can still be opening an atomically claimed answer. This is
+     * synchronous because the runner process exits immediately afterwards. */
+    finalizeStop(): void;
     /** One poll cycle (hooks → transcript → idle backstop). Exposed for tests to
      *  drive deterministically; the async {@link loop} just calls it on an interval. */
     tick(): void;
     private loop;
     private pollHooks;
     private handleHook;
+    /** Process a provider failure only after this tick has discovered every
+     *  blocking request already appended by its hook subprocess. */
+    private flushTurnFailure;
+    /** Emit the Stop idle signal only after this tick has discovered native
+     *  interactions. A pending question/permission is active execution, not idle. */
+    private flushStopSignal;
     /** SessionStart drives discovery (first) and rotation (a later one with a NEW
      *  session id + transcript). `/clear` → source="clear"; `/fork` → source="resume"
      *  into an unseen id with a forkedFrom marker. Any other new-transcript
@@ -127,6 +167,39 @@ export declare class ClaudeLiveSession {
      *  rotation, so their cursors are NOT reset). */
     private repointTranscript;
     private pollTranscript;
+    /** Tail blocking hook requests after transcript records, so an interaction
+     *  emitted in the same poll attaches to the user Turn that caused it. */
+    private pollInteractions;
+    private drainInteractionCommits;
+    /** A hook acknowledgement is the commit point: it is appended after the hook
+     * consumes the one-shot response and before it returns the native verdict. */
+    private pollInteractionAcks;
+    /** A claimed response is already consumed by the native hook. This fallback
+     * converges the interaction even if the hook exits before appending its
+     * redacted ACK. */
+    private pollInteractionClaims;
+    /** A request cannot remain actionable after its blocking hook exits. A short
+     * post-submit timeout also converges requests created by older hooks that did
+     * not publish a waiter pid, and scrubs any unacknowledged secret response. */
+    private pollAbandonedInteractions;
+    /** Deliver an answer to the blocked hook. The bridge file contains the real
+     *  answer; only the canonical resolved event receives a secret-redacted copy. */
+    resolveInteraction(interactionId: string, resolution: SessionInteractionResolution): ResolveInteractionResult;
+    private cancelPendingInteractions;
+    /** Terminal cancellation may race the hook's atomic result claim. A claim
+     * always wins; otherwise the cancellation file becomes the hook's verdict. */
+    private cancelOrSettlePendingInteraction;
+    private settleClaimedInteraction;
+    /** A claim is the hook's private handoff file and can contain secret answers.
+     * ACK/finally normally removes it; process death or an expired lease is the
+     * crash fallback after the canonical interaction has already settled. */
+    private pollClaimedInteractionCleanup;
+    /** Once this forwarder stops it can no longer poll a later hook crash. Keep a
+     * short unref'd scrub deadline so unredacted claim material cannot persist for
+     * the lifetime of the daemon. */
+    private scheduleClaimedInteractionScrubs;
+    private settleCancelledInteraction;
+    private rememberSettled;
     private handleRecord;
     /** Fold a `TaskCreate` (new pending task) or `TaskUpdate` (status/subject/delete)
      *  record into the task list; on any change emit the whole list as a snapshot. */
@@ -182,7 +255,7 @@ export interface TerminalInjector {
     clearInputLine(): void;
     paste(text: string): void;
     sendEnter(): void;
-    /** Interrupt the running turn (Escape) — the web Stop button (omnigent). */
+    /** Interrupt the running turn (Escape) — the web Stop button (reference implementation). */
     interrupt(): void;
 }
 export interface InjectViaTerminalOptions {
@@ -200,12 +273,12 @@ export interface InjectViaTerminalOptions {
     signal?: AbortSignal;
 }
 /**
- * Deliver `text` into a claude TUI pane, the omnigent recipe:
+ * Deliver `text` into a claude TUI pane, the reference implementation recipe:
  *   ready-gate (poll for `❯`) → clear leftover → bracketed paste (+ trailing
  *   newline) → wait for the draft to land → settle → submit Enter → verify the
  *   draft left the box (re-send Enter while it hasn't).
  *
- * THROWS if the prompt never appears within the ready-gate window (omnigent
+ * THROWS if the prompt never appears within the ready-gate window (reference implementation
  * `_wait_for_claude_prompt_ready` RAISE) — a not-ready pane is a hard error the
  * caller reports, NOT a signal to fall through to a second output path. Returns
  * `true` once the message is submitted (best-effort even if submit-verify times out).