@hunterzhu/pulse-runtime 0.1.5 → 0.1.7

package/dist/scheduler/runtime.js

@@ -24,6 +24,7 @@ import { prepareFindingPublication } from '../storage/findings.js';
 import { runtimeErrorFromCause } from '../core/errors.js';
 import { RuntimeToolRegistry } from '../tools/registry.js';
 import { SchedulerDecisionCoordinator, schedulerDecisionCandidateFromLane } from './decision.js';
+import { HumanArbitrationCoordinator, ruleHumanArbitration } from './human-arbitration.js';
 function encodeEffectExecution(execution) {
     const encoded = structuredClone(execution);
     const artifact = execution.artifact;
@@ -111,6 +112,19 @@ function validateHostCommand(command) {
         }
         return;
     }
+    if (value.type === 'human_input') {
+        if (typeof value.agentId !== 'string' || value.agentId.length === 0 || typeof value.inputId !== 'string' || value.inputId.length === 0)
+            throw new Error('INVALID_HOST_COMMAND');
+        if (value.targetEffectId !== undefined && (typeof value.targetEffectId !== 'string' || value.targetEffectId.length === 0))
+            throw new Error('INVALID_HOST_COMMAND');
+        try {
+            strictJsonValue(value.value);
+        }
+        catch {
+            throw new Error('INVALID_HOST_COMMAND_VALUE');
+        }
+        return;
+    }
     if (value.type === 'cancel' || value.type === 'cancel_effect') {
         if (typeof value.agentId !== 'string' || value.agentId.length === 0 || typeof value.reason !== 'string' || value.reason.length === 0)
             throw new Error('INVALID_HOST_COMMAND');
@@ -125,6 +139,31 @@ function validateHostCommand(command) {
     }
     throw new Error('INVALID_HOST_COMMAND');
 }
+function parseHumanArbitrationDecision(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    const actions = new Set(['respond', 'steer', 'spawn', 'defer', 'cancel']);
+    if (typeof candidate.decisionId !== 'string' || typeof candidate.inputId !== 'string' || typeof candidate.agentId !== 'string' || typeof candidate.modelId !== 'string' || typeof candidate.action !== 'string' || !actions.has(candidate.action))
+        return undefined;
+    if (candidate.targetLaneId !== undefined && typeof candidate.targetLaneId !== 'string')
+        return undefined;
+    if (candidate.targetEffectId !== undefined && typeof candidate.targetEffectId !== 'string')
+        return undefined;
+    if (candidate.reason !== undefined && typeof candidate.reason !== 'string')
+        return undefined;
+    return {
+        schemaVersion: 1,
+        decisionId: candidate.decisionId,
+        inputId: candidate.inputId,
+        agentId: candidate.agentId,
+        action: candidate.action,
+        ...(candidate.targetLaneId === undefined ? {} : { targetLaneId: candidate.targetLaneId }),
+        ...(candidate.targetEffectId === undefined ? {} : { targetEffectId: candidate.targetEffectId }),
+        ...(candidate.reason === undefined ? {} : { reason: candidate.reason }),
+        modelId: candidate.modelId,
+    };
+}
 function artifactOutput(value) {
     if (value instanceof Uint8Array)
         return { mediaType: 'application/octet-stream', content: new Uint8Array(value) };
@@ -414,6 +453,13 @@ export class PulseRuntime {
     auditLogPrivacy;
     persistenceBackend;
     sessionStore;
+    /**
+     * The file session store is synchronous by design, so avoid rewriting an
+     * unchanged warm-start snapshot on every scheduler tick.  Without this
+     * guard an idle run can spend its whole event loop serializing and fsyncing
+     * the same snapshot, starving effect dispatch and human input handling.
+     */
+    sessionStoreDigests = new Map();
     enforcingRecoveryPrograms;
     toolVersions;
     recoveryCompatibility;
@@ -456,6 +502,7 @@ export class PulseRuntime {
     factInboxDedupeArchive;
     customExecutor;
     builtinHumanEffects;
+    humanInputProgram;
     enqueueSeq = 1;
     maxSteps;
     maxTickMs;
@@ -468,6 +515,10 @@ export class PulseRuntime {
     maxPreparedLLMs;
     effectSubmissionPreparer;
     schedulerDecisionCoordinator;
+    humanArbitrationCoordinator;
+    humanArbitrationModelId;
+    humanArbitrationRequestSeq = 1;
+    humanArbitrationRequests = new Map();
     schedulerDecisionConfig;
     schedulerDecisionModelId;
     schedulerDecisionMaxReorderDistance;
@@ -482,7 +533,15 @@ export class PulseRuntime {
     sessionId;
     hostCommandSeq = 1;
     factWaiters = [];
+    activityWaiters = new Set();
     wakeScheduled = false;
+    /**
+     * A lock grant can happen synchronously while an effect completion is being
+     * applied inside tick(). scheduleWake() intentionally avoids re-entering the
+     * drain in that case, so remember forced wake requests and service them once
+     * the current drain has finished.
+     */
+    wakeAfterDrain = false;
     inDrain = false;
     wakeError;
     tickBudget;
@@ -616,6 +675,8 @@ export class PulseRuntime {
             timeoutMs: this.schedulerDecisionConfig.decisionTimeoutMs,
             maxOutstanding: this.schedulerDecisionConfig.maxOutstandingDecisions,
         });
+        this.humanArbitrationModelId = config.humanArbitration?.model?.id;
+        this.humanArbitrationCoordinator = config.humanArbitration?.model === undefined ? undefined : new HumanArbitrationCoordinator(config.humanArbitration.model, config.humanArbitration.timeoutMs ?? 250);
         this.telemetryExporter = config.telemetryExporter;
         this.auditLogSink = config.auditLogSink;
         this.auditLogPrivacy = config.auditLogPrivacy;
@@ -639,6 +700,11 @@ export class PulseRuntime {
         this.syncStoragePolicy();
     }
     register(program) { this.programs.register(program); }
+    /** Register the program used for urgent, concurrent human interactions. */
+    setHumanInputProgram(program) {
+        this.register(program);
+        this.humanInputProgram = program;
+    }
     createAgent(goalOrRequest, program, agentId) {
         if (this.shuttingDown)
             throw new Error('RUNTIME_SHUTTING_DOWN');
@@ -750,6 +816,190 @@ export class PulseRuntime {
     }
     start(agentId) { if (!this.state.agents.has(agentId))
         throw new Error(`UNKNOWN_AGENT:${agentId}`); return new PulseSession(this, agentId); }
+    /** Accept external human input without waiting for the current Effect to settle. */
+    submitHumanInput(agentId, inputId, value, targetEffectId) {
+        if (!agentId)
+            throw new Error('INVALID_AGENT_ID');
+        if (!inputId)
+            throw new Error('INVALID_HUMAN_INPUT_ID');
+        strictJsonValue(value);
+        return this.enqueueHostCommand({ type: 'human_input', agentId, inputId, value, ...(targetEffectId === undefined ? {} : { targetEffectId }) });
+    }
+    humanInputsFor(agentId) {
+        return [...this.state.humanInputs.values()].filter((input) => input.agentId === agentId).map((input) => structuredClone(input));
+    }
+    humanArbitrationRequest(agent, input) {
+        const lanes = [...this.state.lanes.values()].filter((lane) => lane.agentId === agent.id || this.ownsAgentForRuntime(lane.agentId, agent.id)).map((lane) => ({ laneId: lane.id, agentId: lane.agentId, status: lane.status, priority: lane.priority, ...(lane.goal ? { goal: lane.goal } : {}), ...(lane.activeWaitId === undefined ? {} : { activeWaitId: lane.activeWaitId }) }));
+        const effects = [...this.state.effects.values()].filter((effect) => effect.agentId === agent.id || this.ownsAgentForRuntime(effect.agentId, agent.id)).map((effect) => ({ effectId: effect.id, agentId: effect.agentId, laneId: effect.ownerLaneId, kind: effect.kind, state: effect.state, ...(effect.sideEffectPolicy === undefined ? {} : { sideEffectPolicy: effect.sideEffectPolicy }), sideEffectState: effect.sideEffectState }));
+        const llmLimit = this.state.maxRunning.llm;
+        const availableLLMSlots = Number.isFinite(llmLimit) ? Math.max(0, llmLimit - this.runningCount('llm') - 1) : Number.POSITIVE_INFINITY;
+        return { schemaVersion: 1, decisionId: `human-decision-${this.sessionId}-${this.humanArbitrationRequestSeq}`, agentId: agent.id, input: structuredClone(input), lanes, effects, availableLLMSlots };
+    }
+    ownsAgentForRuntime(candidateAgentId, ancestorAgentId) {
+        let current = this.state.agents.get(candidateAgentId);
+        const seen = new Set();
+        while (current && !seen.has(current.id)) {
+            if (current.id === ancestorAgentId)
+                return true;
+            seen.add(current.id);
+            current = current.parentAgentId === undefined ? undefined : this.state.agents.get(current.parentAgentId);
+        }
+        return false;
+    }
+    commitHumanInputDecision(record, decision, eventType = 'human.input.decided') {
+        const next = structuredClone(record);
+        next.decision = decision.action;
+        if (decision.reason === undefined)
+            delete next.decisionReason;
+        else
+            next.decisionReason = decision.reason;
+        next.decisionModelId = decision.modelId;
+        next.decidedAt = this.state.now;
+        const event = { type: eventType, agentId: record.agentId, data: { inputId: record.id, action: decision.action, modelId: decision.modelId, ...(decision.reason === undefined ? {} : { reason: decision.reason }), ...(decision.targetLaneId === undefined ? {} : { targetLaneId: decision.targetLaneId }), ...(decision.targetEffectId === undefined ? {} : { targetEffectId: decision.targetEffectId }) } };
+        const mutations = [{ op: 'setHumanInput', inputId: record.id, record: next }, { op: 'appendEvent', event }];
+        this.assertStorageAdmission(mutations);
+        commitMutationTransaction(this.state, this.mutationLog, `human-input:${record.id}:decision:${decision.action}`, mutations, this.state.now, this.sessionId);
+        Object.assign(record, next);
+        this.state.humanInputs.set(record.id, record);
+    }
+    applyHumanArbitrationDecision(decision) {
+        const record = this.state.humanInputs.get(decision.inputId);
+        if (!record || record.agentId !== decision.agentId || record.status !== 'pending')
+            return false;
+        const targetEffectId = decision.targetEffectId ?? record.targetEffectId;
+        if (decision.action === 'respond') {
+            if (targetEffectId !== undefined) {
+                const effect = this.state.effects.get(targetEffectId);
+                if (!effect || effect.agentId !== record.agentId || effect.kind !== 'human' || effect.outcome)
+                    return false;
+                this.commitHumanInputDecision(record, decision);
+                record.status = 'consumed';
+                const consumed = structuredClone(record);
+                const mutations = [{ op: 'setHumanInput', inputId: record.id, record: consumed }];
+                this.assertStorageAdmission(mutations);
+                commitMutationTransaction(this.state, this.mutationLog, `human-input:${record.id}:respond`, mutations, this.state.now, this.sessionId);
+                Object.assign(record, consumed);
+                this.completeEffect(effect.id, { value: record.value }, 'succeeded');
+                return true;
+            }
+            const next = structuredClone(record);
+            next.status = 'consumed';
+            this.commitHumanInputDecision(record, decision, 'human.input.responded');
+            const mutations = [{ op: 'setHumanInput', inputId: record.id, record: next }];
+            this.assertStorageAdmission(mutations);
+            commitMutationTransaction(this.state, this.mutationLog, `human-input:${record.id}:responded`, mutations, this.state.now, this.sessionId);
+            Object.assign(record, next);
+            this.state.humanInputs.set(record.id, record);
+            return true;
+        }
+        if (decision.action === 'steer') {
+            const lane = this.state.lanes.get(decision.targetLaneId ?? this.state.agents.get(record.agentId)?.rootLaneId ?? '');
+            if (!lane || lane.agentId !== record.agentId || ['succeeded', 'failed', 'cancelled'].includes(lane.status)) {
+                const deferred = structuredClone(record);
+                deferred.status = 'deferred';
+                this.commitHumanInputDecision(record, { ...decision, action: 'defer', reason: decision.reason ?? 'Target lane is no longer active.' }, 'human.input.deferred');
+                Object.assign(record, deferred);
+                return true;
+            }
+            const nextLane = structuredClone(lane);
+            nextLane.pendingHumanInputs = [...(nextLane.pendingHumanInputs ?? []), structuredClone(record)];
+            nextLane.priority = Math.max(nextLane.priority, 2);
+            nextLane.version++;
+            const next = structuredClone(record);
+            next.status = 'consumed';
+            next.handledByLaneId = lane.id;
+            this.commitHumanInputDecision(record, decision);
+            const mutations = [{ op: 'setHumanInput', inputId: record.id, record: next }, { op: 'setLane', laneId: lane.id, record: nextLane }, { op: 'appendEvent', event: { type: 'human.input.steered', agentId: record.agentId, laneId: lane.id, data: { inputId: record.id, priority: 'human' } } }];
+            this.assertStorageAdmission(mutations);
+            commitMutationTransaction(this.state, this.mutationLog, `human-input:${record.id}:steer`, mutations, this.state.now, this.sessionId);
+            Object.assign(record, next);
+            this.state.humanInputs.set(record.id, record);
+            Object.assign(lane, nextLane);
+            this.state.lanes.set(lane.id, lane);
+            if (lane.status === 'ready')
+                this.enqueueReadyItem(readyItemFromLane(lane));
+            return true;
+        }
+        if (decision.action === 'spawn') {
+            if (this.humanInputProgram === undefined) {
+                const deferred = { ...decision, action: 'defer', reason: decision.reason ?? 'No Human interaction program is registered.' };
+                return this.applyHumanArbitrationDecision(deferred);
+            }
+            try {
+                const parentAgent = this.state.agents.get(record.agentId);
+                const parentLane = parentAgent === undefined ? undefined : this.state.lanes.get(parentAgent.rootLaneId);
+                const inheritedResults = parentLane?.visibleResultRefs === undefined ? [] : [...parentLane.visibleResultRefs].slice(-64);
+                const child = this.createAgent({ goal: `Human input: ${typeof record.value === 'string' ? record.value : JSON.stringify(record.value)}`, program: this.humanInputProgram, priority: 'urgent', parentAgentId: record.agentId, warmStart: { agentId: record.agentId, globalVersion: 'latest', include: 'facts_and_findings', ...(inheritedResults.length ? { relevanceRefs: inheritedResults } : {}) } });
+                const next = structuredClone(record);
+                next.status = 'consumed';
+                next.handledByLaneId = child.laneId;
+                this.commitHumanInputDecision(record, decision);
+                const mutations = [{ op: 'setHumanInput', inputId: record.id, record: next }, { op: 'appendEvent', event: { type: 'human.input.dispatched', agentId: record.agentId, laneId: child.laneId, data: { inputId: record.id, decision: 'spawn', childAgentId: child.agentId } } }];
+                this.assertStorageAdmission(mutations);
+                commitMutationTransaction(this.state, this.mutationLog, `human-input:${record.id}:spawn`, mutations, this.state.now, this.sessionId);
+                Object.assign(record, next);
+                this.state.humanInputs.set(record.id, record);
+            }
+            catch (cause) {
+                return this.applyHumanArbitrationDecision({ ...decision, action: 'defer', reason: cause instanceof Error ? cause.message : String(cause) });
+            }
+            return true;
+        }
+        if (decision.action === 'cancel') {
+            const targetEffect = targetEffectId === undefined ? undefined : this.state.effects.get(targetEffectId);
+            if (targetEffect && (targetEffect.agentId !== record.agentId || targetEffect.outcome))
+                return false;
+            this.commitHumanInputDecision(record, decision);
+            const next = structuredClone(record);
+            next.status = 'consumed';
+            const mutations = [{ op: 'setHumanInput', inputId: record.id, record: next }];
+            this.assertStorageAdmission(mutations);
+            commitMutationTransaction(this.state, this.mutationLog, `human-input:${record.id}:cancel`, mutations, this.state.now, this.sessionId);
+            Object.assign(record, next);
+            this.state.humanInputs.set(record.id, record);
+            if (targetEffect)
+                this.cancelEffect(targetEffect.id, targetEffect.cancelGraceMs ?? 0, decision.reason ?? 'HUMAN_CANCELLED');
+            else
+                this.cancelAgent(record.agentId, decision.reason ?? 'HUMAN_CANCELLED');
+            return true;
+        }
+        const deferred = structuredClone(record);
+        deferred.status = 'deferred';
+        this.commitHumanInputDecision(record, decision, 'human.input.deferred');
+        const mutations = [{ op: 'setHumanInput', inputId: record.id, record: deferred }];
+        this.assertStorageAdmission(mutations);
+        commitMutationTransaction(this.state, this.mutationLog, `human-input:${record.id}:defer`, mutations, this.state.now, this.sessionId);
+        Object.assign(record, deferred);
+        this.state.humanInputs.set(record.id, record);
+        return true;
+    }
+    requestHumanArbitration(agent, input) {
+        const coordinator = this.humanArbitrationCoordinator;
+        if (!coordinator)
+            return false;
+        const request = this.humanArbitrationRequest(agent, input);
+        const requestId = request.decisionId;
+        this.humanArbitrationRequestSeq++;
+        this.humanArbitrationRequests.set(requestId, { agentId: agent.id, inputId: input.id });
+        const accepted = coordinator.request(request, (decision) => {
+            this.humanArbitrationRequests.delete(requestId);
+            if (decision.decisionId !== requestId || decision.inputId !== input.id || decision.agentId !== agent.id || decision.modelId !== this.humanArbitrationModelId)
+                return;
+            try {
+                this.enqueueFact({ type: 'human_arbitration', decision: strictJsonValue(decision) }, `human-arbitration:${requestId}`, true);
+            }
+            catch { /* malformed model output is handled as a deferred input */ }
+        }, () => {
+            this.humanArbitrationRequests.delete(requestId);
+            try {
+                this.enqueueFact({ type: 'human_arbitration', decision: strictJsonValue({ schemaVersion: 1, decisionId: requestId, inputId: input.id, agentId: agent.id, action: 'defer', reason: 'Human arbitration timed out.', modelId: this.humanArbitrationModelId ?? 'model' }) }, `human-arbitration:${requestId}:timeout`, true);
+            }
+            catch { /* runtime shutdown */ }
+        });
+        if (!accepted)
+            this.humanArbitrationRequests.delete(requestId);
+        return accepted;
+    }
     requestCancel(agentId, reason = 'USER_REQUESTED') {
         if (!agentId)
             throw new Error('INVALID_AGENT_ID');
@@ -834,14 +1084,25 @@ export class PulseRuntime {
     async persist(backend) {
         const persistedPolicy = this.storagePolicy.clone();
         persistedPolicy.markPersisted();
-        const exported = exportRuntimePersistence(this.persistenceState(), this.mutationLog, this.outbox, this.quarantine, persistedPolicy, this.factInbox.snapshot(), this.persistenceCompatibility());
+        // The saved state is already authoritative: restore does not replay the
+        // journal unless the snapshot is a checkpoint. Rewriting every historical
+        // mutation on each flush copies full Effect records into a file that grows
+        // without bound and blocks the next dispatch. For the attached backend,
+        // persist the watermark only and drop those entries after the save succeeds.
+        const attached = backend === this.persistenceBackend;
+        const journalWatermark = attached ? this.mutationLog.lastSequence : undefined;
+        const exportedLog = journalWatermark === undefined ? this.mutationLog : new MutationLog([], journalWatermark);
+        const exported = exportRuntimePersistence(this.persistenceState(), exportedLog, this.outbox, this.quarantine, persistedPolicy, this.factInbox.snapshot(), this.persistenceCompatibility());
         // Never write a snapshot that the constructor would refuse to load; failing here is recoverable, a poisoned store is not.
         validateRuntimePersistenceSnapshot(exported);
         const withResults = backend.resultStore === undefined ? exported : await externalizeRuntimeResultBodies(exported, backend.resultStore);
         const snapshot = backend.snapshotStore === undefined ? withResults : await externalizeRuntimeSnapshotBodies(withResults, backend.snapshotStore);
-        await backend.save(snapshot, backend === this.persistenceBackend ? this.persistenceDigest : undefined);
-        if (backend === this.persistenceBackend)
+        await backend.save(snapshot, attached ? this.persistenceDigest : undefined);
+        if (attached) {
             this.persistenceDigest = snapshot.integrity?.digest;
+            if (journalWatermark !== undefined && journalWatermark > this.mutationLog.watermark && journalWatermark <= this.mutationLog.lastSequence)
+                this.mutationLog.truncateThrough(journalWatermark);
+        }
         this.storagePolicy.markPersisted();
         this.markArtifactsPersisted();
         this.syncStoragePolicy();
@@ -849,9 +1110,15 @@ export class PulseRuntime {
     async flushPersistence() {
         if (!this.persistenceBackend)
             return;
-        // An explicit flush is a request to try now, even while background retries are backing off.
+        // An explicit flush retries a pending/dirty snapshot, but must not mark an
+        // already clean runtime dirty on every scheduler tick. The run loop calls
+        // this after each tick; forcing a new write there can keep persistence
+        // permanently dirty and starve the durable-dispatch gate.
         this.persistenceBackoff = false;
-        this.schedulePersistence();
+        if (!this.persistenceDirty && !this.persistenceScheduled)
+            return;
+        if (this.persistenceDirty)
+            this.schedulePersistence();
         while (true) {
             await this.persistencePending;
             if (!this.persistenceDirty)
@@ -1073,9 +1340,9 @@ export class PulseRuntime {
             }
             catch (cause) {
                 if (signal.aborted && isSideEffectful(definition.manifest.sideEffectPolicy))
-                    return { value: null, executionState: 'remote_unknown', sideEffectState: 'unknown', ...(executionRef === undefined ? {} : { executionRef }), metadata: { toolVersion: definition.manifest.version, reconcileRequired: true }, ...(cause instanceof Error ? { error: { code: 'TOOL_CANCELLED_UNKNOWN', message: cause.message } } : {}) };
+                    return { value: null, executionState: 'remote_unknown', sideEffectState: 'unknown', ...(executionRef === undefined ? {} : { executionRef }), metadata: { toolVersion: definition.manifest.version, reconcileRequired: true }, error: runtimeErrorFromCause(cause, 'TOOL_CANCELLED_UNKNOWN') };
                 const error = runtimeErrorFromCause(cause, 'TOOL_EXECUTION_FAILED');
-                return { value: null, status: signal.aborted ? 'cancelled' : 'failed', executionState: 'failed', sideEffectState: 'none', ...(executionRef === undefined ? {} : { executionRef }), ...(cause instanceof Error ? { error } : {}), ...(observations.length ? { observations } : {}) };
+                return { value: null, status: signal.aborted ? 'cancelled' : 'failed', executionState: 'failed', sideEffectState: 'none', ...(executionRef === undefined ? {} : { executionRef }), error, ...(observations.length ? { observations } : {}) };
             }
         }
         if (effect.kind !== 'llm')
@@ -1156,18 +1423,19 @@ export class PulseRuntime {
         }
         this.mutationLog.append(transactionId, mutations, this.state.now);
     }
-    enqueueFact(fact, eventId) {
+    enqueueFact(fact, eventId, urgent = false) {
         const candidateInbox = FactInbox.fromSnapshot(this.factInbox.snapshot());
-        if (!candidateInbox.enqueue(fact, eventId))
+        if (!(urgent ? candidateInbox.enqueueUrgent(fact, eventId) : candidateInbox.enqueue(fact, eventId)))
             return false;
         const candidatePolicy = this.storagePolicy.clone();
         this.syncStoragePolicy(candidatePolicy, this.state, candidateInbox);
-        const envelope = this.factInbox.enqueue(fact, eventId);
+        const envelope = urgent ? this.factInbox.enqueueUrgent(fact, eventId) : this.factInbox.enqueue(fact, eventId);
         if (!envelope)
             return false;
         this.syncStoragePolicy();
         this.schedulePersistence();
         this.scheduleWake();
+        this.notifyActivity();
         for (const resolve of this.factWaiters.splice(0))
             resolve();
         return true;
@@ -1175,9 +1443,11 @@ export class PulseRuntime {
     enqueueHostCommand(command) {
         validateHostCommand(command);
         const eventId = `host-command-${this.hostCommandSeq}`;
-        if (!this.enqueueFact(command, eventId))
-            return;
+        const urgent = command.type === 'human_input' || command.type === 'reply' || command.type === 'cancel' || command.type === 'cancel_effect';
+        if (!this.enqueueFact(command, eventId, urgent))
+            return false;
         this.hostCommandSeq++;
+        return true;
     }
     enqueueEffectCompletion(effectId, attemptId, execution, status = 'succeeded', error, dispatchError) {
         const fact = { type: 'effect_completion', effectId, attemptId, execution: encodeEffectExecution(execution), status, ...(error === undefined ? {} : { error: error }), ...(dispatchError === undefined ? {} : { dispatchError: dispatchError }) };
@@ -1193,7 +1463,12 @@ export class PulseRuntime {
         this.enqueueFact(fact, `effect-reconcile:${effect.id}:${effect.attemptId}:${status}`);
     }
     scheduleWake(force = false) {
-        if (this.wakeScheduled || this.inDrain)
+        if (this.inDrain) {
+            if (force)
+                this.wakeAfterDrain = true;
+            return;
+        }
+        if (this.wakeScheduled)
             return;
         if (!force && this.factInbox.size === 0)
             return;
@@ -1211,7 +1486,9 @@ export class PulseRuntime {
             }
             finally {
                 this.inDrain = false;
-                if (this.wakeError === undefined && (this.factInbox.size > 0 || this.hasPendingTickCleanup()))
+                const wakeAfterDrain = this.wakeAfterDrain;
+                this.wakeAfterDrain = false;
+                if (this.wakeError === undefined && (wakeAfterDrain || this.factInbox.size > 0 || this.hasPendingTickCleanup()))
                     this.scheduleWake(true);
             }
         });
@@ -1370,6 +1647,7 @@ export class PulseRuntime {
         this.wakeError = undefined;
         this.assertRecoveryPrograms();
         this.state.now = this.clock.now();
+        const mutationSequenceBeforeTick = this.mutationLog.lastSequence;
         const tickStartedAt = performance.now();
         let tickOperations = 0;
         const canStartTickOperation = () => tickOperations === 0 || performance.now() - tickStartedAt < this.maxTickMs;
@@ -1409,6 +1687,17 @@ export class PulseRuntime {
                 else if (envelope.fact.type === 'scheduler_decision') {
                     commandApplied = this.applySchedulerDecision(envelope.fact);
                 }
+                else if (envelope.fact.type === 'human_arbitration') {
+                    const decision = parseHumanArbitrationDecision(envelope.fact.decision);
+                    if (decision !== undefined)
+                        commandApplied = this.applyHumanArbitrationDecision(decision);
+                    else {
+                        const raw = envelope.fact.decision && typeof envelope.fact.decision === 'object' && !Array.isArray(envelope.fact.decision) ? envelope.fact.decision : {};
+                        const record = typeof raw.inputId === 'string' ? this.state.humanInputs.get(raw.inputId) : undefined;
+                        if (record && record.status === 'pending')
+                            commandApplied = this.applyHumanArbitrationDecision({ schemaVersion: 1, decisionId: typeof raw.decisionId === 'string' ? raw.decisionId : `invalid:${record.id}`, inputId: record.id, agentId: record.agentId, action: 'defer', reason: 'Human arbitration returned an invalid decision.', modelId: 'runtime-safety' });
+                    }
+                }
                 else if (envelope.fact.type === 'effect_completion') {
                     if (envelope.fact.dispatchError !== undefined)
                         this.tryEmit({ type: 'effect.dispatch_failed', effectId: envelope.fact.effectId, data: envelope.fact.dispatchError });
@@ -1434,6 +1723,43 @@ export class PulseRuntime {
                         commandApplied = true;
                     }
                 }
+                else if (envelope.fact.type === 'human_input') {
+                    const agent = this.state.agents.get(envelope.fact.agentId);
+                    if (!agent) {
+                        this.rejectHostCommand(envelope.eventId, 'AGENT_NOT_FOUND');
+                        commandApplied = true;
+                    }
+                    else if (this.state.humanInputs.has(envelope.fact.inputId)) {
+                        this.tryEmit({ type: 'human.input.duplicate', agentId: agent.id, data: { inputId: envelope.fact.inputId } });
+                        this.emit({ type: 'command.applied', data: { eventId: envelope.eventId, duplicate: true } });
+                        commandApplied = true;
+                    }
+                    else {
+                        const target = envelope.fact.targetEffectId === undefined ? undefined : this.state.effects.get(envelope.fact.targetEffectId);
+                        if (target !== undefined && (target.agentId !== agent.id || target.kind !== 'human' || target.outcome !== undefined)) {
+                            this.rejectHostCommand(envelope.eventId, target.agentId !== agent.id ? 'EFFECT_NOT_OWNED' : 'EFFECT_NOT_REPLYABLE');
+                            commandApplied = true;
+                        }
+                        else {
+                            const record = { id: envelope.fact.inputId, agentId: agent.id, value: structuredClone(envelope.fact.value), receivedAt: this.state.now, status: 'pending', ...(target === undefined ? {} : { targetEffectId: target.id }) };
+                            const event = { type: 'human.input.received', agentId: agent.id, ...(target === undefined ? {} : { effectId: target.id }), data: { inputId: record.id, value: record.value, priority: 'human', ...(target === undefined ? {} : { targetEffectId: target.id }) } };
+                            const mutations = [{ op: 'setHumanInput', inputId: record.id, record }, { op: 'appendEvent', event }, { op: 'appendEvent', event: { type: 'command.applied', data: { eventId: envelope.eventId } } }];
+                            this.assertStorageAdmission(mutations);
+                            commitMutationTransaction(this.state, this.mutationLog, `human-input:${record.id}`, mutations, this.state.now, this.sessionId);
+                            commandApplied = true;
+                            if (target !== undefined) {
+                                this.applyHumanArbitrationDecision({ schemaVersion: 1, decisionId: `target:${record.id}`, inputId: record.id, agentId: agent.id, action: 'respond', targetEffectId: target.id, modelId: 'target-effect' });
+                            }
+                            else {
+                                const rule = ruleHumanArbitration(record.value, agent.id, record.id);
+                                if (rule !== undefined)
+                                    this.applyHumanArbitrationDecision(rule);
+                                else if (!this.requestHumanArbitration(agent, record) && this.humanInputProgram !== undefined)
+                                    this.applyHumanArbitrationDecision({ schemaVersion: 1, decisionId: `default:${record.id}`, inputId: record.id, agentId: agent.id, action: 'spawn', modelId: 'runtime-default' });
+                            }
+                        }
+                    }
+                }
                 else if (envelope.fact.type === 'reply') {
                     const effect = this.state.effects.get(envelope.fact.effectId);
                     if (effect?.agentId === envelope.fact.agentId && effect.kind === 'human' && !effect.outcome)
@@ -1458,7 +1784,7 @@ export class PulseRuntime {
                     else
                         commandApplied = this.cancelEffect(envelope.fact.effectId, 0, envelope.fact.reason, [{ op: 'appendEvent', event: { type: 'command.applied', data: { eventId: envelope.eventId } } }]);
                 }
-                else {
+                else if (envelope.fact.type === 'set_lane_priority') {
                     const lane = this.state.lanes.get(envelope.fact.laneId);
                     if (!lane) {
                         this.rejectHostCommand(envelope.eventId, 'LANE_NOT_FOUND');
@@ -1484,6 +1810,9 @@ export class PulseRuntime {
                         commandApplied = true;
                     }
                 }
+                else {
+                    commandApplied = false;
+                }
                 if (!commandApplied && envelope.fact.type !== 'effect_completion' && envelope.fact.type !== 'scheduler_decision')
                     this.emit({ type: 'command.applied', data: { eventId: envelope.eventId } });
             }
@@ -1507,6 +1836,12 @@ export class PulseRuntime {
             timer.callback();
             tickOperations++;
         }
+        // A restored snapshot may contain a settled Effect and its still-pending
+        // Wait when the process stopped between the two persistence writes. Re-run
+        // wait resolution after recovery timers have fired so the Lane receives its
+        // ResumeInput before the next program step is evaluated.
+        if ([...this.state.waits.values()].some((wait) => wait.state === 'pending'))
+            this.refreshWaits();
         let progressed = 0;
         while (progressed < this.maxSteps && canStartTickOperation()) {
             const laneId = this.selectReadyLane(this.state.now, this.maxSteps - progressed);
@@ -1528,7 +1863,7 @@ export class PulseRuntime {
                 continue;
             }
             let output;
-            const stepContext = { lane: stepLane, state: structuredClone(this.state), ...(lane.pendingResumeInput ? { resumeInput: structuredClone(lane.pendingResumeInput) } : {}), now: this.state.now, observe: (event) => { this.observationInbox.enqueue({ ...event, agentId: lane.agentId, laneId: lane.id, timestamp: this.state.now }); } };
+            const stepContext = { lane: stepLane, state: structuredClone(this.state), ...(lane.pendingResumeInput ? { resumeInput: structuredClone(lane.pendingResumeInput) } : {}), ...(lane.pendingHumanInputs?.length ? { humanInputs: structuredClone(lane.pendingHumanInputs) } : {}), now: this.state.now, observe: (event) => { this.observationInbox.enqueue({ ...event, agentId: lane.agentId, laneId: lane.id, timestamp: this.state.now }); this.notifyActivity(); } };
             try {
                 output = withPureStepGuard(() => lane.series || program.seriesMember ? this.seriesStep(program, stepContext, lane.series) : program.step(stepContext));
             }
@@ -1602,6 +1937,7 @@ export class PulseRuntime {
                         return mutation;
                     const nextLane = structuredClone(mutation.record);
                     delete nextLane.consecutiveControlErrors;
+                    delete nextLane.pendingHumanInputs;
                     replaceResumeInput(nextLane, undefined);
                     nextLane.progressWatchdog = watchdog.state;
                     return { ...mutation, record: nextLane };
@@ -1642,12 +1978,19 @@ export class PulseRuntime {
         this.dispatchQueuedEffects();
         this.completeFinishedChildAgents();
         this.finalizeCancellations();
-        this.syncStoragePolicy();
-        this.schedulePersistence();
+        const tickMutated = this.mutationLog.lastSequence !== mutationSequenceBeforeTick;
+        if (tickMutated)
+            this.syncStoragePolicy();
+        // A wake can be scheduled solely to retry dispatch or drain an empty
+        // queue. Persist only when this tick committed a mutation; otherwise a
+        // waiting run rewrites the full runtime snapshot on every wake.
+        if (tickMutated)
+            this.schedulePersistence();
         const pendingTickCleanup = this.hasPendingTickCleanup();
         this.tickBudget = undefined;
         if (pendingTickCleanup)
             this.scheduleWake(true);
+        this.notifyActivity();
         return progressed;
     }
     async run(agentOrMaxTicks = 10_000, requestedMaxTicks = 10_000) {
@@ -1662,7 +2005,7 @@ export class PulseRuntime {
             }
             if (this.ready.size === 0 && this.executions.size === 0 && !this.hasQueuedEffects() && !this.hasPendingTickCleanup()) {
                 if (this.preparingLLMs.size) {
-                    await Promise.resolve();
+                    await this.waitForFact();
                     continue;
                 }
                 if (this.factInbox.size > 0)
@@ -1731,7 +2074,7 @@ export class PulseRuntime {
             }
             if (this.ready.size === 0 && this.executions.size === 0 && !this.hasQueuedEffects() && !this.hasPendingTickCleanup()) {
                 if (this.preparingLLMs.size) {
-                    await Promise.resolve();
+                    await this.waitForFact();
                     continue;
                 }
                 if (this.factInbox.size > 0)
@@ -1784,13 +2127,15 @@ export class PulseRuntime {
         if (this.executions.size)
             await Promise.race([...this.executions.values()].map((execution) => execution.promise));
         else if (this.preparingLLMs.size)
-            await Promise.resolve();
+            await this.waitForFact();
         else if (this.hasQueuedEffects() || this.factInbox.size || this.hasPendingTickCleanup() || this.hasDueTimer())
             await new Promise((resolve) => setImmediate(resolve));
     } await this.flushPersistence(); }
     async shutdown(timeoutMs = 5_000) {
         this.shuttingDown = true;
         this.schedulerDecisionCoordinator?.cancel();
+        this.humanArbitrationCoordinator?.cancel();
+        this.humanArbitrationRequests.clear();
         this.schedulerDecisionRequests.clear();
         this.schedulerDecisionCache = undefined;
         for (const agent of this.state.agents.values())
@@ -1984,9 +2329,16 @@ export class PulseRuntime {
                 if (result)
                     Object.assign(result, value);
             }
-            if (this.sessionStore)
-                for (const agent of state.agents.values())
-                    this.sessionStore.put(exportWarmStartSession(state, agent.id));
+            if (this.sessionStore) {
+                for (const agent of state.agents.values()) {
+                    const snapshot = exportWarmStartSession(state, agent.id);
+                    const digest = contentHash(snapshot);
+                    if (this.sessionStoreDigests.get(agent.id) === digest)
+                        continue;
+                    this.sessionStore.put(snapshot);
+                    this.sessionStoreDigests.set(agent.id, digest);
+                }
+            }
         }
     }
     hasQueuedEffects() { return [...this.state.effects.values()].some((effect) => effect.state === 'queued' && !this.executions.has(effect.id)); }
@@ -2025,7 +2377,39 @@ export class PulseRuntime {
     }
     hasPendingHostInteraction(agentId) { return [...this.state.effects.values()].some((effect) => effect.kind === 'human' && !effect.outcome && (agentId === undefined || effect.agentId === agentId)); }
     waitForFact() { return new Promise((resolve) => this.factWaiters.push(resolve)); }
+    /** Wait for a state or observation change without polling the event loop. */
+    waitForActivity(timeoutMs = 250) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                this.activityWaiters.delete(finish);
+                clearTimeout(timer);
+                resolve();
+            };
+            const timer = setTimeout(finish, timeoutMs);
+            this.activityWaiters.add(finish);
+        });
+    }
+    notifyActivity() {
+        for (const resolve of [...this.activityWaiters])
+            resolve();
+    }
     completeFinishedChildAgents() {
+        // Human interaction Agents are detached from the main Lane rather than
+        // represented by an agent Effect. Settle their Agent record when the root
+        // Lane reaches a terminal state so session streams can close correctly.
+        for (const child of this.state.agents.values()) {
+            if (child.parentAgentId === undefined || ['succeeded', 'failed', 'cancelled'].includes(child.state ?? ''))
+                continue;
+            const root = this.state.lanes.get(child.rootLaneId);
+            if (!root || !['succeeded', 'failed', 'cancelled'].includes(root.status))
+                continue;
+            const status = root.status === 'succeeded' ? 'succeeded' : root.status === 'cancelled' ? 'cancelled' : 'failed';
+            this.commitAgentState(child.id, status, `agent:${child.id}:interaction-settled:${root.version}`);
+        }
         for (const effect of this.state.effects.values()) {
             if (effect.kind !== 'agent' || !effect.childAgentId || effect.outcome)
                 continue;
@@ -2229,8 +2613,10 @@ export class PulseRuntime {
         }
         this.releaseEffectLocks(effectId);
         this.outbox.ack(`${effect.id}:${effect.attemptId}`);
-        for (const observation of effectiveExecution.observations ?? [])
+        for (const observation of effectiveExecution.observations ?? []) {
             this.observationInbox.enqueue({ ...observation, agentId: effect.agentId, laneId: effect.ownerLaneId, timestamp: this.state.now });
+            this.notifyActivity();
+        }
         const settlementTransactionId = `effect:${effect.id}:${settledAttemptId}:settled`;
         const settlementMutations = [...publicationMutations];
         commitMutationTransaction(this.state, this.mutationLog, settlementTransactionId, settlementMutations, this.state.now, this.sessionId);
@@ -2464,8 +2850,9 @@ export class PulseRuntime {
             ...cancellableEffects.map((effect) => ({ type: 'effect.cancel_requested', effectId: effect.id, data: { reason } })),
             ...cancellableEffects.flatMap((effect) => {
                 if (this.executions.has(effect.id) && (effect.cancelGraceMs ?? 0) === 0) {
-                    const state = isSideEffectful(effect.sideEffectPolicy) ? 'reconcile_required' : 'cancelled';
-                    return [{ type: 'effect.quarantined', effectId: effect.id, data: { reason, state } }];
+                    if (isSideEffectful(effect.sideEffectPolicy))
+                        return [{ type: 'effect.quarantined', effectId: effect.id, data: { reason, state: 'reconcile_required' } }];
+                    return [{ type: 'effect.settled', effectId: effect.id, data: { status: 'cancelled', error: { code: 'CANCELLED', message: reason } } }];
                 }
                 if (!this.executions.has(effect.id))
                     return [{ type: 'effect.settled', effectId: effect.id, data: { status: 'cancelled', error: { code: 'CANCELLED', message: reason } } }];
@@ -2499,9 +2886,10 @@ export class PulseRuntime {
                 const candidate = structuredClone(effect);
                 candidate.cancelRequested = { reason, at: this.state.now };
                 if (this.executions.has(effect.id) && (effect.cancelGraceMs ?? 0) === 0) {
-                    candidate.executionState = 'remote_unknown';
-                    candidate.sideEffectState = isSideEffectful(candidate.sideEffectPolicy) ? 'unknown' : 'none';
-                    candidate.state = candidate.sideEffectState === 'unknown' ? 'reconcile_required' : 'cancelled';
+                    const shouldQuarantine = isSideEffectful(candidate.sideEffectPolicy);
+                    candidate.executionState = shouldQuarantine ? 'remote_unknown' : 'local_closed';
+                    candidate.sideEffectState = shouldQuarantine ? 'unknown' : 'none';
+                    candidate.state = shouldQuarantine ? 'reconcile_required' : 'cancelled';
                     if (candidate.state === 'cancelled')
                         candidate.outcome = { status: 'cancelled', reason, error: { code: reason, message: reason } };
                 }
@@ -2620,7 +3008,8 @@ export class PulseRuntime {
             return { id: lane.id, agentId: lane.agentId, status: lane.status, cancelReason: lane.cancelReason ?? null, failure: lane.failure?.error ?? null, goal: lane.goal, basePriority: lane.priority, effectivePriority: ready?.effectivePriority ?? lane.priority, queueWaitMs: ready ? Math.max(0, this.state.now - lane.readySince) : 0, blockedBy, activeWaitId: lane.activeWaitId ?? null, lastEventSeq: lastEvent('lane', lane.id), watchdog: lane.progressWatchdog ?? null, consecutiveControlErrors: lane.consecutiveControlErrors ?? 0, lastInterventionReason: lane.progressWatchdog?.lastReason ?? null, unresolvedEffectIds: lane.unresolvedEffectIds ?? [] };
         });
         const effects = [...this.state.effects.values()].filter((effect) => laneId === undefined || effect.ownerLaneId === laneId).map((effect) => ({ id: effect.id, state: effect.state, executionState: effect.executionState, sideEffectState: effect.sideEffectState, attemptId: effect.attemptId, inheritedFloor: effect.inheritedFloor ?? null, deadlineAt: effect.deadlineAt ?? null, lastEventSeq: lastEvent('effect', effect.id), preparation: effect.preparation ?? null, metadata: latestEffectMetadata(effect.id) }));
-        return { now: this.state.now, lanes, effects, preparation: { preparing: this.preparingLLMs.size, prepared: [...this.state.effects.values()].filter((effect) => effect.state === 'queued' && effect.preparation?.state === 'prepared').length, maxPreparing: this.maxPreparingLLMs, maxPrepared: this.maxPreparedLLMs }, quarantine: this.quarantine.unresolvedEffectIds };
+        const humanInputs = [...this.state.humanInputs.values()].filter((input) => laneId === undefined || input.agentId === this.state.lanes.get(laneId)?.agentId).map((input) => structuredClone(input));
+        return { now: this.state.now, lanes, effects, humanInputs, preparation: { preparing: this.preparingLLMs.size, prepared: [...this.state.effects.values()].filter((effect) => effect.state === 'queued' && effect.preparation?.state === 'prepared').length, maxPreparing: this.maxPreparingLLMs, maxPrepared: this.maxPreparedLLMs }, quarantine: this.quarantine.unresolvedEffectIds };
     }
     retryEffect(effectId, delayMs) {
         const effect = this.state.effects.get(effectId);
@@ -2687,9 +3076,13 @@ export class PulseRuntime {
                 this.dispatchQueuedEffectsNow();
                 return;
             }
-            this.schedulePersistence();
             if (this.dispatchPersistencePending)
                 return;
+            // Do not mark persistence dirty again while the durability gate is
+            // already flushing. The scheduler calls this method on every tick; a
+            // write scheduled before this guard would keep the flush promise alive
+            // forever and starve the queued effects behind it.
+            this.schedulePersistence();
             this.dispatchPersistencePending = true;
             void this.flushPersistence().then(() => {
                 this.dispatchPersistencePending = false;
@@ -2709,6 +3102,13 @@ export class PulseRuntime {
         // Higher effective priority (max of own priority and inherited floor) dispatches first, matching ReadyQueue semantics.
         const effectivePriority = (effect) => Math.max(effect.schedulePriority ?? 0, effect.inheritedFloor ?? Number.NEGATIVE_INFINITY);
         const queued = [...this.state.effects.values()].filter((effect) => effect.state === 'queued' && !this.executions.has(effect.id)).sort((a, b) => (effectivePriority(b) - effectivePriority(a)) || a.id.localeCompare(b.id));
+        const llmLimit = () => {
+            const configured = this.state.maxRunning.llm;
+            if ((this.humanInputProgram === undefined && this.humanArbitrationCoordinator === undefined) || !Number.isFinite(configured))
+                return configured;
+            const hasUrgentHumanWork = queued.some((candidate) => candidate.kind === 'llm' && effectivePriority(candidate) >= 2);
+            return hasUrgentHumanWork ? configured : Math.max(0, configured - 1);
+        };
         for (const effect of queued) {
             if (this.tickBudget && !this.tickBudget.canStart())
                 break;
@@ -2716,7 +3116,7 @@ export class PulseRuntime {
                 continue;
             if (effect.kind === 'llm' && !this.prepareLLMEffect(effect))
                 continue;
-            if (effect.concurrencyClass !== 'none' && this.runningCount(effect.concurrencyClass) >= this.state.maxRunning[effect.concurrencyClass])
+            if (effect.concurrencyClass !== 'none' && this.runningCount(effect.concurrencyClass) >= (effect.concurrencyClass === 'llm' ? llmLimit() : this.state.maxRunning[effect.concurrencyClass]))
                 continue;
             const budgetError = this.budgetRejection(effect);
             if (budgetError) {
@@ -2823,6 +3223,7 @@ export class PulseRuntime {
                     return;
                 }
                 this.observationInbox.enqueue({ ...observation, agentId: effect.agentId, laneId: effect.ownerLaneId, timestamp: this.state.now });
+                this.notifyActivity();
             };
             const attemptId = effect.attemptId;
             const promise = this.executor(effect, controller.signal, emitObservation).then((execution) => {
@@ -2909,25 +3310,28 @@ export class PulseRuntime {
         if (!effect || effect.outcome)
             return false;
         const candidate = structuredClone(effect);
+        const shouldQuarantine = isSideEffectful(candidate.sideEffectPolicy);
         if (precedingEvent?.type === 'effect.cancel_requested' || precedingEvent?.type === 'limit.rejected')
             candidate.cancelRequested = { reason, at: this.state.now };
-        candidate.executionState = 'remote_unknown';
-        candidate.sideEffectState = isSideEffectful(candidate.sideEffectPolicy) ? 'unknown' : 'none';
-        candidate.state = candidate.sideEffectState === 'unknown' ? 'reconcile_required' : 'cancelled';
+        candidate.executionState = shouldQuarantine ? 'remote_unknown' : 'local_closed';
+        candidate.sideEffectState = shouldQuarantine ? 'unknown' : 'none';
+        candidate.state = shouldQuarantine ? 'reconcile_required' : 'cancelled';
         if (candidate.state === 'cancelled')
             candidate.outcome = { status: 'cancelled', reason, error: { code: reason, message: reason } };
         const lane = this.state.lanes.get(effect.ownerLaneId);
         const candidateLane = lane === undefined ? undefined : structuredClone(lane);
-        if (candidateLane)
+        if (shouldQuarantine && candidateLane)
             candidateLane.unresolvedEffectIds = [...new Set([...(candidateLane.unresolvedEffectIds ?? []), effectId])];
-        const quarantineEvent = { type: 'effect.quarantined', effectId, data: { reason, state: candidate.state } };
+        const terminalEvent = shouldQuarantine
+            ? { type: 'effect.quarantined', effectId, data: { reason, state: candidate.state } }
+            : { type: 'effect.settled', effectId, data: candidate.outcome };
         const admission = [{ op: 'setEffect', effectId, record: candidate }];
         if (candidateLane)
             admission.push({ op: 'setLane', laneId: candidateLane.id, record: candidateLane });
         if (precedingEvent)
             admission.push({ op: 'appendEvent', event: precedingEvent });
         admission.push(...additionalMutations.map((mutation) => structuredClone(mutation)));
-        admission.push({ op: 'appendEvent', event: quarantineEvent });
+        admission.push({ op: 'appendEvent', event: terminalEvent });
         this.assertStorageAdmission(admission);
         if (execution) {
             execution.controller.abort();
@@ -2941,7 +3345,8 @@ export class PulseRuntime {
             Object.assign(lane, candidateLane);
             this.state.lanes.set(candidateLane.id, lane);
         }
-        this.quarantine.add(effectId, this.state.now, reason);
+        if (shouldQuarantine)
+            this.quarantine.add(effectId, this.state.now, reason);
         this.refreshWaits();
         this.schedulePersistence();
         return true;