@fitchmultz/pi-subagents 0.52.19 → 0.52.21

package/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 ## [Unreleased]
 
+## 0.52.21 - 2026-11-07
+
+<!-- npm-release:unreleased:start -->
+
+- Join broker socket acquisition during disconnect, share repeated close work, and make registration and parking acknowledgement ownership explicit.
+- Make socket framing failures terminal and represent JSONL record parsing as blank, reading, or invalid without changing publication policies.
+- Represent actor work as idle or running with its exact launch and task; validate command payloads by action.
+- Name absent, launcher-only, live, exited, and uncertain actor claims while keeping shell evidence and signal-time birth checks separate.
+- Give broker-staged replacement messages one timer owner and name recipient-side supersession before native handoff.
+- Share explicit completion-delivery decisions between canonical and legacy results while keeping native file and memory receipts distinct.
+
+<!-- npm-release:unreleased:end -->
+
+- refactor: give staged replacement delivery one owner (#358) ([f292627](https://github.com/fitchmultz/pi-subagents/commit/f292627a357a5eb99cc9ad2e7a1e9b9622eaa082))
+
+### What's Changed
+
+- refactor: give staged replacement delivery one owner by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/358
+- refactor: make actor work and command payload states explicit by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/345
+- refactor: share completion delivery decisions by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/357
+- refactor: make framing and JSONL record states explicit by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/359
+- refactor: share process claim inspection by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/364
+- refactor: own socket acquisition through joined disconnect by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/362
+
+**Full Changelog**: https://github.com/fitchmultz/pi-subagents/compare/v0.52.20...v0.52.21
+
+## 0.52.20 - 2026-11-07
+
+<!-- npm-release:unreleased:start -->
+
+- Give bridge wake and presence schedulers explicit timer, running, and stopped ownership while retaining durable wake policy.
+- Centralize broker request settlement and close multipart snapshot readers after completion or failure.
+
+<!-- npm-release:unreleased:end -->
+
+- refactor: centralize request settlement and snapshot phases (#354) ([335c7e2](https://github.com/fitchmultz/pi-subagents/commit/335c7e269936467672f7e8d70cc67bf875a0a1c6))
+
+### What's Changed
+
+- refactor: centralize broker request settlement by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/354
+- refactor: make bridge scheduler ownership explicit by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/355
+
+**Full Changelog**: https://github.com/fitchmultz/pi-subagents/compare/v0.52.19...v0.52.20
+
 ## 0.52.19 - 2026-11-07
 
 <!-- npm-release:unreleased:start -->

package/dist/agent/contracts.js

@@ -80,14 +80,23 @@ export const resultSchema = Type.Object({
         baseline: Type.Array(Type.String()),
     })),
 });
-export const commandSchema = Type.Object({
+export const commandMetadataSchema = Type.Object({
     id: Type.String(),
     runId: Type.String(),
     action: Type.Union([Type.Literal("run"), Type.Literal("steer"), Type.Literal("stop")]),
-    prompt: Type.Optional(Type.String()),
-    actorToken: Type.Optional(Type.String()),
     createdAt: Type.Number(),
 });
+const commandFields = Type.Omit(commandMetadataSchema, ["action"]).properties;
+export const commandSchema = Type.Union([
+    Type.Object({ ...commandFields, action: Type.Literal("run") }),
+    Type.Object({ ...commandFields, action: Type.Literal("steer"), prompt: Type.String() }),
+    Type.Object({
+        ...commandFields,
+        action: Type.Literal("stop"),
+        // Historical unbound Stops parse but cannot target any current actor.
+        actorToken: Type.Optional(Type.String()),
+    }),
+]);
 export const successorSchema = Type.Object({ id: Type.String() });
 /** Authority to restore exact working state, valid only after the named actor has exited. */
 /** Exact parked authority: one exited generation's state bytes for this session and leaf. */

package/dist/agent/index.js

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
 import * as loadedSDK from "@earendil-works/pi-coding-agent";
-import { actor, alive, ensureActor, ownIdentity, parkFailure, requestStop, signalProcess, } from "./process.js";
+import { inspectActorClaim, possiblyLive, ensureActor, ownIdentity, parkFailure, requestStop, signalProcess, } from "./process.js";
 import { stopChildren } from "./shutdown.js";
 import { isChild, errorText, managedHost, rememberSDK, retainsChildren, } from "./host.js";
 import { serveParked } from "./parking.js";
@@ -261,7 +261,7 @@ class AgentRuntime {
             executionCwd: executionCwd(this.pi, context),
         });
         this.checkMain();
-        enqueue(this.base, launch, "run");
+        enqueue(this.base, launch, { action: "run" });
         await ensureActor(this.base, launch, this.shutdown.signal);
         return renderReceipt(this.base, launch, this.ctx, {
             receipt: "launch",
@@ -286,10 +286,10 @@ class AgentRuntime {
         return;
     }
     async retryContinuation(launch, input) {
-        const identity = actor(this.base, launch);
+        const claim = inspectActorClaim(this.base, launch);
         const command = read(path.join(conversation(this.base, launch), "commands", `${launch.id}.json`), commandSchema);
         if (input.prompt !== launch.prompt ||
-            (identity && alive(identity)) ||
+            possiblyLive(claim) ||
             command?.id !== launch.id ||
             command.runId !== launch.id ||
             command.action !== "run") {
@@ -310,9 +310,9 @@ class AgentRuntime {
         if (completed === "pending") {
             return this.retryContinuation(launch, input);
         }
-        const identity = actor(this.base, launch);
-        if (!completed && identity && alive(identity)) {
-            const command = enqueue(this.base, launch, "steer", { prompt: input.prompt });
+        const claim = completed ? undefined : inspectActorClaim(this.base, launch);
+        if (possiblyLive(claim)) {
+            const command = enqueue(this.base, launch, { action: "steer", prompt: input.prompt });
             return renderReceipt(this.base, launch, this.ctx, {
                 receipt: "guidance",
                 command,
@@ -327,7 +327,7 @@ class AgentRuntime {
             });
         }
         // Retain successor claims on ambiguous after-launch failures: no replay.
-        enqueue(this.base, next, "run");
+        enqueue(this.base, next, { action: "run" });
         await ensureActor(this.base, next, this.shutdown.signal);
         return renderReceipt(this.base, next, this.ctx, { receipt: "continuation" });
     }
@@ -344,7 +344,7 @@ class AgentRuntime {
         });
         if (created) {
             // The durable adoption claim survives ambiguous after-launch failures.
-            enqueue(this.base, launch, "run");
+            enqueue(this.base, launch, { action: "run" });
             await ensureActor(this.base, launch, this.shutdown.signal);
         }
         return renderReceipt(this.base, launch, this.ctx, {

package/dist/agent/legacy.js

@@ -5,7 +5,7 @@ import { journalStamp } from "../shared/native-journal.js";
 import { receiptId } from "./receipts.js";
 import { resolveTempRootDir } from "../shared/types.js";
 import { isRecord } from "../shared/unknown.js";
-import { release, isHeld } from "./notifications.js";
+import { release, completionDelivery } from "./notifications.js";
 import { missing } from "./storage.js";
 // Retain only foreign classifications, never their saved output, for each live native manager.
 const ignoredInputs = new WeakMap();
@@ -102,19 +102,19 @@ function published(ctx, input) {
 }
 function notification(ctx, input) {
     const identity = `legacy:${input.id}:${input.key}`;
-    const where = published(ctx, input);
-    if (where !== undefined) {
+    const state = completionDelivery(input.owner, identity, published(ctx, input));
+    if (state.kind === "published") {
         release(input.owner, identity);
         // Retire only an unchanged recovery input whose receipt is LF-published in the session file.
         // An in-memory receipt stops redelivery but never removes the saved input.
-        if (where === "file" &&
+        if (state.where === "file" &&
             journalStamp(fs.lstatSync(input.file, { bigint: true })) === input.stamp &&
             fs.readFileSync(input.file, "utf8") === input.raw) {
             fs.unlinkSync(input.file);
         }
         return;
     }
-    if (isHeld(input.owner, identity)) {
+    if (state.kind === "held") {
         return;
     }
     return {

package/dist/agent/notifications.js

@@ -25,18 +25,19 @@ function queuedAdmissions() {
 }
 const admissions = queuedAdmissions();
 function hold(owner, id) {
-    const key = `${owner}/${id}`;
-    if (admissions.has(key)) {
-        return false;
-    }
-    admissions.add(key);
-    return true;
+    admissions.add(`${owner}/${id}`);
 }
 export function release(owner, id) {
     admissions.delete(`${owner}/${id}`);
 }
-export function isHeld(owner, id) {
-    return admissions.has(`${owner}/${id}`);
+/** Canonical result readers establish availability before deciding delivery. */
+function deliveryDecision(receipt, held) {
+    return receipt === undefined
+        ? { kind: held ? "held" : "deliverable" }
+        : { kind: "published", where: receipt };
+}
+export function completionDelivery(owner, id, receipt) {
+    return deliveryDecision(receipt, admissions.has(`${owner}/${id}`));
 }
 /** Returns whether any admission was released for reconciliation. */
 export function settle(owner, pending) {
@@ -197,14 +198,20 @@ export function notifications(ctx, base, owner) {
     const awaited = new Set();
     const runs = completed(base, owner, awaited);
     const receipts = runs.length === 0 ? undefined : completionReceipts(ctx.sessionManager, owner);
+    const where = ctx.sessionManager.getSessionFile() === undefined ? "memory" : "file";
     for (const run of runs) {
-        const key = `${owner}/${run.id}`;
-        if (receipts?.get(run.id) !== undefined) {
-            admissions.delete(key);
-            continue;
+        const state = completionDelivery(owner, run.id, receipts?.get(run.id) === undefined ? undefined : where);
+        switch (state.kind) {
+            case "published":
+                release(owner, run.id);
+                continue;
+            case "held":
+                continue;
+            case "deliverable":
+                break;
         }
-        const loaded = admissions.has(key) ? undefined : (run.loaded ?? load(base, run.id, owner));
-        if (loaded?.result !== undefined) {
+        const loaded = run.loaded ?? load(base, run.id, owner);
+        if (loaded.result !== undefined) {
             notices.push(notification(base, loaded.launch, loaded.result));
         }
     }

package/dist/agent/parent-check.js

@@ -0,0 +1,38 @@
+import { attachmentSchema } from "./contracts.js";
+import { observeAlive, published } from "./process.js";
+import { read } from "./storage.js";
+/** A parent liveness verdict acts only while its check and attachment generation are current. */
+export class ParentCheck {
+    current;
+    check(file, detached) {
+        if (this.current !== undefined) {
+            return Promise.resolve();
+        }
+        const attachment = published(file, read(file, attachmentSchema));
+        if (attachment === undefined || !attachment.attached) {
+            detached();
+            return Promise.resolve();
+        }
+        const check = {};
+        this.current = check;
+        const settle = async () => {
+            try {
+                const [live] = await observeAlive([attachment]);
+                if (this.current === check &&
+                    live !== true &&
+                    read(file, attachmentSchema)?.generation === attachment.generation) {
+                    detached();
+                }
+            }
+            finally {
+                if (this.current === check) {
+                    this.current = undefined;
+                }
+            }
+        };
+        return settle();
+    }
+    cancel() {
+        this.current = undefined;
+    }
+}

package/dist/agent/process.js

@@ -7,7 +7,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { isChildProcessReplaced, observeChildProcessReplaced, readChildProcessIdentity, readProcessClock, trySignalChildTree, } from "../shared/post-exit-stdio-guard.js";
 import { agentObservationSocketPath } from "../pi-intercom/broker/paths.js";
 import { hasErrorCode } from "../shared/unknown.js";
-import { attachmentSchema, parkedSchema, processSchema, wakeFailureSchema, } from "./contracts.js";
+import { parkedSchema, processSchema, wakeFailureSchema, } from "./contracts.js";
 import { conversation, enqueue, read, write } from "./storage.js";
 import { errorText } from "./host.js";
 /** Owner records follow their process's birth; stat after read only moves the bound later. */
@@ -27,10 +27,19 @@ function probe(identity) {
     }
     return identity.identity === "unverified" ? true : undefined;
 }
+function presence(identity) {
+    const probed = probe(identity);
+    if (probed !== undefined) {
+        return probed ? "uncertain" : "exited";
+    }
+    if (readChildProcessIdentity(identity.pid) === identity.identity) {
+        return "live";
+    }
+    return replaced(identity) ? "exited" : "uncertain";
+}
 export function alive(identity) {
-    // Only a proven different birth disproves a live PID; ambiguous identities stay possibly owned.
-    return (probe(identity) ??
-        (readChildProcessIdentity(identity.pid) === identity.identity || !replaced(identity)));
+    // Uncertain identity remains possibly owned; only death/replacement authorizes reuse.
+    return presence(identity) !== "exited";
 }
 /** Routine `alive` without waiting on `ps`; signals still use the synchronous proof. */
 export async function observeAlive(identities) {
@@ -42,50 +51,6 @@ export async function observeAlive(identities) {
     }
     return verdicts;
 }
-/**
- * A child's routine parent check, one observation at a time. A dead parent detaches the child
- * only while its check is current and the attachment generation is unchanged: a newer parent
- * may adopt the child meanwhile.
- */
-export class ParentCheck {
-    current;
-    /**
-     * Reads the attachment synchronously, so an unreadable one still fails the caller at once.
-     * Missing or released attachments detach immediately; a check in flight makes this a no-op.
-     */
-    check(file, detached) {
-        if (this.current !== undefined) {
-            return Promise.resolve();
-        }
-        const attachment = published(file, read(file, attachmentSchema));
-        if (attachment === undefined || !attachment.attached) {
-            detached();
-            return Promise.resolve();
-        }
-        const check = {};
-        this.current = check;
-        const settle = async () => {
-            try {
-                const [live] = await observeAlive([attachment]);
-                if (this.current === check &&
-                    live !== true &&
-                    read(file, attachmentSchema)?.generation === attachment.generation) {
-                    detached();
-                }
-            }
-            finally {
-                if (this.current === check) {
-                    this.current = undefined;
-                }
-            }
-        };
-        return settle();
-    }
-    /** A check settling later no longer acts. */
-    cancel() {
-        this.current = undefined;
-    }
-}
 function replaced(identity) {
     return (identity.identity !== "unverified" &&
         isChildProcessReplaced(identity.pid, identity.identity, identity.published, identity.clock));
@@ -103,6 +68,33 @@ export function actor(base, launch) {
     const file = path.join(conversation(base, launch), "actor.lock", "process.json");
     return published(file, read(file, processSchema));
 }
+export function possiblyLive(claim) {
+    return (claim?.kind === "actor-live" || (claim?.kind === "uncertain" && claim.process !== undefined));
+}
+/** Launcher claims do not prove actor identity; shell ownership is checked separately. */
+export function inspectActorClaim(base, launch) {
+    const process = actor(base, launch);
+    if (process !== undefined) {
+        switch (presence(process)) {
+            case "live":
+                return { kind: "actor-live", process };
+            case "exited":
+                return { kind: "actor-exited", process };
+            case "uncertain":
+                return { kind: "uncertain", process };
+        }
+    }
+    const lock = path.join(conversation(base, launch), "actor.lock");
+    if (!fs.existsSync(lock)) {
+        return { kind: "absent", process: undefined };
+    }
+    return {
+        kind: read(path.join(lock, "claim.json"), processSchema) === undefined
+            ? "uncertain"
+            : "launcher-only",
+        process: undefined,
+    };
+}
 function childEnvironment(launch) {
     const env = { ...process.env };
     for (const key of Object.keys(env)) {
@@ -248,8 +240,9 @@ export async function ensureActor(base, launch, signal) {
     await awaitStopping(dir, actor(base, launch), signal);
     signal?.throwIfAborted();
     // Another parallel tool may replace the claim while this invocation yields.
-    const existing = actor(base, launch);
-    if (existing && alive(existing)) {
+    const claim = inspectActorClaim(base, launch);
+    const existing = claim.process;
+    if (possiblyLive(claim)) {
         return;
     }
     parkFailure(base, launch, existing);
@@ -372,12 +365,12 @@ export function requestStop(base, launch, onError) {
             return false;
         }
     };
-    const identity = actor(base, launch);
+    const identity = inspectActorClaim(base, launch).process;
     const targets = identity ? [identity, ...shells(base, launch, identity.token)] : [];
     // Interactive Stop validates the whole set; shutdown reports and skips only ambiguous targets.
     const live = targets.filter((target) => attempt(() => verifyProcess(target)));
     const command = identity && live.includes(identity)
-        ? enqueue(base, launch, "stop", { actorToken: identity.token })
+        ? enqueue(base, launch, { action: "stop", actorToken: identity.token })
         : undefined;
     if (identity && live.length > 0) {
         write(path.join(conversation(base, launch), `stopping-${identity.token}.json`), {

package/dist/agent/runner.js

@@ -1,8 +1,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { commandSchema, parkedSchema, } from "./contracts.js";
-import { launchAt, missing, read, runDirectory, write } from "./storage.js";
-import { ownIdentity, ParentCheck, shells, signalProcess } from "./process.js";
+import { commandIdentity, launchAt, read, runDirectory, write } from "./storage.js";
+import { ownIdentity, shells, signalProcess } from "./process.js";
+import { ParentCheck } from "./parent-check.js";
 import { errorText, loadSDK } from "./host.js";
 import { Parking } from "./parking.js";
 import { accountingFields, UsageIndex } from "./usage.js";
@@ -10,18 +11,6 @@ import { initializeCwd } from "./cwd.js";
 import { childRuntime } from "./child-runtime.js";
 import { ActorObservation } from "./observation.js";
 import { DirectoryWatch, Wake } from "./wake.js";
-function commandIdentity(file) {
-    try {
-        const stat = fs.statSync(file, { bigint: true });
-        return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
-    }
-    catch (error) {
-        if (missing(error)) {
-            return;
-        }
-        throw error;
-    }
-}
 function completionStatus(stopping, message, error) {
     if (stopping || message?.stopReason === "aborted") {
         return "stopped";
@@ -36,7 +25,9 @@ const failureReason = (error, message) => error ??
     message?.errorMessage ??
     (message ? undefined : "Native run produced no terminal assistant message.");
 class Actor {
-    active;
+    work = {
+        kind: "idle",
+    };
     stopping = false;
     stopDeadline;
     nextParentCheck = 0;
@@ -46,7 +37,6 @@ class Actor {
     wake = new Wake();
     // A deferred run waits for an idle session, which has no command-file event.
     retry = false;
-    current;
     errors = [];
     started = new Set();
     // Actor-local validation metadata only; never retain command prompts or receipt authority.
@@ -130,7 +120,10 @@ class Actor {
         this.stopping = true;
         this.wake.raise();
         write(path.join(this.dir, `stopping-${this.token}.json`), { at: Date.now() });
-        write(path.join(this.dir, "stop-acknowledged.json"), { at: Date.now(), id: this.current?.id });
+        write(path.join(this.dir, "stop-acknowledged.json"), {
+            at: Date.now(),
+            id: this.work.kind === "running" ? this.work.launch.id : undefined,
+        });
         this.session?.abort().catch((error) => {
             this.errors.push(errorText(error));
         });
@@ -162,29 +155,29 @@ class Actor {
         if (!session) {
             throw new Error("Native child session is not ready.");
         }
-        this.current = launch;
         const baseline = new Set(session.sessionManager.getEntries().map((entry) => entry.id));
+        const task = Promise.resolve().then(() => this.executeRun(launch, session, baseline));
+        this.work = { kind: "running", launch, task };
         this.observation?.working(true);
-        this.active = (async () => {
-            try {
-                if (launch.provider !== this.initial.provider ||
-                    launch.model !== this.initial.model ||
-                    launch.thinking !== this.initial.thinking) {
-                    throw new Error("Continuation model snapshot changed unexpectedly.");
-                }
-                await session.prompt(launch.prompt, { expandPromptTemplates: false });
-                await session.waitForIdle();
-                this.saveResult(launch, baseline);
-            }
-            catch (error) {
-                this.saveResult(launch, baseline, errorText(error));
-            }
-            finally {
-                this.active = undefined;
-                this.current = undefined;
-                this.observation?.working(false);
+    }
+    async executeRun(launch, session, baseline) {
+        try {
+            if (launch.provider !== this.initial.provider ||
+                launch.model !== this.initial.model ||
+                launch.thinking !== this.initial.thinking) {
+                throw new Error("Continuation model snapshot changed unexpectedly.");
             }
-        })();
+            await session.prompt(launch.prompt, { expandPromptTemplates: false });
+            await session.waitForIdle();
+            this.saveResult(launch, baseline);
+        }
+        catch (error) {
+            this.saveResult(launch, baseline, errorText(error));
+        }
+        finally {
+            this.work = { kind: "idle" };
+            this.observation?.working(false);
+        }
     }
     commandLaunch(command) {
         const receipt = path.join(this.dir, "admissions", `${command.id}.json`);
@@ -213,7 +206,7 @@ class Actor {
             return;
         }
         if (command.action === "run" &&
-            (this.stopping || this.active !== undefined || !session.isIdle)) {
+            (this.stopping || this.work.kind === "running" || !session.isIdle)) {
             this.retry = true;
             return;
         }
@@ -233,31 +226,31 @@ class Actor {
         this.applyCommand(command, launch, session);
     }
     staleCommand(command, launch, session) {
-        // Unbound legacy Stops cannot safely target this generation either.
-        if (command.action === "stop") {
-            return command.actorToken !== this.token;
+        switch (command.action) {
+            case "stop":
+                return command.actorToken !== this.token;
+            case "steer":
+                return this.work.kind !== "running" || session.isIdle || this.work.launch.id !== launch.id;
+            case "run":
+                return false;
         }
-        return (command.action === "steer" &&
-            (this.active === undefined || session.isIdle || this.current?.id !== launch.id));
     }
     applyCommand(command, launch, session) {
-        if (command.action === "stop") {
-            this.stop();
-            return;
-        }
-        if (command.action === "run") {
-            this.run(launch);
-            return;
+        switch (command.action) {
+            case "stop":
+                this.stop();
+                return;
+            case "run":
+                this.run(launch);
+                return;
+            case "steer":
+                // Synchronous native queue admission cannot turn into an idle prompt after an await.
+                session.agent.steer({
+                    role: "user",
+                    content: [{ type: "text", text: command.prompt }],
+                    timestamp: Date.now(),
+                });
         }
-        if (command.prompt === undefined) {
-            throw new Error("Missing guidance.");
-        }
-        // Synchronous native queue admission cannot turn into an idle prompt after an await.
-        session.agent.steer({
-            role: "user",
-            content: [{ type: "text", text: command.prompt }],
-            timestamp: Date.now(),
-        });
     }
     pendingCommand(file) {
         const identity = commandIdentity(file);
@@ -297,7 +290,7 @@ class Actor {
                 this.errors.push(errorText(error));
             });
         }
-        return this.stopping && this.active === undefined && (this.session?.isIdle ?? true);
+        return this.stopping && this.work.kind === "idle" && (this.session?.isIdle ?? true);
     }
     /** Durable command readiness, not elapsed time, defines admission. */
     async admitCommands(runtime, parked) {
@@ -338,14 +331,14 @@ class Actor {
             this.parking = await parked.park(runtime, {
                 signal: owner.signal,
                 pi: this.context?.pi,
-                busy: this.stopping || this.active !== undefined || this.observation?.watched === true,
+                busy: this.stopping || this.work.kind === "running" || this.observation?.watched === true,
                 // Raced commands and viewers keep this actor resident; the loop admits after release.
                 quiet: () => {
                     const queued = this.pending().some((command) => this.commandLaunch(command));
                     if (queued) {
                         this.wake.raise();
                     }
-                    const idle = this.active === undefined && !this.stopping;
+                    const idle = this.work.kind === "idle" && !this.stopping;
                     return !queued && idle && this.observation?.watched !== true;
                 },
                 errors: this.errors,
@@ -357,7 +350,7 @@ class Actor {
         return this.parking !== "resident";
     }
     failure(error, unopened) {
-        const launch = this.current ?? this.initial;
+        const launch = this.work.kind === "running" ? this.work.launch : this.initial;
         const result = {
             id: launch.id,
             owner: launch.owner,
@@ -454,7 +447,9 @@ class Actor {
             process.on("SIGTERM", this.stop);
             process.on("SIGINT", this.stop);
             await this.admitCommands(runtime, parked);
-            await this.active;
+            if (this.work.kind === "running") {
+                await this.work.task;
+            }
         }
         catch (error) {
             this.failure(error, parked?.opened === true ? undefined : parkedToken);

package/dist/agent/storage.js

@@ -118,13 +118,25 @@ export function latest(base, initial) {
 export function conversation(base, launch) {
     return runDirectory(base, launch.rootId);
 }
-export function enqueue(base, launch, action, options = {}) {
-    const id = action === "run" ? launch.id : randomUUID();
+/** Metadata only: replacing command bytes invalidates the actor's parsed-command cache. */
+export function commandIdentity(file) {
+    try {
+        const stat = fs.statSync(file, { bigint: true });
+        return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+    }
+    catch (error) {
+        if (missing(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+export function enqueue(base, launch, input) {
+    const id = input.action === "run" ? launch.id : randomUUID();
     const command = {
         id,
         runId: launch.id,
-        action,
-        ...options,
+        ...input,
         createdAt: Date.now(),
     };
     write(path.join(conversation(base, launch), "commands", `${id}.json`), command, true);