@longtable/cli 0.1.7 → 0.1.9

package/README.md

@@ -1,17 +1,12 @@
 # @longtable/cli
 
-Long Table의 researcher-facing CLI입니다.
+Researcher-facing CLI for LongTable.
 
-이 패키지의 핵심은 명령을 많이 외우게 하는 것이 아니라, 아래 두 단계를 명확하게 만드는 것입니다.
+LongTable is designed around a simple contract:
 
-1. `longtable init`
-2. `longtable start`
-
-중요한 점:
-
-- 이 두 명령은 **터미널에서 실행하는 셸 명령**입니다.
-- Codex 채팅창에 `longtable start`를 입력하는 것이 아닙니다.
-- `longtable start`로 프로젝트 작업공간을 만든 뒤, 그 디렉토리에서 `codex`를 여는 것이 기본 경로입니다.
+1. seed the researcher profile once
+2. create a workspace for each project
+3. continue the research conversation inside that workspace
 
 ## Install
 
@@ -19,47 +14,7 @@ Long Table의 researcher-facing CLI입니다.
 npm install -g @longtable/cli
 ```
 
-## 1. Global setup
-
-```bash
-longtable init --flow interview
-```
-
-여기서는 연구자 프로필과 기본 선호를 묻습니다.
-
-- 연구 분야
-- 연구자 역할
-- challenge 강도
-- 저자성/서사 관련 기본값
-- Long Table이 보통 어디서부터 시작해야 하는지
-
-## 2. Project start
-
-```bash
-longtable start
-```
-
-여기서는 실제 작업공간을 만듭니다.
-
-- 프로젝트 이름
-- 프로젝트 디렉토리 위치
-- 현재 세션 목표
-- 현재 blocker
-- 필요한 관점
-- disagreement 가시성
-
-그리고 Long Table은:
-
-- 프로젝트 디렉토리 생성
-- `.longtable/` 메모리 파일 생성
-- 프로젝트용 `AGENTS.md` 생성
-- `START-HERE.md` 생성
-- `NEXT-STEPS.md` 생성
-- `SESSION-SNAPSHOT.md` 생성
-
-을 수행합니다.
-
-## Recommended flow
+## Primary Flow
 
 ```bash
 longtable init --flow interview
@@ -68,9 +23,7 @@ cd "<project-path>"
 codex
 ```
 
-이게 현재 가장 신뢰할 수 있는 Long Table 사용 경로입니다.
-
-돌아와서 다시 이어갈 때는:
+Return later:
 
 ```bash
 cd "<project-path>"
@@ -78,58 +31,69 @@ longtable resume
 codex
 ```
 
-## After the project starts
-
-프로젝트 디렉토리 안에서는 보통 그냥 `codex`를 열고 자연어로 연구를 시작하면 됩니다.
-
-Codex 안에서 더 명시적으로 부르고 싶다면, 아래처럼 짧은 문법도 사용할 수 있습니다.
+## What `longtable start` Creates
 
 ```text
-lt explore: 연구 질문을 어디서부터 좁혀야 할지 모르겠어.
-lt review: 이 주장 어디가 약한지 봐줘.
-lt panel: 이 방향에 대한 의견 충돌도 같이 보여줘.
-lt editor: BJET 편집자 관점에서 봐줘.
-lt methods: 방법론적으로 어디가 취약한지 말해줘.
+<project>/
+  AGENTS.md
+  CURRENT.md
+  .longtable/
+    project.json
+    current-session.json
+    state.json
+    sessions/
 ```
 
-CLI를 계속 쓰고 싶다면 아래 명령은 보조 경로입니다.
+## Artifact Contract
 
-## Advanced commands
+- `AGENTS.md`: runtime guidance for Codex
+- `CURRENT.md`: human-facing current view regenerated from state
+- `.longtable/project.json`: stable project identity
+- `.longtable/current-session.json`: current session cursor
+- `.longtable/state.json`: layered memory state
+- `.longtable/sessions/`: historical snapshots
 
-```bash
-longtable roles
-longtable resume --cwd "<project-path>"
-longtable ask --cwd "<project-path>" --prompt "연구 질문을 어디서부터 좁혀야 할지 모르겠어."
-longtable review --cwd "<project-path>" --prompt "방법론적으로 어디가 취약한지 말해줘." --role methods_critic
-```
+## Why This Shape
 
-## Roles
+The CLI tries to keep the root simple for novice researchers while preserving enough structure for power users and downstream tooling.
 
-```bash
-longtable roles
-```
+The memory model distinguishes:
 
-예:
+- explicit state
+- working state
+- inferred hypotheses
+- open tensions
+- narrative traces
 
-- `editor`
-- `reviewer`
-- `methods_critic`
-- `voice_keeper`
+This is how LongTable avoids turning tacit knowledge into fake certainty.
 
-## Codex prompt-file integration
+## Commands
 
 ```bash
-longtable codex install-prompts
-longtable codex status
+longtable init
+longtable start
+longtable resume --cwd "<project-path>"
+longtable roles
+longtable ask --cwd "<project-path>" --prompt "..."
 ```
 
-이 경로는 현재 실험적입니다.  
-사용자에게 약속하는 주 경로는 아닙니다.
+## Inside Codex
 
-기본 경로는 여전히:
+Natural language should be the default.
 
-- `longtable init`
-- `longtable start`
-- 프로젝트 디렉토리에서 `codex`
+Explicit short forms are available when needed:
 
-입니다.
+```text
+lt explore: Where should I narrow the question first?
+lt review: What is weak in this claim?
+lt panel: Show me the disagreement before I commit.
+lt methods: Where is the design vulnerable?
+```
+
+## Validation
+
+```bash
+npm install
+npm run typecheck
+npm run build
+```

package/dist/cli.js

@@ -1,16 +1,17 @@
 #!/usr/bin/env node
 import { existsSync, readFileSync, statSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
 import { emitKeypressEvents } from "node:readline";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output, cwd, exit } from "node:process";
-import { resolve } from "node:path";
+import { dirname, resolve } from "node:path";
 import { homedir } from "node:os";
-import { buildProviderChoices, buildQuickSetupFlow, createPersistedSetupOutput, installRuntimeConfigFromStoredSetup, loadSetupOutput, renderInstallSummary, renderSetupSummary, resolveDefaultRuntimeConfigPath, resolveDefaultSetupPath, saveSetupAndRuntimeConfig, serializeSetupOutput } from "@diverga/setup";
-import { buildCodexThinWrappedPrompt, runCodexThinWrapper } from "@diverga/provider-codex";
+import { buildProviderChoices, buildQuickSetupFlow, createPersistedSetupOutput, installRuntimeConfigFromStoredSetup, loadSetupOutput, renderInstallSummary, renderSetupSummary, resolveDefaultRuntimeConfigPath, resolveDefaultSetupPath, saveSetupAndRuntimeConfig, serializeSetupOutput } from "@longtable/setup";
+import { buildCodexThinWrappedPrompt, runCodexThinWrapper } from "@longtable/provider-codex";
 import { installCodexPromptAliases, listInstalledCodexPromptAliases, removeCodexPromptAliases, resolveCodexPromptsDir } from "./prompt-aliases.js";
 import { buildPersonaGuidance, parseInvocationDirective } from "./persona-router.js";
 import { PERSONA_DEFINITIONS } from "./personas.js";
-import { createOrUpdateProjectWorkspace, loadProjectContextFromDirectory, renderProjectWorkspaceSummary } from "./project-session.js";
+import { createOrUpdateProjectWorkspace, loadProjectContextFromDirectory, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.js";
 const VALID_MODES = new Set([
     "explore",
     "review",
@@ -154,11 +155,11 @@ function buildSetupFlowChoices() {
     ];
 }
 function renderSetupHeader(flow) {
-    const title = flow === "interview" ? "Long Table Setup Interview" : "Long Table Quickstart";
+    const title = flow === "interview" ? "LongTable Setup Interview" : "LongTable Quickstart";
     const subtitle = flow === "interview"
         ? "We will ask about your research persona, challenge preferences, and authorship defaults."
-        : "We will capture the minimum profile needed to start using Long Table.";
-    return [renderBrandBanner("Long Table", "Research workspace setup"), "", renderSectionCard(title, [subtitle])].join("\n");
+        : "We will capture the minimum profile needed to start using LongTable.";
+    return [renderBrandBanner("LongTable", "Research workspace setup"), "", renderSectionCard(title, [subtitle])].join("\n");
 }
 function renderQuestionHeader(index, total, section, prompt) {
     return [
@@ -175,7 +176,7 @@ function questionSection(questionId) {
         return "Interaction style";
     }
     if (questionId === "weakestDomain" || questionId === "panelPreference") {
-        return "How Long Table should challenge you";
+        return "How LongTable should challenge you";
     }
     return "Authorship and voice";
 }
@@ -242,6 +243,29 @@ function resolveInteractiveProjectPath(parentOrPath, projectName) {
     }
     return resolve(normalized);
 }
+async function verifyWritableWorkspaceParent(projectPath) {
+    const parentDir = dirname(resolve(projectPath));
+    const probePrefix = resolve(parentDir, ".longtable-permission-check-");
+    try {
+        const created = await mkdtemp(probePrefix);
+        await rm(created, { recursive: true, force: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error([
+            `LongTable could not create a project workspace under: ${parentDir}`,
+            "Reason: your current shell process cannot write to that parent directory.",
+            "",
+            "What to try next:",
+            `- test it directly: mkdir -p "${resolve(parentDir, "_longtable_write_test")}"`,
+            "- if that fails too, this is an OS/disk permission problem rather than a LongTable command problem",
+            "- try a known-writable path such as ~/Research",
+            "- or choose a different existing parent directory when LongTable asks where the project should live",
+            "",
+            `Original error: ${message}`
+        ].join("\n"));
+    }
+}
 async function promptChoiceByNumber(rl, prompt, choices) {
     while (true) {
         const answer = await rl.question(`${prompt}\n${renderChoices(choices)}\nSelect one number: `);
@@ -457,7 +481,7 @@ async function collectInteractiveAnswers(initialFlow) {
     const rl = createInterface({ input, output });
     try {
         const flow = initialFlow ??
-            (await promptChoice(rl, "How would you like to set up Long Table?", buildSetupFlowChoices()));
+            (await promptChoice(rl, "How would you like to set up LongTable?", buildSetupFlowChoices()));
         console.log("");
         console.log(renderSetupHeader(flow));
         console.log("");
@@ -535,11 +559,11 @@ async function collectProjectInterview(setup, args) {
     try {
         if (needsInteractivePrompts) {
             console.log("");
-            console.log(renderBrandBanner("Long Table", "Project workspace interview"));
+            console.log(renderBrandBanner("LongTable", "Project workspace interview"));
             console.log("");
-            console.log(renderSectionCard("Long Table Project Start", [
+            console.log(renderSectionCard("LongTable Project Start", [
                 "We will create a project workspace and a session memory seed for today's work.",
-                "At the end, Long Table will tell you exactly which directory to open in Codex."
+                "At the end, LongTable will tell you exactly which directory to open in Codex."
             ]));
             console.log("");
         }
@@ -551,7 +575,7 @@ async function collectProjectInterview(setup, args) {
         const suggestedPath = resolveInteractiveProjectPath(suggestedParentDir, projectName);
         const projectPath = (typeof args.path === "string" && args.path.trim()
             ? normalizeUserPath(args.path.trim())
-            : resolveInteractiveProjectPath((await promptText(rl, renderQuestionHeader(2, 6, "Project interview", `Which parent directory should contain this project?\nLong Table will create this folder:\n${suggestedPath}`), true)), projectName));
+            : resolveInteractiveProjectPath((await promptText(rl, renderQuestionHeader(2, 6, "Project interview", `Which parent directory should contain this project?\nLongTable will create this folder:\n${suggestedPath}`), true)), projectName));
         const currentGoal = (typeof args.goal === "string" && args.goal.trim()) ||
             (await promptText(rl, renderQuestionHeader(3, 6, "Current session", "What are you trying to accomplish in this session?"), true));
         const currentBlocker = (typeof args.blocker === "string" && args.blocker.trim()) ||
@@ -564,7 +588,7 @@ async function collectProjectInterview(setup, args) {
                 {
                     id: "synthesis_only",
                     label: "Synthesis only",
-                    description: "Show one Long Table answer unless I ask for more."
+                    description: "Show one LongTable answer unless I ask for more."
                 },
                 {
                     id: "show_on_conflict",
@@ -685,7 +709,7 @@ async function runInit(args) {
         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.");
-        console.log("- Suggested next action: create a project workspace and let Long Table interview the current session.");
+        console.log("- Suggested next action: create a project workspace and let LongTable interview the current session.");
     }
 }
 async function runShow(args) {
@@ -743,7 +767,7 @@ async function runCodexPersistInit(args) {
         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.");
-        console.log("- Suggested next action: create a project workspace and let Long Table interview the current session.");
+        console.log("- Suggested next action: create a project workspace and let LongTable interview the current session.");
     }
 }
 async function resolvePrompt(prompt) {
@@ -755,7 +779,7 @@ async function resolvePrompt(prompt) {
     }
     const rl = createInterface({ input, output });
     try {
-        return (await rl.question("What should Long Table help with?\n> ")).trim();
+        return (await rl.question("What should LongTable help with?\n> ")).trim();
     }
     finally {
         rl.close();
@@ -818,7 +842,7 @@ async function buildProjectAwarePrompt(prompt, workingDirectory) {
         return { prompt, projectContextFound: false };
     }
     const lines = [
-        "Long Table project context",
+        "LongTable project context",
         `project: ${context.project.projectName}`,
         `current session goal: ${context.session.currentGoal}`,
         ...(context.session.currentBlocker ? [`current blocker: ${context.session.currentBlocker}`] : []),
@@ -912,8 +936,8 @@ async function runRoles(args) {
         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("LongTable roles");
+    console.log("These are perspectives LongTable can consult when relevant.");
     console.log("Inside Codex, explicit forms like `lt editor: ...` and `lt methods: ...` are stronger than plain natural language.");
     console.log("");
     for (const persona of payload) {
@@ -927,9 +951,10 @@ async function runStart(args) {
     const setupPath = typeof args.setup === "string" ? args.setup : undefined;
     const existingSetup = await loadOptionalSetup(setupPath);
     if (!existingSetup) {
-        throw new Error("Long Table global setup is missing. Run `longtable init --flow interview` first.");
+        throw new Error("LongTable global setup is missing. Run `longtable init --flow interview` first.");
     }
     const interview = await collectProjectInterview(existingSetup, args);
+    await verifyWritableWorkspaceParent(interview.projectPath);
     const context = await createOrUpdateProjectWorkspace({
         projectName: interview.projectName,
         projectPath: interview.projectPath,
@@ -943,8 +968,12 @@ async function runStart(args) {
         console.log(JSON.stringify({
             project: context.project,
             session: context.session,
-            projectFilePath: context.projectFilePath,
-            sessionFilePath: context.sessionFilePath
+            files: {
+                project: context.projectFilePath,
+                session: context.sessionFilePath,
+                state: context.stateFilePath,
+                current: context.currentFilePath
+            }
         }, null, 2));
         return;
     }
@@ -954,7 +983,7 @@ async function runStart(args) {
         `1. cd "${context.project.projectPath}"`,
         "2. run `codex` in that directory",
         "3. begin with your current goal in natural language",
-        "4. if you return later, read `START-HERE.md`, `NEXT-STEPS.md`, or run `longtable resume`",
+        "4. if you return later, open `CURRENT.md` or run `longtable resume`",
         "",
         `Suggested first message: ${context.session.currentBlocker ? `"I want to work on ${context.session.currentGoal}. My current blocker is ${context.session.currentBlocker}."` : `"I want to work on ${context.session.currentGoal}."`}`,
         "",
@@ -965,22 +994,24 @@ async function runResume(args) {
     const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
     const context = await loadProjectContextFromDirectory(workingDirectory);
     if (!context) {
-        throw new Error("No Long Table project workspace was found here. Run `longtable start` first or pass --cwd.");
+        throw new Error("No LongTable project workspace was found here. Run `longtable start` first or pass --cwd.");
     }
+    await syncCurrentWorkspaceView(context);
     const payload = {
         project: context.project,
         session: context.session,
         files: {
-            startHere: resolve(context.project.projectPath, "START-HERE.md"),
-            nextSteps: resolve(context.project.projectPath, "NEXT-STEPS.md"),
-            sessionSnapshot: resolve(context.project.projectPath, "SESSION-SNAPSHOT.md")
+            current: resolve(context.project.projectPath, "CURRENT.md"),
+            project: context.projectFilePath,
+            session: context.sessionFilePath,
+            state: context.stateFilePath
         }
     };
     if (args.json === true) {
         console.log(JSON.stringify(payload, null, 2));
         return;
     }
-    console.log(renderSectionCard("Long Table Resume", [
+    console.log(renderSectionCard("LongTable Resume", [
         `Project: ${context.project.projectName}`,
         `Path: ${context.project.projectPath}`,
         `Current goal: ${context.session.currentGoal}`,
@@ -988,19 +1019,17 @@ async function runResume(args) {
         `Requested perspectives: ${context.session.requestedPerspectives.length > 0 ? context.session.requestedPerspectives.join(", ") : "auto"}`,
         `Disagreement: ${context.session.disagreementPreference}`,
         "",
-        "Resume files:",
-        `- ${payload.files.startHere}`,
-        `- ${payload.files.nextSteps}`,
-        `- ${payload.files.sessionSnapshot}`,
+        "Current file:",
+        `- ${payload.files.current}`,
         "",
-        `Suggested restart message: ${context.session.currentBlocker ? `"I want to continue ${context.session.currentGoal}. The unresolved blocker is ${context.session.currentBlocker}."` : `"I want to continue ${context.session.currentGoal}."`}`
+        `Suggested restart message: "${context.session.resumeHint ?? (context.session.currentBlocker ? `I want to continue ${context.session.currentGoal}. The unresolved blocker is ${context.session.currentBlocker}.` : `I want to continue ${context.session.currentGoal}.`)}"`
     ]));
 }
 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(`Installed ${installed.length} LongTable 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}`);
@@ -1013,7 +1042,7 @@ async function runCodexSubcommand(subcommand, args) {
     }
     if (subcommand === "remove-prompts") {
         const removed = await removeCodexPromptAliases(customDir);
-        console.log(`Removed ${removed.length} Long Table prompt aliases from ${resolveCodexPromptsDir(customDir)}`);
+        console.log(`Removed ${removed.length} LongTable prompt aliases from ${resolveCodexPromptsDir(customDir)}`);
         return;
     }
     if (subcommand === "status") {
@@ -1032,7 +1061,7 @@ async function runCodexSubcommand(subcommand, args) {
             console.log(JSON.stringify(status, null, 2));
             return;
         }
-        console.log("Long Table Codex status");
+        console.log("LongTable 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}`);
@@ -1101,7 +1130,9 @@ main().catch((error) => {
     if (message === "Setup cancelled.") {
         exit(1);
     }
-    console.error("");
-    console.error(usage());
+    if (message.startsWith("Unknown command:") || message.startsWith("Invalid ")) {
+        console.error("");
+        console.error(usage());
+    }
     exit(1);
 });

package/dist/persona-router.d.ts

@@ -1,5 +1,5 @@
 import { type CanonicalPersona } from "./personas.js";
-import type { InteractionMode } from "@diverga/core";
+import type { InteractionMode } from "@longtable/core";
 export type OutputLanguage = "ko" | "en";
 export interface PersonaRoutingResult {
     outputLanguage: OutputLanguage;

package/dist/persona-router.js

@@ -118,8 +118,8 @@ export function renderDisclosure(roles, language) {
     }
     const labels = roles.map((role) => getPersonaDefinition(role).label);
     return language === "ko"
-        ? `Long Table consulted: ${labels.join(", ")}`
-        : `Long Table consulted: ${labels.join(", ")}`;
+        ? `LongTable consulted: ${labels.join(", ")}`
+        : `LongTable consulted: ${labels.join(", ")}`;
 }
 export function buildPersonaGuidance(options) {
     const directive = parseInvocationDirective(options.prompt);
@@ -129,8 +129,8 @@ export function buildPersonaGuidance(options) {
     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)}`);
+        ? `LongTable mode: ${options.mode[0].toUpperCase()}${options.mode.slice(1)}`
+        : `LongTable mode: ${options.mode[0].toUpperCase()}${options.mode.slice(1)}`);
     if (disclosure) {
         lines.push(disclosure);
     }
@@ -141,8 +141,8 @@ export function buildPersonaGuidance(options) {
     }
     if (options.panel || directive.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.");
+            ? "Return format: 1) LongTable synthesis 2) panel opinions by role 3) decision prompt to the researcher."
+            : "Return format: 1) LongTable synthesis 2) panel opinions by role 3) decision prompt to the researcher.");
     }
     if (options.showConflicts || directive.showConflicts) {
         lines.push(routing.outputLanguage === "ko"

package/dist/project-session.d.ts

@@ -1,11 +1,13 @@
-import type { SetupPersistedOutput } from "@diverga/setup";
+import type { SetupPersistedOutput } from "@longtable/setup";
 export type ProjectDisagreementPreference = "synthesis_only" | "show_on_conflict" | "always_visible";
 export interface LongTableProjectRecord {
     schemaVersion: 1;
-    product: "Long Table";
+    product: "LongTable";
     projectName: string;
     projectPath: string;
     createdAt: string;
+    contractVersion?: "workspace-v2";
+    locale?: string;
     globalSetupSummary: {
         field: string;
         careerStage: string;
@@ -20,20 +22,29 @@ export interface LongTableSessionRecord {
     schemaVersion: 1;
     id: string;
     createdAt: string;
+    lastUpdatedAt?: string;
     projectName: string;
     projectPath: string;
     currentGoal: string;
     currentBlocker?: string;
+    nextAction?: string;
+    openQuestions?: string[];
     requestedPerspectives: string[];
     disagreementPreference: ProjectDisagreementPreference;
+    activeModes?: string[];
+    resumeHint?: string;
+    locale?: string;
 }
 export interface LongTableProjectContext {
     project: LongTableProjectRecord;
     session: LongTableSessionRecord;
     projectFilePath: string;
     sessionFilePath: string;
+    stateFilePath: string;
+    currentFilePath: string;
     metaDir: string;
 }
+export declare function syncCurrentWorkspaceView(context: LongTableProjectContext): Promise<string>;
 export declare function createOrUpdateProjectWorkspace(options: {
     projectName: string;
     projectPath: string;

package/dist/project-session.js

@@ -1,7 +1,10 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
+import { execSync } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
-import { createEmptyResearchState } from "@diverga/memory";
+import { createEmptyResearchState } from "@longtable/memory";
+const CURRENT_FILE_NAME = "CURRENT.md";
+const LEGACY_ROOT_FILES = ["LONGTABLE.md", "START-HERE.md", "NEXT-STEPS.md", "SESSION-SNAPSHOT.md"];
 function nowIso() {
     return new Date().toISOString();
 }
@@ -16,160 +19,168 @@ function slugify(input) {
 function resolveMetaDir(projectPath) {
     return join(projectPath, ".longtable");
 }
-function buildWorkspaceGuide(project, session) {
-    const lines = [
-        "# Long Table Workspace",
-        "",
-        "This directory is a Long Table research workspace.",
-        "",
-        "## Current project",
-        `- Project: ${project.projectName}`,
-        `- Goal right now: ${session.currentGoal}`,
-        ...(session.currentBlocker ? [`- Current blocker: ${session.currentBlocker}`] : []),
-        `- Disagreement visibility: ${session.disagreementPreference}`,
-        `- Requested perspectives: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
-        "",
-        "## How Codex should behave here",
-        "- Treat this as a researcher-facing Long Table session, not a generic coding task.",
-        "- Ask clarifying or tension questions before closing too early.",
-        "- If you foreground specific roles, disclose them with `Long Table consulted: ...`.",
-        "- Keep one accountable synthesis, but keep disagreement visible by default when it matters.",
-        "- For factual, current, or external claims, attach source links or local file references whenever possible.",
-        "- If you cannot source a statement, label it as an inference or estimate.",
-        "- Do not expose internal tool logs or process commentary in researcher-facing answers.",
-        "",
-        "## Session files",
-        "- `.longtable/project.json` contains project-level metadata.",
-        "- `.longtable/current-session.json` contains the current session goal and blocker."
-    ];
-    return lines.join("\n");
+function resolveStateFilePath(projectPath) {
+    return join(resolveMetaDir(projectPath), "state.json");
 }
-function buildStartHereGuide(project, session) {
-    const lines = [
-        "# Start Here",
-        "",
-        `Project: ${project.projectName}`,
-        "",
-        "This workspace was created by Long Table for a single research project.",
-        "",
-        "## What to do now",
-        "1. Open Codex in this directory.",
-        "2. Start with your current goal, not a shell command.",
-        "3. Let Long Table keep disagreement visible when it matters.",
-        "4. If you ask for factual or current external information, expect sources or an explicit inference label.",
-        "",
-        "## Suggested first message",
-        session.currentBlocker
-            ? `"I want to work on ${session.currentGoal}. My current blocker is: ${session.currentBlocker}."`
-            : `"I want to work on ${session.currentGoal}."`,
-        "",
-        "## Explicit Long Table invocation inside Codex",
-        "- `lt explore: <question>`",
-        "- `lt review: <claim or plan>`",
-        "- `lt panel: <claim or plan>`",
-        "- `lt editor: <draft or positioning question>`",
-        "- `lt reviewer: <claim or section>`",
-        "- `lt methods: <design, measure, or analysis plan>`",
-        "- `lt commit: <decision that needs commitment>`",
-        "",
-        "## What Long Table already knows in this directory",
-        `- Current goal: ${session.currentGoal}`,
-        ...(session.currentBlocker ? [`- Current blocker: ${session.currentBlocker}`] : []),
-        `- Requested perspectives: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
-        `- Disagreement visibility: ${session.disagreementPreference}`,
-        "",
-        "## Files",
-        "- `AGENTS.md` tells Codex how to behave in this workspace.",
-        "- `.longtable/current-session.json` stores the current session goal and blocker.",
-        "- `.longtable/project.json` stores the project-level record.",
-        "- `NEXT-STEPS.md` stores the immediate next actions.",
-        "- `SESSION-SNAPSHOT.md` stores the short resume snapshot."
-    ];
-    return lines.join("\n");
+function resolveCurrentFilePath(projectPath) {
+    return join(projectPath, CURRENT_FILE_NAME);
 }
-function buildNextStepsGuide(project, session) {
-    const firstQuestion = session.currentBlocker
+function normalizeLocale(locale) {
+    if ((locale ?? "").toLowerCase().startsWith("ko")) {
+        return "ko";
+    }
+    return "en";
+}
+function resolveUserLocale() {
+    const envLocale = process.env.LC_ALL ??
+        process.env.LC_MESSAGES ??
+        process.env.LANG ??
+        "";
+    if (envLocale && !["c", "c.utf-8", "posix"].includes(envLocale.toLowerCase())) {
+        return normalizeLocale(envLocale);
+    }
+    if (process.platform === "darwin") {
+        try {
+            const appleLocale = execSync("defaults read -g AppleLocale", { encoding: "utf8" }).trim();
+            if (appleLocale) {
+                return normalizeLocale(appleLocale);
+            }
+        }
+        catch {
+            // Ignore and fall back to Intl below.
+        }
+    }
+    return normalizeLocale(Intl.DateTimeFormat().resolvedOptions().locale);
+}
+function buildFirstQuestion(session) {
+    return session.currentBlocker
         ? `What would reduce the uncertainty around "${session.currentBlocker}" first?`
         : `What is the first concrete question that would move "${session.currentGoal}" forward?`;
+}
+function buildOpenQuestions(session) {
+    const firstQuestion = buildFirstQuestion(session);
+    return session.currentBlocker
+        ? [
+            firstQuestion,
+            `What evidence would let you decide whether "${session.currentBlocker}" is a knowledge gap, a coding rule gap, or a data gap?`
+        ]
+        : [
+            firstQuestion,
+            `What would count as a good first outcome for "${session.currentGoal}" in this session?`
+        ];
+}
+function buildNextAction(session) {
+    return session.currentBlocker
+        ? `Open with the blocker, then ask LongTable to surface the first high-leverage uncertainty around "${session.currentBlocker}".`
+        : "Open with your current goal in one sentence, then ask LongTable for the first concrete research move.";
+}
+function buildResumeHint(session) {
+    return session.currentBlocker
+        ? `I want to continue ${session.currentGoal}. The unresolved blocker is ${session.currentBlocker}.`
+        : `I want to continue ${session.currentGoal}.`;
+}
+function buildCurrentGuide(project, session) {
+    const locale = normalizeLocale(session.locale ?? project.locale);
+    const openQuestions = session.openQuestions && session.openQuestions.length > 0
+        ? session.openQuestions
+        : buildOpenQuestions(session);
+    const nextAction = session.nextAction ?? buildNextAction(session);
+    const resumeHint = session.resumeHint ?? buildResumeHint(session);
+    const suggestedPrompt = `lt explore: ${openQuestions[0]}`;
+    if (locale === "ko") {
+        return [
+            "# CURRENT",
+            "",
+            `Project: ${project.projectName}`,
+            "",
+            "이 파일은 `.longtable/current-session.json`과 `.longtable/state.json`에서 재생성되는 현재 작업 뷰입니다.",
+            "",
+            "## 지금 초점",
+            `- 현재 목표: ${session.currentGoal}`,
+            ...(session.currentBlocker ? [`- 현재 blocker: ${session.currentBlocker}`] : []),
+            `- 다음 액션: ${nextAction}`,
+            `- 관점: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
+            `- disagreement: ${session.disagreementPreference}`,
+            "",
+            "## 열린 질문",
+            ...openQuestions.map((question) => `- ${question}`),
+            "",
+            "## 다시 시작 문장",
+            `- "${resumeHint}"`,
+            "",
+            "## 빠른 시작",
+            "- 이 디렉토리에서 `codex`를 엽니다.",
+            `- 첫 메시지는 보통 \`${suggestedPrompt}\` 정도면 충분합니다.`,
+            "",
+            "## 증거 규칙",
+            "- 외부 사실이나 현재 정보는 source를 붙이거나 inference로 낮춥니다."
+        ].join("\n");
+    }
     return [
-        "# Next Steps",
+        "# CURRENT",
         "",
         `Project: ${project.projectName}`,
         "",
-        "## Immediate actions",
-        "1. Open Codex in this directory.",
-        "2. State your current goal in one sentence.",
-        "3. Ask Long Table to surface disagreement before closing on a plan.",
+        "This file is regenerated from `.longtable/current-session.json` and `.longtable/state.json`.",
         "",
-        "## Suggested openings",
-        `- ${session.currentBlocker ? `"I want to work on ${session.currentGoal}. My current blocker is ${session.currentBlocker}."` : `"I want to work on ${session.currentGoal}."`}`,
-        `- "lt explore: ${firstQuestion}"`,
-        `- "lt panel: Show me the strongest disagreement before I commit."`,
-        "",
-        "## If you come back later",
-        "- Read `SESSION-SNAPSHOT.md` first.",
-        "- Continue from the unresolved blocker rather than restating the whole project.",
+        "## Focus Now",
+        `- Current goal: ${session.currentGoal}`,
+        ...(session.currentBlocker ? [`- Current blocker: ${session.currentBlocker}`] : []),
+        `- Next action: ${nextAction}`,
+        `- Perspectives: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
+        `- Disagreement: ${session.disagreementPreference}`,
         "",
-        "## Evidence reminder",
-        "- For factual or current external claims, Long Table should provide a source link or label the statement as inference."
-    ].join("\n");
-}
-function buildSessionSnapshot(project, session) {
-    return [
-        "# Session Snapshot",
+        "## Open Questions",
+        ...openQuestions.map((question) => `- ${question}`),
         "",
-        `Project: ${project.projectName}`,
-        `Current goal: ${session.currentGoal}`,
-        ...(session.currentBlocker ? [`Current blocker: ${session.currentBlocker}`] : []),
-        `Requested perspectives: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
-        `Disagreement visibility: ${session.disagreementPreference}`,
+        "## Restart Prompt",
+        `- "${resumeHint}"`,
         "",
-        "## Resume prompt",
-        session.currentBlocker
-            ? `"I want to continue ${session.currentGoal}. The unresolved blocker is ${session.currentBlocker}."`
-            : `"I want to continue ${session.currentGoal}."`,
+        "## Quick Start",
+        "- Open `codex` in this directory.",
+        `- A good first message is usually \`${suggestedPrompt}\`.`,
         "",
-        "## Notes",
-        "- This is a short orientation artifact, not a full transcript.",
-        "- If factual or external claims matter, Long Table should cite sources or mark them as inference."
+        "## Evidence Rule",
+        "- External or current claims should carry a source link or be labeled as inference."
     ].join("\n");
 }
 function buildProjectAgentsMd(project, session) {
     return [
         "# AGENTS.md",
         "",
-        "This directory is a Long Table research workspace.",
+        "This directory is a LongTable research workspace.",
         "",
-        "## Purpose",
-        `- Project name: ${project.projectName}`,
-        `- Current goal: ${session.currentGoal}`,
-        ...(session.currentBlocker ? [`- Current blocker: ${session.currentBlocker}`] : []),
-        `- Requested perspectives: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
-        `- Disagreement visibility: ${session.disagreementPreference}`,
-        "",
-        "## Research-facing behavior",
+        "## Runtime Contract",
         "- Treat researcher interaction as the primary task.",
-        "- If the user message starts with `lt `, `longtable `, `long table `, or `롱테이블 ` followed by a directive and `:`, treat it as an explicit Long Table invocation.",
+        "- Read `.longtable/current-session.json` before giving substantial guidance.",
+        "- Use `.longtable/project.json` as stable project context.",
+        "- Use `.longtable/state.json` as layered working memory.",
+        "- Prefer `currentGoal`, `currentBlocker`, `nextAction`, and `openQuestions` over generic assumptions.",
+        "- Treat `AGENTS.md` as runtime guidance, not as the researcher-facing resume artifact.",
+        "",
+        "## Invocation Rules",
+        "- If the user message starts with `lt `, `longtable `, `long table `, or `롱테이블 ` followed by a directive and `:`, treat it as an explicit LongTable invocation.",
         "- Supported explicit directives are: explore, review, critique, draft, commit, panel, status, editor, reviewer, methods, theory, measurement, ethics, voice, venue.",
-        "- For explicit Long Table invocations, do not begin by scanning the workspace. Use the current session files first and answer as Long Table immediately.",
-        "- For general research requests in this workspace, prefer Long Table behavior before generic coding behavior.",
+        "- For explicit LongTable invocations, do not begin by scanning the workspace. Use the current session files first and answer as LongTable immediately.",
+        "- For general research requests in this workspace, prefer LongTable behavior before generic coding behavior.",
+        "",
+        "## Research Behavior",
         "- Begin exploratory work with clarifying or tension questions before recommending a direction.",
-        "- If you foreground role perspectives, disclose them with `Long Table consulted: ...`.",
+        "- If you foreground role perspectives, disclose them with `LongTable consulted: ...`.",
         "- Keep one accountable synthesis, but do not hide meaningful disagreement.",
-        "- For factual, current, or external claims, provide source links or file references when possible.",
-        "- If a statement cannot be sourced, label it as an inference or estimate instead of presenting it as a fact.",
         ...(session.disagreementPreference === "always_visible"
-            ? ["- In this workspace, panel disagreement should be visible by default rather than hidden behind a single synthesis."]
+            ? ["- Panel disagreement should be visible by default rather than hidden behind a single synthesis."]
             : []),
+        "- For factual, current, or external claims, provide source links or file references when possible.",
+        "- If a statement cannot be sourced, label it as an inference or estimate instead of presenting it as a fact.",
         "- Do not expose internal tool logs, file-search traces, or process commentary in the researcher-facing answer.",
         "",
-        "## Session memory",
-        "- Read `.longtable/current-session.json` before giving substantial guidance.",
-        "- Use `.longtable/project.json` as the project-level context.",
-        "- Prefer the current goal and blocker over generic assumptions.",
-        "- Do not recursively search unrelated files unless the researcher explicitly asks for file analysis or code changes.",
-        "",
         "## Scope",
+        `- Project: ${project.projectName}`,
+        `- Current goal: ${session.currentGoal}`,
+        ...(session.currentBlocker ? [`- Current blocker: ${session.currentBlocker}`] : []),
+        `- Requested perspectives: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
+        `- Disagreement visibility: ${session.disagreementPreference}`,
         "- These instructions apply to this directory and its children."
     ].join("\n");
 }
@@ -180,12 +191,18 @@ function buildStateSeed(project, session, setup) {
         careerStage: setup.profileSeed.careerStage,
         experienceLevel: setup.profileSeed.experienceLevel,
         projectName: project.projectName,
-        currentGoal: session.currentGoal,
         disagreementPreference: session.disagreementPreference,
         requestedPerspectives: session.requestedPerspectives
     };
+    state.workingState = {
+        currentGoal: session.currentGoal,
+        ...(session.currentBlocker ? { currentBlocker: session.currentBlocker } : {}),
+        ...(session.nextAction ? { nextAction: session.nextAction } : {}),
+        openQuestions: session.openQuestions ?? [],
+        activeModes: session.activeModes ?? [],
+        ...(session.resumeHint ? { resumeHint: session.resumeHint } : {})
+    };
     if (session.currentBlocker) {
-        state.explicitState.currentBlocker = session.currentBlocker;
         state.openTensions.push(session.currentBlocker);
     }
     if (setup.profileSeed.humanAuthorshipSignal) {
@@ -213,24 +230,42 @@ function buildStateSeed(project, session, setup) {
     }
     return JSON.stringify(state, null, 2);
 }
+async function removeLegacyRootFiles(projectPath) {
+    await Promise.all(LEGACY_ROOT_FILES.map((file) => rm(join(projectPath, file), { force: true })));
+}
+export async function syncCurrentWorkspaceView(context) {
+    const body = buildCurrentGuide(context.project, context.session);
+    await writeFile(context.currentFilePath, body, "utf8");
+    return context.currentFilePath;
+}
 export async function createOrUpdateProjectWorkspace(options) {
     const projectPath = resolve(options.projectPath);
     const metaDir = resolveMetaDir(projectPath);
     const sessionsDir = join(metaDir, "sessions");
     const projectFilePath = join(metaDir, "project.json");
     const sessionFilePath = join(metaDir, "current-session.json");
+    const stateFilePath = resolveStateFilePath(projectPath);
+    const currentFilePath = resolveCurrentFilePath(projectPath);
     const sessionId = slugify(`${options.projectName}-${Date.now()}`);
+    const locale = resolveUserLocale();
+    const timestamp = nowIso();
     await mkdir(projectPath, { recursive: true });
     await mkdir(metaDir, { recursive: true });
     await mkdir(sessionsDir, { recursive: true });
     const project = existsSync(projectFilePath)
-        ? JSON.parse(await readFile(projectFilePath, "utf8"))
+        ? {
+            ...JSON.parse(await readFile(projectFilePath, "utf8")),
+            contractVersion: "workspace-v2",
+            locale
+        }
         : {
             schemaVersion: 1,
-            product: "Long Table",
+            product: "LongTable",
             projectName: options.projectName,
             projectPath,
-            createdAt: nowIso(),
+            createdAt: timestamp,
+            contractVersion: "workspace-v2",
+            locale,
             globalSetupSummary: {
                 field: options.setup.profileSeed.field,
                 careerStage: options.setup.profileSeed.careerStage,
@@ -250,30 +285,67 @@ export async function createOrUpdateProjectWorkspace(options) {
     const session = {
         schemaVersion: 1,
         id: sessionId,
-        createdAt: nowIso(),
+        createdAt: timestamp,
+        lastUpdatedAt: timestamp,
         projectName: project.projectName,
         projectPath,
         currentGoal: options.currentGoal,
         ...(options.currentBlocker ? { currentBlocker: options.currentBlocker } : {}),
+        nextAction: buildNextAction({
+            schemaVersion: 1,
+            id: sessionId,
+            createdAt: timestamp,
+            projectName: project.projectName,
+            projectPath,
+            currentGoal: options.currentGoal,
+            ...(options.currentBlocker ? { currentBlocker: options.currentBlocker } : {}),
+            requestedPerspectives: options.requestedPerspectives,
+            disagreementPreference: options.disagreementPreference
+        }),
+        openQuestions: buildOpenQuestions({
+            schemaVersion: 1,
+            id: sessionId,
+            createdAt: timestamp,
+            projectName: project.projectName,
+            projectPath,
+            currentGoal: options.currentGoal,
+            ...(options.currentBlocker ? { currentBlocker: options.currentBlocker } : {}),
+            requestedPerspectives: options.requestedPerspectives,
+            disagreementPreference: options.disagreementPreference
+        }),
         requestedPerspectives: options.requestedPerspectives,
-        disagreementPreference: options.disagreementPreference
+        disagreementPreference: options.disagreementPreference,
+        activeModes: ["explore"],
+        resumeHint: buildResumeHint({
+            schemaVersion: 1,
+            id: sessionId,
+            createdAt: timestamp,
+            projectName: project.projectName,
+            projectPath,
+            currentGoal: options.currentGoal,
+            ...(options.currentBlocker ? { currentBlocker: options.currentBlocker } : {}),
+            requestedPerspectives: options.requestedPerspectives,
+            disagreementPreference: options.disagreementPreference
+        }),
+        locale
     };
-    await writeFile(projectFilePath, JSON.stringify(project, null, 2), "utf8");
-    await writeFile(sessionFilePath, JSON.stringify(session, null, 2), "utf8");
-    await writeFile(join(sessionsDir, `${sessionId}.json`), JSON.stringify(session, null, 2), "utf8");
-    await writeFile(join(metaDir, "state.json"), buildStateSeed(project, session, options.setup), "utf8");
-    await writeFile(join(projectPath, "LONGTABLE.md"), buildWorkspaceGuide(project, session), "utf8");
-    await writeFile(join(projectPath, "START-HERE.md"), buildStartHereGuide(project, session), "utf8");
-    await writeFile(join(projectPath, "NEXT-STEPS.md"), buildNextStepsGuide(project, session), "utf8");
-    await writeFile(join(projectPath, "SESSION-SNAPSHOT.md"), buildSessionSnapshot(project, session), "utf8");
-    await writeFile(join(projectPath, "AGENTS.md"), buildProjectAgentsMd(project, session), "utf8");
-    return {
+    const context = {
         project,
         session,
         projectFilePath,
         sessionFilePath,
+        stateFilePath,
+        currentFilePath,
         metaDir
     };
+    await writeFile(projectFilePath, JSON.stringify(project, null, 2), "utf8");
+    await writeFile(sessionFilePath, JSON.stringify(session, null, 2), "utf8");
+    await writeFile(join(sessionsDir, `${sessionId}.json`), JSON.stringify(session, null, 2), "utf8");
+    await writeFile(stateFilePath, buildStateSeed(project, session, options.setup), "utf8");
+    await writeFile(join(projectPath, "AGENTS.md"), buildProjectAgentsMd(project, session), "utf8");
+    await syncCurrentWorkspaceView(context);
+    await removeLegacyRootFiles(projectPath);
+    return context;
 }
 export async function loadProjectContextFromDirectory(startPath) {
     let current = resolve(startPath);
@@ -282,11 +354,22 @@ export async function loadProjectContextFromDirectory(startPath) {
         const projectFilePath = join(metaDir, "project.json");
         const sessionFilePath = join(metaDir, "current-session.json");
         if (existsSync(projectFilePath) && existsSync(sessionFilePath)) {
+            const project = JSON.parse(await readFile(projectFilePath, "utf8"));
+            const session = JSON.parse(await readFile(sessionFilePath, "utf8"));
             return {
-                project: JSON.parse(await readFile(projectFilePath, "utf8")),
-                session: JSON.parse(await readFile(sessionFilePath, "utf8")),
+                project,
+                session: {
+                    ...session,
+                    locale: session.locale ?? project.locale ?? resolveUserLocale(),
+                    openQuestions: session.openQuestions ?? buildOpenQuestions(session),
+                    nextAction: session.nextAction ?? buildNextAction(session),
+                    resumeHint: session.resumeHint ?? buildResumeHint(session),
+                    activeModes: session.activeModes ?? ["explore"]
+                },
                 projectFilePath,
                 sessionFilePath,
+                stateFilePath: resolveStateFilePath(project.projectPath),
+                currentFilePath: resolveCurrentFilePath(project.projectPath),
                 metaDir
             };
         }
@@ -300,7 +383,7 @@ export async function loadProjectContextFromDirectory(startPath) {
 export function renderProjectWorkspaceSummary(context) {
     return [
         "┌──────────────────────────────────────────────┐",
-        "│ Long Table Project Workspace               │",
+        "│ LongTable Project Workspace               │",
         "└──────────────────────────────────────────────┘",
         `Project: ${context.project.projectName}`,
         `Path: ${context.project.projectPath}`,
@@ -312,9 +395,8 @@ export function renderProjectWorkspaceSummary(context) {
         "Created files:",
         `- ${context.projectFilePath}`,
         `- ${context.sessionFilePath}`,
-        `- ${join(context.project.projectPath, "START-HERE.md")}`,
-        `- ${join(context.project.projectPath, "NEXT-STEPS.md")}`,
-        `- ${join(context.project.projectPath, "SESSION-SNAPSHOT.md")}`,
+        `- ${context.stateFilePath}`,
+        `- ${context.currentFilePath}`,
         `- ${join(context.project.projectPath, "AGENTS.md")}`
     ].join("\n");
 }

package/dist/prompt-aliases.js

@@ -9,26 +9,26 @@ function promptSpec() {
     return [
         {
             name: "longtable",
-            description: "Single-entry Long Table router for research conversations",
+            description: "Single-entry LongTable router for research conversations",
             argumentHint: "<natural language research request>",
             body: [
-                "You are Long Table.",
+                "You are LongTable.",
                 "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.",
+                "Always begin with `LongTable mode: <Mode>`.",
+                "Always disclose consulted roles with `LongTable 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.",
+                "In panel mode, return 1) LongTable 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",
+            description: "Run LongTable researcher onboarding inside Codex",
             argumentHint: "[project context or current uncertainty]",
             body: [
-                "You are Long Table onboarding inside Codex.",
+                "You are LongTable 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.",
@@ -45,11 +45,11 @@ function promptSpec() {
         },
         {
             name: "longtable-explore",
-            description: "Long Table explore mode for open research questions",
+            description: "LongTable explore mode for open research questions",
             argumentHint: "<topic or research problem>",
             body: [
-                "You are Long Table in explore mode.",
-                "Always begin with `Long Table mode: Explore`.",
+                "You are LongTable in explore mode.",
+                "Always begin with `LongTable mode: Explore`.",
                 "Ask at least two clarifying or tension questions before any recommendation.",
                 "Keep unresolved tensions visible.",
                 "Do not rush to synthesis.",
@@ -59,11 +59,11 @@ function promptSpec() {
         },
         {
             name: "longtable-review",
-            description: "Long Table review mode for critical evaluation",
+            description: "LongTable review mode for critical evaluation",
             argumentHint: "<claim, paragraph, design, or plan>",
             body: [
-                "You are Long Table in review mode.",
-                "Always begin with `Long Table mode: Review`.",
+                "You are LongTable in review mode.",
+                "Always begin with `LongTable 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."
@@ -71,12 +71,12 @@ function promptSpec() {
         },
         {
             name: "longtable-panel",
-            description: "Long Table panel mode with visible role disagreement",
+            description: "LongTable panel mode with visible role disagreement",
             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.",
+                "You are LongTable in panel mode.",
+                "Always begin with `LongTable mode: Panel`.",
+                "Return 1) a LongTable 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."
@@ -84,10 +84,10 @@ function promptSpec() {
         },
         {
             name: "longtable-editor",
-            description: "Long Table editor view",
+            description: "LongTable editor view",
             argumentHint: "<claim, draft, or paper positioning>",
             body: [
-                "You are Long Table with the Journal Editor role foregrounded.",
+                "You are LongTable 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."
@@ -95,10 +95,10 @@ function promptSpec() {
         },
         {
             name: "longtable-reviewer",
-            description: "Long Table reviewer view",
+            description: "LongTable reviewer view",
             argumentHint: "<claim, method, or manuscript section>",
             body: [
-                "You are Long Table with the Reviewer role foregrounded.",
+                "You are LongTable 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."
@@ -106,10 +106,10 @@ function promptSpec() {
         },
         {
             name: "longtable-methods",
-            description: "Long Table methods-critic view",
+            description: "LongTable methods-critic view",
             argumentHint: "<study design, measure, or analysis plan>",
             body: [
-                "You are Long Table with the Methods Critic role foregrounded.",
+                "You are LongTable 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."
@@ -117,10 +117,10 @@ function promptSpec() {
         },
         {
             name: "longtable-critique",
-            description: "Long Table critique mode for stronger counterarguments",
+            description: "LongTable critique mode for stronger counterarguments",
             argumentHint: "<claim or draft to challenge>",
             body: [
-                "You are Long Table in critique mode.",
+                "You are LongTable 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."
@@ -128,10 +128,10 @@ function promptSpec() {
         },
         {
             name: "longtable-draft",
-            description: "Long Table draft mode with narrative-trace preservation",
+            description: "LongTable draft mode with narrative-trace preservation",
             argumentHint: "<draft goal or section request>",
             body: [
-                "You are Long Table in draft mode.",
+                "You are LongTable 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."
@@ -139,10 +139,10 @@ function promptSpec() {
         },
         {
             name: "longtable-commit",
-            description: "Long Table commit mode for explicit human decisions",
+            description: "LongTable commit mode for explicit human decisions",
             argumentHint: "<decision or choice that needs commitment>",
             body: [
-                "You are Long Table in commit mode.",
+                "You are LongTable 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."
@@ -150,11 +150,11 @@ function promptSpec() {
         },
         {
             name: "longtable-status",
-            description: "Inspect Long Table setup and Codex alias status",
+            description: "Inspect LongTable 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/`.",
+                "You are LongTable status mode.",
+                "Inspect whether setup and runtime artifacts appear to exist under `~/.longtable/` and whether LongTable 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."
             ]

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@longtable/cli",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "private": false,
-  "description": "Researcher-facing Long Table CLI on top of the legacy Diverga package surface",
+  "description": "Researcher-facing LongTable CLI",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -12,6 +12,9 @@
       "import": "./dist/index.js"
     }
   },
+  "bin": {
+    "longtable": "./bin/longtable"
+  },
   "directories": {
     "bin": "./bin"
   },
@@ -25,9 +28,9 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@diverga/memory": "0.1.0",
-    "@diverga/provider-codex": "0.1.1",
-    "@diverga/setup": "0.1.4"
+    "@longtable/memory": "0.1.9",
+    "@longtable/provider-codex": "0.1.9",
+    "@longtable/setup": "0.1.9"
   },
   "devDependencies": {
     "@types/node": "^22.10.1",
@@ -44,9 +47,9 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/HosungYou/Long-Table-Refactoring.git"
+    "url": "git+https://github.com/HosungYou/LongTable.git"
   },
-  "homepage": "https://github.com/HosungYou/Long-Table-Refactoring#readme",
+  "homepage": "https://github.com/HosungYou/LongTable#readme",
   "publishConfig": {
     "access": "public"
   },