@longtable/cli 0.1.0

package/README.md

@@ -0,0 +1,91 @@
+# @longtable/cli
+
+Researcher-facing Long Table CLI built on top of the legacy `@diverga/*` package surface.
+
+중요한 현재 상태:
+
+- `@longtable/cli`는 repo 안에서는 구현되어 있음
+- npm의 `@longtable` scope가 아직 준비되지 않아 실제 publish는 아직 안 됨
+- 지금 공개 설치 경로는 여전히 `@diverga/setup`, `@diverga/provider-codex`
+
+## Install
+
+로컬 preview:
+
+```bash
+npm install
+npm run build
+node packages/longtable/dist/cli.js --help
+```
+
+예상 공개 설치 경로:
+
+```bash
+npm install -g @longtable/cli
+```
+
+## Recommended flow
+
+Run setup once and install Codex prompt aliases:
+
+```bash
+longtable init --install-prompts
+```
+
+Then you can work in two ways.
+
+From the terminal:
+
+```bash
+longtable review --prompt "Review this claim critically."
+longtable review --prompt "BJET 편집자 관점에서 봐줘." --role editor
+longtable review --prompt "방법론적으로 어디가 취약한지 말해줘." --panel --show-conflicts
+```
+
+Inside Codex after prompt aliases are installed:
+
+- `/prompts:longtable-init`
+- `/prompts:longtable-explore`
+- `/prompts:longtable-review`
+- `/prompts:longtable-critique`
+- `/prompts:longtable-draft`
+- `/prompts:longtable-commit`
+- `/prompts:longtable-status`
+
+## Core commands
+
+```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."
+```
+
+## Codex overlay
+
+Install Codex prompt aliases:
+
+```bash
+longtable codex install-prompts
+```
+
+Check whether setup and aliases are present:
+
+```bash
+longtable codex status
+```
+
+Remove the aliases:
+
+```bash
+longtable codex remove-prompts
+```
+
+## Why this package exists
+
+Long Table is the product name.
+`Diverga` is still the legacy technical identifier for package names, CLI binaries, and runtime paths.
+
+This package creates a researcher-facing command surface now, without forcing a breaking rename of the published package chain yet.

package/bin/longtable

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import("../dist/cli.js").catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output, cwd, exit } from "node:process";
+import { buildProviderChoices, buildQuickSetupFlow, createPersistedSetupOutput, installRuntimeConfigFromStoredSetup, loadSetupOutput, renderInstallSummary, renderSetupSummary, resolveDefaultRuntimeConfigPath, resolveDefaultSetupPath, saveSetupAndRuntimeConfig, serializeSetupOutput } from "@diverga/setup";
+import { buildCodexThinWrappedPrompt, runCodexThinWrapper } from "@diverga/provider-codex";
+import { installCodexPromptAliases, listInstalledCodexPromptAliases, removeCodexPromptAliases, resolveCodexPromptsDir } from "./prompt-aliases.js";
+import { buildPersonaGuidance } from "./persona-router.js";
+const VALID_MODES = new Set([
+    "explore",
+    "review",
+    "critique",
+    "draft",
+    "commit",
+    "submit"
+]);
+const VALID_STAGES = new Set([
+    "problem_framing",
+    "theory_selection",
+    "method_design",
+    "measurement_design",
+    "analysis_planning",
+    "writing",
+    "submission"
+]);
+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 show [--json] [--path <file>]",
+        "  longtable install [--json] [--path <file>] [--runtime-path <file>]",
+        "  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 install-prompts [--dir <path>]",
+        "  longtable codex remove-prompts [--dir <path>]",
+        "  longtable codex status [--dir <path>] [--json]",
+        "",
+        "Examples:",
+        "  longtable init --install-prompts",
+        "  longtable review --prompt \"Review this claim critically.\" --panel --show-conflicts",
+        "  longtable review --role editor --prompt \"BJET 편집자 관점에서 봐줘.\"",
+        "  longtable codex install-prompts"
+    ].join("\n");
+}
+function parseArgs(argv) {
+    const [command, maybeSubcommand] = argv;
+    const values = {};
+    let subcommand = maybeSubcommand;
+    const modeCommand = command && VALID_MODES.has(command);
+    const directCommand = command && ["init", "show", "install", "codex"].includes(command);
+    let startIndex = 1;
+    if (modeCommand) {
+        subcommand = undefined;
+        startIndex = 1;
+    }
+    else if (command === "codex") {
+        startIndex = 2;
+    }
+    else if (directCommand) {
+        subcommand = undefined;
+        startIndex = 1;
+    }
+    else if (!command || command === "--help") {
+        return { values };
+    }
+    else {
+        startIndex = 1;
+        subcommand = undefined;
+    }
+    const tokens = argv.slice(startIndex);
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (!token.startsWith("--")) {
+            continue;
+        }
+        const key = token.slice(2);
+        const next = tokens[index + 1];
+        if (!next || next.startsWith("--")) {
+            values[key] = true;
+            continue;
+        }
+        values[key] = next;
+        index += 1;
+    }
+    return { command, subcommand, values };
+}
+function renderChoices(choices) {
+    return choices
+        .map((choice, index) => `${index + 1}. ${choice.label} — ${choice.description}`)
+        .join("\n");
+}
+async function promptChoice(rl, prompt, choices) {
+    while (true) {
+        const answer = await rl.question(`${prompt}\n${renderChoices(choices)}\nSelect one number: `);
+        const numeric = Number(answer.trim());
+        if (!Number.isInteger(numeric) || numeric < 1 || numeric > choices.length) {
+            console.log("Invalid selection. Enter one of the listed numbers.");
+            continue;
+        }
+        const choice = choices[numeric - 1];
+        if (choice.fallbackToText) {
+            const freeText = await rl.question("Type your custom value: ");
+            if (!freeText.trim()) {
+                console.log("Custom value cannot be empty.");
+                continue;
+            }
+            return freeText.trim();
+        }
+        return choice.id;
+    }
+}
+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 toSetupAnswers(args) {
+    return {
+        field: String(args.field),
+        careerStage: String(args["career-stage"]),
+        experienceLevel: String(args.experience),
+        currentProjectType: String(args["project-type"]),
+        preferredCheckpointIntensity: String(args.checkpoint),
+        humanAuthorshipSignal: typeof args["authorship-signal"] === "string" && args["authorship-signal"].trim().length > 0
+            ? args["authorship-signal"].trim()
+            : undefined
+    };
+}
+async function collectInteractiveAnswers() {
+    const rl = createInterface({ input, output });
+    try {
+        const provider = await promptChoice(rl, "Which provider do you want to configure?", buildProviderChoices());
+        const answers = {};
+        for (const question of buildQuickSetupFlow()) {
+            if (!question.choices) {
+                continue;
+            }
+            const value = await promptChoice(rl, question.prompt, question.choices);
+            if (question.id === "field")
+                answers.field = value;
+            if (question.id === "careerStage")
+                answers.careerStage = value;
+            if (question.id === "experienceLevel")
+                answers.experienceLevel = value;
+            if (question.id === "currentProjectType")
+                answers.currentProjectType = value;
+            if (question.id === "preferredCheckpointIntensity") {
+                answers.preferredCheckpointIntensity = value;
+            }
+            if (question.id === "humanAuthorshipSignal" && value !== "other") {
+                answers.humanAuthorshipSignal = value;
+            }
+        }
+        return {
+            provider,
+            answers: answers
+        };
+    }
+    finally {
+        rl.close();
+    }
+}
+async function runInit(args) {
+    const json = args.json === true;
+    const installRuntime = args["no-install"] !== true;
+    const installPrompts = args["install-prompts"] === true;
+    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)
+        ? {
+            provider: String(args.provider) === "claude" ? "claude" : "codex",
+            answers: toSetupAnswers(args)
+        }
+        : await collectInteractiveAnswers();
+    const outputValue = createPersistedSetupOutput(answers, provider);
+    const result = await saveSetupAndRuntimeConfig(outputValue, {
+        setupPath: customPath,
+        runtimePath
+    });
+    let installedPrompts = [];
+    if (provider === "codex" && installPrompts) {
+        installedPrompts = await installCodexPromptAliases(promptsDir);
+    }
+    if (json) {
+        console.log(serializeSetupOutput(outputValue));
+        return;
+    }
+    console.log(renderSetupSummary(outputValue));
+    if (installRuntime) {
+        console.log("");
+        console.log(renderInstallSummary(result));
+    }
+    if (installedPrompts.length > 0) {
+        console.log("");
+        console.log("Installed Codex prompt aliases:");
+        for (const prompt of installedPrompts) {
+            console.log(`- /prompts:${prompt.name}`);
+        }
+    }
+}
+async function runShow(args) {
+    const outputValue = await loadSetupOutput(typeof args.path === "string" ? args.path : undefined);
+    if (args.json === true) {
+        console.log(serializeSetupOutput(outputValue));
+        return;
+    }
+    console.log(renderSetupSummary(outputValue));
+}
+async function runInstall(args) {
+    const result = await installRuntimeConfigFromStoredSetup({
+        setupPath: typeof args.path === "string" ? args.path : undefined,
+        runtimePath: typeof args["runtime-path"] === "string" ? args["runtime-path"] : undefined
+    });
+    if (args.json === true) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(renderInstallSummary(result));
+}
+async function resolvePrompt(prompt) {
+    if (prompt?.trim()) {
+        return prompt.trim();
+    }
+    if (!process.stdin.isTTY) {
+        return readFileSync(0, "utf8").trim();
+    }
+    const rl = createInterface({ input, output });
+    try {
+        return (await rl.question("What should Long Table help with?\n> ")).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function runModeCommand(mode, args) {
+    const prompt = await resolvePrompt(typeof args.prompt === "string" ? args.prompt : undefined);
+    if (!prompt) {
+        throw new Error("A prompt is required.");
+    }
+    const stage = typeof args.stage === "string" ? args.stage : undefined;
+    if (stage && !VALID_STAGES.has(stage)) {
+        throw new Error(`Invalid stage: ${stage}`);
+    }
+    const { guidedPrompt } = buildPersonaGuidance({
+        prompt,
+        roleFlag: typeof args.role === "string" ? args.role : undefined,
+        panel: args.panel === true,
+        showConflicts: args["show-conflicts"] === true,
+        showDeliberation: args["show-deliberation"] === true
+    });
+    if (args.print === true) {
+        const wrapped = await buildCodexThinWrappedPrompt({
+            prompt: guidedPrompt,
+            mode,
+            researchStage: stage,
+            setupPath: typeof args.setup === "string" ? args.setup : undefined,
+            workingDirectory: typeof args.cwd === "string" ? args.cwd : cwd()
+        });
+        console.log(wrapped.wrappedPrompt);
+        return;
+    }
+    const exitCode = await runCodexThinWrapper({
+        prompt: guidedPrompt,
+        mode,
+        researchStage: stage,
+        setupPath: typeof args.setup === "string" ? args.setup : undefined,
+        workingDirectory: typeof args.cwd === "string" ? args.cwd : cwd(),
+        json: args.json === true
+    });
+    exit(exitCode);
+}
+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)}`);
+        for (const prompt of installed) {
+            console.log(`- /prompts:${prompt.name}`);
+        }
+        return;
+    }
+    if (subcommand === "remove-prompts") {
+        const removed = await removeCodexPromptAliases(customDir);
+        console.log(`Removed ${removed.length} Long Table prompt aliases from ${resolveCodexPromptsDir(customDir)}`);
+        return;
+    }
+    if (subcommand === "status") {
+        const aliases = await listInstalledCodexPromptAliases(customDir);
+        const setupPath = resolveDefaultSetupPath(typeof args.path === "string" ? args.path : undefined).path;
+        const runtimePath = resolveDefaultRuntimeConfigPath("codex", typeof args["runtime-path"] === "string" ? args["runtime-path"] : undefined).path;
+        const status = {
+            setupPath,
+            setupExists: existsSync(setupPath),
+            runtimePath,
+            runtimeExists: existsSync(runtimePath),
+            promptsDir: resolveCodexPromptsDir(customDir),
+            promptAliasesInstalled: aliases.map((alias) => alias.name)
+        };
+        if (args.json === true) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        console.log("Long Table Codex status");
+        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}`);
+        if (aliases.length === 0) {
+            console.log("- prompt aliases: none");
+        }
+        else {
+            console.log("- prompt aliases:");
+            for (const alias of aliases) {
+                console.log(`  - /prompts:${alias.name}`);
+            }
+        }
+        return;
+    }
+    throw new Error("Unknown codex subcommand.");
+}
+async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    const { command, subcommand, values } = parsed;
+    if (!command || command === "--help" || values.help === true) {
+        console.log(usage());
+        return;
+    }
+    if (command === "init") {
+        await runInit(values);
+        return;
+    }
+    if (command === "show") {
+        await runShow(values);
+        return;
+    }
+    if (command === "install") {
+        await runInstall(values);
+        return;
+    }
+    if (command === "codex") {
+        await runCodexSubcommand(subcommand, values);
+        return;
+    }
+    if (VALID_MODES.has(command)) {
+        await runModeCommand(command, values);
+        return;
+    }
+    throw new Error(`Unknown command: ${command}`);
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    console.error("");
+    console.error(usage());
+    exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./prompt-aliases.js";
+export * from "./personas.js";
+export * from "./persona-router.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./prompt-aliases.js";
+export * from "./personas.js";
+export * from "./persona-router.js";

package/dist/persona-router.d.ts

@@ -0,0 +1,23 @@
+import { type CanonicalPersona } from "./personas.js";
+export type OutputLanguage = "ko" | "en";
+export interface PersonaRoutingResult {
+    outputLanguage: OutputLanguage;
+    explicitRoles: CanonicalPersona[];
+    implicitRoles: CanonicalPersona[];
+    consultedRoles: CanonicalPersona[];
+    ambiguousSignal: string | null;
+}
+export declare function detectOutputLanguage(input: string): OutputLanguage;
+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: {
+    prompt: string;
+    roleFlag?: string;
+    panel?: boolean;
+    showConflicts?: boolean;
+    showDeliberation?: boolean;
+}): {
+    guidedPrompt: string;
+    routing: PersonaRoutingResult;
+};

package/dist/persona-router.js

@@ -0,0 +1,94 @@
+import { getPersonaDefinition, parsePersonaKey, PERSONA_DEFINITIONS } from "./personas.js";
+const AUTO_CALL_LIMIT = 3;
+function unique(items) {
+    return [...new Set(items)];
+}
+export function detectOutputLanguage(input) {
+    return /[가-힣]/.test(input) ? "ko" : "en";
+}
+export function parseRoleFlag(value) {
+    if (!value?.trim()) {
+        return [];
+    }
+    return unique(value
+        .split(",")
+        .map((part) => parsePersonaKey(part))
+        .filter((part) => part !== null));
+}
+export function routePersonas(prompt, explicitRoleFlag) {
+    const normalizedPrompt = prompt.toLowerCase();
+    const explicitRoles = parseRoleFlag(explicitRoleFlag);
+    const naturalLanguageExplicit = PERSONA_DEFINITIONS.filter((persona) => persona.synonyms.some((synonym) => normalizedPrompt.includes(synonym.toLowerCase()))).map((persona) => persona.key);
+    const mergedExplicit = unique([...explicitRoles, ...naturalLanguageExplicit]);
+    const implicitRoles = PERSONA_DEFINITIONS.filter((persona) => {
+        if (persona.triggerMode !== "auto-callable") {
+            return false;
+        }
+        if (mergedExplicit.includes(persona.key)) {
+            return false;
+        }
+        return persona.synonyms.some((synonym) => normalizedPrompt.includes(synonym.toLowerCase()));
+    })
+        .map((persona) => persona.key)
+        .slice(0, AUTO_CALL_LIMIT);
+    let ambiguousSignal = null;
+    if (normalizedPrompt.includes("review") ||
+        normalizedPrompt.includes("봐줘") ||
+        normalizedPrompt.includes("검토") ||
+        normalizedPrompt.includes("판단")) {
+        const hasEditor = mergedExplicit.includes("editor") || implicitRoles.includes("editor");
+        const hasReviewer = mergedExplicit.includes("reviewer") || implicitRoles.includes("reviewer");
+        if (!hasEditor && !hasReviewer) {
+            ambiguousSignal = "editor_or_reviewer";
+        }
+    }
+    return {
+        outputLanguage: detectOutputLanguage(prompt),
+        explicitRoles: mergedExplicit,
+        implicitRoles,
+        consultedRoles: unique([...mergedExplicit, ...implicitRoles]),
+        ambiguousSignal
+    };
+}
+export function renderDisclosure(roles, language) {
+    if (roles.length === 0) {
+        return null;
+    }
+    const labels = roles.map((role) => getPersonaDefinition(role).label);
+    return language === "ko"
+        ? `Long Table consulted: ${labels.join(", ")}`
+        : `Long Table consulted: ${labels.join(", ")}`;
+}
+export function buildPersonaGuidance(options) {
+    const routing = routePersonas(options.prompt, options.roleFlag);
+    const disclosure = renderDisclosure(routing.consultedRoles, routing.outputLanguage);
+    const lines = [];
+    if (disclosure) {
+        lines.push(disclosure);
+    }
+    if (routing.ambiguousSignal === "editor_or_reviewer") {
+        lines.push(routing.outputLanguage === "ko"
+            ? "Ambiguity note: 편집자 관점인지 리뷰어 관점인지 애매합니다. 먼저 둘 중 무엇을 우선할지 짧게 확인하세요."
+            : "Ambiguity note: it is unclear whether the user wants an editor view or reviewer view. Ask briefly before closing.");
+    }
+    if (options.panel) {
+        lines.push(routing.outputLanguage === "ko"
+            ? "Return format: 1) Long Table synthesis 2) panel opinions by role 3) decision prompt to the researcher."
+            : "Return format: 1) Long Table synthesis 2) panel opinions by role 3) decision prompt to the researcher.");
+    }
+    if (options.showConflicts) {
+        lines.push(routing.outputLanguage === "ko"
+            ? "If roles disagree, show the conflict explicitly instead of forcing one answer."
+            : "If roles disagree, show the conflict explicitly instead of forcing one answer.");
+    }
+    if (options.showDeliberation) {
+        lines.push(routing.outputLanguage === "ko"
+            ? "Include a short deliberation trace showing why the roles diverged."
+            : "Include a short deliberation trace showing why the roles diverged.");
+    }
+    lines.push(options.prompt.trim());
+    return {
+        guidedPrompt: lines.join("\n\n"),
+        routing
+    };
+}

package/dist/personas.d.ts

@@ -0,0 +1,12 @@
+export declare const CANONICAL_PERSONAS: readonly ["editor", "reviewer", "theory_critic", "methods_critic", "measurement_auditor", "ethics_reviewer", "voice_keeper", "venue_strategist"];
+export type CanonicalPersona = (typeof CANONICAL_PERSONAS)[number];
+export interface PersonaDefinition {
+    key: CanonicalPersona;
+    label: string;
+    shortDescription: string;
+    triggerMode: "auto-callable" | "explicit-only";
+    synonyms: string[];
+}
+export declare const PERSONA_DEFINITIONS: readonly PersonaDefinition[];
+export declare function parsePersonaKey(value: string): CanonicalPersona | null;
+export declare function getPersonaDefinition(key: CanonicalPersona): PersonaDefinition;

package/dist/personas.js

@@ -0,0 +1,87 @@
+export const CANONICAL_PERSONAS = [
+    "editor",
+    "reviewer",
+    "theory_critic",
+    "methods_critic",
+    "measurement_auditor",
+    "ethics_reviewer",
+    "voice_keeper",
+    "venue_strategist"
+];
+export const PERSONA_DEFINITIONS = [
+    {
+        key: "editor",
+        label: "Journal Editor",
+        shortDescription: "Assesses venue fit, framing strength, and editorial salience.",
+        triggerMode: "auto-callable",
+        synonyms: ["editor", "journal editor", "editorial", "편집자", "저널 편집자", "에디터"]
+    },
+    {
+        key: "reviewer",
+        label: "Reviewer",
+        shortDescription: "Surfaces likely peer-review objections and requests for clarification.",
+        triggerMode: "auto-callable",
+        synonyms: ["reviewer", "peer reviewer", "심사자", "리뷰어", "심사위원"]
+    },
+    {
+        key: "theory_critic",
+        label: "Theory Critic",
+        shortDescription: "Checks conceptual coherence, anchor theory fit, and overreach.",
+        triggerMode: "auto-callable",
+        synonyms: ["theory", "theoretical", "conceptual", "이론", "이론적", "개념적"]
+    },
+    {
+        key: "methods_critic",
+        label: "Methods Critic",
+        shortDescription: "Challenges design logic, methodological defensibility, and alignment.",
+        triggerMode: "auto-callable",
+        synonyms: ["method", "methods", "methodology", "research design", "방법론", "방법", "연구 설계"]
+    },
+    {
+        key: "measurement_auditor",
+        label: "Measurement Auditor",
+        shortDescription: "Looks for construct validity, scale choice, and evidence quality issues.",
+        triggerMode: "auto-callable",
+        synonyms: [
+            "measurement",
+            "measure",
+            "scale",
+            "validity",
+            "reliability",
+            "측정",
+            "척도",
+            "타당도",
+            "신뢰도"
+        ]
+    },
+    {
+        key: "ethics_reviewer",
+        label: "Ethics Reviewer",
+        shortDescription: "Flags consent, IRB, representation, and trust harms.",
+        triggerMode: "auto-callable",
+        synonyms: ["ethics", "ethical", "irb", "윤리", "윤리적", "irb"]
+    },
+    {
+        key: "voice_keeper",
+        label: "Voice Keeper",
+        shortDescription: "Protects narrative trace, authorship, and the researcher's own voice.",
+        triggerMode: "auto-callable",
+        synonyms: ["voice", "tone", "narrative", "authorship", "목소리", "서사", "저자성", "문체"]
+    },
+    {
+        key: "venue_strategist",
+        label: "Venue Strategist",
+        shortDescription: "Compares venue expectations and suggests positioning tradeoffs.",
+        triggerMode: "explicit-only",
+        synonyms: ["venue", "journal fit", "conference fit", "저널 적합성", "학회 적합성", "투고처"]
+    }
+];
+export function parsePersonaKey(value) {
+    const normalized = value.trim().toLowerCase().replace(/\s+/g, "_");
+    return CANONICAL_PERSONAS.includes(normalized)
+        ? normalized
+        : null;
+}
+export function getPersonaDefinition(key) {
+    return PERSONA_DEFINITIONS.find((persona) => persona.key === key);
+}

package/dist/prompt-aliases.d.ts

@@ -0,0 +1,9 @@
+export interface InstalledPromptAlias {
+    name: string;
+    path: string;
+    description: string;
+}
+export declare function resolveCodexPromptsDir(customDir?: string): string;
+export declare function installCodexPromptAliases(customDir?: string): Promise<InstalledPromptAlias[]>;
+export declare function removeCodexPromptAliases(customDir?: string): Promise<string[]>;
+export declare function listInstalledCodexPromptAliases(customDir?: string): Promise<InstalledPromptAlias[]>;

package/dist/prompt-aliases.js

@@ -0,0 +1,188 @@
+import { mkdir, readdir, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+export function resolveCodexPromptsDir(customDir) {
+    return customDir ? resolve(customDir) : join(homedir(), ".codex", "prompts");
+}
+function promptSpec() {
+    return [
+        {
+            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.",
+                "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 tell the researcher the exact `longtable init ...` command to persist it.",
+                "If the researcher asks you to stay inside Codex, keep the conversation in numbered form and do not prematurely close.",
+                "Treat any slash-command arguments as context for why setup is being done now."
+            ]
+        },
+        {
+            name: "longtable-explore",
+            description: "Long Table explore mode for open research questions",
+            argumentHint: "<topic or research problem>",
+            body: [
+                "You are Long Table in explore mode.",
+                "Ask at least two clarifying or tension questions before any recommendation.",
+                "Keep unresolved tensions visible.",
+                "Do not rush to synthesis.",
+                "Treat any slash-command arguments as the current research object."
+            ]
+        },
+        {
+            name: "longtable-review",
+            description: "Long Table review mode for critical evaluation",
+            argumentHint: "<claim, paragraph, design, or plan>",
+            body: [
+                "You are Long Table in review mode.",
+                "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."
+            ]
+        },
+        {
+            name: "longtable-panel",
+            description: "Long Table panel mode with visible role disagreement",
+            argumentHint: "<claim, plan, or draft for multi-role review>",
+            body: [
+                "You are Long Table in panel mode.",
+                "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.",
+                "Treat any slash-command arguments as the object under discussion."
+            ]
+        },
+        {
+            name: "longtable-editor",
+            description: "Long Table editor view",
+            argumentHint: "<claim, draft, or paper positioning>",
+            body: [
+                "You are Long Table with the Journal Editor role foregrounded.",
+                "Prioritize venue fit, framing clarity, contribution shape, and likely editorial concerns.",
+                "Disclose that the editor role was consulted.",
+                "Treat any slash-command arguments as the editorial object."
+            ]
+        },
+        {
+            name: "longtable-reviewer",
+            description: "Long Table reviewer view",
+            argumentHint: "<claim, method, or manuscript section>",
+            body: [
+                "You are Long Table with the Reviewer role foregrounded.",
+                "Prioritize likely objections, missing evidence, weak claims, and points needing clarification.",
+                "Disclose that the reviewer role was consulted.",
+                "Treat any slash-command arguments as the review object."
+            ]
+        },
+        {
+            name: "longtable-methods",
+            description: "Long Table methods-critic view",
+            argumentHint: "<study design, measure, or analysis plan>",
+            body: [
+                "You are Long Table with the Methods Critic role foregrounded.",
+                "Prioritize design fit, methodological defensibility, and mismatches between question, measure, and analysis.",
+                "Disclose that the methods critic role was consulted.",
+                "Treat any slash-command arguments as the methodological object."
+            ]
+        },
+        {
+            name: "longtable-critique",
+            description: "Long Table critique mode for stronger counterarguments",
+            argumentHint: "<claim or draft to challenge>",
+            body: [
+                "You are Long Table in critique mode.",
+                "Prioritize counterarguments, blind spots, and hidden assumptions.",
+                "Do not smooth over uncertainty.",
+                "Treat any slash-command arguments as the object to challenge."
+            ]
+        },
+        {
+            name: "longtable-draft",
+            description: "Long Table draft mode with narrative-trace preservation",
+            argumentHint: "<draft goal or section request>",
+            body: [
+                "You are Long Table in draft mode.",
+                "Preserve narrative trace and avoid generic fluency.",
+                "Keep the researcher's voice recognizable.",
+                "Treat any slash-command arguments as the drafting target."
+            ]
+        },
+        {
+            name: "longtable-commit",
+            description: "Long Table commit mode for explicit human decisions",
+            argumentHint: "<decision or choice that needs commitment>",
+            body: [
+                "You are Long Table in commit mode.",
+                "Before making any recommendation, ask for the human commitment that is actually at stake.",
+                "Make the trade-offs explicit.",
+                "Treat any slash-command arguments as the decision under consideration."
+            ]
+        },
+        {
+            name: "longtable-status",
+            description: "Inspect Long Table setup and Codex alias status",
+            argumentHint: "[optional concern]",
+            body: [
+                "You are Long Table status mode.",
+                "Inspect whether setup and runtime artifacts appear to exist under `~/.diverga/` and whether Long Table prompt aliases appear to be installed under `~/.codex/prompts/`.",
+                "Summarize what is configured, what is missing, and the next minimal action.",
+                "Treat any slash-command arguments as the user's concern."
+            ]
+        }
+    ];
+}
+function renderPromptFile(description, argumentHint, body) {
+    return [
+        "---",
+        `description: \"${description}\"`,
+        `argument-hint: \"${argumentHint}\"`,
+        "---",
+        ...body
+    ].join("\n");
+}
+export async function installCodexPromptAliases(customDir) {
+    const promptsDir = resolveCodexPromptsDir(customDir);
+    await mkdir(promptsDir, { recursive: true });
+    const installed = [];
+    for (const spec of promptSpec()) {
+        const path = join(promptsDir, `${spec.name}.md`);
+        await writeFile(path, renderPromptFile(spec.description, spec.argumentHint, spec.body), "utf8");
+        installed.push({
+            name: spec.name,
+            path,
+            description: spec.description
+        });
+    }
+    return installed;
+}
+export async function removeCodexPromptAliases(customDir) {
+    const promptsDir = resolveCodexPromptsDir(customDir);
+    const removed = [];
+    for (const spec of promptSpec()) {
+        const path = join(promptsDir, `${spec.name}.md`);
+        if (existsSync(path)) {
+            await rm(path);
+            removed.push(path);
+        }
+    }
+    return removed;
+}
+export async function listInstalledCodexPromptAliases(customDir) {
+    const promptsDir = resolveCodexPromptsDir(customDir);
+    if (!existsSync(promptsDir)) {
+        return [];
+    }
+    const files = new Set(await readdir(promptsDir));
+    return promptSpec()
+        .filter((spec) => files.has(`${spec.name}.md`))
+        .map((spec) => ({
+        name: spec.name,
+        path: join(promptsDir, `${spec.name}.md`),
+        description: spec.description
+    }));
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@longtable/cli",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Researcher-facing Long Table CLI on top of the legacy Diverga package surface",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "directories": {
+    "bin": "./bin"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@diverga/provider-codex": "0.1.1",
+    "@diverga/setup": "0.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.1",
+    "typescript": "^5.6.0"
+  },
+  "keywords": [
+    "long-table",
+    "research",
+    "codex",
+    "onboarding",
+    "checkpoints"
+  ],
+  "author": "Hosung You",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HosungYou/Diverga-Refactoring.git"
+  },
+  "homepage": "https://github.com/HosungYou/Diverga-Refactoring#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}