@felixdotgo/aidlc-kit 0.1.1 → 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,96 +1,15 @@
 #!/usr/bin/env node
-import { stdin, stdout } from "node:process";
-import { spawnSync } from "node:child_process";
-import { resolve, join } from "node:path";
-import { fileURLToPath } from "node:url";
-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");
-/* --- Argv helpers --------------------------------------------------------- */
-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 COMMAND_KEYWORDS = ["init", "upgrade", "uninstall", "status", "doctor", "validate", "run", "list"];
-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) => !COMMAND_KEYWORDS.includes(item)) ?? fallback;
-/* --- Loop configuration --------------------------------------------------- */
-const parseWorkerMapping = (rawWorkers) => {
-    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 workers;
-};
-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");
-    return validateLoopConfig({ mode, agents: { lead, workers: parseWorkerMapping(rawWorkers) } });
-};
-/* --- Option builders and shared flows -------------------------------------- */
-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)
@@ -101,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) => ({
@@ -116,67 +35,9 @@ 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 });
-};
-/* --- MCP setup options ----------------------------------------------------- */
-const mcpSetupSelections = 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 selected;
-};
-const mcpSetupOptions = async (args) => {
-    const selected = await mcpSetupSelections(args);
-    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") };
-};
-/* --- Command handlers ------------------------------------------------------ */
-const runLoopCommand = (args) => {
-    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);
@@ -194,6 +55,7 @@ const runInit = async (args) => {
     }
 };
 const runUninstall = async (args) => {
+    assertKnownOptions(args, UNINSTALL_FLAGS);
     const options = initOptions(args);
     const plan = planUninstall(options.root);
     preview("UNINSTALL", plan);
@@ -203,6 +65,7 @@ const runUninstall = async (args) => {
     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);
@@ -221,48 +84,19 @@ const runUpgrade = async (args) => {
     const result = applyUpgrade(root, plan);
     console.log(`Upgrade complete. Backup: ${result.backup}; changed: ${result.changed}`);
 };
-const runMcpSetup = async (args) => {
-    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 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 [command = "help", ...args] = process.argv.slice(2);
-    if (command === "help" || command === "--help")
+    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);
-    if (command === "loop")
-        return void runLoopCommand(args);
-    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")
-        return void await runInit(args);
-    if (command === "uninstall")
-        return void await runUninstall(args);
-    if (command === "upgrade")
-        return void await runUpgrade(args);
-    if (command === "mcp" && args[0] === "setup")
-        return void await runMcpSetup(args);
-    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(" → ")}`);
-        return;
-    }
-    throw new Error(`Unknown command: ${command}`);
+    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-kit: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; });

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)
@@ -40,6 +40,7 @@ const reviewGateDiagnostics = (root, task) => {
     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) => {
@@ -82,7 +83,7 @@ export const checkGate = (root, state, taskId, gate) => {
         diagnostics.push(...reviewGateDiagnostics(root, task));
     if (gate === "G2_codereview")
         diagnostics.push(...codeReviewGateDiagnostics(root, task));
-    if (!diagnostics.length)
+    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,12 +1,8 @@
-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. */
@@ -14,7 +10,18 @@ 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;
+};

package/dist/src/installer.js

@@ -1,113 +1,23 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { adapters, findAdapter, installableAdapters, resolvedAdapters } from "./adapters.js";
-import { loadProjectConfig, validateLoopConfig } from "./profiles.js";
+import { adapters, findAdapter, resolvedAdapters } from "./adapters.js";
+import { loadProjectConfig } from "./profiles.js";
 import { loadState } from "./state.js";
 import { planProjectLayoutMigration } from "./project-migration.js";
-import { managedBlock, mergeManagedBlock } from "./managed-content.js";
+import { legacyManagedMarker, managedBlock, removeManagedBlock } from "./managed-content.js";
+import { hasOwnedManifest, managedContentHash, planLoopSelection, planManagedWrites, readManifest, readManifestFile, splitInventoryKey } from "./managed-planning.js";
 import { resolveProjectPathWithoutSymlinks } from "./project-path.js";
 import { contentHash, coreWorkflowFiles, initialProjectFiles, manifestSpec, packageVersion } from "./workflow.js";
+/** Manifest reading lives in the managed-planning core; this export path stays stable for existing importers. */
+export { readManifest } from "./managed-planning.js";
 const shortHash = (content) => contentHash(content).slice(0, 12);
 const safeTarget = (root, path) => resolveProjectPathWithoutSymlinks(root, path, "Managed path escapes the project", "Managed path crosses a symlink");
-/** Managed prompt blocks share a path across owners, so inventory keys carry the owner. */
-export const installedHashFor = (files, spec) => {
-    if (!files)
-        return undefined;
-    const keyed = files[`${spec.path}#${spec.owner}`];
-    if (keyed)
-        return keyed.hash;
-    const legacy = files[spec.path];
-    return legacy && (spec.strategy !== "managed-block" || legacy.owner === spec.owner) ? legacy.hash : undefined;
-};
-export const managedContentHash = (spec, content) => {
-    const managed = managedBlock(spec, content);
-    return managed === undefined ? undefined : contentHash(managed);
-};
-export const readManifest = (root) => {
-    const path = join(resolve(root), ".agents/aidlc/manifest.json");
-    if (!existsSync(path))
-        return undefined;
-    try {
-        const value = JSON.parse(readFileSync(path, "utf8"));
-        const validFiles = value.files && typeof value.files === "object" && !Array.isArray(value.files) && Object.values(value.files).every((item) => item && typeof item.hash === "string" && typeof item.owner === "string" && ["replace", "managed-block"].includes(item.strategy));
-        return value.schemaVersion === 2 && typeof value.packageVersion === "string" && value.workflow === "AI-DLC" && value.source === "local-package-assets" && value.remoteUpdates === false && (value.managedBy === "aidlc-kit" || value.managedBy === "aidlc-workflow") && Array.isArray(value.adapters) && validFiles ? value : undefined;
-    }
-    catch {
-        return undefined;
-    } /* intentional: a malformed manifest is treated as "not installed" */
-};
-export const detectedAgents = (root) => installableAdapters().filter((adapter) => adapter.detect(root)).map((adapter) => adapter.id);
+export const detectedAgents = (root) => resolvedAdapters().filter((adapter) => adapter.detect(root)).map((adapter) => adapter.id);
 export const selectAgents = (options) => {
     if (options.all)
         return adapters.map((adapter) => adapter.id);
     return [...new Set(options.agents)];
 };
-const planFile = (root, spec, force, installed) => {
-    const target = safeTarget(root, spec.path);
-    if (spec.ownershipClass === "project" || spec.ownershipClass === "state") {
-        return existsSync(target)
-            ? { ...spec, content: readFileSync(target, "utf8"), action: "preserve", reason: `${spec.ownershipClass}-owned file` }
-            : { ...spec, action: "create", reason: `new ${spec.ownershipClass}-owned file` };
-    }
-    if (spec.strategy === "managed-block") {
-        const current = existsSync(target) ? readFileSync(target, "utf8") : "";
-        const next = mergeManagedBlock(spec, current);
-        return { ...spec, content: next, action: existsSync(target) ? (next === current ? "skip" : "update") : "create", reason: existsSync(target) ? "managed prompt block" : "new managed prompt" };
-    }
-    if (!existsSync(target))
-        return { ...spec, action: "create", reason: "new managed file" };
-    const current = readFileSync(target, "utf8");
-    if (current === spec.content)
-        return { ...spec, action: "skip", reason: "already current" };
-    if (spec.path === ".agents/aidlc/manifest.json" && installed)
-        return { ...spec, action: "update", reason: "refresh manifest inventory" };
-    const installedHash = installedHashFor(installed?.files, spec);
-    if (installedHash && contentHash(current) === installedHash)
-        return { ...spec, action: "update", reason: "unchanged managed file" };
-    if (force)
-        return { ...spec, action: "update", reason: "--force permits replacement of an unmanaged file" };
-    return { ...spec, action: "conflict", reason: "managed ownership cannot be proven; use upgrade or review --force" };
-};
-/** Include an explicitly selected loop config in the same preview/transaction as setup. */
-export const planLoopSelection = (plan, selection) => {
-    if (selection === undefined)
-        return;
-    const loop = validateLoopConfig(selection);
-    const config = plan.find((item) => item.path === ".agents/config.json");
-    if (!config || !["create", "preserve", "skip", "migrate"].includes(config.action))
-        throw new Error("Cannot change loop configuration while the project config has another planned change");
-    const parsed = JSON.parse(config.content);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-        throw new Error("Invalid project config");
-    const current = parsed;
-    if (JSON.stringify(current.loop) === JSON.stringify(loop))
-        return;
-    const previousAction = config.action;
-    current.loop = loop;
-    config.content = `${JSON.stringify(current, null, 2)}\n`;
-    config.action = previousAction === "create" || previousAction === "migrate" ? previousAction : "update";
-    config.reason = "explicit loop mode selection";
-};
-/** Merges a later owner of an already-planned shared managed-block path into the emitted entry. */
-const mergeIntoPlannedBlock = (root, previous, spec) => {
-    const target = safeTarget(root, spec.path);
-    const current = existsSync(target) ? readFileSync(target, "utf8") : "";
-    previous.content = mergeManagedBlock(spec, previous.content);
-    previous.action = existsSync(target) ? (previous.content === current ? "skip" : "update") : "create";
-    previous.reason = existsSync(target) ? "managed prompt block" : "new managed prompt";
-};
-/** Plans managed workflow files, the manifest, and project-owned files; later block owners merge in line. */
-const planManagedWrites = (root, files, force, installed) => {
-    const plan = [];
-    for (const spec of files) {
-        const previous = spec.strategy === "managed-block" ? plan.find((item) => item.path === spec.path && ["create", "update", "skip"].includes(item.action)) : undefined;
-        if (!previous)
-            plan.push(planFile(root, spec, force, installed));
-        else
-            mergeIntoPlannedBlock(root, previous, spec);
-    }
-    return plan;
-};
 /** Plans an init transaction: managed workflow files, manifest, and project-owned files. */
 export const planInit = (options) => {
     const root = resolve(options.root);
@@ -121,7 +31,7 @@ export const planInit = (options) => {
     const agentFiles = selected.flatMap((id) => findAdapter(id)?.files() ?? []).map((file) => ({ ...file, ownershipClass: "managed" }));
     const managedFiles = [...coreWorkflowFiles(), ...agentFiles];
     const files = [...managedFiles, manifestSpec(managedFiles, selected), ...initialProjectFiles()];
-    const plan = planManagedWrites(root, files, options.force, installed);
+    const plan = planManagedWrites(root, files, { flow: "init", force: options.force, installed, resolvePath: safeTarget });
     planProjectLayoutMigration(root, plan);
     planLoopSelection(plan, options.loop);
     return plan;
@@ -137,28 +47,10 @@ export const applyPlan = (root, plan) => {
     }
 };
 export const formatPlan = (plan) => plan.map((item) => `${item.action.padEnd(8)} ${item.path} (${item.reason}; sha=${shortHash(item.contentEncoding === "base64" ? Buffer.from(item.content, "base64") : item.content)})`).join("\n");
-const hasOwnedManifest = (root) => {
-    const path = join(resolve(root), ".agents/aidlc/manifest.json");
-    if (!existsSync(path))
-        return false;
-    try {
-        const parsed = JSON.parse(readFileSync(path, "utf8"));
-        return parsed.managedBy === "aidlc-kit" || parsed.managedBy === "aidlc-workflow";
-    }
-    catch {
-        return false;
-    } /* intentional: a malformed/missing manifest is not owned */
-};
-const removeManagedBlock = (current, owner) => {
-    const start = `<!-- aidlc-installer:${owner}:start -->`;
-    const end = `<!-- aidlc-installer:${owner}:end -->`;
-    return current.replace(new RegExp(`${start}[\\s\\S]*?${end}\\n?`, "g"), "").replace(/\n{3,}/g, "\n\n").trimEnd();
-};
 /** Maps one manifest inventory record onto its current spec and installed hash. */
 const uninstallEntry = (key, item, currentSpecs) => {
-    const separator = key.lastIndexOf("#");
-    const path = separator > 0 ? key.slice(0, separator) : key;
-    const owner = separator > 0 ? key.slice(separator + 1) : item.owner;
+    const { path, owner: keyedOwner } = splitInventoryKey(key);
+    const owner = keyedOwner ?? item.owner;
     const spec = currentSpecs.find((candidate) => candidate.path === path && (candidate.strategy !== "managed-block" || candidate.owner === owner)) ?? { path, owner, strategy: item.strategy, content: "", ownershipClass: "managed" };
     return { spec, hash: item.hash };
 };
@@ -178,7 +70,7 @@ const stripManagedBlocks = (group, current) => {
         const block = managedBlock(spec, next);
         // A v0.2.1 single-marker block cannot be removed safely; retain ownership instead of orphaning it.
         if (!block) {
-            if (next.includes(`<!-- aidlc-installer:${spec.owner} -->`))
+            if (next.includes(legacyManagedMarker(spec.owner)))
                 modified = spec;
             continue;
         }
@@ -200,7 +92,7 @@ const uninstallWholeFile = (group, exists, current) => {
         return contentHash(current) === installedHash ? { ...spec, action: "delete", reason: "remove unchanged managed file" } : { ...spec, action: "preserve", reason: "managed file was modified" };
     }
     const { next, modified } = stripManagedBlocks(group, current);
-    const legacyResidue = group.find(({ spec }) => next.includes(`<!-- aidlc-installer:${spec.owner} -->`));
+    const legacyResidue = group.find(({ spec }) => next.includes(legacyManagedMarker(spec.owner)));
     const ownerSpec = group[0].spec;
     if (modified)
         return { ...modified, action: "preserve", reason: "managed block was modified" };
@@ -233,45 +125,45 @@ export const planUninstall = (root) => {
     plan.push(manifestDisposition(plan));
     return plan;
 };
-/** Reports installed workflow version, schema, and detected agents. */
-export const status = (root) => {
+export const statusData = (root) => {
     const manifest = readManifest(root);
     const legacyPath = join(resolve(root), ".agents/aidlc/manifest.json");
+    return {
+        workflow: manifest || existsSync(legacyPath) ? "installed" : "not installed",
+        installedVersion: manifest?.packageVersion ?? (existsSync(legacyPath) ? "legacy/unknown" : "none"),
+        schema: `${manifest?.schemaVersion ?? (existsSync(legacyPath) ? "legacy" : "none")}`,
+        detectedAgents: detectedAgents(root)
+    };
+};
+/** Reports installed workflow version, schema, and detected agents. */
+export const status = (root) => {
+    const data = statusData(root);
     return [
-        `workflow: ${manifest || existsSync(legacyPath) ? "installed" : "not installed"}`,
-        `installed version: ${manifest?.packageVersion ?? (existsSync(legacyPath) ? "legacy/unknown" : "none")}`,
-        `schema: ${manifest?.schemaVersion ?? (existsSync(legacyPath) ? "legacy" : "none")}`,
-        `detected agents: ${detectedAgents(root).join(", ") || "none"}`
+        `workflow: ${data.workflow}`,
+        `installed version: ${data.installedVersion}`,
+        `schema: ${data.schema}`,
+        `detected agents: ${data.detectedAgents.join(", ") || "none"}`
     ].join("\n");
 };
-/** Path portion of a manifest inventory key (`path#owner` for shared managed blocks). */
-const inventoryKeyPath = (key) => {
-    const separator = key.lastIndexOf("#");
-    return separator > 0 ? key.slice(0, separator) : key;
-};
 /** Manifest inventory paths whose on-disk content no longer matches the recorded owner hash. */
 const modifiedManagedPaths = (root, manifest) => {
     const modified = Object.entries(manifest.files).filter(([key, item]) => {
-        const target = safeTarget(root, inventoryKeyPath(key));
+        const target = safeTarget(root, splitInventoryKey(key).path);
         if (!existsSync(target))
             return true;
         const spec = { owner: item.owner, strategy: item.strategy };
         return managedContentHash(spec, readFileSync(target, "utf8")) !== item.hash;
     });
-    return [...new Set(modified.map(([key]) => inventoryKeyPath(key)))];
+    return [...new Set(modified.map(([key]) => splitInventoryKey(key).path))];
 };
 /** Validates the installed workflow manifest and local config/state. */
 export const doctor = (root, strict = false) => {
-    const manifestPath = join(resolve(root), ".agents/aidlc/manifest.json");
-    if (!existsSync(manifestPath))
+    const read = readManifestFile(root);
+    if (read.status === "missing")
         return "ERROR: .agents/aidlc/manifest.json is missing. Run npx @felixdotgo/aidlc-kit init --yes.";
-    let parsed;
-    try {
-        parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
-    }
-    catch {
+    if (read.status === "invalid")
         return "ERROR: workflow manifest is invalid JSON.";
-    }
+    const parsed = read.value;
     if (parsed.remoteUpdates || parsed.source !== "local-package-assets" || (parsed.managedBy !== "aidlc-kit" && parsed.managedBy !== "aidlc-workflow"))
         return "ERROR: workflow manifest violates local-only asset policy.";
     if (typeof parsed.schemaVersion === "number" && parsed.schemaVersion > 2)
@@ -291,3 +183,8 @@ export const doctor = (root, strict = false) => {
         return `${strict ? "ERROR" : "WARN"}: managed integrity differs: ${modified.join(", ")}`;
     return `OK: local workflow ${manifest.packageVersion} is valid; remote updates are disabled.`;
 };
+export const doctorData = (root, strict = false) => {
+    const message = doctor(root, strict);
+    const level = message.startsWith("ERROR:") ? "error" : message.startsWith("WARN:") ? "warn" : "ok";
+    return { level, message, strict };
+};