@longtable/mcp 0.1.43 → 0.1.44

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./first-research-shape.js";
+export * from "./research-specification.js";
 export * from "./server.js";

package/dist/index.js

@@ -1,2 +1,3 @@
 export * from "./first-research-shape.js";
+export * from "./research-specification.js";
 export * from "./server.js";

package/dist/research-specification.d.ts

@@ -0,0 +1,65 @@
+import type { QuestionOption } from "@longtable/core";
+export interface ResearchSpecification {
+    title: string;
+    status?: "draft" | "confirmed" | "deferred";
+    createdAt?: string;
+    updatedAt?: string;
+    sourceHookId?: string;
+    researchDirection: {
+        question?: string;
+        purpose: string;
+        scopeBoundary?: string;
+        inclusionCriteria?: string[];
+        exclusionCriteria?: string[];
+    };
+    constructOntology: {
+        coreConstructs: string[];
+        distinctions: string[];
+        termsToAvoidCollapsing?: string[];
+    };
+    theoryAndFraming: {
+        anchors: string[];
+        alternatives?: string[];
+        overreachRisks?: string[];
+    };
+    measurementCoding: {
+        variablesOrConstructs: string[];
+        evidenceTypes: string[];
+        codingRules: string[];
+        openStandards?: string[];
+    };
+    methodAnalysis: {
+        design?: string;
+        analysisOptions: string[];
+        dataSufficiencyCriteria?: string[];
+        unsettledChoices?: string[];
+    };
+    evidenceAccess: {
+        requiredSources?: string[];
+        accessRequirements?: string[];
+        evidenceStandards?: string[];
+    };
+    epistemicAlignment: {
+        researcherKnowledge?: string[];
+        projectStatePriority?: string[];
+        aiInferenceLimits?: string[];
+        conflictResolutionRule?: string;
+    };
+    protectedDecisions: string[];
+    openQuestions: string[];
+    nextActions: string[];
+    confidence: "low" | "medium" | "high";
+    confirmedAt?: string;
+}
+export interface ResearchSpecificationQuestionSpec {
+    prompt: string;
+    title: string;
+    question: string;
+    checkpointKey: string;
+    options: QuestionOption[];
+    displayReason: string;
+}
+export declare function renderResearchSpecificationPreview(specification: ResearchSpecification): string;
+export declare function buildResearchSpecificationQuestion(specification: ResearchSpecification): ResearchSpecificationQuestionSpec;
+export declare function researchSpecificationAnswerConfirms(answer: string): boolean;
+export declare function researchSpecificationAnswerStatus(answer: string): "confirmed" | "active" | "deferred";

package/dist/research-specification.js

@@ -0,0 +1,108 @@
+function compactList(values, limit = 3) {
+    const kept = (values ?? []).map((value) => value.trim()).filter(Boolean).slice(0, limit);
+    return kept.length > 0 ? kept.join("; ") : "not specified";
+}
+function usesKorean(specification) {
+    const values = [
+        specification.title,
+        specification.researchDirection.question,
+        specification.researchDirection.purpose,
+        specification.researchDirection.scopeBoundary,
+        ...specification.constructOntology.coreConstructs,
+        ...specification.constructOntology.distinctions,
+        ...specification.theoryAndFraming.anchors,
+        ...specification.measurementCoding.codingRules,
+        ...specification.methodAnalysis.analysisOptions,
+        specification.epistemicAlignment.conflictResolutionRule,
+        ...specification.protectedDecisions,
+        ...specification.openQuestions,
+        ...specification.nextActions
+    ];
+    return values.some((value) => typeof value === "string" && /[ㄱ-ㅎㅏ-ㅣ가-힣]/.test(value));
+}
+export function renderResearchSpecificationPreview(specification) {
+    const korean = usesKorean(specification);
+    const lines = [
+        korean ? "Research Specification Preview" : "Research Specification Preview",
+        `${korean ? "제목" : "Title"}: ${specification.title}`,
+        `${korean ? "목적" : "Purpose"}: ${specification.researchDirection.purpose}`,
+        specification.researchDirection.scopeBoundary
+            ? `${korean ? "범위" : "Scope"}: ${specification.researchDirection.scopeBoundary}`
+            : undefined,
+        `${korean ? "핵심 construct" : "Core constructs"}: ${compactList(specification.constructOntology.coreConstructs)}`,
+        `${korean ? "구분" : "Distinctions"}: ${compactList(specification.constructOntology.distinctions)}`,
+        `${korean ? "이론 앵커" : "Theory anchors"}: ${compactList(specification.theoryAndFraming.anchors)}`,
+        `${korean ? "코딩 규칙" : "Coding rules"}: ${compactList(specification.measurementCoding.codingRules)}`,
+        `${korean ? "분석 옵션" : "Analysis options"}: ${compactList(specification.methodAnalysis.analysisOptions)}`,
+        specification.epistemicAlignment.conflictResolutionRule
+            ? `${korean ? "충돌 조정" : "Conflict rule"}: ${specification.epistemicAlignment.conflictResolutionRule}`
+            : undefined,
+        `${korean ? "열린 질문" : "Open questions"}: ${compactList(specification.openQuestions, 2)}`,
+        `${korean ? "다음 행동" : "Next actions"}: ${compactList(specification.nextActions, 2)}`,
+        `${korean ? "신뢰도" : "Confidence"}: ${specification.confidence}`
+    ].filter(Boolean);
+    return lines.join("\n");
+}
+function baseOptions(specification) {
+    const korean = usesKorean(specification);
+    return [
+        {
+            value: "confirm_specification",
+            label: korean ? "저장/확정" : "Confirm and save",
+            description: korean
+                ? "이 Research Specification을 현재 연구 명세로 저장하고 이어갑니다."
+                : "Save this Research Specification as the current research specification.",
+            recommended: specification.confidence !== "low"
+        },
+        {
+            value: "ask_one_more",
+            label: korean ? "한 질문 더" : "Ask one more question",
+            description: korean
+                ? "저장하기 전에 가장 위험한 빈칸 하나를 더 묻습니다."
+                : "Ask one more high-risk clarification before saving it.",
+            recommended: specification.confidence === "low"
+        },
+        {
+            value: "revise_section",
+            label: korean ? "섹션 수정" : "Revise a section",
+            description: korean
+                ? "범위, construct, 이론, 코딩, 방법, 접근, 정렬 중 특정 섹션을 수정합니다."
+                : "Revise one section such as scope, constructs, theory, coding, method, access, or alignment."
+        },
+        {
+            value: "keep_open",
+            label: korean ? "열어두기" : "Keep open",
+            description: korean
+                ? "아직 이 명세를 확정하지 않고 draft로 둡니다."
+                : "Keep this specification as a draft instead of confirming it."
+        }
+    ];
+}
+export function buildResearchSpecificationQuestion(specification) {
+    const korean = usesKorean(specification);
+    const preview = renderResearchSpecificationPreview(specification);
+    return {
+        prompt: preview,
+        title: korean ? "Research Specification 확인" : "Research Specification Confirmation",
+        question: korean
+            ? "이 Research Specification을 어떻게 처리할까요?"
+            : "How should LongTable handle this Research Specification?",
+        checkpointKey: "research_specification_confirmation",
+        options: baseOptions(specification),
+        displayReason: korean
+            ? `${preview}\n\n인터뷰가 단순한 방향 요약을 넘어 연구 명세를 만들 만큼 구체화되었습니다. 저장 전에 범위, construct, 이론, 코딩, 방법, 접근, 정렬을 명시적으로 확인해야 합니다.`
+            : `${preview}\n\nThe interview has moved beyond a short direction summary into a research specification. Scope, constructs, theory, coding, method, access, and epistemic alignment should be explicit before saving.`
+    };
+}
+export function researchSpecificationAnswerConfirms(answer) {
+    return answer === "confirm_specification";
+}
+export function researchSpecificationAnswerStatus(answer) {
+    if (researchSpecificationAnswerConfirms(answer)) {
+        return "confirmed";
+    }
+    if (answer === "keep_open") {
+        return "deferred";
+    }
+    return "active";
+}

package/dist/server.js

@@ -13,6 +13,7 @@ import { renderQuestionRecordPrompt } from "@longtable/provider-codex";
 import { loadSetupOutput } from "@longtable/setup";
 import { answerWorkspaceQuestion, clearWorkspaceQuestion, createOrUpdateProjectWorkspace, createWorkspaceQuestion, inspectProjectWorkspace, loadProjectContextFromDirectory, loadWorkspaceState, syncCurrentWorkspaceView } from "@longtable/cli";
 import { buildFirstResearchShapeQuestion, firstResearchShapeAnswerConfirms, firstResearchShapeAnswerStatus } from "./first-research-shape.js";
+import { buildResearchSpecificationQuestion, renderResearchSpecificationPreview, researchSpecificationAnswerConfirms, researchSpecificationAnswerStatus } from "./research-specification.js";
 const SERVER_NAME = "longtable-state";
 const require = createRequire(import.meta.url);
 const SERVER_VERSION = String(require("../package.json").version ?? "0.0.0");
@@ -24,8 +25,11 @@ const TOOL_NAMES = [
     "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",
@@ -56,6 +60,59 @@ const firstResearchShapeSchema = z.object({
     sourceHookId: z.string().optional(),
     confirmedAt: z.string().optional()
 });
+const optionalStringArraySchema = z.array(z.string().min(1)).optional();
+const researchSpecificationSchema = z.object({
+    title: z.string().min(1),
+    status: z.enum(["draft", "confirmed", "deferred"]).optional(),
+    createdAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+    sourceHookId: z.string().optional(),
+    researchDirection: z.object({
+        question: z.string().optional(),
+        purpose: z.string().min(1),
+        scopeBoundary: z.string().optional(),
+        inclusionCriteria: optionalStringArraySchema,
+        exclusionCriteria: optionalStringArraySchema
+    }),
+    constructOntology: z.object({
+        coreConstructs: z.array(z.string().min(1)).default([]),
+        distinctions: z.array(z.string().min(1)).default([]),
+        termsToAvoidCollapsing: optionalStringArraySchema
+    }),
+    theoryAndFraming: z.object({
+        anchors: z.array(z.string().min(1)).default([]),
+        alternatives: optionalStringArraySchema,
+        overreachRisks: optionalStringArraySchema
+    }),
+    measurementCoding: z.object({
+        variablesOrConstructs: z.array(z.string().min(1)).default([]),
+        evidenceTypes: z.array(z.string().min(1)).default([]),
+        codingRules: z.array(z.string().min(1)).default([]),
+        openStandards: optionalStringArraySchema
+    }),
+    methodAnalysis: z.object({
+        design: z.string().optional(),
+        analysisOptions: z.array(z.string().min(1)).default([]),
+        dataSufficiencyCriteria: optionalStringArraySchema,
+        unsettledChoices: optionalStringArraySchema
+    }),
+    evidenceAccess: z.object({
+        requiredSources: optionalStringArraySchema,
+        accessRequirements: optionalStringArraySchema,
+        evidenceStandards: optionalStringArraySchema
+    }),
+    epistemicAlignment: z.object({
+        researcherKnowledge: optionalStringArraySchema,
+        projectStatePriority: optionalStringArraySchema,
+        aiInferenceLimits: optionalStringArraySchema,
+        conflictResolutionRule: z.string().optional()
+    }),
+    protectedDecisions: z.array(z.string().min(1)).default([]),
+    openQuestions: z.array(z.string().min(1)).default([]),
+    nextActions: z.array(z.string().min(1)).default([]),
+    confidence: z.enum(["low", "medium", "high"]).default("medium"),
+    confirmedAt: z.string().optional()
+});
 function textResult(structuredContent) {
     return {
         content: [
@@ -360,6 +417,119 @@ async function summarizeInterviewHook(context, options) {
     await syncCurrentWorkspaceView(context);
     return { hook, shape, state: updated, session };
 }
+function normalizeStringArray(values) {
+    return (values ?? []).map((value) => value.trim()).filter(Boolean);
+}
+function normalizeOptionalString(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeResearchSpecification(input, sourceHookId, timestamp) {
+    const title = input.title.trim();
+    const purpose = input.researchDirection.purpose.trim();
+    if (!title || !purpose) {
+        throw new Error("Research Specification title and researchDirection.purpose are required.");
+    }
+    return {
+        title,
+        status: input.confirmedAt ? "confirmed" : input.status ?? "draft",
+        createdAt: input.createdAt ?? timestamp,
+        updatedAt: timestamp,
+        ...(sourceHookId ? { sourceHookId } : {}),
+        researchDirection: {
+            ...(normalizeOptionalString(input.researchDirection.question) ? { question: normalizeOptionalString(input.researchDirection.question) } : {}),
+            purpose,
+            ...(normalizeOptionalString(input.researchDirection.scopeBoundary) ? { scopeBoundary: normalizeOptionalString(input.researchDirection.scopeBoundary) } : {}),
+            inclusionCriteria: normalizeStringArray(input.researchDirection.inclusionCriteria),
+            exclusionCriteria: normalizeStringArray(input.researchDirection.exclusionCriteria)
+        },
+        constructOntology: {
+            coreConstructs: normalizeStringArray(input.constructOntology.coreConstructs),
+            distinctions: normalizeStringArray(input.constructOntology.distinctions),
+            termsToAvoidCollapsing: normalizeStringArray(input.constructOntology.termsToAvoidCollapsing)
+        },
+        theoryAndFraming: {
+            anchors: normalizeStringArray(input.theoryAndFraming.anchors),
+            alternatives: normalizeStringArray(input.theoryAndFraming.alternatives),
+            overreachRisks: normalizeStringArray(input.theoryAndFraming.overreachRisks)
+        },
+        measurementCoding: {
+            variablesOrConstructs: normalizeStringArray(input.measurementCoding.variablesOrConstructs),
+            evidenceTypes: normalizeStringArray(input.measurementCoding.evidenceTypes),
+            codingRules: normalizeStringArray(input.measurementCoding.codingRules),
+            openStandards: normalizeStringArray(input.measurementCoding.openStandards)
+        },
+        methodAnalysis: {
+            ...(normalizeOptionalString(input.methodAnalysis.design) ? { design: normalizeOptionalString(input.methodAnalysis.design) } : {}),
+            analysisOptions: normalizeStringArray(input.methodAnalysis.analysisOptions),
+            dataSufficiencyCriteria: normalizeStringArray(input.methodAnalysis.dataSufficiencyCriteria),
+            unsettledChoices: normalizeStringArray(input.methodAnalysis.unsettledChoices)
+        },
+        evidenceAccess: {
+            requiredSources: normalizeStringArray(input.evidenceAccess.requiredSources),
+            accessRequirements: normalizeStringArray(input.evidenceAccess.accessRequirements),
+            evidenceStandards: normalizeStringArray(input.evidenceAccess.evidenceStandards)
+        },
+        epistemicAlignment: {
+            researcherKnowledge: normalizeStringArray(input.epistemicAlignment.researcherKnowledge),
+            projectStatePriority: normalizeStringArray(input.epistemicAlignment.projectStatePriority),
+            aiInferenceLimits: normalizeStringArray(input.epistemicAlignment.aiInferenceLimits),
+            ...(normalizeOptionalString(input.epistemicAlignment.conflictResolutionRule)
+                ? { conflictResolutionRule: normalizeOptionalString(input.epistemicAlignment.conflictResolutionRule) }
+                : {})
+        },
+        protectedDecisions: normalizeStringArray(input.protectedDecisions),
+        openQuestions: normalizeStringArray(input.openQuestions),
+        nextActions: normalizeStringArray(input.nextActions),
+        confidence: input.confidence,
+        ...(input.confirmedAt ? { confirmedAt: input.confirmedAt } : {})
+    };
+}
+async function summarizeResearchSpecificationHook(context, options) {
+    const state = asInterviewState(await loadWorkspaceState(context));
+    const sourceHookId = options.hookId
+        ?? options.specification.sourceHookId
+        ?? state.firstResearchShape?.sourceHookId;
+    const existing = sourceHookId
+        ? (state.hooks ?? []).find((hook) => isInterviewHookRun(hook) && hook.id === sourceHookId)
+        : activeInterviewHook(state);
+    const timestamp = new Date().toISOString();
+    const specification = normalizeResearchSpecification(options.specification, existing?.id ?? sourceHookId, timestamp);
+    const hook = existing
+        ? {
+            ...existing,
+            status: "ready_to_confirm",
+            updatedAt: timestamp,
+            researchSpecification: specification
+        }
+        : undefined;
+    const session = {
+        ...context.session,
+        lastUpdatedAt: timestamp,
+        researchSpecification: specification,
+        resumeHint: `I want to continue from the Research Specification: ${specification.title}.`
+    };
+    context.session = session;
+    const updated = hook ? upsertInterviewHook(state, hook) : state;
+    updated.researchSpecification = specification;
+    updated.workingState = {
+        ...updated.workingState,
+        researchSpecification: specification
+    };
+    updated.narrativeTraces.push({
+        id: createId("narrative_trace"),
+        timestamp,
+        source: "$longtable-interview",
+        traceType: "judgment",
+        summary: `Research Specification draft: ${specification.title}.`,
+        visibility: "explicit",
+        importance: specification.confidence
+    });
+    await writeFile(context.sessionFilePath, JSON.stringify(session, null, 2), "utf8");
+    await writeFile(context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
+    await syncCurrentWorkspaceView(context);
+    return { hook, specification, state: updated, session };
+}
 async function cancelInterviewHook(context, options) {
     const state = asInterviewState(await loadWorkspaceState(context));
     const existing = activeInterviewHook(state, options.hookId);
@@ -430,6 +600,7 @@ function compactInterviewHook(hook) {
         provider: hook.provider,
         turnCount: hook.turns?.length ?? 0,
         firstResearchShape: hook.firstResearchShape?.handle,
+        researchSpecification: hook.researchSpecification?.title,
         createdAt: hook.createdAt,
         updatedAt: hook.updatedAt
     };
@@ -591,6 +762,87 @@ async function markAlreadyConfirmedFirstResearchShape(context, shape) {
     await syncCurrentWorkspaceView(context);
     return { state: nextState, session, shape: confirmedShape };
 }
+async function markResearchSpecificationConfirmation(context, specification, answer, questionId, decisionId) {
+    const state = asInterviewState(await loadWorkspaceState(context));
+    const timestamp = new Date().toISOString();
+    const confirmedSpecification = researchSpecificationAnswerConfirms(answer)
+        ? { ...specification, status: "confirmed", confirmedAt: timestamp, updatedAt: timestamp }
+        : {
+            ...specification,
+            status: researchSpecificationAnswerStatus(answer) === "deferred" ? "deferred" : "draft",
+            updatedAt: timestamp
+        };
+    state.researchSpecification = confirmedSpecification;
+    state.workingState = {
+        ...state.workingState,
+        researchSpecification: confirmedSpecification
+    };
+    state.hooks = (state.hooks ?? []).map((hook) => {
+        if (hook.id !== specification.sourceHookId || !isInterviewHookRun(hook)) {
+            return hook;
+        }
+        return {
+            ...hook,
+            status: researchSpecificationAnswerStatus(answer),
+            updatedAt: timestamp,
+            researchSpecification: confirmedSpecification,
+            linkedQuestionRecordIds: questionId
+                ? [...(hook.linkedQuestionRecordIds ?? []), questionId]
+                : hook.linkedQuestionRecordIds,
+            linkedDecisionRecordIds: decisionId
+                ? [...(hook.linkedDecisionRecordIds ?? []), decisionId]
+                : hook.linkedDecisionRecordIds
+        };
+    });
+    const session = {
+        ...context.session,
+        researchSpecification: confirmedSpecification,
+        lastUpdatedAt: timestamp
+    };
+    context.session = session;
+    await writeFile(context.sessionFilePath, JSON.stringify(session, null, 2), "utf8");
+    await writeFile(context.stateFilePath, JSON.stringify(state, null, 2), "utf8");
+    await syncCurrentWorkspaceView(context);
+    return { state, session, specification: confirmedSpecification };
+}
+async function markAlreadyConfirmedResearchSpecification(context, specification) {
+    const state = asInterviewState(await loadWorkspaceState(context));
+    const timestamp = new Date().toISOString();
+    const confirmedSpecification = specification.confirmedAt
+        ? specification
+        : { ...specification, status: "confirmed", confirmedAt: timestamp, updatedAt: timestamp };
+    state.researchSpecification = confirmedSpecification;
+    state.workingState = {
+        ...state.workingState,
+        researchSpecification: confirmedSpecification
+    };
+    state.hooks = (state.hooks ?? []).map((hook) => {
+        if (!isInterviewHookRun(hook)) {
+            return hook;
+        }
+        const matchesSource = specification.sourceHookId && hook.id === specification.sourceHookId;
+        const matchesTitle = !specification.sourceHookId && hook.researchSpecification?.title === specification.title;
+        if (!matchesSource && !matchesTitle) {
+            return hook;
+        }
+        return {
+            ...hook,
+            status: "confirmed",
+            updatedAt: timestamp,
+            researchSpecification: confirmedSpecification
+        };
+    });
+    const session = {
+        ...context.session,
+        researchSpecification: confirmedSpecification,
+        lastUpdatedAt: timestamp
+    };
+    context.session = session;
+    await writeFile(context.sessionFilePath, JSON.stringify(session, null, 2), "utf8");
+    await writeFile(context.stateFilePath, JSON.stringify(state, null, 2), "utf8");
+    await syncCurrentWorkspaceView(context);
+    return { state, session, specification: confirmedSpecification };
+}
 function statusForElicitationError(error) {
     const message = error instanceof Error ? error.message : String(error);
     if (/timed?\s*out|timeout/i.test(message)) {
@@ -823,6 +1075,63 @@ export function createLongTableMcpServer() {
             return errorResult(error instanceof Error ? error.message : String(error));
         }
     });
+    server.registerTool("summarize_research_specification", {
+        title: "Summarize LongTable Research Specification",
+        description: "Store the fuller Research Specification after a First Research Shape has enough interview context to preserve scope, constructs, theory, coding, method, evidence/access, and epistemic alignment.",
+        inputSchema: cwdSchema.extend({
+            hookId: z.string().optional(),
+            specification: researchSpecificationSchema
+        })
+    }, async ({ cwd: inputCwd, hookId, specification }) => {
+        try {
+            const context = await requireContext(inputCwd);
+            const result = await summarizeResearchSpecificationHook(context, {
+                hookId,
+                specification: specification
+            });
+            return textResult({
+                hook: compactInterviewHook(result.hook),
+                specification: result.specification,
+                preview: renderResearchSpecificationPreview(result.specification),
+                session: {
+                    currentGoal: result.session.currentGoal,
+                    currentBlocker: result.session.currentBlocker,
+                    nextAction: result.session.nextAction,
+                    firstResearchShape: result.session.firstResearchShape,
+                    researchSpecification: result.session.researchSpecification
+                }
+            });
+        }
+        catch (error) {
+            return errorResult(error instanceof Error ? error.message : String(error));
+        }
+    });
+    server.registerTool("read_research_specification", {
+        title: "Read LongTable Research Specification",
+        description: "Read the current Research Specification and render the researcher-facing preview.",
+        inputSchema: cwdSchema
+    }, async ({ cwd: inputCwd }) => {
+        try {
+            const context = await requireContext(inputCwd);
+            const state = asInterviewState(await loadWorkspaceState(context));
+            const session = context.session;
+            const specification = state.researchSpecification ?? session.researchSpecification;
+            if (!specification) {
+                return textResult({
+                    found: false,
+                    message: "No Research Specification was found. Run summarize_research_specification first."
+                });
+            }
+            return textResult({
+                found: true,
+                specification,
+                preview: renderResearchSpecificationPreview(specification)
+            });
+        }
+        catch (error) {
+            return errorResult(error instanceof Error ? error.message : String(error));
+        }
+    });
     server.registerTool("cancel_interview", {
         title: "Cancel LongTable Interview",
         description: "Explicitly cancel the active $longtable-interview hook without confirming a First Research Shape.",
@@ -954,6 +1263,118 @@ export function createLongTableMcpServer() {
             return errorResult(error instanceof Error ? error.message : String(error));
         }
     });
+    server.registerTool("confirm_research_specification", {
+        title: "Confirm Research Specification",
+        description: "Use MCP form elicitation to confirm, revise, defer, or request one more question for the full Research Specification.",
+        inputSchema: cwdSchema.extend({
+            specification: researchSpecificationSchema.optional(),
+            provider: z.enum(["codex", "claude"]).default("codex"),
+            fallbackOnly: z.boolean().default(false)
+        })
+    }, async ({ cwd: inputCwd, specification: inputSpecification, provider, fallbackOnly }) => {
+        try {
+            const context = await requireContext(inputCwd);
+            const state = asInterviewState(await loadWorkspaceState(context));
+            const session = context.session;
+            const specification = inputSpecification
+                ?? state.researchSpecification
+                ?? session.researchSpecification;
+            if (!specification) {
+                return errorResult("No Research Specification was found to confirm. Run summarize_research_specification first.");
+            }
+            if (specification.confirmedAt) {
+                const confirmation = await markAlreadyConfirmedResearchSpecification(context, specification);
+                return textResult({
+                    specification: confirmation.specification,
+                    preview: renderResearchSpecificationPreview(confirmation.specification),
+                    elicitation: { attempted: false, reason: "already_confirmed" }
+                });
+            }
+            const spec = buildResearchSpecificationQuestion(specification);
+            const created = await createWorkspaceQuestion({
+                context,
+                prompt: spec.prompt,
+                title: spec.title,
+                question: spec.question,
+                checkpointKey: spec.checkpointKey,
+                questionOptions: spec.options,
+                displayReason: spec.displayReason,
+                provider: provider,
+                required: true
+            });
+            const fallback = renderQuestionFallback(created.question, provider);
+            if (fallbackOnly) {
+                const marked = await markQuestionTransport(context, created.question.id, "fallback_rendered", "MCP elicitation skipped by fallbackOnly.");
+                return textResult({
+                    question: marked ?? created.question,
+                    specification,
+                    preview: renderResearchSpecificationPreview(specification),
+                    elicitation: { attempted: false, reason: "fallbackOnly" },
+                    fallback
+                });
+            }
+            try {
+                await markQuestionTransport(context, created.question.id, "attempted");
+                const elicited = await server.server.elicitInput(buildElicitationParams(created.question));
+                const accepted = acceptedAnswer(elicited);
+                if (!accepted) {
+                    const status = elicited.action === "decline" || elicited.action === "cancel"
+                        ? "declined"
+                        : "fallback_rendered";
+                    const marked = await markQuestionTransport(context, created.question.id, status, `MCP elicitation returned action: ${elicited.action}.`);
+                    const cleared = status === "declined"
+                        ? await clearWorkspaceQuestion({
+                            context,
+                            questionId: created.question.id,
+                            reason: `MCP elicitation returned action: ${elicited.action}; Research Specification confirmation was deferred.`
+                        })
+                        : undefined;
+                    return textResult({
+                        question: cleared?.question ?? marked ?? created.question,
+                        specification,
+                        preview: renderResearchSpecificationPreview(specification),
+                        elicitation: { attempted: true, action: elicited.action },
+                        fallback
+                    });
+                }
+                const decided = await answerWorkspaceQuestion({
+                    context,
+                    questionId: created.question.id,
+                    answer: accepted.answer,
+                    provider: provider,
+                    surface: "mcp_elicitation"
+                });
+                const marked = await markQuestionTransport(context, created.question.id, "accepted");
+                const confirmation = await markResearchSpecificationConfirmation(context, specification, accepted.answer, created.question.id, decided.decision.id);
+                return textResult({
+                    specification: confirmation.specification,
+                    preview: renderResearchSpecificationPreview(confirmation.specification),
+                    question: marked ? { ...decided.question, transportStatus: marked.transportStatus } : decided.question,
+                    decision: decided.decision,
+                    elicitation: { attempted: true, action: elicited.action }
+                });
+            }
+            catch (elicitationError) {
+                const status = statusForElicitationError(elicitationError);
+                const message = elicitationError instanceof Error ? elicitationError.message : String(elicitationError);
+                const marked = await markQuestionTransport(context, created.question.id, status, message);
+                return textResult({
+                    question: marked ?? created.question,
+                    specification,
+                    preview: renderResearchSpecificationPreview(specification),
+                    elicitation: {
+                        attempted: true,
+                        supported: status !== "unsupported" ? undefined : false,
+                        error: message
+                    },
+                    fallback
+                });
+            }
+        }
+        catch (error) {
+            return errorResult(error instanceof Error ? error.message : String(error));
+        }
+    });
     server.registerTool("pending_questions", {
         title: "List Pending Researcher Checkpoints",
         description: "List pending LongTable QuestionRecords.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longtable/mcp",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "private": false,
   "description": "LongTable MCP transport for workspace state and Researcher Checkpoints",
   "type": "module",
@@ -26,12 +26,12 @@
     "self-test": "node ./dist/server.js --self-test"
   },
   "dependencies": {
-    "@longtable/checkpoints": "0.1.43",
-    "@longtable/cli": "0.1.43",
-    "@longtable/core": "0.1.43",
-    "@longtable/provider-claude": "0.1.43",
-    "@longtable/provider-codex": "0.1.43",
-    "@longtable/setup": "0.1.43",
+    "@longtable/checkpoints": "0.1.44",
+    "@longtable/cli": "0.1.44",
+    "@longtable/core": "0.1.44",
+    "@longtable/provider-claude": "0.1.44",
+    "@longtable/provider-codex": "0.1.44",
+    "@longtable/setup": "0.1.44",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^4.0.0"
   },