@longtable/cli 0.1.48 → 0.1.49

package/dist/cli.js

@@ -17,7 +17,7 @@ import { installCodexPromptAliases, listInstalledCodexPromptAliases, removeCodex
 import { buildPersonaGuidance, parseInvocationDirective } from "./persona-router.js";
 import { PERSONA_DEFINITIONS, listRoleDefinitions } from "./personas.js";
 import { buildPanelFallback, renderPanelSummary } from "./panel.js";
-import { LONGTABLE_MANAGED_HOOK_EVENTS, codexHooksEnabled, enableCodexHooksFeature, getMissingManagedCodexHookEvents, mergeManagedCodexHooksConfig, removeManagedCodexHooks } from "./codex-hooks.js";
+import { LONGTABLE_MANAGED_HOOK_EVENTS, codexHooksEnabled, enableCodexHooksFeature, getMissingManagedCodexHookEvents, getMissingManagedCodexHookTrustState, mergeCodexHookTrustState, mergeManagedCodexHooksConfig, removeCodexHookTrustState, removeManagedCodexHooks } from "./codex-hooks.js";
 import { appendInvocationRecordToWorkspace, applyResearchSpecificationPatch, assertWorkspaceNotBlocked, answerWorkspaceQuestion, buildQuestionOpportunitySpecs, clearWorkspaceQuestion, createWorkspaceFollowUpQuestions, createWorkspaceQuestion, createOrUpdateProjectWorkspace, diffResearchSpecifications, inspectProjectWorkspace, loadWorkspaceState, loadProjectContextFromDirectory, findUnincorporatedResearchEvidence, proposeResearchSpecificationPatch, pruneWorkspaceQuestions, readResearchSpecificationHistory, repairWorkspaceStateConsistency, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.js";
 import { buildTeamDebate, buildTeamReview, renderTeamDebateSummary } from "./debate.js";
 import { createPromptRenderer } from "./prompt-renderer.js";
@@ -1325,8 +1325,9 @@ async function installCodexNativeHooks(args) {
     const packageRoot = resolveCliPackageRoot();
     const existingConfig = existsSync(configPath) ? await readFile(configPath, "utf8") : "";
     const existingHooks = existsSync(hooksPath) ? await readFile(hooksPath, "utf8") : "";
-    const nextConfig = enableCodexHooksFeature(existingConfig);
     const nextHooks = mergeManagedCodexHooksConfig(existingHooks, packageRoot);
+    const configWithHooksFeature = enableCodexHooksFeature(existingConfig, "hooks");
+    const nextConfig = mergeCodexHookTrustState(configWithHooksFeature, hooksPath, nextHooks);
     await mkdir(dirname(configPath), { recursive: true });
     await mkdir(dirname(hooksPath), { recursive: true });
     await writeFile(configPath, nextConfig, "utf8");
@@ -1336,14 +1337,21 @@ async function installCodexNativeHooks(args) {
         hooksPath,
         codexHooksEnabled: codexHooksEnabled(nextConfig),
         managedEvents: [...LONGTABLE_MANAGED_HOOK_EVENTS],
+        managedTrustEntries: getMissingManagedCodexHookTrustState("", hooksPath, nextHooks).length,
         write: true
     };
 }
 async function removeCodexNativeHooks(args) {
     const configPath = resolveCodexMcpConfigPath(args);
     const hooksPath = resolveCodexHooksPath(args);
+    const configContent = existsSync(configPath) ? await readFile(configPath, "utf8") : "";
     const existingHooks = existsSync(hooksPath) ? await readFile(hooksPath, "utf8") : "";
+    const nextConfig = existingHooks
+        ? removeCodexHookTrustState(configContent, hooksPath, existingHooks)
+        : configContent;
     const removed = existingHooks ? removeManagedCodexHooks(existingHooks) : { nextContent: null, removedCount: 0 };
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, nextConfig, "utf8");
     if (removed.nextContent === null) {
         await rm(hooksPath, { force: true });
     }
@@ -1351,12 +1359,12 @@ async function removeCodexNativeHooks(args) {
         await mkdir(dirname(hooksPath), { recursive: true });
         await writeFile(hooksPath, removed.nextContent, "utf8");
     }
-    const configContent = existsSync(configPath) ? await readFile(configPath, "utf8") : "";
     return {
         configPath,
         hooksPath,
-        codexHooksEnabled: codexHooksEnabled(configContent),
+        codexHooksEnabled: codexHooksEnabled(nextConfig),
         managedEvents: removed.removedCount > 0 ? [...LONGTABLE_MANAGED_HOOK_EVENTS] : [],
+        managedTrustEntries: 0,
         write: true
     };
 }
@@ -1365,8 +1373,9 @@ function renderCodexHookInstallSummary(result) {
         "LongTable Codex hooks",
         `- config: ${result.configPath}`,
         `- hooks: ${result.hooksPath}`,
-        `- codex_hooks feature: ${result.codexHooksEnabled ? "enabled" : "missing"}`,
-        `- managed events: ${result.managedEvents.length > 0 ? result.managedEvents.join(", ") : "none"}`
+        `- hooks feature: ${result.codexHooksEnabled ? "enabled" : "missing"}`,
+        `- managed events: ${result.managedEvents.length > 0 ? result.managedEvents.join(", ") : "none"}`,
+        `- managed trust entries: ${result.managedTrustEntries}`
     ].join("\n");
 }
 function renderMcpInstallSummary(result) {
@@ -1565,6 +1574,9 @@ async function collectDoctorStatus(args) {
     const missingManagedHookEvents = codexHooksContent
         ? (getMissingManagedCodexHookEvents(codexHooksContent) ?? [...LONGTABLE_MANAGED_HOOK_EVENTS])
         : [...LONGTABLE_MANAGED_HOOK_EVENTS];
+    const missingManagedHookTrustState = codexHooksContent
+        ? getMissingManagedCodexHookTrustState(codexMcpConfig, codexHooksPath, codexHooksContent)
+        : [];
     const expectedCodexSkills = buildCodexSkillSpecs(roles, skillSurface).map((skill) => skill.name);
     const expectedClaudeSkills = buildClaudeSkillSpecs(roles, skillSurface).map((skill) => skill.name);
     const [codexSkills, claudeSkills, codexAliases, workspace] = await Promise.all([
@@ -1601,7 +1613,8 @@ async function collectDoctorStatus(args) {
                 hooksPath: codexHooksPath,
                 hooksExists: existsSync(codexHooksPath),
                 codexHooksEnabled: codexHooksEnabled(codexMcpConfig),
-                missingManagedHookEvents
+                missingManagedHookEvents,
+                missingManagedHookTrustState
             },
             claude: {
                 command: "claude",
@@ -1649,8 +1662,9 @@ function renderDoctorStatus(status) {
             : ["- Research Specification MCP tools: complete"]),
         `- MCP elicitation approval: ${status.providers.codex.mcpElicitationsAllowed ? "allowed" : "not allowed"}`,
         `- Codex hooks file: ${status.providers.codex.hooksExists ? "present" : "missing"} (${status.providers.codex.hooksPath})`,
-        `- codex_hooks feature: ${status.providers.codex.codexHooksEnabled ? "enabled" : "missing"}`,
+        `- hooks feature: ${status.providers.codex.codexHooksEnabled ? "enabled" : "missing"}`,
         `- managed hook coverage: ${status.providers.codex.missingManagedHookEvents.length === 0 ? "complete" : `missing ${status.providers.codex.missingManagedHookEvents.join(", ")}`}`,
+        `- managed hook trust: ${status.providers.codex.missingManagedHookTrustState.length === 0 ? "current" : `missing/stale ${status.providers.codex.missingManagedHookTrustState.length}`}`,
         "",
         ...renderProviderDoctorBlock("Claude", status.providers.claude),
         "",
@@ -1700,12 +1714,15 @@ function renderDoctorStatus(status) {
         status.providers.codex.missingMcpTools.length > 0 ||
         !status.providers.codex.codexHooksEnabled ||
         status.providers.codex.missingManagedHookEvents.length > 0 ||
+        status.providers.codex.missingManagedHookTrustState.length > 0 ||
         (status.setupExists &&
             (!status.providers.codex.runtimeExists || !status.providers.claude.runtimeExists));
     if (canFix) {
         nextActions.push("longtable doctor --fix");
     }
-    if (!status.providers.codex.codexHooksEnabled || status.providers.codex.missingManagedHookEvents.length > 0) {
+    if (!status.providers.codex.codexHooksEnabled ||
+        status.providers.codex.missingManagedHookEvents.length > 0 ||
+        status.providers.codex.missingManagedHookTrustState.length > 0) {
         nextActions.push("longtable codex install-hooks");
     }
     if (!status.providers.codex.longtableMcpConfigured ||
@@ -1832,7 +1849,9 @@ async function repairDoctorStatus(args, status) {
     if (status.providers.codex.legacyPromptFilesInstalled.length > 0) {
         repair.removedLegacyPromptFiles = await removeCodexPromptAliases(codexPromptsDir);
     }
-    if (!status.providers.codex.codexHooksEnabled || status.providers.codex.missingManagedHookEvents.length > 0) {
+    if (!status.providers.codex.codexHooksEnabled ||
+        status.providers.codex.missingManagedHookEvents.length > 0 ||
+        status.providers.codex.missingManagedHookTrustState.length > 0) {
         await installCodexNativeHooks(args);
         repair.installedCodexHooks = true;
     }
@@ -3773,7 +3792,10 @@ async function runCodexSubcommand(subcommand, args) {
             hooksExists: existsSync(hooksPath),
             missingManagedHookEvents: hooksContent
                 ? (getMissingManagedCodexHookEvents(hooksContent) ?? [...LONGTABLE_MANAGED_HOOK_EVENTS])
-                : [...LONGTABLE_MANAGED_HOOK_EVENTS]
+                : [...LONGTABLE_MANAGED_HOOK_EVENTS],
+            missingManagedHookTrustState: hooksContent
+                ? getMissingManagedCodexHookTrustState(configContent, hooksPath, hooksContent)
+                : []
         };
         if (args.json === true) {
             console.log(JSON.stringify(status, null, 2));
@@ -3805,9 +3827,10 @@ async function runCodexSubcommand(subcommand, args) {
             }
         }
         console.log(`- codex config: ${status.codexConfigPath}`);
-        console.log(`- codex_hooks feature: ${status.codexHooksEnabled ? "enabled" : "missing"}`);
+        console.log(`- hooks feature: ${status.codexHooksEnabled ? "enabled" : "missing"}`);
         console.log(`- hooks file: ${status.hooksExists ? "present" : "missing"} (${status.hooksPath})`);
         console.log(`- managed hook coverage: ${status.missingManagedHookEvents.length === 0 ? "complete" : `missing ${status.missingManagedHookEvents.join(", ")}`}`);
+        console.log(`- managed hook trust: ${status.missingManagedHookTrustState.length === 0 ? "current" : `missing/stale ${status.missingManagedHookTrustState.length}`}`);
         return;
     }
     throw new Error("Unknown codex subcommand.");

package/dist/codex-hooks.d.ts

@@ -1,4 +1,4 @@
-export declare const LONGTABLE_MANAGED_HOOK_EVENTS: readonly ["SessionStart", "PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop"];
+export declare const LONGTABLE_MANAGED_HOOK_EVENTS: readonly ["SessionStart", "PreToolUse", "PostToolUse", "UserPromptSubmit", "PreCompact", "PostCompact", "Stop"];
 type ManagedHookEventName = (typeof LONGTABLE_MANAGED_HOOK_EVENTS)[number];
 type JsonObject = Record<string, unknown>;
 export interface ManagedCodexHooksConfig {
@@ -12,11 +12,18 @@ export interface RemoveManagedCodexHooksResult {
     nextContent: string | null;
     removedCount: number;
 }
+export interface CodexHookTrustStateEntry {
+    trusted_hash: string;
+}
 export declare function buildManagedCodexHooksConfig(packageRoot: string): ManagedCodexHooksConfig;
 export declare function parseCodexHooksConfig(content: string): ParsedCodexHooksConfig | null;
 export declare function getMissingManagedCodexHookEvents(content: string): ManagedHookEventName[] | null;
+export declare function buildManagedCodexHookTrustState(hooksPath: string, hooksContent: string): Record<string, CodexHookTrustStateEntry>;
+export declare function mergeCodexHookTrustState(config: string, hooksPath: string, hooksContent: string): string;
+export declare function removeCodexHookTrustState(config: string, hooksPath: string, hooksContent: string): string;
+export declare function getMissingManagedCodexHookTrustState(config: string, hooksPath: string, hooksContent: string): string[];
 export declare function mergeManagedCodexHooksConfig(existingContent: string | null | undefined, packageRoot: string): string;
 export declare function removeManagedCodexHooks(existingContent: string): RemoveManagedCodexHooksResult;
-export declare function enableCodexHooksFeature(existing: string): string;
+export declare function enableCodexHooksFeature(existing: string, featureFlag?: string): string;
 export declare function codexHooksEnabled(config: string): boolean;
 export {};

package/dist/codex-hooks.js

@@ -1,11 +1,23 @@
+import { createHash } from "node:crypto";
 import { join } from "node:path";
 export const LONGTABLE_MANAGED_HOOK_EVENTS = [
     "SessionStart",
     "PreToolUse",
     "PostToolUse",
     "UserPromptSubmit",
+    "PreCompact",
+    "PostCompact",
     "Stop"
 ];
+const CODEX_HOOK_EVENT_LABELS = {
+    SessionStart: "session_start",
+    PreToolUse: "pre_tool_use",
+    PostToolUse: "post_tool_use",
+    UserPromptSubmit: "user_prompt_submit",
+    PreCompact: "pre_compact",
+    PostCompact: "post_compact",
+    Stop: "stop"
+};
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -51,6 +63,12 @@ export function buildManagedCodexHooksConfig(packageRoot) {
                     statusMessage: "Applying LongTable research context"
                 })
             ],
+            PreCompact: [
+                buildCommandHook(command)
+            ],
+            PostCompact: [
+                buildCommandHook(command)
+            ],
             Stop: [
                 buildCommandHook(command, {
                     timeout: 30
@@ -126,6 +144,152 @@ function stripManagedHooksFromEntry(entry) {
 function serializeCodexHooksConfig(root) {
     return JSON.stringify(root, null, 2) + "\n";
 }
+function canonicalJson(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => canonicalJson(item));
+    }
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.keys(value)
+            .sort()
+            .map((key) => [key, canonicalJson(value[key])]));
+    }
+    return value;
+}
+function versionForCodexTomlIdentity(value) {
+    const serialized = JSON.stringify(canonicalJson(value));
+    return `sha256:${createHash("sha256").update(serialized).digest("hex")}`;
+}
+function normalizedCommandHookIdentity(eventName, entry, hook) {
+    return {
+        event_name: CODEX_HOOK_EVENT_LABELS[eventName],
+        ...(typeof entry.matcher === "string" ? { matcher: entry.matcher } : {}),
+        hooks: [
+            {
+                type: "command",
+                command: hook.command,
+                timeout: Math.max(1, typeof hook.timeout === "number" ? hook.timeout : 600),
+                async: false,
+                ...(typeof hook.statusMessage === "string" ? { statusMessage: hook.statusMessage } : {})
+            }
+        ]
+    };
+}
+function managedHookStateKey(hooksPath, eventName, groupIndex, handlerIndex) {
+    return `${hooksPath}:${CODEX_HOOK_EVENT_LABELS[eventName]}:${groupIndex}:${handlerIndex}`;
+}
+export function buildManagedCodexHookTrustState(hooksPath, hooksContent) {
+    const parsed = parseCodexHooksConfig(hooksContent);
+    if (!parsed) {
+        return {};
+    }
+    const state = {};
+    for (const eventName of LONGTABLE_MANAGED_HOOK_EVENTS) {
+        const entries = Array.isArray(parsed.hooks[eventName]) ? parsed.hooks[eventName] : [];
+        entries.forEach((entry, groupIndex) => {
+            if (!isPlainObject(entry) || !Array.isArray(entry.hooks)) {
+                return;
+            }
+            entry.hooks.forEach((hook, handlerIndex) => {
+                if (!isPlainObject(hook) ||
+                    hook.type !== "command" ||
+                    typeof hook.command !== "string" ||
+                    !isLongTableManagedHookCommand(hook.command)) {
+                    return;
+                }
+                state[managedHookStateKey(hooksPath, eventName, groupIndex, handlerIndex)] = {
+                    trusted_hash: versionForCodexTomlIdentity(normalizedCommandHookIdentity(eventName, entry, hook))
+                };
+            });
+        });
+    }
+    return state;
+}
+function escapeTomlBasicString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function unescapeTomlBasicString(value) {
+    return value.replace(/\\(["\\])/g, "$1");
+}
+function readHooksStateTableKey(line) {
+    const match = line.trim().match(/^\[hooks\.state\."((?:\\.|[^"\\])*)"\]$/);
+    return match ? unescapeTomlBasicString(match[1]) : null;
+}
+function removeHookStateTables(config, shouldRemove) {
+    const lines = config.split(/\r?\n/);
+    const kept = [];
+    for (let index = 0; index < lines.length;) {
+        const key = readHooksStateTableKey(lines[index]);
+        if (!key || !shouldRemove(key)) {
+            kept.push(lines[index]);
+            index += 1;
+            continue;
+        }
+        index += 1;
+        while (index < lines.length && !/^\s*\[/.test(lines[index])) {
+            index += 1;
+        }
+    }
+    return `${kept.join("\n").trimEnd()}\n`;
+}
+function readHookStateTrustedHashes(config) {
+    const lines = config.split(/\r?\n/);
+    const hashes = new Map();
+    for (let index = 0; index < lines.length;) {
+        const key = readHooksStateTableKey(lines[index]);
+        if (!key) {
+            index += 1;
+            continue;
+        }
+        index += 1;
+        while (index < lines.length && !/^\s*\[/.test(lines[index])) {
+            const match = lines[index].trim().match(/^trusted_hash\s*=\s*"([^"]+)"$/);
+            if (match) {
+                hashes.set(key, match[1]);
+            }
+            index += 1;
+        }
+    }
+    return hashes;
+}
+function renderCodexHookTrustToml(state) {
+    return Object.entries(state)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .flatMap(([key, entry]) => [
+        `[hooks.state."${escapeTomlBasicString(key)}"]`,
+        `trusted_hash = "${escapeTomlBasicString(entry.trusted_hash)}"`,
+        ""
+    ])
+        .join("\n")
+        .trimEnd();
+}
+export function mergeCodexHookTrustState(config, hooksPath, hooksContent) {
+    const state = buildManagedCodexHookTrustState(hooksPath, hooksContent);
+    const keys = new Set(Object.keys(state));
+    if (keys.size === 0) {
+        return config.trimEnd() ? `${config.trimEnd()}\n` : "";
+    }
+    const withoutCurrent = removeHookStateTables(config, (key) => keys.has(key)).trimEnd();
+    const trustToml = renderCodexHookTrustToml(state);
+    return withoutCurrent ? `${withoutCurrent}\n\n${trustToml}\n` : `${trustToml}\n`;
+}
+export function removeCodexHookTrustState(config, hooksPath, hooksContent) {
+    const keys = new Set(Object.keys(buildManagedCodexHookTrustState(hooksPath, hooksContent)));
+    if (keys.size === 0) {
+        return config.trimEnd() ? `${config.trimEnd()}\n` : "";
+    }
+    return removeHookStateTables(config, (key) => keys.has(key));
+}
+export function getMissingManagedCodexHookTrustState(config, hooksPath, hooksContent) {
+    const expected = buildManagedCodexHookTrustState(hooksPath, hooksContent);
+    const hashes = readHookStateTrustedHashes(config);
+    const missing = [];
+    for (const [key, entry] of Object.entries(expected)) {
+        if (hashes.get(key) !== entry.trusted_hash) {
+            missing.push(key);
+        }
+    }
+    return missing;
+}
 export function mergeManagedCodexHooksConfig(existingContent, packageRoot) {
     const managedConfig = buildManagedCodexHooksConfig(packageRoot);
     const parsed = typeof existingContent === "string"
@@ -204,22 +368,26 @@ function findSectionBounds(lines, sectionHeader) {
     }
     return { start, end };
 }
-export function enableCodexHooksFeature(existing) {
+function normalizeCodexHookFeatureFlag(value) {
+    return value === "codex_hooks" ? "codex_hooks" : "hooks";
+}
+export function enableCodexHooksFeature(existing, featureFlag) {
+    const flagName = normalizeCodexHookFeatureFlag(featureFlag);
     const trimmed = existing.trimEnd();
     const lines = trimmed ? trimmed.split(/\r?\n/) : [];
     const section = findSectionBounds(lines, "[features]");
     if (!section) {
         return trimmed
-            ? `${trimmed}\n\n[features]\ncodex_hooks = true\n`
-            : "[features]\ncodex_hooks = true\n";
+            ? `${trimmed}\n\n[features]\n${flagName} = true\n`
+            : `[features]\n${flagName} = true\n`;
     }
     const featureLines = lines.slice(section.start + 1, section.end);
-    const existingIndex = featureLines.findIndex((line) => /^\s*codex_hooks\s*=/.test(line));
+    const existingIndex = featureLines.findIndex((line) => new RegExp(`^\\s*${flagName}\\s*=`).test(line));
     if (existingIndex !== -1) {
-        featureLines[existingIndex] = "codex_hooks = true";
+        featureLines[existingIndex] = `${flagName} = true`;
     }
     else {
-        featureLines.push("codex_hooks = true");
+        featureLines.push(`${flagName} = true`);
     }
     const rebuilt = [
         ...lines.slice(0, section.start + 1),
@@ -236,5 +404,5 @@ export function codexHooksEnabled(config) {
     }
     return lines
         .slice(section.start + 1, section.end)
-        .some((line) => /^\s*codex_hooks\s*=\s*true\s*$/.test(line));
+        .some((line) => /^\s*(?:hooks|codex_hooks)\s*=\s*true\s*$/.test(line));
 }

package/dist/longtable-codex-native-hook.js

@@ -21,6 +21,8 @@ function readHookEventName(payload) {
         candidate === "PreToolUse" ||
         candidate === "PostToolUse" ||
         candidate === "UserPromptSubmit" ||
+        candidate === "PreCompact" ||
+        candidate === "PostCompact" ||
         candidate === "Stop") {
         return candidate;
     }
@@ -329,6 +331,31 @@ function sessionStartContext(runtime) {
     sections.push("Treat `.longtable/` state and `CURRENT.md` as the source of truth for this workspace.");
     return sections.filter(Boolean).join("\n\n");
 }
+function postCompactContext(runtime) {
+    const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
+    const blockingObligation = pendingObligations(runtime.state)[0];
+    const interview = activeInterviewHook(runtime.state);
+    if (!blockingQuestion && !blockingObligation && !interview) {
+        return null;
+    }
+    const sections = [buildWorkspaceSummary(runtime, "compact").join("\n")];
+    if (interview) {
+        sections.push(buildActiveInterviewContext(interview));
+        if (blockingQuestion) {
+            sections.push(buildSeparatePendingQuestionNotice(blockingQuestion));
+        }
+        else if (blockingObligation) {
+            sections.push(buildSeparatePendingObligationNotice(blockingObligation));
+        }
+    }
+    else if (blockingQuestion) {
+        sections.push(buildPendingQuestionContext(blockingQuestion));
+    }
+    else if (blockingObligation) {
+        sections.push(buildPendingObligationContext(blockingObligation));
+    }
+    return sections.filter(Boolean).join("\n\n");
+}
 async function userPromptSubmitContext(runtime, prompt) {
     const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
     const blockingObligation = pendingObligations(runtime.state)[0];
@@ -451,6 +478,15 @@ export async function dispatchCodexHook(payload, cwdOverride) {
     if (hookEventName === "PostToolUse") {
         return postToolUseOutput(runtime, payload);
     }
+    if (hookEventName === "PreCompact") {
+        return null;
+    }
+    if (hookEventName === "PostCompact") {
+        const additionalContext = postCompactContext(runtime);
+        return additionalContext
+            ? buildAdditionalContextOutput(hookEventName, additionalContext)
+            : null;
+    }
     if (hookEventName === "Stop") {
         return stopOutput(runtime);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longtable/cli",
-  "version": "0.1.48",
+  "version": "0.1.49",
   "private": false,
   "description": "Researcher-facing LongTable CLI",
   "type": "module",
@@ -29,12 +29,12 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.2.0",
-    "@longtable/checkpoints": "0.1.48",
-    "@longtable/core": "0.1.48",
-    "@longtable/memory": "0.1.48",
-    "@longtable/provider-claude": "0.1.48",
-    "@longtable/provider-codex": "0.1.48",
-    "@longtable/setup": "0.1.48"
+    "@longtable/checkpoints": "0.1.49",
+    "@longtable/core": "0.1.49",
+    "@longtable/memory": "0.1.49",
+    "@longtable/provider-claude": "0.1.49",
+    "@longtable/provider-codex": "0.1.49",
+    "@longtable/setup": "0.1.49"
   },
   "devDependencies": {
     "@types/node": "^22.10.1",