@tea-agent/loop-agent 0.35.1-beta.3 → 0.35.1

package/dist/workflows/dag/frontend-writer-recovery.js

@@ -1,106 +0,0 @@
-import path from "node:path";
-import { readFile } from "node:fs/promises";
-import { getDagRunDir } from "./lifecycle.js";
-import { captureWriterBaseline, readJournalFile, restoreJournal, sha256HexBytes, writeJournalFile, } from "./frontend-writer-rollback.js";
-/**
- * Phase 5: writer transient partial-write recovery — compose the phase-4 rollback
- * journal with the phase-3 staged child handoff. A frontend writer attempt is
- * snapshotted before the provider call so a transient partial write can be rolled
- * back to the pre-attempt baseline, then recovered by a staged child that re-runs
- * `frontend-implement-pi`.
- *
- * The runner remains the single-writer coordinator: it captures the baseline via
- * {@link captureFrontendWriterAttemptIntent} before the writer provider call, and
- * on a transient partial write runs {@link rollbackFrontendWriter} before writing
- * the recovery intent and staging the child.
- */
-/** Rollback intent path inside a run dir (written before the writer provider call). */
-export const FRONTEND_WRITER_ROLLBACK_INTENT_REL = ".runtime/frontend-writer-rollback.json";
-export function frontendWriterRollbackIntentAbsPath(runDir) {
-    return path.join(runDir, FRONTEND_WRITER_ROLLBACK_INTENT_REL);
-}
-/**
- * AC/P1-9: capture the writeSet baseline and persist the attempt intent BEFORE
- * the writer provider call. Returns the intent path. Callers must fail the
- * attempt closed if this throws (no baseline → no rollback → no recovery).
- */
-export async function captureFrontendWriterAttemptIntent(input) {
-    const baseline = await captureWriterBaseline(input.cwd, input.writeSet);
-    const intentPath = frontendWriterRollbackIntentAbsPath(input.runDir);
-    await writeJournalFile(intentPath, baseline);
-    return intentPath;
-}
-/**
- * Record the writer attempt's changed paths and per-path attempt hashes into the
- * rollback intent AFTER the provider call. This is what makes restoreJournal able
- * to CAS-restore: it compares each changed path's current hash against the
- * recorded attempt hash before writing back the baseline.
- */
-export async function recordFrontendWriterAttempt(input) {
-    const intentPath = frontendWriterRollbackIntentAbsPath(input.runDir);
-    const snapshot = await readJournalFile(intentPath);
-    if (!snapshot)
-        return; // no baseline was captured; nothing to record
-    const changed = [...new Set(input.changedPaths)].sort((a, b) => a.localeCompare(b));
-    const fileHashes = {};
-    for (const rel of changed) {
-        try {
-            const bytes = await readFile(path.join(input.cwd, rel));
-            fileHashes[rel] = sha256HexBytes(bytes);
-        }
-        catch {
-            fileHashes[rel] = "absent";
-        }
-    }
-    snapshot.attemptChangedPaths = changed;
-    snapshot.attemptFileHashes = fileHashes;
-    await writeJournalFile(intentPath, snapshot);
-}
-/**
- * Restore the parent workspace to its pre-attempt baseline using the phase-4 CAS
- * journal. This must run BEFORE the recovery intent is written and the child is
- * staged (rollback commit point): a blocked rollback short-circuits to
- * `auto-recovery-blocked` and never stages a child.
- */
-export async function rollbackFrontendWriter(input) {
-    const parentRunDir = getDagRunDir(input.cwd, "active", input.parentRunId);
-    const snapshot = await readJournalFile(frontendWriterRollbackIntentAbsPath(parentRunDir));
-    if (!snapshot) {
-        return {
-            ok: false,
-            state: "missing-intent",
-            reason: "auto-recovery-blocked: writer rollback intent missing (baseline was not captured before the provider call)",
-        };
-    }
-    const result = await restoreJournal(snapshot, { repoRoot: input.cwd });
-    if (result.state !== "completed") {
-        return {
-            ok: false,
-            state: "blocked",
-            reason: result.blockedReason ?? "auto-recovery-blocked",
-        };
-    }
-    return {
-        ok: true,
-        state: "completed",
-        restoredPaths: result.restoredPaths,
-        snapshot,
-    };
-}
-/**
- * Transient failure categories that indicate a writer may have partially written
- * before the attempt was interrupted. Clean-timeout (zero writes) is handled by
- * the retry policy and never reaches terminal aggregation as a recovery trigger.
- */
-const TRANSIENT_WRITER_FAILURE_CATEGORIES = new Set([
-    "timeout",
-    "network",
-    "rate-limit",
-    "unavailable",
-    "terminated",
-    "disconnect",
-    "provider-error",
-]);
-export function isFrontendWriterTransientPartialWrite(input) {
-    return TRANSIENT_WRITER_FAILURE_CATEGORIES.has(input.failureCategory ?? "");
-}