@tea-agent/loop-agent 0.1.0

package/dist/commands/dag-report.js

@@ -0,0 +1,177 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { buildDagCloseoutDraft, buildDagReport, DAG_PAUSED_LATEST_REPORT_PRESET, DAG_RECOVERY_ACTIONS, formatDagReportHandoffMarkdown, formatDagReportMarkdown, serializeDagReportJson, } from "../workflows/dag/report.js";
+const RECOVERY_ACTIONS = new Set(DAG_RECOVERY_ACTIONS);
+const LIFECYCLE_FILTERS = new Set([
+    "active",
+    "paused",
+    "completed",
+    "all",
+]);
+export function parseDagReportArgs(args) {
+    let runId;
+    let lifecycle = "all";
+    let json = false;
+    let markdown = false;
+    let failedOnly = false;
+    let latest = false;
+    let pausedLatest = false;
+    let action;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--run-id") {
+            runId = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--run-id=")) {
+            runId = arg.slice("--run-id=".length);
+            continue;
+        }
+        if (arg === "--lifecycle") {
+            const value = args[++i];
+            if (!LIFECYCLE_FILTERS.has(value)) {
+                throw new Error(`invalid --lifecycle value: ${value} (expected active|paused|completed|all)`);
+            }
+            lifecycle = value;
+            continue;
+        }
+        if (arg.startsWith("--lifecycle=")) {
+            const value = arg.slice("--lifecycle=".length);
+            if (!LIFECYCLE_FILTERS.has(value)) {
+                throw new Error(`invalid --lifecycle value: ${value} (expected active|paused|completed|all)`);
+            }
+            lifecycle = value;
+            continue;
+        }
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--markdown") {
+            markdown = true;
+            continue;
+        }
+        if (arg === "--failed-only") {
+            failedOnly = true;
+            continue;
+        }
+        if (arg === "--latest") {
+            latest = true;
+            continue;
+        }
+        if (arg === "--paused-latest") {
+            pausedLatest = true;
+            continue;
+        }
+        if (arg === "--action") {
+            const value = args[++i];
+            if (!RECOVERY_ACTIONS.has(value)) {
+                throw new Error(`invalid --action value: ${value} (expected ${[...DAG_RECOVERY_ACTIONS].join("|")})`);
+            }
+            action = value;
+            continue;
+        }
+        if (arg.startsWith("--action=")) {
+            const value = arg.slice("--action=".length);
+            if (!RECOVERY_ACTIONS.has(value)) {
+                throw new Error(`invalid --action value: ${value} (expected ${[...DAG_RECOVERY_ACTIONS].join("|")})`);
+            }
+            action = value;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag report flag: ${arg}`);
+        }
+        throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (json && markdown) {
+        throw new Error("cannot use --json and --markdown together");
+    }
+    if (pausedLatest) {
+        if (lifecycle !== "all") {
+            throw new Error("cannot combine --paused-latest with an explicit --lifecycle filter");
+        }
+        lifecycle = DAG_PAUSED_LATEST_REPORT_PRESET.lifecycle;
+        latest = DAG_PAUSED_LATEST_REPORT_PRESET.latest;
+    }
+    return {
+        runId,
+        lifecycle,
+        json,
+        markdown,
+        failedOnly,
+        latest,
+        pausedLatest,
+        action,
+    };
+}
+export async function runDagReport(repoRoot, rawArgs) {
+    const parsed = parseDagReportArgs(rawArgs);
+    const report = await buildDagReport({
+        repoRoot,
+        runId: parsed.runId,
+        lifecycle: parsed.lifecycle,
+        failedOnly: parsed.failedOnly,
+        latest: parsed.latest,
+        action: parsed.action,
+    });
+    if (parsed.json) {
+        console.log(JSON.stringify(serializeDagReportJson(report), null, 2));
+        return;
+    }
+    if (parsed.markdown) {
+        console.log(formatDagReportHandoffMarkdown(report));
+        return;
+    }
+    console.log(formatDagReportMarkdown(report));
+}
+export function parseDagCloseoutDraftArgs(args) {
+    let runId;
+    let outputPath;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        const requireValue = (flag) => {
+            const value = args[++i];
+            if (!value || value.startsWith("-")) {
+                throw new Error(`missing value for ${flag}`);
+            }
+            return value;
+        };
+        if (arg === "--run-id") {
+            runId = requireValue("--run-id");
+            continue;
+        }
+        if (arg.startsWith("--run-id=")) {
+            runId = arg.slice("--run-id=".length);
+            if (!runId)
+                throw new Error("missing value for --run-id");
+            continue;
+        }
+        if (arg === "--output") {
+            outputPath = requireValue("--output");
+            continue;
+        }
+        if (arg.startsWith("--output=")) {
+            outputPath = arg.slice("--output=".length);
+            if (!outputPath)
+                throw new Error("missing value for --output");
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag closeout-draft flag: ${arg}`);
+        }
+        throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    return { runId, outputPath };
+}
+export async function runDagCloseoutDraft(repoRoot, rawArgs) {
+    const parsed = parseDagCloseoutDraftArgs(rawArgs);
+    const draft = await buildDagCloseoutDraft({
+        repoRoot,
+        runId: parsed.runId,
+        outputPath: parsed.outputPath,
+    });
+    await mkdir(path.dirname(draft.outputPath), { recursive: true });
+    await writeFile(draft.outputPath, draft.markdown, "utf-8");
+    console.log(`Wrote closeout draft to ${draft.outputPath}`);
+}

package/dist/commands/dag-resume.js

@@ -0,0 +1,34 @@
+import { resumeDagRun } from "../workflows/dag/runner.js";
+export function parseDagResumeArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag resume --run-id <id>");
+    }
+    let runId;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--run-id") {
+            runId = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--run-id=")) {
+            runId = arg.slice("--run-id=".length);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag resume flag: ${arg}`);
+        }
+        throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (!runId) {
+        throw new Error("dag resume requires --run-id <id>");
+    }
+    return { runId };
+}
+export async function runDagResume(repoRoot, rawArgs) {
+    const parsed = parseDagResumeArgs(rawArgs);
+    const summary = await resumeDagRun({
+        cwd: repoRoot,
+        runId: parsed.runId,
+    });
+    console.log(JSON.stringify(summary, null, 2));
+}

package/dist/commands/dag-run-task.js

@@ -0,0 +1,470 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { resolveAutoRoutingProfile, requiresSupervisedQualityGate, } from "../workflows/dag/governance-profile.js";
+import { resolveShellCommands } from "../executors/shell-executor.js";
+import { parseDagSpec } from "../workflows/dag/types.js";
+import { pathMatchesPattern } from "../shared/git-progress.js";
+import { loadHarnessManifest } from "../governance/harness.js";
+import { defaultHybridDagOutputPath, initHybridDagFromTask, } from "../workflows/dag/init-hybrid.js";
+import { runDagValidate } from "./dag-validate.js";
+import { runRunDag } from "./run-dag.js";
+const PLACEHOLDER_WRITESET_MARKER = "REPLACE/WITH";
+export function parseDagRunTaskArgs(args, defaultCwd) {
+    if (args.length === 0) {
+        throw new Error("usage: dag run-task <task-id> [--output <path>] [--profile auto|minimal|standard|reviewed|supervised] [--strict-models] [--no-cursor] [--execute] [--init-only] [--dry-run] [--cwd <dir>] [--max-concurrent N] [--run-id id] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]]");
+    }
+    let taskId;
+    let outputPath;
+    let strictModels = false;
+    let noCursor = false;
+    let execute = false;
+    let initOnly = false;
+    let dryRun = false;
+    let cwd;
+    let maxConcurrent;
+    let runId;
+    let canvasPath;
+    let canvasName;
+    let canvasesDir;
+    let profile = "standard";
+    let profileExplicit = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--output" || arg === "-o") {
+            outputPath = args[++i];
+            if (!outputPath) {
+                throw new Error("dag run-task --output requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--output=")) {
+            outputPath = arg.slice("--output=".length);
+            continue;
+        }
+        if (arg === "--strict-models") {
+            strictModels = true;
+            continue;
+        }
+        if (arg === "--no-cursor") {
+            noCursor = true;
+            continue;
+        }
+        if (arg === "--execute") {
+            execute = true;
+            continue;
+        }
+        if (arg === "--init-only") {
+            initOnly = true;
+            continue;
+        }
+        if (arg === "--dry-run") {
+            dryRun = true;
+            continue;
+        }
+        if (arg === "--cwd" || arg === "-C") {
+            cwd = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--cwd=")) {
+            cwd = arg.slice(6);
+            continue;
+        }
+        if (arg === "--max-concurrent") {
+            maxConcurrent = Number(args[++i]);
+            continue;
+        }
+        if (arg === "--run-id") {
+            runId = args[++i];
+            continue;
+        }
+        if (arg === "--canvas-path") {
+            canvasPath = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--canvas-path=")) {
+            canvasPath = arg.slice(14);
+            continue;
+        }
+        if (arg === "--canvas") {
+            canvasName = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--canvas=")) {
+            canvasName = arg.slice(9);
+            continue;
+        }
+        if (arg === "--canvases-dir") {
+            canvasesDir = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--canvases-dir=")) {
+            canvasesDir = arg.slice(15);
+            continue;
+        }
+        if (arg === "--profile") {
+            const value = args[++i];
+            if (!value) {
+                throw new Error("dag run-task --profile requires a value");
+            }
+            profile = parseDagRunTaskProfile(value);
+            profileExplicit = true;
+            continue;
+        }
+        if (arg.startsWith("--profile=")) {
+            profile = parseDagRunTaskProfile(arg.slice("--profile=".length));
+            profileExplicit = true;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag run-task flag: ${arg}`);
+        }
+        if (taskId) {
+            throw new Error(`unexpected positional argument: ${arg}`);
+        }
+        taskId = arg;
+    }
+    if (!taskId) {
+        throw new Error("dag run-task requires <task-id>");
+    }
+    return {
+        taskId,
+        outputPath: outputPath ? path.resolve(outputPath) : undefined,
+        strictModels,
+        noCursor,
+        execute,
+        initOnly,
+        dryRun,
+        cwd: path.resolve(cwd ?? defaultCwd ?? process.cwd()),
+        maxConcurrent,
+        runId,
+        canvasPath,
+        canvasName,
+        canvasesDir,
+        profile,
+        profileExplicit,
+    };
+}
+function parseDagRunTaskProfile(value) {
+    if (value === "auto" ||
+        value === "minimal" ||
+        value === "standard" ||
+        value === "reviewed" ||
+        value === "supervised") {
+        return value;
+    }
+    throw new Error(`dag run-task --profile must be one of: auto, minimal, standard, reviewed, supervised; got ${value}`);
+}
+function buildValidateArgs(dagPath, parsed) {
+    const validateArgs = ["--dag", dagPath];
+    if (parsed.strictModels)
+        validateArgs.push("--strict-models");
+    if (parsed.noCursor)
+        validateArgs.push("--forbid-executor", "cursor");
+    return validateArgs;
+}
+function buildRunDagArgs(dagPath, parsed) {
+    const runArgs = ["--dag", dagPath, "--cwd", parsed.cwd];
+    if (parsed.dryRun)
+        runArgs.push("--dry-run");
+    else if (parsed.initOnly)
+        runArgs.push("--init-only");
+    if (parsed.noCursor)
+        runArgs.push("--no-cursor");
+    if (parsed.maxConcurrent !== undefined) {
+        runArgs.push("--max-concurrent", String(parsed.maxConcurrent));
+    }
+    if (parsed.runId)
+        runArgs.push("--run-id", parsed.runId);
+    if (parsed.canvasPath)
+        runArgs.push("--canvas-path", parsed.canvasPath);
+    if (parsed.canvasName)
+        runArgs.push("--canvas", parsed.canvasName);
+    if (parsed.canvasesDir)
+        runArgs.push("--canvases-dir", parsed.canvasesDir);
+    return runArgs;
+}
+function shouldRunExecution(parsed) {
+    return parsed.execute || parsed.initOnly || parsed.dryRun;
+}
+function resolveExecutionMode(parsed) {
+    if (parsed.dryRun)
+        return "dry-run";
+    if (parsed.initOnly)
+        return "init-only";
+    return "execute";
+}
+function isUnsafeWriteSetEntry(entry) {
+    const normalized = entry.trim();
+    if (!normalized || normalized === "." || normalized === "./")
+        return true;
+    if (normalized === "**")
+        return true;
+    return normalized.includes(PLACEHOLDER_WRITESET_MARKER);
+}
+export async function assertSafeForExecution(dagPath) {
+    const raw = JSON.parse(await readFile(dagPath, "utf-8"));
+    const unsafe = [];
+    for (const task of raw.tasks ?? []) {
+        if (task.writePolicy !== "exclusive")
+            continue;
+        const writeSet = Array.isArray(task.writeSet) ? task.writeSet : [];
+        for (const entry of writeSet) {
+            if (typeof entry !== "string")
+                continue;
+            if (isUnsafeWriteSetEntry(entry)) {
+                const taskId = typeof task.id === "string" ? task.id : "unknown";
+                unsafe.push(`task=${taskId}, writeSet=${entry}`);
+            }
+        }
+    }
+    if (unsafe.length === 0)
+        return;
+    throw new Error(`refusing execution: narrow implement writeSet before --execute/init-only/dry-run: ${unsafe.join("; ")}`);
+}
+async function captureValidateSummary(repoRoot, validateArgs) {
+    let captured;
+    const originalLog = console.log;
+    console.log = (message) => {
+        if (typeof message === "string") {
+            captured = JSON.parse(message);
+        }
+    };
+    try {
+        await runDagValidate(repoRoot, validateArgs);
+    }
+    finally {
+        console.log = originalLog;
+    }
+    if (!captured) {
+        throw new Error("dag run-task validate produced no JSON summary");
+    }
+    return captured;
+}
+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}`,
+    ];
+}
+function isBroadWriteSetEntryForPacket(entry) {
+    const normalized = entry.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+    if (!normalized || normalized === "." || normalized === "./")
+        return true;
+    if (normalized === "**")
+        return true;
+    return normalized.includes(PLACEHOLDER_WRITESET_MARKER);
+}
+function resolveWritePolicyForPacket(task, spec) {
+    return task.writePolicy ?? spec.defaults?.writePolicy ?? "none";
+}
+function collectWriterTasksForPacket(spec) {
+    return spec.tasks.filter((task) => {
+        const writePolicy = resolveWritePolicyForPacket(task, spec);
+        return writePolicy === "exclusive" && (task.writeSet?.length ?? 0) > 0;
+    });
+}
+function findForbiddenOverlapsForPacket(task) {
+    const overlaps = [];
+    for (const writeSetEntry of task.writeSet ?? []) {
+        for (const forbiddenPath of task.forbiddenPaths ?? []) {
+            if (pathMatchesPattern(writeSetEntry, forbiddenPath) ||
+                pathMatchesPattern(forbiddenPath, writeSetEntry)) {
+                overlaps.push({ writeSetEntry, forbiddenPath });
+            }
+        }
+    }
+    return overlaps;
+}
+function isVerificationShellTask(task) {
+    if (task.executor !== "shell" || !task.shell)
+        return false;
+    if (/verify|verification/i.test(task.id))
+        return true;
+    const commands = resolveShellCommands(task.shell);
+    return commands.some((command) => /(vitest|npm run (lint|typecheck|test)|check-repo\.sh|loop-agent-standard-verify)/.test(command));
+}
+async function buildReviewPacket(input) {
+    const spec = parseDagSpec(JSON.parse(await readFile(input.dagPath, "utf-8")));
+    const writers = collectWriterTasksForPacket(spec).map((task) => {
+        const writeSet = task.writeSet ?? [];
+        return {
+            nodeId: task.id,
+            role: task.role,
+            writePolicy: resolveWritePolicyForPacket(task, spec),
+            writeSet,
+            broadEntries: writeSet.filter(isBroadWriteSetEntryForPacket),
+            forbiddenOverlaps: findForbiddenOverlapsForPacket(task),
+        };
+    });
+    const shellTasks = spec.tasks.filter((task) => task.executor === "shell" && task.shell);
+    const shellVerification = shellTasks
+        .filter(isVerificationShellTask)
+        .map((task) => ({
+        nodeId: task.id,
+        commands: resolveShellCommands(task.shell),
+    }));
+    return {
+        profileRouting: {
+            requestedProfile: input.profileRouting.requestedProfile,
+            selectedByProfile: input.profileRouting.selectedByProfile,
+            selectedTemplate: input.profileRouting.selectedTemplate,
+            source: input.profileRouting.source,
+            ...(input.profileRouting.routingReasons
+                ? { routingReasons: input.profileRouting.routingReasons }
+                : {}),
+        },
+        governanceProfile: input.governanceProfile,
+        writers,
+        broadWriteSetRisk: writers.some((writer) => writer.broadEntries.length > 0),
+        forbiddenOverlapRisk: writers.some((writer) => writer.forbiddenOverlaps.length > 0),
+        shellGates: shellTasks
+            .filter((task) => task.shell?.verdictGate)
+            .map((task) => ({
+            nodeId: task.id,
+            fromNodeId: task.shell.verdictGate.fromNodeId,
+            accept: task.shell.verdictGate.accept,
+            lineMode: task.shell.verdictGate.lineMode ?? "first-non-empty",
+            label: task.shell.verdictGate.label,
+            commands: resolveShellCommands(task.shell),
+        })),
+        shellVerification,
+        decisionGates: spec.tasks.map((task) => ({
+            nodeId: task.id,
+            enabled: task.decisionGate?.enabled ?? false,
+            mode: task.decisionGate?.enabled
+                ? (task.decisionGate.mode ?? "record-only")
+                : "disabled",
+        })),
+        expectedVerification: shellVerification.flatMap((entry) => entry.commands),
+    };
+}
+function templateForProfile(policy, profile) {
+    return policy.dag.profileRouting[profile];
+}
+async function resolveProfileRouting(repoRoot, parsed, candidateProfile) {
+    if (!parsed.profileExplicit) {
+        return {
+            requestedProfile: parsed.profile,
+            selectedByProfile: "standard",
+            selectedTemplate: "standard-dag",
+            source: "default",
+            candidateProfile,
+        };
+    }
+    const manifest = await loadHarnessManifest(repoRoot);
+    if (parsed.profile === "auto") {
+        const supervisedGate = requiresSupervisedQualityGate(candidateProfile);
+        const selectedByProfile = resolveAutoRoutingProfile(candidateProfile);
+        const escalatedToSupervised = supervisedGate.required && selectedByProfile === "supervised";
+        return {
+            requestedProfile: "auto",
+            selectedByProfile,
+            selectedTemplate: templateForProfile(manifest.workflowPolicy, selectedByProfile),
+            source: escalatedToSupervised
+                ? "supervised-quality-gate"
+                : "workflowPolicy",
+            candidateProfile,
+            routingReasons: supervisedGate.required
+                ? supervisedGate.reasons
+                : undefined,
+        };
+    }
+    return {
+        requestedProfile: parsed.profile,
+        selectedByProfile: parsed.profile,
+        selectedTemplate: templateForProfile(manifest.workflowPolicy, parsed.profile),
+        source: "cli",
+        candidateProfile,
+    };
+}
+export async function runDagRunTask(repoRoot, rawArgs) {
+    const parsed = parseDagRunTaskArgs(rawArgs, repoRoot);
+    const candidateResult = await initHybridDagFromTask(repoRoot, parsed.taskId, {
+        outputPath: parsed.outputPath,
+        template: "standard-dag",
+    });
+    const candidateValidateArgs = buildValidateArgs(candidateResult.outputPath, parsed);
+    const candidateValidateSummary = await captureValidateSummary(repoRoot, candidateValidateArgs);
+    const profileRouting = await resolveProfileRouting(repoRoot, parsed, candidateValidateSummary.governanceProfile ?? {
+        profile: "standard",
+        process: [],
+        delivery: [],
+        codeChange: [],
+        reasons: ["dag run-task validate did not report governanceProfile"],
+    });
+    const initResult = profileRouting.selectedTemplate === "standard-dag"
+        ? candidateResult
+        : await initHybridDagFromTask(repoRoot, parsed.taskId, {
+            outputPath: parsed.outputPath,
+            template: profileRouting.selectedTemplate,
+        });
+    const outputPath = initResult.outputPath;
+    const validateArgs = buildValidateArgs(outputPath, parsed);
+    const validateSummary = profileRouting.selectedTemplate === "standard-dag"
+        ? candidateValidateSummary
+        : await captureValidateSummary(repoRoot, validateArgs);
+    const governanceProfile = validateSummary.governanceProfile ?? {
+        profile: "standard",
+        process: [],
+        delivery: [],
+        codeChange: [],
+        reasons: ["dag run-task validate did not report governanceProfile"],
+    };
+    const reviewPacket = await buildReviewPacket({
+        dagPath: outputPath,
+        profileRouting,
+        governanceProfile,
+    });
+    if (!shouldRunExecution(parsed)) {
+        console.log(JSON.stringify({
+            mode: "generate+validate",
+            ok: true,
+            taskId: initResult.taskId,
+            outputPath,
+            defaultOutputPath: defaultHybridDagOutputPath(parsed.taskId),
+            taskCount: initResult.taskCount,
+            nodeIds: initResult.nodeIds,
+            title: validateSummary.title,
+            ranks: validateSummary.ranks,
+            governanceProfile,
+            profileRouting,
+            reviewPacket,
+            warnings: validateSummary.warnings,
+            next: buildNextSteps(parsed.taskId, outputPath, parsed.cwd),
+        }, null, 2));
+        return;
+    }
+    await assertSafeForExecution(outputPath);
+    const runArgs = buildRunDagArgs(outputPath, parsed);
+    const executionMode = resolveExecutionMode(parsed);
+    let runSummary;
+    const originalLog = console.log;
+    console.log = (message) => {
+        if (typeof message === "string") {
+            runSummary = JSON.parse(message);
+        }
+    };
+    try {
+        await runRunDag(repoRoot, runArgs);
+    }
+    finally {
+        console.log = originalLog;
+    }
+    console.log(JSON.stringify({
+        mode: executionMode,
+        ok: true,
+        taskId: initResult.taskId,
+        outputPath,
+        taskCount: initResult.taskCount,
+        nodeIds: initResult.nodeIds,
+        title: validateSummary.title,
+        ranks: validateSummary.ranks,
+        governanceProfile,
+        profileRouting,
+        reviewPacket,
+        warnings: validateSummary.warnings,
+        run: runSummary,
+    }, null, 2));
+}