@tea-agent/loop-agent 0.1.0 → 0.2.0

package/dist/cli/command-definitions.js

@@ -0,0 +1,571 @@
+import { runDoctor } from "../commands/doctor.js";
+import { runDocsArchive } from "../commands/docs-archive.js";
+import { runDocsAudit } from "../commands/docs-audit.js";
+import { runCoverageAudit } from "../commands/coverage-audit.js";
+import { runExamples } from "../commands/examples.js";
+import { runCloseout } from "../commands/closeout.js";
+import { runHandoffCheck } from "../commands/handoff-check.js";
+import { runInspect } from "../commands/inspect.js";
+import { runInstructions } from "../commands/instructions.js";
+import { runNewTask } from "../commands/new-task.js";
+import { runPlanList } from "../commands/plan-list.js";
+import { runPromoteRun } from "../commands/promote-run.js";
+import { runSpine } from "../commands/spine.js";
+import { runStats } from "../commands/stats.js";
+import { runStatus } from "../commands/status.js";
+import { runWorktreeCreate } from "../commands/worktree-create.js";
+import { runWorktreeList } from "../commands/worktree-list.js";
+import { runWorktreeRemove } from "../commands/worktree-remove.js";
+import { runDelegate } from "../commands/delegate.js";
+import { runHarvest } from "../commands/harvest.js";
+import { runInit } from "../commands/init.js";
+import { runRunDag } from "../commands/run-dag.js";
+import { runDagInitHybrid } from "../commands/dag-init-hybrid.js";
+import { runDagValidate } from "../commands/dag-validate.js";
+import { runDagWorkflowValidate } from "../commands/dag-workflow-validate.js";
+import { runDagWorkflowCompile } from "../commands/dag-workflow-compile.js";
+import { runDagWorkflowPlan } from "../commands/dag-workflow-plan.js";
+import { runDagApprove } from "../commands/dag-approve.js";
+import { runDagReject } from "../commands/dag-reject.js";
+import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
+import { runDagResume } from "../commands/dag-resume.js";
+import { runDagDecisionInspect, runDagDecisionValidate, } from "../workflows/dag/decision-envelope.js";
+import { runDagDoctor, runDagStatus, } from "../workflows/dag/lifecycle.js";
+import { runDagRunTask } from "../commands/dag-run-task.js";
+import { runDagCloseoutDraft, runDagReport } from "../commands/dag-report.js";
+import { runDagFinalVerification } from "../commands/dag-final-verification.js";
+import { runCursorWorker } from "../commands/cursor-worker.js";
+import { runKnowledge } from "../commands/knowledge.js";
+import { runLoopBenchmark } from "../commands/loop-benchmark.js";
+import { runPiReuseBenchmark } from "../commands/pi-reuse-benchmark.js";
+import { runGoal } from "../commands/goal.js";
+import { runLoop } from "../commands/loop.js";
+import { runWorkflowCommand } from "../commands/workflow.js";
+import { runReferenceIndex } from "../commands/reference-index.js";
+import { runStudyInit } from "../commands/study-init.js";
+export function formatSubcommandUsage(name, subcommands) {
+    return `${name} <${subcommands.join("|")}> ...`;
+}
+export function formatSubcommandUsageError(name, subcommands) {
+    return `usage: ${formatSubcommandUsage(name, subcommands)}`;
+}
+const DOCS_SUBCOMMANDS = ["audit", "archive"];
+const INIT_SUBCOMMANDS = ["instructions", "doctor"];
+const EXAMPLES_SUBCOMMANDS = ["list", "show", "copy"];
+const CLOSEOUT_SUBCOMMANDS = ["task"];
+const PLAN_SUBCOMMANDS = ["list"];
+const SPINE_SUBCOMMANDS = ["audit"];
+const HANDOFF_SUBCOMMANDS = ["check", "coverage"];
+const HANDOFF_USAGE = "handoff <check|coverage> [taskId]";
+const REFERENCE_SUBCOMMANDS = ["index"];
+const STUDY_SUBCOMMANDS = ["init"];
+const WORKTREE_SUBCOMMANDS = ["create", "list", "remove"];
+const KNOWLEDGE_SUBCOMMANDS = ["curate"];
+const DAG_SUBCOMMANDS = [
+    "init-hybrid",
+    "run-task",
+    "validate",
+    "workflow-plan",
+    "workflow-validate",
+    "workflow-compile",
+    "approve",
+    "reject",
+    "resume",
+    "status",
+    "doctor",
+    "report",
+    "closeout-draft",
+    "reconcile-tasks",
+    "final-verification",
+    "decision",
+];
+const WORKFLOW_SUBCOMMANDS = [
+    "list",
+    "inspect",
+    "save",
+    "run",
+    "diff",
+    "replay",
+];
+const WORKFLOW_USAGE = "workflow <list|inspect|save|run|diff|replay> [name] [options]";
+const LOOP_SUBCOMMANDS = [
+    "init",
+    "status",
+    "run",
+    "record-round",
+    "add-signal",
+    "closeout",
+];
+/** Order remains stable for compatibility; tiers provide the selection signal. */
+export const COMMAND_DEFINITIONS = [
+    {
+        name: "inspect",
+        adapter: "required",
+        tier: "operator",
+        intent: "Inspect the target repo harness manifest.",
+        usage: "inspect",
+        handler: async ({ adapter, repoRoot }) => {
+            await runInspect(adapter, repoRoot);
+        },
+    },
+    {
+        name: "doctor",
+        adapter: "required",
+        tier: "operator",
+        intent: "Check local loop-agent runtime health.",
+        usage: "doctor",
+        handler: async ({ adapter, repoRoot }) => {
+            await runDoctor(adapter, repoRoot);
+        },
+    },
+    {
+        name: "docs",
+        adapter: "required",
+        tier: "operator",
+        intent: "Audit or archive repo governance documents.",
+        usage: formatSubcommandUsage("docs", DOCS_SUBCOMMANDS),
+        subcommands: [...DOCS_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            if (subcommand === "audit") {
+                await runDocsAudit(repoRoot);
+                return;
+            }
+            if (subcommand === "archive") {
+                const [planPath] = rest;
+                if (!planPath)
+                    throw new Error("usage: docs archive <active-plan-path>");
+                await runDocsArchive(repoRoot, planPath);
+                return;
+            }
+            throw new Error(formatSubcommandUsageError("docs", DOCS_SUBCOMMANDS));
+        },
+    },
+    {
+        name: "init",
+        adapter: "none",
+        tier: "primary",
+        intent: "Initialize a target repository with loop-agent harness capabilities.",
+        usage: "init [instructions|doctor] [--profile full|minimal] [--merge]",
+        subcommands: [...INIT_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runInit(repoRoot, [subcommand, ...rest].filter(Boolean));
+        },
+    },
+    {
+        name: "examples",
+        adapter: "none",
+        tier: "operator",
+        intent: "List, show, or copy bundled loop-agent examples.",
+        usage: "examples <list|show|copy> [name] [--output <path>]",
+        subcommands: [...EXAMPLES_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runExamples(repoRoot, [subcommand, ...rest].filter(Boolean));
+        },
+    },
+    {
+        name: "new-task",
+        adapter: "required",
+        tier: "primary",
+        intent: "Create a harness task before DAG autonomous work.",
+        usage: "new-task <task-id> [title]",
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            const [taskId, ...titleParts] = [subcommand, ...rest];
+            if (!taskId)
+                throw new Error("taskId required");
+            await runNewTask(repoRoot, taskId, titleParts.join(" ") || undefined);
+        },
+    },
+    {
+        name: "status",
+        adapter: "required",
+        tier: "operator",
+        intent: "Inspect a task state and machine-readable action context.",
+        usage: "status <task-id> [--json]",
+        handler: async ({ repoRoot, subcommand }) => {
+            const taskId = subcommand;
+            if (!taskId)
+                throw new Error("taskId required");
+            await runStatus(repoRoot, taskId);
+        },
+    },
+    {
+        name: "instructions",
+        adapter: "required",
+        tier: "operator",
+        intent: "Resolve task artifact targets, dependencies, templates, and write policy.",
+        usage: "instructions <source|dag-draft|task-artifacts|promotion|closeout> --task <task-id> [--json]",
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runInstructions(repoRoot, [subcommand, ...rest].filter(Boolean));
+        },
+    },
+    {
+        name: "promote-run",
+        adapter: "required",
+        tier: "operator",
+        intent: "Promote completed DAG or one-shot run evidence into task artifacts without mutating run facts.",
+        usage: "promote-run <task-id> --run-id <run-id>",
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runPromoteRun(repoRoot, [subcommand, ...rest].filter(Boolean));
+        },
+    },
+    {
+        name: "closeout",
+        adapter: "required",
+        tier: "operator",
+        intent: "Create deterministic task closeout/progress records from promoted task artifacts.",
+        usage: "closeout task <task-id>",
+        subcommands: [...CLOSEOUT_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runCloseout(repoRoot, [subcommand, ...rest].filter(Boolean));
+        },
+    },
+    {
+        name: "stats",
+        adapter: "required",
+        tier: "operator",
+        intent: "Inspect historical step duration statistics.",
+        usage: "stats",
+        handler: async ({ repoRoot }) => {
+            await runStats(repoRoot);
+        },
+    },
+    {
+        name: "plan",
+        adapter: "required",
+        tier: "operator",
+        intent: "List repo execution plans.",
+        usage: formatSubcommandUsage("plan", PLAN_SUBCOMMANDS),
+        subcommands: [...PLAN_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand }) => {
+            if (subcommand === "list") {
+                await runPlanList(repoRoot);
+                return;
+            }
+            throw new Error(formatSubcommandUsageError("plan", PLAN_SUBCOMMANDS));
+        },
+    },
+    {
+        name: "spine",
+        adapter: "required",
+        tier: "operator",
+        intent: "Audit a task minimal spec spine: source, path ownership, requirements, and final verification coverage.",
+        usage: "spine audit <task-id> [--json|--markdown]",
+        subcommands: [...SPINE_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runSpine(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));
+        },
+    },
+    {
+        name: "handoff",
+        adapter: "required",
+        tier: "operator",
+        intent: "Check task handoff completeness and requirement coverage.",
+        usage: HANDOFF_USAGE,
+        subcommands: [...HANDOFF_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            if (subcommand === "check") {
+                const [taskId] = rest;
+                await runHandoffCheck(repoRoot, taskId);
+                return;
+            }
+            if (subcommand === "coverage") {
+                const [taskId, ...flags] = rest;
+                if (!taskId)
+                    throw new Error("usage: handoff coverage <taskId> [--json|--markdown]");
+                const json = flags.includes("--json");
+                const markdown = flags.includes("--markdown");
+                const exitCode = await runCoverageAudit(repoRoot, taskId, {
+                    json,
+                    markdown,
+                });
+                process.exitCode = exitCode;
+                return;
+            }
+            throw new Error(`usage: ${HANDOFF_USAGE}`);
+        },
+    },
+    {
+        name: "goal",
+        adapter: "required",
+        tier: "compatibility",
+        compatibilityStatus: "deprecated-candidate",
+        intent: "Manage legacy task continuation goals (compatibility-only; prefer Agent DAG closeout).",
+        usage: "goal <set|get|pause|resume|clear> ...",
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runGoal(repoRoot, subcommand, rest);
+        },
+    },
+    {
+        name: "reference",
+        adapter: "required",
+        tier: "compatibility",
+        compatibilityStatus: "compatibility-only",
+        intent: "Index external references for feature-study tasks (compatibility-only).",
+        usage: "reference <index> <task-id>",
+        subcommands: [...REFERENCE_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            if (subcommand === "index") {
+                const [taskId] = rest;
+                if (!taskId)
+                    throw new Error("usage: reference index <task-id>");
+                await runReferenceIndex(repoRoot, taskId);
+                return;
+            }
+            throw new Error("usage: reference <index> <task-id>");
+        },
+    },
+    {
+        name: "study",
+        adapter: "required",
+        tier: "compatibility",
+        compatibilityStatus: "compatibility-only",
+        intent: "Initialize feature-study tasks (compatibility-only; prefer DAG work).",
+        usage: "study init <task-id> [title] ...",
+        subcommands: [...STUDY_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            if (subcommand === "init") {
+                await runStudyInit(repoRoot, rest);
+                return;
+            }
+            throw new Error("usage: study init <task-id> [title] ...");
+        },
+    },
+    {
+        name: "worktree",
+        adapter: "required",
+        tier: "escape-hatch",
+        intent: "Manage delegated worktrees directly.",
+        usage: formatSubcommandUsage("worktree", WORKTREE_SUBCOMMANDS),
+        subcommands: [...WORKTREE_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            if (subcommand === "create") {
+                await runWorktreeCreate(repoRoot, rest);
+                return;
+            }
+            if (subcommand === "list") {
+                await runWorktreeList(repoRoot);
+                return;
+            }
+            if (subcommand === "remove") {
+                await runWorktreeRemove(repoRoot, rest);
+                return;
+            }
+            throw new Error(formatSubcommandUsageError("worktree", WORKTREE_SUBCOMMANDS));
+        },
+    },
+    {
+        name: "delegate",
+        adapter: "required",
+        tier: "escape-hatch",
+        intent: "Prepare or run isolated executor delegation outside the normal DAG path.",
+        usage: "delegate <task-id> [options]",
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            const delegateArgs = [subcommand, ...rest].filter((arg) => Boolean(arg));
+            await runDelegate(repoRoot, delegateArgs);
+        },
+    },
+    {
+        name: "harvest",
+        adapter: "required",
+        tier: "escape-hatch",
+        intent: "Merge and close isolated delegated work after completion.",
+        usage: "harvest <task-id> [options]",
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            const harvestArgs = [subcommand, ...rest].filter((arg) => Boolean(arg));
+            await runHarvest(repoRoot, harvestArgs);
+        },
+    },
+    {
+        name: "cursor-worker",
+        adapter: "required",
+        tier: "escape-hatch",
+        intent: "Inspect or control the optional Cursor SDK worker process.",
+        usage: "cursor-worker <status|stop|ping>",
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runCursorWorker(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));
+        },
+    },
+    {
+        name: "knowledge",
+        adapter: "required",
+        tier: "operator",
+        intent: "Curate completed convergence patterns into human-gated learned guidance proposals.",
+        usage: "knowledge curate [--json|--markdown] [--output <path>]",
+        subcommands: [...KNOWLEDGE_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runKnowledge(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));
+        },
+    },
+    {
+        name: "dag",
+        adapter: "required",
+        tier: "primary",
+        intent: "Generate, validate, inspect, recover, close out Agent DAG runs, and use experimental dynamic workflow compile seams.",
+        usage: formatSubcommandUsage("dag", DAG_SUBCOMMANDS),
+        subcommands: [...DAG_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            if (subcommand === "init-hybrid") {
+                const initArgs = rest.filter((arg) => Boolean(arg));
+                await runDagInitHybrid(repoRoot, initArgs);
+                return;
+            }
+            if (subcommand === "validate") {
+                const validateArgs = rest.filter((arg) => Boolean(arg));
+                await runDagValidate(repoRoot, validateArgs);
+                return;
+            }
+            if (subcommand === "workflow-validate") {
+                const validateArgs = rest.filter((arg) => Boolean(arg));
+                await runDagWorkflowValidate(repoRoot, validateArgs);
+                return;
+            }
+            if (subcommand === "workflow-plan") {
+                const planArgs = rest.filter((arg) => Boolean(arg));
+                await runDagWorkflowPlan(repoRoot, planArgs);
+                return;
+            }
+            if (subcommand === "workflow-compile") {
+                const compileArgs = rest.filter((arg) => Boolean(arg));
+                await runDagWorkflowCompile(repoRoot, compileArgs);
+                return;
+            }
+            if (subcommand === "approve") {
+                const approveArgs = rest.filter((arg) => Boolean(arg));
+                await runDagApprove(repoRoot, approveArgs);
+                return;
+            }
+            if (subcommand === "reject") {
+                const rejectArgs = rest.filter((arg) => Boolean(arg));
+                await runDagReject(repoRoot, rejectArgs);
+                return;
+            }
+            if (subcommand === "resume") {
+                const resumeArgs = rest.filter((arg) => Boolean(arg));
+                await runDagResume(repoRoot, resumeArgs);
+                return;
+            }
+            if (subcommand === "status") {
+                const statusArgs = rest.filter((arg) => Boolean(arg));
+                await runDagStatus(repoRoot, statusArgs);
+                return;
+            }
+            if (subcommand === "doctor") {
+                const doctorArgs = rest.filter((arg) => Boolean(arg));
+                await runDagDoctor(repoRoot, doctorArgs);
+                return;
+            }
+            if (subcommand === "run-task") {
+                const runTaskArgs = rest.filter((arg) => Boolean(arg));
+                await runDagRunTask(repoRoot, runTaskArgs);
+                return;
+            }
+            if (subcommand === "report") {
+                const reportArgs = rest.filter((arg) => Boolean(arg));
+                await runDagReport(repoRoot, reportArgs);
+                return;
+            }
+            if (subcommand === "closeout-draft") {
+                const closeoutArgs = rest.filter((arg) => Boolean(arg));
+                await runDagCloseoutDraft(repoRoot, closeoutArgs);
+                return;
+            }
+            if (subcommand === "reconcile-tasks") {
+                const reconcileArgs = rest.filter((arg) => Boolean(arg));
+                await runDagReconcileTasks(repoRoot, reconcileArgs);
+                return;
+            }
+            if (subcommand === "final-verification") {
+                const finalVerificationArgs = rest.filter((arg) => Boolean(arg));
+                await runDagFinalVerification(repoRoot, finalVerificationArgs);
+                return;
+            }
+            if (subcommand === "decision") {
+                const decisionSubcommand = rest[0];
+                const decisionArgs = rest.slice(1).filter((arg) => Boolean(arg));
+                if (decisionSubcommand === "inspect") {
+                    await runDagDecisionInspect(repoRoot, decisionArgs);
+                    return;
+                }
+                if (decisionSubcommand === "validate") {
+                    await runDagDecisionValidate(repoRoot, decisionArgs);
+                    return;
+                }
+                throw new Error("usage: dag decision <inspect|validate> --run-id <id> [--node-id <node-id>]");
+            }
+            throw new Error(formatSubcommandUsageError("dag", DAG_SUBCOMMANDS));
+        },
+    },
+    {
+        name: "run-dag",
+        adapter: "required",
+        tier: "primary",
+        intent: "Execute a reviewed Agent DAG spec.",
+        usage: "run-dag --dag <path> [options]",
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            const runDagArgs = [subcommand, ...rest].filter((arg) => Boolean(arg));
+            await runRunDag(repoRoot, runDagArgs);
+        },
+    },
+    {
+        name: "workflow",
+        adapter: "required",
+        tier: "experimental",
+        intent: "List, save, inspect, run, diff, and replay saved dynamic workflows.",
+        usage: WORKFLOW_USAGE,
+        subcommands: [...WORKFLOW_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runWorkflowCommand(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));
+        },
+    },
+    {
+        name: "loop",
+        adapter: "required",
+        tier: "experimental",
+        intent: "Manage durable long-running task loop state above Agent DAG rounds.",
+        usage: "loop <init|status|run|record-round|add-signal|closeout> <task-id> [options]",
+        subcommands: [...LOOP_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runLoop(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));
+        },
+    },
+    {
+        name: "cursor-prompt",
+        adapter: "none",
+        tier: "escape-hatch",
+        intent: "Run one-shot Cursor diagnostics without harness state.",
+        usage: "cursor-prompt [options] [task]",
+    },
+    {
+        name: "pi-prompt",
+        adapter: "none",
+        tier: "escape-hatch",
+        intent: "Run one-shot Pi diagnostics without harness state.",
+        usage: "pi-prompt [options] [task]",
+    },
+    {
+        name: "pi-reuse-benchmark",
+        adapter: "required",
+        tier: "operator",
+        intent: "Read existing Pi runtime reuse benchmark evidence.",
+        usage: "pi-reuse-benchmark [--report <path>] [--approval <path>] [--off-executor|--off-task ...] [--on-executor|--on-task ...] [--json] [--markdown]",
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            const benchmarkArgs = [subcommand, ...rest].filter((arg) => Boolean(arg));
+            await runPiReuseBenchmark(repoRoot, benchmarkArgs);
+        },
+    },
+    {
+        name: "loop-benchmark",
+        adapter: "required",
+        tier: "operator",
+        intent: "Generate deterministic loop convergence benchmark baseline evidence.",
+        usage: "loop-benchmark [--json|--markdown] [--output <path>]",
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            const benchmarkArgs = [subcommand, ...rest].filter((arg) => Boolean(arg));
+            await runLoopBenchmark(repoRoot, benchmarkArgs);
+        },
+    },
+];
+export function toCommandManifestEntry(definition) {
+    const { handler: _handler, ...manifest } = definition;
+    return manifest;
+}

package/dist/cli/index.js

@@ -1,3 +1,5 @@
 export * from "./catalog.js";
+export * from "./command-definitions.js";
 export * from "./help.js";
 export * from "./program.js";
+export * from "./router.js";

package/dist/cli/program.js

@@ -21,9 +21,11 @@ import { runDelegate } from "../commands/delegate.js";
 import { runDocsArchive } from "../commands/docs-archive.js";
 import { runDocsAudit } from "../commands/docs-audit.js";
 import { runDoctor } from "../commands/doctor.js";
+import { runExamples } from "../commands/examples.js";
 import { runGoal } from "../commands/goal.js";
 import { runHandoffCheck } from "../commands/handoff-check.js";
 import { runHarvest } from "../commands/harvest.js";
+import { runInit } from "../commands/init.js";
 import { runInspect } from "../commands/inspect.js";
 import { runInstructions } from "../commands/instructions.js";
 import { runKnowledge } from "../commands/knowledge.js";
@@ -48,6 +50,13 @@ import { handleStandaloneOneShotCommandError } from "../shared/one-shot-prompt-a
 import { runDagDecisionInspect, runDagDecisionValidate, } from "../workflows/dag/decision-envelope.js";
 import { runDagDoctor, runDagStatus } from "../workflows/dag/lifecycle.js";
 import { CODE_AGENT_COMMAND_MANIFEST } from "./catalog.js";
+function resolveRepoRootOnly(command, defaultRepoRoot) {
+    const options = collectGlobalOptions(command);
+    const repoRoot = path.resolve(options.repoRoot ?? defaultRepoRoot);
+    if (options.repoRoot)
+        console.log(`[loop-agent] repo root: ${repoRoot}`);
+    return repoRoot;
+}
 function collectGlobalOptions(command) {
     let current = command;
     const merged = {};
@@ -314,6 +323,18 @@ function addRawSubcommands(parent, subcommands, defaultRepoRoot) {
         parent.addCommand(createRawArgsCommand(subcommand, `${parent.name()} ${subcommand}`, defaultRepoRoot));
     }
 }
+function addStandaloneSubcommands(parent, subcommands, handler) {
+    for (const subcommand of subcommands) {
+        parent
+            .command(subcommand)
+            .allowUnknownOption(true)
+            .allowExcessArguments(true)
+            .argument("[args...]", "command-specific arguments")
+            .action(async (args, _options, command) => {
+            await handler([subcommand, ...args], command);
+        });
+    }
+}
 function configureDagValidate(command) {
     command
         .description("Validate an Agent DAG spec")
@@ -386,7 +407,13 @@ function optionTokens(command) {
     return tokens;
 }
 function commandArgsWithOptions(args, command) {
-    return [...args, ...optionTokens(command)];
+    const tokens = [];
+    let current = command;
+    while (current?.parent) {
+        tokens.push(...optionTokens(current));
+        current = current.parent;
+    }
+    return [...args, ...tokens];
 }
 function replaceActionWithOptionAwareDispatch(command, defaultRepoRoot) {
     command.action(async (args, _options, actionCommand) => {
@@ -446,6 +473,12 @@ async function runPiPromptCommand(args) {
         handleStandaloneOneShotCommandError(err, printPiPromptUsage);
     }
 }
+async function runInitCommand(args, command, defaultRepoRoot) {
+    await runInit(resolveRepoRootOnly(command, defaultRepoRoot), commandArgsWithOptions(args, command));
+}
+async function runExamplesCommand(args, command, defaultRepoRoot) {
+    await runExamples(resolveRepoRootOnly(command, defaultRepoRoot), commandArgsWithOptions(args, command));
+}
 export function buildLoopAgentProgram(options) {
     const program = new Command();
     program
@@ -480,6 +513,37 @@ export function buildLoopAgentProgram(options) {
                 .action(async (args) => runPiPromptCommand(args));
             continue;
         }
+        if (entry.name === "init") {
+            const command = new Command("init")
+                .description(entry.intent)
+                .allowUnknownOption(true)
+                .allowExcessArguments(true)
+                .argument("[args...]", "init arguments")
+                .option("--project-name <name>", "target project name")
+                .option("--governance-root <path>", "governance root", "docs")
+                .option("--profile <profile>", "full|minimal", "full")
+                .option("--merge", "merge existing files")
+                .option("--no-merge", "skip existing files")
+                .option("--provider <provider>", "model provider")
+                .option("--model <model>", "model name")
+                .option("--json", "print JSON");
+            command.action(async (args, _options, actionCommand) => runInitCommand(args, actionCommand, options.defaultRepoRoot));
+            addStandaloneSubcommands(command, entry.subcommands ?? [], (args, actionCommand) => runInitCommand(args, actionCommand, options.defaultRepoRoot));
+            program.addCommand(command);
+            continue;
+        }
+        if (entry.name === "examples") {
+            const command = new Command("examples")
+                .description(entry.intent)
+                .allowUnknownOption(true)
+                .allowExcessArguments(true)
+                .argument("[args...]", "examples arguments")
+                .option("-o, --output <path>", "copy output path");
+            command.action(async (args, _options, actionCommand) => runExamplesCommand(args, actionCommand, options.defaultRepoRoot));
+            addStandaloneSubcommands(command, entry.subcommands ?? [], (args, actionCommand) => runExamplesCommand(args, actionCommand, options.defaultRepoRoot));
+            program.addCommand(command);
+            continue;
+        }
         const command = createRawArgsCommand(entry.name, entry.intent, options.defaultRepoRoot);
         if (entry.name === "run-dag") {
             configureRunDag(command);