@longtable/cli 0.1.9 → 0.1.11

package/dist/project-session.js

@@ -2,7 +2,8 @@ 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 "@longtable/memory";
+import { appendDecisionRecord as appendDecisionToResearchState, appendInvocationRecord as appendInvocationToResearchState, appendQuestionRecords, createEmptyResearchState } from "@longtable/memory";
+import { classifyCheckpointTrigger } from "@longtable/checkpoints";
 const CURRENT_FILE_NAME = "CURRENT.md";
 const LEGACY_ROOT_FILES = ["LONGTABLE.md", "START-HERE.md", "NEXT-STEPS.md", "SESSION-SNAPSHOT.md"];
 function nowIso() {
@@ -79,7 +80,7 @@ function buildResumeHint(session) {
         ? `I want to continue ${session.currentGoal}. The unresolved blocker is ${session.currentBlocker}.`
         : `I want to continue ${session.currentGoal}.`;
 }
-function buildCurrentGuide(project, session) {
+function buildCurrentGuide(project, session, recentInvocations = [], pendingQuestions = []) {
     const locale = normalizeLocale(session.locale ?? project.locale);
     const openQuestions = session.openQuestions && session.openQuestions.length > 0
         ? session.openQuestions
@@ -104,6 +105,27 @@ function buildCurrentGuide(project, session) {
             "",
             "## 열린 질문",
             ...openQuestions.map((question) => `- ${question}`),
+            ...(recentInvocations.length > 0
+                ? [
+                    "",
+                    "## 최근 LongTable 호출",
+                    ...recentInvocations.map((record) => {
+                        const roles = record.intent.roles.length > 0 ? record.intent.roles.join(", ") : "auto";
+                        return `- ${record.intent.kind}/${record.intent.mode} via ${record.surface}: ${roles}`;
+                    })
+                ]
+                : []),
+            ...(pendingQuestions.length > 0
+                ? [
+                    "",
+                    "## 대기 중인 결정 질문",
+                    ...pendingQuestions.map((record) => {
+                        const options = formatQuestionOptionValues(record).join("/");
+                        return `- ${record.id}: ${record.prompt.question} (${options})`;
+                    }),
+                    "- 답변 기록: `longtable decide --question <id> --answer <value>`"
+                ]
+                : []),
             "",
             "## 다시 시작 문장",
             `- "${resumeHint}"`,
@@ -132,6 +154,27 @@ function buildCurrentGuide(project, session) {
         "",
         "## Open Questions",
         ...openQuestions.map((question) => `- ${question}`),
+        ...(recentInvocations.length > 0
+            ? [
+                "",
+                "## Recent LongTable Invocations",
+                ...recentInvocations.map((record) => {
+                    const roles = record.intent.roles.length > 0 ? record.intent.roles.join(", ") : "auto";
+                    return `- ${record.intent.kind}/${record.intent.mode} via ${record.surface}: ${roles}`;
+                })
+            ]
+            : []),
+        ...(pendingQuestions.length > 0
+            ? [
+                "",
+                "## Pending Decision Questions",
+                ...pendingQuestions.map((record) => {
+                    const options = formatQuestionOptionValues(record).join("/");
+                    return `- ${record.id}: ${record.prompt.question} (${options})`;
+                }),
+                "- Record an answer: `longtable decide --question <id> --answer <value>`"
+            ]
+            : []),
         "",
         "## Restart Prompt",
         `- "${resumeHint}"`,
@@ -144,6 +187,102 @@ function buildCurrentGuide(project, session) {
         "- External or current claims should carry a source link or be labeled as inference."
     ].join("\n");
 }
+async function loadResearchState(stateFilePath) {
+    if (!existsSync(stateFilePath)) {
+        return createEmptyResearchState();
+    }
+    const parsed = JSON.parse(await readFile(stateFilePath, "utf8"));
+    return {
+        explicitState: parsed.explicitState ?? {},
+        workingState: parsed.workingState ?? {},
+        inferredHypotheses: parsed.inferredHypotheses ?? [],
+        openTensions: parsed.openTensions ?? [],
+        decisionLog: parsed.decisionLog ?? [],
+        invocationLog: parsed.invocationLog ?? [],
+        questionLog: parsed.questionLog ?? [],
+        artifactRecords: parsed.artifactRecords ?? [],
+        narrativeTraces: parsed.narrativeTraces ?? [],
+        ...(parsed.studyContract ? { studyContract: parsed.studyContract } : {})
+    };
+}
+export async function loadWorkspaceState(context) {
+    return loadResearchState(context.stateFilePath);
+}
+function recentInvocationRecords(state, limit = 3) {
+    return (state.invocationLog ?? []).slice(-limit).reverse();
+}
+function recentPendingQuestions(state, limit = 3) {
+    return (state.questionLog ?? [])
+        .filter((record) => record.status === "pending")
+        .slice(-limit)
+        .reverse();
+}
+function formatQuestionOptionValues(record) {
+    const values = record.prompt.options.map((option) => option.value);
+    if (record.prompt.allowOther) {
+        values.push(record.prompt.otherLabel ? `other:${record.prompt.otherLabel}` : "other");
+    }
+    return values;
+}
+function summarizeWorkspaceInspection(context, state) {
+    const questions = state.questionLog ?? [];
+    const pendingQuestions = questions.filter((record) => record.status === "pending");
+    const answeredQuestions = questions.filter((record) => record.status === "answered");
+    return {
+        found: true,
+        rootPath: context.project.projectPath,
+        project: {
+            name: context.project.projectName,
+            path: context.project.projectPath,
+            field: context.project.globalSetupSummary.field,
+            careerStage: context.project.globalSetupSummary.careerStage,
+            checkpointIntensity: context.project.globalSetupSummary.checkpointIntensity
+        },
+        session: {
+            currentGoal: context.session.currentGoal,
+            ...(context.session.currentBlocker ? { currentBlocker: context.session.currentBlocker } : {}),
+            requestedPerspectives: context.session.requestedPerspectives,
+            disagreementPreference: context.session.disagreementPreference
+        },
+        files: {
+            project: context.projectFilePath,
+            session: context.sessionFilePath,
+            state: context.stateFilePath,
+            current: context.currentFilePath
+        },
+        counts: {
+            invocations: (state.invocationLog ?? []).length,
+            questions: questions.length,
+            pendingQuestions: pendingQuestions.length,
+            answeredQuestions: answeredQuestions.length,
+            decisions: (state.decisionLog ?? []).length
+        },
+        recentInvocations: recentInvocationRecords(state, 5).map((record) => ({
+            id: record.id,
+            kind: record.intent.kind,
+            mode: record.intent.mode,
+            surface: record.surface,
+            status: record.status,
+            roles: record.intent.roles,
+            linkedQuestions: record.panelResult?.linkedQuestionRecordIds.length ?? 0,
+            linkedDecisions: record.panelResult?.linkedDecisionRecordIds.length ?? 0
+        })),
+        pendingQuestions: pendingQuestions.slice(-5).reverse().map((record) => ({
+            id: record.id,
+            title: record.prompt.title,
+            question: record.prompt.question,
+            options: formatQuestionOptionValues(record),
+            required: record.prompt.required
+        })),
+        recentDecisions: (state.decisionLog ?? []).slice(-5).reverse().map((record) => ({
+            id: record.id,
+            checkpointKey: record.checkpointKey,
+            summary: record.summary,
+            ...(record.selectedOption ? { selectedOption: record.selectedOption } : {}),
+            timestamp: record.timestamp
+        }))
+    };
+}
 function buildProjectAgentsMd(project, session) {
     return [
         "# AGENTS.md",
@@ -234,10 +373,227 @@ 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);
+    const state = await loadResearchState(context.stateFilePath);
+    const body = buildCurrentGuide(context.project, context.session, recentInvocationRecords(state), recentPendingQuestions(state));
     await writeFile(context.currentFilePath, body, "utf8");
     return context.currentFilePath;
 }
+export async function appendInvocationRecordToWorkspace(context, invocation, questions = []) {
+    const state = await loadResearchState(context.stateFilePath);
+    const withInvocation = appendInvocationToResearchState(state, invocation);
+    const updated = questions.length > 0
+        ? appendQuestionRecords(withInvocation, questions)
+        : withInvocation;
+    await writeFile(context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
+    await syncCurrentWorkspaceView(context);
+    return updated;
+}
+function createId(prefix) {
+    return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function findQuestionForDecision(state, questionId) {
+    const pending = (state.questionLog ?? []).filter((record) => record.status === "pending");
+    if (questionId) {
+        return pending.find((record) => record.id === questionId) ?? null;
+    }
+    return pending.at(-1) ?? null;
+}
+function pendingRequiredQuestions(state) {
+    return (state.questionLog ?? []).filter((record) => record.status === "pending" && record.prompt.required);
+}
+export async function listBlockingWorkspaceQuestions(context) {
+    const state = await loadResearchState(context.stateFilePath);
+    return pendingRequiredQuestions(state);
+}
+export async function assertWorkspaceNotBlocked(context) {
+    const blocking = await listBlockingWorkspaceQuestions(context);
+    if (blocking.length === 0) {
+        return;
+    }
+    const first = blocking[0];
+    const options = formatQuestionOptionValues(first).join("/");
+    throw new Error([
+        `LongTable is blocked by a required Researcher Checkpoint: ${first.id}`,
+        first.prompt.question,
+        `Options: ${options}`,
+        `Record an answer with: longtable decide --question ${first.id} --answer <value>`
+    ].join("\n"));
+}
+function questionTitleForCheckpoint(family) {
+    switch (family) {
+        case "meta_decision":
+            return "Meta-decision checkpoint";
+        case "submission":
+            return "Submission checkpoint";
+        case "commitment":
+            return "Research commitment checkpoint";
+        case "evidence":
+            return "Evidence checkpoint";
+        case "authorship":
+            return "Authorship checkpoint";
+        case "review":
+            return "Review checkpoint";
+        case "exploration":
+            return "Exploration checkpoint";
+        default:
+            return "Researcher Checkpoint";
+    }
+}
+function questionTextForCheckpoint(family, prompt) {
+    switch (family) {
+        case "meta_decision":
+            return "What should LongTable do before treating this platform decision as settled?";
+        case "submission":
+            return "What must happen before this work can move toward external release or submission?";
+        case "commitment":
+            return "What should LongTable treat as the human research commitment here?";
+        case "evidence":
+            return "How should LongTable handle the evidence risk before using this claim?";
+        case "authorship":
+            return "What should LongTable preserve before changing the researcher's voice or authorship trace?";
+        case "exploration":
+            return "What ambiguity should LongTable keep open before recommending a direction?";
+        default:
+            return `What should LongTable decide before proceeding with: ${prompt}`;
+    }
+}
+function optionsForCheckpointFamily(family) {
+    if (family === "evidence") {
+        return [
+            { value: "verify", label: "Verify evidence first", description: "Check whether the source supports the specific claim." },
+            { value: "limit", label: "Limit the claim", description: "Keep the point but narrow it to what the evidence can support." },
+            { value: "rewrite", label: "Rewrite without the claim", description: "Avoid relying on the uncertain citation or claim." },
+            { value: "defer", label: "Keep evidence risk open", description: "Do not settle the claim yet." }
+        ];
+    }
+    if (family === "meta_decision") {
+        return [
+            { value: "revise", label: "Revise the platform decision", description: "Change the term, policy, or README positioning before treating it as settled." },
+            { value: "evidence", label: "Gather implementation evidence first", description: "Inspect behavior or docs before committing the platform decision." },
+            { value: "proceed", label: "Proceed with current decision", description: "Accept the current platform framing and continue." },
+            { value: "defer", label: "Keep the decision open", description: "Do not make this platform language authoritative yet." }
+        ];
+    }
+    if (family === "submission") {
+        return [
+            { value: "review", label: "Review risk first", description: "Check claims, ethics, venue fit, or study contract before external release." },
+            { value: "evidence", label: "Verify evidence first", description: "Confirm source support before submission or public sharing." },
+            { value: "proceed", label: "Proceed toward submission", description: "Accept the remaining risk and continue." },
+            { value: "defer", label: "Do not submit yet", description: "Keep the submission decision open." }
+        ];
+    }
+    return [
+        { value: "revise", label: "Revise before proceeding", description: "Change the framing, design, or draft before treating this as settled." },
+        { value: "evidence", label: "Gather or verify evidence first", description: "Do not proceed until the relevant evidence is checked." },
+        { value: "proceed", label: "Proceed with current direction", description: "Accept the risk profile and continue." },
+        { value: "defer", label: "Keep this open", description: "Do not commit yet; keep the issue visible as an open tension." }
+    ];
+}
+export async function createWorkspaceQuestion(options) {
+    const state = await loadResearchState(options.context.stateFilePath);
+    const trigger = classifyCheckpointTrigger(options.prompt, {
+        unresolvedTensions: state.openTensions ?? [],
+        studyContract: state.studyContract
+    });
+    const createdAt = nowIso();
+    const question = {
+        id: createId("question_record"),
+        createdAt,
+        updatedAt: createdAt,
+        status: "pending",
+        prompt: {
+            id: createId("question_prompt"),
+            checkpointKey: trigger.signal.checkpointKey,
+            title: options.title ?? questionTitleForCheckpoint(trigger.family),
+            question: options.question ?? questionTextForCheckpoint(trigger.family, options.prompt),
+            type: "single_choice",
+            options: optionsForCheckpointFamily(trigger.family),
+            allowOther: true,
+            otherLabel: "Other decision",
+            required: options.required ?? trigger.requiresQuestionBeforeClosure,
+            source: "checkpoint",
+            rationale: [
+                ...trigger.rationale,
+                `Trigger family: ${trigger.family}.`,
+                `Trigger confidence: ${trigger.confidence}.`,
+                `Original prompt: ${options.prompt}`
+            ],
+            preferredSurfaces: options.provider === "claude"
+                ? ["native_structured", "numbered"]
+                : ["numbered", "native_structured"]
+        }
+    };
+    const updated = appendQuestionRecords(state, [question]);
+    await writeFile(options.context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
+    await syncCurrentWorkspaceView(options.context);
+    return { question, state: updated };
+}
+function updateInvocationWithDecision(invocation, questionId, decisionId) {
+    if (!invocation.panelResult?.linkedQuestionRecordIds.includes(questionId)) {
+        return invocation;
+    }
+    const linkedDecisionRecordIds = invocation.panelResult.linkedDecisionRecordIds.includes(decisionId)
+        ? invocation.panelResult.linkedDecisionRecordIds
+        : [...invocation.panelResult.linkedDecisionRecordIds, decisionId];
+    return {
+        ...invocation,
+        updatedAt: nowIso(),
+        panelResult: {
+            ...invocation.panelResult,
+            updatedAt: nowIso(),
+            linkedDecisionRecordIds
+        }
+    };
+}
+export async function answerWorkspaceQuestion(options) {
+    const state = await loadResearchState(options.context.stateFilePath);
+    const question = findQuestionForDecision(state, options.questionId);
+    if (!question) {
+        throw new Error(options.questionId ? `No pending LongTable question found for ${options.questionId}.` : "No pending LongTable question was found.");
+    }
+    const option = question.prompt.options.find((candidate) => candidate.value === options.answer);
+    const explicitOther = options.answer === "other" && question.prompt.allowOther;
+    const answer = {
+        promptId: question.prompt.id,
+        selectedValues: [option?.value ?? "other"],
+        selectedLabels: [option?.label ?? (explicitOther ? question.prompt.otherLabel ?? "Other" : options.answer)],
+        ...(option || explicitOther ? {} : { otherText: options.answer }),
+        ...(options.rationale ? { rationale: options.rationale } : {}),
+        ...(options.provider ? { provider: options.provider } : {}),
+        surface: options.provider === "claude" ? "native_structured" : "numbered"
+    };
+    const timestamp = nowIso();
+    const decision = {
+        id: createId("decision"),
+        timestamp,
+        checkpointKey: question.prompt.checkpointKey ?? "manual",
+        level: question.prompt.required ? "adaptive_required" : "recommended",
+        mode: "commit",
+        summary: `Answered ${question.prompt.title}: ${answer.selectedLabels.join(", ")}`,
+        selectedOption: answer.selectedValues[0],
+        ...(options.rationale ? { rationale: options.rationale } : {})
+    };
+    const answeredQuestion = {
+        ...question,
+        updatedAt: timestamp,
+        status: "answered",
+        answer,
+        decisionRecordId: decision.id
+    };
+    const withQuestion = {
+        ...state,
+        questionLog: (state.questionLog ?? []).map((record) => record.id === question.id ? answeredQuestion : record),
+        invocationLog: (state.invocationLog ?? []).map((record) => updateInvocationWithDecision(record, question.id, decision.id))
+    };
+    const updated = appendDecisionToResearchState(withQuestion, decision);
+    await writeFile(options.context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
+    await syncCurrentWorkspaceView(options.context);
+    return {
+        question: answeredQuestion,
+        decision,
+        state: updated
+    };
+}
 export async function createOrUpdateProjectWorkspace(options) {
     const projectPath = resolve(options.projectPath);
     const metaDir = resolveMetaDir(projectPath);
@@ -380,6 +736,14 @@ export async function loadProjectContextFromDirectory(startPath) {
         current = parent;
     }
 }
+export async function inspectProjectWorkspace(startPath) {
+    const context = await loadProjectContextFromDirectory(startPath);
+    if (!context) {
+        return { found: false };
+    }
+    const state = await loadResearchState(context.stateFilePath);
+    return summarizeWorkspaceInspection(context, state);
+}
 export function renderProjectWorkspaceSummary(context) {
     return [
         "┌──────────────────────────────────────────────┐",

package/dist/prompt-aliases.js

@@ -35,8 +35,8 @@ function promptSpec() {
                 "Do not move to the next question until the researcher answers the current one.",
                 "Quickstart covers: provider, field, career stage, experience level, checkpoint intensity, and human authorship signal.",
                 "Interview also covers: preferred entry mode, weakest domain, and panel visibility preference.",
-                "After collecting all answers, summarize the proposed setup and then output both: 1) the exact `longtable codex persist-init ... --install-prompts` command and 2) a strict JSON object with keys provider, flow, field, careerStage, experienceLevel, preferredCheckpointIntensity, and optional humanAuthorshipSignal, preferredEntryMode, weakestDomain, panelPreference.",
-                "If the user prefers paste-based setup, tell them they can pipe the JSON into `longtable codex persist-init --stdin --install-prompts`.",
+                "After collecting all answers, summarize the proposed setup and then output both: 1) the exact `longtable codex persist-init ... --install-skills` command and 2) a strict JSON object with keys provider, flow, field, careerStage, experienceLevel, preferredCheckpointIntensity, and optional humanAuthorshipSignal, preferredEntryMode, weakestDomain, panelPreference.",
+                "If the user prefers paste-based setup, tell them they can pipe the JSON into `longtable codex persist-init --stdin --install-skills`.",
                 "If the researcher asks you to stay inside Codex, keep the conversation in numbered form and do not prematurely close.",
                 "Frame the setup like a short researcher interview, not a bare config form.",
                 "Do not pretend that this is the full project-start interview. The real project-start interview happens in `longtable start`.",
@@ -154,7 +154,7 @@ function promptSpec() {
             argumentHint: "[optional concern]",
             body: [
                 "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/`.",
+                "Inspect whether setup and runtime artifacts appear to exist under `~/.longtable/` and whether LongTable skills appear to be installed under `~/.codex/skills/`.",
                 "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,6 +1,6 @@
 {
   "name": "@longtable/cli",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "private": false,
   "description": "Researcher-facing LongTable CLI",
   "type": "module",
@@ -28,9 +28,12 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@longtable/memory": "0.1.9",
-    "@longtable/provider-codex": "0.1.9",
-    "@longtable/setup": "0.1.9"
+    "@longtable/checkpoints": "0.1.11",
+    "@longtable/core": "0.1.11",
+    "@longtable/memory": "0.1.11",
+    "@longtable/provider-claude": "0.1.11",
+    "@longtable/provider-codex": "0.1.11",
+    "@longtable/setup": "0.1.11"
   },
   "devDependencies": {
     "@types/node": "^22.10.1",