@hunterzhu/pulse-runtime 0.1.6 → 0.1.8

package/dist/context/builder.d.ts

@@ -1,16 +1,21 @@
-import type { AgentRecord, ArtifactRef, LaneRecord, LLMRequestProjection, PrivacyLabel, PrivacyTaint, ResultRef, RuntimeState, JsonValue, ContextDelta } from '../core/types.js';
+import type { AgentRecord, ArtifactRef, ConversationMessage, LaneRecord, LLMRequestProjection, PrivacyLabel, PrivacyTaint, ResultRef, RuntimeState, JsonValue, ContextDelta } from '../core/types.js';
 export interface ContextBuildInput {
     agent: AgentRecord;
     lane: LaneRecord;
     resultRefs?: ResultRef[];
     artifactRefs?: ArtifactRef[];
     eventIds?: string[];
+    conversation?: ConversationMessage[];
     instruction: string;
     system?: string;
     policy?: JsonValue;
     tools?: JsonValue;
     toolSetId: string;
 }
+export declare const MAX_DSL_INSTRUCTION_BYTES = 2048;
+/** Keep large tool results from crowding out the actual task and conversation. */
+export declare const MAX_INLINE_RESULT_BYTES = 4096;
+export declare function assertDslInstructionSize(value: string): string;
 export declare class ContextBuilder {
     private readonly state;
     readonly version = "1";

package/dist/context/builder.js

@@ -8,6 +8,35 @@ function stable(value) {
     return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${stable(item)}`).join(',')}}`;
 }
 function hash(value) { return createHash('sha256').update(stable(value)).digest('hex'); }
+export const MAX_DSL_INSTRUCTION_BYTES = 2_048;
+/** Keep large tool results from crowding out the actual task and conversation. */
+export const MAX_INLINE_RESULT_BYTES = 4_096;
+function utf8Prefix(value, maxBytes) {
+    return Buffer.from(value, 'utf8').subarray(0, maxBytes).toString('utf8');
+}
+function projectResultValue(result) {
+    const value = result.value ?? null;
+    const originalBytes = Buffer.byteLength(JSON.stringify(value), 'utf8');
+    if (originalBytes <= MAX_INLINE_RESULT_BYTES)
+        return { value, summarized: false };
+    if (result.summary !== undefined)
+        return { value: result.summary, summarized: true, originalBytes };
+    return {
+        value: {
+            truncated: true,
+            originalBytes,
+            preview: utf8Prefix(JSON.stringify(value), MAX_INLINE_RESULT_BYTES),
+            note: 'The full result is retained by the runtime. Use this preview. Do not re-run the producing tool.',
+        },
+        summarized: true,
+        originalBytes,
+    };
+}
+export function assertDslInstructionSize(value) {
+    if (Buffer.byteLength(value, 'utf8') > MAX_DSL_INSTRUCTION_BYTES)
+        throw Object.assign(new Error('Instruction exceeds the 2 KB DSL limit.'), { code: 'INSTRUCTION_TOO_LARGE', retryable: false });
+    return value;
+}
 export class ContextBuilder {
     state;
     version = '1';
@@ -15,8 +44,7 @@ export class ContextBuilder {
         this.state = state;
     }
     build(input) {
-        if (input.instruction.length > 2048)
-            throw new Error('INSTRUCTION_TOO_LARGE');
+        assertDslInstructionSize(input.instruction);
         const global = input.agent.globalVersions.get(input.lane.contextSnapshotVersion);
         if (global === undefined)
             throw new Error('UNKNOWN_CONTEXT_VERSION');
@@ -55,15 +83,20 @@ export class ContextBuilder {
             ...effectiveResults.flatMap((item) => (item.result.privacyTaints ?? []).map((taint) => ({ path: [item.result.id, ...taint.path], privacy: taint.privacy }))),
             ...effectiveArtifacts.flatMap((item) => (item.artifact.privacyTaints ?? []).map((taint) => ({ path: [item.artifact.ref, ...taint.path], privacy: taint.privacy }))),
         ];
-        const contextSpec = { globalSnapshotVersion: input.lane.contextSnapshotVersion, laneSnapshotVersion: input.lane.context.version, resultRefs, ...(artifactRefs.length ? { artifactRefs } : {}), eventIds: input.eventIds ?? [], toolSetId: input.toolSetId, instruction: input.instruction, privacy, privacyRefs, ...(privacyTaints.length ? { privacyTaints } : {}) };
+        const conversation = input.conversation ?? [];
+        const contextSpec = { globalSnapshotVersion: input.lane.contextSnapshotVersion, laneSnapshotVersion: input.lane.context.version, resultRefs, ...(artifactRefs.length ? { artifactRefs } : {}), eventIds: input.eventIds ?? [], toolSetId: input.toolSetId, instruction: input.instruction, ...(conversation.length ? { conversation: structuredClone(conversation) } : {}), privacy, privacyRefs, ...(privacyTaints.length ? { privacyTaints } : {}) };
         const prefixBlocks = [
             { kind: 'system', content: input.system ?? '' },
             { kind: 'policy', content: input.policy ?? {} },
             { kind: 'tools', content: input.tools ?? {} },
             { kind: 'global', content: global },
+            ...(conversation.length ? [{ kind: 'conversation', content: structuredClone(conversation) }] : []),
             { kind: 'history', content: input.lane.context.history.map((record) => ({ seq: record.seq, ...(record.effectId === undefined ? {} : { effectId: record.effectId }), instruction: record.instruction, resultRefs: record.resultRefs, ...(record.resultSelection === undefined ? {} : { resultSelection: record.resultSelection }), ...(record.result === undefined ? {} : { result: record.result }), ...(record.findings === undefined ? {} : { findings: record.findings }), output: record.output, privacy: record.privacy, ...(record.privacyTaints === undefined ? {} : { privacyTaints: record.privacyTaints }) })) },
         ];
-        const blocks = [...prefixBlocks, { kind: 'lane', content: input.lane.context.state }, { kind: 'events', content: input.eventIds ?? [] }, { kind: 'results', content: results.map((result) => ({ id: result.id, value: result.value ?? null, ...(result.privacyTaints === undefined ? {} : { privacyTaints: result.privacyTaints.map((taint) => ({ path: [...taint.path], privacy: taint.privacy })) }) })) }, { kind: 'artifacts', content: artifacts.map((artifact) => ({ ref: artifact.ref, mediaType: artifact.mediaType, sizeBytes: artifact.sizeBytes, contentHash: artifact.contentHash })) }, { kind: 'instruction', content: input.instruction }];
+        const blocks = [...prefixBlocks, { kind: 'lane', content: input.lane.context.state }, { kind: 'events', content: input.eventIds ?? [] }, { kind: 'results', content: results.map((result) => {
+                    const projected = projectResultValue(result);
+                    return { id: result.id, value: projected.value, ...(projected.summarized ? { summarized: true, ...(projected.originalBytes === undefined ? {} : { originalBytes: projected.originalBytes }) } : {}), ...(result.privacyTaints === undefined ? {} : { privacyTaints: result.privacyTaints.map((taint) => ({ path: [...taint.path], privacy: taint.privacy })) }) };
+                }) }, { kind: 'artifacts', content: artifacts.map((artifact) => ({ ref: artifact.ref, mediaType: artifact.mediaType, sizeBytes: artifact.sizeBytes, contentHash: artifact.contentHash })) }, { kind: 'instruction', content: input.instruction }];
         return { contextSpec, blocks, prefixHash: hash(prefixBlocks), projectionHash: hash(blocks), builderVersion: this.version, policyVersion: '1', toolSetVersion: input.toolSetId, privacy, privacyRefs, ...(privacyTaints.length ? { privacyTaints } : {}) };
     }
 }

package/dist/core/types.d.ts

@@ -504,14 +504,19 @@ export interface LLMContextSpec {
     eventIds: string[];
     toolSetId: string;
     instruction: string;
+    conversation?: ConversationMessage[];
     privacy: PrivacyLabel;
     privacyRefs: ProvenanceRef[];
     privacyTaints?: PrivacyTaint[];
 }
+export interface ConversationMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
 export interface LLMRequestProjection {
     contextSpec: LLMContextSpec;
     blocks: Array<{
-        kind: 'system' | 'policy' | 'tools' | 'global' | 'history' | 'lane' | 'events' | 'results' | 'artifacts' | 'instruction';
+        kind: 'system' | 'policy' | 'tools' | 'global' | 'conversation' | 'history' | 'lane' | 'events' | 'results' | 'artifacts' | 'instruction';
         content: JsonValue;
     }>;
     prefixHash: string;

package/dist/dsl/program.d.ts

@@ -1,6 +1,6 @@
 import { z, type ZodTypeAny } from 'zod';
 import type { LaneProgram } from '../scheduler/runtime.js';
-import type { ContextDelta, JsonValue, LaneRecord, ResultRef, ProvenanceRef, RuntimeAction, ResumeInput, ProgressWatchdogState, ContextOp, LaneId, PrivacyLabel, RuntimeError, MergeProposal, ResourceLockSpec, Outcome, WaitResolution } from '../core/types.js';
+import type { ContextDelta, ConversationMessage, JsonValue, LaneRecord, ResultRef, ProvenanceRef, RuntimeAction, ResumeInput, ProgressWatchdogState, ContextOp, LaneId, PrivacyLabel, RuntimeError, MergeProposal, ResourceLockSpec, Outcome, WaitResolution, HumanInputRecord } from '../core/types.js';
 import type { ProgramRef } from './templates.js';
 import type { RuntimeToolDiscoveryQuery } from '../tools/registry.js';
 export type NextStepTarget<TState = unknown> = string | {
@@ -33,11 +33,13 @@ export interface StepInputs {
     findings?: ResultRef[];
     artifacts?: string[];
     events?: string[];
+    conversation?: ConversationMessage[];
     toolDiscovery?: RuntimeToolDiscoveryQuery;
 }
 export interface HistoryCompactionOptions {
     summarizeTask: string;
     keepRecentRounds: number;
+    instruction?: string;
 }
 export interface HistoryRecordMeta {
     seq: number;
@@ -76,6 +78,7 @@ export interface StepContext<TState = JsonValue> {
     now: number;
     watchdog?: ProgressWatchdogState;
     resumeInput?: ResumeInput;
+    humanInputs?: readonly HumanInputRecord[];
     results: {
         meta(ref: ResultRef): ResultMeta | undefined;
         summary(ref: ResultRef): JsonValue | undefined;

package/dist/dsl/program.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { globalContextRef, laneContextRef } from '../core/types.js';
 import { createDraftProxy } from './context-proxy.js';
-import { contentHash, stableSerialize } from '../context/builder.js';
+import { assertDslInstructionSize, contentHash, stableSerialize } from '../context/builder.js';
 function target(step, fallback) {
     if (typeof step === 'string')
         return { step };
@@ -29,9 +29,7 @@ function scalarProjection(value) {
     return Object.fromEntries(Object.entries(value).filter(([, child]) => child === null || typeof child === 'string' || typeof child === 'number' || typeof child === 'boolean').map(([key, child]) => [key, child]));
 }
 function boundedInstruction(value) {
-    if (Buffer.byteLength(value, 'utf8') > 2048)
-        throw Object.assign(new Error('Instruction exceeds the 2 KB DSL limit.'), { code: 'INSTRUCTION_TOO_LARGE', retryable: false });
-    return value;
+    return assertDslInstructionSize(value);
 }
 function programLLMInput(config, input) {
     return { ...input, ...(config.system === undefined ? {} : { system: config.system }), ...(config.toolSet === undefined ? {} : { toolSetId: config.toolSet }) };
@@ -201,6 +199,16 @@ function collectResumeResultRefs(input, refs) {
             refs.add(ref);
     }
 }
+/** Return a wait resolution even when the scheduler wrapped it in a control error. */
+function waitResolution(input) {
+    if (!input)
+        return undefined;
+    if (input.type === 'wait')
+        return input.resolution;
+    if (input.type === 'control_error')
+        return waitResolution(input.original);
+    return undefined;
+}
 function annotateAction(action, derivedFrom) {
     if (!derivedFrom.length)
         return action;
@@ -213,7 +221,7 @@ function annotateAction(action, derivedFrom) {
 const resultReaders = new WeakMap();
 function readResult(ctx, ref) { return resultReaders.get(ctx)?.(ref); }
 function waitFailure(ctx) {
-    const resolution = ctx.resumeInput?.type === 'wait' ? ctx.resumeInput.resolution : undefined;
+    const resolution = waitResolution(ctx.resumeInput);
     if (!resolution)
         return undefined;
     let dependencyError;
@@ -222,6 +230,10 @@ function waitFailure(ctx) {
             dependencyError = dependency.outcome.error;
             break;
         }
+        if (dependency.state !== 'pending' && dependency.outcome.status === 'cancelled') {
+            dependencyError = dependency.outcome.error ?? { code: 'EFFECT_CANCELLED', message: dependency.outcome.reason ?? 'A waited effect was cancelled.', retryable: false };
+            break;
+        }
     }
     if (dependencyError)
         return dependencyError;
@@ -288,7 +300,7 @@ function makeContext(context, initialState) {
         delta = { target: 'global', baseVersion: agent?.latestGlobalVersion ?? 0, sourceLaneId: context.lane.id, ops: clone(ops), ...(value.privacy === undefined ? {} : { privacy: value.privacy }), proposal: value.proposal };
     };
     const ctx = {
-        lane: context.lane, goal: context.lane.goal, global, globalVersion, laneState: readonlyState, history, now: context.now, ...(context.lane.progressWatchdog === undefined ? {} : { watchdog: context.lane.progressWatchdog }), ...(context.resumeInput ? { resumeInput: context.resumeInput } : {}),
+        lane: context.lane, goal: context.lane.goal, global, globalVersion, laneState: readonlyState, history, now: context.now, ...(context.lane.progressWatchdog === undefined ? {} : { watchdog: context.lane.progressWatchdog }), ...(context.resumeInput ? { resumeInput: context.resumeInput } : {}), ...(context.humanInputs?.length ? { humanInputs: context.humanInputs } : {}),
         results: { meta: resultMeta, summary: (ref) => { if (context.state.results.has(ref) && resultVisible(context, ref))
                 derivedRefs.add(ref); return resultMeta(ref)?.summary; } },
         mergeProposals: [...context.state.mergeProposals.values()].filter((proposal) => proposal.agentId === context.lane.agentId).map((proposal) => { for (const ref of proposal.delta.derivedFrom ?? [])
@@ -371,16 +383,34 @@ export class StepBuilder {
     }
     addReActLoopStep(name, options) {
         this.compactionBoundaries.add(name);
+        // The decode step handles ReAct compaction after consuming the current
+        // model result. This preserves the wait's result references while the
+        // summary is being generated.
         const readTurns = (ctx) => { const sdk = sdkLocals(ctx.lane.resume.locals); const turn = sdk[`${name}Turns`]; return typeof turn === 'number' && Number.isInteger(turn) && turn >= 0 ? turn : 0; };
         const inputKey = `${name}Inputs`;
         const readInputs = (ctx) => { const value = sdkLocals(ctx.lane.resume.locals)[inputKey]; return value && typeof value === 'object' && !Array.isArray(value) ? value : {}; };
-        const writeTurns = (ctx, turns, inputs = readInputs(ctx)) => { const locals = ctx.lane.resume.locals; const base = locals && typeof locals === 'object' && !Array.isArray(locals) ? locals : {}; return { ...base, $sdk: { ...sdkLocals(locals), [`${name}Turns`]: turns, [inputKey]: asJson(inputs) } }; };
-        const resultRefFromWait = (ctx) => { const dependency = ctx.resumeInput?.type === 'wait' ? Object.values(ctx.resumeInput.resolution.dependencies)[0] : undefined; return dependency?.state === 'settled' ? dependency.outcome.resultRef : undefined; };
-        const resultRefsFromWait = (ctx) => ctx.resumeInput?.type === 'wait' ? Object.values(ctx.resumeInput.resolution.dependencies).flatMap((dependency) => dependency.state === 'settled' && dependency.outcome.resultRef ? [dependency.outcome.resultRef] : []) : [];
+        const writeTurns = (ctx, turns, inputs = readInputs(ctx)) => { const { conversation: _conversation, ...persistedInputs } = inputs; const locals = ctx.lane.resume.locals; const base = locals && typeof locals === 'object' && !Array.isArray(locals) ? locals : {}; return { ...base, $sdk: { ...sdkLocals(locals), [`${name}Turns`]: turns, [inputKey]: asJson(persistedInputs) } }; };
+        const pendingResultKey = `${name}PendingResultRef`;
+        const pendingResultRef = (ctx) => { const value = sdkLocals(ctx.lane.resume.locals)[pendingResultKey]; return typeof value === 'string' ? value : undefined; };
+        const clearPendingResult = (ctx) => {
+            const locals = ordinaryLocals(ctx.lane.resume.locals);
+            const sdk = { ...sdkLocals(ctx.lane.resume.locals) };
+            delete sdk[pendingResultKey];
+            return { ...locals, $sdk: sdk };
+        };
+        const resultRefFromWait = (ctx) => {
+            const pending = pendingResultRef(ctx);
+            if (pending)
+                return pending;
+            const resolution = waitResolution(ctx.resumeInput);
+            const dependency = resolution === undefined ? undefined : Object.values(resolution.dependencies).find((candidate) => candidate.state === 'settled');
+            return dependency?.state === 'settled' ? dependency.outcome.resultRef : undefined;
+        };
+        const resultRefsFromWait = (ctx) => { const resolution = waitResolution(ctx.resumeInput); return resolution === undefined ? [] : Object.values(resolution.dependencies).flatMap((dependency) => dependency.state === 'settled' && dependency.outcome.resultRef ? [dependency.outcome.resultRef] : []); };
         const instruction = (ctx) => boundedInstruction(typeof options.instruction === 'string' ? options.instruction : options.instruction({ goal: ctx.goal, state: scalarProjection(ctx.laneState) }));
-        const submitModel = (ctx, turn, inputs = {}) => { const resultRefs = [...new Set(inputs.results ?? [])]; const findingRefs = [...new Set(inputs.findings ?? [])]; const artifactRefs = [...new Set(inputs.artifacts ?? [])]; const dataRefs = [...resultRefs, ...findingRefs, ...artifactRefs.map((ref) => ({ kind: 'artifact', ref }))]; const requirements = { ...(options.requirements ?? {}), ...(options.toolAllow === undefined ? {} : { toolCalling: true }) }; return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-turn-${turn}`, kind: 'llm', concurrencyClass: 'llm', input: programLLMInput(this.config, { task: options.task ?? 'reason', instruction: instruction(ctx), inputs: { ...(resultRefs.length ? { results: resultRefs } : {}), ...(findingRefs.length ? { findings: findingRefs } : {}), ...(artifactRefs.length ? { artifacts: artifactRefs } : {}), ...(inputs.events?.length ? { events: [...new Set(inputs.events)] } : {}) }, turn, ...(inputs.toolDiscovery === undefined ? {} : { toolDiscovery: inputs.toolDiscovery }), ...(options.outputSchema === undefined ? {} : { outputSchema: zodJsonSchema(options.outputSchema) }), ...(Object.keys(requirements).length ? { requirements } : {}) }), ...(dataRefs.length ? { derivedFrom: dataRefs } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: { programId: this.config.id, programVersion: this.config.version, step: `${name}:decode`, locals: writeTurns(ctx, turn, inputs) }, locals: writeTurns(ctx, turn, inputs) }; };
+        const submitModel = (ctx, turn, inputs = {}) => { const resultRefs = [...new Set(inputs.results ?? [])]; const findingRefs = [...new Set(inputs.findings ?? [])]; const artifactRefs = [...new Set(inputs.artifacts ?? [])]; const dataRefs = [...resultRefs, ...findingRefs, ...artifactRefs.map((ref) => ({ kind: 'artifact', ref }))]; const requirements = { ...(options.requirements ?? {}), ...(options.toolAllow === undefined ? {} : { toolCalling: true }) }; return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-turn-${turn}`, kind: 'llm', concurrencyClass: 'llm', input: programLLMInput(this.config, { task: options.task ?? 'reason', instruction: instruction(ctx), inputs: { ...(resultRefs.length ? { results: resultRefs } : {}), ...(findingRefs.length ? { findings: findingRefs } : {}), ...(artifactRefs.length ? { artifacts: artifactRefs } : {}), ...(inputs.events?.length ? { events: [...new Set(inputs.events)] } : {}), ...(inputs.conversation?.length ? { conversation: inputs.conversation } : {}) }, turn, ...(inputs.toolDiscovery === undefined ? {} : { toolDiscovery: inputs.toolDiscovery }), ...(options.outputSchema === undefined ? {} : { outputSchema: zodJsonSchema(options.outputSchema) }), ...(Object.keys(requirements).length ? { requirements } : {}) }), ...(dataRefs.length ? { derivedFrom: dataRefs } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: { programId: this.config.id, programVersion: this.config.version, step: `${name}:decode`, locals: writeTurns(ctx, turn, inputs) }, locals: writeTurns(ctx, turn, inputs) }; };
         this.handlers.set(name, (ctx) => { const turn = readTurns(ctx) + 1; const inputs = options.inputs?.(ctx) ?? {}; const output = submitModel(ctx, turn, inputs); return { ...output, next: `${name}:decode` }; });
-        this.handlers.set(`${name}:tools`, (ctx) => { const turn = readTurns(ctx); const previous = readInputs(ctx); const inputs = { ...previous, results: [...new Set([...(previous.results ?? []), ...resultRefsFromWait(ctx)])] }; return { ...submitModel(ctx, turn + 1, inputs), next: `${name}:decode` }; });
+        this.handlers.set(`${name}:tools`, (ctx) => { const turn = readTurns(ctx); const previous = readInputs(ctx); const current = options.inputs?.(ctx) ?? {}; const inputs = { ...current, ...previous, results: [...new Set([...(previous.results ?? []), ...resultRefsFromWait(ctx)])] }; return { ...submitModel(ctx, turn + 1, inputs), next: `${name}:decode` }; });
         this.handlers.set(`${name}:decode`, (ctx) => {
             const turns = readTurns(ctx);
             const ref = resultRefFromWait(ctx);
@@ -388,19 +418,33 @@ export class StepBuilder {
             const record = value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
             const finishReason = record?.finishReason;
             const toolCalls = Array.isArray(record?.toolCalls) ? record.toolCalls : [];
-            const fail = (runtimeError) => options.onError ? { next: options.onError(runtimeError, ctx) } : (() => { const error = Object.assign(new Error(runtimeError.message), runtimeError); throw error; })();
+            const fail = (runtimeError) => options.onError ? { next: options.onError(runtimeError, ctx), locals: clearPendingResult(ctx) } : (() => { const error = Object.assign(new Error(runtimeError.message), runtimeError); throw error; })();
             const dependencyError = waitFailure(ctx);
             if (dependencyError)
                 return fail(dependencyError);
             const maxTurns = Math.max(1, Math.floor(options.maxTurns ?? 10));
-            const maxTurnsReached = () => options.onMaxTurns ? { next: options.onMaxTurns(ctx) } : fail({ code: 'MAX_TURNS_REACHED', message: `ReAct loop ${name} reached its maximum of ${maxTurns} turns.`, retryable: false });
+            const maxTurnsReached = () => options.onMaxTurns ? { next: options.onMaxTurns(ctx), locals: clearPendingResult(ctx) } : fail({ code: 'MAX_TURNS_REACHED', message: `ReAct loop ${name} reached its maximum of ${maxTurns} turns.`, retryable: false });
+            // The current model result must be retained while older history is
+            // summarized. The generic compaction macro then returns to decode and
+            // this pending reference lets us continue processing the same result.
+            const compaction = this.config.historyCompaction;
+            const pressure = ctx.lane.historyPressure;
+            const shouldCompactAfterResult = compaction !== undefined && ref !== undefined && pendingResultRef(ctx) === undefined && sdkLocals(ctx.lane.resume.locals).compactPending !== true && pressure !== undefined && pressure.historyTokens > pressure.softTokens && ctx.lane.context.history.length > Math.max(0, Math.floor(compaction.keepRecentRounds));
+            if (shouldCompactAfterResult) {
+                const locals = ordinaryLocals(ctx.lane.resume.locals);
+                const sdk = sdkLocals(ctx.lane.resume.locals);
+                return { actions: [], next: '$compact:summarize', locals: { ...locals, $sdk: { ...sdk, compactPending: true, compactReturnStep: `${name}:decode`, [pendingResultKey]: ref } } };
+            }
             if (finishReason === 'tool_calls') {
                 if (turns >= maxTurns || toolCalls.length === 0)
                     return maxTurnsReached();
                 const invalidTool = toolCalls.find((call) => { const item = call && typeof call === 'object' && !Array.isArray(call) ? call : {}; const toolName = typeof item.name === 'string' ? item.name : ''; return !toolName || (options.toolAllow !== undefined && !options.toolAllow.includes(toolName)); });
                 if (invalidTool !== undefined)
                     return fail({ code: 'ACTION_TOOL_NOT_ALLOWED', message: 'Model requested a tool outside the ReAct allow-list.', retryable: false });
-                const sourceEffectId = ctx.resumeInput?.type === 'wait' ? Object.values(ctx.resumeInput.resolution.dependencies).find((dependency) => dependency.state === 'settled' && dependency.target.kind === 'effect')?.target.id : undefined;
+                const resolution = waitResolution(ctx.resumeInput);
+                const sourceEffectId = ref !== undefined && ctx.results.meta(ref)?.producer.kind === 'effect'
+                    ? ctx.results.meta(ref)?.producer.id
+                    : resolution === undefined ? undefined : Object.values(resolution.dependencies).find((dependency) => dependency.state === 'settled' && dependency.target.kind === 'effect')?.target.id;
                 const sourcePrivacy = ref === undefined ? undefined : ctx.results.meta(ref)?.privacy;
                 const toolDerivedFrom = ref === undefined ? [] : [ref];
                 const calls = toolCalls.map((call, index) => {
@@ -409,6 +453,72 @@ export class StepBuilder {
                     const toolName = typeof item.name === 'string' ? item.name : '';
                     return { originalId, toolName, toolCallId: `${name}:${turns}:${originalId}`, input: item.input ?? {} };
                 });
+                const askCalls = calls.filter((call) => String(call.toolName).startsWith('ask.'));
+                if (askCalls.length > 0) {
+                    if (askCalls.length !== calls.length)
+                        return fail({ code: 'ASK_MIXED_TOOL_CALLS', message: 'An ask interaction must be requested in a separate model turn from workspace tools.', retryable: false });
+                    if (askCalls.length !== 1)
+                        return fail({ code: 'ASK_MULTIPLE_REQUESTS', message: 'Only one ask interaction may be requested at a time.', retryable: false });
+                    const call = askCalls[0];
+                    const rawInput = call.input && typeof call.input === 'object' && !Array.isArray(call.input) ? call.input : {};
+                    const askType = call.toolName === 'ask.choice' ? 'choice' : call.toolName === 'ask.multi' ? 'multi' : call.toolName === 'ask.input' ? 'input' : undefined;
+                    if (!askType)
+                        return fail({ code: 'ASK_TOOL_UNKNOWN', message: `Unknown ask tool ${String(call.toolName)}.`, retryable: false });
+                    if (typeof rawInput.prompt === 'string' && rawInput.prompt.length > 2_000)
+                        return fail({ code: 'ASK_PROMPT_TOO_LARGE', message: 'Ask prompts must be 2000 characters or fewer.', retryable: false });
+                    const prompt = typeof rawInput.prompt === 'string' && rawInput.prompt.trim() ? rawInput.prompt : `Pulse needs your input for ${askType}.`;
+                    const askInput = { kind: 'ask', type: askType, toolName: String(call.toolName), toolCallId: String(call.toolCallId), prompt };
+                    if (askType === 'choice' || askType === 'multi') {
+                        const rawOptions = Array.isArray(rawInput.options) ? rawInput.options : [];
+                        if (rawOptions.length > 50)
+                            return fail({ code: 'ASK_OPTIONS_TOO_MANY', message: 'ask.choice and ask.multi accept at most 50 options.', retryable: false });
+                        const seen = new Set();
+                        const options = rawOptions.flatMap((option) => {
+                            const item = typeof option === 'string' ? { label: option, value: option } : option && typeof option === 'object' && !Array.isArray(option) ? option : undefined;
+                            if (!item || typeof item.label !== 'string' || typeof item.value !== 'string')
+                                return [];
+                            if (item.label.length === 0 || item.label.length > 500 || item.value.length === 0 || item.value.length > 500 || seen.has(item.value))
+                                return [];
+                            seen.add(item.value);
+                            return [{ label: item.label, value: item.value }];
+                        });
+                        if (options.length === 0)
+                            return fail({ code: 'ASK_OPTIONS_REQUIRED', message: 'ask.choice and ask.multi require at least one valid option.', retryable: false });
+                        askInput.options = options;
+                        if (askType === 'multi') {
+                            const min = typeof rawInput.min === 'number' && Number.isInteger(rawInput.min) ? rawInput.min : undefined;
+                            const max = typeof rawInput.max === 'number' && Number.isInteger(rawInput.max) ? rawInput.max : undefined;
+                            if ((rawInput.min !== undefined && (min === undefined || min < 0)) || (rawInput.max !== undefined && (max === undefined || max < 1)) || (min !== undefined && max !== undefined && min > max))
+                                return fail({ code: 'ASK_RANGE_INVALID', message: 'ask.multi min and max must be integers with min <= max.', retryable: false });
+                            if (min !== undefined)
+                                askInput.min = min;
+                            if (max !== undefined)
+                                askInput.max = max;
+                        }
+                    }
+                    else {
+                        if (typeof rawInput.placeholder === 'string') {
+                            if (rawInput.placeholder.length > 500)
+                                return fail({ code: 'ASK_PROMPT_TOO_LARGE', message: 'Ask placeholders must be 500 characters or fewer.', retryable: false });
+                            askInput.placeholder = rawInput.placeholder;
+                        }
+                        if (typeof rawInput.defaultValue === 'string') {
+                            if (rawInput.defaultValue.length > 2_000)
+                                return fail({ code: 'ASK_PROMPT_TOO_LARGE', message: 'Ask default values must be 2000 characters or fewer.', retryable: false });
+                            askInput.defaultValue = rawInput.defaultValue;
+                        }
+                    }
+                    const humanEffect = {
+                        key: `${name}-ask-${turns}`,
+                        ...(sourceEffectId === undefined ? {} : { llmEffectId: sourceEffectId }),
+                        ...(sourcePrivacy === undefined ? {} : { privacy: sourcePrivacy }),
+                        ...(toolDerivedFrom.length ? { derivedFrom: [...toolDerivedFrom] } : {}),
+                        kind: 'human',
+                        concurrencyClass: 'none',
+                        input: askInput,
+                    };
+                    return { actions: [{ type: 'submit_effects', effects: [humanEffect], wait: { onUnsatisfied: 'resume_with_error' } }], next: `${name}:tools`, locals: clearPendingResult(ctx) };
+                }
                 const makeToolEffects = (approvedCalls) => ({ type: 'submit_effects', effects: approvedCalls.map((call, index) => ({ key: `${name}-tool-${turns}-${index + 1}`, toolCallId: String(call.toolCallId ?? `${name}:${turns}:${String(call.originalId)}`), ...(sourceEffectId === undefined ? {} : { llmEffectId: sourceEffectId }), ...(sourcePrivacy === undefined ? {} : { privacy: sourcePrivacy }), ...(toolDerivedFrom.length ? { derivedFrom: [...toolDerivedFrom] } : {}), kind: 'tool', concurrencyClass: 'tool', input: { toolCallId: String(call.toolCallId ?? `${name}:${turns}:${String(call.originalId)}`), name: String(call.toolName), arguments: call.input, ...(sourcePrivacy === undefined ? {} : { privacy: sourcePrivacy }), ...(toolDerivedFrom.length ? { derivedFrom: [...toolDerivedFrom] } : {}) } })), wait: { onUnsatisfied: 'resume_with_error' } });
                 if (options.toolApproval) {
                     const approvalKey = `${name}PendingToolCalls`;
@@ -419,13 +529,21 @@ export class StepBuilder {
                     const extra = typeof options.toolApproval.prompt === 'string' ? options.toolApproval.prompt : options.toolApproval.prompt(calls.map((call) => ({ name: call.toolName, toolCallId: call.originalId })), ctx);
                     const prompt = boundedInstruction(`Approve ${calls.length} tool call(s). Digest ${digest}.\n${listing}\n${extra}`);
                     this.handlers.set(`${name}:approval`, (approvalCtx) => {
-                        const dependency = approvalCtx.resumeInput?.type === 'wait' ? Object.values(approvalCtx.resumeInput.resolution.dependencies)[0] : undefined;
+                        const resolution = waitResolution(approvalCtx.resumeInput);
+                        const dependency = resolution === undefined ? undefined : Object.values(resolution.dependencies).find((candidate) => candidate.state === 'settled');
                         const approvalError = waitFailure(approvalCtx);
                         if (approvalError)
                             return fail(approvalError);
-                        if (dependency?.state !== 'settled')
-                            return fail({ code: 'APPROVAL_RESPONSE_MISSING', message: 'Approval response was not received.', retryable: false });
-                        const value = dependency.outcome.resultRef ? readResult(approvalCtx, dependency.outcome.resultRef) : undefined;
+                        const settledDependency = dependency;
+                        if (settledDependency?.state !== 'settled') {
+                            return fail({
+                                code: 'APPROVAL_RESPONSE_MISSING',
+                                message: 'Approval response was not received.',
+                                retryable: false,
+                                details: { dependencyState: settledDependency?.state ?? 'missing', waitId: resolution?.waitId ?? null },
+                            });
+                        }
+                        const value = settledDependency.outcome.resultRef ? readResult(approvalCtx, settledDependency.outcome.resultRef) : undefined;
                         const parsed = z.object({ approved: z.boolean(), reason: z.string().optional() }).safeParse(value);
                         if (!parsed.success)
                             return fail({ code: 'APPROVAL_RESPONSE_INVALID', message: 'Approval response must contain approved=true or false.', retryable: false, details: parsed.error.message });
@@ -447,7 +565,7 @@ export class StepBuilder {
                     });
                     return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-approval-${turns}`, kind: 'human', concurrencyClass: 'none', input: { prompt, digest, tools: calls }, ...(toolDerivedFrom.length ? { derivedFrom: [...toolDerivedFrom] } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: `${name}:approval`, locals: { ...locals, $sdk: { ...sdkLocals(locals), [approvalKey]: calls, [digestKey]: digest } } };
                 }
-                return { actions: [makeToolEffects(calls)], next: `${name}:tools` };
+                return { actions: [makeToolEffects(calls)], next: `${name}:tools`, locals: clearPendingResult(ctx) };
             }
             if (turns >= maxTurns)
                 return maxTurnsReached();
@@ -460,15 +578,15 @@ export class StepBuilder {
             if (!ref)
                 return fail({ code: 'MISSING_RESULT_REF', message: 'ReAct result did not produce a ResultRef.', retryable: false });
             if (typeof options.onFinish === 'function')
-                return { next: options.onFinish(ref, ctx) };
+                return { next: options.onFinish(ref, ctx), locals: clearPendingResult(ctx) };
             if (options.onFinish.structured) {
                 const structuredValue = record?.structured ?? value;
                 const parsed = options.onFinish.structured.schema.safeParse(structuredValue);
                 if (!parsed.success)
                     return fail({ code: 'OUTPUT_SCHEMA_VIOLATION', message: 'ReAct structured result did not match schema.', retryable: false, details: parsed.error.message });
-                return { next: options.onFinish.structured.onParsed(parsed.data, ctx) };
+                return { next: options.onFinish.structured.onParsed(parsed.data, ctx), locals: clearPendingResult(ctx) };
             }
-            return { next: options.onFinish.text(ref, ctx) };
+            return { next: options.onFinish.text(ref, ctx), locals: clearPendingResult(ctx) };
         });
         return this;
     }
@@ -624,7 +742,7 @@ export class StepBuilder {
                 if (upToSeq === undefined)
                     return { next: returnStep === compactSummarize ? entry : returnStep, locals: { ...locals, $sdk: sdk } };
                 return {
-                    actions: [{ type: 'submit_effects', effects: [{ key: '$compact-summary', kind: 'llm', concurrencyClass: 'llm', input: programLLMInput(this.config, { task: compaction.summarizeTask, historySeqs: candidates.map((record) => record.seq), upToSeq }) }], wait: { onUnsatisfied: 'resume_with_error' } }],
+                    actions: [{ type: 'submit_effects', effects: [{ key: '$compact-summary', kind: 'llm', concurrencyClass: 'llm', input: programLLMInput(this.config, { task: compaction.summarizeTask, ...(compaction.instruction === undefined ? {} : { instruction: compaction.instruction }), historySeqs: candidates.map((record) => record.seq), upToSeq }) }], wait: { onUnsatisfied: 'resume_with_error' } }],
                     next: compactApply,
                     locals: { ...locals, $sdk: { ...sdk, compactPending: true, compactReturnStep: returnStep, compactUpToSeq: upToSeq } },
                 };
@@ -662,7 +780,12 @@ export class StepBuilder {
             step: (context) => {
                 const sdk = sdkLocals(context.lane.resume.locals);
                 const pressure = context.lane.historyPressure;
-                const shouldCompact = compaction !== undefined && this.compactionBoundaries.has(context.lane.resume.step) && !context.lane.resume.step.startsWith('$compact:') && context.lane.activeWaitId === undefined && sdk.compactPending !== true && pressure !== undefined && pressure.historyTokens > pressure.softTokens && context.lane.context.history.length > Math.max(0, Math.floor(compaction.keepRecentRounds));
+                const keepRecentRounds = compaction === undefined ? 0 : Math.max(0, Math.floor(compaction.keepRecentRounds));
+                const foldable = context.lane.context.history.slice(0, Math.max(0, context.lane.context.history.length - keepRecentRounds));
+                // A prefix that is already one compaction summary cannot get smaller by
+                // summarizing it again. Wait until newer rounds accumulate.
+                const onlyExistingSummary = foldable.length === 1 && foldable[0]?.instruction === '[history compacted]';
+                const shouldCompact = compaction !== undefined && this.compactionBoundaries.has(context.lane.resume.step) && !context.lane.resume.step.startsWith('$compact:') && context.lane.activeWaitId === undefined && sdk.compactPending !== true && pressure !== undefined && pressure.historyTokens > pressure.softTokens && context.lane.context.history.length > keepRecentRounds && !onlyExistingSummary;
                 if (shouldCompact)
                     return { actions: [], next: { programId: this.config.id, programVersion: this.config.version, step: compactSummarize, locals: { ...ordinaryLocals(context.lane.resume.locals), $sdk: { ...sdk, compactPending: true, compactReturnStep: context.lane.resume.step } } } };
                 const requestedStep = shouldCompact ? compactSummarize : context.lane.resume.step;

package/dist/dsl/session.js

@@ -71,7 +71,9 @@ export class PulseSession {
             const root = [...this.runtime.state.lanes.values()].find((lane) => lane.agentId === this.agentId && lane.ownerLaneId === undefined);
             if (root && ['succeeded', 'failed', 'cancelled'].includes(root.status) && !this.hasActiveDescendant() && (this.runtime.state.events.at(-1)?.seq ?? compactedThrough) === cursor)
                 return;
-            await new Promise((resolve) => setImmediate(resolve));
+            // Wait for runtime activity instead of polling with setImmediate while
+            // an external effect is still in flight.
+            await this.runtime.waitForActivity();
         }
     }
     async snapshot() {
@@ -98,17 +100,21 @@ export class PulseSession {
     async outcome() { return this.execution; }
     async reply(effectId, value) {
         const effect = this.runtime.state.effects.get(effectId);
-        if (!effect || effect.agentId !== this.agentId)
+        if (!effect || !this.ownsAgent(effect.agentId))
             throw new Error('EFFECT_NOT_OWNED');
         if (effect.kind !== 'human' || effect.outcome)
             throw new Error('EFFECT_NOT_REPLYABLE');
-        this.runtime.enqueueHostCommand({ type: 'reply', agentId: this.agentId, effectId, value });
+        if (!this.runtime.enqueueHostCommand({ type: 'reply', agentId: effect.agentId, effectId, value })) {
+            throw new Error('HOST_COMMAND_NOT_ENQUEUED');
+        }
     }
     /** Submit a human message while the agent is still running. The scheduler
      * records it immediately; targetEffectId is optional for direct replies to
      * a waiting Human Effect. */
     async submitHumanInput(inputId, value, targetEffectId) {
-        this.runtime.submitHumanInput(this.agentId, inputId, value, targetEffectId);
+        if (!this.runtime.submitHumanInput(this.agentId, inputId, value, targetEffectId)) {
+            throw new Error('HOST_COMMAND_NOT_ENQUEUED');
+        }
     }
     async cancel(reason) { this.runtime.requestCancel(this.agentId, reason); }
 }

package/dist/dsl/templates.d.ts

@@ -1,4 +1,4 @@
-import { type LaneProgramDefinition, type StepContext, type InstructionView, type NextStepTarget, type StepInputs } from './program.js';
+import { type HistoryCompactionOptions, type LaneProgramDefinition, type StepContext, type InstructionView, type NextStepTarget, type StepInputs } from './program.js';
 import type { LaneProgram } from '../scheduler/runtime.js';
 import type { Outcome, JsonValue } from '../core/types.js';
 import type { ZodTypeAny } from 'zod';
@@ -24,10 +24,7 @@ export declare function defineReActLane(config: {
         prompt: string | ((calls: JsonValue, ctx: StepContext<JsonValue>) => string);
         onDenied?: (reason: string, ctx: StepContext<JsonValue>) => NextStepTarget<JsonValue>;
     };
-    historyCompaction?: {
-        summarizeTask: string;
-        keepRecentRounds: number;
-    };
+    historyCompaction?: HistoryCompactionOptions;
 }): LaneProgramDefinition;
 export declare function defineSeriesLane(config: {
     id: string;

package/dist/scheduler/human-arbitration.js

@@ -35,11 +35,19 @@ export function ruleHumanArbitration(value, agentId, inputId, modelId = 'rules')
     const object = value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
     const text = typeof value === 'string' ? value.trim() : typeof object?.text === 'string' ? object.text.trim() : undefined;
     const command = typeof object?.command === 'string' ? object.command : text?.startsWith('/') ? text.slice(1).split(/\s+/, 1)[0] : undefined;
+    const targetLaneId = typeof object?.laneId === 'string' ? object.laneId : undefined;
+    const targetEffectId = typeof object?.effectId === 'string' ? object.effectId : undefined;
+    if (!command && text) {
+        const normalizedText = text.toLowerCase().replace(/[\s，。！？!?、,.]+/g, '');
+        const isContinuation = /^(继续|继续处理|接着做|往下做|恢复任务|resume|continue|goon|keepgoing)$/.test(normalizedText);
+        const isStatusCheck = /^(你还活着吗|还在吗|有进展吗|进展呢|现在怎么样|areyoualive|areyoustillthere|anyupdate|status)$/.test(normalizedText);
+        if (isContinuation || isStatusCheck) {
+            return { schemaVersion: 1, decisionId: `rule:${inputId}`, inputId, agentId, action: 'steer', ...(targetLaneId === undefined ? {} : { targetLaneId }), reason: isContinuation ? 'Human asked the current task to continue.' : 'Human asked for the current task status.', modelId };
+        }
+    }
     if (!command)
         return undefined;
     const normalized = command.toLowerCase();
-    const targetLaneId = typeof object?.laneId === 'string' ? object.laneId : undefined;
-    const targetEffectId = typeof object?.effectId === 'string' ? object.effectId : undefined;
     if (normalized === 'cancel' || normalized === 'stop' || normalized === 'abort')
         return { schemaVersion: 1, decisionId: `rule:${inputId}`, inputId, agentId, action: 'cancel', ...(targetLaneId === undefined ? {} : { targetLaneId }), ...(targetEffectId === undefined ? {} : { targetEffectId }), reason: 'Human requested cancellation.', modelId };
     if (normalized === 'steer' || normalized === 'redirect')

package/dist/scheduler/runtime.d.ts

@@ -278,6 +278,13 @@ export declare class PulseRuntime {
     private readonly auditLogPrivacy;
     private readonly persistenceBackend;
     private readonly 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.
+     */
+    private readonly sessionStoreDigests;
     private readonly enforcingRecoveryPrograms;
     private readonly toolVersions;
     private readonly recoveryCompatibility;
@@ -351,6 +358,7 @@ export declare class PulseRuntime {
     private readonly sessionId;
     private hostCommandSeq;
     private factWaiters;
+    private activityWaiters;
     private wakeScheduled;
     /**
      * A lock grant can happen synchronously while an effect completion is being
@@ -371,7 +379,7 @@ export declare class PulseRuntime {
     createAgent(goal: string, program: LaneProgram, agentId?: string): AgentHandle;
     start(agentId: string): PulseSession;
     /** Accept external human input without waiting for the current Effect to settle. */
-    submitHumanInput(agentId: string, inputId: string, value: JsonValue, targetEffectId?: string): void;
+    submitHumanInput(agentId: string, inputId: string, value: JsonValue, targetEffectId?: string): boolean;
     humanInputsFor(agentId: string): HumanInputRecord[];
     private humanArbitrationRequest;
     private ownsAgentForRuntime;
@@ -406,7 +414,7 @@ export declare class PulseRuntime {
     private executeRegisteredEffect;
     private journalEffect;
     private enqueueFact;
-    enqueueHostCommand(command: HostCommand): void;
+    enqueueHostCommand(command: HostCommand): boolean;
     private enqueueEffectCompletion;
     private enqueueLLMPreparation;
     private enqueueEffectReconcile;
@@ -454,6 +462,9 @@ export declare class PulseRuntime {
     private hasPendingTickCleanup;
     private hasPendingHostInteraction;
     private waitForFact;
+    /** Wait for a state or observation change without polling the event loop. */
+    waitForActivity(timeoutMs?: number): Promise<void>;
+    private notifyActivity;
     private completeFinishedChildAgents;
     completeEffect(effectId: string, execution: EffectExecution, status?: 'succeeded' | 'failed' | 'cancelled', error?: RuntimeError, additionalMutations?: Mutation[]): boolean;
     markRemoteUnknown(effectId: string, sideEffectState: 'none' | 'applied' | 'known' | 'unknown'): void;

package/dist/scheduler/runtime.js

@@ -453,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;
@@ -526,6 +533,7 @@ export class PulseRuntime {
     sessionId;
     hostCommandSeq = 1;
     factWaiters = [];
+    activityWaiters = new Set();
     wakeScheduled = false;
     /**
      * A lock grant can happen synchronously while an effect completion is being
@@ -815,7 +823,7 @@ export class PulseRuntime {
         if (!inputId)
             throw new Error('INVALID_HUMAN_INPUT_ID');
         strictJsonValue(value);
-        this.enqueueHostCommand({ type: 'human_input', agentId, inputId, value, ...(targetEffectId === undefined ? {} : { targetEffectId }) });
+        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));
@@ -918,7 +926,10 @@ export class PulseRuntime {
                 return this.applyHumanArbitrationDecision(deferred);
             }
             try {
-                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' } });
+                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;
@@ -1073,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();
@@ -1088,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)
@@ -1312,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')
@@ -1407,6 +1435,7 @@ export class PulseRuntime {
         this.syncStoragePolicy();
         this.schedulePersistence();
         this.scheduleWake();
+        this.notifyActivity();
         for (const resolve of this.factWaiters.splice(0))
             resolve();
         return true;
@@ -1416,8 +1445,9 @@ export class PulseRuntime {
         const eventId = `host-command-${this.hostCommandSeq}`;
         const urgent = command.type === 'human_input' || command.type === 'reply' || command.type === 'cancel' || command.type === 'cancel_effect';
         if (!this.enqueueFact(command, eventId, urgent))
-            return;
+            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 }) };
@@ -1617,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;
@@ -1805,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);
@@ -1826,7 +1863,7 @@ export class PulseRuntime {
                 continue;
             }
             let output;
-            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 }); } };
+            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));
             }
@@ -1941,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) {
@@ -1961,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)
@@ -2030,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)
@@ -2083,7 +2127,7 @@ 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(); }
@@ -2285,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)); }
@@ -2326,6 +2377,26 @@ 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
@@ -2542,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);
@@ -2777,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 } } }];
@@ -2812,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 } };
                 }
@@ -3001,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;
@@ -3144,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) => {
@@ -3230,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();
@@ -3262,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;

package/dist/scheduler/worker.d.ts

@@ -85,6 +85,8 @@ export declare class WorkerCoordinator implements WorkerCoordinatorContract {
     private readonly persistenceBackend;
     private persistenceDigest;
     private persistencePending;
+    private persistenceDirty;
+    private persistenceScheduled;
     private sequence;
     constructor(options?: WorkerCoordinatorOptions);
     static restore(snapshot: WorkerCoordinatorSnapshot, options?: WorkerCoordinatorOptions): WorkerCoordinator;

package/dist/scheduler/worker.js

@@ -173,6 +173,8 @@ export class WorkerCoordinator {
     persistenceBackend;
     persistenceDigest;
     persistencePending = Promise.resolve();
+    persistenceDirty = false;
+    persistenceScheduled = false;
     sequence = 1;
     constructor(options = {}) { this.persistenceBackend = options.persistenceBackend; }
     static restore(snapshot, options = {}) {
@@ -349,10 +351,28 @@ export class WorkerCoordinator {
     schedulePersistence() {
         if (!this.persistenceBackend)
             return;
+        this.persistenceDirty = true;
+        if (this.persistenceScheduled)
+            return;
+        this.persistenceScheduled = true;
         const operation = this.persistencePending.catch(() => undefined).then(async () => {
-            const snapshot = this.snapshot();
-            await this.persistenceBackend.save(snapshot, this.persistenceDigest);
-            this.persistenceDigest = snapshot.integrity?.digest;
+            while (this.persistenceDirty) {
+                this.persistenceDirty = false;
+                const snapshot = this.snapshot();
+                const digest = snapshot.integrity?.digest;
+                if (digest === this.persistenceDigest)
+                    continue;
+                try {
+                    await this.persistenceBackend.save(snapshot, this.persistenceDigest);
+                    this.persistenceDigest = digest;
+                }
+                catch (cause) {
+                    this.persistenceDirty = true;
+                    throw cause;
+                }
+            }
+        }).finally(() => {
+            this.persistenceScheduled = false;
         });
         this.persistencePending = operation;
     }
@@ -668,7 +688,7 @@ export class SqliteDistributedWorkerCoordinator {
                 result.reject(task.error ?? { code: 'WORKER_FAILED', message: 'WORKER_FAILED' });
             else
                 result.reject(new Error('WORKER_CANCELLED'));
-        }, 10);
+        }, 50);
         watcher.unref();
         this.watchers.set(taskId, watcher);
     }

package/dist/transitions/validate.js

@@ -614,7 +614,12 @@ function prepareLLMInput(state, lane, submission) {
     const rejectedInputs = readRefs('rejectedOutputRefs');
     const artifactInputs = readRefs('artifacts');
     const eventInputs = readRefs('events');
-    const inputError = resultInputs.error ?? findingInputs.error ?? rejectedInputs.error ?? artifactInputs.error ?? eventInputs.error;
+    const rawConversation = rawInputs.conversation;
+    const conversation = rawConversation === undefined ? [] : Array.isArray(rawConversation) && rawConversation.every((item) => item && typeof item === 'object' && !Array.isArray(item) && item.role !== undefined && ['system', 'user', 'assistant'].includes(String(item.role)) && typeof item.content === 'string')
+        ? rawConversation
+        : undefined;
+    const conversationError = rawConversation !== undefined && conversation === undefined ? 'INVALID_LLM_CONVERSATION' : undefined;
+    const inputError = resultInputs.error ?? findingInputs.error ?? rejectedInputs.error ?? artifactInputs.error ?? eventInputs.error ?? conversationError;
     if (inputError)
         return { error: inputError };
     const resultRefs = [...new Set([...(resultInputs.refs ?? []), ...(findingInputs.refs ?? []), ...(rejectedInputs.refs ?? [])])];
@@ -623,7 +628,7 @@ function prepareLLMInput(state, lane, submission) {
         const agent = state.agents.get(lane.agentId);
         if (!agent)
             return { error: 'UNKNOWN_AGENT' };
-        const projection = new ContextBuilder(state).build({ agent, lane, resultRefs, ...(artifactRefs.length ? { artifactRefs } : {}), eventIds: eventInputs.refs ?? [], instruction, ...(typeof input.system === 'string' ? { system: input.system } : {}), ...(input.policy === undefined ? {} : { policy: input.policy }), ...(input.tools === undefined ? {} : { tools: input.tools }), toolSetId: typeof input.toolSetId === 'string' ? input.toolSetId : 'default' });
+        const projection = new ContextBuilder(state).build({ agent, lane, resultRefs, ...(artifactRefs.length ? { artifactRefs } : {}), eventIds: eventInputs.refs ?? [], ...(conversation === undefined || conversation.length === 0 ? {} : { conversation }), instruction, ...(typeof input.system === 'string' ? { system: input.system } : {}), ...(input.policy === undefined ? {} : { policy: input.policy }), ...(input.tools === undefined ? {} : { tools: input.tools }), toolSetId: typeof input.toolSetId === 'string' ? input.toolSetId : 'default' });
         return { input: { ...input, request: projection } };
     }
     catch (cause) {
@@ -708,8 +713,13 @@ export function validateStep(state, laneId, output) {
     else if (output.adoptCommittedContext)
         return { rejection: error('INVALID_ADOPT_COMMITTED_CONTEXT', 'adoptCommittedContext requires a ContextDelta') };
     const compactRequested = output.contextDelta?.target === 'lane' && output.contextDelta.ops.some((op) => op.op === 'compact_history');
+    // ReAct can discover pressure only after consuming a model result. Permit
+    // the two-step compaction handoff and its summary request to cross the hard
+    // threshold; the following compact_history delta removes the old records.
+    const compactionHandoff = output.next.step === '$compact:summarize' && actions.length === 0;
+    const compactionSummarySubmission = actions.some((action) => action.type === 'submit_effects' && action.effects.some((effect) => effect.key === '$compact-summary'));
     const nextHistoryTokens = estimateHistoryTokens(workingLane.context.history);
-    if (nextHistoryTokens > state.historyHardTokens && !compactRequested)
+    if (nextHistoryTokens > state.historyHardTokens && !compactRequested && !compactionHandoff && !compactionSummarySubmission)
         return { rejection: error('CONTEXT_TOO_LARGE', 'Lane history exceeded hardTokens and must be compacted before another Step can commit.', { historyTokens: nextHistoryTokens, softTokens: state.historySoftTokens, hardTokens: state.historyHardTokens }) };
     const pressure = historyPressure(workingLane.context.history, state.historySoftTokens, state.historyHardTokens);
     if (pressure)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hunterzhu/pulse-runtime",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "repository": {
     "type": "git",
     "url": "https://github.com/zhuhengtan/Pulse"