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

package/dist/workflows/dag/rerun-task.js

@@ -0,0 +1,370 @@
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+import { generateTaskDagUseCase } from "../../application/dag/generate-task-dag.js";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { DAG_RUNS_DIR, isTerminalDagRunStatus, locateDagRun, readDagRunSpec, readDagRunState, } from "./lifecycle.js";
+import { parseDagSpec } from "./types.js";
+export const RERUN_TASK_LINEAGE_REL_PATH = ".runtime/rerun-task-lineage.json";
+export function parseDagRerunTaskArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag rerun-task --run-id <id> --reason <text> --request-id <key> [--profile auto|minimal|standard|reviewed|supervised] [--task-id <id>] [--json]");
+    }
+    let parentRunId;
+    let reason;
+    let requestId;
+    let profile = "auto";
+    let profileExplicit = false;
+    let taskIdOverride;
+    let execute = true;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--run-id")
+            parentRunId = args[++index];
+        else if (arg.startsWith("--run-id="))
+            parentRunId = arg.slice("--run-id=".length);
+        else if (arg === "--reason")
+            reason = args[++index];
+        else if (arg.startsWith("--reason="))
+            reason = arg.slice("--reason=".length);
+        else if (arg === "--request-id")
+            requestId = args[++index];
+        else if (arg.startsWith("--request-id="))
+            requestId = arg.slice("--request-id=".length);
+        else if (arg === "--profile") {
+            profile = parseDagRerunTaskProfile(args[++index]);
+            profileExplicit = true;
+        }
+        else if (arg.startsWith("--profile=")) {
+            profile = parseDagRerunTaskProfile(arg.slice("--profile=".length));
+            profileExplicit = true;
+        }
+        else if (arg === "--task-id")
+            taskIdOverride = args[++index];
+        else if (arg.startsWith("--task-id="))
+            taskIdOverride = arg.slice("--task-id=".length);
+        else if (arg === "--json")
+            continue;
+        else if (arg === "--no-execute")
+            execute = false;
+        else if (arg.startsWith("-"))
+            throw new Error(`unknown dag rerun-task flag: ${arg}`);
+        else
+            throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (!parentRunId) {
+        throw new Error("dag rerun-task requires --run-id <id>");
+    }
+    if (!reason?.trim()) {
+        throw new Error("dag rerun-task requires --reason <text>");
+    }
+    if (!requestId?.trim()) {
+        throw new Error("dag rerun-task requires --request-id <key>");
+    }
+    return {
+        parentRunId,
+        reason: reason.trim(),
+        requestId: requestId.trim(),
+        profile,
+        profileExplicit,
+        ...(taskIdOverride?.trim() ? { taskIdOverride: taskIdOverride.trim() } : {}),
+        execute,
+    };
+}
+function parseDagRerunTaskProfile(value) {
+    if (value === "auto" ||
+        value === "minimal" ||
+        value === "standard" ||
+        value === "reviewed" ||
+        value === "supervised") {
+        return value;
+    }
+    throw new Error(`dag rerun-task --profile must be one of: auto, minimal, standard, reviewed, supervised; got ${value ?? ""}`);
+}
+function assessStandaloneTaskRerunEligibility(input) {
+    if (input.lifecycle === "paused") {
+        return {
+            eligible: false,
+            blockedReason: "parent-run-paused-use-resume",
+        };
+    }
+    if (input.lifecycle === "active" &&
+        !isTerminalDagRunStatus(input.state.status)) {
+        return {
+            eligible: false,
+            blockedReason: "parent-run-still-active",
+        };
+    }
+    if (!isTerminalDagRunStatus(input.state.status)) {
+        return {
+            eligible: false,
+            blockedReason: "parent-run-not-terminal",
+        };
+    }
+    if (input.state.status === "superseded" || input.state.status === "abandoned") {
+        return {
+            eligible: false,
+            blockedReason: `parent-run-${input.state.status}`,
+        };
+    }
+    if (input.state.status === "finished") {
+        return {
+            eligible: true,
+            note: "parent-run-succeeded-full-rerun-still-allowed",
+        };
+    }
+    return { eligible: true };
+}
+function resolveTaskIdForRerun(spec, taskIdOverride) {
+    if (taskIdOverride?.trim()) {
+        return { taskId: taskIdOverride.trim() };
+    }
+    const fromContract = spec.taskContractBinding?.taskId;
+    const fromSource = spec.sourceBinding?.taskId;
+    if (fromContract && fromSource && fromContract !== fromSource) {
+        return { blockedReason: "ambiguous-task-identity" };
+    }
+    const taskId = fromContract ?? fromSource;
+    if (!taskId) {
+        return {
+            blockedReason: "missing-task-identity-requires-task-id-override",
+        };
+    }
+    return { taskId };
+}
+function operatorRequestPath(cwd, requestId) {
+    return path.join(cwd, DAG_RUNS_DIR, ".operator-requests", `${requestId}.json`);
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const GENERATED_OUTPUT_CONFLICT_REASON = "generated-output-conflict";
+/**
+ * Determine whether a regenerated DAG would overwrite existing/dirty generated
+ * outputs that overlap a requireChangedFiles writer's declared write set.
+ *
+ * Only concrete writeSet entries are checked: glob-only entries (containing
+ * `*`) are skipped, consistent with the bounded-writer constraint that a
+ * requireChangedFiles writer declare concrete paths. This is a deterministic,
+ * path-bounded preflight — it never deletes files and never inspects `.harness/**`
+ * internals. Returns the list of conflicting concrete paths (relative to cwd).
+ */
+export async function assessGeneratedOutputConflict(spec, cwd) {
+    const conflictPaths = [];
+    const seen = new Set();
+    for (const task of spec.tasks) {
+        const isRequireChangedFilesWriter = task.executor === "pi" &&
+            task.toolProfile === "write" &&
+            task.writerOutcomePolicy?.type === "implementation-outcome-v1" &&
+            task.writerOutcomePolicy?.requireChangedFiles === true;
+        if (!isRequireChangedFilesWriter)
+            continue;
+        const writeSet = task.writeSet ?? [];
+        for (const entry of writeSet) {
+            const normalized = entry
+                .trim()
+                .replace(/\\/g, "/")
+                .replace(/^\.\//, "");
+            if (!normalized || normalized.includes("*"))
+                continue;
+            if (seen.has(normalized))
+                continue;
+            seen.add(normalized);
+            const absolute = path.join(cwd, normalized);
+            if (await fileExists(absolute)) {
+                conflictPaths.push(normalized);
+            }
+        }
+    }
+    return conflictPaths;
+}
+async function readExistingOperatorRequest(cwd, requestId) {
+    try {
+        const raw = JSON.parse(await readFile(operatorRequestPath(cwd, requestId), "utf-8"));
+        if (raw.result && typeof raw.result === "object") {
+            return { ...raw.result, idempotentReplay: true };
+        }
+    }
+    catch {
+        // not found or unreadable
+    }
+    return undefined;
+}
+async function persistOperatorRequest(cwd, result) {
+    await writeJsonAtomic(operatorRequestPath(cwd, result.requestId), {
+        schemaVersion: 1,
+        kind: "standalone-task-rerun-request",
+        parentRunId: result.parentRunId,
+        newRunId: result.newRunId,
+        taskId: result.taskId,
+        reason: result.reason,
+        requestId: result.requestId,
+        createdAt: new Date().toISOString(),
+        result,
+    }, { repoRoot: cwd });
+}
+async function writeRerunTaskLineage(cwd, newRunId, input) {
+    const located = await locateDagRun(cwd, newRunId);
+    if (!located)
+        return;
+    await writeJsonAtomic(path.join(located.runDir, RERUN_TASK_LINEAGE_REL_PATH), {
+        schemaVersion: 1,
+        kind: "standalone-task-rerun",
+        parentRunId: input.parentRunId,
+        reason: input.reason,
+        requestId: input.requestId,
+        createdAt: new Date().toISOString(),
+    }, { repoRoot: cwd, allowCompletedFactsWrite: true });
+}
+function blockedResult(input) {
+    return {
+        ok: false,
+        parentRunId: input.parentRunId,
+        reason: input.reason,
+        requestId: input.requestId,
+        mode: "blocked",
+        blockedReason: input.blockedReason,
+        ...(input.note ? { note: input.note } : {}),
+        ...(input.taskId ? { taskId: input.taskId } : {}),
+        ...(input.conflictPaths ? { conflictPaths: input.conflictPaths } : {}),
+    };
+}
+function extractRunSummary(generateResult) {
+    if (generateResult.mode === "generate+basic-validate")
+        return undefined;
+    return generateResult.run;
+}
+function extractNewRunId(generateResult) {
+    const runSummary = extractRunSummary(generateResult);
+    return runSummary?.runId;
+}
+export async function rerunStandaloneTask(input) {
+    const existing = await readExistingOperatorRequest(input.cwd, input.requestId);
+    if (existing) {
+        return existing;
+    }
+    const located = await locateDagRun(input.cwd, input.parentRunId);
+    if (!located) {
+        throw new Error(`dag run not found: ${input.parentRunId}`);
+    }
+    const state = await readDagRunState(located.runDir);
+    const eligibility = assessStandaloneTaskRerunEligibility({
+        lifecycle: located.lifecycle,
+        state,
+    });
+    if (!eligibility.eligible) {
+        return blockedResult({
+            parentRunId: input.parentRunId,
+            reason: input.reason,
+            requestId: input.requestId,
+            blockedReason: eligibility.blockedReason,
+            note: eligibility.note,
+        });
+    }
+    const spec = await readDagRunSpec(located.runDir);
+    const taskResolution = resolveTaskIdForRerun(spec, input.taskIdOverride);
+    if (!taskResolution.taskId) {
+        return blockedResult({
+            parentRunId: input.parentRunId,
+            reason: input.reason,
+            requestId: input.requestId,
+            blockedReason: taskResolution.blockedReason,
+            note: eligibility.note,
+        });
+    }
+    const execute = input.execute ?? true;
+    // AC-001 generated-output-conflict preflight: when a real execution is
+    // requested, first generate the DAG draft (execute:false) so we can inspect
+    // the regenerated spec's requireChangedFiles writer write sets against
+    // existing/dirty generated outputs. This is deterministic and path-bounded:
+    // it never deletes files and never reads `.harness/**` internals. Only the
+    // two-phase path pays the double-generate cost; --no-execute and idempotent
+    // replays are unaffected.
+    if (execute) {
+        const preflight = await generateTaskDagUseCase({
+            repoRoot: input.cwd,
+            taskId: taskResolution.taskId,
+            cwd: input.cwd,
+            strictModels: true,
+            execute: false,
+            initOnly: false,
+            dryRun: false,
+            profile: input.profile ?? "auto",
+            profileExplicit: input.profileExplicit ?? false,
+        });
+        if (preflight.mode === "generate+basic-validate") {
+            let conflictPaths = [];
+            try {
+                const raw = await readFile(preflight.outputPath, "utf8");
+                const preflightSpec = parseDagSpec(JSON.parse(raw));
+                conflictPaths = await assessGeneratedOutputConflict(preflightSpec, input.cwd);
+            }
+            catch {
+                // If the draft cannot be parsed, fall through to the real execution
+                // path: execution's own validation will surface the structural defect.
+                conflictPaths = [];
+            }
+            if (conflictPaths.length > 0) {
+                return blockedResult({
+                    parentRunId: input.parentRunId,
+                    reason: input.reason,
+                    requestId: input.requestId,
+                    taskId: taskResolution.taskId,
+                    blockedReason: GENERATED_OUTPUT_CONFLICT_REASON,
+                    conflictPaths,
+                    note: `generated-output-conflict: existing outputs overlap requireChangedFiles writer write sets at ${conflictPaths.join(", ")}; use a fresh worktree or precisely restore the listed paths before rerunning — rerun-task will not delete files automatically and will not accept arbitrary already-satisfied generation outcomes`,
+                });
+            }
+        }
+    }
+    const generateResult = await generateTaskDagUseCase({
+        repoRoot: input.cwd,
+        taskId: taskResolution.taskId,
+        cwd: input.cwd,
+        strictModels: true,
+        execute,
+        initOnly: false,
+        dryRun: false,
+        profile: input.profile ?? "auto",
+        profileExplicit: input.profileExplicit ?? false,
+    });
+    const newRunId = extractNewRunId(generateResult);
+    const runSummary = extractRunSummary(generateResult);
+    const completedSuccessfully = !execute ||
+        (runSummary !== undefined && "status" in runSummary && runSummary.status === "finished");
+    if (execute && newRunId) {
+        await writeRerunTaskLineage(input.cwd, newRunId, {
+            parentRunId: input.parentRunId,
+            reason: input.reason,
+            requestId: input.requestId,
+        });
+    }
+    const result = {
+        ok: completedSuccessfully,
+        parentRunId: input.parentRunId,
+        reason: input.reason,
+        requestId: input.requestId,
+        mode: "generate+validate+execute",
+        taskId: taskResolution.taskId,
+        ...(newRunId ? { newRunId } : {}),
+        ...(runSummary && !completedSuccessfully && "status" in runSummary
+            ? { note: `child-run-${runSummary.status}` }
+            : eligibility.note
+                ? { note: eligibility.note }
+                : {}),
+        generateResult,
+        ...(runSummary ? { runSummary } : {}),
+    };
+    if (await fileExists(operatorRequestPath(input.cwd, input.requestId))) {
+        const replay = await readExistingOperatorRequest(input.cwd, input.requestId);
+        if (replay)
+            return replay;
+    }
+    await persistOperatorRequest(input.cwd, result);
+    return result;
+}

package/dist/workflows/dag/retry-policy.js

@@ -0,0 +1,263 @@
+import { z } from "zod";
+/**
+ * Failure categories that are safe to auto-retry for read-only Pi nodes.
+ *
+ * These are failures with no repository write side-effects: model connection
+ * interruption, provider rate-limiting, temporary provider unavailability,
+ * request timeout, or a settled read-only turn with no assistant text.
+ *
+ * `quota` is intentionally NOT included: a quota exhaustion is an account
+ * billing/plan state, not a transient rate limit, and retrying immediately
+ * will not help and may waste budget.
+ */
+export const DEFAULT_DAG_RETRY_CATEGORIES = [
+    "timeout",
+    "network",
+    "rate-limit",
+    "unavailable",
+    "empty-output",
+];
+export const STRUCTURED_OUTPUT_RETRY_CATEGORY = "output-too-large";
+export const PROTOCOL_INVALID_RETRY_CATEGORY = "protocol-invalid";
+/** Recoverable model artifact/schema formatting failure on read-only structured nodes. */
+export const STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY = "invalid-output";
+/** Provider stopReason=length truncated the response before the JSON contract completed. */
+export const STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY = "structured-output-truncated";
+/** Retry only a proven no-op from an explicitly opt-in bounded Pi writer. */
+export const WRITER_EMPTY_DIFF_RETRY_CATEGORY = "writer-empty-diff";
+/** Retry when a backend-test writer finished but Completeness Gate found missing/broken targets. */
+export const INCOMPLETE_WRITE_SET_RETRY_CATEGORY = "incomplete-write-set";
+/**
+ * Provider/transport stall or absolute timeout on a Pi exclusive writer that
+ * left zero attributed workspace writes and zero write-tool calls. Safe to
+ * retry once because the attempt was a pure provider flake (no side effects).
+ * Partial writes keep the original `timeout` category and do NOT retry.
+ */
+export const WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY = "writer-clean-timeout";
+export const STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES = [
+    ...DEFAULT_DAG_RETRY_CATEGORIES,
+    STRUCTURED_OUTPUT_RETRY_CATEGORY,
+    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
+    STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY,
+];
+/** Categories allowed on nodes that declare a machine-readable outputProtocol. */
+export const PROTOCOL_AWARE_DAG_RETRY_CATEGORIES = [
+    ...DEFAULT_DAG_RETRY_CATEGORIES,
+    PROTOCOL_INVALID_RETRY_CATEGORY,
+    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
+];
+export const ALL_DAG_RETRY_CATEGORIES = [
+    ...DEFAULT_DAG_RETRY_CATEGORIES,
+    STRUCTURED_OUTPUT_RETRY_CATEGORY,
+    PROTOCOL_INVALID_RETRY_CATEGORY,
+    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
+    STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY,
+    WRITER_EMPTY_DIFF_RETRY_CATEGORY,
+    INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
+    WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY,
+];
+const RETRY_SAFE_PI_ROLES = new Set([
+    "planner",
+    "scout",
+    "reviewer",
+    "verifier",
+    "supervisor",
+    "closeout",
+]);
+export const dagRetryCategorySchema = z.enum(ALL_DAG_RETRY_CATEGORIES);
+export const dagRetryBackoffSchema = z.enum(["exponential"]);
+/**
+ * Opt-in retry policy for a DagTask. Generated for safe read-only Pi nodes,
+ * except the single validation-gated writer-empty-diff policy. Validation
+ * rejects all other writers, dynamic, shell, static, and decision-gate nodes.
+ */
+export const dagRetryPolicySchema = z
+    .object({
+    /**
+     * Total number of attempts (including the first try). Must be 1..5.
+     * A value of 1 disables retry (one attempt, no retry).
+     */
+    maxAttempts: z.number().int().positive().max(5),
+    backoff: dagRetryBackoffSchema.default("exponential"),
+    /** Initial delay before the second attempt, in milliseconds. */
+    initialDelayMs: z.number().int().nonnegative().default(2000),
+    /** Upper bound on a single backoff delay, in milliseconds. */
+    maxDelayMs: z.number().int().nonnegative().default(30000),
+    /**
+     * Explicit set of failure categories eligible for retry. Defaults to
+     * {@link DEFAULT_DAG_RETRY_CATEGORIES}. `quota` and other categories
+     * are never retried.
+     */
+    retryCategories: z
+        .array(dagRetryCategorySchema)
+        .default([...DEFAULT_DAG_RETRY_CATEGORIES]),
+})
+    .superRefine((policy, ctx) => {
+    if (policy.maxDelayMs < policy.initialDelayMs) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "retryPolicy.maxDelayMs must be >= retryPolicy.initialDelayMs",
+            path: ["maxDelayMs"],
+        });
+    }
+});
+/**
+ * The default retry policy applied to safe generated read-only Pi nodes.
+ * Total attempts: 3, exponential backoff with cap.
+ */
+export const DEFAULT_READ_ONLY_PI_RETRY_POLICY = {
+    maxAttempts: 3,
+    backoff: "exponential",
+    initialDelayMs: 2000,
+    maxDelayMs: 30000,
+    retryCategories: [...DEFAULT_DAG_RETRY_CATEGORIES],
+};
+/**
+ * Structured planner nodes may retry with a compact-output instruction
+ * when the model produced an oversized assistant response. This category is
+ * not part of the default read-only retry set because report/review nodes
+ * should not silently learn new output semantics.
+ */
+export const STRUCTURED_REQUIRED_PI_RETRY_POLICY = {
+    ...DEFAULT_READ_ONLY_PI_RETRY_POLICY,
+    retryCategories: [...STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES],
+};
+/**
+ * Planner read-only nodes (standard DAG contract-pi / plan-pi) may retry with
+ * a compact-output instruction when the model produced an oversized assistant
+ * response. Only `output-too-large` is added on top of the default set;
+ * report/review and other read-only roles keep the default set so they do not
+ * silently learn new output semantics.
+ */
+export const PLANNER_OUTPUT_LIMIT_RETRY_POLICY = {
+    ...DEFAULT_READ_ONLY_PI_RETRY_POLICY,
+    retryCategories: [...DEFAULT_DAG_RETRY_CATEGORIES, STRUCTURED_OUTPUT_RETRY_CATEGORY],
+};
+/**
+ * Default retry for reviewer / recovery nodes that declare outputProtocol.
+ * Includes protocol-invalid so missing VERDICT lines are corrected in-node.
+ */
+export const PROTOCOL_AWARE_PI_RETRY_POLICY = {
+    ...DEFAULT_READ_ONLY_PI_RETRY_POLICY,
+    retryCategories: [...PROTOCOL_AWARE_DAG_RETRY_CATEGORIES],
+};
+/**
+ * The sole writer retry policy for requireChangedFiles writers. It is
+ * intentionally not included in any read-only default: a writer may retry only
+ * after its executor proves an otherwise successful attempt changed no files.
+ */
+export const WRITER_EMPTY_DIFF_RETRY_POLICY = {
+    maxAttempts: 2,
+    backoff: "exponential",
+    initialDelayMs: 2000,
+    maxDelayMs: 30000,
+    retryCategories: [WRITER_EMPTY_DIFF_RETRY_CATEGORY],
+};
+/**
+ * Bounded transport retry for standard exclusive implementers when a provider
+ * stall/timeout left no workspace writes. maxAttempts=2 (one retry). Never
+ * retries timeout with partial writes (those stay non-retryable `timeout`).
+ */
+export const WRITER_TRANSPORT_RETRY_POLICY = {
+    maxAttempts: 2,
+    backoff: "exponential",
+    initialDelayMs: 5000,
+    maxDelayMs: 30000,
+    retryCategories: [WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY],
+};
+/**
+ * Backend-test generation writers: empty-diff once, plus bounded incomplete-write-set
+ * recovery attempts driven by Completeness Gate (missing/broken target files).
+ */
+export const BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY = {
+    maxAttempts: 3,
+    backoff: "exponential",
+    initialDelayMs: 2000,
+    maxDelayMs: 30000,
+    retryCategories: [
+        WRITER_EMPTY_DIFF_RETRY_CATEGORY,
+        INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
+    ],
+};
+/**
+ * Deterministic helper: is this raw failure category eligible for retry under
+ * the given policy? Pure function; executor never decides retry eligibility.
+ */
+export function isRetryablePiFailureCategory(rawFailureCategory, options = {}) {
+    if (!rawFailureCategory)
+        return false;
+    const categories = options.retryCategories ?? DEFAULT_DAG_RETRY_CATEGORIES;
+    return categories.includes(rawFailureCategory);
+}
+function isExclusivePiImplementer(task) {
+    return (task.executor === "pi" &&
+        task.role === "implementer" &&
+        task.toolProfile === "write" &&
+        task.writePolicy === "exclusive" &&
+        (task.writeSet?.length ?? 0) > 0 &&
+        !task.decisionGate?.enabled &&
+        !task.dynamicExpansion &&
+        !task.dynamicReduction &&
+        !task.dynamicCondition &&
+        !task.dynamicLoopUntil);
+}
+/**
+ * Static eligibility for the requireChangedFiles writer-empty-diff class.
+ * The Pi executor assigns writer-empty-diff only after post-write-guard
+ * attribution proves an empty changedFiles list.
+ */
+export function isWriterEmptyDiffRetryCandidate(task) {
+    return (isExclusivePiImplementer(task) &&
+        task.writerOutcomePolicy?.requireChangedFiles === true);
+}
+/**
+ * Standard exclusive implementers (implementation-outcome writers) may take a
+ * single clean-timeout transport retry. Backend completeness writers already
+ * have their own policy and are excluded here.
+ */
+export function isWriterTransportRetryCandidate(task) {
+    return (isExclusivePiImplementer(task) &&
+        task.writerOutcomePolicy?.type === "implementation-outcome-v1" &&
+        task.writerOutcomePolicy.requireChangedFiles !== true);
+}
+export function isSafeReadOnlyPiRetryCandidate(task) {
+    if (task.executor !== "pi")
+        return false;
+    if (!task.role || !RETRY_SAFE_PI_ROLES.has(task.role))
+        return false;
+    if (task.toolProfile === "write")
+        return false;
+    if (task.writePolicy !== undefined &&
+        task.writePolicy !== "read-only" &&
+        task.writePolicy !== "none") {
+        return false;
+    }
+    if (task.decisionGate?.enabled)
+        return false;
+    if (task.dynamicExpansion ||
+        task.dynamicReduction ||
+        task.dynamicCondition ||
+        task.dynamicLoopUntil) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Compute the backoff delay (in ms) to wait before the given attempt number.
+ *
+ * attemptNumber is 1-based: the delay returned is the wait BEFORE that attempt
+ * runs (i.e. the wait between attempt N-1 and attempt N). attemptNumber <= 1
+ * returns 0 (no wait before the first try).
+ *
+ * Exponential: initialDelayMs * 2^(attemptNumber - 2), capped at maxDelayMs.
+ */
+export function computeBackoffDelayMs(attemptNumber, policy) {
+    if (attemptNumber <= 1)
+        return 0;
+    if (policy.backoff !== "exponential") {
+        return Math.min(policy.initialDelayMs, policy.maxDelayMs);
+    }
+    const exponent = attemptNumber - 2;
+    const raw = policy.initialDelayMs * 2 ** exponent;
+    return Math.min(raw, policy.maxDelayMs);
+}

package/dist/workflows/dag/run-store.js

@@ -0,0 +1,41 @@
+import { mkdir, rm } from "node:fs/promises";
+import path from "node:path";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { readDagRunSpec, readDagRunState, transferDagRunDir, writeDagRunState, } from "./lifecycle.js";
+export async function readRunState(runDir) {
+    return readDagRunState(runDir);
+}
+export async function writeRunState(runDir, state, options) {
+    await writeDagRunState(runDir, state, options);
+}
+export async function readRunSpec(runDir) {
+    return readDagRunSpec(runDir);
+}
+/** Prepare any lifecycle run directory (active / dry-run / init-only / …). */
+export async function prepareRunDir(runDir) {
+    await rm(runDir, { recursive: true, force: true });
+    await mkdir(runDir, { recursive: true });
+}
+/** @deprecated Prefer prepareRunDir; kept as thin alias for execute callers. */
+export async function prepareActiveRunDir(runDir) {
+    await prepareRunDir(runDir);
+}
+export async function writeRunSpec(runDir, spec) {
+    await writeJsonAtomic(path.join(runDir, "run.json"), spec);
+}
+export async function writeNodeRecord(runDir, nodeId, record) {
+    await writeJsonAtomic(path.join(runDir, `${nodeId}.json`), record);
+}
+export async function writeNodeSkillArtifacts(runDir, nodeId, resolvedSkills) {
+    if (resolvedSkills.length === 0)
+        return;
+    const nodeDir = path.join(runDir, nodeId);
+    await mkdir(nodeDir, { recursive: true });
+    await writeJsonAtomic(path.join(nodeDir, "skills.json"), { resolvedSkills });
+}
+export async function moveToPausedRunDir(runDir, pausedRunDir) {
+    return transferDagRunDir(runDir, pausedRunDir);
+}
+export async function moveToCompletedRunDir(runDir, completedRunDir) {
+    return transferDagRunDir(runDir, completedRunDir);
+}