@tea-agent/loop-agent 0.1.0 → 0.2.1

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

@@ -0,0 +1,280 @@
+import { readFile } from "node:fs/promises";
+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 { validateDagUseCase } from "./validate-dag.js";
+import { runDagUseCase } from "./run-dag.js";
+const PLACEHOLDER_WRITESET_MARKER = "REPLACE/WITH";
+function buildValidateInput(repoRoot, dagPath, parsed) {
+    return {
+        repoRoot,
+        dagPath,
+        strictModelMatrix: parsed.strictModels,
+        strictGovernance: false,
+        forbidExecutors: parsed.noCursor ? ["cursor"] : [],
+    };
+}
+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("; ")}`);
+}
+function buildNextSteps(taskId, outputPath, cwd) {
+    return [
+        `Review ${outputPath}`,
+        `loop-agent dag validate --dag ${outputPath} --strict-models --strict-governance`,
+        `loop-agent run-dag --dag ${outputPath} --cwd ${cwd}`,
+        `loop-agent dag run-task ${taskId} --execute --cwd ${cwd}`,
+    ];
+}
+function isBroadWriteSetEntryForPacket(entry) {
+    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 generateTaskDagUseCase(input) {
+    const { repoRoot, ...parsed } = input;
+    const candidateResult = await initHybridDagFromTask(repoRoot, parsed.taskId, {
+        outputPath: parsed.outputPath,
+        template: "standard-dag",
+    });
+    const candidateValidateSummary = await validateDagUseCase(buildValidateInput(repoRoot, candidateResult.outputPath, parsed));
+    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 validateSummary = profileRouting.selectedTemplate === "standard-dag"
+        ? candidateValidateSummary
+        : await validateDagUseCase(buildValidateInput(repoRoot, outputPath, parsed));
+    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)) {
+        return {
+            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),
+        };
+    }
+    await assertSafeForExecution(outputPath);
+    const runSummary = await runDagUseCase({
+        repoRoot,
+        dagPath: outputPath,
+        cwd: parsed.cwd,
+        initOnly: parsed.initOnly,
+        dryRun: parsed.dryRun,
+        maxConcurrent: parsed.maxConcurrent,
+        runId: parsed.runId,
+        noCursor: parsed.noCursor,
+        canvasPath: parsed.canvasPath,
+        canvasName: parsed.canvasName,
+        canvasesDir: parsed.canvasesDir,
+    });
+    return {
+        mode: resolveExecutionMode(parsed),
+        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,
+    };
+}

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

@@ -0,0 +1,14 @@
+import { buildDagReport, serializeDagReportJson, } from "../../workflows/dag/report.js";
+export async function reportDagUseCase(input) {
+    return buildDagReport({
+        repoRoot: input.repoRoot,
+        runId: input.runId,
+        lifecycle: input.lifecycle,
+        failedOnly: input.failedOnly,
+        latest: input.latest,
+        action: input.action,
+    });
+}
+export function serializeReportDagJson(report) {
+    return serializeDagReportJson(report);
+}

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

@@ -0,0 +1,106 @@
+import { readFile } from "node:fs/promises";
+import { createDagCanvasObserver, resolveCanvasPath, } from "../../workflows/dag/canvas-observer.js";
+import { loadDagSpecFromFile, runDag } from "../../workflows/dag/runner.js";
+import { assertValidDagSpec, collectForbiddenExecutorIssues, } from "../../workflows/dag/validate.js";
+async function loadRawTaskExecutorMap(dagPath) {
+    const raw = JSON.parse(await readFile(dagPath, "utf-8"));
+    const map = new Map();
+    for (const task of raw.tasks ?? []) {
+        if (typeof task.id === "string")
+            map.set(task.id, task.executor);
+    }
+    return map;
+}
+function assertNoCursorTasks(spec, rawTaskExecutors) {
+    const issues = collectForbiddenExecutorIssues(spec, ["cursor"]);
+    if (issues.length === 0)
+        return;
+    const details = issues
+        .map((issue) => {
+        const implicitDefault = rawTaskExecutors.get(issue.taskId) === undefined;
+        return `task=${issue.taskId}${implicitDefault ? " (implicit cursor default)" : ""}`;
+    })
+        .join("; ");
+    throw new Error(`--no-cursor forbids cursor executor tasks: ${details}`);
+}
+function getCanvasFlushErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function flushCanvasSafely(canvas) {
+    if (!canvas)
+        return undefined;
+    try {
+        await canvas.flush();
+        return undefined;
+    }
+    catch (error) {
+        // Canvas is a derived view; failed writes must not decide canonical DAG success.
+        return getCanvasFlushErrorMessage(error);
+    }
+}
+function buildRunDagNextSteps(runId) {
+    return [
+        `loop-agent dag report --run-id ${runId} --markdown`,
+        `loop-agent dag doctor --run-id ${runId} --markdown`,
+        `loop-agent promote-run <task-id> --run-id ${runId}`,
+        `loop-agent dag closeout-draft --run-id ${runId}`,
+    ];
+}
+export async function runDagUseCase(input) {
+    const spec = await loadDagSpecFromFile(input.dagPath);
+    if (input.noCursor) {
+        const rawTaskExecutors = await loadRawTaskExecutorMap(input.dagPath);
+        assertNoCursorTasks(spec, rawTaskExecutors);
+    }
+    assertValidDagSpec(spec);
+    const resolvedCanvasPath = resolveCanvasPath({
+        canvasPath: input.canvasPath,
+        canvasName: input.canvasName,
+        canvasesDir: input.canvasesDir,
+        cwd: input.cwd,
+    });
+    const canvas = resolvedCanvasPath
+        ? createDagCanvasObserver({ canvasPath: resolvedCanvasPath, spec })
+        : undefined;
+    if (input.dryRun) {
+        const summary = await runDag(spec, {
+            cwd: input.cwd,
+            dryRun: true,
+            runId: input.runId,
+            observer: canvas?.observer,
+        });
+        const canvasError = await flushCanvasSafely(canvas);
+        return {
+            mode: "dry-run",
+            title: spec.title,
+            taskCount: spec.tasks.length,
+            ranks: summary.ranks,
+            runId: summary.runId,
+            runDir: summary.runDir,
+            next: buildRunDagNextSteps(summary.runId),
+            ...(resolvedCanvasPath ? { canvasPath: resolvedCanvasPath } : {}),
+            ...(canvasError ? { canvasError } : {}),
+        };
+    }
+    const summary = await runDag(spec, {
+        cwd: input.cwd,
+        initOnly: input.initOnly,
+        dryRun: false,
+        maxConcurrent: input.maxConcurrent,
+        runId: input.runId,
+        observer: canvas?.observer,
+    });
+    const canvasError = await flushCanvasSafely(canvas);
+    if (resolvedCanvasPath) {
+        return {
+            ...summary,
+            next: buildRunDagNextSteps(summary.runId),
+            canvasPath: resolvedCanvasPath,
+            ...(canvasError ? { canvasError } : {}),
+        };
+    }
+    return {
+        ...summary,
+        next: buildRunDagNextSteps(summary.runId),
+    };
+}

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

@@ -0,0 +1,102 @@
+import { readFile } from "node:fs/promises";
+import { loadDagSpecFromFile } from "../../workflows/dag/runner.js";
+import { assertValidDagSpec, collectExecutorModelWarnings, collectForbiddenExecutorIssues, collectGovernanceWarnings, validateDagSpec, } from "../../workflows/dag/validate.js";
+import { inferGovernanceProfile } from "../../workflows/dag/governance-profile.js";
+import { topoSortToRanks } from "../../workflows/dag/topo.js";
+import { runSpineAudit } from "../../governance/spine-audit.js";
+function formatModelMatrixWarnings(warnings) {
+    return warnings.map((warning) => ({
+        executor: warning.executor,
+        complexity: warning.complexity,
+        expected: warning.expected,
+        actual: warning.actual,
+    }));
+}
+function formatGovernanceWarnings(warnings) {
+    return warnings.map((warning) => ({
+        type: warning.type,
+        message: warning.message,
+    }));
+}
+function ensureStrictModelMatrix(warnings) {
+    if (warnings.length === 0) {
+        return;
+    }
+    const details = warnings
+        .map((entry) => `executor=${entry.executor}, complexity=${entry.complexity}, expected=${entry.expected}, actual=${entry.actual}`)
+        .join("; ");
+    throw new Error(`non-canonical executorModels overrides are blocked by --strict-models: ${details}`);
+}
+async function loadRawTaskExecutorMap(dagPath) {
+    const raw = JSON.parse(await readFile(dagPath, "utf-8"));
+    const map = new Map();
+    for (const task of raw.tasks ?? []) {
+        if (typeof task.id === "string")
+            map.set(task.id, task.executor);
+    }
+    return map;
+}
+function ensureNoForbiddenExecutors(spec, forbidExecutors, rawTaskExecutors) {
+    const supported = new Set(["cursor", "pi", "shell", "static"]);
+    const normalized = forbidExecutors.map((executor) => {
+        if (!supported.has(executor)) {
+            throw new Error(`unsupported executor for --forbid-executor: ${executor}`);
+        }
+        return executor;
+    });
+    const issues = collectForbiddenExecutorIssues(spec, normalized);
+    if (issues.length === 0)
+        return;
+    const details = issues
+        .map((issue) => {
+        const implicitDefault = rawTaskExecutors.get(issue.taskId) === undefined;
+        return `task=${issue.taskId}, executor=${issue.executor}${implicitDefault ? " (implicit default)" : ""}`;
+    })
+        .join("; ");
+    throw new Error(`forbidden executor present: ${details}`);
+}
+export async function validateDagUseCase(input) {
+    const spec = await loadDagSpecFromFile(input.dagPath);
+    const rawTaskExecutors = await loadRawTaskExecutorMap(input.dagPath);
+    ensureNoForbiddenExecutors(spec, input.forbidExecutors, rawTaskExecutors);
+    const validationIssues = validateDagSpec(spec);
+    const warnings = collectExecutorModelWarnings(spec);
+    const governanceWarnings = collectGovernanceWarnings(validationIssues);
+    if (input.strictModelMatrix) {
+        ensureStrictModelMatrix(warnings);
+    }
+    const spineAudit = input.spineTaskId
+        ? await runSpineAudit(input.repoRoot, input.spineTaskId)
+        : undefined;
+    if (input.strictGovernance && spineAudit && !spineAudit.ok) {
+        throw new Error(`minimal spec spine audit failed for ${input.spineTaskId}: ${spineAudit.findings
+            .filter((finding) => finding.severity === "error")
+            .map((finding) => `${finding.type}: ${finding.message}`)
+            .join("; ")}`);
+    }
+    assertValidDagSpec(spec, {
+        issues: validationIssues,
+        strictGovernance: input.strictGovernance,
+    });
+    const { ranks } = topoSortToRanks(spec);
+    const governanceProfile = inferGovernanceProfile(spec);
+    return {
+        title: spec.title,
+        taskCount: spec.tasks.length,
+        ranks,
+        governanceProfile,
+        spineAudit: spineAudit
+            ? {
+                ok: spineAudit.ok,
+                taskId: spineAudit.taskId,
+                findings: spineAudit.findings,
+                verifyCommandLabels: spineAudit.verifyCommandLabels,
+            }
+            : undefined,
+        warnings: [
+            ...formatModelMatrixWarnings(warnings),
+            ...formatGovernanceWarnings(governanceWarnings),
+        ],
+        next: [`loop-agent run-dag --dag ${input.dagPath} --cwd ${input.repoRoot}`],
+    };
+}

package/dist/application/loop/run-action.js

@@ -0,0 +1,23 @@
+import { runLoopCursorFix } from "../../workflows/loop/actions/cursor-fix.js";
+import { runLoopDagAction } from "../../workflows/loop/actions/dag-action.js";
+import { runLoopPiReview } from "../../workflows/loop/actions/pi-review.js";
+import { runLoopShellVerification, } from "../../workflows/loop/actions/shell-verify.js";
+import { runLoopWorkflowAction, runLoopWorkflowGateSignalAction, } from "../../workflows/loop/actions/workflow-action.js";
+export async function runLoopAction(input) {
+    if (input.action === "shell-verify") {
+        return runLoopShellVerification(input.repoRoot, input.taskId, input.options);
+    }
+    if (input.action === "pi-review") {
+        return runLoopPiReview(input.repoRoot, input.taskId, input.options);
+    }
+    if (input.action === "cursor-fix") {
+        return runLoopCursorFix(input.repoRoot, input.taskId, input.options);
+    }
+    if (input.action === "dag") {
+        return runLoopDagAction(input.repoRoot, input.taskId, input.options);
+    }
+    if (input.action === "workflow") {
+        return runLoopWorkflowAction(input.repoRoot, input.taskId, input.options);
+    }
+    return runLoopWorkflowGateSignalAction(input.repoRoot, input.taskId, input.options?.signals);
+}