@tea-agent/loop-agent 0.41.1 → 0.42.0-next.10

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, normalizeConcreteWriteSetPath, } 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,24 +152,29 @@ 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"
-        ? "authorized"
-        : "denied";
+    return result.classification === "accepted" ? "authorized" : "denied";
 }
 /** Fail-closed: leave no PENDING nodes that look "still scheduled" after abort. */
 export function markPendingNodesControllerInterrupted(state, reason = "run aborted by controller (abortSignal)") {
@@ -399,6 +414,12 @@ export async function executeDagRanksOnce(input) {
                     continue;
                 }
                 const decision = isFrontendWriterAuthorized(admission.result);
+                const normalizedWriteSet = admission.result.writeSet
+                    .map(normalizeConcreteWriteSetPath)
+                    .filter((entry) => entry !== undefined);
+                const concreteWriteSetValid = (admission.result.writeSet.length > 0 &&
+                    normalizedWriteSet.length === admission.result.writeSet.length &&
+                    new Set(normalizedWriteSet).size === normalizedWriteSet.length);
                 node.frontendWriterAdmission = {
                     schemaVersion: 1,
                     writerNodeId: id,
@@ -410,18 +431,110 @@ export async function executeDagRanksOnce(input) {
                         ? `classification: ${admission.result.classification}`
                         : null,
                 };
-                if (decision === "denied") {
+                if (decision === "denied" || !concreteWriteSetValid) {
+                    node.frontendWriterAdmission.reason = decision === "denied"
+                        ? `classification: ${admission.result.classification}`
+                        : "admission writeSet is not a concrete unique path set";
                     node.status = "SKIPPED";
                     node.skippedReason = "frontend-prewrite-not-authorized";
                     node.finishedAt = checkedAt;
                     frontendAdmissionSettled.push(id);
                 }
+                else {
+                    node.runtimeWriteAuthorization = {
+                        schemaVersion: 1,
+                        status: "validated",
+                        approvalSourceNodeId: FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT,
+                        approvalDigest: admission.result.admissionDigest,
+                        effectiveWriteSet: normalizedWriteSet,
+                    };
+                }
             }
             if (frontendAdmissionSettled.length > 0)
                 await input.persistState();
         }
         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 +549,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" &&

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),