@tea-agent/loop-agent 0.3.0 → 0.5.0

package/dist/worker/progress-reporter.js

@@ -0,0 +1,81 @@
+/**
+ * Human-readable progress reporting for long-running worker commands.
+ *
+ * Why this exists: agent-worker batch runs can take many minutes per task with
+ * zero stdout/stderr feedback, which looks indistinguishable from a hang. The
+ * system writes rich state to disk (state.json, run.json, .task-pool artifacts)
+ * but never echoes it to the triggering terminal, so users assume it is dead.
+ *
+ * Design:
+ * - Progress goes to STDERR only. STDOUT stays reserved for the final
+ *   machine-readable JSON payload, so `... | jq` and pipes keep working.
+ * - Default ON. `--quiet` disables it. Non-interactive use that only wants JSON
+ *   can pass `--quiet` (or redirect stderr).
+ * - TTY-aware for ANSI only: if stderr is not a TTY, we still print the lines
+ *   (they are line-buffered text and flush fine) but skip ANSI decoration.
+ * - A `noop` reporter keeps library callers (and tests that don't care) quiet
+ *   with zero changes to their call sites beyond accepting the option.
+ */
+const ANSI = {
+    bold: "\x1b[1m",
+    green: "\x1b[32m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    cyan: "\x1b[36m",
+    dim: "\x1b[2m",
+    reset: "\x1b[0m",
+};
+function stamp(now) {
+    const iso = now.toISOString();
+    // YYYY-MM-DDTHH:MM:SS — drop millis and trailing Z noise for compact lines.
+    return `[${iso.slice(0, 19)}]`;
+}
+export function createProgressReporter(options = {}) {
+    if (options.quiet)
+        return noopProgressReporter;
+    const sink = options.sink ?? ((chunk) => process.stderr.write(chunk));
+    const isTty = options.isTty ?? process.stderr.isTTY === true;
+    const now = options.now ?? (() => new Date());
+    function decorate(prefix, message, color) {
+        return isTty ? `${color}${prefix}${ANSI.reset} ${message}` : `${prefix} ${message}`;
+    }
+    return {
+        batch(message) {
+            sink(`${stamp(now())} ${decorate("==", message, ANSI.bold + ANSI.cyan)}\n`);
+        },
+        task(message) {
+            sink(`${stamp(now())} ${decorate("▶", message, ANSI.bold)}\n`);
+        },
+        step(message) {
+            const body = isTty ? `${ANSI.dim}${message}${ANSI.reset}` : message;
+            sink(`${stamp(now())}   ${body}\n`);
+        },
+        note(message) {
+            sink(`${stamp(now())} ${decorate("•", message, ANSI.dim)}\n`);
+        },
+    };
+}
+export const noopProgressReporter = {
+    batch() { },
+    task() { },
+    step() { },
+    note() { },
+};
+/** Format a millisecond duration as a compact human string: "6m 35s", "1h 2m 3s", "450ms". */
+export function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        return "?";
+    if (ms < 1000)
+        return `${Math.round(ms)}ms`;
+    const totalSeconds = Math.round(ms / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0 || hours > 0)
+        parts.push(`${minutes}m`);
+    parts.push(`${seconds}s`);
+    return parts.join(" ");
+}

package/dist/worker/report/morning-report.js

@@ -0,0 +1,69 @@
+import { access, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { getRunsJsonlPath, readAllTaskPoolStates, readJsonlFile, } from "../pool/run-store.js";
+export async function renderMorningReport(options) {
+    const runs = (await readJsonlFile(getRunsJsonlPath(options.repoRoot))).filter((run) => !options.batchRunId || run.batchRunId === options.batchRunId);
+    const total = runs.length;
+    const succeeded = runs.filter((run) => run.status === "succeeded").length;
+    const failed = runs.filter((run) => run.status === "failed").length;
+    const followUps = runs.filter((run) => run.failure).length;
+    const states = await readAllTaskPoolStates(options.repoRoot);
+    const blocked = Object.values(states).filter((state) => state.status === "Blocked").length;
+    const lines = [
+        "# Nightly Worker Report",
+        "",
+        "## Summary",
+        "",
+        `- Total: ${total}`,
+        `- Succeeded: ${succeeded}`,
+        `- Failed: ${failed}`,
+        `- Blocked: ${blocked}`,
+        `- Follow-ups: ${followUps}`,
+        "",
+        "## Results",
+        "",
+        "| Task | Status | Run | Failure | Next | Artifacts |",
+        "|---|---|---|---|---|---|",
+    ];
+    for (const run of runs) {
+        lines.push(`| ${run.taskId} | ${run.status} | ${run.workerRunId} | ${run.failure?.category ?? "-"} | ${run.failure?.derivedFollowUpTaskId ?? "-"} | ${await artifactSummary(run)} |`);
+    }
+    if (followUps > 0) {
+        lines.push("", "## Human Actions", "");
+        for (const run of runs.filter((candidate) => candidate.failure)) {
+            lines.push(`- ${run.failure?.derivedFollowUpTaskId}: ${run.failure?.recommendedFollowUpKind} for ${run.taskId}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+export async function writeMorningReport(input) {
+    const markdown = await renderMorningReport(input);
+    await mkdir(path.dirname(input.outputPath), { recursive: true });
+    await writeFile(input.outputPath, markdown, "utf-8");
+    return input.outputPath;
+}
+async function artifactSummary(run) {
+    const artifacts = [
+        ["dag", run.dagPath],
+        ["record", run.runRecordPath],
+        ["report", run.failureArtifacts?.reportMarkdownArtifactPath],
+        ["doctor", run.failureArtifacts?.doctorMarkdownArtifactPath],
+        ["closeout", run.failureArtifacts?.closeoutDraftPath],
+    ].filter((entry) => Boolean(entry[1]));
+    if (artifacts.length === 0)
+        return "-";
+    const parts = [];
+    for (const [label, artifactPath] of artifacts) {
+        parts.push(`${label}:${(await exists(artifactPath)) ? artifactPath : `missing artifact ${artifactPath}`}`);
+    }
+    return parts.join("<br>");
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/worker/repos/repo-resolver.js

@@ -0,0 +1,23 @@
+import path from "node:path";
+export function resolveRepoPath(config, pathRef) {
+    const entry = config.repos?.[pathRef];
+    if (!entry) {
+        return {
+            ok: false,
+            code: "repo-path-ref-missing",
+            message: `repo path_ref is not configured: ${pathRef}`,
+        };
+    }
+    if (typeof entry.path !== "string" || entry.path.trim().length === 0) {
+        return {
+            ok: false,
+            code: "repo-path-invalid",
+            message: `repo path_ref has invalid path: ${pathRef}`,
+        };
+    }
+    return {
+        ok: true,
+        repoRoot: path.resolve(entry.path),
+        defaultBranch: typeof entry.default_branch === "string" ? entry.default_branch : undefined,
+    };
+}

package/dist/worker/run-task/run-task.js

@@ -0,0 +1,359 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { formatDuration, noopProgressReporter } from "../progress-reporter.js";
+import { materializeTaskSpec, } from "../materialize/harness-task-materializer.js";
+import { preflightTargetRepo } from "../preflight.js";
+export const DEFAULT_RUN_DAG_TIMEOUT_MS = 1_800_000;
+export const MAX_WORKER_TIMEOUT_MS = 7_200_000;
+export async function runTaskSpec(options) {
+    const now = options.now ?? new Date();
+    const workerRunId = options.workerRunId ?? buildWorkerRunId(options.taskSpec.id, now);
+    const commands = [];
+    const client = new RecordingRunTaskClient(options.client, commands);
+    const progress = options.progress ?? noopProgressReporter;
+    if (options.preflight !== false) {
+        progress.step("preflight: version + inspect + docs-audit + git-status" + (options.preflight && typeof options.preflight === "object" && options.preflight.runCheckRepo ? " + check-repo" : ""));
+        const preflightStartedAt = Date.now();
+        const preflight = await preflightTargetRepo({
+            repoRoot: options.repoRoot,
+            client,
+            ...(typeof options.preflight === "object" ? options.preflight : {}),
+        });
+        if (!preflight.ok) {
+            progress.note(`preflight FAILED: ${preflight.code}`);
+            throw new Error(`target repo preflight failed: ${preflight.code}: ${preflight.message}`);
+        }
+        progress.step(`preflight ok in ${formatDuration(Date.now() - preflightStartedAt)}`);
+    }
+    progress.step("materialize harness task");
+    const materializeStartedAt = Date.now();
+    const materializeManifest = await materializeTaskSpec({
+        repoRoot: options.repoRoot,
+        taskSpec: options.taskSpec,
+        taskSpecPath: options.taskSpecPath,
+        client,
+        now,
+    });
+    progress.step(`materialized ${materializeManifest.harnessTaskId} in ${formatDuration(Date.now() - materializeStartedAt)}`);
+    const taskArtifactsDir = path.join(options.repoRoot, ".harness", "tasks", materializeManifest.harnessTaskId, "artifacts");
+    await mkdir(taskArtifactsDir, { recursive: true });
+    const dagPath = path.join(taskArtifactsDir, `${workerRunId}-dag.json`);
+    const runRecordPath = path.join(taskArtifactsDir, "worker-run-record.json");
+    progress.step("dag run-task: generate DAG");
+    const dagGenStartedAt = Date.now();
+    await runRequiredCommand(options.repoRoot, client, "dag-run-task", [
+        "dag",
+        "run-task",
+        materializeManifest.harnessTaskId,
+        "--profile",
+        materializeManifest.loopAgentProfile,
+        "--strict-models",
+        "--output",
+        dagPath,
+        "--cwd",
+        options.repoRoot,
+        ...noCursorArgs(options.taskSpec),
+    ]);
+    progress.step(`dag generated in ${formatDuration(Date.now() - dagGenStartedAt)}`);
+    if (options.piModel) {
+        progress.step(`pi-model override: rewriting executorModels.pi → ${options.piModel}`);
+        await applyPiModelOverride(dagPath, options.piModel);
+    }
+    progress.step("dag validate");
+    const validateStartedAt = Date.now();
+    await runRequiredCommand(options.repoRoot, client, "dag-validate", [
+        "dag",
+        "validate",
+        "--dag",
+        dagPath,
+        ...strictModelsArgs(options.piModel),
+        "--strict-governance",
+        "--spine-task",
+        materializeManifest.harnessTaskId,
+        ...forbidCursorArgs(options.taskSpec),
+    ]);
+    progress.step(`dag validated in ${formatDuration(Date.now() - validateStartedAt)}`);
+    progress.step("run-dag: executing DAG nodes (this is the long step)");
+    const runDagStartedAt = Date.now();
+    await runRequiredCommand(options.repoRoot, client, "run-dag", [
+        "run-dag",
+        "--dag",
+        dagPath,
+        "--cwd",
+        options.repoRoot,
+        "--run-id",
+        workerRunId,
+        ...maxConcurrentArgs(options.taskSpec),
+        ...noCursorArgs(options.taskSpec),
+    ], true, resolveRunDagTimeoutMs(options.taskSpec));
+    progress.step(`run-dag finished in ${formatDuration(Date.now() - runDagStartedAt)}`);
+    const reportJson = await client.run([
+        "dag",
+        "report",
+        "--run-id",
+        workerRunId,
+        "--lifecycle",
+        "all",
+        "--json",
+    ], {
+        cwd: options.repoRoot,
+        artifactName: "dag-report-json",
+        expectJson: true,
+    });
+    const reportDecision = decideFromReport(workerRunId, reportJson);
+    await client.run([
+        "dag",
+        "report",
+        "--run-id",
+        workerRunId,
+        "--lifecycle",
+        "all",
+        "--markdown",
+    ], {
+        cwd: options.repoRoot,
+        artifactName: "dag-report-markdown",
+    });
+    const status = reportDecision.succeeded ? "succeeded" : "failed";
+    progress.step(`report decision: ${status} (${reportDecision.reason}${reportDecision.runStatus ? `, status=${reportDecision.runStatus}` : ""})`);
+    const failureArtifacts = reportDecision.succeeded
+        ? undefined
+        : await collectFailureArtifacts({
+            client,
+            repoRoot: options.repoRoot,
+            workerRunId,
+            taskArtifactsDir,
+        });
+    if (reportDecision.succeeded) {
+        progress.step("promote + closeout");
+        await runRequiredCommand(options.repoRoot, client, "promote-run", ["promote-run", materializeManifest.harnessTaskId, "--run-id", workerRunId], true);
+        await runRequiredCommand(options.repoRoot, client, "closeout-task", ["closeout", "task", materializeManifest.harnessTaskId], true);
+    }
+    const record = {
+        schemaVersion: 1,
+        status,
+        workerRunId,
+        businessId: options.taskSpec.id,
+        harnessTaskId: materializeManifest.harnessTaskId,
+        featureId: options.taskSpec.feature_id,
+        loopAgentProfile: materializeManifest.loopAgentProfile,
+        dagPath,
+        runRecordPath,
+        materializeManifest,
+        reportDecision,
+        commands,
+        ...(failureArtifacts ? { failureArtifacts } : {}),
+    };
+    await writeFile(runRecordPath, `${JSON.stringify(record, null, 2)}\n`, "utf-8");
+    return {
+        status,
+        workerRunId,
+        businessId: options.taskSpec.id,
+        harnessTaskId: materializeManifest.harnessTaskId,
+        runRecordPath,
+        dagPath,
+        reportDecision,
+        ...(failureArtifacts ? { failureArtifacts } : {}),
+    };
+}
+export function buildWorkerRunId(businessId, now) {
+    const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+    const hash = createHash("sha256")
+        .update(`${businessId}:${now.toISOString()}`)
+        .digest("hex")
+        .slice(0, 6);
+    return `wr-${date}-${businessId}-${hash}`;
+}
+async function runRequiredCommand(repoRoot, client, artifactName, args, expectJson = true, timeoutMs) {
+    const result = await client.run(args, {
+        cwd: repoRoot,
+        artifactName,
+        expectJson,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    });
+    if (!result.ok) {
+        throw new Error(`loop-agent command failed: ${args.join(" ")}`);
+    }
+    return result;
+}
+function resolveRunDagTimeoutMs(taskSpec) {
+    return Math.min(taskSpec.worker.timeout_ms ?? DEFAULT_RUN_DAG_TIMEOUT_MS, MAX_WORKER_TIMEOUT_MS);
+}
+async function collectFailureArtifacts(input) {
+    const doctor = await input.client.run(["dag", "doctor", "--run-id", input.workerRunId, "--markdown"], {
+        cwd: input.repoRoot,
+        artifactName: "dag-doctor-markdown",
+    });
+    const closeoutDraftPath = path.join(input.repoRoot, ".task-pool", "failure-handoffs", `${input.workerRunId}-failure-closeout-draft.md`);
+    await input.client.run([
+        "dag",
+        "closeout-draft",
+        "--run-id",
+        input.workerRunId,
+        "--output",
+        closeoutDraftPath,
+    ], {
+        cwd: input.repoRoot,
+        artifactName: "dag-closeout-draft",
+    });
+    const reportMarkdown = input.client instanceof RecordingRunTaskClient
+        ? input.client.findArtifact("dag-report-markdown")
+        : undefined;
+    return {
+        reportMarkdownArtifactPath: reportMarkdown?.result.artifacts.stdoutPath ?? "",
+        doctorMarkdownArtifactPath: doctor.artifacts.stdoutPath,
+        closeoutDraftPath,
+    };
+}
+function decideFromReport(workerRunId, result) {
+    if (!result.ok || !result.json) {
+        return {
+            succeeded: false,
+            reason: "report-json-unavailable",
+        };
+    }
+    const runs = readObjectArray(result.json, "runs");
+    const run = runs.find((candidate) => readString(candidate, "runId") === workerRunId) ??
+        runs[0];
+    if (!run) {
+        return {
+            succeeded: false,
+            reason: "report-run-missing",
+        };
+    }
+    const runStatus = readString(run, "status");
+    const nodes = readObjectArray(run, "nodes");
+    const failedNode = nodes.find((node) => {
+        const status = readString(node, "status");
+        const failureCategory = readString(node, "failureCategory");
+        return (status === "ERROR" ||
+            status === "SKIPPED" ||
+            (Boolean(failureCategory) && failureCategory !== "success"));
+    });
+    if (runStatus !== "completed" && runStatus !== "finished") {
+        return {
+            succeeded: false,
+            reason: "run-not-completed",
+            runStatus,
+            primaryFailure: readProperty(run, "primaryFailure"),
+        };
+    }
+    if (failedNode) {
+        return {
+            succeeded: false,
+            reason: "node-failure",
+            runStatus,
+            primaryFailure: readProperty(run, "primaryFailure") ?? failedNode,
+        };
+    }
+    return {
+        succeeded: true,
+        reason: "report-completed",
+        runStatus,
+        primaryFailure: readProperty(run, "primaryFailure"),
+    };
+}
+class RecordingRunTaskClient {
+    delegate;
+    records;
+    constructor(delegate, records) {
+        this.delegate = delegate;
+        this.records = records;
+    }
+    async run(args, options) {
+        const result = await this.delegate.run(args, options);
+        this.records.push({
+            name: commandRecordName(args, options.artifactName),
+            artifactName: options.artifactName,
+            args,
+            result: {
+                ok: result.ok,
+                exitCode: result.exitCode,
+                durationMs: result.durationMs,
+                timedOut: result.timedOut,
+                artifacts: result.artifacts,
+                ...(result.parseFailure ? { parseFailure: result.parseFailure } : {}),
+            },
+        });
+        return result;
+    }
+    async runExternal(command, args, options) {
+        const result = await this.delegate.runExternal(command, args, options);
+        this.records.push({
+            name: options.artifactName,
+            artifactName: options.artifactName,
+            args: [command, ...args],
+            result: {
+                ok: result.ok,
+                exitCode: result.exitCode,
+                durationMs: result.durationMs,
+                timedOut: result.timedOut,
+                artifacts: result.artifacts,
+                ...(result.parseFailure ? { parseFailure: result.parseFailure } : {}),
+            },
+        });
+        return result;
+    }
+    findArtifact(artifactName) {
+        return this.records.find((record) => record.artifactName === artifactName);
+    }
+}
+function commandRecordName(args, artifactName) {
+    if (args[0] === "new-task")
+        return "new-task";
+    return artifactName;
+}
+function noCursorArgs(taskSpec) {
+    return taskSpec.loop_agent.no_cursor ? ["--no-cursor"] : [];
+}
+function forbidCursorArgs(taskSpec) {
+    return taskSpec.loop_agent.no_cursor ? ["--forbid-executor", "cursor"] : [];
+}
+function maxConcurrentArgs(taskSpec) {
+    return ["--max-concurrent", String(taskSpec.loop_agent.max_concurrent)];
+}
+/**
+ * When a smoke `piModel` override is active, drop `--strict-models` so the
+ * non-canonical `executorModels.pi` rewrite passes `dag validate`. Governance,
+ * forbidden-executor and spine audits are still enforced by their own flags.
+ */
+function strictModelsArgs(piModel) {
+    return piModel ? [] : ["--strict-models"];
+}
+/**
+ * Rewrite `executorModels.pi.{LOW,MED,HIGH}` in an already-generated DAG JSON
+ * so every pi executor node resolves to the smoke override model. Cursor / shell
+ * slots are left untouched.
+ */
+export async function applyPiModelOverride(dagPath, piModel) {
+    const raw = await readFile(dagPath, "utf-8");
+    const spec = JSON.parse(raw);
+    spec.executorModels = {
+        ...(spec.executorModels?.cursor ? { cursor: spec.executorModels.cursor } : {}),
+        pi: {
+            LOW: piModel,
+            MED: piModel,
+            HIGH: piModel,
+        },
+    };
+    await writeFile(dagPath, `${JSON.stringify(spec, null, 2)}\n`, "utf-8");
+}
+function readObjectArray(value, key) {
+    if (!value || typeof value !== "object")
+        return [];
+    const child = value[key];
+    if (!Array.isArray(child))
+        return [];
+    return child.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item));
+}
+function readString(value, key) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const child = value[key];
+    return typeof child === "string" ? child : undefined;
+}
+function readProperty(value, key) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    return value[key];
+}