@tea-agent/loop-agent 0.39.0-beta.2 → 0.39.0-beta.4

package/dist/workflows/dag/scheduler.js

@@ -3,7 +3,8 @@ 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 { frontendPrewriteResultV1Schema, FRONTEND_PREWRITE_RESULT_ARTIFACT_NAME, } from "./frontend-prewrite-gate.js";
+import { boundaryForTargetNode, computeFrontendShapeNodeDigest, evaluateFrontendShapeBoundary, } from "./frontend-shape-facts.js";
+import { FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT, frontendWriterAdmissionResultV1Schema, } from "./frontend-writer-admission.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 "));
@@ -111,16 +112,25 @@ 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);
 /**
- * Read and validate the frontend-prewrite-result-v1 artifact. Fail-closed:
- * a missing file or invalid payload returns ok:false and never throws.
+ * 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).
  */
 export async function readFrontendPrewriteResult(runDir) {
-    const artifactPath = path.join(runDir, "contracts", FRONTEND_PREWRITE_RESULT_ARTIFACT_NAME);
+    const artifactPath = path.join(runDir, FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT);
     let raw;
     try {
         raw = await readFile(artifactPath, "utf8");
@@ -129,7 +139,7 @@ export async function readFrontendPrewriteResult(runDir) {
         if (error.code === "ENOENT") {
             return {
                 ok: false,
-                reason: `frontend prewrite result artifact missing: ${artifactPath}`,
+                reason: `frontend writer admission artifact missing: ${artifactPath}`,
             };
         }
         throw error;
@@ -142,22 +152,30 @@ export async function readFrontendPrewriteResult(runDir) {
     catch (error) {
         return {
             ok: false,
-            reason: `frontend prewrite result artifact is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+            reason: `frontend writer admission artifact is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
-    const result = frontendPrewriteResultV1Schema.safeParse(parsed);
+    const result = frontendWriterAdmissionResultV1Schema.safeParse(parsed);
     if (!result.success) {
         return {
             ok: false,
-            reason: "frontend prewrite result artifact failed schema validation",
+            reason: "frontend writer admission artifact failed schema validation",
         };
     }
     return { ok: true, result: result.data, artifactHash };
 }
-/** Authorize only accepted / accepted-normalized classifications. */
+/**
+ * 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. */
 export function isFrontendWriterAuthorized(result) {
     return result.classification === "accepted" ||
-        result.classification === "accepted-normalized"
+        result.classification === "admitted"
         ? "authorized"
         : "denied";
 }
@@ -422,6 +440,86 @@ 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");
@@ -436,12 +534,12 @@ export async function executeDagRanksOnce(input) {
         if (blocked.length > 0) {
             await input.persistState();
         }
-        const pauseGateRunnable = runnableAfterAdmission.filter((id) => {
+        const pauseGateRunnable = runnableAfterShape.filter((id) => {
             const task = input.tasksById.get(id);
             return isPauseOnHumanDecisionGate(task);
         });
-        const regularRunnable = runnableAfterAdmission.filter((id) => !pauseGateRunnable.includes(id));
-        const rankWriterNodeIds = runnableAfterAdmission.filter((id) => {
+        const regularRunnable = runnableAfterShape.filter((id) => !pauseGateRunnable.includes(id));
+        const rankWriterNodeIds = runnableAfterShape.filter((id) => {
             const task = input.tasksById.get(id);
             return (task?.executor === "pi" &&
                 task.toolProfile === "write" &&