@tea-agent/loop-agent 0.44.0-next.1 → 0.44.0-next.10

package/dist/infrastructure/console/operation-store.js

@@ -6,6 +6,26 @@ import { buildFrontendSplitAggregateCloseout, computeFrontendSplitDigest, finali
 import { frontendCloseoutFactsSchema, frontendTestHandoffSchema, } from "../../workflows/dag/frontend-closeout.js";
 import { listJsonFiles, readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
 export const TERMINAL_OPERATION_STATES = new Set(["succeeded", "failed", "timed-out", "restarting"]);
+/**
+ * Operation states that hold an admission slot. needs-reconcile requires
+ * inspection but does not itself prove a live operation; callers still check
+ * DAG/Worker/chat activity separately. restarting is the terminal receipt of
+ * a successful Console handoff, retained across boots, not a live slot.
+ * A needs-reconcile record remains visible as a non-business outcome, but
+ * must never strand later mutations after its runtime is gone.
+ */
+export const OCCUPIED_OPERATION_STATES = new Set(["queued", "starting", "running"]);
+/** True when the state can still make progress and therefore holds the slot. */
+export function isOperationOccupied(state) {
+    return OCCUPIED_OPERATION_STATES.has(state);
+}
+/**
+ * True when no further state transition will ever occur: a business terminal
+ * (succeeded/failed/timed-out/restarting) or a stranded needs-reconcile.
+ */
+export function isOperationSettled(state) {
+    return TERMINAL_OPERATION_STATES.has(state) || state === "needs-reconcile";
+}
 function operationFile(appData, operationId) {
     return path.join(appData.operations, `${operationId}.json`);
 }
@@ -359,14 +379,11 @@ export class OperationStore {
         for (const op of await this.list()) {
             if (TERMINAL_OPERATION_STATES.has(op.state))
                 continue;
-            // A consoleUpdateAndInit whose record already proves a requested
-            // handoff died before writing its terminal state: the update and
-            // restart themselves succeeded — the booting process IS the
-            // handoff target. Mark it succeeded instead of surfacing the
-            // generic needs-reconcile failure copy to the operator.
+            // A consoleUpdateAndInit that proved its handoff before the process
+            // died must not be reported as a stranded failure: the booting
+            // process IS the handoff target, so the update actually succeeded.
             if (op.action === "consoleUpdateAndInit" &&
-                op.state === "needs-reconcile" &&
-                isProvenConsoleUpdateHandoff(op.result)) {
+                isProvenConsoleUpdateHandoff(op)) {
                 changed.push(await this.update(op.operationId, {
                     state: "succeeded",
                     errorCode: undefined,
@@ -398,17 +415,34 @@ export function isTerminalOperationState(state) {
     return TERMINAL_OPERATION_STATES.has(state);
 }
 /**
- * True when a consoleUpdateAndInit result proves the handoff was requested
- * (install verified + init clean + new Console spawned). Used by boot
- * reconcile to close the record as succeeded even though the old process
- * died before writing its terminal state.
+ * True when a consoleUpdateAndInit record proves the handoff actually
+ * succeeded (install verified + new Console spawned), so boot reconcile can
+ * close it as succeeded even though the dying process never wrote its
+ * terminal state.
+ *
+ * The proof reads the maintenance projection rather than only `result.state`.
+ * The old check required `result.state === "restarting"`, but the executor
+ * writes `state` and `maintenance` together (`console-update-and-init.ts`),
+ * so any path that recorded the handoff proof together with a non-restarting
+ * `state` — most importantly the `needs-reconcile` record that
+ * `acceptConsoleUpdateAndInit` writes when the executor throws *after* a
+ * successful handoff — could never satisfy it. Such records were stranded
+ * forever: boot reconcile skipped them and they blocked later updates.
+ *
+ * `handoff.status === "requested"` is only ever set on the success path, and
+ * `package.status === "failed"` explicitly disqualifies a record, so this
+ * stays fail-closed for genuine failures.
  */
-function isProvenConsoleUpdateHandoff(result) {
+export function isProvenConsoleUpdateHandoff(operation) {
+    if (!operation || operation.action !== "consoleUpdateAndInit")
+        return false;
+    const result = operation.result;
     if (!result || typeof result !== "object")
         return false;
     const shape = result;
-    return (shape.state === "restarting" &&
-        shape.maintenance?.handoff?.status === "requested");
+    if (shape.maintenance?.handoff?.status !== "requested")
+        return false;
+    return shape.maintenance?.package?.status !== "failed";
 }
 export function clipPreview(text, max = 4096) {
     if (text.length <= max)

package/dist/infrastructure/evaluation/corpus-store.js

@@ -1,3 +1,4 @@
+import { readFileBoundarySafe } from "../../shared/path-safety.js";
 import { access, mkdir, readdir, readFile, rename, rm } from "node:fs/promises";
 import path from "node:path";
 import { mkdtemp } from "node:fs/promises";
@@ -30,28 +31,27 @@ async function pathExists(filePath) {
 function serializeManifest(manifest) {
     return `${JSON.stringify(manifest, null, 2)}\n`;
 }
+function compareArtifactPaths(a, b) {
+    return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+}
 function normalizeTasksForStorage(tasks) {
     return [...tasks]
         .map((task) => ({
         ...task,
         taskRef: task.taskRef.replace(/\\/g, "/"),
         seeds: [...task.seeds].sort((a, b) => a - b),
+        ...("category" in task ? {
+            requirements: [...task.requirements].sort(compareArtifactPaths),
+            initialFiles: [...task.initialFiles].sort(compareArtifactPaths),
+            oracleFiles: [...task.oracleFiles].sort(compareArtifactPaths),
+        } : {}),
     }))
         .sort((a, b) => a.taskRef < b.taskRef ? -1 : a.taskRef > b.taskRef ? 1 : 0);
 }
 export async function materializeCorpusManifest(raw) {
     const input = corpusManifestInputSchema.parse(raw);
     const tasks = normalizeTasksForStorage(input.tasks);
-    const withoutHash = {
-        schemaVersion: 1,
-        corpusId: input.corpusId,
-        createdAt: input.createdAt,
-        ...(input.description !== undefined
-            ? { description: input.description }
-            : {}),
-        tasks,
-    };
-    const corpusHash = computeCorpusHash(withoutHash);
+    const corpusHash = computeCorpusHash(input);
     if (input.corpusHash) {
         const provided = formatContentSha(normalizeContentSha(input.corpusHash));
         if (provided !== corpusHash) {
@@ -59,10 +59,30 @@ export async function materializeCorpusManifest(raw) {
         }
     }
     return corpusManifestSchema.parse({
-        ...withoutHash,
+        ...input,
+        tasks,
         corpusHash,
     });
 }
+export async function assertCorpusArtifacts(repoRoot, manifest) {
+    if (manifest.schemaVersion !== 2)
+        return;
+    const snapshots = new Map();
+    for (const task of manifest.tasks)
+        for (const ref of [...task.requirements, ...task.initialFiles, ...task.oracleFiles]) {
+            const bytes = await readFileBoundarySafe({ boundaryRoot: repoRoot,
+                targetPath: path.resolve(repoRoot, ref.path), label: "frontend corpus artifact" });
+            if (sha256Hex(bytes) !== ref.sha256)
+                throw Error(`corpus artifact hash mismatch: ${ref.path}`);
+            snapshots.set(ref.path, bytes);
+        }
+    for (const [file, expected] of snapshots) {
+        const actual = await readFileBoundarySafe({ boundaryRoot: repoRoot,
+            targetPath: path.resolve(repoRoot, file), label: "frontend corpus artifact recheck" });
+        if (!actual.equals(expected))
+            throw Error(`corpus artifact changed during collection: ${file}`);
+    }
+}
 async function assertManifestIntegrity(repoRoot, corpusId, rawManifest) {
     const integrityPath = path.join(corpusDir(repoRoot, corpusId), MANIFEST_INTEGRITY_FILE);
     const expected = (await readFile(integrityPath, "utf-8")).trim();
@@ -98,6 +118,7 @@ export async function readCorpusManifest(repoRoot, corpusId) {
     if (recomputed !== stored.corpusHash) {
         throw new Error(`corpusHash mismatch for ${corpusId}: expected ${recomputed}, got ${stored.corpusHash}`);
     }
+    await assertCorpusArtifacts(repoRoot, stored);
     return stored;
 }
 export async function listCorpusIds(repoRoot) {
@@ -117,7 +138,11 @@ export async function listCorpusIds(repoRoot) {
     }
 }
 export async function registerCorpusManifest(input) {
-    const { repoRoot, manifest } = input;
+    const repoRoot = input.repoRoot;
+    const manifest = corpusManifestSchema.parse(input.manifest);
+    if (computeCorpusHash(manifest) !== manifest.corpusHash)
+        throw Error("corpusHash mismatch");
+    await assertCorpusArtifacts(repoRoot, manifest);
     assertCorpusId(manifest.corpusId);
     const manifestPath = corpusManifestPath(repoRoot, manifest.corpusId);
     if (await pathExists(manifestPath)) {

package/dist/shared/file-identity.js

@@ -0,0 +1,23 @@
+/**
+ * Compare two stat records as the same file identity.
+ *
+ * POSIX: `dev` and `ino` together identify the inode; both must match.
+ *
+ * win32: libuv reports `dev` inconsistently across stat APIs — `fstat()`
+ * (from an open handle) returns the volume serial number while `lstat()`
+ * (from a path) returns 0. A cross-API comparison therefore always fails on
+ * Windows even when the path still refers to the same file, breaking every
+ * guard that rechecks identity after opening (user-reported on 0.42.1 and
+ * 0.43.0, Node 23.x). On win32 the `dev` field is skipped and `ino` plus the
+ * caller-side type/link/realpath checks remain the identity boundary.
+ *
+ * When both stats come from the same API the comparison is exact on every
+ * platform; the win32 relaxation only affects cross-API rechecks.
+ */
+export function sameFileIdentity(opened, current, platform = process.platform) {
+    if (current.ino !== opened.ino)
+        return false;
+    if (platform !== "win32" && current.dev !== opened.dev)
+        return false;
+    return true;
+}