@botiverse/raft-daemon 0.67.0 → 0.69.0-play.20260704183824

package/dist/{chunk-H3WRFI54.js → chunk-FRBMWZ3P.js}

@@ -3288,6 +3288,7 @@ var AGENT_ACTIVITY_DETAIL_KINDS = [
   "compaction_stale",
   "reviewing_changes",
   "review_finished",
+  "review_stale",
   "runtime_reconnecting",
   "runtime_error",
   "runtime_crashed",
@@ -3303,6 +3304,14 @@ var AGENT_ACTIVITY_DETAIL_KINDS = [
   "synthetic_repair",
   "slock_action",
   "system_message",
+  // Generic structured runtime-progress heartbeat (Claude --include-partial-messages
+  // stream events / system status) — a "working" liveness signal with no rendered
+  // content. NOT a subagent. (APM 1.6 6a)
+  "runtime_progress",
+  // A subagent (Claude `Agent` tool) lifecycle/activity row, marked from explicit
+  // parent_tool_use_id / task-lifecycle lineage — never inferred from display text.
+  // (APM 1.6 6b)
+  "subagent_activity",
   "other"
 ];
 var isAgentActivityDetailKind = makeIsMember(AGENT_ACTIVITY_DETAIL_KINDS);
@@ -4700,6 +4709,19 @@ function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.
   return candidates.filter((candidate) => existsSync(candidate.path));
 }
 
+// src/authEnv.ts
+var DAEMON_API_KEY_ENV = "SLOCK_MACHINE_API_KEY";
+var SLOCK_AGENT_TOKEN_ENV = "SLOCK_AGENT_TOKEN";
+function scrubDaemonAuthEnv(env) {
+  delete env[DAEMON_API_KEY_ENV];
+  return env;
+}
+function scrubDaemonChildEnv(env) {
+  delete env[DAEMON_API_KEY_ENV];
+  delete env[SLOCK_AGENT_TOKEN_ENV];
+  return env;
+}
+
 // src/agentCredentialProxy.ts
 import { randomBytes } from "crypto";
 import http from "http";
@@ -5875,27 +5897,44 @@ function writeProxyFailureResponse(res, failure) {
     res.destroy();
     return;
   }
-  res.writeHead(502, { "content-type": "application/json" });
-  res.end(JSON.stringify({
-    error: "failed to proxy local agent request",
-    code: "agent_proxy_failed",
+  const body = {
+    error: failure.responseError ?? "failed to proxy local agent request",
+    code: failure.responseCode ?? "agent_proxy_failed",
     detail: failure.errorMessage
-  }));
+  };
+  if (failure.lifecycleInvalidAgentId) body.agent_id = failure.lifecycleInvalidAgentId;
+  if (failure.lifecycleInvalidContext) body.invariant_context = failure.lifecycleInvalidContext;
+  res.writeHead(failure.responseStatusCode ?? 502, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
 }
 function proxyFailureForError(method, target, err) {
   const queryKeys = target ? [.../* @__PURE__ */ new Set([...target.searchParams.keys()])].sort() : [];
   const cause = err instanceof Error ? err.cause : void 0;
+  const errorMessage = truncateProxyErrorMessage(err instanceof Error ? err.message : String(err));
+  const lifecycleInvalid = parseAgentNoProcessResidencyInvariant(errorMessage);
   const failure = {
     method,
     pathname: target?.pathname ?? "unknown",
     queryKeys,
     errorName: err instanceof Error ? err.name : typeof err,
-    errorMessage: truncateProxyErrorMessage(err instanceof Error ? err.message : String(err))
+    errorMessage
   };
+  if (lifecycleInvalid) {
+    failure.responseStatusCode = 409;
+    failure.responseCode = "agent_lifecycle_state_invalid";
+    failure.responseError = "local daemon agent lifecycle state invalid";
+    failure.lifecycleInvalidAgentId = lifecycleInvalid.agentId;
+    failure.lifecycleInvalidContext = lifecycleInvalid.context;
+  }
   const errorCause = describeProxyErrorCause(cause);
   if (errorCause) failure.errorCause = errorCause;
   return failure;
 }
+function parseAgentNoProcessResidencyInvariant(message) {
+  const match = /^Agent no-process residency invariant violation after ([^:]+): .+ for ([0-9a-f-]{36})\b/i.exec(message);
+  if (!match) return void 0;
+  return { context: match[1], agentId: match[2] };
+}
 function describeProxyErrorCause(cause) {
   if (!cause) return void 0;
   if (cause instanceof Error) {
@@ -5932,18 +5971,21 @@ function transportNormalizedErrorForHttpStatus(target, status, launchId) {
   };
 }
 function transportNormalizedErrorForError(target, err, launchId) {
+  const localDaemonStateInvalid = parseAgentNoProcessResidencyInvariant(
+    sanitizeTransportOriginalMessage(err instanceof Error ? err.message : String(err))
+  );
   return {
-    normalizedCode: "transport_failure",
+    normalizedCode: localDaemonStateInvalid ? "local_daemon_state_invalid" : "transport_failure",
     routeFamily: routeFamilyForPath(target?.pathname ?? "unknown"),
     responseStarted: false,
-    upstreamLayer: target ? upstreamLayerForProxyError(err) : "unknown",
+    upstreamLayer: localDaemonStateInvalid ? "unknown" : target ? upstreamLayerForProxyError(err) : "unknown",
     originalMessage: sanitizeTransportOriginalMessage(err instanceof Error ? err.message : String(err)),
     launchId,
-    targetHostClass: target ? daemonUpstreamTargetHostClass(target) : "custom_server",
+    targetHostClass: localDaemonStateInvalid ? "local_daemon" : target ? daemonUpstreamTargetHostClass(target) : "custom_server",
     // Today the local credential proxy is only used by CLI wrappers. If runtime
     // or daemon-internal callers use it later, plumb the caller identity here.
     downstreamCaller: "cli",
-    upstream: "server"
+    upstream: localDaemonStateInvalid ? "local_daemon" : "server"
   };
 }
 function routeFamilyForPath(pathname) {
@@ -6254,7 +6296,9 @@ var LOOPBACK_NO_PROXY = "127.0.0.1,localhost";
 var CLI_TRANSPORT_TRACE_DIR_ENV = "SLOCK_CLI_TRANSPORT_TRACE_DIR";
 var safePathPart = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var RAW_CREDENTIAL_ENV_DENYLIST = [
-  "SLOCK_AGENT_CREDENTIAL_KEY"
+  "SLOCK_AGENT_TOKEN",
+  "SLOCK_AGENT_CREDENTIAL_KEY",
+  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
 ];
 var WORKSPACE_CLI_TRANSPORT_FILENAMES = [
   "agent-token",
@@ -6609,7 +6653,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
     SLOCK_SERVER_URL: ctx.config.serverUrl,
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  delete spawnEnv.SLOCK_AGENT_TOKEN;
+  scrubDaemonChildEnv(spawnEnv);
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -6628,6 +6672,28 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
 }
 
 // src/drivers/claudeEventNormalizer.ts
+function extractSubagentLineage(event) {
+  const parentToolUseId = finiteString(event.parent_tool_use_id);
+  const subagentType = finiteString(event.subagent_type);
+  if (!parentToolUseId && !subagentType) return void 0;
+  return {
+    ...parentToolUseId ? { parentToolUseId } : {},
+    ...subagentType ? { subagentType } : {},
+    phase: "active"
+  };
+}
+function taskLifecyclePhase(subtype) {
+  switch (subtype) {
+    case "task_started":
+      return "started";
+    case "task_progress":
+      return "progress";
+    case "task_notification":
+      return "notification";
+    default:
+      return null;
+  }
+}
 function collectResultErrorDetail(message, fallback) {
   const parts = [];
   if (Array.isArray(message.errors)) {
@@ -6801,6 +6867,25 @@ var ClaudeEventNormalizer = class {
         if (event.subtype === "compact_boundary") {
           events.push({ kind: "compaction_finished" });
         }
+        {
+          const phase = typeof event.subtype === "string" ? taskLifecyclePhase(event.subtype) : null;
+          if (phase) {
+            events.push({
+              kind: "subagent_progress",
+              source: "claude_task_lifecycle",
+              phase,
+              ...finiteString(event.task_id) ? { taskId: finiteString(event.task_id) } : {},
+              // `system` task-lifecycle envelopes carry the outer Agent tool id
+              // as `tool_use_id`; belt-and-suspenders fall back to
+              // `parent_tool_use_id` in case a Claude version names it that way
+              // on the envelope (confirmed field name = tool_use_id, @Huarong).
+              ...finiteString(event.tool_use_id) ?? finiteString(event.parent_tool_use_id) ? { parentToolUseId: finiteString(event.tool_use_id) ?? finiteString(event.parent_tool_use_id) } : {},
+              ...finiteString(event.subagent_type) ? { subagentType: finiteString(event.subagent_type) } : {},
+              ...finiteString(event.last_tool_name) ? { lastToolName: finiteString(event.last_tool_name) } : {},
+              payloadBytes: Buffer.byteLength(line, "utf8")
+            });
+          }
+        }
         break;
       case "stream_event":
         events.push({
@@ -6812,19 +6897,21 @@ var ClaudeEventNormalizer = class {
         break;
       case "assistant": {
         const content = event.message?.content;
+        const subagent = extractSubagentLineage(event);
+        const withLineage = subagent ? { subagent } : {};
         if (Array.isArray(content)) {
           const hasToolUse = content.some((block) => block?.type === "tool_use");
           for (const block of content) {
             if (block.type === "thinking" && block.thinking) {
-              events.push({ kind: "thinking", text: block.thinking });
+              events.push({ kind: "thinking", text: block.thinking, ...withLineage });
             } else if (block.type === "text" && block.text) {
               if (isProviderApiFailureText(block.text, hasToolUse)) {
                 events.push({ kind: "error", message: block.text });
               } else {
-                events.push({ kind: "text", text: block.text });
+                events.push({ kind: "text", text: block.text, ...withLineage });
               }
             } else if (block.type === "tool_use") {
-              events.push({ kind: "tool_call", name: block.name || "unknown_tool", input: block.input });
+              events.push({ kind: "tool_call", name: block.name || "unknown_tool", input: block.input, ...withLineage });
             }
           }
         }
@@ -6832,10 +6919,12 @@ var ClaudeEventNormalizer = class {
       }
       case "user": {
         const content = event.message?.content;
+        const subagent = extractSubagentLineage(event);
+        const withLineage = subagent ? { subagent } : {};
         if (Array.isArray(content)) {
           for (const block of content) {
             if (block.type === "tool_result") {
-              events.push({ kind: "tool_output", name: block.name || block.tool_use_id || "tool_result" });
+              events.push({ kind: "tool_output", name: block.name || block.tool_use_id || "tool_result", ...withLineage });
             }
           }
         }
@@ -7132,7 +7221,7 @@ function requiresWindowsShell(command, platform = process.platform) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   if (platform === "win32") {
@@ -7158,7 +7247,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -9242,11 +9331,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return withWindowsUserEnvironment({
+  return scrubDaemonChildEnv(withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps);
+  }, deps));
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -9302,7 +9391,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync5;
-  const env = deps.env ?? process.env;
+  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
   const winPath = path8.win32;
   let geminiEntry = null;
   try {
@@ -9439,12 +9528,15 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { chmodSync, existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import os4 from "os";
 import path9 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
+var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
+var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
+var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -9453,6 +9545,73 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
+function readKimiConfigSource(home = os4.homedir(), env = process.env) {
+  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  if (inlineConfig && inlineConfig.trim()) {
+    return {
+      raw: inlineConfig,
+      explicitPath: null,
+      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
+    };
+  }
+  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
+  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path9.join(home, ".kimi", "config.toml");
+  try {
+    return {
+      raw: readFileSync3(configPath, "utf8"),
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  } catch {
+    return {
+      raw: null,
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  }
+}
+function buildKimiSpawnEnv(env = process.env) {
+  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
+  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
+  return scrubDaemonChildEnv(spawnEnv);
+}
+function buildKimiEffectiveEnv(ctx, overrideEnv) {
+  return {
+    ...process.env,
+    ...ctx.config.envVars || {},
+    ...overrideEnv || {}
+  };
+}
+function buildKimiLaunchOptions(ctx, opts = {}) {
+  const env = buildKimiEffectiveEnv(ctx, opts.env);
+  const source = readKimiConfigSource(opts.home ?? os4.homedir(), env);
+  const args = [];
+  let configFilePath = null;
+  let configContent = null;
+  if (source.explicitPath) {
+    configFilePath = source.explicitPath;
+  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
+    configFilePath = path9.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
+    configContent = source.raw;
+    if (opts.writeGeneratedConfig !== false) {
+      writeFileSync3(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
+      chmodSync(configFilePath, 384);
+    }
+  }
+  if (configFilePath) {
+    args.push("--config-file", configFilePath);
+  }
+  if (ctx.config.model && ctx.config.model !== "default") {
+    args.push("--model", ctx.config.model);
+  }
+  return {
+    args,
+    env: buildKimiSpawnEnv(env),
+    configFilePath,
+    configContent
+  };
+}
 function resolveKimiSpawn(commandArgs, deps = {}) {
   return {
     command: resolveCommandOnPath("kimi", deps) ?? "kimi",
@@ -9476,7 +9635,25 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+    toLaunchSpec: (modelId, ctx, opts) => {
+      if (!ctx) return { args: ["--model", modelId] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = buildKimiLaunchOptions(launchCtx, {
+        home: opts?.home,
+        writeGeneratedConfig: false
+      });
+      return {
+        args: launch.args,
+        env: launch.env,
+        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
+      };
+    }
   };
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
@@ -9500,21 +9677,23 @@ var KimiDriver = class {
       `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
       ""
     ].join("\n"), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
       "--agent-file",
       agentFilePath,
       "--session",
-      this.sessionId
+      this.sessionId,
+      ...launch.args
     ];
     const launchRuntimeFields = runtimeConfigToLaunchFields(hydrateRuntimeConfig(ctx.config));
     if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
       args.push("--model", launchRuntimeFields.model);
     }
     const spawnEnv = (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
-    const launch = resolveKimiSpawn(args);
-    const proc = spawn7(launch.command, launch.args, {
+    const spawnTarget = resolveKimiSpawn(args);
+    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -9522,7 +9701,7 @@ var KimiDriver = class {
       // and has an 8191-character command-line limit. Kimi's official
       // installer/uv entrypoint is an executable, so launch it directly and
       // keep prompts on stdin / files instead of routing through cmd.exe.
-      shell: launch.shell
+      shell: spawnTarget.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -9635,14 +9814,9 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir()) {
-  const configPath = path9.join(home, ".kimi", "config.toml");
-  let raw;
-  try {
-    raw = readFileSync3(configPath, "utf8");
-  } catch {
-    return null;
-  }
+function detectKimiModels(home = os4.homedir(), opts = {}) {
+  const raw = readKimiConfigSource(home, opts.env).raw;
+  if (raw === null) return null;
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -10308,7 +10482,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
+    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -10465,6 +10639,7 @@ var OpenCodeDriver = class {
   };
   supportsStdinNotification = false;
   busyDeliveryMode = "none";
+  supportsNativeStandingPrompt = true;
   terminateProcessOnTurnEnd = true;
   deferSpawnUntilMessage = true;
   shouldDeferWakeMessage(message) {
@@ -12107,6 +12282,18 @@ var AgentLifecycleRecords = class {
   pendingSpawnCauses = /* @__PURE__ */ new Map();
   runtimeErrorFingerprintFences = /* @__PURE__ */ new Map();
   activityClientSeqs = /* @__PURE__ */ new Map();
+  stopEpochs = /* @__PURE__ */ new Map();
+  recordStop(agentId) {
+    const next = (this.stopEpochs.get(agentId) ?? 0) + 1;
+    this.stopEpochs.set(agentId, next);
+    return next;
+  }
+  stopEpoch(agentId) {
+    return this.stopEpochs.get(agentId) ?? 0;
+  }
+  stopEpochChanged(agentId, epoch) {
+    return this.stopEpoch(agentId) !== epoch;
+  }
   nextActivityClientSeq(agentId) {
     const next = (this.activityClientSeqs.get(agentId) ?? 0) + 1;
     this.activityClientSeqs.set(agentId, next);
@@ -13008,6 +13195,36 @@ var WORKSPACE_IMAGE_MIME_BY_EXTENSION = {
   ".png": "image/png",
   ".webp": "image/webp"
 };
+var WORKSPACE_NEVER_VISIBLE_HIDDEN_NAMES = /* @__PURE__ */ new Set([
+  ".aws",
+  ".gnupg",
+  ".ssh",
+  ".slock",
+  ".slock-runtime"
+]);
+var WORKSPACE_SECRET_FILE_PATTERNS = [
+  /^\.env(?:\.|$)/i,
+  /(?:^|[._-])secret(?:s)?(?:[._-]|$)/i,
+  /(?:^|[._-])credential(?:s)?(?:[._-]|$)/i,
+  /(?:^|[._-])token(?:s)?(?:[._-]|$)/i
+];
+function isWorkspaceNeverVisibleHiddenEntry(name) {
+  return WORKSPACE_NEVER_VISIBLE_HIDDEN_NAMES.has(name) || name.startsWith(".slock-");
+}
+function workspacePathParts(relativePath) {
+  return relativePath.split(path14.sep).filter(Boolean);
+}
+function isWorkspaceHiddenPath(relativePath) {
+  return workspacePathParts(relativePath).some((part) => part.startsWith("."));
+}
+function isWorkspaceNeverVisibleHiddenPath(relativePath) {
+  return workspacePathParts(relativePath).some(isWorkspaceNeverVisibleHiddenEntry);
+}
+function isWorkspaceSecretFilePath(filePath) {
+  return workspacePathParts(filePath).some(
+    (part) => WORKSPACE_SECRET_FILE_PATTERNS.some((pattern) => pattern.test(part))
+  );
+}
 function readPositiveIntegerEnv(name, fallback) {
   const raw = process.env[name];
   if (!raw) return fallback;
@@ -13102,9 +13319,6 @@ function toLocalTime(iso) {
   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 formatChannelLabel(message) {
-  return message.channel_type === "dm" ? `DM:@${message.channel_name}` : `#${message.channel_name}`;
-}
 function formatMessageTarget(message) {
   return formatAgentMessageVisibleTarget(message);
 }
@@ -13437,15 +13651,6 @@ function formatRuntimeProfileControlStartupInput(control, driver) {
     control.message
   ].join("\n");
 }
-function buildUnreadSummary(messages, excludeChannel) {
-  const summary = /* @__PURE__ */ new Map();
-  for (const message of messages) {
-    const label = formatChannelLabel(message);
-    if (excludeChannel && label === excludeChannel) continue;
-    summary.set(label, (summary.get(label) || 0) + 1);
-  }
-  return summary.size > 0 ? Object.fromEntries(summary) : void 0;
-}
 var MAX_TRAJECTORY_TEXT = 2e3;
 var TRAJECTORY_COALESCE_MS = 350;
 var ACTIVITY_HEARTBEAT_MS = 6e4;
@@ -13456,11 +13661,12 @@ var RUNTIME_ERROR_DELIVERY_BACKOFF_MAX_MS = 5 * 6e4;
 var RUNTIME_ERROR_FINGERPRINT_FENCE_THRESHOLD = 3;
 var SPAWN_FAIL_BACKOFF_BASE_MS = 1e3;
 var SPAWN_FAIL_BACKOFF_MAX_MS = 3e4;
-var SPAWN_FAIL_BACKOFF_THRESHOLD = 3;
+var SPAWN_FAIL_BACKOFF_THRESHOLD = 0;
 var RUNNER_CREDENTIAL_MINT_BACKOFF_BASE_MS = 6e4;
 var RUNNER_CREDENTIAL_MINT_BACKOFF_MAX_MS = 10 * 6e4;
 var RUNNER_CREDENTIAL_MINT_BACKOFF_THRESHOLD = 0;
 var COMPACTION_STALE_MS = 5 * 6e4;
+var REVIEW_STALE_MS = 10 * 6e4;
 var RUNTIME_PROGRESS_STALE_MS = 15 * 6e4;
 var DEFAULT_RUNTIME_START_TIMEOUT_MS = 2 * 6e4;
 var DEFAULT_STALLED_RECOVERY_SIGTERM_TIMEOUT_MS = 1e4;
@@ -14096,6 +14302,39 @@ function runtimeRecoveryTraceAttrs(event) {
     details_present: Boolean(event.details)
   };
 }
+function subagentProgressDetail(event) {
+  const role = event.subagentType ? ` (${event.subagentType})` : "";
+  switch (event.phase) {
+    case "started":
+      return `Subagent started${role}`;
+    case "progress":
+      return `Subagent working${role}`;
+    case "notification":
+      return `Subagent update${role}`;
+    default:
+      return `Subagent working${role}`;
+  }
+}
+function subagentLineageFromEvent(event) {
+  return {
+    ...event.parentToolUseId ? { parentToolUseId: event.parentToolUseId } : {},
+    ...event.subagentType ? { subagentType: event.subagentType } : {},
+    ...event.taskId ? { taskId: event.taskId } : {},
+    phase: event.phase
+  };
+}
+function subagentProgressTraceAttrs(event) {
+  return {
+    kind: event.kind,
+    source: event.source,
+    phase: event.phase,
+    parent_tool_use_id_present: Boolean(event.parentToolUseId),
+    subagent_type_present: Boolean(event.subagentType),
+    task_id_present: Boolean(event.taskId),
+    last_tool_name_present: Boolean(event.lastToolName),
+    payloadBytes: event.payloadBytes
+  };
+}
 function currentErrorCandidates(ap) {
   return ap.decisionErrorWindow.currentErrorCandidates();
 }
@@ -14465,6 +14704,7 @@ var AgentProcessManager = class _AgentProcessManager {
     this.cliTransportTraceDir = traceDir;
   }
   assertStartPendingDeliveryInvariants(context) {
+    this.repairNonresidentRuntimeErrorFingerprintFences(context);
     const residencySnapshot = this.noProcessResidencySnapshot();
     AgentNoProcessResidency.assertInvariants(context, residencySnapshot);
     this.lifecycleRecords.assertInvariants(context, this.agentLifecycleRecordSnapshot());
@@ -14515,10 +14755,10 @@ var AgentProcessManager = class _AgentProcessManager {
   }
   // ----- SPAWN-FAIL BACKOFF (per-agent) ----------------------------------
   // Anchored at auto_restart_from_idle (apm:3596) + runtime_profile_auto_restart (apm:4137).
-  // Generic spawn errors keep a threshold > 1 so single-transient hiccups behave as today.
-  // Runner credential mint failures are different: one outer spawn failure already means the
-  // inner credential-mint loop exhausted RUNNER_CREDENTIAL_MINT_MAX_ATTEMPTS. Those enter a
-  // longer cooldown immediately so repeated wakes don't keep burning three network fetches.
+  // One outer spawn failure enters cooldown immediately so repeated wakes cannot burn one
+  // full spawn attempt per delivery. Runner credential mint failures keep a longer cooldown
+  // because one outer failure already means the inner credential-mint loop exhausted
+  // RUNNER_CREDENTIAL_MINT_MAX_ATTEMPTS.
   // Successful spawn resets state. State lives outside AgentProcess because spawn fails BEFORE
   // ap exists and the rate-window must persist across stop/respawn (else stop/start churn
   // bypasses the cap — CC1 lifecycle pattern). Never advances any consume cursor or model-seen
@@ -14602,6 +14842,17 @@ var AgentProcessManager = class _AgentProcessManager {
       reset_source: resetSource
     });
   }
+  resetRuntimeErrorFingerprintFenceIfNonresident(agentId, resetSource, ap) {
+    if (this.agents.has(agentId)) return;
+    if (this.lifecycleRecords.getRestartSnapshot(agentId)) return;
+    if (this.lifecycleRecords.getTerminalFailure(agentId)) return;
+    this.resetRuntimeErrorFingerprintFence(agentId, resetSource, ap);
+  }
+  repairNonresidentRuntimeErrorFingerprintFences(context) {
+    for (const agentId of [...this.lifecycleRecords.runtimeErrorFingerprintFenceAgentIds()]) {
+      this.resetRuntimeErrorFingerprintFenceIfNonresident(agentId, `invariant_repair:${context}`);
+    }
+  }
   formatRuntimeErrorFingerprintFenceDetail(state) {
     return [
       `Runtime stopped after ${state.attempts} repeated runtime errors with the same fingerprint (${state.fingerprint}).`,
@@ -14660,14 +14911,22 @@ var AgentProcessManager = class _AgentProcessManager {
       this.sendStdinNotification(agentId);
     }, delayMs);
   }
-  flushAsyncRejectedIdleDelivery(agentId) {
+  scheduleIdleInboxDeliveryRetry(agentId, ap, notificationCount, source, traceName) {
+    if (notificationCount <= 0 || !ap.driver.supportsStdinNotification || !ap.sessionId) return false;
+    ap.notifications.add(notificationCount);
+    ap.notifications.clearTimer();
+    return ap.notifications.schedule(() => {
+      this.flushIdleInboxDeliveryRetry(agentId, source, traceName);
+    }, this.stdinNotificationRetryMs);
+  }
+  flushIdleInboxDeliveryRetry(agentId, source, traceName) {
     const ap = this.agents.get(agentId);
     if (!ap) return false;
     const count = ap.notifications.takePendingAndClearTimer();
     if (count === 0) return false;
     if (!ap.driver.supportsStdinNotification || !ap.sessionId || ap.inbox.length === 0) {
       ap.notifications.add(count);
-      this.recordDaemonTrace("daemon.agent.stdin_delivery.async_rejected.retry", {
+      this.recordDaemonTrace(traceName, {
         agentId,
         runtime: ap.config.runtime,
         model: ap.config.model,
@@ -14688,7 +14947,7 @@ var AgentProcessManager = class _AgentProcessManager {
     ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
     const messages = ap.notifications.filterUncontributedMessages(ap.inbox, ap.sessionId);
     if (messages.length === 0) {
-      this.recordDaemonTrace("daemon.agent.stdin_delivery.async_rejected.retry", {
+      this.recordDaemonTrace(traceName, {
         agentId,
         runtime: ap.config.runtime,
         model: ap.config.model,
@@ -14702,16 +14961,16 @@ var AgentProcessManager = class _AgentProcessManager {
       return false;
     }
     this.commitApmIdleState(agentId, ap, false);
-    this.startRuntimeTrace(agentId, ap, "async-rejected-idle-delivery-retry", messages);
+    this.startRuntimeTrace(agentId, ap, source.replaceAll("_", "-"), messages);
     this.broadcastMessageReceivedActivity(agentId);
     const accepted = this.deliverInboxUpdateViaStdin(
       agentId,
       ap,
       messages,
       "idle",
-      "async_rejected_idle_delivery_retry"
+      source
     );
-    this.recordDaemonTrace("daemon.agent.stdin_delivery.async_rejected.retry", {
+    this.recordDaemonTrace(traceName, {
       agentId,
       runtime: ap.config.runtime,
       model: ap.config.model,
@@ -14724,6 +14983,13 @@ var AgentProcessManager = class _AgentProcessManager {
     });
     return accepted;
   }
+  flushAsyncRejectedIdleDelivery(agentId) {
+    return this.flushIdleInboxDeliveryRetry(
+      agentId,
+      "async_rejected_idle_delivery_retry",
+      "daemon.agent.stdin_delivery.async_rejected.retry"
+    );
+  }
   isApmIdle(ap) {
     return ap.gatedSteering.isIdle;
   }
@@ -14769,7 +15035,7 @@ var AgentProcessManager = class _AgentProcessManager {
     this.broadcastActivity(agentId, "working", "Message received", [], void 0, "message_received");
   }
   toolActivityDetailKind(toolName) {
-    switch (toolName) {
+    switch (resolveToolSemantic(toolName) ?? toolName) {
       case "bash":
         return "running_command";
       case "check_messages":
@@ -14787,6 +15053,7 @@ var AgentProcessManager = class _AgentProcessManager {
     if (options.includeCompactionWatchdog ?? true) {
       this.clearCompactionWatchdog(ap);
     }
+    this.clearReviewWatchdog(ap);
     this.clearStalledRecoverySigtermWatchdog(ap);
   }
   clearRuntimeErrorDeliveryBackoffWithTrace(agentId, ap, resetSource) {
@@ -15119,7 +15386,11 @@ var AgentProcessManager = class _AgentProcessManager {
       path: input.pathname,
       query_keys: input.queryKeys,
       error_name: input.errorName,
-      error_message: input.errorMessage
+      error_message: input.errorMessage,
+      response_status_code: input.responseStatusCode,
+      response_code: input.responseCode,
+      lifecycle_invalid_agent_id: input.lifecycleInvalidAgentId,
+      lifecycle_invalid_context: input.lifecycleInvalidContext
     }, "error");
   }
   recordAgentProxyTransportNormalizedError(agentId, input) {
@@ -15158,7 +15429,8 @@ var AgentProcessManager = class _AgentProcessManager {
       detailKind: activity.statusEntry.detailKind ?? "daemon_activity",
       entries: activity.entries,
       launchId: ap?.launchId || void 0,
-      clientSeq: ap ? this.nextActivityClientSeq(agentId) : void 0
+      clientSeq: ap ? this.nextActivityClientSeq(agentId) : void 0,
+      isHeartbeat: false
     });
   }
   recordRuntimeDiagnosticActivity(agentId, ap, event) {
@@ -15171,7 +15443,8 @@ var AgentProcessManager = class _AgentProcessManager {
       detailKind: ap.lastActivityDetailKind || "none",
       entries: [runtimeDiagnosticTrajectoryEntry(event)],
       launchId: ap.launchId || void 0,
-      clientSeq: this.nextActivityClientSeq(agentId)
+      clientSeq: this.nextActivityClientSeq(agentId),
+      isHeartbeat: false
     });
     this.recordDaemonTrace("daemon.runtime.diagnostic", {
       agentId,
@@ -15180,6 +15453,38 @@ var AgentProcessManager = class _AgentProcessManager {
       ...runtimeDiagnosticTraceAttrs(event)
     });
   }
+  /**
+   * APM 1.6 6a — surface a generic structured "working" signal from an
+   * internal_progress liveness tick during a long turn. Only transitions INTO
+   * the runtime-progress state once (idempotent while already in it) so the
+   * high-frequency Claude partial-message stream does not spam a rendered status
+   * line every tick; the activity heartbeat then keeps the signal live. Carries
+   * no raw content — a bounded "Working" detail only. Never marks a subagent.
+   */
+  maybeBroadcastRuntimeProgressActivity(agentId, ap) {
+    const alreadyLive = ap.lastActivityKind === "working" || ap.lastActivityKind === "thinking";
+    if (alreadyLive) return;
+    this.broadcastActivity(agentId, "working", "Working", [], void 0, "runtime_progress");
+  }
+  recordSubagentProgressActivity(agentId, ap, event) {
+    this.flushPendingTrajectory(agentId);
+    this.broadcastActivity(
+      agentId,
+      "working",
+      subagentProgressDetail(event),
+      [],
+      void 0,
+      "subagent_activity",
+      "working",
+      subagentLineageFromEvent(event)
+    );
+    this.recordDaemonTrace("daemon.runtime.subagent.progress", {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      ...subagentProgressTraceAttrs(event)
+    });
+  }
   recordRuntimeRecoveryActivity(agentId, ap, event) {
     this.sendToServer({
       type: "agent:activity",
@@ -15190,7 +15495,8 @@ var AgentProcessManager = class _AgentProcessManager {
       detailKind: ap.lastActivityDetailKind || "none",
       entries: [runtimeRecoveryTrajectoryEntry(event)],
       launchId: ap.launchId || void 0,
-      clientSeq: this.nextActivityClientSeq(agentId)
+      clientSeq: this.nextActivityClientSeq(agentId),
+      isHeartbeat: false
     });
     this.recordDaemonTrace("daemon.runtime.recovery.visible", {
       agentId,
@@ -15416,7 +15722,10 @@ var AgentProcessManager = class _AgentProcessManager {
   rebindRunningStart(agentId, start, reason) {
     const ap = this.agents.get(agentId);
     if (!ap) {
-      this.lifecycleRecords.setPendingStartRebind(agentId, start);
+      this.lifecycleRecords.setPendingStartRebind(agentId, {
+        ...start,
+        stopEpochAtRebind: this.lifecycleRecords.stopEpoch(agentId)
+      });
       return false;
     }
     const previousLaunchId = ap.launchId;
@@ -15466,7 +15775,16 @@ var AgentProcessManager = class _AgentProcessManager {
         ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient, resumeMessages),
         reason: "already_starting"
       });
-      this.lifecycleRecords.setPendingStartRebind(agentId, { config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient, resumeMessages });
+      this.lifecycleRecords.setPendingStartRebind(agentId, {
+        config,
+        wakeMessage,
+        unreadSummary,
+        resumePrompt,
+        launchId,
+        wakeMessageTransient,
+        resumeMessages,
+        stopEpochAtRebind: this.lifecycleRecords.stopEpoch(agentId)
+      });
       logger.info(`[Agent ${agentId}] Start rebind deferred (startup in progress)`);
       return;
     }
@@ -15544,7 +15862,10 @@ var AgentProcessManager = class _AgentProcessManager {
       if (this.agents.has(item.agentId)) {
         this.rebindRunningStart(item.agentId, item, "already_running_or_starting");
       } else {
-        this.lifecycleRecords.setPendingStartRebind(item.agentId, item);
+        this.lifecycleRecords.setPendingStartRebind(item.agentId, {
+          ...item,
+          stopEpochAtRebind: this.lifecycleRecords.stopEpoch(item.agentId)
+        });
       }
       logger.info(`[Agent ${item.agentId}] Queued start skipped (already running or starting)`);
       item.resolve();
@@ -15642,10 +15963,20 @@ var AgentProcessManager = class _AgentProcessManager {
         ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient, resumeMessages),
         reason: "already_starting"
       });
-      this.lifecycleRecords.setPendingStartRebind(agentId, { config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient, resumeMessages });
+      this.lifecycleRecords.setPendingStartRebind(agentId, {
+        config,
+        wakeMessage,
+        unreadSummary,
+        resumePrompt,
+        launchId,
+        wakeMessageTransient,
+        resumeMessages,
+        stopEpochAtRebind: this.lifecycleRecords.stopEpoch(agentId)
+      });
       logger.info(`[Agent ${agentId}] Start rebind deferred (startup in progress)`);
       return;
     }
+    let startStopEpoch = this.lifecycleRecords.stopEpoch(agentId);
     this.agentStarts.markStarting(agentId);
     let agentProcess = null;
     let pendingStartRebind;
@@ -15691,6 +16022,7 @@ var AgentProcessManager = class _AgentProcessManager {
         resumePrompt = pendingStartRebind.resumePrompt;
         launchId = pendingStartRebind.launchId || launchId;
         resumeMessages = pendingStartRebind.resumeMessages;
+        startStopEpoch = pendingStartRebind.stopEpochAtRebind ?? startStopEpoch;
         if (pendingStartRebind.wakeMessage) {
           wakeMessage = pendingStartRebind.wakeMessage;
           wakeMessageTransient = pendingStartRebind.wakeMessageTransient === true;
@@ -15834,6 +16166,11 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         this.agentStarts.clearStarting(agentId);
         this.closeNoProcessResidency(agentId, "suppressed", { negativeEvidenceBucket: "defer_until_concrete_message" });
         this.assertStartPendingDeliveryInvariants("defer-empty-start-drain");
+        if (this.lifecycleRecords.stopEpochChanged(agentId, startStopEpoch)) {
+          this.closeNoProcessResidency(agentId, "suppressed", { negativeEvidenceBucket: "explicit_stop" });
+          logger.info(`[Agent ${agentId}] Deferred ${driver.id} spawn suppressed by stop request`);
+          return;
+        }
         this.lifecycleRecords.setRestartSnapshot(agentId, {
           config: this.buildRestartSafeConfig(runtimeConfig, runtimeConfig.sessionId || null),
           sessionId: runtimeConfig.sessionId || null,
@@ -15896,6 +16233,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         readinessTransition: null,
         activation: { kind: "idle" },
         compaction: { kind: "none" },
+        review: { kind: "none" },
         runtimeProgress: new RuntimeProgressState(Date.now()),
         runtimeTraceSpan: null,
         runtimeTraceCounters: createRuntimeTraceCounters(),
@@ -15919,6 +16257,10 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       };
       this.startingInboxes.drainOnSpawn(agentId);
       this.agents.set(agentId, agentProcess);
+      if (this.lifecycleRecords.stopEpochChanged(agentId, startStopEpoch)) {
+        await this.cleanupStoppedRuntimeStart(agentId, agentProcess);
+        return;
+      }
       this.lifecycleRecords.setRestartSnapshot(agentId, {
         config: this.buildRestartSafeConfig(runtimeConfig, restartSessionId),
         sessionId: restartSessionId,
@@ -16108,16 +16450,16 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
             return;
           }
           if (processEndedCleanly) {
+            const pendingRestartMessages = ap.inbox.splice(0).filter((message) => !this.isTransientDelivery(message));
             let queuedWakeMessage;
-            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;
-                queuedWakeMessage = candidate;
-                break;
+            const bufferedRestartMessages = [];
+            for (const message of pendingRestartMessages) {
+              if (!queuedWakeMessage && !this.shouldDeferWakeMessage(agentId, ap.driver, message)) {
+                queuedWakeMessage = message;
+              } else {
+                bufferedRestartMessages.push(message);
               }
             }
-            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 = this.buildRestartSafeConfig(ap.config, ap.sessionId);
@@ -16131,7 +16473,12 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
               if (expectedTerminationReason === "stalled_recovery") {
                 this.lifecycleRecords.setPendingSpawnCause(agentId, "restart_stall");
               }
-              this.startAgent(agentId, nextConfig, queuedWakeMessage, unreadSummary2, void 0, ap.launchId || void 0).catch((err) => {
+              const startPromise = this.startAgent(agentId, nextConfig, queuedWakeMessage, void 0, void 0, ap.launchId || void 0);
+              if (bufferedRestartMessages.length > 0) {
+                this.startingInboxes.bufferMessagesDuringStart(agentId, bufferedRestartMessages);
+                this.assertStartPendingDeliveryInvariants("clean-exit-pending-inbox-transfer");
+              }
+              startPromise.catch((err) => {
                 logger.error(`[Agent ${agentId}] Failed to continue with queued message`, err);
                 if (this.reportRunnerCredentialMintFailure(agentId, err, ap.launchId, "queued_continuation")) {
                   this.lifecycleRecords.setRestartSnapshot(agentId, {
@@ -16187,9 +16534,11 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
               logger.warn(`[Agent ${agentId}] Startup timeout cleanup completed (${reason})`);
             } else if (startupRequestErrorTermination) {
               this.lifecycleRecords.deleteRestartSnapshot(agentId);
+              this.resetRuntimeErrorFingerprintFenceIfNonresident(agentId, "startup_request_error_cleanup", ap);
               logger.warn(`[Agent ${agentId}] Startup request failure cleanup completed (${reason})`);
             } else {
               this.lifecycleRecords.deleteRestartSnapshot(agentId);
+              this.resetRuntimeErrorFingerprintFenceIfNonresident(agentId, "nonrecoverable_process_close", ap);
               logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
               this.sendAgentStatus(agentId, "inactive", ap.launchId);
             }
@@ -16278,6 +16627,47 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       throw err;
     }
   }
+  async cleanupStoppedRuntimeStart(agentId, ap) {
+    if (this.agents.get(agentId) !== ap) return;
+    this.agentStarts.clearStarting(agentId);
+    this.lifecycleRecords.deletePendingStartRebind(agentId);
+    this.lifecycleRecords.deletePendingSpawnCause(agentId);
+    this.lifecycleRecords.deleteRestartSnapshot(agentId);
+    this.startingInboxes.cancelStart(agentId);
+    ap.notifications.clearTimer();
+    this.disposeAgentProcessTimers(ap);
+    this.closeRuntimeReadinessTransition(ap, "terminal");
+    this.closeActivationTransition(ap, "terminal");
+    cleanupAgentCredentialProxy(agentId, ap.launchId);
+    this.revokeManagedRunnerCredential(agentId, ap.config, ap.launchId);
+    this.agents.delete(agentId);
+    this.closeNoProcessResidency(agentId, "suppressed", { negativeEvidenceBucket: "explicit_stop" });
+    this.assertStartPendingDeliveryInvariants("runtime-start-stop-epoch-fence");
+    this.runtimeExitTraceAttrs.set(ap.runtime, {
+      stop_source: "explicit_request",
+      stop_wait_requested: false,
+      stop_silent: false,
+      stop_epoch_fence: true
+    });
+    try {
+      await ap.runtime.stop({ signal: "SIGTERM", reason: "explicit_request" });
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      logger.warn(`[Agent ${agentId}] Failed to stop runtime suppressed by stop epoch: ${reason}`);
+    }
+    logger.info(`[Agent ${agentId}] Runtime start discarded after stop request`);
+  }
+  suppressFailedRestartAfterStop(agentId, stopEpochAtRestart, source) {
+    if (!this.lifecycleRecords.stopEpochChanged(agentId, stopEpochAtRestart)) return false;
+    this.lifecycleRecords.deleteRestartSnapshot(agentId);
+    this.lifecycleRecords.deletePendingStartRebind(agentId);
+    this.lifecycleRecords.deletePendingSpawnCause(agentId);
+    this.startingInboxes.cancelStart(agentId);
+    this.closeNoProcessResidency(agentId, "suppressed", { negativeEvidenceBucket: "explicit_stop" });
+    this.assertStartPendingDeliveryInvariants(`${source}-stop-epoch-fence`);
+    logger.info(`[Agent ${agentId}] Failed ${source} restart suppressed after stop request`);
+    return true;
+  }
   cleanupFailedRuntimeStart(agentId, ap, err) {
     if (!ap) return;
     if (this.agents.get(agentId) !== ap) return;
@@ -16298,6 +16688,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     if (this.lifecycleRecords.deleteTerminalFailure(agentId)) {
       this.closeNoProcessResidency(agentId, "terminal", { negativeEvidenceBucket: "runtime_start_failed" });
     }
+    this.resetRuntimeErrorFingerprintFenceIfNonresident(agentId, "runtime_start_failed_cleanup", ap);
   }
   cleanupTerminalRuntimeFailure(agentId, ap, detail) {
     if (this.agents.get(agentId) !== ap) return;
@@ -16583,6 +16974,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     return messages.some((message) => !runtimeProfileNotificationFromMessage(message));
   }
   async stopAgent(agentId, { wait = false, silent = false } = {}) {
+    this.lifecycleRecords.recordStop(agentId);
     this.cancelQueuedAgentStart(agentId, "stop requested");
     this.lifecycleRecords.deletePendingStartRebind(agentId);
     this.lifecycleRecords.deleteRestartSnapshot(agentId);
@@ -16759,6 +17151,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
           return true;
         }
         this.lifecycleRecords.deleteRestartSnapshot(agentId);
+        const restartStopEpoch = this.lifecycleRecords.stopEpoch(agentId);
         this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
           outcome: "auto_restart_from_idle",
           accepted: true,
@@ -16774,6 +17167,9 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
           return true;
         }, (err) => {
           logger.error(`[Agent ${agentId}] Failed to auto-restart`, err);
+          if (this.suppressFailedRestartAfterStop(agentId, restartStopEpoch, "idle-auto-restart")) {
+            return false;
+          }
           if (this.reportRunnerCredentialMintFailure(agentId, err, cached.launchId, "idle_auto_restart")) {
             this.lifecycleRecords.setRestartSnapshot(agentId, cached);
             const report2 = this.recordSpawnFailure(agentId, "runner_credential_mint");
@@ -17428,12 +17824,23 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         return true;
       }
       this.lifecycleRecords.deleteRestartSnapshot(agentId);
+      const restartStopEpoch = this.lifecycleRecords.stopEpoch(agentId);
       return this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0).then(() => {
         this.resetSpawnFailBackoff(agentId);
         this.assertStartPendingDeliveryInvariants("runtime-profile-auto-restart-success");
         return true;
       }, (err) => {
         logger.error(`[Agent ${agentId}] Failed to auto-restart for runtime profile notification`, err);
+        if (this.suppressFailedRestartAfterStop(agentId, restartStopEpoch, "runtime-profile-auto-restart")) {
+          span.end("ok", {
+            attrs: {
+              outcome: "suppressed_after_stop",
+              runtime: cached.config.runtime,
+              launchId: cached.launchId || void 0
+            }
+          });
+          return false;
+        }
         if (this.reportRunnerCredentialMintFailure(agentId, err, cached.launchId, "runtime_profile_auto_restart")) {
           this.lifecycleRecords.setRestartSnapshot(agentId, cached);
           const report2 = this.recordSpawnFailure(agentId, "runner_credential_mint");
@@ -17574,7 +17981,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     return deleteWorkspaceDirectory(this.dataDir, directoryName);
   }
   // Workspace file browsing
-  async getFileTree(agentId, dirPath) {
+  async getFileTree(agentId, dirPath, includeHidden = false) {
     const agentDir = path14.join(this.dataDir, agentId);
     try {
       await stat2(agentDir);
@@ -17587,9 +17994,16 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       if (!resolved.startsWith(agentDir + path14.sep) && resolved !== agentDir) {
         return [];
       }
+      const relativePath = path14.relative(agentDir, resolved);
+      if (isWorkspaceNeverVisibleHiddenPath(relativePath)) {
+        return [];
+      }
+      if (!includeHidden && isWorkspaceHiddenPath(relativePath)) {
+        return [];
+      }
       targetDir = resolved;
     }
-    return this.listDirectoryChildren(targetDir, agentDir);
+    return this.listDirectoryChildren(targetDir, agentDir, includeHidden);
   }
   async readFile(agentId, filePath) {
     const agentDir = path14.join(this.dataDir, agentId);
@@ -17597,6 +18011,10 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     if (!resolved.startsWith(agentDir + path14.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
+    const relativePath = path14.relative(agentDir, resolved);
+    if (isWorkspaceNeverVisibleHiddenPath(relativePath) || isWorkspaceSecretFilePath(relativePath)) {
+      throw new Error("Preview is disabled for sensitive workspace files");
+    }
     const info = await stat2(resolved);
     if (info.isDirectory()) throw new Error("Cannot read a directory");
     const ext = path14.extname(resolved).toLowerCase();
@@ -17909,12 +18327,19 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
    * should carry explicit reason/correlation/window attrs so the server no
    * longer infers lifecycle semantics from generic activity strings.
    */
-  broadcastActivity(agentId, activityKind, detail, extraTrajectory = [], launchIdOverride, detailKind = "other", activityDisplay = activityKind) {
+  broadcastActivity(agentId, activityKind, detail, extraTrajectory = [], launchIdOverride, detailKind = "other", activityDisplay = activityKind, subagentLineage) {
     const ap = this.agents.get(agentId);
     const entries = [...extraTrajectory];
     const hasToolStart = entries.some((e) => e.kind === "tool_start");
     if (!hasToolStart) {
-      entries.push({ kind: "status", activity: activityKind, activityKind, detail, detailKind });
+      entries.push({
+        kind: "status",
+        activity: activityKind,
+        activityKind,
+        detail,
+        detailKind,
+        ...subagentLineage ? { subagent: subagentLineage } : {}
+      });
     }
     const launchId = launchIdOverride || ap?.launchId || void 0;
     const clientSeq = this.nextActivityClientSeq(agentId);
@@ -17929,7 +18354,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       entries,
       launchId,
       clientSeq,
-      producerFactId
+      producerFactId,
+      isHeartbeat: false
     });
     this.recordActivityProducedTrace(agentId, activityKind, detail, detailKind, entries, ap, launchId, clientSeq, producerFactId);
     if (ap) {
@@ -17957,7 +18383,10 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
               detailKind: ap.lastActivityDetailKind,
               launchId: heartbeatLaunchId,
               clientSeq: heartbeatClientSeq,
-              producerFactId: heartbeatProducerFactId
+              producerFactId: heartbeatProducerFactId,
+              // The one knowing site: this timer re-broadcasts stale
+              // lastActivity, so it declares its replay provenance.
+              isHeartbeat: true
             });
             this.recordActivityProducedTrace(agentId, ap.lastActivityKind, ap.lastActivityDetail, ap.lastActivityDetailKind, [], ap, heartbeatLaunchId, heartbeatClientSeq, heartbeatProducerFactId);
           }, ACTIVITY_HEARTBEAT_MS);
@@ -18038,7 +18467,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       launchId,
       probeId,
       clientSeq,
-      producerFactId
+      producerFactId,
+      isHeartbeat: false
     });
     this.recordActivityProducedTrace(agentId, activityKind, detail, detailKind, [], ap, launchId, clientSeq, producerFactId);
   }
@@ -18050,13 +18480,10 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     ap.pendingTrajectory = null;
     const text = pending.text.length > MAX_TRAJECTORY_TEXT ? pending.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : pending.text;
     if (!text) return;
-    if (pending.kind === "thinking") {
-      this.broadcastActivity(agentId, "thinking", "", [{ kind: "thinking", text }], void 0, "none");
-    } else {
-      this.broadcastActivity(agentId, "thinking", "", [{ kind: "text", text }], void 0, "none");
-    }
+    const entry = pending.kind === "thinking" ? { kind: "thinking", text, ...pending.subagent ? { subagent: pending.subagent } : {} } : { kind: "text", text, ...pending.subagent ? { subagent: pending.subagent } : {} };
+    this.broadcastActivity(agentId, "thinking", "", [entry], void 0, "none");
   }
-  queueTrajectoryText(agentId, kind, text) {
+  queueTrajectoryText(agentId, kind, text, subagent) {
     const ap = this.agents.get(agentId);
     if (!ap) {
       this.recordDaemonTrace("daemon.agent.activity.skipped", {
@@ -18072,7 +18499,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       return;
     }
     const pending = ap.pendingTrajectory;
-    if (pending && pending.kind === kind) {
+    const sameLineage = JSON.stringify(pending?.subagent ?? null) === JSON.stringify(subagent ?? null);
+    if (pending && pending.kind === kind && sameLineage) {
       pending.text += text;
       clearTimeout(pending.timer);
       pending.timer = setTimeout(() => this.flushPendingTrajectory(agentId), TRAJECTORY_COALESCE_MS);
@@ -18085,6 +18513,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     ap.pendingTrajectory = {
       kind,
       text,
+      ...subagent ? { subagent } : {},
       timer: setTimeout(() => this.flushPendingTrajectory(agentId), TRAJECTORY_COALESCE_MS)
     };
   }
@@ -18187,6 +18616,29 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     ap.compaction = { ...ap.compaction, watchdog: null };
     this.broadcastActivity(agentId, "working", "Context compaction still running; no finish event observed", [], void 0, "compaction_stale");
   }
+  startReviewWatchdog(agentId, ap) {
+    this.clearReviewWatchdog(ap);
+    const startedAt = Date.now();
+    const watchdog = setTimeout(() => {
+      this.markReviewStale(agentId, startedAt);
+    }, REVIEW_STALE_MS);
+    ap.review = { kind: "active", startedAt, watchdog };
+  }
+  clearReviewWatchdog(ap) {
+    if (ap.review.kind === "active" && ap.review.watchdog) {
+      clearTimeout(ap.review.watchdog);
+    }
+    ap.review = { kind: "none" };
+  }
+  markReviewStale(agentId, startedAt) {
+    const ap = this.agents.get(agentId);
+    if (!ap || ap.review.kind !== "active" || ap.review.startedAt !== startedAt) return;
+    ap.review = { ...ap.review, watchdog: null };
+    this.broadcastActivity(agentId, "working", "Review mode still active; no finish event observed", [], void 0, "review_stale");
+    const reduction = reduceApmGatedReview(ap.gatedSteering, { kind: "review_finished" });
+    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "review_finished", inferred: true });
+    this.flushReviewBoundaryMessages(agentId, ap);
+  }
   completeCompactionIfActive(agentId, detail = "Context compaction finished", options = {}) {
     const ap = this.agents.get(agentId);
     if (!ap || ap.compaction.kind !== "active") return;
@@ -18795,6 +19247,23 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     if (ap.runtimeProgress.isStale) return true;
     const staleForMs = ap.runtimeProgress.ageMs();
     if (staleForMs < RUNTIME_PROGRESS_STALE_MS) return false;
+    const subprocessPidAlive = this.probeRuntimeProcessLiveness(ap);
+    if (subprocessPidAlive === true) {
+      this.recordDaemonTrace("daemon.runtime.stall.suppressed_alive", {
+        ...this.processLifecycleIdentityAttrs(agentId, ap),
+        last_event_kind: ap.lastActivityKind || void 0,
+        last_event_age_ms_bucket: bucketMs(staleForMs),
+        subprocess_pid_alive: true,
+        subprocess_socket_alive: !ap.runtime.closed,
+        daemon_connected_to_server: this.serverConnected()
+      });
+      this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.silent_alive", {
+        staleForMs: bucketMs(staleForMs),
+        lastActivity: ap.lastActivityKind || void 0,
+        lastActivityDetailKind: ap.lastActivityDetailKind
+      });
+      return false;
+    }
     ap.runtimeProgress.markStale();
     const staleForMinutes = Math.max(1, Math.floor(staleForMs / 6e4));
     const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes);
@@ -18814,15 +19283,6 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       ...runtimeTraceCounterAttrs(ap),
       ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_stalled")
     });
-    let subprocessPidAlive;
-    if (typeof ap.runtime.pid === "number") {
-      try {
-        process.kill(ap.runtime.pid, 0);
-        subprocessPidAlive = true;
-      } catch {
-        subprocessPidAlive = false;
-      }
-    }
     this.recordDaemonTrace("daemon.runtime.stall.detected", {
       ...this.processLifecycleIdentityAttrs(agentId, ap),
       last_event_kind: ap.lastActivityKind || void 0,
@@ -18834,6 +19294,17 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     this.broadcastActivity(agentId, "error", diagnostic.detail, [], void 0, "runtime_stalled");
     return true;
   }
+  probeRuntimeProcessLiveness(ap) {
+    const pid = ap.runtime.pid;
+    if (typeof pid !== "number") return void 0;
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (err) {
+      const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+      return code === "EPERM" ? true : false;
+    }
+  }
   recoverStaleProcessForQueuedMessageIfNeeded(agentId, ap) {
     const staleForMs = ap.runtimeProgress.ageMs();
     const reduction = reduceApmStalledRecoveryTermination(ap.gatedSteering, {
@@ -18944,6 +19415,15 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         source: event.source,
         itemType: event.itemType,
         payloadBytes: event.payloadBytes
+      } : event.kind === "subagent_progress" ? {
+        kind: event.kind,
+        source: event.source,
+        phase: event.phase,
+        parent_tool_use_id_present: Boolean(event.parentToolUseId),
+        subagent_type_present: Boolean(event.subagentType),
+        task_id_present: Boolean(event.taskId),
+        last_tool_name_present: Boolean(event.lastToolName),
+        payloadBytes: event.payloadBytes
       } : event.kind === "runtime_diagnostic" ? runtimeDiagnosticTraceAttrs(event) : event.kind === "runtime_recovery" ? runtimeRecoveryTraceAttrs(event) : { kind: event.kind };
       this.recordRuntimeTraceEvent(agentId, ap, "runtime.event.received", eventAttrs);
       const recordProgressObservedAfterStall = () => {
@@ -18965,6 +19445,15 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
           itemType: event.itemType,
           payloadBytes: event.payloadBytes
         });
+        this.maybeBroadcastRuntimeProgressActivity(agentId, ap);
+        return;
+      }
+      if (event.kind === "subagent_progress") {
+        this.noteRuntimeProgress(ap, event.kind);
+        recordProgressObservedAfterStall();
+        this.invalidateRecoveryErrorView(ap);
+        this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
+        this.recordSubagentProgressActivity(agentId, ap, event);
         return;
       }
       if (event.kind === "runtime_diagnostic") {
@@ -19001,7 +19490,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         break;
       case "thinking": {
         this.completeCompactionIfActive(agentId, "Context compaction finished (inferred from resumed output)");
-        this.queueTrajectoryText(agentId, "thinking", event.text);
+        this.queueTrajectoryText(agentId, "thinking", event.text, event.subagent);
         if (ap) {
           this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
           const reduction = reduceApmGatedAssistantContinuation(ap.gatedSteering);
@@ -19012,7 +19501,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       }
       case "text": {
         this.completeCompactionIfActive(agentId, "Context compaction finished (inferred from resumed output)");
-        this.queueTrajectoryText(agentId, "text", event.text);
+        this.queueTrajectoryText(agentId, "text", event.text, event.subagent);
         if (ap) {
           this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
           const reduction = reduceApmGatedAssistantContinuation(ap.gatedSteering);
@@ -19039,8 +19528,9 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         this.broadcastActivity(agentId, "working", detail, [{
           kind: "tool_start",
           toolName: invocation.toolName,
-          toolInput: inputSummary
-        }], void 0, this.toolActivityDetailKind(invocation.toolName));
+          toolInput: inputSummary,
+          ...event.subagent ? { subagent: event.subagent } : {}
+        }], void 0, event.subagent ? "subagent_activity" : this.toolActivityDetailKind(invocation.toolName));
         break;
       }
       case "tool_output": {
@@ -19088,11 +19578,15 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         if (ap) {
           const reduction = reduceApmGatedReview(ap.gatedSteering, { kind: "review_started" });
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "review_started" });
+          this.startReviewWatchdog(agentId, ap);
         }
         break;
       case "review_finished":
         this.flushPendingTrajectory(agentId);
-        if (ap) this.recordRuntimeTraceEvent(agentId, ap, "runtime.review_mode.finished");
+        if (ap) {
+          this.clearReviewWatchdog(ap);
+          this.recordRuntimeTraceEvent(agentId, ap, "runtime.review_mode.finished");
+        }
         this.broadcastActivity(agentId, "working", "Review finished", [], void 0, "review_finished");
         if (ap) {
           const reduction = reduceApmGatedReview(ap.gatedSteering, { kind: "review_finished" });
@@ -19613,6 +20107,15 @@ ${RESPONSE_TARGET_HINT}`;
       `${mode} inbox update`
     );
     if (!sendResult.ok) {
+      const retryNotificationCount = mode === "idle" && ap.driver.supportsStdinNotification && ap.sessionId ? messages.length : 0;
+      const retrySource = source.endsWith("_retry") ? source : `${source}_retry`;
+      const retryScheduled = mode === "idle" ? this.scheduleIdleInboxDeliveryRetry(
+        agentId,
+        ap,
+        retryNotificationCount,
+        retrySource,
+        "daemon.agent.stdin_delivery.idle_retry"
+      ) : false;
       if (mode === "idle") {
         this.commitApmIdleState(agentId, ap, true);
       }
@@ -19637,7 +20140,9 @@ ${RESPONSE_TARGET_HINT}`;
         outcome: runtimeSendFailureOutcome(sendResult),
         failure_reason: sendResult.reason,
         failure_error: sendResult.error,
-        requeued_messages_count: 0,
+        requeued_messages_count: retryNotificationCount,
+        retry_scheduled: retryScheduled,
+        notification_timer_present: ap.notifications.hasTimer,
         cursors_advanced: "none"
       }, "error");
       return false;
@@ -19779,7 +20284,7 @@ ${RESPONSE_TARGET_HINT}`);
     return true;
   }
   /** List ONE level of a directory — directories returned without children (lazy-loaded on demand) */
-  async listDirectoryChildren(dir, rootDir) {
+  async listDirectoryChildren(dir, rootDir, includeHidden = false) {
     let entries;
     try {
       entries = await readdir2(dir, { withFileTypes: true });
@@ -19793,7 +20298,9 @@ ${RESPONSE_TARGET_HINT}`);
     });
     const nodes = [];
     for (const entry of entries) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const isHidden = entry.name.startsWith(".");
+      if (entry.name === "node_modules") continue;
+      if (isHidden && (!includeHidden || isWorkspaceNeverVisibleHiddenEntry(entry.name))) continue;
       const fullPath = path14.join(dir, entry.name);
       const relativePath = path14.relative(rootDir, fullPath);
       let info;
@@ -19803,9 +20310,9 @@ ${RESPONSE_TARGET_HINT}`);
         continue;
       }
       if (entry.isDirectory()) {
-        nodes.push({ name: entry.name, path: relativePath, isDirectory: true, size: 0, modifiedAt: info.mtime.toISOString() });
+        nodes.push({ name: entry.name, path: relativePath, isDirectory: true, size: 0, modifiedAt: info.mtime.toISOString(), isHidden });
       } else {
-        nodes.push({ name: entry.name, path: relativePath, isDirectory: false, size: info.size, modifiedAt: info.mtime.toISOString() });
+        nodes.push({ name: entry.name, path: relativePath, isDirectory: false, size: info.size, modifiedAt: info.mtime.toISOString(), isHidden });
       }
     }
     return nodes;
@@ -19820,6 +20327,14 @@ var systemClock = {
   clearTimeout: (timer) => clearTimeout(timer)
 };
 var INBOUND_WATCHDOG_MS = 7e4;
+function normalizeHandshakeReason(value) {
+  const raw = Array.isArray(value) ? value[0] : value;
+  if (typeof raw !== "string") return null;
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (!/^[a-z0-9_:-]{1,80}$/i.test(trimmed)) return "invalid_header";
+  return trimmed;
+}
 function durationMsBucket(ms) {
   if (ms == null || !Number.isFinite(ms) || ms < 0) return "unknown";
   if (ms === 0) return "0";
@@ -19843,6 +20358,7 @@ var DaemonConnection = class {
   lastDroppedSendLogAt = 0;
   lastInboundAt = null;
   lastInboundMessageKind = null;
+  inboundProbeInFlight = false;
   pendingActivityByAgent = /* @__PURE__ */ new Map();
   latestObservedLaunchIdByAgent = /* @__PURE__ */ new Map();
   constructor(options) {
@@ -19911,6 +20427,7 @@ var DaemonConnection = class {
     });
     const ws = this.options.wsFactory ? this.options.wsFactory(wsUrl, wsOptions) : new WebSocket(wsUrl, wsOptions);
     this.ws = ws;
+    let handshakeRejected = false;
     ws.on("open", () => {
       if (this.ws !== ws) return;
       if (!this.shouldConnect) return;
@@ -19971,8 +20488,27 @@ var DaemonConnection = class {
       this.options.onDisconnect();
       this.scheduleReconnect();
     });
+    ws.on("unexpected-response", (_request, response) => {
+      if (this.ws !== ws) return;
+      handshakeRejected = true;
+      const reason = normalizeHandshakeReason(response.headers["slock-reason"]);
+      const statusCode = response.statusCode ?? 0;
+      const reasonText = reason ? `, slock_reason=${reason}` : "";
+      logger.error(`[Daemon] WebSocket handshake rejected (status=${statusCode}${reasonText})`);
+      this.trace("daemon.connection.handshake_rejected", {
+        status_code: statusCode,
+        slock_reason_present: Boolean(reason),
+        slock_reason: reason
+      }, "error");
+      response.resume();
+      try {
+        ws.terminate();
+      } catch {
+      }
+    });
     ws.on("error", (err) => {
       if (this.ws !== ws) return;
+      if (handshakeRejected) return;
       logger.error(`[Daemon] WebSocket error: ${err.message}`);
       this.trace("daemon.connection.error", {
         error_class: err.name || "Error"
@@ -19996,11 +20532,44 @@ var DaemonConnection = class {
   }
   resetWatchdog() {
     this.clearWatchdog();
+    this.inboundProbeInFlight = false;
+    this.scheduleWatchdogDeadline();
+  }
+  scheduleWatchdogDeadline() {
     const ms = this.options.inboundWatchdogMs ?? INBOUND_WATCHDOG_MS;
     this.watchdogTimer = this.clock.setTimeout(() => {
-      logger.warn(`[Daemon] No inbound traffic for ${ms / 1e3}s \u2014 forcing reconnect`);
+      if (!this.inboundProbeInFlight && this.ws?.readyState === WebSocket.OPEN) {
+        this.inboundProbeInFlight = true;
+        logger.info(`[Daemon] No inbound traffic for ${ms / 1e3}s \u2014 sending liveness probe`);
+        this.trace("daemon.connection.inbound_probe_sent", {
+          inbound_watchdog_ms: ms,
+          last_inbound_message_kind: this.lastInboundMessageKind,
+          last_inbound_age_ms_bucket: this.lastInboundAgeBucket(),
+          ws_ready_state: this.ws.readyState,
+          reconnecting: this.shouldConnect
+        });
+        try {
+          this.ws.send(JSON.stringify({ type: "ping" }));
+        } catch (err) {
+          this.trace("daemon.connection.inbound_probe_send_failed", {
+            inbound_watchdog_ms: ms,
+            error_class: err instanceof Error ? err.name : typeof err,
+            ws_ready_state: this.ws?.readyState ?? null,
+            reconnecting: this.shouldConnect
+          }, "error");
+          try {
+            this.ws?.terminate();
+          } catch {
+          }
+          return;
+        }
+        this.scheduleWatchdogDeadline();
+        return;
+      }
+      logger.warn(`[Daemon] No inbound traffic after liveness probe \u2014 forcing reconnect`);
       this.trace("daemon.connection.watchdog_timeout", {
         inbound_watchdog_ms: ms,
+        probe_in_flight: this.inboundProbeInFlight,
         last_inbound_message_kind: this.lastInboundMessageKind,
         last_inbound_age_ms_bucket: this.lastInboundAgeBucket(),
         ws_ready_state: this.ws?.readyState ?? null,
@@ -20957,7 +21526,7 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
     spanAttrs: ["agentId", "event_kind", "runtime"]
   }
 };
-var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
+var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -20993,9 +21562,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args) {
+function parseDaemonCliArgs(args, env = {}) {
   let serverUrl = "";
-  let apiKey = "";
+  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
     if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
@@ -21032,7 +21601,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-TGKVYIA7.js");
+  await import("./dist-IHHGSWH2.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -21144,7 +21713,7 @@ function summarizeIncomingMessage(msg) {
     case "agent:runtime_profile:daemon_release_notice":
       return `(agent=${msg.agentId}, notice=${msg.noticeKey})`;
     case "agent:workspace:list":
-      return `(agent=${msg.agentId}, dir=${msg.dirPath || "."})`;
+      return `(agent=${msg.agentId}, dir=${msg.dirPath || "."}, hidden=${msg.includeHidden ? "yes" : "no"})`;
     case "agent:workspace:read":
       return `(agent=${msg.agentId}, path=${msg.path})`;
     case "agent:skills:list":
@@ -21669,8 +22238,8 @@ var DaemonCore = class {
         break;
       }
       case "agent:workspace:list":
-        this.agentManager.getFileTree(msg.agentId, msg.dirPath).then((files) => {
-          this.connection.send({ type: "agent:workspace:file_tree", agentId: msg.agentId, files, dirPath: msg.dirPath });
+        this.agentManager.getFileTree(msg.agentId, msg.dirPath, Boolean(msg.includeHidden)).then((files) => {
+          this.connection.send({ type: "agent:workspace:file_tree", agentId: msg.agentId, files, dirPath: msg.dirPath, includeHidden: Boolean(msg.includeHidden) });
         });
         break;
       case "agent:workspace:read":
@@ -21974,6 +22543,8 @@ var DaemonCore = class {
 
 export {
   subscribeDaemonLogs,
+  DAEMON_API_KEY_ENV,
+  scrubDaemonAuthEnv,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,