@longtable/cli 0.1.1 → 0.1.3

package/README.md

@@ -1,101 +1,101 @@
 # @longtable/cli
 
-Researcher-facing Long Table CLI built on top of the legacy `@diverga/*` package surface.
+Long Table의 researcher-facing CLI입니다.
 
-현재 공개 설치 경로는 `@longtable/cli`입니다.
+이 패키지는 연구자가 아래처럼 시작할 수 있게 만드는 것이 목표입니다.
 
-## Install
-
-공개 설치:
+- `longtable init`
+- `longtable start`
+- `longtable ask --prompt "..."`
 
-```bash
-npm install -g @longtable/cli
-```
+긴 내부 명령이나 legacy package 이름을 알 필요 없이,  
+연구자가 `오늘 무엇이 필요한가`에서 바로 출발할 수 있게 하는 표면입니다.
 
-로컬 preview:
+## Install
 
 ```bash
-npm install
-npm run build
-node packages/longtable/dist/cli.js --help
+npm install -g @longtable/cli
 ```
 
 ## Recommended flow
 
-Run setup once and install Codex prompt aliases:
+### 1. Setup once
 
 ```bash
-longtable init --install-prompts
+longtable init --flow interview
 ```
 
-`longtable init` now uses an arrow-key terminal menu instead of plain number-entry prompts.
+이 인터뷰 setup은 연구자의
+
+- 현재 주제
+- 현재 막힘
+- 선호하는 첫 진입 모드
+- 가장 많이 도전받고 싶은 영역
+- 역할 간 의견 충돌 가시성
 
-Then you can work in two ways.
+까지 저장합니다.
 
-From the terminal:
+### 2. Start from today’s work
 
 ```bash
-longtable review --prompt "Review this claim critically."
-longtable review --prompt "BJET 편집자 관점에서 봐줘." --role editor
-longtable review --prompt "방법론적으로 어디가 취약한지 말해줘." --panel --show-conflicts
+longtable start
 ```
 
-Inside Codex after prompt aliases are installed:
+`longtable start`는 가장 단순한 진입점입니다.  
+오늘 필요한 작업을 먼저 고르고, 그 다음 자연어로 상황을 말하면 됩니다.
 
-- `/prompts:longtable-init`
-- `/prompts:longtable-explore`
-- `/prompts:longtable-review`
-- `/prompts:longtable-critique`
-- `/prompts:longtable-draft`
-- `/prompts:longtable-commit`
-- `/prompts:longtable-status`
-
-## Core commands
+### 3. Or jump straight in
 
 ```bash
-longtable init
-longtable show --json
-longtable install --json
-longtable explore --prompt "Help me stay exploratory."
-longtable review --prompt "Review this claim critically."
-longtable commit --prompt "Help me make this decision carefully."
+longtable ask --prompt "연구를 시작하고 싶은데 어디서부터 좁혀야 할지 모르겠어."
 ```
 
-## Codex overlay
-
-Install Codex prompt aliases:
+## Useful commands
 
 ```bash
-longtable codex install-prompts
+longtable start
+longtable roles
+longtable ask --prompt "이 연구 아이디어를 어디서부터 열어야 할지 모르겠어."
+longtable review --prompt "BJET 편집자 관점에서 봐줘." --role editor
+longtable review --prompt "방법론적으로 어디가 취약한지 말해줘." --role methods_critic
+longtable review --prompt "의견 충돌까지 보여줘." --panel --show-conflicts
+longtable show --json
 ```
 
-If you finish onboarding inside Codex with `/prompts:longtable-init`, you can persist the collected answers with:
+## What `roles` means
 
 ```bash
-longtable codex persist-init --provider codex --field education --career-stage doctoral --experience intermediate --project-type "journal article" --checkpoint balanced --install-prompts
+longtable roles
 ```
 
-Or from a JSON block:
+Long Table이 어떤 관점을 호출할 수 있는지 짧게 보여줍니다.
 
-```bash
-pbpaste | longtable codex persist-init --stdin --install-prompts
-```
+예:
+
+- `editor`
+- `reviewer`
+- `methods_critic`
+- `voice_keeper`
 
-Check whether setup and aliases are present:
+기본값은 하나의 Long Table synthesis이지만, 필요하면 panel과 conflict도 드러낼 수 있습니다.
+
+## Codex integration
+
+Long Table은 Codex prompt file 설치도 지원합니다.
 
 ```bash
+longtable codex install-prompts
 longtable codex status
 ```
 
-Remove the aliases:
+하지만 이 경로는 현재 `실험적`입니다.
 
-```bash
-longtable codex remove-prompts
-```
+- Codex 버전/빌드에 따라 prompt file이 slash command로 바로 노출되지 않을 수 있습니다.
+- 그래서 기본 사용자 경로는 `/prompts:...`가 아니라 `longtable start`와 `longtable ask`입니다.
 
 ## Why this package exists
 
-Long Table is the product name.
-`Diverga` remains an internal compatibility layer for some lower-level packages and runtime paths.
+Long Table은 제품명입니다.  
+`Diverga`는 아직 일부 하위 패키지와 runtime path에서만 남아 있는 호환성 레이어입니다.
 
-This package exists so researchers can install and run `longtable` directly while that compatibility layer remains underneath.
+이 패키지는 연구자가 `longtable`만 알면 되게 하기 위해 존재합니다.

package/dist/cli.js

@@ -7,6 +7,7 @@ import { buildProviderChoices, buildQuickSetupFlow, createPersistedSetupOutput,
 import { buildCodexThinWrappedPrompt, runCodexThinWrapper } from "@diverga/provider-codex";
 import { installCodexPromptAliases, listInstalledCodexPromptAliases, removeCodexPromptAliases, resolveCodexPromptsDir } from "./prompt-aliases.js";
 import { buildPersonaGuidance } from "./persona-router.js";
+import { PERSONA_DEFINITIONS } from "./personas.js";
 const VALID_MODES = new Set([
     "explore",
     "review",
@@ -27,9 +28,12 @@ const VALID_STAGES = new Set([
 function usage() {
     return [
         "Usage:",
-        "  longtable init [--provider codex|claude] [--field <field>] [--career-stage <stage>] [--experience novice|intermediate|advanced] [--project-type <type>] [--checkpoint low|balanced|high] [--authorship-signal <text>] [--json] [--no-install] [--install-prompts]",
+        "  longtable init [--flow quickstart|interview] [--provider codex|claude] [--field <field>] [--career-stage <stage>] [--experience novice|intermediate|advanced] [--project-type <type>] [--checkpoint low|balanced|high] [--authorship-signal <text>] [--topic <text>] [--blocker <text>] [--entry-mode explore|review|critique|draft|commit] [--weakest-domain theory|methodology|measurement|analysis|writing] [--panel-preference synthesis_only|show_on_conflict|always_visible] [--json] [--no-install] [--install-prompts]",
+        "  longtable start [--prompt <text>] [--setup <path>] [--cwd <path>] [--print] [--json]",
+        "  longtable roles [--json]",
         "  longtable show [--json] [--path <file>]",
         "  longtable install [--json] [--path <file>] [--runtime-path <file>]",
+        "  longtable ask [--prompt <text>] [--print] [--json] [--setup <path>] [--cwd <path>]",
         "  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-prompts] [--json]",
         "  longtable codex install-prompts [--dir <path>]",
@@ -37,7 +41,10 @@ function usage() {
         "  longtable codex status [--dir <path>] [--json]",
         "",
         "Examples:",
-        "  longtable init --install-prompts",
+        "  longtable init --flow interview --install-prompts",
+        "  longtable start",
+        "  longtable roles",
+        "  longtable ask --prompt \"연구를 시작하고 싶어. 지금 어디서부터 좁혀야 할지 모르겠어.\"",
         "  longtable review --prompt \"Review this claim critically.\" --panel --show-conflicts",
         "  longtable review --role editor --prompt \"BJET 편집자 관점에서 봐줘.\"",
         "  printf '{\"provider\":\"codex\",...}' | longtable codex persist-init --stdin --install-prompts",
@@ -49,7 +56,7 @@ function parseArgs(argv) {
     const values = {};
     let subcommand = maybeSubcommand;
     const modeCommand = command && VALID_MODES.has(command);
-    const directCommand = command && ["init", "show", "install", "codex"].includes(command);
+    const directCommand = command && ["init", "start", "roles", "show", "install", "codex", "ask"].includes(command);
     let startIndex = 1;
     if (modeCommand) {
         subcommand = undefined;
@@ -91,6 +98,53 @@ function renderChoices(choices) {
         .map((choice, index) => `${index + 1}. ${choice.label} — ${choice.description}`)
         .join("\n");
 }
+function buildSetupFlowChoices() {
+    return [
+        {
+            id: "quickstart",
+            label: "Quickstart",
+            description: "Minimal setup for the fastest first win."
+        },
+        {
+            id: "interview",
+            label: "Interview",
+            description: "A more detailed researcher profile interview for better first guidance."
+        }
+    ];
+}
+function renderSetupHeader(flow) {
+    const title = flow === "interview" ? "Long Table Setup Interview" : "Long Table Quickstart";
+    const subtitle = flow === "interview"
+        ? "We will ask about your research persona, current topic, blocker, and preferred kind of challenge."
+        : "We will capture the minimum profile needed to start using Long Table.";
+    return [
+        "┌──────────────────────────────────────────────┐",
+        `│ ${title.padEnd(44, " ")}│`,
+        "└──────────────────────────────────────────────┘",
+        subtitle
+    ].join("\n");
+}
+function renderQuestionHeader(index, total, section, prompt) {
+    return [``, `[${index}/${total}] ${section}`, prompt].join("\n");
+}
+function questionSection(questionId) {
+    if (questionId === "field" || questionId === "careerStage" || questionId === "experienceLevel") {
+        return "Researcher profile";
+    }
+    if (questionId === "currentProjectType" || questionId === "currentResearchTopic" || questionId === "currentBlocker") {
+        return "Current work";
+    }
+    if (questionId === "preferredCheckpointIntensity" || questionId === "preferredEntryMode") {
+        return "Interaction style";
+    }
+    if (questionId === "weakestDomain" || questionId === "panelPreference") {
+        return "How Long Table should challenge you";
+    }
+    return "Authorship and voice";
+}
+function formatModeLabel(mode) {
+    return `${mode[0].toUpperCase()}${mode.slice(1)}`;
+}
 function moveCursorUp(lines) {
     return lines > 0 ? `\u001B[${lines}A` : "";
 }
@@ -125,6 +179,18 @@ async function promptChoiceByNumber(rl, prompt, choices) {
         return choice.id;
     }
 }
+async function promptText(rl, prompt, required) {
+    while (true) {
+        const answer = (await rl.question(`${prompt}\n> `)).trim();
+        if (!required) {
+            return answer || undefined;
+        }
+        if (answer) {
+            return answer;
+        }
+        console.log("This answer cannot be empty.");
+    }
+}
 async function promptChoiceWithArrows(rl, prompt, choices) {
     const stream = input;
     if (!stream.isTTY || !output.isTTY) {
@@ -194,10 +260,59 @@ async function promptChoiceWithArrows(rl, prompt, choices) {
 async function promptChoice(rl, prompt, choices) {
     return promptChoiceWithArrows(rl, prompt, choices);
 }
+async function promptStartAction(rl, blocker) {
+    return (await promptChoice(rl, blocker?.trim()
+        ? `What do you want to do with this first?\nCurrent blocker: ${blocker.trim()}`
+        : "What do you want Long Table to help you do first?", [
+        {
+            id: "explore",
+            label: "Open the problem",
+            description: "Start with questions, tensions, and a clearer research direction."
+        },
+        {
+            id: "review",
+            label: "Review something",
+            description: "Critically inspect a claim, outline, or draft."
+        },
+        {
+            id: "critique",
+            label: "Challenge me hard",
+            description: "Push back, stress-test assumptions, and surface hidden risks."
+        },
+        {
+            id: "editor",
+            label: "Journal editor view",
+            description: "See how an editor might judge framing, fit, and contribution."
+        },
+        {
+            id: "methods",
+            label: "Methods check",
+            description: "Focus on design fit, defensibility, and methodological weakness."
+        },
+        {
+            id: "panel",
+            label: "Show disagreement",
+            description: "Let multiple roles disagree instead of forcing one answer."
+        },
+        {
+            id: "status",
+            label: "Check my setup",
+            description: "See what Long Table knows and what is installed."
+        },
+        {
+            id: "roles",
+            label: "What roles exist?",
+            description: "See what perspectives Long Table can bring into the conversation."
+        }
+    ]));
+}
 function hasCompleteFlagInput(args) {
     const required = ["provider", "field", "career-stage", "experience", "project-type", "checkpoint"];
     return required.every((key) => typeof args[key] === "string" && String(args[key]).trim().length > 0);
 }
+function resolveSetupFlow(args) {
+    return String(args.flow) === "interview" ? "interview" : "quickstart";
+}
 function toSetupAnswers(args) {
     return {
         field: String(args.field),
@@ -207,19 +322,43 @@ function toSetupAnswers(args) {
         preferredCheckpointIntensity: String(args.checkpoint),
         humanAuthorshipSignal: typeof args["authorship-signal"] === "string" && args["authorship-signal"].trim().length > 0
             ? args["authorship-signal"].trim()
+            : undefined,
+        currentResearchTopic: typeof args.topic === "string" && args.topic.trim().length > 0 ? args.topic.trim() : undefined,
+        currentBlocker: typeof args.blocker === "string" && args.blocker.trim().length > 0 ? args.blocker.trim() : undefined,
+        preferredEntryMode: typeof args["entry-mode"] === "string" && VALID_MODES.has(String(args["entry-mode"]))
+            ? String(args["entry-mode"])
+            : undefined,
+        weakestDomain: typeof args["weakest-domain"] === "string"
+            ? String(args["weakest-domain"])
+            : undefined,
+        panelPreference: typeof args["panel-preference"] === "string"
+            ? String(args["panel-preference"])
             : undefined
     };
 }
 async function collectInteractiveAnswers() {
     const rl = createInterface({ input, output });
     try {
+        const flow = (await promptChoice(rl, "How would you like to set up Long Table?", buildSetupFlowChoices()));
+        console.log("");
+        console.log(renderSetupHeader(flow));
+        console.log("");
         const provider = await promptChoice(rl, "Which provider do you want to configure?", buildProviderChoices());
         const answers = {};
-        for (const question of buildQuickSetupFlow()) {
-            if (!question.choices) {
+        const questions = buildQuickSetupFlow(flow);
+        for (let index = 0; index < questions.length; index += 1) {
+            const question = questions[index];
+            const prompt = renderQuestionHeader(index + 1, questions.length, questionSection(question.id), question.prompt);
+            let value;
+            if (question.kind === "text") {
+                value = await promptText(rl, prompt, question.required);
+            }
+            else if (question.choices) {
+                value = await promptChoice(rl, prompt, question.choices);
+            }
+            if (!value) {
                 continue;
             }
-            const value = await promptChoice(rl, question.prompt, question.choices);
             if (question.id === "field")
                 answers.field = value;
             if (question.id === "careerStage")
@@ -234,8 +373,19 @@ async function collectInteractiveAnswers() {
             if (question.id === "humanAuthorshipSignal" && value !== "other") {
                 answers.humanAuthorshipSignal = value;
             }
+            if (question.id === "currentResearchTopic")
+                answers.currentResearchTopic = value;
+            if (question.id === "currentBlocker")
+                answers.currentBlocker = value;
+            if (question.id === "preferredEntryMode")
+                answers.preferredEntryMode = value;
+            if (question.id === "weakestDomain")
+                answers.weakestDomain = value;
+            if (question.id === "panelPreference")
+                answers.panelPreference = value;
         }
         return {
+            flow,
             provider,
             answers: answers
         };
@@ -246,6 +396,7 @@ async function collectInteractiveAnswers() {
 }
 function normalizePersistAnswers(raw) {
     return {
+        flow: raw.flow === "interview" ? "interview" : "quickstart",
         provider: raw.provider === "claude" ? "claude" : "codex",
         answers: {
             field: raw.field,
@@ -255,13 +406,32 @@ function normalizePersistAnswers(raw) {
             preferredCheckpointIntensity: raw.preferredCheckpointIntensity,
             ...(raw.humanAuthorshipSignal?.trim()
                 ? { humanAuthorshipSignal: raw.humanAuthorshipSignal.trim() }
+                : {}),
+            ...(raw.currentResearchTopic?.trim()
+                ? { currentResearchTopic: raw.currentResearchTopic.trim() }
+                : {}),
+            ...(raw.currentBlocker?.trim()
+                ? { currentBlocker: raw.currentBlocker.trim() }
+                : {}),
+            ...(raw.preferredEntryMode
+                ? { preferredEntryMode: raw.preferredEntryMode }
+                : {}),
+            ...(raw.weakestDomain
+                ? { weakestDomain: raw.weakestDomain }
+                : {}),
+            ...(raw.panelPreference
+                ? { panelPreference: raw.panelPreference }
                 : {})
         }
     };
 }
 async function readPersistAnswers(args) {
     if (typeof args["answers-json"] === "string") {
-        return normalizePersistAnswers(JSON.parse(args["answers-json"]));
+        const normalized = normalizePersistAnswers(JSON.parse(args["answers-json"]));
+        return {
+            ...normalized,
+            flow: typeof args.flow === "string" ? resolveSetupFlow(args) : normalized.flow
+        };
     }
     if (args.stdin === true) {
         const raw = readFileSync(0, "utf8").trim();
@@ -272,6 +442,7 @@ async function readPersistAnswers(args) {
     }
     if (hasCompleteFlagInput(args)) {
         return {
+            flow: resolveSetupFlow(args),
             provider: String(args.provider) === "claude" ? "claude" : "codex",
             answers: toSetupAnswers(args)
         };
@@ -285,13 +456,14 @@ async function runInit(args) {
     const customPath = typeof args.path === "string" ? args.path : undefined;
     const runtimePath = typeof args["runtime-path"] === "string" ? args["runtime-path"] : undefined;
     const promptsDir = typeof args.dir === "string" ? args.dir : undefined;
-    const { provider, answers } = hasCompleteFlagInput(args)
+    const { flow, provider, answers } = hasCompleteFlagInput(args)
         ? {
+            flow: resolveSetupFlow(args),
             provider: String(args.provider) === "claude" ? "claude" : "codex",
             answers: toSetupAnswers(args)
         }
         : await collectInteractiveAnswers();
-    const outputValue = createPersistedSetupOutput(answers, provider);
+    const outputValue = createPersistedSetupOutput(answers, provider, flow);
     const result = await saveSetupAndRuntimeConfig(outputValue, {
         setupPath: customPath,
         runtimePath
@@ -311,10 +483,27 @@ async function runInit(args) {
     }
     if (installedPrompts.length > 0) {
         console.log("");
-        console.log("Installed Codex prompt aliases:");
+        console.log("Installed Codex prompt files:");
         for (const prompt of installedPrompts) {
             console.log(`- /prompts:${prompt.name}`);
         }
+        console.log("  Note: whether Codex exposes these as slash commands depends on your Codex build.");
+    }
+    if (provider === "codex") {
+        console.log("");
+        console.log("Next step:");
+        console.log("- Start here: `longtable start`.");
+        console.log("- If you want a direct natural-language entry: `longtable ask --prompt \"...\"`.");
+        console.log("- Codex prompt files are available as an experimental integration, not the primary path.");
+        if (answers.currentBlocker) {
+            console.log(`- Suggested first message: ${answers.currentBlocker}`);
+        }
+        else if (answers.currentResearchTopic) {
+            console.log(`- Suggested first message: Help me open the problem around ${answers.currentResearchTopic}.`);
+        }
+        else {
+            console.log("- Suggested first message: I want to start my research and need help opening the problem.");
+        }
     }
 }
 async function runShow(args) {
@@ -337,8 +526,8 @@ async function runInstall(args) {
     console.log(renderInstallSummary(result));
 }
 async function runCodexPersistInit(args) {
-    const { provider, answers } = await readPersistAnswers(args);
-    const outputValue = createPersistedSetupOutput(answers, provider);
+    const { flow, provider, answers } = await readPersistAnswers(args);
+    const outputValue = createPersistedSetupOutput(answers, provider, flow);
     const result = await saveSetupAndRuntimeConfig(outputValue, {
         setupPath: typeof args.path === "string" ? args.path : undefined,
         runtimePath: typeof args["runtime-path"] === "string" ? args["runtime-path"] : undefined
@@ -360,10 +549,27 @@ async function runCodexPersistInit(args) {
     console.log(renderInstallSummary(result));
     if (installedPrompts.length > 0) {
         console.log("");
-        console.log("Installed Codex prompt aliases:");
+        console.log("Installed Codex prompt files:");
         for (const prompt of installedPrompts) {
             console.log(`- /prompts:${prompt.name}`);
         }
+        console.log("  Note: whether Codex exposes these as slash commands depends on your Codex build.");
+    }
+    if (provider === "codex") {
+        console.log("");
+        console.log("Next step:");
+        console.log("- Start here: `longtable start`.");
+        console.log("- If you want a direct natural-language entry: `longtable ask --prompt \"...\"`.");
+        console.log("- Codex prompt files are available as an experimental integration, not the primary path.");
+        if (answers.currentBlocker) {
+            console.log(`- Suggested first message: ${answers.currentBlocker}`);
+        }
+        else if (answers.currentResearchTopic) {
+            console.log(`- Suggested first message: Help me think through ${answers.currentResearchTopic}.`);
+        }
+        else {
+            console.log("- Suggested first message: I want to start my research and I am not sure where to open the problem.");
+        }
     }
 }
 async function resolvePrompt(prompt) {
@@ -381,6 +587,57 @@ async function resolvePrompt(prompt) {
         rl.close();
     }
 }
+function inferModeFromPrompt(prompt) {
+    const normalized = prompt.toLowerCase();
+    if (normalized.includes("status") ||
+        normalized.includes("설정") ||
+        normalized.includes("상태") ||
+        normalized.includes("롱테이블 상태")) {
+        return "status";
+    }
+    if (normalized.includes("패널") ||
+        normalized.includes("의견 충돌") ||
+        normalized.includes("conflict") ||
+        normalized.includes("disagree") ||
+        normalized.includes("panel")) {
+        return "panel";
+    }
+    if (normalized.includes("결정") ||
+        normalized.includes("고를") ||
+        normalized.includes("선택") ||
+        normalized.includes("commit")) {
+        return "commit";
+    }
+    if (normalized.includes("초안") ||
+        normalized.includes("써줘") ||
+        normalized.includes("문단") ||
+        normalized.includes("draft") ||
+        normalized.includes("write")) {
+        return "draft";
+    }
+    if (normalized.includes("비판") ||
+        normalized.includes("반론") ||
+        normalized.includes("critique") ||
+        normalized.includes("challenge")) {
+        return "critique";
+    }
+    if (normalized.includes("검토") ||
+        normalized.includes("review") ||
+        normalized.includes("편집자") ||
+        normalized.includes("리뷰어") ||
+        normalized.includes("judge")) {
+        return "review";
+    }
+    return "explore";
+}
+async function loadOptionalSetup(path) {
+    try {
+        return await loadSetupOutput(path);
+    }
+    catch {
+        return null;
+    }
+}
 async function runModeCommand(mode, args) {
     const prompt = await resolvePrompt(typeof args.prompt === "string" ? args.prompt : undefined);
     if (!prompt) {
@@ -390,10 +647,16 @@ async function runModeCommand(mode, args) {
     if (stage && !VALID_STAGES.has(stage)) {
         throw new Error(`Invalid stage: ${stage}`);
     }
+    const setup = await loadOptionalSetup(typeof args.setup === "string" ? args.setup : undefined);
+    const panelPreference = setup?.profileSeed.panelPreference;
+    const panelRequested = args.panel === true ||
+        panelPreference === "always_visible" ||
+        (panelPreference === "show_on_conflict" && args["show-conflicts"] === true);
     const { guidedPrompt } = buildPersonaGuidance({
+        mode,
         prompt,
         roleFlag: typeof args.role === "string" ? args.role : undefined,
-        panel: args.panel === true,
+        panel: panelRequested,
         showConflicts: args["show-conflicts"] === true,
         showDeliberation: args["show-deliberation"] === true
     });
@@ -418,11 +681,139 @@ async function runModeCommand(mode, args) {
     });
     exit(exitCode);
 }
+async function runAsk(args) {
+    const prompt = await resolvePrompt(typeof args.prompt === "string" ? args.prompt : undefined);
+    if (!prompt) {
+        throw new Error("A prompt is required.");
+    }
+    const inferred = inferModeFromPrompt(prompt);
+    if (inferred === "status") {
+        await runCodexSubcommand("status", args);
+        return;
+    }
+    const mode = inferred === "panel" ? "review" : inferred;
+    const delegatedArgs = {
+        ...args,
+        prompt
+    };
+    if (inferred === "panel" && delegatedArgs.panel !== true) {
+        delegatedArgs.panel = true;
+        delegatedArgs["show-conflicts"] = true;
+    }
+    await runModeCommand(mode, delegatedArgs);
+}
+async function runRoles(args) {
+    const payload = PERSONA_DEFINITIONS.map((persona) => ({
+        key: persona.key,
+        label: persona.label,
+        description: persona.shortDescription,
+        triggerMode: persona.triggerMode,
+        exampleTriggers: persona.synonyms.slice(0, 4)
+    }));
+    if (args.json === true) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log("Long Table roles");
+    console.log("These are perspectives Long Table can consult when relevant.");
+    console.log("");
+    for (const persona of payload) {
+        console.log(`- ${persona.label} (${persona.key})`);
+        console.log(`  ${persona.description}`);
+        console.log(`  Trigger: ${persona.triggerMode === "auto-callable" ? "auto-callable when your language strongly implies it" : "explicit request only"}`);
+        console.log(`  Examples: ${persona.exampleTriggers.join(", ")}`);
+    }
+}
+async function runStart(args) {
+    const setupPath = typeof args.setup === "string" ? args.setup : undefined;
+    const existingSetup = await loadOptionalSetup(setupPath);
+    if (!existingSetup) {
+        console.log("Long Table is not set up yet. Starting the interview flow first.");
+        console.log("");
+        await runInit({
+            ...args,
+            flow: typeof args.flow === "string" ? args.flow : "interview",
+            "install-prompts": true
+        });
+        return;
+    }
+    const directPrompt = typeof args.prompt === "string" ? args.prompt.trim() : "";
+    if (directPrompt) {
+        await runAsk({
+            ...args,
+            prompt: directPrompt,
+            ...(setupPath ? { setup: setupPath } : {})
+        });
+        return;
+    }
+    const rl = createInterface({ input, output });
+    try {
+        const action = await promptStartAction(rl, existingSetup.profileSeed.currentBlocker ?? existingSetup.profileSeed.currentResearchTopic);
+        if (action === "status") {
+            rl.close();
+            await runCodexSubcommand("status", args);
+            return;
+        }
+        if (action === "roles") {
+            rl.close();
+            await runRoles(args);
+            return;
+        }
+        const defaultPrompt = existingSetup.profileSeed.currentBlocker ??
+            existingSetup.profileSeed.currentResearchTopic ??
+            "";
+        const prompt = (await rl.question(defaultPrompt
+            ? `What are you working on today?\nPress Enter to use: ${defaultPrompt}\n> `
+            : "What are you working on today?\n> ")).trim() || defaultPrompt;
+        rl.close();
+        if (!prompt) {
+            throw new Error("A prompt is required.");
+        }
+        if (action === "editor") {
+            await runModeCommand("review", {
+                ...args,
+                prompt,
+                role: "editor",
+                ...(setupPath ? { setup: setupPath } : {})
+            });
+            return;
+        }
+        if (action === "methods") {
+            await runModeCommand("review", {
+                ...args,
+                prompt,
+                role: "methods_critic",
+                ...(setupPath ? { setup: setupPath } : {})
+            });
+            return;
+        }
+        if (action === "panel") {
+            await runModeCommand("review", {
+                ...args,
+                prompt,
+                panel: true,
+                "show-conflicts": true,
+                ...(setupPath ? { setup: setupPath } : {})
+            });
+            return;
+        }
+        const mode = action;
+        await runModeCommand(mode, {
+            ...args,
+            prompt,
+            ...(setupPath ? { setup: setupPath } : {})
+        });
+    }
+    finally {
+        rl.close();
+    }
+}
 async function runCodexSubcommand(subcommand, args) {
     const customDir = typeof args.dir === "string" ? args.dir : undefined;
     if (subcommand === "install-prompts") {
         const installed = await installCodexPromptAliases(customDir);
         console.log(`Installed ${installed.length} Long Table prompt aliases in ${resolveCodexPromptsDir(customDir)}`);
+        console.log("Note: prompt-file discovery depends on the Codex build. Treat this as an experimental integration.");
         for (const prompt of installed) {
             console.log(`- /prompts:${prompt.name}`);
         }
@@ -457,6 +848,7 @@ async function runCodexSubcommand(subcommand, args) {
         console.log(`- setup: ${status.setupExists ? "present" : "missing"} (${setupPath})`);
         console.log(`- codex runtime artifact: ${status.runtimeExists ? "present" : "missing"} (${runtimePath})`);
         console.log(`- prompt aliases dir: ${status.promptsDir}`);
+        console.log("- prompt-file integration: experimental (your Codex build may not expose these as slash commands)");
         if (aliases.length === 0) {
             console.log("- prompt aliases: none");
         }
@@ -481,6 +873,14 @@ async function main() {
         await runInit(values);
         return;
     }
+    if (command === "start") {
+        await runStart(values);
+        return;
+    }
+    if (command === "roles") {
+        await runRoles(values);
+        return;
+    }
     if (command === "show") {
         await runShow(values);
         return;
@@ -489,6 +889,10 @@ async function main() {
         await runInstall(values);
         return;
     }
+    if (command === "ask") {
+        await runAsk(values);
+        return;
+    }
     if (command === "codex") {
         await runCodexSubcommand(subcommand, values);
         return;
@@ -500,7 +904,11 @@ async function main() {
     throw new Error(`Unknown command: ${command}`);
 }
 main().catch((error) => {
-    console.error(error instanceof Error ? error.message : String(error));
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    if (message === "Setup cancelled.") {
+        exit(1);
+    }
     console.error("");
     console.error(usage());
     exit(1);

package/dist/persona-router.d.ts

@@ -1,4 +1,5 @@
 import { type CanonicalPersona } from "./personas.js";
+import type { InteractionMode } from "@diverga/core";
 export type OutputLanguage = "ko" | "en";
 export interface PersonaRoutingResult {
     outputLanguage: OutputLanguage;
@@ -12,6 +13,7 @@ export declare function parseRoleFlag(value?: string): CanonicalPersona[];
 export declare function routePersonas(prompt: string, explicitRoleFlag?: string): PersonaRoutingResult;
 export declare function renderDisclosure(roles: CanonicalPersona[], language: OutputLanguage): string | null;
 export declare function buildPersonaGuidance(options: {
+    mode: InteractionMode;
     prompt: string;
     roleFlag?: string;
     panel?: boolean;

package/dist/persona-router.js

@@ -63,6 +63,9 @@ export function buildPersonaGuidance(options) {
     const routing = routePersonas(options.prompt, options.roleFlag);
     const disclosure = renderDisclosure(routing.consultedRoles, routing.outputLanguage);
     const lines = [];
+    lines.push(routing.outputLanguage === "ko"
+        ? `Long Table mode: ${options.mode[0].toUpperCase()}${options.mode.slice(1)}`
+        : `Long Table mode: ${options.mode[0].toUpperCase()}${options.mode.slice(1)}`);
     if (disclosure) {
         lines.push(disclosure);
     }
@@ -86,6 +89,9 @@ export function buildPersonaGuidance(options) {
             ? "Include a short deliberation trace showing why the roles diverged."
             : "Include a short deliberation trace showing why the roles diverged.");
     }
+    lines.push(routing.outputLanguage === "ko"
+        ? "Do not show internal file-search logs, tool traces, or process commentary in the researcher-facing answer."
+        : "Do not show internal file-search logs, tool traces, or process commentary in the researcher-facing answer.");
     lines.push(options.prompt.trim());
     return {
         guidedPrompt: lines.join("\n\n"),

package/dist/prompt-aliases.js

@@ -7,19 +7,38 @@ export function resolveCodexPromptsDir(customDir) {
 }
 function promptSpec() {
     return [
+        {
+            name: "longtable",
+            description: "Single-entry Long Table router for research conversations",
+            argumentHint: "<natural language research request>",
+            body: [
+                "You are Long Table.",
+                "Classify the user's request into one of these modes: explore, review, critique, draft, commit, panel, or status.",
+                "If the request is ambiguous, ask one short clarifying question before closing.",
+                "Always begin with `Long Table mode: <Mode>`.",
+                "Always disclose consulted roles with `Long Table consulted: ...` when any role is foregrounded.",
+                "In explore mode, ask at least two clarifying or tension questions before any recommendation.",
+                "In panel mode, return 1) Long Table synthesis 2) visible panel opinions by role 3) conflict summary if needed 4) a decision prompt for the researcher.",
+                "Do not expose internal tool logs, file searches, or process notes in the researcher-facing answer.",
+                "Treat any slash-command arguments as the current research object."
+            ]
+        },
         {
             name: "longtable-init",
             description: "Run Long Table researcher onboarding inside Codex",
             argumentHint: "[project context or current uncertainty]",
             body: [
                 "You are Long Table onboarding inside Codex.",
+                "First ask whether the researcher wants Quickstart or Interview setup.",
                 "Ask exactly one setup question at a time.",
                 "Use numbered choices when possible and include a 'None of the above' option when needed.",
                 "Do not move to the next question until the researcher answers the current one.",
-                "Cover these fields: provider, field, career stage, experience level, current project type, checkpoint intensity, and human authorship signal.",
-                "After collecting all answers, summarize the proposed setup and then output both: 1) the exact `longtable codex persist-init ... --install-prompts` command and 2) a strict JSON object with keys provider, field, careerStage, experienceLevel, currentProjectType, preferredCheckpointIntensity, and optional humanAuthorshipSignal.",
+                "Quickstart covers: provider, field, career stage, experience level, current project type, checkpoint intensity, and human authorship signal.",
+                "Interview also covers: current research topic, current blocker, preferred entry mode, weakest domain, and panel visibility preference.",
+                "After collecting all answers, summarize the proposed setup and then output both: 1) the exact `longtable codex persist-init ... --install-prompts` command and 2) a strict JSON object with keys provider, flow, field, careerStage, experienceLevel, currentProjectType, preferredCheckpointIntensity, and optional humanAuthorshipSignal, currentResearchTopic, currentBlocker, preferredEntryMode, weakestDomain, panelPreference.",
                 "If the user prefers paste-based setup, tell them they can pipe the JSON into `longtable codex persist-init --stdin --install-prompts`.",
                 "If the researcher asks you to stay inside Codex, keep the conversation in numbered form and do not prematurely close.",
+                "Frame the setup like a short researcher interview, not a bare config form.",
                 "Treat any slash-command arguments as context for why setup is being done now."
             ]
         },
@@ -29,9 +48,11 @@ function promptSpec() {
             argumentHint: "<topic or research problem>",
             body: [
                 "You are Long Table in explore mode.",
+                "Always begin with `Long Table mode: Explore`.",
                 "Ask at least two clarifying or tension questions before any recommendation.",
                 "Keep unresolved tensions visible.",
                 "Do not rush to synthesis.",
+                "Do not expose internal process notes or file-search summaries.",
                 "Treat any slash-command arguments as the current research object."
             ]
         },
@@ -41,6 +62,7 @@ function promptSpec() {
             argumentHint: "<claim, paragraph, design, or plan>",
             body: [
                 "You are Long Table in review mode.",
+                "Always begin with `Long Table mode: Review`.",
                 "Surface why this may be wrong before synthesis.",
                 "Preserve the researcher's own language where possible.",
                 "Treat any slash-command arguments as the object to review."
@@ -52,6 +74,7 @@ function promptSpec() {
             argumentHint: "<claim, plan, or draft for multi-role review>",
             body: [
                 "You are Long Table in panel mode.",
+                "Always begin with `Long Table mode: Panel`.",
                 "Return 1) a Long Table synthesis 2) visible panel opinions by role 3) a decision prompt for the researcher.",
                 "If roles disagree, do not collapse them too early.",
                 "Disclose which roles were consulted.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longtable/cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "description": "Researcher-facing Long Table CLI on top of the legacy Diverga package surface",
   "type": "module",
@@ -26,7 +26,7 @@
   },
   "dependencies": {
     "@diverga/provider-codex": "0.1.1",
-    "@diverga/setup": "0.1.1"
+    "@diverga/setup": "0.1.3"
   },
   "devDependencies": {
     "@types/node": "^22.10.1",