@tea-agent/loop-agent 0.3.0 → 0.5.0

package/dist/commands/init.js

@@ -6,6 +6,8 @@ import { copyDir } from "../shared/copy-dir.js";
 import { loadHarnessManifest } from "../governance/harness.js";
 const MANAGED_BLOCK_START = "<!-- LOOP_AGENT_INIT_START -->";
 const MANAGED_BLOCK_END = "<!-- LOOP_AGENT_INIT_END -->";
+const GITIGNORE_BLOCK_START = "# LOOP_AGENT_INIT_START";
+const GITIGNORE_BLOCK_END = "# LOOP_AGENT_INIT_END";
 const INIT_SURFACE_STATE_PATH = ".harness/init-surface.json";
 const CORE_DOC_FILES = [
     "README.md",
@@ -720,17 +722,88 @@ function mergeManagedBlock(existing, block) {
     }
     return `${existing.trimEnd()}\n\n${block}\n`;
 }
+function mergeGitignoreManagedBlock(existing, block) {
+    const start = existing.indexOf(GITIGNORE_BLOCK_START);
+    const end = existing.indexOf(GITIGNORE_BLOCK_END);
+    if (start >= 0 && end > start) {
+        return `${existing.slice(0, start).trimEnd()}\n\n${block}\n${existing.slice(end + GITIGNORE_BLOCK_END.length).trimStart()}`.trimEnd() + "\n";
+    }
+    if (!existing.trim())
+        return `${block}\n`;
+    return `${existing.trimEnd()}\n\n${block}\n`;
+}
+/** Shared ignore rules for loop-agent runtime facts; keep prompts/ and directory structure shareable. */
+export function buildManagedGitignoreBlock() {
+    return [
+        GITIGNORE_BLOCK_START,
+        "# loop-agent runtime: ignore personal/session facts; keep prompts and directory placeholders shareable",
+        "",
+        "# tasks (source + runtime state per developer/session)",
+        ".harness/tasks/*",
+        "!.harness/tasks/.gitkeep",
+        "",
+        "# DAG runs",
+        ".harness/dag-runs/active/*",
+        "!.harness/dag-runs/active/.gitkeep",
+        ".harness/dag-runs/completed/*",
+        "!.harness/dag-runs/completed/.gitkeep",
+        ".harness/dag-runs/paused/*",
+        "!.harness/dag-runs/paused/.gitkeep",
+        "",
+        "# one-shot executor runs",
+        ".harness/runs/*",
+        "!.harness/runs/.gitkeep",
+        "",
+        "# session / cache / logs / recomputable surface state",
+        ".harness/live/",
+        ".harness/cache/",
+        ".harness/*.log",
+        ".harness/init-surface.json",
+        "",
+        "# worker task pool",
+        ".task-pool/",
+        "",
+        "# multi-worktree parallel mode",
+        ".worktrees/",
+        GITIGNORE_BLOCK_END,
+    ].join("\n");
+}
+function extractGitignoreManagedBlock(content) {
+    const start = content.indexOf(GITIGNORE_BLOCK_START);
+    const end = content.indexOf(GITIGNORE_BLOCK_END);
+    if (start < 0 || end <= start)
+        return undefined;
+    return content.slice(start, end + GITIGNORE_BLOCK_END.length);
+}
 function buildHarness(input) {
-    const modelOverride = input.provider || input.model
-        ? {
-            analyze: { provider: input.provider, model: input.model },
-            plan: { provider: input.provider, model: input.model },
-            implement: { provider: input.provider, model: input.model },
-            verify: { provider: input.provider, model: input.model },
-            retrospective: { provider: input.provider, model: input.model },
-        }
-        : undefined;
-    return {
+    const templateExecutors = isRecord(input.template.executors)
+        ? { ...input.template.executors }
+        : {};
+    const existingExecutors = isRecord(input.existing.executors)
+        ? input.existing.executors
+        : {};
+    // Cursor executor is opt-in for package developers; do not project it to target apps.
+    // Keep it only when the target already configured executors.cursor.
+    if (!isRecord(existingExecutors.cursor)) {
+        delete templateExecutors.cursor;
+    }
+    const mergedExecutors = mergeRecord(templateExecutors, existingExecutors);
+    // requiresApiKey is Cursor-facing only; never project it on pi.
+    if (isRecord(mergedExecutors.pi) && "requiresApiKey" in mergedExecutors.pi) {
+        const pi = { ...mergedExecutors.pi };
+        delete pi.requiresApiKey;
+        mergedExecutors.pi = pi;
+    }
+    // Prefer DAG-facing executors.*.defaultModel over legacy top-level models.*.
+    // --provider/--model still apply as a convenience override for pi defaultModel.
+    if (input.provider || input.model) {
+        const piExisting = isRecord(mergedExecutors.pi) ? mergedExecutors.pi : {};
+        mergedExecutors.pi = {
+            ...piExisting,
+            ...(input.model ? { defaultModel: input.model } : {}),
+        };
+    }
+    const harness = {
         ...input.existing,
         version: 1,
         project: input.projectName,
@@ -771,11 +844,30 @@ function buildHarness(input) {
             standardVerify: "bash scripts/ci-governance.sh",
             fullVerify: "bash scripts/ci.sh",
         }),
-        models: modelOverride ?? input.existing.models ?? input.template.models ?? {},
-        modelProfiles: input.existing.modelProfiles ?? input.template.modelProfiles ?? {},
-        modelRouting: input.existing.modelRouting ?? input.template.modelRouting ?? {},
-        executors: mergeRecord(input.template.executors, input.existing.executors),
+        executors: mergedExecutors,
     };
+    // Do not project legacy step-routing models / modelProfiles / modelRouting into
+    // new or refreshed harness.json. Keep them only when the target already has them
+    // so old files remain loadable until the user migrates.
+    if (isRecord(input.existing.models) && Object.keys(input.existing.models).length > 0) {
+        harness.models = input.existing.models;
+    }
+    else {
+        delete harness.models;
+    }
+    if (isRecord(input.existing.modelProfiles) && Object.keys(input.existing.modelProfiles).length > 0) {
+        harness.modelProfiles = input.existing.modelProfiles;
+    }
+    else {
+        delete harness.modelProfiles;
+    }
+    if (isRecord(input.existing.modelRouting) && Object.keys(input.existing.modelRouting).length > 0) {
+        harness.modelRouting = input.existing.modelRouting;
+    }
+    else {
+        delete harness.modelRouting;
+    }
+    return harness;
 }
 async function writeTextIfMissing(input) {
     const target = path.join(input.repoRoot, input.relativePath);
@@ -899,8 +991,11 @@ function inferInitSurfaceMode(relativePath) {
         relativePath.endsWith("/")) {
         return "directory";
     }
-    if (relativePath === "README.md" || relativePath === "AGENTS.md")
+    if (relativePath === "README.md" ||
+        relativePath === "AGENTS.md" ||
+        relativePath === ".gitignore") {
         return "managed-block";
+    }
     if (relativePath === "harness.json" ||
         relativePath.startsWith("scripts/") ||
         relativePath.startsWith(".harness/prompts/") ||
@@ -934,6 +1029,9 @@ async function buildDesiredSurfaceContent(input) {
             }),
         };
     }
+    if (manifestPath === ".gitignore") {
+        return { content: buildManagedGitignoreBlock() };
+    }
     if (manifestPath === "harness.json") {
         const template = await readJsonIfExists(path.join(input.assetRoot, "harness.json"));
         return {
@@ -953,6 +1051,16 @@ async function buildDesiredSurfaceContent(input) {
         const name = path.basename(manifestPath);
         return { content: COMPAT_PROMPTS[name] };
     }
+    // `.agents/skills/...` is a target-only mirror of the bundled `skills/...`
+    // directory; the package ships `skills/`, never `.agents/skills/`.
+    if (manifestPath.startsWith(".agents/skills/")) {
+        const sourceManifestPath = manifestPath.slice(".agents/".length);
+        const mirrorSourcePath = path.join(input.assetRoot, sourceManifestPath);
+        if (await exists(mirrorSourcePath)) {
+            return { content: await readFile(mirrorSourcePath, "utf-8"), sourcePath: mirrorSourcePath };
+        }
+        return {};
+    }
     if (manifestPath.startsWith("docs/")) {
         const doc = manifestPath.slice("docs/".length);
         const generated = buildGeneratedCoreDoc({
@@ -1031,7 +1139,10 @@ async function buildCurrentSurfaceState(input) {
         const current = await readFile(targetPath);
         const currentSha256 = sha256Buffer(current);
         if (entry.mode === "managed-block") {
-            const currentBlock = extractManagedBlock(current.toString("utf-8"));
+            const text = current.toString("utf-8");
+            const currentBlock = entry.path === ".gitignore" || targetRelativePath === ".gitignore"
+                ? extractGitignoreManagedBlock(text)
+                : extractManagedBlock(text);
             files[targetRelativePath] = {
                 ...base,
                 currentSha256,
@@ -1462,7 +1573,8 @@ export function buildInitInstructions(input) {
         "- After deterministic initialization, inspect README/config/build files (for example package.json, pyproject.toml, go.mod, Cargo.toml, pom.xml, Gradle files, Makefile, .sln/.csproj, or project-specific scripts) and adapt `scripts/ci-tests.sh` plus the verification matrix to the real project.",
         "- Enrich the root `README.md`: keep the deterministic project title and the loop-agent managed block intact, and fill the human-authored sections (项目概览, 技术栈与目录结构, 开发与验证) from the target project's actual files. The root README must serve both as a human-first project entry and as an agent work entry; replace the initialization-model supplement comments when the project files provide the information.",
         "- Populate `docs/verification-matrix.md` with the target project's actual quick, standard, and full verification commands derived from its real language and toolchain, keeping the governance rows intact.",
-        "- Copy repo-local skills by default so the target repo has auditable skill instructions.",
+        "- Copy repo-local skills by default so the target repo has auditable skill instructions; full profile also mirrors skills into `.agents/skills/` for external agents.",
+        "- Merge a loop-agent managed block into `.gitignore` that ignores harness runtime facts (tasks, dag-runs, runs, live, cache, init-surface.json, .task-pool) while keeping prompts and directory placeholders shareable.",
         "- Do not copy examples by default; examples stay bundled in the tool and are available through `loop-agent examples`.",
         "- Add or update a loop-agent managed block in AGENTS.md.",
         "- The generated AGENTS.md must include documentation convergence and structured DAG write-boundary rules so target projects keep the same working discipline as this repository.",
@@ -1556,6 +1668,18 @@ export async function initializeLoopAgentProject(options) {
         written,
         skipped,
     });
+    const gitignorePath = path.join(repoRoot, ".gitignore");
+    const existingGitignore = (await exists(gitignorePath))
+        ? await readFile(gitignorePath, "utf-8")
+        : "";
+    await writeText({
+        repoRoot,
+        relativePath: ".gitignore",
+        content: mergeGitignoreManagedBlock(existingGitignore, buildManagedGitignoreBlock()),
+        merge: true,
+        written,
+        skipped,
+    });
     for (const doc of CORE_DOC_FILES) {
         const generated = buildGeneratedCoreDoc({ doc, projectName, governanceRoot });
         if (generated) {
@@ -1604,9 +1728,21 @@ export async function initializeLoopAgentProject(options) {
             targetRelativePath: "skills",
             written,
         });
+        // Mirror bundled skills into the agent-compatible `.agents/skills/` path so
+        // external agents (e.g. OpenCode) that auto-discover `.agents/skills/<name>/SKILL.md`
+        // share the same skill content as loop-agent's primary `skills/` path.
+        // The package still ships only `skills/`; `.agents/skills` is a target projection.
+        await copyDirMerge({
+            assetRoot,
+            repoRoot,
+            sourceRelativePath: "skills",
+            targetRelativePath: ".agents/skills",
+            written,
+        });
     }
     else {
         skipped.push("skills/");
+        skipped.push(".agents/skills/");
     }
     skipped.push("examples/");
     for (const [relativePath, content] of Object.entries(buildInitScriptFiles(governanceRoot))) {
@@ -1736,6 +1872,27 @@ export async function checkInitUpdate(input) {
             }
         }
     }
+    // Safe harness hygiene: strip obsolete pi.requiresApiKey without full harness rewrite.
+    // Cursor requiresApiKey is intentionally kept when present.
+    const harnessPath = path.join(repoRoot, "harness.json");
+    if (await exists(harnessPath)) {
+        try {
+            const harness = JSON.parse(await readFile(harnessPath, "utf-8"));
+            if (isRecord(harness) &&
+                isRecord(harness.executors) &&
+                isRecord(harness.executors.pi) &&
+                Object.prototype.hasOwnProperty.call(harness.executors.pi, "requiresApiKey")) {
+                deterministicActions.push({
+                    type: "strip-pi-requires-api-key",
+                    path: "harness.json",
+                    reason: "executors.pi.requiresApiKey is unused; strip it while keeping user model config and cursor.requiresApiKey",
+                });
+            }
+        }
+        catch {
+            // leave malformed harness for model merge / doctor
+        }
+    }
     const partial = {
         repoRoot,
         controllerVersion: currentState.controllerVersion,
@@ -1759,6 +1916,29 @@ export async function checkInitUpdate(input) {
     };
 }
 async function applySafeAction(input) {
+    if (input.action.type === "strip-pi-requires-api-key") {
+        const target = path.join(input.repoRoot, "harness.json");
+        if (!(await exists(target)))
+            return false;
+        const harness = JSON.parse(await readFile(target, "utf-8"));
+        if (!isRecord(harness) || !isRecord(harness.executors) || !isRecord(harness.executors.pi)) {
+            return false;
+        }
+        if (!Object.prototype.hasOwnProperty.call(harness.executors.pi, "requiresApiKey")) {
+            return false;
+        }
+        const nextPi = { ...harness.executors.pi };
+        delete nextPi.requiresApiKey;
+        const next = {
+            ...harness,
+            executors: {
+                ...harness.executors,
+                pi: nextPi,
+            },
+        };
+        await writeFile(target, `${JSON.stringify(next, null, 2)}\n`, "utf-8");
+        return true;
+    }
     const assetRoot = await findPackageRoot();
     const entry = {
         path: input.action.path,
@@ -1789,11 +1969,13 @@ async function applySafeAction(input) {
     await mkdir(path.dirname(target), { recursive: true });
     if (input.action.type === "refresh-managed-block") {
         const existing = (await exists(target)) ? await readFile(target, "utf-8") : "";
-        const next = input.action.path === "README.md" && existing.trim().length === 0
-            ? buildTargetReadme({ projectName: input.projectName, governanceRoot: input.governanceRoot })
-            : input.action.path === "AGENTS.md" && existing.trim().length === 0
-                ? `# AGENTS.md\n\n${desired.content}\n`
-                : mergeManagedBlock(existing, desired.content);
+        const next = input.action.path === ".gitignore"
+            ? mergeGitignoreManagedBlock(existing, desired.content)
+            : input.action.path === "README.md" && existing.trim().length === 0
+                ? buildTargetReadme({ projectName: input.projectName, governanceRoot: input.governanceRoot })
+                : input.action.path === "AGENTS.md" && existing.trim().length === 0
+                    ? `# AGENTS.md\n\n${desired.content}\n`
+                    : mergeManagedBlock(existing, desired.content);
         await writeFile(target, next, "utf-8");
         return true;
     }
@@ -1826,16 +2008,18 @@ export async function applyInitUpdate(input) {
                 skipped.push(action);
                 continue;
             }
-            const currentState = await buildCurrentSurfaceState({
-                repoRoot,
-                projectName,
-                governanceRoot,
-                stateKind: "inferred-baseline",
-            });
-            const relationship = currentState.files[action.path]?.relationship;
-            if (relationship === "local-existing-unknown") {
-                skipped.push(action);
-                continue;
+            if (action.type !== "strip-pi-requires-api-key") {
+                const currentState = await buildCurrentSurfaceState({
+                    repoRoot,
+                    projectName,
+                    governanceRoot,
+                    stateKind: "inferred-baseline",
+                });
+                const relationship = currentState.files[action.path]?.relationship;
+                if (relationship === "local-existing-unknown") {
+                    skipped.push(action);
+                    continue;
+                }
             }
             if (await applySafeAction({ repoRoot, projectName, governanceRoot, action }))
                 applied.push(action);
@@ -1909,6 +2093,10 @@ export async function runInitDoctor(input) {
     const readme = path.join(repoRoot, "README.md");
     add("README loop-agent block", (await exists(readme)) && (await readFile(readme, "utf-8")).includes(MANAGED_BLOCK_START), "managed block present");
     add("repo-local skills", await exists(path.join(repoRoot, "skills", "loop-agent", "SKILL.md")), "skills/loop-agent/SKILL.md");
+    add("agent-compatible skills mirror", await exists(path.join(repoRoot, ".agents", "skills", "loop-agent", "SKILL.md")), ".agents/skills/loop-agent/SKILL.md");
+    const gitignorePath = path.join(repoRoot, ".gitignore");
+    const gitignoreContent = (await exists(gitignorePath)) ? await readFile(gitignorePath, "utf-8") : "";
+    add("gitignore loop-agent block", gitignoreContent.includes(GITIGNORE_BLOCK_START) && gitignoreContent.includes(".harness/tasks/*"), ".gitignore managed runtime ignores");
     const requiredScripts = Object.keys(INIT_SCRIPT_FILES);
     const missingScripts = [];
     for (const script of requiredScripts) {

package/dist/executors/config-core.js

@@ -1,5 +1,5 @@
 import { DEFAULT_CURSOR_MODEL } from './cursor-executor.js';
-import { DEFAULT_DAG_MODELS } from './model-routing.js';
+import { resolveExecutorModelMatrix } from './model-routing.js';
 export const TASK_COMPLEXITY_TO_DAG = {
     small: 'LOW',
     medium: 'MED',
@@ -13,7 +13,8 @@ export function resolveCursorModelForTaskConfig(taskConfig, cursorConfig) {
         return taskConfig.cursorModel.trim();
     }
     const dagLevel = TASK_COMPLEXITY_TO_DAG[taskConfig.complexity ?? 'medium'];
-    return DEFAULT_DAG_MODELS[dagLevel] ?? resolveCursorModel({}, cursorConfig);
+    const matrix = resolveExecutorModelMatrix('cursor', cursorConfig);
+    return matrix[dagLevel] ?? resolveCursorModel({}, cursorConfig);
 }
 export function resolveTaskExecutor(taskConfig, override) {
     if (override)

package/dist/executors/dag-pi-executor.js

@@ -148,7 +148,14 @@ export function buildDagPiUserMessage(task, persona, step) {
     ].join(" ");
 }
 function resolveDagPiModelConfig(model) {
-    return { provider: DAG_PI_MODEL_PROVIDERS[model] ?? DEFAULT_DAG_PI_PROVIDER, model };
+    const provider = DAG_PI_MODEL_PROVIDERS[model] ?? DEFAULT_DAG_PI_PROVIDER;
+    return {
+        provider,
+        model,
+        ...(provider === "wizard-local" && model === "gpt-5.5"
+            ? { thinking: "low" }
+            : {}),
+    };
 }
 const SUMMARY_STDOUT_MAX = 4_000;
 const SUMMARY_STDERR_MAX = 2_000;

package/dist/executors/model-routing.js

@@ -1,9 +1,52 @@
+import { DEFAULT_DAG_EXECUTOR_MODELS, } from '../workflows/dag/types.js';
 export const DEFAULT_DAG_CURSOR_MODEL = "composer-2.5";
 export const DEFAULT_DAG_MODELS = {
     HIGH: "gpt-5.5",
     MED: "composer-2.5",
     LOW: "composer-2.5",
 };
+/**
+ * DAG executor model tier keys that may carry a per-complexity override.
+ */
+const EXECUTOR_MODEL_TIERS = ["LOW", "MED", "HIGH"];
+/**
+ * Resolve the DAG executor model matrix for a single executor from its harness
+ * `executors.<name>` config.
+ *
+ * Priority per tier (LOW/MED/HIGH):
+ *   1. execConfig[tier]  (truthy and !== "default" sentinel)
+ *   2. execConfig.defaultModel (truthy and !== "default" sentinel)
+ *   3. DEFAULT_DAG_EXECUTOR_MODELS[executor][tier]
+ *
+ * The "default" literal (injected by the schema `.default("default")`) and
+ * absent/undefined both mean "no override, fall through".
+ */
+export function resolveExecutorModelMatrix(executor, execConfig) {
+    const tierValue = (tier) => {
+        const tierOverride = execConfig?.[tier];
+        if (tierOverride && tierOverride !== "default")
+            return tierOverride;
+        const defaultModel = execConfig?.defaultModel;
+        if (defaultModel && defaultModel !== "default")
+            return defaultModel;
+        return DEFAULT_DAG_EXECUTOR_MODELS[executor][tier];
+    };
+    return {
+        LOW: tierValue("LOW"),
+        MED: tierValue("MED"),
+        HIGH: tierValue("HIGH"),
+    };
+}
+/**
+ * Resolve both pi and cursor DAG executor model matrices from a harness manifest.
+ * Single entry point for DAG generation and --strict-models baseline resolution.
+ */
+export function resolveExecutorModelMatrices(manifest) {
+    return {
+        pi: resolveExecutorModelMatrix("pi", manifest.executors?.pi),
+        cursor: resolveExecutorModelMatrix("cursor", manifest.executors?.cursor),
+    };
+}
 export function resolveModelSelection(manifest, taskConfig, step, options) {
     const retryAttempt = options?.retryAttempt ?? 0;
     if (Object.keys(manifest.modelProfiles ?? {}).length === 0) {

package/dist/governance/manifest-types.js

@@ -21,7 +21,15 @@ export const executorManifestSchema = z.object({
     description: z.string().optional(),
     enabled: z.boolean().optional(),
     defaultModel: z.string().optional().default("default"),
-    requiresApiKey: z.string().optional().default("CURSOR_API_KEY"),
+    /**
+     * Per-complexity DAG model overrides. When set (and not the "default" sentinel),
+     * these take priority over defaultModel for the matching DAG executor tier.
+     * "default" literal and absent/undefined both mean "no override, fall through".
+     */
+    LOW: z.string().optional(),
+    MED: z.string().optional(),
+    HIGH: z.string().optional(),
+    requiresApiKey: z.string().optional(),
 });
 export const workflowPolicyProfileNameSchema = z.enum([
     "minimal",

package/dist/worker/cli.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import YAML from "yaml";
+import { LoopAgentClient } from "./loop-agent/loop-agent-client.js";
+import { resolveLoopAgentProfile } from "./profile-mapping.js";
+import { writeMorningReport } from "./report/morning-report.js";
+import { buildBatchRunId, runReadyTasks } from "./runner/run-ready.js";
+import { createProgressReporter } from "./progress-reporter.js";
+import { taskSpecSchema } from "./task-spec/schema.js";
+import { validateTaskSpec } from "./task-spec/validate.js";
+export function buildAgentWorkerProgram() {
+    const program = new Command();
+    program
+        .name("agent-worker")
+        .description("Local product-line worker utilities for TaskSpec validation")
+        .showHelpAfterError()
+        .showSuggestionAfterError();
+    const task = program.command("task").description("TaskSpec utilities");
+    const batch = program.command("batch").description("Task Pool batch utilities");
+    const report = program.command("report").description("Task Pool reporting utilities");
+    task
+        .command("validate")
+        .argument("<task-yaml>", "TaskSpec YAML file")
+        .description("Validate a TaskSpec and print JSON")
+        .action(async (taskYaml) => {
+        const taskSpecPath = path.resolve(taskYaml);
+        const raw = await readTaskYaml(taskSpecPath);
+        const result = await validateTaskSpec(raw, { taskSpecPath });
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        if (!result.ok)
+            process.exitCode = 1;
+    });
+    task
+        .command("explain-profile")
+        .argument("<task-yaml>", "TaskSpec YAML file")
+        .description("Explain business profile to loop-agent profile mapping")
+        .action(async (taskYaml) => {
+        const raw = await readTaskYaml(path.resolve(taskYaml));
+        const parsed = taskSpecSchema.parse(raw);
+        const result = resolveLoopAgentProfile(parsed);
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    });
+    batch
+        .command("run-ready")
+        .requiredOption("--feature-dir <dir>", "Feature directory containing tasks/task-graph.yaml")
+        .requiredOption("--repo <repo-root>", "Target repo root")
+        .option("--limit <count>", "Maximum ready tasks to run")
+        .option("--loop-agent-bin <bin>", "loop-agent binary", "loop-agent")
+        .option("--batch-run-id <id>", "Batch run id")
+        .option("--check-repo", "Run bash scripts/check-repo.sh during target repo preflight")
+        .option("--check-repo-command <command...>", "Override the check-repo preflight command")
+        .option("--quiet", "Suppress human-readable progress on stderr (JSON still goes to stdout)")
+        .option("--pi-model <model>", "Smoke override: force every pi executor node to this model (drops --strict-models)")
+        .description("Run ready TaskSpec tasks serially")
+        .action(async (options) => {
+        const repoRoot = path.resolve(options.repo);
+        const batchRunId = options.batchRunId ?? buildBatchRunId(new Date());
+        const client = new LoopAgentClient({
+            loopAgentBin: options.loopAgentBin,
+            artifactRoot: path.join(repoRoot, ".task-pool", "artifacts", batchRunId),
+        });
+        const progress = createProgressReporter({ quiet: options.quiet ?? false });
+        const result = await runReadyTasks({
+            repoRoot,
+            featureDir: path.resolve(options.featureDir),
+            ...(options.limit ? { limit: Number.parseInt(options.limit, 10) } : {}),
+            batchRunId,
+            client,
+            runCheckRepo: options.checkRepo ?? false,
+            ...(options.checkRepoCommand
+                ? { checkRepoCommand: options.checkRepoCommand }
+                : {}),
+            progress,
+            ...(options.piModel ? { piModel: options.piModel } : {}),
+        });
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        if (result.status !== "completed")
+            process.exitCode = 1;
+    });
+    report
+        .command("morning")
+        .requiredOption("--repo <repo-root>", "Target repo root")
+        .option("--batch-run-id <id>", "Filter to one batch run id")
+        .option("--output <path>", "Write markdown report to this path")
+        .description("Render a markdown morning report from Task Pool runs")
+        .action(async (options) => {
+        const repoRoot = path.resolve(options.repo);
+        const outputPath = options.output ??
+            path.join(repoRoot, ".task-pool", "reports", "morning-report.md");
+        await writeMorningReport({
+            repoRoot,
+            ...(options.batchRunId ? { batchRunId: options.batchRunId } : {}),
+            outputPath: path.resolve(outputPath),
+        });
+        process.stdout.write(`${JSON.stringify({ ok: true, outputPath }, null, 2)}\n`);
+    });
+    return program;
+}
+export async function main(argv = process.argv) {
+    await buildAgentWorkerProgram().parseAsync(argv);
+}
+async function readTaskYaml(taskSpecPath) {
+    return YAML.parse(await readFile(taskSpecPath, "utf-8"));
+}
+function isDirectRun() {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    return path.resolve(entry) === fileURLToPath(import.meta.url);
+}
+if (isDirectRun()) {
+    main().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

package/dist/worker/loop-agent/command-result.js

@@ -0,0 +1 @@
+export {};