@fitchmultz/pi-subagents 0.52.20 → 0.52.22

package/CHANGELOG.md

@@ -2,9 +2,55 @@
 
 ## [Unreleased]
 
+## 0.52.22 - 2026-11-07
+
+<!-- npm-release:unreleased:start -->
+
+- Bind each durable wake reservation to one POST and its required settlement, preserving retryable settlement failures and crash uncertainty.
+
+<!-- npm-release:unreleased:end -->
+
+- refactor: bind wake reservations to one settled attempt (#366) ([9bd60f9](https://github.com/fitchmultz/pi-subagents/commit/9bd60f92a4630ca9300ed9c4c06bc48758077a40))
+
+### What's Changed
+
+- refactor: bind wake reservations to one settled attempt by @fitchmultz in https://github.com/fitchmultz/pi-subagents/pull/366
+
+**Full Changelog**: https://github.com/fitchmultz/pi-subagents/compare/v0.52.21...v0.52.22
+
+## 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))
@@ -26,10 +72,8 @@
 - Bind parent attachment to explicit detached, waiting, attaching and attached phases; managed readiness attaches only its own still-current waiting binding and shutdown joins admitted publication before releasing the matching generation.
 - Add optional `delegate.thinking` to select child effort independently of the parent on all supported hosts, including official Pi 1.5.0. Omission keeps inherited effort. Native model suffixes must agree with an explicit field. Pi still clamps effort to model capabilities; guidance and saved continuations retain the child's saved effort.
 - Represent child accounting as unrecorded, verified, pending or unavailable while keeping execution status and saved result formats unchanged.
-- Give bridge wake and presence schedulers explicit timer, running, and stopped ownership while retaining durable wake policy.
 - Make directory-watch availability and the coalesced wake's single-owner contract explicit without changing polling fallback.
 - Preserve stranded last-good builds until a complete replacement publishes, and report retained recovery paths when a later build fails.
-- Centralize broker request settlement and close multipart snapshot readers after completion or failure.
 - Give prepared topic transactions action-specific payloads while preserving validate-before-commit and stale-restore normalization.
 
 <!-- npm-release:unreleased:end -->

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);