@sema-agent/core 1.293.0 → 1.295.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();
@@ -1199,7 +1224,8 @@ export class Runner {
         const batchArgs = postToolBatchHook ? new Map() : undefined;
         let toolBatch = [];
         const onToolStart = (event) => {
-            toolStartAt.set(event.toolCallId, Date.now());
+            const startAt = Date.now();
+            toolStartAt.set(event.toolCallId, startAt);
             startedToolCallIds.add(event.toolCallId);
             batchArgs?.set(event.toolCallId, event.args);
             stats.toolCalls += 1;
@@ -1210,7 +1236,7 @@ export class Runner {
                     groundingSignalPostR9 = true;
             }
             const activityArg = primaryActivityArg(event.args);
-            internals?.onActivity?.({ phase: "start", toolCallId: event.toolCallId, toolName: event.toolName, ...(activityArg !== undefined ? { arg: activityArg } : {}) });
+            internals?.onActivity?.({ phase: "start", toolCallId: event.toolCallId, toolName: event.toolName, at: startAt, ...(activityArg !== undefined ? { arg: activityArg } : {}) });
             pushContent({
                 type: "tool_start",
                 toolCallId: event.toolCallId,
@@ -1260,7 +1286,7 @@ export class Runner {
                 ok: !event.isError,
                 ts: toolNow,
             }));
-            internals?.onActivity?.({ phase: "end", toolCallId: event.toolCallId, toolName: event.toolName, isError: event.isError });
+            internals?.onActivity?.({ phase: "end", toolCallId: event.toolCallId, toolName: event.toolName, isError: event.isError, at: toolNow });
             if (prepared.lspDiagnostics && !event.isError) {
                 const name = canonicalToolName(event.toolName);
                 if (name === "Edit" || name === "Write" || name === "NotebookEdit") {
@@ -2421,7 +2447,7 @@ export class Runner {
                 prepared.suspendRef.token === undefined &&
                 prepared.reviewRef.token === undefined;
             try {
-                await defaultTaskRegistry.settleKilledForOwner({ owner: spec.taskId ?? prepared.sessionId, scope: spec.principal ?? "default" }, {
+                await defaultTaskRegistry.settleKilledForOwner({ owner: spec.taskId ?? prepared.sessionId, scope: spec.principal ?? "default", sessionId: prepared.sessionId }, {
                     source: abortedLive &&
                         !timeout.fired &&
                         !turnsExceeded &&
@@ -2432,6 +2458,7 @@ export class Runner {
                         : "parent",
                     skipSessionScoped: true,
                     envDying: ownedEnvDying,
+                    retainProcesses: spec.retainBackgroundProcesses === true,
                 });
             }
             catch (e) {
@@ -2442,13 +2469,15 @@ export class Runner {
                 }
             }
             const bgEnv = prepared.ownedEnv ?? this.deps.executionEnv;
-            if (bgEnv && hasBackgroundShell(bgEnv)) {
+            const retainBgBySpec = spec.retainBackgroundProcesses === true && !ownedEnvDying;
+            if (bgEnv && hasBackgroundShell(bgEnv) && !retainBgBySpec) {
                 try {
                     const keepAlive = ownedEnvDying && bgEnv === prepared.ownedEnv
                         ? []
                         : [
                             ...defaultTaskRegistry.sessionResidentShellIds(prepared.sessionId, bgEnv),
                             ...defaultTaskRegistry.timeoutResidentShellIds(bgEnv),
+                            ...defaultTaskRegistry.retainedShellIds(bgEnv),
                         ];
                     await bgEnv.disposeBackgroundShells(keepAlive.length > 0 ? { except: keepAlive } : undefined);
                 }
@@ -2663,6 +2692,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 +2794,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 +2824,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);