@longtable/cli 0.1.35 → 0.1.37

package/dist/cli.js

@@ -17,7 +17,7 @@ import { buildPersonaGuidance, parseInvocationDirective } from "./persona-router
 import { PERSONA_DEFINITIONS, listRoleDefinitions } from "./personas.js";
 import { buildPanelFallback, renderPanelSummary } from "./panel.js";
 import { LONGTABLE_MANAGED_HOOK_EVENTS, codexHooksEnabled, enableCodexHooksFeature, getMissingManagedCodexHookEvents, mergeManagedCodexHooksConfig, removeManagedCodexHooks } from "./codex-hooks.js";
-import { appendInvocationRecordToWorkspace, assertWorkspaceNotBlocked, answerWorkspaceQuestion, clearWorkspaceQuestion, createWorkspaceFollowUpQuestions, createWorkspaceQuestion, createOrUpdateProjectWorkspace, inspectProjectWorkspace, loadWorkspaceState, loadProjectContextFromDirectory, repairWorkspaceStateConsistency, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.js";
+import { appendInvocationRecordToWorkspace, assertWorkspaceNotBlocked, answerWorkspaceQuestion, buildQuestionOpportunitySpecs, clearWorkspaceQuestion, createWorkspaceFollowUpQuestions, createWorkspaceQuestion, createOrUpdateProjectWorkspace, inspectProjectWorkspace, loadWorkspaceState, loadProjectContextFromDirectory, repairWorkspaceStateConsistency, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.js";
 import { buildTeamDebate, buildTeamReview, renderTeamDebateSummary } from "./debate.js";
 import { createPromptRenderer } from "./prompt-renderer.js";
 const VALID_MODES = new Set([
@@ -45,7 +45,7 @@ const ANSI = {
     green: "\u001B[32m"
 };
 const LONGTABLE_MCP_SERVER_NAME = "longtable-state";
-const LONGTABLE_MCP_PACKAGE_VERSION = "0.1.35";
+const LONGTABLE_MCP_PACKAGE_VERSION = "0.1.37";
 const LONGTABLE_MCP_MARKER_START = "# LongTable state MCP START";
 const LONGTABLE_MCP_MARKER_END = "# LongTable state MCP END";
 function style(text, prefix) {
@@ -101,6 +101,7 @@ function usage() {
         "  longtable resume [--cwd <path>] [--json]",
         "  longtable doctor [--cwd <path>] [--fix] [--json] [--codex-dir <path>] [--codex-config <path>] [--hooks-path <path>] [--claude-dir <path>] [--codex-prompts-dir <path>] [--codex-runtime-path <file>] [--claude-runtime-path <file>]",
         "  longtable status [--cwd <path>] [--fix] [--json] [--codex-dir <path>] [--codex-config <path>] [--hooks-path <path>] [--claude-dir <path>] [--codex-prompts-dir <path>] [--codex-runtime-path <file>] [--claude-runtime-path <file>]",
+        "  longtable audit [questions|roles] [--json]",
         "  longtable roles [--json]",
         "  longtable show [--json] [--path <file>]",
         "  longtable install [--json] [--path <file>] [--runtime-path <file>]",
@@ -149,7 +150,7 @@ function parseArgs(argv) {
     const values = {};
     let subcommand = maybeSubcommand;
     const modeCommand = command && VALID_MODES.has(command);
-    const directCommand = command && ["init", "setup", "start", "resume", "doctor", "status", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "clear-question", "panel", "decide", "sentinel", "team", "search"].includes(command);
+    const directCommand = command && ["init", "setup", "start", "resume", "doctor", "status", "audit", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "clear-question", "panel", "decide", "sentinel", "team", "search"].includes(command);
     let startIndex = 1;
     if (modeCommand) {
         subcommand = undefined;
@@ -162,6 +163,10 @@ function parseArgs(argv) {
         subcommand = maybeSubcommand;
         startIndex = 2;
     }
+    else if (command === "audit" && maybeSubcommand && !maybeSubcommand.startsWith("--")) {
+        subcommand = maybeSubcommand;
+        startIndex = 2;
+    }
     else if (directCommand) {
         subcommand = undefined;
         startIndex = 1;
@@ -1742,6 +1747,193 @@ async function runDoctor(args) {
     }
     console.log(renderDoctorStatus(status));
 }
+const QUESTION_AUDIT_FIXTURES = [
+    {
+        id: "harness_philosophy",
+        prompt: "LongTable 훅과 체크포인트가 연구자의 철학에 맞는지, 질문을 멈춰야 하는 지점에서 생성하는지 평가해줘.",
+        expectedKinds: ["harness_design", "question_policy", "philosophical_reflection"]
+    },
+    {
+        id: "all_needed_questions",
+        prompt: "매번 내가 필요한 질문을 해줘 라고 하지 않아도 필요한 질문을 모두 하는 에이전트로 만들고 싶어.",
+        expectedKinds: ["question_policy"]
+    },
+    {
+        id: "trust_calibration_construct",
+        prompt: "Trust calibration에서 subjective trust와 reliance, switch to AI를 같은 측정으로 봐도 되는지 검토해줘.",
+        expectedKinds: ["research_commitment"]
+    },
+    {
+        id: "tacit_assumption",
+        prompt: "이 계획에는 말하지 않은 전제와 암묵적 가정이 있는 것 같아.",
+        expectedKinds: ["tacit_assumption"]
+    },
+    {
+        id: "protected_decision_closure",
+        prompt: "Protected decision closure pressure: measurement. User prompt: Implement the plan.",
+        expectedKinds: ["research_commitment"]
+    },
+    {
+        id: "low_stakes_copyedit",
+        prompt: "문장 끝 공백만 정리해줘.",
+        expectedKinds: []
+    }
+];
+function runQuestionAudit() {
+    const fixtures = QUESTION_AUDIT_FIXTURES.map((fixture) => {
+        const opportunities = buildQuestionOpportunitySpecs(fixture.prompt, {
+            includeFallback: false,
+            autoOnly: true
+        });
+        const observedKinds = [...new Set(opportunities.map((opportunity) => opportunity.kind))];
+        const failures = fixture.expectedKinds
+            .filter((kind) => !observedKinds.includes(kind))
+            .map((kind) => `missing expected question kind: ${kind}`);
+        if (fixture.expectedKinds.length === 0 && observedKinds.length > 0) {
+            failures.push(`expected no auto questions, observed: ${observedKinds.join(", ")}`);
+        }
+        return {
+            id: fixture.id,
+            prompt: fixture.prompt,
+            expectedKinds: fixture.expectedKinds,
+            observedKinds,
+            passed: failures.length === 0,
+            failures
+        };
+    });
+    const passedCount = fixtures.filter((fixture) => fixture.passed).length;
+    return {
+        passed: passedCount === fixtures.length,
+        fixtures,
+        totals: {
+            fixtureCount: fixtures.length,
+            passedCount,
+            failedCount: fixtures.length - passedCount
+        }
+    };
+}
+const REQUIRED_ROLE_SKILL_SECTIONS = [
+    "## Purpose",
+    "## Role Focus",
+    "## Must-Ask Questions",
+    "## Stop Conditions",
+    "## Output Contract",
+    "## Anti-Patterns",
+    "## Rules"
+];
+function buildRoleAuditEntry(provider, spec) {
+    const body = spec.body.join("\n");
+    const missingSections = REQUIRED_ROLE_SKILL_SECTIONS.filter((section) => !body.includes(section));
+    const warnings = [];
+    if (spec.body.length < 35) {
+        warnings.push("role skill is too thin to carry a distinct research perspective");
+    }
+    if (!body.includes("Researcher Checkpoint")) {
+        warnings.push("role skill does not explicitly mention Researcher Checkpoint behavior");
+    }
+    if (!body.includes("evidence")) {
+        warnings.push("role skill does not explicitly mention evidence needs");
+    }
+    return {
+        name: spec.name,
+        provider,
+        lineCount: spec.body.length,
+        missingSections,
+        warnings
+    };
+}
+function runRoleAudit() {
+    const baseSkillNames = new Set([
+        "longtable",
+        "longtable-interview",
+        "longtable-panel",
+        "longtable-explore",
+        "longtable-review"
+    ]);
+    const roles = [
+        ...buildCodexSkillSpecs(listRoleDefinitions())
+            .filter((spec) => !baseSkillNames.has(spec.name))
+            .map((spec) => buildRoleAuditEntry("codex", spec)),
+        ...buildClaudeSkillSpecs(listRoleDefinitions())
+            .filter((spec) => !baseSkillNames.has(spec.name))
+            .map((spec) => buildRoleAuditEntry("claude", spec))
+    ];
+    const passedCount = roles.filter((role) => role.missingSections.length === 0 && role.warnings.length === 0).length;
+    return {
+        passed: passedCount === roles.length,
+        roles,
+        totals: {
+            roleCount: roles.length,
+            passedCount,
+            failedCount: roles.length - passedCount
+        }
+    };
+}
+function renderQuestionAudit(result) {
+    const lines = [
+        "LongTable question audit",
+        `Result: ${result.passed ? "passed" : "failed"} (${result.totals.passedCount}/${result.totals.fixtureCount})`,
+        ""
+    ];
+    for (const fixture of result.fixtures) {
+        lines.push(`- ${fixture.id}: ${fixture.passed ? "passed" : "failed"}`);
+        lines.push(`  expected: ${fixture.expectedKinds.length > 0 ? fixture.expectedKinds.join(", ") : "none"}`);
+        lines.push(`  observed: ${fixture.observedKinds.length > 0 ? fixture.observedKinds.join(", ") : "none"}`);
+        for (const failure of fixture.failures) {
+            lines.push(`  failure: ${failure}`);
+        }
+    }
+    return lines.join("\n");
+}
+function renderRoleAudit(result) {
+    const lines = [
+        "LongTable role skill audit",
+        `Result: ${result.passed ? "passed" : "failed"} (${result.totals.passedCount}/${result.totals.roleCount})`,
+        ""
+    ];
+    for (const role of result.roles) {
+        const passed = role.missingSections.length === 0 && role.warnings.length === 0;
+        lines.push(`- ${role.provider}:${role.name}: ${passed ? "passed" : "failed"} (${role.lineCount} lines)`);
+        if (role.missingSections.length > 0) {
+            lines.push(`  missing: ${role.missingSections.join(", ")}`);
+        }
+        for (const warning of role.warnings) {
+            lines.push(`  warning: ${warning}`);
+        }
+    }
+    return lines.join("\n");
+}
+async function runAudit(subcommand, args) {
+    if (subcommand === "questions" || subcommand === "question") {
+        const result = runQuestionAudit();
+        console.log(args.json === true ? JSON.stringify(result, null, 2) : renderQuestionAudit(result));
+        if (!result.passed) {
+            exit(1);
+        }
+        return;
+    }
+    if (subcommand === "roles" || subcommand === "role") {
+        const result = runRoleAudit();
+        console.log(args.json === true ? JSON.stringify(result, null, 2) : renderRoleAudit(result));
+        if (!result.passed) {
+            exit(1);
+        }
+        return;
+    }
+    const questions = runQuestionAudit();
+    const roles = runRoleAudit();
+    const result = {
+        passed: questions.passed && roles.passed,
+        questions,
+        roles
+    };
+    console.log(args.json === true
+        ? JSON.stringify(result, null, 2)
+        : [renderQuestionAudit(questions), "", renderRoleAudit(roles)].join("\n"));
+    if (!result.passed) {
+        exit(1);
+    }
+}
 async function runCodexPersistInit(args) {
     const { flow, provider, answers } = await readPersistAnswers(args);
     const outputValue = createPersistedSetupOutput(answers, provider, flow);
@@ -2627,7 +2819,8 @@ async function runAutomaticFollowUpIfNeeded(prompt, args) {
         context,
         prompt,
         provider,
-        required: true
+        required: true,
+        auto: true
     });
     if (result.questions.length === 0) {
         return false;
@@ -3239,6 +3432,10 @@ async function main() {
         await runDoctor(values);
         return;
     }
+    if (command === "audit") {
+        await runAudit(subcommand, values);
+        return;
+    }
     if (command === "roles") {
         await runRoles(values);
         return;

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

@@ -1,5 +1,5 @@
 import { pathToFileURL } from "node:url";
-import { loadProjectContextFromDirectory, loadWorkspaceState, pendingQuestionObligations } from "./index.js";
+import { createWorkspaceFollowUpQuestions, loadProjectContextFromDirectory, loadWorkspaceState, pendingQuestionObligations } from "./index.js";
 function safeString(value) {
     return typeof value === "string" ? value : "";
 }
@@ -110,6 +110,37 @@ function looksLikeClosurePrompt(prompt) {
     return /\b(final|finalize|commit|ship|submit|revise|rewrite|draft|publish|implement|fix)\b/i.test(normalized)
         || /최종|확정|커밋|제출|수정|초안|구현|진행|고쳐/.test(normalized);
 }
+function looksLikeExecutionDirective(prompt) {
+    const normalized = prompt.trim();
+    if (!normalized) {
+        return false;
+    }
+    return /\b(proceed|implement|fix|publish|release|deploy|tag|push|ship)\b/i.test(normalized)
+        || /진행|구현|수정|고쳐|배포|릴리즈|태그|푸시|출시/.test(normalized);
+}
+function looksLikeLongTableEngineeringPrompt(prompt) {
+    const normalized = prompt.trim();
+    if (!normalized) {
+        return false;
+    }
+    return /\b(longtable|hook|checkpoint|mcp|agent|npm|version|global|publish|release|deploy|git)\b/i.test(normalized)
+        || /롱테이블|훅|체크포인트|에이전트|글로벌|배포|버전|릴리즈|깃|깃허브/.test(normalized);
+}
+function shouldAutoCreateQuestionsForPrompt(prompt) {
+    return !(looksLikeExecutionDirective(prompt) && looksLikeLongTableEngineeringPrompt(prompt));
+}
+function shouldApplyProtectedDecisionClosure(runtime, prompt) {
+    return Boolean(runtime.context.session.protectedDecision) &&
+        looksLikeClosurePrompt(prompt) &&
+        !looksLikeLongTableEngineeringPrompt(prompt);
+}
+function protectedDecisionClosurePrompt(prompt) {
+    return [
+        "Protected decision closure pressure.",
+        "The protected decision text is stored in the current session.",
+        `User prompt: ${prompt}`
+    ].join("\n");
+}
 function isStateChangingBash(command) {
     const normalized = command.trim();
     if (!normalized) {
@@ -153,9 +184,24 @@ function buildPendingQuestionContext(question) {
     return [
         `Required Researcher Checkpoint is still pending: ${question.prompt.question}`,
         `Options: ${formatQuestionOptions(question)}`,
-        `Record it with longtable decide --question ${question.id} --answer <value> if you are outside MCP elicitation.`
+        `Record it with longtable decide --question ${question.id} --answer <value> if you are outside MCP elicitation.`,
+        "Do not choose or record an answer unless the researcher explicitly provides the selection."
     ].join("\n");
 }
+function buildGeneratedQuestionsContext(questions, created) {
+    const lines = [
+        created
+            ? `LongTable created ${questions.length} required Researcher Checkpoint${questions.length === 1 ? "" : "s"} for this prompt.`
+            : `LongTable found ${questions.length} pending Researcher Checkpoint${questions.length === 1 ? "" : "s"} for this prompt.`
+    ];
+    for (const question of questions) {
+        lines.push(`- ${question.prompt.title}: ${question.prompt.question}`);
+        lines.push(`  Options: ${formatQuestionOptions(question)}`);
+        lines.push(`  Record it with longtable decide --question ${question.id} --answer <value> if you are outside MCP elicitation.`);
+    }
+    lines.push("Do not choose or record answers for these checkpoints unless the researcher explicitly provides the selections.");
+    return lines.join("\n");
+}
 function buildPendingObligationContext(obligation) {
     return [
         `Pending LongTable research obligation: ${obligation.prompt}`,
@@ -192,7 +238,7 @@ function sessionStartContext(runtime) {
     sections.push("Treat `.longtable/` state and `CURRENT.md` as the source of truth for this workspace.");
     return sections.filter(Boolean).join("\n\n");
 }
-function userPromptSubmitContext(runtime, prompt) {
+async function userPromptSubmitContext(runtime, prompt) {
     const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
     if (blockingQuestion) {
         return buildPendingQuestionContext(blockingQuestion);
@@ -205,7 +251,34 @@ function userPromptSubmitContext(runtime, prompt) {
     if (interview) {
         return buildActiveInterviewContext(interview);
     }
-    if (runtime.context.session.protectedDecision && looksLikeClosurePrompt(prompt)) {
+    const generatedQuestions = [];
+    let createdQuestions = false;
+    if (shouldAutoCreateQuestionsForPrompt(prompt)) {
+        const generated = await createWorkspaceFollowUpQuestions({
+            context: runtime.context,
+            prompt,
+            provider: "codex",
+            required: true,
+            auto: true
+        });
+        generatedQuestions.push(...generated.questions);
+        createdQuestions = createdQuestions || generated.created;
+    }
+    if (shouldApplyProtectedDecisionClosure(runtime, prompt)) {
+        const protectedGenerated = await createWorkspaceFollowUpQuestions({
+            context: runtime.context,
+            prompt: protectedDecisionClosurePrompt(prompt),
+            provider: "codex",
+            required: true,
+            auto: true
+        });
+        generatedQuestions.push(...protectedGenerated.questions.filter((question) => !generatedQuestions.some((existing) => existing.id === question.id)));
+        createdQuestions = createdQuestions || protectedGenerated.created;
+    }
+    if (generatedQuestions.length > 0) {
+        return buildGeneratedQuestionsContext(generatedQuestions, createdQuestions);
+    }
+    if (shouldApplyProtectedDecisionClosure(runtime, prompt)) {
         return [
             `This workspace marks ${runtime.context.session.protectedDecision} as a protected decision.`,
             "Before you settle it through drafting, revision, or closure, surface one researcher-facing checkpoint grounded in the current blocker or open questions."
@@ -251,14 +324,7 @@ function postToolUseOutput(runtime, payload) {
     return null;
 }
 function stopOutput(runtime) {
-    const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
-    if (blockingQuestion) {
-        return buildStopBlockOutput("A required LongTable Researcher Checkpoint is still pending.");
-    }
-    const blockingObligation = pendingObligations(runtime.state)[0];
-    if (blockingObligation) {
-        return buildStopBlockOutput("A LongTable research obligation is still pending.");
-    }
+    void runtime;
     return null;
 }
 export async function dispatchCodexHook(payload, cwdOverride) {
@@ -274,7 +340,7 @@ export async function dispatchCodexHook(payload, cwdOverride) {
         return buildAdditionalContextOutput(hookEventName, sessionStartContext(runtime));
     }
     if (hookEventName === "UserPromptSubmit") {
-        const additionalContext = userPromptSubmitContext(runtime, readPromptText(payload));
+        const additionalContext = await userPromptSubmitContext(runtime, readPromptText(payload));
         return additionalContext
             ? buildAdditionalContextOutput(hookEventName, additionalContext)
             : null;

package/dist/project-session.d.ts

@@ -1,4 +1,4 @@
-import type { DecisionRecord, InvocationRecord, LongTableQuestionObligation, ProviderKind, QuestionOption, QuestionSurface, QuestionRecord, ResearchState } from "@longtable/core";
+import type { DecisionRecord, InvocationRecord, LongTableQuestionObligation, ProviderKind, QuestionOption, 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";
@@ -223,12 +223,20 @@ export declare function summarizeLongTableInterview(options: {
 export declare function listBlockingWorkspaceQuestions(context: LongTableProjectContext): Promise<QuestionRecord[]>;
 export declare function listBlockingWorkspaceObligations(context: LongTableProjectContext): Promise<LongTableQuestionObligation[]>;
 export declare function assertWorkspaceNotBlocked(context: LongTableProjectContext): Promise<void>;
+type FollowUpQuestionSpec = QuestionOpportunity;
+interface BuildFollowUpQuestionOptions {
+    includeFallback?: boolean;
+    autoOnly?: boolean;
+}
+export declare function buildQuestionOpportunitySpecs(prompt: string, options?: BuildFollowUpQuestionOptions): FollowUpQuestionSpec[];
+export declare function generateQuestionOpportunities(prompt: string, options?: BuildFollowUpQuestionOptions): QuestionGenerationResult;
 export declare function createWorkspaceFollowUpQuestions(options: {
     context: LongTableProjectContext;
     prompt: string;
     provider?: ProviderKind;
     required?: boolean;
     force?: boolean;
+    auto?: boolean;
 }): Promise<{
     questions: QuestionRecord[];
     state: ResearchState;
@@ -291,3 +299,4 @@ export declare function createOrUpdateProjectWorkspace(options: {
 export declare function loadProjectContextFromDirectory(startPath: string): Promise<LongTableProjectContext | null>;
 export declare function inspectProjectWorkspace(startPath: string): Promise<LongTableWorkspaceInspection>;
 export declare function renderProjectWorkspaceSummary(context: LongTableProjectContext): string;
+export {};

package/dist/project-session.js

@@ -984,17 +984,182 @@ function includesAny(prompt, patterns) {
 function followUpQuestionOptions(first, second, third, fourth) {
     return [first, second, third, ...(fourth ? [fourth] : [])];
 }
-function buildFollowUpQuestionSpecs(prompt) {
+export function buildQuestionOpportunitySpecs(prompt, options = {}) {
     const normalized = prompt.toLowerCase();
     const specs = [];
     function push(spec) {
         if (!specs.some((candidate) => candidate.key === spec.key)) {
-            specs.push(spec);
+            specs.push({
+                required: true,
+                confidence: "medium",
+                autoEligible: false,
+                cues: [],
+                ...spec
+            });
         }
     }
+    if (includesAny(normalized, [
+        /\blongtable\b/,
+        /\bharness\b/,
+        /\bhook\b/,
+        /\bcheckpoint\b/,
+        /\bagents?\b/,
+        /\bmcp\b/,
+        /\bover[- ]?engineer/,
+        /롱테이블|하네스|훅|체크포인트|에이전트|오버\s*엔지니어링|과설계/
+    ])) {
+        push({
+            key: "harness_question_harness",
+            kind: "harness_design",
+            title: "Question harness target",
+            question: "Which LongTable failure should the question system optimize against first?",
+            whyNow: "Harness changes can optimize for visible activity while still missing the moments where researcher judgment should stop the run.",
+            options: followUpQuestionOptions({ value: "missing_questions", label: "Missing necessary questions", description: "Prioritize stopping at unstated assumptions, construct collapse, or closure pressure.", recommended: true }, { value: "false_interruptions", label: "Unhelpful interruptions", description: "Reduce questions that slow execution without protecting a real research judgment." }, { value: "role_surface_quality", label: "Role and skill quality", description: "Audit whether agents and markdown skills ask the right questions for their roles." }, { value: "state_traceability", label: "State traceability", description: "Prioritize durable question, answer, and checkpoint records over UI convenience." }),
+            confidence: "high",
+            autoEligible: true,
+            cues: ["longtable", "harness", "hook", "checkpoint", "agent", "mcp"]
+        });
+    }
+    if (includesAny(normalized, [
+        /\bneeded questions?\b/,
+        /\bnecessary questions?\b/,
+        /\bask (all|every|more)\b/,
+        /\bquestion generation\b/,
+        /\bclarifying questions?\b/,
+        /필요한\s*질문|질문을\s*(모두|많이|생성)|질문.*(?:생성|멈춰|지점)|질문이\s*모두|질문\s*생성|물어봐|질문해/
+    ])) {
+        push({
+            key: "needed_question_policy",
+            kind: "question_policy",
+            title: "Question policy",
+            question: "When LongTable detects missing context, what questioning rule should it follow before continuing?",
+            whyNow: "A question-heavy agent needs a policy for when questions are required, batched, advisory, or too disruptive.",
+            options: followUpQuestionOptions({ value: "ask_required_first", label: "Ask required blockers first", description: "Stop only for questions that protect a real decision or construct boundary.", recommended: true }, { value: "batch_all_questions", label: "Batch all plausible questions", description: "Generate a fuller question queue even if some items are advisory." }, { value: "continue_with_assumptions", label: "Continue with assumptions", description: "Proceed but record assumptions and unresolved questions explicitly." }),
+            confidence: "high",
+            autoEligible: true,
+            cues: ["needed_questions", "question_generation"]
+        });
+    }
+    if (includesAny(normalized, [
+        /\bphilosoph/i,
+        /\breflect(ion|ive)?\b/,
+        /\bfundamental questions?\b/,
+        /\bprinciple\b/,
+        /\bagency\b/,
+        /철학|성찰|근본(?:적)?\s*질문|원칙|내\s*철학|연구자성|주체성/
+    ])) {
+        push({
+            key: "philosophical_checkpoint_boundary",
+            kind: "philosophical_reflection",
+            title: "Checkpoint philosophy",
+            question: "What should a checkpoint philosophically protect in this LongTable run?",
+            whyNow: "A checkpoint can either protect researcher agency or become a procedural interruption; LongTable should not choose that philosophy silently.",
+            options: followUpQuestionOptions({ value: "researcher_agency", label: "Researcher agency", description: "Stop when LongTable is about to decide for the researcher.", recommended: true }, { value: "construct_integrity", label: "Construct integrity", description: "Stop when distinct ideas may be collapsed into one claim." }, { value: "usability_burden", label: "Usability burden", description: "Stop only when the benefit justifies interrupting the workflow." }),
+            autoEligible: true,
+            cues: ["philosophy", "reflection", "researcher_agency"]
+        });
+    }
+    if (includesAny(normalized, [
+        /\bprotected decision\b/,
+        /\bclosure pressure\b/,
+        /\bsettle\b/,
+        /\bfinalize\b/,
+        /\bcommit\b/,
+        /보호된\s*결정|확정|최종|마무리|결정\s*압력/
+    ])) {
+        push({
+            key: "protected_decision_closure",
+            kind: "research_commitment",
+            title: "Protected decision closure",
+            question: "What should LongTable do with the protected decision before proceeding?",
+            whyNow: "The prompt creates closure pressure around a decision the workspace says should not settle silently.",
+            options: followUpQuestionOptions({ value: "keep_open", label: "Keep it open", description: "Do not treat the decision as settled; preserve it as an explicit blocker.", recommended: true }, { value: "ask_researcher", label: "Ask the researcher now", description: "Pause execution until the researcher chooses the decision boundary." }, { value: "proceed_with_record", label: "Proceed with record", description: "Continue only after recording the assumption and residual risk." }),
+            confidence: "high",
+            autoEligible: true,
+            cues: ["protected_decision", "closure_pressure"]
+        });
+    }
+    if (includesAny(normalized, [
+        /\btrust\b/,
+        /\breliance\b/,
+        /\bcalibration\b/,
+        /\bconstruct\b/,
+        /\bmeasurement\b/,
+        /\bdefinition\b/,
+        /신뢰|의존|의존성|캘리브레이션|교정|보정|개념|구성개념|측정|정의/
+    ])) {
+        push({
+            key: "construct_boundary_commitment",
+            kind: "research_commitment",
+            title: "Construct boundary",
+            question: "Which construct boundary should LongTable keep explicit before treating the direction as settled?",
+            whyNow: "Trust, reliance, calibration, and measurement choices can look compatible while requiring different evidence and analysis rules.",
+            options: followUpQuestionOptions({ value: "separate_trust_reliance", label: "Separate trust from reliance", description: "Treat subjective trust as a predictor or correlate rather than the same thing as reliance.", recommended: true }, { value: "condition_calibration", label: "Condition calibration carefully", description: "Define calibration using AI correctness and participant correctness instead of switch behavior alone." }, { value: "hold_construct_open", label: "Keep construct open", description: "Do not settle the construct boundary until evidence or design constraints are clearer." }),
+            confidence: "high",
+            autoEligible: true,
+            cues: ["trust", "reliance", "calibration", "construct", "measurement"]
+        });
+    }
+    if (includesAny(normalized, [
+        /\bknowledge gap\b/,
+        /\bgap\b/,
+        /\bunknown\b/,
+        /\buncertain\b/,
+        /\bnot sure\b/,
+        /\bblocker\b/,
+        /지식\s*공백|모르겠|불확실|블로커|막히|애매/
+    ])) {
+        push({
+            key: "knowledge_gap_probe",
+            kind: "knowledge_gap",
+            title: "Knowledge gap",
+            question: "Which unknown should LongTable resolve before it recommends or implements a direction?",
+            whyNow: "The request signals uncertainty; moving directly to advice can hide the real blocker.",
+            options: followUpQuestionOptions({ value: "scope_gap", label: "Scope is unclear", description: "Clarify what is included, excluded, and high stakes.", recommended: true }, { value: "evidence_gap", label: "Evidence is missing", description: "Clarify what sources or data should anchor the answer." }, { value: "decision_gap", label: "Decision is unsettled", description: "Clarify the researcher judgment that must stay open." }),
+            autoEligible: true,
+            cues: ["knowledge_gap", "uncertainty", "blocker"]
+        });
+    }
+    if (includesAny(normalized, [
+        /\bassumption\b/,
+        /\bimplicit\b/,
+        /\btacit\b/,
+        /\bunstated\b/,
+        /전제|가정|암묵|묵시|숨은\s*가정|말하지\s*않은/
+    ])) {
+        push({
+            key: "tacit_assumption_probe",
+            kind: "tacit_assumption",
+            title: "Tacit assumption",
+            question: "Which assumption should LongTable make explicit before proceeding?",
+            whyNow: "Tacit assumptions often determine the answer while remaining invisible in the artifact.",
+            options: followUpQuestionOptions({ value: "researcher_intent", label: "Researcher intent", description: "Clarify the user's intended boundary or priority.", recommended: true }, { value: "evidence_standard", label: "Evidence standard", description: "Clarify what would count as adequate support." }, { value: "system_behavior", label: "System behavior", description: "Clarify what the agent or hook should do at runtime." }),
+            autoEligible: true,
+            cues: ["assumption", "implicit", "tacit"]
+        });
+    }
+    if (includesAny(normalized, [
+        /\btrade[- ]?off\b/,
+        /\bconflict\b/,
+        /\btension\b/,
+        /\bvs\.?\b/,
+        /갈등|긴장|상충|균형|대립|비교/
+    ])) {
+        push({
+            key: "value_conflict_boundary",
+            kind: "value_conflict",
+            title: "Value conflict",
+            question: "Which tradeoff should LongTable keep visible instead of resolving silently?",
+            whyNow: "Competing values such as rigor, usability, speed, and authorship require researcher judgment.",
+            options: followUpQuestionOptions({ value: "rigor_over_speed", label: "Rigor over speed", description: "Ask more before changing the research direction.", recommended: true }, { value: "usability_over_coverage", label: "Usability over coverage", description: "Limit questions to those that unblock the current task." }, { value: "record_disagreement", label: "Record disagreement", description: "Proceed only after preserving the conflict in state or output." }),
+            autoEligible: true,
+            cues: ["tradeoff", "conflict", "tension"]
+        });
+    }
     if (includesAny(normalized, [/\brubrics?\b/, /루브릭|채점기준/])) {
         push({
             key: "rubric_update_basis",
+            kind: "research_commitment",
             title: "Rubric update basis",
             question: "How should LongTable use the available materials to update the rubric?",
             whyNow: "Rubric updates can silently change grading criteria if LongTable guesses the calibration basis.",
@@ -1004,6 +1169,7 @@ function buildFollowUpQuestionSpecs(prompt) {
     if (includesAny(normalized, [/\bexemplar\b/, /\bbest submission\b/, /\bselected submission\b/, /\bTA\b/i, /우수\s*답안|예시|선정|조교/])) {
         push({
             key: "exemplar_use",
+            kind: "evidence_risk",
             title: "Exemplar use",
             question: "How should LongTable use selected exemplars or TA guidance?",
             whyNow: "Exemplars can either calibrate criteria privately or become visible evidence inside the output.",
@@ -1013,6 +1179,7 @@ function buildFollowUpQuestionSpecs(prompt) {
     if (includesAny(normalized, [/\binstruction/, /\bguidance\b/, /\bsource\b/, /\bfile\b/, /\bdocx?\b/, /지침|가이드|문서|파일|자료/])) {
         push({
             key: "source_authority",
+            kind: "source_authority",
             title: "Source authority",
             question: "If sources conflict or leave gaps, which source should LongTable privilege?",
             whyNow: "Without an authority rule, LongTable may resolve conflicts by convenience rather than researcher intent.",
@@ -1022,6 +1189,7 @@ function buildFollowUpQuestionSpecs(prompt) {
     if (includesAny(normalized, [/\bdeliver\b/, /\boutput\b/, /\btracked?[- ]?change/, /\bdocx?\b/, /\bmarkdown\b/, /\btable\b/, /전달|산출물|결과물|수정\s*표시|트랙|형식|포맷/])) {
         push({
             key: "delivery_format",
+            kind: "delivery_format",
             title: "Delivery format",
             question: "How should LongTable deliver the clarified output?",
             whyNow: "Format and change-tracking choices affect whether the result is usable for review or handoff.",
@@ -1031,6 +1199,7 @@ function buildFollowUpQuestionSpecs(prompt) {
     if (includesAny(normalized, [/\bupdate\b/, /\bchange\b/, /\bedit\b/, /\bfix\b/, /\bimplement\b/, /\bbuild\b/, /\bcreate\b/, /업데이트|수정|변경|구현|만들|고쳐/])) {
         push({
             key: "autonomy_boundary",
+            kind: "autonomy_boundary",
             title: "Autonomy boundary",
             question: "How much should LongTable do before checking back with you?",
             whyNow: "Execution requests can move from advice to authorship or artifact ownership unless the boundary is explicit.",
@@ -1040,22 +1209,35 @@ function buildFollowUpQuestionSpecs(prompt) {
     if (includesAny(normalized, [/\bperformance\b/, /\btest\b/, /\bevaluate\b/, /\bcheck\b/, /\bbenchmark\b/, /성능|테스트|평가|체크|검증/])) {
         push({
             key: "evaluation_target",
+            kind: "evaluation_target",
             title: "Evaluation target",
             question: "What should LongTable treat as the main performance target?",
             whyNow: "Performance checks can optimize for UX, correctness, trigger sensitivity, or delivery reliability.",
             options: followUpQuestionOptions({ value: "question_sensitivity", label: "Question sensitivity", description: "Check whether LongTable asks at the right knowledge-gap moments.", recommended: true }, { value: "renderer_convenience", label: "Renderer convenience", description: "Check whether the most convenient question UI is used." }, { value: "state_reliability", label: "State reliability", description: "Check whether questions and answers persist correctly." })
         });
     }
-    if (specs.length === 0) {
+    if (specs.length === 0 && options.includeFallback !== false) {
         push({
             key: "general_missing_context",
+            kind: "general_missing_context",
             title: "Missing context",
             question: "What should LongTable clarify before proceeding?",
             whyNow: "The request can be answered in multiple ways, and choosing silently would hide a researcher judgment.",
             options: followUpQuestionOptions({ value: "scope", label: "Clarify scope first", description: "Ask what is included and excluded before acting.", recommended: true }, { value: "criteria", label: "Clarify success criteria", description: "Ask what would count as a good result." }, { value: "proceed", label: "Proceed with visible assumptions", description: "Continue, but make assumptions explicit." })
         });
     }
-    return specs;
+    return options.autoOnly === true ? specs.filter((spec) => spec.autoEligible) : specs;
+}
+function buildFollowUpQuestionSpecs(prompt) {
+    return buildQuestionOpportunitySpecs(prompt);
+}
+export function generateQuestionOpportunities(prompt, options = {}) {
+    const opportunities = buildQuestionOpportunitySpecs(prompt, options);
+    return {
+        promptSignature: prompt.replace(/\s+/g, " ").trim().toLowerCase().slice(0, 160),
+        opportunities,
+        blocking: opportunities.some((opportunity) => opportunity.required)
+    };
 }
 const FOLLOW_UP_PROMPT_PREFIX = "Follow-up prompt:";
 function hasFollowUpPrompt(record, prompt) {
@@ -1077,7 +1259,24 @@ export async function createWorkspaceFollowUpQuestions(options) {
     const preferredSurfaces = options.provider === "claude"
         ? ["native_structured", "terminal_selector", "numbered"]
         : ["mcp_elicitation", "terminal_selector", "numbered"];
-    const questions = buildFollowUpQuestionSpecs(options.prompt).map((spec) => ({
+    const specs = buildQuestionOpportunitySpecs(options.prompt, {
+        includeFallback: options.force === true ? true : options.auto !== true,
+        autoOnly: options.auto === true
+    });
+    if (specs.length === 0) {
+        return { questions: [], state, created: false, alreadyAnswered: false };
+    }
+    const existingPendingByCheckpoint = new Map((state.questionLog ?? [])
+        .filter((record) => record.status === "pending" && record.prompt.source === "runtime_guidance")
+        .map((record) => [record.prompt.checkpointKey, record]));
+    const pendingMatches = specs
+        .map((spec) => existingPendingByCheckpoint.get(`follow_up_${spec.key}`))
+        .filter((record) => Boolean(record));
+    const specsToCreate = specs.filter((spec) => !existingPendingByCheckpoint.has(`follow_up_${spec.key}`));
+    if (specsToCreate.length === 0) {
+        return { questions: pendingMatches, state, created: false, alreadyAnswered: false };
+    }
+    const questions = specsToCreate.map((spec) => ({
         id: createId("question_record"),
         createdAt,
         updatedAt: createdAt,
@@ -1091,10 +1290,12 @@ export async function createWorkspaceFollowUpQuestions(options) {
             options: spec.options,
             allowOther: true,
             otherLabel: "Other",
-            required: options.required ?? true,
+            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
@@ -1103,7 +1304,7 @@ export async function createWorkspaceFollowUpQuestions(options) {
     const updated = appendQuestionRecords(state, questions);
     await writeFile(options.context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
     await syncCurrentWorkspaceView(options.context);
-    return { questions, state: updated, created: true, alreadyAnswered: false };
+    return { questions: [...pendingMatches, ...questions], state: updated, created: true, alreadyAnswered: false };
 }
 export async function createWorkspaceQuestion(options) {
     const state = await loadResearchState(options.context.stateFilePath);

package/package.json

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