@sema-agent/core 1.292.0 → 1.294.0

package/dist/core/runner/runtask.js

@@ -2,7 +2,7 @@ import { AgentHarness, DEFAULT_COMPACTION_SETTINGS, uuidv7 } from "../../interna
 import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, MAX_SUPPORTED_CHECKPOINT_VERSION, remainingBudgetMicroUsd, validatePendingSteer, winnerFromOutcome, } from "../checkpoint-store.js";
 import { effectiveCushionMs, estimateCycleMs, minLiveWriteoutWindowMs, recordCallSample, recordToolSample, recordTtftSample, softExecDeadlineMs, writeoutCushionMs } from "./call-cap.js";
 import { engineVersion } from "../version.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionWalltimeAbort, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionManualCancel, isCompactionWalltimeAbort, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
 import { computeCostMicroUsd, modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
@@ -41,7 +41,7 @@ import { createBrainMemorySelector } from "../memory-recall.js";
 import { buildRecallQuery, runDynamicRecall } from "../dynamic-recall.js";
 import { guardedMemoryStore } from "../memory.js";
 import { releaseSession } from "../../agents/session-util.js";
-export const DEFAULT_MAX_TURNS = 500;
+export const DEFAULT_MAX_TURNS = 1000;
 const MAX_CONSECUTIVE_COMPACTION_FAILURES = 3;
 const STOP_HOOK_BLOCK_CAP = 8;
 const COMPACTION_REGROWTH_FACTOR = 1.5;
@@ -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) }
@@ -335,9 +337,8 @@ export class Runner {
         const manualCompactRef = { requested: false, waiters: [] };
         const drainManualCompactWaiters = (outcome) => {
             manualCompactRef.requested = false;
-            manualCompactRef.instructions = undefined;
             for (const w of manualCompactRef.waiters.splice(0))
-                w(outcome);
+                w.resolve(outcome);
         };
         const runStartedAt = Date.now();
         const taskIdRef = { current: spec.taskId, sessionId: spec.sessionId };
@@ -348,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) => {
@@ -366,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"
@@ -377,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);
                 }
@@ -446,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();
@@ -532,15 +556,39 @@ export class Runner {
             compact: async (opts) => {
                 if (resultValue)
                     throw steeringError("the task has already finished");
+                if (opts?.signal?.aborted)
+                    return "mooted";
                 const h = handle ?? (await orTimeout(ready));
                 if (!h)
                     throw steeringError("the task is not running");
+                if (opts?.signal?.aborted)
+                    return "mooted";
                 return new Promise((resolve) => {
-                    manualCompactRef.requested = true;
-                    if (opts?.instructions !== undefined) {
-                        manualCompactRef.instructions = opts.instructions;
+                    const signal = opts?.signal;
+                    const entry = {
+                        resolve,
+                        ...(signal !== undefined ? { signal } : {}),
+                        ...(opts?.instructions !== undefined ? { instructions: opts.instructions } : {}),
+                    };
+                    if (signal !== undefined) {
+                        const onAbort = () => {
+                            const i = manualCompactRef.waiters.indexOf(entry);
+                            if (i >= 0) {
+                                manualCompactRef.waiters.splice(i, 1);
+                                if (manualCompactRef.waiters.length === 0) {
+                                    manualCompactRef.requested = false;
+                                }
+                                entry.resolve("mooted");
+                            }
+                        };
+                        entry.resolve = (outcome) => {
+                            signal.removeEventListener("abort", onAbort);
+                            resolve(outcome);
+                        };
+                        signal.addEventListener("abort", onAbort, { once: true });
                     }
-                    manualCompactRef.waiters.push(resolve);
+                    manualCompactRef.requested = true;
+                    manualCompactRef.waiters.push(entry);
                 });
             },
             detach: (toolCallId) => {
@@ -1626,9 +1674,8 @@ export class Runner {
         let trimForceBackoff = false;
         const drainManualCompact = (outcome) => {
             manualCompactRef.requested = false;
-            manualCompactRef.instructions = undefined;
             for (const w of manualCompactRef.waiters.splice(0))
-                w(outcome);
+                w.resolve(outcome);
         };
         const onTurnBoundary = async (event) => {
             let boundarySteered = false;
@@ -1863,17 +1910,35 @@ export class Runner {
                 return undefined;
             }
             const claimedManual = forceManual
-                ? { instructions: manualCompactRef.instructions, waiters: manualCompactRef.waiters.splice(0) }
+                ? (() => {
+                    const waiters = manualCompactRef.waiters.splice(0);
+                    let instructions;
+                    for (let i = waiters.length - 1; i >= 0; i--) {
+                        if (waiters[i].instructions !== undefined) {
+                            instructions = waiters[i].instructions;
+                            break;
+                        }
+                    }
+                    return { instructions, waiters };
+                })()
                 : undefined;
             if (forceManual) {
                 manualCompactRef.requested = false;
-                manualCompactRef.instructions = undefined;
             }
             const resolveClaimedWaiters = (outcome) => {
                 if (claimedManual !== undefined)
                     for (const w of claimedManual.waiters.splice(0))
-                        w(outcome);
+                        w.resolve(outcome);
             };
+            const claimedCancelSignals = claimedManual?.waiters.flatMap((w) => (w.signal !== undefined ? [w.signal] : [])) ?? [];
+            const manualCancelSignal = claimedCancelSignals.length === 0
+                ? undefined
+                : claimedCancelSignals.length === 1
+                    ? claimedCancelSignals[0]
+                    : AbortSignal.any(claimedCancelSignals);
+            const compactionPassSignal = claimedCancelSignals.length > 0
+                ? AbortSignal.any([prepared.abortController.signal, ...claimedCancelSignals])
+                : prepared.abortController.signal;
             const trimPressureArmed = prepared.trimPressureRef.droppedMessages;
             if (trimPressureArmed)
                 prepared.trimPressureRef.droppedMessages = false;
@@ -1893,7 +1958,8 @@ export class Runner {
                     thinking: prepared.thinking,
                     settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
                     customInstructions: manualInstructions ?? spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
-                    signal: prepared.abortController.signal,
+                    signal: compactionPassSignal,
+                    ...(manualCancelSignal !== undefined ? { manualCancelSignal } : {}),
                     minTokens: forceManual ? 0 : compactionFloor,
                     force: forceManual,
                     onInputTruncated: (info) => emitTrace(tracer, () => ({ kind: "compaction.input_truncated", version: 1, taskId, label: info.label, droppedChars: info.droppedChars, keptChars: info.keptChars, ts: Date.now() })),
@@ -1984,7 +2050,12 @@ export class Runner {
                 }
             }
             catch (err) {
-                if (!prepared.abortController.signal.aborted) {
+                const manualCancelAbort = !prepared.abortController.signal.aborted && isCompactionManualCancel(err);
+                if (manualCancelAbort) {
+                    emitTrace(tracer, () => ({ kind: "compaction.mooted", version: 1, taskId, reason: "cancelled", ts: Date.now() }));
+                    manualOutcome = "mooted";
+                }
+                else if (!prepared.abortController.signal.aborted) {
                     const walltimeAbort = isCompactionWalltimeAbort(err);
                     if (!walltimeAbort)
                         compactionBreaker.failures += 1;
@@ -2617,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;
@@ -2710,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 = {
@@ -2724,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);