@longtable/cli 0.1.5 → 0.1.7

package/README.md

@@ -54,6 +54,8 @@ longtable start
 - `.longtable/` 메모리 파일 생성
 - 프로젝트용 `AGENTS.md` 생성
 - `START-HERE.md` 생성
+- `NEXT-STEPS.md` 생성
+- `SESSION-SNAPSHOT.md` 생성
 
 을 수행합니다.
 
@@ -68,16 +70,35 @@ codex
 
 이게 현재 가장 신뢰할 수 있는 Long Table 사용 경로입니다.
 
+돌아와서 다시 이어갈 때는:
+
+```bash
+cd "<project-path>"
+longtable resume
+codex
+```
+
 ## After the project starts
 
 프로젝트 디렉토리 안에서는 보통 그냥 `codex`를 열고 자연어로 연구를 시작하면 됩니다.
 
+Codex 안에서 더 명시적으로 부르고 싶다면, 아래처럼 짧은 문법도 사용할 수 있습니다.
+
+```text
+lt explore: 연구 질문을 어디서부터 좁혀야 할지 모르겠어.
+lt review: 이 주장 어디가 약한지 봐줘.
+lt panel: 이 방향에 대한 의견 충돌도 같이 보여줘.
+lt editor: BJET 편집자 관점에서 봐줘.
+lt methods: 방법론적으로 어디가 취약한지 말해줘.
+```
+
 CLI를 계속 쓰고 싶다면 아래 명령은 보조 경로입니다.
 
 ## Advanced commands
 
 ```bash
 longtable roles
+longtable resume --cwd "<project-path>"
 longtable ask --cwd "<project-path>" --prompt "연구 질문을 어디서부터 좁혀야 할지 모르겠어."
 longtable review --cwd "<project-path>" --prompt "방법론적으로 어디가 취약한지 말해줘." --role methods_critic
 ```

package/dist/cli.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 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 { 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 { installCodexPromptAliases, listInstalledCodexPromptAliases, removeCodexPromptAliases, resolveCodexPromptsDir } from "./prompt-aliases.js";
-import { buildPersonaGuidance } from "./persona-router.js";
+import { buildPersonaGuidance, parseInvocationDirective } from "./persona-router.js";
 import { PERSONA_DEFINITIONS } from "./personas.js";
 import { createOrUpdateProjectWorkspace, loadProjectContextFromDirectory, renderProjectWorkspaceSummary } from "./project-session.js";
 const VALID_MODES = new Set([
@@ -45,6 +46,22 @@ function renderSectionCard(title, body) {
         ...body
     ].join("\n");
 }
+function renderBrandBanner(title, subtitle) {
+    const lines = [
+        style("╭──────────────────────────────────────────────╮", ANSI.cyan),
+        style(`│ ${title.padEnd(44, " ")}│`, `${ANSI.bold}${ANSI.cyan}`),
+        style("╰──────────────────────────────────────────────╯", ANSI.cyan)
+    ];
+    if (subtitle) {
+        lines.push(style(subtitle, ANSI.dim));
+    }
+    return lines.join("\n");
+}
+function renderProgressBar(current, total) {
+    const width = 10;
+    const filled = Math.max(1, Math.round((current / total) * width));
+    return `${"█".repeat(filled)}${"·".repeat(Math.max(0, width - filled))}`;
+}
 function usage() {
     return [
         "Usage:",
@@ -53,6 +70,7 @@ function usage() {
         "",
         "  longtable init [--flow quickstart|interview] [--provider codex|claude] [--field <field>] [--career-stage <stage>] [--experience novice|intermediate|advanced] [--checkpoint low|balanced|high] [--authorship-signal <text>] [--entry-mode explore|review|critique|draft|commit] [--weakest-domain theory|methodology|measurement|analysis|writing] [--panel-preference synthesis_only|show_on_conflict|always_visible] [--json] [--no-install] [--install-prompts]",
         "  longtable start [--path <dir>] [--name <project>] [--goal <text>] [--blocker <text>] [--perspectives <role[,role]>] [--disagreement synthesis_only|show_on_conflict|always_visible] [--setup <path>] [--json]",
+        "  longtable resume [--cwd <path>] [--json]",
         "  longtable roles [--json]",
         "  longtable show [--json] [--path <file>]",
         "  longtable install [--json] [--path <file>] [--runtime-path <file>]",
@@ -79,7 +97,7 @@ function parseArgs(argv) {
     const values = {};
     let subcommand = maybeSubcommand;
     const modeCommand = command && VALID_MODES.has(command);
-    const directCommand = command && ["init", "start", "roles", "show", "install", "codex", "ask"].includes(command);
+    const directCommand = command && ["init", "start", "resume", "roles", "show", "install", "codex", "ask"].includes(command);
     let startIndex = 1;
     if (modeCommand) {
         subcommand = undefined;
@@ -140,10 +158,14 @@ function renderSetupHeader(flow) {
     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 renderSectionCard(title, [subtitle]);
+    return [renderBrandBanner("Long Table", "Research workspace setup"), "", renderSectionCard(title, [subtitle])].join("\n");
 }
 function renderQuestionHeader(index, total, section, prompt) {
-    return [``, style(`[${index}/${total}] ${section}`, `${ANSI.bold}${ANSI.cyan}`), prompt].join("\n");
+    return [
+        "",
+        style(`[${index}/${total}] ${section}  ${renderProgressBar(index, total)}`, `${ANSI.bold}${ANSI.cyan}`),
+        prompt
+    ].join("\n");
 }
 function questionSection(questionId) {
     if (questionId === "field" || questionId === "careerStage" || questionId === "experienceLevel") {
@@ -174,6 +196,52 @@ function renderArrowMenu(prompt, choices, selectedIndex) {
     }
     return lines.join("\n");
 }
+function countRenderedLines(text) {
+    return text.split("\n").length;
+}
+function stripWrappingQuotes(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function expandHomePath(value) {
+    if (value === "~") {
+        return homedir();
+    }
+    if (value.startsWith("~/")) {
+        return resolve(homedir(), value.slice(2));
+    }
+    return value;
+}
+function normalizeUserPath(value) {
+    return expandHomePath(stripWrappingQuotes(value));
+}
+function projectFolderSlug(projectName) {
+    return projectName
+        .trim()
+        .replace(/[^\w가-힣]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function resolveInteractiveProjectPath(parentOrPath, projectName) {
+    const normalized = normalizeUserPath(parentOrPath);
+    const folderName = projectFolderSlug(projectName);
+    if (!normalized) {
+        return resolve(folderName);
+    }
+    try {
+        if (existsSync(normalized) && statSync(normalized).isDirectory()) {
+            return resolve(normalized, folderName);
+        }
+    }
+    catch {
+        return resolve(normalized);
+    }
+    return resolve(normalized);
+}
 async function promptChoiceByNumber(rl, prompt, choices) {
     while (true) {
         const answer = await rl.question(`${prompt}\n${renderChoices(choices)}\nSelect one number: `);
@@ -213,17 +281,19 @@ async function promptChoiceWithArrows(rl, prompt, choices) {
     }
     const previousRawMode = stream.isRaw;
     let selectedIndex = 0;
-    const renderedLineCount = choices.length + 2;
+    let lastRenderLineCount = 0;
     return await new Promise((resolve, reject) => {
         function draw(first = false) {
-            if (!first) {
-                output.write(moveCursorUp(renderedLineCount));
+            const renderedText = renderArrowMenu(prompt, choices, selectedIndex);
+            const rendered = renderedText.split("\n");
+            if (!first && lastRenderLineCount > 0) {
+                output.write(moveCursorUp(lastRenderLineCount));
             }
-            const rendered = renderArrowMenu(prompt, choices, selectedIndex).split("\n");
             for (const line of rendered) {
                 output.write(clearLine());
                 output.write(`${line}\n`);
             }
+            lastRenderLineCount = countRenderedLines(renderedText);
         }
         function cleanup() {
             stream.off("keypress", onKeypress);
@@ -287,12 +357,9 @@ async function promptMultiChoice(rl, prompt, choices) {
     const previousRawMode = stream.isRaw;
     let selectedIndex = 0;
     const selected = new Set();
-    const renderedLineCount = choices.length + 2;
+    let lastRenderLineCount = 0;
     return await new Promise((resolvePromise, reject) => {
         function draw(first = false) {
-            if (!first) {
-                output.write(moveCursorUp(renderedLineCount));
-            }
             const lines = [prompt, "Use ↑/↓, Space to toggle, and Enter to confirm."];
             for (let index = 0; index < choices.length; index += 1) {
                 const choice = choices[index];
@@ -300,10 +367,15 @@ async function promptMultiChoice(rl, prompt, choices) {
                 const marker = selected.has(choice.id) ? "[x]" : "[ ]";
                 lines.push(`${pointer} ${marker} ${choice.label} - ${choice.description}`);
             }
+            const renderedText = lines.join("\n");
+            if (!first && lastRenderLineCount > 0) {
+                output.write(moveCursorUp(lastRenderLineCount));
+            }
             for (const line of lines) {
                 output.write(clearLine());
                 output.write(`${line}\n`);
             }
+            lastRenderLineCount = countRenderedLines(renderedText);
         }
         function cleanup() {
             stream.off("keypress", onKeypress);
@@ -462,6 +534,8 @@ async function collectProjectInterview(setup, args) {
     const rl = createInterface({ input, output });
     try {
         if (needsInteractivePrompts) {
+            console.log("");
+            console.log(renderBrandBanner("Long Table", "Project workspace interview"));
             console.log("");
             console.log(renderSectionCard("Long Table Project Start", [
                 "We will create a project workspace and a session memory seed for today's work.",
@@ -471,11 +545,13 @@ async function collectProjectInterview(setup, args) {
         }
         const projectName = (typeof args.name === "string" && args.name.trim()) ||
             (await promptText(rl, renderQuestionHeader(1, 6, "Project interview", "What should this project be called?"), true));
-        const suggestedPath = typeof args.path === "string" && args.path.trim()
-            ? args.path.trim()
-            : resolve(projectName.replace(/\s+/g, "-"));
-        const projectPath = (typeof args.path === "string" && args.path.trim()) ||
-            (await promptText(rl, renderQuestionHeader(2, 6, "Project interview", `Where should this project live on your machine?\nSuggested path: ${suggestedPath}`), true));
+        const suggestedParentDir = typeof args.path === "string" && args.path.trim()
+            ? normalizeUserPath(args.path.trim())
+            : homedir();
+        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));
         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()) ||
@@ -803,7 +879,9 @@ async function runAsk(args) {
     if (!prompt) {
         throw new Error("A prompt is required.");
     }
-    const inferred = inferModeFromPrompt(prompt);
+    const directive = parseInvocationDirective(prompt);
+    const effectivePrompt = directive.cleanedPrompt;
+    const inferred = directive.mode ?? inferModeFromPrompt(effectivePrompt);
     if (inferred === "status") {
         await runCodexSubcommand("status", args);
         return;
@@ -811,9 +889,12 @@ async function runAsk(args) {
     const mode = inferred === "panel" ? "review" : inferred;
     const delegatedArgs = {
         ...args,
-        prompt
+        prompt: effectivePrompt
     };
-    if (inferred === "panel" && delegatedArgs.panel !== true) {
+    if (directive.roles.length > 0 && typeof delegatedArgs.role !== "string") {
+        delegatedArgs.role = directive.roles.join(",");
+    }
+    if ((inferred === "panel" || directive.panel) && delegatedArgs.panel !== true) {
         delegatedArgs.panel = true;
         delegatedArgs["show-conflicts"] = true;
     }
@@ -833,6 +914,7 @@ async function runRoles(args) {
     }
     console.log("Long Table roles");
     console.log("These are perspectives Long Table 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) {
         console.log(`- ${persona.label} (${persona.key})`);
@@ -872,12 +954,48 @@ 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`",
         "",
         `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}."`}`,
         "",
         `Optional CLI path: longtable ask --cwd "${context.project.projectPath}" --prompt "${context.session.currentGoal.replaceAll("\"", "\\\"")}"`
     ]));
 }
+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.");
+    }
+    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")
+        }
+    };
+    if (args.json === true) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(renderSectionCard("Long Table Resume", [
+        `Project: ${context.project.projectName}`,
+        `Path: ${context.project.projectPath}`,
+        `Current goal: ${context.session.currentGoal}`,
+        ...(context.session.currentBlocker ? [`Current blocker: ${context.session.currentBlocker}`] : []),
+        `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}`,
+        "",
+        `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}."`}`
+    ]));
+}
 async function runCodexSubcommand(subcommand, args) {
     const customDir = typeof args.dir === "string" ? args.dir : undefined;
     if (subcommand === "install-prompts") {
@@ -947,6 +1065,10 @@ async function main() {
         await runStart(values);
         return;
     }
+    if (command === "resume") {
+        await runResume(values);
+        return;
+    }
     if (command === "roles") {
         await runRoles(values);
         return;

package/dist/persona-router.d.ts

@@ -8,8 +8,17 @@ export interface PersonaRoutingResult {
     consultedRoles: CanonicalPersona[];
     ambiguousSignal: string | null;
 }
+export interface LongTableInvocationDirective {
+    explicit: boolean;
+    cleanedPrompt: string;
+    mode?: InteractionMode | "panel" | "status";
+    roles: CanonicalPersona[];
+    panel: boolean;
+    showConflicts: boolean;
+}
 export declare function detectOutputLanguage(input: string): OutputLanguage;
 export declare function parseRoleFlag(value?: string): CanonicalPersona[];
+export declare function parseInvocationDirective(prompt: string): LongTableInvocationDirective;
 export declare function routePersonas(prompt: string, explicitRoleFlag?: string): PersonaRoutingResult;
 export declare function renderDisclosure(roles: CanonicalPersona[], language: OutputLanguage): string | null;
 export declare function buildPersonaGuidance(options: {

package/dist/persona-router.js

@@ -1,5 +1,24 @@
 import { getPersonaDefinition, parsePersonaKey, PERSONA_DEFINITIONS } from "./personas.js";
 const AUTO_CALL_LIMIT = 3;
+const INVOCATION_PREFIX = /^(?:lt|longtable|long table|롱테이블)\s+/i;
+const DIRECTIVE_MAP = [
+    { key: "explore", mode: "explore" },
+    { key: "review", mode: "review" },
+    { key: "critique", mode: "critique" },
+    { key: "draft", mode: "draft" },
+    { key: "commit", mode: "commit" },
+    { key: "panel", mode: "panel", panel: true, showConflicts: true },
+    { key: "status", mode: "status" },
+    { key: "editor", mode: "review", roles: ["editor"] },
+    { key: "reviewer", mode: "review", roles: ["reviewer"] },
+    { key: "methods", mode: "review", roles: ["methods_critic"] },
+    { key: "method", mode: "review", roles: ["methods_critic"] },
+    { key: "theory", mode: "review", roles: ["theory_critic"] },
+    { key: "measurement", mode: "review", roles: ["measurement_auditor"] },
+    { key: "ethics", mode: "review", roles: ["ethics_reviewer"] },
+    { key: "voice", mode: "review", roles: ["voice_keeper"] },
+    { key: "venue", mode: "review", roles: ["venue_strategist"] }
+];
 function unique(items) {
     return [...new Set(items)];
 }
@@ -15,6 +34,49 @@ export function parseRoleFlag(value) {
         .map((part) => parsePersonaKey(part))
         .filter((part) => part !== null));
 }
+export function parseInvocationDirective(prompt) {
+    const trimmed = prompt.trim();
+    if (!INVOCATION_PREFIX.test(trimmed)) {
+        return {
+            explicit: false,
+            cleanedPrompt: prompt,
+            roles: [],
+            panel: false,
+            showConflicts: false
+        };
+    }
+    const withoutPrefix = trimmed.replace(INVOCATION_PREFIX, "");
+    const colonIndex = withoutPrefix.indexOf(":");
+    if (colonIndex === -1) {
+        return {
+            explicit: false,
+            cleanedPrompt: prompt,
+            roles: [],
+            panel: false,
+            showConflicts: false
+        };
+    }
+    const directiveKey = withoutPrefix.slice(0, colonIndex).trim().toLowerCase();
+    const body = withoutPrefix.slice(colonIndex + 1).trim();
+    const directive = DIRECTIVE_MAP.find((entry) => entry.key === directiveKey);
+    if (!directive) {
+        return {
+            explicit: false,
+            cleanedPrompt: body || prompt,
+            roles: [],
+            panel: false,
+            showConflicts: false
+        };
+    }
+    return {
+        explicit: true,
+        cleanedPrompt: body || prompt,
+        mode: directive.mode,
+        roles: directive.roles ?? [],
+        panel: directive.panel === true,
+        showConflicts: directive.showConflicts === true
+    };
+}
 export function routePersonas(prompt, explicitRoleFlag) {
     const normalizedPrompt = prompt.toLowerCase();
     const explicitRoles = parseRoleFlag(explicitRoleFlag);
@@ -60,7 +122,10 @@ export function renderDisclosure(roles, language) {
         : `Long Table consulted: ${labels.join(", ")}`;
 }
 export function buildPersonaGuidance(options) {
-    const routing = routePersonas(options.prompt, options.roleFlag);
+    const directive = parseInvocationDirective(options.prompt);
+    const effectivePrompt = directive.cleanedPrompt;
+    const mergedRoleFlag = [options.roleFlag, directive.roles.join(",")].filter(Boolean).join(",");
+    const routing = routePersonas(effectivePrompt, mergedRoleFlag || undefined);
     const disclosure = renderDisclosure(routing.consultedRoles, routing.outputLanguage);
     const lines = [];
     lines.push(routing.outputLanguage === "ko"
@@ -74,12 +139,12 @@ export function buildPersonaGuidance(options) {
             ? "Ambiguity note: 편집자 관점인지 리뷰어 관점인지 애매합니다. 먼저 둘 중 무엇을 우선할지 짧게 확인하세요."
             : "Ambiguity note: it is unclear whether the user wants an editor view or reviewer view. Ask briefly before closing.");
     }
-    if (options.panel) {
+    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.");
     }
-    if (options.showConflicts) {
+    if (options.showConflicts || directive.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.");
@@ -89,10 +154,13 @@ export function buildPersonaGuidance(options) {
             ? "Include a short deliberation trace showing why the roles diverged."
             : "Include a short deliberation trace showing why the roles diverged.");
     }
+    lines.push(routing.outputLanguage === "ko"
+        ? "For factual, current, or external claims, attach source links or local file references when possible. If you cannot source a statement, label it as inference or estimate."
+        : "For factual, current, or external claims, attach source links or local file references when possible. If you cannot source a statement, label it as inference or estimate.");
     lines.push(routing.outputLanguage === "ko"
         ? "Do not show internal file-search logs, tool traces, or process commentary in the researcher-facing answer."
         : "Do not show internal file-search logs, tool traces, or process commentary in the researcher-facing answer.");
-    lines.push(options.prompt.trim());
+    lines.push(effectivePrompt.trim());
     return {
         guidedPrompt: lines.join("\n\n"),
         routing

package/dist/project-session.js

@@ -34,6 +34,8 @@ function buildWorkspaceGuide(project, session) {
         "- 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",
@@ -54,12 +56,22 @@ function buildStartHereGuide(project, session) {
         "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}`] : []),
@@ -69,10 +81,59 @@ function buildStartHereGuide(project, session) {
         "## 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."
+        "- `.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 buildNextStepsGuide(project, session) {
+    const firstQuestion = session.currentBlocker
+        ? `What would reduce the uncertainty around "${session.currentBlocker}" first?`
+        : `What is the first concrete question that would move "${session.currentGoal}" forward?`;
+    return [
+        "# Next Steps",
+        "",
+        `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.",
+        "",
+        "## 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.",
+        "",
+        "## 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",
+        "",
+        `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}`,
+        "",
+        "## Resume prompt",
+        session.currentBlocker
+            ? `"I want to continue ${session.currentGoal}. The unresolved blocker is ${session.currentBlocker}."`
+            : `"I want to continue ${session.currentGoal}."`,
+        "",
+        "## 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."
+    ].join("\n");
+}
 function buildProjectAgentsMd(project, session) {
     return [
         "# AGENTS.md",
@@ -88,9 +149,15 @@ function buildProjectAgentsMd(project, session) {
         "",
         "## Research-facing behavior",
         "- 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.",
+        "- 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.",
         "- Begin exploratory work with clarifying or tension questions before recommending a direction.",
         "- If you foreground role perspectives, disclose them with `Long Table 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."]
             : []),
@@ -100,6 +167,7 @@ function buildProjectAgentsMd(project, session) {
         "- 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",
         "- These instructions apply to this directory and its children."
@@ -196,6 +264,8 @@ export async function createOrUpdateProjectWorkspace(options) {
     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 {
         project,
@@ -243,6 +313,8 @@ export function renderProjectWorkspaceSummary(context) {
         `- ${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")}`,
         `- ${join(context.project.projectPath, "AGENTS.md")}`
     ].join("\n");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longtable/cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "private": false,
   "description": "Researcher-facing Long Table CLI on top of the legacy Diverga package surface",
   "type": "module",