@botiverse/raft-daemon 0.67.0 → 0.68.0

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

@@ -3303,6 +3303,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);
@@ -5875,27 +5883,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 +5957,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) {
@@ -6628,6 +6656,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 +6851,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 +6881,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 +6903,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 });
             }
           }
         }
@@ -10465,6 +10538,7 @@ var OpenCodeDriver = class {
   };
   supportsStdinNotification = false;
   busyDeliveryMode = "none";
+  supportsNativeStandingPrompt = true;
   terminateProcessOnTurnEnd = true;
   deferSpawnUntilMessage = true;
   shouldDeferWakeMessage(message) {
@@ -12107,6 +12181,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 +13094,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 +13218,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 +13550,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;
@@ -14096,6 +14200,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 +14602,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());
@@ -14602,6 +14740,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}).`,
@@ -14769,7 +14918,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":
@@ -15119,7 +15268,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) {
@@ -15180,6 +15333,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",
@@ -15416,7 +15601,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 +15654,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 +15741,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 +15842,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 +15901,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 +16045,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,
@@ -15919,6 +16135,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 +16328,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 +16351,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 +16412,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 +16505,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 +16566,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 +16852,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 +17029,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 +17045,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 +17702,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 +17859,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 +17872,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 +17889,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 +18205,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);
@@ -18050,13 +18353,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 +18372,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 +18386,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)
     };
   }
@@ -18795,6 +19097,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 +19133,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 +19144,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 +19265,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 +19295,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 +19340,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 +19351,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 +19378,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": {
@@ -19779,7 +20119,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 +20133,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 +20145,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;
@@ -19843,6 +20185,7 @@ var DaemonConnection = class {
   lastDroppedSendLogAt = 0;
   lastInboundAt = null;
   lastInboundMessageKind = null;
+  inboundProbeInFlight = false;
   pendingActivityByAgent = /* @__PURE__ */ new Map();
   latestObservedLaunchIdByAgent = /* @__PURE__ */ new Map();
   constructor(options) {
@@ -19996,11 +20339,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,
@@ -21032,7 +21408,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-Y3VRAU5E.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -21144,7 +21520,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 +22045,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":

package/dist/cli/index.js

@@ -44868,6 +44868,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);

package/dist/core.js

@@ -12,7 +12,7 @@ import {
   runBundledSlockCli,
   scanWorkspaceDirectories,
   subscribeDaemonLogs
-} from "./chunk-H3WRFI54.js";
+} from "./chunk-RXK2KSYW.js";
 export {
   DAEMON_CLI_USAGE,
   DAEMON_CORE_TRACE_ATTR_CONTRACTS,

package/dist/{dist-TGKVYIA7.js → dist-Y3VRAU5E.js}

@@ -44397,6 +44397,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);

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-H3WRFI54.js";
+} from "./chunk-RXK2KSYW.js";
 
 // src/index.ts
 var parsedArgs = parseDaemonCliArgs(process.argv.slice(2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botiverse/raft-daemon",
-  "version": "0.67.0",
+  "version": "0.68.0",
   "type": "module",
   "bin": {
     "raft-daemon": "dist/raft-daemon.js",