@botiverse/raft-daemon 0.61.1 → 0.62.0

package/dist/{chunk-5JCAPBBM.js → chunk-H3G23UPM.js}

@@ -1288,6 +1288,9 @@ var SERVER_CAPABILITY_MATRIX = {
 
 // ../shared/src/index.ts
 var RUNTIME_CONFIG_VERSION = 1;
+var PI_BUILTIN_PROVIDER_ENV_KEYS = {
+  deepseek: "DEEPSEEK_API_KEY"
+};
 var AGENT_ACTIVITIES = ["online", "thinking", "working", "error", "offline"];
 var isAgentActivity = makeIsMember(AGENT_ACTIVITIES);
 var VALID_ACTIVITIES = new Set(AGENT_ACTIVITIES);
@@ -1392,7 +1395,12 @@ function getDefaultModel(runtimeId) {
   return models?.[0]?.id ?? "sonnet";
 }
 var CONTROLLED_RUNTIME_ENV_KEYS = {
-  claude: ["ANTHROPIC_BASE_URL", "ANTHROPIC_API_KEY", "ANTHROPIC_CUSTOM_MODEL_OPTION"]
+  claude: ["ANTHROPIC_BASE_URL", "ANTHROPIC_API_KEY", "ANTHROPIC_CUSTOM_MODEL_OPTION"],
+  // Pi-runtime builtin-provider env vars (e.g. DEEPSEEK_API_KEY). Owned by
+  // RuntimeProviderConfig.pi-builtin → runtimeConfigToLaunchFields, not by
+  // user-supplied envVars: reading from PI_BUILTIN_PROVIDER_ENV_KEYS keeps
+  // this list in sync as new providers are added.
+  pi: Object.values(PI_BUILTIN_PROVIDER_ENV_KEYS)
 };
 function isPlainRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -1426,15 +1434,24 @@ function modelConfigFromLegacy(runtime, model) {
   return isPresetRuntimeModel(runtime, model) ? { kind: "preset", id: model } : { kind: "custom", name: model };
 }
 function parseProviderConfig(runtime, value, legacyApiUrl, legacyApiKey) {
-  if (runtime !== "claude") return void 0;
-  if (!isPlainRecord(value)) return { kind: "default" };
-  if (value.kind === "custom" && typeof value.apiUrl === "string" && value.apiUrl.trim() && typeof value.apiKey === "string" && value.apiKey.trim()) {
-    return { kind: "custom", apiUrl: value.apiUrl.trim(), apiKey: value.apiKey.trim() };
+  if (runtime === "claude") {
+    if (!isPlainRecord(value)) return { kind: "default" };
+    if (value.kind === "custom" && typeof value.apiUrl === "string" && value.apiUrl.trim() && typeof value.apiKey === "string" && value.apiKey.trim()) {
+      return { kind: "custom", apiUrl: value.apiUrl.trim(), apiKey: value.apiKey.trim() };
+    }
+    if (value.kind === "custom" && legacyApiUrl?.trim() && legacyApiKey?.trim()) {
+      return { kind: "custom", apiUrl: legacyApiUrl.trim(), apiKey: legacyApiKey.trim() };
+    }
+    return { kind: "default" };
   }
-  if (value.kind === "custom" && legacyApiUrl?.trim() && legacyApiKey?.trim()) {
-    return { kind: "custom", apiUrl: legacyApiUrl.trim(), apiKey: legacyApiKey.trim() };
+  if (runtime === "pi") {
+    if (!isPlainRecord(value)) return { kind: "default" };
+    if (value.kind === "pi-builtin" && typeof value.providerId === "string" && value.providerId.trim() && typeof value.apiKey === "string" && value.apiKey.trim() && Object.prototype.hasOwnProperty.call(PI_BUILTIN_PROVIDER_ENV_KEYS, value.providerId.trim())) {
+      return { kind: "pi-builtin", providerId: value.providerId.trim(), apiKey: value.apiKey.trim() };
+    }
+    return { kind: "default" };
   }
-  return { kind: "default" };
+  return void 0;
 }
 function parseModelConfig(runtime, value, fallback, provider, legacyCustomModel) {
   if (!isPlainRecord(value)) return modelConfigFromLegacy(runtime, fallback);
@@ -1496,6 +1513,10 @@ function runtimeConfigToLaunchFields(config) {
       generatedEnvVars.ANTHROPIC_CUSTOM_MODEL_OPTION = normalized.model.name;
     }
   }
+  if (normalized.runtime === "pi" && normalized.provider?.kind === "pi-builtin") {
+    const envKey = PI_BUILTIN_PROVIDER_ENV_KEYS[normalized.provider.providerId];
+    if (envKey) generatedEnvVars[envKey] = normalized.provider.apiKey;
+  }
   const envVars = {
     ...normalized.envVars ?? {},
     ...generatedEnvVars
@@ -1512,7 +1533,7 @@ function runtimeConfigToLaunchFields(config) {
 var PLAN_CONFIG = {
   free: {
     displayName: "Free",
-    limits: { maxMachines: 2, maxAgents: 5, maxChannels: 5, messageHistoryDays: 30, includedAgents: 5 },
+    limits: { maxMachines: -1, maxAgents: -1, maxChannels: -1, messageHistoryDays: 30, includedAgents: -1 },
     comingSoon: false,
     price: 0,
     extraAgentPrice: 0,
@@ -1532,13 +1553,20 @@ var PLAN_CONFIG = {
     comingSoon: false,
     price: 0,
     extraAgentPrice: 0
+  },
+  pro: {
+    displayName: "Pro",
+    limits: { maxMachines: -1, maxAgents: 10, maxChannels: -1, messageHistoryDays: -1, includedAgents: 10 },
+    comingSoon: false,
+    price: 20,
+    extraAgentPrice: 0
   }
 };
 var DISPLAY_PLAN_CONFIG = {
   free: PLAN_CONFIG.free,
   pro: {
     displayName: "Pro",
-    limits: { maxMachines: -1, maxAgents: 10, maxChannels: -1, messageHistoryDays: -1, includedAgents: 10 },
+    limits: { maxMachines: -1, maxAgents: -1, maxChannels: -1, messageHistoryDays: -1, includedAgents: -1 },
     comingSoon: false,
     price: 20,
     priceCadence: "/ seat pack / month",
@@ -1568,14 +1596,406 @@ var DISPLAY_PLAN_CONFIG = {
     ]
   }
 };
+var FREE_MONTHLY_FILE_UPLOAD_LIMIT_BYTES = 100 * 1024 * 1024;
 
 // src/agentProcessManager.ts
-import { mkdirSync as mkdirSync5, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync4 } from "fs";
-import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
-import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync4 } from "fs";
+import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2, lstat, realpath, open } from "fs/promises";
+import { createHash as createHash3, randomUUID as randomUUID5 } from "crypto";
 import path13 from "path";
+import { gzipSync } from "zlib";
 import os6 from "os";
 
+// src/proxy.ts
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { ProxyAgent } from "undici";
+var fetchDispatcherCache = /* @__PURE__ */ new Map();
+function getFetchPreResponseTimeoutMs(env) {
+  const parsed = Number.parseInt(env.SLOCK_DAEMON_FETCH_PRE_RESPONSE_TIMEOUT_MS || "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 3e4;
+}
+function getDefaultPort(protocol) {
+  switch (protocol) {
+    case "https:":
+    case "wss:":
+      return "443";
+    case "http:":
+    case "ws:":
+      return "80";
+    default:
+      return "";
+  }
+}
+function hostMatchesNoProxyEntry(hostname, ruleHost) {
+  if (!ruleHost) return false;
+  const normalizedRule = ruleHost.replace(/^\*\./, ".").replace(/^\./, "").toLowerCase();
+  const normalizedHost = hostname.toLowerCase();
+  return normalizedHost === normalizedRule || normalizedHost.endsWith(`.${normalizedRule}`);
+}
+function getProxyUrlForTarget(targetUrl, env) {
+  const protocol = new URL(targetUrl).protocol;
+  switch (protocol) {
+    case "wss:":
+      return env.WSS_PROXY || env.wss_proxy || env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
+    case "ws:":
+      return env.WS_PROXY || env.ws_proxy || env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
+    case "https:":
+      return env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
+    case "http:":
+      return env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
+    default:
+      return env.ALL_PROXY || env.all_proxy;
+  }
+}
+function shouldBypassProxy(targetUrl, env) {
+  const rawNoProxy = env.NO_PROXY || env.no_proxy;
+  if (!rawNoProxy) return false;
+  const url = new URL(targetUrl);
+  const hostname = url.hostname.toLowerCase();
+  const port = url.port || getDefaultPort(url.protocol);
+  return rawNoProxy.split(",").map((entry) => entry.trim()).filter(Boolean).some((entry) => {
+    if (entry === "*") return true;
+    const [ruleHost, rulePort] = entry.split(":", 2);
+    if (rulePort && rulePort !== port) return false;
+    return hostMatchesNoProxyEntry(hostname, ruleHost);
+  });
+}
+function buildWebSocketOptions(wsUrl, env) {
+  const proxyUrl = getProxyUrlForTarget(wsUrl, env);
+  if (!proxyUrl) return void 0;
+  if (shouldBypassProxy(wsUrl, env)) return void 0;
+  return {
+    agent: new HttpsProxyAgent(proxyUrl)
+  };
+}
+function resolveProxyUrl(targetUrl, env) {
+  const proxyUrl = getProxyUrlForTarget(targetUrl, env);
+  if (!proxyUrl) return void 0;
+  if (shouldBypassProxy(targetUrl, env)) return void 0;
+  return proxyUrl;
+}
+function buildFetchDispatcher(targetUrl, env) {
+  const proxyUrl = resolveProxyUrl(targetUrl, env);
+  if (!proxyUrl) return void 0;
+  const cached = fetchDispatcherCache.get(proxyUrl);
+  if (cached) return cached;
+  const timeoutMs = getFetchPreResponseTimeoutMs(env);
+  const dispatcher = new ProxyAgent({
+    uri: proxyUrl,
+    // All three are pre-response and body-agnostic (see getFetchPreResponseTimeoutMs):
+    // headersTimeout = headers-hang leg; requestTls.timeout = CONNECT-tunnel
+    // establish leg; connect.timeout = socket to the proxy itself (defensive).
+    connect: { timeout: timeoutMs },
+    requestTls: { timeout: timeoutMs },
+    headersTimeout: timeoutMs
+  });
+  fetchDispatcherCache.set(proxyUrl, dispatcher);
+  return dispatcher;
+}
+function evictFetchDispatcher(targetUrl, env) {
+  const proxyUrl = resolveProxyUrl(targetUrl, env);
+  if (!proxyUrl) return false;
+  const cached = fetchDispatcherCache.get(proxyUrl);
+  if (!cached) return false;
+  fetchDispatcherCache.delete(proxyUrl);
+  void Promise.resolve().then(() => cached.close()).catch(() => cached.destroy?.(new Error("evicted"))).catch(() => {
+  });
+  return true;
+}
+
+// src/daemonFetch.ts
+function withDaemonFetchProxy(input, init = {}, env = process.env) {
+  const dispatcher = buildFetchDispatcher(input.toString(), env);
+  return dispatcher ? { ...init, dispatcher } : init;
+}
+async function daemonFetch(input, init, env = process.env) {
+  try {
+    return await fetch(input, withDaemonFetchProxy(input, init, env));
+  } catch (err) {
+    evictFetchDispatcher(input.toString(), env);
+    throw err;
+  }
+}
+
+// src/attachmentFormatting.ts
+function attachmentDownloadHint(style = "slock_cli") {
+  switch (style) {
+    case "slock_cli":
+      return "use `raft attachment view --id <attachmentId> --output <path>` to download";
+    case "mcp_tool":
+      return "use view_file to download";
+  }
+}
+function formatAttachmentSuffix(attachments, style = "slock_cli") {
+  if (!attachments?.length) return "";
+  const attachmentList = attachments.map((attachment) => `${attachment.filename} (id:${attachment.id})`).join(", ");
+  return ` [${attachments.length} attachment${attachments.length > 1 ? "s" : ""}: ${attachmentList} \u2014 ${attachmentDownloadHint(style)}]`;
+}
+
+// src/logger.ts
+var listeners = /* @__PURE__ */ new Set();
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function format(level, msg) {
+  return `${timestamp()} [${level}] ${msg}`;
+}
+function emit(event) {
+  for (const listener of listeners) {
+    listener(event);
+  }
+}
+function subscribeDaemonLogs(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+var logger = {
+  info(msg) {
+    const line = format("INFO", msg);
+    console.log(line);
+    emit({ level: "INFO", line, message: msg });
+  },
+  warn(msg) {
+    const line = format("WARN", msg);
+    console.warn(line);
+    emit({ level: "WARN", line, message: msg });
+  },
+  error(msg, err) {
+    const line = format("ERROR", msg);
+    if (err) {
+      console.error(line, err);
+    } else {
+      console.error(line);
+    }
+    emit({ level: "ERROR", line, message: msg, error: err });
+  }
+};
+
+// src/chatBridgeRequest.ts
+var DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS = Number.parseInt(
+  process.env.SLOCK_CHAT_BRIDGE_TOOL_TIMEOUT_MS || "",
+  10
+) || 6e4;
+var ChatBridgeToolTimeoutError = class extends Error {
+  toolName;
+  target;
+  timeoutMs;
+  durationMs;
+  constructor(toolName, target, timeoutMs, durationMs) {
+    super(`${toolName} timed out after ${timeoutMs}ms${target ? ` (target: ${target})` : ""}`);
+    this.name = "ChatBridgeToolTimeoutError";
+    this.toolName = toolName;
+    this.target = target;
+    this.timeoutMs = timeoutMs;
+    this.durationMs = durationMs;
+  }
+};
+function describeError(err) {
+  if (err instanceof Error) return `${err.name}: ${err.message}`;
+  return String(err);
+}
+async function executeJsonRequest(url, init, {
+  toolName,
+  target = null,
+  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
+  fetchImpl,
+  now = () => Date.now(),
+  warn = (message) => logger.warn(message)
+}) {
+  const startedAt = now();
+  const timeoutController = new AbortController();
+  const signals = [timeoutController.signal];
+  if (init.signal) signals.push(init.signal);
+  const signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+  const timeout = setTimeout(() => {
+    timeoutController.abort();
+  }, timeoutMs);
+  timeout.unref?.();
+  try {
+    const response = await fetchImpl(url, { ...init, signal });
+    const data = await response.json();
+    return { response, data, durationMs: now() - startedAt };
+  } catch (err) {
+    const durationMs = now() - startedAt;
+    if (timeoutController.signal.aborted && !init.signal?.aborted) {
+      warn(
+        `[ChatBridgeTimeout] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} timeout_ms=${timeoutMs} outcome=timeout`
+      );
+      throw new ChatBridgeToolTimeoutError(toolName, target, timeoutMs, durationMs);
+    }
+    warn(
+      `[ChatBridgeError] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} outcome=error error=${describeError(err)}`
+    );
+    throw err;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function executeResponseRequest(url, init, {
+  toolName,
+  target = null,
+  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
+  fetchImpl,
+  now = () => Date.now(),
+  warn = (message) => logger.warn(message)
+}) {
+  const startedAt = now();
+  const timeoutController = new AbortController();
+  const signals = [timeoutController.signal];
+  if (init.signal) signals.push(init.signal);
+  const signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+  const timeout = setTimeout(() => {
+    timeoutController.abort();
+  }, timeoutMs);
+  timeout.unref?.();
+  try {
+    const response = await fetchImpl(url, { ...init, signal });
+    return { response, durationMs: now() - startedAt };
+  } catch (err) {
+    const durationMs = now() - startedAt;
+    if (timeoutController.signal.aborted && !init.signal?.aborted) {
+      warn(
+        `[ChatBridgeTimeout] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} timeout_ms=${timeoutMs} outcome=timeout`
+      );
+      throw new ChatBridgeToolTimeoutError(toolName, target, timeoutMs, durationMs);
+    }
+    warn(
+      `[ChatBridgeError] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} outcome=error error=${describeError(err)}`
+    );
+    throw err;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// src/directUploadCapability.ts
+function joinUrl(base, path18) {
+  return `${base.replace(/\/+$/, "")}${path18}`;
+}
+function jsonHeaders(apiKey) {
+  return {
+    "Content-Type": "application/json",
+    ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+  };
+}
+async function requestDaemonScopeAttestation({
+  serverUrl,
+  apiKey,
+  scope,
+  metadata,
+  fetchImpl = daemonFetch,
+  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS
+}) {
+  const { response, data } = await executeJsonRequest(
+    joinUrl(serverUrl, "/internal/machine/scope-attestation"),
+    {
+      method: "POST",
+      headers: jsonHeaders(apiKey),
+      body: JSON.stringify({
+        scope,
+        ...metadata ? { metadata } : {}
+      })
+    },
+    {
+      toolName: "daemon_direct_upload.scope_attestation",
+      target: scope,
+      timeoutMs,
+      fetchImpl
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to request daemon scope attestation (${response.status})`);
+  }
+  return data;
+}
+async function createDirectUploadSession({
+  serverUrl,
+  apiKey,
+  workerUrl,
+  scope,
+  createPath = "/api/uploads",
+  body,
+  attestationMetadata,
+  fetchImpl = daemonFetch,
+  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS
+}) {
+  const capability = await requestDaemonScopeAttestation({
+    serverUrl,
+    apiKey,
+    scope,
+    metadata: attestationMetadata,
+    fetchImpl,
+    timeoutMs
+  });
+  const { response, data } = await executeJsonRequest(
+    joinUrl(workerUrl, createPath),
+    {
+      method: "POST",
+      headers: jsonHeaders(),
+      body: JSON.stringify({
+        ...body,
+        attestation: capability.attestation
+      })
+    },
+    {
+      toolName: "daemon_direct_upload.create",
+      target: capability.audience,
+      timeoutMs,
+      fetchImpl
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to create direct upload session (${response.status})`);
+  }
+  return { capability, response: data };
+}
+async function uploadWithSignedCapability({
+  serverUrl,
+  apiKey,
+  workerUrl,
+  scope,
+  createPath = "/api/uploads",
+  createBody,
+  attestationMetadata,
+  uploadBody,
+  fetchImpl = daemonFetch,
+  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS
+}) {
+  const { capability, response: session } = await createDirectUploadSession({
+    serverUrl,
+    apiKey,
+    workerUrl,
+    scope,
+    createPath,
+    body: createBody,
+    attestationMetadata,
+    fetchImpl,
+    timeoutMs
+  });
+  const { response: uploadResponse } = await executeResponseRequest(
+    session.upload.url,
+    {
+      method: session.upload.method,
+      headers: session.upload.headers ?? {},
+      body: uploadBody
+    },
+    {
+      toolName: "daemon_direct_upload.put",
+      target: capability.audience,
+      timeoutMs,
+      fetchImpl
+    }
+  );
+  if (!uploadResponse.ok) {
+    throw new Error(`Failed to upload with signed capability (${uploadResponse.status})`);
+  }
+  return { capability, session, uploadResponse };
+}
+
 // src/drivers/claude.ts
 import { spawn } from "child_process";
 
@@ -2170,6 +2590,9 @@ import { URL as URL2 } from "url";
 // src/apmStateMachine.ts
 import { createHash } from "crypto";
 var MAX_APM_GATED_STEERING_EVENTS = 12;
+function reviewStatePatch(state) {
+  return state.reviewing !== void 0 ? { reviewing: state.reviewing } : {};
+}
 function createInitialApmGatedSteeringState() {
   return {
     isIdle: false,
@@ -2182,6 +2605,22 @@ function createInitialApmGatedSteeringState() {
     recentEvents: []
   };
 }
+function commitApmGatedSteeringDecisionState(nextState) {
+  const committed = {
+    isIdle: nextState.isIdle,
+    expectedTerminationReason: nextState.expectedTerminationReason,
+    phase: nextState.phase,
+    outstandingToolUses: nextState.outstandingToolUses,
+    compacting: nextState.compacting,
+    toolBoundaryFlushDisabled: nextState.toolBoundaryFlushDisabled,
+    lastFlushReason: nextState.lastFlushReason,
+    recentEvents: [...nextState.recentEvents]
+  };
+  if (nextState.reviewing !== void 0) {
+    committed.reviewing = nextState.reviewing;
+  }
+  return committed;
+}
 function reduceApmIdleState(state, input) {
   return {
     nextState: {
@@ -2199,6 +2638,7 @@ function reduceApmGatedToolUse(state, input) {
         phase: "tool_wait",
         outstandingToolUses: state.outstandingToolUses + 1,
         compacting: state.compacting,
+        ...reviewStatePatch(state),
         toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
         lastFlushReason: state.lastFlushReason,
         recentEvents: state.recentEvents
@@ -2216,6 +2656,7 @@ function reduceApmGatedToolUse(state, input) {
       phase: "tool_boundary",
       outstandingToolUses,
       compacting: state.compacting,
+      ...reviewStatePatch(state),
       toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
       lastFlushReason: state.lastFlushReason,
       recentEvents: state.recentEvents
@@ -2233,20 +2674,52 @@ function reduceApmGatedCompaction(state, input) {
         phase: "compacting",
         outstandingToolUses: state.outstandingToolUses,
         compacting: true,
+        ...reviewStatePatch(state),
+        toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
+        lastFlushReason: state.lastFlushReason,
+        recentEvents: state.recentEvents
+      }
+    };
+  }
+  if (input.kind === "compaction_interrupted") {
+    return {
+      nextState: {
+        isIdle: false,
+        expectedTerminationReason: state.expectedTerminationReason,
+        phase: state.phase,
+        outstandingToolUses: state.outstandingToolUses,
+        compacting: false,
+        ...reviewStatePatch(state),
         toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
         lastFlushReason: state.lastFlushReason,
         recentEvents: state.recentEvents
       }
     };
   }
-  if (input.kind === "compaction_interrupted") {
+  return {
+    nextState: {
+      isIdle: false,
+      expectedTerminationReason: state.expectedTerminationReason,
+      phase: "assistant_continuation",
+      outstandingToolUses: state.outstandingToolUses,
+      compacting: false,
+      ...reviewStatePatch(state),
+      toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
+      lastFlushReason: state.lastFlushReason,
+      recentEvents: state.recentEvents
+    }
+  };
+}
+function reduceApmGatedReview(state, input) {
+  if (input.kind === "review_started") {
     return {
       nextState: {
         isIdle: false,
         expectedTerminationReason: state.expectedTerminationReason,
-        phase: state.phase,
+        phase: "reviewing",
         outstandingToolUses: state.outstandingToolUses,
-        compacting: false,
+        compacting: state.compacting,
+        reviewing: true,
         toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
         lastFlushReason: state.lastFlushReason,
         recentEvents: state.recentEvents
@@ -2259,7 +2732,8 @@ function reduceApmGatedCompaction(state, input) {
       expectedTerminationReason: state.expectedTerminationReason,
       phase: "assistant_continuation",
       outstandingToolUses: state.outstandingToolUses,
-      compacting: false,
+      compacting: state.compacting,
+      reviewing: false,
       toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
       lastFlushReason: state.lastFlushReason,
       recentEvents: state.recentEvents
@@ -2280,6 +2754,20 @@ function reduceApmGatedCompactionBoundaryFlush(_state, input) {
     }]
   };
 }
+function reduceApmGatedReviewBoundaryFlush(_state, input) {
+  if (!input.hasSession || !input.supportsStdinNotification || input.inboxLength === 0) {
+    return { effects: [] };
+  }
+  if (input.pendingNotificationCount === 0) return { effects: [] };
+  return {
+    effects: [{
+      kind: "notify_stdin",
+      reason: "review_finished",
+      stdinMode: "busy",
+      clauseId: "SMR-002"
+    }]
+  };
+}
 function reduceApmGatedTurnEnd(_state, input = {}) {
   const shouldDeliverQueuedMessages = Boolean(
     input.inboxLength && input.inboxLength > 0 && input.supportsStdinNotification && input.hasSession
@@ -2291,6 +2779,7 @@ function reduceApmGatedTurnEnd(_state, input = {}) {
       phase: "idle",
       outstandingToolUses: 0,
       compacting: false,
+      ..._state.reviewing !== void 0 ? { reviewing: false } : {},
       toolBoundaryFlushDisabled: _state.toolBoundaryFlushDisabled,
       lastFlushReason: _state.lastFlushReason,
       recentEvents: _state.recentEvents
@@ -2312,6 +2801,7 @@ function reduceApmGatedError(state, input = {}) {
       phase: "error",
       outstandingToolUses: state.outstandingToolUses,
       compacting: false,
+      ...state.reviewing !== void 0 ? { reviewing: false } : {},
       toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled || shouldDisableToolBoundaryFlush,
       lastFlushReason: state.lastFlushReason,
       recentEvents: state.recentEvents
@@ -2327,6 +2817,7 @@ function reduceApmGatedAssistantContinuation(state) {
       phase: "assistant_continuation",
       outstandingToolUses: state.outstandingToolUses,
       compacting: state.compacting,
+      ...reviewStatePatch(state),
       toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
       lastFlushReason: state.lastFlushReason,
       recentEvents: state.recentEvents
@@ -2377,6 +2868,17 @@ function reduceApmStartupTimeoutTermination(state, input) {
     blockedReason: null
   };
 }
+function reduceApmStartupRequestErrorTermination(state) {
+  return {
+    nextState: {
+      ...state,
+      isIdle: false,
+      expectedTerminationReason: "startup_request_error",
+      phase: "error"
+    },
+    shouldTerminate: true
+  };
+}
 function reduceApmGatedFlush(state, input) {
   return {
     nextState: {
@@ -2386,7 +2888,8 @@ function reduceApmGatedFlush(state, input) {
   };
 }
 function reduceApmGatedRecentEvent(state, input) {
-  const summary = `${input.event}:${state.phase}:tools=${state.outstandingToolUses}:compact=${state.compacting}`;
+  const reviewSuffix = state.reviewing !== void 0 ? `:review=${state.reviewing === true}` : "";
+  const summary = `${input.event}:${state.phase}:tools=${state.outstandingToolUses}:compact=${state.compacting}${reviewSuffix}`;
   return {
     nextState: {
       ...state,
@@ -2394,6 +2897,154 @@ function reduceApmGatedRecentEvent(state, input) {
     }
   };
 }
+function projectApmRuntimeTerminationTrace(input) {
+  if (input.reason === "startup_timeout") {
+    const attrs = {
+      turn_outcome: "failed",
+      turn_subtype: "runtime_stalled",
+      turn_reason: "no_runtime_events",
+      runtime_start_failure_kind: "runtime_start_timeout",
+      timeout_ms: input.timeoutMs
+    };
+    return {
+      reason: input.reason,
+      runtimeEventName: "runtime.start.timeout",
+      runtimeEventAttrs: attrs,
+      runtimeSpanAttrs: attrs,
+      processExitAttrs: {
+        stop_source: "startup_timeout",
+        expectedTerminationReason: "startup_timeout",
+        timeout_ms: input.timeoutMs
+      },
+      runtimeStopReason: "startup_timeout"
+    };
+  }
+  if (input.reason === "turn_end") {
+    return {
+      reason: input.reason,
+      processExitAttrs: {
+        stop_source: "turn_end",
+        expectedTerminationReason: "turn_end"
+      },
+      runtimeStopReason: "turn_end"
+    };
+  }
+  const eventAttrs = {
+    turn_outcome: "failed",
+    turn_subtype: "runtime_stalled",
+    turn_reason: input.turnReason,
+    pendingMessages: input.pendingMessages,
+    recovery: input.recoveryAction
+  };
+  return {
+    reason: input.reason,
+    runtimeEventName: "runtime.progress.stalled",
+    runtimeEventAttrs: eventAttrs,
+    runtimeSpanAttrs: {
+      ...eventAttrs,
+      ageMs: input.staleForMs,
+      lastActivity: input.lastActivity,
+      lastActivityDetailPresent: input.lastActivityDetailPresent,
+      lastActivityDetailKind: input.lastActivityDetailKind
+    },
+    processExitAttrs: {
+      stop_source: "stalled_recovery",
+      expectedTerminationReason: "stalled_recovery",
+      queued_messages_count: input.pendingMessages
+    },
+    runtimeStopReason: "stalled_recovery"
+  };
+}
+function projectApmRuntimeProgressStalledTrace(input) {
+  const eventAttrs = {
+    turn_outcome: "failed",
+    turn_subtype: "runtime_stalled",
+    turn_reason: input.turnReason
+  };
+  return {
+    runtimeEventName: "runtime.progress.stalled",
+    runtimeEventAttrs: eventAttrs,
+    runtimeSpanAttrs: {
+      ...eventAttrs,
+      ageMs: input.staleForMs,
+      lastActivity: input.lastActivity,
+      lastActivityDetailPresent: input.lastActivityDetailPresent,
+      lastActivityDetailKind: input.lastActivityDetailKind
+    }
+  };
+}
+function projectApmRuntimeStallDiagnostic(input) {
+  const context = [];
+  const lastActivityDetailKind = classifyApmRuntimeStallActivityDetail(input.lastActivityDetail);
+  if (input.lastActivityDetail) {
+    context.push(`after ${input.lastActivityDetail}`);
+  }
+  if (input.runtimeDescriptorBusyDelivery === "gated") {
+    context.push(`phase=${input.gatedPhase}`);
+  }
+  if (input.outstandingToolUses > 0) {
+    context.push(`tools=${input.outstandingToolUses}`);
+  }
+  if (input.compacting) {
+    context.push("compacting");
+  }
+  if (input.reviewing) {
+    context.push("reviewing");
+  }
+  if (input.inboxCount > 0) {
+    context.push(`queued=${input.inboxCount}`);
+  }
+  const detail = [
+    `Runtime stalled: no runtime events for ${input.staleForMinutes}m`,
+    context.length > 0 ? ` (${context.join(", ")})` : ""
+  ].join("");
+  const turnReason = input.runtimeProgressLastEventKind === "tool_output" && input.outstandingToolUses === 0 ? "harness_post_tool_silent_wedge" : "no_runtime_events";
+  return {
+    detail,
+    turnReason,
+    lastActivityDetailPresent: Boolean(input.lastActivityDetail),
+    lastActivityDetailKind,
+    traceAttrs: {
+      ageMs: input.staleForMs,
+      staleForMinutes: input.staleForMinutes,
+      lastActivity: input.lastActivity,
+      lastActivityDetailPresent: Boolean(input.lastActivityDetail),
+      lastActivityDetailKind,
+      runtime: input.runtime,
+      model: input.model,
+      platform: input.platform,
+      arch: input.arch,
+      launchId: input.launchId || void 0,
+      sessionIdPresent: input.sessionIdPresent,
+      inboxCount: input.inboxCount,
+      pendingNotificationCount: input.pendingNotificationCount,
+      processPidPresent: input.processPidPresent,
+      busyDeliveryMode: input.driverBusyDeliveryMode,
+      supportsStdinNotification: input.supportsStdinNotification,
+      gatedPhase: input.runtimeDescriptorBusyDelivery === "gated" ? input.gatedPhase : void 0,
+      outstandingToolUses: input.outstandingToolUses,
+      compacting: input.compacting,
+      reviewing: input.reviewing === true ? true : void 0,
+      recentStderrCount: input.recentStderrCount,
+      recentStdoutCount: input.recentStdoutCount,
+      ...input.runtimeTraceCounterAttrs ?? {}
+    }
+  };
+}
+function classifyApmRuntimeStallActivityDetail(detail) {
+  if (!detail) return void 0;
+  if (detail === "Message received") return "message_received";
+  if (detail === "Starting\u2026") return "starting";
+  if (detail === "Running command\u2026") return "running_command";
+  if (detail === "Checking messages\u2026") return "checking_messages";
+  if (detail === "Compacting context") return "compacting_context";
+  if (detail === "Context compaction finished") return "compaction_finished";
+  if (detail === "Context compaction still running; no finish event observed") return "compaction_stale";
+  if (detail === "Idle" || detail === "Process idle") return "idle";
+  if (detail.startsWith("Restarting stalled ") && detail.endsWith(" runtime for queued message")) return "stalled_recovery";
+  if (detail.startsWith("Runtime stalled: no runtime events for ")) return "runtime_stalled";
+  return "other";
+}
 function reduceApmGatedFlushReadiness(state, input) {
   if (!input.isGated) return { shouldNotify: false, blockedReason: "non_gated", effects: [] };
   if (!input.hasSession) return { shouldNotify: false, blockedReason: "missing_session", effects: [] };
@@ -2402,6 +3053,7 @@ function reduceApmGatedFlushReadiness(state, input) {
     return { shouldNotify: false, blockedReason: "tool_boundary_flush_disabled", effects: [] };
   }
   if (state.compacting) return { shouldNotify: false, blockedReason: "compacting", effects: [] };
+  if (state.reviewing) return { shouldNotify: false, blockedReason: "reviewing", effects: [] };
   if (state.outstandingToolUses > 0) {
     return { shouldNotify: false, blockedReason: "outstanding_tool_uses", effects: [] };
   }
@@ -2894,162 +3546,8 @@ function stripUndefined(value) {
   for (const key of Object.keys(value)) {
     if (value[key] === void 0) delete value[key];
   }
-  return value;
-}
-
-// src/proxy.ts
-import { HttpsProxyAgent } from "https-proxy-agent";
-import { ProxyAgent } from "undici";
-var fetchDispatcherCache = /* @__PURE__ */ new Map();
-function getFetchPreResponseTimeoutMs(env) {
-  const parsed = Number.parseInt(env.SLOCK_DAEMON_FETCH_PRE_RESPONSE_TIMEOUT_MS || "", 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 3e4;
-}
-function getDefaultPort(protocol) {
-  switch (protocol) {
-    case "https:":
-    case "wss:":
-      return "443";
-    case "http:":
-    case "ws:":
-      return "80";
-    default:
-      return "";
-  }
-}
-function hostMatchesNoProxyEntry(hostname, ruleHost) {
-  if (!ruleHost) return false;
-  const normalizedRule = ruleHost.replace(/^\*\./, ".").replace(/^\./, "").toLowerCase();
-  const normalizedHost = hostname.toLowerCase();
-  return normalizedHost === normalizedRule || normalizedHost.endsWith(`.${normalizedRule}`);
-}
-function getProxyUrlForTarget(targetUrl, env) {
-  const protocol = new URL(targetUrl).protocol;
-  switch (protocol) {
-    case "wss:":
-      return env.WSS_PROXY || env.wss_proxy || env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
-    case "ws:":
-      return env.WS_PROXY || env.ws_proxy || env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
-    case "https:":
-      return env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
-    case "http:":
-      return env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
-    default:
-      return env.ALL_PROXY || env.all_proxy;
-  }
-}
-function shouldBypassProxy(targetUrl, env) {
-  const rawNoProxy = env.NO_PROXY || env.no_proxy;
-  if (!rawNoProxy) return false;
-  const url = new URL(targetUrl);
-  const hostname = url.hostname.toLowerCase();
-  const port = url.port || getDefaultPort(url.protocol);
-  return rawNoProxy.split(",").map((entry) => entry.trim()).filter(Boolean).some((entry) => {
-    if (entry === "*") return true;
-    const [ruleHost, rulePort] = entry.split(":", 2);
-    if (rulePort && rulePort !== port) return false;
-    return hostMatchesNoProxyEntry(hostname, ruleHost);
-  });
-}
-function buildWebSocketOptions(wsUrl, env) {
-  const proxyUrl = getProxyUrlForTarget(wsUrl, env);
-  if (!proxyUrl) return void 0;
-  if (shouldBypassProxy(wsUrl, env)) return void 0;
-  return {
-    agent: new HttpsProxyAgent(proxyUrl)
-  };
-}
-function resolveProxyUrl(targetUrl, env) {
-  const proxyUrl = getProxyUrlForTarget(targetUrl, env);
-  if (!proxyUrl) return void 0;
-  if (shouldBypassProxy(targetUrl, env)) return void 0;
-  return proxyUrl;
-}
-function buildFetchDispatcher(targetUrl, env) {
-  const proxyUrl = resolveProxyUrl(targetUrl, env);
-  if (!proxyUrl) return void 0;
-  const cached = fetchDispatcherCache.get(proxyUrl);
-  if (cached) return cached;
-  const timeoutMs = getFetchPreResponseTimeoutMs(env);
-  const dispatcher = new ProxyAgent({
-    uri: proxyUrl,
-    // All three are pre-response and body-agnostic (see getFetchPreResponseTimeoutMs):
-    // headersTimeout = headers-hang leg; requestTls.timeout = CONNECT-tunnel
-    // establish leg; connect.timeout = socket to the proxy itself (defensive).
-    connect: { timeout: timeoutMs },
-    requestTls: { timeout: timeoutMs },
-    headersTimeout: timeoutMs
-  });
-  fetchDispatcherCache.set(proxyUrl, dispatcher);
-  return dispatcher;
-}
-function evictFetchDispatcher(targetUrl, env) {
-  const proxyUrl = resolveProxyUrl(targetUrl, env);
-  if (!proxyUrl) return false;
-  const cached = fetchDispatcherCache.get(proxyUrl);
-  if (!cached) return false;
-  fetchDispatcherCache.delete(proxyUrl);
-  void Promise.resolve().then(() => cached.close()).catch(() => cached.destroy?.(new Error("evicted"))).catch(() => {
-  });
-  return true;
-}
-
-// src/daemonFetch.ts
-function withDaemonFetchProxy(input, init = {}, env = process.env) {
-  const dispatcher = buildFetchDispatcher(input.toString(), env);
-  return dispatcher ? { ...init, dispatcher } : init;
-}
-async function daemonFetch(input, init, env = process.env) {
-  try {
-    return await fetch(input, withDaemonFetchProxy(input, init, env));
-  } catch (err) {
-    evictFetchDispatcher(input.toString(), env);
-    throw err;
-  }
-}
-
-// src/logger.ts
-var listeners = /* @__PURE__ */ new Set();
-function timestamp() {
-  const d = /* @__PURE__ */ new Date();
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-}
-function format(level, msg) {
-  return `${timestamp()} [${level}] ${msg}`;
-}
-function emit(event) {
-  for (const listener of listeners) {
-    listener(event);
-  }
-}
-function subscribeDaemonLogs(listener) {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-}
-var logger = {
-  info(msg) {
-    const line = format("INFO", msg);
-    console.log(line);
-    emit({ level: "INFO", line, message: msg });
-  },
-  warn(msg) {
-    const line = format("WARN", msg);
-    console.warn(line);
-    emit({ level: "WARN", line, message: msg });
-  },
-  error(msg, err) {
-    const line = format("ERROR", msg);
-    if (err) {
-      console.error(line, err);
-    } else {
-      console.error(line);
-    }
-    emit({ level: "ERROR", line, message: msg, error: err });
-  }
-};
+  return value;
+}
 
 // src/agentCredentialProxy.ts
 var registrations = /* @__PURE__ */ new Map();
@@ -3869,7 +4367,8 @@ async function prepareCliTransport(ctx, extraEnv = {}, platform = process.platfo
   }
   const posixWrapper = path2.join(slockDir, "slock");
   const posixRaftWrapper = path2.join(slockDir, "raft");
-  const posixCredentialPrefix = agentCredentialProxy ? `SLOCK_AGENT_PROXY_URL=${shellSingleQuote(agentCredentialProxy.proxyUrl)} SLOCK_AGENT_PROXY_TOKEN_FILE=${shellSingleQuote(agentCredentialProxyTokenFile)} SLOCK_AGENT_ACTIVE_CAPABILITIES=${shellSingleQuote(DEFAULT_ACTIVE_CAPABILITIES)} ` : "";
+  const posixIdentityPrefix = `SLOCK_AGENT_ID=${shellSingleQuote(ctx.agentId)} SLOCK_SERVER_URL=${shellSingleQuote(ctx.config.serverUrl)} `;
+  const posixCredentialPrefix = posixIdentityPrefix + (agentCredentialProxy ? `SLOCK_AGENT_PROXY_URL=${shellSingleQuote(agentCredentialProxy.proxyUrl)} SLOCK_AGENT_PROXY_TOKEN_FILE=${shellSingleQuote(agentCredentialProxyTokenFile)} SLOCK_AGENT_ACTIVE_CAPABILITIES=${shellSingleQuote(DEFAULT_ACTIVE_CAPABILITIES)} ` : `SLOCK_AGENT_TOKEN_FILE=${shellSingleQuote(tokenFile)} `);
   const posixCliFallbackBlock = cliPath === "__cli" || cliFallbackCandidates.length === 0 ? "" : `if [ ! -e "$SLOCK_CLI" ]; then
 ${cliFallbackCandidates.map((candidate, i) => `  ${i === 0 ? "if" : "elif"} [ -e ${shellSingleQuote(candidate)} ]; then SLOCK_CLI=${shellSingleQuote(candidate)};`).join("\n")}
   fi
@@ -3885,10 +4384,14 @@ ${posixCliFallbackBlock}${posixCredentialPrefix}exec ${shellSingleQuote(process.
   if (platform === "win32") {
     const cmdWrapper = path2.join(slockDir, "slock.cmd");
     const cmdRaftWrapper = path2.join(slockDir, "raft.cmd");
-    const cmdCredentialLine = agentCredentialProxy ? `set "SLOCK_AGENT_PROXY_URL=${agentCredentialProxy.proxyUrl}"\r
+    const cmdIdentityLines = `set "SLOCK_AGENT_ID=${ctx.agentId}"\r
+set "SLOCK_SERVER_URL=${ctx.config.serverUrl}"\r
+`;
+    const cmdCredentialLine = cmdIdentityLines + (agentCredentialProxy ? `set "SLOCK_AGENT_PROXY_URL=${agentCredentialProxy.proxyUrl}"\r
 set "SLOCK_AGENT_PROXY_TOKEN_FILE=${agentCredentialProxyTokenFile}"\r
 set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
-` : "";
+` : `set "SLOCK_AGENT_TOKEN_FILE=${tokenFile}"\r
+`);
     const cmdCliFallbackLines = cliPath === "__cli" ? [] : cliFallbackCandidates.map((candidate) => `if not exist "%SLOCK_CLI%" set "SLOCK_CLI=${candidate}"`);
     const cmdBody = [
       "@echo off",
@@ -3908,11 +4411,20 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
     writeFileSync(cmdRaftWrapper, cmdBody);
     const psWrapper = path2.join(slockDir, "slock.ps1");
     const psRaftWrapper = path2.join(slockDir, "raft.ps1");
-    const psCredentialLines = agentCredentialProxy ? [
-      `$env:SLOCK_AGENT_PROXY_URL=${powershellSingleQuote(agentCredentialProxy.proxyUrl)}`,
-      `$env:SLOCK_AGENT_PROXY_TOKEN_FILE=${powershellSingleQuote(agentCredentialProxyTokenFile)}`,
-      `$env:SLOCK_AGENT_ACTIVE_CAPABILITIES=${powershellSingleQuote(DEFAULT_ACTIVE_CAPABILITIES)}`
-    ] : [];
+    const psIdentityLines = [
+      `$env:SLOCK_AGENT_ID=${powershellSingleQuote(ctx.agentId)}`,
+      `$env:SLOCK_SERVER_URL=${powershellSingleQuote(ctx.config.serverUrl)}`
+    ];
+    const psCredentialLines = [
+      ...psIdentityLines,
+      ...agentCredentialProxy ? [
+        `$env:SLOCK_AGENT_PROXY_URL=${powershellSingleQuote(agentCredentialProxy.proxyUrl)}`,
+        `$env:SLOCK_AGENT_PROXY_TOKEN_FILE=${powershellSingleQuote(agentCredentialProxyTokenFile)}`,
+        `$env:SLOCK_AGENT_ACTIVE_CAPABILITIES=${powershellSingleQuote(DEFAULT_ACTIVE_CAPABILITIES)}`
+      ] : [
+        `$env:SLOCK_AGENT_TOKEN_FILE=${powershellSingleQuote(tokenFile)}`
+      ]
+    ];
     const psBody = [
       "$ErrorActionPreference = 'Stop'",
       "$utf8NoBom = [System.Text.UTF8Encoding]::new($false)",
@@ -4663,7 +5175,7 @@ var ClaudeDriver = class {
 };
 
 // src/drivers/codex.ts
-import { spawn as spawn2, execFileSync as execFileSync2, execSync } from "child_process";
+import { spawn as spawn2, execFileSync as execFileSync2 } from "child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
 import os3 from "os";
 import path6 from "path";
@@ -4671,6 +5183,7 @@ import path6 from "path";
 // src/runtimeTurnState.ts
 var RuntimeTurnState = class {
   currentTurnId = null;
+  pendingTurnId = null;
   /**
    * Post-tool window where the app-server may not yet accept stdin steering.
    * Gate busy-mode delivery until turn/completed or next progress.
@@ -4678,22 +5191,25 @@ var RuntimeTurnState = class {
   steeringGateActive = false;
   reset() {
     this.currentTurnId = null;
+    this.pendingTurnId = null;
     this.steeringGateActive = false;
   }
   get activeTurnId() {
     return this.currentTurnId;
   }
   get canSteerBusy() {
-    return Boolean(this.currentTurnId && !this.steeringGateActive);
+    return Boolean(this.currentTurnId && !this.pendingTurnId && !this.steeringGateActive);
   }
   markTurnStarted(turnId) {
-    if (turnId !== void 0 && turnId !== null) {
-      this.currentTurnId = turnId;
+    const startedTurnId = turnId ?? this.pendingTurnId;
+    if (startedTurnId) {
+      this.currentTurnId = startedTurnId;
     }
+    this.pendingTurnId = null;
     this.steeringGateActive = false;
   }
-  adoptTurnId(turnId) {
-    this.currentTurnId = turnId;
+  noteTurnAccepted(turnId) {
+    this.pendingTurnId = turnId;
   }
   markProgress() {
     this.steeringGateActive = false;
@@ -4703,6 +5219,7 @@ var RuntimeTurnState = class {
   }
   markTurnCompleted() {
     this.currentTurnId = null;
+    this.pendingTurnId = null;
     this.steeringGateActive = false;
   }
 };
@@ -4797,27 +5314,79 @@ function getCodexNotificationErrorMessage(params) {
   }
   return null;
 }
-function joinReasoningText(item) {
+function payloadBytes(value) {
+  try {
+    return Buffer.byteLength(JSON.stringify(value), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function codexNotificationProgressEvent(itemType, payload) {
+  return {
+    kind: "internal_progress",
+    source: "codex_app_server_notification",
+    itemType,
+    payloadBytes: payload === void 0 ? void 0 : payloadBytes(payload)
+  };
+}
+function boundedString(value, limit = 1e3) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.length <= limit) return trimmed;
+  return `${trimmed.slice(0, limit - 1)}\u2026`;
+}
+function codexNotificationDiagnosticEvent(message) {
+  const params = message.params ?? {};
+  let diagnosticMessage;
+  let details;
+  switch (message.method) {
+    case "configWarning":
+      diagnosticMessage = boundedString(params.summary) ?? boundedString(params.details) ?? "Codex configuration warning";
+      details = boundedString(params.details);
+      break;
+    case "warning":
+      diagnosticMessage = boundedString(params.message) ?? "Codex warning";
+      break;
+    case "guardianWarning":
+      diagnosticMessage = boundedString(params.message) ?? "Codex guardian warning";
+      break;
+    case "deprecationNotice":
+      diagnosticMessage = boundedString(params.summary) ?? boundedString(params.details) ?? "Codex deprecation notice";
+      details = boundedString(params.details);
+      break;
+    default:
+      return null;
+  }
+  const sessionId = codexMessageThreadId(message);
+  const path18 = boundedString(params.path);
+  return {
+    kind: "runtime_diagnostic",
+    severity: "warning",
+    source: "codex_app_server_notification",
+    itemType: message.method,
+    message: diagnosticMessage,
+    ...details ? { details } : {},
+    ...path18 ? { path: path18 } : {},
+    ...params.range !== void 0 ? { range: params.range } : {},
+    payloadBytes: payloadBytes(params),
+    ...sessionId ? { sessionId } : {}
+  };
+}
+function joinReasoningSummaryText(item) {
   const summary = Array.isArray(item.summary) ? item.summary.filter((entry) => typeof entry === "string") : [];
-  const content = Array.isArray(item.content) ? item.content.filter((entry) => typeof entry === "string") : [];
-  return [...summary, ...content].join("\n").trim();
+  return summary.join("\n").trim();
 }
 function rawResponseItemProgressEvent(message) {
   if (message.method !== "rawResponseItem/completed") return null;
   const item = message.params?.item ?? message.params?.responseItem ?? message.params?.rawItem ?? message.params;
   if (!item || typeof item !== "object") return null;
   const itemType = typeof item.type === "string" ? item.type : void 0;
-  let payloadBytes;
-  try {
-    payloadBytes = Buffer.byteLength(JSON.stringify(item), "utf8");
-  } catch {
-    payloadBytes = void 0;
-  }
   return {
     kind: "internal_progress",
     source: "codex_raw_response_item",
     itemType,
-    payloadBytes
+    payloadBytes: payloadBytes(item)
   };
 }
 function nonEmptyString2(value) {
@@ -4828,11 +5397,15 @@ function codexMcpToolName(item) {
   const server = nonEmptyString2(item.server);
   return server ? `mcp_${server}_${tool}` : `mcp_${tool}`;
 }
+function codexMessageThreadId(message) {
+  return nonEmptyString2(message.params?.threadId) ?? nonEmptyString2(message.params?.thread?.id) ?? nonEmptyString2(message.params?.sessionId);
+}
 var CodexEventNormalizer = class {
   currentThreadId = null;
   sessionAnnounced = false;
   streamedAgentMessageIds = /* @__PURE__ */ new Set();
   streamedReasoningIds = /* @__PURE__ */ new Set();
+  fileChangeToolCallCounts = /* @__PURE__ */ new Map();
   turnState = new RuntimeTurnState();
   reset(opts = {}) {
     this.currentThreadId = opts.threadId ?? null;
@@ -4840,6 +5413,7 @@ var CodexEventNormalizer = class {
     this.sessionAnnounced = false;
     this.streamedAgentMessageIds.clear();
     this.streamedReasoningIds.clear();
+    this.fileChangeToolCallCounts.clear();
   }
   get threadId() {
     return this.currentThreadId;
@@ -4862,11 +5436,11 @@ var CodexEventNormalizer = class {
       }
       const turn = message.result.turn;
       if (turn && typeof turn.id === "string") {
-        this.turnState.adoptTurnId(turn.id);
+        this.turnState.noteTurnAccepted(turn.id);
         return { events };
       }
       if (typeof message.result.turnId === "string") {
-        this.turnState.adoptTurnId(message.result.turnId);
+        this.turnState.noteTurnAccepted(message.result.turnId);
         return { events };
       }
     }
@@ -4874,9 +5448,12 @@ var CodexEventNormalizer = class {
       events.push({ kind: "error", message: message.error.message || "Codex app-server request failed" });
       return { events };
     }
+    if (this.isSecondaryThreadId(codexMessageThreadId(message))) {
+      return { events };
+    }
     const telemetry = parseCodexTelemetryEvent(message);
     if (telemetry) {
-      const telemetrySessionId = nonEmptyString2(message.params?.threadId) ?? nonEmptyString2(message.params?.thread?.id) ?? nonEmptyString2(message.params?.sessionId);
+      const telemetrySessionId = codexMessageThreadId(message);
       const telemetryTurnId = nonEmptyString2(message.params?.turnId) ?? nonEmptyString2(message.params?.turn?.id);
       if (telemetrySessionId) {
         this.currentThreadId = telemetrySessionId;
@@ -4907,7 +5484,7 @@ var CodexEventNormalizer = class {
         const turnId = message.params?.turn?.id;
         this.turnState.markTurnStarted(typeof turnId === "string" ? turnId : null);
         events.push({ kind: "thinking", text: "" });
-        break;
+        return { events, turnStarted: true };
       }
       case "item/agentMessage/delta": {
         const delta = message.params?.delta;
@@ -4921,8 +5498,7 @@ var CodexEventNormalizer = class {
         }
         break;
       }
-      case "item/reasoning/summaryTextDelta":
-      case "item/reasoning/textDelta": {
+      case "item/reasoning/summaryTextDelta": {
         const delta = message.params?.delta;
         const itemId = message.params?.itemId;
         if (typeof itemId === "string") {
@@ -4934,6 +5510,41 @@ var CodexEventNormalizer = class {
         }
         break;
       }
+      case "item/reasoning/textDelta": {
+        const delta = message.params?.delta;
+        if (typeof delta === "string" && delta.length > 0) {
+          this.turnState.markProgress();
+          events.push(codexNotificationProgressEvent("reasoning_text_delta", {
+            itemId: message.params?.itemId,
+            bytes: Buffer.byteLength(delta, "utf8")
+          }));
+        }
+        break;
+      }
+      case "item/commandExecution/outputDelta":
+      case "item/mcpToolCall/progress":
+      case "item/plan/delta":
+      case "turn/plan/updated":
+      case "turn/diff/updated":
+      case "item/fileChange/patchUpdated":
+      case "item/fileChange/outputDelta":
+      case "command/exec/outputDelta":
+      case "process/outputDelta":
+      case "process/exited": {
+        this.turnState.markProgress();
+        events.push(codexNotificationProgressEvent(message.method, message.params));
+        break;
+      }
+      case "configWarning":
+      case "warning":
+      case "guardianWarning":
+      case "deprecationNotice": {
+        const diagnostic = codexNotificationDiagnosticEvent(message);
+        if (diagnostic) {
+          events.push(diagnostic);
+        }
+        break;
+      }
       case "item/started":
       case "item/completed": {
         const item = message.params?.item;
@@ -4944,7 +5555,7 @@ var CodexEventNormalizer = class {
         switch (itemType) {
           case "reasoning":
             if (isCompleted && typeof item.id === "string" && !this.streamedReasoningIds.has(item.id)) {
-              const text = joinReasoningText(item);
+              const text = joinReasoningSummaryText(item);
               if (text) {
                 this.turnState.markProgress();
                 events.push({ kind: "thinking", text });
@@ -4980,14 +5591,45 @@ var CodexEventNormalizer = class {
               events.push({ kind: "compaction_finished" });
             }
             break;
+          case "enteredReviewMode":
+            if (isStarted) {
+              events.push({ kind: "review_started" });
+            }
+            break;
+          case "exitedReviewMode":
+            if (isCompleted) {
+              events.push({ kind: "review_finished" });
+            }
+            break;
           case "fileChange":
             if (isStarted && Array.isArray(item.changes)) {
+              let outputCount = 0;
               for (const change of item.changes) {
                 events.push({
                   kind: "tool_call",
                   name: "file_change",
                   input: { path: change?.path, kind: change?.kind }
                 });
+                outputCount += 1;
+              }
+              if (outputCount > 0 && typeof item.id === "string") {
+                this.fileChangeToolCallCounts.set(item.id, outputCount);
+              }
+            }
+            if (isCompleted) {
+              let outputCount = 0;
+              if (typeof item.id === "string") {
+                outputCount = this.fileChangeToolCallCounts.get(item.id) ?? 0;
+                this.fileChangeToolCallCounts.delete(item.id);
+              }
+              if (outputCount === 0 && Array.isArray(item.changes)) {
+                outputCount = item.changes.length;
+              }
+              for (let index = 0; index < outputCount; index += 1) {
+                events.push({ kind: "tool_output", name: "file_change" });
+              }
+              if (outputCount > 0) {
+                this.turnState.markToolBoundary();
               }
             }
             break;
@@ -5007,6 +5649,7 @@ var CodexEventNormalizer = class {
               events.push({ kind: "tool_call", name: "collab_tool_call", input: { tool: item.tool, prompt: item.prompt } });
             }
             if (isCompleted) {
+              events.push({ kind: "tool_output", name: "collab_tool_call" });
               this.turnState.markToolBoundary();
             }
             break;
@@ -5015,6 +5658,7 @@ var CodexEventNormalizer = class {
               events.push({ kind: "tool_call", name: "web_search", input: { query: item.query } });
             }
             if (isCompleted) {
+              events.push({ kind: "tool_output", name: "web_search" });
               this.turnState.markToolBoundary();
             }
             break;
@@ -5023,24 +5667,37 @@ var CodexEventNormalizer = class {
       }
       case "turn/completed": {
         const turn = message.params?.turn;
-        if (turn?.status === "failed" && turn?.error?.message) {
-          events.push({ kind: "error", message: turn.error.message });
+        if (turn?.status === "failed") {
+          events.push({ kind: "error", message: turn.error?.message || "Codex turn failed" });
+        }
+        if (turn?.status === "interrupted") {
+          const detail = typeof turn?.error?.message === "string" && turn.error.message.length > 0 ? `: ${turn.error.message}` : "";
+          events.push({ kind: "error", message: `Codex turn interrupted${detail}` });
         }
         this.turnState.markTurnCompleted();
         this.streamedAgentMessageIds.clear();
         this.streamedReasoningIds.clear();
+        this.fileChangeToolCallCounts.clear();
         events.push({ kind: "turn_end", sessionId: this.currentThreadId || void 0 });
         break;
       }
       case "error":
-        events.push({
-          kind: "error",
-          message: getCodexNotificationErrorMessage(message.params) || "Unknown Codex app-server error"
-        });
+        if (message.params?.willRetry === true) {
+          this.turnState.markProgress();
+          events.push(codexNotificationProgressEvent("retryable_error", message.params));
+        } else {
+          events.push({
+            kind: "error",
+            message: getCodexNotificationErrorMessage(message.params) || "Unknown Codex app-server error"
+          });
+        }
         break;
     }
     return { events };
   }
+  isSecondaryThreadId(threadId) {
+    return Boolean(threadId && this.currentThreadId && threadId !== this.currentThreadId);
+  }
   handleThreadReady(threadId, events) {
     this.currentThreadId = threadId;
     if (!this.sessionAnnounced) {
@@ -5052,20 +5709,6 @@ var CodexEventNormalizer = class {
 };
 
 // src/drivers/codex.ts
-function ensureGitRepoForCodex(workingDirectory, deps = {}) {
-  const existsSyncFn = deps.existsSyncFn ?? existsSync5;
-  const execSyncFn = deps.execSyncFn ?? execSync;
-  const gitDir = path6.join(workingDirectory, ".git");
-  if (existsSyncFn(gitDir)) return;
-  execSyncFn("git init", { cwd: workingDirectory, stdio: "pipe" });
-  execSyncFn(
-    "git -c user.name=slock -c user.email=slock@local -c commit.gpgsign=false add -A && git -c user.name=slock -c user.email=slock@local -c commit.gpgsign=false commit --allow-empty -m 'init'",
-    {
-      cwd: workingDirectory,
-      stdio: "pipe"
-    }
-  );
-}
 var CODEX_DESKTOP_BUNDLE_PATH = "/Applications/Codex.app/Contents/Resources/codex";
 function isWindowsSandboxRunner(commandPath) {
   return path6.basename(commandPath).toLowerCase().startsWith("codex-command-runner");
@@ -5144,27 +5787,68 @@ function probeCodex(deps = {}) {
 }
 function resolveCodexSpawn(commandArgs, deps = {}) {
   if ((deps.platform ?? process.platform) !== "win32") {
-    return { command: resolveCodexCommand(deps) ?? "codex", args: commandArgs };
+    return { command: resolveCodexCommand(deps) ?? "codex", args: commandArgs, shell: false };
   }
   const codexEntry = resolveWindowsNpmCodexEntry(deps);
   if (codexEntry) {
     return {
       command: process.execPath,
-      args: [codexEntry, ...commandArgs]
+      args: [codexEntry, ...commandArgs],
+      shell: false
     };
   }
   const command = resolveCommandOnPath("codex", deps);
   if (command && !isWindowsSandboxRunner(command)) {
-    return { command, args: commandArgs };
+    return { command, args: commandArgs, shell: requiresWindowsShell(command, deps.platform) };
   }
   const desktopEntry = resolveWindowsCodexDesktopEntry(deps);
   if (desktopEntry) {
-    return { command: desktopEntry, args: commandArgs };
+    return { command: desktopEntry, args: commandArgs, shell: false };
   }
   throw new Error(
     "Cannot resolve Codex CLI entry point on Windows. Install Codex Desktop or install @openai/codex globally via npm (npm i -g @openai/codex). Ignoring .codex/.sandbox-bin/codex-command-runner because it is a sandbox helper, not the Codex CLI."
   );
 }
+function isCodexMissingRolloutError(message) {
+  return /\bno\s+rollout\s+found\b/i.test(message) || /\bmissing\s+rollout\b/i.test(message) || /\brollout\b.*\b(not found|missing)\b/i.test(message) || /\bthread\b.*\b(not found|missing)\b/i.test(message) || /\bmissing\s+thread\b/i.test(message);
+}
+function classifyCodexResumeError(message) {
+  if (isCodexMissingRolloutError(message)) {
+    return {
+      kind: "missing_rollout",
+      resumeErrorClass: "missing_rollout",
+      recoveryAction: "fallback_fresh_thread",
+      telemetry: {
+        kind: "telemetry",
+        name: "recovery",
+        source: "codex_resume_missing_rollout",
+        attrs: {
+          resume_error_class: "missing_rollout",
+          recovery_action: "fallback_fresh_thread"
+        }
+      }
+    };
+  }
+  if (/\b(no\s+permission|permission\s+denied|forbidden|unauthorized)\b/i.test(message)) {
+    return {
+      kind: "terminal_error",
+      resumeErrorClass: "permission_denied"
+    };
+  }
+  return {
+    kind: "terminal_error",
+    resumeErrorClass: "unknown"
+  };
+}
+function hasJsonRpcField(message, field) {
+  return Object.prototype.hasOwnProperty.call(message, field);
+}
+function isJsonRpcResponse(message) {
+  return message.id !== void 0 && (hasJsonRpcField(message, "result") || hasJsonRpcField(message, "error"));
+}
+function isCodexServerRequest(message) {
+  return message.id !== void 0 && typeof message.method === "string" && !isJsonRpcResponse(message);
+}
 var CodexDriver = class {
   id = "codex";
   lifecycle = {
@@ -5176,6 +5860,7 @@ var CodexDriver = class {
     chat: "slock_cli",
     runtimeControl: "none"
   };
+  stdoutChannel = "structured_protocol";
   session = {
     recovery: "resume_or_fresh"
   };
@@ -5183,6 +5868,8 @@ var CodexDriver = class {
     detectedModelsVerifiedAs: "launchable",
     toLaunchSpec: (modelId) => ({ params: { model: modelId } })
   };
+  startupReadiness = "initial_turn";
+  requiresSessionInitForDelivery = true;
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
   supportsNativeStandingPrompt = true;
@@ -5229,25 +5916,32 @@ var CodexDriver = class {
   pendingInitialPrompt = null;
   initializeRequestId = null;
   pendingThreadRequest = null;
+  pendingThreadRequestId = null;
+  pendingThreadRequestMethod = null;
+  pendingResumeFallbackParams = null;
+  pendingInitialTurnRequestId = null;
   initialTurnStarted = false;
   normalizer = new CodexEventNormalizer();
   async spawn(ctx) {
-    ensureGitRepoForCodex(ctx.workingDirectory);
     const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
     this.process = null;
     this.requestId = 0;
     this.pendingInitialPrompt = ctx.prompt;
     this.initializeRequestId = null;
     this.pendingThreadRequest = null;
+    this.pendingThreadRequestId = null;
+    this.pendingThreadRequestMethod = null;
+    this.pendingResumeFallbackParams = null;
+    this.pendingInitialTurnRequestId = null;
     this.initialTurnStarted = false;
-    this.normalizer.reset({ threadId: ctx.config.sessionId || null });
+    this.normalizer.reset();
     const args = ["app-server", "--listen", "stdio://"];
-    const { command, args: spawnArgs } = resolveCodexSpawn(args);
+    const { command, args: spawnArgs, shell } = resolveCodexSpawn(args);
     const proc = spawn2(command, spawnArgs, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
-      shell: false
+      shell
     });
     this.process = proc;
     queueMicrotask(() => {
@@ -5265,24 +5959,77 @@ var CodexDriver = class {
       return [];
     }
     const events = [];
-    if (message.result) {
+    if (isCodexServerRequest(message)) {
+      this.sendErrorResponse(
+        message.id,
+        `Codex app-server request "${message.method}" is not supported by the non-interactive Slock daemon`
+      );
+      return events;
+    }
+    const isResponse = isJsonRpcResponse(message);
+    if (isResponse && hasJsonRpcField(message, "result")) {
       if (message.id === this.initializeRequestId) {
         this.initializeRequestId = null;
         this.sendNotification("initialized", {});
         if (this.pendingThreadRequest) {
-          this.sendRequest(this.pendingThreadRequest.method, this.pendingThreadRequest.params);
+          this.sendThreadRequest(this.pendingThreadRequest.method, this.pendingThreadRequest.params);
           this.pendingThreadRequest = null;
         }
         return events;
       }
     }
-    if (message.error && message.id === this.initializeRequestId) {
+    if (isResponse && hasJsonRpcField(message, "error") && message.id === this.initializeRequestId) {
       this.initializeRequestId = null;
       this.pendingThreadRequest = null;
-      events.push({ kind: "error", message: message.error.message || "Codex app-server request failed" });
+      this.pendingThreadRequestId = null;
+      this.pendingThreadRequestMethod = null;
+      this.pendingResumeFallbackParams = null;
+      events.push({
+        kind: "error",
+        message: message.error?.message || "Codex app-server request failed",
+        startupRequestMethod: "initialize"
+      });
+      return events;
+    }
+    if (isResponse && message.id === this.pendingThreadRequestId) {
+      if (hasJsonRpcField(message, "error")) {
+        const errorMessage = message.error?.message || "Codex app-server request failed";
+        const requestMethod = this.pendingThreadRequestMethod;
+        const resumeErrorClassification = requestMethod === "thread/resume" ? classifyCodexResumeError(errorMessage) : null;
+        if (this.pendingResumeFallbackParams && resumeErrorClassification?.kind === "missing_rollout") {
+          events.push(resumeErrorClassification.telemetry);
+          this.sendThreadRequest("thread/start", this.pendingResumeFallbackParams);
+          this.pendingResumeFallbackParams = null;
+          return events;
+        }
+        this.pendingThreadRequestId = null;
+        this.pendingThreadRequestMethod = null;
+        this.pendingResumeFallbackParams = null;
+        events.push(requestMethod ? { kind: "error", message: errorMessage, startupRequestMethod: requestMethod } : { kind: "error", message: errorMessage });
+        return events;
+      }
+      this.pendingThreadRequestId = null;
+      this.pendingThreadRequestMethod = null;
+      this.pendingResumeFallbackParams = null;
+    }
+    if (isResponse && message.id === this.pendingInitialTurnRequestId) {
+      this.pendingInitialTurnRequestId = null;
+      if (hasJsonRpcField(message, "error")) {
+        events.push({
+          kind: "error",
+          message: message.error?.message || "Codex app-server request failed",
+          startupRequestMethod: "turn/start"
+        });
+      } else {
+        this.pendingInitialPrompt = null;
+      }
       return events;
     }
     const result = this.normalizer.normalizeMessage(message);
+    if (result.turnStarted) {
+      this.pendingInitialTurnRequestId = null;
+      this.pendingInitialPrompt = null;
+    }
     if (result.threadReady) {
       this.startInitialTurn();
     }
@@ -5291,10 +6038,7 @@ var CodexDriver = class {
   get currentSessionId() {
     return this.normalizer.threadId;
   }
-  encodeStdinMessage(text, sessionId, opts) {
-    if (!this.normalizer.threadId && sessionId) {
-      this.normalizer.adoptThreadId(sessionId);
-    }
+  encodeStdinMessage(text, _sessionId, opts) {
     if (!this.normalizer.threadId) return null;
     const mode = opts?.mode || "busy";
     if (mode === "busy") {
@@ -5335,11 +6079,10 @@ var CodexDriver = class {
     return this.requestId;
   }
   startInitialTurn() {
-    if (this.initialTurnStarted || !this.pendingInitialPrompt || !this.normalizer.threadId) return;
+    if (this.initialTurnStarted || this.pendingInitialTurnRequestId !== null || !this.pendingInitialPrompt || !this.normalizer.threadId) return;
     this.initialTurnStarted = true;
     const prompt = this.pendingInitialPrompt;
-    this.pendingInitialPrompt = null;
-    this.sendRequest("turn/start", {
+    this.pendingInitialTurnRequestId = this.sendRequest("turn/start", {
       threadId: this.normalizer.threadId,
       input: [{ type: "text", text: prompt }]
     });
@@ -5354,6 +6097,27 @@ var CodexDriver = class {
     }) + "\n");
     return id;
   }
+  sendErrorResponse(id, message) {
+    this.process?.stdin?.write(JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      error: {
+        code: -32601,
+        message
+      }
+    }) + "\n");
+  }
+  sendThreadRequest(method, params) {
+    const id = this.sendRequest(method, params);
+    this.pendingThreadRequestId = id;
+    this.pendingThreadRequestMethod = method;
+    this.pendingResumeFallbackParams = null;
+    if (method === "thread/resume") {
+      const { threadId: _threadId, ...freshParams } = params;
+      this.pendingResumeFallbackParams = freshParams;
+    }
+    return id;
+  }
   sendNotification(method, params) {
     this.process?.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -5376,7 +6140,7 @@ function detectCodexModels(home = os3.homedir()) {
     for (const entry of entries) {
       const slug = typeof entry?.slug === "string" ? entry.slug : null;
       if (!slug) continue;
-      if (entry?.visibility && entry.visibility !== "public") continue;
+      if (entry?.visibility && entry.visibility !== "public" && entry.visibility !== "list") continue;
       if (entry?.supported_in_api === false) continue;
       const label = typeof entry?.display_name === "string" && entry.display_name.length > 0 ? entry.display_name : slug;
       models.push({ id: slug, label, verified: "launchable" });
@@ -6374,6 +7138,9 @@ function mapKimiSdkEventToParsedEvents(event, state) {
 var KIMI_SDK_RUNTIME_SESSION_DESCRIPTOR = {
   transport: "sdk",
   lifecycle: "sdk_session",
+  stdout: {
+    channel: "diagnostic"
+  },
   input: {
     initial: "start",
     idle: "sdk_prompt",
@@ -7217,7 +7984,8 @@ var PI_SDK_COMPACTION_ENABLED = true;
 var PI_PROVIDER_LABELS = {
   google: "Google",
   openai: "OpenAI",
-  openrouter: "OpenRouter"
+  openrouter: "OpenRouter",
+  deepseek: "DeepSeek"
 };
 function createPiSdkEventMappingState(sessionId = null) {
   return {
@@ -7448,6 +8216,9 @@ function mapPiSdkEventToParsedEvents(event, state) {
 var PI_RUNTIME_SESSION_DESCRIPTOR = {
   transport: "sdk",
   lifecycle: "sdk_session",
+  stdout: {
+    channel: "diagnostic"
+  },
   input: {
     initial: "start",
     idle: "sdk_prompt",
@@ -7838,6 +8609,7 @@ function delay(ms) {
 
 // src/drivers/runtimeSession.ts
 import { EventEmitter as EventEmitter3 } from "events";
+import { StringDecoder } from "string_decoder";
 function descriptorFromDriver(driver) {
   const lifecycle = driver.lifecycle.kind === "per_turn" ? "turn_based" : "persistent_stream";
   const idle = driver.supportsStdinNotification ? "stdin" : "unsupported";
@@ -7845,6 +8617,9 @@ function descriptorFromDriver(driver) {
   return {
     transport: "child_process",
     lifecycle,
+    stdout: {
+      channel: driver.stdoutChannel ?? "diagnostic"
+    },
     input: {
       initial: "start",
       idle,
@@ -7869,6 +8644,7 @@ var ChildProcessRuntimeSession = class {
   process = null;
   started = false;
   stdoutBuffer = "";
+  stdoutDecoder = new StringDecoder("utf8");
   requestedStopReason;
   get pid() {
     return this.process?.pid;
@@ -7931,7 +8707,7 @@ var ChildProcessRuntimeSession = class {
   }
   attachProcess(process2) {
     process2.stdout?.on("data", (chunk) => {
-      const chunkText = chunk.toString();
+      const chunkText = this.stdoutDecoder.write(chunk);
       this.events.emit("stdout", chunkText);
       this.stdoutBuffer += chunkText;
       const lines = this.stdoutBuffer.split("\n");
@@ -8611,6 +9387,73 @@ function getMessageShortId(messageId2) {
   return messageId2.startsWith("thread-") ? messageId2.slice(7) : messageId2.slice(0, 8);
 }
 var RESPONSE_TARGET_HINT = "Reply in the channel or create/reply in a thread as appropriate; use each message's `target` and `msg` fields to choose the exact target.";
+var SESSION_TRANSCRIPT_MAX_BYTES = 10 * 1024 * 1024;
+function runtimeTier(runtime) {
+  const tier1 = /* @__PURE__ */ new Set(["claude", "codex", "kimi-sdk", "kimi", "pi"]);
+  if (tier1.has(runtime)) return "tier1";
+  return "tier2_or_fallback";
+}
+function redactTranscript(text) {
+  return text.replace(/sk_(?:agent|machine|computer)_[A-Za-z0-9_-]+/g, "sk_[redacted]").replace(/sap_[A-Za-z0-9_-]+/g, "sap_[redacted]").replace(/Bearer\s+[A-Za-z0-9_\-./+=]+/g, "Bearer [redacted]").replace(/["']?auth[_-]?token["']?\s*[:=]\s*["'][^"']+["']/gi, "[redacted]").replace(/https?:\/\/[^\s\"]+/g, "[url]");
+}
+function allowedTranscriptRootsForRuntime(runtime, homeDir, workspaceDir) {
+  const roots = [workspaceDir];
+  switch (runtime) {
+    case "claude":
+      roots.push(path13.join(homeDir, ".claude"));
+      break;
+    case "codex":
+      roots.push(path13.join(homeDir, ".codex"));
+      break;
+    case "kimi":
+    case "kimi-sdk":
+      roots.push(path13.join(homeDir, ".kimi"));
+      break;
+    case "pi":
+      roots.push(path13.join(homeDir, ".pi"), path13.join(homeDir, ".pi", "agent"));
+      break;
+  }
+  return roots;
+}
+async function isPathWithinAllowedRoots(filePath, roots) {
+  const real = await realpath(filePath).catch(() => null);
+  if (!real) return false;
+  for (const root of roots) {
+    const realRoot = await realpath(root).catch(() => null);
+    if (!realRoot) continue;
+    const rel = path13.relative(realRoot, real);
+    if (!rel.startsWith("..") && !path13.isAbsolute(rel)) return true;
+  }
+  return false;
+}
+async function readBoundedTranscriptFile(filePath, maxBytes) {
+  const info = await lstat(filePath);
+  if (info.isSymbolicLink()) {
+    throw new Error("symbolic links are not allowed");
+  }
+  if (!info.isFile()) {
+    throw new Error(`not a regular file: ${filePath}`);
+  }
+  const fd = await open(filePath, "r");
+  try {
+    const toRead = Math.min(info.size, maxBytes);
+    const buf = Buffer.alloc(toRead);
+    await fd.read(buf, 0, toRead, 0);
+    const truncated = info.size > maxBytes;
+    const text = buf.toString("utf8");
+    return { text, sizeBytes: Buffer.byteLength(text, "utf8"), truncated };
+  } finally {
+    await fd.close();
+  }
+}
+async function readAndRedact(filePath, maxBytes) {
+  try {
+    const { text, truncated } = await readBoundedTranscriptFile(filePath, maxBytes);
+    return { text: redactTranscript(text), truncated };
+  } catch {
+    return null;
+  }
+}
 function findSessionJsonl(root, predicate) {
   let visited = 0;
   const maxEntries = 1e4;
@@ -8638,6 +9481,53 @@ function findSessionJsonl(root, predicate) {
   };
   return visit(root, maxDepth);
 }
+function findKimiSdkSessionDir(sessionId, agentId, homeDir) {
+  const indexPath = path13.join(homeDir, ".kimi", "session_index.jsonl");
+  try {
+    const index = readFileSync6(indexPath, "utf8");
+    for (const line of index.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.sessionId === sessionId && entry.sessionDir && existsSync9(entry.sessionDir)) {
+          return entry.sessionDir;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const sessionsRoot = path13.join(homeDir, ".kimi", "sessions");
+  try {
+    const prefix = agentId ? `wd_${agentId}_` : `wd_`;
+    for (const entry of readdirSync3(sessionsRoot, { withFileTypes: true })) {
+      if (!entry.isDirectory() || !entry.name.startsWith(prefix)) continue;
+      const candidate = path13.join(sessionsRoot, entry.name, `session_${sessionId}`);
+      if (existsSync9(candidate)) return candidate;
+    }
+  } catch {
+  }
+  return null;
+}
+function findPiSessionFile2(sessionId, workingDirectory, homeDir) {
+  if (workingDirectory) {
+    const piSessionsDir = path13.join(workingDirectory, ".pi-sessions");
+    try {
+      const files = readdirSync3(piSessionsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => ({ name: e.name, path: path13.join(piSessionsDir, e.name), stat: statSync(path13.join(piSessionsDir, e.name)) })).filter((f) => f.stat.isFile() && f.name.includes(sessionId)).sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+      if (files[0]) return files[0].path;
+    } catch {
+    }
+  }
+  const legacyRoots = [
+    path13.join(homeDir, ".pi", "agent"),
+    path13.join(homeDir, ".pi")
+  ];
+  for (const root of legacyRoots) {
+    const found = findSessionJsonl(root, (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId));
+    if (found) return found;
+  }
+  return null;
+}
 function safeSessionFilename(value) {
   const normalized = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized || "unknown-session";
@@ -8677,20 +9567,30 @@ function ensureRuntimeHomeDir(config, defaultHomeDir, workspacePath) {
   }
   return defaultHomeDir;
 }
-function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), fallbackDir) {
-  const directPath = path13.isAbsolute(sessionId) ? sessionId : null;
-  if (directPath) {
-    try {
-      if (statSync(directPath).isFile()) {
-        return { label: sessionId, path: directPath, runtime, reachable: true };
-      }
-    } catch {
-    }
+function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), fallbackDir, opts) {
+  let resolvedPath = null;
+  let lookupMethod = "none";
+  if (runtime === "claude") {
+    lookupMethod = "claude_jsonl";
+    resolvedPath = findSessionJsonl(path13.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`);
+  } else if (runtime === "codex") {
+    lookupMethod = "codex_jsonl";
+    resolvedPath = findSessionJsonl(path13.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId));
+  } else if (runtime === "kimi-sdk" || runtime === "kimi") {
+    lookupMethod = "kimi_sdk_index";
+    resolvedPath = findKimiSdkSessionDir(sessionId, opts?.agentId, homeDir);
+  } else if (runtime === "pi") {
+    lookupMethod = "pi_jsonl";
+    resolvedPath = findPiSessionFile2(sessionId, opts?.workingDirectory, homeDir);
   }
-  const resolvedPath = runtime === "claude" ? findSessionJsonl(path13.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`) : runtime === "codex" ? findSessionJsonl(path13.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId)) : null;
   if (!resolvedPath && fallbackDir) {
     const fallback = writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir);
-    if (fallback) return fallback;
+    if (fallback) {
+      return {
+        ...fallback,
+        reason: `${fallback.reason}; attempted_lookup=${lookupMethod}`
+      };
+    }
   }
   const ref = {
     label: sessionId,
@@ -8699,7 +9599,7 @@ function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), f
     reachable: Boolean(resolvedPath)
   };
   if (!resolvedPath) {
-    ref.reason = "session file path not found";
+    ref.reason = `session file path not found; attempted_lookup=${lookupMethod}`;
   }
   return ref;
 }
@@ -8768,7 +9668,7 @@ function dynamicReplyInstruction() {
 function dynamicClaimInstruction() {
   return "claim the relevant task with `raft task claim`";
 }
-function formatIncomingMessage(message) {
+function formatIncomingMessage(message, options = {}) {
   const threadJoinPrefix = message.thread_join_context ? [
     `[Slock thread context: you were added to a new thread via @mention.]`,
     `parent: ${message.thread_join_context.parent_target}`,
@@ -8786,13 +9686,19 @@ function formatIncomingMessage(message) {
   const msgId = message.message_id ? getMessageShortId(message.message_id) : "-";
   const time = message.timestamp ? toLocalTime(message.timestamp) : "-";
   const senderType = formatVisibleActorType(message.sender_type);
-  const attachSuffix = message.attachments?.length ? ` [${message.attachments.length} attachment${message.attachments.length > 1 ? "s" : ""}: ${message.attachments.map((a) => `${a.filename} (id:${a.id})`).join(", ")} \u2014 use view_file to download]` : "";
+  const attachSuffix = formatAttachmentSuffix(message.attachments, options.attachmentHint);
   const taskSuffix = message.task_status ? ` [task #${message.task_number} status=${message.task_status}${message.task_assignee_id ? ` assignee=${formatTaskAssigneeType(message.task_assignee_type)}:${message.task_assignee_id}` : ""}]` : "";
   const lineageSuffix = formatProducerFactLineageBracket(message.producerFactId);
   const body = `[target=${target} msg=${msgId} time=${time}${senderType}] ${formatSenderHandle(message)}: ${message.content}${attachSuffix}${taskSuffix}${lineageSuffix}`;
   return threadJoinPrefix ? `${threadJoinPrefix}
 ${body}` : body;
 }
+function incomingMessageFormatOptionsForDriver(driver) {
+  switch (driver.communication.chat) {
+    case "slock_cli":
+      return { attachmentHint: "slock_cli" };
+  }
+}
 function formatRuntimeProfileControlPrompt(messages) {
   const controls = messages.map((message) => ({
     message,
@@ -9263,7 +10169,6 @@ function cleanupAgentCredentialProxy(agentId, launchId) {
   unregisterAgentCredentialProxyForLaunch({ agentId, launchId });
 }
 function stripManagedRunnerCredential(config) {
-  if (!config.agentCredentialKey && !config.agentCredentialId) return config;
   const { agentCredentialKey: _agentCredentialKey, agentCredentialId: _agentCredentialId, ...rest } = config;
   return rest;
 }
@@ -9345,6 +10250,68 @@ function summarizeCrash(code, signal) {
   if (typeof code === "number") return `exit code ${code}`;
   return "unknown exit";
 }
+function closeSatisfiedTurnBoundary(ap, expectedTermination) {
+  if (expectedTermination) return true;
+  if (ap.runtime.descriptor.turnBoundary === "process_exit") return true;
+  return !ap.runtimeTraceSpan;
+}
+function isStartupRequestErrorEvent(event) {
+  return event.kind === "error" && !!event.startupRequestMethod;
+}
+function runtimeDiagnosticTitle(event) {
+  switch (event.itemType) {
+    case "configWarning":
+      return "Codex config warning";
+    case "guardianWarning":
+      return "Codex guardian warning";
+    case "deprecationNotice":
+      return "Codex deprecation notice";
+    default:
+      return "Codex warning";
+  }
+}
+function summarizeDiagnosticRange(range) {
+  if (range === void 0 || range === null) return null;
+  try {
+    const json = JSON.stringify(range);
+    if (!json) return null;
+    return json.length <= 300 ? json : `${json.slice(0, 299)}\u2026`;
+  } catch {
+    return null;
+  }
+}
+function runtimeDiagnosticTrajectoryEntry(event) {
+  const lines = [event.message];
+  if (event.details && event.details !== event.message) {
+    lines.push(event.details);
+  }
+  if (event.path) {
+    lines.push(`Path: ${event.path}`);
+  }
+  const range = summarizeDiagnosticRange(event.range);
+  if (range) {
+    lines.push(`Range: ${range}`);
+  }
+  return {
+    kind: "system",
+    title: runtimeDiagnosticTitle(event),
+    text: lines.join("\n")
+  };
+}
+function runtimeDiagnosticTraceAttrs(event) {
+  return {
+    kind: event.kind,
+    severity: event.severity,
+    source: event.source,
+    itemType: event.itemType,
+    payloadBytes: event.payloadBytes,
+    message_present: Boolean(event.message),
+    details_present: Boolean(event.details),
+    path_present: Boolean(event.path),
+    range_present: event.range !== void 0,
+    session_id_present: Boolean(event.sessionId)
+  };
+}
 function currentErrorCandidates(ap) {
   return [
     ap.runtimeErrorSinceProgress ? ap.lastRuntimeError : null,
@@ -9429,79 +10396,39 @@ function isPiReplayRejectedByProvider(text) {
   return /Cannot continue from message role:\s*assistant/i.test(text);
 }
 function resumeSessionRuntimeLabel(runtimeId) {
+  if (runtimeId === "codex") return "Codex";
   if (runtimeId === "opencode") return "OpenCode";
   if (runtimeId === "gemini") return "Gemini";
   if (runtimeId === "pi") return "Pi";
   return "Claude";
 }
-function classifyActivityDetailForTrace(detail) {
-  if (!detail) return void 0;
-  if (detail === "Message received") return "message_received";
-  if (detail === "Starting\u2026") return "starting";
-  if (detail === "Running command\u2026") return "running_command";
-  if (detail === "Checking messages\u2026") return "checking_messages";
-  if (detail === "Compacting context") return "compacting_context";
-  if (detail === "Context compaction finished") return "compaction_finished";
-  if (detail === "Context compaction still running; no finish event observed") return "compaction_stale";
-  if (detail === "Idle" || detail === "Process idle") return "idle";
-  if (detail.startsWith("Restarting stalled ") && detail.endsWith(" runtime for queued message")) return "stalled_recovery";
-  if (detail.startsWith("Runtime stalled: no runtime events for ")) return "runtime_stalled";
-  return "other";
-}
 function buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes) {
-  const context = [];
-  if (ap.lastActivityDetail) {
-    context.push(`after ${ap.lastActivityDetail}`);
-  }
-  if (ap.runtime.descriptor.busyDelivery === "gated") {
-    context.push(`phase=${ap.gatedSteering.phase}`);
-  }
-  if (ap.gatedSteering.outstandingToolUses > 0) {
-    context.push(`tools=${ap.gatedSteering.outstandingToolUses}`);
-  }
-  if (ap.gatedSteering.compacting) {
-    context.push("compacting");
-  }
-  if (ap.inbox.length > 0) {
-    context.push(`queued=${ap.inbox.length}`);
-  }
-  const detail = [
-    `Runtime stalled: no runtime events for ${staleForMinutes}m`,
-    context.length > 0 ? ` (${context.join(", ")})` : ""
-  ].join("");
-  return {
-    detail,
-    traceAttrs: {
-      ageMs: staleForMs,
-      staleForMinutes,
-      lastActivity: ap.lastActivity,
-      lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
-      lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail),
-      runtime: ap.config.runtime,
-      model: ap.config.model,
-      platform: process.platform,
-      arch: process.arch,
-      launchId: ap.launchId || void 0,
-      sessionIdPresent: Boolean(ap.sessionId),
-      inboxCount: ap.inbox.length,
-      pendingNotificationCount: ap.notifications.pendingCount,
-      processPidPresent: typeof ap.runtime.pid === "number",
-      busyDeliveryMode: ap.driver.busyDeliveryMode,
-      supportsStdinNotification: ap.driver.supportsStdinNotification,
-      gatedPhase: ap.runtime.descriptor.busyDelivery === "gated" ? ap.gatedSteering.phase : void 0,
-      outstandingToolUses: ap.gatedSteering.outstandingToolUses,
-      compacting: ap.gatedSteering.compacting,
-      recentStderrCount: ap.recentStderr.length,
-      recentStdoutCount: ap.recentStdout.length,
-      ...runtimeTraceCounterAttrs(ap)
-    }
-  };
-}
-function classifyRuntimeStallReason(ap) {
-  if (ap.runtimeProgress.lastEventKind === "tool_output" && ap.gatedSteering.outstandingToolUses === 0) {
-    return "harness_post_tool_silent_wedge";
-  }
-  return "no_runtime_events";
+  return projectApmRuntimeStallDiagnostic({
+    staleForMs,
+    staleForMinutes,
+    lastActivity: ap.lastActivity,
+    lastActivityDetail: ap.lastActivityDetail,
+    runtimeDescriptorBusyDelivery: ap.runtime.descriptor.busyDelivery,
+    runtimeProgressLastEventKind: ap.runtimeProgress.lastEventKind,
+    runtime: ap.config.runtime,
+    model: ap.config.model,
+    platform: process.platform,
+    arch: process.arch,
+    launchId: ap.launchId,
+    sessionIdPresent: Boolean(ap.sessionId),
+    inboxCount: ap.inbox.length,
+    pendingNotificationCount: ap.notifications.pendingCount,
+    processPidPresent: typeof ap.runtime.pid === "number",
+    driverBusyDeliveryMode: ap.driver.busyDeliveryMode,
+    supportsStdinNotification: ap.driver.supportsStdinNotification,
+    gatedPhase: ap.gatedSteering.phase,
+    outstandingToolUses: ap.gatedSteering.outstandingToolUses,
+    compacting: ap.gatedSteering.compacting,
+    reviewing: ap.gatedSteering.reviewing === true ? true : void 0,
+    recentStderrCount: ap.recentStderr.length,
+    recentStdoutCount: ap.recentStdout.length,
+    runtimeTraceCounterAttrs: runtimeTraceCounterAttrs(ap)
+  });
 }
 function bucketBytes(value) {
   const bytes = typeof value === "string" ? Buffer.byteLength(value, "utf8") : Math.max(0, Math.floor(value ?? 0));
@@ -9730,6 +10657,8 @@ var AgentProcessManager = class _AgentProcessManager {
   agentSpawnFailBackoff = /* @__PURE__ */ new Map();
   daemonVersion;
   computerVersion;
+  workerUrl;
+  fetchImpl;
   constructor(sendToServer, daemonApiKey, opts) {
     this.slockCliPath = opts.slockCliPath ?? "";
     this.sendToServer = sendToServer;
@@ -9742,6 +10671,8 @@ var AgentProcessManager = class _AgentProcessManager {
     this.tracer = opts.tracer ?? noopTracer;
     this.daemonVersion = opts.daemonVersion?.trim() || null;
     this.computerVersion = opts.computerVersion?.trim() || null;
+    this.workerUrl = opts.workerUrl?.trim() || null;
+    this.fetchImpl = opts.fetchImpl ?? daemonFetch;
     this.stdinNotificationRetryMs = Math.max(
       0,
       Math.floor(opts.stdinNotificationRetryMs ?? STDIN_NOTIFICATION_RETRY_DELAY_MS)
@@ -9863,13 +10794,17 @@ var AgentProcessManager = class _AgentProcessManager {
       this.sendStdinNotification(agentId);
     }, delayMs);
   }
+  isApmIdle(ap) {
+    return ap.gatedSteering.isIdle;
+  }
   flushPendingDirectStdinNotificationOnRuntimeProgress(agentId, ap, source) {
     if (ap.notifications.pendingCount === 0) return false;
-    if (ap.isIdle) return false;
+    if (this.isApmIdle(ap)) return false;
     if (!ap.sessionId) return false;
     if (!ap.driver.supportsStdinNotification) return false;
     if (ap.runtime.descriptor.busyDelivery !== "direct") return false;
     if (ap.gatedSteering.compacting) return false;
+    if (ap.gatedSteering.reviewing) return false;
     this.recordDaemonTrace("daemon.agent.stdin_notification.retry_signal", {
       agentId,
       runtime: ap.config.runtime,
@@ -9975,8 +10910,9 @@ var AgentProcessManager = class _AgentProcessManager {
   queueDeliveryForRuntimeErrorBackoff(agentId, ap, message) {
     const remainingMs = this.runtimeErrorDeliveryBackoffRemainingMs(ap);
     if (remainingMs <= 0) return false;
+    const isIdle = this.isApmIdle(ap);
     ap.inbox.push(message);
-    if (!ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
+    if (!isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
       ap.notifications.add();
     }
     const scheduled = this.scheduleRuntimeErrorDeliveryBackoffFlush(agentId, ap);
@@ -9987,7 +10923,7 @@ var AgentProcessManager = class _AgentProcessManager {
       runtime: ap.config.runtime,
       session_id_present: Boolean(ap.sessionId),
       launchId: ap.launchId || void 0,
-      is_idle: ap.isIdle,
+      is_idle: isIdle,
       inbox_count: ap.inbox.length,
       pending_notification_count: ap.notifications.pendingCount,
       runtime_error_backoff_remaining_ms: remainingMs,
@@ -10007,7 +10943,7 @@ var AgentProcessManager = class _AgentProcessManager {
     }
     if (ap.inbox.length === 0) return false;
     const reason = ap.runtimeErrorDeliveryBackoff.reason || "runtime_error_backoff";
-    if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
+    if (this.isApmIdle(ap) && ap.driver.supportsStdinNotification && ap.sessionId) {
       ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
       const messages = ap.notifications.filterUncontributedMessages(ap.inbox, ap.sessionId);
       ap.notifications.clearPending();
@@ -10299,6 +11235,23 @@ var AgentProcessManager = class _AgentProcessManager {
       clientSeq: ap ? this.nextActivityClientSeq(agentId) : void 0
     });
   }
+  recordRuntimeDiagnosticActivity(agentId, ap, event) {
+    this.sendToServer({
+      type: "agent:activity",
+      agentId,
+      activity: ap.lastActivity || "online",
+      detail: ap.lastActivityDetail || "",
+      entries: [runtimeDiagnosticTrajectoryEntry(event)],
+      launchId: ap.launchId || void 0,
+      clientSeq: this.nextActivityClientSeq(agentId)
+    });
+    this.recordDaemonTrace("daemon.runtime.diagnostic", {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      ...runtimeDiagnosticTraceAttrs(event)
+    });
+  }
   recordDaemonTrace(name, attrs, status = "ok", parentTraceparent) {
     const span = this.tracer.startSpan(name, {
       parent: parseTraceparent(parentTraceparent),
@@ -10364,6 +11317,13 @@ var AgentProcessManager = class _AgentProcessManager {
       session_id_present: Boolean(sessionId)
     });
   }
+  initialAgentProcessSessionId(driver, config) {
+    if (driver.requiresSessionInitForDelivery) return null;
+    return config.sessionId || null;
+  }
+  restartSafeSessionId(ap) {
+    return ap.sessionId || (ap.driver.requiresSessionInitForDelivery ? ap.config.sessionId || null : null);
+  }
   sameWakeMessage(left, right) {
     if (!left || !right) return left === right;
     if (left.message_id && right.message_id) return left.message_id === right.message_id;
@@ -10408,16 +11368,18 @@ var AgentProcessManager = class _AgentProcessManager {
     }
     const previousLaunchId = ap.launchId;
     const nextLaunchId = start.launchId || ap.launchId || null;
-    const nextSessionId = ap.sessionId || start.config.sessionId || null;
+    const requiresSessionInit = ap.driver.requiresSessionInitForDelivery === true;
+    const nextSessionId = ap.sessionId || (requiresSessionInit ? null : start.config.sessionId || null);
+    const nextConfigSessionId = nextSessionId || (requiresSessionInit ? start.config.sessionId || null : ap.config.sessionId || start.config.sessionId || null);
     ap.launchId = nextLaunchId;
     ap.sessionId = nextSessionId;
     ap.config = {
       ...start.config,
-      sessionId: nextSessionId
+      sessionId: nextConfigSessionId
     };
     this.idleAgentConfigs.set(agentId, {
-      config: { ...stripManagedRunnerCredential(ap.config), sessionId: nextSessionId },
-      sessionId: nextSessionId,
+      config: this.buildRestartSafeConfig(ap.config, nextConfigSessionId),
+      sessionId: nextConfigSessionId,
       launchId: nextLaunchId
     });
     this.recordStartRebind(agentId, start, reason, previousLaunchId, nextLaunchId, nextSessionId);
@@ -10623,9 +11585,53 @@ var AgentProcessManager = class _AgentProcessManager {
       return;
     }
     this.agentsStarting.add(agentId);
-    this.recordDaemonTrace("daemon.agent.spawn.started", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient));
     let agentProcess = null;
+    let pendingStartRebind;
+    const originalLaunchId = launchId || null;
     try {
+      const agentDataDir = path13.join(this.dataDir, agentId);
+      await mkdir(agentDataDir, { recursive: true });
+      const initialRuntimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
+      const memoryMdPath = path13.join(agentDataDir, "MEMORY.md");
+      try {
+        await access(memoryMdPath);
+      } catch {
+        const initialMemoryMd = buildInitialMemoryMd(initialRuntimeConfig);
+        await writeFile(memoryMdPath, initialMemoryMd);
+      }
+      const notesDir = path13.join(agentDataDir, "notes");
+      await mkdir(notesDir, { recursive: true });
+      if (getOnboardingSeedMode(config) === FIRST_CINDY_SEED_MODE) {
+        const seedFiles = buildOnboardingSeedFiles();
+        for (const { relativePath, content } of seedFiles) {
+          const fullPath = path13.join(agentDataDir, relativePath);
+          try {
+            await access(fullPath);
+          } catch {
+            await mkdir(path13.dirname(fullPath), { recursive: true });
+            await writeFile(fullPath, content);
+          }
+        }
+      }
+      pendingStartRebind = this.pendingStartRebinds.get(agentId);
+      if (pendingStartRebind) {
+        this.pendingStartRebinds.delete(agentId);
+        const previousWakeMessage = wakeMessage;
+        if (previousWakeMessage && pendingStartRebind.wakeMessage && !this.sameWakeMessage(previousWakeMessage, pendingStartRebind.wakeMessage)) {
+          const pending = this.startingInboxes.get(agentId) || [];
+          pending.push(previousWakeMessage);
+          this.startingInboxes.set(agentId, pending);
+        }
+        config = pendingStartRebind.config;
+        unreadSummary = pendingStartRebind.unreadSummary;
+        resumePrompt = pendingStartRebind.resumePrompt;
+        launchId = pendingStartRebind.launchId || launchId;
+        if (pendingStartRebind.wakeMessage) {
+          wakeMessage = pendingStartRebind.wakeMessage;
+          wakeMessageTransient = pendingStartRebind.wakeMessageTransient === true;
+        }
+      }
+      this.recordDaemonTrace("daemon.agent.spawn.started", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient));
       const driver = this.driverResolver(config.runtime || "claude");
       const legacyWakeRuntimeProfile = wakeMessage ? runtimeProfileNotificationFromMessage(wakeMessage) : null;
       if (legacyWakeRuntimeProfile?.kind === "migration") {
@@ -10638,8 +11644,6 @@ var AgentProcessManager = class _AgentProcessManager {
         );
         wakeMessage = void 0;
       }
-      const agentDataDir = path13.join(this.dataDir, agentId);
-      await mkdir(agentDataDir, { recursive: true });
       let runtimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
       const legacyRuntimeProfileControl = runtimeConfig.runtimeProfileControl?.kind === "migration" ? runtimeConfig.runtimeProfileControl : null;
       if (legacyRuntimeProfileControl) {
@@ -10652,27 +11656,6 @@ var AgentProcessManager = class _AgentProcessManager {
         );
         runtimeConfig = { ...runtimeConfig, runtimeProfileControl: null };
       }
-      const memoryMdPath = path13.join(agentDataDir, "MEMORY.md");
-      try {
-        await access(memoryMdPath);
-      } catch {
-        const initialMemoryMd = buildInitialMemoryMd(runtimeConfig);
-        await writeFile(memoryMdPath, initialMemoryMd);
-      }
-      const notesDir = path13.join(agentDataDir, "notes");
-      await mkdir(notesDir, { recursive: true });
-      if (getOnboardingSeedMode(config) === FIRST_CINDY_SEED_MODE) {
-        const seedFiles = buildOnboardingSeedFiles();
-        for (const { relativePath, content } of seedFiles) {
-          const fullPath = path13.join(agentDataDir, relativePath);
-          try {
-            await access(fullPath);
-          } catch {
-            await mkdir(path13.dirname(fullPath), { recursive: true });
-            await writeFile(fullPath, content);
-          }
-        }
-      }
       const isResume = !!runtimeConfig.sessionId;
       const standingPrompt = driver.buildSystemPrompt(runtimeConfig, agentId);
       let prompt;
@@ -10692,7 +11675,7 @@ var AgentProcessManager = class _AgentProcessManager {
         if (transientWakeMessage) {
           prompt = `System notice received:
 
-${formatIncomingMessage(wakeMessage)}
+${formatIncomingMessage(wakeMessage, incomingMessageFormatOptionsForDriver(driver))}
 
 Respond as appropriate. Complete all your work before stopping.
 ${RESPONSE_TARGET_HINT}`;
@@ -10746,20 +11729,15 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         sessionIdPresent: isResume,
         nativeStandingPrompt: Boolean(driver.supportsNativeStandingPrompt)
       });
-      const effectiveConfig = await this.buildSpawnConfig(agentId, runtimeConfig);
-      const pendingStartRebind = this.pendingStartRebinds.get(agentId);
-      if (pendingStartRebind) {
-        this.pendingStartRebinds.delete(agentId);
-      }
-      const effectiveLaunchId = pendingStartRebind?.launchId || launchId || null;
-      const canDeferEmptyStart = driver.deferSpawnUntilMessage === true && !wakeMessage && !pendingStartRebind?.wakeMessage && !runtimeConfig.runtimeProfileControl && (!unreadSummary || Object.keys(unreadSummary).length === 0);
+      const effectiveLaunchId = launchId || null;
+      const canDeferEmptyStart = driver.deferSpawnUntilMessage === true && !wakeMessage && !runtimeConfig.runtimeProfileControl && (!unreadSummary || Object.keys(unreadSummary).length === 0);
       if (canDeferEmptyStart) {
         const pendingMessages = this.startingInboxes.get(agentId) || [];
         this.startingInboxes.delete(agentId);
         this.agentsStarting.delete(agentId);
         this.idleAgentConfigs.set(agentId, {
-          config: effectiveConfig,
-          sessionId: effectiveConfig.sessionId || null,
+          config: this.buildRestartSafeConfig(runtimeConfig, runtimeConfig.sessionId || null),
+          sessionId: runtimeConfig.sessionId || null,
           launchId: effectiveLaunchId
         });
         this.sendAgentStatus(agentId, "active", effectiveLaunchId);
@@ -10775,6 +11753,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         }
         return;
       }
+      const effectiveConfig = await this.buildSpawnConfig(agentId, runtimeConfig);
       const runtimeContext = {
         agentId,
         config: effectiveConfig,
@@ -10789,20 +11768,28 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         tracer: this.tracer
       };
       const runtime = driver.createSession?.(runtimeContext) ?? createChildProcessRuntimeSession(driver, runtimeContext);
+      const liveProcessConfig = {
+        ...runtimeConfig,
+        serverUrl: effectiveConfig.serverUrl,
+        agentCredentialKey: effectiveConfig.agentCredentialKey,
+        agentCredentialId: effectiveConfig.agentCredentialId
+      };
+      const initialSessionId = this.initialAgentProcessSessionId(driver, liveProcessConfig);
+      const restartSessionId = initialSessionId || (driver.requiresSessionInitForDelivery ? liveProcessConfig.sessionId || null : null);
       agentProcess = {
         runtime,
         driver,
         inbox: wakeMessageDeliveredAsInboxUpdate && wakeMessage ? [wakeMessage, ...startingInboxMessages] : startingInboxMessages,
-        config: runtimeConfig,
-        sessionId: runtimeConfig.sessionId || null,
+        config: liveProcessConfig,
+        sessionId: initialSessionId,
         launchId: effectiveLaunchId,
         startupWakeMessage: wakeMessage,
         startupUnreadSummary: unreadSummary,
         startupResumePrompt: resumePrompt,
-        isIdle: false,
         notifications: new RuntimeNotificationState(),
         activityHeartbeat: null,
         startupTimeoutTimer: null,
+        startupReadinessSatisfied: false,
         compactionWatchdog: null,
         compactionStartedAt: null,
         runtimeProgress: new RuntimeProgressState(Date.now()),
@@ -10820,21 +11807,20 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         spawnError: null,
         exitCode: null,
         exitSignal: null,
-        expectedTerminationReason: null,
         stalledRecoverySigtermTimer: null,
-        runtimeProfileTurnControl: runtimeConfig.runtimeProfileControl ? runtimeProfileTurnControl(runtimeConfig.runtimeProfileControl.kind, runtimeConfig.runtimeProfileControl.key, "agent_config") : null,
+        runtimeProfileTurnControl: liveProcessConfig.runtimeProfileControl ? runtimeProfileTurnControl(liveProcessConfig.runtimeProfileControl.kind, liveProcessConfig.runtimeProfileControl.key, "agent_config") : null,
         pendingTrajectory: null,
         gatedSteering: createGatedSteeringState()
       };
       this.startingInboxes.delete(agentId);
       this.agents.set(agentId, agentProcess);
       this.idleAgentConfigs.set(agentId, {
-        config: { ...effectiveConfig, sessionId: effectiveConfig.sessionId || null },
-        sessionId: effectiveConfig.sessionId || null,
+        config: this.buildRestartSafeConfig(runtimeConfig, restartSessionId),
+        sessionId: restartSessionId,
         launchId: effectiveLaunchId
       });
       if (pendingStartRebind) {
-        this.recordStartRebind(agentId, pendingStartRebind, "startup_registered", launchId || null, effectiveLaunchId, agentProcess.sessionId);
+        this.recordStartRebind(agentId, pendingStartRebind, "startup_registered", originalLaunchId, effectiveLaunchId, agentProcess.sessionId);
       }
       this.startRuntimeTrace(agentId, agentProcess, "spawn", wakeMessage ? [wakeMessage] : void 0, runtimeInputTraceAttrs);
       this.agentsStarting.delete(agentId);
@@ -10848,6 +11834,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         this.ackInjectedRuntimeProfileMessages(agentId, [wakeMessage], agentProcess.launchId);
       }
       runtime.on("stdout", (chunkText) => {
+        if (runtime.descriptor.stdout.channel === "structured_protocol") return;
         const current = this.agents.get(agentId);
         if (current) {
           current.recentStdout = pushRecentStdout(current.recentStdout, chunkText);
@@ -10935,17 +11922,24 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           this.clearStalledRecoverySigtermWatchdog(ap);
           const finalCode = ap.exitCode ?? code;
           const finalSignal = ap.exitSignal ?? signal;
-          const startupTimeoutTermination = ap.expectedTerminationReason === "startup_timeout";
-          const expectedTermination = Boolean(ap.expectedTerminationReason);
+          const expectedTerminationReason = ap.gatedSteering.expectedTerminationReason;
+          const startupTimeoutTermination = expectedTerminationReason === "startup_timeout";
+          const startupRequestErrorTermination = expectedTerminationReason === "startup_request_error";
+          const expectedTermination = Boolean(expectedTerminationReason);
           const stickyTerminalFailureDetail = classifyStickyTerminalFailure(ap);
-          const processEndedCleanly = !stickyTerminalFailureDetail && !startupTimeoutTermination && (finalCode === 0 || expectedTermination && !ap.lastRuntimeError);
+          const turnBoundarySatisfied = closeSatisfiedTurnBoundary(ap, expectedTermination);
+          const closeBeforeTurnBoundary = !turnBoundarySatisfied;
+          const processEndedCleanly = !stickyTerminalFailureDetail && !startupTimeoutTermination && !startupRequestErrorTermination && (finalCode === 0 && turnBoundarySatisfied || expectedTermination && !ap.lastRuntimeError);
           const terminalFailureDetail = processEndedCleanly ? null : stickyTerminalFailureDetail ?? classifyTerminalFailure(ap);
           const resumeRecoveryReason = resumeSessionRecoveryReason(ap);
           const shouldColdStartResumeSession = resumeRecoveryReason !== null;
           const summary = summarizeCrash(finalCode, finalSignal);
           this.endRuntimeTrace(ap, processEndedCleanly ? "ok" : "error", {
             outcome: processEndedCleanly ? "process-exit" : "process-crash",
-            expectedTerminationReason: ap.expectedTerminationReason || void 0,
+            expectedTerminationReason: expectedTerminationReason || void 0,
+            runtime_turn_boundary: ap.runtime.descriptor.turnBoundary,
+            runtime_turn_boundary_satisfied: turnBoundarySatisfied,
+            runtime_exit_before_turn_boundary: closeBeforeTurnBoundary || void 0,
             exitCode: finalCode,
             exitSignal: finalSignal,
             ...runtimeTraceCounterAttrs(ap),
@@ -10958,7 +11952,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           if (shouldColdStartResumeSession) {
             const staleSessionId = ap.sessionId;
             const runtimeLabel = resumeSessionRuntimeLabel(ap.driver.id);
-            const restartConfig = { ...stripManagedRunnerCredential(ap.config), sessionId: null };
+            const restartConfig = this.buildRestartSafeConfig(ap.config, null);
             const reasonText = resumeRecoveryReason === "provider_replay_rejected" ? "was rejected by the provider during replay" : "is unavailable locally";
             const activityText = resumeRecoveryReason === "provider_replay_rejected" ? `Stored ${runtimeLabel} session replay rejected; cold-starting a new session\u2026` : `Stored ${runtimeLabel} session missing; cold-starting a new session\u2026`;
             logger.warn(
@@ -10989,7 +11983,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           }
           if (processEndedCleanly) {
             let queuedWakeMessage;
-            if (!ap.driver.supportsStdinNotification || ap.expectedTerminationReason === "stalled_recovery") {
+            if (!ap.driver.supportsStdinNotification || expectedTerminationReason === "stalled_recovery") {
               while (ap.inbox.length > 0) {
                 const candidate = ap.inbox.shift();
                 if (this.shouldDeferWakeMessage(agentId, ap.driver, candidate)) continue;
@@ -11000,7 +11994,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
             const unreadSummary2 = queuedWakeMessage ? buildUnreadSummary(ap.inbox, formatChannelLabel(queuedWakeMessage)) : void 0;
             if (queuedWakeMessage) {
               logger.info(`[Agent ${agentId}] Turn completed; restarting immediately for queued message`);
-              const nextConfig = { ...stripManagedRunnerCredential(ap.config), sessionId: ap.sessionId };
+              const nextConfig = this.buildRestartSafeConfig(ap.config, ap.sessionId);
               this.idleAgentConfigs.set(agentId, {
                 config: nextConfig,
                 sessionId: ap.sessionId,
@@ -11023,7 +12017,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
               return;
             }
             this.idleAgentConfigs.set(agentId, {
-              config: { ...stripManagedRunnerCredential(ap.config), sessionId: ap.sessionId },
+              config: this.buildRestartSafeConfig(ap.config, ap.sessionId),
               sessionId: ap.sessionId,
               launchId: ap.launchId
             });
@@ -11035,7 +12029,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
             const reason = formatCrashReason(finalCode, finalSignal, ap);
             if (terminalFailureDetail && isProviderStreamFailureText(terminalFailureDetail.detail)) {
               this.idleAgentConfigs.set(agentId, {
-                config: { ...ap.config, sessionId: ap.sessionId },
+                config: this.buildRestartSafeConfig(ap.config, ap.sessionId),
                 sessionId: ap.sessionId,
                 launchId: ap.launchId
               });
@@ -11044,13 +12038,16 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
             } else if (startupTimeoutTermination) {
               this.cacheStartupTimeoutRetryConfig(agentId, ap);
               logger.warn(`[Agent ${agentId}] Startup timeout cleanup completed (${reason})`);
+            } else if (startupRequestErrorTermination) {
+              this.idleAgentConfigs.delete(agentId);
+              logger.warn(`[Agent ${agentId}] Startup request failure cleanup completed (${reason})`);
             } else {
               this.idleAgentConfigs.delete(agentId);
               logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
               this.sendAgentStatus(agentId, "inactive", ap.launchId);
             }
             if (terminalFailureDetail) {
-              if (!startupTimeoutTermination) {
+              if (!startupTimeoutTermination && !startupRequestErrorTermination) {
                 this.broadcastActivity(
                   agentId,
                   "error",
@@ -11059,7 +12056,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
                   ap.launchId
                 );
               }
-            } else {
+            } else if (!startupRequestErrorTermination) {
               this.broadcastActivity(agentId, "offline", `Crashed (${summary})`, [], ap.launchId);
             }
           }
@@ -11093,12 +12090,6 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       if (pendingStartRebind && agentProcess.sessionId) {
         this.sendToServer({ type: "agent:session", agentId, sessionId: agentProcess.sessionId, launchId: agentProcess.launchId || void 0 });
       }
-      if (pendingStartRebind?.wakeMessage) {
-        const accepted = this.deliverMessage(agentId, pendingStartRebind.wakeMessage, { transient: pendingStartRebind.wakeMessageTransient === true });
-        if (accepted instanceof Promise) {
-          accepted.catch((err) => logger.error(`[Agent ${agentId}] Failed to deliver wake message after startup rebind`, err));
-        }
-      }
       this.broadcastActivity(agentId, "working", "Starting\u2026");
       this.startRuntimeStartupTimeout(agentId, agentProcess);
     } catch (err) {
@@ -11184,13 +12175,11 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     });
   }
   cacheStartupTimeoutRetryConfig(agentId, ap) {
-    const retryConfig = {
-      ...stripManagedRunnerCredential(ap.config),
-      sessionId: ap.sessionId
-    };
+    const retrySessionId = this.restartSafeSessionId(ap);
+    const retryConfig = this.buildRestartSafeConfig(ap.config, retrySessionId);
     this.idleAgentConfigs.set(agentId, {
       config: retryConfig,
-      sessionId: ap.sessionId,
+      sessionId: retrySessionId,
       launchId: ap.launchId
     });
     this.recordDaemonTrace("daemon.agent.startup_timeout.retry_config_cached", {
@@ -11200,6 +12189,14 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       session_id_present: Boolean(ap.sessionId)
     });
   }
+  buildRestartSafeConfig(config, sessionId) {
+    const stripped = stripManagedRunnerCredential(config);
+    return {
+      ...stripped,
+      serverUrl: this.serverUrl,
+      sessionId
+    };
+  }
   async buildSpawnConfig(agentId, config) {
     const baseConfig = config.serverUrl === this.serverUrl ? config : { ...config, serverUrl: this.serverUrl };
     const runnerConfig = await this.ensureManagedRunnerCredential(agentId, baseConfig);
@@ -11647,6 +12644,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       this.broadcastActivity(agentId, "offline", "Process unavailable; restart required");
       return false;
     }
+    const isIdle = this.isApmIdle(ap);
     if (!transientDelivery && this.shouldDeferWakeMessage(agentId, ap.driver, message)) {
       this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
         outcome: "deferred_wake_message",
@@ -11655,7 +12653,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         runtime: ap.config.runtime,
         session_id_present: Boolean(ap.sessionId),
         launchId: ap.launchId || void 0,
-        is_idle: ap.isIdle,
+        is_idle: isIdle,
         inbox_count: ap.inbox.length
       }));
       return true;
@@ -11670,7 +12668,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           runtime: ap.config.runtime,
           session_id_present: Boolean(ap.sessionId),
           launchId: ap.launchId || void 0,
-          is_idle: ap.isIdle,
+          is_idle: isIdle,
           inbox_count: ap.inbox.length
         }));
         return true;
@@ -11687,7 +12685,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           runtime: ap.config.runtime,
           session_id_present: Boolean(ap.sessionId),
           launchId: ap.launchId || void 0,
-          is_idle: ap.isIdle,
+          is_idle: isIdle,
           inbox_count: ap.inbox.length
         }));
       } else {
@@ -11699,7 +12697,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           runtime: ap.config.runtime,
           session_id_present: Boolean(ap.sessionId),
           launchId: ap.launchId || void 0,
-          is_idle: ap.isIdle,
+          is_idle: isIdle,
           inbox_count: ap.inbox.length
         }));
         this.sendAgentStatus(agentId, "inactive", ap.launchId);
@@ -11710,7 +12708,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     if (!transientDelivery && this.queueDeliveryForRuntimeErrorBackoff(agentId, ap, message)) {
       return true;
     }
-    if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
+    if (isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
       if (transientDelivery) {
         this.commitApmIdleState(agentId, ap, false);
         this.startRuntimeTrace(agentId, ap, "stdin-idle-delivery", [message]);
@@ -11747,7 +12745,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           runtime: ap.config.runtime,
           session_id_present: true,
           launchId: ap.launchId || void 0,
-          is_idle: ap.isIdle,
+          is_idle: isIdle,
           inbox_count: ap.inbox.length,
           pending_notification_count: ap.notifications.pendingCount
         }));
@@ -11786,7 +12784,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         runtime: ap.config.runtime,
         session_id_present: Boolean(ap.sessionId),
         launchId: ap.launchId || void 0,
-        is_idle: ap.isIdle,
+        is_idle: isIdle,
         inbox_count: ap.inbox.length
       }));
       return true;
@@ -11856,6 +12854,34 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       }));
       return true;
     }
+    if (ap.gatedSteering.reviewing) {
+      ap.notifications.add();
+      ap.notifications.clearTimer();
+      if (ap.runtime.descriptor.busyDelivery === "gated") {
+        this.recordGatedSteeringEvent(agentId, ap, "buffer", {
+          reason: "review_boundary",
+          pendingMessages: ap.inbox.length
+        });
+      }
+      this.recordRuntimeTraceEvent(agentId, ap, "runtime.review_boundary.delivery_buffered", {
+        pendingNotificationCount: ap.notifications.pendingCount,
+        pendingMessages: ap.inbox.length,
+        busyDeliveryMode: ap.driver.busyDeliveryMode
+      });
+      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+        outcome: "queued_review_boundary",
+        accepted: true,
+        process_present: true,
+        runtime: ap.config.runtime,
+        session_id_present: true,
+        launchId: ap.launchId || void 0,
+        inbox_count: ap.inbox.length,
+        pending_notification_count: ap.notifications.pendingCount,
+        busy_delivery_mode: ap.driver.busyDeliveryMode,
+        notification_timer_present: false
+      }));
+      return true;
+    }
     if (ap.runtime.descriptor.busyDelivery === "gated") {
       ap.notifications.add();
       if (!ap.notifications.hasTimer) {
@@ -11971,7 +12997,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           path: workspacePath,
           reachable: true
         },
-        sessionRef: sessionId ? resolveRuntimeSessionRef(config.runtime, sessionId, runtimeHomeDir, workspacePath) : null
+        sessionRef: sessionId ? resolveRuntimeSessionRef(config.runtime, sessionId, runtimeHomeDir, workspacePath, { agentId, workingDirectory: workspacePath }) : null
       }
     };
   }
@@ -12040,7 +13066,8 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       traceparent: formatTraceparent(span.context)
     };
     const ap = this.agents.get(agentId);
-    if (ap && !(ap.sessionId && ap.driver.supportsStdinNotification && ap.isIdle) && !(ap.sessionId && ap.runtime.descriptor.busyDelivery === "direct")) {
+    const isIdle = ap ? this.isApmIdle(ap) : false;
+    if (ap && !(ap.sessionId && ap.driver.supportsStdinNotification && isIdle) && !(ap.sessionId && ap.runtime.descriptor.busyDelivery === "direct")) {
       this.enqueueRuntimeProfileNotification(agentId, ap, message, kind, key);
       span.end("ok", {
         attrs: {
@@ -12054,7 +13081,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       });
       return true;
     }
-    if (ap?.sessionId && ap.driver.supportsStdinNotification && ap.isIdle) {
+    if (ap?.sessionId && ap.driver.supportsStdinNotification && isIdle) {
       this.commitApmIdleState(agentId, ap, false);
       this.startRuntimeTrace(agentId, ap, "runtime-profile", [message]);
       const written = this.deliverMessagesViaStdin(agentId, ap, [message], "idle");
@@ -12305,6 +13332,183 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       workspace: [".codex/skills", ".agents/skills"]
     }
   };
+  async getSessionTranscript(agentId) {
+    const agent = this.agents.get(agentId);
+    const idle = this.idleAgentConfigs.get(agentId);
+    const config = agent?.config ?? idle?.config ?? null;
+    const actualSessionId = agent?.sessionId || idle?.sessionId || null;
+    if (!config) {
+      return {
+        runtime: "unknown",
+        sessionId: actualSessionId || "unknown",
+        reachable: false,
+        path: null,
+        fallbackReason: "agent not found or no config",
+        transcript: null,
+        sizeBytes: 0,
+        truncated: false,
+        redacted: false,
+        tier: "unknown"
+      };
+    }
+    const runtime = config.runtime;
+    const workspaceDir = path13.join(this.dataDir, agentId);
+    const homeDir = ensureRuntimeHomeDir(config, this.runtimeSessionHomeDir, workspaceDir);
+    if (!actualSessionId) {
+      return {
+        runtime,
+        sessionId: "unknown",
+        reachable: false,
+        path: null,
+        fallbackReason: "no session id available",
+        transcript: null,
+        sizeBytes: 0,
+        truncated: false,
+        redacted: false,
+        tier: runtimeTier(runtime)
+      };
+    }
+    const ref = resolveRuntimeSessionRef(runtime, actualSessionId, homeDir, workspaceDir, {
+      agentId,
+      workingDirectory: workspaceDir
+    });
+    const tier = runtimeTier(runtime);
+    const span = this.tracer.startSpan("daemon.session_transcript.read", {
+      surface: "daemon",
+      kind: "internal",
+      attrs: {
+        agentId,
+        runtime,
+        sessionId: actualSessionId,
+        reachable: ref.reachable ?? false,
+        tier,
+        lookup_method: ref.reason?.includes("attempted_lookup=") ? ref.reason.split("attempted_lookup=")[1]?.split(";")[0] : "unknown"
+      }
+    });
+    let transcript = null;
+    let sizeBytes = 0;
+    let truncated = false;
+    let redacted = false;
+    if (ref.reachable && ref.path) {
+      try {
+        const resolved = path13.resolve(ref.path);
+        const allowedRoots = allowedTranscriptRootsForRuntime(runtime, homeDir, workspaceDir);
+        if (!await isPathWithinAllowedRoots(resolved, allowedRoots)) {
+          throw new Error("resolved session path is outside allowed runtime directories");
+        }
+        let targetPath = resolved;
+        const info = await lstat(resolved);
+        if (info.isSymbolicLink()) {
+          throw new Error("symbolic links are not allowed");
+        }
+        if (info.isDirectory()) {
+          targetPath = path13.join(resolved, "state.json");
+        }
+        if (!await isPathWithinAllowedRoots(targetPath, allowedRoots)) {
+          throw new Error("resolved session state path is outside allowed runtime directories");
+        }
+        const redactedResult = await readAndRedact(targetPath, SESSION_TRANSCRIPT_MAX_BYTES);
+        if (redactedResult !== null) {
+          transcript = redactedResult.text;
+          sizeBytes = Buffer.byteLength(transcript, "utf8");
+          redacted = true;
+          truncated = redactedResult.truncated;
+        }
+        span.end("ok", { attrs: { transcript_present: Boolean(transcript), size_bytes: sizeBytes, truncated, redacted } });
+      } catch (err) {
+        span.end("error", { attrs: { error_class: err instanceof Error ? err.name : "Error" } });
+      }
+    } else {
+      span.end("ok", { attrs: { transcript_present: false, reason: ref.reason } });
+    }
+    return {
+      runtime,
+      sessionId: actualSessionId,
+      reachable: ref.reachable ?? false,
+      path: ref.path ?? null,
+      fallbackReason: ref.reason ?? void 0,
+      transcript,
+      sizeBytes,
+      truncated,
+      redacted,
+      tier
+    };
+  }
+  /**
+   * Collect the agent's current session transcript and upload it as a trace
+   * bundle linked to a feedback report. The transcript is read using only the
+   * sessionId bound to the agent; no caller-supplied session id is accepted.
+   */
+  async collectFeedbackTranscript(agentId, feedbackReportId) {
+    const transcriptResult = await this.getSessionTranscript(agentId);
+    if (!transcriptResult.reachable || !transcriptResult.transcript) {
+      return {
+        reachable: false,
+        fallbackReason: transcriptResult.fallbackReason ?? "transcript not reachable"
+      };
+    }
+    if (!this.workerUrl) {
+      return {
+        reachable: true,
+        fallbackReason: "daemon worker URL is not configured"
+      };
+    }
+    const span = this.tracer.startSpan("daemon.feedback_transcript.upload", {
+      surface: "daemon",
+      kind: "producer",
+      attrs: {
+        agentId,
+        feedbackReportId,
+        runtime: transcriptResult.runtime,
+        sessionId: transcriptResult.sessionId,
+        transcript_size_bytes: transcriptResult.sizeBytes
+      }
+    });
+    try {
+      const raw = Buffer.from(transcriptResult.transcript, "utf8");
+      const gzipped = gzipSync(raw);
+      const bundleSha256 = createHash3("sha256").update(gzipped).digest("hex");
+      const bundleSizeBytes = gzipped.byteLength;
+      const bundleId = randomUUID5();
+      const uploadResult = await uploadWithSignedCapability({
+        serverUrl: this.serverUrl,
+        apiKey: this.daemonApiKey,
+        workerUrl: this.workerUrl,
+        scope: "daemon-trace-bundle:create",
+        createPath: "/api/trace-bundles",
+        createBody: {
+          bundleSha256,
+          bundleSizeBytes
+        },
+        attestationMetadata: {
+          bundleId,
+          bundleSha256,
+          bundleSizeBytes,
+          bundleContentType: "application/json",
+          bundleContentEncoding: "gzip",
+          feedbackReportId,
+          agentId
+        },
+        uploadBody: new Blob([new Uint8Array(gzipped)], { type: "application/json" }),
+        fetchImpl: this.fetchImpl
+      });
+      const traceBundleId = typeof uploadResult.session.id === "string" ? uploadResult.session.id : bundleId;
+      logger.info(`[FeedbackTranscript] uploaded for report=${feedbackReportId} agent=${agentId} traceBundleId=${traceBundleId} size=${bundleSizeBytes}`);
+      span.end("ok", { attrs: { traceBundleId, bundleSizeBytes } });
+      return {
+        reachable: true,
+        traceBundleId
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger.warn(`[FeedbackTranscript] upload failed for report=${feedbackReportId} agent=${agentId}: ${message}`);
+      span.end("error", { attrs: { error_class: err instanceof Error ? err.name : "Error", error_message: message } });
+      return {
+        reachable: true,
+        error: message
+      };
+    }
+  }
   async listSkills(agentId, runtimeHint) {
     const agent = this.agents.get(agentId);
     const idle = this.idleAgentConfigs.get(agentId);
@@ -12415,6 +13619,17 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       launchId: launchIdOverride || ap?.launchId || void 0,
       clientSeq: ap ? this.nextActivityClientSeq(agentId) : void 0
     });
+    this.recordDaemonTrace("daemon.agent.activity.produced", {
+      agentId,
+      activity,
+      detail_present: Boolean(detail),
+      entry_kinds: entries.map((e) => e.kind).join(","),
+      ap_present: Boolean(ap),
+      launch_id_present: Boolean(launchIdOverride || ap?.launchId),
+      client_seq_present: ap ? true : false,
+      session_id_present: Boolean(ap?.sessionId),
+      runtime: ap?.config.runtime
+    });
     if (ap) {
       ap.lastActivity = activity;
       ap.lastActivityDetail = detail;
@@ -12494,7 +13709,15 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
   }
   queueTrajectoryText(agentId, kind, text) {
     const ap = this.agents.get(agentId);
-    if (!ap) return;
+    if (!ap) {
+      this.recordDaemonTrace("daemon.agent.activity.skipped", {
+        agentId,
+        event_kind: kind,
+        reason: "agent_process_missing",
+        text_length: text.length
+      });
+      return;
+    }
     if (!text) {
       this.broadcastActivity(agentId, "thinking", "");
       return;
@@ -12541,7 +13764,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     ap.stalledRecoverySigtermTimer = setTimeout(() => {
       ap.stalledRecoverySigtermTimer = null;
       const current = this.agents.get(agentId);
-      if (!current || current !== ap || current.runtime !== runtimeAtSignal || current.expectedTerminationReason !== "stalled_recovery") {
+      if (!current || current !== ap || current.runtime !== runtimeAtSignal || current.gatedSteering.expectedTerminationReason !== "stalled_recovery") {
         return;
       }
       this.mergeRuntimeExitTraceAttrs(runtimeAtSignal, {
@@ -12617,6 +13840,25 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     const reduction = reduceApmGatedCompaction(ap.gatedSteering, { kind: "compaction_interrupted" });
     this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState);
   }
+  flushReviewBoundaryMessages(agentId, ap) {
+    const reduction = reduceApmGatedReviewBoundaryFlush(ap.gatedSteering, {
+      hasSession: Boolean(ap.sessionId),
+      supportsStdinNotification: ap.driver.supportsStdinNotification,
+      inboxLength: ap.inbox.length,
+      pendingNotificationCount: ap.notifications.pendingCount
+    });
+    for (const effect of reduction.effects) {
+      this.executeApmGatedSteeringEffect(agentId, ap, effect);
+    }
+  }
+  interruptReviewIfActive(agentId) {
+    const ap = this.agents.get(agentId);
+    if (!ap?.gatedSteering.reviewing) return;
+    const reduction = reduceApmGatedReview(ap.gatedSteering, { kind: "review_finished" });
+    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, {
+      event: "review_interrupted"
+    });
+  }
   messagesTraceAttrs(messages) {
     if (!messages || messages.length === 0) return {};
     const first = messages[0];
@@ -12768,28 +14010,20 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       phase: ap.gatedSteering.phase,
       outstandingToolUses: ap.gatedSteering.outstandingToolUses,
       compacting: ap.gatedSteering.compacting,
+      reviewing: ap.gatedSteering.reviewing === true ? true : void 0,
       toolBoundaryFlushDisabled: ap.gatedSteering.toolBoundaryFlushDisabled,
       pendingMessages: ap.inbox.length,
       ...attrs
     });
   }
   commitGatedSteeringDecisionState(agentId, ap, nextState, phaseEventAttrs) {
-    ap.gatedSteering.phase = nextState.phase;
-    ap.gatedSteering.outstandingToolUses = nextState.outstandingToolUses;
-    ap.gatedSteering.compacting = nextState.compacting;
-    ap.gatedSteering.toolBoundaryFlushDisabled = nextState.toolBoundaryFlushDisabled;
-    ap.gatedSteering.lastFlushReason = nextState.lastFlushReason;
-    ap.gatedSteering.recentEvents = nextState.recentEvents;
-    ap.gatedSteering.isIdle = nextState.isIdle;
-    ap.gatedSteering.expectedTerminationReason = nextState.expectedTerminationReason;
-    ap.isIdle = nextState.isIdle;
-    ap.expectedTerminationReason = nextState.expectedTerminationReason;
+    ap.gatedSteering = commitApmGatedSteeringDecisionState(nextState);
     if (phaseEventAttrs) {
       this.recordGatedSteeringEvent(agentId, ap, "phase", phaseEventAttrs);
     }
   }
-  commitApmIdleState(agentId, ap, isIdle) {
-    const reduction = reduceApmIdleState(ap.gatedSteering, { isIdle });
+  commitApmIdleState(agentId, ap, nextIsIdle) {
+    const reduction = reduceApmIdleState(ap.gatedSteering, { isIdle: nextIsIdle });
     this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState);
   }
   notifyGatedSteeringBoundary(agentId, ap, reason) {
@@ -12932,11 +14166,17 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     clearTimeout(ap.startupTimeoutTimer);
     ap.startupTimeoutTimer = null;
   }
+  runtimeStartupReadinessSatisfiedByEvent(ap, event) {
+    if ((ap.driver.startupReadiness ?? "first_event") !== "initial_turn") {
+      return true;
+    }
+    return event.kind !== "session_init" && event.kind !== "internal_progress" && event.kind !== "runtime_diagnostic";
+  }
   handleRuntimeStartupTimeout(agentId, ap, timeoutMs) {
     const current = this.agents.get(agentId);
     if (current !== ap) return;
     const reduction = reduceApmStartupTimeoutTermination(ap.gatedSteering, {
-      hasRuntimeProgressEvent: Boolean(ap.runtimeProgress.lastEventKind)
+      hasRuntimeProgressEvent: ap.startupReadinessSatisfied
     });
     if (!reduction.shouldTerminate) {
       this.clearRuntimeStartupTimeout(ap);
@@ -12951,37 +14191,86 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     ap.runtimeProgress.markStale();
     const staleForMs = Math.max(timeoutMs, ap.runtimeProgress.ageMs());
     const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, Math.max(1, Math.floor(staleForMs / 6e4)));
-    this.recordRuntimeTraceEvent(agentId, ap, "runtime.start.timeout", {
-      turn_outcome: "failed",
-      turn_subtype: "runtime_stalled",
-      turn_reason: "no_runtime_events",
-      runtime_start_failure_kind: "runtime_start_timeout",
-      timeout_ms: timeoutMs,
+    const projection = projectApmRuntimeTerminationTrace({
+      reason: "startup_timeout",
+      timeoutMs
+    });
+    this.recordRuntimeTraceEvent(agentId, ap, projection.runtimeEventName, {
+      ...projection.runtimeEventAttrs,
       ...diagnostic.traceAttrs
     });
     this.endRuntimeTrace(ap, "error", {
-      turn_outcome: "failed",
-      turn_subtype: "runtime_stalled",
-      turn_reason: "no_runtime_events",
-      runtime_start_failure_kind: "runtime_start_timeout",
-      timeout_ms: timeoutMs,
+      ...projection.runtimeSpanAttrs,
       ...runtimeTraceCounterAttrs(ap),
       ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_stalled")
     });
-    logger.warn(`[Agent ${agentId}] ${ap.driver.id} did not emit a startup runtime event within ${timeoutMs}ms; terminating process`);
+    logger.warn(`[Agent ${agentId}] ${ap.driver.id} did not reach startup readiness within ${timeoutMs}ms; terminating process`);
     this.broadcastActivity(agentId, "error", detail, [{ kind: "text", text: `Error: ${detail}` }], ap.launchId);
     this.sendAgentStatus(agentId, "inactive", ap.launchId);
     this.cacheStartupTimeoutRetryConfig(agentId, ap);
+    try {
+      this.runtimeExitTraceAttrs.set(ap.runtime, projection.processExitAttrs);
+      void ap.runtime.stop({ signal: "SIGTERM", reason: projection.runtimeStopReason });
+    } 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}`);
+    }
+  }
+  handleRuntimeStartupRequestError(agentId, ap, event) {
+    const current = this.agents.get(agentId);
+    if (current !== ap) return;
+    this.clearRuntimeStartupTimeout(ap);
+    this.interruptCompactionIfActive(agentId);
+    this.interruptReviewIfActive(agentId);
+    this.flushPendingTrajectory(agentId);
+    const reduction = reduceApmStartupRequestErrorTermination(ap.gatedSteering);
+    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "startup_request_error" });
+    ap.lastRuntimeError = event.message;
+    ap.runtimeErrorSinceProgress = true;
+    ap.runtimeProgress.markStale();
+    ap.notifications.clearPending();
+    ap.notifications.clearTimer();
+    const diagnostics = buildRuntimeErrorDiagnosticEnvelope(event.message);
+    const visibleErrorMessage = diagnostics.spanAttrs.runtime_error_action_required === true ? formatRuntimeLoginRequiredMessage(ap.driver.id) : event.message;
+    const failureAttrs = {
+      turn_outcome: "failed",
+      turn_subtype: "runtime_start_failed",
+      turn_reason: "startup_request_error",
+      runtime_start_failure_kind: "startup_request_error",
+      startup_request_method: event.startupRequestMethod,
+      ...diagnostics.eventAttrs
+    };
+    this.noteRuntimeTraceCounter(ap, event);
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.event.received", {
+      kind: event.kind,
+      startup_request_method: event.startupRequestMethod
+    });
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.start.request_failed", failureAttrs);
+    this.endRuntimeTrace(ap, "error", {
+      ...failureAttrs,
+      ...diagnostics.spanAttrs,
+      ...runtimeTraceCounterAttrs(ap),
+      ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_error")
+    });
+    logger.warn(
+      `[Agent ${agentId}] ${ap.driver.id} startup request ${event.startupRequestMethod} failed; terminating unusable runtime process`
+    );
+    this.broadcastActivity(agentId, "error", visibleErrorMessage, [
+      { kind: "text", text: `Error: ${visibleErrorMessage}` }
+    ], ap.launchId);
+    this.sendAgentStatus(agentId, "inactive", ap.launchId);
+    this.idleAgentConfigs.delete(agentId);
     try {
       this.runtimeExitTraceAttrs.set(ap.runtime, {
-        stop_source: "startup_timeout",
-        expectedTerminationReason: "startup_timeout",
-        timeout_ms: timeoutMs
+        stop_source: "startup_request_error",
+        expectedTerminationReason: "startup_request_error",
+        startup_request_method: event.startupRequestMethod,
+        runtime_error_class: diagnostics.spanAttrs.runtime_error_class
       });
-      void ap.runtime.stop({ signal: "SIGTERM", reason: "startup_timeout" });
+      void ap.runtime.stop({ signal: "SIGTERM", reason: "startup_request_error" });
     } 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}`);
+      logger.warn(`[Agent ${agentId}] Failed to terminate startup-failed ${ap.driver.id} process: ${reason}`);
     }
   }
   isThinkingBlockMutationError(message) {
@@ -12995,21 +14284,19 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     ap.runtimeProgress.markStale();
     const staleForMinutes = Math.max(1, Math.floor(staleForMs / 6e4));
     const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes);
-    const turnReason = classifyRuntimeStallReason(ap);
-    this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.stalled", {
-      turn_outcome: "failed",
-      turn_subtype: "runtime_stalled",
-      turn_reason: turnReason,
+    const projection = projectApmRuntimeProgressStalledTrace({
+      turnReason: diagnostic.turnReason,
+      staleForMs,
+      lastActivity: ap.lastActivity,
+      lastActivityDetailPresent: diagnostic.lastActivityDetailPresent,
+      lastActivityDetailKind: diagnostic.lastActivityDetailKind
+    });
+    this.recordRuntimeTraceEvent(agentId, ap, projection.runtimeEventName, {
+      ...projection.runtimeEventAttrs,
       ...diagnostic.traceAttrs
     });
     this.endRuntimeTrace(ap, "error", {
-      turn_outcome: "failed",
-      turn_subtype: "runtime_stalled",
-      turn_reason: turnReason,
-      ageMs: staleForMs,
-      lastActivity: ap.lastActivity,
-      lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
-      lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail),
+      ...projection.runtimeSpanAttrs,
       ...runtimeTraceCounterAttrs(ap),
       ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_stalled")
     });
@@ -13036,25 +14323,22 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     const staleForMinutes = Math.max(1, Math.floor(staleForMs / 6e4));
     ap.runtimeProgress.markStale();
     const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes);
-    const turnReason = classifyRuntimeStallReason(ap);
-    this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.stalled", {
-      turn_outcome: "failed",
-      turn_subtype: "runtime_stalled",
-      turn_reason: turnReason,
-      ...diagnostic.traceAttrs,
+    const projection = projectApmRuntimeTerminationTrace({
+      reason: "stalled_recovery",
+      turnReason: diagnostic.turnReason,
+      staleForMs,
+      lastActivity: ap.lastActivity,
+      lastActivityDetailPresent: diagnostic.lastActivityDetailPresent,
+      lastActivityDetailKind: diagnostic.lastActivityDetailKind,
       pendingMessages: ap.inbox.length,
-      recovery: "terminate_for_queued_message"
+      recoveryAction: "terminate_for_queued_message"
+    });
+    this.recordRuntimeTraceEvent(agentId, ap, projection.runtimeEventName, {
+      ...projection.runtimeEventAttrs,
+      ...diagnostic.traceAttrs
     });
     this.endRuntimeTrace(ap, "error", {
-      turn_outcome: "failed",
-      turn_subtype: "runtime_stalled",
-      turn_reason: turnReason,
-      ageMs: staleForMs,
-      lastActivity: ap.lastActivity,
-      lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
-      lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail),
-      pendingMessages: ap.inbox.length,
-      recovery: "terminate_for_queued_message",
+      ...projection.runtimeSpanAttrs,
       ...runtimeTraceCounterAttrs(ap),
       ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_stalled")
     });
@@ -13064,13 +14348,9 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     );
     this.broadcastActivity(agentId, "working", `Restarting stalled ${runtimeLabel} runtime for queued message`);
     try {
-      this.runtimeExitTraceAttrs.set(ap.runtime, {
-        stop_source: "stalled_recovery",
-        expectedTerminationReason: "stalled_recovery",
-        queued_messages_count: ap.inbox.length
-      });
+      this.runtimeExitTraceAttrs.set(ap.runtime, projection.processExitAttrs);
       this.startStalledRecoverySigtermWatchdog(agentId, ap, runtimeLabel, ap.inbox.length, staleForMs);
-      void ap.runtime.stop({ signal: "SIGTERM", reason: "stalled_recovery" });
+      void ap.runtime.stop({ signal: "SIGTERM", reason: projection.runtimeStopReason });
     } catch (err) {
       this.clearStalledRecoverySigtermWatchdog(ap);
       const reason = err instanceof Error ? err.message : String(err);
@@ -13086,16 +14366,23 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       if (ap) this.recordRuntimeTelemetry(agentId, ap, event);
       return;
     }
+    if (ap && isStartupRequestErrorEvent(event)) {
+      this.handleRuntimeStartupRequestError(agentId, ap, event);
+      return;
+    }
     if (ap) {
       const wasStalled = ap.runtimeProgress.isStale;
-      this.clearRuntimeStartupTimeout(ap);
+      if (this.runtimeStartupReadinessSatisfiedByEvent(ap, event)) {
+        ap.startupReadinessSatisfied = true;
+        this.clearRuntimeStartupTimeout(ap);
+      }
       this.noteRuntimeTraceCounter(ap, event);
       const eventAttrs = event.kind === "internal_progress" ? {
         kind: event.kind,
         source: event.source,
         itemType: event.itemType,
         payloadBytes: event.payloadBytes
-      } : { kind: event.kind };
+      } : event.kind === "runtime_diagnostic" ? runtimeDiagnosticTraceAttrs(event) : { kind: event.kind };
       this.recordRuntimeTraceEvent(agentId, ap, "runtime.event.received", eventAttrs);
       if (wasStalled) {
         this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.observed", { afterStall: true });
@@ -13116,7 +14403,19 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         });
         return;
       }
+      if (event.kind === "runtime_diagnostic") {
+        this.noteRuntimeProgress(ap, event.kind);
+        this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
+        this.recordRuntimeDiagnosticActivity(agentId, ap, event);
+        return;
+      }
       this.noteRuntimeProgress(ap, event.kind);
+    } else if (event.kind !== "internal_progress") {
+      this.recordDaemonTrace("daemon.agent.event.received_without_process", {
+        agentId,
+        event_kind: event.kind,
+        runtime: driver.id
+      });
     }
     switch (event.kind) {
       case "session_init":
@@ -13206,6 +14505,25 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           this.flushCompactionBoundaryMessages(agentId, ap);
         }
         break;
+      case "review_started":
+        this.flushPendingTrajectory(agentId);
+        if (ap) this.recordRuntimeTraceEvent(agentId, ap, "runtime.review_mode.started");
+        this.broadcastActivity(agentId, "working", "Reviewing changes");
+        if (ap) {
+          const reduction = reduceApmGatedReview(ap.gatedSteering, { kind: "review_started" });
+          this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "review_started" });
+        }
+        break;
+      case "review_finished":
+        this.flushPendingTrajectory(agentId);
+        if (ap) this.recordRuntimeTraceEvent(agentId, ap, "runtime.review_mode.finished");
+        this.broadcastActivity(agentId, "working", "Review finished");
+        if (ap) {
+          const reduction = reduceApmGatedReview(ap.gatedSteering, { kind: "review_finished" });
+          this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "review_finished" });
+          this.flushReviewBoundaryMessages(agentId, ap);
+        }
+        break;
       case "turn_end":
         if (ap) this.recordRuntimeTraceEvent(agentId, ap, "runtime.turn.completed");
         this.completeCompactionIfActive(agentId, "Context compaction finished (inferred from turn end)", {
@@ -13257,12 +14575,10 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           });
           if (ap.driver.terminateProcessOnTurnEnd) {
             logger.info(`[Agent ${agentId}] Turn completed; terminating ${ap.driver.id} process`);
+            const projection = projectApmRuntimeTerminationTrace({ reason: "turn_end" });
             try {
-              this.runtimeExitTraceAttrs.set(ap.runtime, {
-                stop_source: "turn_end",
-                expectedTerminationReason: "turn_end"
-              });
-              void ap.runtime.stop({ signal: "SIGTERM", reason: "turn_end" });
+              this.runtimeExitTraceAttrs.set(ap.runtime, projection.processExitAttrs);
+              void ap.runtime.stop({ signal: "SIGTERM", reason: projection.runtimeStopReason });
             } 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}`);
@@ -13276,6 +14592,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         break;
       case "error": {
         this.interruptCompactionIfActive(agentId);
+        this.interruptReviewIfActive(agentId);
         this.flushPendingTrajectory(agentId);
         if (ap) {
           ap.lastRuntimeError = event.message;
@@ -13459,7 +14776,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     if (!ap) return false;
     const count = ap.notifications.takePendingAndClearTimer();
     if (count === 0) return false;
-    if (ap.isIdle) return false;
+    if (this.isApmIdle(ap)) return false;
     if (!ap.sessionId) return false;
     const runtimeErrorBackoffRemainingMs = this.runtimeErrorDeliveryBackoffRemainingMs(ap);
     if (runtimeErrorBackoffRemainingMs > 0) {
@@ -13494,6 +14811,18 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       );
       return false;
     }
+    if (ap.gatedSteering.reviewing) {
+      this.recordRuntimeTraceEvent(agentId, ap, "runtime.review_boundary.delivery_suppressed", {
+        pendingNotificationCount: count,
+        pendingMessages: ap.inbox.length,
+        busyDeliveryMode: ap.driver.busyDeliveryMode
+      });
+      ap.notifications.add(count);
+      logger.info(
+        `[Agent ${agentId}] Suppressing stdin delivery until review mode finishes; pending=${ap.inbox.length}`
+      );
+      return false;
+    }
     const inboxCount = ap.inbox.length;
     if (inboxCount === 0) return false;
     ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
@@ -13761,12 +15090,12 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
     const traceSource = options.transient ? `stdin_${mode}_transient_delivery` : `stdin_${mode}_delivery`;
     const prompt = formatRuntimeProfileControlPrompt(messages) ?? (messages.length === 1 ? `New message received:
 
-${formatIncomingMessage(messages[0])}
+${formatIncomingMessage(messages[0], incomingMessageFormatOptionsForDriver(ap.driver))}
 
 Respond as appropriate. Complete all your work before stopping.
 ${RESPONSE_TARGET_HINT}` : `New messages received:
 
-${messages.map((message) => formatIncomingMessage(message)).join("\n")}
+${messages.map((message) => formatIncomingMessage(message, incomingMessageFormatOptionsForDriver(ap.driver))).join("\n")}
 
 Respond as appropriate. Complete all your work before stopping.
 ${RESPONSE_TARGET_HINT}`);
@@ -14211,8 +15540,8 @@ var ReminderCache = class {
 };
 
 // src/machineLock.ts
-import { createHash as createHash4, randomUUID as randomUUID5 } from "crypto";
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync6, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
+import { createHash as createHash4, randomUUID as randomUUID6 } from "crypto";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync7, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
 import os7 from "os";
 import path14 from "path";
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
@@ -14240,7 +15569,7 @@ function ownerPath(lockDir) {
 }
 function readOwner(lockDir) {
   try {
-    return JSON.parse(readFileSync6(ownerPath(lockDir), "utf8"));
+    return JSON.parse(readFileSync7(ownerPath(lockDir), "utf8"));
   } catch {
     return null;
   }
@@ -14268,7 +15597,7 @@ function acquireDaemonMachineLock(options) {
   const lockId = getDaemonMachineLockId(options.apiKey);
   const machineDir = path14.join(rootDir, lockId);
   const lockDir = path14.join(machineDir, "daemon.lock");
-  const token = randomUUID5();
+  const token = randomUUID6();
   mkdirSync6(machineDir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
@@ -14498,232 +15827,11 @@ function isDiagnosticErrorAttr(key) {
 }
 
 // src/traceBundleUpload.ts
-import { createHash as createHash6, randomUUID as randomUUID6 } from "crypto";
-import { gzipSync } from "zlib";
+import { createHash as createHash6, randomUUID as randomUUID7 } from "crypto";
+import { gzipSync as gzipSync2 } from "zlib";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
 import path16 from "path";
 
-// src/chatBridgeRequest.ts
-var DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS = Number.parseInt(
-  process.env.SLOCK_CHAT_BRIDGE_TOOL_TIMEOUT_MS || "",
-  10
-) || 6e4;
-var ChatBridgeToolTimeoutError = class extends Error {
-  toolName;
-  target;
-  timeoutMs;
-  durationMs;
-  constructor(toolName, target, timeoutMs, durationMs) {
-    super(`${toolName} timed out after ${timeoutMs}ms${target ? ` (target: ${target})` : ""}`);
-    this.name = "ChatBridgeToolTimeoutError";
-    this.toolName = toolName;
-    this.target = target;
-    this.timeoutMs = timeoutMs;
-    this.durationMs = durationMs;
-  }
-};
-function describeError(err) {
-  if (err instanceof Error) return `${err.name}: ${err.message}`;
-  return String(err);
-}
-async function executeJsonRequest(url, init, {
-  toolName,
-  target = null,
-  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
-  fetchImpl,
-  now = () => Date.now(),
-  warn = (message) => logger.warn(message)
-}) {
-  const startedAt = now();
-  const timeoutController = new AbortController();
-  const signals = [timeoutController.signal];
-  if (init.signal) signals.push(init.signal);
-  const signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
-  const timeout = setTimeout(() => {
-    timeoutController.abort();
-  }, timeoutMs);
-  timeout.unref?.();
-  try {
-    const response = await fetchImpl(url, { ...init, signal });
-    const data = await response.json();
-    return { response, data, durationMs: now() - startedAt };
-  } catch (err) {
-    const durationMs = now() - startedAt;
-    if (timeoutController.signal.aborted && !init.signal?.aborted) {
-      warn(
-        `[ChatBridgeTimeout] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} timeout_ms=${timeoutMs} outcome=timeout`
-      );
-      throw new ChatBridgeToolTimeoutError(toolName, target, timeoutMs, durationMs);
-    }
-    warn(
-      `[ChatBridgeError] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} outcome=error error=${describeError(err)}`
-    );
-    throw err;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-async function executeResponseRequest(url, init, {
-  toolName,
-  target = null,
-  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
-  fetchImpl,
-  now = () => Date.now(),
-  warn = (message) => logger.warn(message)
-}) {
-  const startedAt = now();
-  const timeoutController = new AbortController();
-  const signals = [timeoutController.signal];
-  if (init.signal) signals.push(init.signal);
-  const signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
-  const timeout = setTimeout(() => {
-    timeoutController.abort();
-  }, timeoutMs);
-  timeout.unref?.();
-  try {
-    const response = await fetchImpl(url, { ...init, signal });
-    return { response, durationMs: now() - startedAt };
-  } catch (err) {
-    const durationMs = now() - startedAt;
-    if (timeoutController.signal.aborted && !init.signal?.aborted) {
-      warn(
-        `[ChatBridgeTimeout] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} timeout_ms=${timeoutMs} outcome=timeout`
-      );
-      throw new ChatBridgeToolTimeoutError(toolName, target, timeoutMs, durationMs);
-    }
-    warn(
-      `[ChatBridgeError] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} outcome=error error=${describeError(err)}`
-    );
-    throw err;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-// src/directUploadCapability.ts
-function joinUrl(base, path18) {
-  return `${base.replace(/\/+$/, "")}${path18}`;
-}
-function jsonHeaders(apiKey) {
-  return {
-    "Content-Type": "application/json",
-    ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
-  };
-}
-async function requestDaemonScopeAttestation({
-  serverUrl,
-  apiKey,
-  scope,
-  metadata,
-  fetchImpl = daemonFetch,
-  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS
-}) {
-  const { response, data } = await executeJsonRequest(
-    joinUrl(serverUrl, "/internal/machine/scope-attestation"),
-    {
-      method: "POST",
-      headers: jsonHeaders(apiKey),
-      body: JSON.stringify({
-        scope,
-        ...metadata ? { metadata } : {}
-      })
-    },
-    {
-      toolName: "daemon_direct_upload.scope_attestation",
-      target: scope,
-      timeoutMs,
-      fetchImpl
-    }
-  );
-  if (!response.ok) {
-    throw new Error(`Failed to request daemon scope attestation (${response.status})`);
-  }
-  return data;
-}
-async function createDirectUploadSession({
-  serverUrl,
-  apiKey,
-  workerUrl,
-  scope,
-  createPath = "/api/uploads",
-  body,
-  attestationMetadata,
-  fetchImpl = daemonFetch,
-  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS
-}) {
-  const capability = await requestDaemonScopeAttestation({
-    serverUrl,
-    apiKey,
-    scope,
-    metadata: attestationMetadata,
-    fetchImpl,
-    timeoutMs
-  });
-  const { response, data } = await executeJsonRequest(
-    joinUrl(workerUrl, createPath),
-    {
-      method: "POST",
-      headers: jsonHeaders(),
-      body: JSON.stringify({
-        ...body,
-        attestation: capability.attestation
-      })
-    },
-    {
-      toolName: "daemon_direct_upload.create",
-      target: capability.audience,
-      timeoutMs,
-      fetchImpl
-    }
-  );
-  if (!response.ok) {
-    throw new Error(`Failed to create direct upload session (${response.status})`);
-  }
-  return { capability, response: data };
-}
-async function uploadWithSignedCapability({
-  serverUrl,
-  apiKey,
-  workerUrl,
-  scope,
-  createPath = "/api/uploads",
-  createBody,
-  attestationMetadata,
-  uploadBody,
-  fetchImpl = daemonFetch,
-  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS
-}) {
-  const { capability, response: session } = await createDirectUploadSession({
-    serverUrl,
-    apiKey,
-    workerUrl,
-    scope,
-    createPath,
-    body: createBody,
-    attestationMetadata,
-    fetchImpl,
-    timeoutMs
-  });
-  const { response: uploadResponse } = await executeResponseRequest(
-    session.upload.url,
-    {
-      method: session.upload.method,
-      headers: session.upload.headers ?? {},
-      body: uploadBody
-    },
-    {
-      toolName: "daemon_direct_upload.put",
-      target: capability.audience,
-      timeoutMs,
-      fetchImpl
-    }
-  );
-  if (!uploadResponse.ok) {
-    throw new Error(`Failed to upload with signed capability (${uploadResponse.status})`);
-  }
-  return { capability, session, uploadResponse };
-}
-
 // src/traceJitter.ts
 import { createHash as createHash5 } from "crypto";
 var INITIAL_UPLOAD_DELAY_SPAN_MS = 3e4;
@@ -14864,9 +15972,9 @@ var DaemonTraceBundleUploader = class {
         span?.end("cancelled", { attrs: { outcome: "empty" } });
         return false;
       }
-      const gzipped = gzipSync(raw);
+      const gzipped = gzipSync2(raw);
       const bundleSha256 = sha256Hex(gzipped);
-      const bundleId = randomUUID6();
+      const bundleId = randomUUID7();
       await uploadWithSignedCapability({
         serverUrl: this.options.serverUrl,
         apiKey: this.options.apiKey,
@@ -15006,6 +16114,15 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
   },
   "daemon.connection.local_disconnect_observed": {
     spanAttrs: ["running_agents_count", "idle_agents_count"]
+  },
+  "daemon.agent.activity.produced": {
+    spanAttrs: ["agentId", "activity", "detail_present", "entry_kinds", "ap_present", "launch_id_present", "client_seq_present", "session_id_present", "runtime"]
+  },
+  "daemon.agent.activity.skipped": {
+    spanAttrs: ["agentId", "event_kind", "reason", "text_length"]
+  },
+  "daemon.agent.event.received_without_process": {
+    spanAttrs: ["agentId", "event_kind", "runtime"]
   }
 };
 var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
@@ -15083,7 +16200,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-KVBO6CH7.js");
+  await import("./dist-DSRBN3VD.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -15193,6 +16310,10 @@ function summarizeIncomingMessage(msg) {
       return `(agent=${msg.agentId}, path=${msg.path})`;
     case "agent:skills:list":
       return `(agent=${msg.agentId}, runtime=${msg.runtime || "auto"})`;
+    case "agent:diagnostic:session_transcript":
+      return `(agent=${msg.agentId})`;
+    case "agent:diagnostic:feedback_transcript":
+      return `(agent=${msg.agentId}, feedbackReportId=${msg.feedbackReportId})`;
     case "agent:activity_probe":
       return `(agent=${msg.agentId}, probe=${msg.probeId.slice(0, 8)}, purpose=${msg.purpose})`;
     case "machine:workspace:delete":
@@ -15251,6 +16372,7 @@ var DaemonCore = class {
     });
     let connection;
     this.agentsDataDir = options.dataDir ?? resolveSlockHomePath("agents", this.slockHome);
+    const traceUploadDisabled = process.env.SLOCK_DAEMON_TRACE_UPLOAD_DISABLED === "1";
     const agentManagerOptions = {
       dataDir: this.agentsDataDir,
       serverUrl: options.serverUrl,
@@ -15258,7 +16380,8 @@ var DaemonCore = class {
       slockCliPath: this.slockCliPath,
       tracer: this.tracer,
       daemonVersion: this.daemonVersion,
-      computerVersion: this.computerVersion
+      computerVersion: this.computerVersion,
+      workerUrl: traceUploadDisabled ? void 0 : process.env.SLOCK_DAEMON_TRACE_UPLOAD_URL || DEFAULT_TRACE_UPLOAD_URL
     };
     this.agentManager = options.agentManagerFactory ? options.agentManagerFactory((msg) => connection.send(msg), options.apiKey, agentManagerOptions) : new AgentProcessManager((msg) => connection.send(msg), options.apiKey, agentManagerOptions);
     const connectionFactory = options.connectionFactory ?? ((connOptions) => new DaemonConnection(connOptions));
@@ -15687,6 +16810,49 @@ var DaemonCore = class {
           this.connection.send({ type: "agent:skills:list_result", agentId: msg.agentId, global: [], workspace: [] });
         });
         break;
+      case "agent:diagnostic:session_transcript":
+        this.agentManager.getSessionTranscript(msg.agentId).then((result) => {
+          this.connection.send({ type: "agent:diagnostic:session_transcript_result", agentId: msg.agentId, requestId: msg.requestId, ...result });
+        }).catch((err) => {
+          logger.error(`[Daemon] Failed to get session transcript for ${msg.agentId}`, err);
+          this.connection.send({
+            type: "agent:diagnostic:session_transcript_result",
+            agentId: msg.agentId,
+            requestId: msg.requestId,
+            runtime: "unknown",
+            sessionId: "unknown",
+            reachable: false,
+            path: null,
+            transcript: null,
+            sizeBytes: 0,
+            truncated: false,
+            redacted: false,
+            tier: "unknown",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+        break;
+      case "agent:diagnostic:feedback_transcript":
+        this.agentManager.collectFeedbackTranscript(msg.agentId, msg.feedbackReportId).then((result) => {
+          this.connection.send({
+            type: "agent:diagnostic:feedback_transcript_result",
+            agentId: msg.agentId,
+            feedbackReportId: msg.feedbackReportId,
+            requestId: msg.requestId,
+            ...result
+          });
+        }).catch((err) => {
+          logger.error(`[Daemon] Failed to collect feedback transcript for ${msg.agentId}`, err);
+          this.connection.send({
+            type: "agent:diagnostic:feedback_transcript_result",
+            agentId: msg.agentId,
+            feedbackReportId: msg.feedbackReportId,
+            requestId: msg.requestId,
+            reachable: false,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+        break;
       case "agent:activity_probe":
         this.agentManager.respondToActivityProbe(msg.agentId, msg.probeId);
         break;