@slock-ai/daemon 0.55.7-play.20260602150229 → 0.56.1

package/dist/{chunk-OV4XD66N.js → chunk-RIBO24KM.js}

@@ -939,10 +939,12 @@ var actionCardActionSchema = z.discriminatedUnion("type", [
 ]);
 
 // ../shared/src/agentInbox.ts
-function formatAgentInboxDelta(rows) {
-  if (rows.length === 0) return "Inbox update: no pending targets";
+function formatAgentInboxDelta(rows, options = {}) {
+  const totalPendingMessages = options.totalPendingMessages;
+  const header = typeof totalPendingMessages === "number" ? `Inbox update: ${totalPendingMessages} unread message${totalPendingMessages === 1 ? "" : "s"} total; ${rows.length === 0 ? "no" : rows.length} changed target${rows.length === 1 ? "" : "s"}` : `Inbox update: ${rows.length} changed target${rows.length === 1 ? "" : "s"}`;
+  if (rows.length === 0) return typeof totalPendingMessages === "number" ? header : "Inbox update: no pending targets";
   return [
-    `Inbox update: ${rows.length} changed target${rows.length === 1 ? "" : "s"}`,
+    header,
     ...rows.map((row) => `${row.target}  ${formatAgentInboxRowDetails(row)}`)
   ].join("\n");
 }
@@ -1305,6 +1307,7 @@ function buildPrompt(config, variant, opts) {
   const sendCmd = isCli ? "`slock message send`" : `\`${t("send_message")}\``;
   const readCmd = isCli ? "`slock message read`" : `\`${t("read_history")}\``;
   const checkCmd = isCli ? "`slock message check`" : `\`${t("check_messages")}\``;
+  const inboxCheckCmd = isCli ? "`slock inbox check`" : checkCmd;
   const taskClaimCmd = isCli ? "`slock task claim`" : `\`${t("claim_tasks")}\``;
   const taskCreateCmd = isCli ? "`slock task create`" : `\`${t("create_tasks")}\``;
   const taskUpdateCmd = isCli ? "`slock task update`" : `\`${t("update_task_status")}\``;
@@ -1785,14 +1788,14 @@ You may develop a specialized role over time through your interactions. Embrace
 
 ## Message Notifications
 
-While you are working, the daemon may write a batched inbox-count notification into your current turn.
+While you are working, the daemon may write a batched, content-free inbox update into your current turn.
 
 How to handle these:
-- Treat the notification as a signal that new Slock messages are waiting; it does not include the message content.
-- Call ${checkCmd} at the next safe breakpoint to materialize the pending messages before taking side-effect actions that depend on current context.
-- If the new message is higher priority, pivot after reading it. If not, continue your current work.`;
+- Treat the notification as a non-urgent signal that new Slock messages are waiting; it does not include the message content and does not require an immediate interruption.
+- Keep working until a natural breakpoint. If you then choose to inspect pending targets, call ${inboxCheckCmd}; use ${checkCmd} / ${readCmd} when you choose to inspect message content.
+- If a message you explicitly read is higher priority, pivot to it. If not, continue your current work.`;
     } else {
-      const notifyExample = isCli ? `\`[Slock inbox notice: You have N pending inbox message(s). Call slock message check to read them when you're ready.]\`` : `\`[Slock inbox notice: You have N pending inbox message(s). Call ${t("check_messages")} to read them when you're ready.]\``;
+      const notifyExample = isCli ? `\`[Slock inbox notice:\\nInbox update: N unread messages total; M changed targets\\n#channel  pending: K messages ...]\`` : `\`[Slock inbox notice:\\nInbox update: N unread messages total; M changed targets\\n#channel  pending: K messages ...]\``;
       prompt += `
 
 ## Message Notifications
@@ -1802,9 +1805,9 @@ While you are busy (executing tools, thinking, etc.), new messages may arrive. W
 ${notifyExample}
 
 How to handle these:
-- Call ${checkCmd} to check for new messages. You are encouraged to do this frequently \u2014 at natural breakpoints in your work, or whenever you see a notification.
-- If the new message is higher priority, you may pivot to it. If not, continue your current work.
-- ${checkCmd} returns instantly with any pending messages (or "no new messages"). It is always safe to call.`;
+- The notice is target-scoped and content-free. Its header may show total unread/pending count, while detail rows list the targets changed by this update; it never includes message bodies.
+- Do not interrupt the current step just because a notice arrived. At a natural breakpoint, call ${inboxCheckCmd} if you choose to inspect pending targets, or use ${checkCmd} / ${readCmd} when you choose to inspect message content.
+- If a message you explicitly read is higher priority, you may pivot to it. If not, continue your current work.`;
     }
   }
   if (config.description) {
@@ -1858,19 +1861,6 @@ function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.
   return candidates.filter((candidate) => existsSync(candidate.path));
 }
 
-// src/authEnv.ts
-var DAEMON_API_KEY_ENV = "SLOCK_MACHINE_API_KEY";
-var SLOCK_AGENT_TOKEN_ENV = "SLOCK_AGENT_TOKEN";
-function scrubDaemonAuthEnv(env) {
-  delete env[DAEMON_API_KEY_ENV];
-  return env;
-}
-function scrubDaemonChildEnv(env) {
-  delete env[DAEMON_API_KEY_ENV];
-  delete env[SLOCK_AGENT_TOKEN_ENV];
-  return env;
-}
-
 // src/agentCredentialProxy.ts
 import { randomBytes } from "crypto";
 import http from "http";
@@ -3026,9 +3016,7 @@ var LOOPBACK_NO_PROXY = "127.0.0.1,localhost";
 var CLI_TRANSPORT_TRACE_DIR_ENV = "SLOCK_CLI_TRANSPORT_TRACE_DIR";
 var safePathPart = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var RAW_CREDENTIAL_ENV_DENYLIST = [
-  "SLOCK_AGENT_TOKEN",
-  "SLOCK_AGENT_CREDENTIAL_KEY",
-  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
+  "SLOCK_AGENT_CREDENTIAL_KEY"
 ];
 var cachedOpencliBinPath;
 function resolveOpencliBinPath() {
@@ -3243,7 +3231,7 @@ exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(opencliBinPath)} "
     ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  scrubDaemonChildEnv(spawnEnv);
+  delete spawnEnv.SLOCK_AGENT_TOKEN;
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -3672,7 +3660,7 @@ function resolveCommandOnWindows(command, env, execFileSyncFn, existsSyncFn) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync2;
   if (platform === "win32") {
@@ -3698,7 +3686,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -5161,11 +5149,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return scrubDaemonChildEnv(withWindowsUserEnvironment({
+  return withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps));
+  }, deps);
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -5221,7 +5209,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync5;
-  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
+  const env = deps.env ?? process.env;
   const winPath = path8.win32;
   let geminiEntry = null;
   try {
@@ -5393,16 +5381,13 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { chmodSync, existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
 import os3 from "os";
 import path9 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
 var KIMI_MCP_FILE = ".slock-kimi-mcp.json";
-var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
-var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
-var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -5411,73 +5396,6 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
-function readKimiConfigSource(home = os3.homedir(), env = process.env) {
-  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
-  if (inlineConfig && inlineConfig.trim()) {
-    return {
-      raw: inlineConfig,
-      explicitPath: null,
-      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
-    };
-  }
-  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
-  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path9.join(home, ".kimi", "config.toml");
-  try {
-    return {
-      raw: readFileSync3(configPath, "utf8"),
-      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
-      sourcePath: configPath
-    };
-  } catch {
-    return {
-      raw: null,
-      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
-      sourcePath: configPath
-    };
-  }
-}
-function buildKimiSpawnEnv(env = process.env) {
-  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
-  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
-  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
-  return scrubDaemonChildEnv(spawnEnv);
-}
-function buildKimiEffectiveEnv(ctx, overrideEnv) {
-  return {
-    ...process.env,
-    ...ctx.config.envVars || {},
-    ...overrideEnv || {}
-  };
-}
-function buildKimiLaunchOptions(ctx, opts = {}) {
-  const env = buildKimiEffectiveEnv(ctx, opts.env);
-  const source = readKimiConfigSource(opts.home ?? os3.homedir(), env);
-  const args = [];
-  let configFilePath = null;
-  let configContent = null;
-  if (source.explicitPath) {
-    configFilePath = source.explicitPath;
-  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
-    configFilePath = path9.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
-    configContent = source.raw;
-    if (opts.writeGeneratedConfig !== false) {
-      writeFileSync6(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
-      chmodSync(configFilePath, 384);
-    }
-  }
-  if (configFilePath) {
-    args.push("--config-file", configFilePath);
-  }
-  if (ctx.config.model && ctx.config.model !== "default") {
-    args.push("--model", ctx.config.model);
-  }
-  return {
-    args,
-    env: buildKimiSpawnEnv(env),
-    configFilePath,
-    configContent
-  };
-}
 function resolveKimiSpawn(commandArgs, deps = {}) {
   return {
     command: resolveCommandOnPath("kimi", deps) ?? "kimi",
@@ -5501,25 +5419,7 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId, ctx, opts) => {
-      if (!ctx) return { args: ["--model", modelId] };
-      const launchCtx = {
-        ...ctx,
-        config: {
-          ...ctx.config,
-          model: modelId
-        }
-      };
-      const launch = buildKimiLaunchOptions(launchCtx, {
-        home: opts?.home,
-        writeGeneratedConfig: false
-      });
-      return {
-        args: launch.args,
-        env: launch.env,
-        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
-      };
-    }
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
   };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
@@ -5573,7 +5473,6 @@ var KimiDriver = class {
         }
       }
     }), "utf8");
-    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
@@ -5582,16 +5481,15 @@ var KimiDriver = class {
       "--mcp-config-file",
       mcpConfigPath,
       "--session",
-      this.sessionId,
-      ...launch.args
+      this.sessionId
     ];
     const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
     if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
       args.push("--model", launchRuntimeFields.model);
     }
     const spawnEnv = (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
-    const spawnTarget = resolveKimiSpawn(args);
-    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
+    const launch = resolveKimiSpawn(args);
+    const proc = spawn7(launch.command, launch.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -5599,7 +5497,7 @@ var KimiDriver = class {
       // and has an 8191-character command-line limit. Kimi's official
       // installer/uv entrypoint is an executable, so launch it directly and
       // keep prompts on stdin / files instead of routing through cmd.exe.
-      shell: spawnTarget.shell
+      shell: launch.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -5713,9 +5611,14 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os3.homedir(), opts = {}) {
-  const raw = readKimiConfigSource(home, opts.env).raw;
-  if (raw === null) return null;
+function detectKimiModels(home = os3.homedir()) {
+  const configPath = path9.join(home, ".kimi", "config.toml");
+  let raw;
+  try {
+    raw = readFileSync3(configPath, "utf8");
+  } catch {
+    return null;
+  }
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -5979,7 +5882,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
+    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -6242,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,
@@ -6261,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);
 }
@@ -6286,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();
@@ -6341,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 {
@@ -6475,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,
@@ -6488,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, {
@@ -6638,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 = {
@@ -6786,7 +6882,9 @@ import { createHash as createHash2 } from "crypto";
 var MAX_RUNTIME_ERROR_MESSAGE_EXCERPT_CHARS = 4096;
 var RUNTIME_AUTH_ACTION_REQUIRED_PATTERNS = [
   /access token could not be refreshed/i,
+  /\btoken_(?:revoked|invalidated)\b/i,
   /refresh token was already used/i,
+  /access token.*invalidated/i,
   /authentication token has been invalidated/i,
   /logged out or signed in to another account/i,
   /not logged in/i,
@@ -6868,6 +6966,9 @@ function classifyRuntimeError(message, httpStatus) {
     return "ProviderApiError";
   }
   if (isRuntimeAuthActionRequiredText(message)) return "AuthError";
+  if (/\bmodel\b.*\bnot supported\b/i.test(message) || /\bunsupported\b.*\bmodel\b/i.test(message) || /\bmodel\b.*\bnot available\b/i.test(message)) {
+    return "ModelConfigError";
+  }
   if (/\b(?:ETIMEDOUT|timeout|timed out)\b/i.test(message)) return "TimeoutError";
   if (/\b(?:ECONNRESET|EPIPE|ECONNREFUSED|ENOTFOUND|EAI_AGAIN)\b/i.test(message) || /\bUnable to connect to API\b/i.test(message)) {
     return "ProviderConnectionError";
@@ -6900,6 +7001,8 @@ function classifyRuntimeErrorReason(runtimeErrorClass) {
       return "auth_failed";
     case "NotFoundError":
       return "not_found";
+    case "ModelConfigError":
+      return "model_config_error";
     case "ProviderServerError":
       return "provider_server_error";
     case "ProviderApiError":
@@ -7043,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;
@@ -7901,7 +8013,7 @@ function classifyTerminalFailure(ap) {
   for (const text of candidates) {
     const diagnostics = buildRuntimeErrorDiagnosticEnvelope(text);
     const lower = text.toLowerCase();
-    if (lower.includes("usage limit") || lower.includes("quota exceeded") || lower.includes("quota limit") || lower.includes("budget limit exceeded") || lower.includes("usage not included in your plan") || lower.includes("modelnotfounderror") || lower.includes("requested entity was not found") || lower.includes("model deprecated") || lower.includes("model not found") || diagnostics.spanAttrs.runtime_error_action_required === true || isProviderStreamFailureText(text) || isRuntimeStartTimeoutText(text)) {
+    if (lower.includes("usage limit") || lower.includes("quota exceeded") || lower.includes("quota limit") || lower.includes("budget limit exceeded") || lower.includes("usage not included in your plan") || lower.includes("modelnotfounderror") || lower.includes("requested entity was not found") || lower.includes("model deprecated") || lower.includes("model not found") || lower.includes("model is not supported") || lower.includes("unsupported model") || /\bmodel\b.*\bnot supported\b/i.test(text) || diagnostics.spanAttrs.runtime_error_action_required === true || isProviderStreamFailureText(text) || isRuntimeStartTimeoutText(text)) {
       const actionRequired = diagnostics.spanAttrs.runtime_error_action_required === true;
       return {
         detail: actionRequired ? formatRuntimeLoginRequiredMessage(ap.driver.id) : text,
@@ -7911,6 +8023,16 @@ function classifyTerminalFailure(ap) {
   }
   return null;
 }
+function classifyStickyTerminalFailure(ap) {
+  const terminalFailure = classifyTerminalFailure(ap);
+  if (!terminalFailure) return null;
+  if (terminalFailure.actionRequired) return terminalFailure;
+  if (/\bmodel\b.*\bnot supported\b/i.test(terminalFailure.detail)) return terminalFailure;
+  if (/\bunsupported\b.*\bmodel\b/i.test(terminalFailure.detail)) return terminalFailure;
+  if (isProviderStreamFailureText(terminalFailure.detail)) return null;
+  if (isRuntimeStartTimeoutText(terminalFailure.detail)) return null;
+  return null;
+}
 function isProviderStreamFailureText(text) {
   return /stream closed before response\.completed|error decoding response body/i.test(text);
 }
@@ -7980,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) {
@@ -8012,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,
@@ -8158,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 = {};
@@ -8170,17 +8294,17 @@ function sanitizeRuntimeTelemetryPayloadAttrs(attrs) {
   return sanitized;
 }
 function getMessageDeliveryText(driver) {
-  return driver.supportsStdinNotification ? "New messages may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you when new messages arrive.";
+  return driver.supportsStdinNotification ? "New inbox updates may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you with an inbox update when new messages arrive.";
 }
 function getBusyDeliveryNote(driver) {
   if (!driver.supportsStdinNotification) return "";
   if (driver.busyDeliveryMode === "direct") {
-    return "\n\nNote: While you are busy, the daemon may write batched inbox-count notifications into your active turn. Call check_messages to read the pending messages before context-sensitive side effects.";
+    return "\n\nNote: While you are busy, the daemon may write batched content-free inbox updates into your active turn. Finish your current step, then check the inbox or read messages at a natural breakpoint.";
   }
   if (driver.busyDeliveryMode === "gated") {
-    return "\n\nNote: While you are busy, the daemon may write batched inbox-count notifications into your active turn at runtime-observed safe boundaries. Call check_messages to read the pending messages before context-sensitive side effects.";
+    return "\n\nNote: While you are busy, the daemon may write batched content-free inbox updates into your active turn at runtime-observed safe boundaries. Finish your current step, then check the inbox or read messages at a natural breakpoint.";
   }
-  return "\n\nNote: While you are busy, you may receive [Slock inbox notice: ...] messages. Finish your current step, then call check_messages to check for messages.";
+  return "\n\nNote: While you are busy, you may receive [Slock inbox notice: ...] messages. Finish your current step, then check the inbox or read messages at a natural breakpoint.";
 }
 var NATIVE_STANDING_PROMPT_STARTUP_INPUT = (
   // Claude Code 2.1.114 treats "follow your system prompt" style user turns as
@@ -8216,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 ?? "";
@@ -8230,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)
@@ -8470,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,
@@ -8479,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,
@@ -8490,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;
@@ -8501,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)`);
@@ -8516,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)`);
@@ -8524,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)`);
@@ -8535,6 +8668,7 @@ var AgentProcessManager = class _AgentProcessManager {
         agentId,
         config,
         wakeMessage,
+        wakeMessageTransient,
         unreadSummary,
         resumePrompt,
         launchId,
@@ -8543,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)`
       );
@@ -8560,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(() => {
@@ -8573,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();
@@ -8582,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)`);
@@ -8596,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();
@@ -8638,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})`);
@@ -8649,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})`);
@@ -8664,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)`);
@@ -8675,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;
@@ -8735,6 +8871,8 @@ var AgentProcessManager = class _AgentProcessManager {
       const standingPrompt = driver.buildSystemPrompt(runtimeConfig, agentId);
       let prompt;
       let promptSource;
+      let wakeMessageDeliveredAsInboxUpdate = false;
+      const startingInboxMessages = this.startingInboxes.get(agentId) || [];
       if (runtimeConfig.runtimeProfileControl && !wakeMessage) {
         prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : formatRuntimeProfileControlStartupInput(runtimeConfig.runtimeProfileControl, driver);
         promptSource = "runtime_profile_control";
@@ -8743,14 +8881,24 @@ var AgentProcessManager = class _AgentProcessManager {
         prompt += getBusyDeliveryNote(driver);
         promptSource = "resume_prompt";
       } else if (wakeMessage) {
-        const runtimeProfileControlPrompt = formatRuntimeProfileControlPrompt([wakeMessage]);
-        const channelLabel = formatChannelLabel(wakeMessage);
-        prompt = runtimeProfileControlPrompt ?? `New message received:
-
-${formatIncomingMessage(wakeMessage, driver)}`;
-        promptSource = runtimeProfileControlPrompt ? "runtime_profile_control_message" : "wake_message";
-        if (!runtimeProfileControlPrompt && unreadSummary && Object.keys(unreadSummary).length > 0) {
-          const otherUnread = Object.entries(unreadSummary).filter(([key]) => key !== channelLabel);
+        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 = 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 += `
 
@@ -8761,18 +8909,9 @@ You also have unread messages in other channels:`;
             }
             prompt += `
 
-Use ${communicationCommand(driver, "read_history")} to catch up, or respond to the message above first.`;
+Use the inbox/read commands at a natural breakpoint if you choose to inspect those targets.`;
           }
         }
-        if (!runtimeProfileControlPrompt) {
-          prompt += `
-
-Respond as appropriate \u2014 ${dynamicReplyInstruction(driver)}, or take action as needed. Complete ALL your work before stopping.
-${RESPONSE_TARGET_HINT}
-
-IMPORTANT: If the message requires multi-step work (e.g. research, code changes, testing), complete ALL steps before stopping. Sending a progress update does NOT mean your task is done \u2014 only stop when you have NO more work to do. ${getMessageDeliveryText(driver)}`;
-          prompt += getBusyDeliveryNote(driver);
-        }
       } else if (isResume && unreadSummary && Object.keys(unreadSummary).length > 0) {
         prompt = `You have unread messages from while you were offline:`;
         for (const [ch, count] of Object.entries(unreadSummary)) {
@@ -8815,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"
         });
@@ -8825,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,
@@ -8837,17 +8976,12 @@ 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: this.startingInboxes.get(agentId) || [],
+        inbox: wakeMessageDeliveredAsInboxUpdate && wakeMessage ? [wakeMessage, ...startingInboxMessages] : startingInboxMessages,
         config: runtimeConfig,
         sessionId: runtimeConfig.sessionId || null,
         launchId: launchId || null,
@@ -8890,30 +9024,22 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       if (runtimeConfig.runtimeProfileControl) {
         this.ackInjectedRuntimeProfileControl(agentId, runtimeConfig.runtimeProfileControl, agentProcess.launchId);
       }
-      if (wakeMessage) {
+      if (wakeMessageDeliveredAsInboxUpdate) {
+        this.recordInboxUpdateProjection(agentId, agentProcess, agentProcess.inbox, "spawn_wake_inbox_update", "wake", prompt);
+      } 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)) {
@@ -8938,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;
@@ -8953,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;
         }
@@ -8970,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);
@@ -8991,8 +9117,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           const finalSignal = ap.exitSignal ?? signal;
           const startupTimeoutTermination = ap.expectedTerminationReason === "startup_timeout";
           const expectedTermination = Boolean(ap.expectedTerminationReason);
-          const processEndedCleanly = finalCode === 0 || expectedTermination && !ap.lastRuntimeError;
-          const terminalFailureDetail = processEndedCleanly ? null : classifyTerminalFailure(ap);
+          const stickyTerminalFailureDetail = classifyStickyTerminalFailure(ap);
+          const processEndedCleanly = !stickyTerminalFailureDetail && (finalCode === 0 || expectedTermination && !ap.lastRuntimeError);
+          const terminalFailureDetail = processEndedCleanly ? null : stickyTerminalFailureDetail ?? classifyTerminalFailure(ap);
           const resumeRecoveryReason = resumeSessionRecoveryReason(ap);
           const shouldColdStartResumeSession = resumeRecoveryReason !== null;
           const summary = summarizeCrash(finalCode, finalSignal);
@@ -9117,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);
@@ -9293,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,
@@ -9360,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);
@@ -9374,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();
         }
       });
@@ -9399,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);
@@ -9419,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,
@@ -9442,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;
@@ -9452,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,
@@ -9462,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,
@@ -9475,13 +9666,73 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }));
       return true;
     }
+    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",
+        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
+      }));
+      this.sendAgentStatus(agentId, "inactive", ap.launchId);
+      this.broadcastActivity(agentId, "error", stickyTerminalFailure.detail);
+      return true;
+    }
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
-      const nextMessages = ap.inbox.splice(0, ap.inbox.length);
-      nextMessages.push(message);
+      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);
-      this.startRuntimeTrace(agentId, ap, "stdin-idle-delivery", nextMessages);
+      this.startRuntimeTrace(agentId, ap, "stdin-idle-delivery", [message]);
       this.broadcastActivity(agentId, "working", "Message received");
-      const stdinAccepted = this.deliverMessagesViaStdin(agentId, ap, nextMessages, "idle");
+      const stdinAccepted = this.deliverInboxUpdateViaStdin(
+        agentId,
+        ap,
+        [message],
+        "idle",
+        "stdin_idle_delivery"
+      );
       this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
         outcome: "stdin_idle_delivery",
         accepted: true,
@@ -9494,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, {
@@ -9534,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
@@ -9559,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);
@@ -9742,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: {
@@ -9772,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: {
@@ -10195,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
       });
@@ -10225,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
@@ -10234,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", {
@@ -10420,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}`, {
@@ -10455,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
@@ -10496,7 +10760,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           return written;
         }
       case "deliver_stdin": {
-        const messages = ap.inbox.splice(0, ap.inbox.length);
+        const messages = [...ap.inbox];
         ap.notifications.clear();
         if (messages.length === 0) {
           this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
@@ -10505,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", {
@@ -10514,7 +10778,22 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           });
         }
         this.broadcastActivity(agentId, "working", "Message received");
-        const accepted = this.deliverMessagesViaStdin(agentId, ap, messages, effect.stdinMode);
+        const runtimeProfileMessages = messages.filter((message) => runtimeProfileNotificationFromMessage(message));
+        const ordinaryMessages = messages.filter((message) => !runtimeProfileNotificationFromMessage(message));
+        let accepted = true;
+        if (runtimeProfileMessages.length > 0) {
+          ap.inbox.splice(0, ap.inbox.length, ...ordinaryMessages);
+          accepted = this.deliverMessagesViaStdin(agentId, ap, runtimeProfileMessages, effect.stdinMode);
+        }
+        if (ordinaryMessages.length > 0) {
+          accepted = this.deliverInboxUpdateViaStdin(
+            agentId,
+            ap,
+            ordinaryMessages,
+            effect.stdinMode,
+            `stdin_${effect.stdinMode}_delivery`
+          ) && accepted;
+        }
         this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
           outcome: accepted ? "written" : "not_written",
           delivered_messages_count: messages.length
@@ -10592,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}`);
@@ -10683,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);
@@ -10826,39 +11105,50 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.flushPendingTrajectory(agentId);
         if (ap) {
           if (event.sessionId) ap.sessionId = event.sessionId;
+          const stickyTerminalFailure = classifyStickyTerminalFailure(ap);
           const reduction = reduceApmGatedTurnEnd(ap.gatedSteering, {
-            inboxLength: ap.inbox.length,
+            inboxLength: stickyTerminalFailure ? 0 : ap.inbox.length,
             supportsStdinNotification: ap.driver.supportsStdinNotification,
             hasSession: Boolean(ap.sessionId),
             terminateProcessOnTurnEnd: ap.driver.terminateProcessOnTurnEnd === true
           });
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "turn_end" });
           const deliverStdinEffect = reduction.effects.find((effect) => effect.kind === "deliver_stdin");
+          if (stickyTerminalFailure) {
+            this.sendAgentStatus(agentId, "inactive", ap.launchId);
+          }
           if (deliverStdinEffect) {
             if (!this.executeApmGatedSteeringEffect(agentId, ap, deliverStdinEffect)) {
               this.commitApmIdleState(agentId, ap, true);
-              this.broadcastActivity(agentId, "online", "Idle");
+              if (stickyTerminalFailure) {
+                this.broadcastActivity(agentId, "error", stickyTerminalFailure.detail);
+              } else {
+                this.broadcastActivity(agentId, "online", "Idle");
+              }
             }
           } else {
-            if (ap.lastRuntimeError) {
+            if (stickyTerminalFailure) {
+              this.broadcastActivity(agentId, "error", stickyTerminalFailure.detail);
+            } else if (ap.lastRuntimeError) {
               this.broadcastActivity(agentId, "error", ap.lastRuntimeError);
             } else {
               this.broadcastActivity(agentId, "online", "Idle");
             }
           }
-          this.endRuntimeTrace(ap, "ok", {
-            outcome: "turn-completed",
+          this.endRuntimeTrace(ap, stickyTerminalFailure ? "error" : "ok", {
+            outcome: stickyTerminalFailure ? "runtime-error-with-turn-end" : "turn-completed",
+            ...stickyTerminalFailure ? { terminalRuntimeError: true } : {},
             ...runtimeTraceCounterAttrs(ap),
-            ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "turn_end")
+            ...this.finalizeRuntimeProfileTurnControl(agentId, ap, stickyTerminalFailure ? "runtime_error" : "turn_end")
           });
           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}`);
@@ -10880,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,
@@ -10907,18 +11197,23 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_error")
           });
           if (ap.driver.supportsStdinNotification && terminalFailure) {
+            const stickyTerminalFailure = classifyStickyTerminalFailure(ap);
             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}`);
               }
+            } else if (stickyTerminalFailure) {
+              ap.notifications.clear();
+              this.sendAgentStatus(agentId, "inactive", ap.launchId);
+              logger.warn(`[Agent ${agentId}] ${ap.driver.id} terminal runtime error requires explicit recovery`);
             } else {
               ap.notifications.clear();
               logger.info(`[Agent ${agentId}] Marked ${ap.driver.id} wakeable after terminal runtime error`);
@@ -10935,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 } : {},
@@ -10954,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 });
   }
@@ -11025,9 +11340,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     const inboxCount = ap.inbox.length;
     if (inboxCount === 0) return false;
-    const inboxRows = projectAgentInboxSnapshot(ap.inbox);
+    const changedMessages = ap.inbox.slice(Math.max(0, ap.inbox.length - count));
+    const inboxRows = projectAgentInboxSnapshot(changedMessages);
     const notification = `[Slock inbox notice:
-${formatAgentInboxDelta(inboxRows)}]`;
+${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
     const notificationByteCount = Buffer.byteLength(notification, "utf8");
     const projectionAttrs = this.inboxProjectionTraceAttrs(inboxRows, inboxCount);
     this.recordDaemonTrace("daemon.agent.inbox_projection.delta", {
@@ -11036,9 +11352,11 @@ ${formatAgentInboxDelta(inboxRows)}]`;
       ...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,
@@ -11063,14 +11381,17 @@ ${formatAgentInboxDelta(inboxRows)}]`;
       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,
@@ -11081,8 +11402,110 @@ ${formatAgentInboxDelta(inboxRows)}]`;
       return false;
     }
   }
+  formatInboxUpdateRuntimeInput(messages, driver, totalPendingMessages = messages.length) {
+    const rows = projectAgentInboxSnapshot(messages);
+    return [
+      "[Slock inbox notice:",
+      formatAgentInboxDelta(rows, { totalPendingMessages }),
+      "]"
+    ].join("\n");
+  }
+  recordInboxUpdateProjection(agentId, ap, messages, source, mode, renderedInput, totalPendingMessages = messages.length) {
+    const rows = projectAgentInboxSnapshot(messages);
+    const projectionAttrs = this.inboxProjectionTraceAttrs(rows, totalPendingMessages);
+    this.recordDaemonTrace("daemon.agent.inbox_projection.delta", {
+      agentId,
+      source,
+      ...projectionAttrs
+    });
+    this.recordDaemonTrace("daemon.agent.inbox_update.pushed", {
+      agentId,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      mode,
+      notification_byte_count: Buffer.byteLength(renderedInput, "utf8"),
+      cursors_advanced: "none",
+      ...projectionAttrs
+    });
+    return projectionAttrs;
+  }
+  deliverInboxUpdateViaStdin(agentId, ap, messages, mode, source) {
+    if (messages.length === 0) return true;
+    const prompt = this.formatInboxUpdateRuntimeInput(messages, ap.driver, ap.inbox.length);
+    const projectionAttrs = this.recordInboxUpdateProjection(agentId, ap, messages, source, mode, prompt, ap.inbox.length);
+    const inputTraceAttrs = buildRuntimeInputTraceAttrs({
+      source,
+      prompt,
+      messages,
+      sessionIdPresent: Boolean(ap.sessionId),
+      nativeStandingPrompt: Boolean(ap.driver.supportsNativeStandingPrompt)
+    });
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.input.prepared", inputTraceAttrs);
+    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);
+      }
+      logger.warn(
+        `[Agent ${agentId}] Failed to encode ${mode} inbox update; ${messages.length === 1 ? "message remains" : "messages remain"} pending`
+      );
+      this.recordDaemonTrace("daemon.agent.stdin_delivery", {
+        agentId,
+        launchId: ap.launchId || void 0,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        mode,
+        messages_count: messages.length,
+        session_id_present: Boolean(ap.sessionId),
+        inbox_count: ap.inbox.length,
+        pending_notification_count: ap.notifications.pendingCount,
+        busy_delivery_mode: ap.driver.busyDeliveryMode,
+        supports_stdin_notification: ap.driver.supportsStdinNotification,
+        ...this.messagesTraceAttrs(messages),
+        ...inputTraceAttrs,
+        ...projectionAttrs,
+        outcome: runtimeSendFailureOutcome(sendResult),
+        failure_reason: sendResult.reason,
+        failure_error: sendResult.error,
+        requeued_messages_count: 0,
+        cursors_advanced: "none"
+      }, "error");
+      return false;
+    }
+    const senders = [...new Set(messages.map((message) => `@${message.sender_name}`))].join(", ");
+    logger.info(
+      `[Agent ${agentId}] Delivering ${mode} inbox update for ${messages.length === 1 ? "message" : `${messages.length} messages`} from ${senders}`
+    );
+    if (this.containsOrdinaryInboxMessage(messages)) {
+      ap.lastRuntimeError = null;
+    }
+    this.recordDaemonTrace("daemon.agent.stdin_delivery", {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      mode,
+      messages_count: messages.length,
+      session_id_present: Boolean(ap.sessionId),
+      inbox_count: ap.inbox.length,
+      pending_notification_count: ap.notifications.pendingCount,
+      busy_delivery_mode: ap.driver.busyDeliveryMode,
+      supports_stdin_notification: ap.driver.supportsStdinNotification,
+      ...this.messagesTraceAttrs(messages),
+      ...inputTraceAttrs,
+      ...projectionAttrs,
+      outcome: "written",
+      stdin_write_attempted: true,
+      cursors_advanced: "none"
+    });
+    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) {
@@ -11120,8 +11543,10 @@ ${formatAgentInboxDelta(inboxRows)}]`;
       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)}
@@ -11134,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);
       }
@@ -11153,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}`
@@ -11166,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,
@@ -12134,7 +12567,7 @@ var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
 var RUNNER_CREDENTIAL_SCOPES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels", "knowledge"];
 var RUNNER_CREDENTIAL_MINT_MAX_ATTEMPTS2 = 3;
 var RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2 = 250;
-var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
+var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -12170,9 +12603,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args, env = {}) {
+function parseDaemonCliArgs(args) {
   let serverUrl = "";
-  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
+  let apiKey = "";
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
     if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
@@ -12373,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));
@@ -12624,7 +13059,8 @@ var DaemonCore = class {
       msg.wakeMessage,
       msg.unreadSummary,
       msg.resumePrompt,
-      msg.launchId
+      msg.launchId,
+      msg.wakeMessageTransient ?? false
     );
   }
   handleMessage(msg) {
@@ -12675,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) {
@@ -12939,8 +13378,6 @@ var DaemonCore = class {
 };
 
 export {
-  DAEMON_API_KEY_ENV,
-  scrubDaemonAuthEnv,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,