npm - @tea-agent/loop-agent - Versions diffs - 0.35.1-beta.1 → 0.35.1-beta.2 - Mend

@tea-agent/loop-agent 0.35.1-beta.1 → 0.35.1-beta.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/CHANGELOG.md +10 -2
package/dist/build-stamp.json +3 -3
package/dist/executors/dag-pi-executor.js +44 -0
package/dist/shared/package-metadata.js +10 -0
package/dist/worker/console/static/assets/{index-fsjzREob.js → index-CvsQgALl.js} +26 -26
package/dist/worker/console/static/index.html +1 -1
package/dist/worker/console/static-src/app/useRecoveryConsole.js +5 -0
package/dist/worker/loop-agent/loop-agent-client.js +4 -3
package/dist/worker/observability/read-model.js +20 -0
package/dist/worker/preflight.js +2 -1
package/dist/workflows/dag/backend-test-scenario-param.js +33 -23
package/dist/workflows/dag/frontend-recovery-plan.js +73 -0
package/dist/workflows/dag/frontend-recovery-root-manifest.js +123 -0
package/dist/workflows/dag/frontend-recovery-run.js +539 -0
package/dist/workflows/dag/frontend-writer-recovery.js +106 -0
package/dist/workflows/dag/frontend-writer-rollback.js +821 -0
package/dist/workflows/dag/recovery-recommendation.js +58 -0
package/dist/workflows/dag/runner.js +201 -16
package/dist/workflows/dag/scheduler.js +159 -0
package/dist/workflows/dag/types.js +107 -0
package/package.json +1 -1

package/dist/worker/console/static/index.html CHANGED Viewed

@@ -6,7 +6,7 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <link rel="stylesheet" href="/inspect/operator-chrome.css" />
     <title>Loop 操作台 · Operator Console</title>
-    <script type="module" crossorigin src="/assets/index-fsjzREob.js"></script>
+    <script type="module" crossorigin src="/assets/index-CvsQgALl.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-hJqCPs_g.css">
   </head>
   <body>

package/dist/worker/console/static-src/app/useRecoveryConsole.js CHANGED Viewed

@@ -22,6 +22,7 @@ export function useRecoveryConsole(params) {
     const [recoveryNodesLoading, setRecoveryNodesLoading] = useState(false);
     const [recoveryRunStatus, setRecoveryRunStatus] = useState(null);
     const [recoveryFailureCategory, setRecoveryFailureCategory] = useState(null);
+    const [frontendRecovery, setFrontendRecovery] = useState(null);
     const [manualRunId, setManualRunId] = useState(false);
     const [manualNodeId, setManualNodeId] = useState(false);
     const [recoveryReport, setRecoveryReport] = useState(null);
@@ -124,6 +125,7 @@ export function useRecoveryConsole(params) {
             setRecoveryNodes([]);
             setRecoveryRunStatus(null);
             setRecoveryFailureCategory(null);
+            setFrontendRecovery(null);
             return;
         }
         setRecoveryNodesLoading(true);
@@ -167,11 +169,13 @@ export function useRecoveryConsole(params) {
                 n.failureCategory &&
                 n.failureCategory !== "success")?.failureCategory;
             setRecoveryFailureCategory(runFailure ?? nodeFailure ?? null);
+            setFrontendRecovery(body.frontendRecovery ?? null);
         }
         catch {
             setRecoveryNodes([]);
             setRecoveryRunStatus(null);
             setRecoveryFailureCategory(null);
+            setFrontendRecovery(null);
         }
         finally {
             setRecoveryNodesLoading(false);
@@ -323,6 +327,7 @@ export function useRecoveryConsole(params) {
         recoveryRunsLoading,
         recoveryNodesLoading,
         recoveryRunStatus,
+        frontendRecovery,
         manualRunId,
         setManualRunId,
         manualNodeId,

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

@@ -2,7 +2,7 @@ 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, readPackageName, readPackageVersion, resolveBinPaths, resolveCmdShim, } from "../../shared/package-metadata.js";
+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;
@@ -182,10 +182,11 @@ export class LoopAgentClient {
         if (!this._identity) {
             throw new Error("controller identity: cannot record a reported version without a pinned identity");
         }
-        if (reportedVersion !== this._identity.packageVersion) {
+        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 };
+        this._identity = { ...this._identity, reportedVersion: normalized };
         return this._identity;
     }
     async run(args, options) {

package/dist/worker/observability/read-model.js CHANGED Viewed

@@ -1491,6 +1491,7 @@ function mergeDagRun(existing, incoming) {
         failureCategory: incoming.failureCategory ?? existing.failureCategory,
         stateConsistent: incoming.stateConsistent ?? existing.stateConsistent,
         recoveryEligibility: incoming.recoveryEligibility ?? existing.recoveryEligibility,
+        frontendRecovery: incoming.frontendRecovery ?? existing.frontendRecovery,
         title: incoming.title ?? existing.title,
         startedAt,
         finishedAt,
@@ -1790,6 +1791,23 @@ async function loadFrontendLintProjection(runDir) {
         blockingReasons: parsed.data.blockingReasons,
     };
 }
+function projectFrontendRecovery(state) {
+    const s = state.frontendRecoveryState;
+    const r = state.frontendRecoveryResult;
+    if (!s && !r)
+        return undefined;
+    return {
+        ...(s?.recoveryRootRunId ? { recoveryRootRunId: s.recoveryRootRunId } : {}),
+        ...(s?.parentRunId ? { parentRunId: s.parentRunId } : {}),
+        ...(s?.childRunId ? { childRunId: s.childRunId } : {}),
+        ...(s?.attemptIndex !== undefined ? { attemptIndex: s.attemptIndex } : {}),
+        ...(s?.continuationCount !== undefined
+            ? { continuationCount: s.continuationCount }
+            : {}),
+        ...(s?.phase ? { phase: s.phase } : {}),
+        ...(r?.outcome ? { outcome: r.outcome } : {}),
+    };
+}
 async function parseDagStateFile(statePath, now) {
     try {
         if (!existsSync(statePath))
@@ -1860,6 +1878,7 @@ async function parseDagStateFile(statePath, now) {
             loadBackendTestProjection(runDir, nodes),
             loadFrontendLintProjection(runDir),
         ]);
+        const frontendRecovery = projectFrontendRecovery(state);
         const continuationRecord = state.continuation &&
             typeof state.continuation.parentRunId === "string" &&
             typeof state.continuation.effectiveFromNodeId === "string" &&
@@ -1918,6 +1937,7 @@ async function parseDagStateFile(statePath, now) {
             ...(continuation ? { continuation } : {}),
             ...(backendTest ? { backendTest } : {}),
             ...(frontendLint ? { frontendLint } : {}),
+            ...(frontendRecovery ? { frontendRecovery } : {}),
         };
     }
     catch {

package/dist/worker/preflight.js CHANGED Viewed

@@ -1,5 +1,6 @@
 import { access } from "node:fs/promises";
 import path from "node:path";
+import { normalizeCliVersionLabel } from "../shared/package-metadata.js";
 import { controllerIdentityExpectationFailure, resolveControllerIdentity, } from "./loop-agent/loop-agent-client.js";
 export const DEFAULT_CHECK_REPO_TIMEOUT_MS = 300_000;
 export async function preflightTargetRepo(input) {
@@ -47,7 +48,7 @@ export async function preflightTargetRepo(input) {
             controllerIdentity: identity,
         };
     }
-    const reportedVersion = version.stdout.trim();
+    const reportedVersion = normalizeCliVersionLabel(version.stdout);
     let controllerIdentity = identity
         ? { ...identity, reportedVersion }
         : undefined;

package/dist/workflows/dag/backend-test-scenario-param.js CHANGED Viewed

@@ -724,30 +724,40 @@ export function deterministicRewriteScenarioParam(input) {
     return { ok: true, source: nextSource, detail: "rewritten" };
 }
 function validatePythonSyntaxWithoutExecution(source) {
-    const result = spawnSync("python", ["-c", "import ast,sys; ast.parse(sys.stdin.read())"], {
-        input: source,
-        encoding: "utf8",
-        env: {
-            ...process.env,
-            PYTHONDONTWRITEBYTECODE: "1",
-            PYTHONUTF8: "1",
-        },
-        timeout: 15_000,
-    });
-    if (result.error) {
-        return {
-            ok: false,
-            detail: `python syntax validation unavailable: ${result.error.message}`,
-        };
-    }
-    if (result.status !== 0) {
-        const detail = String(result.stderr || result.stdout || "invalid Python syntax")
-            .trim()
-            .replace(/\s+/g, " ")
-            .slice(0, 500);
-        return { ok: false, detail: `python syntax validation failed: ${detail}` };
+    // Prefer `python3` (present on modern POSIX images and macOS); fall back to
+    // `python` for older or Windows layouts where only the unversioned shim exists.
+    // A missing interpreter must not silently roll back an otherwise-valid
+    // deterministic rewrite.
+    const candidates = ["python3", "python"];
+    let lastError;
+    for (const interpreter of candidates) {
+        const result = spawnSync(interpreter, ["-c", "import ast,sys; ast.parse(sys.stdin.read())"], {
+            input: source,
+            encoding: "utf8",
+            env: {
+                ...process.env,
+                PYTHONDONTWRITEBYTECODE: "1",
+                PYTHONUTF8: "1",
+            },
+            timeout: 15_000,
+        });
+        if (result.error) {
+            lastError = result.error.message;
+            continue;
+        }
+        if (result.status !== 0) {
+            const detail = String(result.stderr || result.stdout || "invalid Python syntax")
+                .trim()
+                .replace(/\s+/g, " ")
+                .slice(0, 500);
+            return { ok: false, detail: `python syntax validation failed: ${detail}` };
+        }
+        return { ok: true, detail: "python ast.parse PASS" };
     }
-    return { ok: true, detail: "python ast.parse PASS" };
+    return {
+        ok: false,
+        detail: `python syntax validation unavailable: ${lastError ?? "python/python3 not found"}`,
+    };
 }
 export async function applyDeterministicScenarioParamRepairs(input) {
     const repairable = input.facts.entries.filter((entry) => entry.status === "MISMATCH" && entry.repairability === "repairable");

package/dist/workflows/dag/frontend-recovery-plan.js ADDED Viewed

@@ -0,0 +1,73 @@
+import { computeResetClosure } from "./rerun-plan.js";
+/**
+ * Frontend-only candidate-continuation recovery planning (AC-5).
+ *
+ * Distinct from the generic `dag rerun` reset closure: the failure source is
+ * derived from the prewrite-result's `selectedPlanNodeId` rather than an
+ * operator-selected node, and the closure starts at the specific frontend
+ * candidate producer that failed.
+ */
+/** Idempotency namespace for requestId-keyed recovery intents (D2). */
+export const FRONTEND_RECOVERY_INTENT_REL_DIR = ".runtime/frontend-recovery";
+/** Import manifest path inside the child run dir; hashed into the activation marker. */
+export const FRONTEND_RECOVERY_IMPORT_MANIFEST_REL_PATH = ".runtime/import-manifest.json";
+/** Staging directory prefix under `active/` for in-flight child materialization. */
+export const FRONTEND_RECOVERY_STAGING_PREFIX = ".frontend-recovery-staging-";
+export function deriveFrontendRecoveryFailureSource(result) {
+    if (result.selectedPlanNodeId === "frontend-plan-revision-pi") {
+        return "frontend-plan-revision-pi";
+    }
+    if (result.selectedPlanNodeId === "frontend-plan-pi") {
+        return "frontend-plan-pi";
+    }
+    return "frontend-prewrite-gate-shell";
+}
+/**
+ * Compute the frontend candidate-continuation reset partition:
+ * - `frontend-plan-pi` failure → reset plan + design-review + prewrite (+ descendants);
+ * - `frontend-plan-revision-pi` failure → reset revision + final-review + prewrite (+ descendants);
+ * - prewrite-only materialization → reset prewrite (+ descendants), reuse verified plan/review.
+ *
+ * Everything upstream of the failure source is imported as verified parent facts.
+ */
+export function computeFrontendRecoveryPlan(input) {
+    const failureSource = deriveFrontendRecoveryFailureSource(input.result);
+    return computeFrontendRecoveryPlanForSource({
+        spec: input.spec,
+        parentRunId: input.parentRunId,
+        requestId: input.requestId,
+        failureSource,
+    });
+}
+/**
+ * Phase 5: writer transient partial-write recovery plan. The writer itself
+ * failed after some bounded writes, so the child re-runs `frontend-implement-pi`
+ * (and its descendants) while importing the verified contract/scout/plan/prewrite
+ * facts. Everything upstream of the writer is imported; the writer + descendants
+ * are reset.
+ */
+export function computeFrontendWriterRecoveryPlan(input) {
+    return computeFrontendRecoveryPlanForSource({
+        spec: input.spec,
+        parentRunId: input.parentRunId,
+        requestId: input.requestId,
+        failureSource: "frontend-implement-pi",
+    });
+}
+function computeFrontendRecoveryPlanForSource(input) {
+    const resetNodeIds = computeResetClosure(input.spec, input.failureSource);
+    const resetSet = new Set(resetNodeIds);
+    const importedNodeIds = input.spec.tasks
+        .map((task) => task.id)
+        .filter((nodeId) => !resetSet.has(nodeId))
+        .sort();
+    return {
+        schemaVersion: 1,
+        parentRunId: input.parentRunId,
+        requestId: input.requestId,
+        failureSource: input.failureSource,
+        resetNodeIds,
+        importedNodeIds,
+    };
+}
+export { computeFrontendRecoveryPlanForSource };

package/dist/workflows/dag/frontend-recovery-root-manifest.js ADDED Viewed

@@ -0,0 +1,123 @@
+import { mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+/**
+ * Phase 6: frontend recovery root manifest — the single final read model for a
+ * frontend recovery chain. A "root" is the first physical run of a
+ * frontend-implementation attempt; its parent/child lineage is counted once
+ * under `recoveryRootRunId`. report/Console read the manifest for dedup and
+ * final-status display instead of scanning parent/child fields (P1-4).
+ */
+export const FRONTEND_RECOVERY_ROOT_MANIFEST_SCHEMA_ID = "frontend-recovery-root-manifest-v1";
+export const frontendRecoveryRootManifestSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(FRONTEND_RECOVERY_ROOT_MANIFEST_SCHEMA_ID),
+    recoveryRootRunId: z.string().min(1),
+    /** Terminal logical status for the whole chain (finished/partial_failed/failed). */
+    status: z.enum(["finished", "partial_failed", "failed"]),
+    outcome: z.enum([
+        "none",
+        "recovered",
+        "candidate-contract-invalid",
+        "prewrite-blocked",
+        "repair-exhausted",
+        "auto-recovery-blocked",
+    ]),
+    attempts: z.array(z
+        .object({
+        runId: z.string().min(1),
+        role: z.enum(["root", "child"]),
+        attemptIndex: z.number().int().min(0),
+        outcome: z.enum([
+            "none",
+            "recovered",
+            "candidate-contract-invalid",
+            "prewrite-blocked",
+            "repair-exhausted",
+            "auto-recovery-blocked",
+        ]),
+        status: z.enum(["finished", "partial_failed", "failed"]),
+    })
+        .strict()),
+    evidenceRefs: z.array(z
+        .object({
+        runId: z.string().min(1),
+        relativePath: z.string().min(1),
+        sha256: z.string().min(1),
+    })
+        .strict()),
+    createdAt: z.string().min(1),
+})
+    .strict();
+/** Relative path of the root manifest inside a run dir. */
+export const FRONTEND_RECOVERY_ROOT_MANIFEST_REL = "contracts/frontend-recovery-root-manifest.json";
+export function frontendRecoveryRootManifestAbsPath(runDir) {
+    return path.join(runDir, FRONTEND_RECOVERY_ROOT_MANIFEST_REL);
+}
+export async function writeFrontendRecoveryRootManifest(runDir, manifest) {
+    const abs = frontendRecoveryRootManifestAbsPath(runDir);
+    await mkdir(path.dirname(abs), { recursive: true });
+    await writeJsonAtomic(abs, manifest);
+    return abs;
+}
+export async function readFrontendRecoveryRootManifest(runDir) {
+    try {
+        const raw = JSON.parse(await readFile(frontendRecoveryRootManifestAbsPath(runDir), "utf8"));
+        const parsed = frontendRecoveryRootManifestSchema.safeParse(raw);
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Build a root manifest from a converged root run's lineage. The manifest is the
+ * single authority for final status/outcome: parent keeps its raw failure status,
+ * the chain's logical status is only `finished` when a child finished and the
+ * outcome is `recovered`.
+ */
+export function buildFrontendRecoveryRootManifest(input) {
+    const status = input.outcome === "recovered" ? "finished" : "failed";
+    return {
+        schemaVersion: 1,
+        schemaId: FRONTEND_RECOVERY_ROOT_MANIFEST_SCHEMA_ID,
+        recoveryRootRunId: input.recoveryRootRunId,
+        status,
+        outcome: input.outcome,
+        attempts: input.attempts,
+        evidenceRefs: input.evidenceRefs ?? [],
+        createdAt: input.createdAt ?? new Date().toISOString(),
+    };
+}
+/**
+ * Dedup a set of DAG runs by recovery root (P1-4): each root contributes exactly
+ * one summary; parent/child physical runs are folded into the root's attempts.
+ * A run with no `frontendRecoveryState` is its own single-attempt root.
+ */
+export function aggregateFrontendRecoveryRoots(runs) {
+    const byRoot = new Map();
+    for (const run of runs) {
+        const rootId = run.frontendRecoveryState?.recoveryRootRunId ?? run.runId;
+        const list = byRoot.get(rootId) ?? [];
+        list.push(run);
+        byRoot.set(rootId, list);
+    }
+    const result = [];
+    for (const [rootId, list] of byRoot) {
+        const sorted = [...list].sort((a, b) => (a.frontendRecoveryState?.attemptIndex ?? 0) -
+            (b.frontendRecoveryState?.attemptIndex ?? 0));
+        // The root's displayed status is the last attempt's status, unless the
+        // root run itself finished (a child recovered only surfaces `finished`
+        // via the manifest, not via the raw root run status).
+        const last = sorted[sorted.length - 1];
+        result.push({
+            recoveryRootRunId: rootId,
+            status: last.status,
+            attemptCount: sorted.length,
+            runIds: sorted.map((run) => run.runId),
+        });
+    }
+    return result;
+}