@longtable/cli 0.1.45 → 0.1.47

package/dist/cli.js

@@ -49,8 +49,35 @@ 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",
+    "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",
+    "confirm_research_specification"
+];
 function style(text, prefix) {
     return `${prefix}${text}${ANSI.reset}`;
 }
@@ -84,7 +111,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) {
@@ -1131,7 +1158,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 +1189,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 +1218,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 +1545,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 +1582,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 +1631,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 +1684,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 +1697,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 +1741,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 +1797,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);
     }

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, InvocationRecord, LongTableQuestionObligation, ProviderKind, QuestionOption, QuestionCommitmentFamily, QuestionEpistemicBasis, QuestionGenerationResult, QuestionOpportunity, QuestionSurface, QuestionRecord, 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";
@@ -221,6 +221,8 @@ export interface LongTableWorkspaceInspection {
         id: string;
         title: string;
         question: string;
+        commitmentFamily?: QuestionCommitmentFamily;
+        epistemicBasis?: QuestionEpistemicBasis;
         options: string[];
         required: boolean;
     }>;
@@ -235,6 +237,8 @@ export interface LongTableWorkspaceInspection {
         id: string;
         checkpointKey: string;
         summary: string;
+        commitmentFamily?: QuestionCommitmentFamily;
+        epistemicBasis?: QuestionEpistemicBasis;
         selectedOption?: string;
         timestamp: string;
     }>;
@@ -329,6 +333,8 @@ export declare function createWorkspaceQuestion(options: {
     displayReason?: string;
     provider?: ProviderKind;
     required?: boolean;
+    commitmentFamily?: QuestionCommitmentFamily;
+    epistemicBasis?: QuestionEpistemicBasis;
 }): Promise<{
     question: QuestionRecord;
     state: ResearchState;

package/dist/project-session.js

@@ -163,6 +163,43 @@ function renderResearchSpecificationSummary(specification, locale) {
     }
     return lines;
 }
+function renderResearchSpecificationStatus(session, locale) {
+    if (!session.firstResearchShape && !session.researchSpecification) {
+        return [];
+    }
+    const korean = locale === "ko";
+    if (!session.researchSpecification) {
+        return [
+            "",
+            korean ? "## Research Specification 상태" : "## Research Specification Status",
+            korean
+                ? "- 상태: First Research Shape는 있지만 Research Specification은 아직 없습니다."
+                : "- Status: First Research Shape exists, but Research Specification is missing.",
+            korean
+                ? "- 의미: First Research Shape는 짧은 핸들/재개 인덱스이며, 인터뷰 종료나 연구 명세 확정이 아닙니다."
+                : "- Meaning: First Research Shape is a short handle/resume index, not interview closure or a confirmed research specification.",
+            korean
+                ? "- 다음 프로토콜: 충분한 내용이 있으면 `summarize_research_specification`으로 preview를 만들고 `confirm_research_specification`으로 저장/한 질문 더/섹션 수정/열어두기를 확인합니다."
+                : "- Next protocol: when enough detail exists, run `summarize_research_specification` to create the preview, then `confirm_research_specification` to confirm, ask one more question, revise a section, or keep it open."
+        ];
+    }
+    const status = session.researchSpecification.confirmedAt
+        ? "confirmed"
+        : session.researchSpecification.status ?? "draft";
+    if (status === "confirmed") {
+        return [];
+    }
+    return [
+        "",
+        korean ? "## Research Specification 상태" : "## Research Specification Status",
+        korean
+            ? `- 상태: ${status}. Research Specification은 저장되어 있지만 아직 확정된 종료 지점이 아닙니다.`
+            : `- Status: ${status}. Research Specification exists, but it is not a confirmed closure point yet.`,
+        korean
+            ? "- 다음 프로토콜: 명세를 업데이트한 뒤 `confirm_research_specification`으로 다시 preview 확인을 받아야 합니다."
+            : "- Next protocol: update the specification, then return to `confirm_research_specification` for another preview confirmation."
+    ];
+}
 function buildCurrentGuide(project, session, recentInvocations = [], pendingQuestions = [], pendingObligations = []) {
     const locale = normalizeLocale(session.locale ?? project.locale);
     const openQuestions = session.openQuestions && session.openQuestions.length > 0
@@ -191,6 +228,7 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
             `- 다음 액션: ${nextAction}`,
             `- 관점: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
             `- disagreement: ${session.disagreementPreference}`,
+            ...renderResearchSpecificationStatus(session, locale),
             "",
             "## 열린 질문",
             ...openQuestions.map((question) => `- ${question}`),
@@ -210,7 +248,7 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
                     "## 대기 중인 결정 질문",
                     ...pendingQuestions.map((record) => {
                         const options = formatQuestionOptionValues(record).join("/");
-                        return `- ${record.id}: ${record.prompt.question} (${options})`;
+                        return `- ${record.id}: ${record.prompt.question}${formatQuestionMetadata(record)} (${options})`;
                     }),
                     "- 답변 기록: `longtable decide --question <id> --answer <value>`"
                 ]
@@ -266,6 +304,7 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
         `- Next action: ${nextAction}`,
         `- Perspectives: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
         `- Disagreement: ${session.disagreementPreference}`,
+        ...renderResearchSpecificationStatus(session, locale),
         "",
         "## Open Questions",
         ...openQuestions.map((question) => `- ${question}`),
@@ -285,7 +324,7 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
                 "## Pending Decision Questions",
                 ...pendingQuestions.map((record) => {
                     const options = formatQuestionOptionValues(record).join("/");
-                    return `- ${record.id}: ${record.prompt.question} (${options})`;
+                    return `- ${record.id}: ${record.prompt.question}${formatQuestionMetadata(record)} (${options})`;
                 }),
                 "- Record an answer: `longtable decide --question <id> --answer <value>`"
             ]
@@ -375,6 +414,13 @@ function formatQuestionOptionValues(record) {
     }
     return values;
 }
+function formatQuestionMetadata(record) {
+    const parts = [
+        record.commitmentFamily ? `commitment: ${record.commitmentFamily}` : "",
+        record.epistemicBasis ? `basis: ${record.epistemicBasis}` : ""
+    ].filter(Boolean);
+    return parts.length > 0 ? ` [${parts.join("; ")}]` : "";
+}
 function summarizeWorkspaceInspection(context, state) {
     const questions = state.questionLog ?? [];
     const pendingQuestions = questions.filter((record) => record.status === "pending");
@@ -435,6 +481,8 @@ function summarizeWorkspaceInspection(context, state) {
             id: record.id,
             title: record.prompt.title,
             question: record.prompt.question,
+            ...(record.commitmentFamily ? { commitmentFamily: record.commitmentFamily } : {}),
+            ...(record.epistemicBasis ? { epistemicBasis: record.epistemicBasis } : {}),
             options: formatQuestionOptionValues(record),
             required: record.prompt.required
         })),
@@ -449,6 +497,8 @@ function summarizeWorkspaceInspection(context, state) {
             id: record.id,
             checkpointKey: record.checkpointKey,
             summary: record.summary,
+            ...(record.commitmentFamily ? { commitmentFamily: record.commitmentFamily } : {}),
+            ...(record.epistemicBasis ? { epistemicBasis: record.epistemicBasis } : {}),
             ...(record.selectedOption ? { selectedOption: record.selectedOption } : {}),
             timestamp: record.timestamp
         })),
@@ -495,9 +545,12 @@ function buildProjectAgentsMd(project, session) {
         "- Begin exploratory work with clarifying or tension questions before recommending a direction.",
         "- For `$longtable-interview`, ask one natural-language question at a time, reflect with `LongTable hears: ...`, record turns when MCP is available, and avoid early reader/reviewer or theory/method/measurement classification.",
         "- Do not summarize `$longtable-interview` because a fixed number of turns has passed; wait for content-based readiness around research object, focal uncertainty, boundary, evidence/material, protected decision, and next action.",
+        "- First Research Shape is a short handle/resume index, not the default closure point.",
         "- After the First Research Shape, create a Research Specification when the interview has enough detail to preserve scope, construct ontology, theory framing, coding rules, method options, evidence/access requirements, epistemic alignment, protected decisions, open questions, and next actions.",
+        "- If a confirmed First Research Shape exists without a Research Specification, continue directly into the next Research Specification question instead of asking shape-level continue/revise/restart questions.",
+        "- If the researcher chooses `ask_one_more` or `revise_section` at Research Specification confirmation, answer that gap and return to the Research Specification Preview before ending the interview.",
         "- Do not let unrelated pending Researcher Checkpoints interrupt `$longtable-interview`; mention them only as separate unresolved checkpoints unless the researcher is confirming, saving, or recording a research decision.",
-        "- Use structured options only at the final First Research Shape confirmation or at true checkpoint boundaries.",
+        "- Use structured options at the final Research Specification confirmation, at explicit short-handle stop points, or at true checkpoint boundaries.",
         "- If you foreground role perspectives, disclose them with `LongTable consulted: ...`.",
         "- Keep one accountable synthesis, but do not hide meaningful disagreement.",
         ...(session.disagreementPreference === "always_visible"
@@ -1668,6 +1721,70 @@ export function generateQuestionOpportunities(prompt, options = {}) {
     };
 }
 const FOLLOW_UP_PROMPT_PREFIX = "Follow-up prompt:";
+function compactMetadataText(parts) {
+    return parts
+        .flatMap((part) => Array.isArray(part) ? part : [part])
+        .filter((part) => Boolean(part && part.trim()))
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+}
+function textMatchesAny(text, patterns) {
+    return patterns.some((pattern) => pattern.test(text));
+}
+const COMMITMENT_FAMILY_BY_CHECKPOINT = [
+    [/product|meta_decision/, "product_policy"],
+    [/research_question|research_direction|scope|boundary|inclusion|exclusion/, "scope"],
+    [/theory|construct|conceptual/, "construct"],
+    [/measurement|coding|codebook|extraction/, "coding"],
+    [/method|analysis|panel_disagreement|team_debate|review/, "method"],
+    [/evidence|scholarly_access|source_authority/, "evidence"],
+    [/knowledge_gap|tacit_assumption|epistemic/, "epistemic_authority"]
+];
+function inferCommitmentFamily(input) {
+    const checkpointKey = (input.checkpointKey ?? "").toLowerCase();
+    const matched = COMMITMENT_FAMILY_BY_CHECKPOINT.find(([pattern]) => pattern.test(checkpointKey));
+    if (matched)
+        return matched[1];
+    if (input.triggerFamily === "meta_decision")
+        return "product_policy";
+    if (input.triggerFamily === "evidence")
+        return "evidence";
+    const text = compactMetadataText([input.title, input.question, input.prompt, input.rationale]);
+    if (textMatchesAny(text, [/checkpoint policy/, /hook ux/, /product language/, /\breadme\b/, /제품 언어|체크포인트 정책|훅|리드미/])) {
+        return "product_policy";
+    }
+    return undefined;
+}
+function inferEpistemicBasis(input) {
+    const text = compactMetadataText([input.title, input.question, input.prompt, input.rationale]);
+    const bases = [];
+    if (textMatchesAny(text, [/\bresearcher\b/, /\bhuman\b/, /\byour judgment\b/, /\byour knowledge\b/, /연구자|인간|사람|너의\s*판단|당신의\s*판단|내\s*지식|사용자/])) {
+        bases.push("researcher_knowledge");
+    }
+    if (textMatchesAny(text, [/\bproject state\b/, /\bworkspace\b/, /\bcurrent\.md\b/, /\.longtable\b/, /\bstate\.json\b/, /\bdataset\b/, /\bcodebook\b/, /\bcoding sheet\b/, /프로젝트\s*상태|워크스페이스|데이터셋|코드북|코딩\s*시트/])) {
+        bases.push("project_state");
+    }
+    if (textMatchesAny(text, [/\bexternal evidence\b/, /\bliterature\b/, /\bpaper\b/, /\bpdf\b/, /\bsource\b/, /\bcitation\b/, /\breference\b/, /\bfull[- ]?text\b/, /외부\s*근거|문헌|논문|원문|전문|출처|인용|레퍼런스/])) {
+        bases.push("external_evidence");
+    }
+    if (textMatchesAny(text, [/\bcodex\b/, /\bllm\b/, /\blanguage model\b/, /\bmodel judgment\b/, /\bai inference\b/, /\bassistant judgment\b/, /코덱스|언어\s*모델|모델\s*판단|AI\s*추론|LLM/])) {
+        bases.push("ai_inference");
+    }
+    const unique = [...new Set(bases)];
+    if (unique.length > 1)
+        return "mixed";
+    return unique[0];
+}
+function resolveQuestionRecordMetadata(input) {
+    const commitmentFamily = input.commitmentFamily ?? inferCommitmentFamily(input);
+    const epistemicBasis = input.epistemicBasis ?? inferEpistemicBasis(input);
+    return {
+        ...(commitmentFamily ? { commitmentFamily } : {}),
+        ...(epistemicBasis ? { epistemicBasis } : {})
+    };
+}
 function hasFollowUpPrompt(record, prompt) {
     return record.prompt.rationale.includes(`${FOLLOW_UP_PROMPT_PREFIX} ${prompt}`);
 }
@@ -1705,31 +1822,43 @@ export async function createWorkspaceFollowUpQuestions(options) {
     if (specsToCreate.length === 0) {
         return { questions: pendingMatches, state, created: false, alreadyAnswered: false };
     }
-    const questions = specsToCreate.map((spec) => ({
-        id: createId("question_record"),
-        createdAt,
-        updatedAt: createdAt,
-        status: "pending",
-        prompt: {
-            id: createId("question_prompt"),
-            checkpointKey: `follow_up_${spec.key}`,
+    const questions = specsToCreate.map((spec) => {
+        const checkpointKey = `follow_up_${spec.key}`;
+        const rationale = [
+            spec.whyNow,
+            `Question kind: ${spec.kind}`,
+            `Question confidence: ${spec.confidence}`,
+            `${FOLLOW_UP_PROMPT_PREFIX} ${options.prompt}`
+        ];
+        const metadata = resolveQuestionRecordMetadata({
+            checkpointKey,
             title: spec.title,
             question: spec.question,
-            type: "single_choice",
-            options: spec.options,
-            allowOther: true,
-            otherLabel: "Other",
-            required: options.required ?? spec.required,
-            source: "runtime_guidance",
-            rationale: [
-                spec.whyNow,
-                `Question kind: ${spec.kind}`,
-                `Question confidence: ${spec.confidence}`,
-                `${FOLLOW_UP_PROMPT_PREFIX} ${options.prompt}`
-            ],
-            preferredSurfaces: preferredSurfaces
-        }
-    }));
+            prompt: options.prompt,
+            rationale
+        });
+        return {
+            id: createId("question_record"),
+            createdAt,
+            updatedAt: createdAt,
+            status: "pending",
+            ...metadata,
+            prompt: {
+                id: createId("question_prompt"),
+                checkpointKey,
+                title: spec.title,
+                question: spec.question,
+                type: "single_choice",
+                options: spec.options,
+                allowOther: true,
+                otherLabel: "Other",
+                required: options.required ?? spec.required,
+                source: "runtime_guidance",
+                rationale,
+                preferredSurfaces: preferredSurfaces
+            }
+        };
+    });
     const updated = appendQuestionRecords(state, questions);
     await writeFile(options.context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
     await syncCurrentWorkspaceView(options.context);
@@ -1743,16 +1872,35 @@ export async function createWorkspaceQuestion(options) {
     });
     const checkpointKey = options.checkpointKey ?? trigger.signal.checkpointKey;
     const createdAt = nowIso();
+    const title = options.title ?? questionTitleForCheckpoint(trigger.family, checkpointKey);
+    const questionText = options.question ?? questionTextForCheckpoint(trigger.family, options.prompt, checkpointKey);
+    const rationale = [
+        ...trigger.rationale,
+        `Trigger family: ${trigger.family}.`,
+        `Trigger confidence: ${trigger.confidence}.`,
+        `Original prompt: ${options.prompt}`
+    ];
+    const metadata = resolveQuestionRecordMetadata({
+        checkpointKey,
+        triggerFamily: trigger.family,
+        title,
+        question: questionText,
+        prompt: options.prompt,
+        rationale,
+        commitmentFamily: options.commitmentFamily,
+        epistemicBasis: options.epistemicBasis
+    });
     const question = {
         id: createId("question_record"),
         createdAt,
         updatedAt: createdAt,
         status: "pending",
+        ...metadata,
         prompt: {
             id: createId("question_prompt"),
             checkpointKey,
-            title: options.title ?? questionTitleForCheckpoint(trigger.family, checkpointKey),
-            question: options.question ?? questionTextForCheckpoint(trigger.family, options.prompt, checkpointKey),
+            title,
+            question: questionText,
             type: "single_choice",
             options: options.questionOptions ?? optionsForCheckpointTrigger(trigger.family, checkpointKey),
             allowOther: true,
@@ -1760,12 +1908,7 @@ export async function createWorkspaceQuestion(options) {
             required: options.required ?? trigger.requiresQuestionBeforeClosure,
             source: "checkpoint",
             displayReason: options.displayReason ?? trigger.rationale[0],
-            rationale: [
-                ...trigger.rationale,
-                `Trigger family: ${trigger.family}.`,
-                `Trigger confidence: ${trigger.confidence}.`,
-                `Original prompt: ${options.prompt}`
-            ],
+            rationale,
             preferredSurfaces: options.provider === "claude"
                 ? ["native_structured", "numbered"]
                 : ["mcp_elicitation", "numbered"]
@@ -1892,6 +2035,8 @@ export async function answerWorkspaceQuestion(options) {
         level: question.prompt.required ? "adaptive_required" : "recommended",
         mode: "commit",
         summary: `Answered ${question.prompt.title}: ${answer.selectedLabels.join(", ")}`,
+        ...(question.commitmentFamily ? { commitmentFamily: question.commitmentFamily } : {}),
+        ...(question.epistemicBasis ? { epistemicBasis: question.epistemicBasis } : {}),
         selectedOption: answer.selectedValues[0],
         ...(rationale ? { rationale } : {})
     };

package/package.json

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