@longtable/cli 0.1.15 → 0.1.17

package/dist/debate.d.ts

@@ -0,0 +1,21 @@
+import type { InvocationIntent, InvocationRecord, PanelPlan, PanelVisibility, ProviderKind, QuestionRecord, TeamDebateRun } from "@longtable/core";
+export interface BuildTeamDebateOptions {
+    teamId: string;
+    teamDir: string;
+    prompt: string;
+    roleFlag?: string;
+    provider?: ProviderKind;
+    visibility?: PanelVisibility;
+    roundCount?: number;
+    tmux?: boolean;
+}
+export interface TeamDebateBundle {
+    plan: PanelPlan;
+    run: TeamDebateRun;
+    intent: InvocationIntent;
+    invocationRecord: InvocationRecord;
+    questionRecord: QuestionRecord;
+}
+export declare function createTeamDebateQuestionRecord(run: TeamDebateRun, provider?: ProviderKind): QuestionRecord;
+export declare function buildTeamDebate(options: BuildTeamDebateOptions): TeamDebateBundle;
+export declare function renderTeamDebateSummary(run: TeamDebateRun): string;

package/dist/debate.js

@@ -0,0 +1,380 @@
+import { join } from "node:path";
+import { buildInvocationIntent, buildPanelPlan } from "./panel.js";
+import { getPersonaDefinition, parsePersonaKey } from "./personas.js";
+function nowIso() {
+    return new Date().toISOString();
+}
+function createId(prefix) {
+    return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function signalTags(prompt) {
+    const normalized = prompt.toLowerCase();
+    const tags = [];
+    if (/\bmeasure|\bscale|\bvalid|reliab|측정|척도|타당|신뢰/.test(normalized))
+        tags.push("measurement");
+    if (/\btheor|\bconstruct|\bconcept|이론|개념|구성개념/.test(normalized))
+        tags.push("theory");
+    if (/\bmethod|\bdesign|\bsample|\banalysis|방법|설계|분석|표본/.test(normalized))
+        tags.push("method");
+    if (/\bevidence|\bcitation|\breference|근거|인용|문헌/.test(normalized))
+        tags.push("evidence");
+    if (/\bethic|\birb|consent|윤리|동의/.test(normalized))
+        tags.push("ethics");
+    if (/\bvoice|\bauthor|narrative|저자|서사|문체/.test(normalized))
+        tags.push("authorship");
+    return tags.length > 0 ? tags : ["general"];
+}
+function roleFocus(role) {
+    const key = parsePersonaKey(role);
+    return key ? getPersonaDefinition(key).shortDescription : "Inspect the research decision for hidden risk.";
+}
+function readableSignals(tags) {
+    return tags.join(", ");
+}
+function contribution(options) {
+    return {
+        id: createId("team_contribution"),
+        ...options
+    };
+}
+function independentContribution(roundId, plan, role, label, artifactPath) {
+    const tags = signalTags(plan.prompt);
+    return contribution({
+        roundId,
+        role,
+        label,
+        artifactPath,
+        summary: `${label} independently reviews the prompt for ${readableSignals(tags)} risks before any shared synthesis.`,
+        claims: [
+            `${label} should preserve a separate judgment lane rather than accepting the first synthesis.`,
+            `Primary role focus: ${roleFocus(role)}`
+        ],
+        objections: [
+            "The prompt may hide a commitment that has not yet been named by the researcher.",
+            "A fluent answer could collapse measurement, theory, evidence, and authorship concerns into one premature recommendation."
+        ],
+        openQuestions: [
+            "Which decision would become hard to reverse if LongTable proceeded now?",
+            "What evidence or researcher preference is still missing?"
+        ],
+        evidenceNeeds: [
+            "Local project state, manuscript/data references, or cited literature should be checked before closure.",
+            "If the prompt makes an external claim, attach source links or mark the claim as inference."
+        ],
+        tacitAssumptions: [
+            "The researcher may know constraints not present in the prompt.",
+            "The role's critique may over-weight its own domain unless challenged by other roles."
+        ],
+        checkpointTriggers: tags.map((tag) => `${tag}_commitment`)
+    });
+}
+function crossReviewContribution(roundId, plan, role, label, targetRole, targetLabel, artifactPath) {
+    return contribution({
+        roundId,
+        role,
+        label,
+        targetRole,
+        artifactPath,
+        summary: `${label} challenges ${targetLabel}'s likely blind spot before synthesis.`,
+        claims: [
+            `${targetLabel}'s concern is useful only if it does not erase ${label}'s domain-specific risk.`,
+            "The debate should expose disagreement as a researcher decision point rather than normalize it away."
+        ],
+        objections: [
+            `${targetLabel} may be treating its own role priority as the main research problem.`,
+            "The prompt still needs a concrete next decision, not only a list of concerns."
+        ],
+        openQuestions: [
+            `What would make ${targetLabel}'s objection decisive rather than advisory?`,
+            `What must the researcher answer before ${label} can accept ${targetLabel}'s framing?`
+        ],
+        evidenceNeeds: [
+            "Compare role objections against project state and available artifacts.",
+            "Separate source-backed objections from inferred risk."
+        ],
+        tacitAssumptions: [
+            "Roles may disagree because they are protecting different commitments.",
+            "The absence of evidence in the prompt is not evidence that the researcher lacks it."
+        ],
+        checkpointTriggers: ["role_disagreement", "unresolved_gap"]
+    });
+}
+function rebuttalContribution(roundId, role, label, artifactPath) {
+    return contribution({
+        roundId,
+        role,
+        label,
+        artifactPath,
+        summary: `${label} revises its position after cross-review while preserving unresolved risk.`,
+        claims: [
+            "Some objections should be accepted as constraints, not treated as blockers.",
+            "The final synthesis should distinguish actionable next steps from background concern."
+        ],
+        objections: [
+            "A role may over-correct after critique and lose the original high-stakes warning.",
+            "Convergence without a checkpoint would turn debate into hidden automation."
+        ],
+        openQuestions: [
+            "Which objection changes the next action?",
+            "Which unresolved disagreement should remain visible to the researcher?"
+        ],
+        evidenceNeeds: [
+            "Record which objections were accepted, rejected, or deferred.",
+            "Preserve references needed to verify the most consequential claim."
+        ],
+        tacitAssumptions: [
+            "A clean synthesis may be less honest than a visible unresolved tension.",
+            "The researcher should own the final prioritization."
+        ],
+        checkpointTriggers: ["synthesis_boundary", "researcher_authority"]
+    });
+}
+function convergenceContribution(roundId, plan, role, label, artifactPath) {
+    const otherRoles = plan.members.filter((member) => member.role !== role).map((member) => member.label);
+    return contribution({
+        roundId,
+        role,
+        label,
+        artifactPath,
+        summary: `${label} states what it can accept and what must remain open.`,
+        claims: [
+            `Can accept synthesis if it preserves ${label}'s domain warning.`,
+            `Must still show disagreement with: ${otherRoles.join(", ") || "no other roles"}.`
+        ],
+        objections: [
+            "Do not convert unresolved disagreement into a single confident recommendation.",
+            "Do not let the coordinator answer the checkpoint on behalf of the researcher."
+        ],
+        openQuestions: [
+            "Which path should LongTable recommend as the next researcher decision?",
+            "Which issue should be logged as an open tension if not answered now?"
+        ],
+        evidenceNeeds: [
+            "Link the synthesis back to role contributions and local artifacts.",
+            "Mark any missing sources as evidence gaps."
+        ],
+        tacitAssumptions: [
+            "A role's agreement may be conditional.",
+            "The researcher may choose to proceed despite unresolved risk."
+        ],
+        checkpointTriggers: ["panel_next_decision"]
+    });
+}
+function buildSynthesis(plan, artifactPath) {
+    const labels = plan.members.map((member) => member.label);
+    const highSensitivity = plan.checkpointSensitivity === "high";
+    return {
+        artifactPath,
+        summary: `The debate completed fixed 5-round review across ${labels.join(", ")}. It should slow closure by turning role disagreement into an explicit researcher decision.`,
+        consensus: [
+            "The researcher should see role disagreement before LongTable drafts, commits, or submits a conclusion.",
+            "Evidence gaps and tacit assumptions should remain visible instead of being smoothed into fluent prose."
+        ],
+        disagreements: [
+            "Roles may prioritize different first moves: theory framing, method defensibility, measurement validity, evidence verification, or authorship trace.",
+            "The coordinator should not decide which role wins without a researcher checkpoint."
+        ],
+        unresolvedGaps: [
+            "Which role concern is decisive for the next action?",
+            "What source, data, or local project artifact should be checked before closure?"
+        ],
+        researcherDecisionPoints: [
+            "Prioritize revision, evidence gathering, proceeding with risk, or keeping the issue open.",
+            "Choose whether the debate should affect the current artifact, the research design, or only the decision log."
+        ],
+        recommendedCheckpoint: highSensitivity
+            ? "The debate surfaced high-sensitivity disagreement. What should LongTable treat as the next human decision before closure?"
+            : "The debate surfaced role disagreement. Should LongTable revise, verify evidence, proceed, or keep the tension open?"
+    };
+}
+export function createTeamDebateQuestionRecord(run, provider) {
+    const createdAt = nowIso();
+    return {
+        id: createId("question_record"),
+        createdAt,
+        updatedAt: createdAt,
+        status: "pending",
+        prompt: {
+            id: createId("question_prompt"),
+            checkpointKey: "team_debate_next_decision",
+            title: "Team debate follow-up decision",
+            question: run.synthesis.recommendedCheckpoint,
+            type: "single_choice",
+            options: [
+                {
+                    value: "revise",
+                    label: "Revise before proceeding",
+                    description: "Use the debate result to revise the claim, design, or draft first."
+                },
+                {
+                    value: "evidence",
+                    label: "Gather or verify evidence first",
+                    description: "Check source, data, or local artifact support before proceeding."
+                },
+                {
+                    value: "proceed",
+                    label: "Proceed with current direction",
+                    description: "Accept the risk profile and continue with the current direction."
+                },
+                {
+                    value: "defer",
+                    label: "Keep this open",
+                    description: "Do not commit yet; keep the debate issue visible as an open tension."
+                }
+            ],
+            allowOther: true,
+            otherLabel: "Other decision",
+            required: run.roles.some((member) => {
+                const key = parsePersonaKey(member.role);
+                return key ? getPersonaDefinition(key).checkpointSensitivity === "high" : false;
+            }),
+            source: "runtime_guidance",
+            rationale: [
+                "Autonomous team debate is a research harness surface, not a substitute for researcher judgment.",
+                "The fixed debate rounds created disagreement that should connect to an explicit researcher decision.",
+                `Team debate run: ${run.id}.`
+            ],
+            preferredSurfaces: provider === "claude"
+                ? ["native_structured", "numbered"]
+                : ["numbered", "native_structured"]
+        }
+    };
+}
+export function buildTeamDebate(options) {
+    const roundCount = options.roundCount ?? 5;
+    if (roundCount !== 5) {
+        throw new Error("LongTable debate v1 supports fixed 5-round debate only.");
+    }
+    const createdAt = nowIso();
+    const plan = buildPanelPlan({
+        prompt: options.prompt,
+        mode: "review",
+        roleFlag: options.roleFlag,
+        provider: options.provider,
+        visibility: options.visibility ?? "always_visible"
+    });
+    const rounds = [];
+    const round1Id = createId("team_round");
+    rounds.push({
+        id: round1Id,
+        index: 1,
+        kind: "independent_review",
+        title: "Independent review",
+        status: "completed",
+        artifactDir: join(options.teamDir, "round-1-independent"),
+        contributions: plan.members.map((member) => independentContribution(round1Id, plan, member.role, member.label, join("round-1-independent", `${member.role}.json`)))
+    });
+    const round2Id = createId("team_round");
+    const crossContributions = plan.members.flatMap((member) => plan.members
+        .filter((target) => target.role !== member.role)
+        .map((target) => crossReviewContribution(round2Id, plan, member.role, member.label, target.role, target.label, join("round-2-cross-review", `${member.role}-on-${target.role}.json`))));
+    rounds.push({
+        id: round2Id,
+        index: 2,
+        kind: "cross_review",
+        title: "Cross-review",
+        status: "completed",
+        artifactDir: join(options.teamDir, "round-2-cross-review"),
+        contributions: crossContributions
+    });
+    const round3Id = createId("team_round");
+    rounds.push({
+        id: round3Id,
+        index: 3,
+        kind: "rebuttal",
+        title: "Rebuttal and revision",
+        status: "completed",
+        artifactDir: join(options.teamDir, "round-3-rebuttal"),
+        contributions: plan.members.map((member) => rebuttalContribution(round3Id, member.role, member.label, join("round-3-rebuttal", `${member.role}.json`)))
+    });
+    const round4Id = createId("team_round");
+    rounds.push({
+        id: round4Id,
+        index: 4,
+        kind: "convergence",
+        title: "Convergence and unresolved gaps",
+        status: "completed",
+        artifactDir: join(options.teamDir, "round-4-convergence"),
+        contributions: plan.members.map((member) => convergenceContribution(round4Id, plan, member.role, member.label, join("round-4-convergence", `${member.role}.json`)))
+    });
+    const synthesis = buildSynthesis(plan, "synthesis.json");
+    const run = {
+        id: createId("team_debate_run"),
+        teamId: options.teamId,
+        createdAt,
+        updatedAt: createdAt,
+        prompt: options.prompt,
+        roles: plan.members,
+        status: "completed",
+        surface: options.tmux ? "tmux_console" : "file_backed_debate",
+        roundPolicy: "fixed",
+        roundCount,
+        artifactRoot: options.teamDir,
+        rounds: [
+            ...rounds,
+            {
+                id: createId("team_round"),
+                index: 5,
+                kind: "synthesis",
+                title: "Coordinator synthesis and checkpoint",
+                status: "completed",
+                artifactDir: options.teamDir,
+                contributions: []
+            }
+        ],
+        synthesis,
+        linkedQuestionRecordIds: []
+    };
+    const questionRecord = createTeamDebateQuestionRecord(run, options.provider);
+    run.linkedQuestionRecordIds = [questionRecord.id];
+    const intent = buildInvocationIntent({
+        prompt: options.prompt,
+        mode: "review",
+        roles: plan.members.map((member) => member.role),
+        provider: options.provider,
+        visibility: plan.visibility,
+        checkpointSensitivity: plan.checkpointSensitivity,
+        rationale: [
+            "Autonomous debate requested through LongTable team orchestration.",
+            "File-backed fixed rounds keep disagreement inspectable before researcher closure."
+        ]
+    });
+    intent.kind = "team_debate";
+    intent.requestedSurface = run.surface;
+    const invocationRecord = {
+        id: createId("invocation_record"),
+        createdAt,
+        updatedAt: createdAt,
+        intent,
+        status: "completed",
+        provider: options.provider,
+        surface: run.surface,
+        panelPlan: plan,
+        teamDebateRun: run,
+        degradationReason: options.tmux
+            ? undefined
+            : "Tmux was not requested; file-backed debate artifacts are the canonical execution record."
+    };
+    return {
+        plan,
+        run,
+        intent,
+        invocationRecord,
+        questionRecord
+    };
+}
+export function renderTeamDebateSummary(run) {
+    return [
+        "LongTable Team Debate",
+        `- team: ${run.teamId}`,
+        `- surface: ${run.surface}`,
+        `- rounds: ${run.roundCount} fixed`,
+        `- roles: ${run.roles.map((role) => `${role.label} (${role.role})`).join(", ")}`,
+        `- artifacts: ${run.artifactRoot}`,
+        "",
+        run.synthesis.summary,
+        "",
+        "Researcher checkpoint:",
+        `- ${run.synthesis.recommendedCheckpoint}`
+    ].join("\n");
+}

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

@@ -893,6 +893,7 @@ export async function createOrUpdateProjectWorkspace(options) {
     const project = existsSync(projectFilePath)
         ? {
             ...JSON.parse(await readFile(projectFilePath, "utf8")),
+            projectPath,
             contractVersion: "workspace-v2",
             locale
         }
@@ -917,12 +918,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 }
                     : {})
             }
         };
@@ -998,8 +993,15 @@ export async function loadProjectContextFromDirectory(startPath) {
         const projectFilePath = join(metaDir, "project.json");
         const sessionFilePath = join(metaDir, "current-session.json");
         if (existsSync(projectFilePath) && existsSync(sessionFilePath)) {
-            const project = JSON.parse(await readFile(projectFilePath, "utf8"));
-            const session = JSON.parse(await readFile(sessionFilePath, "utf8"));
+            const workspaceRoot = current;
+            const project = {
+                ...JSON.parse(await readFile(projectFilePath, "utf8")),
+                projectPath: workspaceRoot
+            };
+            const session = {
+                ...JSON.parse(await readFile(sessionFilePath, "utf8")),
+                projectPath: workspaceRoot
+            };
             return {
                 project,
                 session: {
@@ -1012,8 +1014,8 @@ export async function loadProjectContextFromDirectory(startPath) {
                 },
                 projectFilePath,
                 sessionFilePath,
-                stateFilePath: resolveStateFilePath(project.projectPath),
-                currentFilePath: resolveCurrentFilePath(project.projectPath),
+                stateFilePath: resolveStateFilePath(workspaceRoot),
+                currentFilePath: resolveCurrentFilePath(workspaceRoot),
                 metaDir
             };
         }

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.17",
   "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.17",
+    "@longtable/core": "0.1.17",
+    "@longtable/memory": "0.1.17",
+    "@longtable/provider-claude": "0.1.17",
+    "@longtable/provider-codex": "0.1.17",
+    "@longtable/setup": "0.1.17"
   },
   "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`.");
-});