@longtable/cli 0.1.45 → 0.1.48

package/dist/cli.js

@@ -18,7 +18,7 @@ import { buildPersonaGuidance, parseInvocationDirective } from "./persona-router
 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 { appendInvocationRecordToWorkspace, assertWorkspaceNotBlocked, answerWorkspaceQuestion, buildQuestionOpportunitySpecs, clearWorkspaceQuestion, createWorkspaceFollowUpQuestions, createWorkspaceQuestion, createOrUpdateProjectWorkspace, inspectProjectWorkspace, loadWorkspaceState, loadProjectContextFromDirectory, pruneWorkspaceQuestions, repairWorkspaceStateConsistency, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.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";
 const VALID_MODES = new Set([
@@ -49,8 +49,45 @@ const require = createRequire(import.meta.url);
 const LONGTABLE_PACKAGE_VERSION = String(require("../package.json").version ?? "0.0.0");
 const LONGTABLE_MCP_SERVER_NAME = "longtable-state";
 const LONGTABLE_MCP_PACKAGE_VERSION = LONGTABLE_PACKAGE_VERSION;
+const LONGTABLE_MCP_PACKAGE_SPEC = `@longtable/mcp@${LONGTABLE_MCP_PACKAGE_VERSION}`;
 const LONGTABLE_MCP_MARKER_START = "# LongTable state MCP START";
 const LONGTABLE_MCP_MARKER_END = "# LongTable state MCP END";
+const LONGTABLE_MCP_MANAGED_TOOLS = [
+    "read_project",
+    "read_session",
+    "inspect_workspace",
+    "create_workspace",
+    "begin_interview",
+    "append_interview_turn",
+    "summarize_interview",
+    "summarize_research_specification",
+    "read_research_specification",
+    "propose_research_spec_patch",
+    "apply_research_spec_patch",
+    "diff_research_specification",
+    "read_research_spec_history",
+    "find_unincorporated_evidence",
+    "cancel_interview",
+    "confirm_first_research_shape",
+    "confirm_research_specification",
+    "pending_questions",
+    "evaluate_checkpoint",
+    "create_question",
+    "elicit_question",
+    "render_question",
+    "append_decision",
+    "regenerate_current"
+];
+const LONGTABLE_MCP_RESEARCH_SPECIFICATION_TOOLS = [
+    "summarize_research_specification",
+    "read_research_specification",
+    "propose_research_spec_patch",
+    "apply_research_spec_patch",
+    "diff_research_specification",
+    "read_research_spec_history",
+    "find_unincorporated_evidence",
+    "confirm_research_specification"
+];
 function style(text, prefix) {
     return `${prefix}${text}${ANSI.reset}`;
 }
@@ -84,7 +121,7 @@ function renderInterviewLaunchSteps(provider) {
         `2. run \`${command}\``,
         "3. invoke `$longtable-interview`",
         "",
-        "The interview will create or resume `.longtable/`, build a First Research Shape, and use option UI only for the final confirmation."
+        "The interview will create or resume `.longtable/`, may store a short First Research Shape handle, and uses option UI for the final Research Specification confirmation."
     ]);
 }
 function renderProgressBar(current, total) {
@@ -105,6 +142,7 @@ function usage() {
         "  longtable doctor [--cwd <path>] [--fix] [--json] [--codex-dir <path>] [--codex-config <path>] [--hooks-path <path>] [--claude-dir <path>] [--codex-prompts-dir <path>] [--codex-runtime-path <file>] [--claude-runtime-path <file>]",
         "  longtable status [--cwd <path>] [--fix] [--json] [--codex-dir <path>] [--codex-config <path>] [--hooks-path <path>] [--claude-dir <path>] [--codex-prompts-dir <path>] [--codex-runtime-path <file>] [--claude-runtime-path <file>]",
         "  longtable audit [questions|roles] [--json]",
+        "  longtable spec [read|history|diff|unincorporated|apply|propose] [--cwd <path>] [--json] [--spec-file <path>] [--patch-id <id>]",
         "  longtable roles [--json]",
         "  longtable show [--json] [--path <file>]",
         "  longtable install [--json] [--path <file>] [--runtime-path <file>]",
@@ -155,7 +193,7 @@ function parseArgs(argv) {
     const values = {};
     let subcommand = maybeSubcommand;
     const modeCommand = command && VALID_MODES.has(command);
-    const directCommand = command && ["init", "setup", "start", "resume", "doctor", "status", "audit", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "clear-question", "prune-questions", "panel", "decide", "sentinel", "team", "access", "search"].includes(command);
+    const directCommand = command && ["init", "setup", "start", "resume", "doctor", "status", "audit", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "clear-question", "prune-questions", "panel", "decide", "sentinel", "team", "access", "search", "spec"].includes(command);
     let startIndex = 1;
     if (modeCommand) {
         subcommand = undefined;
@@ -164,7 +202,7 @@ function parseArgs(argv) {
     else if (command === "codex" || command === "claude" || command === "mcp") {
         startIndex = 2;
     }
-    else if ((command === "access" || command === "search") && maybeSubcommand && !maybeSubcommand.startsWith("--")) {
+    else if ((command === "access" || command === "search" || command === "spec") && maybeSubcommand && !maybeSubcommand.startsWith("--")) {
         subcommand = maybeSubcommand;
         startIndex = 2;
     }
@@ -1131,7 +1169,7 @@ function resolveMcpProviders(value) {
 function resolveMcpPackageSpec(args) {
     return typeof args.package === "string" && args.package.trim()
         ? args.package.trim()
-        : `@longtable/mcp@${LONGTABLE_MCP_PACKAGE_VERSION}`;
+        : LONGTABLE_MCP_PACKAGE_SPEC;
 }
 function resolveCodexMcpConfigPath(args) {
     return resolve(normalizeUserPath(typeof args["codex-config"] === "string" && args["codex-config"].trim()
@@ -1162,6 +1200,12 @@ function renderCodexMcpBlock(serverName, command, mcpArgs) {
         `[mcp_servers.${serverName}]`,
         `command = ${escapeTomlString(command)}`,
         `args = [${mcpArgs.map((arg) => escapeTomlString(arg)).join(", ")}]`,
+        "",
+        ...LONGTABLE_MCP_MANAGED_TOOLS.flatMap((tool) => [
+            `[mcp_servers.${serverName}.tools.${tool}]`,
+            "approval_mode = \"approve\"",
+            ""
+        ]),
         LONGTABLE_MCP_MARKER_END
     ].join("\n");
 }
@@ -1185,10 +1229,55 @@ function codexMcpElicitationsAllowed(config) {
 function codexLongTableMcpConfigured(config) {
     return new RegExp(`\\[mcp_servers\\.${LONGTABLE_MCP_SERVER_NAME.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\]`).test(config);
 }
+function codexLongTableMcpPackageSpec(config) {
+    const serverName = LONGTABLE_MCP_SERVER_NAME.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = new RegExp(`\\[mcp_servers\\.${serverName}\\][\\s\\S]*?(?=\\n\\[|$)`).exec(config);
+    if (!match) {
+        return undefined;
+    }
+    const packageMatch = /@longtable\/mcp@[A-Za-z0-9._~+:-]+/.exec(match[0]);
+    return packageMatch?.[0];
+}
+function codexLongTableMcpToolConfigured(config, tool) {
+    const serverName = LONGTABLE_MCP_SERVER_NAME.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const escapedTool = tool.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`\\[mcp_servers\\.${serverName}\\.tools\\.${escapedTool}\\]`).test(config);
+}
+function missingCodexLongTableMcpTools(config) {
+    if (!codexLongTableMcpConfigured(config)) {
+        return [...LONGTABLE_MCP_MANAGED_TOOLS];
+    }
+    return LONGTABLE_MCP_MANAGED_TOOLS.filter((tool) => !codexLongTableMcpToolConfigured(config, tool));
+}
+function preserveNonLongTableSectionsFromMarkedBlock(block, serverName) {
+    const body = block
+        .replace(LONGTABLE_MCP_MARKER_START, "")
+        .replace(LONGTABLE_MCP_MARKER_END, "")
+        .trim();
+    if (!body) {
+        return "";
+    }
+    const sections = body.split(/(?=^\[[^\]]+\])/m);
+    const serverHeader = `[mcp_servers.${serverName}]`;
+    const toolPrefix = `[mcp_servers.${serverName}.tools.`;
+    return sections
+        .map((section) => section.trim())
+        .filter(Boolean)
+        .filter((section) => {
+        const header = section.split(/\r?\n/, 1)[0]?.trim() ?? "";
+        return header !== serverHeader && !header.startsWith(toolPrefix);
+    })
+        .join("\n\n");
+}
 function replaceMarkedCodexMcpBlock(existing, block, serverName) {
-    const markerPattern = new RegExp(`${LONGTABLE_MCP_MARKER_START.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${LONGTABLE_MCP_MARKER_END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "m");
-    const serverPattern = new RegExp(`\\n?\\[mcp_servers\\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\][\\s\\S]*?(?=\\n\\[|$)`, "m");
-    const trimmed = existing.replace(markerPattern, "").replace(serverPattern, "").trimEnd();
+    const markerPattern = new RegExp(`${LONGTABLE_MCP_MARKER_START.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${LONGTABLE_MCP_MARKER_END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`);
+    const serverPattern = new RegExp(`\\n?\\[mcp_servers\\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\][\\s\\S]*?(?=\\n\\[|$)`);
+    const toolPattern = new RegExp(`\\n?\\[mcp_servers\\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.tools\\.[^\\]]+\\][\\s\\S]*?(?=\\n\\[|$)`, "g");
+    const withoutMarked = existing.replace(markerPattern, (matched) => {
+        const preserved = preserveNonLongTableSectionsFromMarkedBlock(matched, serverName);
+        return preserved ? `${preserved}\n\n` : "";
+    });
+    const trimmed = withoutMarked.replace(toolPattern, "").replace(serverPattern, "").trimEnd();
     return trimmed ? `${trimmed}\n\n${block}\n` : `${block}\n`;
 }
 async function writeCodexMcpConfig(path, block, serverName, options = {}) {
@@ -1467,6 +1556,8 @@ async function collectDoctorStatus(args) {
     const codexMcpConfig = existsSync(codexMcpConfigPath)
         ? await readFile(codexMcpConfigPath, "utf8")
         : "";
+    const codexMcpPackageSpec = codexLongTableMcpPackageSpec(codexMcpConfig);
+    const missingMcpTools = missingCodexLongTableMcpTools(codexMcpConfig);
     const codexHooksPath = resolveCodexHooksPath(args);
     const codexHooksContent = existsSync(codexHooksPath)
         ? await readFile(codexHooksPath, "utf8")
@@ -1502,6 +1593,10 @@ async function collectDoctorStatus(args) {
                 mcpConfigPath: codexMcpConfigPath,
                 mcpConfigExists: existsSync(codexMcpConfigPath),
                 longtableMcpConfigured: codexLongTableMcpConfigured(codexMcpConfig),
+                ...(codexMcpPackageSpec ? { mcpPackageSpec: codexMcpPackageSpec } : {}),
+                expectedMcpPackageSpec: LONGTABLE_MCP_PACKAGE_SPEC,
+                missingMcpTools,
+                missingResearchSpecificationMcpTools: missingMcpTools.filter((tool) => LONGTABLE_MCP_RESEARCH_SPECIFICATION_TOOLS.includes(tool)),
                 mcpElicitationsAllowed: codexMcpElicitationsAllowed(codexMcpConfig),
                 hooksPath: codexHooksPath,
                 hooksExists: existsSync(codexHooksPath),
@@ -1547,6 +1642,11 @@ function renderDoctorStatus(status) {
             : []),
         `- MCP config: ${status.providers.codex.mcpConfigExists ? "present" : "missing"} (${status.providers.codex.mcpConfigPath})`,
         `- LongTable MCP: ${status.providers.codex.longtableMcpConfigured ? "configured" : "missing"}`,
+        `- MCP package: ${status.providers.codex.mcpPackageSpec ?? "unknown"}${status.providers.codex.mcpPackageSpec === status.providers.codex.expectedMcpPackageSpec ? "" : ` (expected ${status.providers.codex.expectedMcpPackageSpec})`}`,
+        `- MCP managed tools: ${LONGTABLE_MCP_MANAGED_TOOLS.length - status.providers.codex.missingMcpTools.length}/${LONGTABLE_MCP_MANAGED_TOOLS.length} configured`,
+        ...(status.providers.codex.missingResearchSpecificationMcpTools.length > 0
+            ? [`- Research Specification MCP tools: missing ${status.providers.codex.missingResearchSpecificationMcpTools.join(", ")}`]
+            : ["- 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"}`,
@@ -1595,6 +1695,9 @@ function renderDoctorStatus(status) {
     const canFix = status.providers.codex.missingSkills.length > 0 ||
         status.providers.claude.missingSkills.length > 0 ||
         status.providers.codex.legacyPromptFilesInstalled.length > 0 ||
+        !status.providers.codex.longtableMcpConfigured ||
+        status.providers.codex.mcpPackageSpec !== status.providers.codex.expectedMcpPackageSpec ||
+        status.providers.codex.missingMcpTools.length > 0 ||
         !status.providers.codex.codexHooksEnabled ||
         status.providers.codex.missingManagedHookEvents.length > 0 ||
         (status.setupExists &&
@@ -1605,6 +1708,11 @@ function renderDoctorStatus(status) {
     if (!status.providers.codex.codexHooksEnabled || status.providers.codex.missingManagedHookEvents.length > 0) {
         nextActions.push("longtable codex install-hooks");
     }
+    if (!status.providers.codex.longtableMcpConfigured ||
+        status.providers.codex.mcpPackageSpec !== status.providers.codex.expectedMcpPackageSpec ||
+        status.providers.codex.missingMcpTools.length > 0) {
+        nextActions.push("longtable mcp install --provider codex --write");
+    }
     if (!status.setupExists) {
         nextActions.push("longtable setup --provider codex");
     }
@@ -1644,7 +1752,7 @@ function renderRepairSummary(repair) {
         }
     }
     if (repair.writtenRuntimeConfigs.length > 0) {
-        lines.push("- wrote runtime configs:");
+        lines.push("- wrote configs:");
         for (const target of repair.writtenRuntimeConfigs) {
             lines.push(`  - ${target.provider}: ${target.path}`);
         }
@@ -1700,6 +1808,21 @@ async function repairDoctorStatus(args, status) {
         writtenRuntimeConfigs: [],
         skipped: []
     };
+    const mcpRepairNeeded = !status.providers.codex.longtableMcpConfigured ||
+        status.providers.codex.mcpPackageSpec !== status.providers.codex.expectedMcpPackageSpec ||
+        status.providers.codex.missingMcpTools.length > 0;
+    if (mcpRepairNeeded) {
+        const mcpConfigPath = resolveDoctorCodexMcpConfigPath(args);
+        const block = renderCodexMcpBlock(LONGTABLE_MCP_SERVER_NAME, "npx", ["-y", LONGTABLE_MCP_PACKAGE_SPEC]);
+        await writeCodexMcpConfig(mcpConfigPath, block, LONGTABLE_MCP_SERVER_NAME, {
+            enableElicitations: status.providers.codex.mcpElicitationsAllowed
+        });
+        repair.writtenRuntimeConfigs.push({
+            provider: "codex",
+            path: mcpConfigPath,
+            format: "toml"
+        });
+    }
     if (status.providers.codex.missingSkills.length > 0) {
         repair.installedCodexSkills = (await installCodexSkills(roles, codexDir, skillSurface)).map((skill) => skill.name);
     }
@@ -2739,6 +2862,108 @@ async function runSearch(subcommand, args) {
     }
     console.log(renderEvidenceRunSummary(run, recordedPath));
 }
+async function requireWorkspaceContext(args) {
+    const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
+    const context = await loadProjectContextFromDirectory(workingDirectory);
+    if (!context) {
+        throw new Error("No LongTable workspace was found from the supplied cwd.");
+    }
+    return context;
+}
+async function readResearchSpecificationFile(path) {
+    if (!path) {
+        throw new Error("A Research Specification JSON file is required. Use --spec-file <path>.");
+    }
+    return JSON.parse(await readFile(resolve(path), "utf8"));
+}
+async function runSpec(subcommand, args) {
+    const context = await requireWorkspaceContext(args);
+    const command = subcommand ?? "read";
+    if (command === "read" || command === "history") {
+        const history = await readResearchSpecificationHistory(context);
+        if (args.json === true) {
+            console.log(JSON.stringify(history, null, 2));
+            return;
+        }
+        console.log("LongTable Research Specification");
+        console.log(`- title: ${history.specification?.title ?? "missing"}`);
+        console.log(`- status: ${history.specification?.confirmedAt ? "confirmed" : history.specification?.status ?? "missing"}`);
+        console.log(`- revisions: ${history.revisions.length}`);
+        console.log(`- patches: ${history.patches.length}`);
+        console.log(`- evidence records: ${history.evidenceRecords.length}`);
+        for (const revision of history.revisions.slice(-5).reverse()) {
+            console.log(`- v${revision.index}: ${revision.title} (${revision.changeSummary.slice(0, 2).join("; ")})`);
+        }
+        return;
+    }
+    if (command === "unincorporated") {
+        const evidenceRecords = await findUnincorporatedResearchEvidence(context);
+        if (args.json === true) {
+            console.log(JSON.stringify({ evidenceRecords }, null, 2));
+            return;
+        }
+        console.log("Unincorporated Research Evidence");
+        for (const record of evidenceRecords.slice(-10).reverse()) {
+            console.log(`- ${record.id} [${record.sourceKind}]: ${record.summary}`);
+        }
+        return;
+    }
+    if (command === "diff") {
+        const specification = await readResearchSpecificationFile(typeof args["spec-file"] === "string" ? args["spec-file"] : undefined);
+        const state = await loadWorkspaceState(context);
+        const changes = diffResearchSpecifications(state.researchSpecification, specification);
+        if (args.json === true) {
+            console.log(JSON.stringify({ changes }, null, 2));
+            return;
+        }
+        console.log("Research Specification Diff");
+        for (const change of changes) {
+            console.log(`- ${change.summary}`);
+        }
+        return;
+    }
+    if (command === "propose") {
+        const specification = await readResearchSpecificationFile(typeof args["spec-file"] === "string" ? args["spec-file"] : undefined);
+        const result = await proposeResearchSpecificationPatch({
+            context,
+            specification,
+            source: "manual",
+            rationale: typeof args.rationale === "string" ? args.rationale : undefined
+        });
+        if (args.json === true) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log("Research Specification patch proposed");
+        console.log(`- patch: ${result.patch.id}`);
+        console.log(`- changes: ${result.changes.length}`);
+        console.log(`- apply: longtable spec apply --patch-id ${result.patch.id}`);
+        return;
+    }
+    if (command === "apply") {
+        const specification = typeof args["spec-file"] === "string"
+            ? await readResearchSpecificationFile(args["spec-file"])
+            : undefined;
+        const result = await applyResearchSpecificationPatch({
+            context,
+            patchId: typeof args["patch-id"] === "string" ? args["patch-id"] : undefined,
+            specification,
+            source: "manual",
+            rationale: typeof args.rationale === "string" ? args.rationale : undefined
+        });
+        if (args.json === true) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log("Research Specification patch applied");
+        console.log(`- revision: v${result.revision.index} (${result.revision.id})`);
+        console.log(`- patch: ${result.patch.id}`);
+        console.log(`- decision: ${result.decision?.id ?? result.patch.decisionRecordId ?? "existing/none"}`);
+        console.log(`- current: ${context.currentFilePath}`);
+        return;
+    }
+    throw new Error(`Unknown spec subcommand: ${command}`);
+}
 async function runQuestion(args) {
     const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
     const prompt = await resolvePrompt(typeof args.prompt === "string" ? args.prompt : undefined);
@@ -3695,6 +3920,10 @@ async function main() {
         await runSearch(subcommand, values);
         return;
     }
+    if (command === "spec") {
+        await runSpec(subcommand, values);
+        return;
+    }
     if (command === "ask") {
         await runAsk(values);
         return;

package/dist/project-session.d.ts

@@ -1,4 +1,4 @@
-import type { DecisionRecord, InvocationRecord, LongTableQuestionObligation, ProviderKind, QuestionOption, QuestionGenerationResult, QuestionOpportunity, QuestionSurface, QuestionRecord, ResearchState } from "@longtable/core";
+import type { DecisionRecord, EvidenceRecord, InvocationRecord, LongTableQuestionObligation, ProviderKind, QuestionOption, QuestionCommitmentFamily, QuestionEpistemicBasis, QuestionGenerationResult, QuestionOpportunity, QuestionSurface, 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";
@@ -40,6 +40,9 @@ export interface ResearchSpecification {
     createdAt?: string;
     updatedAt?: string;
     sourceHookId?: string;
+    latestRevisionId?: string;
+    sourceEvidenceIds?: string[];
+    sectionEvidence?: Record<string, string[]>;
     researchDirection: {
         question?: string;
         purpose: string;
@@ -121,6 +124,10 @@ export type LongTableWorkspaceState = ResearchState & {
     hooks?: LongTableHookRun[];
     firstResearchShape?: FirstResearchShape;
     researchSpecification?: ResearchSpecification;
+    interviewTurns?: LongTableInterviewTurn[];
+    evidenceRecords?: EvidenceRecord[];
+    specPatches?: ResearchSpecificationPatch[];
+    specRevisions?: ResearchSpecificationRevision[];
 };
 export interface LongTableProjectRecord {
     schemaVersion: 1;
@@ -206,6 +213,10 @@ export interface LongTableWorkspaceInspection {
         pendingObligations: number;
         answeredQuestions: number;
         decisions: number;
+        interviewTurns?: number;
+        evidenceRecords?: number;
+        specPatches?: number;
+        specRevisions?: number;
     };
     recentInvocations?: Array<{
         id: string;
@@ -221,6 +232,8 @@ export interface LongTableWorkspaceInspection {
         id: string;
         title: string;
         question: string;
+        commitmentFamily?: QuestionCommitmentFamily;
+        epistemicBasis?: QuestionEpistemicBasis;
         options: string[];
         required: boolean;
     }>;
@@ -235,6 +248,8 @@ export interface LongTableWorkspaceInspection {
         id: string;
         checkpointKey: string;
         summary: string;
+        commitmentFamily?: QuestionCommitmentFamily;
+        epistemicBasis?: QuestionEpistemicBasis;
         selectedOption?: string;
         timestamp: string;
     }>;
@@ -246,6 +261,25 @@ export interface LongTableWorkspaceInspection {
     }>;
 }
 export declare function loadWorkspaceState(context: LongTableProjectContext): Promise<LongTableWorkspaceState>;
+export declare function diffResearchSpecifications(before: ResearchSpecification | undefined, after: ResearchSpecification): ResearchSpecificationChange[];
+export declare function applyResearchSpecificationAuditUpdate(state: LongTableWorkspaceState, options: {
+    specification: ResearchSpecification;
+    timestamp: string;
+    source: ResearchSpecificationPatchSource;
+    title?: string;
+    rationale?: string;
+    sourceEvidenceIds?: string[];
+    patch?: ResearchSpecificationPatch;
+    questionRecordId?: string;
+    decisionRecordId?: string;
+    createDecisionRecord?: boolean;
+}): {
+    state: LongTableWorkspaceState;
+    specification: ResearchSpecification;
+    patch: ResearchSpecificationPatch;
+    revision: ResearchSpecificationRevision;
+    decision?: DecisionRecord;
+};
 export declare function syncCurrentWorkspaceView(context: LongTableProjectContext): Promise<string>;
 export declare function appendInvocationRecordToWorkspace(context: LongTableProjectContext, invocation: InvocationRecord, questions?: QuestionRecord[]): Promise<LongTableWorkspaceState>;
 export declare function beginLongTableInterview(options: {
@@ -294,6 +328,41 @@ export declare function summarizeLongTableResearchSpecification(options: {
     state: LongTableWorkspaceState;
     session: LongTableSessionRecord;
 }>;
+export declare function proposeResearchSpecificationPatch(options: {
+    context: LongTableProjectContext;
+    specification: ResearchSpecification;
+    source?: ResearchSpecificationPatchSource;
+    rationale?: string;
+    sourceEvidenceIds?: string[];
+}): Promise<{
+    patch: ResearchSpecificationPatch;
+    changes: ResearchSpecificationChange[];
+    state: LongTableWorkspaceState;
+}>;
+export declare function applyResearchSpecificationPatch(options: {
+    context: LongTableProjectContext;
+    patchId?: string;
+    specification?: ResearchSpecification;
+    source?: ResearchSpecificationPatchSource;
+    rationale?: string;
+    sourceEvidenceIds?: string[];
+    questionRecordId?: string;
+    decisionRecordId?: string;
+}): Promise<{
+    patch: ResearchSpecificationPatch;
+    revision: ResearchSpecificationRevision;
+    specification: ResearchSpecification;
+    state: LongTableWorkspaceState;
+    session: LongTableSessionRecord;
+    decision?: DecisionRecord;
+}>;
+export declare function readResearchSpecificationHistory(context: LongTableProjectContext): Promise<{
+    specification?: ResearchSpecification;
+    revisions: ResearchSpecificationRevision[];
+    patches: ResearchSpecificationPatch[];
+    evidenceRecords: EvidenceRecord[];
+}>;
+export declare function findUnincorporatedResearchEvidence(context: LongTableProjectContext): Promise<EvidenceRecord[]>;
 export declare function listBlockingWorkspaceQuestions(context: LongTableProjectContext): Promise<QuestionRecord[]>;
 export declare function listBlockingWorkspaceObligations(context: LongTableProjectContext): Promise<LongTableQuestionObligation[]>;
 export declare function assertWorkspaceNotBlocked(context: LongTableProjectContext): Promise<void>;
@@ -329,6 +398,8 @@ export declare function createWorkspaceQuestion(options: {
     displayReason?: string;
     provider?: ProviderKind;
     required?: boolean;
+    commitmentFamily?: QuestionCommitmentFamily;
+    epistemicBasis?: QuestionEpistemicBasis;
 }): Promise<{
     question: QuestionRecord;
     state: ResearchState;