@lucascouts/claude-agent-tui 0.5.1 → 0.6.0

package/dist/image-vision-smoke.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The claude version where `@<path>` → Read-vision was PROVEN to work (story 058 research).
+ *
+ * WHY this exact anchor: on claude 2.1.170 a `@path` image prompt did NOT vision-encode the picture —
+ * the TUI did not turn it into a Read the model could see (story 030). On claude 2.1.195 it DOES: the
+ * two-arm proof (a blue vs a green image under the same uuid filename, each described correctly) showed
+ * `@path` → Read vision-encodes. So 2.1.195 is the earliest version we are willing to call "confirmed";
+ * anything below is treated as unconfirmed and warned about.
+ */
+export declare const VISION_CONFIRMED_CLAUDE_VERSION = "2.1.195";
+/** The verdict {@link imageVisionSmoke} returns. Observability only — there is NO capability toggle here. */
+export interface VisionSmokeResult {
+    /** True iff the running `claude` version is one we have CONFIRMED vision-encodes `@image` via Read. */
+    confirmed: boolean;
+    /**
+     * Human-readable one-liner. On `confirmed=true` it is a positive note. On `confirmed=false` it is the
+     * fail-loud WARNING text and NAMES the detected version (or "undetected") plus the confirmed anchor
+     * (mirrors drift-checks.ts's "name the offending value" habit).
+     */
+    detail: string;
+}
+/**
+ * Compare two `x.y.z` semver strings: `true` iff `a >= b` componentwise (major, then minor, then patch).
+ *
+ * Splits on `.`, parses the three leading numeric components; a missing/non-numeric component counts as
+ * `0` (so `"2.1"` reads as `2.1.0`). Private to this module — exported only so the unit test can pin the
+ * ordering directly. Pure.
+ */
+export declare function versionGte(a: string, b: string): boolean;
+/**
+ * PURE verdict: is the running `claude` `version` one we have CONFIRMED vision-encodes `@image` via Read?
+ *
+ * `confirmed: true` IFF `version` is a parseable leading `x.y.z` that is `>= {@link
+ * VISION_CONFIRMED_CLAUDE_VERSION}`. In that case `detail` is a positive one-liner.
+ *
+ * Otherwise (`null` / `undefined` / unparseable, OR a parseable version BELOW the anchor) `confirmed:
+ * false` and `detail` is the fail-loud WARNING text — it NAMES the detected version (or "undetected")
+ * and the confirmed anchor, and states that the image is NOT blocked (R3.1). No I/O; depends only on
+ * its argument.
+ */
+export declare function imageVisionSmoke(version: string | null | undefined): VisionSmokeResult;
+/**
+ * Best-effort fail-loud reporter: compute {@link imageVisionSmoke} and, WHEN unconfirmed, log the
+ * verdict's `detail` EXACTLY ONCE via `log` with an `[image-vision]` prefix (mirrors claude-path.ts's
+ * reportVersionDrift `[claude-path] …` style). Returns the verdict.
+ *
+ * Logs NOTHING on a confirmed version (a confirmed `claude` is the expected case — no news is good news,
+ * matching reportVersionDrift which is silent when there is no drift). NEVER blocks and NEVER throws out
+ * of the caller's intent — it is pure aside from the single conditional `log` call (R3.1, R3.2).
+ */
+export declare function reportImageVisionSmoke(version: string | null | undefined, log?: (...args: unknown[]) => void): VisionSmokeResult;
+//# sourceMappingURL=image-vision-smoke.d.ts.map

package/dist/image-vision-smoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-vision-smoke.d.ts","sourceRoot":"","sources":["../src/image-vision-smoke.ts"],"names":[],"mappings":"AA8BA;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B,YAAY,CAAC;AAEzD,6GAA6G;AAC7G,MAAM,WAAW,iBAAiB;IAChC,uGAAuG;IACvG,SAAS,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAWxD;AAcD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,iBAAiB,CAiBtF;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAClC,GAAG,GAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAoB,GAChD,iBAAiB,CAMnB"}

package/dist/image-vision-smoke.js

@@ -0,0 +1,111 @@
+// === Story 058 / Task 3.1 (R3.1, R3.2) — version-aware image-vision smoke (pure verdict + fail-loud) ==
+//
+// The whole "image input via @path" feature rests on a VERSION-FRAGILE claude behavior: a prompt
+// containing `@<path>` makes the native TUI invoke the Read tool, and Read vision-encodes the image so
+// the model can see it. This was PROVEN on claude 2.1.195 (story 058 research — two-arm proof: a blue
+// image vs a green image under the same filename, each correctly described). It did NOT work on claude
+// 2.1.170 (story 030): there, `@path` did not vision-encode, so an image prompt silently dropped its
+// picture.
+//
+// Because the behavior is version-fragile, this module makes a too-old / unknown `claude` LOUD instead
+// of silently dropping the image. It mirrors story 049's drift discipline:
+//   - the VERDICT is PURE (no I/O — like src/drift-checks.ts's `{surface, ok, detail}` checks), and
+//   - the REPORTER is best-effort + fail-loud one-liner (like src/claude-path.ts's reportVersionDrift,
+//     `[claude-path] …`); here the prefix is `[image-vision]`.
+//
+// CRITICAL — OBSERVABILITY ONLY, NEVER A GATE (R3.1): this smoke NEVER blocks the prompt and NEVER
+// touches `promptCapabilities.image`, which stays literally `image: true` (acp-agent.ts:1413),
+// UNCONDITIONALLY. The verdict's only output is `{confirmed, detail}` — there is deliberately NO field
+// or return shape here that could disable a capability. A too-old `claude` produces a WARNING, not a
+// degraded capability: the image still rides the @path delivery; we just warn that this `claude` is not
+// a version we have confirmed vision-encodes it.
+//
+// LIMITATION (documented honestly): this is an OFFLINE `>= anchor` version-gate. It catches too-old and
+// undetected/unparseable versions, but it CANNOT catch a *future regression* — a hypothetical 2.1.300
+// that re-breaks @path-vision would still parse as `>= 2.1.195` and report confirmed. Catching a future
+// regression needs the LIVE smoke (opt-in — story 058 R4 probe: actually send @image and check the
+// model saw it), which this offline gate intentionally does NOT implement.
+//
+// node:test runner: `node --experimental-strip-types --test test/image-vision-smoke.test.ts`
+/**
+ * The claude version where `@<path>` → Read-vision was PROVEN to work (story 058 research).
+ *
+ * WHY this exact anchor: on claude 2.1.170 a `@path` image prompt did NOT vision-encode the picture —
+ * the TUI did not turn it into a Read the model could see (story 030). On claude 2.1.195 it DOES: the
+ * two-arm proof (a blue vs a green image under the same uuid filename, each described correctly) showed
+ * `@path` → Read vision-encodes. So 2.1.195 is the earliest version we are willing to call "confirmed";
+ * anything below is treated as unconfirmed and warned about.
+ */
+export const VISION_CONFIRMED_CLAUDE_VERSION = "2.1.195";
+/**
+ * Compare two `x.y.z` semver strings: `true` iff `a >= b` componentwise (major, then minor, then patch).
+ *
+ * Splits on `.`, parses the three leading numeric components; a missing/non-numeric component counts as
+ * `0` (so `"2.1"` reads as `2.1.0`). Private to this module — exported only so the unit test can pin the
+ * ordering directly. Pure.
+ */
+export function versionGte(a, b) {
+    const partsA = a.split(".");
+    const partsB = b.split(".");
+    for (let i = 0; i < 3; i++) {
+        const na = toComponent(partsA[i]);
+        const nb = toComponent(partsB[i]);
+        if (na !== nb) {
+            return na > nb;
+        }
+    }
+    return true; // all three components equal → a >= b holds
+}
+/** Parse one semver component to a non-negative integer; missing / non-numeric → 0. */
+function toComponent(part) {
+    if (part === undefined) {
+        return 0;
+    }
+    const n = Number.parseInt(part, 10);
+    return Number.isNaN(n) ? 0 : n;
+}
+/** Matches a leading `x.y.z` triple — same shape parseClaudeVersion extracts (claude-path.ts:58). */
+const SEMVER_RE = /^(\d+\.\d+\.\d+)/;
+/**
+ * PURE verdict: is the running `claude` `version` one we have CONFIRMED vision-encodes `@image` via Read?
+ *
+ * `confirmed: true` IFF `version` is a parseable leading `x.y.z` that is `>= {@link
+ * VISION_CONFIRMED_CLAUDE_VERSION}`. In that case `detail` is a positive one-liner.
+ *
+ * Otherwise (`null` / `undefined` / unparseable, OR a parseable version BELOW the anchor) `confirmed:
+ * false` and `detail` is the fail-loud WARNING text — it NAMES the detected version (or "undetected")
+ * and the confirmed anchor, and states that the image is NOT blocked (R3.1). No I/O; depends only on
+ * its argument.
+ */
+export function imageVisionSmoke(version) {
+    const parsed = typeof version === "string" ? SEMVER_RE.exec(version) : null;
+    if (parsed && versionGte(parsed[1], VISION_CONFIRMED_CLAUDE_VERSION)) {
+        return {
+            confirmed: true,
+            detail: `claude ${parsed[1]} >= ${VISION_CONFIRMED_CLAUDE_VERSION} — @image is confirmed to vision-encode via Read`,
+        };
+    }
+    const named = parsed ? parsed[1] : "undetected";
+    return {
+        confirmed: false,
+        detail: `@image vision-encoding is UNCONFIRMED on this claude (detected ${named}; confirmed at ` +
+            `${VISION_CONFIRMED_CLAUDE_VERSION}+). Sending images anyway — image input is NOT blocked — but ` +
+            `if the picture is ignored, upgrade claude to ${VISION_CONFIRMED_CLAUDE_VERSION} or newer`,
+    };
+}
+/**
+ * Best-effort fail-loud reporter: compute {@link imageVisionSmoke} and, WHEN unconfirmed, log the
+ * verdict's `detail` EXACTLY ONCE via `log` with an `[image-vision]` prefix (mirrors claude-path.ts's
+ * reportVersionDrift `[claude-path] …` style). Returns the verdict.
+ *
+ * Logs NOTHING on a confirmed version (a confirmed `claude` is the expected case — no news is good news,
+ * matching reportVersionDrift which is silent when there is no drift). NEVER blocks and NEVER throws out
+ * of the caller's intent — it is pure aside from the single conditional `log` call (R3.1, R3.2).
+ */
+export function reportImageVisionSmoke(version, log = console.error) {
+    const result = imageVisionSmoke(version);
+    if (!result.confirmed) {
+        log(`[image-vision] ${result.detail}`);
+    }
+    return result;
+}

package/dist/index.js

@@ -88,6 +88,12 @@ else {
     // (src/live-subagent-env.ts) so the truth table is unit-checkable; threaded through
     // runAcp → AgentDeps → the agent.
     const liveSubagentWatch = liveSubagentWatchEnabled();
+    // Story 056 / Task 7 (R3.5): enable the live agent-discovery probe in PRODUCTION only. The probe
+    // (agent-catalog.ts) spawns `claude --agent <sentinel>` once per createSession to read `claude`'s
+    // canonical persona list (enabled plugins + built-ins) for the 4th `agent` selector. Gated opt-in so
+    // the unit suite — which imports modules directly without this flag — stays on the hermetic glob
+    // fallback and never spawns the real binary. `??=` keeps a user opt-out (`FORK_AGENT_PROBE=0`).
+    process.env.FORK_AGENT_PROBE ??= "1";
     const { connection, agent } = runAcp({ usageUpdate, gate, liveDiff, liveSubagentWatch });
     async function shutdown() {
         await agent.dispose().catch((err) => {

package/dist/mcp-config-writer.d.ts

@@ -0,0 +1,61 @@
+import type { McpServer } from "@agentclientprotocol/sdk";
+/**
+ * A single entry under claude's `--mcp-config` `mcpServers` map. A discriminated union over the
+ * transport claude understands:
+ *   - http/sse → `{ type, url, headers? }` (headers as a plain `{ [name]: value }` object)
+ *   - stdio    → `{ command, args?, env? }` (NO `type` — claude infers stdio from `command`)
+ * ACP-transport servers have no `--mcp-config` equivalent and are dropped before this shape.
+ */
+export type ClaudeMcpEntry = {
+    type: "http" | "sse";
+    url: string;
+    headers?: Record<string, string>;
+} | {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+};
+/** The full claude `--mcp-config` document: a name-keyed map of {@link ClaudeMcpEntry}. */
+export interface ClaudeMcpConfig {
+    mcpServers: Record<string, ClaudeMcpEntry>;
+}
+/**
+ * Translate the ACP `McpServer[]` union into claude's `--mcp-config` `{ mcpServers: { … } }` shape
+ * (R2.1). PURE and total — never throws; empty/undefined input yields `{ mcpServers: {} }`.
+ *
+ * Discriminator (per the ACP schema): `type === "http"|"sse"|"acp"` selects that transport; a server
+ * with NO `type` field is the bare stdio variant. Per-transport mapping:
+ *   - http / sse → `{ type, url, headers? }`; `headers` is OMITTED when the ACP array is empty.
+ *   - stdio      → `{ command, args?, env? }`; `args` and `env` are each OMITTED when empty; NO `type`.
+ *   - acp        → DROPPED (ACP-channel transport has no `--mcp-config` equivalent); a one-line note
+ *                  is emitted to stderr (no url/headers/env — R2.3).
+ *
+ * Duplicate names collapse onto the same key (last wins) — claude's map is name-keyed, so this matches
+ * how claude itself would resolve a repeated server name.
+ *
+ * @param servers the ACP-declared MCP servers, or `undefined`/`[]` when the client declared none.
+ * @returns the claude `--mcp-config` document (possibly with an empty `mcpServers`).
+ */
+export declare function translateMcpServers(servers: readonly McpServer[] | undefined): ClaudeMcpConfig;
+/**
+ * DURABLY write `config` to a fresh uuid-namespaced scratch file under the OS temp dir with mode
+ * `0600`, and RETURN its absolute path (R2.1, R2.3). The file is `JSON.stringify(config, null, 2)`
+ * plus a trailing newline. The caller passes the returned path to `claude --mcp-config <path>` and
+ * is responsible for removing it on teardown via {@link removeMcpScratch}.
+ *
+ * The file may carry MCP auth headers/env (secrets), so it is created owner-only (0600) and is NEVER
+ * logged here (R2.3).
+ *
+ * @param config the document from {@link translateMcpServers}.
+ * @returns the absolute path of the written scratch file.
+ * @throws {Error} if the durable write fails — the partial temp is cleaned up first (no residue).
+ */
+export declare function writeMcpScratch(config: ClaudeMcpConfig): Promise<string>;
+/**
+ * Idempotently remove a scratch file written by {@link writeMcpScratch} (R2.3 teardown). Uses
+ * `fs.rm(filePath, { force: true })`, so a missing/already-removed path is a no-op and NEVER throws.
+ *
+ * @param filePath the path returned by {@link writeMcpScratch}.
+ */
+export declare function removeMcpScratch(filePath: string): Promise<void>;
+//# sourceMappingURL=mcp-config-writer.d.ts.map

package/dist/mcp-config-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-config-writer.d.ts","sourceRoot":"","sources":["../src/mcp-config-writer.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,SAAS,EAA2B,MAAM,0BAA0B,CAAC;AAEnF;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GACvE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAC;AAEvE,2FAA2F;AAC3F,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC5C;AAWD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,GAAG,eAAe,CA2C9F;AAqDD;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAK9E;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtE"}

package/dist/mcp-config-writer.js

@@ -0,0 +1,172 @@
+// Story 057 / Task 2.1 — translate ACP MCP servers → claude `--mcp-config` JSON + scratch-file seam.
+//
+// The fork spawns the real `claude` TUI; claude consumes externally-declared MCP servers via a
+// `--mcp-config <file.json>` flag (a `{ mcpServers: { <name>: { … } } }` document). The Zed client,
+// however, declares its MCP servers over ACP as a `McpServer[]` array (a discriminated union). This
+// module is the standalone, OFFLINE-testable translation + scratch-file seam between the two:
+//
+//   translateMcpServers(servers) → ClaudeMcpConfig   (PURE — array → claude `{mcpServers:{…}}` shape)
+//   writeMcpScratch(config)      → Promise<string>   (DURABLE 0600 write → returns the scratch path)
+//   removeMcpScratch(path)       → Promise<void>     (idempotent unlink on teardown)
+//
+// It owns NO engine wiring — the before-spawn `--mcp-config` plumbing into acp-agent.ts/the engine is
+// a separate Task (2.2/2.3). The scratch-JSON discipline (temp-file → fsync → atomic rename, with a
+// guaranteed 0600 mode) mirrors `gate/settings-writer.ts`'s private `durableWrite`; that pattern is
+// copied here rather than imported (it is not exported there).
+//
+// SECRETS (R2.3): the scratch file may carry MCP auth headers / env / URLs. Its mode is forced to
+// `0600` (owner-only) and it is removable on teardown. The config object, headers, env, and url are
+// NEVER logged — the ONLY log this module emits is a one-line note when an `acp`-transport server is
+// dropped, and that note carries no secret-bearing field.
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import { randomUUID } from "node:crypto";
+/** Convert an ACP `{name,value}[]` list into a plain `{ [name]: value }` object. */
+function pairsToObject(pairs) {
+    const out = {};
+    for (const { name, value } of pairs) {
+        out[name] = value;
+    }
+    return out;
+}
+/**
+ * Translate the ACP `McpServer[]` union into claude's `--mcp-config` `{ mcpServers: { … } }` shape
+ * (R2.1). PURE and total — never throws; empty/undefined input yields `{ mcpServers: {} }`.
+ *
+ * Discriminator (per the ACP schema): `type === "http"|"sse"|"acp"` selects that transport; a server
+ * with NO `type` field is the bare stdio variant. Per-transport mapping:
+ *   - http / sse → `{ type, url, headers? }`; `headers` is OMITTED when the ACP array is empty.
+ *   - stdio      → `{ command, args?, env? }`; `args` and `env` are each OMITTED when empty; NO `type`.
+ *   - acp        → DROPPED (ACP-channel transport has no `--mcp-config` equivalent); a one-line note
+ *                  is emitted to stderr (no url/headers/env — R2.3).
+ *
+ * Duplicate names collapse onto the same key (last wins) — claude's map is name-keyed, so this matches
+ * how claude itself would resolve a repeated server name.
+ *
+ * @param servers the ACP-declared MCP servers, or `undefined`/`[]` when the client declared none.
+ * @returns the claude `--mcp-config` document (possibly with an empty `mcpServers`).
+ */
+export function translateMcpServers(servers) {
+    const mcpServers = {};
+    if (!servers) {
+        return { mcpServers };
+    }
+    for (const server of servers) {
+        // The ACP union is NOT a uniform discriminated union: http/sse/acp carry a `type` tag, but the
+        // stdio variant has NO `type` field at all. So a `"type" in server` guard (not `server.type`)
+        // first splits the tagged members from the bare stdio variant; within the tagged set, `type`
+        // then selects http/sse vs acp.
+        if ("type" in server) {
+            if (server.type === "http" || server.type === "sse") {
+                const entry = { type: server.type, url: server.url };
+                if (server.headers.length > 0) {
+                    entry.headers = pairsToObject(server.headers);
+                }
+                mcpServers[server.name] = entry;
+            }
+            else {
+                // type === "acp": ACP-transport servers ride the ACP channel (mcp/connect…); claude's
+                // --mcp-config cannot express them, so drop. Log ONLY the (non-secret) name — never
+                // id/url/headers/env (R2.3).
+                console.error(`[mcp-config-writer] dropping ACP-transport MCP server ${JSON.stringify(server.name)}: ` +
+                    `no --mcp-config equivalent (ACP-channel transport is not supported by the claude CLI).`);
+            }
+            continue;
+        }
+        // No `type` field → the bare stdio variant: `{ command, args, env }`. NO `type` is emitted
+        // (claude infers stdio from `command`); empty `args`/`env` are omitted.
+        const entry = { command: server.command };
+        if (server.args.length > 0) {
+            entry.args = [...server.args];
+        }
+        if (server.env.length > 0) {
+            entry.env = pairsToObject(server.env);
+        }
+        mcpServers[server.name] = entry;
+    }
+    return { mcpServers };
+}
+/**
+ * Durably write `text` to `filePath` with mode `0600` via a temp-file → fsync → atomic `rename` so a
+ * reader (claude on startup) never observes a partial file. The 0600 mode is GUARANTEED twice: the
+ * temp is created with `mode: 0o600`, and `chmod(0o600)` is re-applied after the rename so a permissive
+ * umask cannot loosen it. On any failure the partial temp is removed before the error propagates.
+ *
+ * Mirrors `gate/settings-writer.ts`'s private `durableWrite` (copied — that helper is not exported),
+ * with the added 0600 guarantee this scratch file requires (R2.3).
+ */
+async function durableWrite0600(filePath, text) {
+    const dir = path.dirname(filePath);
+    const tmp = path.join(dir, `.${path.basename(filePath)}.fork-tmp-${process.pid}-${Date.now()}`);
+    let handle = null;
+    try {
+        // Create the temp owner-only from the outset so its bytes are never world-readable, even briefly.
+        handle = await fs.open(tmp, "w", 0o600);
+        await handle.writeFile(text, "utf8");
+        await handle.sync(); // flush the file's own bytes to disk before the rename
+        await handle.close();
+        handle = null;
+        await fs.rename(tmp, filePath); // atomic swap into place
+        // Re-assert 0600 AFTER the rename so the active umask cannot have loosened the open() mode.
+        await fs.chmod(filePath, 0o600);
+        // Best-effort fsync of the directory entry so the rename itself is durable.
+        try {
+            const dirHandle = await fs.open(dir, "r");
+            try {
+                await dirHandle.sync();
+            }
+            finally {
+                await dirHandle.close();
+            }
+        }
+        catch {
+            // Some platforms reject O_RDONLY dir fsync; the file fsync above is the load-bearing one.
+        }
+    }
+    catch (err) {
+        if (handle !== null) {
+            try {
+                await handle.close();
+            }
+            catch {
+                // ignore
+            }
+        }
+        try {
+            await fs.rm(tmp, { force: true });
+        }
+        catch {
+            // ignore — nothing durable to clean
+        }
+        throw err;
+    }
+}
+/**
+ * DURABLY write `config` to a fresh uuid-namespaced scratch file under the OS temp dir with mode
+ * `0600`, and RETURN its absolute path (R2.1, R2.3). The file is `JSON.stringify(config, null, 2)`
+ * plus a trailing newline. The caller passes the returned path to `claude --mcp-config <path>` and
+ * is responsible for removing it on teardown via {@link removeMcpScratch}.
+ *
+ * The file may carry MCP auth headers/env (secrets), so it is created owner-only (0600) and is NEVER
+ * logged here (R2.3).
+ *
+ * @param config the document from {@link translateMcpServers}.
+ * @returns the absolute path of the written scratch file.
+ * @throws {Error} if the durable write fails — the partial temp is cleaned up first (no residue).
+ */
+export async function writeMcpScratch(config) {
+    const filePath = path.join(os.tmpdir(), `fork-acp-mcp-${randomUUID()}.json`);
+    const text = `${JSON.stringify(config, null, 2)}\n`;
+    await durableWrite0600(filePath, text);
+    return filePath;
+}
+/**
+ * Idempotently remove a scratch file written by {@link writeMcpScratch} (R2.3 teardown). Uses
+ * `fs.rm(filePath, { force: true })`, so a missing/already-removed path is a no-op and NEVER throws.
+ *
+ * @param filePath the path returned by {@link writeMcpScratch}.
+ */
+export async function removeMcpScratch(filePath) {
+    await fs.rm(filePath, { force: true });
+}

package/dist/model-catalog.d.ts

@@ -1,9 +1,36 @@
 import type { ModelInfo } from "@anthropic-ai/claude-agent-sdk";
+/**
+ * Effort levels offered for reasoning-capable models — the SDK's `supportedEffortLevels` vocabulary.
+ * Story 060: exported so the ultracode guard test can assert membership stays the five real levels
+ * (it must NEVER contain {@link ULTRACODE_EFFORT}; the real `--effort` enum is exactly this set).
+ */
+export declare const REASONING_EFFORT_LEVELS: NonNullable<ModelInfo["supportedEffortLevels"]>;
+/**
+ * Story 060 — the "ultracode" pseudo-level sentinel for the effort selector. NOT a real `--effort`
+ * value (claude 2.1.195 rejects `--effort ultracode`; the enum stays {@link REASONING_EFFORT_LEVELS}).
+ * Selecting it maps to `--effort xhigh` PLUS activating the ultracode keyword-trigger for the session
+ * (story 060 Task 3). Kept OUT of REASONING_EFFORT_LEVELS so no real-effort code path ever emits it.
+ */
+export declare const ULTRACODE_EFFORT = "ultracode";
+/** The real effort level the ultracode pseudo-level maps to (its documented effort component). */
+export declare const ULTRACODE_EFFORT_LEVEL = "xhigh";
+/** Selector label — makes clear it is xhigh + orchestration, NOT a duplicate of the plain `xhigh` entry. */
+export declare const ULTRACODE_EFFORT_LABEL = "ultracode (xhigh + orchestration)";
 /**
  * The static curated catalog advertised to the Zed Agent Panel's `model` selector. Each `value` is a
  * `claude` TUI alias accepted by `/model <alias>` (live) and `--model <alias>` (spawn). `default` is
- * first and is the safe fallback. Effort-capable models (`sonnet`, `opus`) carry the metadata that
- * surfaces the effort selector; `default`/`haiku`/`opusplan` advertise no effort levels.
+ * first and is the safe fallback.
+ *
+ * ORDER + membership mirror the ORIGINAL's `/model` picker, LIVE-VERIFIED against 2.1.195 (PTY probe):
+ * `Default (recommended)`, `Opus`, `Sonnet`, `Sonnet (1M context)`, `Haiku`. The original gets this
+ * from the SDK `supportedModels()` the fork cut, so we curate it statically. The 1M alias is literally
+ * `sonnet[1m]` (`/model sonnet[1m]` accepted; `sonnet-1m` → "not found"). `opusplan` is a fork-only
+ * EXTRA (a real `claude` plan-mode preset the original does not list) kept as the trailing entry.
+ *
+ * Effort-capable models (`default`/`opus`/`sonnet`/`sonnet[1m]`) carry `supportsEffort` +
+ * `supportedEffortLevels`; `haiku`/`opusplan` advertise none. `supportsAutoMode: true` on the same four
+ * surfaces the `auto` permission mode (a model classifier) — the original drops `auto` on `haiku`
+ * (the SDK signal `reconcileModeFromTranscript` clamps), so haiku/opusplan omit it.
  */
 export declare const MODEL_CATALOG: ModelInfo[];
 /** The safe fallback entry, kept as a named export so callers can seed/anchor on it without a lookup. */

package/dist/model-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-catalog.d.ts","sourceRoot":"","sources":["../src/model-catalog.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAShE;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,EA8BpC,CAAC;AAEF,yGAAyG;AACzG,eAAO,MAAM,kBAAkB,EAAE,SAA4B,CAAC"}
+{"version":3,"file":"model-catalog.d.ts","sourceRoot":"","sources":["../src/model-catalog.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,SAAS,CAAC,uBAAuB,CAAC,CAMnF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,cAAc,CAAC;AAE5C,kGAAkG;AAClG,eAAO,MAAM,sBAAsB,UAAU,CAAC;AAE9C,4GAA4G;AAC5G,eAAO,MAAM,sBAAsB,sCAAsC,CAAC;AAE1E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,EA6CpC,CAAC;AAEF,yGAAyG;AACzG,eAAO,MAAM,kBAAkB,EAAE,SAA4B,CAAC"}

package/dist/model-catalog.js

@@ -1,20 +1,58 @@
-/** Effort levels offered for reasoning-capable models — the SDK's `supportedEffortLevels` vocabulary. */
-const REASONING_EFFORT_LEVELS = [
+/**
+ * Effort levels offered for reasoning-capable models — the SDK's `supportedEffortLevels` vocabulary.
+ * Story 060: exported so the ultracode guard test can assert membership stays the five real levels
+ * (it must NEVER contain {@link ULTRACODE_EFFORT}; the real `--effort` enum is exactly this set).
+ */
+export const REASONING_EFFORT_LEVELS = [
     "low",
     "medium",
     "high",
+    "xhigh",
+    "max",
 ];
+/**
+ * Story 060 — the "ultracode" pseudo-level sentinel for the effort selector. NOT a real `--effort`
+ * value (claude 2.1.195 rejects `--effort ultracode`; the enum stays {@link REASONING_EFFORT_LEVELS}).
+ * Selecting it maps to `--effort xhigh` PLUS activating the ultracode keyword-trigger for the session
+ * (story 060 Task 3). Kept OUT of REASONING_EFFORT_LEVELS so no real-effort code path ever emits it.
+ */
+export const ULTRACODE_EFFORT = "ultracode";
+/** The real effort level the ultracode pseudo-level maps to (its documented effort component). */
+export const ULTRACODE_EFFORT_LEVEL = "xhigh";
+/** Selector label — makes clear it is xhigh + orchestration, NOT a duplicate of the plain `xhigh` entry. */
+export const ULTRACODE_EFFORT_LABEL = "ultracode (xhigh + orchestration)";
 /**
  * The static curated catalog advertised to the Zed Agent Panel's `model` selector. Each `value` is a
  * `claude` TUI alias accepted by `/model <alias>` (live) and `--model <alias>` (spawn). `default` is
- * first and is the safe fallback. Effort-capable models (`sonnet`, `opus`) carry the metadata that
- * surfaces the effort selector; `default`/`haiku`/`opusplan` advertise no effort levels.
+ * first and is the safe fallback.
+ *
+ * ORDER + membership mirror the ORIGINAL's `/model` picker, LIVE-VERIFIED against 2.1.195 (PTY probe):
+ * `Default (recommended)`, `Opus`, `Sonnet`, `Sonnet (1M context)`, `Haiku`. The original gets this
+ * from the SDK `supportedModels()` the fork cut, so we curate it statically. The 1M alias is literally
+ * `sonnet[1m]` (`/model sonnet[1m]` accepted; `sonnet-1m` → "not found"). `opusplan` is a fork-only
+ * EXTRA (a real `claude` plan-mode preset the original does not list) kept as the trailing entry.
+ *
+ * Effort-capable models (`default`/`opus`/`sonnet`/`sonnet[1m]`) carry `supportsEffort` +
+ * `supportedEffortLevels`; `haiku`/`opusplan` advertise none. `supportsAutoMode: true` on the same four
+ * surfaces the `auto` permission mode (a model classifier) — the original drops `auto` on `haiku`
+ * (the SDK signal `reconcileModeFromTranscript` clamps), so haiku/opusplan omit it.
  */
 export const MODEL_CATALOG = [
     {
         value: "default",
-        displayName: "Default",
-        description: "Use the model the claude TUI is configured with (safe fallback).",
+        displayName: "Default (recommended)",
+        description: "Use the model the claude TUI is configured with (safe fallback); supports reasoning effort.",
+        supportsEffort: true,
+        supportedEffortLevels: REASONING_EFFORT_LEVELS,
+        supportsAutoMode: true,
+    },
+    {
+        value: "opus",
+        displayName: "Opus",
+        description: "Claude Opus — highest capability; supports reasoning effort.",
+        supportsEffort: true,
+        supportedEffortLevels: REASONING_EFFORT_LEVELS,
+        supportsAutoMode: true,
     },
     {
         value: "sonnet",
@@ -22,13 +60,15 @@ export const MODEL_CATALOG = [
         description: "Claude Sonnet — balanced speed and capability; supports reasoning effort.",
         supportsEffort: true,
         supportedEffortLevels: REASONING_EFFORT_LEVELS,
+        supportsAutoMode: true,
     },
     {
-        value: "opus",
-        displayName: "Opus",
-        description: "Claude Opus — highest capability; supports reasoning effort.",
+        value: "sonnet[1m]",
+        displayName: "Sonnet (1M context)",
+        description: "Claude Sonnet with a 1M-token context window; draws from usage credits; supports reasoning effort.",
         supportsEffort: true,
         supportedEffortLevels: REASONING_EFFORT_LEVELS,
+        supportsAutoMode: true,
     },
     {
         value: "haiku",
@@ -38,7 +78,7 @@ export const MODEL_CATALOG = [
     {
         value: "opusplan",
         displayName: "Opus Plan",
-        description: "Opus while planning, Sonnet for execution (plan-mode workflow).",
+        description: "Opus while planning, Sonnet for execution (plan-mode workflow; fork extra).",
     },
 ];
 /** The safe fallback entry, kept as a named export so callers can seed/anchor on it without a lookup. */

package/dist/permissions/gate-wiring.d.ts

@@ -34,6 +34,13 @@ export declare const DEFAULT_CORRELATION_POLL_MS = 50;
  *  fail-closed timeout deny. Tracked separately from the poll interval (the poll is 10-50ms; nudging on
  *  every poll would hammer the pump) — a nudge fires only once ~250ms has elapsed since the last one. */
 export declare const DEFAULT_CORRELATION_RENUDGE_MS = 250;
+/**
+ * FIX(watchdog-permission): while a permission dialog is pending the claude is BLOCKED and writes
+ * nothing to the JSONL, so the end-of-turn watchdog (120s of silence) would mistake a long human
+ * decision for a dead turn. Re-arm it every this-many ms via the bound `noteActivity` for as long as
+ * the dialog is open. Must stay well under TURN_STALL_WATCHDOG_MS (120_000).
+ */
+export declare const DEFAULT_PERMISSION_HEARTBEAT_MS = 30000;
 /** Default window for the native prompt to APPEAR after an allow decision (#52822 sweep, ms).
  *  If no marker renders within it, allow-suppression held (the 2.1.161 case) — nothing to clear. */
 export declare const DEFAULT_PROMPT_APPEAR_MS = 1500;
@@ -99,6 +106,9 @@ export type ResolveSubagentRelay = (innerToolUseId: string) => SubagentRelay | u
 export interface SessionGate {
     /** The verified-free loopback port the hook server bound (== the port in the scratch hook URL). */
     port: number;
+    /** Story 055 (R1.3) — the per-session secret token bound into the hook URL after the marker path.
+     *  The hook-server rejects any PreToolUse POST that does not present `${marker}/<token>`. */
+    readonly token: string;
     /** Absolute path of the per-session scratch settings file (hand to the spawn as `--settings`). */
     settingsPath: string;
     /** The per-session `tool_use.id` correlation map. The live pump REGISTERS every JSONL `tool_use`
@@ -116,7 +126,9 @@ export interface SessionGate {
      * relay a KNOWN subagent tool's dialog under its parent Task id (R1/R2), or to fail LOUD (R4) on
      * an orphan / uncorrelatable subagent. A main-chain tool (no resolver entry) is unchanged (U1).
      */
-    bindSession(sessionId: string, nudge?: () => void, resolveSubagentRelay?: ResolveSubagentRelay): void;
+    bindSession(sessionId: string, nudge?: () => void, resolveSubagentRelay?: ResolveSubagentRelay, 
+    /** FIX(watchdog-permission) — re-arms the end-of-turn watchdog while a permission dialog is open. */
+    noteActivity?: () => void): void;
     /** Bind the live PTY: stores the raw writer for the allow keystroke and (when the PTY exposes
      *  `onData`) attaches the recent-output tap feeding the native-prompt probe. */
     bindPty(pty: GatePty): void;

package/dist/permissions/gate-wiring.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gate-wiring.d.ts","sourceRoot":"","sources":["../../src/permissions/gate-wiring.ts"],"names":[],"mappings":"AAqCA,OAAO,EAEL,iBAAiB,EACjB,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAqB,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAErF;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC,EAAE,SAAS,MAAM,EAO7D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,6BAAwB,CAAC;AAQ5D;8BAC8B;AAC9B,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAM3D;AAED;;;+EAG+E;AAC/E,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAChD,2DAA2D;AAC3D,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAC9C;;;;yGAIyG;AACzG,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAClD;oGACoG;AACpG,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAC7C,sEAAsE;AACtE,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,0FAA0F;AAC1F,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAC9C;;gDAEgD;AAChD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAI7C,2FAA2F;AAC3F,eAAO,MAAM,uBAAuB,4BAA4B,CAAC;AAMjE;;0FAE0F;AAC1F,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG;QAAE,OAAO,IAAI,IAAI,CAAA;KAAE,CAAC;CAC1D;AAED,2FAA2F;AAC3F,MAAM,WAAW,kBAAkB;IACjC,gGAAgG;IAChG,MAAM,EAAE,gBAAgB,CAAC;IACzB,gGAAgG;IAChG,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,gGAAgG;IAChG,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,mFAAmF;IACnF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uFAAuF;IACvF,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,uFAAuF;IACvF,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,+CAA+C;IAC/C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,+CAA+C;IAC/C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kDAAkD;IAClD,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,4CAA4C;IAC5C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6CAA6C;IAC7C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,4CAA4C;IAC5C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CAClC;AAED,mGAAmG;AACnG,MAAM,WAAW,aAAa;IAC5B,uGAAuG;IACvG,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,yEAAyE;IACzE,aAAa,EAAE,MAAM,CAAC;CACvB;AACD,iGAAiG;AACjG,MAAM,MAAM,oBAAoB,GAAG,CAAC,cAAc,EAAE,MAAM,KAAK,aAAa,GAAG,SAAS,CAAC;AAEzF,+FAA+F;AAC/F,MAAM,WAAW,WAAW;IAC1B,mGAAmG;IACnG,IAAI,EAAE,MAAM,CAAC;IACb,kGAAkG;IAClG,YAAY,EAAE,MAAM,CAAC;IACrB;mGAC+F;IAC/F,UAAU,EAAE,iBAAiB,CAAC;IAC9B;;;;;;;;;;;OAWG;IACH,WAAW,CACT,SAAS,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,MAAM,IAAI,EAClB,oBAAoB,CAAC,EAAE,oBAAoB,GAC1C,IAAI,CAAC;IACR;oFACgF;IAChF,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B;8EAC0E;IAC1E,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,0CAA0C;IAC1C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAuXD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC,CAIrF"}
+{"version":3,"file":"gate-wiring.d.ts","sourceRoot":"","sources":["../../src/permissions/gate-wiring.ts"],"names":[],"mappings":"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"}