@longtable/cli 0.1.58 → 0.1.59

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { execSync } from "node:child_process";
+import { execSync, spawnSync } 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";
@@ -157,7 +157,7 @@ function usage() {
         "  longtable sentinel --prompt <text> [--cwd <path>] [--json] [--record]",
         "  longtable ask [--prompt <text>] [--print] [--json] [--setup <path>] [--cwd <path>]",
         "  longtable clarify --prompt <task-context> [--provider codex|claude] [--required|--advisory] [--print] [--cwd <path>] [--json] [--force]",
-        "  longtable question --prompt <decision-context> [--title <text>] [--text <question>] [--provider codex|claude] [--required|--advisory] [--print] [--cwd <path>] [--json]",
+        "  longtable question (--prompt <decision-context> | --question <id>) [--title <text>] [--text <question>] [--provider codex|claude] [--required|--advisory] [--surface tmux_popup|terminal_selector|numbered] [--print] [--cwd <path>] [--json]",
         "  longtable clear-question --question <id> --reason <text> [--cwd <path>] [--json]",
         "  longtable panel [--prompt <text>] [--role <role[,role]>] [--mode review|critique|draft|commit] [--visibility synthesis_only|show_on_conflict|always_visible] [--provider codex|claude] [--native-workers|--native-subagents] [--wait [ms]] [--print] [--json] [--setup <path>] [--cwd <path>]",
         "  longtable panel status --run <panel_run_id> [--wait [ms]] [--cwd <path>] [--json]",
@@ -166,7 +166,7 @@ function usage() {
         "  longtable panel resume --run <panel_run_id> [--wait [ms]] [--cwd <path>] [--json]",
         "  longtable panel record [--invocation <id>] --result-file <json> [--surface sequential_fallback|native_subagents|native_workers] [--cwd <path>] [--json]",
         "  longtable handoff [--cwd <path>] [--output <file>] [--print] [--json]",
-        "  longtable decide [--question <id>] --answer <value-or-text> [--rationale <text>] [--provider codex|claude] [--cwd <path>] [--json]",
+        "  longtable decide [--question <id>] --answer <value-or-text> [--rationale <text>] [--provider codex|claude] [--surface tmux_popup|mcp_elicitation|terminal_selector|numbered] [--cwd <path>] [--json]",
         "  longtable explore|review|critique|draft|commit|submit [--prompt <text>] [--role <role[,role]>] [--panel] [--show-conflicts] [--show-deliberation] [--print] [--json] [--stage <stage>] [--setup <path>] [--cwd <path>]",
         "  longtable codex persist-init [--answers-json <json> | --stdin | full setup flags] [--install-skills] [--install-prompts] [--json]",
         "  longtable codex install-skills [--surface compact|full] [--dir <path>]",
@@ -299,6 +299,27 @@ function parseSkillSurface(args) {
     }
     throw new Error("Invalid --surface value. Use compact or full.");
 }
+const QUESTION_SURFACE_VALUES = [
+    "native_structured",
+    "tmux_popup",
+    "mcp_elicitation",
+    "numbered",
+    "terminal_selector",
+    "web_form"
+];
+function parseQuestionSurface(value) {
+    if (value === undefined || value === false) {
+        return undefined;
+    }
+    if (value === true) {
+        throw new Error(`Invalid --surface value. Use one of: ${QUESTION_SURFACE_VALUES.join(", ")}.`);
+    }
+    const normalized = value.trim();
+    if (QUESTION_SURFACE_VALUES.includes(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Invalid --surface value. Use one of: ${QUESTION_SURFACE_VALUES.join(", ")}.`);
+}
 function stripWrappingQuotes(value) {
     const trimmed = value.trim();
     if ((trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||
@@ -2324,6 +2345,149 @@ function commandAvailable(command) {
         return false;
     }
 }
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringArrayValue(value) {
+    if (Array.isArray(value)) {
+        return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+    }
+    return typeof value === "string" && value.trim().length > 0 ? [value] : [];
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function currentTmuxReturnPane() {
+    const explicit = stringValue(env.OMX_QUESTION_RETURN_PANE);
+    if (explicit) {
+        return explicit;
+    }
+    return stringValue(env.TMUX_PANE);
+}
+function codexTmuxPopupAvailable() {
+    return Boolean(currentTmuxReturnPane() && commandAvailable("omx"));
+}
+function buildOmxQuestionInput(record) {
+    const options = record.prompt.options.map((option) => ({
+        label: option.label,
+        value: option.value,
+        ...(option.description ? { description: option.description } : {})
+    }));
+    const freeText = record.prompt.type === "free_text";
+    const type = record.prompt.type === "multi_choice" ? "multi-answerable" : "single-answerable";
+    return {
+        header: "LongTable",
+        question: record.prompt.question,
+        questions: [{
+                id: record.id,
+                question: record.prompt.question,
+                options,
+                allow_other: freeText ? true : record.prompt.allowOther,
+                other_label: freeText ? "Answer" : record.prompt.otherLabel ?? "Other",
+                type,
+                multi_select: record.prompt.type === "multi_choice"
+            }],
+        options,
+        allow_other: freeText ? true : record.prompt.allowOther,
+        other_label: freeText ? "Answer" : record.prompt.otherLabel ?? "Other",
+        type,
+        multi_select: record.prompt.type === "multi_choice",
+        source: "longtable",
+        session_id: record.id
+    };
+}
+function readOmxAnswerPayload(payload) {
+    const root = isRecord(payload) ? payload : {};
+    const answers = Array.isArray(root.answers) ? root.answers : [];
+    for (const entry of answers) {
+        if (!isRecord(entry)) {
+            continue;
+        }
+        if (entry.answer !== undefined) {
+            return entry.answer;
+        }
+        return entry;
+    }
+    if (root.answer !== undefined) {
+        return root.answer;
+    }
+    return root;
+}
+function questionAnswerFromOmxPayload(record, payload) {
+    const answer = readOmxAnswerPayload(payload);
+    if (typeof answer === "string") {
+        return answer;
+    }
+    if (Array.isArray(answer)) {
+        return stringArrayValue(answer);
+    }
+    if (!isRecord(answer)) {
+        throw new Error("OMX question returned an answer payload LongTable cannot parse.");
+    }
+    if (record.prompt.type === "free_text") {
+        const freeText = [
+            stringValue(answer.other_text),
+            stringValue(answer.otherText),
+            stringValue(answer.text),
+            stringValue(answer.value),
+            stringArrayValue(answer.selected_values).join("\n"),
+            stringArrayValue(answer.selectedValues).join("\n")
+        ].find((entry) => entry && entry.trim().length > 0);
+        if (freeText) {
+            return freeText;
+        }
+    }
+    const selectedValues = [
+        ...stringArrayValue(answer.selected_values),
+        ...stringArrayValue(answer.selectedValues)
+    ];
+    const otherText = stringValue(answer.other_text) ?? stringValue(answer.otherText) ?? stringValue(answer.text);
+    if (answer.kind === "other" && otherText) {
+        return { selectedValues: ["other"], otherText };
+    }
+    if (selectedValues.length > 0) {
+        return otherText
+            ? { selectedValues: selectedValues.includes("other") ? selectedValues : [...selectedValues, "other"], otherText }
+            : selectedValues;
+    }
+    const valueValues = stringArrayValue(answer.value);
+    if (valueValues.length > 0) {
+        return valueValues.length === 1 ? valueValues[0] : valueValues;
+    }
+    if (otherText) {
+        return otherText;
+    }
+    throw new Error("OMX question did not include an answer value.");
+}
+function invokeOmxQuestionPopup(record) {
+    const returnPane = currentTmuxReturnPane();
+    if (!returnPane || !commandAvailable("omx")) {
+        throw new Error("LongTable tmux_popup transport requires an attached tmux pane and the `omx` command.");
+    }
+    const child = spawnSync("omx", ["question", "--input", JSON.stringify(buildOmxQuestionInput(record)), "--json"], {
+        cwd: cwd(),
+        env: {
+            ...env,
+            OMX_QUESTION_RETURN_PANE: returnPane
+        },
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (child.error) {
+        throw child.error;
+    }
+    if (child.status !== 0) {
+        const detail = [String(child.stderr ?? "").trim(), String(child.stdout ?? "").trim()].filter(Boolean).join("\n");
+        throw new Error(`LongTable tmux_popup transport failed${detail ? `: ${detail}` : "."}`);
+    }
+    const raw = String(child.stdout ?? "").trim();
+    try {
+        return raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        throw new Error(`LongTable tmux_popup transport returned non-JSON output: ${raw.slice(0, 200)}`);
+    }
+}
 function parseWaitMs(value) {
     if (value === undefined || value === false) {
         return undefined;
@@ -3393,11 +3557,51 @@ async function runSpec(subcommand, args) {
     }
     throw new Error(`Unknown spec subcommand: ${command}`);
 }
+function questionUsesKorean(record) {
+    return /[가-힣]/.test([
+        record.prompt.title,
+        record.prompt.question,
+        record.prompt.displayReason ?? "",
+        ...record.prompt.options.flatMap((option) => [option.label, option.description ?? ""]),
+        record.prompt.otherLabel ?? ""
+    ].join("\n"));
+}
+function renderQuestionDecisionCard(record) {
+    const korean = questionUsesKorean(record);
+    const lines = [
+        korean ? "LongTable 결정 카드" : "LongTable Decision Card",
+        `${korean ? "체크포인트" : "Checkpoint"}: ${record.prompt.title}`,
+        `${korean ? "무엇이 걸렸나" : "What is blocked"}: ${record.prompt.displayReason ?? record.prompt.rationale[0] ?? record.prompt.title}`,
+        `${korean ? "지금 결정할 것" : "Decision needed"}: ${record.prompt.question}`,
+        korean ? "선택지:" : "Choices:"
+    ];
+    record.prompt.options.forEach((option, index) => {
+        const recommended = option.recommended ? (korean ? " (추천)" : " (recommended)") : "";
+        lines.push(`${index + 1}. ${option.label}${recommended}`);
+        if (option.description) {
+            lines.push(`   ${option.description}`);
+        }
+        lines.push(`   ${korean ? "기록값" : "Record value"}: ${option.value}`);
+    });
+    if (record.prompt.allowOther) {
+        lines.push(`${record.prompt.options.length + 1}. ${record.prompt.otherLabel ?? (korean ? "직접 입력" : "Other")}`);
+        lines.push(`   ${korean ? "기록값" : "Record value"}: other`);
+    }
+    return lines.join("\n");
+}
 async function runQuestion(args) {
     const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
-    const prompt = await resolvePrompt(typeof args.prompt === "string" ? args.prompt : undefined);
-    if (!prompt) {
-        throw new Error("A decision context is required. Pass --prompt <text>.");
+    const requestedSurface = parseQuestionSurface(args.surface);
+    if (requestedSurface &&
+        requestedSurface !== "tmux_popup" &&
+        requestedSurface !== "terminal_selector" &&
+        requestedSurface !== "numbered") {
+        throw new Error("The LongTable question CLI can render tmux_popup, terminal_selector, or numbered surfaces. Use the MCP or provider-native runtime for other surfaces.");
+    }
+    const questionId = typeof args.question === "string" ? args.question.trim() : "";
+    const prompt = questionId ? undefined : await resolvePrompt(typeof args.prompt === "string" ? args.prompt : undefined);
+    if (!prompt && !questionId) {
+        throw new Error("A decision context or pending question id is required. Pass --prompt <text> or --question <id>.");
     }
     const context = await loadProjectContextFromDirectory(workingDirectory);
     if (!context) {
@@ -3405,17 +3609,73 @@ async function runQuestion(args) {
     }
     const provider = args.provider === "claude" ? "claude" : args.provider === "codex" ? "codex" : undefined;
     const required = args.required === true ? true : args.advisory === true ? false : undefined;
-    const result = await createWorkspaceQuestion({
-        context,
-        prompt,
-        title: typeof args.title === "string" ? args.title : undefined,
-        question: typeof args.text === "string" ? args.text : undefined,
-        provider,
-        required
-    });
+    let result;
+    if (questionId) {
+        const state = await loadWorkspaceState(context);
+        const question = state.questionLog.find((record) => record.id === questionId && record.status === "pending");
+        if (!question) {
+            throw new Error(`No pending LongTable question found for ${questionId}.`);
+        }
+        result = { question, state };
+    }
+    else {
+        result = await createWorkspaceQuestion({
+            context,
+            prompt: prompt ?? "",
+            title: typeof args.title === "string" ? args.title : undefined,
+            question: typeof args.text === "string" ? args.text : undefined,
+            provider,
+            required
+        });
+    }
     const transport = provider === "claude"
         ? renderQuestionRecordInput(result.question)
         : renderQuestionRecordPrompt(result.question);
+    const shouldTryTmuxPopup = requestedSurface === "tmux_popup" ||
+        (requestedSurface === undefined && provider === "codex" && codexTmuxPopupAvailable() && args.print !== true && args.json !== true);
+    if (shouldTryTmuxPopup) {
+        try {
+            const popupPayload = invokeOmxQuestionPopup(result.question);
+            const answer = questionAnswerFromOmxPayload(result.question, popupPayload);
+            const decision = await answerWorkspaceQuestion({
+                context,
+                questionId: result.question.id,
+                answer,
+                provider,
+                surface: "tmux_popup"
+            });
+            if (args.json === true) {
+                console.log(JSON.stringify({
+                    question: decision.question,
+                    decision: decision.decision,
+                    transport: {
+                        surface: "tmux_popup",
+                        status: "accepted"
+                    },
+                    files: {
+                        state: context.stateFilePath,
+                        current: context.currentFilePath
+                    }
+                }, null, 2));
+                return;
+            }
+            console.log("LongTable checkpoint decision recorded");
+            console.log(`- question: ${decision.question.id}`);
+            console.log(`- decision: ${decision.decision.id}`);
+            console.log(`- surface: tmux_popup`);
+            console.log(`- answer: ${decision.decision.selectedOption ?? "recorded"}`);
+            console.log(`- state: ${context.stateFilePath}`);
+            console.log(`- current: ${context.currentFilePath}`);
+            return;
+        }
+        catch (error) {
+            if (requestedSurface === "tmux_popup") {
+                throw error;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`LongTable tmux_popup transport unavailable; falling back. ${message}`);
+        }
+    }
     if (args.json === true) {
         console.log(JSON.stringify({
             question: result.question,
@@ -3437,7 +3697,7 @@ async function runQuestion(args) {
         }
         return;
     }
-    if (isInteractiveTerminal()) {
+    if ((requestedSurface === undefined || requestedSurface === "terminal_selector") && isInteractiveTerminal()) {
         console.log(renderBrandBanner("LongTable", "Researcher Checkpoint"));
         console.log("");
         const answer = await promptChoice(renderQuestionHeader(1, 1, result.question.prompt.title, result.question.prompt.question), questionRecordToChoices(result.question));
@@ -3457,16 +3717,11 @@ async function runQuestion(args) {
         console.log(`- current: ${context.currentFilePath}`);
         return;
     }
-    const optionValues = [
-        ...result.question.prompt.options.map((option) => option.value),
-        ...(result.question.prompt.allowOther ? ["other"] : [])
-    ];
     console.log(result.question.prompt.required ? "LongTable required Researcher Checkpoint recorded" : "LongTable advisory Researcher Checkpoint recorded");
     console.log(`- question: ${result.question.id}`);
     console.log(`- checkpoint: ${result.question.prompt.checkpointKey ?? "manual"}`);
-    console.log(`- prompt: ${result.question.prompt.question}`);
-    console.log(`- options: ${optionValues.join("/")}`);
-    console.log(`- answer: longtable decide --question ${result.question.id} --answer <value>`);
+    console.log(renderQuestionDecisionCard(result.question));
+    console.log(`- answer: longtable decide --question ${result.question.id} --answer <value> --surface numbered`);
     console.log(`- current: ${context.currentFilePath}`);
 }
 async function runClearQuestion(args) {
@@ -3928,12 +4183,14 @@ async function runDecide(args) {
         throw new Error("No LongTable project workspace was found here. Run this inside a project or pass --cwd.");
     }
     const provider = args.provider === "claude" ? "claude" : args.provider === "codex" ? "codex" : undefined;
+    const surface = parseQuestionSurface(args.surface);
     const result = await answerWorkspaceQuestion({
         context,
         questionId: typeof args.question === "string" ? args.question : undefined,
         answer,
         rationale: typeof args.rationale === "string" ? args.rationale : undefined,
-        provider
+        provider,
+        ...(surface ? { surface } : {})
     });
     if (args.json === true) {
         console.log(JSON.stringify({

package/dist/debate.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { buildInvocationIntent, buildPanelPlan } from "./panel.js";
+import { buildInvocationIntent, buildPanelDecisionContext, buildPanelPlan } from "./panel.js";
 import { getPersonaDefinition, parsePersonaKey } from "./personas.js";
 function nowIso() {
     return new Date().toISOString();
@@ -167,6 +167,10 @@ function buildSynthesis(plan, artifactPath, kind) {
     const labels = plan.members.map((member) => member.label);
     const highSensitivity = plan.checkpointSensitivity === "high";
     const runLabel = kind === "debate" ? "panel debate" : "panel review";
+    const decisionContext = buildPanelDecisionContext(plan.prompt);
+    const localizedRunLabel = decisionContext.language === "ko"
+        ? (kind === "debate" ? "패널 토론" : "패널 리뷰")
+        : runLabel;
     return {
         artifactPath,
         summary: `The ${runLabel} completed across ${labels.join(", ")}. It should slow closure by turning role disagreement into an explicit researcher decision.`,
@@ -187,13 +191,16 @@ function buildSynthesis(plan, artifactPath, kind) {
             "Choose whether the debate should affect the current artifact, the research design, or only the decision log."
         ],
         recommendedCheckpoint: highSensitivity
-            ? `The ${runLabel} surfaced high-sensitivity disagreement. What should LongTable treat as the next human decision before closure?`
-            : `The ${runLabel} surfaced role disagreement. Should LongTable revise, verify evidence, proceed, or keep the tension open?`
+            ? (decisionContext.language === "ko"
+                ? `${localizedRunLabel}에서 ${decisionContext.focus}에 대한 높은 민감도의 불일치가 드러났습니다. ${decisionContext.decisionQuestion}`
+                : `The ${runLabel} surfaced high-sensitivity disagreement about ${decisionContext.focus}. ${decisionContext.decisionQuestion}`)
+            : decisionContext.decisionQuestion
     };
 }
 export function createTeamDebateQuestionRecord(run, provider) {
     const createdAt = nowIso();
     const isDebate = run.interactionDepth === "debated";
+    const decisionContext = buildPanelDecisionContext(run.prompt);
     return {
         id: createId("question_record"),
         createdAt,
@@ -202,51 +209,32 @@ export function createTeamDebateQuestionRecord(run, provider) {
         prompt: {
             id: createId("question_prompt"),
             checkpointKey: "panel_debate_next_decision",
-            title: isDebate ? "Panel debate follow-up decision" : "Panel review follow-up decision",
+            title: decisionContext.language === "ko"
+                ? (isDebate ? "패널 토론 후속 결정" : "패널 리뷰 후속 결정")
+                : (isDebate ? "Panel debate follow-up decision" : "Panel review follow-up decision"),
             question: run.synthesis.recommendedCheckpoint,
             type: "single_choice",
-            options: [
-                {
-                    value: "revise",
-                    label: "Revise before proceeding",
-                    description: "Use the debate result to revise the claim, design, or draft first."
-                },
-                {
-                    value: "evidence",
-                    label: "Gather or verify evidence first",
-                    description: "Check source, data, or local artifact support before proceeding."
-                },
-                {
-                    value: "proceed",
-                    label: "Proceed with current direction",
-                    description: "Accept the risk profile and continue with the current direction."
-                },
-                {
-                    value: "defer",
-                    label: "Keep this open",
-                    description: "Do not commit yet; keep the debate issue visible as an open tension."
-                }
-            ],
+            options: decisionContext.options,
             allowOther: true,
-            otherLabel: "Other decision",
+            otherLabel: decisionContext.otherLabel,
             required: run.roles.some((member) => {
                 const key = parsePersonaKey(member.role);
                 return key ? getPersonaDefinition(key).checkpointSensitivity === "high" : false;
             }),
             source: "runtime_guidance",
-            displayReason: isDebate
-                ? "Role rebuttals and convergence should connect to an explicit researcher decision."
-                : "Cross-review created role disagreement that should connect to an explicit researcher decision.",
+            displayReason: decisionContext.displayReason,
             rationale: [
                 "LongTable panel orchestration is a research harness surface, not a substitute for researcher judgment.",
                 isDebate
                     ? "The fixed debate rounds created disagreement that should connect to an explicit researcher decision."
                     : "The cross-review round created disagreement that should connect to an explicit researcher decision.",
+                `Panel decision focus: ${decisionContext.focus}.`,
+                "Panel follow-up choices are compact by default; unlisted decisions should use Other.",
                 `LongTable panel run: ${run.id}.`
             ],
             preferredSurfaces: provider === "claude"
                 ? ["native_structured", "numbered"]
-                : ["mcp_elicitation", "numbered"]
+                : ["tmux_popup", "mcp_elicitation", "numbered"]
         }
     };
 }

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

@@ -57,12 +57,41 @@ function readCombinedOutput(payload) {
         safeString(payload.output)
     ].filter(Boolean).join("\n").trim();
 }
-function formatQuestionOptions(question) {
-    const options = question.prompt.options.map((option) => option.value);
+function questionUsesKorean(question) {
+    return /[가-힣]/.test([
+        question.prompt.title,
+        question.prompt.question,
+        question.prompt.displayReason ?? "",
+        ...question.prompt.options.flatMap((option) => [option.label, option.description ?? ""]),
+        question.prompt.otherLabel ?? ""
+    ].join("\n"));
+}
+function formatQuestionChoices(question) {
+    const korean = questionUsesKorean(question);
+    const options = question.prompt.options.flatMap((option, index) => {
+        const recommended = option.recommended ? (korean ? " (추천)" : " (recommended)") : "";
+        return [
+            `${index + 1}. ${option.label}${recommended}`,
+            ...(option.description ? [`   ${option.description}`] : []),
+            `   ${korean ? "기록값" : "Record value"}: ${option.value}`
+        ];
+    });
     if (question.prompt.allowOther) {
-        options.push("other");
+        options.push(`${question.prompt.options.length + 1}. ${question.prompt.otherLabel ?? (korean ? "직접 입력" : "Other")}`);
+        options.push(`   ${korean ? "기록값" : "Record value"}: other`);
     }
-    return options.join("/");
+    return options.join("\n");
+}
+function buildQuestionDecisionCard(question) {
+    const korean = questionUsesKorean(question);
+    return [
+        korean ? "LongTable 결정 카드" : "LongTable Decision Card",
+        `${korean ? "체크포인트" : "Checkpoint"}: ${question.prompt.title}`,
+        `${korean ? "무엇이 걸렸나" : "What is blocked"}: ${question.prompt.displayReason ?? question.prompt.rationale[0] ?? question.prompt.title}`,
+        `${korean ? "지금 결정할 것" : "Decision needed"}: ${question.prompt.question}`,
+        korean ? "선택지:" : "Choices:",
+        formatQuestionChoices(question)
+    ].join("\n");
 }
 function pendingRequiredQuestions(state) {
     return (state.questionLog ?? []).filter((question) => question.status === "pending" && question.prompt.required);
@@ -271,8 +300,8 @@ function buildWorkspaceSummary(runtime, detail = "compact") {
 }
 function buildPendingQuestionContext(question) {
     return [
-        `Required Researcher Checkpoint is still pending: ${question.prompt.question}`,
-        `Options: ${formatQuestionOptions(question)}`,
+        "Required Researcher Checkpoint is still pending.",
+        buildQuestionDecisionCard(question),
         `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");
@@ -291,8 +320,7 @@ function buildGeneratedQuestionsContext(questions, created) {
             : `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(buildQuestionDecisionCard(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.");

package/dist/panel.d.ts

@@ -1,5 +1,6 @@
-import type { CheckpointSensitivity, InteractionMode, InvocationIntent, InvocationRecord, PanelPlan, PanelResult, PanelVisibility, QuestionRecord, ProviderKind, InvocationSurface, RoleKey } from "@longtable/core";
+import type { CheckpointSensitivity, InteractionMode, InvocationIntent, InvocationRecord, PanelPlan, PanelResult, PanelVisibility, QuestionOption, QuestionRecord, ProviderKind, InvocationSurface, RoleKey } from "@longtable/core";
 import { type CanonicalPersona } from "./personas.js";
+import { type OutputLanguage } from "./persona-router.js";
 export interface BuildPanelPlanOptions {
     prompt: string;
     mode?: InteractionMode;
@@ -18,6 +19,16 @@ export interface PanelFallback {
     questionRecord: QuestionRecord;
     prompt: string;
 }
+interface PanelDecisionContext {
+    language: OutputLanguage;
+    focus: string;
+    blockerSummary: string;
+    decisionQuestion: string;
+    displayReason: string;
+    options: QuestionOption[];
+    otherLabel: string;
+}
+export declare function buildPanelDecisionContext(prompt: string): PanelDecisionContext;
 export declare function buildPanelPlan(options: BuildPanelPlanOptions): PanelPlan;
 export declare function buildInvocationIntent(options: {
     prompt: string;
@@ -41,3 +52,4 @@ export declare function renderSequentialFallbackPrompt(plan: PanelPlan): string;
 export declare function buildPanelFallback(options: BuildPanelPlanOptions): PanelFallback;
 export declare function renderPanelSummary(plan: PanelPlan): string;
 export declare function listDefaultPanelRoles(): CanonicalPersona[];
+export {};

package/dist/panel.js

@@ -61,6 +61,336 @@ function memberForRole(role, explicitRoles, routedRoles) {
         required: DEFAULT_PANEL_ROLES.includes(role) || explicitRoles.includes(role)
     };
 }
+function firstPromptClause(prompt) {
+    const projectContextMatch = prompt.match(/(?:^|\n)LongTable project context\n[\s\S]*?\n\n([\s\S]+)$/);
+    const sourcePrompt = projectContextMatch?.[1] ?? prompt;
+    const normalized = sourcePrompt.replace(/\s+/g, " ").trim();
+    const sentenceEnd = normalized.search(/[.!?]\s/);
+    const first = sentenceEnd >= 0 ? normalized.slice(0, sentenceEnd + 1) : normalized;
+    return first
+        .replace(/^(please\s+)?(run\s+)?(a\s+)?(structured\s+)?(panel\s+)?(review|critique|evaluate|assess|inspect)\s+/i, "")
+        .replace(/^(whether|if|of)\s+/i, "")
+        .replace(/^the\s+/i, "")
+        .trim();
+}
+function conciseFocusFromPrompt(prompt) {
+    const focus = firstPromptClause(prompt)
+        .replace(/[.:;,\s]+$/g, "")
+        .trim();
+    if (!focus) {
+        return "the reviewed issue";
+    }
+    return focus.length > 96 ? `${focus.slice(0, 93).trim()}...` : focus;
+}
+function languageText(language, en, ko) {
+    return language === "ko" ? ko : en;
+}
+function withFocus(template, focus) {
+    return template.replace(/\{focus\}/g, focus);
+}
+function shouldIncludeDeferOption(prompt) {
+    return /\b(defer|postpone|not decide|keep open|open tension|later|uncertain|unresolved)\b/i.test(prompt)
+        || /보류|미루|나중|열린\s*쟁점|열어\s*두|불확실|미해결/.test(prompt);
+}
+const PANEL_DECISION_COPY = {
+    manuscript_spine: {
+        focus: {
+            en: "the manuscript table/figure spine",
+            ko: "원고의 표/그림 spine"
+        },
+        blockerSummary: {
+            en: "The panel concern is that the current manuscript shell does not yet carry its argument through a useful table/figure spine.",
+            ko: "패널이 멈춘 이유는 현재 원고 shell이 논문 주장을 운반할 표/그림 spine을 충분히 보여주지 못했기 때문입니다."
+        },
+        recommendedValue: "revise",
+        labels: {
+            revise: { en: "Revise manuscript table/figure spine", ko: "원고 표/그림 spine을 다시 설계한다" },
+            evidence: { en: "Verify table/figure evidence", ko: "표/그림 근거를 먼저 확인한다" },
+            proceed: { en: "Proceed with current manuscript direction", ko: "현재 원고 방향을 유지하고 표/그림만 보강한다" },
+            defer: { en: "Keep manuscript spine concern open", ko: "원고 spine 우려를 열린 쟁점으로 둔다" }
+        },
+        descriptions: {
+            revise: {
+                en: "Use the panel result to redesign the table/figure spine before drafting the manuscript.",
+                ko: "패널 결과를 반영해 원고를 쓰기 전에 표/그림 spine을 다시 잡습니다."
+            },
+            evidence: {
+                en: "Check which tables, figures, analyses, and citations can actually support the manuscript claim.",
+                ko: "어떤 표, 그림, 분석, 인용이 실제로 원고 주장을 지탱할 수 있는지 먼저 확인합니다."
+            },
+            proceed: {
+                en: "Keep the current manuscript direction and only strengthen the missing table/figure pieces.",
+                ko: "현재 원고 방향은 유지하고 부족한 표/그림 요소만 보강합니다."
+            },
+            defer: {
+                en: "Do not settle the manuscript spine yet; keep the concern visible as an open issue.",
+                ko: "아직 원고 spine을 확정하지 않고 이 우려를 열린 쟁점으로 남깁니다."
+            }
+        }
+    },
+    manuscript_argument: {
+        focus: {
+            en: "the manuscript or draft argument",
+            ko: "원고 또는 초안의 논지"
+        },
+        blockerSummary: {
+            en: "The panel concern is that the manuscript direction could settle before the argument, evidence, and reviewer risk are aligned.",
+            ko: "패널이 멈춘 이유는 논지, 근거, 리뷰어 리스크가 정렬되기 전에 원고 방향이 확정될 수 있기 때문입니다."
+        },
+        recommendedValue: "revise",
+        labels: {
+            revise: { en: "Revise manuscript argument", ko: "원고 논지를 먼저 수정한다" },
+            evidence: { en: "Verify manuscript evidence", ko: "원고 근거를 먼저 확인한다" },
+            proceed: { en: "Proceed with current manuscript direction", ko: "현재 원고 방향으로 진행한다" },
+            defer: { en: "Keep manuscript concern open", ko: "원고 우려를 열린 쟁점으로 둔다" }
+        },
+        descriptions: {
+            revise: {
+                en: "Use the panel result to revise the claim, structure, or draft before proceeding.",
+                ko: "패널 결과를 반영해 주장, 구조, 초안을 먼저 수정합니다."
+            },
+            evidence: {
+                en: "Check source, data, artifact, or citation support for the manuscript direction before proceeding.",
+                ko: "현재 원고 방향을 지탱할 자료, 데이터, 산출물, 인용 근거를 먼저 확인합니다."
+            },
+            proceed: {
+                en: "Accept the visible risk profile and continue with the current manuscript direction.",
+                ko: "드러난 위험을 감수하고 현재 원고 방향으로 계속 진행합니다."
+            },
+            defer: {
+                en: "Do not commit yet; keep the manuscript issue visible as an open tension.",
+                ko: "아직 확정하지 않고 원고 쟁점을 열린 긴장으로 남깁니다."
+            }
+        }
+    },
+    measurement: {
+        focus: {
+            en: "the measurement or coding decision",
+            ko: "측정 또는 코딩 결정"
+        },
+        blockerSummary: {
+            en: "The panel concern is that measurement or coding rules decide what will count as evidence later.",
+            ko: "패널이 멈춘 이유는 측정 또는 코딩 규칙이 이후 무엇을 근거로 볼지 결정하기 때문입니다."
+        },
+        recommendedValue: "revise",
+        labels: {
+            revise: { en: "Revise measurement/coding plan", ko: "측정/코딩 계획을 수정한다" },
+            evidence: { en: "Verify measurement validity evidence", ko: "측정 타당도 근거를 확인한다" },
+            proceed: { en: "Proceed with current measurement/coding plan", ko: "현재 측정/코딩 계획으로 진행한다" },
+            defer: { en: "Keep measurement/coding concern open", ko: "측정/코딩 우려를 열린 쟁점으로 둔다" }
+        },
+        descriptions: {
+            revise: {
+                en: "Use the panel result to revise the variables, coding rules, or construct boundary before proceeding.",
+                ko: "패널 결과를 반영해 변수, 코딩 규칙, 구성개념 경계를 먼저 수정합니다."
+            },
+            evidence: {
+                en: "Check validity, reliability, source, or coding evidence before treating the plan as settled.",
+                ko: "타당도, 신뢰도, 출처, 코딩 근거를 확인한 뒤 계획을 확정합니다."
+            },
+            proceed: {
+                en: "Accept the visible measurement risk and continue with the current plan.",
+                ko: "드러난 측정 위험을 감수하고 현재 계획으로 계속 진행합니다."
+            },
+            defer: {
+                en: "Do not commit yet; keep the measurement or coding issue visible as an open tension.",
+                ko: "아직 확정하지 않고 측정 또는 코딩 쟁점을 열린 긴장으로 남깁니다."
+            }
+        }
+    },
+    method: {
+        focus: {
+            en: "the method or analysis design",
+            ko: "방법 또는 분석 설계"
+        },
+        blockerSummary: {
+            en: "The panel concern is that the method or analysis choice could become a hard-to-reverse research commitment.",
+            ko: "패널이 멈춘 이유는 방법 또는 분석 선택이 되돌리기 어려운 연구 결정이 될 수 있기 때문입니다."
+        },
+        recommendedValue: "revise",
+        labels: {
+            revise: { en: "Revise method/analysis plan", ko: "방법/분석 계획을 수정한다" },
+            evidence: { en: "Verify method/analysis evidence", ko: "방법/분석 근거를 확인한다" },
+            proceed: { en: "Proceed with current method/analysis plan", ko: "현재 방법/분석 계획으로 진행한다" },
+            defer: { en: "Keep method/analysis concern open", ko: "방법/분석 우려를 열린 쟁점으로 둔다" }
+        },
+        descriptions: {
+            revise: {
+                en: "Use the panel result to revise the design, model, sample, or analysis plan before proceeding.",
+                ko: "패널 결과를 반영해 설계, 모형, 표본, 분석 계획을 먼저 수정합니다."
+            },
+            evidence: {
+                en: "Check data, model, method, or artifact support before treating the plan as settled.",
+                ko: "데이터, 모형, 방법, 산출물 근거를 확인한 뒤 계획을 확정합니다."
+            },
+            proceed: {
+                en: "Accept the visible method risk and continue with the current plan.",
+                ko: "드러난 방법론적 위험을 감수하고 현재 계획으로 계속 진행합니다."
+            },
+            defer: {
+                en: "Do not commit yet; keep the method or analysis issue visible as an open tension.",
+                ko: "아직 확정하지 않고 방법 또는 분석 쟁점을 열린 긴장으로 남깁니다."
+            }
+        }
+    },
+    evidence: {
+        focus: {
+            en: "the evidence or source standard",
+            ko: "근거 또는 출처 기준"
+        },
+        blockerSummary: {
+            en: "The panel concern is that LongTable could proceed before the source, artifact, or citation support is explicit.",
+            ko: "패널이 멈춘 이유는 출처, 산출물, 인용 근거가 명시되기 전에 LongTable이 진행할 수 있기 때문입니다."
+        },
+        recommendedValue: "evidence",
+        labels: {
+            revise: { en: "Revise evidence standard", ko: "근거 기준을 수정한다" },
+            evidence: { en: "Verify source/citation support", ko: "출처/인용 근거를 확인한다" },
+            proceed: { en: "Proceed with current evidence boundary", ko: "현재 근거 경계로 진행한다" },
+            defer: { en: "Keep evidence concern open", ko: "근거 우려를 열린 쟁점으로 둔다" }
+        },
+        descriptions: {
+            revise: {
+                en: "Use the panel result to revise what will count as adequate evidence.",
+                ko: "패널 결과를 반영해 충분한 근거의 기준을 먼저 수정합니다."
+            },
+            evidence: {
+                en: "Check source, data, artifact, or citation support before proceeding.",
+                ko: "진행하기 전에 출처, 데이터, 산출물, 인용 근거를 확인합니다."
+            },
+            proceed: {
+                en: "Accept the visible evidence risk and continue with the current boundary.",
+                ko: "드러난 근거 위험을 감수하고 현재 경계로 계속 진행합니다."
+            },
+            defer: {
+                en: "Do not commit yet; keep the evidence issue visible as an open tension.",
+                ko: "아직 확정하지 않고 근거 쟁점을 열린 긴장으로 남깁니다."
+            }
+        }
+    },
+    theory: {
+        focus: {
+            en: "the theory or conceptual frame",
+            ko: "이론 또는 개념 프레임"
+        },
+        blockerSummary: {
+            en: "The panel concern is that the conceptual frame could settle before its distinctions and limits are explicit.",
+            ko: "패널이 멈춘 이유는 개념 구분과 한계가 명확해지기 전에 이론 프레임이 확정될 수 있기 때문입니다."
+        },
+        recommendedValue: "revise",
+        labels: {
+            revise: { en: "Revise theory/conceptual frame", ko: "이론/개념 프레임을 수정한다" },
+            evidence: { en: "Verify theory support", ko: "이론 근거를 확인한다" },
+            proceed: { en: "Proceed with current theory frame", ko: "현재 이론 프레임으로 진행한다" },
+            defer: { en: "Keep theory concern open", ko: "이론 우려를 열린 쟁점으로 둔다" }
+        },
+        descriptions: {
+            revise: {
+                en: "Use the panel result to revise the conceptual frame, distinctions, or scope before proceeding.",
+                ko: "패널 결과를 반영해 개념 프레임, 구분, 범위를 먼저 수정합니다."
+            },
+            evidence: {
+                en: "Check theory, literature, concept, or citation support before treating the frame as settled.",
+                ko: "이론, 문헌, 개념, 인용 근거를 확인한 뒤 프레임을 확정합니다."
+            },
+            proceed: {
+                en: "Accept the visible theory risk and continue with the current frame.",
+                ko: "드러난 이론적 위험을 감수하고 현재 프레임으로 계속 진행합니다."
+            },
+            defer: {
+                en: "Do not commit yet; keep the theory issue visible as an open tension.",
+                ko: "아직 확정하지 않고 이론 쟁점을 열린 긴장으로 남깁니다."
+            }
+        }
+    },
+    generic: {
+        focus: {
+            en: "the reviewed issue",
+            ko: "검토된 쟁점"
+        },
+        blockerSummary: {
+            en: "The panel concern is that LongTable has reached a decision point that should belong to the researcher.",
+            ko: "패널이 멈춘 이유는 LongTable이 연구자가 직접 정해야 할 결정 지점에 도달했기 때문입니다."
+        },
+        recommendedValue: "revise",
+        labels: {
+            revise: { en: "Revise reviewed issue", ko: "검토된 쟁점을 수정한다" },
+            evidence: { en: "Verify evidence first", ko: "근거를 먼저 확인한다" },
+            proceed: { en: "Proceed with current direction", ko: "현재 방향으로 진행한다" },
+            defer: { en: "Keep issue open", ko: "쟁점을 열린 상태로 둔다" }
+        },
+        descriptions: {
+            revise: {
+                en: "Use the panel result to revise {focus} before proceeding.",
+                ko: "패널 결과를 반영해 {focus}을/를 먼저 수정합니다."
+            },
+            evidence: {
+                en: "Check source, data, artifact, or citation support for {focus} before proceeding.",
+                ko: "{focus}을/를 지탱할 출처, 데이터, 산출물, 인용 근거를 먼저 확인합니다."
+            },
+            proceed: {
+                en: "Accept the visible risk profile for {focus} and continue.",
+                ko: "{focus}에 대해 드러난 위험을 감수하고 계속 진행합니다."
+            },
+            defer: {
+                en: "Do not commit yet; keep {focus} visible as an open tension.",
+                ko: "아직 확정하지 않고 {focus}을/를 열린 긴장으로 남깁니다."
+            }
+        }
+    }
+};
+function decisionDomainFromPrompt(prompt) {
+    const normalized = prompt.toLowerCase();
+    if (/get[-_ ]?journal|table\/figure|table and figure|figure spine|table spine|manuscript shell|journal manuscript/.test(normalized)) {
+        return "manuscript_spine";
+    }
+    if (/\bmanuscript\b|\bdraft\b|\bpaper\b|\barticle\b|\bsection\b|\bsubmission\b/.test(normalized)) {
+        return "manuscript_argument";
+    }
+    if (/\bmeasurement\b|\bmeasure\b|\bscale\b|\bconstruct\b|\bcoding\b|측정|척도|구성개념|코딩/.test(normalized)) {
+        return "measurement";
+    }
+    if (/\bmethod\b|\bdesign\b|\banalysis\b|\bmodel\b|\bsample\b|\bidentification\b|방법|설계|분석|표본/.test(normalized)) {
+        return "method";
+    }
+    if (/\bevidence\b|\bsource\b|\bcitation\b|\breference\b|\bpdf\b|\bcorpus\b|근거|인용|문헌|자료/.test(normalized)) {
+        return "evidence";
+    }
+    if (/\btheory\b|\bframework\b|\bontology\b|\bconcept\b|이론|개념|온톨로지/.test(normalized)) {
+        return "theory";
+    }
+    return "generic";
+}
+function panelDecisionOptions(copy, language, focus, includeDefer) {
+    const values = includeDefer
+        ? ["revise", "evidence", "defer"]
+        : ["revise", "evidence", "proceed"];
+    return values
+        .sort((left, right) => Number(right === copy.recommendedValue) - Number(left === copy.recommendedValue))
+        .map((value) => ({
+        value,
+        label: copy.labels[value][language],
+        description: withFocus(copy.descriptions[value][language], focus),
+        ...(value === copy.recommendedValue ? { recommended: true } : {})
+    }));
+}
+export function buildPanelDecisionContext(prompt) {
+    const language = detectOutputLanguage(prompt);
+    const domain = decisionDomainFromPrompt(prompt);
+    const copy = PANEL_DECISION_COPY[domain];
+    const domainFocus = copy.focus[language];
+    const focus = domain === "generic" ? conciseFocusFromPrompt(prompt) || domainFocus : domainFocus;
+    const blockerSummary = copy.blockerSummary[language];
+    return {
+        language,
+        focus,
+        blockerSummary,
+        decisionQuestion: languageText(language, `What should LongTable treat as the next human decision for ${focus} after this panel review?`, `이 패널 리뷰 이후 LongTable이 ${focus}에 대해 다음 인간 결정으로 기록해야 할 것은 무엇인가요?`),
+        displayReason: languageText(language, `${blockerSummary} This should be resolved by the researcher before LongTable treats the direction as settled.`, `${blockerSummary} LongTable이 방향을 확정하기 전에 연구자가 직접 선택해야 합니다.`),
+        options: panelDecisionOptions(copy, language, focus, shouldIncludeDeferOption(prompt)),
+        otherLabel: languageText(language, "Other decision", "직접 입력")
+    };
+}
 export function buildPanelPlan(options) {
     const mode = options.mode ?? "review";
     const explicitRoles = unique([...(options.roles ?? []), ...parseRoleFlag(options.roleFlag)]);
@@ -112,6 +442,7 @@ export function buildInvocationIntent(options) {
 }
 export function createPlannedPanelQuestionRecord(plan, provider) {
     const createdAt = nowIso();
+    const decisionContext = buildPanelDecisionContext(plan.prompt);
     return {
         id: createId("question_record"),
         createdAt,
@@ -120,43 +451,24 @@ export function createPlannedPanelQuestionRecord(plan, provider) {
         prompt: {
             id: createId("question_prompt"),
             checkpointKey: "panel_next_decision",
-            title: "Panel follow-up decision",
-            question: "What should LongTable treat as the next human decision after this panel review?",
+            title: languageText(decisionContext.language, "Panel follow-up decision", "패널 후속 결정"),
+            question: decisionContext.decisionQuestion,
             type: "single_choice",
-            options: [
-                {
-                    value: "revise",
-                    label: "Revise before proceeding",
-                    description: "Use the panel result to revise the claim, design, or draft first."
-                },
-                {
-                    value: "evidence",
-                    label: "Gather or verify evidence first",
-                    description: "Do not proceed until the relevant evidence or citation support is checked."
-                },
-                {
-                    value: "proceed",
-                    label: "Proceed with current direction",
-                    description: "Accept the risk profile and continue with the current direction."
-                },
-                {
-                    value: "defer",
-                    label: "Keep this open",
-                    description: "Do not commit yet; keep the panel issue visible as an open tension."
-                }
-            ],
+            options: decisionContext.options,
             allowOther: true,
-            otherLabel: "Other decision",
+            otherLabel: decisionContext.otherLabel,
             required: plan.checkpointSensitivity === "high",
             source: "runtime_guidance",
             rationale: [
                 "Panel review creates disagreement or risk visibility that should connect to an explicit researcher decision.",
+                `Panel decision focus: ${decisionContext.focus}.`,
+                "Panel follow-up choices are compact by default; unlisted decisions should use Other.",
                 `Panel checkpoint sensitivity: ${plan.checkpointSensitivity}.`
             ],
-            displayReason: "Panel review can surface role disagreement that should not be collapsed without researcher approval.",
+            displayReason: decisionContext.displayReason,
             preferredSurfaces: provider === "claude"
                 ? ["native_structured", "numbered"]
-                : ["mcp_elicitation", "numbered"]
+                : ["tmux_popup", "mcp_elicitation", "numbered"]
         }
     };
 }

package/dist/project-session.js

@@ -497,6 +497,14 @@ function formatQuestionMetadata(record) {
     ].filter(Boolean);
     return parts.length > 0 ? ` [${parts.join("; ")}]` : "";
 }
+const QUESTION_SURFACES = new Set([
+    "native_structured",
+    "tmux_popup",
+    "mcp_elicitation",
+    "numbered",
+    "terminal_selector",
+    "web_form"
+]);
 function compactLine(value, limit = 160) {
     const compacted = value.replace(/\s+/g, " ").trim();
     return compacted.length > limit ? `${compacted.slice(0, limit - 1)}…` : compacted;
@@ -506,6 +514,15 @@ function asRecord(value) {
         ? value
         : null;
 }
+function asStringArray(value) {
+    if (Array.isArray(value)) {
+        return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+    }
+    return typeof value === "string" && value.trim().length > 0 ? [value] : [];
+}
+function isQuestionSurfaceValue(value) {
+    return typeof value === "string" && QUESTION_SURFACES.has(value);
+}
 const SPEC_DIFF_IGNORED_PATHS = new Set([
     "createdAt",
     "updatedAt",
@@ -602,10 +619,10 @@ function buildResearchSpecificationGapQuestion(gaps, timestamp, sourceEvidenceId
                 "Research Specification is the required durable interview artifact.",
                 "Missing required sections can make later resume, screening, coding, or evidence decisions stale."
             ],
-            preferredSurfaces: ["mcp_elicitation", "numbered"]
+            preferredSurfaces: ["tmux_popup", "mcp_elicitation", "numbered"]
         },
         transportStatus: {
-            surface: "mcp_elicitation",
+            surface: "tmux_popup",
             status: "not_attempted",
             updatedAt: timestamp,
             ...(sourceEvidenceIds.length > 0 ? { message: `Source evidence: ${sourceEvidenceIds.join(", ")}` } : {})
@@ -2682,7 +2699,7 @@ export async function createWorkspaceFollowUpQuestions(options) {
     const createdAt = nowIso();
     const preferredSurfaces = options.provider === "claude"
         ? ["native_structured", "terminal_selector", "numbered"]
-        : ["mcp_elicitation", "terminal_selector", "numbered"];
+        : ["tmux_popup", "mcp_elicitation", "terminal_selector", "numbered"];
     const specs = buildQuestionOpportunitySpecs(options.prompt, {
         includeFallback: options.force === true ? true : options.auto !== true,
         autoOnly: options.auto === true,
@@ -2795,7 +2812,7 @@ export async function createWorkspaceQuestion(options) {
             rationale,
             preferredSurfaces: options.provider === "claude"
                 ? ["native_structured", "numbered"]
-                : ["mcp_elicitation", "numbered"]
+                : ["tmux_popup", "mcp_elicitation", "numbered"]
         }
     };
     const updated = appendQuestionRecords(state, [question]);
@@ -2998,6 +3015,15 @@ function normalizeQuestionAnswerSelection(question, rawAnswer) {
         ...(inlineRationale ? { inlineRationale } : {})
     };
 }
+function selectedLabelsForValues(question, selectedValues) {
+    return selectedValues.map((value) => {
+        if (value === "other") {
+            return question.prompt.otherLabel ?? "Other";
+        }
+        const option = question.prompt.options.find((candidate) => candidate.value === value);
+        return option?.label ?? value;
+    });
+}
 export async function answerWorkspaceQuestion(options) {
     const state = await loadResearchState(options.context.stateFilePath);
     const question = findQuestionForDecision(state, options.questionId);
@@ -3036,7 +3062,12 @@ export async function answerWorkspaceQuestion(options) {
         updatedAt: timestamp,
         status: "answered",
         answer,
-        decisionRecordId: decision.id
+        decisionRecordId: decision.id,
+        transportStatus: {
+            surface: answer.surface,
+            status: "accepted",
+            updatedAt: timestamp
+        }
     };
     const withQuestion = {
         ...state,
@@ -3242,6 +3273,58 @@ export async function repairWorkspaceStateConsistency(options) {
             })
         };
     }
+    const repairTimestamp = nowIso();
+    const repairedQuestionLog = (updated.questionLog ?? []).map((record) => {
+        const answerRecord = asRecord(record.answer);
+        if (!answerRecord) {
+            return record;
+        }
+        const selectedValues = [
+            ...asStringArray(answerRecord.selectedValues),
+            ...asStringArray(answerRecord.selectedValue),
+            ...asStringArray(answerRecord.selectedOptions),
+            ...asStringArray(answerRecord.value)
+        ];
+        if (selectedValues.length === 0) {
+            return record;
+        }
+        const selectedLabels = asStringArray(answerRecord.selectedLabels);
+        const needsRepair = typeof answerRecord.promptId !== "string" ||
+            selectedLabels.length === 0 ||
+            !isQuestionSurfaceValue(answerRecord.surface);
+        if (!needsRepair) {
+            return record;
+        }
+        repaired.push(`normalized legacy answer shape for question ${record.id}`);
+        const normalizedAnswer = {
+            promptId: typeof answerRecord.promptId === "string" ? answerRecord.promptId : record.prompt.id,
+            selectedValues: uniqueStrings(selectedValues),
+            selectedLabels: selectedLabels.length > 0
+                ? selectedLabels
+                : selectedLabelsForValues(record, uniqueStrings(selectedValues)),
+            ...(typeof answerRecord.otherText === "string" && answerRecord.otherText.trim()
+                ? { otherText: answerRecord.otherText }
+                : {}),
+            ...(typeof answerRecord.rationale === "string" && answerRecord.rationale.trim()
+                ? { rationale: answerRecord.rationale }
+                : {}),
+            ...(answerRecord.provider === "codex" || answerRecord.provider === "claude"
+                ? { provider: answerRecord.provider }
+                : {}),
+            surface: isQuestionSurfaceValue(answerRecord.surface) ? answerRecord.surface : "numbered"
+        };
+        return {
+            ...record,
+            updatedAt: repairTimestamp,
+            answer: normalizedAnswer
+        };
+    });
+    if (repairedQuestionLog.some((record, index) => record !== (updated.questionLog ?? [])[index])) {
+        updated = {
+            ...updated,
+            questionLog: repairedQuestionLog
+        };
+    }
     if (repaired.length > 0) {
         await writeFile(options.context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
         await syncCurrentWorkspaceView(options.context);

package/package.json

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