@longtable/cli 0.1.58 → 0.1.60

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/dist/search/index.d.ts

@@ -1,6 +1 @@
-export * from "./types.js";
-export * from "./query.js";
-export * from "./sources.js";
-export * from "./rank.js";
-export * from "./run.js";
-export * from "./publisher-access.js";
+export * from "@longtable/scholar-research";

package/dist/search/index.js

@@ -1,6 +1 @@
-export * from "./types.js";
-export * from "./query.js";
-export * from "./sources.js";
-export * from "./rank.js";
-export * from "./run.js";
-export * from "./publisher-access.js";
+export * from "@longtable/scholar-research";