@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,912 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { writeTextAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { getTaskPaths } from "../../task/runtime.js";
+import { formatDuration, noopProgressReporter, } from "../progress-reporter.js";
+import { redactForPreview, truncatePreview } from "../observability/events.js";
+import { controllerIdentityExpectationFailure, resolveControllerIdentity, } from "../loop-agent/loop-agent-client.js";
+import { materializeTaskSpecV2, } from "../materialize/harness-task-materializer.js";
+import { preflightTargetRepo } from "../preflight.js";
+import { getTaskPoolRoot } from "../pool/run-store.js";
+import { checkRequiredOutputs } from "../outcomes/gate.js";
+import { projectOutcome } from "../outcomes/projector.js";
+import { writeOutcome } from "../outcomes/store.js";
+/** No outer wall-clock by default; the DAG kernel owns liveness supervision. */
+export const DEFAULT_RUN_DAG_TIMEOUT_MS = 0;
+export const MAX_WORKER_TIMEOUT_MS = 7_200_000;
+export async function runTaskSpec(options) {
+    let controllerIdentity = resolveControllerIdentity(options.client, options.controllerIdentity);
+    const identityFailure = controllerIdentityExpectationFailure(controllerIdentity, options.controllerExpectation);
+    if (identityFailure) {
+        throw new Error(`${identityFailure.code}: ${identityFailure.message}`);
+    }
+    const now = options.now ?? new Date();
+    const workerRunId = options.workerRunId ?? buildWorkerRunId(options.taskSpec.id, now);
+    const commands = [];
+    const progress = options.progress ?? noopProgressReporter;
+    const taskId = options.taskSpec.id;
+    const eventCtx = {
+        progress,
+        workerRunId,
+        taskId,
+        featureId: options.taskSpec.feature_id,
+    };
+    const recordingClient = new RecordingRunTaskClient(options.client, commands);
+    const client = new ObservedRunTaskClient(recordingClient, eventCtx);
+    if (options.preflight !== false) {
+        const preflightStep = "preflight";
+        const preflightStartedAt = Date.now();
+        await runObservedStep(eventCtx, preflightStep, async () => {
+            progress.step("preflight: version + inspect + docs-audit + git-status" +
+                (options.preflight &&
+                    typeof options.preflight === "object" &&
+                    options.preflight.runCheckRepo
+                    ? " + check-repo"
+                    : ""));
+            const preflight = await preflightTargetRepo({
+                repoRoot: options.repoRoot,
+                client,
+                ...(typeof options.preflight === "object" ? options.preflight : {}),
+                ...(options.controllerExpectation
+                    ? { expectation: options.controllerExpectation }
+                    : {}),
+            });
+            if (!preflight.ok) {
+                progress.note(`preflight FAILED: ${preflight.code}`);
+                throw new Error(`target repo preflight failed: ${preflight.code}: ${preflight.message}`);
+            }
+            controllerIdentity = preflight.controllerIdentity ?? controllerIdentity;
+        });
+        progress.step(`preflight ok in ${formatDuration(Date.now() - preflightStartedAt)}`);
+    }
+    const materializeStep = "materialize";
+    const materializeStartedAt = Date.now();
+    const materializeResult = await runObservedStep(eventCtx, materializeStep, async () => {
+        progress.step("materialize harness task");
+        return materializeTaskSpecV2({
+            repoRoot: options.repoRoot,
+            taskSpec: options.taskSpec,
+            taskSpecPath: options.taskSpecPath,
+            client,
+            now,
+        });
+    });
+    const materializeManifest = materializeResult.manifest;
+    const materializeOutcome = materializeResult.outcome;
+    if (materializeOutcome.type === "recovery-required") {
+        throw new Error(`materialize recovery required (${materializeOutcome.recovery.recommendedAction}): ${materializeOutcome.recovery.reason}`);
+    }
+    if (materializeOutcome.type === "resume-existing") {
+        progress.note(`materialize resume-existing: revision ${materializeOutcome.revisionId}, run ${materializeOutcome.runId}`);
+    }
+    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");
+    const canonicalDraftPath = getTaskPaths(options.repoRoot, materializeManifest.harnessTaskId).dagDraftPath;
+    // Standard lifecycle: task advance to writeSet gate (generate + strict validate).
+    const prepareStep = "task-advance-prepare";
+    const prepareStartedAt = Date.now();
+    let gateToken = await runObservedStep(eventCtx, prepareStep, async () => {
+        progress.step("task advance: generate/validate DAG and open writeSet gate");
+        const result = await runRequiredCommand(options.repoRoot, client, "task-advance-prepare", [
+            "task",
+            "advance",
+            materializeManifest.harnessTaskId,
+            "--profile",
+            materializeManifest.loopAgentProfile,
+            "--dag-output",
+            dagPath,
+            "--json",
+        ], true, undefined, eventCtx);
+        return extractWriteSetGateToken(result, materializeManifest.harnessTaskId);
+    });
+    progress.step(`task advance prepare finished in ${formatDuration(Date.now() - prepareStartedAt)}`);
+    if (options.piModel) {
+        const piModelStep = "pi-model-override";
+        await runObservedStep(eventCtx, piModelStep, async () => {
+            progress.step(`pi-model override: rewriting executorModels.pi → ${options.piModel}`);
+            // Rewrite both per-run copy and canonical draft so re-validate sees override.
+            await applyPiModelOverride(canonicalDraftPath, options.piModel);
+            await applyPiModelOverride(dagPath, options.piModel);
+        });
+        // Re-open gate after draft rewrite (digest bound to DAG hash).
+        gateToken = await runObservedStep(eventCtx, "task-advance-revalidate", async () => {
+            progress.step("task advance: re-validate after piModel override (no strict-models)");
+            const result = await runRequiredCommand(options.repoRoot, client, "task-advance-revalidate", [
+                "task",
+                "advance",
+                materializeManifest.harnessTaskId,
+                "--profile",
+                materializeManifest.loopAgentProfile,
+                "--no-strict-models",
+                "--dag-output",
+                dagPath,
+                "--json",
+            ], true, undefined, eventCtx);
+            return extractWriteSetGateToken(result, materializeManifest.harnessTaskId);
+        });
+    }
+    const runAdvanceStep = "task-advance-execute";
+    const runAdvanceStartedAt = Date.now();
+    const dagEventsPath = path.join(getTaskPoolRoot(options.repoRoot), "observability", "runs", workerRunId, "dag-events.jsonl");
+    await mkdir(path.dirname(dagEventsPath), { recursive: true }).catch(() => { });
+    const workerAssociation = JSON.stringify({
+        schemaVersion: 1,
+        workerRunId,
+        featureId: options.taskSpec.feature_id,
+        taskId: options.taskSpec.id,
+    });
+    await runObservedStep(eventCtx, runAdvanceStep, async () => {
+        progress.step("task advance: approve writeSet gate and execute DAG (long step)");
+        const advanceResult = await runTaskAdvanceExecuteWithEventsFallback({
+            repoRoot: options.repoRoot,
+            client,
+            taskId: materializeManifest.harnessTaskId,
+            gateToken,
+            workerRunId,
+            workerAssociation,
+            dagEventsPath,
+            maxConcurrent: options.taskSpec.loop_agent.max_concurrent,
+            timeoutMs: resolveRunDagTimeoutMs(options.taskSpec),
+            eventCtx,
+        });
+        // Terminal DAG failure is still a completed execute step for Worker: report
+        // decision + failure artifacts remain authoritative downstream.
+        if (!advanceResult.ok && !isTerminalTaskAdvanceFailure(advanceResult)) {
+            assertAdvanceExecuteOk(advanceResult, [
+                "task",
+                "advance",
+                materializeManifest.harnessTaskId,
+                "--approve-gate",
+                gateToken,
+            ]);
+        }
+        return advanceResult;
+    });
+    progress.step(`task advance execute finished in ${formatDuration(Date.now() - runAdvanceStartedAt)}`);
+    // Keep per-run DAG artifact aligned with canonical draft after execution prep.
+    await runObservedStep(eventCtx, "publish-per-run-dag-copy", async () => {
+        const dagBytes = await readFile(canonicalDraftPath, "utf-8");
+        await writeTextAtomic(dagPath, dagBytes, {
+            repoRoot: options.repoRoot,
+        });
+    });
+    const reportStep = "report-decision";
+    let capturedReportJson;
+    const reportDecision = await runObservedStep(eventCtx, reportStep, async () => {
+        const reportJson = await client.run([
+            "dag",
+            "report",
+            "--run-id",
+            workerRunId,
+            "--lifecycle",
+            "all",
+            "--json",
+        ], {
+            cwd: options.repoRoot,
+            artifactName: "dag-report-json",
+            expectJson: true,
+        });
+        capturedReportJson = reportJson;
+        const decision = decideFromReport(workerRunId, reportJson);
+        await client.run([
+            "dag",
+            "report",
+            "--run-id",
+            workerRunId,
+            "--lifecycle",
+            "all",
+            "--markdown",
+        ], {
+            cwd: options.repoRoot,
+            artifactName: "dag-report-markdown",
+        });
+        return decision;
+    }, {
+        statusForResult: (decision) => decision.succeeded ? "succeeded" : "failed",
+    });
+    const dagReportRun = extractDagReportRun(workerRunId, capturedReportJson);
+    const declaredArtifacts = options.declaredArtifacts
+        ? options.declaredArtifacts.map((entry) => ({
+            kind: entry.kind,
+            ...(entry.schemaId ? { schemaId: entry.schemaId } : {}),
+            ...(entry.path ? { path: entry.path } : {}),
+        }))
+        : undefined;
+    let 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,
+            eventCtx,
+        });
+    // The outcome adapter reads a canonical worker record. Persist that fact
+    // before gating, but do not promote or close out until the projection passes.
+    const provisionalRecord = {
+        schemaVersion: 1,
+        status,
+        workerRunId,
+        businessId: options.taskSpec.id,
+        harnessTaskId: materializeManifest.harnessTaskId,
+        featureId: options.taskSpec.feature_id,
+        workflow: materializeManifest.workflow,
+        loopAgentProfile: materializeManifest.loopAgentProfile,
+        dagPath,
+        runRecordPath,
+        materializeManifest,
+        materializeOutcome,
+        lineageId: materializeManifest.lineageId,
+        revisionId: materializeManifest.revisionId,
+        reportDecision,
+        commands,
+        ...(declaredArtifacts ? { declaredArtifacts } : {}),
+        ...(failureArtifacts ? { failureArtifacts } : {}),
+        ...(controllerIdentity ? { controllerIdentity } : {}),
+    };
+    await writeFile(runRecordPath, `${JSON.stringify(provisionalRecord, null, 2)}\n`, "utf-8");
+    let outcome;
+    let outcomeFailure;
+    const projection = await projectOutcome({
+        repoRoot: options.repoRoot,
+        workerRunId,
+        taskSpec: options.taskSpec,
+        taskSpecPath: options.taskSpecPath,
+        runRecord: {
+            featureId: options.taskSpec.feature_id,
+            taskId: options.taskSpec.id,
+            workerRunId,
+            harnessTaskId: materializeManifest.harnessTaskId,
+            workflow: materializeManifest.workflow,
+            ...(controllerIdentity ? { controllerIdentity } : {}),
+        },
+        reportDecision,
+        runRecordPath,
+        dagPath,
+        ...(dagReportRun ? { dagReportRun } : {}),
+        ...(declaredArtifacts ? { declaredArtifacts } : {}),
+        acceptanceRefs: options.taskSpec.acceptance_refs,
+        now,
+    });
+    if (!projection.ok) {
+        status = "failed";
+        outcomeFailure = {
+            category: projection.category,
+            reason: projection.reason,
+        };
+        progress.step(`outcome projection failed: ${projection.category} (${projection.reason})`);
+    }
+    else {
+        let envelope = projection.envelope;
+        const gate = checkRequiredOutputs(envelope, options.taskSpec.outputs.required);
+        if (reportDecision.succeeded && !gate.passed) {
+            status = "failed";
+            outcomeFailure = {
+                category: "ContractMismatch",
+                reason: `missing required outputs: ${gate.missing.join(", ")}`,
+            };
+            envelope = {
+                ...envelope,
+                outcomeStatus: "failed",
+                outcomeFailure: {
+                    category: "ContractMismatch",
+                    reason: `missing required outputs: ${gate.missing.join(", ")}`,
+                    missingOutputs: [...gate.missing],
+                },
+            };
+            progress.step(`required output gate failed: ${gate.missing.join(", ")}`);
+        }
+        else if (envelope.outcomeFailure) {
+            outcomeFailure = {
+                category: envelope.outcomeFailure.category,
+                reason: envelope.outcomeFailure.reason,
+            };
+        }
+        // Persist succeeded and failed envelopes so read models can inspect
+        // outcomeFailure without re-parsing run-record / report decision.
+        outcome = await writeOutcome(options.repoRoot, envelope);
+    }
+    if (status === "succeeded" && !options.skipSuccessFinalization) {
+        await runObservedStep(eventCtx, "task-advance-closeout", async () => {
+            progress.step("task advance: promote + closeout");
+            // Lifecycle closeout path; advance is idempotent when run already associated.
+            await runRequiredCommand(options.repoRoot, client, "task-advance-closeout", ["task", "advance", materializeManifest.harnessTaskId, "--json"], true, undefined, eventCtx);
+        });
+    }
+    const record = {
+        schemaVersion: 1,
+        status,
+        workerRunId,
+        businessId: options.taskSpec.id,
+        harnessTaskId: materializeManifest.harnessTaskId,
+        featureId: options.taskSpec.feature_id,
+        workflow: materializeManifest.workflow,
+        loopAgentProfile: materializeManifest.loopAgentProfile,
+        dagPath,
+        runRecordPath,
+        materializeManifest,
+        materializeOutcome,
+        lineageId: materializeManifest.lineageId,
+        revisionId: materializeManifest.revisionId,
+        reportDecision,
+        commands,
+        ...(declaredArtifacts ? { declaredArtifacts } : {}),
+        ...(failureArtifacts ? { failureArtifacts } : {}),
+        ...(controllerIdentity ? { controllerIdentity } : {}),
+    };
+    await writeFile(runRecordPath, `${JSON.stringify(record, null, 2)}\n`, "utf-8");
+    emit(progress, {
+        type: "artifact.written",
+        source: "artifact",
+        label: "worker-run-record",
+        workerRunId,
+        featureId: options.taskSpec.feature_id,
+        taskId,
+        artifactRefs: {
+            runRecordPath,
+            dagPath,
+            ...(failureArtifacts
+                ? {
+                    reportMarkdown: failureArtifacts.reportMarkdownArtifactPath,
+                    doctorMarkdown: failureArtifacts.doctorMarkdownArtifactPath,
+                    closeoutDraft: failureArtifacts.closeoutDraftPath,
+                }
+                : {}),
+        },
+    });
+    return {
+        status,
+        workerRunId,
+        businessId: options.taskSpec.id,
+        harnessTaskId: materializeManifest.harnessTaskId,
+        workflow: materializeManifest.workflow,
+        runRecordPath,
+        dagPath,
+        reportDecision,
+        ...(outcome ? { outcome } : {}),
+        ...(outcomeFailure ? { outcomeFailure } : {}),
+        ...(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, _eventCtx) {
+    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 extractWriteSetGateToken(result, taskId) {
+    const root = result.json;
+    if (!root || typeof root !== "object") {
+        throw new Error(`task advance prepare did not return JSON for ${taskId}; cannot approve writeSet gate`);
+    }
+    const envelope = root;
+    const payload = envelope.result && typeof envelope.result === "object"
+        ? envelope.result
+        : envelope;
+    const gate = payload.gate && typeof payload.gate === "object"
+        ? payload.gate
+        : undefined;
+    const id = typeof gate?.id === "string" ? gate.id : undefined;
+    const digest = typeof gate?.digest === "string" ? gate.digest : undefined;
+    if (!id || !digest) {
+        const lifecycleState = typeof payload.lifecycleState === "string"
+            ? payload.lifecycleState
+            : "unknown";
+        throw new Error(`task advance prepare for ${taskId} did not open a writeSet gate (lifecycleState=${lifecycleState})`);
+    }
+    return `${id}:${digest}`;
+}
+/**
+ * `--events-jsonl` is additive observability. Older published controllers may
+ * reject the flag; retry without it, keeping the same run id / gate digest.
+ */
+function assertAdvanceExecuteOk(result, args) {
+    if (!result.ok && !isTerminalTaskAdvanceFailure(result)) {
+        throw new Error(`loop-agent command failed: ${args.join(" ")}`);
+    }
+}
+function readTaskAdvancePayload(result) {
+    const root = result.json;
+    if (!root || typeof root !== "object")
+        return null;
+    const envelope = root;
+    if (envelope.result && typeof envelope.result === "object") {
+        return envelope.result;
+    }
+    return envelope;
+}
+/**
+ * Terminal DAG failure from `task advance --approve-gate` is an expected
+ * worker path: CLI may return non-zero / outcome=blocked while still writing
+ * a completed run that `dag report` can diagnose.
+ */
+function isTerminalTaskAdvanceFailure(result) {
+    const payload = readTaskAdvancePayload(result);
+    if (!payload)
+        return false;
+    const lifecycleState = typeof payload.lifecycleState === "string" ? payload.lifecycleState : "";
+    if (lifecycleState === "run-failed" ||
+        lifecycleState === "needs-attention" ||
+        lifecycleState === "awaiting-decision") {
+        return true;
+    }
+    const run = payload.run && typeof payload.run === "object"
+        ? payload.run
+        : null;
+    const runStatus = typeof run?.status === "string" ? run.status : "";
+    const runLifecycle = typeof run?.lifecycle === "string" ? run.lifecycle : "";
+    return (runStatus === "failed" ||
+        runStatus === "partial_failed" ||
+        (runLifecycle === "completed" && runStatus !== "finished"));
+}
+async function runTaskAdvanceExecuteWithEventsFallback(input) {
+    const baseArgs = [
+        "task",
+        "advance",
+        input.taskId,
+        "--approve-gate",
+        input.gateToken,
+        "--run-id",
+        input.workerRunId,
+        "--worker-association",
+        input.workerAssociation,
+        "--max-concurrent",
+        String(input.maxConcurrent),
+        "--skip-finalize",
+        "--json",
+    ];
+    const withEvents = [...baseArgs, "--events-jsonl", input.dagEventsPath];
+    const result = await input.client.run(withEvents, {
+        cwd: input.repoRoot,
+        artifactName: "task-advance-execute",
+        expectJson: true,
+        timeoutMs: input.timeoutMs,
+    });
+    if (result.ok || isTerminalTaskAdvanceFailure(result))
+        return result;
+    if (!rejectsEventsJsonl(result)) {
+        assertAdvanceExecuteOk(result, withEvents);
+    }
+    input.eventCtx.progress.note("task advance controller does not support --events-jsonl; retrying without DAG event stream");
+    const fallback = await input.client.run(baseArgs, {
+        cwd: input.repoRoot,
+        artifactName: "task-advance-execute-events-fallback",
+        expectJson: true,
+        timeoutMs: input.timeoutMs,
+    });
+    assertAdvanceExecuteOk(fallback, baseArgs);
+    return fallback;
+}
+function rejectsEventsJsonl(result) {
+    return /unknown (?:run-dag|dag execute|task advance) flag:\s*--events-jsonl|unknown flag --events-jsonl/i.test(`${result.stderr}\n${result.stdout}`);
+}
+function emit(progress, input) {
+    const structured = progress;
+    if (typeof structured.event !== "function")
+        return;
+    void structured.event(input).catch(() => { });
+}
+function emitStepStarted(ctx, stepName) {
+    emit(ctx.progress, {
+        type: "step.started",
+        source: "worker",
+        label: stepName,
+        spanId: `step:${ctx.workerRunId}:${stepName}`,
+        parentSpanId: ctx.workerRunId,
+        workerRunId: ctx.workerRunId,
+        featureId: ctx.featureId,
+        taskId: ctx.taskId,
+        status: "running",
+    });
+}
+function emitStepFinished(ctx, stepName, status, durationMs) {
+    emit(ctx.progress, {
+        type: "step.finished",
+        source: "worker",
+        label: stepName,
+        spanId: `step:${ctx.workerRunId}:${stepName}`,
+        parentSpanId: ctx.workerRunId,
+        workerRunId: ctx.workerRunId,
+        featureId: ctx.featureId,
+        taskId: ctx.taskId,
+        status,
+        durationMs,
+    });
+}
+async function runObservedStep(ctx, stepName, run, options) {
+    const startedAt = Date.now();
+    emitStepStarted(ctx, stepName);
+    try {
+        const result = await run();
+        emitStepFinished(ctx, stepName, options?.statusForResult?.(result) ?? "succeeded", Date.now() - startedAt);
+        return result;
+    }
+    catch (error) {
+        emitStepFinished(ctx, stepName, "failed", Date.now() - startedAt);
+        throw error;
+    }
+}
+/**
+ * Explicit worker.timeout_ms remains an operator hard limit. Omission disables
+ * the Worker wall clock so the DAG kernel can supervise active nodes.
+ */
+function resolveRunDagTimeoutMs(taskSpec) {
+    return taskSpec.worker.timeout_ms === undefined
+        ? DEFAULT_RUN_DAG_TIMEOUT_MS
+        : Math.min(taskSpec.worker.timeout_ms, MAX_WORKER_TIMEOUT_MS);
+}
+async function collectFailureArtifacts(input) {
+    const doctor = await runObservedStep(input.eventCtx, "dag-doctor", () => input.client.run(["dag", "doctor", "--run-id", input.workerRunId, "--markdown"], {
+        cwd: input.repoRoot,
+        artifactName: "dag-doctor-markdown",
+    }), { statusForResult: (result) => (result.ok ? "succeeded" : "failed") });
+    const failureHandoffRoot = path.resolve(getTaskPoolRoot(input.repoRoot), "failure-handoffs");
+    const closeoutDraftPath = path.resolve(failureHandoffRoot, `${input.workerRunId}-failure-closeout-draft.md`);
+    if (!isPathInside(failureHandoffRoot, closeoutDraftPath)) {
+        throw new Error("closeout draft output must be under .harness/task-pool/failure-handoffs/");
+    }
+    await runObservedStep(input.eventCtx, "closeout-draft", () => input.client.run([
+        "dag",
+        "closeout-draft",
+        "--run-id",
+        input.workerRunId,
+        "--output",
+        closeoutDraftPath,
+    ], {
+        cwd: input.repoRoot,
+        artifactName: "dag-closeout-draft",
+    }), { statusForResult: (result) => (result.ok ? "succeeded" : "failed") });
+    const reportMarkdown = input.client instanceof ObservedRunTaskClient ||
+        input.client instanceof RecordingRunTaskClient
+        ? input.client.findArtifact("dag-report-markdown")
+        : undefined;
+    return {
+        reportMarkdownArtifactPath: reportMarkdown?.result.artifacts.stdoutPath ?? "",
+        doctorMarkdownArtifactPath: doctor.artifacts.stdoutPath,
+        closeoutDraftPath,
+    };
+}
+function isPathInside(root, target) {
+    const relative = path.relative(root, target);
+    return (relative !== "" &&
+        relative !== ".." &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative));
+}
+/** Exported for unit tests: map DAG report JSON into Worker report decision. */
+export 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");
+    // Condition-branch SKIPPED nodes are expected on green backend-test / hybrid
+    // paths (e.g. revise/repair not selected). Do not treat SKIPPED as failure.
+    // ERROR and non-success failureCategory on executed nodes still fail closed.
+    const failedNode = nodes.find((node) => {
+        const status = readString(node, "status");
+        const failureCategory = readString(node, "failureCategory");
+        if (status === "SKIPPED") {
+            return false;
+        }
+        return (status === "ERROR" ||
+            (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"),
+    };
+}
+/**
+ * Extract the canonical DAG report run fact used by Outcome adapters for
+ * structured artifact projection. Returns undefined when the report is missing
+ * or does not contain the worker run — adapters then project only canonical
+ * runtime artifacts (fail-closed for domain structured kinds).
+ */
+function extractDagReportRun(workerRunId, result) {
+    if (!result?.ok || !result.json)
+        return undefined;
+    const runs = readObjectArray(result.json, "runs");
+    const run = runs.find((candidate) => readString(candidate, "runId") === workerRunId) ??
+        runs[0];
+    if (!run)
+        return undefined;
+    const nodes = readObjectArray(run, "nodes").map((node) => ({
+        ...(readString(node, "nodeId") || readString(node, "id")
+            ? { id: readString(node, "nodeId") ?? readString(node, "id") }
+            : {}),
+        ...(readString(node, "status")
+            ? { status: readString(node, "status") }
+            : {}),
+        ...(readString(node, "failureCategory")
+            ? { failureCategory: readString(node, "failureCategory") }
+            : {}),
+        ...(readString(node, "stdoutArtifactPath")
+            ? { stdoutArtifactPath: readString(node, "stdoutArtifactPath") }
+            : {}),
+        ...(readString(node, "assistantArtifactPath")
+            ? { assistantArtifactPath: readString(node, "assistantArtifactPath") }
+            : {}),
+        ...(readString(node, "structuredArtifactPath")
+            ? { structuredArtifactPath: readString(node, "structuredArtifactPath") }
+            : {}),
+        ...(readString(node, "structuredArtifactSha256")
+            ? {
+                structuredArtifactSha256: readString(node, "structuredArtifactSha256"),
+            }
+            : {}),
+        ...(readString(node, "structuredArtifactSchemaId")
+            ? {
+                structuredArtifactSchemaId: readString(node, "structuredArtifactSchemaId"),
+            }
+            : {}),
+    }));
+    return {
+        ...(readString(run, "runId") ? { runId: readString(run, "runId") } : {}),
+        ...(readString(run, "status") ? { status: readString(run, "status") } : {}),
+        nodes,
+    };
+}
+class RecordingRunTaskClient {
+    delegate;
+    records;
+    constructor(delegate, records) {
+        this.delegate = delegate;
+        this.records = records;
+    }
+    getIdentity() {
+        return this.delegate.getIdentity?.();
+    }
+    observeReportedVersion(reportedVersion) {
+        return this.delegate.observeReportedVersion?.(reportedVersion);
+    }
+    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);
+    }
+}
+class ObservedRunTaskClient {
+    delegate;
+    eventCtx;
+    constructor(delegate, eventCtx) {
+        this.delegate = delegate;
+        this.eventCtx = eventCtx;
+    }
+    getIdentity() {
+        return this.delegate.getIdentity();
+    }
+    observeReportedVersion(reportedVersion) {
+        return this.delegate.observeReportedVersion(reportedVersion);
+    }
+    run(args, options) {
+        return this.runObserved(args, options, (observedOptions) => this.delegate.run(args, observedOptions));
+    }
+    runExternal(command, args, options) {
+        return this.runObserved([command, ...args], options, (observedOptions) => this.delegate.runExternal(command, args, observedOptions));
+    }
+    findArtifact(artifactName) {
+        return this.delegate.findArtifact(artifactName);
+    }
+    async runObserved(command, options, run) {
+        const observedOptions = {
+            ...options,
+            onSpawn: (info) => {
+                options.onSpawn?.(info);
+                emit(this.eventCtx.progress, {
+                    type: "command.started",
+                    source: "loop-agent-command",
+                    label: options.artifactName,
+                    workerRunId: this.eventCtx.workerRunId,
+                    featureId: this.eventCtx.featureId,
+                    taskId: this.eventCtx.taskId,
+                    pid: info.pid,
+                    timeoutMs: options.timeoutMs,
+                    command,
+                    artifactRefs: info.artifactRefs,
+                    status: "running",
+                });
+            },
+            onStdout: (chunk) => {
+                options.onStdout?.(chunk);
+                this.emitOutput(options.artifactName, chunk);
+            },
+            onStderr: (chunk) => {
+                options.onStderr?.(chunk);
+                this.emitOutput(options.artifactName, chunk);
+            },
+            onHeartbeat: (info) => {
+                options.onHeartbeat?.(info);
+                emit(this.eventCtx.progress, {
+                    type: "command.heartbeat",
+                    source: "loop-agent-command",
+                    label: options.artifactName,
+                    workerRunId: this.eventCtx.workerRunId,
+                    featureId: this.eventCtx.featureId,
+                    taskId: this.eventCtx.taskId,
+                    message: `elapsed ${info.elapsedMs}ms`,
+                });
+            },
+        };
+        try {
+            const result = await run(observedOptions);
+            emit(this.eventCtx.progress, {
+                type: "command.finished",
+                source: "loop-agent-command",
+                label: options.artifactName,
+                workerRunId: this.eventCtx.workerRunId,
+                featureId: this.eventCtx.featureId,
+                taskId: this.eventCtx.taskId,
+                exitCode: result.exitCode,
+                timedOut: result.timedOut,
+                durationMs: result.durationMs,
+                artifactRefs: result.artifacts,
+                status: result.ok ? "succeeded" : "failed",
+            });
+            return result;
+        }
+        catch (error) {
+            emit(this.eventCtx.progress, {
+                type: "command.finished",
+                source: "loop-agent-command",
+                label: options.artifactName,
+                workerRunId: this.eventCtx.workerRunId,
+                featureId: this.eventCtx.featureId,
+                taskId: this.eventCtx.taskId,
+                status: "failed",
+                message: errorMessage(error),
+            });
+            throw error;
+        }
+    }
+    emitOutput(label, chunk) {
+        emit(this.eventCtx.progress, {
+            type: "command.output",
+            source: "loop-agent-command",
+            label,
+            workerRunId: this.eventCtx.workerRunId,
+            featureId: this.eventCtx.featureId,
+            taskId: this.eventCtx.taskId,
+            outputPreview: redactForPreview(truncatePreview(chunk)),
+        });
+    }
+}
+function commandRecordName(args, artifactName) {
+    if (args[0] === "new-task")
+        return "new-task";
+    if (args[0] === "task" && args[1] === "advance") {
+        return artifactName.startsWith("task-advance-")
+            ? artifactName
+            : "task-advance";
+    }
+    return artifactName;
+}
+/**
+ * Rewrite `executorModels.pi.{LOW,MED,HIGH}` in an already-generated DAG JSON
+ * so every pi executor node resolves to the smoke override model.
+ */
+export async function applyPiModelOverride(dagPath, piModel) {
+    const raw = await readFile(dagPath, "utf-8");
+    let spec;
+    try {
+        spec = JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid generated DAG JSON at ${dagPath}: ${message}`);
+    }
+    spec.executorModels = {
+        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];
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}