@tea-agent/loop-agent 0.1.0 → 0.2.1

package/dist/cli/router.js

@@ -0,0 +1,13 @@
+import { buildUnsupportedCommandMessage } from "./help.js";
+import { COMMAND_DEFINITIONS, } from "./command-definitions.js";
+export function resolveCliCommandHandler(command) {
+    return COMMAND_DEFINITIONS.find((definition) => definition.name === command)
+        ?.handler;
+}
+export async function dispatchCliCommand(ctx) {
+    const handler = resolveCliCommandHandler(ctx.command);
+    if (!handler) {
+        throw new Error(buildUnsupportedCommandMessage(ctx.command, ctx.subcommand));
+    }
+    await handler(ctx);
+}

package/dist/cli-governance/active-residue-check.js

@@ -0,0 +1,38 @@
+import { readFileSync } from "node:fs";
+import { evaluateActiveResidue, formatActiveResidueFinding, shouldFailActiveResidue, } from "../infrastructure/harness/active-residue-policy.js";
+function readEntriesFile(filePath) {
+    const raw = readFileSync(filePath, "utf-8");
+    return raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function getRequiredFlag(args, flag) {
+    const index = args.indexOf(flag);
+    const value = index >= 0 ? args[index + 1] : undefined;
+    if (!value) {
+        throw new Error(`missing required flag: ${flag}`);
+    }
+    return value;
+}
+function main(rawArgs, env) {
+    const dagEntriesFile = getRequiredFlag(rawArgs, "--dag-entries-file");
+    const toolEntriesFile = getRequiredFlag(rawArgs, "--tool-entries-file");
+    const findings = evaluateActiveResidue({
+        dagActiveEntries: readEntriesFile(dagEntriesFile),
+        toolActiveEntries: readEntriesFile(toolEntriesFile),
+    });
+    for (const finding of findings) {
+        if (env[finding.allowEnv] === "1")
+            continue;
+        process.stderr.write(formatActiveResidueFinding(finding));
+    }
+    return shouldFailActiveResidue(findings, env).fail ? 1 : 0;
+}
+try {
+    process.exitCode = main(process.argv.slice(2), process.env);
+}
+catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+}

package/dist/commands/dag-report.js

@@ -1,113 +1,12 @@
 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,
-    };
-}
+import { buildDagCloseoutDraft, formatDagReportHandoffMarkdown, formatDagReportMarkdown, } from "../workflows/dag/report.js";
+import { parseDagReportArgs, } from "../application/dag/args.js";
+import { reportDagUseCase, serializeReportDagJson, } from "../application/dag/report-dag.js";
+export { parseDagReportArgs };
 export async function runDagReport(repoRoot, rawArgs) {
     const parsed = parseDagReportArgs(rawArgs);
-    const report = await buildDagReport({
+    const report = await reportDagUseCase({
         repoRoot,
         runId: parsed.runId,
         lifecycle: parsed.lifecycle,
@@ -116,7 +15,7 @@ export async function runDagReport(repoRoot, rawArgs) {
         action: parsed.action,
     });
     if (parsed.json) {
-        console.log(JSON.stringify(serializeDagReportJson(report), null, 2));
+        console.log(JSON.stringify(serializeReportDagJson(report), null, 2));
         return;
     }
     if (parsed.markdown) {

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

@@ -1,470 +1,12 @@
-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,
-    };
-}
+import { assertSafeForExecution, generateTaskDagUseCase, } from "../application/dag/generate-task-dag.js";
+import { parseDagRunTaskArgs, } from "../application/dag/args.js";
+export { assertSafeForExecution };
+export { parseDagRunTaskArgs };
 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,
+    const result = await generateTaskDagUseCase({
+        repoRoot,
+        ...parsed,
     });
-    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));
+    console.log(JSON.stringify(result, null, 2));
 }