@fitchmultz/pi-subagents 0.51.0 → 0.52.1

package/src/agent/process.ts

@@ -13,7 +13,13 @@ import {
 } from "../shared/post-exit-stdio-guard.ts";
 import { agentObservationSocketPath } from "../pi-intercom/broker/paths.ts";
 import { hasErrorCode } from "../shared/unknown.ts";
-import { attachmentSchema, processSchema, type Launch, type ProcessIdentity } from "./contracts.ts";
+import {
+  attachmentSchema,
+  parkedSchema,
+  processSchema,
+  type Launch,
+  type ProcessIdentity,
+} from "./contracts.ts";
 import { conversation, enqueue, launchAt, list, read, write } from "./storage.ts";
 import { errorText } from "./host.ts";
 
@@ -183,9 +189,12 @@ async function awaitStopping(
   existing: OwnedProcess | undefined,
   signal?: AbortSignal,
 ): Promise<void> {
-  if (existing && fs.existsSync(path.join(dir, `stopping-${existing.token}.json`))) {
-    const deadline = Date.now() + 5000;
-    while (alive(existing)) {
+  if (existing) {
+    const stopping = path.join(dir, `stopping-${existing.token}.json`);
+    // Parking ends in exit or a removed marker, after native shutdown persistence.
+    const parking = path.join(dir, "actor.lock", "parking.json");
+    const deadline = Date.now() + (fs.existsSync(stopping) ? 5000 : 30_000);
+    while ((fs.existsSync(stopping) || fs.existsSync(parking)) && alive(existing)) {
       signal?.throwIfAborted();
       if (Date.now() > deadline) {
         throw new Error("Previous actor is still stopping; no replacement was launched.");
@@ -210,6 +219,7 @@ export async function ensureActor(
   if (existing && alive(existing)) {
     return;
   }
+  parkFailure(base, launch, existing);
   if (existing) {
     if (shells(base, launch, existing.token).some(alive)) {
       throw new Error("Owned native shell work remains live; stop it before continuing.");
@@ -231,6 +241,33 @@ export async function ensureActor(
   write(path.join(lock, "claim.json"), { ...ownIdentity(), token });
   spawnActor(base, launch, token);
 }
+/** A failed park keeps its input queued; exact state is lost, so nothing restarts it implicitly. */
+export function parkFailure(base: string, launch: Launch, exited?: OwnedProcess): void {
+  const dir = conversation(base, launch);
+  const parked = read(path.join(dir, "parked.json"), parkedSchema);
+  if (exited && parked && parked.token !== exited.token) {
+    // Only the exited claim that saved this state may hand it to the next generation.
+    throw new Error(
+      "Parked working state belongs to another actor generation; nothing was reopened.",
+    );
+  }
+  const file = path.join(dir, "park-failed.json");
+  if (fs.existsSync(file)) {
+    throw new Error(
+      `This idle child exited without saving its exact working state (${file}). Nothing was restarted or admitted; messages for it stay queued. Inspect it, then delegate new work.`,
+    );
+  }
+}
+/** A broker wake may only restore exact parked state, never reopen the journal alone. */
+export async function wakeActor(base: string, launch: Launch, signal?: AbortSignal): Promise<void> {
+  const dir = conversation(base, launch);
+  await awaitStopping(dir, actor(base, launch), signal);
+  parkFailure(base, launch);
+  if (!fs.existsSync(path.join(dir, "parked.json"))) {
+    throw new Error("No parked working state; the child was not woken.");
+  }
+  await ensureActor(base, launch, signal);
+}
 /** A crashed generation cannot unlink its endpoint; its exact token names the leftover. */
 function removeObservationEndpoint(token: string): void {
   try {

package/src/agent/runner.ts

@@ -1,20 +1,16 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type {
-  AgentSession,
-  CreateAgentSessionRuntimeFactory,
-  ExtensionAPI,
-  ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
+import type { AgentSession, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { AssistantMessage } from "@earendil-works/pi-ai";
 import { commandSchema, type Command, type Launch, type Result } from "./contracts.ts";
 import { launchAt, missing, read, runDirectory, write } from "./storage.ts";
-import { ownIdentity, ParentCheck, shellCommand, shells, signalProcess } from "./process.ts";
+import { ownIdentity, ParentCheck, shells, signalProcess } from "./process.ts";
 import { errorText, loadSDK } from "./host.ts";
+import { Parking, type Runtime } from "./parking.ts";
 import { childUsage } from "./usage.ts";
-import { initializeCwd, localCwdOwner } from "./cwd.ts";
+import { initializeCwd } from "./cwd.ts";
+import { childRuntime } from "./child-runtime.ts";
 import { ActorObservation, type ObservationStats } from "./observation.ts";
-import type { ToolEvent } from "./observation-state.ts";
 import { DirectoryWatch, Wake } from "./wake.ts";
 
 function commandIdentity(file: string): string | undefined {
@@ -41,30 +37,12 @@ function completionStatus(
   }
   return "completed";
 }
-function guard(pi: ExtensionAPI, directory: string, token: string): void {
-  pi.on("tool_call", (event) => {
-    if (event.toolName === "delegate" || event.toolName === "agent_runs") {
-      return { block: true, reason: "Only a main session may delegate or control children." };
-    }
-    const owner = pi.getAllTools().find((tool) => tool.name === "bash")?.sourceInfo;
-    if (
-      event.toolName === "bash" &&
-      typeof event.input.command === "string" &&
-      owner &&
-      (owner.source === "builtin" || localCwdOwner(owner))
-    ) {
-      // Preserve the selected local owner's cwd/env and leave remote/custom tools alone.
-      const input = event.input;
-      input.command = shellCommand(event.input.command, directory, token);
-    }
-    return;
-  });
-}
 class Actor {
   private active?: Promise<void>;
   private stopping = false;
   private stopDeadline?: NodeJS.Timeout;
   private nextParentCheck = 0;
+  private parking = false;
   private readonly parent = new ParentCheck();
   // Raised when durable commands may need admission: change hints and stop.
   private readonly wake = new Wake();
@@ -151,67 +129,6 @@ class Actor {
         .join("\n") ?? ""
     );
   }
-  private createRuntime(
-    sdk: Awaited<ReturnType<typeof loadSDK>>,
-  ): CreateAgentSessionRuntimeFactory {
-    return async ({ sessionManager }) => {
-      const launch = this.initial;
-      if (!fs.existsSync(launch.sessionFile)) {
-        throw new Error("Missing saved native session; refusing to create another.");
-      }
-      const settingsManager = sdk.SettingsManager.create(launch.cwd, launch.agentDir, {
-        projectTrusted: launch.trusted,
-      });
-      const services = await sdk.createAgentSessionServices({
-        cwd: launch.cwd,
-        agentDir: launch.agentDir,
-        settingsManager,
-        resourceLoaderOptions: {
-          additionalExtensionPaths: [launch.entry],
-          extensionFactories: [
-            {
-              name: "codemode",
-              builtin: true,
-              factory: sdk.createCodemodeExtension({ mode: "on" }),
-            },
-            { name: "tool_search", builtin: true, factory: sdk.createToolSearchExtension() },
-            { name: "mcp", builtin: true, factory: sdk.createMcpExtension() },
-            (pi) => {
-              guard(pi, this.dir, this.token);
-              pi.on("session_start", (_event, ctx) => {
-                this.context = { pi, ctx };
-              });
-              // Sparse tool lifecycle keeps the live view's tools even while nobody watches.
-              const tool = (event: ToolEvent): void => this.observation?.tool(event);
-              pi.on("tool_execution_start", tool);
-              pi.on("tool_execution_update", tool);
-              pi.on("tool_execution_end", tool);
-            },
-          ],
-        },
-      });
-      const diagnostics = services.resourceLoader.getExtensions().errors;
-      if (diagnostics.length > 0) {
-        throw new Error(`Child extension load failed: ${JSON.stringify(diagnostics)}`);
-      }
-      const model = services.modelRuntime.getModel(launch.provider, launch.model);
-      if (!model) {
-        throw new Error(
-          `Saved model ${launch.provider}/${launch.model} is unavailable; no fallback was used.`,
-        );
-      }
-      return {
-        ...(await sdk.createAgentSessionFromServices({
-          services,
-          sessionManager,
-          model,
-          thinkingLevel: launch.thinking,
-        })),
-        services,
-        diagnostics: services.diagnostics,
-      };
-    };
-  }
   private readonly stop = (): void => {
     if (this.stopping) {
       return;
@@ -399,7 +316,7 @@ class Actor {
     return this.stopping && this.active === undefined && (this.session?.isIdle ?? true);
   }
   /** Durable command readiness, not elapsed time, defines admission. */
-  private async admitCommands(): Promise<void> {
+  private async admitCommands(runtime: Runtime, parked: Parking): Promise<void> {
     // Queued commands create this directory; otherwise pending() does and the next pass arms.
     const directory = path.join(this.dir, "commands");
     const commands = new DirectoryWatch(directory, () => true, this.wake.raise);
@@ -411,6 +328,10 @@ class Actor {
           this.retry = false;
           this.pending().forEach((command) => this.accept(command));
         }
+        // oxlint-disable-next-line no-await-in-loop
+        if (await this.park(runtime, parked)) {
+          return;
+        }
         const polling = this.retry || this.stopping || watch === "unwatched";
         const tick = Math.max(1, this.nextParentCheck - performance.now());
         // oxlint-disable-next-line no-await-in-loop
@@ -422,6 +343,35 @@ class Actor {
       commands.close();
     }
   }
+  /** Parks a final-idle actor; the parent/stop owner stays live while preparation awaits. */
+  private async park(runtime: Runtime, parked: Parking): Promise<boolean> {
+    const owner = new AbortController();
+    const watch = setInterval(() => {
+      if (this.shouldExit() || this.stopping) {
+        owner.abort();
+      }
+    }, 100);
+    try {
+      this.parking = await parked.park(runtime, {
+        signal: owner.signal,
+        pi: this.context?.pi,
+        busy: this.stopping || this.active !== undefined || 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;
+          return !queued && idle && this.observation?.watched !== true;
+        },
+        errors: this.errors,
+      });
+    } finally {
+      clearInterval(watch);
+    }
+    return this.parking;
+  }
   private failure(error: unknown): void {
     const launch = this.current ?? this.initial;
     const result: Result = {
@@ -438,71 +388,101 @@ class Actor {
     }
     process.exitCode = 1;
   }
+  private async start(sdk: Awaited<ReturnType<typeof loadSDK>>, parked: Parking): Promise<Runtime> {
+    const sessionManager = parked.open();
+    const factory = childRuntime(sdk, this.initial, {
+      directory: this.dir,
+      token: this.token,
+      saved: parked.saved,
+      started: (pi, ctx) => {
+        this.context = { pi, ctx };
+      },
+      tool: (event) => this.observation?.tool(event),
+    });
+    const runtime = await sdk.createAgentSessionRuntime(factory, {
+      cwd: this.initial.cwd,
+      agentDir: this.initial.agentDir,
+      sessionManager,
+    });
+    try {
+      await this.ready(runtime, parked);
+    } catch (error) {
+      // A runtime that never became ready is still disposed, so the failed actor exits.
+      await runtime.dispose();
+      throw error;
+    }
+    return runtime;
+  }
+  private async ready(runtime: Runtime, parked: Parking): Promise<void> {
+    this.session = runtime.session;
+    await this.session.bindExtensions({
+      mode: "print",
+      onError: (error) => {
+        this.errors.push(error.error);
+      },
+    });
+    if (!this.context) {
+      throw new Error("Child extension context is unavailable.");
+    }
+    initializeCwd(this.context.pi, this.context.ctx, this.initial.cwd, this.dir);
+    if (this.initial.name !== undefined && !parked.saved) {
+      this.session.sessionManager.appendSessionInfo(this.initial.name);
+    }
+    // Optional live view, bound before readiness; its faults never change native execution.
+    this.observation = await ActorObservation.open(this.session, {
+      token: this.token,
+      rootId: this.initial.rootId,
+      sessionId: this.session.sessionManager.getSessionId(),
+    });
+    write(path.join(this.dir, "actor.lock", "process.json"), {
+      ...ownIdentity(),
+      token: this.token,
+    });
+    write(path.join(this.dir, "ready.json"), {
+      pid: process.pid,
+      token: this.token,
+      sessionId: this.session.sessionManager.getSessionId(),
+      at: Date.now(),
+    });
+    parked.adopt();
+  }
   async serve(): Promise<void> {
     const sdk = await loadSDK(this.initial.sdk);
-    let runtime: Awaited<ReturnType<typeof sdk.createAgentSessionRuntime>> | undefined;
+    const parked = new Parking(this.base, this.initial, this.token, sdk);
+    let runtime: Runtime | undefined;
     try {
-      runtime = await sdk.createAgentSessionRuntime(this.createRuntime(sdk), {
-        cwd: this.initial.cwd,
-        agentDir: this.initial.agentDir,
-        sessionManager: sdk.SessionManager.open(
-          this.initial.sessionFile,
-          undefined,
-          this.initial.cwd,
-        ),
-      });
-      this.session = runtime.session;
-      await this.session.bindExtensions({
-        mode: "print",
-        onError: (error) => {
-          this.errors.push(error.error);
-        },
-      });
-      if (!this.context) {
-        throw new Error("Child extension context is unavailable.");
-      }
-      initializeCwd(this.context.pi, this.context.ctx, this.initial.cwd, this.dir);
-      if (this.initial.name !== undefined) {
-        this.session.sessionManager.appendSessionInfo(this.initial.name);
-      }
-      // Optional live view, bound before readiness; its faults never change native execution.
-      this.observation = await ActorObservation.open(this.session, {
-        token: this.token,
-        rootId: this.initial.rootId,
-        sessionId: this.session.sessionManager.getSessionId(),
-      });
-      write(path.join(this.dir, "actor.lock", "process.json"), {
-        ...ownIdentity(),
-        token: this.token,
-      });
-      write(path.join(this.dir, "ready.json"), {
-        pid: process.pid,
-        token: this.token,
-        sessionId: this.session.sessionManager.getSessionId(),
-        at: Date.now(),
-      });
+      runtime = await this.start(sdk, parked);
       process.on("SIGTERM", this.stop);
       process.on("SIGINT", this.stop);
-      await this.admitCommands();
+      await this.admitCommands(runtime, parked);
       await this.active;
     } catch (error) {
       this.failure(error);
     } finally {
-      process.off("SIGTERM", this.stop);
-      process.off("SIGINT", this.stop);
-      const observation: ObservationStats | undefined = this.observation?.close();
+      await this.finish(runtime);
+    }
+  }
+  private async finish(runtime: Runtime | undefined): Promise<void> {
+    process.off("SIGTERM", this.stop);
+    process.off("SIGINT", this.stop);
+    const observation: ObservationStats | undefined = this.observation?.close();
+    if (!this.parking) {
       await runtime?.dispose();
-      if (this.stopping) {
-        this.stopShells("SIGKILL");
-      }
-      clearTimeout(this.stopDeadline);
-      write(path.join(this.dir, `shutdown-${this.token}.json`), {
-        at: Date.now(),
-        errors: this.errors,
-        ...(observation === undefined ? {} : { observation }),
-      });
-      // Keep the process claim until a launcher proves this exact actor is gone.
     }
+    if (this.stopping) {
+      this.stopShells("SIGKILL");
+    }
+    clearTimeout(this.stopDeadline);
+    write(path.join(this.dir, `shutdown-${this.token}.json`), {
+      at: Date.now(),
+      errors: this.errors,
+      ...(observation === undefined ? {} : { observation }),
+    });
+    if (this.parking) {
+      // Parked authority requires actual exit; no leftover extension handle may keep it alive.
+      process.exit();
+    }
+    // Keep the process claim until a launcher proves this exact actor is gone.
   }
 }
 const base = process.argv.at(2);

package/src/agent/shell.ts

@@ -2,7 +2,11 @@ import { randomUUID } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import * as path from "node:path";
 import * as fs from "node:fs";
-import { readChildProcessIdentity, readProcessClock } from "../shared/post-exit-stdio-guard.ts";
+import {
+  PS_COMMAND,
+  readChildProcessIdentity,
+  readProcessClock,
+} from "../shared/post-exit-stdio-guard.ts";
 import { read, write } from "./storage.ts";
 import { processSchema } from "./contracts.ts";
 import { verifyProcess } from "./process.ts";
@@ -22,7 +26,7 @@ if (
   throw new Error("Native shell registration requires its actual parent shell.");
 }
 const group = Number(
-  execFileSync("ps", ["-p", String(pid), "-o", "pgid="], {
+  execFileSync(PS_COMMAND, ["-p", String(pid), "-o", "pgid="], {
     encoding: "utf8",
     timeout: 1000,
     stdio: ["ignore", "pipe", "ignore"],

package/src/agent/storage.ts

@@ -84,6 +84,23 @@ export function launchAt(base: string, id: string, owner: string): Launch {
   }
   return launch;
 }
+/** Claims the single successor of a saved run; undefined when another caller already has. */
+export function successor(base: string, launch: Launch, prompt: string): Launch | undefined {
+  const id = randomUUID();
+  const next: Launch = { ...launch, id, predecessor: launch.id, prompt, createdAt: Date.now() };
+  fs.mkdirSync(runDirectory(base, id), { mode: 0o700 });
+  write(path.join(runDirectory(base, id), "launch.json"), next, true);
+  try {
+    write(path.join(runDirectory(base, launch.id), "successor.json"), { id }, true);
+  } catch (error) {
+    fs.rmSync(runDirectory(base, id), { recursive: true });
+    if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) {
+      throw error;
+    }
+    return undefined;
+  }
+  return next;
+}
 export function latest(base: string, initial: Launch): Launch {
   const seen = new Set<string>();
   let launch = initial;

package/src/pi-intercom/broker/broker.ts

@@ -8,6 +8,7 @@ import { brokerPidRecord } from "./pid.ts";
 import { assertBrokerCanStart } from "./spawn.ts";
 import { LastMessageRelay } from "./last.ts";
 import { canSeeSession, findSessions } from "./targets.ts";
+import { ParkedSessions, reachable, type ParkablePeer } from "./parked.ts";
 import { acceptBrokerConnection, registeredSessionInfo } from "./server-connection.ts";
 import { guardedDeliveryError } from "./guard.ts";
 import {
@@ -35,8 +36,7 @@ import {
 const PID_PATH = join(getBrokerRuntimeDir(), "broker.pid");
 const REPLACE_DELIVERY_DELAY_MS = 1500;
 
-interface ConnectedSession {
-  readonly socket: net.Socket;
+interface ConnectedSession extends ParkablePeer {
   info: SessionInfo;
   topics: TopicSnapshot;
   readonly topicFrames: boolean;
@@ -54,6 +54,7 @@ interface PendingReplaceDelivery {
 class IntercomBroker {
   private readonly sessions = new Map<string, ConnectedSession>();
   private readonly lastMessages = new LastMessageRelay(this.sessions);
+  private readonly parking = new ParkedSessions(this.sessions, this.deliverMessage.bind(this));
   private readonly pendingReplaceDeliveries = new Map<string, PendingReplaceDelivery>();
   private readonly server: net.Server;
   private shutdownTimer: NodeJS.Timeout | null = null;
@@ -96,7 +97,7 @@ class IntercomBroker {
 
     this.shutdownTimer = setTimeout(() => {
       this.shutdownTimer = null;
-      if (this.sessions.size === 0) {
+      if (this.parking.exited) {
         console.log("No sessions connected, shutting down");
         this.shutdown();
       }
@@ -130,7 +131,7 @@ class IntercomBroker {
     }
     switch (msg.type) {
       case "unregister":
-        this.removeSession(currentId);
+        this.removeSession(currentId, socket);
         setId(null);
         break;
       case "list":
@@ -140,7 +141,8 @@ class IntercomBroker {
         this.send(socket, msg, currentId);
         break;
       case "last_request":
-        this.lastMessages.request(currentId, msg);
+        // Reads never spawn a parked child.
+        this.lastMessages.request(currentId, msg, (id) => this.parking.reader(id));
         break;
       case "last_response":
         this.lastMessages.respond(currentId, msg);
@@ -148,22 +150,29 @@ class IntercomBroker {
       case "presence":
         this.presence(msg, currentId);
         break;
+      case "park":
+      case "unpark":
+        this.parking.park(socket, currentId, msg.type === "park");
+        break;
       default:
         throw new Error(`Unknown client message type: ${msg.type}`);
     }
   }
 
   private register(socket: net.Socket, msg: UnknownRecord, setId: (id: string) => void): void {
-    const info = registeredSessionInfo(msg, this.sessions);
-    const id = info.id;
+    const registered = registeredSessionInfo(msg, this.sessions);
+    const { id, resumed } = this.parking.claim(msg.requestedId, registered);
+    const info: SessionInfo = { ...registered, id };
     snapshotFrames(randomUUID(), [info], true);
     const topicFrames = msg.topicFrames === true;
     this.sessions.set(id, {
       socket,
       info: messageSender(info),
-      topics: new TopicSnapshot(info),
+      // A woken generation registers no topics; the parked identity's owner keeps them.
+      topics: resumed?.topics ?? new TopicSnapshot(info),
       topicFrames,
       lastMessages: msg.lastMessages === true,
+      parking: msg.parking === true,
       receiptReads: msg.receiptReads === 1,
     });
     setId(id);
@@ -175,21 +184,25 @@ class IntercomBroker {
       type: "registered",
       sessionId: id,
       lastMessages: true,
+      parking: msg.parking === true,
       receiptReads: 1,
       ...(msg.guardedDelivery === 1 ? { guardedDelivery: 1 } : {}),
       ...(topicFrames ? { topicsSupported: true, topicFrames: true } : {}),
     });
+    this.parking.registered(id, resumed);
   }
 
-  private removeSession(sessionId: string): void {
+  private removeSession(sessionId: string, socket: net.Socket): void {
     const session = this.sessions.get(sessionId);
-    if (!session) {
+    if (session?.socket !== socket) {
       return;
     }
-    this.sessions.delete(sessionId);
     this.lastMessages.disconnected(sessionId);
-    this.clearPendingReplaceDeliveries(sessionId);
-    this.broadcast({ type: "session_left", sessionId }, session.info);
+    if (!this.parking.closed(session)) {
+      this.sessions.delete(sessionId);
+      this.clearPendingReplaceDeliveries(sessionId);
+      this.broadcast({ type: "session_left", sessionId }, session.info);
+    }
     this.scheduleShutdownCheck();
   }
 
@@ -208,7 +221,7 @@ class IntercomBroker {
         continue;
       }
       const message = publicationMessage(publication, subscription.awaitRelease === true);
-      const error = this.validateDeliveryPayload(from, message, target.topicFrames);
+      const error = this.validateDeliveryPayload(from, message, target);
       if (error !== null) {
         throw new Error(error);
       }
@@ -374,14 +387,16 @@ class IntercomBroker {
     message: Message,
   ): SendResult {
     const target = this.sessions.get(toId);
-    if (target && shouldReplaceDelivery(message, target.info)) {
+    if (target && target.parked === undefined && shouldReplaceDelivery(message, target.info)) {
       return this.queueReplaceDelivery(fromId, toId, from, message);
     }
     const reason = this.deliverMessage(toId, from, message);
+    const queued = reason === null && target?.parked !== undefined;
     return {
       id: message.id,
       accepted: reason === null,
-      delivered: reason === null,
+      delivered: reason === null && !queued,
+      ...(queued ? { queued } : {}),
       ...(reason !== null ? { reason } : {}),
     };
   }
@@ -410,11 +425,7 @@ class IntercomBroker {
     from: SessionInfo,
     message: Message,
   ): SendResult {
-    const validationError = this.validateDeliveryPayload(
-      from,
-      message,
-      this.sessions.get(toId)?.topicFrames === true,
-    );
+    const validationError = this.validateDeliveryPayload(from, message, this.sessions.get(toId));
     if (validationError !== null) {
       return { id: message.id, accepted: false, delivered: false, reason: validationError };
     }
@@ -450,37 +461,33 @@ class IntercomBroker {
     }
   }
 
+  /** One admission rule; retained input is checked as the uncompacted envelope any later
+   * transport generation accepts. */
   private validateDeliveryPayload(
     from: SessionInfo,
     message: Message,
-    topicFrames: boolean,
+    target: ConnectedSession | undefined,
   ): string | null {
+    const compact = target?.parked === undefined && target?.topicFrames === true;
     return (
       validateIntercomMessageSize({
         type: "message",
         from: messageSender(from),
-        message: topicFrames ? compactTopicMessage(message) : message,
+        message: compact ? compactTopicMessage(message) : message,
       })?.message ?? null
     );
   }
 
   private deliverMessage(toId: string, from: SessionInfo, message: Message): string | null {
-    const guardError = guardedDeliveryError(this.sessions, toId, message);
-    if (guardError !== null) {
-      return guardError;
-    }
     const target = this.sessions.get(toId);
-    if (
-      !target ||
-      target.socket.destroyed ||
-      target.socket.writableEnded ||
-      !target.socket.writable
-    ) {
-      return "Recipient disconnected before delivery";
+    const refused =
+      guardedDeliveryError(this.sessions, toId, message) ??
+      this.validateDeliveryPayload(from, message, target);
+    if (refused !== null || this.parking.retain(target, from, message)) {
+      return refused;
     }
-    const validationError = this.validateDeliveryPayload(from, message, target.topicFrames);
-    if (validationError !== null) {
-      return validationError;
+    if (!reachable(target)) {
+      return "Recipient disconnected before delivery";
     }
     this.touchActivity(toId, true);
     try {