@slock-ai/daemon 0.56.0 → 0.56.1

package/dist/{chunk-4H5XFLYA.js → chunk-RIBO24KM.js}

@@ -6145,7 +6145,6 @@ var OpenCodeDriver = class {
 import { randomUUID as randomUUID3 } from "crypto";
 import { EventEmitter } from "events";
 import { mkdirSync as mkdirSync4, readdirSync } from "fs";
-import { PassThrough, Writable } from "stream";
 import path11 from "path";
 import {
   AuthStorage,
@@ -6164,6 +6163,13 @@ var PI_PROVIDER_LABELS = {
   openai: "OpenAI",
   openrouter: "OpenRouter"
 };
+function createPiSdkEventMappingState(sessionId = null) {
+  return {
+    sessionId,
+    sessionAnnounced: false,
+    sawTextDelta: false
+  };
+}
 function buildPiSessionDir(workingDirectory) {
   return path11.join(workingDirectory, PI_SESSION_DIR);
 }
@@ -6189,12 +6195,6 @@ function findPiSessionFile(sessionDir, sessionId) {
   const match = entries.find((entry) => entry.endsWith(suffix));
   return match ? path11.join(sessionDir, match) : null;
 }
-function piSdkEventToJsonLine(event) {
-  if (event.type === "agent_end") {
-    return JSON.stringify({ type: "agent_end" });
-  }
-  return JSON.stringify(event);
-}
 function detectPiModelsFromRegistry(modelRegistry) {
   const models = [];
   const seen = /* @__PURE__ */ new Set();
@@ -6244,114 +6244,309 @@ function piErrorMessage(error) {
   }
   return "Unknown Pi error";
 }
-var PiSdkProcess = class extends EventEmitter {
-  constructor(session) {
-    super();
-    this.session = session;
-    this.stdin = new Writable({
-      write: (chunk, _encoding, callback) => {
-        this.handleInput(String(chunk)).then(
-          () => callback(),
-          (error) => {
-            this.writeError(error);
-            callback();
-          }
-        );
+function pushSessionInitIfNeeded(state, events) {
+  if (!state.sessionAnnounced && state.sessionId) {
+    events.push({ kind: "session_init", sessionId: state.sessionId });
+    state.sessionAnnounced = true;
+  }
+}
+function mapPiAssistantMessageEvent(assistantEvent, state) {
+  switch (assistantEvent.type) {
+    case "thinking_delta":
+      return typeof assistantEvent.delta === "string" && assistantEvent.delta.length > 0 ? [{ kind: "thinking", text: assistantEvent.delta }] : [];
+    case "text_delta":
+      if (typeof assistantEvent.delta === "string" && assistantEvent.delta.length > 0) {
+        state.sawTextDelta = true;
+        return [{ kind: "text", text: assistantEvent.delta }];
       }
-    });
-    this.session.subscribe((event) => {
-      this.writeStdout(piSdkEventToJsonLine(event));
-    });
+      return [];
+    case "text_end":
+      return !state.sawTextDelta && typeof assistantEvent.content === "string" && assistantEvent.content.length > 0 ? [{ kind: "text", text: assistantEvent.content }] : [];
+    case "error":
+      return [{ kind: "error", message: piErrorMessage(assistantEvent.error.errorMessage || assistantEvent.error) }];
+    case "thinking_start":
+    case "thinking_end":
+    case "text_start":
+    case "toolcall_start":
+    case "toolcall_delta":
+    case "toolcall_end":
+    case "start":
+    case "done":
+      return [];
+    default: {
+      const _exhaustive = assistantEvent;
+      return _exhaustive;
+    }
+  }
+}
+function mapPiSdkEventToParsedEvents(event, state) {
+  const events = [];
+  pushSessionInitIfNeeded(state, events);
+  switch (event.type) {
+    case "agent_start":
+    case "turn_start":
+    case "turn_end":
+    case "message_end":
+    case "tool_execution_update":
+    case "queue_update":
+    case "session_info_changed":
+    case "thinking_level_changed":
+    case "auto_retry_start":
+    case "auto_retry_end":
+      return events;
+    case "message_start":
+      if (event.message.role === "assistant") {
+        state.sawTextDelta = false;
+      }
+      return events;
+    case "message_update":
+      events.push(...mapPiAssistantMessageEvent(event.assistantMessageEvent, state));
+      return events;
+    case "tool_execution_start":
+      events.push({
+        kind: "tool_call",
+        name: event.toolName || "unknown_tool",
+        input: event.args ?? {}
+      });
+      return events;
+    case "tool_execution_end":
+      events.push({ kind: "tool_output", name: event.toolName || "unknown_tool" });
+      return events;
+    case "compaction_start":
+      events.push({ kind: "compaction_started" });
+      return events;
+    case "compaction_end":
+      events.push({ kind: "compaction_finished" });
+      return events;
+    case "agent_end":
+      events.push({ kind: "turn_end", sessionId: state.sessionId || void 0 });
+      return events;
+    default: {
+      const _exhaustive = event;
+      return _exhaustive;
+    }
   }
-  stdout = new PassThrough();
-  stderr = new PassThrough();
-  stdin;
-  pid = void 0;
-  exitCode = null;
-  signalCode = null;
-  killed = false;
-  buffer = "";
-  closed = false;
-  kill(signal = "SIGTERM") {
-    if (this.closed) return false;
-    this.killed = true;
-    this.signalCode = typeof signal === "string" ? signal : null;
-    void this.shutdown(null, this.signalCode);
-    return true;
+}
+var PI_RUNTIME_SESSION_DESCRIPTOR = {
+  transport: "sdk",
+  lifecycle: "sdk_session",
+  input: {
+    initial: "start",
+    idle: "sdk_prompt",
+    busy: "sdk_steer"
+  },
+  readiness: "sdk_ready",
+  turnBoundary: "sdk_event",
+  startPolicy: "immediate",
+  inFlightWake: "steer",
+  busyDelivery: "direct",
+  postTurn: "keep_alive"
+};
+async function createPiAgentSessionForContext(ctx, sessionId) {
+  const sessionDir = buildPiSessionDir(ctx.workingDirectory);
+  mkdirSync4(sessionDir, { recursive: true });
+  const spawnEnv = await buildPiSpawnEnv(ctx);
+  const agentDir = spawnEnv.PI_CODING_AGENT_DIR || getAgentDir();
+  const authStorage = AuthStorage.create(path11.join(agentDir, "auth.json"));
+  const modelRegistry = ModelRegistry.create(authStorage, path11.join(agentDir, "models.json"));
+  const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
+  const model = resolvePiModelFromRegistry(launchRuntimeFields.model, modelRegistry);
+  if (launchRuntimeFields.model && launchRuntimeFields.model !== "default" && !model) {
+    throw new Error(`Pi model not found: ${launchRuntimeFields.model}`);
+  }
+  const settingsManager = SettingsManager.inMemory({ compaction: { enabled: false } });
+  const resourceLoader = new DefaultResourceLoader({
+    cwd: ctx.workingDirectory,
+    agentDir,
+    settingsManager,
+    systemPromptOverride: () => ctx.standingPrompt
+  });
+  await resourceLoader.reload();
+  const existingSessionFile = ctx.config.sessionId ? findPiSessionFile(sessionDir, ctx.config.sessionId) : null;
+  const sessionManager = existingSessionFile ? SessionManager.open(existingSessionFile, sessionDir, ctx.workingDirectory) : SessionManager.create(ctx.workingDirectory, sessionDir, { id: sessionId });
+  const { session } = await createAgentSession({
+    cwd: ctx.workingDirectory,
+    agentDir,
+    model,
+    thinkingLevel: launchRuntimeFields.reasoningEffort,
+    authStorage,
+    modelRegistry,
+    resourceLoader,
+    customTools: [
+      createBashTool(ctx.workingDirectory, {
+        spawnHook: (spawnContext) => ({
+          ...spawnContext,
+          env: {
+            ...spawnContext.env,
+            ...spawnEnv
+          }
+        })
+      })
+    ],
+    sessionManager,
+    settingsManager
+  });
+  return session;
+}
+var PiSdkRuntimeSession = class {
+  constructor(ctx, setCurrentSessionId, sessionFactory = createPiAgentSessionForContext) {
+    this.ctx = ctx;
+    this.setCurrentSessionId = setCurrentSessionId;
+    this.sessionFactory = sessionFactory;
+    this.mappingState = createPiSdkEventMappingState(ctx.config.sessionId || null);
+  }
+  descriptor = PI_RUNTIME_SESSION_DESCRIPTOR;
+  events = new EventEmitter();
+  mappingState;
+  session = null;
+  unsubscribe = null;
+  started = false;
+  didClose = false;
+  requestedStopReason;
+  exitInfo = null;
+  get pid() {
+    return void 0;
   }
-  ref() {
-    return this;
+  get currentSessionId() {
+    return this.mappingState.sessionId;
   }
-  unref() {
-    return this;
+  get exitCode() {
+    return this.exitInfo?.code ?? null;
   }
-  async handleInput(chunk) {
-    this.buffer += chunk;
-    const lines = this.buffer.split("\n");
-    this.buffer = lines.pop() || "";
-    for (const line of lines) {
-      if (!line.trim() || this.closed) continue;
-      await this.handleCommand(line);
-    }
+  get signalCode() {
+    return this.exitInfo?.signal ?? null;
   }
-  async handleCommand(raw) {
-    let command;
-    try {
-      command = JSON.parse(raw);
-    } catch (error) {
-      this.writeError(error);
-      return;
+  get closed() {
+    return this.didClose;
+  }
+  on(event, cb) {
+    this.events.on(event, cb);
+  }
+  async start(input) {
+    if (this.started) {
+      return { ok: false, reason: "runtime_error", error: "runtime session already started" };
     }
-    const id = typeof command.id === "string" ? command.id : void 0;
-    try {
-      if (command.type === "prompt") {
-        await this.session.prompt(String(command.message ?? ""));
-        this.writeStdout(JSON.stringify({ id, type: "response", command: "prompt", success: true }));
-      } else if (command.type === "steer") {
-        await this.session.steer(String(command.message ?? ""));
-        this.writeStdout(JSON.stringify({ id, type: "response", command: "steer", success: true }));
-      } else {
-        throw new Error(`Unsupported Pi SDK command: ${command.type || "unknown"}`);
+    if (this.didClose) return { ok: false, reason: "closed" };
+    this.started = true;
+    const sessionId = input.sessionId || this.ctx.config.sessionId || randomUUID3();
+    this.mappingState.sessionId = sessionId;
+    this.setCurrentSessionId(sessionId);
+    const session = await this.sessionFactory({
+      ...this.ctx,
+      config: {
+        ...this.ctx.config,
+        sessionId
       }
-    } catch (error) {
-      this.writeStdout(JSON.stringify({
-        id,
-        type: "response",
-        command: command.type || "unknown",
-        success: false,
-        error: piErrorMessage(error)
-      }));
+    }, sessionId);
+    this.session = session;
+    this.mappingState.sessionId = session.sessionId;
+    this.setCurrentSessionId(session.sessionId);
+    this.unsubscribe = session.subscribe((event) => {
+      for (const parsed of mapPiSdkEventToParsedEvents(event, this.mappingState)) {
+        this.events.emit("runtime_event", parsed);
+      }
+    });
+    this.emitSessionInit();
+    this.launchPrompt(input.text);
+    return { ok: true, acceptedAs: "prompt" };
+  }
+  send(input) {
+    if (this.didClose) return { ok: false, reason: "closed" };
+    const session = this.session;
+    if (!session) return { ok: false, reason: "closed" };
+    if (input.mode === "busy") {
+      this.deferSdkCall(() => session.steer(input.text));
+      return { ok: true, acceptedAs: "steer" };
+    }
+    if (session.isStreaming) {
+      return { ok: false, reason: "busy_rejected", error: "Pi session is still streaming" };
+    }
+    this.launchPrompt(input.text);
+    return { ok: true, acceptedAs: "prompt" };
+  }
+  async stop(opts) {
+    if (this.didClose) return;
+    this.requestedStopReason = opts?.reason;
+    const signal = opts?.signal ?? "SIGTERM";
+    const session = this.session;
+    if (session?.isStreaming) {
+      try {
+        await session.abort();
+      } catch (error) {
+        this.events.emit("stderr", piErrorMessage(error));
+      }
+    }
+    await this.disposeSession();
+    this.emitExitAndClose(null, signal);
+  }
+  async dispose() {
+    if (this.didClose) return;
+    await this.disposeSession();
+    this.emitExitAndClose(0, null);
+  }
+  emitSessionInit() {
+    const sessionId = this.mappingState.sessionId;
+    if (!sessionId || this.mappingState.sessionAnnounced) return;
+    this.mappingState.sessionAnnounced = true;
+    this.events.emit("runtime_event", { kind: "session_init", sessionId });
+  }
+  launchPrompt(text) {
+    const session = this.session;
+    if (!session) {
+      this.events.emit("runtime_event", {
+        kind: "error",
+        message: "Pi SDK session is not started"
+      });
+      return;
     }
+    this.deferSdkCall(() => session.prompt(text));
   }
-  writeStdout(line) {
-    if (this.closed) return;
-    this.stdout.write(line + "\n");
-  }
-  writeError(error) {
-    if (this.closed) return;
-    this.stderr.write(piErrorMessage(error) + "\n");
+  deferSdkCall(invoke) {
+    setImmediate(() => {
+      if (this.didClose) return;
+      try {
+        void invoke().catch((error) => {
+          if (this.didClose) return;
+          this.events.emit("runtime_event", {
+            kind: "error",
+            message: piErrorMessage(error)
+          });
+        });
+      } catch (error) {
+        if (this.didClose) return;
+        this.events.emit("runtime_event", {
+          kind: "error",
+          message: piErrorMessage(error)
+        });
+      }
+    });
   }
-  async shutdown(code, signal) {
-    if (this.closed) return;
-    this.closed = true;
-    this.exitCode = code;
-    this.signalCode = signal;
+  async disposeSession() {
+    const unsubscribe = this.unsubscribe;
+    this.unsubscribe = null;
     try {
-      if (this.session.isStreaming) {
-        await this.session.abort();
-      }
-    } catch (error) {
-      this.stderr.write(piErrorMessage(error) + "\n");
+      unsubscribe?.();
+    } catch {
     }
+    const session = this.session;
+    this.session = null;
     try {
-      this.session.dispose();
-    } catch {
+      session?.dispose();
+    } catch (error) {
+      this.events.emit("stderr", piErrorMessage(error));
     }
-    this.stdin.destroy();
-    this.stdout.end();
-    this.stderr.end();
-    this.emit("exit", code, signal);
-    this.emit("close", code, signal);
+  }
+  emitExitAndClose(code, signal) {
+    if (this.didClose) return;
+    this.didClose = true;
+    const info = {
+      code,
+      signal,
+      reason: this.requestedStopReason ? "requested" : "runtime_exit"
+    };
+    this.exitInfo = info;
+    this.events.emit("exit", info);
+    this.events.emit("close", info);
   }
 };
 var PiDriver = class {
@@ -6378,10 +6573,9 @@ var PiDriver = class {
   busyDeliveryMode = "direct";
   usesSlockCliForCommunication = true;
   sessionId = null;
-  sessionAnnounced = false;
-  sawTextDelta = false;
-  requestId = 0;
-  process = null;
+  get currentSessionId() {
+    return this.sessionId;
+  }
   probe() {
     return {
       available: true,
@@ -6391,144 +6585,20 @@ var PiDriver = class {
   async detectModels() {
     return detectPiModels();
   }
-  async spawn(ctx) {
-    this.sessionId = ctx.config.sessionId || randomUUID3();
-    this.sessionAnnounced = false;
-    this.sawTextDelta = false;
-    this.requestId = 0;
-    const sessionDir = buildPiSessionDir(ctx.workingDirectory);
-    mkdirSync4(sessionDir, { recursive: true });
-    const spawnEnv = await buildPiSpawnEnv(ctx);
-    const agentDir = spawnEnv.PI_CODING_AGENT_DIR || getAgentDir();
-    const authStorage = AuthStorage.create(path11.join(agentDir, "auth.json"));
-    const modelRegistry = ModelRegistry.create(authStorage, path11.join(agentDir, "models.json"));
-    const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
-    const model = resolvePiModelFromRegistry(launchRuntimeFields.model, modelRegistry);
-    if (launchRuntimeFields.model && launchRuntimeFields.model !== "default" && !model) {
-      throw new Error(`Pi model not found: ${launchRuntimeFields.model}`);
-    }
-    const settingsManager = SettingsManager.inMemory({ compaction: { enabled: false } });
-    const resourceLoader = new DefaultResourceLoader({
-      cwd: ctx.workingDirectory,
-      agentDir,
-      settingsManager,
-      systemPromptOverride: () => ctx.standingPrompt
-    });
-    await resourceLoader.reload();
-    const existingSessionFile = ctx.config.sessionId ? findPiSessionFile(sessionDir, ctx.config.sessionId) : null;
-    const sessionManager = existingSessionFile ? SessionManager.open(existingSessionFile, sessionDir, ctx.workingDirectory) : SessionManager.create(ctx.workingDirectory, sessionDir, { id: this.sessionId });
-    const { session } = await createAgentSession({
-      cwd: ctx.workingDirectory,
-      agentDir,
-      model,
-      thinkingLevel: launchRuntimeFields.reasoningEffort,
-      authStorage,
-      modelRegistry,
-      resourceLoader,
-      customTools: [
-        createBashTool(ctx.workingDirectory, {
-          spawnHook: (spawnContext) => ({
-            ...spawnContext,
-            env: {
-              ...spawnContext.env,
-              ...spawnEnv
-            }
-          })
-        })
-      ],
-      sessionManager,
-      settingsManager
-    });
-    this.sessionId = session.sessionId;
-    const proc = new PiSdkProcess(session);
-    this.process = proc;
-    setImmediate(() => {
-      if (this.process === proc && !proc.killed) {
-        this.sendRpcCommand("prompt", { message: ctx.prompt });
-      }
+  createSession(ctx) {
+    this.sessionId = ctx.config.sessionId || null;
+    return new PiSdkRuntimeSession(ctx, (sessionId) => {
+      this.sessionId = sessionId;
     });
-    return { process: proc };
   }
-  parseLine(line) {
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
-      return [];
-    }
-    const events = [];
-    if (event.type === "session" && event.id) {
-      this.sessionId = event.id;
-      if (!this.sessionAnnounced) {
-        this.sessionAnnounced = true;
-        events.push({ kind: "session_init", sessionId: event.id });
-      }
-      return events;
-    }
-    if (!this.sessionAnnounced && this.sessionId) {
-      events.push({ kind: "session_init", sessionId: this.sessionId });
-      this.sessionAnnounced = true;
-    }
-    if (event.type === "response") {
-      if (event.data?.sessionId && event.data.sessionId !== this.sessionId) {
-        this.sessionId = event.data.sessionId;
-      }
-      if (event.success === false) {
-        events.push({ kind: "error", message: piErrorMessage(event.error) });
-      }
-      return events;
-    }
-    if (event.type === "message_start" && event.message?.role === "assistant") {
-      this.sawTextDelta = false;
-      return events;
-    }
-    const assistantEvent = event.assistantMessageEvent;
-    if (event.type === "message_update" && assistantEvent) {
-      switch (assistantEvent.type) {
-        case "thinking_delta":
-          if (typeof assistantEvent.delta === "string" && assistantEvent.delta.length > 0) {
-            events.push({ kind: "thinking", text: assistantEvent.delta });
-          }
-          break;
-        case "text_delta":
-          if (typeof assistantEvent.delta === "string" && assistantEvent.delta.length > 0) {
-            this.sawTextDelta = true;
-            events.push({ kind: "text", text: assistantEvent.delta });
-          }
-          break;
-        case "thinking_start":
-        case "text_start":
-          break;
-        case "tool_use":
-        case "tool_call":
-        case "tool_start":
-          events.push({
-            kind: "tool_call",
-            name: assistantEvent.name || assistantEvent.toolName || "unknown_tool",
-            input: assistantEvent.input ?? assistantEvent.parameters ?? {}
-          });
-          break;
-        case "text_end":
-          if (!this.sawTextDelta && typeof assistantEvent.content === "string" && assistantEvent.content.length > 0) {
-            events.push({ kind: "text", text: assistantEvent.content });
-          }
-          break;
-      }
-      return events;
-    }
-    if (event.type === "agent_end") {
-      events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
-    } else if (event.type === "error") {
-      events.push({ kind: "error", message: piErrorMessage(event.error ?? event.message) });
-    }
-    return events;
+  async spawn(_ctx) {
+    throw new Error("PiDriver uses a native RuntimeSession; child-process spawn is unsupported");
   }
-  encodeStdinMessage(text, _sessionId, opts) {
-    return JSON.stringify({
-      id: this.nextRequestId(),
-      type: opts?.mode === "idle" ? "prompt" : "steer",
-      message: text
-    });
+  parseLine(_line) {
+    return [];
+  }
+  encodeStdinMessage(_text, _sessionId, _opts) {
+    return null;
   }
   buildSystemPrompt(config, _agentId) {
     return buildCliTransportSystemPrompt(config, {
@@ -6541,18 +6611,141 @@ var PiDriver = class {
       messageNotificationStyle: "direct"
     });
   }
-  nextRequestId() {
-    this.requestId += 1;
-    return String(this.requestId);
+};
+
+// src/drivers/runtimeSession.ts
+import { EventEmitter as EventEmitter2 } from "events";
+function descriptorFromDriver(driver) {
+  const lifecycle = driver.lifecycle.kind === "per_turn" ? "turn_based" : "persistent_stream";
+  const idle = driver.supportsStdinNotification ? "stdin" : "unsupported";
+  const busy = driver.supportsStdinNotification ? "stdin_steer" : "unsupported";
+  return {
+    transport: "child_process",
+    lifecycle,
+    input: {
+      initial: "start",
+      idle,
+      busy
+    },
+    readiness: "spawned",
+    turnBoundary: driver.lifecycle.kind === "per_turn" ? "process_exit" : "parsed_event",
+    startPolicy: driver.lifecycle.kind === "per_turn" ? driver.lifecycle.start : "immediate",
+    inFlightWake: driver.lifecycle.inFlightWake,
+    busyDelivery: driver.busyDeliveryMode,
+    postTurn: driver.terminateProcessOnTurnEnd ? "terminate_process" : driver.endStdinOnTurnEnd ? "close_stdin" : "keep_alive"
+  };
+}
+var ChildProcessRuntimeSession = class {
+  constructor(driver, ctx) {
+    this.driver = driver;
+    this.ctx = ctx;
+    this.descriptor = descriptorFromDriver(driver);
   }
-  sendRpcCommand(type, params) {
-    this.process?.stdin?.write(JSON.stringify({
-      id: this.nextRequestId(),
-      type,
-      ...params
-    }) + "\n");
+  descriptor;
+  events = new EventEmitter2();
+  process = null;
+  started = false;
+  stdoutBuffer = "";
+  requestedStopReason;
+  get pid() {
+    return this.process?.pid;
+  }
+  get currentSessionId() {
+    return this.driver.currentSessionId;
+  }
+  get exitCode() {
+    return this.process?.exitCode ?? null;
+  }
+  get signalCode() {
+    return this.process?.signalCode ?? null;
+  }
+  get closed() {
+    return this.process ? this.process.exitCode != null || this.process.signalCode != null : false;
+  }
+  on(event, cb) {
+    this.events.on(event, cb);
+  }
+  async start(input) {
+    if (this.started) {
+      return { ok: false, reason: "runtime_error", error: "runtime session already started" };
+    }
+    this.started = true;
+    const launchCtx = {
+      ...this.ctx,
+      prompt: input.text,
+      config: {
+        ...this.ctx.config,
+        sessionId: input.sessionId ?? this.ctx.config.sessionId
+      }
+    };
+    const { process: process2 } = await this.driver.spawn(launchCtx);
+    this.process = process2;
+    this.attachProcess(process2);
+    return { ok: true, acceptedAs: "prompt" };
+  }
+  send(input) {
+    const proc = this.process;
+    if (!proc || this.closed) return { ok: false, reason: "closed" };
+    const encoded = this.driver.encodeStdinMessage(input.text, input.sessionId ?? null, { mode: input.mode });
+    if (!encoded) return { ok: false, reason: "unsupported" };
+    proc.stdin?.write(encoded + "\n");
+    return { ok: true, acceptedAs: input.mode === "busy" ? "steer" : "prompt" };
+  }
+  async stop(opts) {
+    const proc = this.process;
+    if (!proc || this.closed) return;
+    this.requestedStopReason = opts?.reason;
+    proc.kill(opts?.signal ?? "SIGTERM");
+    if (!opts?.forceAfterMs) return;
+    setTimeout(() => {
+      if (!this.closed) {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+        }
+      }
+    }, opts.forceAfterMs).unref?.();
+  }
+  attachProcess(process2) {
+    process2.stdout?.on("data", (chunk) => {
+      const chunkText = chunk.toString();
+      this.events.emit("stdout", chunkText);
+      this.stdoutBuffer += chunkText;
+      const lines = this.stdoutBuffer.split("\n");
+      this.stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        for (const event of this.driver.parseLine(line)) {
+          this.events.emit("runtime_event", event);
+        }
+      }
+    });
+    process2.stderr?.on("data", (chunk) => {
+      const text = chunk.toString().trim();
+      if (text) this.events.emit("stderr", text);
+    });
+    process2.on("error", (err) => {
+      this.events.emit("error", err);
+    });
+    process2.on("exit", (code, signal) => {
+      this.events.emit("exit", {
+        code,
+        signal,
+        reason: this.requestedStopReason ? "requested" : "runtime_exit"
+      });
+    });
+    process2.on("close", (code, signal) => {
+      this.events.emit("close", {
+        code,
+        signal,
+        reason: this.requestedStopReason ? "requested" : "runtime_exit"
+      });
+    });
   }
 };
+function createChildProcessRuntimeSession(driver, ctx) {
+  return new ChildProcessRuntimeSession(driver, ctx);
+}
 
 // src/drivers/index.ts
 var driverFactories = {
@@ -6953,6 +7146,15 @@ var RUNNER_CREDENTIAL_MINT_MAX_ATTEMPTS = 3;
 function assertNeverApmEffect(effect) {
   throw new Error(`Unhandled APM gated steering effect: ${String(effect)}`);
 }
+function requireImmediateRuntimeSendResult(result, context) {
+  if (typeof result.then === "function") {
+    throw new Error(`RuntimeSession.send returned async result in synchronous APM path: ${context}`);
+  }
+  return result;
+}
+function runtimeSendFailureOutcome(result) {
+  return !result.ok && result.reason === "unsupported" ? "encode_failed" : "send_failed";
+}
 var RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS = 250;
 var WORKSPACE_TEXT_FILE_MAX_BYTES = 1048576;
 var WORKSPACE_IMAGE_PREVIEW_MAX_BYTES = 5 * 1024 * 1024;
@@ -7900,7 +8102,7 @@ function buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes) {
   if (ap.lastActivityDetail) {
     context.push(`after ${ap.lastActivityDetail}`);
   }
-  if (ap.driver.busyDeliveryMode === "gated") {
+  if (ap.runtime.descriptor.busyDelivery === "gated") {
     context.push(`phase=${ap.gatedSteering.phase}`);
   }
   if (ap.gatedSteering.outstandingToolUses > 0) {
@@ -7932,10 +8134,10 @@ function buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes) {
       sessionIdPresent: Boolean(ap.sessionId),
       inboxCount: ap.inbox.length,
       pendingNotificationCount: ap.notifications.pendingCount,
-      processPidPresent: typeof ap.process.pid === "number",
+      processPidPresent: typeof ap.runtime.pid === "number",
       busyDeliveryMode: ap.driver.busyDeliveryMode,
       supportsStdinNotification: ap.driver.supportsStdinNotification,
-      gatedPhase: ap.driver.busyDeliveryMode === "gated" ? ap.gatedSteering.phase : void 0,
+      gatedPhase: ap.runtime.descriptor.busyDelivery === "gated" ? ap.gatedSteering.phase : void 0,
       outstandingToolUses: ap.gatedSteering.outstandingToolUses,
       compacting: ap.gatedSteering.compacting,
       recentStderrCount: ap.recentStderr.length,
@@ -8078,8 +8280,10 @@ var RUNTIME_TELEMETRY_RESERVED_ATTR_KEYS = /* @__PURE__ */ new Set([
   "runtimeResultId",
   "daemonVersion",
   "daemon_version",
+  "daemon_version_present",
   "computerVersion",
-  "computer_version"
+  "computer_version",
+  "computer_version_present"
 ]);
 function sanitizeRuntimeTelemetryPayloadAttrs(attrs) {
   const sanitized = {};
@@ -8136,9 +8340,11 @@ var AgentProcessManager = class _AgentProcessManager {
   stdinNotificationRetryMs;
   cliTransportTraceDir = null;
   deliveryTraceContexts = /* @__PURE__ */ new WeakMap();
-  processExitTraceAttrs = /* @__PURE__ */ new WeakMap();
+  runtimeExitTraceAttrs = /* @__PURE__ */ new WeakMap();
   agentVisibleBoundaries = /* @__PURE__ */ new Map();
   agentVisibleMessageIds = /* @__PURE__ */ new Map();
+  daemonVersion;
+  computerVersion;
   constructor(chatBridgePath, sendToServer, daemonApiKey, opts) {
     this.chatBridgePath = chatBridgePath;
     this.slockCliPath = opts.slockCliPath ?? "";
@@ -8150,6 +8356,8 @@ var AgentProcessManager = class _AgentProcessManager {
     this.driverResolver = opts.driverResolver || getDriver;
     this.defaultAgentEnvVarsProvider = opts.defaultAgentEnvVarsProvider || null;
     this.tracer = opts.tracer ?? noopTracer;
+    this.daemonVersion = opts.daemonVersion?.trim() || null;
+    this.computerVersion = opts.computerVersion?.trim() || null;
     this.stdinNotificationRetryMs = Math.max(
       0,
       Math.floor(opts.stdinNotificationRetryMs ?? STDIN_NOTIFICATION_RETRY_DELAY_MS)
@@ -8390,7 +8598,7 @@ var AgentProcessManager = class _AgentProcessManager {
     });
     span.end(status);
   }
-  startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
+  startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient = false) {
     return {
       agentId,
       launchId,
@@ -8399,6 +8607,7 @@ var AgentProcessManager = class _AgentProcessManager {
       session_id_present: Boolean(config.sessionId),
       launch_id_present: Boolean(launchId),
       wake_message_present: Boolean(wakeMessage),
+      wake_message_transient: Boolean(wakeMessage && wakeMessageTransient),
       unread_channels_count: unreadSummary ? Object.keys(unreadSummary).length : 0,
       resume_prompt_present: Boolean(resumePrompt),
       queue_depth: this.agentStartQueue.length,
@@ -8410,6 +8619,9 @@ var AgentProcessManager = class _AgentProcessManager {
   getDeliveryTraceContext(message) {
     return this.deliveryTraceContexts.get(message) ?? {};
   }
+  isTransientDelivery(message) {
+    return this.getDeliveryTraceContext(message).transient === true;
+  }
   deliveryTraceAttrs(agentId, message, attrs = {}) {
     const context = this.getDeliveryTraceContext(message);
     const deliveryCorrelationId = context.deliveryId ?? message.message_id;
@@ -8421,14 +8633,15 @@ var AgentProcessManager = class _AgentProcessManager {
       sender_type: message.sender_type,
       messageId: message.message_id,
       message_id_present: Boolean(message.message_id),
+      transient_delivery: context.transient === true,
       ...attrs
     };
   }
-  async startAgent(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
-    this.recordDaemonTrace("daemon.agent.start.requested", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId));
+  async startAgent(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient = false) {
+    this.recordDaemonTrace("daemon.agent.start.requested", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient));
     if (this.agents.has(agentId)) {
       this.recordDaemonTrace("daemon.agent.start.ignored", {
-        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_running"
       });
       logger.info(`[Agent ${agentId}] Start ignored (already running)`);
@@ -8436,7 +8649,7 @@ var AgentProcessManager = class _AgentProcessManager {
     }
     if (this.agentsStarting.has(agentId)) {
       this.recordDaemonTrace("daemon.agent.start.ignored", {
-        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_starting"
       });
       logger.info(`[Agent ${agentId}] Start ignored (startup in progress)`);
@@ -8444,7 +8657,7 @@ var AgentProcessManager = class _AgentProcessManager {
     }
     if (this.queuedAgentStarts.has(agentId)) {
       this.recordDaemonTrace("daemon.agent.start.ignored", {
-        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_queued"
       });
       logger.info(`[Agent ${agentId}] Start ignored (startup already queued)`);
@@ -8455,6 +8668,7 @@ var AgentProcessManager = class _AgentProcessManager {
         agentId,
         config,
         wakeMessage,
+        wakeMessageTransient,
         unreadSummary,
         resumePrompt,
         launchId,
@@ -8463,7 +8677,7 @@ var AgentProcessManager = class _AgentProcessManager {
       };
       this.agentStartQueue.push(item);
       this.queuedAgentStarts.set(agentId, item);
-      this.recordDaemonTrace("daemon.agent.start.queued", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId));
+      this.recordDaemonTrace("daemon.agent.start.queued", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient));
       logger.info(
         `[Agent ${agentId}] Start queued (queue=${this.agentStartQueue.length}, active=${this.activeAgentStartCount}, max=${this.maxConcurrentAgentStarts}, interval=${this.agentStartIntervalMs}ms)`
       );
@@ -8480,7 +8694,7 @@ var AgentProcessManager = class _AgentProcessManager {
     const waitMs = shouldRateLimit ? Math.max(0, this.agentStartIntervalMs - elapsed) : 0;
     if (waitMs > 0) {
       this.recordDaemonTrace("daemon.agent.start.rate_limited", {
-        ...this.startQueueTraceAttrs(next.agentId, next.config, next.wakeMessage, next.unreadSummary, next.resumePrompt, next.launchId),
+        ...this.startQueueTraceAttrs(next.agentId, next.config, next.wakeMessage, next.unreadSummary, next.resumePrompt, next.launchId, next.wakeMessageTransient),
         wait_ms: waitMs
       });
       this.agentStartPumpTimer = setTimeout(() => {
@@ -8493,7 +8707,7 @@ var AgentProcessManager = class _AgentProcessManager {
     if (!item) return;
     if (this.queuedAgentStarts.get(item.agentId) !== item) {
       this.recordDaemonTrace("daemon.agent.start.skipped", {
-        ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId),
+        ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient),
         reason: "stale_queue_item"
       });
       this.pumpAgentStartQueue();
@@ -8502,7 +8716,7 @@ var AgentProcessManager = class _AgentProcessManager {
     this.queuedAgentStarts.delete(item.agentId);
     if (this.agents.has(item.agentId) || this.agentsStarting.has(item.agentId)) {
       this.recordDaemonTrace("daemon.agent.start.skipped", {
-        ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId),
+        ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient),
         reason: "already_running_or_starting"
       });
       logger.info(`[Agent ${item.agentId}] Queued start skipped (already running or starting)`);
@@ -8516,14 +8730,15 @@ var AgentProcessManager = class _AgentProcessManager {
     logger.info(
       `[Agent ${item.agentId}] Dequeued start (remaining=${this.agentStartQueue.length}, active=${this.activeAgentStartCount})`
     );
-    this.recordDaemonTrace("daemon.agent.start.dequeued", this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId));
+    this.recordDaemonTrace("daemon.agent.start.dequeued", this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient));
     this.startAgentNow(
       item.agentId,
       item.config,
       item.wakeMessage,
       item.unreadSummary,
       item.resumePrompt,
-      item.launchId
+      item.launchId,
+      item.wakeMessageTransient ?? false
     ).then(() => {
       this.releaseAgentStartSlot(item.agentId, "spawn attempted");
       item.resolve();
@@ -8558,7 +8773,7 @@ var AgentProcessManager = class _AgentProcessManager {
       this.agentStartPumpTimer = null;
     }
     this.recordDaemonTrace("daemon.agent.start.cancelled", {
-      ...this.startQueueTraceAttrs(agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId),
+      ...this.startQueueTraceAttrs(agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient),
       reason
     }, "cancelled");
     logger.info(`[Agent ${agentId}] Queued start cancelled (${reason})`);
@@ -8569,7 +8784,7 @@ var AgentProcessManager = class _AgentProcessManager {
     for (const item of this.agentStartQueue) {
       if (this.queuedAgentStarts.get(item.agentId) === item) {
         this.recordDaemonTrace("daemon.agent.start.cancelled", {
-          ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId),
+          ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient),
           reason
         }, "cancelled");
         logger.info(`[Agent ${item.agentId}] Queued start cancelled (${reason})`);
@@ -8584,10 +8799,10 @@ var AgentProcessManager = class _AgentProcessManager {
       this.agentStartPumpTimer = null;
     }
   }
-  async startAgentNow(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
+  async startAgentNow(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient = false) {
     if (this.agents.has(agentId)) {
       this.recordDaemonTrace("daemon.agent.spawn.skipped", {
-        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_running"
       });
       logger.info(`[Agent ${agentId}] Start ignored (already running)`);
@@ -8595,14 +8810,15 @@ var AgentProcessManager = class _AgentProcessManager {
     }
     if (this.agentsStarting.has(agentId)) {
       this.recordDaemonTrace("daemon.agent.spawn.skipped", {
-        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_starting"
       });
       logger.info(`[Agent ${agentId}] Start ignored (startup in progress)`);
       return;
     }
     this.agentsStarting.add(agentId);
-    this.recordDaemonTrace("daemon.agent.spawn.started", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId));
+    this.recordDaemonTrace("daemon.agent.spawn.started", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient));
+    let agentProcess = null;
     try {
       const driver = this.driverResolver(config.runtime || "claude");
       const legacyWakeRuntimeProfile = wakeMessage ? runtimeProfileNotificationFromMessage(wakeMessage) : null;
@@ -8665,15 +8881,23 @@ var AgentProcessManager = class _AgentProcessManager {
         prompt += getBusyDeliveryNote(driver);
         promptSource = "resume_prompt";
       } else if (wakeMessage) {
-        const runtimeProfileControlPrompt = formatRuntimeProfileControlPrompt([wakeMessage]);
-        if (runtimeProfileControlPrompt) {
+        const transientWakeMessage = wakeMessageTransient === true;
+        const runtimeProfileControlPrompt = transientWakeMessage ? null : formatRuntimeProfileControlPrompt([wakeMessage]);
+        if (transientWakeMessage) {
+          prompt = `System notice received:
+
+${formatIncomingMessage(wakeMessage, driver)}
+
+Respond as appropriate. Complete all your work before stopping.
+${RESPONSE_TARGET_HINT}`;
+        } else if (runtimeProfileControlPrompt) {
           prompt = runtimeProfileControlPrompt;
         } else {
           wakeMessageDeliveredAsInboxUpdate = true;
           prompt = this.formatInboxUpdateRuntimeInput([wakeMessage, ...startingInboxMessages], driver);
         }
-        promptSource = runtimeProfileControlPrompt ? "runtime_profile_control_message" : "wake_inbox_update";
-        if (!runtimeProfileControlPrompt && unreadSummary && Object.keys(unreadSummary).length > 0) {
+        promptSource = transientWakeMessage ? "transient_wake_message" : runtimeProfileControlPrompt ? "runtime_profile_control_message" : "wake_inbox_update";
+        if (!transientWakeMessage && !runtimeProfileControlPrompt && unreadSummary && Object.keys(unreadSummary).length > 0) {
           const otherUnread = Object.entries(unreadSummary);
           if (otherUnread.length > 0) {
             prompt += `
@@ -8730,7 +8954,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.sendAgentStatus(agentId, "active", launchId || null);
         this.broadcastActivity(agentId, "online", "Process idle");
         this.recordDaemonTrace("daemon.agent.spawn.deferred", {
-          ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+          ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
           pending_messages_count: pendingMessages.length,
           reason: "defer_until_concrete_message"
         });
@@ -8740,7 +8964,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         }
         return;
       }
-      const { process: proc } = await driver.spawn({
+      const runtimeContext = {
         agentId,
         config: effectiveConfig,
         standingPrompt,
@@ -8752,15 +8976,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         launchId: launchId || null,
         agentCredentialProxyInboxCoordinator: this.createAgentProxyInboxCoordinator(agentId),
         cliTransportTraceDir: this.cliTransportTraceDir
-      });
-      this.recordDaemonTrace("daemon.agent.spawn.created", {
-        ...this.startQueueTraceAttrs(agentId, effectiveConfig, wakeMessage, unreadSummary, resumePrompt, launchId),
-        detached: false,
-        new_session: false,
-        process_pid_present: typeof proc.pid === "number"
-      });
-      const agentProcess = {
-        process: proc,
+      };
+      const runtime = driver.createSession?.(runtimeContext) ?? createChildProcessRuntimeSession(driver, runtimeContext);
+      agentProcess = {
+        runtime,
         driver,
         inbox: wakeMessageDeliveredAsInboxUpdate && wakeMessage ? [wakeMessage, ...startingInboxMessages] : startingInboxMessages,
         config: runtimeConfig,
@@ -8807,30 +9026,20 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }
       if (wakeMessageDeliveredAsInboxUpdate) {
         this.recordInboxUpdateProjection(agentId, agentProcess, agentProcess.inbox, "spawn_wake_inbox_update", "wake", prompt);
-      } else if (wakeMessage) {
+      } else if (wakeMessage && !wakeMessageTransient) {
         this.consumeVisibleMessages(agentId, { messages: [wakeMessage], source: "spawn_wake_message" });
         this.ackInjectedRuntimeProfileMessages(agentId, [wakeMessage], agentProcess.launchId);
       }
-      let buffer = "";
-      proc.stdout?.on("data", (chunk) => {
-        const chunkText = chunk.toString();
+      runtime.on("stdout", (chunkText) => {
         const current = this.agents.get(agentId);
         if (current) {
           current.recentStdout = pushRecentStdout(current.recentStdout, chunkText);
         }
-        buffer += chunkText;
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          const events = driver.parseLine(line);
-          for (const event of events) {
-            this.handleParsedEvent(agentId, event, driver);
-          }
-        }
       });
-      proc.stderr?.on("data", (chunk) => {
-        const text = chunk.toString().trim();
+      runtime.on("runtime_event", (event) => {
+        this.handleParsedEvent(agentId, event, driver);
+      });
+      runtime.on("stderr", (text) => {
         if (!text) return;
         const current = this.agents.get(agentId);
         if (driver.id === "codex" && isCodexProviderReconnectLog(text)) {
@@ -8855,7 +9064,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         }
         logger.error(`[Agent ${agentId} stderr]: ${text}`);
       });
-      proc.on("error", (err) => {
+      runtime.on("error", (err) => {
         const current = this.agents.get(agentId);
         if (current) {
           current.spawnError = err.message;
@@ -8870,9 +9079,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         }, "error");
         logger.error(`[Agent ${agentId}] Process error: ${err.message}`);
       });
-      proc.on("exit", (code, signal) => {
+      runtime.on("exit", ({ code, signal }) => {
         const current = this.agents.get(agentId);
-        if (current && current.process === proc) {
+        if (current && current.runtime === runtime) {
           current.exitCode = code;
           current.exitSignal = signal;
         }
@@ -8887,14 +9096,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           runtime_trace_active: Boolean(current?.runtimeTraceSpan),
           inbox_count: current?.inbox.length ?? 0,
           pending_notification_count: current?.notifications.pendingCount ?? 0,
-          ...this.processExitTraceAttrs.get(proc)
+          ...this.runtimeExitTraceAttrs.get(runtime)
         });
         logger.info(`[Agent ${agentId}] Process exited with code ${code}${signal ? ` (signal ${signal})` : ""}`);
       });
-      proc.on("close", (code, signal) => {
+      runtime.on("close", ({ code, signal }) => {
         if (this.agents.has(agentId)) {
           const ap = this.agents.get(agentId);
-          if (ap.process !== proc) return;
+          if (ap.runtime !== runtime) return;
           ap.notifications.clearTimer();
           if (ap.pendingTrajectory?.timer) {
             clearTimeout(ap.pendingTrajectory.timer);
@@ -9035,14 +9244,54 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           }
         }
       });
+      const startResult = await runtime.start({ text: prompt, sessionId: effectiveConfig.sessionId || null });
+      if (!startResult.ok) {
+        throw new Error(`Runtime session failed to start: ${startResult.reason}${startResult.error ? ` (${startResult.error})` : ""}`);
+      }
+      this.recordDaemonTrace("daemon.agent.spawn.created", {
+        ...this.startQueueTraceAttrs(agentId, effectiveConfig, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
+        detached: false,
+        new_session: false,
+        process_pid_present: typeof runtime.pid === "number"
+      });
       this.sendAgentStatus(agentId, "active", launchId || null);
       this.broadcastActivity(agentId, "working", "Starting\u2026");
       this.startRuntimeStartupTimeout(agentId, agentProcess);
     } catch (err) {
       this.agentsStarting.delete(agentId);
+      this.cleanupFailedRuntimeStart(agentId, agentProcess, err);
       throw err;
     }
   }
+  cleanupFailedRuntimeStart(agentId, ap, err) {
+    if (!ap) return;
+    if (this.agents.get(agentId) !== ap) return;
+    ap.notifications.clearTimer();
+    if (ap.pendingTrajectory?.timer) {
+      clearTimeout(ap.pendingTrajectory.timer);
+      ap.pendingTrajectory.timer = null;
+    }
+    if (ap.activityHeartbeat) {
+      clearInterval(ap.activityHeartbeat);
+      ap.activityHeartbeat = null;
+    }
+    if (ap.compactionWatchdog) {
+      clearTimeout(ap.compactionWatchdog);
+      ap.compactionWatchdog = null;
+    }
+    this.clearRuntimeStartupTimeout(ap);
+    this.clearStalledRecoverySigtermWatchdog(ap);
+    this.endRuntimeTrace(ap, "error", {
+      outcome: "runtime-start-failed",
+      failure_detail: err instanceof Error ? err.message : String(err),
+      ...runtimeTraceCounterAttrs(ap),
+      ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_error")
+    });
+    cleanupAgentCredentialProxy(agentId, ap.launchId);
+    this.revokeManagedRunnerCredential(agentId, ap.config, ap.launchId);
+    this.agents.delete(agentId);
+    this.idleAgentConfigs.delete(agentId);
+  }
   async buildSpawnConfig(agentId, config) {
     const baseConfig = config.serverUrl === this.serverUrl ? config : { ...config, serverUrl: this.serverUrl };
     const runnerConfig = await this.ensureManagedRunnerCredential(agentId, baseConfig);
@@ -9211,7 +9460,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     ap.inbox.push(message);
     if (ap.driver.supportsStdinNotification && ap.sessionId) {
       ap.notifications.add();
-      if (ap.driver.busyDeliveryMode === "gated") {
+      if (ap.runtime.descriptor.busyDelivery === "gated") {
         this.recordGatedSteeringEvent(agentId, ap, "buffer", {
           reason: "runtime_profile",
           kind,
@@ -9278,12 +9527,16 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     cleanupAgentCredentialProxy(agentId, ap.launchId);
     this.revokeManagedRunnerCredential(agentId, ap.config, ap.launchId);
     this.agents.delete(agentId);
-    this.processExitTraceAttrs.set(ap.process, {
+    this.runtimeExitTraceAttrs.set(ap.runtime, {
       stop_source: silent ? "daemon_internal" : "explicit_request",
       stop_wait_requested: wait,
       stop_silent: silent
     });
-    ap.process.kill("SIGTERM");
+    await ap.runtime.stop({
+      signal: "SIGTERM",
+      forceAfterMs: wait ? 5e3 : void 0,
+      reason: silent ? "daemon_internal" : "explicit_request"
+    });
     if (!silent) {
       this.sendRuntimeProfileReportFor(agentId, ap.config, ap.sessionId, ap.launchId);
       this.sendAgentStatus(agentId, "inactive", ap.launchId);
@@ -9292,22 +9545,18 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     if (wait) {
       await new Promise((resolve) => {
-        const forceKillTimer = setTimeout(() => {
+        const timeoutTimer = setTimeout(() => {
           if (!silent) {
             logger.warn(`[Agent ${agentId}] Stop timed out; force killing`);
           }
-          try {
-            ap.process.kill("SIGKILL");
-          } catch {
-          }
           resolve();
         }, 5e3);
-        ap.process.on("exit", () => {
-          clearTimeout(forceKillTimer);
+        ap.runtime.on("exit", () => {
+          clearTimeout(timeoutTimer);
           resolve();
         });
-        if (ap.process.exitCode !== null || ap.process.signalCode !== null) {
-          clearTimeout(forceKillTimer);
+        if (ap.runtime.closed) {
+          clearTimeout(timeoutTimer);
           resolve();
         }
       });
@@ -9317,9 +9566,24 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (traceContext.deliveryId) {
       this.deliveryTraceContexts.set(message, traceContext);
     }
+    if (traceContext.transient) {
+      this.deliveryTraceContexts.set(message, traceContext);
+    }
+    const transientDelivery = this.isTransientDelivery(message);
     const ap = this.agents.get(agentId);
     if (!ap) {
       if (this.agentsStarting.has(agentId) || this.queuedAgentStarts.has(agentId)) {
+        if (transientDelivery) {
+          const queuedStart2 = this.queuedAgentStarts.get(agentId);
+          this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+            outcome: "transient_dropped_during_start",
+            accepted: true,
+            process_present: false,
+            startup_pending: true,
+            launchId: queuedStart2?.launchId
+          }));
+          return true;
+        }
         const queuedStart = this.queuedAgentStarts.get(agentId);
         const pending = this.startingInboxes.get(agentId) || [];
         pending.push(message);
@@ -9337,7 +9601,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       const cached = this.idleAgentConfigs.get(agentId);
       if (cached) {
         const driver = this.driverResolver(cached.config.runtime || "claude");
-        if (this.shouldDeferWakeMessage(agentId, driver, message)) {
+        if (!transientDelivery && this.shouldDeferWakeMessage(agentId, driver, message)) {
           this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
             outcome: "deferred_wake_message",
             accepted: true,
@@ -9360,7 +9624,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           session_id_present: Boolean(cached.sessionId),
           launchId: cached.launchId || void 0
         }));
-        return this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0).then(() => true, (err) => {
+        return this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0, transientDelivery).then(() => true, (err) => {
           logger.error(`[Agent ${agentId}] Failed to auto-restart`, err);
           if (this.reportRunnerCredentialMintFailure(agentId, err, cached.launchId, "idle_auto_restart")) {
             return false;
@@ -9370,6 +9634,15 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         });
       }
       logger.warn(`[Agent ${agentId}] Delivery received but no running process or cached idle config exists`);
+      if (transientDelivery) {
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: "transient_dropped_no_process",
+          accepted: true,
+          process_present: false,
+          cached_idle_config_present: false
+        }));
+        return true;
+      }
       this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
         outcome: "rejected_no_process",
         accepted: false,
@@ -9380,7 +9653,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       this.broadcastActivity(agentId, "offline", "Process unavailable; restart required");
       return false;
     }
-    if (this.shouldDeferWakeMessage(agentId, ap.driver, message)) {
+    if (!transientDelivery && this.shouldDeferWakeMessage(agentId, ap.driver, message)) {
       this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
         outcome: "deferred_wake_message",
         accepted: true,
@@ -9395,6 +9668,19 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     const stickyTerminalFailure = classifyStickyTerminalFailure(ap);
     if (stickyTerminalFailure) {
+      if (transientDelivery) {
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: "transient_dropped_terminal_runtime_error",
+          accepted: true,
+          process_present: true,
+          runtime: ap.config.runtime,
+          session_id_present: Boolean(ap.sessionId),
+          launchId: ap.launchId || void 0,
+          is_idle: ap.isIdle,
+          inbox_count: ap.inbox.length
+        }));
+        return true;
+      }
       ap.inbox.push(message);
       this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
         outcome: "queued_terminal_runtime_error",
@@ -9411,6 +9697,30 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       return true;
     }
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
+      if (transientDelivery) {
+        this.commitApmIdleState(agentId, ap, false);
+        this.startRuntimeTrace(agentId, ap, "stdin-idle-delivery", [message]);
+        this.broadcastActivity(agentId, "working", "Message received");
+        const stdinAccepted2 = this.deliverMessagesViaStdin(
+          agentId,
+          ap,
+          [message],
+          "idle",
+          { transient: true }
+        );
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: "stdin_idle_transient_delivery",
+          accepted: true,
+          process_present: true,
+          runtime: ap.config.runtime,
+          session_id_present: true,
+          launchId: ap.launchId || void 0,
+          stdin_delivery_accepted: stdinAccepted2,
+          delivered_messages_count: 1,
+          inbox_count: ap.inbox.length
+        }));
+        return true;
+      }
       ap.inbox.push(message);
       const nextMessages = [...ap.inbox];
       this.commitApmIdleState(agentId, ap, false);
@@ -9435,6 +9745,19 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }));
       return true;
     }
+    if (transientDelivery) {
+      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+        outcome: "transient_dropped_busy",
+        accepted: true,
+        process_present: true,
+        runtime: ap.config.runtime,
+        session_id_present: Boolean(ap.sessionId),
+        launchId: ap.launchId || void 0,
+        is_idle: ap.isIdle,
+        inbox_count: ap.inbox.length
+      }));
+      return true;
+    }
     ap.inbox.push(message);
     if (this.recoverStaleProcessForQueuedMessageIfNeeded(agentId, ap)) {
       this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
@@ -9475,7 +9798,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (ap.gatedSteering.compacting) {
       ap.notifications.add();
       ap.notifications.clearTimer();
-      if (ap.driver.busyDeliveryMode === "gated") {
+      if (ap.runtime.descriptor.busyDelivery === "gated") {
         this.recordGatedSteeringEvent(agentId, ap, "buffer", {
           reason: "compaction_boundary",
           pendingMessages: ap.inbox.length
@@ -9500,7 +9823,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }));
       return true;
     }
-    if (ap.driver.busyDeliveryMode === "gated") {
+    if (ap.runtime.descriptor.busyDelivery === "gated") {
       ap.notifications.add();
       if (!ap.notifications.hasTimer) {
         this.scheduleStdinNotification(agentId, ap, STDIN_NOTIFICATION_INITIAL_DELAY_MS);
@@ -9683,7 +10006,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       traceparent: formatTraceparent(span.context)
     };
     const ap = this.agents.get(agentId);
-    if (ap && !(ap.sessionId && ap.driver.supportsStdinNotification && ap.isIdle) && !(ap.sessionId && ap.driver.busyDeliveryMode === "direct")) {
+    if (ap && !(ap.sessionId && ap.driver.supportsStdinNotification && ap.isIdle) && !(ap.sessionId && ap.runtime.descriptor.busyDelivery === "direct")) {
       this.enqueueRuntimeProfileNotification(agentId, ap, message, kind, key);
       span.end("ok", {
         attrs: {
@@ -9713,7 +10036,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       });
       return written;
     }
-    if (ap?.sessionId && ap.driver.busyDeliveryMode === "direct") {
+    if (ap?.sessionId && ap.runtime.descriptor.busyDelivery === "direct") {
       const written = this.deliverMessagesViaStdin(agentId, ap, [message], "busy");
       span.end(written ? "ok" : "error", {
         attrs: {
@@ -10136,23 +10459,23 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     clearTimeout(ap.stalledRecoverySigtermTimer);
     ap.stalledRecoverySigtermTimer = null;
   }
-  mergeProcessExitTraceAttrs(proc, attrs) {
-    this.processExitTraceAttrs.set(proc, {
-      ...this.processExitTraceAttrs.get(proc) ?? {},
+  mergeRuntimeExitTraceAttrs(runtime, attrs) {
+    this.runtimeExitTraceAttrs.set(runtime, {
+      ...this.runtimeExitTraceAttrs.get(runtime) ?? {},
       ...attrs
     });
   }
   startStalledRecoverySigtermWatchdog(agentId, ap, runtimeLabel, queuedMessagesAtSignal, staleForMs) {
     this.clearStalledRecoverySigtermWatchdog(ap);
     const timeoutMs = stalledRecoverySigtermTimeoutMs();
-    const processAtSignal = ap.process;
+    const runtimeAtSignal = ap.runtime;
     ap.stalledRecoverySigtermTimer = setTimeout(() => {
       ap.stalledRecoverySigtermTimer = null;
       const current = this.agents.get(agentId);
-      if (!current || current !== ap || current.process !== processAtSignal || current.expectedTerminationReason !== "stalled_recovery") {
+      if (!current || current !== ap || current.runtime !== runtimeAtSignal || current.expectedTerminationReason !== "stalled_recovery") {
         return;
       }
-      this.mergeProcessExitTraceAttrs(processAtSignal, {
+      this.mergeRuntimeExitTraceAttrs(runtimeAtSignal, {
         stalled_recovery_sigterm_timeout: true,
         stalled_recovery_sigterm_timeout_ms: timeoutMs
       });
@@ -10166,7 +10489,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         queued_messages_at_signal: queuedMessagesAtSignal,
         stale_age_ms_at_signal: staleForMs,
         timeout_ms: timeoutMs,
-        process_pid_present: typeof processAtSignal.pid === "number",
+        process_pid_present: typeof runtimeAtSignal.pid === "number",
         session_id_present: Boolean(current.sessionId),
         supports_stdin_notification: current.driver.supportsStdinNotification,
         busy_delivery_mode: current.driver.busyDeliveryMode
@@ -10175,7 +10498,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         `[Agent ${agentId}] Stalled ${runtimeLabel} runtime did not exit after SIGTERM within ${timeoutMs}ms; force killing`
       );
       try {
-        processAtSignal.kill("SIGKILL");
+        void runtimeAtSignal.stop({ signal: "SIGKILL", reason: "stalled_recovery_sigterm_timeout" });
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
         this.recordDaemonTrace("daemon.agent.stalled_recovery.sigkill_failed", {
@@ -10361,7 +10684,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     ap.runtimeProgress.noteRuntimeEvent(eventKind);
   }
   recordGatedSteeringEvent(agentId, ap, event, attrs = {}) {
-    if (ap.driver.busyDeliveryMode !== "gated") return;
+    if (ap.runtime.descriptor.busyDelivery !== "gated") return;
     const reduction = reduceApmGatedRecentEvent(ap.gatedSteering, { event });
     this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState);
     this.recordRuntimeTraceEvent(agentId, ap, `runtime.gated_steering.${event}`, {
@@ -10396,7 +10719,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   }
   notifyGatedSteeringBoundary(agentId, ap, reason) {
     const readiness = reduceApmGatedFlushReadiness(ap.gatedSteering, {
-      isGated: ap.driver.busyDeliveryMode === "gated",
+      isGated: ap.runtime.descriptor.busyDelivery === "gated",
       hasSession: Boolean(ap.sessionId),
       inboxLength: ap.inbox.length,
       reason
@@ -10446,7 +10769,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           });
           return true;
         }
-        if (ap.driver.busyDeliveryMode === "gated") {
+        if (ap.runtime.descriptor.busyDelivery === "gated") {
           const flushReduction = reduceApmGatedFlush(ap.gatedSteering, { reason: effect.reason });
           this.commitGatedSteeringDecisionState(agentId, ap, flushReduction.nextState);
           this.recordGatedSteeringEvent(agentId, ap, "flush", {
@@ -10548,12 +10871,12 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     this.sendAgentStatus(agentId, "inactive", ap.launchId);
     this.idleAgentConfigs.delete(agentId);
     try {
-      this.processExitTraceAttrs.set(ap.process, {
+      this.runtimeExitTraceAttrs.set(ap.runtime, {
         stop_source: "startup_timeout",
         expectedTerminationReason: "startup_timeout",
         timeout_ms: timeoutMs
       });
-      ap.process.kill("SIGTERM");
+      void ap.runtime.stop({ signal: "SIGTERM", reason: "startup_timeout" });
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
       logger.warn(`[Agent ${agentId}] Failed to terminate startup-timed-out ${ap.driver.id} process: ${reason}`);
@@ -10639,13 +10962,13 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     );
     this.broadcastActivity(agentId, "working", `Restarting stalled ${runtimeLabel} runtime for queued message`);
     try {
-      this.processExitTraceAttrs.set(ap.process, {
+      this.runtimeExitTraceAttrs.set(ap.runtime, {
         stop_source: "stalled_recovery",
         expectedTerminationReason: "stalled_recovery",
         queued_messages_count: ap.inbox.length
       });
       this.startStalledRecoverySigtermWatchdog(agentId, ap, runtimeLabel, ap.inbox.length, staleForMs);
-      ap.process.kill("SIGTERM");
+      void ap.runtime.stop({ signal: "SIGTERM", reason: "stalled_recovery" });
     } catch (err) {
       this.clearStalledRecoverySigtermWatchdog(ap);
       const reason = err instanceof Error ? err.message : String(err);
@@ -10821,11 +11144,11 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           if (ap.driver.terminateProcessOnTurnEnd) {
             logger.info(`[Agent ${agentId}] Turn completed; terminating ${ap.driver.id} process`);
             try {
-              this.processExitTraceAttrs.set(ap.process, {
+              this.runtimeExitTraceAttrs.set(ap.runtime, {
                 stop_source: "turn_end",
                 expectedTerminationReason: "turn_end"
               });
-              ap.process.kill("SIGTERM");
+              void ap.runtime.stop({ signal: "SIGTERM", reason: "turn_end" });
             } catch (err) {
               const reason = err instanceof Error ? err.message : String(err);
               logger.warn(`[Agent ${agentId}] Failed to terminate ${ap.driver.id} after turn_end: ${reason}`);
@@ -10847,7 +11170,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           if (runtimeErrorDiagnostics.spanAttrs.runtime_error_action_required === true) {
             visibleErrorMessage = formatRuntimeLoginRequiredMessage(ap.driver.id);
           }
-          const shouldDisableToolBoundaryFlush = ap.driver.busyDeliveryMode === "gated" && this.isThinkingBlockMutationError(event.message);
+          const shouldDisableToolBoundaryFlush = ap.runtime.descriptor.busyDelivery === "gated" && this.isThinkingBlockMutationError(event.message);
           const terminalFailure = classifyTerminalFailure(ap);
           const reduction = reduceApmGatedError(ap.gatedSteering, {
             disableToolBoundaryFlush: shouldDisableToolBoundaryFlush,
@@ -10878,11 +11201,11 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             if (terminalFailure.actionRequired) {
               logger.warn(`[Agent ${agentId}] ${ap.driver.id} auth requires user action; terminating runtime process`);
               try {
-                this.processExitTraceAttrs.set(ap.process, {
+                this.runtimeExitTraceAttrs.set(ap.runtime, {
                   stop_source: "runtime_auth_error",
                   runtime_error_class: "AuthError"
                 });
-                ap.process.kill("SIGTERM");
+                void ap.runtime.stop({ signal: "SIGTERM", reason: "runtime_auth_error" });
               } catch (err) {
                 const reason = err instanceof Error ? err.message : String(err);
                 logger.warn(`[Agent ${agentId}] Failed to terminate ${ap.driver.id} after auth error: ${reason}`);
@@ -10907,8 +11230,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   recordRuntimeTelemetry(agentId, ap, event) {
     const sessionId = ap.driver.currentSessionId ?? event.sessionId;
     const payloadAttrs = sanitizeRuntimeTelemetryPayloadAttrs(event.attrs);
+    const versionAttrs = this.runtimeTelemetryVersionAttrs();
     const telemetryAttrs = {
       ...payloadAttrs,
+      ...versionAttrs,
       ...event.source ? { source: event.source } : {},
       ...event.usageKind ? { usageKind: event.usageKind } : {},
       ...sessionId ? { sessionId } : {},
@@ -10926,6 +11251,24 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     ap.runtimeTraceSpan?.addEvent(`runtime.telemetry.${event.name}`, telemetryAttrs);
     this.recordDaemonTrace(`daemon.runtime.telemetry.${event.name}`, attrs);
   }
+  runtimeTelemetryVersionAttrs() {
+    return {
+      ...this.daemonVersion ? {
+        daemonVersion: this.daemonVersion,
+        daemon_version: this.daemonVersion,
+        daemon_version_present: true
+      } : {
+        daemon_version_present: false
+      },
+      ...this.computerVersion ? {
+        computerVersion: this.computerVersion,
+        computer_version: this.computerVersion,
+        computer_version_present: true
+      } : {
+        computer_version_present: false
+      }
+    };
+  }
   sendAgentStatus(agentId, status, launchId) {
     this.sendToServer({ type: "agent:status", agentId, status, launchId: launchId || void 0 });
   }
@@ -11009,9 +11352,11 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
       ...projectionAttrs
     });
     logger.info(`[Agent ${agentId}] Sending stdin inbox update: ${inboxRows.length} changed target(s), ${inboxCount} pending message(s)`);
-    const encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId, { mode: "busy" });
-    if (encoded) {
-      ap.process.stdin?.write(encoded + "\n");
+    const sendResult = requireImmediateRuntimeSendResult(
+      ap.runtime.send({ mode: "busy", text: notification, sessionId: ap.sessionId }),
+      "busy inbox notification"
+    );
+    if (sendResult.ok) {
       this.recordDaemonTrace("daemon.agent.inbox_update.pushed", {
         agentId,
         runtime: ap.config.runtime,
@@ -11036,14 +11381,17 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
       return true;
     } else {
       ap.notifications.add(count);
-      const retryScheduled = ap.driver.busyDeliveryMode === "direct" ? this.scheduleStdinNotification(agentId, ap, this.stdinNotificationRetryMs) : false;
+      const retryScheduled = ap.runtime.descriptor.busyDelivery === "direct" ? this.scheduleStdinNotification(agentId, ap, this.stdinNotificationRetryMs) : false;
+      const outcome = runtimeSendFailureOutcome(sendResult);
       this.recordDaemonTrace("daemon.agent.stdin_notification", {
         agentId,
         runtime: ap.config.runtime,
         model: ap.config.model,
         launchId: ap.launchId || void 0,
-        outcome: "encode_failed",
+        outcome,
         mode: "busy",
+        failure_reason: sendResult.reason,
+        failure_error: sendResult.error,
         pending_notification_count: count,
         retry_scheduled: retryScheduled,
         notification_timer_present: ap.notifications.hasTimer,
@@ -11094,8 +11442,11 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
       nativeStandingPrompt: Boolean(ap.driver.supportsNativeStandingPrompt)
     });
     this.recordRuntimeTraceEvent(agentId, ap, "runtime.input.prepared", inputTraceAttrs);
-    const encoded = ap.driver.encodeStdinMessage(prompt, ap.sessionId, { mode });
-    if (!encoded) {
+    const sendResult = requireImmediateRuntimeSendResult(
+      ap.runtime.send({ mode, text: prompt, sessionId: ap.sessionId }),
+      `${mode} inbox update`
+    );
+    if (!sendResult.ok) {
       if (mode === "idle") {
         this.commitApmIdleState(agentId, ap, true);
       }
@@ -11117,7 +11468,9 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
         ...this.messagesTraceAttrs(messages),
         ...inputTraceAttrs,
         ...projectionAttrs,
-        outcome: "encode_failed",
+        outcome: runtimeSendFailureOutcome(sendResult),
+        failure_reason: sendResult.reason,
+        failure_error: sendResult.error,
         requeued_messages_count: 0,
         cursors_advanced: "none"
       }, "error");
@@ -11130,7 +11483,6 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
     if (this.containsOrdinaryInboxMessage(messages)) {
       ap.lastRuntimeError = null;
     }
-    ap.process.stdin?.write(encoded + "\n");
     this.recordDaemonTrace("daemon.agent.stdin_delivery", {
       agentId,
       launchId: ap.launchId || void 0,
@@ -11153,7 +11505,7 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
     return true;
   }
   /** Deliver a message to an agent via stdin, formatting it the same way as the MCP bridge */
-  deliverMessagesViaStdin(agentId, ap, messages, mode) {
+  deliverMessagesViaStdin(agentId, ap, messages, mode, options = {}) {
     if (messages.length === 0) return true;
     const runtimeProfileMigrationMessages = messages.filter((message) => runtimeProfileNotificationFromMessage(message)?.kind === "migration");
     if (runtimeProfileMigrationMessages.length > 0) {
@@ -11191,8 +11543,10 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
       pending_notification_count: ap.notifications.pendingCount,
       busy_delivery_mode: ap.driver.busyDeliveryMode,
       supports_stdin_notification: ap.driver.supportsStdinNotification,
+      transient_delivery: options.transient === true,
       ...this.messagesTraceAttrs(messages)
     };
+    const traceSource = options.transient ? `stdin_${mode}_transient_delivery` : `stdin_${mode}_delivery`;
     const prompt = formatRuntimeProfileControlPrompt(messages) ?? (messages.length === 1 ? `New message received:
 
 ${formatIncomingMessage(messages[0], ap.driver)}
@@ -11205,16 +11559,21 @@ ${messages.map((message) => formatIncomingMessage(message, ap.driver)).join("\n"
 Respond as appropriate. Complete all your work before stopping.
 ${RESPONSE_TARGET_HINT}`);
     const inputTraceAttrs = buildRuntimeInputTraceAttrs({
-      source: `stdin_${mode}_delivery`,
+      source: traceSource,
       prompt,
       messages,
       sessionIdPresent: Boolean(ap.sessionId),
       nativeStandingPrompt: Boolean(ap.driver.supportsNativeStandingPrompt)
     });
     this.recordRuntimeTraceEvent(agentId, ap, "runtime.input.prepared", inputTraceAttrs);
-    const encoded = ap.driver.encodeStdinMessage(prompt, ap.sessionId, { mode });
-    if (!encoded) {
-      ap.inbox.unshift(...messages);
+    const sendResult = requireImmediateRuntimeSendResult(
+      ap.runtime.send({ mode, text: prompt, sessionId: ap.sessionId }),
+      `${mode} message delivery`
+    );
+    if (!sendResult.ok) {
+      if (!options.transient) {
+        ap.inbox.unshift(...messages);
+      }
       if (mode === "idle") {
         this.commitApmIdleState(agentId, ap, true);
       }
@@ -11224,12 +11583,16 @@ ${RESPONSE_TARGET_HINT}`);
       this.recordDaemonTrace("daemon.agent.stdin_delivery", {
         ...traceAttrs,
         ...inputTraceAttrs,
-        outcome: "encode_failed",
-        requeued_messages_count: messages.length
+        outcome: runtimeSendFailureOutcome(sendResult),
+        failure_reason: sendResult.reason,
+        failure_error: sendResult.error,
+        requeued_messages_count: options.transient ? 0 : messages.length
       }, "error");
       return false;
     }
-    this.consumeVisibleMessages(agentId, { messages, source: `stdin_${mode}_delivery` });
+    if (!options.transient) {
+      this.consumeVisibleMessages(agentId, { messages, source: traceSource });
+    }
     const senders = [...new Set(messages.map((message) => `@${message.sender_name}`))].join(", ");
     logger.info(
       `[Agent ${agentId}] Delivering ${mode} ${messages.length === 1 ? "message" : `${messages.length} messages`} via stdin from ${senders}`
@@ -11237,7 +11600,6 @@ ${RESPONSE_TARGET_HINT}`);
     if (this.containsOrdinaryInboxMessage(messages)) {
       ap.lastRuntimeError = null;
     }
-    ap.process.stdin?.write(encoded + "\n");
     this.ackInjectedRuntimeProfileMessages(agentId, messages, ap.launchId);
     this.recordDaemonTrace("daemon.agent.stdin_delivery", {
       ...traceAttrs,
@@ -12444,7 +12806,9 @@ var DaemonCore = class {
       serverUrl: options.serverUrl,
       defaultAgentEnvVarsProvider: options.defaultAgentEnvVarsProvider,
       slockCliPath: this.slockCliPath,
-      tracer: this.tracer
+      tracer: this.tracer,
+      daemonVersion: this.daemonVersion,
+      computerVersion: this.computerVersion
     };
     this.agentManager = options.agentManagerFactory ? options.agentManagerFactory(this.chatBridgePath, (msg) => connection.send(msg), options.apiKey, agentManagerOptions) : new AgentProcessManager(this.chatBridgePath, (msg) => connection.send(msg), options.apiKey, agentManagerOptions);
     const connectionFactory = options.connectionFactory ?? ((connOptions) => new DaemonConnection(connOptions));
@@ -12695,7 +13059,8 @@ var DaemonCore = class {
       msg.wakeMessage,
       msg.unreadSummary,
       msg.resumePrompt,
-      msg.launchId
+      msg.launchId,
+      msg.wakeMessageTransient ?? false
     );
   }
   handleMessage(msg) {
@@ -12746,7 +13111,10 @@ var DaemonCore = class {
         logger.info(`[Agent ${msg.agentId}] Delivery received (seq=${msg.seq}, from=@${msg.message.sender_name}, target=${formatChannelTarget(msg)})`);
         try {
           span.addEvent("daemon.receive", { seq: msg.seq, deliveryId: msg.deliveryId });
-          const acceptedOrPromise = this.agentManager.deliverMessage(msg.agentId, msg.message, { deliveryId: msg.deliveryId });
+          const acceptedOrPromise = this.agentManager.deliverMessage(msg.agentId, msg.message, {
+            deliveryId: msg.deliveryId,
+            transient: msg.transient ?? false
+          });
           Promise.resolve(acceptedOrPromise).then((accepted) => {
             span.addEvent("daemon.deliver_to_agent_manager", { accepted });
             if (!accepted) {