@longtable/mcp 0.1.40 → 0.1.42

package/README.md

@@ -15,7 +15,7 @@ longtable-state
 Run:
 
 ```bash
-npx -y @longtable/mcp@0.1.40
+npx -y @longtable/mcp@0.1.41
 ```
 
 Self-test:
@@ -39,6 +39,7 @@ Provider guidance should use interview tools for `$longtable-interview`:
 - `begin_interview`
 - `append_interview_turn`
 - `summarize_interview`
+- `cancel_interview`
 - `confirm_first_research_shape`
 
 For later Researcher Checkpoints, provider guidance should use

package/dist/first-research-shape.js

@@ -1,4 +1,7 @@
 function questionTitle(shape) {
+    if (usesKorean(shape)) {
+        return "First Research Shape 확인";
+    }
     if (shape.protectedDecision) {
         return "Protected Research Decision";
     }
@@ -7,7 +10,22 @@ function questionTitle(shape) {
     }
     return "Emerging Research Direction";
 }
+function usesKorean(shape) {
+    return [
+        shape.handle,
+        shape.currentGoal,
+        shape.currentBlocker,
+        shape.researchObject,
+        shape.gapRisk,
+        shape.protectedDecision,
+        ...shape.openQuestions,
+        shape.nextAction
+    ].some((value) => typeof value === "string" && /[ㄱ-ㅎㅏ-ㅣ가-힣]/.test(value));
+}
 function questionText(shape) {
+    if (usesKorean(shape)) {
+        return "이 First Research Shape를 어떻게 처리할까요?";
+    }
     if (shape.protectedDecision) {
         return "Before LongTable moves forward, what protected research decision should stay explicit?";
     }
@@ -20,6 +38,18 @@ function questionText(shape) {
     return "How should LongTable carry this emerging study forward?";
 }
 function displayReason(shape) {
+    if (usesKorean(shape)) {
+        if (shape.protectedDecision) {
+            return `인터뷰에서 보호해야 할 연구 판단이 드러났습니다: ${shape.protectedDecision}. LongTable은 이 판단이 조용히 확정되지 않게 해야 합니다.`;
+        }
+        if (shape.currentBlocker) {
+            return `주요 blocker가 아직 열려 있습니다: ${shape.currentBlocker}. 다음 행동은 이 불확실성을 명시적으로 다뤄야 합니다.`;
+        }
+        if (shape.openQuestions.length > 0) {
+            return "인터뷰에서 열린 연구 질문이 드러났습니다. 가장 중요한 질문을 보존하는 다음 행동을 선택해야 합니다.";
+        }
+        return "LongTable은 provisional research direction을 제안할 만큼의 맥락을 얻었지만, 다음 연구 행동은 명시적으로 선택되어야 합니다.";
+    }
     if (shape.protectedDecision) {
         return `The interview surfaced a protected decision: ${shape.protectedDecision}. LongTable should not let it settle silently.`;
     }
@@ -46,47 +76,59 @@ function recommendedValue(shape) {
 function baseOptions(shape) {
     const recommended = recommendedValue(shape);
     const options = [];
+    const korean = usesKorean(shape);
     if (shape.protectedDecision) {
         options.push({
             value: "protect_decision",
-            label: "Keep the protected decision open",
-            description: `Treat this as the guarded judgment while the broader direction stays provisional: ${shape.protectedDecision}`,
+            label: korean ? "보호 결정 열어두기" : "Keep the protected decision open",
+            description: korean
+                ? `전체 방향은 provisional로 두고, 이 판단을 보호된 결정으로 유지합니다: ${shape.protectedDecision}`
+                : `Treat this as the guarded judgment while the broader direction stays provisional: ${shape.protectedDecision}`,
             recommended: recommended === "protect_decision"
         });
     }
     options.push({
         value: "stabilize_shape",
-        label: "Use this as the provisional direction",
-        description: "Carry this research shape forward as the current working direction.",
+        label: korean ? "저장/확정" : "Use this as the provisional direction",
+        description: korean
+            ? "이 research shape를 현재 작업 방향으로 저장하고 이어갑니다."
+            : "Carry this research shape forward as the current working direction.",
         recommended: recommended === "stabilize_shape"
     }, {
         value: "gather_context",
-        label: "Gather one more concrete case",
-        description: "Ask for one more scene, source, dataset, or example before stabilizing it.",
+        label: korean ? "한 질문 더" : "Gather one more concrete case",
+        description: korean
+            ? "저장하기 전에 한 가지 장면, 출처, 데이터셋, 사례, 또는 결정 맥락을 더 묻습니다."
+            : "Ask for one more scene, source, dataset, or example before stabilizing it.",
         recommended: recommended === "gather_context"
     }, {
         value: "revise_shape",
-        label: "Revise the emerging shape",
-        description: "Change the handle, blocker, or next action before LongTable treats it as usable."
+        label: korean ? "수정" : "Revise the emerging shape",
+        description: korean
+            ? "LongTable이 이를 usable한 방향으로 다루기 전에 handle, blocker, next action 등을 수정합니다."
+            : "Change the handle, blocker, or next action before LongTable treats it as usable."
     });
     if (!shape.protectedDecision) {
         options.push({
             value: "keep_open",
-            label: "Keep the study open longer",
-            description: "Do not stabilize this direction yet."
+            label: korean ? "열어두기" : "Keep the study open longer",
+            description: korean ? "아직 이 방향을 확정하지 않습니다." : "Do not stabilize this direction yet."
         });
     }
     return options;
 }
 export function buildFirstResearchShapeQuestion(shape) {
+    const korean = usesKorean(shape);
     const summaryLines = [
-        "LongTable has enough context to propose a provisional research direction.",
-        `Handle: ${shape.handle}`,
-        `Goal: ${shape.currentGoal}`,
-        shape.currentBlocker ? `Blocker: ${shape.currentBlocker}` : undefined,
-        shape.protectedDecision ? `Protected decision: ${shape.protectedDecision}` : undefined,
-        shape.openQuestions.length > 0 ? `Open question: ${shape.openQuestions[0]}` : undefined,
-        `Next action: ${shape.nextAction}`
+        korean
+            ? "LongTable이 provisional research direction을 제안할 만큼의 맥락을 얻었습니다."
+            : "LongTable has enough context to propose a provisional research direction.",
+        `${korean ? "핸들" : "Handle"}: ${shape.handle}`,
+        `${korean ? "목표" : "Goal"}: ${shape.currentGoal}`,
+        shape.currentBlocker ? `${korean ? "막힌 지점" : "Blocker"}: ${shape.currentBlocker}` : undefined,
+        shape.protectedDecision ? `${korean ? "보호할 결정" : "Protected decision"}: ${shape.protectedDecision}` : undefined,
+        shape.openQuestions.length > 0 ? `${korean ? "열린 질문" : "Open question"}: ${shape.openQuestions[0]}` : undefined,
+        `${korean ? "다음 행동" : "Next action"}: ${shape.nextAction}`
     ].filter(Boolean);
     return {
         prompt: summaryLines.join("\n"),

package/dist/server.js

@@ -1,5 +1,6 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { basename, resolve } from "node:path";
 import { cwd, exit } from "node:process";
 import { fileURLToPath } from "node:url";
@@ -13,7 +14,8 @@ 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";
 const SERVER_NAME = "longtable-state";
-const SERVER_VERSION = "0.1.39";
+const require = createRequire(import.meta.url);
+const SERVER_VERSION = String(require("../package.json").version ?? "0.0.0");
 const TOOL_NAMES = [
     "read_project",
     "read_session",
@@ -22,6 +24,7 @@ const TOOL_NAMES = [
     "begin_interview",
     "append_interview_turn",
     "summarize_interview",
+    "cancel_interview",
     "confirm_first_research_shape",
     "pending_questions",
     "evaluate_checkpoint",
@@ -169,9 +172,10 @@ function resolveFirstResearchShapeObligation(state, options) {
     };
 }
 function interviewDepth(turns) {
-    const usableTurns = turns.filter((turn) => turn.quality !== "thin").length;
-    if (usableTurns >= 3)
+    if (turns.some((turn) => turn.readyToSummarize === true && turn.quality !== "thin")) {
         return "ready_to_summarize";
+    }
+    const usableTurns = turns.filter((turn) => turn.quality !== "thin").length;
     if (usableTurns >= 1)
         return "forming_first_handle";
     return "gathering_context";
@@ -250,6 +254,10 @@ async function appendInterviewTurn(context, options) {
     const followUpQuestion = needsFollowUp
         ? options.followUpQuestion ?? defaultFollowUpQuestion(options.answer)
         : options.followUpQuestion;
+    const readyToSummarize = options.readyToSummarize === true && quality !== "thin";
+    const readinessRationale = options.readinessRationale
+        ?.map((rationale) => rationale.trim())
+        .filter(Boolean);
     const timestamp = new Date().toISOString();
     const turn = {
         id: createId("interview_turn"),
@@ -261,6 +269,8 @@ async function appendInterviewTurn(context, options) {
         quality,
         needsFollowUp,
         ...(followUpQuestion?.trim() ? { followUpQuestion: followUpQuestion.trim() } : {}),
+        ...(readyToSummarize ? { readyToSummarize } : {}),
+        ...(readinessRationale && readinessRationale.length > 0 ? { readinessRationale } : {}),
         ...(options.rationale && options.rationale.length > 0 ? { rationale: options.rationale } : {})
     };
     const turns = [...existing.turns, turn];
@@ -273,7 +283,10 @@ async function appendInterviewTurn(context, options) {
         turns,
         qualityNotes: [
             ...existing.qualityNotes,
-            ...(needsFollowUp ? [`Turn ${turn.index} needs follow-up: ${followUpQuestion}`] : [])
+            ...(needsFollowUp ? [`Turn ${turn.index} needs follow-up: ${followUpQuestion}`] : []),
+            ...(readyToSummarize
+                ? [`Turn ${turn.index} marked ready to summarize: ${(readinessRationale ?? ["content-based readiness signal"]).join("; ")}`]
+                : [])
         ]
     };
     const updated = upsertInterviewHook(state, hook);
@@ -347,6 +360,53 @@ async function summarizeInterviewHook(context, options) {
     await syncCurrentWorkspaceView(context);
     return { hook, shape, state: updated, session };
 }
+async function cancelInterviewHook(context, options) {
+    const state = asInterviewState(await loadWorkspaceState(context));
+    const existing = activeInterviewHook(state, options.hookId);
+    if (!existing) {
+        throw new Error("No active LongTable interview hook was found to cancel.");
+    }
+    const timestamp = new Date().toISOString();
+    const hook = {
+        ...existing,
+        status: "cancelled",
+        updatedAt: timestamp,
+        rationale: [
+            ...existing.rationale,
+            options.reason?.trim()
+                ? `Interview cancelled explicitly: ${options.reason.trim()}`
+                : "Interview cancelled explicitly by the researcher."
+        ]
+    };
+    const updated = upsertInterviewHook(state, hook);
+    const workingState = {
+        ...(updated.workingState ?? {})
+    };
+    if (workingState.activeInterviewHookId === existing.id) {
+        delete workingState.activeInterviewHookId;
+        delete workingState.interviewSurface;
+        delete workingState.interviewOpeningQuestion;
+        delete workingState.interviewSeedAnswer;
+    }
+    updated.workingState = workingState;
+    updated.narrativeTraces = [
+        ...(updated.narrativeTraces ?? []),
+        {
+            id: createId("narrative_trace"),
+            timestamp,
+            source: "$longtable-interview",
+            traceType: "judgment",
+            summary: options.reason?.trim()
+                ? `LongTable interview cancelled: ${options.reason.trim()}.`
+                : "LongTable interview cancelled before First Research Shape confirmation.",
+            visibility: "explicit",
+            importance: "low"
+        }
+    ];
+    await writeFile(context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
+    await syncCurrentWorkspaceView(context);
+    return { hook, state: updated };
+}
 function findQuestion(records, questionId) {
     if (questionId) {
         return records.find((record) => record.id === questionId) ?? null;
@@ -709,9 +769,11 @@ export function createLongTableMcpServer() {
             quality: z.enum(["thin", "usable", "rich"]).optional(),
             needsFollowUp: z.boolean().optional(),
             followUpQuestion: z.string().optional(),
+            readyToSummarize: z.boolean().optional().describe("Set true only when the interview has content-based closure readiness; never infer this from turn count alone."),
+            readinessRationale: z.array(z.string()).optional().describe("Brief evidence that the interview has enough context for a First Research Shape."),
             rationale: z.array(z.string()).optional()
         })
-    }, async ({ cwd: inputCwd, hookId, question, answer, reflection, quality, needsFollowUp, followUpQuestion, rationale }) => {
+    }, async ({ cwd: inputCwd, hookId, question, answer, reflection, quality, needsFollowUp, followUpQuestion, readyToSummarize, readinessRationale, rationale }) => {
         try {
             const context = await requireContext(inputCwd);
             const result = await appendInterviewTurn(context, {
@@ -722,6 +784,8 @@ export function createLongTableMcpServer() {
                 quality: quality,
                 needsFollowUp,
                 followUpQuestion,
+                readyToSummarize,
+                readinessRationale,
                 rationale
             });
             return textResult(result);
@@ -759,6 +823,26 @@ export function createLongTableMcpServer() {
             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.",
+        inputSchema: cwdSchema.extend({
+            hookId: z.string().optional(),
+            reason: z.string().optional()
+        })
+    }, async ({ cwd: inputCwd, hookId, reason }) => {
+        try {
+            const context = await requireContext(inputCwd);
+            const result = await cancelInterviewHook(context, { hookId, reason });
+            return textResult({
+                hook: compactInterviewHook(result.hook),
+                cancelled: true
+            });
+        }
+        catch (error) {
+            return errorResult(error instanceof Error ? error.message : String(error));
+        }
+    });
     server.registerTool("confirm_first_research_shape", {
         title: "Confirm First Research Shape",
         description: "Use MCP form elicitation to confirm, revise, defer, or request more context for the First Research Shape.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longtable/mcp",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "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.40",
-    "@longtable/cli": "0.1.40",
-    "@longtable/core": "0.1.40",
-    "@longtable/provider-claude": "0.1.40",
-    "@longtable/provider-codex": "0.1.40",
-    "@longtable/setup": "0.1.40",
+    "@longtable/checkpoints": "0.1.42",
+    "@longtable/cli": "0.1.42",
+    "@longtable/core": "0.1.42",
+    "@longtable/provider-claude": "0.1.42",
+    "@longtable/provider-codex": "0.1.42",
+    "@longtable/setup": "0.1.42",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^4.0.0"
   },