@hunterzhu/pulse-runtime 0.5.1 → 0.6.0

package/dist/storage/policy.d.ts

@@ -52,6 +52,8 @@ export declare class SessionStoragePolicy {
     pin(key: string): void;
     unpin(key: string): void;
     remove(key: string): boolean;
+    /** Only after the event archive has durably acknowledged these exact events. */
+    forgetArchivedEvents(ids: Iterable<string>): void;
     /** Replace one logical owner’s pins without double-counting repeated reconciliation. */
     replacePinSource(source: string, keys: Iterable<string>): void;
     /** Make a private copy suitable for validate-stage storage admission. Shallow: records are immutable and shared. */

package/dist/storage/policy.js

@@ -123,6 +123,14 @@ export class SessionStoragePolicy {
         }
         return true;
     }
+    /** Only after the event archive has durably acknowledged these exact events. */
+    forgetArchivedEvents(ids) {
+        for (const id of ids) {
+            const record = this.records.get(`event:${id}`);
+            if (record?.kind === 'event' && record.storageState === 'persisted' && record.pinCount === 0)
+                this.unset(record.key);
+        }
+    }
     /** Replace one logical owner’s pins without double-counting repeated reconciliation. */
     replacePinSource(source, keys) {
         const next = new Set(keys);

package/dist/transitions/validate.js

@@ -619,6 +619,9 @@ function prepareLLMInput(state, lane, submission) {
         ? rawConversation
         : undefined;
     const conversationError = rawConversation !== undefined && conversation === undefined ? 'INVALID_LLM_CONVERSATION' : undefined;
+    const historySeqs = input.historySeqs;
+    if (historySeqs !== undefined && (!Array.isArray(historySeqs) || historySeqs.some(seq => typeof seq !== 'number' || !Number.isSafeInteger(seq) || seq < 1)))
+        return { error: 'INVALID_LLM_HISTORY_SELECTION' };
     const inputError = resultInputs.error ?? findingInputs.error ?? rejectedInputs.error ?? artifactInputs.error ?? eventInputs.error ?? conversationError;
     if (inputError)
         return { error: inputError };
@@ -628,7 +631,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, explicitContext: input.explicitContext === true, 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' });
+        const projection = new ContextBuilder(state).build({ agent, lane, explicitContext: input.explicitContext === true, includeLaneHistory: input.includeLaneHistory === true, ...(Array.isArray(historySeqs) ? { historySeqs: historySeqs } : {}), 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) {
@@ -679,40 +682,42 @@ export function validateStep(state, laneId, output) {
     const seenToolCallIds = new Set();
     const seenCancelTargets = new Set();
     const cancelledSubtreeLanes = new Set();
-    if (output.contextDelta !== undefined) {
-        const deltaShapeError = validateContextDeltaShape(output.contextDelta);
+    if (output.laneContextDelta !== undefined && (output.contextDelta?.target !== 'global' || output.laneContextDelta?.target !== 'lane'))
+        return { rejection: error('INVALID_CONTEXT_DELTA_PAIR', 'A secondary lane delta requires a primary global delta') };
+    if (output.adoptCommittedContext && output.contextDelta?.target !== 'global')
+        return { rejection: error('INVALID_ADOPT_COMMITTED_CONTEXT', 'adoptCommittedContext requires a global ContextDelta') };
+    for (const delta of [output.contextDelta, output.laneContextDelta]) {
+        if (delta === undefined)
+            continue;
+        const deltaShapeError = validateContextDeltaShape(delta);
         if (deltaShapeError)
             return { rejection: error(deltaShapeError, 'ContextDelta shape is invalid') };
-        const deltaPrivacyTaintError = validatePrivacyTaints(output.contextDelta.privacyTaints);
+        const deltaPrivacyTaintError = validatePrivacyTaints(delta.privacyTaints);
         if (deltaPrivacyTaintError)
             return { rejection: error(deltaPrivacyTaintError, 'ContextDelta privacy taints are invalid') };
-        const deltaDerived = derivedPrivacy(state, lane, output.contextDelta.derivedFrom ?? []);
+        const deltaDerived = derivedPrivacy(state, lane, delta.derivedFrom ?? []);
         if (deltaDerived.error)
             return { rejection: error(deltaDerived.error, 'ContextDelta provenance references an unknown or invisible result') };
-        if (output.contextDelta.privacy !== undefined && deltaDerived.privacy !== undefined && privacyRank(output.contextDelta.privacy) < privacyRank(deltaDerived.privacy))
+        if (delta.privacy !== undefined && deltaDerived.privacy !== undefined && privacyRank(delta.privacy) < privacyRank(deltaDerived.privacy))
             return { rejection: error('PRIVACY_DOWNGRADE_WITHOUT_PROOF', 'ContextDelta privacy cannot be broader than its sources') };
-        if (output.contextDelta.target === 'global' && !output.contextDelta.proposal && lane.ownerLaneId !== undefined)
+        if (delta.target === 'global' && !delta.proposal && lane.ownerLaneId !== undefined)
             return { rejection: error('GLOBAL_CONTEXT_WRITE_NOT_AUTHORIZED', 'Only the root Lane may commit Global Context directly.') };
-        if (output.contextDelta.target !== 'global' && output.contextDelta.proposal)
+        if (delta.target !== 'global' && delta.proposal)
             return { rejection: error('INVALID_MERGE_PROPOSAL', 'Only Global Context deltas may be proposals.') };
-        const applied = applyContextDelta(state, workingLane, output.contextDelta, mutations, output.contextDelta.proposal ? `proposal-${proposalCounter++}` : undefined);
+        const applied = applyContextDelta(state, workingLane, delta, mutations, delta.proposal ? `proposal-${proposalCounter++}` : undefined);
         if (applied.error)
             return { rejection: error(applied.error, 'ContextDelta rejected') };
-        if (output.contextDelta.target === 'lane') {
+        if (delta.target === 'lane') {
             const nextValue = mutations[mutations.length - 1];
             if (nextValue?.op === 'setLaneContext')
                 workingLane.context = { ...workingLane.context, state: nextValue.value, version: applied.nextVersion, ...(nextValue.history === undefined ? {} : { history: structuredClone(nextValue.history) }), ...(nextValue.metadata === undefined ? {} : structuredClone(nextValue.metadata)) };
         }
-        if (output.adoptCommittedContext && output.contextDelta.target !== 'global')
-            return { rejection: error('INVALID_ADOPT_COMMITTED_CONTEXT', 'adoptCommittedContext requires a global ContextDelta') };
-        if (output.contextDelta.proposal && output.adoptCommittedContext)
+        if (delta.proposal && output.adoptCommittedContext)
             return { rejection: error('INVALID_ADOPT_COMMITTED_CONTEXT', 'proposals cannot be adopted in the same transaction') };
-        if (output.contextDelta.target === 'global' && output.adoptCommittedContext)
+        if (delta.target === 'global' && output.adoptCommittedContext)
             workingLane.contextSnapshotVersion = applied.nextVersion;
     }
-    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');
+    const compactRequested = [output.contextDelta, output.laneContextDelta].some(delta => delta?.target === 'lane' && delta.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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hunterzhu/pulse-runtime",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "license": "PolyForm-Noncommercial-1.0.0",
   "repository": {
     "type": "git",