@tea-agent/loop-agent 0.31.1 → 0.32.1

package/dist/worker/pool/begin-attempt.js

@@ -0,0 +1,35 @@
+import { createWorkerAttemptIdentity } from "./attempt-identity.js";
+import { registerRunOwner } from "./run-owner-store.js";
+import { writeTaskPoolState } from "./run-store.js";
+/**
+ * Attempt begin transaction (Phase 1/4 foundation):
+ * register immutable owner → write Running state.
+ * Callers then emit required lifecycle events and launch DAG.
+ */
+export async function beginWorkerAttempt(input) {
+    const now = input.now ?? new Date();
+    const identity = createWorkerAttemptIdentity({
+        featureId: input.featureId,
+        taskId: input.taskId,
+        workerRunId: input.workerRunId,
+        batchRunId: input.batchRunId,
+    });
+    const ownerRegistration = await registerRunOwner({
+        repoRoot: input.repoRoot,
+        identity,
+        now,
+        ...(input.controllerAnchor ? { controllerAnchor: input.controllerAnchor } : {}),
+        ...(input.revisionId ? { revisionId: input.revisionId } : {}),
+    });
+    const state = {
+        schemaVersion: 2,
+        featureId: identity.featureId,
+        taskId: identity.taskId,
+        status: "Running",
+        updatedAt: now.toISOString(),
+        workerRunId: identity.workerRunId,
+        ...(input.stateExtras ?? {}),
+    };
+    await writeTaskPoolState(input.repoRoot, state);
+    return { identity, ownerRegistration, state };
+}

package/dist/worker/pool/failure-routing.js

@@ -1,3 +1,4 @@
+import { defaultRetryabilityForCategory, recommendedActionForRetryability, } from "./recovery-decision.js";
 const PRODUCT_CATEGORIES = new Set([
     "SpecUnclear",
     "ContractMismatch",
@@ -82,6 +83,54 @@ export function deriveFailureRouteFromError(message, businessId) {
         source: "runner-error",
     };
 }
+/**
+ * Phase-aware V2 failure for new writers. V1 FailureRoute remains available.
+ */
+export function deriveFailureRouteV2(result, phase = "execute") {
+    const base = deriveFailureRoute(result);
+    if (!base)
+        return undefined;
+    const retryability = defaultRetryabilityForCategory(base.category, phase);
+    return {
+        ...base,
+        schemaVersion: 2,
+        phase,
+        retryability,
+        recommendedAction: recommendedActionForRetryability(retryability),
+        message: result.reportDecision.reason,
+        evidence: [
+            result.runRecordPath,
+            result.dagPath,
+            ...(result.failureArtifacts
+                ? Object.values(result.failureArtifacts).filter((value) => typeof value === "string")
+                : []),
+        ],
+    };
+}
+export function deriveFailureRouteV2FromError(message, businessId, phase = "prepare") {
+    const base = deriveFailureRouteFromError(message, businessId);
+    const retryability = defaultRetryabilityForCategory(base.category, phase);
+    return {
+        ...base,
+        schemaVersion: 2,
+        phase,
+        retryability,
+        recommendedAction: recommendedActionForRetryability(retryability),
+        message,
+        evidence: [],
+    };
+}
+export function toWorkerAttemptFailureV2(route) {
+    return {
+        schemaVersion: 2,
+        phase: route.phase,
+        category: route.category,
+        message: route.message ?? route.recommendedFollowUpKind,
+        retryability: route.retryability,
+        recommendedAction: route.recommendedAction,
+        evidence: route.evidence ?? [],
+    };
+}
 function readProductCategory(value, key) {
     const candidate = readString(value, key);
     return candidate && PRODUCT_CATEGORIES.has(candidate)

package/dist/worker/pool/recovery-decision.js

@@ -0,0 +1,163 @@
+/**
+ * Single recovery decision for CLI / Feature Review / Console / Scheduler.
+ * Uncertain facts → reconcile or decide; never guess retry.
+ */
+export function resolveWorkerRecoveryDecision(facts) {
+    if (facts.factsIncomplete) {
+        return {
+            recommendedAction: "reconcile",
+            reason: "attempt facts are incomplete or conflicting",
+            retryability: "requires-reconcile",
+        };
+    }
+    const failureV2 = facts.state?.failureV2 ?? facts.terminalRun?.failureV2 ?? undefined;
+    if (failureV2) {
+        return decisionFromFailureV2(failureV2);
+    }
+    const status = facts.state?.status;
+    if (status === "Done") {
+        return { recommendedAction: "none", reason: "attempt already succeeded" };
+    }
+    if (status === "Running" || status === "Queued") {
+        if (facts.dagCanResume) {
+            return {
+                recommendedAction: "resume",
+                reason: "DAG is paused or recoverable; resume same attempt",
+                retryability: "requires-resume",
+            };
+        }
+        if (facts.hasActiveOrRecoverableDag) {
+            return {
+                recommendedAction: "none",
+                reason: "attempt is still active",
+            };
+        }
+        return {
+            recommendedAction: "reconcile",
+            reason: "Running state without live DAG or terminal evidence",
+            retryability: "requires-reconcile",
+        };
+    }
+    if (status === "Blocked" || status === "HumanReview") {
+        const category = facts.state?.failure?.category;
+        if (category === "ContractMismatch" ||
+            category === "SpecUnclear" ||
+            category === "Unknown") {
+            return {
+                recommendedAction: "revise-contract",
+                reason: "contract/risk prerequisite blocks execution",
+                retryability: "requires-contract-revision",
+                category,
+            };
+        }
+        return {
+            recommendedAction: "decide",
+            reason: "human gate or non-retryable block",
+            retryability: "requires-human",
+            category,
+        };
+    }
+    if (status === "Failed" || status === "Abandoned") {
+        const category = facts.state?.failure?.category ?? facts.terminalRun?.failure?.category;
+        if (category === "EnvFailure" ||
+            category === "FlakyTest" ||
+            category === "ProductBug" ||
+            category === "TestBug" ||
+            facts.terminalRun?.status === "run-error" ||
+            facts.terminalRun?.status === "failed") {
+            return {
+                recommendedAction: "retry",
+                reason: "terminal failure is safe to retry as a new attempt",
+                retryability: "safe",
+                category,
+            };
+        }
+        return {
+            recommendedAction: "decide",
+            reason: "terminal failure requires human review before retry",
+            retryability: "requires-human",
+            category,
+        };
+    }
+    return {
+        recommendedAction: "none",
+        reason: "no recovery action for current facts",
+    };
+}
+function decisionFromFailureV2(failure) {
+    return {
+        recommendedAction: failure.recommendedAction,
+        reason: failure.message,
+        retryability: failure.retryability,
+        phase: failure.phase,
+        category: failure.category,
+    };
+}
+export function isSafeRetryDecision(decision) {
+    return (decision.recommendedAction === "retry" &&
+        (decision.retryability === "safe" || decision.retryability === undefined));
+}
+export function defaultRetryabilityForCategory(category, phase) {
+    if (phase === "prepare" || phase === "materialize") {
+        if (category === "ContractMismatch" ||
+            category === "SpecUnclear" ||
+            category === "Unknown") {
+            return "requires-contract-revision";
+        }
+    }
+    switch (category) {
+        case "EnvFailure":
+        case "FlakyTest":
+        case "ProductBug":
+        case "TestBug":
+            return "safe";
+        case "DependencyFailure":
+            return "requires-human";
+        case "RiskyChange":
+        case "NeedsHuman":
+            return "requires-human";
+        case "ContractMismatch":
+        case "SpecUnclear":
+            return "requires-contract-revision";
+        case "Unknown":
+            return phase === "prepare" || phase === "materialize"
+                ? "requires-contract-revision"
+                : "requires-human";
+        default:
+            return "requires-human";
+    }
+}
+export function recommendedActionForRetryability(retryability, _status) {
+    switch (retryability) {
+        case "safe":
+            return "retry";
+        case "requires-resume":
+            return "resume";
+        case "requires-reconcile":
+            return "reconcile";
+        case "requires-contract-revision":
+            return "revise-contract";
+        case "requires-human":
+        case "never":
+            return "decide";
+        default:
+            return "decide";
+    }
+}
+/** @deprecated Use recommendedActionForRetryability */
+export const actionFromRetryability = recommendedActionForRetryability;
+export function inferPhaseFromRunStatus(runStatus) {
+    if (runStatus === "run-error")
+        return "prepare";
+    if (runStatus === "failed")
+        return "execute";
+    if (runStatus === "succeeded")
+        return "record";
+    return "execute";
+}
+export function inferRetryability(category, phase, runStatus) {
+    if (category === "EnvFailure" && runStatus === "failed") {
+        return "requires-human";
+    }
+    return defaultRetryabilityForCategory(category, phase);
+}

package/dist/worker/pool/run-owner-store.js

@@ -0,0 +1,126 @@
+import { mkdir, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { assertWorkerAttemptIdentity, createWorkerAttemptIdentity, ownerMatchesIdentity, } from "./attempt-identity.js";
+import { assertSafeTaskPoolId, getTaskPoolRoot } from "./run-store.js";
+import { TASK_POOL_STATE_ERROR_CODES, TaskPoolStateError } from "./types.js";
+export const RUN_OWNERS_RELATIVE = "run-owners";
+export function getRunOwnersRoot(repoRoot) {
+    return path.join(getTaskPoolRoot(repoRoot), RUN_OWNERS_RELATIVE);
+}
+export function getRunOwnerPath(repoRoot, workerRunId) {
+    assertSafeTaskPoolId(workerRunId, "workerRunId");
+    const ownerPath = path.join(getRunOwnersRoot(repoRoot), `${workerRunId}.json`);
+    const root = path.resolve(getRunOwnersRoot(repoRoot));
+    const resolved = path.resolve(ownerPath);
+    const relative = path.relative(root, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.PATH_MISMATCH, `run owner path escapes run-owners root: ${ownerPath}`);
+    }
+    return ownerPath;
+}
+function isOwnerRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return (record.schemaVersion === 1 &&
+        typeof record.featureId === "string" &&
+        record.featureId.length > 0 &&
+        typeof record.taskId === "string" &&
+        record.taskId.length > 0 &&
+        typeof record.workerRunId === "string" &&
+        record.workerRunId.length > 0 &&
+        typeof record.batchRunId === "string" &&
+        record.batchRunId.length > 0 &&
+        typeof record.registeredAt === "string" &&
+        !Number.isNaN(Date.parse(record.registeredAt)));
+}
+export async function readRunOwner(repoRoot, workerRunId) {
+    const ownerPath = getRunOwnerPath(repoRoot, workerRunId);
+    try {
+        const raw = await readFile(ownerPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return isOwnerRecord(parsed) ? parsed : undefined;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+/**
+ * Register an immutable run owner before Task-scoped events / DAG start.
+ * Same identity → idempotent reuse. Conflicting identity → fail-closed.
+ */
+export async function registerRunOwner(input) {
+    assertWorkerAttemptIdentity(input.identity);
+    assertSafeTaskPoolId(input.identity.featureId, "featureId");
+    assertSafeTaskPoolId(input.identity.taskId, "taskId");
+    assertSafeTaskPoolId(input.identity.workerRunId, "workerRunId");
+    const existing = await readRunOwner(input.repoRoot, input.identity.workerRunId);
+    if (existing) {
+        if (ownerMatchesIdentity(existing, input.identity)) {
+            return { status: "idempotent-reuse", owner: existing };
+        }
+        throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `run owner conflict for ${input.identity.workerRunId}: existing ` +
+            `${existing.featureId}/${existing.taskId}/${existing.batchRunId} vs ` +
+            `${input.identity.featureId}/${input.identity.taskId}/${input.identity.batchRunId}`);
+    }
+    const owner = {
+        schemaVersion: 1,
+        featureId: input.identity.featureId,
+        taskId: input.identity.taskId,
+        workerRunId: input.identity.workerRunId,
+        batchRunId: input.identity.batchRunId,
+        registeredAt: (input.now ?? new Date()).toISOString(),
+        ...(input.controllerAnchor ? { controllerAnchor: input.controllerAnchor } : {}),
+        ...(input.revisionId ? { revisionId: input.revisionId } : {}),
+    };
+    await mkdir(getRunOwnersRoot(input.repoRoot), { recursive: true });
+    const ownerPath = getRunOwnerPath(input.repoRoot, input.identity.workerRunId);
+    await writeJsonAtomic(ownerPath, owner, { repoRoot: input.repoRoot });
+    const confirmed = await readRunOwner(input.repoRoot, input.identity.workerRunId);
+    if (!confirmed) {
+        throw new Error(`failed to persist run owner for ${input.identity.workerRunId}`);
+    }
+    if (!ownerMatchesIdentity(confirmed, input.identity)) {
+        throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `run owner race conflict for ${input.identity.workerRunId}`);
+    }
+    // If another writer won first with the same identity, treat as idempotent.
+    if (confirmed.registeredAt !== owner.registeredAt) {
+        return { status: "idempotent-reuse", owner: confirmed };
+    }
+    return { status: "created", owner: confirmed };
+}
+export async function listRunOwners(repoRoot) {
+    const root = getRunOwnersRoot(repoRoot);
+    let entries;
+    try {
+        entries = await readdir(root);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const owners = [];
+    for (const entry of entries) {
+        if (!entry.endsWith(".json"))
+            continue;
+        const workerRunId = entry.slice(0, -".json".length);
+        const owner = await readRunOwner(repoRoot, workerRunId);
+        if (owner)
+            owners.push(owner);
+    }
+    return owners;
+}
+export function identityFromOwner(owner) {
+    return createWorkerAttemptIdentity({
+        featureId: owner.featureId,
+        taskId: owner.taskId,
+        workerRunId: owner.workerRunId,
+        batchRunId: owner.batchRunId,
+    });
+}

package/dist/worker/pool/run-store.js

@@ -2,6 +2,10 @@ import { createHash, randomUUID } from "node:crypto";
 import { appendFile, mkdir, readFile, readdir, rename, stat, unlink, writeFile, } from "node:fs/promises";
 import path from "node:path";
 import { TASK_POOL_STATE_ERROR_CODES, TaskPoolStateError, } from "./types.js";
+import { reduceAttemptTransition } from "./attempt-transition.js";
+import { createWorkerAttemptIdentity } from "./attempt-identity.js";
+import { stateFromRun as stateFromRunProjection } from "./state-projection.js";
+export { projectTaskPoolStatusFromRun } from "./state-projection.js";
 export const TASK_POOL_RELATIVE_ROOT = ".harness/task-pool";
 const SAFE_TASK_POOL_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
 export function getTaskPoolRoot(repoRoot) {
@@ -52,7 +56,7 @@ export function getLegacyTaskStatePath(repoRoot, taskId) {
 export async function recordTaskPoolRun(input) {
     await ensurePoolDirs(input.repoRoot);
     await appendJsonlFile(getRunsJsonlPath(input.repoRoot), input.run);
-    await writeTaskPoolState(input.repoRoot, stateFromRun(input.run));
+    await writeTaskPoolState(input.repoRoot, stateFromRunProjection(input.run));
     await appendJsonlFile(getEventsJsonlPath(input.repoRoot), eventFromRun(input.run));
 }
 export async function appendTaskPoolEvent(repoRoot, event) {
@@ -74,13 +78,34 @@ export async function prepareTaskPoolRetry(input) {
     if (!current) {
         throw new Error(`cannot retry ${input.taskId}: Task Pool state does not exist`);
     }
+    if (current.status === "Done") {
+        throw new Error(`cannot retry ${input.taskId}: task is Done`);
+    }
+    if (current.status === "Running") {
+        throw new Error(`cannot retry ${input.taskId}: active attempt still Running; reconcile first`);
+    }
     if (current.status !== "Failed") {
         throw new Error(`cannot retry ${input.taskId}: expected Failed state, found ${current.status}`);
     }
     if (!current.workerRunId) {
         throw new Error(`cannot retry ${input.taskId}: failed state is missing workerRunId`);
     }
-    const retryRequestedAt = (input.now ?? new Date()).toISOString();
+    const identity = createWorkerAttemptIdentity({
+        featureId,
+        taskId: input.taskId,
+        workerRunId: current.workerRunId,
+        batchRunId: "retry",
+    });
+    const transition = reduceAttemptTransition({
+        identity,
+        from: current,
+        event: {
+            type: "retry-requested",
+            ...(input.reason ? { reason: input.reason } : {}),
+            now: input.now ?? new Date(),
+        },
+    });
+    const retryRequestedAt = transition.nextState.retryRequestedAt ?? transition.nextState.updatedAt;
     const result = {
         taskId: input.taskId,
         featureId,
@@ -89,26 +114,11 @@ export async function prepareTaskPoolRetry(input) {
         retryRequestedAt,
         ...(input.reason ? { reason: input.reason } : {}),
     };
-    await writeTaskPoolState(input.repoRoot, {
-        schemaVersion: 2,
-        featureId,
-        taskId: current.taskId,
-        status: "Ready",
-        updatedAt: retryRequestedAt,
-        retryOfWorkerRunId: current.workerRunId,
-        retryRequestedAt,
-        ...(input.reason ? { retryReason: input.reason } : {}),
-    });
+    await writeTaskPoolState(input.repoRoot, transition.nextState);
     await ensurePoolDirs(input.repoRoot);
-    await appendJsonlFile(getEventsJsonlPath(input.repoRoot), {
-        schemaVersion: 1,
-        at: retryRequestedAt,
-        type: "task-retry-requested",
-        taskId: input.taskId,
-        featureId,
-        previousWorkerRunId: current.workerRunId,
-        ...(input.reason ? { reason: input.reason } : {}),
-    });
+    if (transition.auditEvent) {
+        await appendJsonlFile(getEventsJsonlPath(input.repoRoot), transition.auditEvent);
+    }
     return result;
 }
 async function resolveRetryFeatureId(repoRoot, taskId, featureId) {
@@ -328,31 +338,7 @@ async function ensurePoolDirs(repoRoot) {
     await mkdir(getStatesRoot(repoRoot), { recursive: true });
 }
 export function stateFromRun(run) {
-    return {
-        schemaVersion: 2,
-        featureId: run.featureId,
-        taskId: run.taskId,
-        status: stateStatusFromRun(run),
-        updatedAt: run.recordedAt,
-        workerRunId: run.workerRunId,
-        ...(run.runRecordPath ? { lastRunRecordPath: run.runRecordPath } : {}),
-        ...(run.failure ? { failure: run.failure } : {}),
-        ...(run.retryOfWorkerRunId
-            ? { retryOfWorkerRunId: run.retryOfWorkerRunId }
-            : {}),
-    };
-}
-function stateStatusFromRun(run) {
-    if (run.status === "succeeded")
-        return "Done";
-    // A pre-DAG provider/executor configuration failure is retryable after the
-    // operator corrects the environment; do not bury it in a non-retryable Blocked state.
-    if (run.status === "run-error" && run.failure?.category === "EnvFailure") {
-        return "Failed";
-    }
-    if (run.status === "run-error")
-        return "Blocked";
-    return "Failed";
+    return stateFromRunProjection(run);
 }
 function eventFromRun(run) {
     return {

package/dist/worker/pool/runtime-reconcile-inventory.js

@@ -0,0 +1,127 @@
+/**
+ * Phase 7 Track A: runtime reconcile inventory facts + dry-run builder.
+ * Apply/quarantine orchestration remains intentionally out of scope.
+ */
+export function classifyRuntimeCandidate(signals) {
+    const evidence = [];
+    if (signals.ownerConflict || signals.taskOwnerMismatch) {
+        evidence.push("owner-or-lease conflict detected");
+        return {
+            liveness: "conflict",
+            recommendedAction: "human-review",
+            evidence,
+        };
+    }
+    if (signals.lifecycle === "completed" || signals.hasTerminalEvidence) {
+        evidence.push("terminal run evidence present");
+        return {
+            liveness: "healthy",
+            recommendedAction: "wait",
+            evidence,
+        };
+    }
+    const progress = signals.sessionEventsGrowing === true || signals.providerActive === true;
+    if (signals.heartbeatFresh && progress) {
+        evidence.push("heartbeat fresh with meaningful progress");
+        return {
+            liveness: "healthy",
+            recommendedAction: signals.lifecycle === "paused" ? "resume" : "wait",
+            evidence,
+        };
+    }
+    if (signals.heartbeatFresh && !progress) {
+        evidence.push("heartbeat fresh but no recent session/provider progress");
+        return {
+            liveness: "recoverable",
+            recommendedAction: "wait",
+            evidence,
+        };
+    }
+    if (signals.processAlive && progress) {
+        evidence.push("process alive with progress despite stale heartbeat");
+        return {
+            liveness: "recoverable",
+            recommendedAction: "resume",
+            evidence,
+        };
+    }
+    if (signals.lifecycle === "partial" && signals.processAlive !== true) {
+        evidence.push("partial lifecycle without live process");
+        return {
+            liveness: "orphaned",
+            recommendedAction: "reconcile",
+            evidence,
+        };
+    }
+    evidence.push("no heartbeat or progress signals");
+    return {
+        liveness: "stale",
+        recommendedAction: signals.lifecycle === "active" ? "quarantine" : "abandon",
+        evidence,
+    };
+}
+export function projectRuntimeRecoveryCommand(candidate) {
+    const featureArgs = candidate.featureId && candidate.taskId
+        ? `--feature-id ${JSON.stringify(candidate.featureId)} --task-id ${JSON.stringify(candidate.taskId)}`
+        : undefined;
+    switch (candidate.recommendedAction) {
+        case "wait":
+            return undefined;
+        case "resume":
+            return candidate.dagRunId
+                ? `loop-agent dag resume --run-id ${JSON.stringify(candidate.dagRunId)}`
+                : "loop-agent dag resume --run-id <dagRunId>";
+        case "reconcile":
+            return featureArgs
+                ? `agent-worker task reconcile ${featureArgs}`
+                : "agent-worker task reconcile --feature-id <featureId> --task-id <taskId>";
+        case "quarantine":
+            return featureArgs
+                ? `agent-worker pool doctor --json ${featureArgs}`
+                : "agent-worker pool doctor --json";
+        case "abandon":
+            return featureArgs
+                ? `agent-worker task mark-failed ${featureArgs} --reason reconcile-abandon`
+                : "agent-worker task mark-failed --feature-id <featureId> --task-id <taskId> --reason reconcile-abandon";
+        case "human-review":
+            return featureArgs
+                ? `agent-worker feature review --feature-id ${JSON.stringify(candidate.featureId)}`
+                : "agent-worker feature review";
+        default:
+            return undefined;
+    }
+}
+/**
+ * Pure dry-run inventory: classify candidates and attach a single recovery command.
+ * Does not mutate Task Pool / lease / DAG facts.
+ */
+export function buildRuntimeReconcileInventoryDryRun(input) {
+    const candidates = input.items.map((item) => {
+        const classified = classifyRuntimeCandidate(item.signals);
+        const base = {
+            lifecycle: item.signals.lifecycle,
+            ...classified,
+            ...(item.workerAttemptId ? { workerAttemptId: item.workerAttemptId } : {}),
+            ...(item.dagRunId ? { dagRunId: item.dagRunId } : {}),
+            ...(item.featureId ? { featureId: item.featureId } : {}),
+            ...(item.taskId ? { taskId: item.taskId } : {}),
+        };
+        const recoveryCommand = projectRuntimeRecoveryCommand(base);
+        return recoveryCommand ? { ...base, recoveryCommand } : base;
+    });
+    const summary = {
+        total: candidates.length,
+        healthy: candidates.filter((c) => c.liveness === "healthy").length,
+        recoverable: candidates.filter((c) => c.liveness === "recoverable").length,
+        stale: candidates.filter((c) => c.liveness === "stale").length,
+        orphaned: candidates.filter((c) => c.liveness === "orphaned").length,
+        conflict: candidates.filter((c) => c.liveness === "conflict").length,
+    };
+    return {
+        schemaVersion: 1,
+        mode: "dry-run",
+        generatedAt: (input.now ?? new Date()).toISOString(),
+        candidates,
+        summary,
+    };
+}

package/dist/worker/pool/state-projection.js

@@ -0,0 +1,57 @@
+import { inferRetryability, inferPhaseFromRunStatus } from "./recovery-decision.js";
+/**
+ * Project Task Pool status from an immutable terminal run record.
+ * Blocked is reserved for contract/risk/dependency/human gates.
+ */
+export function projectTaskPoolStatusFromRun(run) {
+    if (run.status === "succeeded")
+        return "Done";
+    if (run.status === "run-error") {
+        const failureV2 = run.failureV2;
+        if (failureV2?.retryability === "safe")
+            return "Failed";
+        if (failureV2?.retryability === "requires-contract-revision")
+            return "Blocked";
+        const category = failureV2?.category ?? run.failure?.category;
+        const phase = failureV2?.phase ?? inferPhaseFromRunStatus(run.status);
+        if (category) {
+            const retryability = inferRetryability(category, phase, run.status);
+            if (retryability === "safe")
+                return "Failed";
+            if (retryability === "requires-contract-revision")
+                return "Blocked";
+            if (retryability === "requires-human" ||
+                category === "RiskyChange" ||
+                category === "NeedsHuman" ||
+                category === "DependencyFailure") {
+                return "Blocked";
+            }
+        }
+        // EnvFailure pre-DAG errors remain retryable execution failures.
+        if (run.failure?.category === "EnvFailure")
+            return "Failed";
+        const hasCompleteEvidence = Boolean(run.error || run.failure || run.failureV2 || run.runRecordPath);
+        if (hasCompleteEvidence && category === "ProductBug")
+            return "Failed";
+        if (hasCompleteEvidence && category === "TestBug")
+            return "Failed";
+        return "Blocked";
+    }
+    return "Failed";
+}
+export function stateFromRun(run) {
+    return {
+        schemaVersion: 2,
+        featureId: run.featureId,
+        taskId: run.taskId,
+        status: projectTaskPoolStatusFromRun(run),
+        updatedAt: run.recordedAt,
+        workerRunId: run.workerRunId,
+        ...(run.runRecordPath ? { lastRunRecordPath: run.runRecordPath } : {}),
+        ...(run.failure ? { failure: run.failure } : {}),
+        ...(run.failureV2 ? { failureV2: run.failureV2 } : {}),
+        ...(run.retryOfWorkerRunId
+            ? { retryOfWorkerRunId: run.retryOfWorkerRunId }
+            : {}),
+    };
+}