@drisp/cli 0.4.2 → 0.4.5

package/dist/{chunk-WHELLVBL.js → chunk-PJUDHH4R.js}

@@ -32,7 +32,7 @@ import {
   resolveActiveWorkflow,
   resolveWorkflow,
   resolveWorkflowPlugins
-} from "./chunk-GE6PPB6Z.js";
+} from "./chunk-5VK2ZMVV.js";
 
 // src/shared/utils/processRegistry.ts
 var ProcessRegistry = class {
@@ -3079,8 +3079,8 @@ function spawnClaude(options) {
     cwd: projectDir,
     stdio: ["ignore", "pipe", "pipe"],
     env: {
-      // Trigger auto-compact at ~95% of 130k (~123.5k tokens used).
-      CLAUDE_CODE_AUTO_COMPACT_WINDOW: "130000",
+      // Claude compacts around 95% of this window; 185k keeps the trigger above 175k tokens used.
+      CLAUDE_CODE_AUTO_COMPACT_WINDOW: "185000",
       ...process.env,
       ...extraEnv ?? {},
       ATHENA_INSTANCE_ID: String(instanceId),
@@ -6555,7 +6555,7 @@ function buildCodexPromptOptions(input) {
     agentRoots: input.workflowPlan?.agentRoots && input.workflowPlan.agentRoots.length > 0 ? input.workflowPlan.agentRoots : void 0,
     plugins: resolveCodexWorkflowPlugins(input.workflowPlan),
     config: {
-      model_auto_compact_token_limit: 13e4,
+      model_auto_compact_token_limit: 175e3,
       ...resolveCodexMcpConfig(input.pluginMcpConfig, input.workflowPlan) ?? {}
     },
     ephemeral: input.ephemeral,
@@ -7297,130 +7297,6 @@ var EXEC_EXIT_CODE = {
 import crypto2 from "crypto";
 import path17 from "path";
 
-// src/core/controller/rules.ts
-function ruleMatches(ruleToolName, toolName) {
-  if (ruleToolName === "*") return true;
-  if (ruleToolName === toolName) return true;
-  if (ruleToolName.endsWith("__*")) {
-    const prefix = ruleToolName.slice(0, -1);
-    return toolName.startsWith(prefix);
-  }
-  return false;
-}
-function matchRule(rules, toolName) {
-  const denyMatch = rules.find(
-    (r) => r.action === "deny" && ruleMatches(r.toolName, toolName)
-  );
-  if (denyMatch) return denyMatch;
-  return rules.find(
-    (r) => r.action === "approve" && ruleMatches(r.toolName, toolName)
-  );
-}
-
-// src/core/controller/permission.ts
-var SESSION_APPROVAL_REQUEST_HOOKS = /* @__PURE__ */ new Set([
-  "item/commandExecution/requestApproval",
-  "item/fileChange/requestApproval",
-  "item/permissions/requestApproval"
-]);
-function isScopedPermissionsRequest(hookName) {
-  return hookName === "item/permissions/requestApproval";
-}
-function supportsSessionApproval(hookName) {
-  return hookName !== void 0 && SESSION_APPROVAL_REQUEST_HOOKS.has(hookName);
-}
-function extractPermissionSnapshot(event) {
-  const data = event.data;
-  const toolNameFromData = typeof data["tool_name"] === "string" ? data["tool_name"] : void 0;
-  const toolInputFromData = typeof data["tool_input"] === "object" && data["tool_input"] !== null ? data["tool_input"] : void 0;
-  const toolUseIdFromData = typeof data["tool_use_id"] === "string" ? data["tool_use_id"] : void 0;
-  return {
-    request_id: event.id,
-    ts: event.timestamp,
-    kind: event.kind,
-    hookName: event.hookName,
-    tool_name: event.toolName ?? toolNameFromData ?? "Unknown",
-    tool_input: toolInputFromData ?? {},
-    tool_use_id: event.toolUseId ?? toolUseIdFromData,
-    suggestions: data.permission_suggestions
-  };
-}
-
-// src/core/controller/runtimeController.ts
-function handleEvent(event, cb) {
-  const eventKind2 = event.kind;
-  const isScoped = isScopedPermissionsRequest(event.hookName);
-  const eventData = event.data;
-  const toolName = event.toolName ?? (typeof eventData["tool_name"] === "string" ? eventData["tool_name"] : void 0);
-  if (eventKind2 === "permission.request" && toolName === "user_input") {
-    cb.enqueueQuestion(event.id);
-    cb.relayQuestion?.(event);
-    return { handled: true };
-  }
-  if (eventKind2 === "permission.request" && toolName) {
-    const rule = matchRule(cb.getRules(), toolName);
-    if (rule?.action === "deny") {
-      return {
-        handled: true,
-        decision: {
-          type: "json",
-          source: "rule",
-          intent: {
-            kind: "permission_deny",
-            reason: `Blocked by rule: ${rule.addedBy}`
-          }
-        }
-      };
-    }
-    if (rule?.action === "approve") {
-      return {
-        handled: true,
-        decision: {
-          type: "json",
-          source: "rule",
-          intent: { kind: "permission_allow" },
-          // Scoped Codex permission grants are session-scoped under
-          // auto rules so the same capability isn't re-prompted.
-          ...isScoped ? { data: { scope: "session" } } : {}
-        }
-      };
-    }
-    cb.enqueuePermission(event);
-    cb.relayPermission?.(event);
-    return { handled: true };
-  }
-  if (eventKind2 === "tool.pre" && toolName === "AskUserQuestion") {
-    cb.enqueueQuestion(event.id);
-    cb.relayQuestion?.(event);
-    return { handled: true };
-  }
-  if (eventKind2 === "tool.pre" && toolName) {
-    const rule = matchRule(cb.getRules(), toolName);
-    if (rule?.action === "deny") {
-      return {
-        handled: true,
-        decision: {
-          type: "json",
-          source: "rule",
-          intent: {
-            kind: "pre_tool_deny",
-            reason: `Blocked by rule: ${rule.addedBy}`
-          }
-        }
-      };
-    }
-    return {
-      handled: true,
-      decision: {
-        type: "json",
-        source: "rule",
-        intent: { kind: "pre_tool_allow" }
-      }
-    };
-  }
-  return { handled: false };
-}
-
 // src/core/feed/todo.ts
 function isSubagentTool(toolName) {
   return toolName === "Task" || toolName === "Agent";
@@ -7802,8 +7678,16 @@ function createTranscriptReader() {
     try {
       const buf = Buffer.alloc(fileSize - offset);
       const bytesRead = fs15.readSync(fd, buf, 0, buf.length, offset);
-      offsets.set(transcriptPath, offset + bytesRead);
-      const chunk = buf.toString("utf8", 0, bytesRead);
+      let lastNewline = -1;
+      for (let i = bytesRead - 1; i >= 0; i--) {
+        if (buf[i] === 10) {
+          lastNewline = i;
+          break;
+        }
+      }
+      if (lastNewline === -1) return [];
+      offsets.set(transcriptPath, offset + lastNewline + 1);
+      const chunk = buf.toString("utf8", 0, lastNewline + 1);
       const lines = chunk.split("\n").filter((l) => l.trim().length > 0);
       const messages = [];
       for (const line of lines) {
@@ -7846,55 +7730,54 @@ function createTranscriptReader() {
   return { readNewAssistantMessages, getOffset };
 }
 
-// src/core/feed/mapper.ts
-function createFeedMapper(bootstrap) {
-  const MAX_STREAMED_TOOL_OUTPUT_CHARS = 64e3;
-  const STREAMED_TOOL_OUTPUT_TRUNCATED_NOTICE = "[streaming output truncated to recent content]\n";
+// src/core/feed/internals/runLifecycle.ts
+function createRunLifecycle() {
   let currentSession = null;
   let currentRun = null;
-  let lastRootTasks = [];
-  const actors = new ActorRegistry();
   let seq = 0;
   let runSeq = 0;
-  const toolPreIndex = /* @__PURE__ */ new Map();
-  const toolDeltaTextByUseId = /* @__PURE__ */ new Map();
-  const truncatedToolDeltaUseIds = /* @__PURE__ */ new Set();
-  const eventIdByRequestId = /* @__PURE__ */ new Map();
-  const eventKindByRequestId = /* @__PURE__ */ new Map();
-  const resolvedRequestById = /* @__PURE__ */ new Map();
-  if (bootstrap) {
-    for (const e of bootstrap.feedEvents) {
-      if (e.seq > seq) seq = e.seq;
-      const m = e.run_id.match(/:R(\d+)$/);
-      if (m) {
-        const n = parseInt(m[1], 10);
-        if (n > runSeq) runSeq = n;
-      }
-      if (e.kind === "tool.pre" && e.actor_id === "agent:root" && e.data.tool_name === "TodoWrite") {
-        lastRootTasks = extractTodoItems(e.data.tool_input);
-      }
-    }
-    const lastAdapterId = bootstrap.adapterSessionIds.at(-1);
-    if (lastAdapterId) {
-      currentSession = {
-        session_id: lastAdapterId,
-        started_at: bootstrap.createdAt,
-        source: "resume"
-      };
-    }
-    let lastRunStart;
-    let lastRunEnd;
-    for (const e of bootstrap.feedEvents) {
-      if (e.kind === "run.start") lastRunStart = e;
-      if (e.kind === "run.end") lastRunEnd = e;
-    }
-    if (lastRunStart && (!lastRunEnd || lastRunEnd.seq < lastRunStart.seq)) {
-      const triggerData = lastRunStart.data;
+  function getRunId() {
+    const sessId = currentSession?.session_id ?? "unknown";
+    return `${sessId}:R${runSeq}`;
+  }
+  return {
+    allocateSeq() {
+      return ++seq;
+    },
+    getRunId,
+    getSession() {
+      return currentSession;
+    },
+    getCurrentRun() {
+      return currentRun;
+    },
+    setSession(session) {
+      currentSession = session;
+    },
+    endSession(ts) {
+      if (currentSession) currentSession.ended_at = ts;
+    },
+    clearSession() {
+      currentSession = null;
+    },
+    incrementCounter(name) {
+      if (currentRun) currentRun.counters[name]++;
+    },
+    closeRun(ts, status) {
+      if (!currentRun) return null;
+      currentRun.status = status;
+      currentRun.ended_at = ts;
+      const closed = currentRun;
+      currentRun = null;
+      return closed;
+    },
+    openNewRun(ts, sessionId, triggerType, promptPreview) {
+      runSeq++;
       currentRun = {
-        run_id: lastRunStart.run_id,
-        session_id: lastRunStart.session_id,
-        started_at: lastRunStart.ts,
-        trigger: triggerData.trigger,
+        run_id: getRunId(),
+        session_id: sessionId,
+        started_at: ts,
+        trigger: { type: triggerType, prompt_preview: promptPreview },
         status: "running",
         actors: { root_agent_id: "agent:root", subagent_ids: [] },
         counters: {
@@ -7904,54 +7787,344 @@ function createFeedMapper(bootstrap) {
           blocks: 0
         }
       };
+      return currentRun;
+    },
+    restoreFrom(bootstrap) {
       for (const e of bootstrap.feedEvents) {
-        if (e.run_id !== currentRun.run_id) continue;
-        if (e.kind === "tool.pre") currentRun.counters.tool_uses++;
-        if (e.kind === "tool.failure") currentRun.counters.tool_failures++;
-        if (e.kind === "permission.request")
-          currentRun.counters.permission_requests++;
+        if (e.seq > seq) seq = e.seq;
+        const m = e.run_id.match(/:R(\d+)$/);
+        if (m) {
+          const n = parseInt(m[1], 10);
+          if (n > runSeq) runSeq = n;
+        }
+      }
+      const lastAdapterId = bootstrap.adapterSessionIds.at(-1);
+      if (lastAdapterId) {
+        currentSession = {
+          session_id: lastAdapterId,
+          started_at: bootstrap.createdAt,
+          source: "resume"
+        };
+      }
+      let lastRunStart;
+      let lastRunEnd;
+      for (const e of bootstrap.feedEvents) {
+        if (e.kind === "run.start") lastRunStart = e;
+        if (e.kind === "run.end") lastRunEnd = e;
+      }
+      if (lastRunStart && (!lastRunEnd || lastRunEnd.seq < lastRunStart.seq)) {
+        const triggerData = lastRunStart.data;
+        currentRun = {
+          run_id: lastRunStart.run_id,
+          session_id: lastRunStart.session_id,
+          started_at: lastRunStart.ts,
+          trigger: triggerData.trigger,
+          status: "running",
+          actors: { root_agent_id: "agent:root", subagent_ids: [] },
+          counters: {
+            tool_uses: 0,
+            tool_failures: 0,
+            permission_requests: 0,
+            blocks: 0
+          }
+        };
+        for (const e of bootstrap.feedEvents) {
+          if (e.run_id !== currentRun.run_id) continue;
+          if (e.kind === "tool.pre") currentRun.counters.tool_uses++;
+          if (e.kind === "tool.failure") currentRun.counters.tool_failures++;
+          if (e.kind === "permission.request")
+            currentRun.counters.permission_requests++;
+        }
       }
     }
-  }
-  function extractTodoItems(toolInput) {
-    const input = toolInput;
-    return Array.isArray(input?.todos) ? input.todos : [];
-  }
-  function mapPlanStepStatus(status) {
-    switch (status) {
-      case "inProgress":
-        return "in_progress";
-      case "completed":
-        return "completed";
-      case void 0:
-      default:
-        return "pending";
+  };
+}
+
+// src/core/feed/internals/decisionCorrelation.ts
+function createDecisionCorrelation() {
+  const eventIdByRequestId = /* @__PURE__ */ new Map();
+  const eventKindByRequestId = /* @__PURE__ */ new Map();
+  const resolvedRequestById = /* @__PURE__ */ new Map();
+  return {
+    recordRequest(requestId, eventId, kind) {
+      eventIdByRequestId.set(requestId, eventId);
+      eventKindByRequestId.set(requestId, kind);
+      resolvedRequestById.set(requestId, { event_id: eventId, kind });
+    },
+    lookupResolved(requestId) {
+      return resolvedRequestById.get(requestId) ?? null;
+    },
+    consumeForDecision(requestId) {
+      const parentEventId = eventIdByRequestId.get(requestId);
+      if (!parentEventId) return null;
+      const originalKind = eventKindByRequestId.get(requestId);
+      eventIdByRequestId.delete(requestId);
+      eventKindByRequestId.delete(requestId);
+      return { parentEventId, originalKind };
+    },
+    resetForNewRun() {
+      eventIdByRequestId.clear();
+      eventKindByRequestId.clear();
+      resolvedRequestById.clear();
     }
+  };
+}
+
+// src/core/feed/internals/toolCorrelation.ts
+var MAX_STREAMED_TOOL_OUTPUT_CHARS = 64e3;
+var STREAMED_TOOL_OUTPUT_TRUNCATED_NOTICE = "[streaming output truncated to recent content]\n";
+function createToolCorrelation() {
+  const toolPreIndex = /* @__PURE__ */ new Map();
+  const toolDeltaTextByUseId = /* @__PURE__ */ new Map();
+  const truncatedToolDeltaUseIds = /* @__PURE__ */ new Set();
+  return {
+    recordPre(toolUseId, eventId) {
+      toolPreIndex.set(toolUseId, eventId);
+    },
+    lookupParent(toolUseId) {
+      return toolUseId ? toolPreIndex.get(toolUseId) : void 0;
+    },
+    forgetTool(toolUseId) {
+      toolDeltaTextByUseId.delete(toolUseId);
+      truncatedToolDeltaUseIds.delete(toolUseId);
+    },
+    appendDelta(toolUseId, chunk) {
+      if (!toolUseId) return chunk;
+      const cumulative = `${toolDeltaTextByUseId.get(toolUseId) ?? ""}${chunk}`;
+      if (cumulative.length <= MAX_STREAMED_TOOL_OUTPUT_CHARS) {
+        toolDeltaTextByUseId.set(toolUseId, cumulative);
+        return truncatedToolDeltaUseIds.has(toolUseId) ? `${STREAMED_TOOL_OUTPUT_TRUNCATED_NOTICE}${cumulative}` : cumulative;
+      }
+      const tail2 = cumulative.slice(-MAX_STREAMED_TOOL_OUTPUT_CHARS);
+      toolDeltaTextByUseId.set(toolUseId, tail2);
+      truncatedToolDeltaUseIds.add(toolUseId);
+      return `${STREAMED_TOOL_OUTPUT_TRUNCATED_NOTICE}${tail2}`;
+    },
+    resetForNewRun() {
+      toolPreIndex.clear();
+      toolDeltaTextByUseId.clear();
+      truncatedToolDeltaUseIds.clear();
+    }
+  };
+}
+
+// src/core/feed/internals/agentMessageStream.ts
+function normalizeAgentMessage(message) {
+  return message.replace(/\r\n/g, "\n").trimEnd();
+}
+function agentMessageKey(actorId, scope) {
+  return `${actorId}\0${scope}`;
+}
+function createAgentMessageStream(eventBuilder, transcriptReader) {
+  const pendingMessages = /* @__PURE__ */ new Map();
+  const lastAgentMessageByActorScope = /* @__PURE__ */ new Map();
+  const reasoningSummaryByKey = /* @__PURE__ */ new Map();
+  function emit(args) {
+    const normalized = normalizeAgentMessage(args.message);
+    if (!normalized) return null;
+    const key = agentMessageKey(args.actorId, args.scope);
+    if (lastAgentMessageByActorScope.get(key) === normalized) return null;
+    const data = {
+      message: normalized,
+      source: args.source,
+      scope: args.scope,
+      ...args.model ? { model: args.model } : {}
+    };
+    const event = eventBuilder(
+      "agent.message",
+      "info",
+      args.actorId,
+      data,
+      args.runtimeEvent,
+      args.cause
+    );
+    lastAgentMessageByActorScope.set(key, normalized);
+    return event;
   }
-  function nextSeq() {
-    return ++seq;
-  }
-  function appendToolDelta(toolUseId, chunk) {
-    if (!toolUseId) {
-      return chunk;
+  return {
+    emit,
+    appendPendingDelta(itemId, delta, defaultActorId, defaultScope) {
+      if (!delta) return;
+      const key = itemId ?? "__legacy_root__";
+      const existing = pendingMessages.get(key);
+      if (existing) {
+        existing.message += delta;
+        return;
+      }
+      pendingMessages.set(key, {
+        message: delta,
+        actorId: defaultActorId,
+        scope: defaultScope
+      });
+    },
+    emitCompleted({
+      itemId,
+      messageText,
+      fallbackActorId,
+      fallbackScope,
+      runtimeEvent
+    }) {
+      const key = itemId ?? "__legacy_root__";
+      const pending = pendingMessages.get(key);
+      const message = messageText ?? pending?.message ?? "";
+      pendingMessages.delete(key);
+      if (!message) return null;
+      const actorId = pending?.actorId ?? fallbackActorId;
+      const scope = pending?.scope ?? fallbackScope;
+      return emit({
+        runtimeEvent,
+        actorId,
+        scope,
+        message,
+        source: "hook"
+      });
+    },
+    flushPending(runtimeEvent) {
+      const out = [];
+      for (const [key, pending] of pendingMessages) {
+        if (pending.message) {
+          const ev = emit({
+            runtimeEvent,
+            actorId: pending.actorId,
+            scope: pending.scope,
+            message: pending.message,
+            source: "hook"
+          });
+          if (ev) out.push(ev);
+        }
+        pendingMessages.delete(key);
+      }
+      return out;
+    },
+    emitTranscriptMessages(transcriptPath, runtimeEvent, actorId, scope) {
+      const msgs = transcriptReader.readNewAssistantMessages(transcriptPath);
+      const out = [];
+      for (const msg of msgs) {
+        const ev = emit({
+          runtimeEvent,
+          actorId,
+          scope,
+          message: msg.text,
+          source: "transcript",
+          model: msg.model
+        });
+        if (ev) out.push(ev);
+      }
+      return out;
+    },
+    drainTranscript(transcriptPath) {
+      transcriptReader.readNewAssistantMessages(transcriptPath);
+    },
+    appendReasoningSummary(itemId, index, chunk) {
+      const key = `${itemId ?? ""}:${index ?? 0}`;
+      const next = `${reasoningSummaryByKey.get(key) ?? ""}${chunk}`;
+      reasoningSummaryByKey.set(key, next);
+      return next;
+    },
+    clearPending() {
+      pendingMessages.clear();
+    },
+    resetDeduper() {
+      lastAgentMessageByActorScope.clear();
+    },
+    resetForNewRun() {
+      lastAgentMessageByActorScope.clear();
+      reasoningSummaryByKey.clear();
     }
-    const cumulative = `${toolDeltaTextByUseId.get(toolUseId) ?? ""}${chunk}`;
-    if (cumulative.length <= MAX_STREAMED_TOOL_OUTPUT_CHARS) {
-      toolDeltaTextByUseId.set(toolUseId, cumulative);
-      return truncatedToolDeltaUseIds.has(toolUseId) ? `${STREAMED_TOOL_OUTPUT_TRUNCATED_NOTICE}${cumulative}` : cumulative;
+  };
+}
+
+// src/core/feed/internals/rootPlanTracker.ts
+function createRootPlanTracker() {
+  let items = [];
+  return {
+    set(next) {
+      items = next;
+    },
+    current() {
+      return items;
+    },
+    differs(next) {
+      if (next.length !== items.length) return true;
+      for (let i = 0; i < next.length; i++) {
+        if (next[i]?.content !== items[i]?.content) return true;
+        if (next[i]?.status !== items[i]?.status) return true;
+      }
+      return false;
     }
-    const tail2 = cumulative.slice(-MAX_STREAMED_TOOL_OUTPUT_CHARS);
-    toolDeltaTextByUseId.set(toolUseId, tail2);
-    truncatedToolDeltaUseIds.add(toolUseId);
-    return `${STREAMED_TOOL_OUTPUT_TRUNCATED_NOTICE}${tail2}`;
-  }
-  function getRunId() {
-    const sessId = currentSession?.session_id ?? "unknown";
-    return `${sessId}:R${runSeq}`;
+  };
+}
+
+// src/core/feed/internals/subagentTracker.ts
+function createSubagentTracker() {
+  const stack = [];
+  const descriptions = /* @__PURE__ */ new Map();
+  let pendingDescription;
+  return {
+    pushActor(actorId) {
+      stack.push(actorId);
+    },
+    popActor(actorId) {
+      const idx = stack.lastIndexOf(actorId);
+      if (idx !== -1) stack.splice(idx, 1);
+    },
+    peek() {
+      return stack.length > 0 ? stack[stack.length - 1] : void 0;
+    },
+    clear() {
+      stack.length = 0;
+    },
+    currentScope() {
+      return stack.length > 0 ? "subagent" : "root";
+    },
+    recordPendingDescription(description) {
+      pendingDescription = description;
+    },
+    clearPendingDescription() {
+      pendingDescription = void 0;
+    },
+    consumePendingDescription() {
+      const value = pendingDescription;
+      pendingDescription = void 0;
+      return value;
+    },
+    setDescription(agentId, description) {
+      descriptions.set(agentId, description);
+    },
+    description(agentId) {
+      return descriptions.get(agentId);
+    }
+  };
+}
+
+// src/core/feed/mapper.ts
+function extractTodoItems(toolInput) {
+  const input = toolInput;
+  return Array.isArray(input?.todos) ? input.todos : [];
+}
+function mapPlanStepStatus(status) {
+  switch (status) {
+    case "inProgress":
+      return "in_progress";
+    case "completed":
+      return "completed";
+    case void 0:
+    default:
+      return "pending";
   }
+}
+function createFeedMapper(bootstrap) {
+  const runLifecycle = createRunLifecycle();
+  const decisionCorrelation = createDecisionCorrelation();
+  const toolCorrelation = createToolCorrelation();
+  const transcriptReader = createTranscriptReader();
+  const actors = new ActorRegistry();
+  const rootPlan = createRootPlanTracker();
+  const subagents = createSubagentTracker();
   function makeEvent(kind, level, actorId, data, runtimeEvent, cause) {
-    const s = nextSeq();
-    const eventId = `${getRunId()}:E${s}`;
+    const s = runLifecycle.allocateSeq();
+    const runId = runLifecycle.getRunId();
+    const eventId = `${runId}:E${s}`;
     const baseCause = {
       hook_request_id: runtimeEvent.id,
       transcript_path: runtimeEvent.context.transcriptPath,
@@ -7962,7 +8135,7 @@ function createFeedMapper(bootstrap) {
       seq: s,
       ts: runtimeEvent.timestamp,
       session_id: runtimeEvent.sessionId,
-      run_id: getRunId(),
+      run_id: runId,
       kind,
       level,
       actor_id: actorId,
@@ -7974,57 +8147,50 @@ function createFeedMapper(bootstrap) {
     };
     fe.title = composeTitle(fe, runtimeEvent);
     if (runtimeEvent.interaction.expectsDecision || kind === "permission.request" || kind === "stop.request") {
-      eventIdByRequestId.set(runtimeEvent.id, eventId);
-      eventKindByRequestId.set(runtimeEvent.id, kind);
-      resolvedRequestById.set(runtimeEvent.id, { event_id: eventId, kind });
+      decisionCorrelation.recordRequest(runtimeEvent.id, eventId, kind);
     }
     return fe;
   }
-  function closeRun(runtimeEvent, status) {
-    if (!currentRun) return null;
-    currentRun.status = status;
-    currentRun.ended_at = runtimeEvent.timestamp;
-    const evt = makeEvent(
+  const agentMessageStream = createAgentMessageStream(
+    makeEvent,
+    transcriptReader
+  );
+  if (bootstrap) {
+    runLifecycle.restoreFrom(bootstrap);
+    for (const e of bootstrap.feedEvents) {
+      if (e.kind === "tool.pre" && e.actor_id === "agent:root" && e.data.tool_name === "TodoWrite") {
+        rootPlan.set(
+          extractTodoItems(e.data.tool_input)
+        );
+      }
+    }
+  }
+  function closeRunIntoEvent(runtimeEvent, status) {
+    const closed = runLifecycle.closeRun(runtimeEvent.timestamp, status);
+    if (!closed) return null;
+    return makeEvent(
       "run.end",
       "info",
       "system",
-      { status, counters: { ...currentRun.counters } },
+      { status, counters: { ...closed.counters } },
       runtimeEvent
     );
-    currentRun = null;
-    return evt;
   }
   function ensureRunArray(runtimeEvent, triggerType = "other", promptPreview) {
-    if (currentRun && triggerType === "other") return [];
+    if (runLifecycle.getCurrentRun() && triggerType === "other") return [];
     const results = [];
-    if (currentRun) {
-      const closeEvt = closeRun(runtimeEvent, "completed");
-      if (closeEvt) results.push(closeEvt);
-    }
-    runSeq++;
-    toolPreIndex.clear();
-    toolDeltaTextByUseId.clear();
-    truncatedToolDeltaUseIds.clear();
-    reasoningSummaryByKey.clear();
-    eventIdByRequestId.clear();
-    eventKindByRequestId.clear();
-    resolvedRequestById.clear();
-    resetAgentMessageDeduper();
-    activeSubagentStack.length = 0;
-    currentRun = {
-      run_id: getRunId(),
-      session_id: runtimeEvent.sessionId,
-      started_at: runtimeEvent.timestamp,
-      trigger: { type: triggerType, prompt_preview: promptPreview },
-      status: "running",
-      actors: { root_agent_id: "agent:root", subagent_ids: [] },
-      counters: {
-        tool_uses: 0,
-        tool_failures: 0,
-        permission_requests: 0,
-        blocks: 0
-      }
-    };
+    const closeEvt = closeRunIntoEvent(runtimeEvent, "completed");
+    if (closeEvt) results.push(closeEvt);
+    toolCorrelation.resetForNewRun();
+    decisionCorrelation.resetForNewRun();
+    agentMessageStream.resetForNewRun();
+    subagents.clear();
+    runLifecycle.openNewRun(
+      runtimeEvent.timestamp,
+      runtimeEvent.sessionId,
+      triggerType,
+      promptPreview
+    );
     results.push(
       makeEvent(
         "run.start",
@@ -8036,73 +8202,8 @@ function createFeedMapper(bootstrap) {
     );
     return results;
   }
-  const activeSubagentStack = [];
-  let lastTaskDescription;
-  const subagentDescriptions = /* @__PURE__ */ new Map();
-  const pendingMessages = /* @__PURE__ */ new Map();
-  const lastAgentMessageByActorScope = /* @__PURE__ */ new Map();
-  const reasoningSummaryByKey = /* @__PURE__ */ new Map();
-  const transcriptReader = createTranscriptReader();
-  function emitTranscriptMessages(transcriptPath, runtimeEvent, actorId, scope) {
-    const msgs = transcriptReader.readNewAssistantMessages(transcriptPath);
-    const results = [];
-    for (const msg of msgs) {
-      const agentMsg = emitAgentMessage(
-        runtimeEvent,
-        actorId,
-        scope,
-        msg.text,
-        "transcript",
-        void 0,
-        msg.model
-      );
-      if (agentMsg) {
-        results.push(agentMsg);
-      }
-    }
-    return results;
-  }
-  function agentMessageKey(actorId, scope) {
-    return `${actorId}\0${scope}`;
-  }
-  function normalizeAgentMessage(message) {
-    return message.replace(/\r\n/g, "\n").trimEnd();
-  }
-  function resetAgentMessageDeduper() {
-    lastAgentMessageByActorScope.clear();
-  }
-  function appendReasoningSummary(itemId, index, chunk) {
-    const key = `${itemId ?? ""}:${index ?? 0}`;
-    const next = `${reasoningSummaryByKey.get(key) ?? ""}${chunk}`;
-    reasoningSummaryByKey.set(key, next);
-    return next;
-  }
-  function emitAgentMessage(runtimeEvent, actorId, scope, message, source, cause, model) {
-    const normalized = normalizeAgentMessage(message);
-    if (!normalized) return null;
-    const key = agentMessageKey(actorId, scope);
-    const previous = lastAgentMessageByActorScope.get(key);
-    if (previous === normalized) {
-      return null;
-    }
-    const event = makeEvent(
-      "agent.message",
-      "info",
-      actorId,
-      {
-        message: normalized,
-        source,
-        scope,
-        ...model ? { model } : {}
-      },
-      runtimeEvent,
-      cause
-    );
-    lastAgentMessageByActorScope.set(key, normalized);
-    return event;
-  }
   function resolveToolActor() {
-    return activeSubagentStack.length > 0 ? activeSubagentStack[activeSubagentStack.length - 1] : "agent:root";
+    return subagents.peek() ?? "agent:root";
   }
   function resolveToolUseId(event, record) {
     return event.toolUseId ?? record["tool_use_id"];
@@ -8145,100 +8246,44 @@ function createFeedMapper(bootstrap) {
     };
     const eventKind2 = event.kind;
     const results = [];
-    const resolveMessageScope = () => {
-      const actorId = resolveToolActor();
-      return {
-        actorId,
-        scope: activeSubagentStack.length > 0 ? "subagent" : "root"
-      };
-    };
-    const appendPendingMessageDelta = (itemId, delta) => {
-      if (!delta) return;
-      const key = itemId ?? "__legacy_root__";
-      const existing = pendingMessages.get(key);
-      if (existing) {
-        existing.message += delta;
-        return;
-      }
-      const scope = resolveMessageScope();
-      pendingMessages.set(key, {
-        message: delta,
-        actorId: scope.actorId,
-        scope: scope.scope
-      });
-    };
-    const emitCompletedMessage = (itemId, messageText) => {
-      const key = itemId ?? "__legacy_root__";
-      const pending = pendingMessages.get(key);
-      const message = messageText ?? pending?.message ?? "";
-      if (!message) return;
-      const scope = pending ?? resolveMessageScope();
-      const agentMsg = emitAgentMessage(
-        event,
-        scope.actorId,
-        scope.scope,
-        message,
-        "hook"
-      );
-      if (agentMsg) {
-        results.push(agentMsg);
-      }
-      pendingMessages.delete(key);
-    };
-    const flushPendingMessages = () => {
-      for (const [itemId, pending] of pendingMessages) {
-        if (!pending.message) continue;
-        const agentMsg = emitAgentMessage(
-          event,
-          pending.actorId,
-          pending.scope,
-          pending.message,
-          "hook"
-        );
-        if (agentMsg) {
-          results.push(agentMsg);
-        }
-        pendingMessages.delete(itemId);
-      }
-    };
+    const currentScope = () => subagents.currentScope();
     function emitFallbackMessage(parentKind, actorId, scope) {
       if (results.some((r) => r.kind === "agent.message")) return;
       const msg = readString(d["last_assistant_message"]);
       if (!msg) return;
       const parentEvt = results.find((r) => r.kind === parentKind);
-      const agentMsg = emitAgentMessage(
-        event,
+      const ev = agentMessageStream.emit({
+        runtimeEvent: event,
         actorId,
         scope,
-        msg,
-        "hook",
-        parentEvt ? { parent_event_id: parentEvt.event_id } : void 0
-      );
-      if (agentMsg) {
-        results.push(agentMsg);
-      }
+        message: msg,
+        source: "hook",
+        cause: parentEvt ? { parent_event_id: parentEvt.event_id } : void 0
+      });
+      if (ev) results.push(ev);
     }
     const transcriptPath = event.context.transcriptPath;
     const isStopEvent = eventKind2 === "stop.request" || eventKind2 === "subagent.stop";
     if (transcriptPath && !isStopEvent) {
-      const transcriptMsgs = emitTranscriptMessages(
-        transcriptPath,
-        event,
-        resolveToolActor(),
-        activeSubagentStack.length > 0 ? "subagent" : "root"
+      results.push(
+        ...agentMessageStream.emitTranscriptMessages(
+          transcriptPath,
+          event,
+          resolveToolActor(),
+          currentScope()
+        )
       );
-      results.push(...transcriptMsgs);
     }
     switch (eventKind2) {
       case "session.start": {
-        pendingMessages.clear();
+        agentMessageStream.clearPending();
         const source = readString(d["source"]) ?? "startup";
-        currentSession = {
+        runLifecycle.setSession({
           session_id: event.sessionId,
           started_at: event.timestamp,
           source,
           agent_type: readString(d["agent_type"])
-        };
+        });
         if (source === "resume" || source === "clear" || source === "compact") {
           results.push(
             ...ensureRunArray(event, source)
@@ -8260,11 +8305,9 @@ function createFeedMapper(bootstrap) {
         break;
       }
       case "session.end": {
-        pendingMessages.clear();
-        if (currentRun) {
-          const closeEvt = closeRun(event, "completed");
-          if (closeEvt) results.push(closeEvt);
-        }
+        agentMessageStream.clearPending();
+        const closeEvt = closeRunIntoEvent(event, "completed");
+        if (closeEvt) results.push(closeEvt);
         results.push(
           makeEvent(
             "session.end",
@@ -8276,9 +8319,7 @@ function createFeedMapper(bootstrap) {
             event
           )
         );
-        if (currentSession) {
-          currentSession.ended_at = event.timestamp;
-        }
+        runLifecycle.endSession(event.timestamp);
         break;
       }
       case "user.prompt": {
@@ -8302,7 +8343,7 @@ function createFeedMapper(bootstrap) {
         break;
       }
       case "turn.start": {
-        pendingMessages.clear();
+        agentMessageStream.clearPending();
         const prompt = readString(d["prompt"]);
         results.push(
           ...ensureRunArray(
@@ -8329,23 +8370,29 @@ function createFeedMapper(bootstrap) {
         break;
       }
       case "message.delta": {
-        appendPendingMessageDelta(
+        agentMessageStream.appendPendingDelta(
           readString(d["item_id"]),
-          readString(d["delta"]) ?? ""
+          readString(d["delta"]) ?? "",
+          resolveToolActor(),
+          currentScope()
         );
         break;
       }
       case "message.complete": {
         results.push(...ensureRunArray(event));
-        emitCompletedMessage(
-          readString(d["item_id"]),
-          readString(d["message"])
-        );
+        const ev = agentMessageStream.emitCompleted({
+          itemId: readString(d["item_id"]),
+          messageText: readString(d["message"]),
+          fallbackActorId: resolveToolActor(),
+          fallbackScope: currentScope(),
+          runtimeEvent: event
+        });
+        if (ev) results.push(ev);
         break;
       }
       case "turn.complete": {
-        if (!currentRun) {
-          pendingMessages.clear();
+        if (!runLifecycle.getCurrentRun()) {
+          agentMessageStream.clearPending();
           break;
         }
         const stopEvt = makeEvent(
@@ -8358,39 +8405,29 @@ function createFeedMapper(bootstrap) {
           event
         );
         results.push(stopEvt);
-        const messageCountBeforeFlush = results.length;
-        flushPendingMessages();
-        if (results.length > messageCountBeforeFlush) {
-          for (let i = messageCountBeforeFlush; i < results.length; i++) {
-            results[i].cause = {
-              ...results[i].cause ?? {},
-              parent_event_id: stopEvt.event_id
-            };
-          }
-        }
-        const closeEvt = closeRun(event, "completed");
-        if (closeEvt) {
-          results.push(closeEvt);
+        const flushed = agentMessageStream.flushPending(event);
+        for (const f of flushed) {
+          f.cause = {
+            ...f.cause ?? {},
+            parent_event_id: stopEvt.event_id
+          };
+          results.push(f);
         }
+        const closeEvt = closeRunIntoEvent(event, "completed");
+        if (closeEvt) results.push(closeEvt);
         break;
       }
       case "plan.delta": {
         const planSteps = d["plan"];
         if (Array.isArray(planSteps) && planSteps.length > 0) {
-          const changed = planSteps.length !== lastRootTasks.length || planSteps.some(
-            (step, i) => {
-              const content = typeof step.step === "string" ? step.step : "";
-              const status = mapPlanStepStatus(step.status);
-              return content !== lastRootTasks[i]?.content || status !== lastRootTasks[i]?.status;
-            }
+          const next = planSteps.map(
+            (step) => ({
+              content: typeof step.step === "string" ? step.step : "",
+              status: mapPlanStepStatus(step.status)
+            })
           );
-          if (changed) {
-            lastRootTasks = planSteps.map(
-              (step) => ({
-                content: typeof step.step === "string" ? step.step : "",
-                status: mapPlanStepStatus(step.status)
-              })
-            );
+          if (rootPlan.differs(next)) {
+            rootPlan.set(next);
             results.push(
               makeEvent(
                 "todo.update",
@@ -8435,7 +8472,7 @@ function createFeedMapper(bootstrap) {
               "info",
               "agent:root",
               {
-                message: appendReasoningSummary(
+                message: agentMessageStream.appendReasoningSummary(
                   readString(d["item_id"]),
                   summaryIndex,
                   readString(d["delta"]) ?? ""
@@ -8472,9 +8509,9 @@ function createFeedMapper(bootstrap) {
         results.push(...ensureRunArray(event));
         const toolUseId = resolveToolUseId(event, d);
         const toolName = event.toolName ?? readString(d["tool_name"]) ?? "Unknown";
-        const parentId = toolUseId ? toolPreIndex.get(toolUseId) : void 0;
+        const parentId = toolCorrelation.lookupParent(toolUseId);
         const chunk = readString(d["delta"]) ?? "";
-        const cumulative = appendToolDelta(toolUseId, chunk);
+        const cumulative = toolCorrelation.appendDelta(toolUseId, chunk);
         results.push(
           makeEvent(
             "tool.delta",
@@ -8494,7 +8531,7 @@ function createFeedMapper(bootstrap) {
       }
       case "tool.pre": {
         results.push(...ensureRunArray(event));
-        if (currentRun) currentRun.counters.tool_uses++;
+        runLifecycle.incrementCounter("tool_uses");
         const toolUseId = resolveToolUseId(event, d);
         const toolName = event.toolName ?? readString(d["tool_name"]) ?? "Unknown";
         const fe = makeEvent(
@@ -8510,7 +8547,7 @@ function createFeedMapper(bootstrap) {
           toolUseId ? { tool_use_id: toolUseId } : void 0
         );
         if (toolUseId) {
-          toolPreIndex.set(toolUseId, fe.event_id);
+          toolCorrelation.recordPre(toolUseId, fe.event_id);
         }
         results.push(fe);
         if (toolName === "WebSearch") {
@@ -8536,22 +8573,23 @@ function createFeedMapper(bootstrap) {
           );
         }
         if (toolName === "TodoWrite" && fe.actor_id === "agent:root") {
-          lastRootTasks = extractTodoItems(readObject(d["tool_input"]));
+          rootPlan.set(extractTodoItems(readObject(d["tool_input"])));
         }
         if (isSubagentTool(toolName)) {
           const input = readObject(d["tool_input"]);
-          lastTaskDescription = typeof input["description"] === "string" ? input["description"] : void 0;
+          if (typeof input["description"] === "string") {
+            subagents.recordPendingDescription(input["description"]);
+          } else {
+            subagents.clearPendingDescription();
+          }
         }
         break;
       }
       case "tool.post": {
         results.push(...ensureRunArray(event));
         const toolUseId = resolveToolUseId(event, d);
-        if (toolUseId) {
-          toolDeltaTextByUseId.delete(toolUseId);
-          truncatedToolDeltaUseIds.delete(toolUseId);
-        }
-        const parentId = toolUseId ? toolPreIndex.get(toolUseId) : void 0;
+        if (toolUseId) toolCorrelation.forgetTool(toolUseId);
+        const parentId = toolCorrelation.lookupParent(toolUseId);
         const toolName = event.toolName ?? readString(d["tool_name"]) ?? "Unknown";
         const postEvent = makeEvent(
           "tool.post",
@@ -8599,13 +8637,10 @@ function createFeedMapper(bootstrap) {
       }
       case "tool.failure": {
         results.push(...ensureRunArray(event));
-        if (currentRun) currentRun.counters.tool_failures++;
+        runLifecycle.incrementCounter("tool_failures");
         const toolUseId = resolveToolUseId(event, d);
-        if (toolUseId) {
-          toolDeltaTextByUseId.delete(toolUseId);
-          truncatedToolDeltaUseIds.delete(toolUseId);
-        }
-        const parentId = toolUseId ? toolPreIndex.get(toolUseId) : void 0;
+        if (toolUseId) toolCorrelation.forgetTool(toolUseId);
+        const parentId = toolCorrelation.lookupParent(toolUseId);
         const toolName = event.toolName ?? readString(d["tool_name"]) ?? "Unknown";
         results.push(
           makeEvent(
@@ -8627,7 +8662,7 @@ function createFeedMapper(bootstrap) {
       }
       case "permission.request": {
         results.push(...ensureRunArray(event));
-        if (currentRun) currentRun.counters.permission_requests++;
+        runLifecycle.incrementCounter("permission_requests");
         const toolName = event.toolName ?? readString(d["tool_name"]) ?? "Unknown";
         results.push(
           makeEvent(
@@ -8676,9 +8711,11 @@ function createFeedMapper(bootstrap) {
         const agentType = event.agentType ?? readString(d["agent_type"]);
         if (agentId) {
           actors.ensureSubagent(agentId, agentType ?? "unknown");
+          const currentRun = runLifecycle.getCurrentRun();
           if (currentRun) currentRun.actors.subagent_ids.push(agentId);
-          activeSubagentStack.push(`subagent:${agentId}`);
+          subagents.pushActor(`subagent:${agentId}`);
         }
+        const description = subagents.consumePendingDescription() ?? readString(d["prompt"]);
         results.push(
           makeEvent(
             "subagent.start",
@@ -8687,7 +8724,7 @@ function createFeedMapper(bootstrap) {
             {
               agent_id: agentId ?? "",
               agent_type: agentType ?? "",
-              description: lastTaskDescription ?? readString(d["prompt"]) ?? void 0,
+              description: description ?? void 0,
               tool: readString(d["tool"]),
               sender_thread_id: readString(d["sender_thread_id"]),
               receiver_thread_id: readString(d["receiver_thread_id"]),
@@ -8697,22 +8734,16 @@ function createFeedMapper(bootstrap) {
             event
           )
         );
-        if (agentId && (lastTaskDescription || readString(d["prompt"]))) {
-          subagentDescriptions.set(
-            agentId,
-            lastTaskDescription ?? readString(d["prompt"]) ?? ""
-          );
+        if (agentId && description) {
+          subagents.setDescription(agentId, description);
         }
-        lastTaskDescription = void 0;
         break;
       }
       case "subagent.stop": {
         results.push(...ensureRunArray(event));
         const agentId = event.agentId ?? readString(d["agent_id"]);
         if (agentId) {
-          const actorId = `subagent:${agentId}`;
-          const idx = activeSubagentStack.lastIndexOf(actorId);
-          if (idx !== -1) activeSubagentStack.splice(idx, 1);
+          subagents.popActor(`subagent:${agentId}`);
         }
         const subStopActorId = `subagent:${agentId ?? "unknown"}`;
         const subStopEvt = makeEvent(
@@ -8725,7 +8756,7 @@ function createFeedMapper(bootstrap) {
             stop_hook_active: readBoolean(d["stop_hook_active"]) ?? false,
             agent_transcript_path: readString(d["agent_transcript_path"]),
             last_assistant_message: readString(d["last_assistant_message"]),
-            description: subagentDescriptions.get(agentId ?? ""),
+            description: subagents.description(agentId ?? ""),
             tool: readString(d["tool"]),
             status: readString(d["status"]),
             sender_thread_id: readString(d["sender_thread_id"]),
@@ -8836,7 +8867,7 @@ function createFeedMapper(bootstrap) {
           ],
           "server_request.resolved": (data, runtimeEvent, ctx) => {
             const requestId = data["request_id"] !== void 0 ? String(data["request_id"]) : void 0;
-            const resolved = requestId ? resolvedRequestById.get(requestId) : void 0;
+            const resolved = requestId ? decisionCorrelation.lookupResolved(requestId) : null;
             return [
               makeEvent(
                 "server.request.resolved",
@@ -9174,100 +9205,260 @@ function createFeedMapper(bootstrap) {
       }
     }
     if (eventKind2 === "stop.request") {
-      if (transcriptPath) {
-        transcriptReader.readNewAssistantMessages(transcriptPath);
-      }
+      if (transcriptPath) agentMessageStream.drainTranscript(transcriptPath);
       emitFallbackMessage("stop.request", "agent:root", "root");
     }
     if (eventKind2 === "subagent.stop") {
       const agentId = readString(d["agent_id"]) ?? "unknown";
-      if (transcriptPath) {
-        transcriptReader.readNewAssistantMessages(transcriptPath);
-      }
+      if (transcriptPath) agentMessageStream.drainTranscript(transcriptPath);
       emitFallbackMessage("subagent.stop", `subagent:${agentId}`, "subagent");
     }
-    return results;
+    return results;
+  }
+  function mapDecision(requestId, decision) {
+    const consumed = decisionCorrelation.consumeForDecision(requestId);
+    if (!consumed) return null;
+    const { parentEventId, originalKind } = consumed;
+    function makeDecisionEvent(kind, data) {
+      const s = runLifecycle.allocateSeq();
+      const runId = runLifecycle.getRunId();
+      const session = runLifecycle.getSession();
+      const fe = {
+        event_id: `${runId}:E${s}`,
+        seq: s,
+        ts: Date.now(),
+        session_id: session?.session_id ?? "unknown",
+        run_id: runId,
+        kind,
+        level: "info",
+        actor_id: decision.source === "user" ? "user" : "system",
+        cause: {
+          parent_event_id: parentEventId,
+          hook_request_id: requestId
+        },
+        title: "",
+        data
+      };
+      fe.title = generateTitle(fe);
+      return fe;
+    }
+    if (originalKind === "permission.request") {
+      let data;
+      if (decision.source === "timeout") {
+        data = { decision_type: "no_opinion", reason: "timeout" };
+      } else if (decision.type === "passthrough") {
+        data = { decision_type: "no_opinion", reason: decision.source };
+      } else if (decision.intent?.kind === "permission_allow") {
+        data = { decision_type: "allow" };
+      } else if (decision.intent?.kind === "permission_deny") {
+        data = {
+          decision_type: "deny",
+          message: decision.intent.reason
+        };
+      } else {
+        data = { decision_type: "no_opinion", reason: "unknown" };
+      }
+      return makeDecisionEvent("permission.decision", data);
+    }
+    if (originalKind === "stop.request") {
+      let data;
+      const d = decision.data;
+      const decisionReason = typeof d?.reason === "string" ? d.reason : void 0;
+      if (decision.source === "timeout") {
+        data = { decision_type: "no_opinion", reason: "timeout" };
+      } else if (decision.type === "passthrough") {
+        data = { decision_type: "no_opinion", reason: decision.source };
+      } else if (d?.decision === "block") {
+        data = {
+          decision_type: "block",
+          reason: decisionReason ?? decision.reason ?? "Blocked"
+        };
+      } else if (d?.ok === false) {
+        data = {
+          decision_type: "block",
+          reason: decisionReason ?? "Blocked by hook"
+        };
+      } else {
+        data = { decision_type: "allow" };
+      }
+      return makeDecisionEvent("stop.decision", data);
+    }
+    return null;
+  }
+  return {
+    mapEvent,
+    mapDecision,
+    getSession: () => runLifecycle.getSession(),
+    getCurrentRun: () => runLifecycle.getCurrentRun(),
+    getActors: () => actors.all(),
+    getTasks: () => rootPlan.current(),
+    allocateSeq: () => runLifecycle.allocateSeq()
+  };
+}
+
+// src/core/controller/rules.ts
+function ruleMatches(ruleToolName, toolName) {
+  if (ruleToolName === "*") return true;
+  if (ruleToolName === toolName) return true;
+  if (ruleToolName.endsWith("__*")) {
+    const prefix = ruleToolName.slice(0, -1);
+    return toolName.startsWith(prefix);
+  }
+  return false;
+}
+function matchRule(rules, toolName) {
+  const denyMatch = rules.find(
+    (r) => r.action === "deny" && ruleMatches(r.toolName, toolName)
+  );
+  if (denyMatch) return denyMatch;
+  return rules.find(
+    (r) => r.action === "approve" && ruleMatches(r.toolName, toolName)
+  );
+}
+
+// src/core/controller/permission.ts
+var SESSION_APPROVAL_REQUEST_HOOKS = /* @__PURE__ */ new Set([
+  "item/commandExecution/requestApproval",
+  "item/fileChange/requestApproval",
+  "item/permissions/requestApproval"
+]);
+function isScopedPermissionsRequest(hookName) {
+  return hookName === "item/permissions/requestApproval";
+}
+function supportsSessionApproval(hookName) {
+  return hookName !== void 0 && SESSION_APPROVAL_REQUEST_HOOKS.has(hookName);
+}
+function extractPermissionSnapshot(event) {
+  const data = event.data;
+  const toolNameFromData = typeof data["tool_name"] === "string" ? data["tool_name"] : void 0;
+  const toolInputFromData = typeof data["tool_input"] === "object" && data["tool_input"] !== null ? data["tool_input"] : void 0;
+  const toolUseIdFromData = typeof data["tool_use_id"] === "string" ? data["tool_use_id"] : void 0;
+  return {
+    request_id: event.id,
+    ts: event.timestamp,
+    kind: event.kind,
+    hookName: event.hookName,
+    tool_name: event.toolName ?? toolNameFromData ?? "Unknown",
+    tool_input: toolInputFromData ?? {},
+    tool_use_id: event.toolUseId ?? toolUseIdFromData,
+    suggestions: data.permission_suggestions
+  };
+}
+
+// src/core/controller/runtimeController.ts
+function handleEvent(event, cb) {
+  const eventKind2 = event.kind;
+  const isScoped = isScopedPermissionsRequest(event.hookName);
+  const eventData = event.data;
+  const toolName = event.toolName ?? (typeof eventData["tool_name"] === "string" ? eventData["tool_name"] : void 0);
+  if (eventKind2 === "permission.request" && toolName === "user_input") {
+    cb.enqueueQuestion(event.id);
+    cb.relayQuestion?.(event);
+    return { handled: true };
+  }
+  if (eventKind2 === "permission.request" && toolName) {
+    const rule = matchRule(cb.getRules(), toolName);
+    if (rule?.action === "deny") {
+      return {
+        handled: true,
+        decision: {
+          type: "json",
+          source: "rule",
+          intent: {
+            kind: "permission_deny",
+            reason: `Blocked by rule: ${rule.addedBy}`
+          }
+        }
+      };
+    }
+    if (rule?.action === "approve") {
+      return {
+        handled: true,
+        decision: {
+          type: "json",
+          source: "rule",
+          intent: { kind: "permission_allow" },
+          // Scoped Codex permission grants are session-scoped under
+          // auto rules so the same capability isn't re-prompted.
+          ...isScoped ? { data: { scope: "session" } } : {}
+        }
+      };
+    }
+    cb.enqueuePermission(event);
+    cb.relayPermission?.(event);
+    return { handled: true };
   }
-  function mapDecision(requestId, decision) {
-    const parentEventId = eventIdByRequestId.get(requestId);
-    if (!parentEventId) return null;
-    const originalKind = eventKindByRequestId.get(requestId);
-    eventIdByRequestId.delete(requestId);
-    eventKindByRequestId.delete(requestId);
-    function makeDecisionEvent(kind, data) {
-      const s = nextSeq();
-      const fe = {
-        event_id: `${getRunId()}:E${s}`,
-        seq: s,
-        ts: Date.now(),
-        session_id: currentSession?.session_id ?? "unknown",
-        run_id: getRunId(),
-        kind,
-        level: "info",
-        actor_id: decision.source === "user" ? "user" : "system",
-        cause: {
-          parent_event_id: parentEventId,
-          hook_request_id: requestId
-        },
-        title: "",
-        data
+  if (eventKind2 === "tool.pre" && toolName === "AskUserQuestion") {
+    cb.enqueueQuestion(event.id);
+    cb.relayQuestion?.(event);
+    return { handled: true };
+  }
+  if (eventKind2 === "tool.pre" && toolName) {
+    const rule = matchRule(cb.getRules(), toolName);
+    if (rule?.action === "deny") {
+      return {
+        handled: true,
+        decision: {
+          type: "json",
+          source: "rule",
+          intent: {
+            kind: "pre_tool_deny",
+            reason: `Blocked by rule: ${rule.addedBy}`
+          }
+        }
       };
-      fe.title = generateTitle(fe);
-      return fe;
-    }
-    if (originalKind === "permission.request") {
-      let data;
-      if (decision.source === "timeout") {
-        data = { decision_type: "no_opinion", reason: "timeout" };
-      } else if (decision.type === "passthrough") {
-        data = { decision_type: "no_opinion", reason: decision.source };
-      } else if (decision.intent?.kind === "permission_allow") {
-        data = { decision_type: "allow" };
-      } else if (decision.intent?.kind === "permission_deny") {
-        data = {
-          decision_type: "deny",
-          message: decision.intent.reason
-        };
-      } else {
-        data = { decision_type: "no_opinion", reason: "unknown" };
-      }
-      return makeDecisionEvent("permission.decision", data);
     }
-    if (originalKind === "stop.request") {
-      let data;
-      const d = decision.data;
-      const decisionReason = typeof d?.reason === "string" ? d.reason : void 0;
-      if (decision.source === "timeout") {
-        data = { decision_type: "no_opinion", reason: "timeout" };
-      } else if (decision.type === "passthrough") {
-        data = { decision_type: "no_opinion", reason: decision.source };
-      } else if (d?.decision === "block") {
-        data = {
-          decision_type: "block",
-          reason: decisionReason ?? decision.reason ?? "Blocked"
-        };
-      } else if (d?.ok === false) {
-        data = {
-          decision_type: "block",
-          reason: decisionReason ?? "Blocked by hook"
-        };
-      } else {
-        data = { decision_type: "allow" };
+    return {
+      handled: true,
+      decision: {
+        type: "json",
+        source: "rule",
+        intent: { kind: "pre_tool_allow" }
       }
-      return makeDecisionEvent("stop.decision", data);
-    }
-    return null;
+    };
+  }
+  return { handled: false };
+}
+
+// src/core/feed/ingest.ts
+function ingestRuntimeEvent(event, ctx) {
+  const controllerResult = handleEvent(event, ctx.controllerCallbacks);
+  const feedEvents = ctx.mapper.mapEvent(event);
+  if (ctx.store) {
+    persistOrDegrade(
+      ctx.store,
+      () => ctx.store.recordEvent(event, feedEvents),
+      "recordEvent failed",
+      ctx.onPersistFailure
+    );
   }
   return {
-    mapEvent,
-    mapDecision,
-    getSession: () => currentSession,
-    getCurrentRun: () => currentRun,
-    getActors: () => actors.all(),
-    getTasks: () => lastRootTasks,
-    allocateSeq: nextSeq
+    feedEvents,
+    decision: controllerResult.handled && controllerResult.decision ? controllerResult.decision : null
   };
 }
+function ingestRuntimeDecision(eventId, decision, ctx) {
+  const feedEvent = ctx.mapper.mapDecision(eventId, decision);
+  if (feedEvent && ctx.store) {
+    persistOrDegrade(
+      ctx.store,
+      () => ctx.store.recordFeedEvents([feedEvent]),
+      "recordFeedEvents failed",
+      ctx.onPersistFailure
+    );
+  }
+  return feedEvent;
+}
+function persistOrDegrade(store, action, label, onFailure) {
+  try {
+    action();
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    const message = `${label}: ${reason}`;
+    store.markDegraded(message);
+    onFailure?.(message);
+  }
+}
 
 // src/infra/sessions/store.ts
 import fs16 from "fs";
@@ -9523,6 +9714,20 @@ function initSchema(db) {
   }
 }
 
+// src/infra/sessions/types.ts
+function rowToAthenaSession(row, adapterSessionIds, firstPrompt) {
+  return {
+    id: row.id,
+    projectDir: row.project_dir,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    label: row.label ?? void 0,
+    eventCount: row.event_count ?? 0,
+    firstPrompt,
+    adapterSessionIds
+  };
+}
+
 // src/infra/sessions/store.ts
 function createSessionStore(opts) {
   if (opts.dbPath !== ":memory:") {
@@ -9639,15 +9844,7 @@ function createSessionStore(opts) {
     const adapterRows = db.prepare("SELECT * FROM adapter_sessions ORDER BY started_at").all();
     const feedRows = db.prepare("SELECT data FROM feed_events ORDER BY seq").all();
     const adapterSessionIds = adapterRows.map((r) => r.session_id);
-    const session = sessionRow ? {
-      id: sessionRow.id,
-      projectDir: sessionRow.project_dir,
-      createdAt: sessionRow.created_at,
-      updatedAt: sessionRow.updated_at,
-      label: sessionRow.label ?? void 0,
-      eventCount: sessionRow.event_count ?? 0,
-      adapterSessionIds
-    } : {
+    const session = sessionRow ? rowToAthenaSession(sessionRow, adapterSessionIds) : {
       id: opts.sessionId,
       projectDir: opts.projectDir,
       createdAt: now,
@@ -9677,24 +9874,17 @@ function createSessionStore(opts) {
   function getAthenaSession() {
     const sessionRow = db.prepare("SELECT * FROM session WHERE id = ?").get(opts.sessionId);
     const adapterRows = db.prepare("SELECT session_id FROM adapter_sessions ORDER BY started_at").all();
+    const adapterSessionIds = adapterRows.map((r) => r.session_id);
     if (!sessionRow) {
       return {
         id: opts.sessionId,
         projectDir: opts.projectDir,
         createdAt: now,
         updatedAt: now,
-        adapterSessionIds: adapterRows.map((r) => r.session_id)
+        adapterSessionIds
       };
     }
-    return {
-      id: sessionRow.id,
-      projectDir: sessionRow.project_dir,
-      createdAt: sessionRow.created_at,
-      updatedAt: sessionRow.updated_at,
-      label: sessionRow.label ?? void 0,
-      eventCount: sessionRow.event_count ?? 0,
-      adapterSessionIds: adapterRows.map((r) => r.session_id)
-    };
+    return rowToAthenaSession(sessionRow, adapterSessionIds);
   }
   const updateTokens = db.prepare(
     `UPDATE adapter_sessions SET
@@ -9847,16 +10037,11 @@ function readSessionFromDb(dbPath) {
         firstPrompt = promptRow.prompt;
       }
     }
-    return {
-      id: row.id,
-      projectDir: row.project_dir,
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-      label: row.label ?? void 0,
-      eventCount: row.event_count ?? 0,
-      firstPrompt,
-      adapterSessionIds: adapters.map((a) => a.session_id)
-    };
+    return rowToAthenaSession(
+      row,
+      adapters.map((a) => a.session_id),
+      firstPrompt
+    );
   } catch {
     return null;
   } finally {
@@ -10844,6 +11029,33 @@ function resolveFinalMessage(input) {
   return { message: "", source: "empty" };
 }
 
+// src/app/exec/failureLatch.ts
+function createFailureLatch(onRegister) {
+  let failure;
+  return {
+    register(next) {
+      if (failure) return;
+      failure = next;
+      onRegister(failure);
+    },
+    current() {
+      return failure;
+    },
+    hasFailure() {
+      return failure !== void 0;
+    }
+  };
+}
+function exitCodeFromFailure(failure) {
+  if (!failure) return EXEC_EXIT_CODE.SUCCESS;
+  if (failure.kind === "timeout") return EXEC_EXIT_CODE.TIMEOUT;
+  if (failure.kind === "output") return EXEC_EXIT_CODE.OUTPUT;
+  if (failure.kind === "workflow") {
+    return failure.state === "exhausted" ? EXEC_EXIT_CODE.WORKFLOW_EXHAUSTED : EXEC_EXIT_CODE.WORKFLOW_BLOCKED;
+  }
+  return EXEC_EXIT_CODE.RUNTIME;
+}
+
 // src/app/exec/output.ts
 import fs19 from "fs/promises";
 import path16 from "path";
@@ -10951,7 +11163,6 @@ async function runExec(options) {
     now
   });
   const rules = [];
-  let failure;
   let runtimeStarted = false;
   let cumulativeTokens = { ...NULL_TOKENS3 };
   let streamFinalMessage = null;
@@ -11016,28 +11227,22 @@ async function runExec(options) {
     runtime,
     spawnProcess: options.spawnProcess
   });
-  function registerFailure(next) {
-    if (failure) return;
-    failure = next;
+  const latch = createFailureLatch((next) => {
     output.error(next.message);
     output.emitJsonEvent("exec.error", {
       kind: next.kind,
       message: next.message
     });
     void sessionController.kill();
-  }
+  });
   const abortListener = () => {
-    registerFailure({
-      kind: "process",
-      message: "Execution cancelled."
-    });
+    latch.register({ kind: "process", message: "Execution cancelled." });
   };
   if (options.signal?.aborted) {
     abortListener();
   } else {
     options.signal?.addEventListener("abort", abortListener, { once: true });
   }
-  const hasFailure = () => failure !== void 0;
   const currentAdapterSessionId = () => adapterSessionId;
   const bridgeFactory = options.bridgeFactory ?? startSessionBridge;
   const bridge = options.channels && options.channels.length > 0 ? await bridgeFactory({
@@ -11079,23 +11284,21 @@ async function runExec(options) {
       toolName: runtimeEvent.toolName ?? null,
       data: runtimeEvent.data
     });
-    if (hasFailure()) return;
-    const controllerResult = handleEvent(runtimeEvent, controllerCallbacks);
-    if (controllerResult.handled && controllerResult.decision) {
-      runtime.sendDecision(runtimeEvent.id, controllerResult.decision);
+    if (latch.hasFailure()) return;
+    const { feedEvents, decision } = ingestRuntimeEvent(runtimeEvent, {
+      mapper,
+      store,
+      controllerCallbacks,
+      onPersistFailure: (message) => output.warn(message)
+    });
+    if (decision) {
+      runtime.sendDecision(runtimeEvent.id, decision);
     }
-    const mapped = mapper.mapEvent(runtimeEvent);
-    for (const event of mapped) {
+    for (const event of feedEvents) {
       if (event.kind === "agent.message") {
         mappedFinalMessage = event.data.message;
       }
     }
-    safePersist(
-      store,
-      () => store.recordEvent(runtimeEvent, mapped),
-      (message) => output.warn(message),
-      "recordEvent failed"
-    );
   });
   const unsubscribeDecision = runtime.onDecision(
     (eventId, decision) => {
@@ -11103,20 +11306,17 @@ async function runExec(options) {
         eventId,
         decision
       });
-      const mapped = mapper.mapDecision(eventId, decision);
-      if (!mapped) return;
-      safePersist(
+      ingestRuntimeDecision(eventId, decision, {
+        mapper,
         store,
-        () => store.recordFeedEvents([mapped]),
-        (message) => output.warn(message),
-        "recordFeedEvents failed"
-      );
+        onPersistFailure: (message) => output.warn(message)
+      });
     }
   );
   let timeoutTimer;
   if (typeof options.timeoutMs === "number" && options.timeoutMs > 0) {
     timeoutTimer = setTimeout(() => {
-      registerFailure({
+      latch.register({
         kind: "timeout",
         message: `Execution timed out after ${options.timeoutMs}ms.`
       });
@@ -11186,30 +11386,30 @@ async function runExec(options) {
     activeRunId = handle.runId;
     const runResult = await handle.result;
     cumulativeTokens = runResult.tokens;
-    if (!failure) {
+    if (!latch.hasFailure()) {
       if (runResult.status === "blocked") {
-        registerFailure(
+        latch.register(
           workflowFailure(
             "blocked",
             runResult.stopReason ? `Workflow blocked: ${runResult.stopReason}` : "Workflow blocked."
           )
         );
       } else if (runResult.status === "exhausted") {
-        registerFailure(
+        latch.register(
           workflowFailure(
             "exhausted",
             `Workflow reached the maximum of ${workflow?.loop?.maxIterations ?? 0} iterations.`
           )
         );
       } else if (runResult.status === "failed") {
-        registerFailure({
+        latch.register({
           kind: "process",
           message: runResult.stopReason ?? "Workflow run failed."
         });
       }
     }
   } catch (error) {
-    registerFailure({
+    latch.register({
       kind: "process",
       message: error instanceof Error ? error.message : String(error)
     });
@@ -11231,39 +11431,26 @@ async function runExec(options) {
     streamMessage: streamFinalMessage,
     mappedMessage: mappedFinalMessage
   });
-  if (resolvedFinalMessage.source === "empty" && !failure) {
+  if (resolvedFinalMessage.source === "empty" && !latch.hasFailure()) {
     const warning = "No assistant message found in stream or hook events; writing empty output.";
     output.warn(warning);
     output.emitJsonEvent("exec.warning", { message: warning });
   }
-  if (!failure && options.outputLastMessagePath) {
+  if (!latch.hasFailure() && options.outputLastMessagePath) {
     try {
       await output.writeLastMessage(
         options.outputLastMessagePath,
         resolvedFinalMessage.message
       );
     } catch (error) {
-      failure = {
+      latch.register({
         kind: "output",
         message: `Failed writing --output-last-message: ${error instanceof Error ? error.message : String(error)}`
-      };
-      output.error(failure.message);
-      output.emitJsonEvent("exec.error", {
-        kind: failure.kind,
-        message: failure.message
       });
     }
   }
-  let exitCode = EXEC_EXIT_CODE.SUCCESS;
-  if (failure?.kind === "timeout") {
-    exitCode = EXEC_EXIT_CODE.TIMEOUT;
-  } else if (failure?.kind === "output") {
-    exitCode = EXEC_EXIT_CODE.OUTPUT;
-  } else if (failure?.kind === "workflow") {
-    exitCode = failure.state === "exhausted" ? EXEC_EXIT_CODE.WORKFLOW_EXHAUSTED : EXEC_EXIT_CODE.WORKFLOW_BLOCKED;
-  } else if (failure) {
-    exitCode = EXEC_EXIT_CODE.RUNTIME;
-  }
+  const failure = latch.current();
+  const exitCode = exitCodeFromFailure(failure);
   const success = exitCode === EXEC_EXIT_CODE.SUCCESS;
   const finalMessage = success ? resolvedFinalMessage.message : null;
   if (success && finalMessage !== null) {
@@ -11421,54 +11608,335 @@ function createInstanceSocketClient(opts) {
         next.terminate();
       } catch {
       }
-      throw err;
+      throw err;
+    }
+    ws = next;
+    startHeartbeat();
+    next.on("message", (data) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(String(data));
+      } catch (err) {
+        log(
+          "warn",
+          `instance socket frame parse failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+        return;
+      }
+      handleFrame(parsed);
+    });
+    next.on("close", (_code, reasonBuf) => {
+      if (next !== ws) return;
+      ws = null;
+      const reason = reasonBuf.toString() || "closed";
+      emitClose(reason);
+    });
+    next.on("error", (err) => {
+      log("warn", `instance socket error: ${err.message}`);
+    });
+  }
+  function close(reason) {
+    stopHeartbeat();
+    if (ws) {
+      try {
+        ws.close(1e3, reason ?? "client closed");
+      } catch {
+        ws.terminate();
+      }
+    }
+    ws = null;
+  }
+  function onFrame(handler) {
+    frameHandlers.add(handler);
+  }
+  function onClose(handler) {
+    closeHandlers.add(handler);
+  }
+  function sendRunEvent(event) {
+    send({ type: "run_event", ...event });
+  }
+  return { connect: connect2, close, onFrame, onClose, sendRunEvent };
+}
+
+// src/app/dashboard/runStreamClient.ts
+import { WebSocket as WebSocket3 } from "ws";
+var DEFAULT_RECONNECT_DELAYS_MS = [250, 1e3, 2e3, 5e3, 15e3];
+var DEFAULT_HEARTBEAT_MS2 = 3e4;
+var DEFAULT_WATCHDOG_MS = 9e4;
+var DEFAULT_MAX_QUEUE_SIZE = 5e3;
+function createRunStreamClient(opts) {
+  const log = opts.log ?? (() => {
+  });
+  const now = opts.now ?? (() => Date.now());
+  const reconnectDelays = opts.reconnectDelaysMs ?? DEFAULT_RECONNECT_DELAYS_MS;
+  const heartbeatMs = opts.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS2;
+  const watchdogMs = opts.watchdogTimeoutMs ?? DEFAULT_WATCHDOG_MS;
+  const maxQueueSize = opts.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+  const makeWebSocket = opts.makeWebSocket ?? ((url) => new WebSocket3(url));
+  const setTimer = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearTimer = opts.clearTimer ?? ((t) => clearTimeout(t));
+  let nextSeq = 1;
+  const queue = [];
+  let ws = null;
+  let connectAttempt = 0;
+  let stopped = false;
+  let serverTerminated = false;
+  let heartbeatTimer = null;
+  let watchdogTimer = null;
+  let reconnectTimer = null;
+  let resumeResolved = false;
+  let firstConnect = null;
+  const terminationWaiters = [];
+  function trimQueueUpTo(lastAckedSeq) {
+    while (queue.length > 0 && queue[0].seq <= lastAckedSeq) {
+      queue.shift();
+    }
+  }
+  function trimQueueUpToExclusive(expectedSeq) {
+    while (queue.length > 0 && queue[0].seq < expectedSeq) {
+      queue.shift();
+    }
+  }
+  function clearTimers() {
+    if (heartbeatTimer) {
+      clearTimer(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    if (watchdogTimer) {
+      clearTimer(watchdogTimer);
+      watchdogTimer = null;
+    }
+    if (reconnectTimer) {
+      clearTimer(reconnectTimer);
+      reconnectTimer = null;
+    }
+  }
+  function startHeartbeat() {
+    if (heartbeatMs <= 0) return;
+    const tick = () => {
+      if (!ws || ws.readyState !== ws.OPEN) return;
+      try {
+        ws.send(JSON.stringify({ type: "ping", ts: now() }));
+      } catch (err) {
+        log(
+          "warn",
+          `run-stream ping failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      heartbeatTimer = setTimer(tick, heartbeatMs);
+      heartbeatTimer.unref?.();
+    };
+    heartbeatTimer = setTimer(tick, heartbeatMs);
+    heartbeatTimer.unref?.();
+  }
+  function bumpWatchdog() {
+    if (watchdogMs <= 0) return;
+    if (watchdogTimer) clearTimer(watchdogTimer);
+    watchdogTimer = setTimer(() => {
+      log(
+        "warn",
+        `run-stream watchdog: no server frames for ${watchdogMs}ms \u2014 recycling socket`
+      );
+      try {
+        ws?.terminate();
+      } catch {
+      }
+    }, watchdogMs);
+    watchdogTimer.unref?.();
+  }
+  function flushQueue() {
+    if (!ws || ws.readyState !== ws.OPEN || !resumeResolved) return;
+    for (const frame of queue) {
+      try {
+        ws.send(JSON.stringify(frame));
+      } catch (err) {
+        log(
+          "warn",
+          `run-stream flush stopped: ${err instanceof Error ? err.message : String(err)}`
+        );
+        return;
+      }
+    }
+  }
+  function notifyTerminated() {
+    serverTerminated = true;
+    const waiters = terminationWaiters.splice(0, terminationWaiters.length);
+    for (const w of waiters) {
+      try {
+        w();
+      } catch {
+      }
+    }
+  }
+  function handleServerFrame(parsed) {
+    bumpWatchdog();
+    switch (parsed.type) {
+      case "resume": {
+        resumeResolved = true;
+        trimQueueUpTo(parsed.lastAckedSeq);
+        if (firstConnect) {
+          const f = firstConnect;
+          firstConnect = null;
+          f.resolve();
+        }
+        if (parsed.terminated) {
+          notifyTerminated();
+          try {
+            ws?.close(1e3, "already_terminated");
+          } catch {
+          }
+          return;
+        }
+        flushQueue();
+        return;
+      }
+      case "ack": {
+        trimQueueUpTo(parsed.seq);
+        return;
+      }
+      case "pong":
+        return;
+      case "error": {
+        if (parsed.code === "sequence_gap" && typeof parsed.expected === "number") {
+          trimQueueUpToExclusive(parsed.expected);
+          flushQueue();
+          log(
+            "warn",
+            `run-stream sequence_gap: server expected seq=${parsed.expected}; replayed ${queue.length} frames`
+          );
+          return;
+        }
+        log(
+          "warn",
+          `run-stream server error: ${parsed.code}${parsed.message ? ` ${parsed.message}` : ""}`
+        );
+        return;
+      }
     }
+  }
+  function nextReconnectDelay() {
+    if (reconnectDelays.length === 0) return 0;
+    const idx = Math.min(connectAttempt, reconnectDelays.length - 1);
+    const ms = reconnectDelays[idx] ?? 0;
+    connectAttempt += 1;
+    return ms;
+  }
+  function scheduleReconnect() {
+    if (stopped || serverTerminated) return;
+    const delayMs = nextReconnectDelay();
+    log("info", `run-stream reconnect scheduled in ${delayMs}ms`);
+    reconnectTimer = setTimer(() => {
+      reconnectTimer = null;
+      void openSocket();
+    }, delayMs);
+    reconnectTimer.unref?.();
+  }
+  async function openSocket() {
+    if (stopped || serverTerminated) return;
+    resumeResolved = false;
+    const next = makeWebSocket(opts.wsUrl);
     ws = next;
-    startHeartbeat();
+    next.on("open", () => {
+      connectAttempt = 0;
+      startHeartbeat();
+      bumpWatchdog();
+    });
     next.on("message", (data) => {
       let parsed;
       try {
         parsed = JSON.parse(String(data));
-      } catch (err) {
-        log(
-          "warn",
-          `instance socket frame parse failed: ${err instanceof Error ? err.message : String(err)}`
-        );
+      } catch {
+        log("warn", "run-stream received non-JSON frame");
         return;
       }
-      handleFrame(parsed);
+      handleServerFrame(parsed);
     });
-    next.on("close", (_code, reasonBuf) => {
+    next.on("close", (code, reasonBuf) => {
       if (next !== ws) return;
       ws = null;
-      const reason = reasonBuf.toString() || "closed";
-      emitClose(reason);
+      clearTimers();
+      const reason = reasonBuf?.toString?.() || "closed";
+      if (code === 1e3 && reason === "run_terminated") {
+        notifyTerminated();
+        return;
+      }
+      if (firstConnect) {
+        const f = firstConnect;
+        firstConnect = null;
+        f.reject(
+          new Error(`run-stream initial connect failed: ${reason} (${code})`)
+        );
+        return;
+      }
+      scheduleReconnect();
     });
     next.on("error", (err) => {
-      log("warn", `instance socket error: ${err.message}`);
+      log(
+        "warn",
+        `run-stream socket error: ${err instanceof Error ? err.message : String(err)}`
+      );
     });
   }
-  function close(reason) {
-    stopHeartbeat();
-    if (ws) {
-      try {
-        ws.close(1e3, reason ?? "client closed");
-      } catch {
-        ws.terminate();
+  return {
+    async connect() {
+      if (firstConnect) {
+        throw new Error("run-stream client already connecting");
+      }
+      await new Promise((resolve, reject) => {
+        firstConnect = { resolve, reject };
+        void openSocket();
+      });
+    },
+    sendEvent(input) {
+      const frame = {
+        seq: nextSeq++,
+        ts: input.ts,
+        kind: input.kind,
+        payload: input.payload ?? null
+      };
+      if (queue.length >= maxQueueSize) {
+        log(
+          "warn",
+          `run-stream queue at cap (${maxQueueSize}); dropping oldest unacked frame seq=${queue[0].seq}`
+        );
+        queue.shift();
+      }
+      queue.push(frame);
+      if (ws && ws.readyState === ws.OPEN && resumeResolved) {
+        try {
+          ws.send(JSON.stringify(frame));
+        } catch (err) {
+          log(
+            "warn",
+            `run-stream send failed (will replay): ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    },
+    whenTerminated() {
+      if (serverTerminated) return Promise.resolve();
+      return new Promise((resolve) => {
+        terminationWaiters.push(resolve);
+      });
+    },
+    async close(reason = "client_close") {
+      stopped = true;
+      clearTimers();
+      const current = ws;
+      ws = null;
+      if (current) {
+        try {
+          current.close(1e3, reason);
+        } catch {
+          try {
+            current.terminate();
+          } catch {
+          }
+        }
       }
+      notifyTerminated();
     }
-    ws = null;
-  }
-  function onFrame(handler) {
-    frameHandlers.add(handler);
-  }
-  function onClose(handler) {
-    closeHandlers.add(handler);
-  }
-  function sendRunEvent(event) {
-    send({ type: "run_event", ...event });
-  }
-  return { connect: connect2, close, onFrame, onClose, sendRunEvent };
+  };
 }
 
 // src/app/dashboard/remoteRunExecutor.ts
@@ -11479,6 +11947,8 @@ function parseRunSpec(value) {
   if (typeof prompt !== "string" || prompt.trim().length === 0) return null;
   const env = obj["env"];
   const workflow = obj["workflow"];
+  const callbackWsUrl = obj["callbackWsUrl"];
+  const callbackToken = obj["callbackToken"];
   return {
     prompt,
     sessionId: typeof obj["sessionId"] === "string" && obj["sessionId"].length > 0 ? obj["sessionId"] : void 0,
@@ -11489,7 +11959,9 @@ function parseRunSpec(value) {
         (entry) => typeof entry[1] === "string"
       )
     ) : void 0,
-    timeoutSec: typeof obj["timeoutSec"] === "number" && Number.isFinite(obj["timeoutSec"]) ? obj["timeoutSec"] : void 0
+    timeoutSec: typeof obj["timeoutSec"] === "number" && Number.isFinite(obj["timeoutSec"]) ? obj["timeoutSec"] : void 0,
+    callbackWsUrl: typeof callbackWsUrl === "string" && callbackWsUrl.length > 0 ? callbackWsUrl : void 0,
+    callbackToken: typeof callbackToken === "string" && callbackToken.length > 0 ? callbackToken : void 0
   };
 }
 function workflowNameFromRef(ref) {
@@ -11542,112 +12014,165 @@ async function executeRemoteAssignment({
   runExecFn = runExec,
   bootstrapRuntimeConfigFn = bootstrapRuntimeConfig,
   now = Date.now,
-  abortSignal
+  abortSignal,
+  createRunStreamClientFn = createRunStreamClient,
+  runStreamConnectTimeoutMs = 5e3
 }) {
-  let seq = 0;
   let lastTerminalFailureMessage = null;
   let deferredFailedCompletion = null;
+  const spec = parseRunSpec(frame.runSpec);
+  let runStream = null;
+  if (spec?.callbackWsUrl && spec.callbackToken) {
+    const connect2 = createRunStreamClientFn({
+      wsUrl: spec.callbackWsUrl,
+      token: spec.callbackToken,
+      log: (level, message) => log(level, `run-stream[${frame.runId}]: ${message}`),
+      now
+    });
+    const timeoutPromise = new Promise((resolve) => {
+      const t = setTimeout(() => resolve("timeout"), runStreamConnectTimeoutMs);
+      t.unref?.();
+    });
+    try {
+      const result = await Promise.race([
+        connect2.connect().then(() => "connected"),
+        timeoutPromise
+      ]);
+      if (result === "connected") {
+        runStream = connect2;
+      } else {
+        log(
+          "warn",
+          `run-stream[${frame.runId}]: connect timed out after ${runStreamConnectTimeoutMs}ms; falling back to instance-socket relay`
+        );
+        void connect2.close("connect_timeout");
+      }
+    } catch (err) {
+      log(
+        "warn",
+        `run-stream[${frame.runId}]: connect failed (${err instanceof Error ? err.message : String(err)}); falling back to instance-socket relay`
+      );
+    }
+  }
+  let legacySeq = 0;
   const send = (kind, payload, ts = now()) => {
-    seq += 1;
     if (kind === "error" && typeof payload === "object" && payload !== null && typeof payload.message === "string") {
       lastTerminalFailureMessage = payload.message;
     }
+    if (runStream) {
+      runStream.sendEvent({ ts, kind, payload });
+      return;
+    }
+    legacySeq += 1;
     client.sendRunEvent({
       runId: frame.runId,
-      seq,
+      seq: legacySeq,
       ts,
       kind,
       payload
     });
   };
   send("progress", { message: "assignment received" });
-  const spec = parseRunSpec(frame.runSpec);
-  if (!spec) {
-    send("error", {
-      message: "remote assignment missing prompt"
-    });
-    return;
-  }
-  const projectDir = spec.projectDir ?? fallbackProjectDir;
-  let runtimeConfig;
   try {
-    runtimeConfig = bootstrapRuntimeConfigFn({
-      projectDir,
-      showSetup: false,
-      isolationPreset: "minimal",
-      workflowOverride: workflowNameFromRef(spec.workflow?.ref)
-    });
-  } catch (err) {
-    send("error", {
-      message: err instanceof Error ? err.message : String(err)
-    });
-    return;
-  }
-  for (const warning of runtimeConfig.warnings) {
-    send("warning", { message: warning });
-  }
-  let buffered = "";
-  const stdout = {
-    write(chunk) {
-      buffered += chunk;
-      let newline = buffered.indexOf("\n");
-      while (newline >= 0) {
-        const line = buffered.slice(0, newline).trim();
-        buffered = buffered.slice(newline + 1);
-        if (line.length > 0) {
-          try {
-            const event = JSON.parse(line);
-            const data = event.data;
-            if (event.type === "exec.completed" && data?.success === false) {
-              deferredFailedCompletion = event;
-              continue;
+    if (!spec) {
+      send("error", { message: "remote assignment missing prompt" });
+      return;
+    }
+    const projectDir = spec.projectDir ?? fallbackProjectDir;
+    let runtimeConfig;
+    try {
+      runtimeConfig = bootstrapRuntimeConfigFn({
+        projectDir,
+        showSetup: false,
+        isolationPreset: "minimal",
+        workflowOverride: workflowNameFromRef(spec.workflow?.ref)
+      });
+    } catch (err) {
+      send("error", {
+        message: err instanceof Error ? err.message : String(err)
+      });
+      return;
+    }
+    for (const warning of runtimeConfig.warnings) {
+      send("warning", { message: warning });
+    }
+    let buffered = "";
+    const stdout = {
+      write(chunk) {
+        buffered += chunk;
+        let newline = buffered.indexOf("\n");
+        while (newline >= 0) {
+          const line = buffered.slice(0, newline).trim();
+          buffered = buffered.slice(newline + 1);
+          if (line.length > 0) {
+            try {
+              const event = JSON.parse(line);
+              const data = event.data;
+              if (event.type === "exec.completed" && data?.success === false) {
+                deferredFailedCompletion = event;
+                continue;
+              }
+              send(eventKind(event), eventPayload(event), now());
+            } catch (err) {
+              send("progress", { line });
+              log(
+                "warn",
+                `remote run emitted malformed JSONL: ${err instanceof Error ? err.message : String(err)}`
+              );
             }
-            send(eventKind(event), eventPayload(event), now());
-          } catch (err) {
-            send("progress", { line });
-            log(
-              "warn",
-              `remote run emitted malformed JSONL: ${err instanceof Error ? err.message : String(err)}`
-            );
           }
+          newline = buffered.indexOf("\n");
         }
-        newline = buffered.indexOf("\n");
+        return true;
       }
-      return true;
-    }
-  };
-  const stderr = {
-    write(chunk) {
-      const text = chunk.trim();
-      if (text.length > 0) send("stderr", { text });
-      return true;
-    }
-  };
-  try {
-    await withEnv(spec.env, async () => {
-      const result = await runExecFn({
-        prompt: spec.prompt,
-        projectDir,
-        harness: runtimeConfig.harness,
-        athenaSessionId: spec.sessionId ?? `athena-${frame.runId}`,
-        isolationConfig: runtimeConfig.isolationConfig,
-        pluginMcpConfig: runtimeConfig.pluginMcpConfig,
-        workflow: runtimeConfig.workflow,
-        workflowPlan: runtimeConfig.workflowPlan,
-        json: true,
-        verbose: false,
-        ephemeral: false,
-        timeoutMs: spec.timeoutSec ? spec.timeoutSec * 1e3 : void 0,
-        signal: abortSignal,
-        stdout,
-        stderr
-      });
-      if (deferredFailedCompletion) {
-        const data = typeof deferredFailedCompletion.data === "object" && deferredFailedCompletion.data !== null ? deferredFailedCompletion.data : {};
-        send(
-          "error",
-          {
-            ...data,
+    };
+    const stderr = {
+      write(chunk) {
+        const text = chunk.trim();
+        if (text.length > 0) send("stderr", { text });
+        return true;
+      }
+    };
+    try {
+      await withEnv(spec.env, async () => {
+        const result = await runExecFn({
+          prompt: spec.prompt,
+          projectDir,
+          harness: runtimeConfig.harness,
+          athenaSessionId: spec.sessionId ?? `athena-${frame.runId}`,
+          isolationConfig: runtimeConfig.isolationConfig,
+          pluginMcpConfig: runtimeConfig.pluginMcpConfig,
+          workflow: runtimeConfig.workflow,
+          workflowPlan: runtimeConfig.workflowPlan,
+          json: true,
+          verbose: false,
+          ephemeral: false,
+          timeoutMs: spec.timeoutSec ? spec.timeoutSec * 1e3 : void 0,
+          signal: abortSignal,
+          stdout,
+          stderr
+        });
+        if (deferredFailedCompletion) {
+          const data = typeof deferredFailedCompletion.data === "object" && deferredFailedCompletion.data !== null ? deferredFailedCompletion.data : {};
+          send(
+            "error",
+            {
+              ...data,
+              success: result.success,
+              exitCode: result.exitCode,
+              athenaSessionId: result.athenaSessionId,
+              adapterSessionId: result.adapterSessionId,
+              finalMessage: result.finalMessage,
+              tokens: result.tokens,
+              durationMs: result.durationMs,
+              message: result.failure?.message ?? eventPayload(deferredFailedCompletion).message ?? "remote execution failed"
+            },
+            typeof deferredFailedCompletion.ts === "number" ? deferredFailedCompletion.ts : now()
+          );
+          return;
+        }
+        if (result.failure && result.failure.message !== lastTerminalFailureMessage) {
+          send("error", {
             success: result.success,
             exitCode: result.exitCode,
             athenaSessionId: result.athenaSessionId,
@@ -11655,34 +12180,142 @@ async function executeRemoteAssignment({
             finalMessage: result.finalMessage,
             tokens: result.tokens,
             durationMs: result.durationMs,
-            message: result.failure?.message ?? eventPayload(deferredFailedCompletion).message ?? "remote execution failed"
-          },
-          typeof deferredFailedCompletion.ts === "number" ? deferredFailedCompletion.ts : now()
-        );
-        return;
-      }
-      if (result.failure && result.failure.message !== lastTerminalFailureMessage) {
-        send("error", {
-          success: result.success,
-          exitCode: result.exitCode,
-          athenaSessionId: result.athenaSessionId,
-          adapterSessionId: result.adapterSessionId,
-          finalMessage: result.finalMessage,
-          tokens: result.tokens,
-          durationMs: result.durationMs,
-          message: result.failure.message
-        });
-      }
-    });
+            message: result.failure.message
+          });
+        }
+      });
+    } catch (err) {
+      send("error", {
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  } finally {
+    if (runStream) {
+      const drainTimeout = new Promise((resolve) => {
+        const t = setTimeout(() => resolve(), 1e4);
+        t.unref?.();
+      });
+      await Promise.race([runStream.whenTerminated(), drainTimeout]);
+      await runStream.close("done");
+    }
+  }
+}
+
+// src/infra/config/attachmentMirror.ts
+import crypto3 from "crypto";
+import fs20 from "fs";
+import os11 from "os";
+import path18 from "path";
+function attachmentMirrorPath(env = process.env) {
+  const home = env["HOME"] ?? os11.homedir();
+  return path18.join(home, ".config", "athena", "attachments.json");
+}
+function readAttachmentMirror(env = process.env) {
+  const file = attachmentMirrorPath(env);
+  let raw;
+  try {
+    raw = fs20.readFileSync(file, "utf-8");
   } catch (err) {
-    send("error", {
-      message: err instanceof Error ? err.message : String(err)
-    });
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `attachment mirror ${file} is invalid JSON: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    return parseAttachmentMirror(parsed);
+  } catch (err) {
+    throw new Error(
+      `attachment mirror ${file} is invalid: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function writeAttachmentMirror(mirror, env = process.env) {
+  const validated = parseAttachmentMirror(mirror);
+  const file = attachmentMirrorPath(env);
+  const dir = path18.dirname(file);
+  fs20.mkdirSync(dir, { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.${crypto3.randomBytes(4).toString("hex")}.tmp`;
+  const fd = fs20.openSync(tmp, "w", 384);
+  try {
+    fs20.writeSync(fd, JSON.stringify(validated, null, 2) + "\n");
+    fs20.fsyncSync(fd);
+  } finally {
+    fs20.closeSync(fd);
+  }
+  try {
+    fs20.renameSync(tmp, file);
+  } catch (err) {
+    try {
+      fs20.unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+  if (process.platform !== "win32") {
+    try {
+      fs20.chmodSync(dir, 448);
+      fs20.chmodSync(file, 384);
+    } catch {
+    }
+  }
+}
+function removeAttachmentMirror(env = process.env) {
+  const file = attachmentMirrorPath(env);
+  try {
+    fs20.unlinkSync(file);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+function parseAttachmentMirror(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("root must be an object");
+  }
+  const obj = raw;
+  if (typeof obj["instanceId"] !== "string" || obj["instanceId"].length === 0) {
+    throw new Error("instanceId must be a non-empty string");
+  }
+  if (typeof obj["fetchedAt"] !== "number") {
+    throw new Error("fetchedAt must be a number");
   }
+  if (!Array.isArray(obj["attachments"])) {
+    throw new Error("attachments must be an array");
+  }
+  const attachments = obj["attachments"].map((entry, idx) => {
+    if (typeof entry !== "object" || entry === null) {
+      throw new Error(`attachments[${idx}] must be an object`);
+    }
+    const e = entry;
+    if (typeof e["runnerId"] !== "string" || e["runnerId"].length === 0) {
+      throw new Error(
+        `attachments[${idx}].runnerId must be a non-empty string`
+      );
+    }
+    const out = { runnerId: e["runnerId"] };
+    if (typeof e["name"] === "string") out.name = e["name"];
+    if (typeof e["executionTarget"] === "string") {
+      out.executionTarget = e["executionTarget"];
+    }
+    if (typeof e["remoteInstanceId"] === "string") {
+      out.remoteInstanceId = e["remoteInstanceId"];
+    }
+    return out;
+  });
+  return {
+    instanceId: obj["instanceId"],
+    fetchedAt: obj["fetchedAt"],
+    attachments
+  };
 }
 
 // src/app/dashboard/runtimeDaemon.ts
-var DEFAULT_RECONNECT_DELAYS_MS = [1e3, 2e3, 5e3, 1e4, 3e4];
+var DEFAULT_RECONNECT_DELAYS_MS2 = [1e3, 2e3, 5e3, 1e4, 3e4];
 var DEFAULT_MAX_CONCURRENT_RUNS = 1;
 var DEFAULT_REFRESH_LEAD_SEC = 60;
 var DEFAULT_REFRESH_FAILURE_LIMIT = 5;
@@ -11708,7 +12341,7 @@ async function runDashboardRuntimeDaemon(options = {}) {
   const projectDir = options.projectDir ?? process.cwd();
   const log = options.log ?? (() => {
   });
-  const reconnectDelays = options.reconnectDelaysMs ?? DEFAULT_RECONNECT_DELAYS_MS;
+  const reconnectDelays = options.reconnectDelaysMs ?? DEFAULT_RECONNECT_DELAYS_MS2;
   const maxConcurrentRuns = options.maxConcurrentRuns ?? DEFAULT_MAX_CONCURRENT_RUNS;
   const refreshLeadSec = options.refreshLeadSec ?? DEFAULT_REFRESH_LEAD_SEC;
   const refreshFailureLimit = options.refreshFailureLimit ?? DEFAULT_REFRESH_FAILURE_LIMIT;
@@ -11716,6 +12349,7 @@ async function runDashboardRuntimeDaemon(options = {}) {
   const refreshCooldownMs = options.refreshCooldownMs ?? DEFAULT_REFRESH_COOLDOWN_MS;
   const runHistoryLimit = options.runHistoryLimit ?? DEFAULT_RUN_HISTORY_LIMIT;
   const now = options.now ?? (() => Date.now());
+  const writeMirror = options.writeMirror ?? writeAttachmentMirror;
   const startedAt = now();
   let stopped = false;
   let reconnectAttempt = 0;
@@ -11849,6 +12483,26 @@ async function runDashboardRuntimeDaemon(options = {}) {
     });
     next.onFrame((frame) => {
       lastFrameAt = now();
+      if (frame.type === "attachments.changed") {
+        try {
+          writeMirror({
+            instanceId: token.instanceId,
+            fetchedAt: now(),
+            attachments: frame.attachments.map((a) => ({
+              runnerId: a.runnerId,
+              ...a.name !== void 0 ? { name: a.name } : {},
+              ...a.executionTarget !== void 0 ? { executionTarget: a.executionTarget } : {},
+              ...a.remoteInstanceId !== void 0 ? { remoteInstanceId: a.remoteInstanceId } : {}
+            }))
+          });
+        } catch (err) {
+          log(
+            "warn",
+            `runtime daemon: failed to write attachment mirror: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        return;
+      }
       if (frame.type === "cancel") {
         const entry = active.get(frame.runId);
         if (entry) {
@@ -11973,27 +12627,27 @@ async function runDashboardRuntimeDaemon(options = {}) {
 }
 
 // src/infra/daemon/stateDir.ts
-import fs20 from "fs";
-import os11 from "os";
-import path18 from "path";
+import fs21 from "fs";
+import os12 from "os";
+import path19 from "path";
 function daemonStatePaths(env = process.env) {
   const xdg = env["XDG_STATE_HOME"];
-  const home = env["HOME"] ?? os11.homedir();
-  const base = xdg && xdg.length > 0 ? xdg : path18.join(home, ".local", "state");
-  const dir = path18.join(base, "drisp");
+  const home = env["HOME"] ?? os12.homedir();
+  const base = xdg && xdg.length > 0 ? xdg : path19.join(home, ".local", "state");
+  const dir = path19.join(base, "drisp");
   return {
     dir,
-    pidPath: path18.join(dir, "dashboard-daemon.pid"),
-    logPath: path18.join(dir, "dashboard-daemon.log"),
-    socketPath: path18.join(dir, "dashboard-daemon.sock")
+    pidPath: path19.join(dir, "dashboard-daemon.pid"),
+    logPath: path19.join(dir, "dashboard-daemon.log"),
+    socketPath: path19.join(dir, "dashboard-daemon.sock")
   };
 }
 function ensureDaemonStateDir(env = process.env) {
   const paths = daemonStatePaths(env);
-  fs20.mkdirSync(paths.dir, { recursive: true, mode: 448 });
+  fs21.mkdirSync(paths.dir, { recursive: true, mode: 448 });
   if (process.platform !== "win32") {
     try {
-      fs20.chmodSync(paths.dir, 448);
+      fs21.chmodSync(paths.dir, 448);
     } catch {
     }
   }
@@ -12001,18 +12655,18 @@ function ensureDaemonStateDir(env = process.env) {
 }
 
 // src/infra/daemon/pidLock.ts
-import fs21 from "fs";
+import fs22 from "fs";
 function acquirePidLock(pidPath) {
   const ownPid = process.pid;
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const fd = fs21.openSync(pidPath, "wx", 384);
+      const fd = fs22.openSync(pidPath, "wx", 384);
       try {
-        fs21.writeSync(fd, `${ownPid}
+        fs22.writeSync(fd, `${ownPid}
 `);
-        fs21.fsyncSync(fd);
+        fs22.fsyncSync(fd);
       } finally {
-        fs21.closeSync(fd);
+        fs22.closeSync(fd);
       }
       return makeHandle(pidPath, ownPid);
     } catch (err) {
@@ -12026,7 +12680,7 @@ function acquirePidLock(pidPath) {
     }
     if (existing.state === "stale") {
       try {
-        fs21.unlinkSync(pidPath);
+        fs22.unlinkSync(pidPath);
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
       }
@@ -12040,7 +12694,7 @@ function acquirePidLock(pidPath) {
 function readPidLock(pidPath) {
   let raw;
   try {
-    raw = fs21.readFileSync(pidPath, "utf-8");
+    raw = fs22.readFileSync(pidPath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { state: "absent" };
@@ -12064,9 +12718,9 @@ function makeHandle(pidPath, pid) {
       if (released) return;
       released = true;
       try {
-        const raw = fs21.readFileSync(pidPath, "utf-8").trim();
+        const raw = fs22.readFileSync(pidPath, "utf-8").trim();
         if (raw === String(pid)) {
-          fs21.unlinkSync(pidPath);
+          fs22.unlinkSync(pidPath);
         }
       } catch (err) {
         if (err.code !== "ENOENT") {
@@ -12092,8 +12746,37 @@ function isProcessAlive(pid) {
 }
 
 // src/infra/daemon/udsIpc.ts
-import fs22 from "fs";
+import fs23 from "fs";
 import net2 from "net";
+
+// src/infra/daemon/udsFrameCodec.ts
+var DEFAULT_MAX_FRAME_BYTES = 1e6;
+function tryReadFrame(buffer, maxBodyBytes = DEFAULT_MAX_FRAME_BYTES) {
+  const newlineIdx = buffer.indexOf(10);
+  if (newlineIdx < 0) return null;
+  const lenStr = buffer.subarray(0, newlineIdx).toString("utf-8");
+  const len = Number.parseInt(lenStr, 10);
+  if (!Number.isFinite(len) || len < 0 || len > maxBodyBytes) {
+    return {
+      ok: false,
+      error: `uds bad framing header: ${JSON.stringify(lenStr.slice(0, 32))}`,
+      rest: buffer.subarray(newlineIdx + 1)
+    };
+  }
+  if (buffer.length < newlineIdx + 1 + len) return null;
+  const body = buffer.subarray(newlineIdx + 1, newlineIdx + 1 + len);
+  const rest = buffer.subarray(newlineIdx + 1 + len);
+  return { ok: true, body, rest };
+}
+function writeFrame(socket, value) {
+  const body = JSON.stringify(value);
+  const buf = Buffer.from(body, "utf-8");
+  socket.write(`${buf.length}
+`);
+  socket.write(buf);
+}
+
+// src/infra/daemon/udsIpc.ts
 async function startUdsServer(socketPath, handler, log) {
   await unlinkStaleSocket(socketPath);
   const server = net2.createServer((socket) => {
@@ -12108,7 +12791,7 @@ async function startUdsServer(socketPath, handler, log) {
   });
   if (process.platform !== "win32") {
     try {
-      fs22.chmodSync(socketPath, 384);
+      fs23.chmodSync(socketPath, 384);
     } catch {
     }
   }
@@ -12118,7 +12801,7 @@ async function startUdsServer(socketPath, handler, log) {
         server.close(() => resolve());
       });
       try {
-        fs22.unlinkSync(socketPath);
+        fs23.unlinkSync(socketPath);
       } catch (err) {
         if (err.code !== "ENOENT") {
         }
@@ -12142,21 +12825,15 @@ async function handleConnection(socket, handler, log) {
   });
   async function drain() {
     for (; ; ) {
-      const newlineIdx = buffer.indexOf(10);
-      if (newlineIdx < 0) return;
-      const lenStr = buffer.subarray(0, newlineIdx).toString("utf-8");
-      const len = Number.parseInt(lenStr, 10);
-      if (!Number.isFinite(len) || len < 0 || len > 1e6) {
-        log?.(
-          "warn",
-          `uds bad framing header: ${JSON.stringify(lenStr.slice(0, 32))}`
-        );
+      const frame = tryReadFrame(buffer);
+      if (frame === null) return;
+      if (!frame.ok) {
+        log?.("warn", frame.error);
         socket.destroy();
         return;
       }
-      if (buffer.length < newlineIdx + 1 + len) return;
-      const body = buffer.subarray(newlineIdx + 1, newlineIdx + 1 + len);
-      buffer = buffer.subarray(newlineIdx + 1 + len);
+      const { body } = frame;
+      buffer = frame.rest;
       let parsed;
       try {
         parsed = JSON.parse(body.toString("utf-8"));
@@ -12178,13 +12855,6 @@ async function handleConnection(socket, handler, log) {
     }
   }
 }
-function writeFrame(socket, response) {
-  const body = JSON.stringify(response);
-  const buf = Buffer.from(body, "utf-8");
-  socket.write(`${buf.length}
-`);
-  socket.write(buf);
-}
 async function sendUdsRequest(socketPath, request, options = {}) {
   const timeoutMs = options.timeoutMs ?? 5e3;
   return await new Promise((resolve, reject) => {
@@ -12209,30 +12879,20 @@ async function sendUdsRequest(socketPath, request, options = {}) {
       action();
     };
     socket.on("connect", () => {
-      const body = JSON.stringify(request);
-      const buf = Buffer.from(body, "utf-8");
-      socket.write(`${buf.length}
-`);
-      socket.write(buf);
+      writeFrame(socket, request);
     });
     socket.on("data", (chunk) => {
       const chunkBuf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
       buffer = Buffer.concat([buffer, chunkBuf]);
-      const newlineIdx = buffer.indexOf(10);
-      if (newlineIdx < 0) return;
-      const len = Number.parseInt(
-        buffer.subarray(0, newlineIdx).toString("utf-8"),
-        10
-      );
-      if (!Number.isFinite(len)) {
+      const frame = tryReadFrame(buffer);
+      if (frame === null) return;
+      if (!frame.ok) {
         finish(() => reject(new Error("uds reply malformed")));
         return;
       }
-      if (buffer.length < newlineIdx + 1 + len) return;
-      const body = buffer.subarray(newlineIdx + 1, newlineIdx + 1 + len).toString("utf-8");
       let parsed;
       try {
-        parsed = JSON.parse(body);
+        parsed = JSON.parse(frame.body.toString("utf-8"));
       } catch (err) {
         finish(
           () => reject(
@@ -12259,7 +12919,7 @@ async function sendUdsRequest(socketPath, request, options = {}) {
 async function unlinkStaleSocket(socketPath) {
   let stat;
   try {
-    stat = fs22.statSync(socketPath);
+    stat = fs23.statSync(socketPath);
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -12286,7 +12946,7 @@ async function unlinkStaleSocket(socketPath) {
       `uds path ${socketPath} is in use by another process; aborting`
     );
   }
-  fs22.unlinkSync(socketPath);
+  fs23.unlinkSync(socketPath);
 }
 
 export {
@@ -12301,7 +12961,8 @@ export {
   extractPermissionSnapshot,
   isSubagentTool,
   createFeedMapper,
-  handleEvent,
+  ingestRuntimeEvent,
+  ingestRuntimeDecision,
   generateId,
   createSessionStore,
   sessionsDir,
@@ -12350,6 +13011,9 @@ export {
   bootstrapRuntimeConfig,
   EXEC_EXIT_CODE,
   runExec,
+  readAttachmentMirror,
+  writeAttachmentMirror,
+  removeAttachmentMirror,
   runDashboardRuntimeDaemon,
   daemonStatePaths,
   ensureDaemonStateDir,
@@ -12358,4 +13022,4 @@ export {
   startUdsServer,
   sendUdsRequest
 };
-//# sourceMappingURL=chunk-WHELLVBL.js.map
+//# sourceMappingURL=chunk-PJUDHH4R.js.map