@hunterzhu/pulse-runtime 0.5.1 → 0.7.0

package/dist/storage/persistence.js

@@ -102,6 +102,20 @@ export class FileRuntimeContentStore {
             throw new Error('RUNTIME_CONTENT_REF_COLLISION');
         return structuredClone(envelope.value);
     }
+    loadSync(ref) {
+        let envelope;
+        try {
+            envelope = JSON.parse(readFileSync(this.pathFor(ref), 'utf8'));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        }
+        if (envelope.schemaVersion !== 1 || envelope.ref !== ref || envelope.value === undefined)
+            throw new Error('INVALID_RUNTIME_CONTENT');
+        return envelope.value;
+    }
     pathFor(ref) { return join(this.directory, `${createHash('sha256').update(ref).digest('hex')}.json`); }
     async readEnvelope(path) {
         try {
@@ -176,6 +190,10 @@ export class SqliteRuntimeContentStore {
             return structuredClone(JSON.parse(row.payload));
         });
     }
+    loadSync(ref) {
+        const row = this.open().prepare('SELECT payload FROM runtime_content WHERE namespace = ? AND ref = ?').get(this.namespace, ref);
+        return row && typeof row.payload === 'string' ? JSON.parse(row.payload) : undefined;
+    }
     async close() {
         await this.enqueue(async () => {
             this.database?.close();
@@ -888,8 +906,10 @@ export async function externalizeRuntimeResultBodies(snapshot, store) {
     const states = [copy.state, ...(copy.checkpoint === undefined ? [] : [copy.checkpoint.state])];
     for (const session of states) {
         for (const [ref, result] of session.state.results) {
-            if (result.value === undefined)
+            if (result.value === undefined) {
+                refs.add(ref);
                 continue;
+            }
             await store.save(ref, result.value);
             delete result.value;
             refs.add(ref);

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/tools/registry.d.ts

@@ -58,6 +58,7 @@ export interface RuntimeToolDefinition {
     execute(input: unknown, context: RuntimeToolContext): Promise<unknown> | unknown;
     executionRef?(input: unknown, context: RuntimeToolContext): JsonValue;
     resolveResources?(input: unknown): ResourceLockSpec[];
+    resolveTimeoutMs?(input: unknown): number;
     reconcile?(executionRef: JsonValue, context: RuntimeReconcileContext): Promise<RuntimeReconcileResult>;
     normalize?(output: unknown): JsonValue;
     summarize?(output: unknown): JsonValue;

package/dist/tools/registry.js

@@ -299,7 +299,10 @@ export class RuntimeToolRegistry {
     admission(name, input) {
         const definition = this.require(name);
         const parsed = this.validateInput(name, input);
-        return { locks: structuredClone(this.resolveResources(name, parsed)), sideEffectPolicy: definition.manifest.sideEffectPolicy, defaultTimeoutMs: definition.manifest.defaultTimeoutMs, retrySafety: definition.manifest.retrySafety, version: definition.manifest.version };
+        const timeout = definition.resolveTimeoutMs?.(parsed) ?? definition.manifest.defaultTimeoutMs;
+        if (definition.resolveTimeoutMs && (!Number.isSafeInteger(timeout) || timeout <= 0 || timeout > 600_000))
+            throw Object.assign(new Error('Resolved tool timeout is outside host limits.'), { code: 'INVALID_TOOL_TIMEOUT' });
+        return { locks: structuredClone(this.resolveResources(name, parsed)), sideEffectPolicy: definition.manifest.sideEffectPolicy, defaultTimeoutMs: timeout, retrySafety: definition.manifest.retrySafety, version: definition.manifest.version };
     }
     require(name) {
         if (!this.isAllowed(name))

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.7.0",
   "license": "PolyForm-Noncommercial-1.0.0",
   "repository": {
     "type": "git",