@longtable/cli 0.1.41 → 0.1.43

package/README.md

@@ -188,6 +188,12 @@ Inside a LongTable project workspace, panel planning also appends an
 `InvocationRecord` to `.longtable/state.json`, creates a pending follow-up
 `QuestionRecord`, and refreshes `CURRENT.md`.
 
+Panel output should remain inspectable. A panel or debate result is expected to
+show the consulted roles, each role's main claim or objection, the disagreement
+map, decision options, a defensible recommendation when one exists, and the
+exact researcher-facing question before a high-stakes decision is treated as
+settled.
+
 Default panel roles include:
 
 - `reviewer`
@@ -204,6 +210,12 @@ measurement, theory, method, evidence, authorship, or tacit-assumption risks.
 Use `--record` inside a LongTable workspace to store the finding as an
 unconfirmed inferred hypothesis.
 
+The Codex hook stays quiet for advisory-only questions. Required hook context is
+reserved for durable Researcher Checkpoints, especially when a prompt would
+change the research question/scope, theory frame, measurement/coding standard,
+method design, or analysis strategy. Low-risk reversible work should proceed
+with visible assumptions rather than a noisy hook interruption.
+
 `longtable team` creates a file-backed agent-team review under
 `.longtable/team/<id>/`: independent review, cross-review, and
 synthesis/checkpoint. Use it when roles should inspect each other's concerns

package/dist/cli.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { execSync } from "node:child_process";
 import { createInterface } from "node:readline/promises";
+import { createRequire } from "node:module";
 import { stdin as input, stdout as output, cwd, env, exit } from "node:process";
 import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
@@ -44,8 +45,10 @@ const ANSI = {
     cyan: "\u001B[36m",
     green: "\u001B[32m"
 };
+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 = "0.1.39";
+const LONGTABLE_MCP_PACKAGE_VERSION = LONGTABLE_PACKAGE_VERSION;
 const LONGTABLE_MCP_MARKER_START = "# LongTable state MCP START";
 const LONGTABLE_MCP_MARKER_END = "# LongTable state MCP END";
 function style(text, prefix) {

package/dist/longtable-codex-native-hook.js

@@ -1,5 +1,5 @@
 import { pathToFileURL } from "node:url";
-import { buildQuestionOpportunitySpecs, createWorkspaceFollowUpQuestions, loadProjectContextFromDirectory, loadWorkspaceState, pendingQuestionObligations } from "./index.js";
+import { createWorkspaceFollowUpQuestions, loadProjectContextFromDirectory, loadWorkspaceState, pendingQuestionObligations } from "./index.js";
 function safeString(value) {
     return typeof value === "string" ? value : "";
 }
@@ -115,7 +115,7 @@ function looksLikeLongTableProductOrToolingPrompt(prompt) {
     if (!normalized) {
         return false;
     }
-    return /\b(longlongtable|hook|checkpoint|mcp|agents?|skills?|ux|interface|setup|install|cli|npm|version|global|release|deploy|git|github|readme|docs?|documentation|workflow|package|router|autocomplete|simulation test)\b/i.test(normalized)
+    return /\b(longtable|longlongtable|hook|checkpoint|mcp|agents?|skills?|ux|interface|setup|install|cli|npm|version|global|release|deploy|git|github|readme|docs?|documentation|workflow|package|router|autocomplete|simulation test)\b/i.test(normalized)
         || /롱테이블|훅|체크포인트|에이전트|스킬|사용성|인터페이스|설치|세팅|글로벌|배포|버전|릴리즈|깃|깃허브|문서화된\s*절차|패키지|라우터|자동완성|시뮬레이션\s*테스트/.test(normalized);
 }
 function looksLikeResearchDomainPrompt(prompt) {
@@ -123,34 +123,74 @@ function looksLikeResearchDomainPrompt(prompt) {
     if (!normalized) {
         return false;
     }
-    return /\b(research|study|paper|manuscript|journal|article|method|methodology|measurement|construct|theory|analysis|model|data|participant|sample|scale|survey|instrument|validity|hypothesis|literature|meta[- ]?analysis|gold standard|coding|trust|reliance|calibration)\b/i.test(normalized)
-        || /연구|논문|원고|저널|방법론|방법|연구\s*설계|측정|구성개념|개념|이론|분석|모형|모델|데이터|참가자|표본|샘플|척도|설문|도구|타당도|가설|문헌|메타\s*분석|골드\s*스탠더드|코딩|신뢰|의존|캘리브레이션|교정|보정/.test(normalized);
+    return /\b(research|research question|research direction|scope|boundary|study|paper|manuscript|journal|article|method|methodology|measurement|construct|theory|framework|analysis|analysis plan|model|data|participant|sample|scale|survey|instrument|validity|hypothesis|literature|meta[- ]?analysis|gold standard|coding|criteria|trust|reliance|calibration)\b/i.test(normalized)
+        || /연구|연구\s*질문|연구\s*방향|범위|경계|논문|원고|저널|방법론|방법|연구\s*설계|측정|구성개념|개념|이론|프레임워크|분석|분석\s*계획|모형|모델|데이터|참가자|표본|샘플|척도|설문|도구|타당도|가설|문헌|메타\s*분석|골드\s*스탠더드|코딩|기준|신뢰|의존|캘리브레이션|교정|보정/.test(normalized);
 }
 function looksLikeResearchCommitmentPrompt(prompt) {
-    return looksLikeResearchDomainPrompt(prompt) && looksLikeClosurePrompt(prompt);
+    return looksLikeResearchDomainPrompt(prompt) && (looksLikeClosurePrompt(prompt) ||
+        /\b(change|revise|update|replace|reframe|modify|alter)\b/i.test(prompt) ||
+        /바꾸|변경|수정|교체|전환|재설정/.test(prompt));
 }
-function buildResponseOnlyAdvisoryQuestions(prompt) {
-    if (looksLikeLongTableProductOrToolingPrompt(prompt)) {
-        return [];
+function looksLikeQuestionGenerationPrompt(prompt) {
+    return /\b(needed questions?|necessary questions?|question generation|clarifying questions?|ask questions?)\b/i.test(prompt)
+        || /필요한\s*질문|질문을\s*(모두|많이|생성)|질문\s*생성|물어봐|질문해/.test(prompt);
+}
+function looksLikeMultiCommitmentChangePrompt(prompt) {
+    const normalized = prompt.trim();
+    const actionCue = /\b(change|revise|update|replace|reframe|modify|alter)\b/i.test(normalized)
+        || /바꾸|변경|수정|교체|전환|재설정/.test(normalized);
+    if (!actionCue) {
+        return false;
     }
-    const opportunities = buildQuestionOpportunitySpecs(prompt, {
-        includeFallback: false,
-        autoOnly: true
-    });
-    if (opportunities.length === 0) {
-        return [];
+    const categories = [
+        /\b(research question|research direction|scope|boundary|inclusion criteria|exclusion criteria)\b/i.test(normalized)
+            || /연구\s*질문|연구\s*문제|연구\s*방향|범위|경계|포함\s*기준|제외\s*기준/.test(normalized),
+        /\b(theory|framework|conceptual model|construct map)\b/i.test(normalized)
+            || /이론|프레임워크|개념\s*모형|구성개념\s*지도|컨스트럭트/.test(normalized),
+        /\b(measure|measurement|scale|instrument|coding|coding rule|extraction rule|operationali[sz]ation)\b/i.test(normalized)
+            || /측정|척도|도구|코딩|코딩\s*규칙|코딩\s*기준|추출\s*규칙|추출\s*기준|조작화/.test(normalized),
+        /\b(method|methodology|study design|sampling|sample)\b/i.test(normalized)
+            || /방법론|방법|연구\s*설계|표본|샘플링/.test(normalized),
+        /\b(analysis plan|analysis method|meta[- ]?analysis|masem|(?:statistical|structural|path|analysis) model|moderator|random[- ]?effects)\b/i.test(normalized)
+            || /분석\s*계획|분석\s*방법|메타\s*분석|분석\s*(?:모형|모델)|통계\s*(?:모형|모델)|구조\s*방정식|경로\s*모형|조절효과|랜덤\s*효과/.test(normalized)
+    ];
+    return categories.filter(Boolean).length >= 2;
+}
+function looksLikeExplicitInterviewPrompt(prompt) {
+    const normalized = prompt.trim();
+    if (!normalized) {
+        return false;
+    }
+    if (/\$longtable-interview\b/i.test(normalized)) {
+        return true;
+    }
+    if (looksLikeLongTableProductOrToolingPrompt(normalized)) {
+        return false;
     }
-    if (!looksLikeResearchDomainPrompt(prompt) && !/\b(needed questions?|necessary questions?|clarifying questions?|question generation|assumptions?|uncertain|not sure|gap|tension|trade[- ]?off)\b/i.test(prompt) && !/필요한\s*질문|질문\s*생성|물어봐|질문해|전제|가정|불확실|모르겠|공백|긴장|상충|균형/.test(prompt)) {
-        return [];
+    return /\bLongTable\b.*\binterview\b/i.test(normalized)
+        || /\bfirst research shape\b/i.test(normalized)
+        || /롱테이블.*인터뷰|LongTable.*인터뷰|First Research Shape/i.test(normalized);
+}
+function looksLikeResearchStateConfirmationPrompt(prompt) {
+    if (looksLikeLongTableProductOrToolingPrompt(prompt) && !looksLikeExplicitInterviewPrompt(prompt)) {
+        return false;
     }
-    return opportunities.slice(0, 3);
+    return looksLikeResearchCommitmentPrompt(prompt)
+        || (looksLikeExplicitInterviewPrompt(prompt) && looksLikeClosurePrompt(prompt))
+        || /\b(confirm|summarize|save|store|record)\b.*\b(first research shape|research direction|research shape)\b/i.test(prompt)
+        || /(First Research Shape|연구\s*방향|연구\s*형태).*(확정|저장|기록|요약)/.test(prompt);
+}
+function shouldSurfaceInterviewContext(prompt) {
+    return looksLikeExplicitInterviewPrompt(prompt) || looksLikeResearchStateConfirmationPrompt(prompt);
 }
 function shouldCreateRequiredQuestionsForPrompt(prompt) {
     return !looksLikeLongTableProductOrToolingPrompt(prompt) && looksLikeResearchCommitmentPrompt(prompt);
 }
 function shouldApplyProtectedDecisionClosure(runtime, prompt) {
     return Boolean(runtime.context.session.protectedDecision) &&
-        shouldCreateRequiredQuestionsForPrompt(prompt);
+        shouldCreateRequiredQuestionsForPrompt(prompt) &&
+        !looksLikeQuestionGenerationPrompt(prompt) &&
+        !looksLikeMultiCommitmentChangePrompt(prompt);
 }
 function protectedDecisionClosurePrompt(prompt) {
     return [
@@ -167,6 +207,14 @@ function isStateChangingBash(command) {
     return /\b(git\s+commit|npm\s+version|mv|cp|rm|sed\s+-i|perl\s+-i|tee|touch|mkdir|rmdir|apply_patch|patch)\b/.test(normalized)
         || />\s*\S+/.test(normalized);
 }
+function mutatesLongTableResearchState(command) {
+    const normalized = command.trim();
+    if (!normalized) {
+        return false;
+    }
+    return /\.longtable(?:\/|\b)|\bCURRENT\.md\b/.test(normalized)
+        || /\blongtable\s+(?:start|question|clear-question|prune-questions|ask|clarify|panel|team)\b/.test(normalized);
+}
 async function loadLongTableRuntime(startPath) {
     const context = await loadProjectContextFromDirectory(startPath);
     if (!context) {
@@ -206,6 +254,13 @@ function buildPendingQuestionContext(question) {
         "Do not choose or record an answer unless the researcher explicitly provides the selection."
     ].join("\n");
 }
+function buildSeparatePendingQuestionNotice(question) {
+    return [
+        `Separate unresolved Researcher Checkpoint: ${question.prompt.title}.`,
+        `Question: ${question.prompt.question}`,
+        "This is not part of the active interview. Keep it visible, but do not answer or record it unless the researcher explicitly provides the selection."
+    ].join("\n");
+}
 function buildGeneratedQuestionsContext(questions, created) {
     const lines = [
         created
@@ -220,16 +275,6 @@ function buildGeneratedQuestionsContext(questions, created) {
     lines.push("Do not choose or record answers for these checkpoints unless the researcher explicitly provides the selections.");
     return lines.join("\n");
 }
-function buildAdvisoryQuestionsContext(questions) {
-    const lines = [
-        `LongTable surfaced ${questions.length} response-only advisory question${questions.length === 1 ? "" : "s"} for this prompt.`,
-        "Use these only if they help the reply. Do not create QuestionRecord entries, call longtable decide, or answer for the researcher unless the prompt explicitly asks to commit a research decision."
-    ];
-    for (const question of questions) {
-        lines.push(`- ${question.title}: ${question.question}`);
-    }
-    return lines.join("\n");
-}
 function buildPendingObligationContext(obligation) {
     return [
         `Pending LongTable research obligation: ${obligation.prompt}`,
@@ -239,6 +284,12 @@ function buildPendingObligationContext(obligation) {
             : "Resume the LongTable interview and let it ask the next research-facing checkpoint before settling the direction."
     ].join("\n");
 }
+function buildSeparatePendingObligationNotice(obligation) {
+    return [
+        `Separate unresolved LongTable obligation: ${obligation.prompt}`,
+        "This is not part of the active interview. Keep it visible only when the researcher is settling or saving the research direction."
+    ].join("\n");
+}
 function buildActiveInterviewContext(hook) {
     const turnCount = hook.turns?.length ?? 0;
     return [
@@ -254,64 +305,78 @@ function sessionStartContext(runtime) {
     const interview = activeInterviewHook(runtime.state);
     const needsDetailedSummary = Boolean(blockingQuestion || blockingObligation);
     const sections = [buildWorkspaceSummary(runtime, needsDetailedSummary ? "full" : "compact").join("\n")];
-    if (blockingQuestion) {
+    if (interview) {
+        sections.push(buildActiveInterviewContext(interview));
+        if (blockingQuestion) {
+            sections.push(buildSeparatePendingQuestionNotice(blockingQuestion));
+        }
+        else if (blockingObligation) {
+            sections.push(buildSeparatePendingObligationNotice(blockingObligation));
+        }
+    }
+    else if (blockingQuestion) {
         sections.push(buildPendingQuestionContext(blockingQuestion));
     }
     else if (blockingObligation) {
         sections.push(buildPendingObligationContext(blockingObligation));
     }
-    else if (interview) {
-        sections.push(buildActiveInterviewContext(interview));
-    }
     sections.push("Treat `.longtable/` state and `CURRENT.md` as the source of truth for this workspace.");
     return sections.filter(Boolean).join("\n\n");
 }
 async function userPromptSubmitContext(runtime, prompt) {
     const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
-    if (blockingQuestion) {
+    const blockingObligation = pendingObligations(runtime.state)[0];
+    const interview = activeInterviewHook(runtime.state);
+    const shouldSurfaceInterview = shouldSurfaceInterviewContext(prompt);
+    const shouldSurfaceBlockingState = looksLikeResearchStateConfirmationPrompt(prompt);
+    if (interview && shouldSurfaceInterview) {
+        const sections = [buildActiveInterviewContext(interview)];
+        if (blockingQuestion) {
+            sections.push(buildSeparatePendingQuestionNotice(blockingQuestion));
+        }
+        else if (blockingObligation) {
+            sections.push(buildSeparatePendingObligationNotice(blockingObligation));
+        }
+        return sections.join("\n\n");
+    }
+    if (blockingQuestion && shouldSurfaceBlockingState) {
         return buildPendingQuestionContext(blockingQuestion);
     }
-    const blockingObligation = pendingObligations(runtime.state)[0];
-    if (blockingObligation) {
+    if (blockingObligation && shouldSurfaceBlockingState) {
         return buildPendingObligationContext(blockingObligation);
     }
-    const interview = activeInterviewHook(runtime.state);
     if (interview) {
-        return buildActiveInterviewContext(interview);
+        return null;
     }
     const generatedQuestions = [];
     let createdQuestions = false;
-    if (shouldCreateRequiredQuestionsForPrompt(prompt)) {
-        const generated = await createWorkspaceFollowUpQuestions({
+    if (shouldApplyProtectedDecisionClosure(runtime, prompt)) {
+        const protectedGenerated = await createWorkspaceFollowUpQuestions({
             context: runtime.context,
-            prompt,
+            prompt: protectedDecisionClosurePrompt(prompt),
             provider: "codex",
             required: true,
             auto: true,
             requiredOnly: true
         });
-        generatedQuestions.push(...generated.questions);
-        createdQuestions = createdQuestions || generated.created;
+        generatedQuestions.push(...protectedGenerated.questions);
+        createdQuestions = createdQuestions || protectedGenerated.created;
     }
-    if (shouldApplyProtectedDecisionClosure(runtime, prompt)) {
-        const protectedGenerated = await createWorkspaceFollowUpQuestions({
+    else if (shouldCreateRequiredQuestionsForPrompt(prompt)) {
+        const generated = await createWorkspaceFollowUpQuestions({
             context: runtime.context,
-            prompt: protectedDecisionClosurePrompt(prompt),
+            prompt,
             provider: "codex",
             required: true,
             auto: true,
             requiredOnly: true
         });
-        generatedQuestions.push(...protectedGenerated.questions.filter((question) => !generatedQuestions.some((existing) => existing.id === question.id)));
-        createdQuestions = createdQuestions || protectedGenerated.created;
+        generatedQuestions.push(...generated.questions);
+        createdQuestions = createdQuestions || generated.created;
     }
     if (generatedQuestions.length > 0) {
         return buildGeneratedQuestionsContext(generatedQuestions, createdQuestions);
     }
-    const advisoryQuestions = buildResponseOnlyAdvisoryQuestions(prompt);
-    if (advisoryQuestions.length > 0) {
-        return buildAdvisoryQuestionsContext(advisoryQuestions);
-    }
     return null;
 }
 function preToolUseOutput(runtime, payload) {
@@ -319,16 +384,17 @@ function preToolUseOutput(runtime, payload) {
         return null;
     }
     const command = readCommandText(payload);
-    if (!isStateChangingBash(command)) {
+    const stateChangingCommand = isStateChangingBash(command) || mutatesLongTableResearchState(command);
+    if (!stateChangingCommand) {
         return null;
     }
     const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
-    if (blockingQuestion) {
-        return buildBlockOutput("PreToolUse", "A required LongTable checkpoint is still pending before a state-changing Bash command.", buildPendingQuestionContext(blockingQuestion));
+    if (blockingQuestion && mutatesLongTableResearchState(command)) {
+        return buildBlockOutput("PreToolUse", "A required LongTable checkpoint is still pending before a research-state Bash command.", buildPendingQuestionContext(blockingQuestion));
     }
     const blockingObligation = pendingObligations(runtime.state)[0];
-    if (blockingObligation) {
-        return buildBlockOutput("PreToolUse", "A LongTable research obligation is still pending before a state-changing Bash command.", buildPendingObligationContext(blockingObligation));
+    if (blockingObligation && mutatesLongTableResearchState(command)) {
+        return buildBlockOutput("PreToolUse", "A LongTable research obligation is still pending before a research-state Bash command.", buildPendingObligationContext(blockingObligation));
     }
     return null;
 }
@@ -341,8 +407,8 @@ function postToolUseOutput(runtime, payload) {
     const output = readCombinedOutput(payload);
     const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
     const blockingObligation = pendingObligations(runtime.state)[0];
-    if ((blockingQuestion || blockingObligation) && isStateChangingBash(command)) {
-        return buildBlockOutput("PostToolUse", "A state-changing Bash command completed while LongTable still had an unresolved checkpoint or obligation.", blockingQuestion
+    if ((blockingQuestion || blockingObligation) && mutatesLongTableResearchState(command)) {
+        return buildBlockOutput("PostToolUse", "A research-state Bash command completed while LongTable still had an unresolved checkpoint or obligation.", blockingQuestion
             ? buildPendingQuestionContext(blockingQuestion)
             : buildPendingObligationContext(blockingObligation));
     }

package/dist/project-session.d.ts

@@ -44,6 +44,8 @@ export interface LongTableInterviewTurn {
     quality: InterviewTurnQuality;
     needsFollowUp: boolean;
     followUpQuestion?: string;
+    readyToSummarize?: boolean;
+    readinessRationale?: string[];
     rationale?: string[];
 }
 export interface LongTableHookRun {
@@ -204,6 +206,8 @@ export declare function appendLongTableInterviewTurn(options: {
     quality?: InterviewTurnQuality;
     needsFollowUp?: boolean;
     followUpQuestion?: string;
+    readyToSummarize?: boolean;
+    readinessRationale?: string[];
     rationale?: string[];
 }): Promise<{
     hook: LongTableHookRun;

package/dist/project-session.js

@@ -420,7 +420,9 @@ function buildProjectAgentsMd(project, session) {
         "",
         "## Research Behavior",
         "- 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: ...`, and avoid early reader/reviewer or theory/method/measurement classification.",
+        "- 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.",
+        "- 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.",
         "- If you foreground role perspectives, disclose them with `LongTable consulted: ...`.",
         "- Keep one accountable synthesis, but do not hide meaningful disagreement.",
@@ -580,10 +582,10 @@ function defaultFollowUpQuestion(answer) {
     return "What concrete scene, case, material, text, dataset, or decision would make that problem easier to inspect first?";
 }
 function depthForInterview(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";
     }
@@ -614,6 +616,15 @@ export async function beginLongTableInterview(options) {
     if (existing) {
         return { hook: existing, state };
     }
+    const confirmedShape = state.firstResearchShape?.confirmedAt ? state.firstResearchShape : undefined;
+    if (confirmedShape) {
+        const confirmedHook = [...(state.hooks ?? [])].reverse().find((hook) => hook.kind === "longtable_interview" &&
+            hook.status === "confirmed" &&
+            hook.firstResearchShape?.handle === confirmedShape.handle);
+        if (confirmedHook) {
+            return { hook: confirmedHook, state };
+        }
+    }
     const timestamp = nowIso();
     const hook = {
         id: createId("hook_interview"),
@@ -654,6 +665,10 @@ export async function appendLongTableInterviewTurn(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 = nowIso();
     const turns = existing.turns ?? [];
     const turn = {
@@ -666,6 +681,8 @@ export async function appendLongTableInterviewTurn(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 nextTurns = [...turns, turn];
@@ -678,7 +695,10 @@ export async function appendLongTableInterviewTurn(options) {
         turns: nextTurns,
         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 = upsertHook(state, hook);
@@ -981,6 +1001,29 @@ function optionsForCheckpointTrigger(family, checkpointKey) {
 function includesAny(prompt, patterns) {
     return patterns.some((pattern) => pattern.test(prompt));
 }
+function questionPriority(spec) {
+    const byKey = {
+        protected_decision_closure: 100,
+        research_direction_change_commitment: 96,
+        construct_boundary_commitment: 94,
+        measurement_coding_standard: 92,
+        analysis_strategy_commitment: 90,
+        theory_frame_commitment: 88,
+        method_design_commitment: 86,
+        research_scope_boundary: 84,
+        epistemic_alignment_boundary: 82,
+        value_conflict_boundary: 80,
+        source_authority: 70,
+        knowledge_gap_probe: 68,
+        tacit_assumption_probe: 66,
+        needed_question_policy: 60,
+        philosophical_checkpoint_boundary: 58,
+        harness_question_harness: 55
+    };
+    const confidenceWeight = spec.confidence === "high" ? 10 : spec.confidence === "medium" ? 5 : 0;
+    const requiredWeight = spec.kind === "research_commitment" || spec.required ? 20 : 0;
+    return (byKey[spec.key] ?? 0) + confidenceWeight + requiredWeight;
+}
 function followUpQuestionOptions(first, second, third, fourth) {
     return [first, second, third, ...(fourth ? [fourth] : [])];
 }
@@ -998,6 +1041,158 @@ export function buildQuestionOpportunitySpecs(prompt, options = {}) {
             });
         }
     }
+    const decisionActionCue = includesAny(normalized, [
+        /\b(final|finalize|commit|decide|settle|freeze|lock|record|apply|incorporate|change|revise|update|replace|reframe|modify|alter)\b/i,
+        /최종|확정|결정|고정|기록|반영|바꾸|변경|수정|교체|전환|재설정/
+    ]);
+    const scopeCue = includesAny(normalized, [
+        /\bresearch question\b/i,
+        /\bresearch direction\b/i,
+        /\bscope\b/i,
+        /\bboundary\b/i,
+        /\binclusion criteria\b/i,
+        /\bexclusion criteria\b/i,
+        /연구\s*질문|연구\s*문제|연구\s*방향|범위|경계|포함\s*기준|제외\s*기준/
+    ]);
+    const theoryCue = includesAny(normalized, [
+        /\btheory\b/i,
+        /\bframework\b/i,
+        /\bconceptual model\b/i,
+        /\bconstruct map\b/i,
+        /이론|프레임워크|개념\s*모형|구성개념\s*지도|컨스트럭트/
+    ]);
+    const measurementCodingCue = includesAny(normalized, [
+        /\bmeasure\b/i,
+        /\bmeasurement\b/i,
+        /\bscale\b/i,
+        /\binstrument\b/i,
+        /\bcoding\b/i,
+        /\bcoding rule\b/i,
+        /\bextraction rule\b/i,
+        /\boperationali[sz]ation\b/i,
+        /측정|척도|도구|코딩|코딩\s*규칙|코딩\s*기준|추출\s*규칙|추출\s*기준|조작화/
+    ]);
+    const methodCue = includesAny(normalized, [
+        /\bmethod\b/i,
+        /\bmethodology\b/i,
+        /\bstudy design\b/i,
+        /\bsampling\b/i,
+        /\bsample\b/i,
+        /방법론|방법|연구\s*설계|표본|샘플링/
+    ]);
+    const analysisCue = includesAny(normalized, [
+        /\banalysis plan\b/i,
+        /\banalysis method\b/i,
+        /\bmeta[- ]?analysis\b/i,
+        /\bmasem\b/i,
+        /\b(statistical|structural|path|analysis) model\b/i,
+        /\bmoderator\b/i,
+        /\brandom[- ]?effects\b/i,
+        /분석\s*계획|분석\s*방법|메타\s*분석|분석\s*(?:모형|모델)|통계\s*(?:모형|모델)|구조\s*방정식|경로\s*모형|조절효과|랜덤\s*효과/
+    ]);
+    const decisionFamilyCount = [scopeCue, theoryCue, measurementCodingCue, methodCue, analysisCue]
+        .filter(Boolean).length;
+    if (decisionActionCue && decisionFamilyCount >= 2) {
+        push({
+            key: "research_direction_change_commitment",
+            kind: "research_commitment",
+            title: "Research direction change",
+            question: "Which high-risk research commitment should LongTable clarify first before changing the project direction?",
+            whyNow: "The prompt touches multiple protected research commitments; proceeding silently would let LongTable choose the priority order for the researcher.",
+            options: followUpQuestionOptions({ value: "scope_first", label: "Scope or research question first", description: "Clarify what the study includes, excludes, or asks before changing downstream work.", recommended: true }, { value: "theory_first", label: "Theory or construct frame first", description: "Clarify the conceptual frame before changing methods or analysis." }, { value: "method_analysis_first", label: "Method or analysis first", description: "Clarify design, data, or analysis implications before changing the artifact." }, { value: "defer", label: "Keep the direction open", description: "Do not change the research direction until the commitment order is explicit." }),
+            confidence: "high",
+            autoEligible: true,
+            required: true,
+            cues: ["research_direction", "multi_commitment_change"]
+        });
+    }
+    if (decisionActionCue && scopeCue) {
+        push({
+            key: "research_scope_boundary",
+            kind: "research_commitment",
+            title: "Research scope boundary",
+            question: "What scope boundary should LongTable keep explicit before treating the research direction as changed?",
+            whyNow: "Scope changes can redefine the population, domain, corpus, or research question before the researcher has explicitly chosen the boundary.",
+            options: followUpQuestionOptions({ value: "revise_scope", label: "Revise the scope", description: "Change the inclusion boundary before downstream work continues.", recommended: true }, { value: "compare_boundaries", label: "Compare boundaries first", description: "Keep candidate scopes visible before choosing one." }, { value: "proceed_with_scope_assumption", label: "Proceed with scope assumption", description: "Continue only after stating the assumed boundary." }, { value: "defer", label: "Keep scope open", description: "Do not settle the scope yet." }),
+            confidence: "high",
+            autoEligible: true,
+            cues: ["research_scope", "boundary"]
+        });
+    }
+    if (decisionActionCue && theoryCue) {
+        push({
+            key: "theory_frame_commitment",
+            kind: "research_commitment",
+            title: "Theory frame",
+            question: "Which theory or construct frame should LongTable treat as the candidate commitment before revising the model?",
+            whyNow: "Theory-frame changes can make later measurement, coding, and analysis choices look settled when they are only inferred.",
+            options: followUpQuestionOptions({ value: "compare_theories", label: "Compare theory frames first", description: "Keep competing theoretical anchors visible before choosing one.", recommended: true }, { value: "revise_theory", label: "Revise the frame", description: "Change the framework and record the conceptual tradeoff." }, { value: "use_current_frame", label: "Use current frame tentatively", description: "Proceed but mark the theory choice as provisional." }, { value: "defer", label: "Keep theory open", description: "Do not settle the theory frame yet." }),
+            confidence: "high",
+            autoEligible: true,
+            cues: ["theory", "framework", "construct"]
+        });
+    }
+    if (decisionActionCue && measurementCodingCue) {
+        push({
+            key: "measurement_coding_standard",
+            kind: "research_commitment",
+            title: "Measurement and coding standard",
+            question: "What measurement or coding rule should LongTable ask you to fix before extracting or revising data?",
+            whyNow: "Measurement and coding rules decide what counts as evidence; changing them silently can make later synthesis non-reproducible.",
+            options: followUpQuestionOptions({ value: "define_construct_rule", label: "Define construct rule first", description: "Clarify what counts as the construct or variable before extraction.", recommended: true }, { value: "define_extraction_rule", label: "Define extraction rule first", description: "Clarify correlation, path, beta, or qualitative evidence extraction rules." }, { value: "pilot_code", label: "Pilot the coding rule", description: "Test the rule on a small sample before committing." }, { value: "defer", label: "Keep coding open", description: "Do not settle measurement or coding yet." }),
+            confidence: "high",
+            autoEligible: true,
+            cues: ["measurement", "coding", "extraction"]
+        });
+    }
+    if (decisionActionCue && methodCue) {
+        push({
+            key: "method_design_commitment",
+            kind: "research_commitment",
+            title: "Method design",
+            question: "Which method-design choice should LongTable keep explicit before changing the study plan?",
+            whyNow: "Method changes affect the defensible claim, sample, evidence standard, and ethics boundary.",
+            options: followUpQuestionOptions({ value: "revise_design", label: "Revise design first", description: "Change the design or sample boundary before proceeding.", recommended: true }, { value: "check_feasibility", label: "Check feasibility first", description: "Inspect whether data, evidence, and access support the method." }, { value: "proceed_with_method_assumption", label: "Proceed with method assumption", description: "Continue only after stating the assumed method." }, { value: "defer", label: "Keep method open", description: "Do not commit the method yet." }),
+            confidence: "high",
+            autoEligible: true,
+            cues: ["method", "study_design", "sample"]
+        });
+    }
+    if (decisionActionCue && analysisCue) {
+        push({
+            key: "analysis_strategy_commitment",
+            kind: "research_commitment",
+            title: "Analysis strategy",
+            question: "What analysis strategy should LongTable treat as unsettled before revising or running the synthesis?",
+            whyNow: "Analysis choices determine what effect sizes, moderators, and interpretations become defensible.",
+            options: followUpQuestionOptions({ value: "choose_analysis_family", label: "Choose analysis family first", description: "Clarify MASEM, family-level meta-analysis, moderator analysis, or narrative synthesis.", recommended: true }, { value: "check_data_sufficiency", label: "Check data sufficiency first", description: "Inspect whether primary quantitative effects support the analysis." }, { value: "proceed_with_analysis_assumption", label: "Proceed with assumption", description: "Continue only after stating the analysis assumption." }, { value: "defer", label: "Keep analysis open", description: "Do not settle the analysis plan yet." }),
+            confidence: "high",
+            autoEligible: true,
+            cues: ["analysis", "model", "meta_analysis"]
+        });
+    }
+    if (decisionActionCue && includesAny(normalized, [
+        /\bconflict\b/i,
+        /\bcontradict/i,
+        /\bontology\b/i,
+        /\bepistem/i,
+        /\bhuman knowledge\b/i,
+        /\bai knowledge\b/i,
+        /\balignment\b/i,
+        /충돌|상충|모순|존재론|인식론|지식|인간의\s*지식|ai의\s*지식|정렬|방향성/
+    ])) {
+        push({
+            key: "epistemic_alignment_boundary",
+            kind: "value_conflict",
+            title: "Knowledge alignment",
+            question: "When researcher knowledge, AI inference, and project state conflict, what should LongTable privilege before acting?",
+            whyNow: "The prompt asks LongTable to mediate knowledge conflict; that mediation should be visible rather than hidden inside an implementation choice.",
+            options: followUpQuestionOptions({ value: "ask_researcher", label: "Ask researcher clarity first", description: "Pause when human meaning or priority is underspecified.", recommended: true }, { value: "inspect_project_state", label: "Inspect project state first", description: "Use durable files and prior decisions before inferring intent." }, { value: "proceed_with_trace", label: "Proceed with explicit trace", description: "Continue only after naming the conflict and assumption." }, { value: "defer", label: "Keep conflict open", description: "Do not collapse the conflict into one answer yet." }),
+            confidence: "high",
+            autoEligible: true,
+            cues: ["knowledge_conflict", "epistemic_alignment"]
+        });
+    }
     if (includesAny(normalized, [
         /\blongtable\b/,
         /\bharness\b/,
@@ -1231,7 +1426,13 @@ export function buildQuestionOpportunitySpecs(prompt, options = {}) {
     if (options.requiredOnly === true) {
         selected = selected.filter((spec) => spec.kind === "research_commitment");
     }
-    return selected;
+    if (normalized.includes("protected decision closure pressure")) {
+        selected = selected.filter((spec) => spec.key === "protected_decision_closure");
+    }
+    else if (options.requiredOnly === true && selected.some((spec) => spec.key === "research_direction_change_commitment")) {
+        selected = selected.filter((spec) => spec.key === "research_direction_change_commitment");
+    }
+    return selected.sort((a, b) => questionPriority(b) - questionPriority(a));
 }
 function buildFollowUpQuestionSpecs(prompt) {
     return buildQuestionOpportunitySpecs(prompt);

package/package.json

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