@tea-agent/loop-agent 0.2.0 → 0.3.0

package/bin/loop-agent.js

@@ -1,21 +1,21 @@
-#!/usr/bin/env node
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-const cliEntry = join(packageRoot, "dist", "cli.js");
-
-if (!existsSync(cliEntry)) {
-  console.error(
-    `loop-agent: cannot find built CLI at ${cliEntry}. Run \`npm run build\` before using the package bin.`,
-  );
-  process.exit(1);
-}
-
-try {
-  await import(pathToFileURL(cliEntry).href);
-} catch (error) {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-}
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const cliEntry = join(packageRoot, "dist", "cli.js");
+
+if (!existsSync(cliEntry)) {
+  console.error(
+    `loop-agent: cannot find built CLI at ${cliEntry}. Run \`npm run build\` before using the package bin.`,
+  );
+  process.exit(1);
+}
+
+try {
+  await import(pathToFileURL(cliEntry).href);
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}

package/dist/application/dag/args.js

@@ -159,6 +159,7 @@ export function parseDagValidateArgs(args) {
     let dagPath;
     let strictModelMatrix = false;
     let strictGovernance = false;
+    let strictSkills = false;
     const forbidExecutors = [];
     let spineTaskId;
     for (let i = 0; i < args.length; i += 1) {
@@ -185,6 +186,10 @@ export function parseDagValidateArgs(args) {
             strictGovernance = true;
             continue;
         }
+        if (arg === "--strict-skills") {
+            strictSkills = true;
+            continue;
+        }
         if (arg === "--forbid-executor") {
             const executor = args[++i];
             if (!executor) {
@@ -230,6 +235,7 @@ export function parseDagValidateArgs(args) {
         dagPath: path.resolve(dagPath),
         strictModelMatrix,
         strictGovernance,
+        strictSkills,
         forbidExecutors,
         spineTaskId,
     };

package/dist/application/dag/generate-task-dag.js

@@ -58,9 +58,9 @@ export async function assertSafeForExecution(dagPath) {
 function buildNextSteps(taskId, outputPath, cwd) {
     return [
         `Review ${outputPath}`,
-        `npm run dev -- dag validate --dag ${outputPath}`,
-        `npm run dev -- run-dag --dag ${outputPath} --cwd ${cwd}`,
-        `npm run dev -- dag run-task ${taskId} --execute --cwd ${cwd}`,
+        `loop-agent dag validate --dag ${outputPath} --strict-models --strict-governance`,
+        `loop-agent run-dag --dag ${outputPath} --cwd ${cwd}`,
+        `loop-agent dag run-task ${taskId} --execute --cwd ${cwd}`,
     ];
 }
 function isBroadWriteSetEntryForPacket(entry) {
@@ -233,6 +233,7 @@ export async function generateTaskDagUseCase(input) {
     if (!shouldRunExecution(parsed)) {
         return {
             mode: "generate+validate",
+            message: "DAG draft created",
             ok: true,
             taskId: initResult.taskId,
             outputPath,
@@ -264,6 +265,7 @@ export async function generateTaskDagUseCase(input) {
     });
     return {
         mode: resolveExecutionMode(parsed),
+        message: "DAG draft created",
         ok: true,
         taskId: initResult.taskId,
         outputPath,

package/dist/application/dag/run-dag.js

@@ -38,6 +38,14 @@ async function flushCanvasSafely(canvas) {
         return getCanvasFlushErrorMessage(error);
     }
 }
+function buildRunDagNextSteps(runId) {
+    return [
+        `loop-agent dag report --run-id ${runId} --markdown`,
+        `loop-agent dag doctor --run-id ${runId} --markdown`,
+        `loop-agent promote-run <task-id> --run-id ${runId}`,
+        `loop-agent dag closeout-draft --run-id ${runId}`,
+    ];
+}
 export async function runDagUseCase(input) {
     const spec = await loadDagSpecFromFile(input.dagPath);
     if (input.noCursor) {
@@ -64,11 +72,13 @@ export async function runDagUseCase(input) {
         const canvasError = await flushCanvasSafely(canvas);
         return {
             mode: "dry-run",
+            message: "DAG run prepared",
             title: spec.title,
             taskCount: spec.tasks.length,
             ranks: summary.ranks,
             runId: summary.runId,
             runDir: summary.runDir,
+            next: buildRunDagNextSteps(summary.runId),
             ...(resolvedCanvasPath ? { canvasPath: resolvedCanvasPath } : {}),
             ...(canvasError ? { canvasError } : {}),
         };
@@ -85,9 +95,15 @@ export async function runDagUseCase(input) {
     if (resolvedCanvasPath) {
         return {
             ...summary,
+            message: "DAG run finished",
+            next: buildRunDagNextSteps(summary.runId),
             canvasPath: resolvedCanvasPath,
             ...(canvasError ? { canvasError } : {}),
         };
     }
-    return summary;
+    return {
+        ...summary,
+        message: "DAG run finished",
+        next: buildRunDagNextSteps(summary.runId),
+    };
 }

package/dist/application/dag/validate-dag.js

@@ -4,6 +4,8 @@ import { assertValidDagSpec, collectExecutorModelWarnings, collectForbiddenExecu
 import { inferGovernanceProfile } from "../../workflows/dag/governance-profile.js";
 import { topoSortToRanks } from "../../workflows/dag/topo.js";
 import { runSpineAudit } from "../../governance/spine-audit.js";
+import { resolveDagNodeSkills } from "../../workflows/dag/skills.js";
+import { resolveDagSkillInstructions } from "../../workflows/dag/skill-instructions.js";
 function formatModelMatrixWarnings(warnings) {
     return warnings.map((warning) => ({
         executor: warning.executor,
@@ -55,6 +57,36 @@ function ensureNoForbiddenExecutors(spec, forbidExecutors, rawTaskExecutors) {
         .join("; ");
     throw new Error(`forbidden executor present: ${details}`);
 }
+async function ensureStrictSkillResolution(spec, repoRoot) {
+    const failures = [];
+    for (const task of spec.tasks) {
+        if (task.executor !== "pi" && task.executor !== "cursor")
+            continue;
+        const skills = resolveDagNodeSkills(spec, task);
+        if (skills.length === 0)
+            continue;
+        const resolved = await resolveDagSkillInstructions(skills, {
+            cwd: repoRoot,
+            perSkillMaxChars: 100_000,
+            totalMaxChars: 1_000_000,
+        });
+        for (const entry of resolved) {
+            if (entry.resolution !== "resolved") {
+                failures.push(`${task.id}:${entry.name}:${entry.resolution}${entry.error ? `:${entry.error}` : ""}`);
+                continue;
+            }
+            if (entry.truncated) {
+                failures.push(`${task.id}:${entry.name}:truncated`);
+            }
+            for (const unresolved of entry.unresolvedReferences ?? []) {
+                failures.push(`${task.id}:${entry.name}:unresolved-reference:${unresolved.path}:${unresolved.reason}`);
+            }
+        }
+    }
+    if (failures.length > 0) {
+        throw new Error(`strict skill audit failed: ${failures.join("; ")}`);
+    }
+}
 export async function validateDagUseCase(input) {
     const spec = await loadDagSpecFromFile(input.dagPath);
     const rawTaskExecutors = await loadRawTaskExecutorMap(input.dagPath);
@@ -65,6 +97,9 @@ export async function validateDagUseCase(input) {
     if (input.strictModelMatrix) {
         ensureStrictModelMatrix(warnings);
     }
+    if (input.strictSkills) {
+        await ensureStrictSkillResolution(spec, input.repoRoot);
+    }
     const spineAudit = input.spineTaskId
         ? await runSpineAudit(input.repoRoot, input.spineTaskId)
         : undefined;
@@ -81,9 +116,14 @@ export async function validateDagUseCase(input) {
     const { ranks } = topoSortToRanks(spec);
     const governanceProfile = inferGovernanceProfile(spec);
     return {
+        message: "DAG validation passed",
         title: spec.title,
         taskCount: spec.tasks.length,
         ranks,
+        checks: {
+            writeSets: "checked",
+            decisionGates: "checked",
+        },
         governanceProfile,
         spineAudit: spineAudit
             ? {
@@ -97,5 +137,6 @@ export async function validateDagUseCase(input) {
             ...formatModelMatrixWarnings(warnings),
             ...formatGovernanceWarnings(governanceWarnings),
         ],
+        next: [`loop-agent run-dag --dag ${input.dagPath} --cwd ${input.repoRoot}`],
     };
 }

package/dist/cli/command-definitions.js

@@ -50,7 +50,7 @@ export function formatSubcommandUsageError(name, subcommands) {
     return `usage: ${formatSubcommandUsage(name, subcommands)}`;
 }
 const DOCS_SUBCOMMANDS = ["audit", "archive"];
-const INIT_SUBCOMMANDS = ["instructions", "doctor"];
+const INIT_SUBCOMMANDS = ["instructions", "doctor", "check-update", "update"];
 const EXAMPLES_SUBCOMMANDS = ["list", "show", "copy"];
 const CLOSEOUT_SUBCOMMANDS = ["task"];
 const PLAN_SUBCOMMANDS = ["list"];
@@ -145,7 +145,7 @@ export const COMMAND_DEFINITIONS = [
         adapter: "none",
         tier: "primary",
         intent: "Initialize a target repository with loop-agent harness capabilities.",
-        usage: "init [instructions|doctor] [--profile full|minimal] [--merge]",
+        usage: "init [instructions|doctor|check-update|update] [--profile full|minimal] [--merge] [--json|--markdown] [--bootstrap-surface|--apply-safe]",
         subcommands: [...INIT_SUBCOMMANDS],
         handler: async ({ repoRoot, subcommand, rest }) => {
             await runInit(repoRoot, [subcommand, ...rest].filter(Boolean));

package/dist/cli/program.js

@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 import path from "node:path";
 import { Command } from "commander";
 import { resolveAdapter } from "../adapters/index.js";
@@ -50,10 +51,22 @@ 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) {
+function readPackageVersion() {
+    try {
+        const raw = readFileSync(new URL("../../package.json", import.meta.url), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.version === "string")
+            return parsed.version;
+    }
+    catch {
+        // Fall back only if the package metadata is unexpectedly unavailable.
+    }
+    return "0.0.0";
+}
+function resolveRepoRootOnly(command, defaultRepoRoot, behavior) {
     const options = collectGlobalOptions(command);
     const repoRoot = path.resolve(options.repoRoot ?? defaultRepoRoot);
-    if (options.repoRoot)
+    if (options.repoRoot && !behavior?.quiet)
         console.log(`[loop-agent] repo root: ${repoRoot}`);
     return repoRoot;
 }
@@ -341,6 +354,7 @@ function configureDagValidate(command) {
         .option("--dag <path>", "DAG spec path")
         .option("--strict-models", "fail on model routing warnings")
         .option("--strict-governance", "fail on governance warnings")
+        .option("--strict-skills", "fail on missing, errored, truncated, or unresolved skill instructions")
         .option("--forbid-executor <executor>", "forbid executor", (value, previous = []) => [
         ...previous,
         value,
@@ -474,7 +488,9 @@ async function runPiPromptCommand(args) {
     }
 }
 async function runInitCommand(args, command, defaultRepoRoot) {
-    await runInit(resolveRepoRootOnly(command, defaultRepoRoot), commandArgsWithOptions(args, command));
+    const initArgs = commandArgsWithOptions(args, command);
+    const quiet = initArgs.includes("--json") || initArgs.includes("--markdown");
+    await runInit(resolveRepoRootOnly(command, defaultRepoRoot, { quiet }), initArgs);
 }
 async function runExamplesCommand(args, command, defaultRepoRoot) {
     await runExamples(resolveRepoRootOnly(command, defaultRepoRoot), commandArgsWithOptions(args, command));
@@ -484,6 +500,7 @@ export function buildLoopAgentProgram(options) {
     program
         .name("loop-agent")
         .description("Loop Agent task and DAG automation CLI")
+        .version(readPackageVersion(), "-V, --version", "display version")
         .showHelpAfterError()
         .option("--repo-root <path>", "repository root")
         .option("--adapter <name>", "harness adapter name")
@@ -526,7 +543,10 @@ export function buildLoopAgentProgram(options) {
                 .option("--no-merge", "skip existing files")
                 .option("--provider <provider>", "model provider")
                 .option("--model <model>", "model name")
-                .option("--json", "print JSON");
+                .option("--json", "print JSON")
+                .option("--markdown", "print Markdown")
+                .option("--bootstrap-surface", "write an inferred .harness/init-surface.json baseline")
+                .option("--apply-safe", "apply deterministic safe init updates");
             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);