@felixdotgo/aidlc-kit 0.1.0 → 0.2.0

package/dist/src/cli/prompt.js

@@ -0,0 +1,66 @@
+/**
+ * Interactive layer: TTY detection, dynamic @inquirer/prompts loading, and the
+ * prompting flows (loop configuration, MCP setup selections, confirmations).
+ * Parsing of argv into options happens in ./argv.ts and ./options.ts.
+ */
+import { stdin, stdout } from "node:process";
+import { LOOP_PROVIDERS } from "../model.js";
+import { validateLoopConfig } from "../profiles.js";
+import { loopSelection, mcpArgSelections, parseWorkerMapping } from "./options.js";
+export const interactive = () => Boolean(stdin.isTTY && stdout.isTTY);
+const prompts = async () => import("@inquirer/prompts");
+export const chooseLoop = async (args, upgrade) => {
+    let { mode, lead: leadArg, workers: workersArg } = loopSelection(args);
+    if (!mode && (leadArg || workersArg))
+        throw new Error("--loop-lead and --loop-workers require --loop-mode");
+    if (!mode && interactive()) {
+        const { select } = await prompts();
+        mode = await select({ message: "Loop execution mode", choices: [
+                ...(upgrade ? [{ name: "Keep existing loop configuration", value: "keep" }] : []),
+                { name: "Off", value: "off" }, { name: "Local", value: "local" }, { name: "Fleet", value: "fleet" }
+            ] });
+    }
+    if (!mode || mode === "keep")
+        return undefined;
+    if (mode === "off") {
+        if (leadArg || workersArg)
+            throw new Error("Disabled loop cannot specify agents");
+        return validateLoopConfig({ mode });
+    }
+    let lead = leadArg, rawWorkers = workersArg;
+    if (interactive() && (!lead || !rawWorkers)) {
+        const { select, input } = await prompts();
+        lead ??= await select({ message: "Lead agent", choices: LOOP_PROVIDERS.map((name) => ({ name, value: name })) });
+        rawWorkers ??= await input({ message: "Workers (id=provider, comma separated)", default: "codex-worker=codex,claude-worker=claude" });
+    }
+    if (!lead || !rawWorkers)
+        throw new Error("An enabled loop requires --loop-lead and --loop-workers");
+    return validateLoopConfig({ mode, agents: { lead, workers: parseWorkerMapping(rawWorkers) } });
+};
+export const mcpSetupSelections = async (args) => {
+    const selected = mcpArgSelections(args);
+    if ((!selected.deployment || !selected.storage || !selected.bind || !selected.workspace) && !interactive())
+        throw new Error("mcp setup outside a TTY requires --deployment, --storage, --bind and --workspace");
+    if (interactive()) {
+        const { input, select, checkbox } = await prompts();
+        selected.deployment ??= await select({ message: "State service deployment", choices: [{ name: "Docker on this machine", value: "docker" }, { name: "Remote service (configure endpoint later)", value: "remote" }] });
+        selected.storage ??= await select({ message: "Database", choices: [{ name: "SQLite (local Docker volume)", value: "sqlite" }, { name: "PostgreSQL (multi-host production)", value: "postgres" }] });
+        selected.bind ??= await select({ message: "Network binding", choices: [{ name: "localhost only", value: "localhost" }, { name: "network (requires token/TLS)", value: "network" }] });
+        selected.workspace ??= await input({ message: "Workspace ID", default: "default", required: true });
+        if (!selected.providers.length)
+            selected.providers = await checkbox({ message: "Project-management connectors to configure", choices: ["jira", "trello", "github-issues"].map((value) => ({ name: value, value })) });
+    }
+    if (!Number.isInteger(selected.pollMs) || selected.pollMs < 1_000 || selected.pollMs > 3_600_000)
+        throw new Error("--poll-ms must be an integer from 1000 to 3600000");
+    return selected;
+};
+export const confirmGeneral = async (options, operation) => {
+    if (options.dryRun)
+        return false;
+    if (options.yes)
+        return true;
+    if (!interactive())
+        return false;
+    const { confirm } = await prompts();
+    return confirm({ message: `${operation} this plan?`, default: false });
+};

package/dist/src/cli.js

@@ -1,90 +1,15 @@
 #!/usr/bin/env node
-import { stdin, stdout } from "node:process";
-import { spawnSync } from "node:child_process";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { join } from "node:path";
-import { installableAdapters } from "./adapters.js";
-import { applyPlan, detectedAgents, doctor, formatPlan, planInit, planUninstall, selectAgents, status } from "./installer.js";
-import { LOOP_PROVIDERS } from "./model.js";
-import { loadProjectConfig, resolveProfiles, validateLoopConfig } from "./profiles.js";
+import { resolvedAdapters } from "./adapters.js";
+import { assertKnownOptions, flags, INIT_FLAGS, rootArg, UNINSTALL_FLAGS, UPGRADE_FLAGS, usage } from "./cli/argv.js";
+import { runDoctor, runLoopCommand, runMcp, runProfile, runStatus, runUi } from "./cli/commands.js";
+import { initOptions } from "./cli/options.js";
+import { chooseLoop, confirmGeneral, interactive } from "./cli/prompt.js";
+import { applyPlan, detectedAgents, formatPlan, planInit, planUninstall, selectAgents } from "./installer.js";
 import { applyUpgrade, planUpgrade } from "./upgrade.js";
 import { packageVersion } from "./workflow.js";
-import { applyMcpSetup, planMcpSetup } from "./mcp-setup.js";
-const usage = `Usage:
-  npx @felixdotgo/aidlc-kit init [path] [--agent <name[,name]> | --all] [--loop-mode off|local|fleet] [--loop-lead ${LOOP_PROVIDERS.join("|")}] [--loop-workers <id=provider,...>] [--yes] [--dry-run] [--force]
-  npx @felixdotgo/aidlc-kit upgrade [path] [--loop-mode off|local|fleet] [--loop-lead ${LOOP_PROVIDERS.join("|")}] [--loop-workers <id=provider,...>] [--dry-run]
-  npx @felixdotgo/aidlc-kit uninstall [path] [--yes] [--dry-run]
-  npx @felixdotgo/aidlc-kit status [path]
-  npx @felixdotgo/aidlc-kit doctor [path] [--strict]
-  npx @felixdotgo/aidlc-kit profile validate [path]
-  npx @felixdotgo/aidlc-kit loop start|status|resume [--task-id ID] [--root PATH] [--mode local|fleet]
-  npx @felixdotgo/aidlc-kit mcp setup [path] [--dry-run] [--yes] [--storage sqlite|postgres] [--deployment docker|remote] [--bind localhost|network] [--workspace <id>] [--poll-ms <n>] [--enable]`;
-const interactive = () => Boolean(stdin.isTTY && stdout.isTTY);
+/* Kept in this file: test/unit/cli.test.ts pins these prompt sources (and the upgrade boundary strings below) to src/cli.ts; the shared interactive flows live in ./cli/prompt.ts. */
 const prompts = async () => import("@inquirer/prompts");
-const value = (args, name) => {
-    const index = args.indexOf(name);
-    return index < 0 ? undefined : args[index + 1];
-};
-const flags = (args) => new Set(args.filter((item) => item.startsWith("--")));
-const valueFlags = new Set(["--agent", "--storage", "--deployment", "--bind", "--workspace", "--poll-ms", "--token-env", "--providers", "--loop-mode", "--loop-lead", "--loop-workers"]);
-const positional = (args) => {
-    const result = [];
-    for (let index = 0; index < args.length; index += 1) {
-        if (valueFlags.has(args[index])) {
-            index += 1;
-            continue;
-        }
-        if (!args[index].startsWith("--"))
-            result.push(args[index]);
-    }
-    return result;
-};
-const rootArg = (args, fallback = ".") => positional(args).find((item) => !["init", "upgrade", "uninstall", "status", "doctor", "validate", "run", "list"].includes(item)) ?? fallback;
-const chooseLoop = async (args, upgrade) => {
-    let mode = value(args, "--loop-mode");
-    const leadArg = value(args, "--loop-lead"), workersArg = value(args, "--loop-workers");
-    if (!mode && (leadArg || workersArg))
-        throw new Error("--loop-lead and --loop-workers require --loop-mode");
-    if (!mode && interactive()) {
-        const { select } = await prompts();
-        mode = await select({ message: "Loop execution mode", choices: [
-                ...(upgrade ? [{ name: "Keep existing loop configuration", value: "keep" }] : []),
-                { name: "Off", value: "off" }, { name: "Local", value: "local" }, { name: "Fleet", value: "fleet" }
-            ] });
-    }
-    if (!mode || mode === "keep")
-        return undefined;
-    if (mode === "off") {
-        if (leadArg || workersArg)
-            throw new Error("Disabled loop cannot specify agents");
-        return validateLoopConfig({ mode });
-    }
-    let lead = leadArg, rawWorkers = workersArg;
-    if (interactive() && (!lead || !rawWorkers)) {
-        const { select, input } = await prompts();
-        lead ??= await select({ message: "Lead agent", choices: LOOP_PROVIDERS.map((name) => ({ name, value: name })) });
-        rawWorkers ??= await input({ message: "Workers (id=provider, comma separated)", default: "codex-worker=codex,claude-worker=claude" });
-    }
-    if (!lead || !rawWorkers)
-        throw new Error("An enabled loop requires --loop-lead and --loop-workers");
-    const workers = Object.create(null);
-    for (const entry of rawWorkers.split(",")) {
-        const parts = entry.split("=");
-        if (parts.length !== 2 || !parts[0] || !parts[1] || Object.hasOwn(workers, parts[0]))
-            throw new Error("Invalid or duplicate loop worker mapping");
-        workers[parts[0]] = parts[1];
-    }
-    return validateLoopConfig({ mode, agents: { lead, workers } });
-};
-const initOptions = (args) => ({
-    root: rootArg(args),
-    agents: (value(args, "--agent") ?? "").split(",").filter(Boolean),
-    all: flags(args).has("--all"),
-    dryRun: flags(args).has("--dry-run"),
-    yes: flags(args).has("--yes"),
-    force: flags(args).has("--force")
-});
+/* --- Agent selection and plan preview -------------------------------------- */
 const chooseAgents = async (options) => {
     const selected = selectAgents(options);
     if (selected.length)
@@ -95,7 +20,7 @@ const chooseAgents = async (options) => {
     if (!interactive())
         throw new Error(`Unable to select an agent automatically. Use --agent <name> or --all. Detected: ${detected.join(", ") || "none"}`);
     const { checkbox } = await prompts();
-    const choices = installableAdapters();
+    const choices = resolvedAdapters();
     const agents = await checkbox({
         message: "Select one or more agents",
         choices: choices.map((adapter) => ({
@@ -110,143 +35,68 @@ const preview = (operation, plan) => {
     console.log(`◆ ${operation} preview — changes have NOT been applied`);
     console.log(formatPlan(plan));
 };
-const confirmGeneral = async (options, operation) => {
-    if (options.dryRun)
-        return false;
-    if (options.yes)
-        return true;
-    if (!interactive())
-        return false;
-    const { confirm } = await prompts();
-    return confirm({ message: `${operation} this plan?`, default: false });
-};
-const mcpSetupOptions = async (args) => {
-    const selected = {
-        deployment: value(args, "--deployment"),
-        storage: value(args, "--storage"),
-        bind: value(args, "--bind"),
-        workspace: value(args, "--workspace"),
-        pollMs: Number(value(args, "--poll-ms") ?? 30_000),
-        tokenEnv: value(args, "--token-env") ?? "AIDLC_MCP_TOKEN",
-        providers: (value(args, "--providers") ?? "").split(",").filter(Boolean)
-    };
-    if ((!selected.deployment || !selected.storage || !selected.bind || !selected.workspace) && !interactive())
-        throw new Error("mcp setup outside a TTY requires --deployment, --storage, --bind and --workspace");
-    if (interactive()) {
-        const { input, select, checkbox } = await prompts();
-        selected.deployment ??= await select({ message: "State service deployment", choices: [{ name: "Docker on this machine", value: "docker" }, { name: "Remote service (configure endpoint later)", value: "remote" }] });
-        selected.storage ??= await select({ message: "Database", choices: [{ name: "SQLite (local Docker volume)", value: "sqlite" }, { name: "PostgreSQL (multi-host production)", value: "postgres" }] });
-        selected.bind ??= await select({ message: "Network binding", choices: [{ name: "localhost only", value: "localhost" }, { name: "network (requires token/TLS)", value: "network" }] });
-        selected.workspace ??= await input({ message: "Workspace ID", default: "default", required: true });
-        if (!selected.providers.length)
-            selected.providers = await checkbox({ message: "Project-management connectors to configure", choices: ["jira", "trello", "github-issues"].map((value) => ({ name: value, value })) });
-    }
-    if (!Number.isInteger(selected.pollMs) || selected.pollMs < 1_000 || selected.pollMs > 3_600_000)
-        throw new Error("--poll-ms must be an integer from 1000 to 3600000");
-    return { root: rootArg(args), template: join(fileURLToPath(new URL("../services/aidlc-coordination", import.meta.url))), dryRun: flags(args).has("--dry-run"), deployment: selected.deployment, storage: selected.storage, bind: selected.bind, workspace: selected.workspace, pollMs: selected.pollMs, tokenEnv: selected.tokenEnv, providers: selected.providers, enable: flags(args).has("--enable") };
-};
-const main = async () => {
-    const [command = "help", ...args] = process.argv.slice(2);
-    if (command === "help" || command === "--help")
-        return void console.log(usage);
-    if (command === "loop") {
-        const action = args[0];
-        if (!["start", "status", "resume"].includes(action))
-            throw new Error("Expected loop start, status, or resume");
-        const parsed = new Map();
-        for (let index = 1; index < args.length; index += 2) {
-            const key = args[index], entry = args[index + 1];
-            if (!["--task-id", "--root", "--mode"].includes(key) || !entry || entry.startsWith("--") || parsed.has(key))
-                throw new Error("Invalid or duplicate loop option");
-            parsed.set(key, entry);
-        }
-        const root = resolve(parsed.get("--root") ?? ".");
-        const script = join(root, ".agents", "aidlc", "scripts", "loop-entry.mjs");
-        const child = spawnSync(process.execPath, [script, action, parsed.get("--task-id") ?? "", root, parsed.get("--mode") ?? ""], { stdio: "inherit" });
-        if (child.error)
-            throw child.error;
-        if (child.status !== 0)
-            process.exitCode = child.status ?? 1;
+/* --- Command handlers that consume the pinned prompts above ----------------- */
+const runInit = async (args) => {
+    assertKnownOptions(args, INIT_FLAGS);
+    const options = { ...await chooseAgents(initOptions(args)), loop: await chooseLoop(args, false) };
+    const plan = planInit(options);
+    preview("INIT", plan);
+    if (plan.some((item) => item.action === "conflict"))
+        throw new Error("No files were written because the plan contains conflicts.");
+    if (!await confirmGeneral(options, "Apply"))
         return;
+    if (plan.some((item) => item.action === "migrate" || item.action === "delete")) {
+        const result = applyUpgrade(options.root, plan);
+        console.log(`Installed local AI-DLC workflow assets and migrated legacy data. Backup: ${result.backup}; changed: ${result.changed}`);
     }
-    if (command === "status")
-        return void console.log(status(rootArg(args)));
-    if (command === "doctor") {
-        const result = doctor(rootArg(args), flags(args).has("--strict"));
-        console.log(result);
-        if (result.startsWith("ERROR:"))
-            process.exitCode = 1;
-        return;
-    }
-    if (command === "init") {
-        const options = { ...await chooseAgents(initOptions(args)), loop: await chooseLoop(args, false) };
-        const plan = planInit(options);
-        preview("INIT", plan);
-        if (plan.some((item) => item.action === "conflict"))
-            throw new Error("No files were written because the plan contains conflicts.");
-        if (!await confirmGeneral(options, "Apply"))
-            return;
-        const migratesLegacyData = plan.some((item) => item.action === "migrate" || item.action === "delete");
-        if (migratesLegacyData) {
-            const result = applyUpgrade(options.root, plan);
-            console.log(`Installed local AI-DLC workflow assets and migrated legacy data. Backup: ${result.backup}; changed: ${result.changed}`);
-        }
-        else {
-            applyPlan(options.root, plan);
-            console.log("Installed local AI-DLC workflow assets.");
-        }
-        return;
-    }
-    if (command === "uninstall") {
-        const options = initOptions(args);
-        const plan = planUninstall(options.root);
-        preview("UNINSTALL", plan);
-        if (!await confirmGeneral(options, "Remove"))
-            return;
+    else {
         applyPlan(options.root, plan);
-        console.log("Removed eligible managed assets; project config and state were preserved.");
-        return;
+        console.log("Installed local AI-DLC workflow assets.");
     }
-    if (command === "upgrade") {
-        if (flags(args).has("--yes") || flags(args).has("--force"))
-            throw new Error("upgrade does not support --yes or --force; apply requires a human interactive TTY confirmation");
-        const root = rootArg(args);
-        const plan = planUpgrade(root, await chooseLoop(args, true));
-        preview("UPGRADE", plan);
-        if (plan.some((item) => item.action === "conflict"))
-            throw new Error("Upgrade contains conflicts; no files were written.");
-        if (flags(args).has("--dry-run"))
-            return;
-        if (!interactive())
-            throw new Error("Upgrade apply requires an interactive TTY. AI and non-interactive processes must not apply upgrades.");
-        const expected = packageVersion();
-        const { input } = await prompts();
-        if ((await input({ message: `Type ${expected} to apply this user-initiated upgrade` })).trim() !== expected)
-            throw new Error("Upgrade confirmation did not match the target version");
-        const result = applyUpgrade(root, plan);
-        console.log(`Upgrade complete. Backup: ${result.backup}; changed: ${result.changed}`);
-        return;
-    }
-    if (command === "mcp" && args[0] === "setup") {
-        const options = await mcpSetupOptions(args.slice(1));
-        const plan = planMcpSetup(options);
-        console.log(`◆ MCP SETUP preview — ${options.dryRun ? "no files will be written" : "review before applying"}`);
-        console.log(JSON.stringify(plan, null, 2));
-        if (options.dryRun)
-            return;
-        if (!await confirmGeneral({ ...initOptions(args), root: options.root }, "Apply MCP setup"))
-            return;
-        applyMcpSetup(options);
-        console.log(`MCP setup written to ${plan.target}. MCP remains ${options.enable ? "enabled" : "disabled"}; start Docker explicitly with docker compose --env-file .env -f ${join(plan.target, "compose.yaml")} up -d.`);
+};
+const runUninstall = async (args) => {
+    assertKnownOptions(args, UNINSTALL_FLAGS);
+    const options = initOptions(args);
+    const plan = planUninstall(options.root);
+    preview("UNINSTALL", plan);
+    if (!await confirmGeneral(options, "Remove"))
         return;
-    }
-    if (command === "profile" && args[0] === "validate") {
-        const root = rootArg(args.slice(1));
-        const config = loadProjectConfig(root);
-        const profiles = resolveProfiles(root, config.extends);
-        console.log(`OK: ${profiles.map((item) => item.id).join(" → ")}`);
+    applyPlan(options.root, plan);
+    console.log("Removed eligible managed assets; project config and state were preserved.");
+};
+const runUpgrade = async (args) => {
+    assertKnownOptions(args, UPGRADE_FLAGS);
+    if (flags(args).has("--yes") || flags(args).has("--force"))
+        throw new Error("upgrade does not support --yes or --force; apply requires a human interactive TTY confirmation");
+    const root = rootArg(args);
+    const plan = planUpgrade(root, await chooseLoop(args, true));
+    preview("UPGRADE", plan);
+    if (plan.some((item) => item.action === "conflict"))
+        throw new Error("Upgrade contains conflicts; no files were written.");
+    if (flags(args).has("--dry-run"))
         return;
-    }
-    throw new Error(`Unknown command: ${command}`);
+    if (!interactive())
+        throw new Error("Upgrade apply requires an interactive TTY. AI and non-interactive processes must not apply upgrades.");
+    const expected = packageVersion();
+    const { input } = await prompts();
+    if ((await input({ message: `Type ${expected} to apply this user-initiated upgrade` })).trim() !== expected)
+        throw new Error("Upgrade confirmation did not match the target version");
+    const result = applyUpgrade(root, plan);
+    console.log(`Upgrade complete. Backup: ${result.backup}; changed: ${result.changed}`);
+};
+const runHelp = () => console.log(usage);
+const runVersion = () => console.log(packageVersion());
+const REGISTRY = { init: runInit, upgrade: runUpgrade, uninstall: runUninstall, status: runStatus, doctor: runDoctor, loop: runLoopCommand, ui: runUi, mcp: runMcp, profile: runProfile, version: runVersion, help: runHelp };
+const main = async () => {
+    const argv = process.argv.slice(2);
+    if (argv.includes("--version") || argv.includes("-v"))
+        return void console.log(packageVersion());
+    if (argv.includes("--help"))
+        return void console.log(usage);
+    const [command = "help", ...args] = argv;
+    const handler = Object.hasOwn(REGISTRY, command) ? REGISTRY[command] : undefined;
+    if (!handler)
+        throw new Error(`Unknown command: ${command}`);
+    return void await handler(args);
 };
-main().catch((error) => { console.error(`aidlc-workflow: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; });
+main().catch((error) => { console.error(`aidlc-kit: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; });

package/dist/src/context.js

@@ -6,10 +6,12 @@ import { loadMemoryRegistry, nextAction, selectAgenticMemory } from "./state.js"
 const assetRoot = fileURLToPath(new URL("../assets/.agents/aidlc", import.meta.url));
 const phaseFile = (phase) => phase === "done" ? "phase-wrap.md" : `phase-${phase}.md`;
 const readAsset = (path) => readFileSync(join(assetRoot, path), "utf8");
+/** Keeps only the latest test/lint/review record per (kind, area, gate) and strips prose details. */
 const requiredEvidence = (task) => task.evidence.filter((item, index, entries) => {
     const key = `${item.kind}:${item.area ?? ""}:${item.gate ?? ""}`;
     return !entries.slice(index + 1).some((candidate) => `${candidate.kind}:${candidate.area ?? ""}:${candidate.gate ?? ""}` === key);
 }).map(({ detail: _detail, ...item }) => item);
+/** Compact canonical view of the task for a phase packet; `itemId` narrows execution items only. */
 const compactTask = (task, itemId) => JSON.stringify({
     id: task.id,
     title: task.title,

package/dist/src/gate.d.ts

@@ -1,4 +1,5 @@
 import type { Diagnostic, Gate, TaskState, WorkflowState } from "./model.js";
+/** Runs all diagnostics for a gate and returns them (empty-ish with GATE_OK when clean). */
 export declare const checkGate: (root: string, state: WorkflowState, taskId: string, gate: Gate) => Diagnostic[];
 export declare const approveAndAdvance: (root: string, state: WorkflowState, taskId: string, gate: Gate, source: string, recordedAt?: string) => {
     task: TaskState;

package/dist/src/gate.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { resolveProjectPathWithoutSymlinks } from "./project-path.js";
-import { hasAreaVerification, hasReview, isLegacyG2Wait, nextAction, repairBounds, transitionDiagnostics, transitionTask } from "./state.js";
+import { hasAreaVerification, hasReview, isLegacyG2Wait, loopPartitionStrict, nextAction, partitionDiagnostics, repairBounds, transitionDiagnostics, transitionTask } from "./state.js";
 const safeArtifactTarget = (root, path) => resolveProjectPathWithoutSymlinks(root, path, "Unsafe artifact path", "Artifact path crosses a symlink");
 const artifactContent = (root, path) => {
     if (!path)
@@ -11,7 +11,7 @@ const artifactContent = (root, path) => {
     }
     catch {
         return undefined;
-    }
+    } /* intentional: unreadable/unsafe artifact is treated as absent */
 };
 const artifactDiagnostics = (root, task, names) => names.flatMap((name) => {
     const path = task.artifacts[name];
@@ -24,10 +24,40 @@ const artifactDiagnostics = (root, task, names) => names.flatMap((name) => {
         return [{ level: "ERROR", code: "ARTIFACT_UNSAFE", message: error instanceof Error ? error.message : String(error) }];
     }
 });
-export const checkGate = (root, state, taskId, gate) => {
-    const task = state.tasks[taskId];
-    if (!task)
-        return [{ level: "ERROR", code: "TASK_UNKNOWN", message: `Unknown task: ${taskId}` }];
+const missingHeadings = (content, headings) => headings.filter((heading) => !content.includes(heading));
+const confirmGateDiagnostics = (root, task) => {
+    const diagnostics = artifactDiagnostics(root, task, ["intent"]);
+    const content = artifactContent(root, task.artifacts.intent);
+    if (content !== undefined)
+        for (const heading of missingHeadings(content, ["## 📋 Problem", "## 🗺️ Affected areas", "## 💭 Assumptions", "## ❓ Open questions", "## 🎯 Scope"]))
+            diagnostics.push({ level: "ERROR", code: "INTENT_HEADING", message: `Intent is missing ${heading}` });
+    return diagnostics;
+};
+const reviewGateDiagnostics = (root, task) => {
+    const diagnostics = artifactDiagnostics(root, task, ["intent", "design", "workplan"]);
+    diagnostics.push(...transitionDiagnostics(task, "build").filter((item) => item.code === "UNRESOLVED_DECISION"));
+    const content = artifactContent(root, task.artifacts.design);
+    if (content !== undefined)
+        for (const heading of missingHeadings(content, ["## 🧩 Solution per affected area", "## 📌 Spec traceability", "## 🔗 Cross-service contracts", "## ⚠️ Risks / edge cases"]))
+            diagnostics.push({ level: "ERROR", code: "DESIGN_HEADING", message: `Design is missing ${heading}` });
+    diagnostics.push(...partitionDiagnostics(task, { strict: loopPartitionStrict(root) }));
+    return diagnostics;
+};
+const codeReviewGateDiagnostics = (root, task) => {
+    const diagnostics = artifactDiagnostics(root, task, ["intent", "design", "workplan"]);
+    if (task.tasks.some((item) => item.status !== "done" && item.status !== "deferred"))
+        diagnostics.push({ level: "ERROR", code: "TASKS_OPEN", message: "Build tasks remain open" });
+    for (const area of task.areas)
+        if (!hasAreaVerification(task, area))
+            diagnostics.push({ level: "ERROR", code: "VERIFY_EVIDENCE", message: `Latest post-G1 verification evidence must pass for affected area: ${area}` });
+    if (!hasReview(task))
+        diagnostics.push({ level: "ERROR", code: "REVIEW_EVIDENCE", message: "Latest post-G1 review evidence must pass" });
+    const bounds = repairBounds(task);
+    if (!isLegacyG2Wait(task) && (bounds.verifyExhausted || bounds.reviewExhausted))
+        diagnostics.push({ level: "ERROR", code: "REPAIR_BOUND", message: "Repair bound exhausted; record a durable handoff instead of presenting G2" });
+    return diagnostics;
+};
+const generalGateDiagnostics = (taskId, task, gate) => {
     const diagnostics = [];
     if (task.gate !== gate)
         diagnostics.push({ level: "ERROR", code: "GATE_STATE", message: `Task is at ${task.gate}, not ${gate}` });
@@ -39,37 +69,21 @@ export const checkGate = (root, state, taskId, gate) => {
         diagnostics.push({ level: "ERROR", code: "TASK_ID", message: "Task key and id differ" });
     if (!task.title.trim() || !task.areas.length)
         diagnostics.push({ level: "ERROR", code: "TASK_FIELDS", message: "Task title and affected areas are required" });
-    if (gate === "G0_confirm") {
-        diagnostics.push(...artifactDiagnostics(root, task, ["intent"]));
-        const content = artifactContent(root, task.artifacts.intent);
-        if (content !== undefined)
-            for (const heading of ["## 📋 Problem", "## 🗺️ Affected areas", "## 💭 Assumptions", "## ❓ Open questions", "## 🎯 Scope"])
-                if (!content.includes(heading))
-                    diagnostics.push({ level: "ERROR", code: "INTENT_HEADING", message: `Intent is missing ${heading}` });
-    }
-    if (gate === "G1_review") {
-        diagnostics.push(...artifactDiagnostics(root, task, ["intent", "design", "workplan"]));
-        diagnostics.push(...transitionDiagnostics(task, "build").filter((item) => item.code === "UNRESOLVED_DECISION"));
-        const content = artifactContent(root, task.artifacts.design);
-        if (content !== undefined)
-            for (const heading of ["## 🧩 Solution per affected area", "## 📌 Spec traceability", "## 🔗 Cross-service contracts", "## ⚠️ Risks / edge cases"])
-                if (!content.includes(heading))
-                    diagnostics.push({ level: "ERROR", code: "DESIGN_HEADING", message: `Design is missing ${heading}` });
-    }
-    if (gate === "G2_codereview") {
-        diagnostics.push(...artifactDiagnostics(root, task, ["intent", "design", "workplan"]));
-        if (task.tasks.some((item) => item.status !== "done" && item.status !== "deferred"))
-            diagnostics.push({ level: "ERROR", code: "TASKS_OPEN", message: "Build tasks remain open" });
-        for (const area of task.areas)
-            if (!hasAreaVerification(task, area))
-                diagnostics.push({ level: "ERROR", code: "VERIFY_EVIDENCE", message: `Latest post-G1 verification evidence must pass for affected area: ${area}` });
-        if (!hasReview(task))
-            diagnostics.push({ level: "ERROR", code: "REVIEW_EVIDENCE", message: "Latest post-G1 review evidence must pass" });
-        const bounds = repairBounds(task);
-        if (!isLegacyG2Wait(task) && (bounds.verifyExhausted || bounds.reviewExhausted))
-            diagnostics.push({ level: "ERROR", code: "REPAIR_BOUND", message: "Repair bound exhausted; record a durable handoff instead of presenting G2" });
-    }
-    if (!diagnostics.length)
+    return diagnostics;
+};
+/** Runs all diagnostics for a gate and returns them (empty-ish with GATE_OK when clean). */
+export const checkGate = (root, state, taskId, gate) => {
+    const task = state.tasks[taskId];
+    if (!task)
+        return [{ level: "ERROR", code: "TASK_UNKNOWN", message: `Unknown task: ${taskId}` }];
+    const diagnostics = generalGateDiagnostics(taskId, task, gate);
+    if (gate === "G0_confirm")
+        diagnostics.push(...confirmGateDiagnostics(root, task));
+    if (gate === "G1_review")
+        diagnostics.push(...reviewGateDiagnostics(root, task));
+    if (gate === "G2_codereview")
+        diagnostics.push(...codeReviewGateDiagnostics(root, task));
+    if (!diagnostics.some((item) => item.level === "ERROR"))
         diagnostics.push({ level: "INFO", code: "GATE_OK", message: `${gate} checks passed for ${taskId}` });
     return diagnostics;
 };

package/dist/src/installer.d.ts

@@ -1,15 +1,27 @@
-import type { AgentId, FileSpec, InitOptions, LoopConfig, ManifestInventoryItem, PlannedWrite, WorkflowManifest } from "./model.js";
-/** Managed prompt blocks share a path across owners, so inventory keys carry the owner. */
-export declare const installedHashFor: (files: Record<string, ManifestInventoryItem> | undefined, spec: Pick<FileSpec, "path" | "owner" | "strategy">) => string | undefined;
-export declare const managedContentHash: (spec: Pick<FileSpec, "owner" | "strategy">, content: string) => string | undefined;
-export declare const readManifest: (root: string) => WorkflowManifest | undefined;
+import type { AgentId, InitOptions, PlannedWrite } from "./model.js";
+/** Manifest reading lives in the managed-planning core; this export path stays stable for existing importers. */
+export { readManifest } from "./managed-planning.js";
 export declare const detectedAgents: (root: string) => AgentId[];
 export declare const selectAgents: (options: Pick<InitOptions, "root" | "agents" | "all">) => AgentId[];
-/** Include an explicitly selected loop config in the same preview/transaction as setup. */
-export declare const planLoopSelection: (plan: PlannedWrite[], selection?: LoopConfig) => void;
+/** Plans an init transaction: managed workflow files, manifest, and project-owned files. */
 export declare const planInit: (options: InitOptions) => PlannedWrite[];
+/** Applies a planned init/uninstall transaction to disk. */
 export declare const applyPlan: (root: string, plan: PlannedWrite[]) => void;
 export declare const formatPlan: (plan: PlannedWrite[]) => string;
+/** Plans an uninstall transaction that removes only unchanged managed assets. */
 export declare const planUninstall: (root: string) => PlannedWrite[];
+export declare const statusData: (root: string) => {
+    workflow: string;
+    installedVersion: string;
+    schema: string;
+    detectedAgents: string[];
+};
+/** Reports installed workflow version, schema, and detected agents. */
 export declare const status: (root: string) => string;
+/** Validates the installed workflow manifest and local config/state. */
 export declare const doctor: (root: string, strict?: boolean) => string;
+export declare const doctorData: (root: string, strict?: boolean) => {
+    level: "ok" | "warn" | "error";
+    message: string;
+    strict: boolean;
+};