@felixdotgo/aidlc-kit 0.0.1 → 0.1.1

package/dist/src/cli.js

@@ -1,29 +1,34 @@
 #!/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 { join } from "node:path";
 import { installableAdapters } from "./adapters.js";
 import { applyPlan, detectedAgents, doctor, formatPlan, planInit, planUninstall, selectAgents, status } from "./installer.js";
-import { loadProjectConfig, resolveProfiles } from "./profiles.js";
+import { LOOP_PROVIDERS } from "./model.js";
+import { loadProjectConfig, resolveProfiles, validateLoopConfig } from "./profiles.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] [--yes] [--dry-run] [--force]
-  npx @felixdotgo/aidlc-kit upgrade [path] [--dry-run]
+  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);
 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"]);
+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) {
@@ -36,7 +41,48 @@ const positional = (args) => {
     }
     return result;
 };
-const rootArg = (args, fallback = ".") => positional(args).find((item) => !["init", "upgrade", "uninstall", "status", "doctor", "validate", "run", "list"].includes(item)) ?? fallback;
+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),
@@ -80,7 +126,8 @@ const confirmGeneral = async (options, operation) => {
     const { confirm } = await prompts();
     return confirm({ message: `${operation} this plan?`, default: false });
 };
-const mcpSetupOptions = async (args) => {
+/* --- MCP setup options ----------------------------------------------------- */
+const mcpSetupSelections = async (args) => {
     const selected = {
         deployment: value(args, "--deployment"),
         storage: value(args, "--storage"),
@@ -103,12 +150,95 @@ const mcpSetupOptions = async (args) => {
     }
     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;
+};
+const runInit = async (args) => {
+    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}`);
+    }
+    else {
+        applyPlan(options.root, plan);
+        console.log("Installed local AI-DLC workflow assets.");
+    }
+};
+const runUninstall = async (args) => {
+    const options = initOptions(args);
+    const plan = planUninstall(options.root);
+    preview("UNINSTALL", plan);
+    if (!await confirmGeneral(options, "Remove"))
+        return;
+    applyPlan(options.root, plan);
+    console.log("Removed eligible managed assets; project config and state were preserved.");
+};
+const runUpgrade = async (args) => {
+    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}`);
+};
+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 main = async () => {
     const [command = "help", ...args] = process.argv.slice(2);
     if (command === "help" || command === "--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") {
@@ -118,68 +248,14 @@ const main = async () => {
             process.exitCode = 1;
         return;
     }
-    if (command === "init") {
-        const options = await chooseAgents(initOptions(args));
-        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;
-        applyPlan(options.root, plan);
-        console.log("Removed eligible managed assets; project config and state were preserved.");
-        return;
-    }
-    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);
-        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.`);
-        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);
@@ -189,4 +265,4 @@ const main = async () => {
     }
     throw new Error(`Unknown command: ${command}`);
 };
-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

@@ -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,39 @@ 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}` });
+    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,36 +68,20 @@ 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" });
-    }
+    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.length)
         diagnostics.push({ level: "INFO", code: "GATE_OK", message: `${gate} checks passed for ${taskId}` });
     return diagnostics;
@@ -98,9 +111,9 @@ export const formatDiagnostics = (diagnostics) => diagnostics.map((item) => `${i
 const oneLine = (value) => value.replace(/[\r\n\t]+/g, " ").replace(/\s+/g, " ").replace(/ACTION\s+REQUIRED/gi, "ACTION-REQUIRED").trim();
 const markdownText = (value) => oneLine(value).replace(/([\\`*_{}\[\]()<>#+.!|>~])/g, "\\$1");
 const gateMeta = {
-    G0_confirm: { icon: "🟢", title: "GATE G0 · CONFIRM INTENT", action: "Reply `ok` to approve intent, or state changes." },
-    G1_review: { icon: "🔵", title: "GATE G1 · REVIEW PLAN", action: "Reply `approve` to start build, or state decision changes." },
-    G2_codereview: { icon: "🟣", title: "GATE G2 · REVIEW CODE", action: "Approve to wrap, or point out what to fix." }
+    G0_confirm: { icon: "🟢", title: "Review step · Confirm requirements", action: "Reply `ok` to confirm requirements, or state changes." },
+    G1_review: { icon: "🔵", title: "Review step · Approve plan", action: "Reply `approve` to approve the plan and start implementation, or state decision changes." },
+    G2_codereview: { icon: "🟣", title: "Review step · Review implementation", action: "Approve the implementation to complete the task, or point out what to fix." }
 };
 const artifactRows = (task) => Object.entries(task.artifacts).flatMap(([name, path]) => path ? [{ name: oneLine(name), path: oneLine(path) }] : []);
 const markdownLinkTarget = (value) => encodeURI(value).replace(/[()#?]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);

package/dist/src/installer.d.ts

@@ -1,11 +1,20 @@
-import type { AgentId, FileSpec, InitOptions, PlannedWrite, WorkflowManifest } from "./model.js";
+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;
 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[];
+/** 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;