@longtable/cli 0.1.49 → 0.1.51

package/README.md

@@ -2,16 +2,9 @@
 
 Researcher-facing CLI for LongTable.
 
-LongTable is an npm-first, provider-neutral research harness. It keeps the core
-product contract in project files and shared packages, while Codex skills,
-Claude skills, and future MCP surfaces remain generated adapter artifacts.
-
-The basic contract is:
-
-1. approve provider/runtime support once
-2. start each project inside the provider with `$longtable-interview`
-3. create or resume a workspace from that interview
-4. preserve decisions, tensions, and evidence as durable project state
+LongTable keeps scholarly project state in `.longtable/` and exposes generated
+provider skills for Codex and Claude Code. The CLI installs setup, state,
+checkpoint, search, and diagnostic tooling. It does not replace the provider.
 
 ## Install
 
@@ -19,55 +12,35 @@ The basic contract is:
 npm install -g @longtable/cli
 ```
 
-The npm install only installs the CLI. It does not write Codex skills, MCP
-config, hooks, or provider runtime files without explicit setup approval.
-
 ## Primary Flow
 
-Start Codex from the research folder. The provider uses the shell working
-directory at process start as the session workspace.
-
 ```bash
 longtable setup --provider codex
 cd "<research-folder>"
 codex
 ```
 
-You can use `codex -C "<research-folder>"` instead of `cd` plus `codex`.
-Changing directories after Codex is already running does not change that
-session's workspace root or rerun LongTable's `SessionStart` hook.
-
-Examples:
+Then invoke:
 
-```bash
-# macOS / Linux
-codex -C "/Users/yourname/Research/My-Research-Project"
-```
-
-```powershell
-# Windows PowerShell
-codex -C "C:\Users\YourName\Documents\Research\My-Research-Project"
+```text
+$longtable-start
 ```
 
-Then invoke `$longtable-interview` inside Codex.
-
-`longtable setup --provider codex` is the permission-first setup route. It asks
-where LongTable may install support, which runtime surfaces it may enable, how
-strongly it may interrupt research decisions, and whether to show the
-provider-native interview launch steps. `longtable init` remains only as a
-deprecated compatibility alias.
+`$longtable-start` creates or resumes the workspace, asks open research-start
+questions, and stores a Research Specification when there is enough material.
 
-Return later:
+After a Research Specification exists, use:
 
-```bash
-cd "<project-path>"
-codex
+```text
+$longtable-interview
 ```
 
-Run `longtable resume` inside the project folder when you want a terminal
-summary without starting a provider session.
+`$longtable-interview` is post-start. It uses option-first follow-up choices for
+spec revisions, checkpoint resolution, evidence boundaries, coding rules, method
+choices, and protected decisions. If no usable Research Specification exists, it
+must route to `$longtable-start`.
 
-## What `$longtable-interview` Creates
+## Workspace Artifacts
 
 ```text
 <project>/
@@ -80,221 +53,35 @@ summary without starting a provider session.
     sessions/
 ```
 
-## Artifact Contract
-
-- `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, including First Research
-  Shape and Research Specification when the interview has produced them
-- `.longtable/sessions/`: historical snapshots
-
-`$longtable-interview` first stabilizes a short First Research Shape. When the
-conversation is substantive enough, it should also preserve a Research
-Specification covering scope, construct ontology, theory framing,
-measurement/coding, method options, evidence/access requirements, epistemic
-alignment, protected decisions, open questions, and next actions. `CURRENT.md`
-renders that specification so later agents do not need to reconstruct the full
-interview from memory.
-
-## Why This Shape
-
-The CLI tries to keep the root simple for novice researchers while preserving enough structure for power users and downstream tooling.
-
-The memory model distinguishes:
-
-- explicit state
-- working state
-- inferred hypotheses
-- open tensions
-- narrative traces
+- `CURRENT.md`: human-readable current project state
+- `.longtable/state.json`: durable memory, questions, decisions, interview
+  turns, evidence records, First Research Shape, and Research Specification
+- `QuestionRecord -> DecisionRecord`: the durable checkpoint lifecycle
 
-This is how LongTable avoids turning tacit knowledge into fake certainty.
+Provider UI is transport. LongTable supports MCP/native structured elicitation,
+interactive TTY selector surfaces, and numbered/plain-text fallback. Tmux is not
+required for LongTable core behavior.
 
 ## Commands
 
 ```bash
-longtable setup
+longtable setup --provider codex
+longtable doctor
+longtable status --cwd "<project-path>"
 longtable resume --cwd "<project-path>"
 longtable roles
-longtable ask --cwd "<project-path>" --prompt "..."
-longtable panel --prompt "..."
-longtable sentinel --prompt "Should I define a new measurement construct?"
-longtable team --prompt "Review this measurement plan." --role editor,measurement_auditor --json
-longtable team --debate --prompt "Review this measurement plan." --role editor,measurement_auditor --json
-longtable codex install-skills
-longtable claude install-skills
-```
-
-Useful structured routes for scripts and debugging:
-
-```bash
-longtable panel --prompt "review this methods section" --json
-longtable review --role methods_critic,measurement_auditor --panel --prompt "review this methods section" --json
-longtable ask --prompt "lt panel: show the disagreement before I commit" --json
-```
-
-## Inside Codex
-
-Natural language should be the default.
-
-Codex UI Researcher Checkpoints are a core LongTable feature when enabled:
-
-```bash
-longtable setup --provider codex --surfaces skills_mcp --checkpoint-ui strong
+longtable question --prompt "<decision context>"
+longtable decide --question <id> --answer <value>
+longtable spec read --cwd "<project-path>"
+longtable search --query "<topic>"
 ```
 
-That setup writes the MCP configuration and Codex elicitation approval needed
-for form-style checkpoint prompts. Without it, LongTable keeps the same
-`QuestionRecord` pending and falls back to numbered text.
-
-## Runtime Boundary
-
-LongTable is not a replacement wrapper for Codex. Markdown docs and generated
-skills are soft policy; hooks, MCP elicitation, CLI gates, and `.longtable/`
-state are the enforcement layers.
-
-LongTable should ask and stop before acting when the next step would change or
-settle one of four high-risk research commitments:
-
-1. Research question or scope
-2. Theory frame or construct map
-3. Measurement, coding, or extraction standard
-4. Method design or analysis strategy
-
-Low-risk reversible work should continue with visible assumptions instead of a
-hook interruption. If human knowledge, AI inference, and durable project state
-conflict, LongTable should prefer the most explicit durable state; if that state
-is not explicit enough, it should ask the researcher for clarity.
-
-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?
-```
-
-Provider-native surfaces are available when installed:
-
-```bash
-longtable codex install-skills
-longtable claude install-skills
-```
-
-By default, provider skills use the compact surface: `longtable`,
-`longtable-interview`, and five short role shortcuts: `longtable-methods`,
-`longtable-measure`, `longtable-theory`, `longtable-reviewer`, and
-`longtable-voice`. `$longtable` remains the general router and can still invoke
-editor, ethics, venue, panel, explore, or review behavior when the request calls
-for it.
-
-Power users can install the legacy full surface explicitly:
-
-```bash
-longtable codex install-skills --surface full
-longtable claude install-skills --surface full
-```
-
-Do not depend on `/prompts`; current Codex builds may reject it.
-
-## Panel Orchestration
-
-Panel orchestration is for moments where disagreement matters: methods risk,
-measurement validity, theory fit, literature positioning, and claims that need
-challenge before they become project memory.
-
-The CLI creates a provider-neutral `PanelPlan` and returns a planned
-`PanelResult`. When native subagents are unavailable, LongTable uses a stable
-sequential fallback prompt. That keeps the same research semantics available in
-Codex and Claude Code without making either provider's native question or agent
-tool the source of truth.
-
-Inside a LongTable project workspace, panel planning also appends an
-`InvocationRecord` to `.longtable/state.json`, creates a pending follow-up
-`QuestionRecord`, and refreshes `CURRENT.md`.
-
-Panel output should remain inspectable. A panel or debate result is expected to
-show the consulted roles, each role's main claim or objection, the disagreement
-map, decision options, a defensible recommendation when one exists, and the
-exact researcher-facing question before a high-stakes decision is treated as
-settled.
-
-Default panel roles include:
-
-- `reviewer`
-- `methods_critic`
-- `measurement_auditor`
-- `theory_critic`
-
-Use `--role` to constrain the panel when the research problem is already clear.
-
-## Sentinel And Agent Team
-
-`longtable sentinel` is an explicit gap/tacit check for prompts that may contain
-measurement, theory, method, evidence, authorship, or tacit-assumption risks.
-Use `--record` inside a LongTable workspace to store the finding as an
-unconfirmed inferred hypothesis.
-
-The Codex hook stays quiet for advisory-only questions. Required hook context is
-reserved for durable Researcher Checkpoints, especially when a prompt would
-change the research question/scope, theory frame, measurement/coding standard,
-method design, or analysis strategy. Low-risk reversible work should proceed
-with visible assumptions rather than a noisy hook interruption.
-
-`longtable team` creates a file-backed agent-team review under
-`.longtable/team/<id>/`: independent review, cross-review, and
-synthesis/checkpoint. Use it when roles should inspect each other's concerns
-before LongTable proposes a researcher decision.
-
-`longtable team --debate` creates a fixed five-round debate record under
-`.longtable/team/<id>/`: independent review, cross-review, rebuttal,
-convergence, and synthesis/checkpoint. The file-backed artifact directory is
-the source of truth.
-
-See `docs/AGENT-TEAM-README.md` in the repository for a user-facing guide to
-panel, team, and debate surfaces.
-
-## Evidence And Search Direction
-
-LongTable should not behave like a generic web scraper. Research search should
-start from scholarly routes when the user needs literature discovery, citation
-verification, publication metadata, or evidence-backed research decisions.
-
-`longtable search` routes research queries through arXiv, Crossref, OpenAlex,
-Semantic Scholar, PubMed/NCBI, ERIC, DOAJ, and Unpaywall, then normalizes,
-deduplicates, ranks, and labels results as evidence cards. Some sources work
-without keys, some require a contact email, and some need API keys for reliable
-use.
-
-Scholarly access is configured separately through `longtable access setup`.
-It records readiness for metadata, OA full text, institutional access,
-publisher API/TDM credentials, and manual PDFs without storing secrets.
-Publisher probes cover Elsevier, Springer Nature, Wiley, and Taylor & Francis.
-
-Citation support should be checked explicitly. A reference can be useful as
-background while still failing to support the specific claim attached to it.
-
-```bash
-longtable access setup
-longtable access probe --doi "10.1016/example" --publisher elsevier
-longtable search --query "trust calibration measurement" --intent measurement
-longtable search --query "trust calibration measurement" --publisher-access --json
-longtable search --query "trust calibration citation support" --intent citation --record
-```
-
-See:
-
-- [Research Search](https://github.com/HosungYou/LongTable/blob/main/docs/RESEARCH-SEARCH.md)
-- [Evidence Policy](https://github.com/HosungYou/LongTable/blob/main/docs/EVIDENCE-POLICY.md)
-- [LongTable Command Surface](https://github.com/HosungYou/LongTable/blob/main/docs/LONGTABLE-COMMAND-SURFACE.md)
+`longtable start` remains available for scripted workspace creation with
+`--no-interview --json`, but it is not the primary research-start surface.
 
-## Validation
+## Development
 
 ```bash
-npm install
-npm run typecheck
-npm run build
+npm run build --workspace @longtable/cli
+npm run typecheck --workspace @longtable/cli
 ```

package/dist/cli.js

@@ -112,16 +112,16 @@ function renderBrandBanner(title, subtitle) {
 }
 function renderInterviewLaunchSteps(provider) {
     const command = provider === "codex" ? "codex" : "claude";
-    return renderSectionCard("LongTable Interview", [
+    return renderSectionCard("LongTable Start", [
         "Setup is permission and runtime calibration, not the research interview.",
         "The first research conversation now happens inside the provider so the model can listen, reflect, and ask one natural-language follow-up at a time.",
         "",
         "Next:",
         "1. cd \"<research-folder>\"",
         `2. run \`${command}\``,
-        "3. invoke `$longtable-interview`",
+        "3. invoke `$longtable-start`",
         "",
-        "The interview will create or resume `.longtable/`, may store a short First Research Shape handle, and uses option UI for the final Research Specification confirmation."
+        "The start interview will create or resume `.longtable/`, may store a short First Research Shape handle, and uses option UI for the final Research Specification confirmation."
     ]);
 }
 function renderProgressBar(current, total) {
@@ -133,7 +133,7 @@ function usage() {
     return [
         "Usage:",
         "  Run `longtable ...` in your terminal, not inside the Codex chat box.",
-        "  LongTable research starts inside Codex or Claude with `$longtable-interview` after setup.",
+        "  LongTable research starts inside Codex or Claude with `$longtable-start` after setup.",
         "",
         "  longtable setup [--provider codex|claude] [--install-scope user|project|none] [--surfaces cli_only|skills|skills_mcp|skills_mcp_sentinel] [--intervention advisory|balanced|strong] [--checkpoint-ui off|interactive|strong] [--workspace create|later] [--project-dir <path>] [--json] [--dir <path>] [--skills-dir <path>] [--runtime-path <file>] [--setup-path <file>]",
         "  longtable init [deprecated alias for setup; full legacy flags still supported for automation]",
@@ -178,7 +178,7 @@ function usage() {
         "Examples:",
         "  longtable setup --provider codex",
         "  cd \"<research-folder>\" && codex",
-        "  $longtable-interview",
+        "  $longtable-start",
         "  longtable start --no-interview --path ~/Research/My-Project --name \"AI Adoption Meta-Analysis\" --goal \"Narrow the review question\"",
         "  longtable doctor",
         "  longtable roles",
@@ -525,12 +525,12 @@ function buildPermissionSetupChoices() {
             {
                 id: "create",
                 label: "Show interview launch steps",
-                description: "Why: research should start inside the provider. What you get: setup finishes with Codex/Claude + $longtable-interview steps. Tradeoff: workspace creation waits for the in-provider interview."
+                description: "Why: research should start inside the provider. What you get: setup finishes with Codex/Claude + $longtable-start steps. Tradeoff: workspace creation waits for the in-provider interview."
             },
             {
                 id: "later",
                 label: "No, prepare runtime only",
-                description: "Why: keeps setup short. What you get: runtime support without project state. Tradeoff: no durable research memory until `$longtable-interview` creates or resumes a workspace."
+                description: "Why: keeps setup short. What you get: runtime support without project state. Tradeoff: no durable research memory until `$longtable-start` creates or resumes a workspace."
             }
         ]
     };
@@ -652,7 +652,7 @@ async function runSetup(args) {
         interventionPosture: effectiveIntervention,
         checkpointUiMode: checkpointUi,
         workspaceCreationPreference: workspacePreference,
-        officialStartSurface: "$longtable-interview",
+        officialStartSurface: "$longtable-start",
         setupPosture: "permission_first",
         teamMode: "panel"
     };
@@ -698,9 +698,9 @@ async function runSetup(args) {
             mcpInstall,
             workspacePreference,
             nextStep: {
-                surface: "$longtable-interview",
+                surface: "$longtable-start",
                 command: provider === "codex" ? "codex" : "claude",
-                description: "Open the provider in the research folder and invoke `$longtable-interview`."
+                description: "Open the provider in the research folder and invoke `$longtable-start`."
             }
         }, null, 2));
         return;
@@ -734,7 +734,7 @@ async function runSetup(args) {
     console.log(renderInterviewLaunchSteps(provider));
     if (workspacePreference === "create") {
         console.log("");
-        console.log("Workspace launch requested. Open the provider in your research folder and run `$longtable-interview`; the interview will create `.longtable/` there.");
+        console.log("Workspace launch requested. Open the provider in your research folder and run `$longtable-start`; the interview will create `.longtable/` there.");
     }
 }
 function perspectiveChoices() {
@@ -2009,6 +2009,7 @@ function buildRoleAuditEntry(provider, spec) {
 function runRoleAudit() {
     const baseSkillNames = new Set([
         "longtable",
+        "longtable-start",
         "longtable-interview",
         "longtable-panel",
         "longtable-explore",
@@ -3624,7 +3625,7 @@ async function runStart(args) {
             "1. longtable setup --provider codex",
             "2. cd \"<research-folder>\"",
             "3. codex",
-            "4. $longtable-interview",
+            "4. $longtable-start",
             "",
             "For automation, pass `--no-interview --json` with `--name`, `--path`, and `--goal`."
         ]));

package/dist/longtable-codex-native-hook.js

@@ -168,15 +168,15 @@ function looksLikeExplicitInterviewPrompt(prompt) {
     if (!normalized) {
         return false;
     }
-    if (/\$longtable-interview\b/i.test(normalized)) {
+    if (/\$longtable-(?:start|interview)\b/i.test(normalized)) {
         return true;
     }
     if (looksLikeLongTableProductOrToolingPrompt(normalized)) {
         return false;
     }
-    return /\bLongTable\b.*\binterview\b/i.test(normalized)
+    return /\bLongTable\b.*\b(?:start|interview)\b/i.test(normalized)
         || /\bfirst research shape\b/i.test(normalized)
-        || /롱테이블.*인터뷰|LongTable.*인터뷰|First Research Shape/i.test(normalized);
+        || /롱테이블.*(?:시작|인터뷰)|LongTable.*인터뷰|First Research Shape/i.test(normalized);
 }
 function looksLikeResearchStateConfirmationPrompt(prompt) {
     if (looksLikeLongTableProductOrToolingPrompt(prompt) && !looksLikeExplicitInterviewPrompt(prompt)) {

package/dist/project-session.d.ts

@@ -1,4 +1,4 @@
-import type { DecisionRecord, EvidenceRecord, InvocationRecord, LongTableQuestionObligation, ProviderKind, QuestionOption, QuestionCommitmentFamily, QuestionEpistemicBasis, QuestionGenerationResult, QuestionOpportunity, QuestionSurface, QuestionRecord, ResearchSpecificationChange, ResearchSpecificationPatch, ResearchSpecificationPatchSource, ResearchSpecificationRevision, ResearchState } from "@longtable/core";
+import type { DecisionRecord, EvidenceRecord, InvocationRecord, LongTableQuestionObligation, ProviderKind, QuestionOption, QuestionCommitmentFamily, QuestionEpistemicBasis, QuestionGenerationResult, QuestionOpportunity, QuestionSurface, QuestionPromptType, QuestionRecord, ResearchSpecificationChange, ResearchSpecificationPatch, ResearchSpecificationPatchSource, ResearchSpecificationRevision, 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";
@@ -393,8 +393,11 @@ export declare function createWorkspaceQuestion(options: {
     prompt: string;
     title?: string;
     question?: string;
+    type?: QuestionPromptType;
     checkpointKey?: string;
     questionOptions?: QuestionOption[];
+    allowOther?: boolean;
+    otherLabel?: string;
     displayReason?: string;
     provider?: ProviderKind;
     required?: boolean;
@@ -404,10 +407,17 @@ export declare function createWorkspaceQuestion(options: {
     question: QuestionRecord;
     state: ResearchState;
 }>;
+type WorkspaceQuestionAnswerInput = string | string[] | {
+    answer?: string | string[];
+    selectedValue?: string;
+    selectedValues?: string[];
+    otherText?: string;
+    rationale?: string;
+};
 export declare function answerWorkspaceQuestion(options: {
     context: LongTableProjectContext;
     questionId?: string;
-    answer: string;
+    answer: WorkspaceQuestionAnswerInput;
     rationale?: string;
     provider?: "codex" | "claude";
     surface?: QuestionSurface;

package/dist/project-session.js

@@ -339,7 +339,7 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
             "",
             "## 빠른 시작",
             "- 이 디렉토리에서 `codex`를 엽니다.",
-            `- 첫 메시지는 보통 \`${session.firstResearchShape ? suggestedPrompt : "$longtable-interview"}\` 정도면 충분합니다.`,
+            `- 첫 메시지는 보통 \`${session.firstResearchShape ? suggestedPrompt : "$longtable-start"}\` 정도면 충분합니다.`,
             "",
             "## 증거 규칙",
             "- 외부 사실이나 현재 정보는 source를 붙이거나 inference로 낮춥니다."
@@ -416,7 +416,7 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
         "",
         "## Quick Start",
         "- Open `codex` in this directory.",
-        `- A good first message is usually \`${session.firstResearchShape ? suggestedPrompt : "$longtable-interview"}\`.`,
+        `- A good first message is usually \`${session.firstResearchShape ? suggestedPrompt : "$longtable-start"}\`.`,
         "",
         "## Evidence Rule",
         "- External or current claims should carry a source link or be labeled as inference."
@@ -878,7 +878,8 @@ 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 `$longtable-start`, run the LongTable research-start flow before generic research advice.",
+        "- If the user message starts with `$longtable-interview`, use post-start structured interview only when a usable Research Specification exists; otherwise route to `$longtable-start`.",
         "- 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: 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.",
@@ -886,13 +887,14 @@ function buildProjectAgentsMd(project, session) {
         "",
         "## 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: ...`, record turns when MCP is available, and avoid early reader/reviewer or theory/method/measurement classification.",
-        "- Do not summarize `$longtable-interview` because a fixed number of turns has passed; wait for content-based readiness around research object, focal uncertainty, boundary, evidence/material, protected decision, and next action.",
+        "- For `$longtable-start`, ask one natural-language question at a time, reflect with `LongTable hears: ...`, record turns when MCP is available, and avoid early reader/reviewer or theory/method/measurement classification.",
+        "- Do not summarize `$longtable-start` because a fixed number of turns has passed; wait for content-based readiness around research object, focal uncertainty, boundary, evidence/material, protected decision, and next action.",
         "- First Research Shape is a short handle/resume index, not the default closure point.",
         "- After the First Research Shape, create a Research Specification when the interview has enough detail to preserve scope, construct ontology, theory framing, coding rules, method options, evidence/access requirements, epistemic alignment, protected decisions, open questions, and next actions.",
         "- If a confirmed First Research Shape exists without a Research Specification, continue directly into the next Research Specification question instead of asking shape-level continue/revise/restart questions.",
         "- If the researcher chooses `ask_one_more` or `revise_section` at Research Specification confirmation, answer that gap and return to the Research Specification Preview before ending the interview.",
-        "- Do not let unrelated pending Researcher Checkpoints interrupt `$longtable-interview`; mention them only as separate unresolved checkpoints unless the researcher is confirming, saving, or recording a research decision.",
+        "- Do not let unrelated pending Researcher Checkpoints interrupt `$longtable-start`; mention them only as separate unresolved checkpoints unless the researcher is confirming, saving, or recording a research decision.",
+        "- For `$longtable-interview` after a Research Specification exists, use option-first follow-up choices with Other/free-text or one open-question escape hatch.",
         "- Use structured options at the final Research Specification confirmation, at explicit short-handle stop points, 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.",
@@ -1195,7 +1197,7 @@ export async function beginLongTableInterview(options) {
         turns: [],
         qualityNotes: [],
         rationale: [
-            "Official LongTable research start surface is provider-native `$longtable-interview`, not the CLI start questionnaire.",
+            "Official LongTable research start surface is provider-native `$longtable-start`, not the CLI start questionnaire.",
             "The hook keeps early research ambiguity open until a first research handle can be summarized."
         ]
     };
@@ -1203,7 +1205,7 @@ export async function beginLongTableInterview(options) {
     updated.workingState = {
         ...updated.workingState,
         activeInterviewHookId: hook.id,
-        interviewSurface: "$longtable-interview",
+        interviewSurface: "$longtable-start",
         ...(options.openingQuestion ? { interviewOpeningQuestion: options.openingQuestion } : {}),
         ...(options.seedAnswer ? { interviewSeedAnswer: options.seedAnswer } : {})
     };
@@ -1335,7 +1337,7 @@ export async function summarizeLongTableInterview(options) {
     updated.narrativeTraces.push({
         id: createId("narrative_trace"),
         timestamp,
-        source: "$longtable-interview",
+        source: "$longtable-start",
         traceType: "judgment",
         summary: `First Research Shape: ${shape.handle}.`,
         visibility: "explicit",
@@ -1457,7 +1459,7 @@ export async function summarizeLongTableResearchSpecification(options) {
     updated.narrativeTraces.push({
         id: createId("narrative_trace"),
         timestamp,
-        source: "$longtable-interview",
+        source: "$longtable-start",
         traceType: "judgment",
         summary: `Research Specification draft: ${specification.title}.`,
         visibility: "explicit",
@@ -2397,6 +2399,7 @@ export async function createWorkspaceQuestion(options) {
         studyContract: state.studyContract
     });
     const checkpointKey = options.checkpointKey ?? trigger.signal.checkpointKey;
+    const promptType = options.type ?? "single_choice";
     const createdAt = nowIso();
     const title = options.title ?? questionTitleForCheckpoint(trigger.family, checkpointKey);
     const questionText = options.question ?? questionTextForCheckpoint(trigger.family, options.prompt, checkpointKey);
@@ -2427,10 +2430,10 @@ export async function createWorkspaceQuestion(options) {
             checkpointKey,
             title,
             question: questionText,
-            type: "single_choice",
+            type: promptType,
             options: options.questionOptions ?? optionsForCheckpointTrigger(trigger.family, checkpointKey),
-            allowOther: true,
-            otherLabel: "Other decision",
+            allowOther: options.allowOther ?? promptType !== "free_text",
+            otherLabel: options.otherLabel ?? "Other decision",
             required: options.required ?? trigger.requiresQuestionBeforeClosure,
             source: "checkpoint",
             displayReason: options.displayReason ?? trigger.rationale[0],
@@ -2486,53 +2489,159 @@ function splitAnswerAndRationale(rawAnswer) {
         ...(rationale ? { rationale } : {})
     };
 }
-function normalizeQuestionAnswerSelection(question, rawAnswer) {
-    const trimmed = rawAnswer.trim();
-    const { selection, rationale } = splitAnswerAndRationale(trimmed);
-    const numeric = Number(selection);
-    if (/^\d+$/.test(selection) && Number.isInteger(numeric)) {
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function answerInputParts(input) {
+    if (typeof input === "string") {
+        return { values: [input], rawText: input };
+    }
+    if (Array.isArray(input)) {
+        return { values: input };
+    }
+    let values = input.selectedValues ?? [];
+    if (values.length === 0 && input.selectedValue) {
+        values = [input.selectedValue];
+    }
+    if (values.length === 0 && Array.isArray(input.answer)) {
+        values = input.answer;
+    }
+    if (values.length === 0 && typeof input.answer === "string") {
+        values = [input.answer];
+    }
+    const otherText = input.otherText?.trim();
+    const rationale = input.rationale?.trim();
+    return {
+        values,
+        ...(otherText ? { otherText } : {}),
+        ...(rationale ? { inlineRationale: rationale } : {})
+    };
+}
+function splitSelectionTokens(selection, type) {
+    if (type !== "multi_choice") {
+        return [selection];
+    }
+    return selection.split(/[;,]/).map((token) => token.trim()).filter(Boolean);
+}
+function normalizeFreeTextAnswer(input) {
+    const parts = answerInputParts(input);
+    const selectedText = parts.values.join("\n").trim();
+    const text = parts.rawText ?? (selectedText || parts.otherText || "");
+    const trimmed = text.trim();
+    if (!trimmed) {
+        throw new Error("Free-text LongTable question answers cannot be empty.");
+    }
+    return {
+        selectedValues: [trimmed],
+        selectedLabels: [trimmed],
+        otherText: trimmed,
+        ...(parts.inlineRationale ? { inlineRationale: parts.inlineRationale } : {})
+    };
+}
+function resolveQuestionAnswerToken(question, token) {
+    const trimmed = token.trim();
+    if (!trimmed) {
+        throw new Error("LongTable question answers cannot contain empty selections.");
+    }
+    const numeric = Number(trimmed);
+    if (/^\d+$/.test(trimmed) && Number.isInteger(numeric)) {
         const option = question.prompt.options[numeric - 1];
         if (option) {
             return {
                 selectedValue: option.value,
-                selectedLabel: option.label,
-                ...(rationale ? { inlineRationale: rationale } : {})
+                selectedLabel: option.label
             };
         }
         if (question.prompt.allowOther && numeric === question.prompt.options.length + 1) {
             return {
                 selectedValue: "other",
-                selectedLabel: question.prompt.otherLabel ?? "Other",
-                ...(rationale ? { inlineRationale: rationale } : {})
+                selectedLabel: question.prompt.otherLabel ?? "Other"
             };
         }
-        throw new Error(`Answer ${selection} is outside the available LongTable question options.`);
+        throw new Error(`Answer ${trimmed} is outside the available LongTable question options.`);
     }
-    const normalizedSelection = normalizeAnswerToken(selection);
+    const normalizedSelection = normalizeAnswerToken(trimmed);
     const option = question.prompt.options.find((candidate) => optionAnswerCandidates(candidate).includes(normalizedSelection));
     if (option) {
         return {
             selectedValue: option.value,
-            selectedLabel: option.label,
-            ...(rationale ? { inlineRationale: rationale } : {})
+            selectedLabel: option.label
         };
     }
     if (normalizedSelection === "other" && question.prompt.allowOther) {
         return {
             selectedValue: "other",
-            selectedLabel: question.prompt.otherLabel ?? "Other",
-            ...(rationale ? { inlineRationale: rationale } : {})
+            selectedLabel: question.prompt.otherLabel ?? "Other"
         };
     }
     if (question.prompt.allowOther) {
         return {
-            selectedValue: "other",
-            selectedLabel: selection,
-            otherText: trimmed,
-            ...(rationale ? { inlineRationale: rationale } : {})
+            selectedValue: trimmed,
+            selectedLabel: question.prompt.otherLabel ?? "Other",
+            otherText: trimmed
         };
     }
-    throw new Error(`Answer "${selection}" does not match a LongTable question option.`);
+    throw new Error(`Answer "${trimmed}" does not match a LongTable question option.`);
+}
+function isOtherAnswerToken(question, token) {
+    if (!question.prompt.allowOther) {
+        return false;
+    }
+    const trimmed = token.trim();
+    const normalized = normalizeAnswerToken(trimmed);
+    const otherLabel = normalizeAnswerToken(question.prompt.otherLabel ?? "Other");
+    if (normalized === "other" || normalized === otherLabel) {
+        return true;
+    }
+    const numeric = Number(trimmed);
+    return /^\d+$/.test(trimmed) && Number.isInteger(numeric) && numeric === question.prompt.options.length + 1;
+}
+function normalizeQuestionAnswerSelection(question, rawAnswer) {
+    if (question.prompt.type === "free_text") {
+        return normalizeFreeTextAnswer(rawAnswer);
+    }
+    const parts = answerInputParts(rawAnswer);
+    const parsedValues = parts.values.flatMap((value) => {
+        if (typeof rawAnswer === "string") {
+            const { selection } = splitAnswerAndRationale(value.trim());
+            return splitSelectionTokens(selection, question.prompt.type);
+        }
+        return splitSelectionTokens(value, question.prompt.type);
+    });
+    const inlineRationale = typeof rawAnswer === "string"
+        ? splitAnswerAndRationale(rawAnswer.trim()).rationale
+        : parts.inlineRationale;
+    const hasOtherText = Boolean(parts.otherText);
+    const hasOtherToken = parsedValues.some((value) => isOtherAnswerToken(question, value));
+    if (hasOtherText && !hasOtherToken) {
+        throw new Error("Other text requires selecting the LongTable question Other option.");
+    }
+    const selectionTokens = parts.otherText
+        ? parsedValues.filter((value) => !isOtherAnswerToken(question, value))
+        : parsedValues;
+    const tokens = uniqueStrings([
+        ...selectionTokens,
+        ...(parts.otherText ? [parts.otherText] : [])
+    ]);
+    if (tokens.length === 0) {
+        throw new Error("LongTable question answers cannot be empty.");
+    }
+    if (question.prompt.type !== "multi_choice" && tokens.length > 1) {
+        throw new Error("Single-choice LongTable questions accept exactly one answer.");
+    }
+    const resolved = tokens.map((token) => resolveQuestionAnswerToken(question, token));
+    const selectedValues = uniqueStrings(resolved.map((entry) => entry.selectedValue));
+    const selectedLabels = selectedValues.map((value) => {
+        const entry = resolved.find((candidate) => candidate.selectedValue === value);
+        return entry?.selectedLabel ?? value;
+    });
+    const otherText = parts.otherText ?? resolved.map((entry) => entry.otherText).find(Boolean);
+    return {
+        selectedValues,
+        selectedLabels,
+        ...(otherText ? { otherText } : {}),
+        ...(inlineRationale ? { inlineRationale } : {})
+    };
 }
 export async function answerWorkspaceQuestion(options) {
     const state = await loadResearchState(options.context.stateFilePath);
@@ -2546,8 +2655,8 @@ export async function answerWorkspaceQuestion(options) {
         .join("\n");
     const answer = {
         promptId: question.prompt.id,
-        selectedValues: [normalized.selectedValue],
-        selectedLabels: [normalized.selectedLabel],
+        selectedValues: normalized.selectedValues,
+        selectedLabels: normalized.selectedLabels,
         ...(normalized.otherText ? { otherText: normalized.otherText } : {}),
         ...(rationale ? { rationale } : {}),
         ...(options.provider ? { provider: options.provider } : {}),
@@ -2564,6 +2673,7 @@ export async function answerWorkspaceQuestion(options) {
         ...(question.commitmentFamily ? { commitmentFamily: question.commitmentFamily } : {}),
         ...(question.epistemicBasis ? { epistemicBasis: question.epistemicBasis } : {}),
         selectedOption: answer.selectedValues[0],
+        selectedOptions: answer.selectedValues,
         ...(rationale ? { rationale } : {})
     };
     const answeredQuestion = {

package/dist/prompt-aliases.js

@@ -29,7 +29,7 @@ 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-interview` inside Codex for the project interview.",
+                "Treat `longtable init` as deprecated. Prefer `longtable setup --provider codex` for runtime permissions, then `$longtable-start` 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.",
@@ -37,10 +37,10 @@ function promptSpec() {
                 "Do not ask for field, career stage, experience level, authorship signal, weakest domain, or panel preference during runtime setup.",
                 "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, tell them to open Codex in the research folder and invoke `$longtable-interview`.",
+                "If the researcher is ready to create a project workspace, tell them to open Codex in the research folder and invoke `$longtable-start`.",
                 "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-interview`.",
+                "Do not pretend setup is the full project-start interview. The project-start interview happens in `$longtable-start`.",
                 "Treat any slash-command arguments as context for why setup is being done now."
             ]
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longtable/cli",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "private": false,
   "description": "Researcher-facing LongTable CLI",
   "type": "module",
@@ -29,12 +29,12 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.2.0",
-    "@longtable/checkpoints": "0.1.49",
-    "@longtable/core": "0.1.49",
-    "@longtable/memory": "0.1.49",
-    "@longtable/provider-claude": "0.1.49",
-    "@longtable/provider-codex": "0.1.49",
-    "@longtable/setup": "0.1.49"
+    "@longtable/checkpoints": "0.1.51",
+    "@longtable/core": "0.1.51",
+    "@longtable/memory": "0.1.51",
+    "@longtable/provider-claude": "0.1.51",
+    "@longtable/provider-codex": "0.1.51",
+    "@longtable/setup": "0.1.51"
   },
   "devDependencies": {
     "@types/node": "^22.10.1",