@longtable/cli 0.1.48 → 0.1.50

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/dist/project-session.d.ts

@@ -1,4 +1,4 @@
-import type { DecisionRecord, EvidenceRecord, InvocationRecord, LongTableQuestionObligation, ProviderKind, QuestionOption, QuestionCommitmentFamily, QuestionEpistemicBasis, QuestionGenerationResult, QuestionOpportunity, QuestionSurface, QuestionRecord, ResearchSpecificationChange, ResearchSpecificationPatch, ResearchSpecificationPatchSource, ResearchSpecificationRevision, ResearchState } from "@longtable/core";
+import type { DecisionRecord, EvidenceRecord, InvocationRecord, LongTableQuestionObligation, ProviderKind, QuestionOption, QuestionCommitmentFamily, QuestionEpistemicBasis, QuestionGenerationResult, QuestionOpportunity, QuestionSurface, QuestionPromptType, QuestionRecord, ResearchSpecificationChange, ResearchSpecificationPatch, ResearchSpecificationPatchSource, ResearchSpecificationRevision, ResearchState } from "@longtable/core";
 import type { SetupPersistedOutput } from "@longtable/setup";
 export type ProjectDisagreementPreference = "synthesis_only" | "show_on_conflict" | "always_visible";
 export type StartInterviewSignal = "phenomenon" | "audience" | "artifact" | "evidence" | "assumption" | "decision_risk" | "voice";
@@ -393,8 +393,11 @@ export declare function createWorkspaceQuestion(options: {
     prompt: string;
     title?: string;
     question?: string;
+    type?: QuestionPromptType;
     checkpointKey?: string;
     questionOptions?: QuestionOption[];
+    allowOther?: boolean;
+    otherLabel?: string;
     displayReason?: string;
     provider?: ProviderKind;
     required?: boolean;
@@ -404,10 +407,17 @@ export declare function createWorkspaceQuestion(options: {
     question: QuestionRecord;
     state: ResearchState;
 }>;
+type WorkspaceQuestionAnswerInput = string | string[] | {
+    answer?: string | string[];
+    selectedValue?: string;
+    selectedValues?: string[];
+    otherText?: string;
+    rationale?: string;
+};
 export declare function answerWorkspaceQuestion(options: {
     context: LongTableProjectContext;
     questionId?: string;
-    answer: string;
+    answer: WorkspaceQuestionAnswerInput;
     rationale?: string;
     provider?: "codex" | "claude";
     surface?: QuestionSurface;

package/dist/project-session.js

@@ -2397,6 +2397,7 @@ export async function createWorkspaceQuestion(options) {
         studyContract: state.studyContract
     });
     const checkpointKey = options.checkpointKey ?? trigger.signal.checkpointKey;
+    const promptType = options.type ?? "single_choice";
     const createdAt = nowIso();
     const title = options.title ?? questionTitleForCheckpoint(trigger.family, checkpointKey);
     const questionText = options.question ?? questionTextForCheckpoint(trigger.family, options.prompt, checkpointKey);
@@ -2427,10 +2428,10 @@ export async function createWorkspaceQuestion(options) {
             checkpointKey,
             title,
             question: questionText,
-            type: "single_choice",
+            type: promptType,
             options: options.questionOptions ?? optionsForCheckpointTrigger(trigger.family, checkpointKey),
-            allowOther: true,
-            otherLabel: "Other decision",
+            allowOther: options.allowOther ?? promptType !== "free_text",
+            otherLabel: options.otherLabel ?? "Other decision",
             required: options.required ?? trigger.requiresQuestionBeforeClosure,
             source: "checkpoint",
             displayReason: options.displayReason ?? trigger.rationale[0],
@@ -2486,53 +2487,159 @@ function splitAnswerAndRationale(rawAnswer) {
         ...(rationale ? { rationale } : {})
     };
 }
-function normalizeQuestionAnswerSelection(question, rawAnswer) {
-    const trimmed = rawAnswer.trim();
-    const { selection, rationale } = splitAnswerAndRationale(trimmed);
-    const numeric = Number(selection);
-    if (/^\d+$/.test(selection) && Number.isInteger(numeric)) {
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function answerInputParts(input) {
+    if (typeof input === "string") {
+        return { values: [input], rawText: input };
+    }
+    if (Array.isArray(input)) {
+        return { values: input };
+    }
+    let values = input.selectedValues ?? [];
+    if (values.length === 0 && input.selectedValue) {
+        values = [input.selectedValue];
+    }
+    if (values.length === 0 && Array.isArray(input.answer)) {
+        values = input.answer;
+    }
+    if (values.length === 0 && typeof input.answer === "string") {
+        values = [input.answer];
+    }
+    const otherText = input.otherText?.trim();
+    const rationale = input.rationale?.trim();
+    return {
+        values,
+        ...(otherText ? { otherText } : {}),
+        ...(rationale ? { inlineRationale: rationale } : {})
+    };
+}
+function splitSelectionTokens(selection, type) {
+    if (type !== "multi_choice") {
+        return [selection];
+    }
+    return selection.split(/[;,]/).map((token) => token.trim()).filter(Boolean);
+}
+function normalizeFreeTextAnswer(input) {
+    const parts = answerInputParts(input);
+    const selectedText = parts.values.join("\n").trim();
+    const text = parts.rawText ?? (selectedText || parts.otherText || "");
+    const trimmed = text.trim();
+    if (!trimmed) {
+        throw new Error("Free-text LongTable question answers cannot be empty.");
+    }
+    return {
+        selectedValues: [trimmed],
+        selectedLabels: [trimmed],
+        otherText: trimmed,
+        ...(parts.inlineRationale ? { inlineRationale: parts.inlineRationale } : {})
+    };
+}
+function resolveQuestionAnswerToken(question, token) {
+    const trimmed = token.trim();
+    if (!trimmed) {
+        throw new Error("LongTable question answers cannot contain empty selections.");
+    }
+    const numeric = Number(trimmed);
+    if (/^\d+$/.test(trimmed) && Number.isInteger(numeric)) {
         const option = question.prompt.options[numeric - 1];
         if (option) {
             return {
                 selectedValue: option.value,
-                selectedLabel: option.label,
-                ...(rationale ? { inlineRationale: rationale } : {})
+                selectedLabel: option.label
             };
         }
         if (question.prompt.allowOther && numeric === question.prompt.options.length + 1) {
             return {
                 selectedValue: "other",
-                selectedLabel: question.prompt.otherLabel ?? "Other",
-                ...(rationale ? { inlineRationale: rationale } : {})
+                selectedLabel: question.prompt.otherLabel ?? "Other"
             };
         }
-        throw new Error(`Answer ${selection} is outside the available LongTable question options.`);
+        throw new Error(`Answer ${trimmed} is outside the available LongTable question options.`);
     }
-    const normalizedSelection = normalizeAnswerToken(selection);
+    const normalizedSelection = normalizeAnswerToken(trimmed);
     const option = question.prompt.options.find((candidate) => optionAnswerCandidates(candidate).includes(normalizedSelection));
     if (option) {
         return {
             selectedValue: option.value,
-            selectedLabel: option.label,
-            ...(rationale ? { inlineRationale: rationale } : {})
+            selectedLabel: option.label
         };
     }
     if (normalizedSelection === "other" && question.prompt.allowOther) {
         return {
             selectedValue: "other",
-            selectedLabel: question.prompt.otherLabel ?? "Other",
-            ...(rationale ? { inlineRationale: rationale } : {})
+            selectedLabel: question.prompt.otherLabel ?? "Other"
         };
     }
     if (question.prompt.allowOther) {
         return {
-            selectedValue: "other",
-            selectedLabel: selection,
-            otherText: trimmed,
-            ...(rationale ? { inlineRationale: rationale } : {})
+            selectedValue: trimmed,
+            selectedLabel: question.prompt.otherLabel ?? "Other",
+            otherText: trimmed
         };
     }
-    throw new Error(`Answer "${selection}" does not match a LongTable question option.`);
+    throw new Error(`Answer "${trimmed}" does not match a LongTable question option.`);
+}
+function isOtherAnswerToken(question, token) {
+    if (!question.prompt.allowOther) {
+        return false;
+    }
+    const trimmed = token.trim();
+    const normalized = normalizeAnswerToken(trimmed);
+    const otherLabel = normalizeAnswerToken(question.prompt.otherLabel ?? "Other");
+    if (normalized === "other" || normalized === otherLabel) {
+        return true;
+    }
+    const numeric = Number(trimmed);
+    return /^\d+$/.test(trimmed) && Number.isInteger(numeric) && numeric === question.prompt.options.length + 1;
+}
+function normalizeQuestionAnswerSelection(question, rawAnswer) {
+    if (question.prompt.type === "free_text") {
+        return normalizeFreeTextAnswer(rawAnswer);
+    }
+    const parts = answerInputParts(rawAnswer);
+    const parsedValues = parts.values.flatMap((value) => {
+        if (typeof rawAnswer === "string") {
+            const { selection } = splitAnswerAndRationale(value.trim());
+            return splitSelectionTokens(selection, question.prompt.type);
+        }
+        return splitSelectionTokens(value, question.prompt.type);
+    });
+    const inlineRationale = typeof rawAnswer === "string"
+        ? splitAnswerAndRationale(rawAnswer.trim()).rationale
+        : parts.inlineRationale;
+    const hasOtherText = Boolean(parts.otherText);
+    const hasOtherToken = parsedValues.some((value) => isOtherAnswerToken(question, value));
+    if (hasOtherText && !hasOtherToken) {
+        throw new Error("Other text requires selecting the LongTable question Other option.");
+    }
+    const selectionTokens = parts.otherText
+        ? parsedValues.filter((value) => !isOtherAnswerToken(question, value))
+        : parsedValues;
+    const tokens = uniqueStrings([
+        ...selectionTokens,
+        ...(parts.otherText ? [parts.otherText] : [])
+    ]);
+    if (tokens.length === 0) {
+        throw new Error("LongTable question answers cannot be empty.");
+    }
+    if (question.prompt.type !== "multi_choice" && tokens.length > 1) {
+        throw new Error("Single-choice LongTable questions accept exactly one answer.");
+    }
+    const resolved = tokens.map((token) => resolveQuestionAnswerToken(question, token));
+    const selectedValues = uniqueStrings(resolved.map((entry) => entry.selectedValue));
+    const selectedLabels = selectedValues.map((value) => {
+        const entry = resolved.find((candidate) => candidate.selectedValue === value);
+        return entry?.selectedLabel ?? value;
+    });
+    const otherText = parts.otherText ?? resolved.map((entry) => entry.otherText).find(Boolean);
+    return {
+        selectedValues,
+        selectedLabels,
+        ...(otherText ? { otherText } : {}),
+        ...(inlineRationale ? { inlineRationale } : {})
+    };
 }
 export async function answerWorkspaceQuestion(options) {
     const state = await loadResearchState(options.context.stateFilePath);
@@ -2546,8 +2653,8 @@ export async function answerWorkspaceQuestion(options) {
         .join("\n");
     const answer = {
         promptId: question.prompt.id,
-        selectedValues: [normalized.selectedValue],
-        selectedLabels: [normalized.selectedLabel],
+        selectedValues: normalized.selectedValues,
+        selectedLabels: normalized.selectedLabels,
         ...(normalized.otherText ? { otherText: normalized.otherText } : {}),
         ...(rationale ? { rationale } : {}),
         ...(options.provider ? { provider: options.provider } : {}),
@@ -2564,6 +2671,7 @@ export async function answerWorkspaceQuestion(options) {
         ...(question.commitmentFamily ? { commitmentFamily: question.commitmentFamily } : {}),
         ...(question.epistemicBasis ? { epistemicBasis: question.epistemicBasis } : {}),
         selectedOption: answer.selectedValues[0],
+        selectedOptions: answer.selectedValues,
         ...(rationale ? { rationale } : {})
     };
     const answeredQuestion = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longtable/cli",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "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.50",
+    "@longtable/core": "0.1.50",
+    "@longtable/memory": "0.1.50",
+    "@longtable/provider-claude": "0.1.50",
+    "@longtable/provider-codex": "0.1.50",
+    "@longtable/setup": "0.1.50"
   },
   "devDependencies": {
     "@types/node": "^22.10.1",