@bastani/atomic 0.9.62 → 0.9.63

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [0.9.63] - 2026-11-02
+
+Workflow journals that survive a stalled lock holder, and pooled roots that stay responsive with thousands of finished runs.
+
+- **A stalled journal lock holder no longer fails everyone:** journal writes wait through up to 10 minutes of a write lock held by a stalled process instead of giving up after 30 s, and group commits release the lock every 100 ms; with 300 pooled children and a holder stopped for 45 s, the root and all 300 children now complete instead of all failing ([#4186](https://github.com/bastani-inc/atomic/pull/4186))
+- **Activity batches stay fast with many finished runs:** applying a pooled root's activity looks runs up by id instead of scanning the store, so with 5,000 finished runs a batch takes 11 ms instead of 101 to 145 ms ([#4184](https://github.com/bastani-inc/atomic/pull/4184))
+
+### Fixed
+
+- Workflow runs no longer fail when another process stalls while it holds the workflow journal's write lock, for example starved of CPU on a heavily loaded host, paused by garbage collection, or stopped by a signal. Every other journal writer used to give up after 30 s with `database is locked … gave up after 30xxx ms waiting for the write lock`, which failed pooled roots together with all their children, although the holder commits as soon as it runs again. Journal writes now keep waiting through up to 10 minutes of such a stall, retrying less often after the first 30 s, and a writer that does give up names the process holding the lock and how long ago it took it. Registering a run no longer waits for the lock synchronously, which froze the process for up to 5 s, and a long batch of queued transactions commits what it has every 100 ms, so other processes' writers get in between. With 300 pooled children and another process stopped for 45 s holding the lock, the root and all 300 children used to fail; now all of them keep running ([#4183](https://github.com/bastani-inc/atomic/issues/4183))
+- A root with many children on local workers (`workflows.localWorkers`) no longer stalls its terminal for a tenth of a second or more each time it applies its children's latest activity, once the host has accumulated thousands of finished runs. Applying a batch of activity found each published run by scanning every run in the store, several times per child; runs are now looked up by id. With 300 busy children and 5,000 finished runs in the store, applying a batch now takes p90 11 ms instead of 101–145 ms, and the main thread's p99 lag drops from 88–111 ms to 11 ms ([#4182](https://github.com/bastani-inc/atomic/issues/4182))
+
+## [0.9.63-alpha.1] - 2026-11-02
+
+Workflow journals that survive a stalled lock holder, and pooled roots that stay responsive with thousands of finished runs.
+
+- **A stalled journal lock holder no longer fails everyone:** journal writes wait through up to 10 minutes of a write lock held by a stalled process instead of giving up after 30 s, and group commits release the lock every 100 ms; with 300 pooled children and a holder stopped for 45 s, the root and all 300 children now complete instead of all failing ([#4186](https://github.com/bastani-inc/atomic/pull/4186))
+- **Activity batches stay fast with many finished runs:** applying a pooled root's activity looks runs up by id instead of scanning the store, so with 5,000 finished runs a batch takes 11 ms instead of 101 to 145 ms ([#4184](https://github.com/bastani-inc/atomic/pull/4184))
+
+### Fixed
+
+- Workflow runs no longer fail when another process stalls while it holds the workflow journal's write lock, for example starved of CPU on a heavily loaded host, paused by garbage collection, or stopped by a signal. Every other journal writer used to give up after 30 s with `database is locked … gave up after 30xxx ms waiting for the write lock`, which failed pooled roots together with all their children, although the holder commits as soon as it runs again. Journal writes now keep waiting through up to 10 minutes of such a stall, retrying less often after the first 30 s, and a writer that does give up names the process holding the lock and how long ago it took it. Registering a run no longer waits for the lock synchronously, which froze the process for up to 5 s, and a long batch of queued transactions commits what it has every 100 ms, so other processes' writers get in between. With 300 pooled children and another process stopped for 45 s holding the lock, the root and all 300 children used to fail; now all of them keep running ([#4183](https://github.com/bastani-inc/atomic/issues/4183))
+- A root with many children on local workers (`workflows.localWorkers`) no longer stalls its terminal for a tenth of a second or more each time it applies its children's latest activity, once the host has accumulated thousands of finished runs. Applying a batch of activity found each published run by scanning every run in the store, several times per child; runs are now looked up by id. With 300 busy children and 5,000 finished runs in the store, applying a batch now takes p90 11 ms instead of 101–145 ms, and the main thread's p99 lag drops from 88–111 ms to 11 ms ([#4182](https://github.com/bastani-inc/atomic/issues/4182))
+
 ## [0.9.62] - 2026-11-02
 
 Pooled roots that keep dispatching under load, children that survive a stalled worker, and Intercom sends that no longer report a delivered message as failed.

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.62",
+  "version": "0.9.63",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.62",
+  "version": "0.9.63",
   "private": true,
   "description": "Atomic's pi-compatible MCP integration for server connections, OAuth, tools, resources, and terminal management.",
   "contributors": [

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.62",
+  "version": "0.9.63",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with parallel execution. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.62",
+  "version": "0.9.63",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [

package/dist/builtin/workflows/builtin/{chunk-vzbec50q.js → chunk-95r61ve5.js}

@@ -37,7 +37,7 @@ import {
   parseFailureDiagnostics,
   summarizeReviewConvergence,
   reverify_consolidated_batch
-} from "./chunk-zhyqnf5g.js";
+} from "./chunk-rv4xxwd6.js";
 import {
   VERIFICATION_SCALE
 } from "./chunk-n1910xc4.js";

package/dist/builtin/workflows/builtin/{chunk-a2j0x1a6.js → chunk-qbthhjjk.js}

@@ -39,7 +39,7 @@ import {
   reviewerFailureText,
   summarizeReviewConvergence,
   reverify_consolidated_batch
-} from "./chunk-zhyqnf5g.js";
+} from "./chunk-rv4xxwd6.js";
 import {
   fold_usage
 } from "./chunk-tgt0s5e5.js";

package/dist/builtin/workflows/builtin/{chunk-zhyqnf5g.js → chunk-rv4xxwd6.js}

@@ -1329,13 +1329,13 @@ class WorkflowObservationRuntime {
       return run.rootRunId;
     if (run.parentRunId === undefined)
       return run.id;
-    const parent = this.runs().find((candidate) => candidate.id === run.parentRunId);
+    const parent = this.runs.find(run.parentRunId);
     return parent ? this.rootRunId(parent) : run.parentRunId;
   }
   lifecycle(target, attribution = "unknown") {
     if (this.recovering && !this.liveRunIds.has(target.runId))
       return;
-    const run = this.runs().find((candidate) => candidate.id === target.runId);
+    const run = this.runs.find(target.runId);
     if (!run)
       return;
     const rootRunId = this.rootRunId(run);
@@ -1356,7 +1356,7 @@ class WorkflowObservationRuntime {
     });
   }
   control(runId, action, attribution = "unknown") {
-    const run = this.runs().find((candidate) => candidate.id === runId);
+    const run = this.runs.find(runId);
     if (!run)
       return;
     if ((action === "quit" || action === "kill" || action === "pause") && this.liveRunIds.has(runId))
@@ -1367,7 +1367,7 @@ class WorkflowObservationRuntime {
     this.invalidate({ runId });
   }
   heartbeat(runId, scheduledAt, intervalMinutes) {
-    const run = this.runs().find((candidate) => candidate.id === runId);
+    const run = this.runs.find(runId);
     if (run)
       this.emit({
         kind: "heartbeat",
@@ -1393,7 +1393,7 @@ class WorkflowObservationRuntime {
     if (changes === undefined) {
       const next = new Map;
       const nextOwners = new Map;
-      for (const run of this.runs()) {
+      for (const run of this.runs.all()) {
         const owners = nextOwners.get(run.id) ?? new Map;
         nextOwners.set(run.id, owners);
         this.captureRun(run, this.previous.has(`run:${run.id}`), next, owners);
@@ -1420,10 +1420,15 @@ class WorkflowObservationRuntime {
         nodes.tools.add(change.toolNodeId);
       changed.set(change.runId, nodes);
     }
-    for (const run of this.runs()) {
-      const change = changed.get(run.id);
-      if (change === undefined)
+    const ordered = [...changed.keys()].flatMap((runId) => {
+      const position = this.runs.position(runId);
+      return position === undefined ? [] : [{ runId, position }];
+    }).sort((left, right) => left.position - right.position);
+    for (const { runId } of ordered) {
+      const run = this.runs.find(runId);
+      if (run === undefined)
         continue;
+      const change = changed.get(runId);
       const existing = this.previous.has(`run:${run.id}`);
       const nodes = change === "run" || !existing ? undefined : change;
       const next = new Map;
@@ -1461,7 +1466,7 @@ class WorkflowObservationRuntime {
         keys.push(key);
       const previous = this.previous.get(key);
       if (!historical && this.liveRunIds.has(target.runId) && previous?.status !== target.status) {
-        this.lifecycle(previous && previous.kind !== "prompt" && target.kind !== "prompt" ? { ...target, previousStatus: previous.status } : target, this.runs().find((candidate) => candidate.id === target.runId)?.origin);
+        this.lifecycle(previous && previous.kind !== "prompt" && target.kind !== "prompt" ? { ...target, previousStatus: previous.status } : target, this.runs.find(target.runId)?.origin);
       }
     };
     visit("run", `run:${run.id}`, { kind: "run", runId: run.id, status: run.status });
@@ -1591,6 +1596,7 @@ function applyRunEndMetadata(run, metadata) {
 function createStoreState() {
   return {
     runs: [],
+    runPositions: new Map,
     notices: [],
     listeners: new Set,
     invalidationListeners: new Set,
@@ -1600,11 +1606,27 @@ function createStoreState() {
     version: 0
   };
 }
+function reindexRuns(state) {
+  state.runPositions.clear();
+  state.runs.forEach((run, position) => {
+    if (!state.runPositions.has(run.id))
+      state.runPositions.set(run.id, position);
+  });
+}
+function runPosition(state, runId) {
+  const position = state.runPositions.get(runId);
+  if (position !== undefined && state.runs[position]?.id === runId)
+    return position;
+  if (position === undefined && state.runPositions.size === state.runs.length)
+    return;
+  reindexRuns(state);
+  return state.runPositions.get(runId);
+}
 function createStoreContext(state = createStoreState()) {
   let cachedGraphVersion = -1;
   let cachedGraphSnapshot;
   const graphBuilder = new GraphStoreSnapshotBuilder;
-  const observation = new WorkflowObservationRuntime(() => state.runs, bumpAndNotify);
+  const observation = new WorkflowObservationRuntime({ all: () => state.runs, find: findRun, position: (runId) => runPosition(state, runId) }, bumpAndNotify);
   function snapshot() {
     return JSON.parse(JSON.stringify({ runs: state.runs, notices: state.notices, version: state.version }));
   }
@@ -1618,7 +1640,7 @@ function createStoreContext(state = createStoreState()) {
   function graphRun(runId) {
     if (cachedGraphSnapshot !== undefined && cachedGraphVersion === state.version)
       return findSnapshotRun(cachedGraphSnapshot.runs, runId);
-    const run = state.runs.find((candidate) => candidate.id === runId);
+    const run = findRun(runId);
     return run === undefined ? undefined : graphBuilder.buildRun(run);
   }
   let batchDepth = 0;
@@ -1672,7 +1694,29 @@ function createStoreContext(state = createStoreState()) {
     }
   }
   function findRun(runId) {
-    return state.runs.find((r) => r.id === runId);
+    const position = runPosition(state, runId);
+    return position === undefined ? undefined : state.runs[position];
+  }
+  function placeRun(run) {
+    const position = runPosition(state, run.id);
+    if (position !== undefined) {
+      state.runs[position] = run;
+      return;
+    }
+    state.runPositions.set(run.id, state.runs.length);
+    state.runs.push(run);
+  }
+  function removeRunAt(position) {
+    const [removed] = state.runs.splice(position, 1);
+    if (removed === undefined)
+      return;
+    state.runPositions.delete(removed.id);
+    for (let index = position;index < state.runs.length; index++)
+      state.runPositions.set(state.runs[index].id, index);
+  }
+  function clearRuns() {
+    state.runs.length = 0;
+    state.runPositions.clear();
   }
   function findStage(run, stageId) {
     return run.stages.find((s) => s.id === stageId);
@@ -1728,6 +1772,10 @@ function createStoreContext(state = createStoreState()) {
     batch,
     bumpAndNotify,
     findRun,
+    runPosition: (runId) => runPosition(state, runId),
+    placeRun,
+    removeRunAt,
+    clearRuns,
     findStage,
     rejectPrompt,
     rejectStagePrompt,
@@ -2488,6 +2536,9 @@ function createRunStoreMethods(context) {
     runs() {
       return state.runs;
     },
+    run(runId) {
+      return context.findRun(runId);
+    },
     notices() {
       return state.notices;
     },
@@ -2507,11 +2558,7 @@ function createRunStoreMethods(context) {
       return null;
     },
     recordRunStart(run) {
-      const index = state.runs.findIndex((existing) => existing.id === run.id);
-      if (index === -1)
-        state.runs.push(run);
-      else
-        state.runs[index] = run;
+      context.placeRun(run);
       context.bumpAndNotify({ runId: run.id });
     },
     recordRunSummary(runId, summary, summarizedThrough) {
@@ -2652,17 +2699,13 @@ function createRunStoreMethods(context) {
         restored.result = metadata.result;
       if (metadata.budgetState !== undefined)
         restored.budgetState = metadata.budgetState;
-      const index = state.runs.findIndex((candidate) => candidate.id === source.id);
-      if (index < 0)
-        state.runs.push(restored);
-      else
-        state.runs[index] = restored;
+      context.placeRun(restored);
       context.bumpAndNotify();
       return true;
     },
     removeRun(runId) {
-      const index = state.runs.findIndex((r) => r.id === runId);
-      if (index < 0)
+      const index = context.runPosition(runId);
+      if (index === undefined)
         return false;
       const run = state.runs[index];
       const pending = run.pendingPrompt;
@@ -2674,7 +2717,7 @@ function createRunStoreMethods(context) {
       for (const stage of run.stages) {
         state.stagePromptAnswers.delete(context.stagePromptAnswerKey(runId, stage.id));
       }
-      state.runs.splice(index, 1);
+      context.removeRunAt(index);
       for (let i = state.notices.length - 1;i >= 0; i--) {
         if (state.notices[i]?.runId === runId)
           state.notices.splice(i, 1);
@@ -2766,7 +2809,7 @@ function createRunStoreMethods(context) {
     clear() {
       if (state.runs.length === 0 && state.notices.length === 0 && state.resolvers.size === 0 && state.stagePromptAnswers.size === 0 && state.stagePromptDrafts.size === 0)
         return;
-      state.runs.length = 0;
+      context.clearRuns();
       state.notices.length = 0;
       for (const entry of state.resolvers.values()) {
         entry.reject(new Error("atomic-workflows: store cleared"));

package/dist/builtin/workflows/builtin/goal.js

@@ -1,7 +1,7 @@
 import {
   goal_default
-} from "./chunk-vzbec50q.js";
-import"./chunk-zhyqnf5g.js";
+} from "./chunk-95r61ve5.js";
+import"./chunk-rv4xxwd6.js";
 import"./chunk-2377r57g.js";
 import"./chunk-z0d03ktm.js";
 import"./chunk-n1910xc4.js";

package/dist/builtin/workflows/builtin/index.js

@@ -16,8 +16,8 @@ import {
 } from "./chunk-8d40nyz9.js";
 import {
   goal_default
-} from "./chunk-vzbec50q.js";
-import"./chunk-zhyqnf5g.js";
+} from "./chunk-95r61ve5.js";
+import"./chunk-rv4xxwd6.js";
 import"./chunk-z0d03ktm.js";
 import {
   open_claude_design_default
@@ -27,7 +27,7 @@ import {
 } from "./chunk-37gm3bzk.js";
 import {
   ralph_default
-} from "./chunk-a2j0x1a6.js";
+} from "./chunk-qbthhjjk.js";
 import {
   tournament_default
 } from "./chunk-2f1shjah.js";

package/dist/builtin/workflows/builtin/ralph.js

@@ -1,7 +1,7 @@
 import {
   ralph_default
-} from "./chunk-a2j0x1a6.js";
-import"./chunk-zhyqnf5g.js";
+} from "./chunk-qbthhjjk.js";
+import"./chunk-rv4xxwd6.js";
 import"./chunk-2377r57g.js";
 import"./chunk-z0d03ktm.js";
 import"./chunk-n1910xc4.js";

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.62",
+  "version": "0.9.63",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [

package/dist/builtin/workflows/src/durable/journal/internal.d.ts

@@ -1,7 +1,17 @@
-import type { SqliteExecutor } from "@bastani/atomic/storage";
+import type { SqliteExecutor, SqliteTransactionOptions } from "@bastani/atomic/storage";
 import { type AppendOutcome, type Lease, type RunJournal, type RunJournalBatchAppend, type RunSnapshotTail, type RunVersion } from "./types.js";
 export type { RunJournalBatchAppend as JournalBatchAppend, RunSnapshotTail, RunVersion } from "./types.js";
 export declare const JOURNAL_READ_PAGE_SIZE = 256;
+/**
+ * How every journal write transaction waits for the write lock: up to 10 minutes of no commit anywhere, far past the
+ * 30 s a connection waits by default. A process stalled holding the lock (starved of CPU, paused for garbage
+ * collection, stopped by a signal) commits or rolls back once it runs again, and failing the waiting write would only
+ * fail its run without freeing the lock (#4183). Only waiting for the lock is longer: once a write has the lock it
+ * checks its lease or work lease as before, so a stall longer than a lease ends in that lease's expiry and fencing,
+ * never in a write applied under a lease that was lost meanwhile. Waiters keep their writers'-queue order only while
+ * they keep polling; that order is fairness, not correctness, which the checks inside each transaction keep.
+ */
+export declare const JOURNAL_TRANSACTION: SqliteTransactionOptions;
 /** Event types the durable backend folds without replacing the run's handle; every other event carries it. */
 export declare const NON_SNAPSHOT_EVENT_TYPES: readonly ["CheckpointRecorded", "MessageSettled", "MessageDelivered"];
 /** Lets a durable backend re-read only the runs that changed. */

package/dist/builtin/workflows/src/durable/journal/sql-run-journal.d.ts

@@ -17,6 +17,8 @@ export declare class SqlRunJournal implements RunJournal {
     get descriptor(): StorageDescriptor;
     get path(): string;
     private assertOpen;
+    /** A journal write transaction, waiting out a write lock held by a stalled process (`JOURNAL_TRANSACTION`). */
+    private transaction;
     private operation;
     private snapshotJson;
     createRun(header: RunHeader): Promise<"created" | "exists">;