@longtable/cli 0.1.30 → 0.1.32

package/dist/project-session.d.ts

@@ -1,6 +1,71 @@
 import type { DecisionRecord, InvocationRecord, ProviderKind, QuestionOption, QuestionSurface, QuestionRecord, ResearchState } from "@longtable/core";
 import type { SetupPersistedOutput } from "@longtable/setup";
 export type ProjectDisagreementPreference = "synthesis_only" | "show_on_conflict" | "always_visible";
+export type StartInterviewSignal = "phenomenon" | "audience" | "artifact" | "evidence" | "assumption" | "decision_risk" | "voice";
+export interface StartInterviewTurn {
+    index: number;
+    question: string;
+    answer: string;
+    signal: StartInterviewSignal;
+    purpose: string;
+}
+export interface StartInterviewSession {
+    mode: "adaptive";
+    openingStyle: "scene_problem";
+    createdAt: string;
+    completedAt: string;
+    turnCount: number;
+    turns: StartInterviewTurn[];
+    inferredSignals: StartInterviewSignal[];
+    summary: string;
+}
+export type InterviewTurnQuality = "thin" | "usable" | "rich";
+export type InterviewDepth = "gathering_context" | "forming_first_handle" | "ready_to_summarize";
+export interface FirstResearchShape {
+    handle: string;
+    currentGoal: string;
+    currentBlocker?: string;
+    researchObject?: string;
+    gapRisk?: string;
+    protectedDecision?: string;
+    openQuestions: string[];
+    nextAction: string;
+    confidence: "low" | "medium" | "high";
+    sourceHookId?: string;
+    confirmedAt?: string;
+}
+export interface LongTableInterviewTurn {
+    id: string;
+    index: number;
+    createdAt: string;
+    question: string;
+    answer: string;
+    reflection?: string;
+    quality: InterviewTurnQuality;
+    needsFollowUp: boolean;
+    followUpQuestion?: string;
+    rationale?: string[];
+}
+export interface LongTableHookRun {
+    id: string;
+    kind: "longtable_interview" | "quality_probe" | "checkpoint" | "panel_decision";
+    status: "pending" | "active" | "ready_to_confirm" | "confirmed" | "deferred" | "cancelled";
+    createdAt: string;
+    updatedAt: string;
+    targetOutcome?: "first_research_handle" | string;
+    depth?: InterviewDepth;
+    provider?: ProviderKind;
+    turns?: LongTableInterviewTurn[];
+    firstResearchShape?: FirstResearchShape;
+    qualityNotes?: string[];
+    rationale?: string[];
+    linkedQuestionRecordIds?: string[];
+    linkedDecisionRecordIds?: string[];
+}
+export type LongTableWorkspaceState = ResearchState & {
+    hooks?: LongTableHookRun[];
+    firstResearchShape?: FirstResearchShape;
+};
 export interface LongTableProjectRecord {
     schemaVersion: 1;
     product: "LongTable";
@@ -33,6 +98,8 @@ export interface LongTableSessionRecord {
     protectedDecision?: string;
     nextAction?: string;
     openQuestions?: string[];
+    startInterview?: StartInterviewSession;
+    firstResearchShape?: FirstResearchShape;
     requestedPerspectives: string[];
     disagreementPreference: ProjectDisagreementPreference;
     activeModes?: string[];
@@ -108,9 +175,43 @@ export interface LongTableWorkspaceInspection {
         suggestion?: string;
     }>;
 }
-export declare function loadWorkspaceState(context: LongTableProjectContext): Promise<ResearchState>;
+export declare function loadWorkspaceState(context: LongTableProjectContext): Promise<LongTableWorkspaceState>;
 export declare function syncCurrentWorkspaceView(context: LongTableProjectContext): Promise<string>;
-export declare function appendInvocationRecordToWorkspace(context: LongTableProjectContext, invocation: InvocationRecord, questions?: QuestionRecord[]): Promise<ResearchState>;
+export declare function appendInvocationRecordToWorkspace(context: LongTableProjectContext, invocation: InvocationRecord, questions?: QuestionRecord[]): Promise<LongTableWorkspaceState>;
+export declare function beginLongTableInterview(options: {
+    context: LongTableProjectContext;
+    provider?: ProviderKind;
+    openingQuestion?: string;
+    seedAnswer?: string;
+}): Promise<{
+    hook: LongTableHookRun;
+    state: LongTableWorkspaceState;
+}>;
+export declare function appendLongTableInterviewTurn(options: {
+    context: LongTableProjectContext;
+    hookId?: string;
+    question: string;
+    answer: string;
+    reflection?: string;
+    quality?: InterviewTurnQuality;
+    needsFollowUp?: boolean;
+    followUpQuestion?: string;
+    rationale?: string[];
+}): Promise<{
+    hook: LongTableHookRun;
+    turn: NonNullable<LongTableHookRun["turns"]>[number];
+    state: LongTableWorkspaceState;
+}>;
+export declare function summarizeLongTableInterview(options: {
+    context: LongTableProjectContext;
+    hookId?: string;
+    shape: FirstResearchShape;
+}): Promise<{
+    hook: LongTableHookRun;
+    shape: FirstResearchShape;
+    state: LongTableWorkspaceState;
+    session: LongTableSessionRecord;
+}>;
 export declare function listBlockingWorkspaceQuestions(context: LongTableProjectContext): Promise<QuestionRecord[]>;
 export declare function assertWorkspaceNotBlocked(context: LongTableProjectContext): Promise<void>;
 export declare function createWorkspaceFollowUpQuestions(options: {
@@ -159,6 +260,7 @@ export declare function createOrUpdateProjectWorkspace(options: {
     researchObject?: string;
     gapRisk?: string;
     protectedDecision?: string;
+    startInterview?: StartInterviewSession;
     requestedPerspectives: string[];
     disagreementPreference: ProjectDisagreementPreference;
     setup: SetupPersistedOutput;

package/dist/project-session.js

@@ -54,28 +54,53 @@ function resolveUserLocale() {
     return normalizeLocale(Intl.DateTimeFormat().resolvedOptions().locale);
 }
 function buildFirstQuestion(session) {
+    if (session.firstResearchShape?.openQuestions?.[0]) {
+        return session.firstResearchShape.openQuestions[0];
+    }
     return session.currentBlocker
-        ? `What would reduce the uncertainty around "${session.currentBlocker}" first?`
-        : `What is the first concrete question that would move "${session.currentGoal}" forward?`;
+        ? `Where does "${session.currentBlocker}" show up most concretely in the scene, material, or evidence?`
+        : `What scene, case, text, data, or draft would make "${session.currentGoal}" easiest to inspect first?`;
 }
 function buildOpenQuestions(session) {
     const firstQuestion = buildFirstQuestion(session);
+    if (session.startInterview) {
+        return [
+            firstQuestion,
+            `What still feels hardest to name or make concrete in "${session.currentGoal}"?`
+        ];
+    }
     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?`
+            `What would give "${session.currentBlocker}" a usable first research handle without forcing a final research question yet?`
         ]
         : [
             firstQuestion,
-            `What would count as a good first outcome for "${session.currentGoal}" in this session?`
+            `What would give this project a usable first research handle without pretending the question is settled?`
         ];
 }
 function buildNextAction(session) {
+    if (session.firstResearchShape) {
+        return session.firstResearchShape.nextAction;
+    }
+    if (session.startInterview) {
+        return session.currentBlocker
+            ? `Begin from the start-interview brief, then make "${session.currentBlocker}" concrete with one scene, source, case, or dataset.`
+            : "Begin from the start-interview brief, then choose one concrete scene, source, case, or dataset to inspect first.";
+    }
     return session.currentBlocker
-        ? `Open with the blocker, then ask LongTable to surface the first high-leverage uncertainty around "${session.currentBlocker}".`
+        ? `Open with the blocker, then make "${session.currentBlocker}" concrete with one scene, source, case, or dataset.`
         : "Open with your current goal in one sentence, then ask LongTable for the first concrete research move.";
 }
 function buildResumeHint(session) {
+    if (session.firstResearchShape) {
+        return `I want to continue from the First Research Shape: ${session.firstResearchShape.handle}.`;
+    }
+    if (session.startInterview) {
+        return session.currentBlocker
+            ? `I want to continue from the LongTable start interview. The first unresolved issue is ${session.currentBlocker}.`
+            : `I want to continue from the LongTable start interview for ${session.currentGoal}.`;
+    }
     return session.currentBlocker
         ? `I want to continue ${session.currentGoal}. The unresolved blocker is ${session.currentBlocker}.`
         : `I want to continue ${session.currentGoal}.`;
@@ -102,6 +127,8 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
             ...(session.researchObject ? [`- 연구 객체: ${session.researchObject}`] : []),
             ...(session.gapRisk ? [`- 공백/암묵지 위험: ${session.gapRisk}`] : []),
             ...(session.protectedDecision ? [`- 보호할 결정: ${session.protectedDecision}`] : []),
+            ...(session.firstResearchShape ? [`- First Research Shape: ${session.firstResearchShape.handle}`] : []),
+            ...(session.startInterview ? [`- start interview: ${session.startInterview.summary}`] : []),
             `- 다음 액션: ${nextAction}`,
             `- 관점: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
             `- disagreement: ${session.disagreementPreference}`,
@@ -132,10 +159,19 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
             "",
             "## 다시 시작 문장",
             `- "${resumeHint}"`,
+            ...(session.firstResearchShape
+                ? [
+                    "",
+                    "## First Research Shape",
+                    `- Handle: ${session.firstResearchShape.handle}`,
+                    `- Confidence: ${session.firstResearchShape.confidence}`,
+                    ...session.firstResearchShape.openQuestions.map((question) => `- Open question: ${question}`)
+                ]
+                : []),
             "",
             "## 빠른 시작",
             "- 이 디렉토리에서 `codex`를 엽니다.",
-            `- 첫 메시지는 보통 \`${suggestedPrompt}\` 정도면 충분합니다.`,
+            `- 첫 메시지는 보통 \`${session.firstResearchShape ? suggestedPrompt : "$longtable-interview"}\` 정도면 충분합니다.`,
             "",
             "## 증거 규칙",
             "- 외부 사실이나 현재 정보는 source를 붙이거나 inference로 낮춥니다."
@@ -154,6 +190,8 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
         ...(session.researchObject ? [`- Research object: ${session.researchObject}`] : []),
         ...(session.gapRisk ? [`- Gap/tacit risk: ${session.gapRisk}`] : []),
         ...(session.protectedDecision ? [`- Protected decision: ${session.protectedDecision}`] : []),
+        ...(session.firstResearchShape ? [`- First Research Shape: ${session.firstResearchShape.handle}`] : []),
+        ...(session.startInterview ? [`- Start interview: ${session.startInterview.summary}`] : []),
         `- Next action: ${nextAction}`,
         `- Perspectives: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
         `- Disagreement: ${session.disagreementPreference}`,
@@ -184,10 +222,19 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
         "",
         "## Restart Prompt",
         `- "${resumeHint}"`,
+        ...(session.firstResearchShape
+            ? [
+                "",
+                "## First Research Shape",
+                `- Handle: ${session.firstResearchShape.handle}`,
+                `- Confidence: ${session.firstResearchShape.confidence}`,
+                ...session.firstResearchShape.openQuestions.map((question) => `- Open question: ${question}`)
+            ]
+            : []),
         "",
         "## Quick Start",
         "- Open `codex` in this directory.",
-        `- A good first message is usually \`${suggestedPrompt}\`.`,
+        `- A good first message is usually \`${session.firstResearchShape ? suggestedPrompt : "$longtable-interview"}\`.`,
         "",
         "## Evidence Rule",
         "- External or current claims should carry a source link or be labeled as inference."
@@ -202,6 +249,8 @@ async function loadResearchState(stateFilePath) {
         ...parsed,
         explicitState: parsed.explicitState ?? {},
         workingState: parsed.workingState ?? {},
+        hooks: parsed.hooks ?? [],
+        ...(parsed.firstResearchShape ? { firstResearchShape: parsed.firstResearchShape } : {}),
         inferredHypotheses: parsed.inferredHypotheses ?? [],
         openTensions: parsed.openTensions ?? [],
         decisionLog: parsed.decisionLog ?? [],
@@ -321,13 +370,16 @@ function buildProjectAgentsMd(project, session) {
         "- Treat `AGENTS.md` as runtime guidance, not as the researcher-facing resume artifact.",
         "",
         "## Invocation Rules",
+        "- If the user message starts with `$longtable-interview`, run the LongTable interview flow before generic research advice.",
         "- 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.",
+        "- Supported explicit directives are: interview, explore, review, critique, draft, commit, panel, status, editor, reviewer, methods, theory, measurement, ethics, voice, venue.",
         "- 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.",
+        "- For `$longtable-interview`, ask one natural-language question at a time, reflect with `LongTable hears: ...`, and avoid early reader/reviewer or theory/method/measurement classification.",
+        "- Use structured options only at the final First Research Shape confirmation or at true checkpoint boundaries.",
         "- If you foreground role perspectives, disclose them with `LongTable consulted: ...`.",
         "- Keep one accountable synthesis, but do not hide meaningful disagreement.",
         ...(session.disagreementPreference === "always_visible"
@@ -344,6 +396,8 @@ function buildProjectAgentsMd(project, session) {
         ...(session.researchObject ? [`- Research object: ${session.researchObject}`] : []),
         ...(session.gapRisk ? [`- Gap/tacit risk: ${session.gapRisk}`] : []),
         ...(session.protectedDecision ? [`- Protected decision: ${session.protectedDecision}`] : []),
+        ...(session.firstResearchShape ? [`- First Research Shape: ${session.firstResearchShape.handle}`] : []),
+        ...(session.startInterview ? [`- Start interview summary: ${session.startInterview.summary}`] : []),
         `- Requested perspectives: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
         `- Disagreement visibility: ${session.disagreementPreference}`,
         "- These instructions apply to this directory and its children."
@@ -368,8 +422,13 @@ function buildStateSeed(project, session, setup) {
         ...(session.nextAction ? { nextAction: session.nextAction } : {}),
         openQuestions: session.openQuestions ?? [],
         activeModes: session.activeModes ?? [],
+        ...(session.startInterview ? { startInterview: session.startInterview } : {}),
         ...(session.resumeHint ? { resumeHint: session.resumeHint } : {})
     };
+    if (session.firstResearchShape) {
+        state.firstResearchShape = session.firstResearchShape;
+        state.workingState.firstResearchShape = session.firstResearchShape;
+    }
     if (session.currentBlocker) {
         state.openTensions.push(session.currentBlocker);
     }
@@ -414,6 +473,25 @@ function buildStateSeed(project, session, setup) {
             importance: "high"
         });
     }
+    if (session.startInterview) {
+        state.narrativeTraces.push({
+            id: "project-session-start-interview",
+            timestamp: nowIso(),
+            source: "longtable-start",
+            traceType: "experience",
+            summary: session.startInterview.summary,
+            visibility: "explicit",
+            importance: "high"
+        });
+        if (session.startInterview.inferredSignals.length > 0) {
+            state.inferredHypotheses.push({
+                hypothesis: `Start interview suggests these early lenses: ${session.startInterview.inferredSignals.join(", ")}.`,
+                confidence: 0.65,
+                evidence: session.startInterview.turns.map((turn) => turn.answer).filter(Boolean),
+                status: "unconfirmed"
+            });
+        }
+    }
     return JSON.stringify(state, null, 2);
 }
 async function removeLegacyRootFiles(projectPath) {
@@ -438,6 +516,200 @@ export async function appendInvocationRecordToWorkspace(context, invocation, que
 function createId(prefix) {
     return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
+function normalizeInterviewQuality(answer, quality) {
+    if (quality) {
+        return quality;
+    }
+    const trimmed = answer.trim();
+    const wordCount = trimmed.split(/\s+/).filter(Boolean).length;
+    if (trimmed.length < 12 || wordCount < 3) {
+        return "thin";
+    }
+    if (trimmed.length > 80 || wordCount >= 12) {
+        return "rich";
+    }
+    return "usable";
+}
+function defaultFollowUpQuestion(answer) {
+    const trimmed = answer.trim();
+    if (trimmed.length < 12) {
+        return "Say one more sentence about where this problem appears or why it matters before LongTable tries to classify it.";
+    }
+    return "What concrete scene, case, material, text, dataset, or decision would make that problem easier to inspect first?";
+}
+function depthForInterview(turns = []) {
+    const usableTurns = turns.filter((turn) => turn.quality !== "thin").length;
+    if (usableTurns >= 3) {
+        return "ready_to_summarize";
+    }
+    if (usableTurns >= 1) {
+        return "forming_first_handle";
+    }
+    return "gathering_context";
+}
+function activeInterviewHook(state, hookId) {
+    const hooks = state.hooks ?? [];
+    if (hookId) {
+        return hooks.find((hook) => hook.id === hookId);
+    }
+    return [...hooks].reverse().find((hook) => hook.kind === "longtable_interview" &&
+        (hook.status === "pending" || hook.status === "active" || hook.status === "ready_to_confirm"));
+}
+function upsertHook(state, hook) {
+    const hooks = state.hooks ?? [];
+    const existingIndex = hooks.findIndex((candidate) => candidate.id === hook.id);
+    const nextHooks = existingIndex >= 0
+        ? hooks.map((candidate) => candidate.id === hook.id ? hook : candidate)
+        : [...hooks, hook];
+    return {
+        ...state,
+        hooks: nextHooks
+    };
+}
+export async function beginLongTableInterview(options) {
+    const state = await loadResearchState(options.context.stateFilePath);
+    const existing = activeInterviewHook(state);
+    if (existing) {
+        return { hook: existing, state };
+    }
+    const timestamp = nowIso();
+    const hook = {
+        id: createId("hook_interview"),
+        kind: "longtable_interview",
+        status: "active",
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        targetOutcome: "first_research_handle",
+        depth: "gathering_context",
+        provider: options.provider,
+        turns: [],
+        qualityNotes: [],
+        rationale: [
+            "Official LongTable research start surface is provider-native `$longtable-interview`, not the CLI start questionnaire.",
+            "The hook keeps early research ambiguity open until a first research handle can be summarized."
+        ]
+    };
+    let updated = upsertHook(state, hook);
+    updated.workingState = {
+        ...updated.workingState,
+        activeInterviewHookId: hook.id,
+        interviewSurface: "$longtable-interview",
+        ...(options.openingQuestion ? { interviewOpeningQuestion: options.openingQuestion } : {}),
+        ...(options.seedAnswer ? { interviewSeedAnswer: options.seedAnswer } : {})
+    };
+    await writeFile(options.context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
+    await syncCurrentWorkspaceView(options.context);
+    return { hook, state: updated };
+}
+export async function appendLongTableInterviewTurn(options) {
+    const state = await loadResearchState(options.context.stateFilePath);
+    const existing = activeInterviewHook(state, options.hookId);
+    if (!existing) {
+        throw new Error("No active LongTable interview hook was found. Run begin_interview first.");
+    }
+    const quality = normalizeInterviewQuality(options.answer, options.quality);
+    const needsFollowUp = options.needsFollowUp ?? quality === "thin";
+    const followUpQuestion = needsFollowUp
+        ? options.followUpQuestion ?? defaultFollowUpQuestion(options.answer)
+        : options.followUpQuestion;
+    const timestamp = nowIso();
+    const turns = existing.turns ?? [];
+    const turn = {
+        id: createId("interview_turn"),
+        index: turns.length + 1,
+        createdAt: timestamp,
+        question: options.question.trim(),
+        answer: options.answer.trim(),
+        ...(options.reflection?.trim() ? { reflection: options.reflection.trim() } : {}),
+        quality,
+        needsFollowUp,
+        ...(followUpQuestion?.trim() ? { followUpQuestion: followUpQuestion.trim() } : {}),
+        ...(options.rationale && options.rationale.length > 0 ? { rationale: options.rationale } : {})
+    };
+    const nextTurns = [...turns, turn];
+    const depth = depthForInterview(nextTurns);
+    const hook = {
+        ...existing,
+        status: depth === "ready_to_summarize" ? "ready_to_confirm" : "active",
+        updatedAt: timestamp,
+        depth,
+        turns: nextTurns,
+        qualityNotes: [
+            ...(existing.qualityNotes ?? []),
+            ...(needsFollowUp ? [`Turn ${turn.index} needs follow-up: ${followUpQuestion}`] : [])
+        ]
+    };
+    const updated = upsertHook(state, hook);
+    await writeFile(options.context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
+    await syncCurrentWorkspaceView(options.context);
+    return { hook, turn, state: updated };
+}
+export async function summarizeLongTableInterview(options) {
+    const state = await loadResearchState(options.context.stateFilePath);
+    const existing = activeInterviewHook(state, options.hookId);
+    if (!existing) {
+        throw new Error("No active LongTable interview hook was found. Run begin_interview first.");
+    }
+    const timestamp = nowIso();
+    const shape = {
+        ...options.shape,
+        handle: options.shape.handle.trim(),
+        currentGoal: options.shape.currentGoal.trim(),
+        openQuestions: options.shape.openQuestions.map((question) => question.trim()).filter(Boolean),
+        nextAction: options.shape.nextAction.trim(),
+        sourceHookId: existing.id
+    };
+    const hook = {
+        ...existing,
+        status: "ready_to_confirm",
+        updatedAt: timestamp,
+        depth: "ready_to_summarize",
+        firstResearchShape: shape
+    };
+    const session = {
+        ...options.context.session,
+        lastUpdatedAt: timestamp,
+        currentGoal: shape.currentGoal,
+        ...(shape.currentBlocker ? { currentBlocker: shape.currentBlocker } : {}),
+        ...(shape.researchObject ? { researchObject: shape.researchObject } : {}),
+        ...(shape.gapRisk ? { gapRisk: shape.gapRisk } : {}),
+        ...(shape.protectedDecision ? { protectedDecision: shape.protectedDecision } : {}),
+        nextAction: shape.nextAction,
+        openQuestions: shape.openQuestions,
+        firstResearchShape: shape,
+        resumeHint: `I want to continue from the First Research Shape: ${shape.handle}.`
+    };
+    options.context.session = session;
+    let updated = upsertHook(state, hook);
+    updated.firstResearchShape = shape;
+    updated.workingState = {
+        ...updated.workingState,
+        currentGoal: shape.currentGoal,
+        ...(shape.currentBlocker ? { currentBlocker: shape.currentBlocker } : {}),
+        ...(shape.researchObject ? { researchObject: shape.researchObject } : {}),
+        ...(shape.gapRisk ? { gapRisk: shape.gapRisk } : {}),
+        ...(shape.protectedDecision ? { protectedDecision: shape.protectedDecision } : {}),
+        openQuestions: shape.openQuestions,
+        nextAction: shape.nextAction,
+        firstResearchShape: shape
+    };
+    if (shape.currentBlocker && !updated.openTensions.includes(shape.currentBlocker)) {
+        updated.openTensions.push(shape.currentBlocker);
+    }
+    updated.narrativeTraces.push({
+        id: createId("narrative_trace"),
+        timestamp,
+        source: "$longtable-interview",
+        traceType: "judgment",
+        summary: `First Research Shape: ${shape.handle}.`,
+        visibility: "explicit",
+        importance: shape.confidence
+    });
+    await writeFile(options.context.sessionFilePath, JSON.stringify(session, null, 2), "utf8");
+    await writeFile(options.context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
+    await syncCurrentWorkspaceView(options.context);
+    return { hook, shape, state: updated, session };
+}
 function findQuestionForDecision(state, questionId) {
     const pending = (state.questionLog ?? []).filter((record) => record.status === "pending");
     if (questionId) {
@@ -1008,6 +1280,7 @@ export async function createOrUpdateProjectWorkspace(options) {
         ...(options.researchObject ? { researchObject: options.researchObject } : {}),
         ...(options.gapRisk ? { gapRisk: options.gapRisk } : {}),
         ...(options.protectedDecision ? { protectedDecision: options.protectedDecision } : {}),
+        ...(options.startInterview ? { startInterview: options.startInterview } : {}),
         nextAction: buildNextAction({
             schemaVersion: 1,
             id: sessionId,
@@ -1019,6 +1292,7 @@ export async function createOrUpdateProjectWorkspace(options) {
             ...(options.researchObject ? { researchObject: options.researchObject } : {}),
             ...(options.gapRisk ? { gapRisk: options.gapRisk } : {}),
             ...(options.protectedDecision ? { protectedDecision: options.protectedDecision } : {}),
+            ...(options.startInterview ? { startInterview: options.startInterview } : {}),
             requestedPerspectives: options.requestedPerspectives,
             disagreementPreference: options.disagreementPreference
         }),
@@ -1033,6 +1307,7 @@ export async function createOrUpdateProjectWorkspace(options) {
             ...(options.researchObject ? { researchObject: options.researchObject } : {}),
             ...(options.gapRisk ? { gapRisk: options.gapRisk } : {}),
             ...(options.protectedDecision ? { protectedDecision: options.protectedDecision } : {}),
+            ...(options.startInterview ? { startInterview: options.startInterview } : {}),
             requestedPerspectives: options.requestedPerspectives,
             disagreementPreference: options.disagreementPreference
         }),
@@ -1050,6 +1325,7 @@ export async function createOrUpdateProjectWorkspace(options) {
             ...(options.researchObject ? { researchObject: options.researchObject } : {}),
             ...(options.gapRisk ? { gapRisk: options.gapRisk } : {}),
             ...(options.protectedDecision ? { protectedDecision: options.protectedDecision } : {}),
+            ...(options.startInterview ? { startInterview: options.startInterview } : {}),
             requestedPerspectives: options.requestedPerspectives,
             disagreementPreference: options.disagreementPreference
         }),
@@ -1123,13 +1399,19 @@ export async function inspectProjectWorkspace(startPath) {
 }
 export function renderProjectWorkspaceSummary(context) {
     return [
-        "┌──────────────────────────────────────────────┐",
-        "│ LongTable Project Workspace               │",
-        "└──────────────────────────────────────────────┘",
+        "┌─ LongTable Project Workspace ─────────────────────────┐",
+        "└───────────────────────────────────────────────────────┘",
         `Project: ${context.project.projectName}`,
         `Path: ${context.project.projectPath}`,
+        "",
+        "┌─ Current Research Shape ──────────────────────────────┐",
         `Goal: ${context.session.currentGoal}`,
         ...(context.session.currentBlocker ? [`Blocker: ${context.session.currentBlocker}`] : []),
+        ...(context.session.researchObject ? [`Working object: ${context.session.researchObject}`] : []),
+        ...(context.session.firstResearchShape ? [`First Research Shape: ${context.session.firstResearchShape.handle}`] : []),
+        ...(context.session.startInterview ? [`Start interview: ${context.session.startInterview.summary}`] : []),
+        "└───────────────────────────────────────────────────────┘",
+        "",
         `Perspectives: ${context.session.requestedPerspectives.length > 0 ? context.session.requestedPerspectives.join(", ") : "auto"}`,
         `Disagreement: ${context.session.disagreementPreference}`,
         "",

package/dist/prompt-aliases.js

@@ -29,18 +29,18 @@ function promptSpec() {
             argumentHint: "[project context or current uncertainty]",
             body: [
                 "You are LongTable setup guidance inside Codex.",
-                "Treat `longtable init` as deprecated. Prefer `longtable setup --provider codex` for runtime permissions, then `longtable start` for the project interview.",
+                "Treat `longtable init` as deprecated. Prefer `longtable setup --provider codex` for runtime permissions, then `$longtable-interview` inside Codex for the project interview.",
                 "Ask exactly one setup question at a time.",
                 "Use numbered choices and include a concise Why / What you get / Tradeoff for each option.",
                 "Do not move to the next question until the researcher answers the current one.",
-                "Runtime setup covers only: provider, install scope, runtime surfaces, intervention strength, and whether to create a workspace now.",
+                "Runtime setup covers only: provider, install scope, runtime surfaces, intervention strength, and whether to show interview launch steps.",
                 "Do not ask for field, career stage, experience level, authorship signal, weakest domain, or panel preference during runtime setup.",
-                "Project start covers: research object, gap/tacit risk, and protected decision area.",
+                "Project interview covers: the first research handle, early uncertainty, first inspectable material, and final structured confirmation.",
                 "After collecting runtime answers, summarize the proposed setup and output the exact `longtable setup --provider codex ...` command.",
-                "If the researcher is ready to create a project workspace, output the exact `longtable start ...` command separately.",
+                "If the researcher is ready to create a project workspace, tell them to open Codex in the research folder and invoke `$longtable-interview`.",
                 "If the researcher asks you to stay inside Codex, keep the conversation in numbered form and do not prematurely close.",
                 "Frame setup as permission and intervention calibration, not a researcher profile interview.",
-                "Do not pretend setup is the full project-start interview. The project-start interview happens in `longtable start`.",
+                "Do not pretend setup is the full project-start interview. The project-start interview happens in `$longtable-interview`.",
                 "Treat any slash-command arguments as context for why setup is being done now."
             ]
         },

package/dist/prompt-renderer.d.ts

@@ -0,0 +1,11 @@
+import type { SetupChoice } from "@longtable/setup";
+export interface PromptRenderer {
+    text(prompt: string, options?: {
+        required?: boolean;
+        placeholder?: string;
+    }): Promise<string | undefined>;
+    select(prompt: string, choices: SetupChoice[]): Promise<string>;
+    multiselect(prompt: string, choices: SetupChoice[]): Promise<string[]>;
+    note(message: string, title?: string): void;
+}
+export declare function createPromptRenderer(): PromptRenderer;