@lucascouts/claude-agent-tui 0.6.0 → 0.7.0

package/dist/command-catalog.js

@@ -0,0 +1,339 @@
+// Story 063 / Task 1.2 (R1.1, R2, R3, R5) — OFFLINE discovery of custom slash-commands for the ACP
+// fork's `available_commands` advertisement.
+//
+// The command analog of {@link file://./agent-catalog.ts}: PURE + dependency-injectable, sharing the
+// exact style — a minimal inline frontmatter line-parser (NO YAML dep), graceful `readdirMd`/`readFile`
+// seams (try/catch → the empty-state, NEVER a throw), an ordered `Map<name, entry>` first-wins dedup,
+// and an alphabetical sort. Unlike `agent-catalog.ts` this surface is FULLY OFFLINE — no subprocess,
+// no probe, no network: slash-commands live on disk (`<cwd>/.claude/commands/*.md`, `~/.claude/commands/
+// *.md`) plus a curated built-in tier. The only `node:` builtins are os/fs/path; the single non-`node:`
+// import is TYPE-ONLY (`AvailableCommand`), so it is erased at runtime and adds no runtime dependency
+// (FORK.md pins node-pty + the SDK as the only runtime deps; this file adds none).
+//
+// PRECEDENCE (R1.1 / R7 / R8.1). Four disk surfaces are consulted, highest precedence first — commands
+// out-scope skills at the SAME scope, and any cwd surface out-scopes any user surface:
+//   1. `<cwd>/.claude/commands/*.md`    (cwd commands)
+//   2. `<cwd>/.claude/skills/*/SKILL.md` (cwd skills — R7)
+//   3. `~/.claude/commands/*.md`         (user commands)
+//   4. `~/.claude/skills/*/SKILL.md`      (user skills — R7)
+// then the built-in tier (R9, populated in Task 1.5) is the LOWEST precedence: a built-in whose name
+// collides with a disk entry loses. One entry per name (first-wins across the ordered surfaces). The
+// visible result is FLAT ALPHABETICAL by `name` — tiers govern collision dedup ONLY, not grouping
+// (determinism + parity with `agent-catalog.ts`'s `sortByValue`).
+//
+// SKILLS (R7 / R7.1): a skill lives at `<scope>/.claude/skills/<name>/SKILL.md`; the command `name` is
+// the DIRECTORY name (same R3 allowlist as a command) and `description` comes from the `SKILL.md`
+// frontmatter. A skills subdir WITHOUT a `SKILL.md` is NOT a command (the `readFile` throw skips it).
+// Skills carry no `argument-hint`, so a skill entry is `{ name, description }` with no `input`.
+//
+// SECURITY (R3): a command `name` is the file's basename sans `.md`; it is checked against
+// {@link SAFE_COMMAND_NAME} = `/^[a-z0-9_-]+$/` and the entry is DROPPED on any failure (a name with
+// spaces, quotes, path separators, uppercase, … never renders). A missing/unreadable dir or file yields
+// `[]` for that surface — discovery NEVER throws or crashes the session (R3 / R5).
+//
+// PURE + dependency-injectable (R5): all fs/home access goes through the {@link DiscoverCommandsDeps}
+// seams so the unit tests inject an in-memory fs and never touch the real `~/.claude`; the built-in tier
+// is likewise an injectable seam (`builtins`) defaulting to {@link BUILTIN_COMMANDS}.
+//
+// node:test runner: `node --experimental-strip-types --test test/command-catalog.test.ts`
+import { homedir as osHomedir } from "node:os";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * The curated built-in slash-command tier (R9) — the interactive `claude` TUI's own built-ins, which are
+ * baked into the binary and therefore NOT disk-discoverable. This is a CURATED APPROXIMATION (C1), NOT a
+ * live probe: it stands beside the same static-curation idea as `MODEL_CATALOG`. It is the LOWEST-
+ * precedence tier, so any disk command/skill of the same name shadows a built-in (R1/R9). Names are
+ * lowercase (R3) and every entry carries a non-empty `description` (the SDK requires it). The list is
+ * intentionally small and conservative — a documented approximation, not an exhaustive enumeration.
+ */
+export const BUILTIN_COMMANDS = [
+    { name: "clear", description: "Clear the conversation history and free up context" },
+    { name: "compact", description: "Summarize and compact the current conversation" },
+    { name: "config", description: "Open the settings / configuration panel" },
+    { name: "cost", description: "Show token usage and cost for the current session" },
+    { name: "help", description: "List available slash commands and usage help" },
+    { name: "init", description: "Initialize a CLAUDE.md with codebase documentation" },
+    { name: "memory", description: "Edit the project or user memory (CLAUDE.md) files" },
+    { name: "model", description: "Switch the active model for the session" },
+    { name: "resume", description: "Resume a previous conversation" },
+    { name: "review", description: "Review a pull request or the pending changes" },
+];
+/**
+ * The command-name allowlist (R3). A single un-namespaced segment: LOWERCASE letters/digits/underscore/
+ * hyphen only (no spaces, no uppercase, no shell metacharacters, no path separators). Slash-command
+ * names are conventionally lowercase, so — unlike `agent-catalog.ts`'s {@link SAFE_AGENT_NAME} — this
+ * allowlist excludes uppercase.
+ */
+export const SAFE_COMMAND_NAME = /^[a-z0-9_-]+$/;
+/** True iff `name` is a non-empty string matching {@link SAFE_COMMAND_NAME} (R3). */
+export function isSafeCommandName(name) {
+    return typeof name === "string" && SAFE_COMMAND_NAME.test(name);
+}
+/**
+ * Default `readdirMd`: list `*.md` filenames in `dir`, returning `[]` when the directory is missing or
+ * unreadable (the empty-state — never throws). Sorted for a stable first-wins ordering within a dir.
+ * Mirrors `agent-catalog.ts`'s `defaultReaddirMd`.
+ */
+function defaultReaddirMd(dir) {
+    try {
+        return readdirSync(dir)
+            .filter((f) => f.toLowerCase().endsWith(".md"))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Default `readdirDirs`: list the IMMEDIATE sub-directory names of `dir`, returning `[]` when the
+ * directory is missing or unreadable (the empty-state — never throws). Sorted for a stable first-wins
+ * ordering within the skills tier. Mirrors the graceful try/catch style of {@link defaultReaddirMd}.
+ */
+function defaultReaddirDirs(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** Default `readFile`: UTF-8 file read via the `node:fs` stdlib. */
+function defaultReadFile(path) {
+    return readFileSync(path, "utf8");
+}
+/** The leading `name` (sans `.md`) of a command file — the command's name. */
+function baseName(filename) {
+    return filename.replace(/\.md$/i, "");
+}
+/**
+ * Minimal `---`-fenced frontmatter line-parser (NOT a full YAML dep). Reads the leading `---\n … \n---`
+ * block and pulls the `description` and `argument-hint` `key: value` lines; a single pair of surrounding
+ * quotes on a value is stripped. The frontmatter key `argument-hint` (a HYPHEN) is returned as the
+ * camelCase {@link CommandFrontmatter.argumentHint}. A file whose first line is not `---` yields `{}`.
+ * Tiny + pure on purpose, mirroring `agent-catalog.ts`'s `parseFrontmatter` — the command frontmatter we
+ * consume is flat `key: value`.
+ */
+export function parseCommandFrontmatter(content) {
+    // The opening fence must be the very first line. Bail to `{}` when there is no fenced block.
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---")
+        return {};
+    const out = {};
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim() === "---")
+            break; // closing fence — stop
+        const m = /^([A-Za-z][\w-]*)\s*:\s*(.*)$/.exec(line);
+        if (!m)
+            continue; // not a `key: value` line — skip (lists/comments/blanks)
+        const key = m[1].toLowerCase();
+        if (key !== "description" && key !== "argument-hint")
+            continue;
+        let value = m[2].trim();
+        // Strip a single pair of matching surrounding quotes.
+        if (value.length >= 2 &&
+            ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'")))) {
+            value = value.slice(1, -1);
+        }
+        if (value.length === 0)
+            continue;
+        if (key === "description")
+            out.description = value;
+        else
+            out.argumentHint = value; // `argument-hint` → camelCase `argumentHint`
+    }
+    return out;
+}
+/**
+ * Resolve a single command `*.md` file into an {@link AvailableCommand}, or `null` when it cannot
+ * contribute a SAFE entry. The name is the filename stem, run through the R3 allowlist — the file is
+ * DROPPED (→ `null`) on any failure, including an unreadable file (NEVER throws). `description` defaults
+ * to `""` (the SDK REQUIRES it) when absent; an `argument-hint` maps to `input: { hint }`, which is
+ * OMITTED entirely when there is none.
+ */
+function resolveEntry(dir, filename, readFile) {
+    const name = baseName(filename);
+    // SECURITY (R3): drop any entry whose name escapes the allowlist — optional debug log, never a throw.
+    if (!isSafeCommandName(name)) {
+        if (process.env.FORK_COMMAND_DEBUG === "1") {
+            process.stderr.write(`[command-catalog] dropped unsafe command name: ${JSON.stringify(name)}\n`);
+        }
+        return null;
+    }
+    let fm;
+    try {
+        fm = parseCommandFrontmatter(readFile(join(dir, filename)));
+    }
+    catch {
+        return null; // unreadable file — skip it, never throw (R3 / R5 graceful)
+    }
+    const description = fm.description ?? ""; // AvailableCommand.description is REQUIRED
+    return {
+        name,
+        description,
+        ...(fm.argumentHint ? { input: { hint: fm.argumentHint } } : {}), // OMIT `input` when no hint
+    };
+}
+/**
+ * Resolve a single skill sub-directory into an {@link AvailableCommand}, or `null` when it cannot
+ * contribute a SAFE entry (R7 / R7.1). The name is the DIRECTORY name `subdirName`, run through the R3
+ * allowlist — DROPPED (→ `null`, same optional `FORK_COMMAND_DEBUG` log as {@link resolveEntry}) on any
+ * failure. The skill's `SKILL.md` is REQUIRED: `join(skillsDir, subdirName, "SKILL.md")` is read inside
+ * a try/catch and a subdir WITHOUT one (`readFile` throws) is NOT a skill (→ `null`, never throws).
+ * `description` is the `SKILL.md` frontmatter `description` (default `""` when absent). Skills carry NO
+ * `argument-hint`, so the entry is `{ name, description }` — no `input`.
+ */
+function resolveSkillEntry(skillsDir, subdirName, readFile) {
+    const name = subdirName;
+    // SECURITY (R3): drop any skill whose dir name escapes the allowlist — optional debug log, never a throw.
+    if (!isSafeCommandName(name)) {
+        if (process.env.FORK_COMMAND_DEBUG === "1") {
+            process.stderr.write(`[command-catalog] dropped unsafe skill name: ${JSON.stringify(name)}\n`);
+        }
+        return null;
+    }
+    let fm;
+    try {
+        fm = parseCommandFrontmatter(readFile(join(skillsDir, subdirName, "SKILL.md")));
+    }
+    catch {
+        return null; // no readable SKILL.md — NOT a skill, skip it, never throw (R7 guard / R5 graceful)
+    }
+    const description = fm.description ?? ""; // AvailableCommand.description is REQUIRED
+    return { name, description }; // skills have no argument-hint → no `input`
+}
+/** Sort entries by `name` for a stable, scope-independent ordering (parity with `sortByValue`). */
+function sortByName(entries) {
+    return entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+/**
+ * Read the set of ENABLED plugin MARKETPLACES from `~/.claude/plugins/installed_plugins.json` (R8). The
+ * gate is intentionally PRESENCE-in-the-manifest: per R8's explicitly-named source, an INSTALLED plugin
+ * == an ENABLED plugin for this story (a finer `settings.json` → `enabledPlugins` gate is out of scope).
+ *
+ * The real manifest shape is `{ version, plugins: { "<name>@<marketplace>": [ { installPath, … }, … ] } }`
+ * — a marketplace is enabled iff at least one `<name>@<marketplace>` key maps to a NON-EMPTY install
+ * array. Everything here is DEFENSIVE against manifest-shape drift (R8 risk): a MISSING or MALFORMED
+ * manifest, a non-object `plugins`, or any key/value that doesn't fit is treated as "disabled" and simply
+ * contributes nothing — this NEVER throws (an unreadable/parse failure degrades to the empty set → all
+ * plugins skipped).
+ *
+ * @param home     the resolved home dir (the manifest lives under `home/.claude/plugins`).
+ * @param readFile the injectable UTF-8 file reader (throws on a missing manifest — caught here).
+ * @returns the set of enabled marketplace names (EMPTY when the manifest is absent/malformed).
+ */
+function readEnabledMarketplaces(home, readFile) {
+    const path = join(home, ".claude", "plugins", "installed_plugins.json");
+    let parsed;
+    try {
+        parsed = JSON.parse(readFile(path));
+    }
+    catch {
+        return new Set(); // missing or malformed manifest → no enabled marketplaces (plugins skipped)
+    }
+    const enabled = new Set();
+    // `plugins` must be a plain, non-null object; anything else (array, primitive, null, absent) → empty.
+    const plugins = parsed?.plugins;
+    if (typeof plugins !== "object" || plugins === null || Array.isArray(plugins))
+        return enabled;
+    for (const [key, value] of Object.entries(plugins)) {
+        // An installed plugin: a `<name>@<marketplace>` key mapping to a NON-EMPTY install array.
+        if (!Array.isArray(value) || value.length === 0)
+            continue; // treat "not installed" as disabled
+        const at = key.lastIndexOf("@"); // marketplace = substring AFTER the last `@`
+        if (at < 0)
+            continue;
+        const marketplace = key.slice(at + 1);
+        if (marketplace.length > 0)
+            enabled.add(marketplace);
+    }
+    return enabled;
+}
+/**
+ * Discover the custom slash-commands to advertise via ACP `available_commands` — FULLY OFFLINE (no
+ * subprocess, no network).
+ *
+ * TIERS, highest precedence first:
+ *   1. `<cwd>/.claude/commands/*.md`      (cwd commands — R1.1 precedence)
+ *   2. `<cwd>/.claude/skills/<name>/SKILL.md` (cwd skills — R7)
+ *   3. `~/.claude/commands/*.md`           (user commands)
+ *   4. `~/.claude/skills/<name>/SKILL.md`   (user skills — R7)
+ *   5. `~/.claude/plugins/marketplaces/<m>/{commands,skills}` (ENABLED-plugin tier — R8; a plugin
+ *      surface loses a name collision to any higher tier — R8.1)
+ *   6. {@link DiscoverCommandsDeps.builtins} (the R9 built-in tier — LOWEST; a built-in loses a name
+ *      collision to any disk entry)
+ *
+ * Each command `*.md` file yields `{ name, description, input? }` (R2): `name` = basename sans `.md`,
+ * `description` = frontmatter `description` (else `""`), `input: { hint }` from `argument-hint` (omitted
+ * when absent). Each skill `<name>/SKILL.md` yields `{ name, description }` (no `input`): `name` = the
+ * DIRECTORY name, `description` = the `SKILL.md` frontmatter (R7 / R7.1). Every name is dropped if it
+ * fails the R3 {@link SAFE_COMMAND_NAME} allowlist. Names are deduped FIRST-WINS across the ordered
+ * surfaces — so a cwd command out-ranks a cwd skill (cmd > skill, same scope), any cwd surface
+ * out-ranks any user surface, an enabled-plugin surface out-ranks the built-ins but LOSES to any
+ * cwd/user surface (R8.1) — then the merged set is returned FLAT ALPHABETICAL by `name`.
+ *
+ * Never throws (R3 / R5): a missing/unreadable dir or file yields `[]` for that surface; a skills subdir
+ * without a readable `SKILL.md` is skipped.
+ *
+ * @param cwd  the SESSION cwd (project dir) whose `.claude/{commands,skills}` take precedence.
+ * @param deps injectable fs/home/builtins seams (default: `node:` stdlib + {@link BUILTIN_COMMANDS}).
+ */
+export function discoverCommands(cwd, deps = {}) {
+    const homedir = deps.homedir ?? osHomedir;
+    const readdirMd = deps.readdirMd ?? defaultReaddirMd;
+    const readdirDirs = deps.readdirDirs ?? defaultReaddirDirs;
+    const readFile = deps.readFile ?? defaultReadFile;
+    const builtins = deps.builtins ?? BUILTIN_COMMANDS;
+    const home = homedir();
+    // Ordered disk surfaces (highest precedence first) — commands scanned via `readdirMd`+`resolveEntry`,
+    // skills via `readdirDirs`+`resolveSkillEntry`. A cwd command outranks a cwd skill; any cwd surface
+    // outranks any user surface (R1.1 / R7). The plugin tier (R8) slots in AFTER these, before builtins.
+    const userSources = [
+        { kind: "commands", dir: join(cwd, ".claude", "commands") }, // cwd commands — highest
+        { kind: "skills", dir: join(cwd, ".claude", "skills") }, // cwd skills
+        { kind: "commands", dir: join(home, ".claude", "commands") }, // user commands
+        { kind: "skills", dir: join(home, ".claude", "skills") }, // user skills
+    ];
+    const byName = new Map();
+    const add = (entry) => {
+        if (entry && !byName.has(entry.name))
+            byName.set(entry.name, entry);
+    };
+    // Fold one ordered disk surface into `byName` (first-wins): a commands dir via `readdirMd`, a skills
+    // dir via `readdirDirs`. Shared by the user tier and the per-marketplace plugin tier.
+    const foldSource = (source) => {
+        if (source.kind === "commands") {
+            for (const filename of readdirMd(source.dir))
+                add(resolveEntry(source.dir, filename, readFile));
+        }
+        else {
+            for (const subdir of readdirDirs(source.dir))
+                add(resolveSkillEntry(source.dir, subdir, readFile));
+        }
+    };
+    for (const source of userSources)
+        foldSource(source);
+    // Plugin tier (R8), AFTER the user surfaces and BEFORE builtins — gated to ENABLED marketplaces per
+    // `installed_plugins.json`. For each enabled marketplace (dirs already sorted), fold its `commands`
+    // then its `skills`; first-wins means any plugin name already claimed by a cwd/user surface is DROPPED
+    // (R8.1). A missing marketplaces dir / manifest degrades to skipping plugins (never throws).
+    const marketplacesDir = join(home, ".claude", "plugins", "marketplaces");
+    const enabled = readEnabledMarketplaces(home, readFile);
+    for (const m of readdirDirs(marketplacesDir)) {
+        if (!enabled.has(m))
+            continue; // treat a not-installed marketplace as disabled
+        foldSource({ kind: "commands", dir: join(marketplacesDir, m, "commands") });
+        foldSource({ kind: "skills", dir: join(marketplacesDir, m, "skills") });
+    }
+    // Built-in tier LAST (lowest precedence): a built-in whose name already appeared on disk is dropped.
+    for (const cmd of builtins) {
+        if (isSafeCommandName(cmd.name) && !byName.has(cmd.name))
+            byName.set(cmd.name, cmd);
+    }
+    return sortByName([...byName.values()]);
+}

package/dist/diff-enriched-reader.d.ts

@@ -38,4 +38,3 @@ export interface DiffEnrichedReaderOptions {
  * @returns a {@link GetMessages} that yields the base messages with `toolUseResult` hydrated by uuid.
  */
 export declare function createDiffEnrichedReader(base: GetMessages, opts?: DiffEnrichedReaderOptions): GetMessages;
-//# sourceMappingURL=diff-enriched-reader.d.ts.map

package/dist/diff-source.d.ts

@@ -101,4 +101,3 @@ export interface DiffToolCallUpdate {
  *   diff content (an unsupported/not-a-diff-source source, or a translation with no `content`).
  */
 export declare function diffToolCallUpdate(source: DiffSource, toolCallId: string): DiffToolCallUpdate | null;
-//# sourceMappingURL=diff-source.d.ts.map

package/dist/drift-checks.d.ts

@@ -54,4 +54,3 @@ export declare function checkJsonlShape(lines: ReadonlyArray<Record<string, unkn
  * allow-inject.ts:29 `KEYSTROKE_YES`. Pure: depends only on `keystroke`.
  */
 export declare function checkAllowKeystroke(keystroke: string): CheckResult;
-//# sourceMappingURL=drift-checks.d.ts.map

package/dist/end-of-turn.d.ts

@@ -175,4 +175,3 @@ export interface TurnResolver {
  * late boundary cannot produce a second settlement).
  */
 export declare function createTurnResolver(opts?: TurnResolverOptions): TurnResolver;
-//# sourceMappingURL=end-of-turn.d.ts.map

package/dist/engine-lifecycle.d.ts

@@ -303,4 +303,3 @@ export interface CreateSessionEngineOptions {
  * ──────────────────────────────────────────────────────────────────────────────────────────────
  */
 export declare function createSessionEngine(opts: CreateSessionEngineOptions): SessionEngine;
-//# sourceMappingURL=engine-lifecycle.d.ts.map

package/dist/engine-pty.d.ts

@@ -218,4 +218,3 @@ export declare const CLEAR_INPUT_DELAY_MS = 60;
  * try/catch); the payload and `\r` writes are scheduled and post-exit-safe.
  */
 export declare function sendPrompt(p: IPty, text: string, schedule?: (fn: () => void, ms: number) => void): void;
-//# sourceMappingURL=engine-pty.d.ts.map

package/dist/engine-watcher.d.ts

@@ -80,4 +80,3 @@ export interface JsonlWatcher extends SessionWatcher {
  * @returns a {@link JsonlWatcher} (a {@link SessionWatcher} plus `notifyEndOfTurn`).
  */
 export declare function createJsonlWatcher(opts: JsonlWatcherOptions): JsonlWatcher;
-//# sourceMappingURL=engine-watcher.d.ts.map

package/dist/engine.d.ts

@@ -27,4 +27,3 @@ export declare class StubEngine implements Engine {
 }
 /** Factory for the default story-011 engine (the no-op stub). */
 export declare function createStubEngine(): Engine;
-//# sourceMappingURL=engine.d.ts.map

package/dist/event-switch.d.ts

@@ -161,4 +161,3 @@ export type EventClassification = ContentClassification | LifecycleClassificatio
  */
 export declare function classifyEvent(event: JsonlEvent, opts?: ClassifyOptions): EventClassification;
 export {};
-//# sourceMappingURL=event-switch.d.ts.map

package/dist/gate/port.d.ts

@@ -35,4 +35,3 @@ export type ServerFactory = () => PortServer;
  *   the last bind error.
  */
 export declare function findFreePort(attempts?: number, makeServer?: ServerFactory): Promise<number>;
-//# sourceMappingURL=port.d.ts.map

package/dist/gate/settings-writer.d.ts

@@ -158,4 +158,3 @@ export declare function restore(backup: Backup): Promise<RestoreResult>;
  *   (ENOENT → treated as `{}`), mirroring the rest of the module's discipline.
  */
 export declare function applyUltracodeSettings(settingsPath: string, active: boolean): Promise<void>;
-//# sourceMappingURL=settings-writer.d.ts.map

package/dist/image-input.d.ts

@@ -28,4 +28,3 @@ export declare function materializeImage(data: string, mimeType: string | undefi
  * (no image materialized this turn) returns immediately.
  */
 export declare function cleanupMaterializedImages(paths: readonly string[] | undefined): void;
-//# sourceMappingURL=image-input.d.ts.map

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

@@ -49,4 +49,3 @@ export declare function imageVisionSmoke(version: string | null | undefined): Vi
  * 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/index.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/jsonl.d.ts

@@ -264,4 +264,3 @@ export declare function stripHeavyImages(message: unknown, imageSkipBytes?: numb
  * @returns the typed {@link JsonlEvent}.
  */
 export declare function projectEvent(message: unknown, opts?: ProjectOptions): JsonlEvent;
-//# sourceMappingURL=jsonl.d.ts.map

package/dist/lib.d.ts

@@ -3,4 +3,3 @@ export { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./u
 export { toolInfoFromToolUse, toDisplayPath, planEntries, toolUpdateFromToolResult, } from "./tools.js";
 export { SettingsManager, type SettingsManagerOptions } from "./settings.js";
 export type { ClaudePlanEntry } from "./tools.js";
-//# sourceMappingURL=lib.d.ts.map

package/dist/linearize.d.ts

@@ -137,7 +137,7 @@ export declare function readOrderedMessages(sessionId: string, dir: string | und
  * Exported (story 043 R2.1) so acp-agent.ts can reuse it as the PRODUCTION reduced base it wraps in
  * the diff-enriched reader when `liveDiff` is ON (it is the same reduced reader `readOrderedMessages`
  * already falls back to). linearize.ts is a fork module imported directly from ../dist/ — NOT via
- * lib.ts, whose public surface is frozen to upstream v0.39.0 — so this export is safe.
+ * lib.ts, whose public surface is frozen to upstream v0.53.0 — so this export is safe.
  */
 export declare function defaultGetMessages(sessionId: string, opts?: {
     dir?: string;
@@ -216,4 +216,3 @@ export interface EndOfTurnBinding {
  * @returns an {@link EndOfTurnBinding} (`notifyEndOfTurn` + `stop`).
  */
 export declare function bindEndOfTurnReparse(opts: BindEndOfTurnOptions): EndOfTurnBinding;
-//# sourceMappingURL=linearize.d.ts.map

package/dist/linearize.js

@@ -277,7 +277,7 @@ export async function readOrderedMessages(sessionId, dir, opts = {}) {
  * Exported (story 043 R2.1) so acp-agent.ts can reuse it as the PRODUCTION reduced base it wraps in
  * the diff-enriched reader when `liveDiff` is ON (it is the same reduced reader `readOrderedMessages`
  * already falls back to). linearize.ts is a fork module imported directly from ../dist/ — NOT via
- * lib.ts, whose public surface is frozen to upstream v0.39.0 — so this export is safe.
+ * lib.ts, whose public surface is frozen to upstream v0.53.0 — so this export is safe.
  */
 export async function defaultGetMessages(sessionId, opts) {
     const sdk = await import("@anthropic-ai/claude-agent-sdk");

package/dist/live-diff-env.d.ts

@@ -4,4 +4,3 @@
  * index.ts calls this so the truth table is unit-checkable without running the entrypoint.
  */
 export declare function liveDiffEnabled(env?: Record<string, string | undefined>): boolean;
-//# sourceMappingURL=live-diff-env.d.ts.map

package/dist/live-subagent-env.d.ts

@@ -4,4 +4,3 @@
  * index.ts calls this so the truth table is unit-checkable without running the entrypoint.
  */
 export declare function liveSubagentWatchEnabled(env?: Record<string, string | undefined>): boolean;
-//# sourceMappingURL=live-subagent-env.d.ts.map

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

@@ -58,4 +58,3 @@ export declare function writeMcpScratch(config: ClaudeMcpConfig): Promise<string
  * @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/model-catalog.d.ts

@@ -33,6 +33,44 @@ export declare const ULTRACODE_EFFORT_LABEL = "ultracode (xhigh + orchestration)
  * (the SDK signal `reconcileModeFromTranscript` clamps), so haiku/opusplan omit it.
  */
 export declare const MODEL_CATALOG: ModelInfo[];
+/**
+ * Story 068 (R1, R1.1, R2) — the REAL per-alias context window, keyed by the EXACT {@link MODEL_CATALOG}
+ * `value`. These windows are NOT uniform: `opus` is natively 1M, `sonnet`/`haiku` are 200K, and
+ * `sonnet[1m]` is the explicit 1M variant. This map is the single source of truth that
+ * `inferContextWindowFromModel` (acp-agent.ts) consults BEFORE the `\b1m\b` regex fallback — the bug it
+ * fixes is `opus` having wrongly reported 200K (the regex only ever matched the literal `1m` token).
+ *
+ * Story 069 (R2): `default` and `opusplan` seed to 1M — `default` is the recommended Opus (the claude TUI's
+ * `/model default` resolves to `claude-opus-4-8[1m]`, a 1M model) and `opusplan` plans with Opus. This is
+ * only the PRE-FIRST-TURN seed: once a turn arrives, `inferContextWindowFromModelId` (story 069)
+ * AUTHORITATIVELY refines the window from the transcript's real `model`. Keys MIRROR `MODEL_CATALOG`
+ * `value`s; the drift guard lives in the test (068 anti-drift: every catalog value has an explicit entry).
+ */
+export declare const MODEL_CONTEXT_WINDOWS: Record<string, number>;
+/**
+ * Story 069 (R1.1) — the REAL context window per concrete model ID, mirroring the claude CLI's
+ * `context:{window}` table. Used to AUTHORITATIVELY refine the window from a turn's actual `model`
+ * (the JSONL `model` field), correcting the alias seed. Opus is NOT uniform: 4.6 = 200K, 4.7+ = 1M.
+ * Dated snapshots / future versions are covered by the family+version heuristic in
+ * `inferContextWindowFromModelId`; this table is the exact-ID source of truth for today's gateway IDs.
+ */
+export declare const MODEL_ID_CONTEXT_WINDOWS: Record<string, number>;
+/**
+ * Story 072 — the version/context PREFIX the claude `/model` picker now shows before the static tagline
+ * (e.g. "Opus 4.8 with 1M context · Best for everyday, complex tasks"). Keyed by catalog `value`.
+ *
+ * CURATED + DRIFT-PRONE, exactly like MODEL_CATALOG membership: the fork holds only aliases pre-turn and
+ * cannot derive the concrete version (the SDK `supportedModels()` was cut), so these MIRROR the LIVE
+ * picker and MUST be re-verified on each model launch (source: the user's live `/model` output). The
+ * static tagline stays on `ModelInfo.description` (069 R3 untouched); this only prepends "<version> · ".
+ * `opusplan` is intentionally absent — its tagline ("Use Opus in plan mode, Sonnet otherwise") already
+ * names the models, so it renders bare.
+ */
+export declare const MODEL_VERSION_LABELS: Record<string, string>;
+/**
+ * Story 072 — compose the Zed selector description: "<version label> · <tagline>", or the bare tagline
+ * when no label exists (e.g. `opusplan`). PURE + TOTAL: never throws on a missing label or tagline.
+ */
+export declare function modelSelectorDescription(info: ModelInfo): string;
 /** The safe fallback entry, kept as a named export so callers can seed/anchor on it without a lookup. */
 export declare const DEFAULT_MODEL_INFO: ModelInfo;
-//# sourceMappingURL=model-catalog.d.ts.map