@sema-agent/core 1.293.0 → 1.294.0

package/dist/core/runner/runtask.js

@@ -213,6 +213,8 @@ export class Runner {
     sessionLocks = new Map();
     snapshotTooLargeRoots = new Map();
     pendingSessionNotifications = new PendingSessionNotifications();
+    parentConstraintRegistry = new Map();
+    static PARENT_CONSTRAINT_REGISTRY_CAP = 1024;
     constructor(deps) {
         this.deps = deps.memoryStore
             ? { ...deps, memoryStore: guardedMemoryStore(deps.memoryStore, deps.utilityGate) }
@@ -347,6 +349,18 @@ export class Runner {
             try {
                 await this.runLocked(spec, queue, (r) => {
                     resultValue = r;
+                    const pcs = internals?.inheritedGate?.parentConstraints;
+                    if (resume !== undefined && r.checkpointToken !== resume.cp.token) {
+                        this.parentConstraintRegistry.delete(resume.cp.token);
+                    }
+                    if (r.status === "suspended" && r.checkpointToken !== undefined && pcs !== undefined && pcs.length > 0) {
+                        if (this.parentConstraintRegistry.size >= Runner.PARENT_CONSTRAINT_REGISTRY_CAP) {
+                            const oldest = this.parentConstraintRegistry.keys().next().value;
+                            if (oldest !== undefined)
+                                this.parentConstraintRegistry.delete(oldest);
+                        }
+                        this.parentConstraintRegistry.set(r.checkpointToken, pcs);
+                    }
                 }, (p) => {
                     consolidationDone = p;
                 }, (p) => {
@@ -365,7 +379,7 @@ export class Runner {
             }
         })();
         const settled = run.catch(async (err) => {
-            const code = errorCodeOf(err);
+            let code = errorCodeOf(err);
             const reopenReason = code === "resume.env_failed"
                 ? "env_failed"
                 : code === "resume.tool_unavailable"
@@ -376,10 +390,20 @@ export class Runner {
                 try {
                     await resume.onEnvRestoreFailed(reopenReason);
                 }
-                catch {
+                catch (reopenErr) {
+                    this.parentConstraintRegistry.delete(resume.cp.token);
+                    if (errorCodeOf(reopenErr) === "checkpoint.reopen_failed") {
+                        const original = err instanceof Error ? err : new Error(String(err));
+                        const reopenMsg = reopenErr instanceof Error ? reopenErr.message : String(reopenErr);
+                        err = Object.assign(new Error(`${reopenMsg} (original resume failure: ${original.message})`, { cause: original }), {
+                            code: "checkpoint.reopen_failed",
+                        });
+                        code = "checkpoint.reopen_failed";
+                    }
                 }
             }
-            else if (resume && !reopenable) {
+            else if (resume) {
+                this.parentConstraintRegistry.delete(resume.cp.token);
                 try {
                     await this.sessions.unpin?.(resume.cp.sessionId);
                 }
@@ -445,6 +469,7 @@ export class Runner {
             }
             if (!won)
                 return;
+            this.parentConstraintRegistry.delete(rh.token);
             if (rh.env && hasDestroy(rh.env)) {
                 try {
                     await rh.env.destroy();
@@ -2663,6 +2688,15 @@ export class Runner {
         if (!cp) {
             throw new CheckpointError("checkpoint.not_found", "no checkpoint found for the supplied token");
         }
+        if ((internals?.inheritedGate?.parentConstraints?.length ?? 0) === 0) {
+            const parked = this.parentConstraintRegistry.get(token);
+            if (parked !== undefined) {
+                internals = {
+                    ...(internals ?? {}),
+                    inheritedGate: { ...(internals?.inheritedGate ?? {}), parentConstraints: parked },
+                };
+            }
+        }
         let wakeMessage;
         if (outcome.gate === "wake") {
             const gk = cp.gate.kind;
@@ -2756,12 +2790,28 @@ export class Runner {
         if (cp.state.workspaceHandle !== undefined && this.deps.executionEnvFactory === undefined) {
             throw new CheckpointError("checkpoint.unsupported_version", "checkpoint has a remote workspaceHandle but no RunnerDeps.executionEnvFactory is wired to rebuild the env");
         }
+        if (cp.state.inheritedGate?.requiresParentConstraint === true) {
+            const supplied = internals?.inheritedGate?.parentConstraints?.length ?? 0;
+            if (supplied === 0) {
+                throw new CheckpointError("resume.parent_constraint_missing", "this checkpoint's task ran under inherited parent-policy constraints (state.inheritedGate.requiresParentConstraint) " +
+                    "— the live policy/onAsk closures cannot be persisted, so the resume must re-supply them via " +
+                    "resumeStream(token, outcome, taskConfig, internals) with internals.inheritedGate.parentConstraints; " +
+                    "rejected pre-CAS (the checkpoint stays pending) rather than silently dropping the ancestors' gate");
+            }
+            const expected = cp.state.inheritedGate.parentConstraintCount;
+            if (expected !== undefined && supplied !== expected) {
+                throw new CheckpointError("resume.parent_constraint_mismatch", `re-supplied ${supplied} parent constraint(s) but the checkpoint recorded ${expected} — a partial/mismatched ` +
+                    "re-supply would run the resumed leg under a different ancestor chain than it suspended with; " +
+                    "rejected pre-CAS (the checkpoint stays pending) — re-resume with the full original chain");
+            }
+        }
         const won = await store.resolve(token, cp.scope, outcome, { rev: cp.rev ?? 0 });
         if (!won) {
             const live = await store.get(token);
             if (live?.status === "pending") {
                 throw new CheckpointError("checkpoint.reopened_concurrently", "checkpoint changed concurrently (its revision advanced via a resolve/reopen cycle since this resume validated) — not executed; re-resume against the current state");
             }
+            this.parentConstraintRegistry.delete(token);
             throw new CheckpointError("checkpoint.already_resolved", "checkpoint already resolved or expired — not re-executed (idempotent)");
         }
         const spec = {
@@ -2770,9 +2820,13 @@ export class Runner {
             sessionId: cp.sessionId,
             preemptSignal: taskConfig.preemptSignal?.aborted ? undefined : taskConfig.preemptSignal,
         };
-        const onEnvRestoreFailed = store.reopen
+        const reopenFn = store.reopen?.bind(store);
+        const onEnvRestoreFailed = reopenFn
             ? async (reason) => {
-                await store.reopen?.(token, cp.scope, reason);
+                const reopened = await reopenFn(token, cp.scope, reason);
+                if (!reopened) {
+                    throw new CheckpointError("checkpoint.reopen_failed", "checkpoint could not be reopened for a retry (missing, expired, or changed concurrently) — the resume failure is terminal");
+                }
             }
             : undefined;
         return this.runTaskStream(spec, { cp, outcome, onEnvRestoreFailed, ...(wakeMessage !== undefined ? { wakeMessage } : {}) }, internals);