@tea-agent/loop-agent 0.41.1-beta.0 → 0.42.0-next.2

package/dist/workflows/dag/scheduler.js

@@ -3,8 +3,7 @@ import path from "node:path";
 import { isPauseOnHumanDecisionGate } from "./decision-envelope.js";
 import { evaluateConditionExpression } from "./dynamic-runtime/condition.js";
 import { sha256Hex } from "./frontend-implementation-contract.js";
-import { boundaryForTargetNode, computeFrontendShapeNodeDigest, evaluateFrontendShapeBoundary, } from "./frontend-shape-facts.js";
-import { FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT, frontendWriterAdmissionResultV1Schema, } from "./frontend-writer-admission.js";
+import { frontendPrewriteResultV1Schema, FRONTEND_PREWRITE_RESULT_ARTIFACT_NAME, } from "./frontend-prewrite-gate.js";
 import { FRONTEND_RECOVERY_IMPORT_MANIFEST_REL_PATH, FRONTEND_RECOVERY_INTENT_REL_DIR, } from "./frontend-recovery-plan.js";
 export function isConditionSkippedReason(reason) {
     return Boolean(reason?.startsWith("condition "));
@@ -112,25 +111,16 @@ async function mapConcurrent(items, limit, fn) {
 }
 export const FRONTEND_WRITER_NODE_IDS = [
     "frontend-implement-pi",
+    "frontend-repair-pi",
 ];
+/** Run-relative artifact location written by the prewrite gate generator. */
+export const FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT = path.posix.join("contracts", FRONTEND_PREWRITE_RESULT_ARTIFACT_NAME);
 /**
- * Run-relative artifact location read by the frontend writer admission gate.
- * M8 re-pointed the legacy prewrite-result source at the new
- * frontend-writer-admission-result.json artifact (written by the
- * frontend-writer-admission-shell); the exported name is retained because
- * runner.ts / node-execution.ts reference it as the admission evidence source.
- */
-export const FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT = FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT;
-export { FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT };
-/**
- * Read and validate the writer admission result artifact.
- * Fail-closed: a missing file or invalid payload returns ok:false and never
- * throws. This is the M8 write authorization source (replaces the legacy
- * frontend-prewrite-result-v1 for dispatch; the legacy artifact remains
- * produced only by the shadow `runFrontendPrewriteGate` library export).
+ * Read and validate the frontend-prewrite-result-v1 artifact. Fail-closed:
+ * a missing file or invalid payload returns ok:false and never throws.
  */
 export async function readFrontendPrewriteResult(runDir) {
-    const artifactPath = path.join(runDir, FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT);
+    const artifactPath = path.join(runDir, "contracts", FRONTEND_PREWRITE_RESULT_ARTIFACT_NAME);
     let raw;
     try {
         raw = await readFile(artifactPath, "utf8");
@@ -139,7 +129,7 @@ export async function readFrontendPrewriteResult(runDir) {
         if (error.code === "ENOENT") {
             return {
                 ok: false,
-                reason: `frontend writer admission artifact missing: ${artifactPath}`,
+                reason: `frontend prewrite result artifact missing: ${artifactPath}`,
             };
         }
         throw error;
@@ -152,30 +142,22 @@ export async function readFrontendPrewriteResult(runDir) {
     catch (error) {
         return {
             ok: false,
-            reason: `frontend writer admission artifact is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+            reason: `frontend prewrite result artifact is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
-    const result = frontendWriterAdmissionResultV1Schema.safeParse(parsed);
+    const result = frontendPrewriteResultV1Schema.safeParse(parsed);
     if (!result.success) {
         return {
             ok: false,
-            reason: "frontend writer admission artifact failed schema validation",
+            reason: "frontend prewrite result artifact failed schema validation",
         };
     }
     return { ok: true, result: result.data, artifactHash };
 }
-/**
- * M8 alias: read the writer admission result artifact under the explicit name.
- * Same fail-closed semantics as `readFrontendPrewriteResult`.
- */
-export async function readFrontendWriterAdmissionResult(runDir) {
-    return readFrontendPrewriteResult(runDir);
-}
-/** Authorize only the `accepted` classification (four-state admission).
- * `requires-human-approval`, `blocked`, and `stale` are all denied. */
+/** Authorize only accepted / accepted-normalized classifications. */
 export function isFrontendWriterAuthorized(result) {
     return result.classification === "accepted" ||
-        result.classification === "admitted"
+        result.classification === "accepted-normalized"
         ? "authorized"
         : "denied";
 }
@@ -440,86 +422,6 @@ export async function executeDagRanksOnce(input) {
         }
         const frontendAdmissionSkippedSet = new Set(frontendAdmissionSettled);
         const runnableAfterAdmission = actuallyRunnable.filter((id) => !frontendAdmissionSkippedSet.has(id));
-        // Shape boundaries are rank gates: evaluate every protected candidate
-        // before creating an executor or starting any sibling in the rank.
-        const shapeBlocked = new Set();
-        const checkedBoundaries = new Set();
-        let shapeTerminalCommitted = false;
-        for (const id of runnableAfterAdmission) {
-            const mapping = boundaryForTargetNode(id);
-            if (!mapping || checkedBoundaries.has(mapping.boundary))
-                continue;
-            checkedBoundaries.add(mapping.boundary);
-            const sourceNode = input.state.nodes[mapping.sourceNodeId];
-            const fact = input.state.frontendShapeState?.committedFacts[mapping.boundary];
-            const outcome = evaluateFrontendShapeBoundary({
-                boundary: mapping.boundary,
-                sourceNode: sourceNode
-                    ? { status: sourceNode.status, digest: computeFrontendShapeNodeDigest(sourceNode) }
-                    : undefined,
-                fact,
-            });
-            if (outcome.kind === "continue") {
-                if (input.state.frontendShapeState) {
-                    input.state.frontendShapeState.lastBoundary = mapping.boundary;
-                    input.state.frontendShapeState.lastOutcome = outcome.kind;
-                    await input.persistState();
-                }
-                continue;
-            }
-            if (outcome.kind === "blocked") {
-                if (input.state.frontendShapeState) {
-                    input.state.frontendShapeState.lastBoundary = mapping.boundary;
-                    input.state.frontendShapeState.lastOutcome = outcome.kind;
-                }
-                const finishedAt = new Date().toISOString();
-                for (const targetId of mapping.targetNodeIds) {
-                    if (!runnableAfterAdmission.includes(targetId))
-                        continue;
-                    const node = input.state.nodes[targetId];
-                    if (!node || node.status !== "PENDING")
-                        continue;
-                    node.status = "SKIPPED";
-                    node.skippedReason = outcome.reason;
-                    node.finishedAt = finishedAt;
-                    shapeBlocked.add(targetId);
-                }
-                await input.persistState();
-                continue;
-            }
-            if (!fact || !input.commitFrontendShapeTransition) {
-                const finishedAt = new Date().toISOString();
-                for (const targetId of mapping.targetNodeIds) {
-                    const node = input.state.nodes[targetId];
-                    if (!node || node.status !== "PENDING")
-                        continue;
-                    node.status = "SKIPPED";
-                    node.skippedReason = "frontend-shape-transition-cas-unavailable";
-                    node.finishedAt = finishedAt;
-                    shapeBlocked.add(targetId);
-                }
-                await input.persistState();
-                continue;
-            }
-            const committed = await input.commitFrontendShapeTransition({
-                boundary: mapping.boundary,
-                outcome: outcome.kind,
-                reason: outcome.reason,
-                expectedRevision: input.state.frontendShapeState?.revision ?? 0,
-                fact,
-            });
-            if (committed.ok) {
-                shapeTerminalCommitted = true;
-                break;
-            }
-            // A failed transition CAS must remain zero-write. Stop the controller
-            // before any executor starts; never compensate with a capsule-less
-            // terminal state or mutate pending descendants.
-            throw new Error(`frontend shape transition CAS failed at ${mapping.boundary}: ${committed.reason}`);
-        }
-        if (shapeTerminalCommitted)
-            break;
-        const runnableAfterShape = runnableAfterAdmission.filter((id) => !shapeBlocked.has(id));
         const blocked = pending.filter((id) => {
             const task = input.tasksById.get(id);
             return (dependencyReadiness(task, input.state.nodes, input.tasksById) === "skip");
@@ -534,12 +436,12 @@ export async function executeDagRanksOnce(input) {
         if (blocked.length > 0) {
             await input.persistState();
         }
-        const pauseGateRunnable = runnableAfterShape.filter((id) => {
+        const pauseGateRunnable = runnableAfterAdmission.filter((id) => {
             const task = input.tasksById.get(id);
             return isPauseOnHumanDecisionGate(task);
         });
-        const regularRunnable = runnableAfterShape.filter((id) => !pauseGateRunnable.includes(id));
-        const rankWriterNodeIds = runnableAfterShape.filter((id) => {
+        const regularRunnable = runnableAfterAdmission.filter((id) => !pauseGateRunnable.includes(id));
+        const rankWriterNodeIds = runnableAfterAdmission.filter((id) => {
             const task = input.tasksById.get(id);
             return (task?.executor === "pi" &&
                 task.toolProfile === "write" &&

package/dist/workflows/dag/skill-snapshot.js

@@ -333,11 +333,27 @@ function parseSnapshot(value) {
 export async function cloneParentSkillSnapshotForContinuation(input) {
     const parentSnapshot = await readSkillSnapshot(input.parentRunDir, input.parentRef, { expectedRunId: input.parentRunId });
     const parentSnapshotSha256 = hashSkillSnapshot(parentSnapshot);
+    const initialTaskIds = input.spec
+        ? input.spec.tasks.map((task) => task.id)
+        : parentSnapshot.initialTaskIds;
+    const bindings = input.spec
+        ? collectDagSkillSnapshotBindings(input.spec, initialTaskIds)
+        : parentSnapshot.bindings;
+    const boundProfileIds = new Set(bindings.map((binding) => binding.profileId));
+    const profiles = parentSnapshot.profiles.filter((profile) => boundProfileIds.has(profile.id));
+    for (const profileId of boundProfileIds) {
+        if (!profiles.some((profile) => profile.id === profileId)) {
+            throw new DagSkillSnapshotIntegrityError(`continuation run spec requires profile missing from parent snapshot: ${profileId}`);
+        }
+    }
     const cloned = {
         ...structuredClone(parentSnapshot),
         runId: input.newRunId,
         createdAt: (input.now ?? new Date()).toISOString(),
         mode: "continuation-from-parent",
+        initialTaskIds,
+        bindings,
+        profiles,
     };
     const ref = await writeSkillSnapshot(input.newRunDir, cloned);
     await writeJsonAtomic(path.join(input.newRunDir, ...SKILL_SNAPSHOT_CONTINUATION_REL_PATH.split("/")), {
@@ -540,6 +556,7 @@ export function buildNodePromptFromSnapshot(input) {
             spec: input.spec,
             task: input.task,
             upstream: input.upstream,
+            runDir: input.runDir,
             resolvedSkills: skillNames,
             resolvedSkillInstructions,
             maxUpstreamChars: policy.resolveMaxUpstreamChars(input.task),