@longtable/cli 0.1.15 → 0.1.16

package/README.md

@@ -19,34 +19,25 @@ The basic contract is:
 npm install -g @longtable/cli
 ```
 
-For global npm installs, LongTable also bootstraps provider-native skill files:
-
-- Codex skills are written to `~/.codex/skills/`.
-- Claude Code skills are written when the `claude` command is detected.
-- `LONGTABLE_POSTINSTALL_PROVIDERS=all npm install -g @longtable/cli` installs
-  both provider skill sets.
-- `LONGTABLE_SKIP_POSTINSTALL=1 npm install -g @longtable/cli` skips the skill
-  bootstrap.
-
-MCP config writes are intentionally opt-in:
-
-```bash
-longtable mcp install --provider codex --write
-```
-
-During `longtable init --flow interview`, LongTable asks whether to configure
-MCP and whether provider-native team/subagent surfaces should be used when they
-are available. The stable fallback remains LongTable's sequential panel.
+The npm install only installs the CLI. It does not write Codex skills, MCP
+config, hooks, tmux state, or provider runtime files without explicit setup
+approval.
 
 ## Primary Flow
 
 ```bash
+longtable setup --provider codex
 longtable init --flow interview
 longtable start
 cd "<project-path>"
 codex
 ```
 
+`longtable setup --provider codex` is the permission-first setup route. It asks
+which runtime surfaces LongTable may enable and explains why each choice matters:
+CLI only, skills, skills + MCP, skills + MCP + sentinel, intervention posture,
+tmux HUD/console, and team discussion mode.
+
 Return later:
 
 ```bash
@@ -100,6 +91,9 @@ 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 hud --watch
+longtable team --tmux --prompt "Review this measurement plan."
 longtable codex install-skills
 longtable claude install-skills
 ```
@@ -170,6 +164,22 @@ Default panel roles include:
 
 Use `--role` to constrain the panel when the research problem is already clear.
 
+## Sentinel, HUD, And Tmux 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.
+
+`longtable hud --watch` renders a compact view of the current project goal,
+blocker, pending checkpoints, recent decisions, and invocation counts.
+`longtable hud --tmux` opens that view in a tmux pane.
+
+`longtable team --tmux` opens role-specific panes for research discussion and
+writes logs under `.longtable/team/<id>/`. This is panel discussion, not merely
+parallel execution: role panes are prompted to state claims, objections, open
+questions, and likely disagreement.
+
 ## Evidence And Search Direction
 
 LongTable should not behave like a generic web scraper. Research search should

package/dist/cli.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { execSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
 import { emitKeypressEvents } from "node:readline";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output, cwd, exit } from "node:process";
-import { dirname, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
+import { classifyCheckpointTrigger } from "@longtable/checkpoints";
 import { buildProviderChoices, buildQuickSetupFlow, createPersistedSetupOutput, installRuntimeConfigFromStoredSetup, loadSetupOutput, renderInstallSummary, renderSetupSummary, resolveDefaultRuntimeConfigPath, resolveDefaultSetupPath, saveSetupAndRuntimeConfig, serializeSetupOutput, writeRuntimeConfig } from "@longtable/setup";
 import { buildCodexSkillSpecs, buildCodexThinWrappedPrompt, installCodexSkills, listInstalledCodexSkills, renderQuestionRecordPrompt, removeCodexSkills, resolveCodexSkillsDir, runCodexThinWrapper } from "@longtable/provider-codex";
 import { buildClaudeSkillSpecs, installClaudeSkills, listInstalledClaudeSkills, renderQuestionRecordInput, removeClaudeSkills, resolveClaudeSkillsDir } from "@longtable/provider-claude";
@@ -14,7 +15,7 @@ import { installCodexPromptAliases, listInstalledCodexPromptAliases, removeCodex
 import { buildPersonaGuidance, parseInvocationDirective } from "./persona-router.js";
 import { PERSONA_DEFINITIONS, listRoleDefinitions } from "./personas.js";
 import { buildPanelFallback, renderPanelSummary } from "./panel.js";
-import { appendInvocationRecordToWorkspace, assertWorkspaceNotBlocked, answerWorkspaceQuestion, createWorkspaceClarificationCard, createWorkspaceQuestion, createOrUpdateProjectWorkspace, inspectProjectWorkspace, loadProjectContextFromDirectory, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.js";
+import { appendInvocationRecordToWorkspace, assertWorkspaceNotBlocked, answerWorkspaceQuestion, createWorkspaceClarificationCard, createWorkspaceQuestion, createOrUpdateProjectWorkspace, inspectProjectWorkspace, loadWorkspaceState, loadProjectContextFromDirectory, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.js";
 const VALID_MODES = new Set([
     "explore",
     "review",
@@ -40,7 +41,7 @@ const ANSI = {
     green: "\u001B[32m"
 };
 const LONGTABLE_MCP_SERVER_NAME = "longtable-state";
-const LONGTABLE_MCP_PACKAGE_VERSION = "0.1.15";
+const LONGTABLE_MCP_PACKAGE_VERSION = "0.1.14";
 const LONGTABLE_MCP_MARKER_START = "# LongTable state MCP START";
 const LONGTABLE_MCP_MARKER_END = "# LongTable state MCP END";
 function style(text, prefix) {
@@ -76,7 +77,8 @@ function usage() {
         "  Run `longtable ...` in your terminal, not inside the Codex chat box.",
         "  After `longtable start`, move into the created project directory and open `codex` there.",
         "",
-        "  longtable init [--flow quickstart|interview] [--provider codex|claude] [--field <field>] [--career-stage <stage>] [--experience novice|intermediate|advanced] [--checkpoint low|balanced|high] [--authorship-signal <text>] [--entry-mode explore|review|critique|draft|commit] [--weakest-domain theory|methodology|measurement|analysis|writing] [--panel-preference synthesis_only|show_on_conflict|always_visible] [--agent-team native_when_available|sequential_panel_only] [--mcp skip|print_config|write_provider|write_all] [--json] [--no-install] [--install-skills] [--install-prompts]",
+        "  longtable init [--flow quickstart|interview] [--provider codex|claude] [--field <field>] [--career-stage <stage>] [--experience novice|intermediate|advanced] [--checkpoint low|balanced|high] [--authorship-signal <text>] [--entry-mode explore|review|critique|draft|commit] [--weakest-domain theory|methodology|measurement|analysis|writing] [--panel-preference synthesis_only|show_on_conflict|always_visible] [--json] [--no-install] [--install-skills] [--install-prompts]",
+        "  longtable setup [--provider codex|claude] [--json] [--dir <path>] [--skills-dir <path>] [--runtime-path <file>] [--setup-path <file>]",
         "  longtable start [--path <dir>] [--name <project>] [--goal <text>] [--blocker <text>] [--perspectives <role[,role]>] [--disagreement synthesis_only|show_on_conflict|always_visible] [--setup <path>] [--json]",
         "  longtable resume [--cwd <path>] [--json]",
         "  longtable doctor [--cwd <path>] [--fix] [--json] [--codex-dir <path>] [--claude-dir <path>] [--codex-prompts-dir <path>] [--codex-runtime-path <file>] [--claude-runtime-path <file>]",
@@ -85,6 +87,9 @@ function usage() {
         "  longtable show [--json] [--path <file>]",
         "  longtable install [--json] [--path <file>] [--runtime-path <file>]",
         "  longtable mcp install [--provider codex|claude|all] [--write] [--json] [--codex-config <path>] [--claude-settings <path>] [--package <spec>]",
+        "  longtable hud [--watch] [--tmux] [--preset minimal|full] [--cwd <path>] [--json]",
+        "  longtable sentinel --prompt <text> [--cwd <path>] [--json] [--record]",
+        "  longtable team --prompt <text> [--role <role[,role]>] [--tmux] [--cwd <path>] [--json]",
         "  longtable ask [--prompt <text>] [--print] [--json] [--setup <path>] [--cwd <path>]",
         "  longtable clarify --prompt <task-context> [--provider codex|claude] [--required|--advisory] [--print] [--cwd <path>] [--json] [--force]",
         "  longtable question --prompt <decision-context> [--title <text>] [--text <question>] [--provider codex|claude] [--required|--advisory] [--print] [--cwd <path>] [--json]",
@@ -120,7 +125,7 @@ function parseArgs(argv) {
     const values = {};
     let subcommand = maybeSubcommand;
     const modeCommand = command && VALID_MODES.has(command);
-    const directCommand = command && ["init", "start", "resume", "doctor", "status", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "panel", "decide"].includes(command);
+    const directCommand = command && ["init", "setup", "start", "resume", "doctor", "status", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "panel", "decide", "hud", "sentinel", "team"].includes(command);
     let startIndex = 1;
     if (modeCommand) {
         subcommand = undefined;
@@ -197,12 +202,9 @@ function questionSection(questionId) {
     if (questionId === "preferredCheckpointIntensity" || questionId === "preferredEntryMode") {
         return "Interaction style";
     }
-    if (questionId === "weakestDomain" || questionId === "panelPreference" || questionId === "agentTeamPreference") {
+    if (questionId === "weakestDomain" || questionId === "panelPreference") {
         return "How LongTable should challenge you";
     }
-    if (questionId === "mcpPreference") {
-        return "Provider integration";
-    }
     return "Authorship and voice";
 }
 function formatModeLabel(mode) {
@@ -499,12 +501,6 @@ function toSetupAnswers(args) {
             : undefined,
         panelPreference: typeof args["panel-preference"] === "string"
             ? String(args["panel-preference"])
-            : undefined,
-        agentTeamPreference: typeof args["agent-team"] === "string"
-            ? String(args["agent-team"])
-            : undefined,
-        mcpPreference: typeof args.mcp === "string"
-            ? String(args.mcp)
             : undefined
     };
 }
@@ -552,11 +548,6 @@ async function collectInteractiveAnswers(initialFlow) {
                 answers.weakestDomain = value;
             if (question.id === "panelPreference")
                 answers.panelPreference = value;
-            if (question.id === "agentTeamPreference") {
-                answers.agentTeamPreference = value;
-            }
-            if (question.id === "mcpPreference")
-                answers.mcpPreference = value;
         }
         return {
             flow,
@@ -568,6 +559,172 @@ async function collectInteractiveAnswers(initialFlow) {
         rl.close();
     }
 }
+function buildPermissionSetupChoices() {
+    return {
+        surfaces: [
+            {
+                id: "cli_only",
+                label: "CLI only",
+                description: "Why: least invasive. Tradeoff: no natural in-provider LongTable entrypoints."
+            },
+            {
+                id: "skills",
+                label: "Skills",
+                description: "Why: enables natural LongTable skill routing. Tradeoff: writes provider skill files."
+            },
+            {
+                id: "skills_mcp",
+                label: "Skills + MCP",
+                description: "Why: adds structured state access. Tradeoff: writes provider config for MCP transport."
+            },
+            {
+                id: "skills_mcp_sentinel",
+                label: "Skills + MCP + Sentinel",
+                description: "Why: prepares advisory gap/tacit monitoring. Tradeoff: LongTable may nudge research turns."
+            }
+        ],
+        intervention: [
+            {
+                id: "advisory",
+                label: "Advisory",
+                description: "Why: notices gaps without blocking. Tradeoff: you may still miss hard commitments."
+            },
+            {
+                id: "balanced",
+                label: "Balanced",
+                description: "Why: blocks clear theory, measurement, method, or evidence commitments. Tradeoff: occasional stops."
+            },
+            {
+                id: "strong",
+                label: "Strong",
+                description: "Why: maximizes judgment protection. Tradeoff: more interruption before closure."
+            }
+        ],
+        tmux: [
+            {
+                id: "standard",
+                label: "Standard chat",
+                description: "Why: portable default. Tradeoff: checkpoints and gaps are less persistently visible."
+            },
+            {
+                id: "hud",
+                label: "Research HUD",
+                description: "Why: keeps goals, blockers, and pending checkpoints visible. Requires tmux."
+            },
+            {
+                id: "console",
+                label: "Research console",
+                description: "Why: enables a richer tmux layout for HUD and team discussion. Requires tmux."
+            }
+        ],
+        team: [
+            {
+                id: "off",
+                label: "Off",
+                description: "Why: simplest. Tradeoff: panel disagreement stays inside one LongTable response."
+            },
+            {
+                id: "panel",
+                label: "Structured panel",
+                description: "Why: role disagreement is visible without tmux. Tradeoff: not parallel."
+            },
+            {
+                id: "tmux_team",
+                label: "Tmux team discussion",
+                description: "Why: opens role panes for parallel debate. Tradeoff: terminal complexity and cleanup."
+            }
+        ]
+    };
+}
+function checkpointIntensityFromIntervention(choice) {
+    if (choice === "strong")
+        return "high";
+    if (choice === "advisory")
+        return "low";
+    return "balanced";
+}
+async function runSetup(args) {
+    const json = args.json === true;
+    const rl = createInterface({ input, output });
+    try {
+        const provider = (typeof args.provider === "string"
+            ? (args.provider === "claude" ? "claude" : "codex")
+            : await promptChoice(rl, "Which provider should LongTable configure?", buildProviderChoices()));
+        const choices = buildPermissionSetupChoices();
+        const surfaces = await promptChoice(rl, [
+            "Which LongTable runtime surfaces should be enabled?",
+            "This is a permission choice because skills, MCP, and sentinel support write provider-facing runtime files."
+        ].join("\n"), choices.surfaces);
+        const intervention = await promptChoice(rl, "How strongly may LongTable interrupt research decisions?", choices.intervention);
+        const tmuxMode = await promptChoice(rl, "Should LongTable recommend a tmux-based research interface?", choices.tmux);
+        const teamMode = await promptChoice(rl, "Should LongTable enable agent/team discussion mode?", choices.team);
+        const outputValue = createPersistedSetupOutput({
+            field: "unspecified",
+            careerStage: "unspecified",
+            experienceLevel: "advanced",
+            preferredCheckpointIntensity: checkpointIntensityFromIntervention(intervention),
+            preferredEntryMode: "explore",
+            panelPreference: teamMode === "off" ? "show_on_conflict" : "always_visible"
+        }, provider, "quickstart");
+        outputValue.initialState.explicitState = {
+            ...outputValue.initialState.explicitState,
+            runtimeSurfaces: surfaces,
+            interventionPosture: intervention,
+            tmuxMode,
+            teamMode
+        };
+        if (surfaces === "skills_mcp_sentinel") {
+            outputValue.initialState.inferredHypotheses.push({
+                hypothesis: "Researcher approved advisory Gap/Tacit Sentinel setup.",
+                confidence: 0.95,
+                evidence: ["Selected Skills + MCP + Sentinel during permission-first setup."],
+                status: "confirmed"
+            });
+        }
+        const result = await saveSetupAndRuntimeConfig(outputValue, {
+            setupPath: typeof args["setup-path"] === "string" ? args["setup-path"] : undefined,
+            runtimePath: typeof args["runtime-path"] === "string" ? args["runtime-path"] : undefined
+        });
+        const installedSkills = surfaces === "cli_only"
+            ? []
+            : provider === "codex"
+                ? await installCodexSkills(listRoleDefinitions(), typeof args["skills-dir"] === "string" ? args["skills-dir"] : typeof args.dir === "string" ? args.dir : undefined)
+                : await installClaudeSkills(listRoleDefinitions(), typeof args["skills-dir"] === "string" ? args["skills-dir"] : typeof args.dir === "string" ? args.dir : undefined);
+        const mcpRequested = surfaces === "skills_mcp" || surfaces === "skills_mcp_sentinel";
+        if (mcpRequested && !json) {
+            console.log("");
+            console.log("MCP setup is approved. To write provider config now, run:");
+            console.log(`- longtable mcp install --provider ${provider} --write`);
+        }
+        if (json) {
+            console.log(JSON.stringify({
+                setup: outputValue,
+                runtime: result,
+                installedSkills: installedSkills.map((skill) => skill.name),
+                mcpRequested,
+                tmuxMode,
+                teamMode
+            }, null, 2));
+            return;
+        }
+        console.log("");
+        console.log(renderSetupSummary(outputValue));
+        console.log("");
+        console.log(renderInstallSummary(result));
+        console.log(`Installed skills: ${installedSkills.length}`);
+        if (tmuxMode !== "standard") {
+            console.log("");
+            console.log("Tmux recommendation:");
+            console.log("- macOS: brew install tmux");
+            console.log("- Ubuntu/Debian: sudo apt install tmux");
+            console.log("- Start HUD in an existing tmux session: longtable hud --tmux");
+            console.log("- Start a discussion team: longtable team --tmux --prompt \"...\"");
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
 function perspectiveChoices() {
     return PERSONA_DEFINITIONS.map((persona) => ({
         id: persona.key,
@@ -671,12 +828,6 @@ function normalizePersistAnswers(raw) {
                 : {}),
             ...(raw.panelPreference
                 ? { panelPreference: raw.panelPreference }
-                : {}),
-            ...(raw.agentTeamPreference
-                ? { agentTeamPreference: raw.agentTeamPreference }
-                : {}),
-            ...(raw.mcpPreference
-                ? { mcpPreference: raw.mcpPreference }
                 : {})
         }
     };
@@ -705,15 +856,6 @@ async function readPersistAnswers(args) {
     }
     throw new Error("persist-init requires either --answers-json, --stdin, or the full set of setup flags.");
 }
-async function applySetupMcpPreference(provider, preference) {
-    if (!preference || preference === "skip") {
-        return undefined;
-    }
-    return installMcpConfig({
-        provider: preference === "write_all" ? "all" : provider,
-        write: preference === "write_provider" || preference === "write_all"
-    });
-}
 async function runInit(args) {
     const json = args.json === true;
     const installRuntime = args["no-install"] !== true;
@@ -746,17 +888,15 @@ async function runInit(args) {
     if (provider === "claude" && installSkills) {
         installedSkills = await installClaudeSkills(listRoleDefinitions(), skillsDir);
     }
-    const mcpInstall = await applySetupMcpPreference(provider, answers.mcpPreference);
     if (json) {
-        if (installedPrompts.length === 0 && installedSkills.length === 0 && !mcpInstall) {
+        if (installedPrompts.length === 0 && installedSkills.length === 0) {
             console.log(serializeSetupOutput(outputValue));
             return;
         }
         console.log(JSON.stringify({
             setup: outputValue,
             installedPrompts: installedPrompts.map((prompt) => prompt.name),
-            installedSkills: installedSkills.map((skill) => skill.name),
-            mcpInstall
+            installedSkills: installedSkills.map((skill) => skill.name)
         }, null, 2));
         return;
     }
@@ -781,10 +921,6 @@ async function runInit(args) {
         }
         console.log("  Use these by naming LongTable naturally, e.g. `lt panel: ...`.");
     }
-    if (mcpInstall) {
-        console.log("");
-        console.log(renderMcpInstallSummary(mcpInstall));
-    }
     if (provider === "codex") {
         console.log("");
         console.log("Next step:");
@@ -918,43 +1054,40 @@ function renderMcpInstallSummary(result) {
     }
     return lines.join("\n").trimEnd();
 }
-async function installMcpConfig(args) {
-    const serverName = typeof args.name === "string" && args.name.trim()
-        ? args.name.trim()
-        : LONGTABLE_MCP_SERVER_NAME;
-    const packageSpec = resolveMcpPackageSpec(args);
-    const command = typeof args.command === "string" && args.command.trim() ? args.command.trim() : "npx";
-    const mcpArgs = command === "npx" ? ["-y", packageSpec] : [packageSpec];
-    const providers = resolveMcpProviders(args.provider);
-    const write = args.write === true;
-    const targets = [];
-    for (const provider of providers) {
-        if (provider === "codex") {
-            const path = resolveCodexMcpConfigPath(args);
-            const block = renderCodexMcpBlock(serverName, command, mcpArgs);
-            const content = write ? await writeCodexMcpConfig(path, block, serverName) : block;
-            targets.push({ provider, path, format: "toml", content });
-        }
-        if (provider === "claude") {
-            const path = resolveClaudeMcpSettingsPath(args);
-            const content = write
-                ? await writeClaudeMcpSettings(path, serverName, command, mcpArgs)
-                : renderClaudeMcpJson(serverName, command, mcpArgs);
-            targets.push({ provider, path, format: "json", content });
-        }
-    }
-    return {
-        serverName,
-        packageSpec,
-        command,
-        args: mcpArgs,
-        write,
-        targets
-    };
-}
 async function runMcpSubcommand(subcommand, args) {
     if (!subcommand || subcommand === "install" || subcommand === "print-config") {
-        const result = await installMcpConfig(args);
+        const serverName = typeof args.name === "string" && args.name.trim()
+            ? args.name.trim()
+            : LONGTABLE_MCP_SERVER_NAME;
+        const packageSpec = resolveMcpPackageSpec(args);
+        const command = typeof args.command === "string" && args.command.trim() ? args.command.trim() : "npx";
+        const mcpArgs = command === "npx" ? ["-y", packageSpec] : [packageSpec];
+        const providers = resolveMcpProviders(args.provider);
+        const write = args.write === true;
+        const targets = [];
+        for (const provider of providers) {
+            if (provider === "codex") {
+                const path = resolveCodexMcpConfigPath(args);
+                const block = renderCodexMcpBlock(serverName, command, mcpArgs);
+                const content = write ? await writeCodexMcpConfig(path, block, serverName) : block;
+                targets.push({ provider, path, format: "toml", content });
+            }
+            if (provider === "claude") {
+                const path = resolveClaudeMcpSettingsPath(args);
+                const content = write
+                    ? await writeClaudeMcpSettings(path, serverName, command, mcpArgs)
+                    : renderClaudeMcpJson(serverName, command, mcpArgs);
+                targets.push({ provider, path, format: "json", content });
+            }
+        }
+        const result = {
+            serverName,
+            packageSpec,
+            command,
+            args: mcpArgs,
+            write,
+            targets
+        };
         if (args.json === true) {
             console.log(JSON.stringify(result, null, 2));
             return;
@@ -1487,8 +1620,7 @@ async function runPanelCommand(args) {
         mode,
         roleFlag: typeof args.role === "string" ? args.role : undefined,
         provider,
-        visibility,
-        agentTeamPreference: setup?.profileSeed.agentTeamPreference
+        visibility
     });
     if (projectAware.projectContextFound) {
         const context = await loadProjectContextFromDirectory(workingDirectory);
@@ -1809,6 +1941,202 @@ async function runAsk(args) {
     }
     await runModeCommand(mode, delegatedArgs);
 }
+function localId(prefix) {
+    return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function shellEscape(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function sentinelSummary(prompt, workingDirectory) {
+    const trigger = classifyCheckpointTrigger(prompt, {
+        fallbackMode: "explore",
+        unresolvedTensions: []
+    });
+    const normalized = prompt.toLowerCase();
+    const signals = [];
+    if (/measure|measurement|scale|validity|reliability|측정|척도|타당도|신뢰도/.test(normalized)) {
+        signals.push("measurement gap or commitment");
+    }
+    if (/theory|theoretical|framework|construct|이론|프레임워크|개념/.test(normalized)) {
+        signals.push("theory or construct commitment");
+    }
+    if (/method|design|sample|participant|방법|설계|표본|참여자/.test(normalized)) {
+        signals.push("method/design gap");
+    }
+    if (/citation|reference|source|evidence|doi|문헌|인용|근거|출처/.test(normalized)) {
+        signals.push("evidence gap");
+    }
+    if (/voice|authorship|narrative|저자성|서사|문체|목소리/.test(normalized)) {
+        signals.push("authorship or narrative-trace risk");
+    }
+    if (/assumption|implicit|tacit|암묵|전제|가정/.test(normalized)) {
+        signals.push("tacit assumption risk");
+    }
+    return {
+        cwd: workingDirectory,
+        checkpoint: trigger.signal.checkpointKey,
+        family: trigger.family,
+        confidence: trigger.confidence,
+        requiresQuestionBeforeClosure: trigger.requiresQuestionBeforeClosure,
+        signals: signals.length > 0 ? signals : ["no specific gap/tacit signal beyond checkpoint classifier"],
+        rationale: trigger.rationale
+    };
+}
+async function runSentinel(args) {
+    const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
+    const prompt = await resolvePrompt(typeof args.prompt === "string" ? args.prompt : undefined);
+    if (!prompt) {
+        throw new Error("A prompt is required.");
+    }
+    const summary = sentinelSummary(prompt, workingDirectory);
+    const context = await loadProjectContextFromDirectory(workingDirectory);
+    if (args.record === true && context) {
+        const state = await loadWorkspaceState(context);
+        state.inferredHypotheses.push({
+            hypothesis: `Sentinel detected: ${summary.signals.join(", ")}.`,
+            confidence: summary.confidence === "high" ? 0.85 : summary.confidence === "medium" ? 0.65 : 0.4,
+            evidence: [`Prompt: ${prompt}`],
+            status: "unconfirmed"
+        });
+        if (summary.requiresQuestionBeforeClosure) {
+            state.openTensions.push(`Pending sentinel risk: ${summary.checkpoint}`);
+        }
+        await writeFile(context.stateFilePath, JSON.stringify(state, null, 2), "utf8");
+        await syncCurrentWorkspaceView(context);
+    }
+    if (args.json === true) {
+        console.log(JSON.stringify(summary, null, 2));
+        return;
+    }
+    console.log("LongTable Sentinel");
+    console.log(`- checkpoint: ${summary.checkpoint}`);
+    console.log(`- family: ${summary.family}`);
+    console.log(`- confidence: ${summary.confidence}`);
+    console.log(`- question before closure: ${summary.requiresQuestionBeforeClosure ? "yes" : "no"}`);
+    console.log("- detected signals:");
+    for (const signal of summary.signals) {
+        console.log(`  - ${signal}`);
+    }
+    if (args.record === true) {
+        console.log(context ? `- recorded in: ${context.stateFilePath}` : "- record skipped: no LongTable workspace found");
+    }
+}
+function renderHudText(inspection, preset) {
+    if (!inspection.found) {
+        return [
+            "LongTable HUD",
+            "- workspace: not found",
+            "- run `longtable start` for durable research state"
+        ].join("\n");
+    }
+    const lines = [
+        "LongTable HUD",
+        `- project: ${inspection.project?.name}`,
+        `- goal: ${inspection.session?.currentGoal}`,
+        ...(inspection.session?.currentBlocker ? [`- blocker: ${inspection.session.currentBlocker}`] : []),
+        `- questions: ${inspection.counts?.pendingQuestions ?? 0} pending / ${inspection.counts?.questions ?? 0} total`,
+        `- decisions: ${inspection.counts?.decisions ?? 0}`,
+        `- invocations: ${inspection.counts?.invocations ?? 0}`
+    ];
+    if (preset !== "minimal") {
+        lines.push("- pending checkpoints:");
+        for (const question of inspection.pendingQuestions ?? []) {
+            lines.push(`  - ${question.required ? "required" : "advisory"}: ${question.question}`);
+        }
+        lines.push("- recent decisions:");
+        for (const decision of inspection.recentDecisions ?? []) {
+            lines.push(`  - ${decision.summary}`);
+        }
+    }
+    return lines.join("\n");
+}
+async function runHud(args) {
+    const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
+    const preset = typeof args.preset === "string" ? args.preset : "full";
+    if (args.tmux === true) {
+        if (!process.env.TMUX) {
+            throw new Error("`longtable hud --tmux` must be run inside an existing tmux session.");
+        }
+        const launcher = process.argv[1] ?? "longtable";
+        const command = `node ${shellEscape(launcher)} hud --watch --preset ${shellEscape(preset)} --cwd ${shellEscape(workingDirectory)}`;
+        execFileSync("tmux", ["split-window", "-v", "-l", "10", command], { stdio: "inherit" });
+        return;
+    }
+    while (true) {
+        const inspection = await inspectProjectWorkspace(workingDirectory);
+        if (args.json === true) {
+            console.log(JSON.stringify(inspection, null, 2));
+            return;
+        }
+        if (args.watch === true) {
+            process.stdout.write("\u001Bc");
+        }
+        console.log(renderHudText(inspection, preset));
+        if (args.watch !== true) {
+            return;
+        }
+        await new Promise((resolvePromise) => setTimeout(resolvePromise, 1500));
+    }
+}
+async function runTeam(args) {
+    const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
+    const prompt = await resolvePrompt(typeof args.prompt === "string" ? args.prompt : undefined);
+    if (!prompt) {
+        throw new Error("A prompt is required.");
+    }
+    const fallback = buildPanelFallback({
+        prompt,
+        mode: "review",
+        roleFlag: typeof args.role === "string" ? args.role : undefined,
+        provider: "codex",
+        visibility: "always_visible"
+    });
+    const teamId = localId("team");
+    const teamDir = join(workingDirectory, ".longtable", "team", teamId);
+    await mkdir(teamDir, { recursive: true });
+    await writeFile(join(teamDir, "prompt.txt"), prompt, "utf8");
+    await writeFile(join(teamDir, "plan.json"), JSON.stringify(fallback.plan, null, 2), "utf8");
+    if (args.json === true) {
+        console.log(JSON.stringify({ teamId, teamDir, plan: fallback.plan }, null, 2));
+        return;
+    }
+    if (args.tmux !== true) {
+        console.log(renderPanelSummary(fallback.plan));
+        console.log("");
+        console.log("Run with `--tmux` to launch role panes for parallel discussion.");
+        return;
+    }
+    const sessionName = `longtable-${teamId.replaceAll("_", "-")}`;
+    const shell = process.env.SHELL || "/bin/sh";
+    const launcher = process.argv[1] ?? "longtable";
+    const leaderCommand = [
+        `echo ${shellEscape(`LongTable team ${teamId}`)}`,
+        `echo ${shellEscape(`Logs: ${teamDir}`)}`,
+        "echo 'Role panes are running. Review logs, then run:'",
+        `echo ${shellEscape(`longtable panel --role ${fallback.plan.members.map((member) => member.role).join(",")} --prompt ${JSON.stringify(prompt)}`)}`,
+        `exec ${shellEscape(shell)}`
+    ].join("; ");
+    execFileSync("tmux", ["new-session", "-d", "-s", sessionName, "-c", workingDirectory, leaderCommand], { stdio: "inherit" });
+    for (const member of fallback.plan.members) {
+        const rolePrompt = [
+            `LongTable team discussion role: ${member.label} (${member.role}).`,
+            "Give claims, objections, open questions, and evidence needs. Address likely disagreement with other roles.",
+            "",
+            prompt
+        ].join("\n");
+        const logPath = join(teamDir, `${member.role}.log`);
+        const command = [
+            `node ${shellEscape(launcher)} review --role ${shellEscape(member.role)} --prompt ${shellEscape(rolePrompt)} --cwd ${shellEscape(workingDirectory)} 2>&1 | tee ${shellEscape(logPath)}`,
+            `echo ${shellEscape(`Role log written to ${logPath}`)}`,
+            `exec ${shellEscape(shell)}`
+        ].join("; ");
+        execFileSync("tmux", ["split-window", "-t", sessionName, "-c", workingDirectory, command], { stdio: "inherit" });
+        execFileSync("tmux", ["select-layout", "-t", sessionName, "tiled"], { stdio: "ignore" });
+    }
+    console.log(`LongTable tmux team launched: ${sessionName}`);
+    console.log(`Attach with: tmux attach -t ${sessionName}`);
+    console.log(`Logs: ${teamDir}`);
+}
 async function runDecide(args) {
     const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
     const answer = typeof args.answer === "string" ? args.answer.trim() : "";
@@ -2095,6 +2423,10 @@ async function main() {
         await runInit(values);
         return;
     }
+    if (command === "setup") {
+        await runSetup(values);
+        return;
+    }
     if (command === "start") {
         await runStart(values);
         return;
@@ -2139,6 +2471,18 @@ async function main() {
         await runPanelCommand(values);
         return;
     }
+    if (command === "hud") {
+        await runHud(values);
+        return;
+    }
+    if (command === "sentinel") {
+        await runSentinel(values);
+        return;
+    }
+    if (command === "team") {
+        await runTeam(values);
+        return;
+    }
     if (command === "decide") {
         await runDecide(values);
         return;

package/dist/panel.d.ts

@@ -1,4 +1,4 @@
-import type { CheckpointSensitivity, InteractionMode, InvocationIntent, InvocationSurface, InvocationRecord, PanelPlan, PanelResult, PanelVisibility, QuestionRecord, ProviderKind, RoleKey } from "@longtable/core";
+import type { CheckpointSensitivity, InteractionMode, InvocationIntent, InvocationRecord, PanelPlan, PanelResult, PanelVisibility, QuestionRecord, ProviderKind, RoleKey } from "@longtable/core";
 import { type CanonicalPersona } from "./personas.js";
 export interface BuildPanelPlanOptions {
     prompt: string;
@@ -7,7 +7,6 @@ export interface BuildPanelPlanOptions {
     roles?: CanonicalPersona[];
     provider?: ProviderKind;
     visibility?: PanelVisibility;
-    agentTeamPreference?: "native_when_available" | "sequential_panel_only";
 }
 export interface PanelFallback {
     intent: InvocationIntent;
@@ -23,7 +22,6 @@ export declare function buildInvocationIntent(options: {
     mode?: InteractionMode;
     roles: RoleKey[];
     provider?: ProviderKind;
-    requestedSurface?: InvocationSurface;
     visibility?: PanelVisibility;
     checkpointSensitivity?: CheckpointSensitivity;
     rationale?: string[];

package/dist/panel.js

@@ -67,9 +67,6 @@ export function buildPanelPlan(options) {
     const routedRoles = routePersonas(options.prompt).consultedRoles;
     const roles = resolvePanelRoles(options);
     const createdAt = nowIso();
-    const preferredSurface = options.agentTeamPreference === "native_when_available"
-        ? "native_parallel"
-        : "sequential_fallback";
     return {
         id: createId("panel_plan"),
         createdAt,
@@ -77,14 +74,12 @@ export function buildPanelPlan(options) {
         prompt: options.prompt,
         members: roles.map((role) => memberForRole(role, explicitRoles, routedRoles)),
         visibility: options.visibility ?? "always_visible",
-        preferredSurface,
+        preferredSurface: "sequential_fallback",
         fallbackSurface: "sequential_fallback",
         checkpointSensitivity: highestSensitivity(roles),
         rationale: [
-            preferredSurface === "native_parallel"
-                ? "Setup prefers native provider team/subagent surfaces when available."
-                : "Setup prefers LongTable's provider-neutral sequential panel surface.",
-            "Sequential fallback remains the stable execution path for both Claude Code and Codex.",
+            "Option A uses provider-neutral panel semantics before native provider orchestration.",
+            "Sequential fallback is the stable execution path for both Claude Code and Codex.",
             roles.length === explicitRoles.length && explicitRoles.length > 0
                 ? "The panel is constrained by explicitly requested roles."
                 : "The panel combines default research-review roles with prompt-triggered roles."
@@ -99,7 +94,7 @@ export function buildInvocationIntent(options) {
         prompt: options.prompt,
         roles: options.roles,
         provider: options.provider,
-        requestedSurface: options.requestedSurface ?? "sequential_fallback",
+        requestedSurface: "sequential_fallback",
         visibility: options.visibility ?? "always_visible",
         checkpointSensitivity: options.checkpointSensitivity ?? "medium",
         rationale: options.rationale ?? ["Panel invocation requested."]
@@ -235,7 +230,6 @@ export function buildPanelFallback(options) {
         mode: plan.mode,
         roles: plan.members.map((member) => member.role),
         provider: options.provider,
-        requestedSurface: plan.preferredSurface,
         visibility: plan.visibility,
         checkpointSensitivity: plan.checkpointSensitivity,
         rationale: plan.rationale

package/dist/project-session.d.ts

@@ -17,8 +17,6 @@ export interface LongTableProjectRecord {
         humanAuthorshipSignal?: string;
         weakestDomain?: string;
         defaultPanelPreference?: ProjectDisagreementPreference;
-        agentTeamPreference?: string;
-        mcpPreference?: string;
     };
 }
 export interface LongTableSessionRecord {

package/dist/project-session.js

@@ -917,12 +917,6 @@ export async function createOrUpdateProjectWorkspace(options) {
                     : {}),
                 ...(options.setup.profileSeed.panelPreference
                     ? { defaultPanelPreference: options.setup.profileSeed.panelPreference }
-                    : {}),
-                ...(options.setup.profileSeed.agentTeamPreference
-                    ? { agentTeamPreference: options.setup.profileSeed.agentTeamPreference }
-                    : {}),
-                ...(options.setup.profileSeed.mcpPreference
-                    ? { mcpPreference: options.setup.profileSeed.mcpPreference }
                     : {})
             }
         };

package/dist/prompt-aliases.js

@@ -35,7 +35,7 @@ function promptSpec() {
                 "Do not move to the next question until the researcher answers the current one.",
                 "Quickstart covers: provider, field, career stage, experience level, checkpoint intensity, and human authorship signal.",
                 "Interview also covers: preferred entry mode, weakest domain, and panel visibility preference.",
-                "After collecting all answers, summarize the proposed setup and then output both: 1) the exact `longtable codex persist-init ... --install-skills` command and 2) a strict JSON object with keys provider, flow, field, careerStage, experienceLevel, preferredCheckpointIntensity, and optional humanAuthorshipSignal, preferredEntryMode, weakestDomain, panelPreference, agentTeamPreference, mcpPreference.",
+                "After collecting all answers, summarize the proposed setup and then output both: 1) the exact `longtable codex persist-init ... --install-skills` command and 2) a strict JSON object with keys provider, flow, field, careerStage, experienceLevel, preferredCheckpointIntensity, and optional humanAuthorshipSignal, preferredEntryMode, weakestDomain, panelPreference.",
                 "If the user prefers paste-based setup, tell them they can pipe the JSON into `longtable codex persist-init --stdin --install-skills`.",
                 "If the researcher asks you to stay inside Codex, keep the conversation in numbered form and do not prematurely close.",
                 "Frame the setup like a short researcher interview, not a bare config form.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longtable/cli",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "private": false,
   "description": "Researcher-facing LongTable CLI",
   "type": "module",
@@ -13,7 +13,7 @@
     }
   },
   "bin": {
-    "longtable": "./bin/longtable"
+    "longtable": "bin/longtable"
   },
   "directories": {
     "bin": "./bin"
@@ -21,21 +21,19 @@
   "files": [
     "dist",
     "bin",
-    "scripts/postinstall.mjs",
     "README.md"
   ],
   "scripts": {
-    "postinstall": "node ./scripts/postinstall.mjs",
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@longtable/checkpoints": "0.1.15",
-    "@longtable/core": "0.1.15",
-    "@longtable/memory": "0.1.15",
-    "@longtable/provider-claude": "0.1.15",
-    "@longtable/provider-codex": "0.1.15",
-    "@longtable/setup": "0.1.15"
+    "@longtable/checkpoints": "0.1.16",
+    "@longtable/core": "0.1.16",
+    "@longtable/memory": "0.1.16",
+    "@longtable/provider-claude": "0.1.16",
+    "@longtable/provider-codex": "0.1.16",
+    "@longtable/setup": "0.1.16"
   },
   "devDependencies": {
     "@types/node": "^22.10.1",

package/scripts/postinstall.mjs

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-
-import { execSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-function envFlag(name) {
-  const value = process.env[name];
-  if (!value) return false;
-  return !["0", "false", "no", "off"].includes(value.toLowerCase());
-}
-
-function isGlobalInstall() {
-  return process.env.npm_config_global === "true" || process.env.npm_config_location === "global";
-}
-
-function commandOnPath(command) {
-  try {
-    execSync(`command -v ${command}`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function requestedProviders() {
-  const raw = process.env.LONGTABLE_POSTINSTALL_PROVIDERS?.trim().toLowerCase();
-  if (!raw || raw === "auto") {
-    const providers = ["codex"];
-    if (commandOnPath("claude")) providers.push("claude");
-    return providers;
-  }
-  if (raw === "all") return ["codex", "claude"];
-  return raw
-    .split(",")
-    .map((entry) => entry.trim())
-    .filter((entry) => entry === "codex" || entry === "claude");
-}
-
-async function main() {
-  if (!isGlobalInstall() || envFlag("LONGTABLE_SKIP_POSTINSTALL")) {
-    return;
-  }
-
-  const distEntrypoint = fileURLToPath(new URL("../dist/personas.js", import.meta.url));
-  if (!existsSync(distEntrypoint)) {
-    console.warn("[longtable] Skipped provider skill bootstrap because package build output was not found.");
-    return;
-  }
-
-  const providers = requestedProviders();
-  if (providers.length === 0) {
-    return;
-  }
-
-  const { listRoleDefinitions } = await import("../dist/personas.js");
-  const roles = listRoleDefinitions();
-  const installed = [];
-
-  if (providers.includes("codex")) {
-    const { installCodexSkills, resolveCodexSkillsDir } = await import("@longtable/provider-codex");
-    const skills = await installCodexSkills(roles);
-    installed.push(`Codex skills: ${skills.length} (${resolveCodexSkillsDir()})`);
-  }
-
-  if (providers.includes("claude")) {
-    const { installClaudeSkills, resolveClaudeSkillsDir } = await import("@longtable/provider-claude");
-    const skills = await installClaudeSkills(roles);
-    installed.push(`Claude skills: ${skills.length} (${resolveClaudeSkillsDir()})`);
-  }
-
-  if (installed.length > 0) {
-    console.log("[longtable] Provider skills installed during global npm install:");
-    for (const line of installed) {
-      console.log(`[longtable] - ${line}`);
-    }
-    console.log("[longtable] Run `longtable doctor` to verify setup.");
-    console.log("[longtable] MCP config is opt-in: run `longtable mcp install --provider codex --write` when you want provider config files updated.");
-  }
-}
-
-main().catch((error) => {
-  console.warn(`[longtable] Postinstall provider skill bootstrap failed: ${error instanceof Error ? error.message : String(error)}`);
-  console.warn("[longtable] You can repair this later with `longtable doctor --fix`.");
-});