@llblab/pi-actors 0.23.0 → 0.24.1

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## Unreleased
+
+## 0.24.1: Build Script Package Hygiene Hotfix
+
+- `[Backlog]` Added the next focused backlog set for recipe doctor remediation UX, actor worker v2, and dist package contract hardening.
+- `[Skills]` Clarified agent-governed promotion of successful transient actor patterns into durable local tools via `register_tool`, without UI buttons or automatic registration.
+
+## 0.24.0: Reliability, Mailbox Workers, and Dist-First Packaging
+
+- `[Prompts]` Clarified that recipe registry warnings are actionable maintenance: invalid or blocking recipes should be fixed, removed, or disabled rather than ignored.
+- `[Backlog]` Pruned and refocused the backlog around reliability, mailbox-loop consolidation, protocol fixtures, follow-up deduplication, and portability reality checks.
+- `[State]` Added resilient JSON/JSONL state reader helpers and routed room, inspector, runtime wake, run inbox, and observability outbox reads through them so malformed state records degrade instead of breaking previews; room status now reports state diagnostic counts and reader degradation behavior has direct regression coverage.
+- `[Observability]` Deduplicated run outbox events by stable event id so line-counter resets do not replay already-seen follow-ups; stale dedupe state is pruned with terminal and missing runs.
+- `[Mailbox Loop]` Added initial run/branch mailbox claim-and-handle helpers plus branch inbox claiming support, failed-handler transitions, standard stop-message detection, bounded message drains, duplicate-claim coverage, and a packaged `actor-worker` demo recipe for canonical mailbox loops.
+- `[Scripts]` Added installed-package coverage proving the packaged `actor-worker` script uses compiled `dist` runtime modules instead of importing TypeScript from `node_modules`; `npm run build` now cleans stale `dist` output, mirrors packaged `scripts/`, `recipes/`, and `fixtures/` into `dist/`, and syntax-checks the built script entrypoints. The `actor-worker`, `async-runner`, `validate-recipe`, and `conformance` executables are now thin shims over compiled TypeScript entrypoint logic in `lib/actor-worker.ts`, `lib/async-runner.ts`, `lib/validate-recipe.ts`, and `lib/conformance.ts`, with build-output regressions for the compiled shim modules.
+- `[Packaging]` Exposed optional `pi.sourceExtensions` metadata pointing at the root TypeScript entrypoint while keeping Node-compatible `pi.extensions` on compiled `dist` output.
+- `[Context]` Clarified the project frame as an experimental self-evolution membrane for local agent capabilities, grounded in explicit actors, recipes, fixtures, skills, and inspectable state.
+- `[Protocol]` Clarified dotted `channel.action` message types as the minimal action surface: scripts can often dispatch from `type` alone while agents may use `body` for free-form prompts.
+- `[Recipes]` Fixed `pipeline-quorum-review` registry loading by inlining the quorum fanout over its `models` array instead of importing a nested repeated recipe with unresolved runtime values.
+- `[Recipes]` Made Markdown recipe frontmatter more forgiving: `args` can be a comma-separated scalar and `defaults` can be a list of `key: value` entries, both normalizing to the canonical JSON recipe shape.
+- `[Packaging]` Build output now mirrors packaged `skills/` into `dist/` alongside scripts, recipes, and fixtures so the JS-only distributive tree carries the project skills; package skill metadata now points at `dist/skills` with `pi.sourceSkills` preserving root TypeScript/source-tree paths, and README now documents the dist-first/source-optional package shape. The dist build pipeline now lives in `scripts/build-dist.mjs` instead of an inline package script, completing the compiled script entrypoint backlog slice.
+- `[Docs]` Added a platform support matrix for mailbox-only, FIFO, named-pipe, and process-control behavior across Linux/macOS/WSL and native Windows, with regressions proving native Windows FIFO limits remain visible and the canonical worker recipe stays mailbox-only.
+- `[Backlog]` Marked the reliability, mailbox loop, protocol fixture, portability, and compiled-entrypoint milestone set complete; future backlog additions should come from concrete actor workflow evidence.
+- `[Scripts]` Migrated `recipe-utils`, `locker`, `coordinator`, and `validate-recipe` command logic behind compiled TypeScript domain modules while preserving the stable `scripts/*.mjs` shim paths; project guidance frames this as deliberate standard-library growth with clear domain boundaries while keeping self-contained application/build scripts such as `music-player.mjs` and `build-dist.mjs` standalone.
+- `[Protocol]` Added compact protocol fixtures for actor messages, mailbox contracts, run inbox/outbox records, room messages/rosters, run state, recipe summaries, and artifact manifests with regression coverage.
+- `[Skills]` Documented the passive-active skill evolution discipline: `actors` tracks extension mechanics while `swarm` tracks orchestration standards and lessons.
+
 ## 0.23.0: Actor Manifests, Inspection, and Runtime Hygiene
 
 - `[Tools]` Unified branch-envelope routing for direct branch messages and selected-recipient room multicast so both paths persist the same branch-local inbox shape before dispatching through the parent run mailbox.

package/README.md

@@ -43,6 +43,8 @@ Or from git:
 pi install git:github.com/llblab/pi-actors
 ```
 
+The npm package is dist-first for JavaScript-only runtimes: default Pi metadata points at compiled `dist/` entrypoints and mirrored runtime assets. Source TypeScript and source skills remain in the package for TypeScript-native runtimes through optional source metadata.
+
 ## Address Surface
 
 Actors and coordination endpoints are addressed with compact route strings:
@@ -255,6 +257,17 @@ Use mailbox declarations when an actor has a stable conversational surface.
 
 Core actor state, inspection, foreground tools, and basic async runs are portable Node.js behavior. Run-local messaging and stop/kill use a platform adapter under the same `message` API: Unix-compatible recipes can use their existing local control endpoint, while native Windows recipes can expose a Windows-native endpoint in run state. Some packaged scripts still depend on Unix tools and are WSL/Linux/macOS-only until migrated; their public recipe surface should stay `spawn` / `message` / `inspect` either way.
 
+| Surface | Linux/macOS/WSL | Native Windows |
+| --- | --- | --- |
+| Foreground tools, recipe discovery, inspect | Supported | Supported |
+| Async runs and file-backed state | Supported | Supported |
+| Mailbox-only actors and worker recipe | Supported | Supported |
+| FIFO control endpoints | Supported | Not supported; use mailbox or named pipe |
+| Named-pipe control endpoints | Not needed | Supported when recipe exposes one |
+| Process cancel/kill | Process group signal with pid fallback | Windows process-tree adapter |
+
+Packaged recipes should prefer mailbox/wake behavior for portable control. Recipes that require FIFO, Unix shell tools, or platform-specific media backends should make that limitation visible in docs or diagnostics before launch.
+
 ## Safety Boundary
 
 `pi-actors` is local-first, not sandbox-first.

package/dist/fixtures/protocol/actor-message-branch.json

@@ -0,0 +1,13 @@
+{
+  "to": "branch:demo/reviewer",
+  "from": "run:demo",
+  "type": "task.assign",
+  "summary": "Review the current slice",
+  "body": {
+    "task": "Check mailbox loop semantics"
+  },
+  "correlation_id": "task-001",
+  "metadata": {
+    "requires_response": true
+  }
+}

package/dist/fixtures/protocol/artifact-manifest.json

@@ -0,0 +1,9 @@
+{
+  "report": {
+    "path": "{state_dir}/report.md",
+    "kind": "markdown",
+    "media_type": "text/markdown",
+    "required": true
+  },
+  "journal": "{state_dir}/journal.jsonl"
+}

package/dist/fixtures/protocol/mailbox-contract.json

@@ -0,0 +1,15 @@
+{
+  "accepts": [
+    "task.assign",
+    {
+      "type": "control.stop",
+      "description": "Request graceful worker shutdown"
+    }
+  ],
+  "emits": [
+    "task.claim",
+    "task.result",
+    "awaiting_assignment",
+    "actor.leave"
+  ]
+}

package/dist/fixtures/protocol/recipe-summary.json

@@ -0,0 +1,16 @@
+{
+  "id": "actor-worker",
+  "path": "recipes/actor-worker.json",
+  "location": "packaged",
+  "active": true,
+  "args": [
+    "run",
+    "branch",
+    "poll_ms",
+    "state_dir"
+  ],
+  "mailbox": {
+    "kind": "branch",
+    "accepts": ["task.assign", "control.stop"]
+  }
+}

package/dist/fixtures/protocol/room-message.json

@@ -0,0 +1,11 @@
+{
+  "to": "room:demo",
+  "from": "branch:demo/worker",
+  "type": "task.result",
+  "summary": "Worker completed task",
+  "body": {
+    "id": "inbox-001",
+    "result": "ok"
+  },
+  "received_at": "2026-05-26T00:00:00.000Z"
+}

package/dist/fixtures/protocol/room-roster.json

@@ -0,0 +1,11 @@
+{
+  "room": "main",
+  "members": {
+    "branch:demo/worker": {
+      "display": "worker",
+      "role": "worker",
+      "status": "present",
+      "last_seen": "2026-05-26T00:00:00.000Z"
+    }
+  }
+}

package/dist/fixtures/protocol/run-inbox-message.json

@@ -0,0 +1,9 @@
+{
+  "id": "inbox-001",
+  "status": "queued",
+  "queued_at": "2026-05-26T00:00:00.000Z",
+  "to": "run:demo",
+  "from": "coordinator",
+  "type": "control.continue",
+  "body": "continue"
+}

package/dist/fixtures/protocol/run-outbox-event.json

@@ -0,0 +1,9 @@
+{
+  "id": "event-001",
+  "type": "task.result",
+  "summary": "Worker completed task",
+  "body": {
+    "result": "ok"
+  },
+  "created_at": "2026-05-26T00:00:00.000Z"
+}

package/dist/fixtures/protocol/run-state.json

@@ -0,0 +1,10 @@
+{
+  "run": "demo",
+  "state_dir": "{state_dir}",
+  "status": "running",
+  "template": "echo demo",
+  "values": {
+    "run_id": "demo",
+    "state_dir": "{state_dir}"
+  }
+}

package/dist/index.js

@@ -39,6 +39,7 @@ export default function toolRegistryExtension(pi) {
     const runDirWatchers = new Map();
     const observedRuns = new Map();
     const observedRunEventLines = new Map();
+    const observedRunOutboxEventIds = new Map();
     const retirementAttempts = new Set();
     let runStatusFrame = 0;
     let communicationWidgetVisible = false;
@@ -102,7 +103,7 @@ export default function toolRegistryExtension(pi) {
             }
             : undefined, { placement: "belowEditor" });
         const transitions = Observability.detectRunTransitions(observedRuns, summary);
-        const outboxEvents = Observability.detectRunOutboxEvents(observedRunEventLines, summary);
+        const outboxEvents = Observability.detectRunOutboxEvents(observedRunEventLines, summary, observedRunOutboxEventIds);
         if (!notify)
             return;
         retireCandidateRuns(ctx, summary);
@@ -121,7 +122,7 @@ export default function toolRegistryExtension(pi) {
                 details: transition,
             }, { deliverAs: "followUp", triggerTurn: true });
         }
-        Observability.pruneRunObservationState(observedRuns, observedRunEventLines, summary, transitions.map((transition) => transition.stateDir ?? transition.run));
+        Observability.pruneRunObservationState(observedRuns, observedRunEventLines, summary, transitions.map((transition) => transition.stateDir ?? transition.run), observedRunOutboxEventIds);
         for (const event of outboxEvents) {
             if (!Observability.shouldNotifyRunOutboxEvent(event))
                 continue;

package/dist/lib/actor-inspector-tui.js

@@ -7,31 +7,14 @@ import * as path from "node:path";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import * as Limits from "./limits.js";
 import * as Paths from "./paths.js";
+import { readJsonFileResilient, readJsonlFileResilient } from "./state-readers.js";
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
         : {};
 }
 function readJsonLines(file) {
-    try {
-        return fs
-            .readFileSync(file, "utf8")
-            .split("\n")
-            .filter(Boolean)
-            .flatMap((line) => {
-            try {
-                return [JSON.parse(line)];
-            }
-            catch {
-                return [];
-            }
-        });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        return [];
-    }
+    return readJsonlFileResilient(file).records;
 }
 function previewValue(value, maxLength = Limits.INSPECTOR_BODY_PREVIEW_CHARS) {
     if (value === undefined)
@@ -85,12 +68,7 @@ function previewFromMessage(run, message, timestamp, displayNames = {}) {
     };
 }
 function readRoomRosterRecords(stateDir, room) {
-    try {
-        return JSON.parse(fs.readFileSync(path.join(stateDir, "rooms", room, "roster.json"), "utf8"));
-    }
-    catch {
-        return {};
-    }
+    return readJsonFileResilient(path.join(stateDir, "rooms", room, "roster.json"), {}).value;
 }
 function memberDisplay(_address, member) {
     const display = typeof member.display === "string" ? member.display.trim() : "";
@@ -170,13 +148,8 @@ function readOutboxPreviews(run, stateDir) {
         .filter((preview) => Boolean(preview));
 }
 function getRunOwnerId(stateDir) {
-    try {
-        const meta = JSON.parse(fs.readFileSync(path.join(stateDir, "run.json"), "utf8"));
-        return typeof meta.ownerId === "string" ? meta.ownerId : undefined;
-    }
-    catch {
-        return undefined;
-    }
+    const meta = readJsonFileResilient(path.join(stateDir, "run.json"), undefined).value;
+    return typeof meta?.ownerId === "string" ? meta.ownerId : undefined;
 }
 function matchesOwner(stateDir, ownerId) {
     return ownerId === undefined || getRunOwnerId(stateDir) === ownerId;

package/dist/lib/actor-rooms.d.ts

@@ -44,6 +44,8 @@ export interface RoomStatus {
     message_count: number;
     roster_count: number;
     compaction?: RoomCompactionInfo;
+    diagnostics?: string[];
+    diagnostics_count?: number;
     last_message_at?: string;
     last_message_from?: string;
     last_message_summary?: string;
@@ -71,6 +73,11 @@ export interface ActorCommunicationSnapshot {
 }
 export declare function readRoomRoster(stateDir: string, room: string): Record<string, RoomMember>;
 export interface BranchInboxRecord extends ActorMessage {
+    claimed_at?: string;
+    claimed_by?: string;
+    error?: string;
+    failed_at?: string;
+    handled_at?: string;
     id?: string;
     queued_at?: string;
     status?: string;
@@ -83,6 +90,7 @@ export declare function readBranchInboxMessages(stateDir: string, run: string, a
 export declare function readBranchInboxDiagnostics(stateDir: string, run: string, address: string, limit?: number): BranchInboxReadResult;
 export declare function getBranchInboxTerminalRetainLimit(): number;
 export declare function appendBranchInboxMessage(stateDir: string, run: string, address: string, message: ActorMessage): void;
+export declare function claimBranchInboxMessage(stateDir: string, run: string, address: string, owner?: string, statuses?: string[]): BranchInboxRecord | undefined;
 export declare function updateBranchInboxMessageStatus(stateDir: string, run: string, address: string, id: string, status: "claimed" | "handled" | "failed", metadata?: Record<string, unknown>): boolean;
 export declare function appendRoomMessage(stateDir: string, room: string, message: ActorMessage): RoomAppendResult;
 export declare function readRoomMessages(stateDir: string, room: string, limit?: number): RoomTimelineEntry[];

package/dist/lib/actor-rooms.js

@@ -8,6 +8,7 @@ import { randomUUID } from "node:crypto";
 import * as path from "node:path";
 import * as Limits from "./limits.js";
 import { notifyRuntimeWake } from "./runtime-notifier.js";
+import { formatStateReadDiagnostics, readJsonFileResilient, readJsonlFileResilient, } from "./state-readers.js";
 const STATE_LOCK_MAX_AGE_MS = 5 * 60 * 1000;
 const STATE_LOCK_TIMEOUT_MS = 5000;
 const DEFAULT_ROOM_MAX_MESSAGES = 10000;
@@ -87,14 +88,7 @@ function runFromRoomAddress(address) {
     return match?.[1];
 }
 function readJsonFile(file, fallback) {
-    try {
-        return JSON.parse(fs.readFileSync(file, "utf8"));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return fallback;
-        throw error;
-    }
+    return readJsonFileResilient(file, fallback).value;
 }
 function writeJsonFile(file, value) {
     fs.mkdirSync(path.dirname(file), { recursive: true });
@@ -394,6 +388,43 @@ export function appendBranchInboxMessage(stateDir, run, address, message) {
         releaseLock();
     }
 }
+export function claimBranchInboxMessage(stateDir, run, address, owner = "runtime", statuses = ["queued"]) {
+    const branch = branchIdFromAddress(address, run);
+    if (!branch)
+        throw new Error(`Expected branch:${run}/<branch>; got ${address}`);
+    const releaseLock = acquireBranchInboxLock(stateDir, branch);
+    try {
+        const file = branchInboxFile(stateDir, branch);
+        const records = readAllBranchInboxLines(stateDir, run, address);
+        let claimed;
+        const now = new Date().toISOString();
+        const updated = records.map((record) => {
+            if (claimed || !("message" in record))
+                return record;
+            const status = record.message.status ?? "queued";
+            if (!statuses.includes(status))
+                return record;
+            claimed = {
+                ...record.message,
+                claimed_at: now,
+                claimed_by: owner,
+                status: "claimed",
+            };
+            return { message: claimed };
+        });
+        if (!claimed)
+            return undefined;
+        fs.writeFileSync(file, `${updated.map((record) => ("raw" in record ? record.raw : JSON.stringify(record.message))).join("\n")}\n`);
+        notifyActorWake(stateDir, address, "branch.inbox.claim", {
+            id: claimed.id,
+            owner,
+        });
+        return claimed;
+    }
+    finally {
+        releaseLock();
+    }
+}
 export function updateBranchInboxMessageStatus(stateDir, run, address, id, status, metadata = {}) {
     const branch = branchIdFromAddress(address, run);
     if (!branch)
@@ -469,7 +500,14 @@ export function appendRoomMessage(stateDir, room, message) {
 export function readRoomMessages(stateDir, room, limit = 40) {
     try {
         const lines = readJsonlTailLines(messagesFile(stateDir, room), limit);
-        return lines.map((line) => JSON.parse(line));
+        return lines.flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        });
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -503,7 +541,14 @@ export function readRoomMessagePreviews(stateDir, room, limit = 40) {
 export function getRoomStatus(stateDir, room) {
     const messageCount = readRoomMessageCount(stateDir, room);
     const [last] = readRoomMessages(stateDir, room, 1);
-    const compaction = readJsonFile(path.join(roomDir(stateDir, room), "compaction.json"), undefined);
+    const compactionRead = readJsonFileResilient(path.join(roomDir(stateDir, room), "compaction.json"), undefined);
+    const rosterRead = readJsonFileResilient(rosterFile(stateDir, room), {});
+    const messageRead = readJsonlFileResilient(messagesFile(stateDir, room));
+    const diagnostics = [
+        ...messageRead.diagnostics,
+        ...rosterRead.diagnostics,
+        ...compactionRead.diagnostics,
+    ];
     return {
         ...(last
             ? {
@@ -513,10 +558,16 @@ export function getRoomStatus(stateDir, room) {
                 last_message_type: last.type,
             }
             : {}),
-        ...(compaction ? { compaction } : {}),
+        ...(compactionRead.value ? { compaction: compactionRead.value } : {}),
+        ...(diagnostics.length
+            ? {
+                diagnostics: formatStateReadDiagnostics(diagnostics),
+                diagnostics_count: diagnostics.length,
+            }
+            : {}),
         message_count: messageCount,
         room,
-        roster_count: Object.keys(readRoomRoster(stateDir, room)).length,
+        roster_count: Object.keys(rosterRead.value).length,
     };
 }
 export function ensureRoomMember(stateDir, run, room, address, body, summary) {
@@ -541,14 +592,7 @@ export function ensureDefaultRoom(stateDir, run) {
     return ensureRoomMember(stateDir, run, "main", `run:${run}`, { role: "run", status: "present" }, "Run joined default room");
 }
 export function readCommunicationSnapshot(stateDir) {
-    try {
-        return JSON.parse(fs.readFileSync(snapshotFile(stateDir), "utf8"));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
-    }
+    return readJsonFileResilient(snapshotFile(stateDir), undefined).value;
 }
 export function readRoomContacts(stateDir, room, self) {
     return Object.values(readRoomRoster(stateDir, room))

package/dist/lib/actor-worker.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Canonical mailbox-backed actor worker entrypoint logic.
+ * Zones: worker demo, mailbox loop recipe runtime
+ */
+interface ActorWorkerArgs {
+    branch?: string;
+    poll_ms?: string | number;
+    run?: string;
+    state_dir?: string;
+}
+export declare function parseActorWorkerArgs(argv: string[]): ActorWorkerArgs;
+export declare function runActorWorker(argv?: string[]): Promise<void>;
+export {};

package/dist/lib/actor-worker.js

@@ -0,0 +1,86 @@
+/**
+ * Canonical mailbox-backed actor worker entrypoint logic.
+ * Zones: worker demo, mailbox loop recipe runtime
+ */
+import { appendFileSync } from "node:fs";
+import { join } from "node:path";
+import { appendRoomMessage, ensureRoomMember } from "./actor-rooms.js";
+import { handleMailboxLoopOnce, isMailboxLoopStopMessage } from "./mailbox-loop.js";
+export function parseActorWorkerArgs(argv) {
+    const args = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token.startsWith("--"))
+            continue;
+        const key = token.slice(2).replaceAll("-", "_");
+        const next = argv[index + 1];
+        if (!next || next.startsWith("--")) {
+            args[key] = true;
+            continue;
+        }
+        args[key] = next;
+        index += 1;
+    }
+    return args;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function text(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+export async function runActorWorker(argv = process.argv.slice(2)) {
+    const args = parseActorWorkerArgs(argv);
+    const stateDir = String(args.state_dir ?? "");
+    const run = String(args.run ?? "");
+    const branch = String(args.branch ?? "worker");
+    const pollMs = Math.max(50, Number(args.poll_ms ?? 1000));
+    if (!stateDir || !run) {
+        throw new Error("usage: actor-worker.mjs --state-dir <dir> --run <id> [--branch worker] [--poll-ms 1000]");
+    }
+    const branchAddress = `branch:${run}/${branch}`;
+    const roomAddress = `room:${run}`;
+    const journalPath = join(stateDir, "worker-events.jsonl");
+    function journal(event, data = {}) {
+        appendFileSync(journalPath, `${JSON.stringify({ event, ts: new Date().toISOString(), ...data })}\n`);
+    }
+    function room(type, summary, body = {}) {
+        appendRoomMessage(stateDir, "main", {
+            body,
+            from: branchAddress,
+            summary,
+            to: roomAddress,
+            type,
+        });
+    }
+    ensureRoomMember(stateDir, run, "main", branchAddress, { display: branch, role: "worker", status: "present" }, `${branch} joined as mailbox worker`);
+    room("awaiting_assignment", `${branch} awaiting assignment`, { branch });
+    journal("worker.started", { branch, run });
+    let stopping = false;
+    while (!stopping) {
+        const result = await handleMailboxLoopOnce({ address: branchAddress, kind: "branch", run, stateDir }, (message) => {
+            if (isMailboxLoopStopMessage(message)) {
+                stopping = true;
+                room("actor.leave", `${branch} stopping`, { branch, reason: message.type });
+                journal("worker.stopping", { id: message.id, type: message.type });
+                return;
+            }
+            room("task.claim", `${branch} claimed ${message.type}`, {
+                branch,
+                id: message.id,
+                type: message.type,
+            });
+            room("task.result", `${branch} handled ${message.type}`, {
+                branch,
+                id: message.id,
+                result: text(message.body),
+                type: message.type,
+            });
+            room("awaiting_assignment", `${branch} awaiting assignment`, { branch });
+            journal("task.handled", { id: message.id, type: message.type });
+        }, { owner: branchAddress });
+        if (!result.handled)
+            await sleep(pollMs);
+    }
+    journal("worker.done", { branch, run });
+}

package/dist/lib/async-runner.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Detached async-runner entrypoint logic.
+ * Zones: async run process, command-template execution telemetry
+ */
+export declare function runAsyncRunner(stateDir?: string): Promise<void>;