@stigmer/runner-slim 3.9.0 → 3.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stigmer/runner-slim",
-  "version": "3.9.0",
+  "version": "3.11.0",
   "description": "Self-contained Stigmer runner build for embedding in desktop apps — the bundle-friendly @stigmer/runner",
   "license": "Apache-2.0",
   "engines": {
@@ -16,11 +16,11 @@
     "jq-wasm": "^1.1.0-jq-1.8.1"
   },
   "optionalDependencies": {
-    "@stigmer/runner-slim-darwin-arm64": "3.9.0",
-    "@stigmer/runner-slim-darwin-x64": "3.9.0",
-    "@stigmer/runner-slim-linux-x64": "3.9.0",
-    "@stigmer/runner-slim-linux-arm64": "3.9.0",
-    "@stigmer/runner-slim-win32-x64": "3.9.0"
+    "@stigmer/runner-slim-darwin-arm64": "3.11.0",
+    "@stigmer/runner-slim-darwin-x64": "3.11.0",
+    "@stigmer/runner-slim-linux-x64": "3.11.0",
+    "@stigmer/runner-slim-linux-arm64": "3.11.0",
+    "@stigmer/runner-slim-win32-x64": "3.11.0"
   },
   "keywords": [
     "stigmer",

package/workflow-bundle.js

@@ -28071,6 +28071,7 @@ async function emitProgress(input, childExecId, progress) {
             type: "agent_call_progress",
             taskName: input.taskName,
             occurredAt: new Date().toISOString(),
+            sequenceNumber: input.nextEventSequence?.(),
             childExecutionId: childExecId,
             agentSlug: input.config.agent ?? "",
             agentPhase: progress?.agentPhase ?? 0,
@@ -28125,6 +28126,13 @@ __webpack_require__.r(__webpack_exports__);
  * type-only imports, and pure JS/TS logic.
  */
 
+// Discovery's bounds ladder (issue #239): the activity heartbeats every 15s,
+// so heartbeatTimeout is pure LIVENESS (dead worker/pod detection) — it no
+// longer kills slow-but-alive discoveries. The activity bounds its own WORK
+// with a transport-aware init timeout (30s HTTP / 270s stdio) that fails with
+// an actionable, endpoint-naming error; startToCloseTimeout is the hard cap
+// above both. Keep the ordering: work bound < hard cap, heartbeat interval
+// (15s) < heartbeatTimeout.
 const discover = (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.proxyActivities)({
     startToCloseTimeout: "600s",
     heartbeatTimeout: "60s",
@@ -28452,7 +28460,21 @@ async function runWorkflowEngine(input, options) {
         dsl: model.document.dsl,
     });
     (0,_metrics_sink_js__WEBPACK_IMPORTED_MODULE_1__.recordExecutionStartMetric)(model.document.name);
-    await eventProxy.ResetEventSequence(executionId);
+    // Event sequence numbers are workflow state: assigned here in the
+    // deterministic sandbox (seeded from the persisted high-water mark) so
+    // they are stable across activity retries, worker restarts, and
+    // concurrent executions — the store can then treat re-sent sequences as
+    // idempotent duplicates. Pre-patch histories recorded the activity
+    // result as void and assigned sequences inside the emit activity from a
+    // process-global counter; they must keep doing so on replay, hence the
+    // gate. Remove the gate (and the activity's legacy counter) once
+    // pre-patch executions have drained.
+    const workflowAssignedSequences = (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.patched)("workflow-assigned-event-sequences");
+    const eventLogHighWaterMark = await eventProxy.ResetEventSequence(executionId);
+    let eventSequence = workflowAssignedSequences ? Number(eventLogHighWaterMark ?? 0) : 0;
+    const nextEventSequence = workflowAssignedSequences
+        ? () => ++eventSequence
+        : undefined;
     let recoveryContext;
     if (options?.recoveryMode && executionId) {
         _temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.log.info("Recovery mode active — loading context", { executionId });
@@ -28476,10 +28498,16 @@ async function runWorkflowEngine(input, options) {
     const emitEvents = async (events) => {
         if (!executionId || events.length === 0)
             return;
+        const stamped = nextEventSequence
+            ? events.map(e => ({ ...e, sequenceNumber: nextEventSequence() }))
+            : events;
         try {
-            await eventProxy.EmitWorkflowEvents(executionId, events, taskStatusAccumulator.toArray());
+            await eventProxy.EmitWorkflowEvents(executionId, stamped, taskStatusAccumulator.toArray());
         }
         catch (err) {
+            // Final guard after the activity's retries are exhausted: a run must
+            // not die because its timeline write failed. With workflow-assigned
+            // sequences the result is a gap in the log, never a poisoned log.
             _temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.log.warn("Failed to emit workflow events (non-fatal)", {
                 executionId,
                 eventCount: events.length,
@@ -28531,6 +28559,7 @@ async function runWorkflowEngine(input, options) {
             parentWorkflowId: agentMeta.parentWorkflowId || (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.workflowInfo)().workflowId,
             taskName: agentMeta.taskName,
             workflowExecutionId: agentMeta.workflowExecutionId || executionId,
+            nextEventSequence,
         }),
         promoteTaskOutput: (taskOutput, wexId, taskName, displayName) => promoteProxy.PromoteTaskOutput(taskOutput, wexId || executionId, taskName, displayName),
     };
@@ -28714,7 +28743,17 @@ async function executeFromExecution(input) {
         envCount: Object.keys(materialized.env).length,
     });
     try {
-        return await (0,_engine_core_js__WEBPACK_IMPORTED_MODULE_1__.runWorkflowEngine)(materialized, {
+        // The engine's output is deliberately NOT returned. Both orchestrator
+        // parents discard this workflow's result (Java awaits it as Void, Go
+        // passes nil to Get), and the output already reaches users through
+        // PromoteTaskOutput and the event log. Returning it would (a) persist
+        // the full workflow output — which may embed secrets — as a plaintext
+        // payload in the cross-language parent's history, and (b) hand the Java
+        // parent a payload it must decode: once the payload-encryption codec is
+        // active, an encrypted result would fail Java's converter lookup
+        // (fromPayloads has no Void special-case). A void return produces a
+        // data-less binary/null payload that every SDK handles natively.
+        await (0,_engine_core_js__WEBPACK_IMPORTED_MODULE_1__.runWorkflowEngine)(materialized, {
             checkPause,
             recoveryMode: input.recovery_mode ?? false,
         });