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

package/dist/worker/loop-agent/loop-agent-client.js

@@ -0,0 +1,489 @@
+import { spawn } from "node:child_process";
+import { appendFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { computeBinarySha256, computePackageFingerprint, findPackageRoot, isJavaScriptScript, normalizeCliVersionLabel, readPackageName, readPackageVersion, resolveBinPaths, resolveCmdShim, } from "../../shared/package-metadata.js";
+import { parseCommandJson } from "./parse-json.js";
+export const DEFAULT_WORKER_COMMAND_TIMEOUT_MS = 120_000;
+export const DEFAULT_HEARTBEAT_INTERVAL_MS = 15_000;
+export const LOOP_AGENT_PACKAGE_NAME = "@tea-agent/loop-agent";
+/** Grace window between the SIGTERM and SIGKILL stages of a hard timeout, so a
+ * runner can persist terminal state (see executeDagCheckpoint) before being
+ * force-killed. */
+export const HARD_TIMEOUT_KILL_GRACE_MS = 10_000;
+const MAX_BUFFERED_OUTPUT_BYTES = 64 * 1024;
+/**
+ * Bind evidence supplied by an orchestration layer to the identity exposed by
+ * the client that will actually launch commands. When the client exposes an
+ * identity, it is authoritative; observational fields such as reportedVersion
+ * must come from the real preflight probe rather than caller-supplied evidence.
+ */
+export function resolveControllerIdentity(client, provided) {
+    const actual = client?.getIdentity?.();
+    if (actual && provided && !controllerIdentitiesMatch(actual, provided)) {
+        throw new Error("controller identity: provided evidence does not match the command client's pinned identity");
+    }
+    return actual ?? provided;
+}
+export function controllerIdentitiesMatch(left, right) {
+    return Boolean(left && right && identityAnchor(left) === identityAnchor(right));
+}
+/** Pure in-memory expectation gate. It performs no command or filesystem write. */
+export function controllerIdentityExpectationFailure(identity, expectation) {
+    if (!expectation)
+        return undefined;
+    if (!identity) {
+        return {
+            code: "identity-unavailable",
+            message: "controller identity expectation was set but no pinned identity is available",
+        };
+    }
+    if (expectation.expectedVersion
+        && identity.packageVersion !== expectation.expectedVersion) {
+        return {
+            code: "expected-version-mismatch",
+            message: `expected controller version ${expectation.expectedVersion}, got package version ${identity.packageVersion}`,
+        };
+    }
+    if (expectation.expectedFingerprint
+        && identity.packageFingerprint.value !== expectation.expectedFingerprint) {
+        return {
+            code: "identity-fingerprint-mismatch",
+            message: `expected controller fingerprint ${expectation.expectedFingerprint}, got ${identity.packageFingerprint.value}`,
+        };
+    }
+    return undefined;
+}
+export class LoopAgentClient {
+    loopAgentBin;
+    baseArgs;
+    artifactRoot;
+    defaultTimeoutMs;
+    heartbeatIntervalMs;
+    env;
+    resolutionInputs;
+    identityRequired;
+    _identity;
+    _identityResolved = false;
+    constructor(options) {
+        this.loopAgentBin = options.loopAgentBin;
+        this.baseArgs = options.baseArgs ?? [];
+        this.artifactRoot = options.artifactRoot;
+        this.defaultTimeoutMs =
+            options.defaultTimeoutMs ?? DEFAULT_WORKER_COMMAND_TIMEOUT_MS;
+        this.heartbeatIntervalMs =
+            options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+        this.env = options.env;
+        this.resolutionInputs = options.resolutionInputs;
+        this.identityRequired = options.resolveIdentity === true;
+        if (this.identityRequired)
+            this.resolveIdentity();
+    }
+    /**
+     * Resolve and freeze the controller identity.
+     */
+    resolveIdentity() {
+        if (this._identityResolved) {
+            if (!this._identity) {
+                throw new Error("controller identity: required identity resolution did not produce an identity");
+            }
+            return this._identity;
+        }
+        const resolvedAt = new Date().toISOString();
+        const resolved = resolveBinPaths(this.loopAgentBin, resolvedAt, this.resolutionInputs);
+        // Detect npm Windows .cmd shim and resolve to the actual JS script
+        let actualEntry = resolved.realEntry;
+        const isWin = this.resolutionInputs?.platform === "win32" || process.platform === "win32";
+        if (isWin) {
+            const lower = actualEntry.toLowerCase();
+            if (lower.endsWith(".cmd") || lower.endsWith(".bat")) {
+                const resolvedScript = resolveCmdShim(actualEntry);
+                if (resolvedScript) {
+                    actualEntry = resolvedScript;
+                }
+                else {
+                    throw new Error(`controller identity: cannot resolve npm .cmd shim: ${resolved.entry}`);
+                }
+            }
+        }
+        // Detect "running from source" pattern: loopAgentBin is a Node
+        // executable and baseArgs points to a script. In this case,
+        // actualEntry must be the script, not the Node binary.
+        const sourceScript = findSourceScript(this.baseArgs, this.resolutionInputs?.cwd ?? process.cwd());
+        if (sourceScript) {
+            actualEntry = sourceScript.path;
+        }
+        // Validate the entry file is readable
+        try {
+            const s = statSync(actualEntry);
+            if (!s.isFile())
+                throw new Error(`not a file: ${actualEntry}`);
+        }
+        catch {
+            throw new Error(`controller identity: bin entry is not readable: ${actualEntry}`);
+        }
+        const packageRoot = findPackageRoot(path.dirname(actualEntry));
+        if (!packageRoot) {
+            throw new Error(`controller identity: cannot locate package root for ${actualEntry}`);
+        }
+        const packageName = readPackageName(packageRoot);
+        if (!packageName) {
+            throw new Error(`controller identity: package.json at ${packageRoot} is missing a "name" field`);
+        }
+        if (packageName !== LOOP_AGENT_PACKAGE_NAME) {
+            throw new Error(`controller identity: unexpected package name ${JSON.stringify(packageName)} at ${packageRoot}; expected ${JSON.stringify(LOOP_AGENT_PACKAGE_NAME)}`);
+        }
+        const pkgVersion = readPackageVersion(packageRoot);
+        if (!pkgVersion) {
+            throw new Error(`controller identity: package.json at ${packageRoot} is missing a "version" field`);
+        }
+        const binarySha256 = computeBinarySha256(actualEntry);
+        if (!binarySha256) {
+            throw new Error(`controller identity: cannot read binary for hashing: ${actualEntry}`);
+        }
+        // Determine launch command and argsPrefix
+        let launchCommand;
+        let launchArgsPrefix;
+        if (sourceScript) {
+            launchCommand = resolveNodeBinary(this.loopAgentBin, resolvedAt, this.resolutionInputs);
+            launchArgsPrefix = [...this.baseArgs];
+            launchArgsPrefix[sourceScript.index] = sourceScript.path;
+        }
+        else if (isJavaScriptScript(actualEntry)) {
+            launchCommand = frozenNodeExecutable();
+            launchArgsPrefix = [actualEntry, ...this.baseArgs];
+        }
+        else {
+            launchCommand = actualEntry;
+            launchArgsPrefix = [...this.baseArgs];
+        }
+        const identity = {
+            schemaVersion: 1,
+            packageName,
+            binName: path.basename(actualEntry),
+            requested: this.loopAgentBin,
+            entry: resolved.entry,
+            realEntry: actualEntry,
+            launch: { command: launchCommand, argsPrefix: launchArgsPrefix },
+            binarySha256,
+            packageRoot,
+            packageVersion: pkgVersion,
+            packageFingerprint: computePackageFingerprint(packageRoot),
+            resolvedAt,
+        };
+        this._identity = identity;
+        this._identityResolved = true;
+        return identity;
+    }
+    getIdentity() {
+        return this._identity;
+    }
+    observeReportedVersion(reportedVersion) {
+        if (!this._identity) {
+            throw new Error("controller identity: cannot record a reported version without a pinned identity");
+        }
+        const normalized = normalizeCliVersionLabel(reportedVersion);
+        if (normalized !== this._identity.packageVersion) {
+            throw new Error(`controller identity: reported version ${reportedVersion} does not match package version ${this._identity.packageVersion}`);
+        }
+        this._identity = { ...this._identity, reportedVersion: normalized };
+        return this._identity;
+    }
+    async run(args, options) {
+        if (this._identity) {
+            assertControllerIdentityUnchangedBeforeSpawn(this._identity);
+            const launch = this._identity.launch;
+            const fullArgs = [...launch.argsPrefix, ...args];
+            return this.runCommand(launch.command, fullArgs, args, options, () => assertControllerIdentityUnchangedBeforeSpawn(this._identity));
+        }
+        if (this.identityRequired || this._identityResolved) {
+            throw new Error("controller identity: pinned launch is unavailable");
+        }
+        return this.runCommand(this.loopAgentBin, [...this.baseArgs, ...args], args, options);
+    }
+    async runExternal(command, args, options) {
+        return this.runCommand(command, args, args, options);
+    }
+    async runCommand(command, commandArgs, resultArgs, options, beforeSpawn) {
+        const startedAt = Date.now();
+        const artifactDir = path.join(this.artifactRoot, sanitizeName(options.artifactName));
+        await mkdir(artifactDir, { recursive: true });
+        const stdoutPath = path.join(artifactDir, "stdout.txt");
+        const stderrPath = path.join(artifactDir, "stderr.txt");
+        const resultPath = path.join(artifactDir, "result.json");
+        const configuredTimeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
+        const { stdout, stdoutBytes, stdoutTruncated, stderr, stderrBytes, stderrTruncated, exitCode, timedOut, } = await spawnCommand({
+            command,
+            args: commandArgs,
+            cwd: options.cwd,
+            hardTimeoutMs: configuredTimeoutMs > 0 ? configuredTimeoutMs : undefined,
+            env: { ...process.env, ...this.env, ...options.env },
+            stdoutPath, stderrPath, resultPath,
+            heartbeatIntervalMs: this.heartbeatIntervalMs,
+            onSpawn: options.onSpawn,
+            onStdout: options.onStdout,
+            onStderr: options.onStderr,
+            onHeartbeat: options.onHeartbeat,
+            beforeSpawn,
+        });
+        const result = {
+            ok: exitCode === 0 && !timedOut,
+            args: resultArgs,
+            command,
+            cwd: options.cwd,
+            durationMs: Date.now() - startedAt,
+            exitCode,
+            stdout, stdoutBytes, stdoutTruncated,
+            stderr, stderrBytes, stderrTruncated,
+            timedOut,
+            artifacts: { dir: artifactDir, stdoutPath, stderrPath, resultPath },
+        };
+        if (options.expectJson) {
+            const jsonSource = stdoutTruncated
+                ? await readFullOutputArtifact(stdoutPath, stdout)
+                : stdout;
+            const parsed = parseCommandJson(jsonSource);
+            if (parsed.ok) {
+                result.json = parsed.value;
+            }
+            else {
+                result.ok = false;
+                result.parseFailure = parsed.failure;
+            }
+        }
+        await writeFile(result.artifacts.resultPath, `${JSON.stringify(result, null, 2)}\n`, "utf-8");
+        return result;
+    }
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function assertControllerIdentityUnchangedBeforeSpawn(identity) {
+    const currentPackageRoot = findPackageRoot(path.dirname(identity.realEntry));
+    if (currentPackageRoot !== identity.packageRoot) {
+        throw controllerIdentityDriftError(`package root changed from ${JSON.stringify(identity.packageRoot)} to ${JSON.stringify(currentPackageRoot)}`);
+    }
+    const currentPackageName = readPackageName(identity.packageRoot);
+    if (currentPackageName !== identity.packageName) {
+        throw controllerIdentityDriftError(`package name changed from ${JSON.stringify(identity.packageName)} to ${JSON.stringify(currentPackageName)}`);
+    }
+    const currentPackageVersion = readPackageVersion(identity.packageRoot);
+    if (currentPackageVersion !== identity.packageVersion) {
+        throw controllerIdentityDriftError(`package version changed from ${JSON.stringify(identity.packageVersion)} to ${JSON.stringify(currentPackageVersion)}`);
+    }
+    const currentBinarySha256 = computeBinarySha256(identity.realEntry);
+    if (currentBinarySha256 !== identity.binarySha256) {
+        throw controllerIdentityDriftError(`entry binary sha256 changed from ${identity.binarySha256} to ${currentBinarySha256 ?? "unreadable"}`);
+    }
+    let currentPackageFingerprint;
+    try {
+        currentPackageFingerprint = computePackageFingerprint(identity.packageRoot);
+    }
+    catch (error) {
+        throw controllerIdentityDriftError(`package fingerprint cannot be recomputed: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+    if (currentPackageFingerprint.algorithm !== identity.packageFingerprint.algorithm
+        || currentPackageFingerprint.scopeVersion !== identity.packageFingerprint.scopeVersion
+        || JSON.stringify(currentPackageFingerprint.scope)
+            !== JSON.stringify(identity.packageFingerprint.scope)
+        || currentPackageFingerprint.value !== identity.packageFingerprint.value
+        || currentPackageFingerprint.fileCount !== identity.packageFingerprint.fileCount) {
+        throw controllerIdentityDriftError(`package fingerprint changed from ${identity.packageFingerprint.value} to ${currentPackageFingerprint.value}`);
+    }
+}
+function controllerIdentityDriftError(message, cause) {
+    return new Error(`controller identity changed before spawn: ${message}`, {
+        cause,
+    });
+}
+/**
+ * Detect whether loopAgentBin is a Node-like executable and baseArgs
+ * contains a script file. Returns the absolute script path, or undefined.
+ */
+function findSourceScript(baseArgs, cwd) {
+    if (baseArgs.length === 0)
+        return undefined;
+    // Look for the last .ts/.js/.mjs/.cjs file in baseArgs
+    let scriptIdx = -1;
+    for (let i = baseArgs.length - 1; i >= 0; i--) {
+        const ext = path.extname(baseArgs[i]).toLowerCase();
+        if (ext === ".ts" || ext === ".js" || ext === ".mjs" || ext === ".cjs") {
+            scriptIdx = i;
+            break;
+        }
+    }
+    if (scriptIdx < 0)
+        return undefined;
+    const scriptPath = path.resolve(cwd, baseArgs[scriptIdx]);
+    try {
+        const s = statSync(scriptPath);
+        if (s.isFile())
+            return { index: scriptIdx, path: realpathSync(scriptPath) };
+    }
+    catch {
+        // script not found
+    }
+    return undefined;
+}
+/**
+ * Resolve the Node binary to an absolute path.
+ */
+function resolveNodeBinary(loopAgentBin, resolvedAt, inputs) {
+    if (path.isAbsolute(loopAgentBin))
+        return realpathSync(loopAgentBin);
+    const resolved = resolveBinPaths(loopAgentBin, resolvedAt, inputs);
+    return resolved.realEntry;
+}
+function frozenNodeExecutable() {
+    try {
+        return realpathSync(process.execPath);
+    }
+    catch {
+        return process.execPath;
+    }
+}
+function spawnCommand(input) {
+    return new Promise((resolve, reject) => {
+        const startedAtMs = Date.now();
+        const startedAt = new Date(startedAtMs).toISOString();
+        try {
+            input.beforeSpawn?.();
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        const child = spawn(input.command, input.args, {
+            cwd: input.cwd,
+            env: input.env,
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        try {
+            writeFileSync(input.stdoutPath, "", "utf-8");
+            writeFileSync(input.stderrPath, "", "utf-8");
+        }
+        catch { /* best-effort */ }
+        invokeSpawnCallback(input.onSpawn, { pid: child.pid, startedAt, artifactRefs: { stdoutPath: input.stdoutPath, stderrPath: input.stderrPath, resultPath: input.resultPath } });
+        let stdout = createBoundedOutput();
+        let stderr = createBoundedOutput();
+        let timedOut = false;
+        let settled = false;
+        const settle = (payload) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimers();
+            resolve({
+                stdout: formatBoundedOutput(stdout),
+                stdoutBytes: stdout.bytes,
+                stdoutTruncated: stdout.truncated,
+                stderr: formatBoundedOutput(stderr),
+                stderrBytes: stderr.bytes,
+                stderrTruncated: stderr.truncated,
+                exitCode: payload.exitCode,
+                timedOut: payload.timedOut,
+            });
+        };
+        let hardTimeout;
+        let killGraceTimeout;
+        if (input.hardTimeoutMs !== undefined && input.hardTimeoutMs > 0) {
+            hardTimeout = setTimeout(() => {
+                timedOut = true;
+                // Two-stage termination: SIGTERM first so the runner can persist a
+                // terminal state (see executeDagCheckpoint signal handler), then
+                // SIGKILL only after the grace window expires.
+                child.kill("SIGTERM");
+                killGraceTimeout = setTimeout(() => {
+                    child.kill("SIGKILL");
+                }, HARD_TIMEOUT_KILL_GRACE_MS);
+            }, input.hardTimeoutMs);
+        }
+        let heartbeatTimer;
+        if (input.heartbeatIntervalMs > 0) {
+            heartbeatTimer = setInterval(() => { invokeHeartbeatCallback(input.onHeartbeat, startedAtMs); }, input.heartbeatIntervalMs);
+        }
+        const clearTimers = () => {
+            if (hardTimeout !== undefined)
+                clearTimeout(hardTimeout);
+            if (killGraceTimeout !== undefined)
+                clearTimeout(killGraceTimeout);
+            if (heartbeatTimer !== undefined) {
+                clearInterval(heartbeatTimer);
+                heartbeatTimer = undefined;
+            }
+        };
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => { stdout = appendBoundedOutput(stdout, chunk); appendChunkBestEffort(input.stdoutPath, chunk); invokeChunkCallback(input.onStdout, chunk); });
+        child.stderr.on("data", (chunk) => { stderr = appendBoundedOutput(stderr, chunk); appendChunkBestEffort(input.stderrPath, chunk); invokeChunkCallback(input.onStderr, chunk); });
+        child.on("error", (error) => { if (!settled) {
+            settled = true;
+            clearTimers();
+            reject(error);
+        } });
+        child.on("close", (exitCode) => {
+            settle({
+                exitCode,
+                timedOut,
+            });
+        });
+    });
+}
+function createBoundedOutput() { return { bytes: 0, text: "", truncated: false }; }
+function appendBoundedOutput(current, chunk) {
+    const bytes = current.bytes + Buffer.byteLength(chunk);
+    const combined = current.text + chunk;
+    if (Buffer.byteLength(combined) <= MAX_BUFFERED_OUTPUT_BYTES)
+        return { bytes, text: combined, truncated: current.truncated };
+    const tail = Buffer.from(combined).subarray(-MAX_BUFFERED_OUTPUT_BYTES).toString("utf-8").replace(/^\uFFFD/, "");
+    return { bytes, text: tail, truncated: true };
+}
+function formatBoundedOutput(output) { return output.truncated ? `${output.text}\n...[truncated]` : output.text; }
+async function readFullOutputArtifact(filePath, fallback) { try {
+    return await readFile(filePath, "utf-8");
+}
+catch {
+    return fallback;
+} }
+function appendChunkBestEffort(filePath, chunk) { try {
+    appendFileSync(filePath, chunk, "utf-8");
+}
+catch { /* best-effort */ } }
+function invokeSpawnCallback(cb, info) { if (!cb)
+    return; try {
+    cb(info);
+}
+catch (error) {
+    process.stderr.write(`LoopAgentClient onSpawn callback error: ${String(error)}\n`);
+} }
+function invokeChunkCallback(cb, chunk) { if (!cb)
+    return; try {
+    cb(chunk);
+}
+catch (error) {
+    process.stderr.write(`LoopAgentClient output callback error: ${String(error)}\n`);
+} }
+function invokeHeartbeatCallback(cb, startedAtMs) { if (!cb)
+    return; try {
+    cb({ at: new Date().toISOString(), elapsedMs: Date.now() - startedAtMs });
+}
+catch (error) {
+    process.stderr.write(`LoopAgentClient onHeartbeat callback error: ${String(error)}\n`);
+} }
+function sanitizeName(name) { return name.replace(/[^a-zA-Z0-9._-]+/g, "-"); }
+function identityAnchor(identity) {
+    return JSON.stringify({
+        schemaVersion: identity.schemaVersion,
+        packageName: identity.packageName,
+        binName: identity.binName,
+        requested: identity.requested,
+        entry: identity.entry,
+        realEntry: identity.realEntry,
+        launch: identity.launch,
+        binarySha256: identity.binarySha256,
+        packageRoot: identity.packageRoot,
+        packageVersion: identity.packageVersion,
+        packageFingerprint: identity.packageFingerprint,
+    });
+}

package/dist/worker/loop-agent/parse-json.js

@@ -0,0 +1,14 @@
+export function parseCommandJson(stdout) {
+    try {
+        return { ok: true, value: JSON.parse(stdout) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            failure: {
+                code: "json-parse-failed",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+}

package/dist/worker/materialize/harness-task-lifecycle-probe.js

@@ -0,0 +1,126 @@
+/**
+ * Worker-local harness Task lifecycle probe.
+ * Uses workflows/DAG facts only — must not import src/application/**.
+ */
+import { assessDagRunLiveness, assessDagRunRecoveryEligibility, listAllDagRunEntries, readDagRunSpec, readDagRunState, } from "../../workflows/dag/lifecycle.js";
+import { resolveWorkerRecoveryDecision } from "../pool/recovery-decision.js";
+export async function listWorkerAssociatedDagRuns(repoRoot, harnessTaskId) {
+    const entries = await listAllDagRunEntries(repoRoot);
+    const related = [];
+    for (const entry of entries) {
+        let matched = false;
+        try {
+            const state = await readDagRunState(entry.runDir);
+            if (state.workerAssociation?.taskId === harnessTaskId) {
+                matched = true;
+            }
+        }
+        catch {
+            // state unreadable; may still match via binding
+        }
+        if (!matched) {
+            try {
+                const spec = await readDagRunSpec(entry.runDir);
+                if (spec.taskContractBinding?.taskId === harnessTaskId ||
+                    spec.sourceBinding?.taskId === harnessTaskId) {
+                    matched = true;
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        if (!matched)
+            continue;
+        related.push({
+            runId: entry.runId,
+            lifecycle: entry.lifecycle,
+        });
+    }
+    return related.sort((a, b) => a.runId.localeCompare(b.runId));
+}
+export async function detectPausedAssociatedRun(repoRoot, harnessTaskId) {
+    const runs = await listWorkerAssociatedDagRuns(repoRoot, harnessTaskId);
+    const paused = runs.find((run) => run.lifecycle === "paused");
+    return paused ? { runId: paused.runId } : undefined;
+}
+export async function detectRecoveryRequired(repoRoot, harnessTaskId, _revisionId) {
+    const entries = await listAllDagRunEntries(repoRoot);
+    let hasActiveOrRecoverableDag = false;
+    let dagCanResume = false;
+    let factsIncomplete = false;
+    let runFailed = false;
+    let needsAttention = false;
+    for (const entry of entries) {
+        let associated = false;
+        try {
+            const state = await readDagRunState(entry.runDir);
+            if (state.workerAssociation?.taskId === harnessTaskId) {
+                associated = true;
+            }
+            if (!associated)
+                continue;
+            const liveness = assessDagRunLiveness({ state });
+            const recovery = assessDagRunRecoveryEligibility({
+                lifecycle: entry.lifecycle,
+                state,
+                liveness: liveness.status,
+            });
+            if (entry.lifecycle === "active" ||
+                entry.lifecycle === "paused" ||
+                liveness.status === "active" ||
+                liveness.status === "node-quiet") {
+                hasActiveOrRecoverableDag = true;
+            }
+            if (entry.lifecycle === "paused" || recovery.canResume) {
+                dagCanResume = true;
+            }
+            if (liveness.status === "orphaned" ||
+                liveness.status === "stale" ||
+                liveness.status === "needs-attention" ||
+                liveness.status === "suspected-stall") {
+                needsAttention = true;
+                hasActiveOrRecoverableDag = true;
+            }
+            if (entry.lifecycle === "completed" && state.status !== "finished") {
+                runFailed = true;
+            }
+        }
+        catch {
+            try {
+                const spec = await readDagRunSpec(entry.runDir);
+                if (spec.taskContractBinding?.taskId === harnessTaskId ||
+                    spec.sourceBinding?.taskId === harnessTaskId) {
+                    factsIncomplete = true;
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    if (factsIncomplete) {
+        return resolveWorkerRecoveryDecision({ factsIncomplete: true });
+    }
+    if (needsAttention || dagCanResume) {
+        const decision = resolveWorkerRecoveryDecision({
+            dagCanResume,
+            hasActiveOrRecoverableDag,
+        });
+        if (decision.recommendedAction === "reconcile" ||
+            decision.recommendedAction === "decide" ||
+            decision.recommendedAction === "revise-contract") {
+            return decision;
+        }
+    }
+    if (runFailed) {
+        const decision = resolveWorkerRecoveryDecision({
+            dagCanResume: false,
+            hasActiveOrRecoverableDag: false,
+        });
+        if (decision.recommendedAction === "revise-contract") {
+            return decision;
+        }
+    }
+    return undefined;
+}