@longtable/cli 0.1.50 → 0.1.52

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-start` creates or resumes the workspace, asks open research-start
+questions, and stores a Research Specification when there is enough material.
 
-`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.
+After a Research Specification exists, use:
 
-Return later:
-
-```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,51 @@ 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.
+- `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
 
-The memory model distinguishes:
-
-- explicit state
-- working state
-- inferred hypotheses
-- open tensions
-- narrative traces
-
-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
+longtable question --prompt "<decision context>"
+longtable decide --question <id> --answer <value>
+longtable spec read --cwd "<project-path>"
+longtable search --query "<topic>"
 ```
 
-Useful structured routes for scripts and debugging:
+`longtable start` remains available for scripted workspace creation with
+`--no-interview --json`, but it is not the primary research-start surface.
 
-```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:
+## Development
 
 ```bash
-longtable setup --provider codex --surfaces skills_mcp --checkpoint-ui strong
+npm run build --workspace @longtable/cli
+npm run typecheck --workspace @longtable/cli
 ```
 
-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?
-```
+## Codex hard-stop diagnostics
 
-Provider-native surfaces are available when installed:
+Codex `Stop` blocks only active LongTable hard-stop blockers: unresolved
+Research Specification question, scope, construct, method, evidence, or protected
+decision commitments. Use:
 
 ```bash
-longtable codex install-skills
-longtable claude install-skills
+longtable codex hook-doctor --json
+longtable codex status --json
+longtable doctor --json
 ```
 
-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)
-
-## Validation
-
-```bash
-npm install
-npm run typecheck
-npm run build
-```
+to inspect hook coverage/trust plus `stopWouldBlock`, `activeBlockers`, stale
+pending-question counts, and next actions. Tmux remains an optional terminal
+transport; LongTable state and hooks own the behavior.

package/dist/cli.js

@@ -8,6 +8,7 @@ import { stdin as input, stdout as output, cwd, env, exit } from "node:process";
 import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
+import { collectHardStopBlockers } from "@longtable/core";
 import { classifyCheckpointTrigger } from "@longtable/checkpoints";
 import { assessSearchSourceCapabilities, buildResearchSearchIntent, parsePublisherTarget, probePublisherAccess, publisherConfigs, runResearchSearch, SEARCH_SOURCES, summarizeConfiguredPublisherAccess } from "./search/index.js";
 import { buildProviderChoices, buildQuickSetupFlow, createPersistedSetupOutput, installRuntimeConfigFromStoredSetup, loadSetupOutput, renderInstallSummary, renderSetupSummary, resolveDefaultRuntimeConfigPath, resolveDefaultSetupPath, saveSetupOutput, saveSetupAndRuntimeConfig, serializeSetupOutput, writeRuntimeConfig } from "@longtable/setup";
@@ -112,16 +113,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 +134,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]",
@@ -169,6 +170,7 @@ function usage() {
         "  longtable codex install-hooks [--codex-config <path>] [--hooks-path <path>] [--json]",
         "  longtable codex remove-hooks [--codex-config <path>] [--hooks-path <path>] [--json]",
         "  longtable codex status [--surface compact|full] [--dir <path>] [--codex-config <path>] [--hooks-path <path>] [--json]",
+        "  longtable codex hook-doctor [--cwd <path>] [--codex-config <path>] [--hooks-path <path>] [--json]",
         "  longtable claude install-skills [--surface compact|full] [--dir <path>]",
         "  longtable claude remove-skills [--dir <path>]",
         "  longtable claude status [--surface compact|full] [--dir <path>] [--json]",
@@ -178,7 +180,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 +527,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 +654,7 @@ async function runSetup(args) {
         interventionPosture: effectiveIntervention,
         checkpointUiMode: checkpointUi,
         workspaceCreationPreference: workspacePreference,
-        officialStartSurface: "$longtable-interview",
+        officialStartSurface: "$longtable-start",
         setupPosture: "permission_first",
         teamMode: "panel"
     };
@@ -698,9 +700,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 +736,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() {
@@ -1527,6 +1529,22 @@ function setupForProvider(setup, provider) {
             }
     };
 }
+async function collectHardStopDiagnostics(startPath) {
+    const empty = {
+        stopWouldBlock: false,
+        activeBlockers: [],
+        staleOrUnrelatedPendingQuestionCount: 0,
+        stalePendingQuestionCount: 0,
+        stalePendingObligationCount: 0,
+        nextActions: []
+    };
+    const context = await loadProjectContextFromDirectory(startPath);
+    if (!context) {
+        return empty;
+    }
+    const state = await loadWorkspaceState(context);
+    return collectHardStopBlockers(state);
+}
 async function collectDoctorStatus(args) {
     const roles = listRoleDefinitions();
     const skillSurface = parseSkillSurface(args);
@@ -1579,11 +1597,13 @@ async function collectDoctorStatus(args) {
         : [];
     const expectedCodexSkills = buildCodexSkillSpecs(roles, skillSurface).map((skill) => skill.name);
     const expectedClaudeSkills = buildClaudeSkillSpecs(roles, skillSurface).map((skill) => skill.name);
-    const [codexSkills, claudeSkills, codexAliases, workspace] = await Promise.all([
+    const workspacePath = typeof args.cwd === "string" ? args.cwd : cwd();
+    const [codexSkills, claudeSkills, codexAliases, workspace, hardStop] = await Promise.all([
         listInstalledCodexSkills(roles, codexDir, skillSurface),
         listInstalledClaudeSkills(roles, claudeDir, skillSurface),
         listInstalledCodexPromptAliases(codexPromptsDir),
-        inspectProjectWorkspace(typeof args.cwd === "string" ? args.cwd : cwd())
+        inspectProjectWorkspace(workspacePath),
+        collectHardStopDiagnostics(workspacePath)
     ]);
     const installedCodexSkills = codexSkills.map((skill) => skill.name);
     const installedClaudeSkills = claudeSkills.map((skill) => skill.name);
@@ -1614,7 +1634,12 @@ async function collectDoctorStatus(args) {
                 hooksExists: existsSync(codexHooksPath),
                 codexHooksEnabled: codexHooksEnabled(codexMcpConfig),
                 missingManagedHookEvents,
-                missingManagedHookTrustState
+                missingManagedHookTrustState,
+                stopWouldBlock: hardStop.stopWouldBlock,
+                activeBlockers: hardStop.activeBlockers,
+                stalePendingQuestionCount: hardStop.stalePendingQuestionCount,
+                stalePendingObligationCount: hardStop.stalePendingObligationCount,
+                nextActions: hardStop.nextActions
             },
             claude: {
                 command: "claude",
@@ -1627,7 +1652,8 @@ async function collectDoctorStatus(args) {
                 missingSkills: missingNames(expectedClaudeSkills, installedClaudeSkills)
             }
         },
-        workspace
+        workspace,
+        hardStop
     };
 }
 function renderProviderDoctorBlock(label, provider) {
@@ -1665,6 +1691,9 @@ function renderDoctorStatus(status) {
         `- hooks feature: ${status.providers.codex.codexHooksEnabled ? "enabled" : "missing"}`,
         `- managed hook coverage: ${status.providers.codex.missingManagedHookEvents.length === 0 ? "complete" : `missing ${status.providers.codex.missingManagedHookEvents.join(", ")}`}`,
         `- managed hook trust: ${status.providers.codex.missingManagedHookTrustState.length === 0 ? "current" : `missing/stale ${status.providers.codex.missingManagedHookTrustState.length}`}`,
+        `- Stop would block now: ${status.hardStop.stopWouldBlock ? "yes" : "no"}`,
+        `- active hard-stop blockers: ${status.hardStop.activeBlockers.length}`,
+        `- stale/unrelated pending questions: ${status.hardStop.staleOrUnrelatedPendingQuestionCount}`,
         "",
         ...renderProviderDoctorBlock("Claude", status.providers.claude),
         "",
@@ -1675,7 +1704,7 @@ function renderDoctorStatus(status) {
     }
     else {
         const workspace = status.workspace;
-        lines.push(`- project: ${workspace.project?.name ?? "unknown"}`, `- root: ${workspace.rootPath ?? "unknown"}`, `- goal: ${workspace.session?.currentGoal ?? "unknown"}`, `- invocations: ${workspace.counts?.invocations ?? 0}`, `- questions: ${workspace.counts?.questions ?? 0} (${workspace.counts?.pendingQuestions ?? 0} pending, ${workspace.counts?.answeredQuestions ?? 0} answered)`, `- obligations: ${workspace.counts?.pendingObligations ?? 0} pending`, `- decisions: ${workspace.counts?.decisions ?? 0}`);
+        lines.push(`- project: ${workspace.project?.name ?? "unknown"}`, `- root: ${workspace.rootPath ?? "unknown"}`, `- goal: ${workspace.session?.currentGoal ?? "unknown"}`, `- invocations: ${workspace.counts?.invocations ?? 0}`, `- questions: ${workspace.counts?.questions ?? 0} (${workspace.counts?.pendingQuestions ?? 0} pending, ${workspace.counts?.answeredQuestions ?? 0} answered)`, `- obligations: ${workspace.counts?.pendingObligations ?? 0} pending`, `- Stop hard-stop: ${workspace.hardStop?.stopWouldBlock ? "would block" : "clear"}`, `- stale/unrelated pending: ${workspace.hardStop?.stalePendingQuestionCount ?? 0} questions, ${workspace.hardStop?.stalePendingObligationCount ?? 0} obligations`, `- decisions: ${workspace.counts?.decisions ?? 0}`);
         if ((workspace.recentInvocations ?? []).length > 0) {
             lines.push("- recent invocations:");
             for (const invocation of workspace.recentInvocations ?? []) {
@@ -1689,12 +1718,25 @@ function renderDoctorStatus(status) {
                 lines.push(`  - ${question.id}: ${question.question} (${question.options.join("/")})`);
             }
         }
+        if (status.hardStop.activeBlockers.length > 0) {
+            lines.push("- active hard-stop blockers:");
+            for (const blocker of status.hardStop.activeBlockers) {
+                lines.push(`  - ${blocker.id}: ${blocker.scope} (${blocker.type})`);
+            }
+        }
         if ((workspace.pendingObligations ?? []).length > 0) {
             lines.push("- pending obligations:");
             for (const obligation of workspace.pendingObligations ?? []) {
                 lines.push(`  - ${obligation.id}: ${obligation.prompt}`);
             }
         }
+        if ((workspace.hardStop?.activeBlockers ?? []).length > 0) {
+            lines.push("- hard-stop blockers:");
+            for (const blocker of workspace.hardStop?.activeBlockers ?? []) {
+                lines.push(`  - ${blocker.id} [${blocker.scope}]: ${blocker.prompt}`);
+                lines.push(`    next: ${blocker.commandHint}`);
+            }
+        }
         if ((workspace.answerWarnings ?? []).length > 0) {
             lines.push("- answer warnings:");
             for (const warning of workspace.answerWarnings ?? []) {
@@ -1736,10 +1778,16 @@ function renderDoctorStatus(status) {
     if (!status.workspace.found) {
         nextActions.push("longtable start");
     }
+    nextActions.push(...status.hardStop.nextActions);
     const firstQuestion = status.workspace.pendingQuestions?.[0];
-    if (firstQuestion) {
+    if (firstQuestion && status.hardStop.nextActions.length === 0) {
         nextActions.push(`longtable decide --question ${firstQuestion.id} --answer <value>`);
     }
+    for (const action of status.workspace.hardStop?.nextActions ?? []) {
+        if (!nextActions.includes(action)) {
+            nextActions.push(action);
+        }
+    }
     if (nextActions.length > 0) {
         lines.push("", "Next actions:");
         for (const action of nextActions) {
@@ -2009,6 +2057,7 @@ function buildRoleAuditEntry(provider, spec) {
 function runRoleAudit() {
     const baseSkillNames = new Set([
         "longtable",
+        "longtable-start",
         "longtable-interview",
         "longtable-panel",
         "longtable-explore",
@@ -2812,7 +2861,7 @@ async function runAccess(subcommand, args) {
         await runAccessSetup(args);
         return;
     }
-    if (subcommand === "status") {
+    if (subcommand === "status" || subcommand === "hook-doctor") {
         await runAccessStatus(args);
         return;
     }
@@ -3624,7 +3673,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`."
         ]));
@@ -3767,7 +3816,7 @@ async function runCodexSubcommand(subcommand, args) {
         console.log(renderCodexHookInstallSummary(result));
         return;
     }
-    if (subcommand === "status") {
+    if (subcommand === "status" || subcommand === "hook-doctor") {
         const aliases = await listInstalledCodexPromptAliases(customDir);
         const skills = await listInstalledCodexSkills(roles, customDir, skillSurface);
         const setupPath = resolveDefaultSetupPath(typeof args.path === "string" ? args.path : undefined).path;
@@ -3776,6 +3825,7 @@ async function runCodexSubcommand(subcommand, args) {
         const configContent = existsSync(configPath) ? await readFile(configPath, "utf8") : "";
         const hooksPath = resolveCodexHooksPath(args);
         const hooksContent = existsSync(hooksPath) ? await readFile(hooksPath, "utf8") : "";
+        const workspace = await inspectProjectWorkspace(typeof args.cwd === "string" ? args.cwd : cwd());
         const status = {
             setupPath,
             setupExists: existsSync(setupPath),
@@ -3795,13 +3845,21 @@ async function runCodexSubcommand(subcommand, args) {
                 : [...LONGTABLE_MANAGED_HOOK_EVENTS],
             missingManagedHookTrustState: hooksContent
                 ? getMissingManagedCodexHookTrustState(configContent, hooksPath, hooksContent)
-                : []
+                : [],
+            workspaceHardStop: workspace.hardStop ?? {
+                stopWouldBlock: false,
+                activeBlockers: [],
+                staleOrUnrelatedPendingQuestionCount: 0,
+                stalePendingQuestionCount: 0,
+                stalePendingObligationCount: 0,
+                nextActions: []
+            }
         };
         if (args.json === true) {
             console.log(JSON.stringify(status, null, 2));
             return;
         }
-        console.log("LongTable Codex status");
+        console.log(subcommand === "hook-doctor" ? "LongTable Codex hook doctor" : "LongTable Codex status");
         console.log(`- setup: ${status.setupExists ? "present" : "missing"} (${setupPath})`);
         console.log(`- codex runtime artifact: ${status.runtimeExists ? "present" : "missing"} (${runtimePath})`);
         console.log(`- skills dir: ${status.skillsDir}`);
@@ -3831,6 +3889,9 @@ async function runCodexSubcommand(subcommand, args) {
         console.log(`- hooks file: ${status.hooksExists ? "present" : "missing"} (${status.hooksPath})`);
         console.log(`- managed hook coverage: ${status.missingManagedHookEvents.length === 0 ? "complete" : `missing ${status.missingManagedHookEvents.join(", ")}`}`);
         console.log(`- managed hook trust: ${status.missingManagedHookTrustState.length === 0 ? "current" : `missing/stale ${status.missingManagedHookTrustState.length}`}`);
+        console.log(`- Stop hard-stop: ${status.workspaceHardStop.stopWouldBlock ? "would block" : "clear"}`);
+        console.log(`- active hard-stop blockers: ${status.workspaceHardStop.activeBlockers.length}`);
+        console.log(`- stale/unrelated pending: ${status.workspaceHardStop.stalePendingQuestionCount} questions, ${status.workspaceHardStop.stalePendingObligationCount} obligations`);
         return;
     }
     throw new Error("Unknown codex subcommand.");

package/dist/codex-hooks.js

@@ -48,14 +48,12 @@ export function buildManagedCodexHooksConfig(packageRoot) {
             ],
             PreToolUse: [
                 buildCommandHook(command, {
-                    matcher: "Bash",
-                    statusMessage: "Running LongTable checkpoint guard"
+                    matcher: "Bash"
                 })
             ],
             PostToolUse: [
                 buildCommandHook(command, {
-                    matcher: "Bash",
-                    statusMessage: "Reviewing LongTable post-tool state"
+                    matcher: "Bash"
                 })
             ],
             UserPromptSubmit: [

package/dist/hard-stop.d.ts

@@ -0,0 +1,2 @@
+export { collectHardStopBlockers } from "@longtable/core";
+export type { HardStopBlocker, HardStopBlockerType, HardStopVerdict } from "@longtable/core";

package/dist/hard-stop.js

@@ -0,0 +1 @@
+export { collectHardStopBlockers } from "@longtable/core";

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export * from "./persona-router.js";
 export * from "./panel.js";
 export * from "./project-session.js";
 export * from "./question-obligations.js";
+export * from "./hard-stop.js";

package/dist/index.js

@@ -5,3 +5,4 @@ export * from "./persona-router.js";
 export * from "./panel.js";
 export * from "./project-session.js";
 export * from "./question-obligations.js";
+export * from "./hard-stop.js";

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

@@ -1,4 +1,5 @@
 import { pathToFileURL } from "node:url";
+import { collectHardStopBlockers } from "@longtable/core";
 import { createWorkspaceFollowUpQuestions, loadProjectContextFromDirectory, loadWorkspaceState, pendingQuestionObligations } from "./index.js";
 function safeString(value) {
     return typeof value === "string" ? value : "";
@@ -66,6 +67,9 @@ function formatQuestionOptions(question) {
 function pendingRequiredQuestions(state) {
     return (state.questionLog ?? []).filter((question) => question.status === "pending" && question.prompt.required);
 }
+function hardStopBlockers(state) {
+    return collectHardStopBlockers(state).activeBlockers;
+}
 function pendingObligations(state) {
     return pendingQuestionObligations(state);
 }
@@ -168,15 +172,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)) {
@@ -283,6 +287,22 @@ function buildGeneratedQuestionsContext(questions, created) {
     lines.push("Do not choose or record answers for these checkpoints unless the researcher explicitly provides the selections.");
     return lines.join("\n");
 }
+function buildHardStopBlockerContext(blocker) {
+    return [
+        `LongTable hard-stop blocker ${blocker.id} affects ${blocker.scope.replace(/_/g, " ")}.`,
+        blocker.prompt,
+        blocker.reason,
+        `Next action: ${blocker.commandHints[0] ?? "decide, clear, or defer with rationale"}`
+    ].join("\n");
+}
+function buildStopBlockerReason(blocker, count) {
+    const suffix = count > 1 ? ` (${count} active blockers total)` : "";
+    return [
+        `LongTable hard-stop ${blocker.id}${suffix}: ${blocker.scope.replace(/_/g, " ")}.`,
+        compactContextValue(blocker.prompt, 120),
+        `Required next action: ${blocker.commandHints[0] ?? "decide, clear, or defer with rationale"}.`
+    ].join(" ");
+}
 function buildPendingObligationContext(obligation) {
     return [
         `Pending LongTable research obligation: ${obligation.prompt}`,
@@ -298,6 +318,21 @@ function buildSeparatePendingObligationNotice(obligation) {
         "This is not part of the active interview. Keep it visible only when the researcher is settling or saving the research direction."
     ].join("\n");
 }
+function buildHardStopContext(runtime) {
+    const verdict = collectHardStopBlockers(runtime.state);
+    const blocker = verdict.activeBlockers[0];
+    if (!blocker) {
+        return null;
+    }
+    return [
+        `Hard-stop Researcher Checkpoint is still pending: ${blocker.id}`,
+        `Affected Research Specification area: ${blocker.scope}`,
+        `Question/obligation: ${blocker.prompt}`,
+        `Reason: ${blocker.reason}`,
+        `Required next action: ${blocker.commandHint}; or clear/defer it with an explicit rationale.`,
+        verdict.activeBlockers.length > 1 ? `Additional hard-stop blockers: ${verdict.activeBlockers.length - 1}` : ""
+    ].filter(Boolean).join("\n");
+}
 function buildActiveInterviewContext(hook) {
     const turnCount = hook.turns?.length ?? 0;
     return [
@@ -421,13 +456,9 @@ function preToolUseOutput(runtime, payload) {
     if (!stateChangingCommand) {
         return null;
     }
-    const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
-    if (blockingQuestion && mutatesLongTableResearchState(command)) {
-        return buildBlockOutput("PreToolUse", "A required LongTable checkpoint is still pending before a research-state Bash command.", buildPendingQuestionContext(blockingQuestion));
-    }
-    const blockingObligation = pendingObligations(runtime.state)[0];
-    if (blockingObligation && mutatesLongTableResearchState(command)) {
-        return buildBlockOutput("PreToolUse", "A LongTable research obligation is still pending before a research-state Bash command.", buildPendingObligationContext(blockingObligation));
+    const hardStopContext = buildHardStopContext(runtime);
+    if (hardStopContext && mutatesLongTableResearchState(command)) {
+        return buildBlockOutput("PreToolUse", "A LongTable hard-stop is pending before a research-state Bash command.", hardStopContext);
     }
     return null;
 }
@@ -438,21 +469,18 @@ function postToolUseOutput(runtime, payload) {
     const command = readCommandText(payload);
     const exitCode = readExitCode(payload);
     const output = readCombinedOutput(payload);
-    const blockingQuestion = pendingRequiredQuestions(runtime.state)[0];
-    const blockingObligation = pendingObligations(runtime.state)[0];
-    if ((blockingQuestion || blockingObligation) && mutatesLongTableResearchState(command)) {
-        return buildBlockOutput("PostToolUse", "A research-state Bash command completed while LongTable still had an unresolved checkpoint or obligation.", blockingQuestion
-            ? buildPendingQuestionContext(blockingQuestion)
-            : buildPendingObligationContext(blockingObligation));
+    const hardStopContext = buildHardStopContext(runtime);
+    if (hardStopContext && mutatesLongTableResearchState(command)) {
+        return buildBlockOutput("PostToolUse", "A research-state Bash command completed while LongTable still had an unresolved hard-stop.", hardStopContext);
     }
-    if (exitCode !== null && exitCode !== 0 && output) {
-        return buildBlockOutput("PostToolUse", "The Bash command returned a non-zero exit code and should be reviewed before LongTable continues.", "Review the command output and explain what failed before retrying or continuing.");
+    if (exitCode !== null && exitCode !== 0 && output && mutatesLongTableResearchState(command)) {
+        return buildBlockOutput("PostToolUse", "A LongTable-relevant Bash command returned a non-zero exit code and should be reviewed before LongTable continues.", "Review the command output and explain what failed before retrying or continuing.");
     }
     return null;
 }
 function stopOutput(runtime) {
-    void runtime;
-    return null;
+    const hardStopContext = buildHardStopContext(runtime);
+    return hardStopContext ? buildStopBlockOutput(hardStopContext) : null;
 }
 export async function dispatchCodexHook(payload, cwdOverride) {
     const hookEventName = readHookEventName(payload);

package/dist/project-session.d.ts

@@ -1,5 +1,6 @@
-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 { DecisionRecord, EvidenceRecord, InvocationRecord, LongTableQuestionObligation, ProviderKind, QuestionOption, HardStopScope, QuestionCommitmentFamily, QuestionEpistemicBasis, QuestionGenerationResult, QuestionOpportunity, QuestionSurface, QuestionPromptType, QuestionRecord, ResearchSpecificationChange, ResearchSpecificationPatch, ResearchSpecificationPatchSource, ResearchSpecificationRevision, ResearchState } from "@longtable/core";
 import type { SetupPersistedOutput } from "@longtable/setup";
+import { type HardStopVerdict } from "@longtable/core";
 export type ProjectDisagreementPreference = "synthesis_only" | "show_on_conflict" | "always_visible";
 export type StartInterviewSignal = "phenomenon" | "audience" | "artifact" | "evidence" | "assumption" | "decision_risk" | "voice";
 export interface StartInterviewTurn {
@@ -211,6 +212,8 @@ export interface LongTableWorkspaceInspection {
         questions: number;
         pendingQuestions: number;
         pendingObligations: number;
+        stalePendingQuestions?: number;
+        stalePendingObligations?: number;
         answeredQuestions: number;
         decisions: number;
         interviewTurns?: number;
@@ -218,6 +221,7 @@ export interface LongTableWorkspaceInspection {
         specPatches?: number;
         specRevisions?: number;
     };
+    hardStop?: HardStopVerdict;
     recentInvocations?: Array<{
         id: string;
         kind: string;
@@ -234,6 +238,8 @@ export interface LongTableWorkspaceInspection {
         question: string;
         commitmentFamily?: QuestionCommitmentFamily;
         epistemicBasis?: QuestionEpistemicBasis;
+        hardStop?: boolean;
+        hardStopScope?: string;
         options: string[];
         required: boolean;
     }>;
@@ -242,6 +248,8 @@ export interface LongTableWorkspaceInspection {
         kind: string;
         prompt: string;
         reason: string;
+        hardStop?: boolean;
+        hardStopScope?: string;
         questionId?: string;
     }>;
     recentDecisions?: Array<{
@@ -379,6 +387,8 @@ export declare function createWorkspaceFollowUpQuestions(options: {
     prompt: string;
     provider?: ProviderKind;
     required?: boolean;
+    hardStop?: boolean;
+    hardStopScope?: HardStopScope;
     force?: boolean;
     auto?: boolean;
     requiredOnly?: boolean;
@@ -401,6 +411,8 @@ export declare function createWorkspaceQuestion(options: {
     displayReason?: string;
     provider?: ProviderKind;
     required?: boolean;
+    hardStop?: boolean;
+    hardStopScope?: HardStopScope;
     commitmentFamily?: QuestionCommitmentFamily;
     epistemicBasis?: QuestionEpistemicBasis;
 }): Promise<{

package/dist/project-session.js

@@ -4,6 +4,7 @@ import { execSync } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { appendDecisionRecord as appendDecisionToResearchState, appendInvocationRecord as appendInvocationToResearchState, appendQuestionRecords, createEmptyResearchState } from "@longtable/memory";
 import { classifyCheckpointTrigger } from "@longtable/checkpoints";
+import { collectHardStopBlockers } from "@longtable/core";
 import { ensureRequiredQuestionObligation, pendingQuestionObligations, resolveQuestionObligationByQuestionId } from "./question-obligations.js";
 const CURRENT_FILE_NAME = "CURRENT.md";
 const LEGACY_ROOT_FILES = ["LONGTABLE.md", "START-HERE.md", "NEXT-STEPS.md", "SESSION-SNAPSHOT.md"];
@@ -339,7 +340,7 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
             "",
             "## 빠른 시작",
             "- 이 디렉토리에서 `codex`를 엽니다.",
-            `- 첫 메시지는 보통 \`${session.firstResearchShape ? suggestedPrompt : "$longtable-interview"}\` 정도면 충분합니다.`,
+            `- 첫 메시지는 보통 \`${session.firstResearchShape ? suggestedPrompt : "$longtable-start"}\` 정도면 충분합니다.`,
             "",
             "## 증거 규칙",
             "- 외부 사실이나 현재 정보는 source를 붙이거나 inference로 낮춥니다."
@@ -416,7 +417,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."
@@ -765,6 +766,7 @@ function summarizeWorkspaceInspection(context, state) {
     const pendingQuestions = questions.filter((record) => record.status === "pending");
     const answeredQuestions = questions.filter((record) => record.status === "answered");
     const pendingObligations = visiblePendingObligations(state);
+    const hardStop = collectHardStopBlockers(state);
     return {
         found: true,
         rootPath: context.project.projectPath,
@@ -803,6 +805,8 @@ function summarizeWorkspaceInspection(context, state) {
             questions: questions.length,
             pendingQuestions: pendingQuestions.length,
             pendingObligations: pendingObligations.length,
+            stalePendingQuestions: hardStop.stalePendingQuestionCount,
+            stalePendingObligations: hardStop.stalePendingObligationCount,
             answeredQuestions: answeredQuestions.length,
             decisions: (state.decisionLog ?? []).length,
             interviewTurns: (state.interviewTurns ?? []).length,
@@ -810,6 +814,7 @@ function summarizeWorkspaceInspection(context, state) {
             specPatches: (state.specPatches ?? []).length,
             specRevisions: (state.specRevisions ?? []).length
         },
+        hardStop,
         recentInvocations: recentInvocationRecords(state, 5).map((record) => ({
             id: record.id,
             kind: record.intent.kind,
@@ -826,6 +831,8 @@ function summarizeWorkspaceInspection(context, state) {
             question: record.prompt.question,
             ...(record.commitmentFamily ? { commitmentFamily: record.commitmentFamily } : {}),
             ...(record.epistemicBasis ? { epistemicBasis: record.epistemicBasis } : {}),
+            ...(typeof record.hardStop === "boolean" ? { hardStop: record.hardStop } : {}),
+            ...(record.hardStopScope ? { hardStopScope: record.hardStopScope } : {}),
             options: formatQuestionOptionValues(record),
             required: record.prompt.required
         })),
@@ -834,6 +841,8 @@ function summarizeWorkspaceInspection(context, state) {
             kind: obligation.kind,
             prompt: obligation.prompt,
             reason: obligation.reason,
+            ...(typeof obligation.hardStop === "boolean" ? { hardStop: obligation.hardStop } : {}),
+            ...(obligation.hardStopScope ? { hardStopScope: obligation.hardStopScope } : {}),
             ...(obligation.questionId ? { questionId: obligation.questionId } : {})
         })),
         recentDecisions: (state.decisionLog ?? []).slice(-5).reverse().map((record) => ({
@@ -878,7 +887,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 +896,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 +1206,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 +1214,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 +1346,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 +1468,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",
@@ -2303,12 +2314,45 @@ function inferEpistemicBasis(input) {
         return "mixed";
     return unique[0];
 }
+function inferHardStopScope(input, commitmentFamily) {
+    if (commitmentFamily === "product_policy")
+        return undefined;
+    if (commitmentFamily === "scope")
+        return "scope";
+    if (commitmentFamily === "construct" || commitmentFamily === "coding")
+        return "construct";
+    if (commitmentFamily === "method")
+        return "method";
+    if (commitmentFamily === "evidence")
+        return "evidence";
+    if (commitmentFamily === "epistemic_authority")
+        return "protected_decision";
+    const text = compactMetadataText([input.checkpointKey, input.title, input.question, input.prompt, input.rationale]);
+    if (textMatchesAny(text, [/product_runtime|checkpoint policy|hook ux|setup|install|cli|npm|release|git|github|docs?|readme|package|workflow/])) {
+        return undefined;
+    }
+    if (textMatchesAny(text, [/protected_decision|closure/]))
+        return "protected_decision";
+    if (textMatchesAny(text, [/research_question|research direction|question_freeze/]))
+        return "research_question";
+    if (textMatchesAny(text, [/scope|boundary|inclusion|exclusion/]))
+        return "scope";
+    if (textMatchesAny(text, [/construct|theory|frame|ontology|measurement|coding|validity/]))
+        return "construct";
+    if (textMatchesAny(text, [/method|design|sample|analysis|strategy|model/]))
+        return "method";
+    if (textMatchesAny(text, [/evidence|access|source|corpus|pdf|full[-_ ]?text|scholarly/]))
+        return "evidence";
+    return undefined;
+}
 function resolveQuestionRecordMetadata(input) {
     const commitmentFamily = input.commitmentFamily ?? inferCommitmentFamily(input);
     const epistemicBasis = input.epistemicBasis ?? inferEpistemicBasis(input);
+    const hardStopScope = inferHardStopScope(input, commitmentFamily);
     return {
         ...(commitmentFamily ? { commitmentFamily } : {}),
-        ...(epistemicBasis ? { epistemicBasis } : {})
+        ...(epistemicBasis ? { epistemicBasis } : {}),
+        ...(hardStopScope ? { hardStop: true, hardStopScope } : {})
     };
 }
 function hasFollowUpPrompt(record, prompt) {
@@ -2369,6 +2413,8 @@ export async function createWorkspaceFollowUpQuestions(options) {
             updatedAt: createdAt,
             status: "pending",
             ...metadata,
+            ...(typeof options.hardStop === "boolean" ? { hardStop: options.hardStop } : {}),
+            ...(options.hardStopScope ? { hardStopScope: options.hardStopScope } : {}),
             prompt: {
                 id: createId("question_prompt"),
                 checkpointKey,
@@ -2423,6 +2469,8 @@ export async function createWorkspaceQuestion(options) {
         updatedAt: createdAt,
         status: "pending",
         ...metadata,
+        ...(typeof options.hardStop === "boolean" ? { hardStop: options.hardStop } : {}),
+        ...(options.hardStopScope ? { hardStopScope: options.hardStopScope } : {}),
         prompt: {
             id: createId("question_prompt"),
             checkpointKey,

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/dist/question-obligations.js

@@ -17,6 +17,8 @@ export function createRequiredQuestionObligation(question) {
         updatedAt: timestamp,
         prompt: question.prompt.question,
         reason: question.prompt.displayReason ?? "A required LongTable checkpoint is pending.",
+        ...(question.hardStop !== undefined ? { hardStop: question.hardStop } : {}),
+        ...(question.hardStopScope ? { hardStopScope: question.hardStopScope } : {}),
         questionId: question.id
     };
 }

package/package.json

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