@drisp/cli 0.5.2 → 0.5.6

package/dist/{chunk-PC46SGTK.js → chunk-ZU7M6YZW.js}

@@ -13,10 +13,6 @@ import {
   isValidHookEventEnvelope,
   resolveHookSocketPath
 } from "./chunk-BTKQ67RE.js";
-import {
-  createInstanceSocketClient,
-  writeAttachmentMirror
-} from "./chunk-JV7CRNTC.js";
 import {
   TransportUnreachableError,
   createUdsClientTransport,
@@ -38,7 +34,7 @@ import {
   resolveWorkflow,
   resolveWorkflowInstall,
   resolveWorkflowPlugins
-} from "./chunk-A54HGVML.js";
+} from "./chunk-7E54JMXH.js";
 
 // src/infra/daemon/stateDir.ts
 import fs from "fs";
@@ -6568,12 +6564,16 @@ function resolveCodexMcpConfig(pluginMcpConfig, workflowPlan) {
   return Object.keys(merged).length === 0 ? void 0 : { mcp_servers: merged };
 }
 function resolveCodexWorkflowPlugins(workflowPlan) {
-  return workflowPlan?.resolvedPlugins.map((plugin) => ({
+  const resolvedTargets = workflowPlan?.resolvedPlugins.map((plugin) => ({
     ref: plugin.ref,
     pluginName: plugin.pluginName,
     marketplacePath: plugin.codexMarketplacePath,
     ...plugin.version !== void 0 && { version: plugin.version }
-  })) ?? workflowPlan?.codexPlugins ?? [];
+  })) ?? [];
+  const directTargets = workflowPlan?.codexPlugins ?? [];
+  return [...resolvedTargets, ...directTargets].filter(
+    (plugin, index, array) => array.findIndex((candidate) => candidate.ref === plugin.ref) === index
+  );
 }
 
 // src/harnesses/codex/session/promptOptions.ts
@@ -7349,11 +7349,6 @@ var EXEC_EXIT_CODE = {
 import crypto2 from "crypto";
 import path18 from "path";
 
-// src/core/feed/todo.ts
-function isSubagentTool(toolName) {
-  return toolName === "Task" || toolName === "Agent";
-}
-
 // src/core/feed/entities.ts
 var ActorRegistry = class {
   actors = /* @__PURE__ */ new Map();
@@ -8149,625 +8144,639 @@ function createSubagentTracker() {
   };
 }
 
-// src/core/feed/mapper.ts
-function extractTodoItems(toolInput) {
-  const input = toolInput;
-  return Array.isArray(input?.todos) ? input.todos : [];
+// src/core/feed/internals/projection.ts
+function readString(...values) {
+  for (const value of values) {
+    if (typeof value === "string") return value;
+  }
+  return void 0;
 }
-function mapPlanStepStatus(status) {
-  switch (status) {
-    case "inProgress":
-      return "in_progress";
-    case "completed":
-      return "completed";
-    case void 0:
-    default:
-      return "pending";
+function readBoolean(...values) {
+  for (const value of values) {
+    if (typeof value === "boolean") return value;
   }
+  return void 0;
 }
-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 = runLifecycle.allocateSeq();
-    const runId = runLifecycle.getRunId();
-    const eventId = `${runId}:E${s}`;
-    const baseCause = {
-      hook_request_id: runtimeEvent.id,
-      transcript_path: runtimeEvent.context.transcriptPath,
-      ...cause
-    };
-    const fe = {
-      event_id: eventId,
-      seq: s,
-      ts: runtimeEvent.timestamp,
-      session_id: runtimeEvent.sessionId,
-      run_id: runId,
-      kind,
-      level,
-      actor_id: actorId,
-      cause: baseCause,
-      title: "",
-      display: runtimeEvent.display,
-      raw: runtimeEvent.payload,
-      data
-    };
-    fe.title = composeTitle(fe, runtimeEvent);
-    if (runtimeEvent.interaction.expectsDecision || kind === "permission.request" || kind === "stop.request") {
-      decisionCorrelation.recordRequest(runtimeEvent.id, eventId, kind);
+function readObject(...values) {
+  for (const value of values) {
+    if (typeof value === "object" && value !== null) {
+      return value;
     }
-    return fe;
   }
-  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)
-        );
-      }
-    }
+  return {};
+}
+function readSuggestionArray(...values) {
+  for (const value of values) {
+    if (Array.isArray(value)) return value;
   }
-  function closeRunIntoEvent(runtimeEvent, status) {
-    const closed = runLifecycle.closeRun(runtimeEvent.timestamp, status);
-    if (!closed) return null;
+  return void 0;
+}
+
+// src/core/feed/todo.ts
+function isSubagentTool(toolName) {
+  return toolName === "Task" || toolName === "Agent";
+}
+
+// src/core/feed/internals/toolProjection.ts
+function extractTodoItems(toolInput) {
+  const input = toolInput;
+  return Array.isArray(input?.todos) ? input.todos : [];
+}
+function resolveToolUseId(event, record) {
+  return event.toolUseId ?? record["tool_use_id"];
+}
+function toolUseCause(toolUseId, parentId) {
+  return {
+    ...toolUseId ? { tool_use_id: toolUseId } : {},
+    ...parentId ? { parent_event_id: parentId } : {}
+  };
+}
+function createToolProjection(args) {
+  const {
+    ensureRunArray,
+    makeEvent,
+    runLifecycle,
+    toolCorrelation,
+    rootPlan,
+    subagents,
+    resolveToolActor
+  } = args;
+  function webSearchStarted(event, data, toolUseId, parentEventId) {
+    const toolInput = readObject(data["tool_input"]);
+    const query = readString(toolInput["query"]);
     return makeEvent(
-      "run.end",
+      "web.search",
       "info",
       "system",
-      { status, counters: { ...closed.counters } },
-      runtimeEvent
+      {
+        message: query ? `Searching web for "${query}".` : "Searching the web.",
+        phase: "started",
+        query,
+        item_id: toolUseId
+      },
+      event,
+      toolUseId ? { parent_event_id: parentEventId, tool_use_id: toolUseId } : { parent_event_id: parentEventId }
     );
   }
-  function ensureRunArray(runtimeEvent, triggerType = "other", promptPreview) {
-    if (runLifecycle.getCurrentRun() && triggerType === "other") return [];
-    const results = [];
-    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",
-        "info",
-        "system",
-        { trigger: { type: triggerType, prompt_preview: promptPreview } },
-        runtimeEvent
-      )
+  function webSearchCompleted(event, data, toolUseId, parentEventId) {
+    const response = readObject(data["tool_response"]);
+    const actionType = readString(response["type"]);
+    const query = readString(readObject(data["tool_input"])["query"]);
+    const url = readString(response["url"]);
+    const pattern = readString(response["pattern"]);
+    const queries = Array.isArray(response["queries"]) ? response["queries"] : void 0;
+    const message = actionType === "openPage" ? url ? `Opened search result ${url}.` : "Opened search result." : actionType === "findInPage" ? pattern ? `Found "${pattern}" in ${url ?? "the page"}.` : `Searched within ${url ?? "the page"}.` : actionType === "search" ? queries && queries.length > 1 ? `Ran ${queries.length} search queries.` : query ? `Searched web for "${query}".` : "Finished web search." : query ? `Finished web search for "${query}".` : "Finished web search.";
+    return makeEvent(
+      "web.search",
+      "info",
+      "system",
+      {
+        message,
+        phase: "completed",
+        query,
+        action_type: actionType,
+        url,
+        pattern,
+        queries,
+        item_id: toolUseId
+      },
+      event,
+      toolUseId ? { parent_event_id: parentEventId, tool_use_id: toolUseId } : { parent_event_id: parentEventId }
     );
-    return results;
-  }
-  function resolveToolActor() {
-    return subagents.peek() ?? "agent:root";
-  }
-  function resolveToolUseId(event, record) {
-    return event.toolUseId ?? record["tool_use_id"];
-  }
-  function toolUseCause(toolUseId, parentId) {
-    return {
-      ...toolUseId ? { tool_use_id: toolUseId } : {},
-      ...parentId ? { parent_event_id: parentId } : {}
-    };
   }
-  function mapEvent(event) {
-    const d = event.data;
-    const readString = (...values) => {
-      for (const value of values) {
-        if (typeof value === "string") return value;
-      }
-      return void 0;
-    };
-    const readBoolean = (...values) => {
-      for (const value of values) {
-        if (typeof value === "boolean") return value;
+  return {
+    mapToolEvent(event, data) {
+      const results = ensureRunArray(event);
+      const toolUseId = resolveToolUseId(event, data);
+      const toolName = event.toolName ?? readString(data["tool_name"]) ?? "Unknown";
+      const toolInput = readObject(data["tool_input"]);
+      if (event.kind === "tool.delta") {
+        const parentId = toolCorrelation.lookupParent(toolUseId);
+        const cumulative = toolCorrelation.appendDelta(
+          toolUseId,
+          readString(data["delta"]) ?? ""
+        );
+        results.push(
+          makeEvent(
+            "tool.delta",
+            "info",
+            resolveToolActor(),
+            {
+              tool_name: toolName,
+              tool_input: toolInput,
+              tool_use_id: toolUseId,
+              delta: cumulative
+            },
+            event,
+            toolUseCause(toolUseId, parentId)
+          )
+        );
+        return results;
       }
-      return void 0;
-    };
-    const readObject = (...values) => {
-      for (const value of values) {
-        if (typeof value === "object" && value !== null) {
-          return value;
+      if (event.kind === "tool.pre") {
+        runLifecycle.incrementCounter("tool_uses");
+        const preEvent = makeEvent(
+          "tool.pre",
+          "info",
+          resolveToolActor(),
+          {
+            tool_name: toolName,
+            tool_input: toolInput,
+            tool_use_id: toolUseId
+          },
+          event,
+          toolUseId ? { tool_use_id: toolUseId } : void 0
+        );
+        if (toolUseId) toolCorrelation.recordPre(toolUseId, preEvent.event_id);
+        results.push(preEvent);
+        if (toolName === "WebSearch") {
+          results.push(
+            webSearchStarted(event, data, toolUseId, preEvent.event_id)
+          );
         }
-      }
-      return {};
-    };
-    const readSuggestionArray = (...values) => {
-      for (const value of values) {
-        if (Array.isArray(value)) {
-          return value;
+        if (toolName === "TodoWrite" && preEvent.actor_id === "agent:root") {
+          rootPlan.set(extractTodoItems(toolInput));
+        }
+        if (isSubagentTool(toolName)) {
+          if (typeof toolInput["description"] === "string") {
+            subagents.recordPendingDescription(toolInput["description"]);
+          } else {
+            subagents.clearPendingDescription();
+          }
         }
+        return results;
       }
-      return void 0;
-    };
-    const eventKind2 = event.kind;
-    const results = [];
-    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 ev = agentMessageStream.emit({
-        runtimeEvent: event,
-        actorId,
-        scope,
-        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) {
-      results.push(
-        ...agentMessageStream.emitTranscriptMessages(
-          transcriptPath,
-          event,
+      if (event.kind === "tool.post") {
+        if (toolUseId) toolCorrelation.forgetTool(toolUseId);
+        const parentId = toolCorrelation.lookupParent(toolUseId);
+        const postEvent = makeEvent(
+          "tool.post",
+          "info",
           resolveToolActor(),
-          currentScope()
-        )
-      );
-    }
-    switch (eventKind2) {
-      case "session.start": {
-        agentMessageStream.clearPending();
-        const source = readString(d["source"]) ?? "startup";
-        runLifecycle.setSession({
-          session_id: event.sessionId,
-          started_at: event.timestamp,
-          source,
-          agent_type: readString(d["agent_type"])
-        });
-        if (source === "resume" || source === "clear" || source === "compact") {
+          {
+            tool_name: toolName,
+            tool_input: toolInput,
+            tool_use_id: toolUseId,
+            tool_response: data.tool_response
+          },
+          event,
+          toolUseCause(toolUseId, parentId)
+        );
+        results.push(postEvent);
+        if (toolName === "WebSearch") {
           results.push(
-            ...ensureRunArray(event, source)
+            webSearchCompleted(event, data, toolUseId, postEvent.event_id)
           );
         }
+        return results;
+      }
+      if (event.kind === "tool.failure") {
+        runLifecycle.incrementCounter("tool_failures");
+        if (toolUseId) toolCorrelation.forgetTool(toolUseId);
+        const parentId = toolCorrelation.lookupParent(toolUseId);
         results.push(
           makeEvent(
-            "session.start",
-            "info",
-            "system",
+            "tool.failure",
+            "error",
+            resolveToolActor(),
             {
-              source,
-              agent_type: readString(d["agent_type"]),
-              model: readString(d["model"])
+              tool_name: toolName,
+              tool_input: toolInput,
+              tool_use_id: toolUseId,
+              error: readString(data["error"]) ?? "Unknown error",
+              is_interrupt: readBoolean(data["is_interrupt"])
             },
-            event
+            event,
+            toolUseCause(toolUseId, parentId)
           )
         );
-        break;
       }
-      case "session.end": {
-        agentMessageStream.clearPending();
-        const closeEvt = closeRunIntoEvent(event, "completed");
-        if (closeEvt) results.push(closeEvt);
-        results.push(
-          makeEvent(
-            "session.end",
-            "info",
-            "system",
-            {
-              reason: readString(d["reason"]) ?? "unknown"
-            },
-            event
-          )
-        );
-        runLifecycle.endSession(event.timestamp);
-        break;
-      }
-      case "user.prompt": {
-        const prompt = readString(d["prompt"]) ?? "";
-        results.push(
-          ...ensureRunArray(event, "user_prompt_submit", prompt.slice(0, 80))
-        );
-        results.push(
-          makeEvent(
-            "user.prompt",
-            "info",
-            "user",
-            {
-              prompt,
-              cwd: event.context.cwd,
-              permission_mode: event.context.permissionMode ?? readString(d["permission_mode"])
-            },
-            event
-          )
-        );
-        break;
-      }
-      case "turn.start": {
-        agentMessageStream.clearPending();
-        const prompt = readString(d["prompt"]);
+      return results;
+    }
+  };
+}
+
+// src/core/feed/internals/notificationProjection.ts
+function createNotificationProjection(args) {
+  const { ensureRunArray, makeEvent, decisionCorrelation } = args;
+  const reviewRoute = (data, runtimeEvent, ctx) => {
+    const item = readObject(data["item"]);
+    return [
+      makeEvent(
+        "review.status",
+        "info",
+        "system",
+        {
+          message: ctx.message,
+          phase: ctx.notificationType.endsWith(".completed") ? "completed" : "started",
+          review: readString(item["review"]),
+          item_id: readString(data["item_id"])
+        },
+        runtimeEvent
+      )
+    ];
+  };
+  const imageViewRoute = (data, runtimeEvent, ctx) => {
+    const item = readObject(data["item"]);
+    return [
+      makeEvent(
+        "image.view",
+        "info",
+        "system",
+        {
+          message: ctx.message,
+          path: readString(item["path"]),
+          item_id: readString(data["item_id"])
+        },
+        runtimeEvent
+      )
+    ];
+  };
+  const contextCompactionRoute = (data, runtimeEvent, ctx) => [
+    makeEvent(
+      "context.compaction",
+      "info",
+      "system",
+      {
+        message: ctx.message,
+        phase: ctx.notificationType.endsWith(".completed") ? "completed" : "started",
+        item_id: readString(data["item_id"])
+      },
+      runtimeEvent
+    )
+  ];
+  const routes = {
+    "codex.error": (data, runtimeEvent, ctx) => [
+      makeEvent(
+        "runtime.error",
+        "error",
+        "system",
+        {
+          message: ctx.message,
+          title: ctx.title,
+          thread_id: readString(data["thread_id"]),
+          turn_id: readString(data["turn_id"]),
+          error_code: readString(data["error_code"]),
+          will_retry: readBoolean(data["will_retry"])
+        },
+        runtimeEvent
+      )
+    ],
+    "thread.status_changed": (data, runtimeEvent, ctx) => [
+      makeEvent(
+        "thread.status",
+        "info",
+        "system",
+        {
+          message: ctx.message,
+          thread_id: readString(data["thread_id"]),
+          status_type: readString(data["status_type"]),
+          active_flags: Array.isArray(data["active_flags"]) ? data["active_flags"] : void 0
+        },
+        runtimeEvent
+      )
+    ],
+    "turn.diff_updated": (data, runtimeEvent, ctx) => [
+      makeEvent(
+        "turn.diff",
+        "info",
+        "system",
+        {
+          message: ctx.message,
+          thread_id: readString(data["thread_id"]),
+          turn_id: readString(data["turn_id"]),
+          diff: readString(data["diff"]) ?? ""
+        },
+        runtimeEvent
+      )
+    ],
+    "server_request.resolved": (data, runtimeEvent, ctx) => {
+      const requestId = data["request_id"] !== void 0 ? String(data["request_id"]) : void 0;
+      const resolved = requestId ? decisionCorrelation.lookupResolved(requestId) : null;
+      return [
+        makeEvent(
+          "server.request.resolved",
+          "info",
+          "system",
+          {
+            message: ctx.message,
+            request_id: requestId,
+            resolved_kind: resolved?.kind
+          },
+          runtimeEvent,
+          resolved ? { parent_event_id: resolved.event_id } : void 0
+        )
+      ];
+    },
+    "item.enteredReviewMode.started": reviewRoute,
+    "item.enteredReviewMode.completed": reviewRoute,
+    "item.exitedReviewMode.started": reviewRoute,
+    "item.exitedReviewMode.completed": reviewRoute,
+    "item.imageView.started": imageViewRoute,
+    "item.imageView.completed": imageViewRoute,
+    "item.contextCompaction.started": contextCompactionRoute,
+    "item.contextCompaction.completed": contextCompactionRoute,
+    "mcp_tool_call.progress": (_data, runtimeEvent, ctx) => [
+      makeEvent(
+        "mcp.progress",
+        "info",
+        "system",
+        {
+          message: ctx.message,
+          title: ctx.title
+        },
+        runtimeEvent
+      )
+    ],
+    "command_execution.terminal_interaction": (_data, runtimeEvent, ctx) => [
+      makeEvent(
+        "terminal.input",
+        "info",
+        "system",
+        {
+          message: ctx.message,
+          input_preview: ctx.message
+        },
+        runtimeEvent
+      )
+    ],
+    "skills.changed": (_data, runtimeEvent, ctx) => [
+      makeEvent(
+        "skills.changed",
+        "info",
+        "system",
+        {
+          message: ctx.message
+        },
+        runtimeEvent
+      )
+    ],
+    "skills.loaded": (_data, runtimeEvent, ctx) => {
+      const payload = typeof runtimeEvent.payload === "object" && runtimeEvent.payload !== null ? runtimeEvent.payload : null;
+      return [
+        makeEvent(
+          "skills.loaded",
+          "info",
+          "system",
+          {
+            message: ctx.message,
+            count: typeof payload?.["count"] === "number" ? payload["count"] : void 0,
+            error_count: typeof payload?.["error_count"] === "number" ? payload["error_count"] : void 0
+          },
+          runtimeEvent
+        )
+      ];
+    }
+  };
+  return {
+    mapNotification(event, data) {
+      const results = ensureRunArray(event);
+      const notificationType = readString(data["notification_type"]);
+      const message = readString(data["message"]) ?? "";
+      const title = readString(data["title"]);
+      const route = notificationType ? routes[notificationType] : void 0;
+      if (route && notificationType) {
         results.push(
-          ...ensureRunArray(
-            event,
-            prompt ? "user_prompt_submit" : "other",
-            prompt?.slice(0, 80)
-          )
-        );
-        if (prompt) {
-          results.push(
-            makeEvent(
-              "user.prompt",
-              "info",
-              "user",
-              {
-                prompt,
-                cwd: event.context.cwd,
-                permission_mode: event.context.permissionMode
-              },
-              event
-            )
-          );
-        }
-        break;
-      }
-      case "message.delta": {
-        agentMessageStream.appendPendingDelta(
-          readString(d["item_id"]),
-          readString(d["delta"]) ?? "",
-          resolveToolActor(),
-          currentScope()
+          ...route(data, event, {
+            notificationType,
+            message,
+            title
+          })
         );
-        break;
-      }
-      case "message.complete": {
-        results.push(...ensureRunArray(event));
-        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;
+        return results;
       }
-      case "turn.complete": {
-        if (!runLifecycle.getCurrentRun()) {
-          agentMessageStream.clearPending();
-          break;
-        }
-        const stopEvt = makeEvent(
-          "stop.request",
+      results.push(
+        makeEvent(
+          "notification",
           "info",
-          "agent:root",
+          "system",
           {
-            stop_hook_active: false
+            message,
+            title,
+            notification_type: notificationType
           },
           event
-        );
-        results.push(stopEvt);
-        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 next = 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",
-                "info",
-                "system",
-                {
-                  todo_id: "plan",
-                  patch: { status: "doing" }
-                },
-                event
-              )
-            );
-          }
-        }
+        )
+      );
+      return results;
+    }
+  };
+}
+
+// src/core/feed/internals/decisionProjection.ts
+function createDecisionProjection(args) {
+  const { ensureRunArray, makeEvent, runLifecycle, decisionCorrelation } = args;
+  function makeDecisionEvent(requestId, parentEventId, decision, 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;
+  }
+  return {
+    mapRequestEvent(event, data) {
+      const results = ensureRunArray(event);
+      if (event.kind === "permission.request") {
+        runLifecycle.incrementCounter("permission_requests");
+        const networkContext = readObject(data["network_context"]);
         results.push(
           makeEvent(
-            "plan.update",
+            "permission.request",
             "info",
             "system",
             {
-              explanation: readString(d["explanation"]) ?? null,
-              delta: readString(d["delta"]),
-              item_id: readString(d["item_id"]),
-              thread_id: readString(d["thread_id"]),
-              turn_id: readString(d["turn_id"]),
-              plan: Array.isArray(planSteps) ? planSteps : void 0
+              tool_name: event.toolName ?? readString(data["tool_name"]) ?? "Unknown",
+              tool_input: readObject(data["tool_input"]),
+              tool_use_id: resolveToolUseId(event, data),
+              permission_suggestions: readSuggestionArray(
+                data["permission_suggestions"]
+              ),
+              network_context: Object.keys(networkContext).length > 0 ? {
+                host: readString(networkContext["host"]),
+                protocol: readString(networkContext["protocol"])
+              } : void 0
             },
             event
           )
         );
-        break;
+        return results;
       }
-      case "reasoning.delta":
-        if (readString(d["phase"]) === "summary" && readString(d["delta"])) {
-          const summaryIndex = (() => {
-            const value = d["summary_index"] ?? d["content_index"];
-            return typeof value === "number" ? value : void 0;
-          })();
-          results.push(
-            makeEvent(
-              "reasoning.summary",
-              "info",
-              "agent:root",
-              {
-                message: agentMessageStream.appendReasoningSummary(
-                  readString(d["item_id"]),
-                  summaryIndex,
-                  readString(d["delta"]) ?? ""
-                ),
-                item_id: readString(d["item_id"]),
-                content_index: typeof d["content_index"] === "number" ? d["content_index"] : void 0,
-                summary_index: typeof d["summary_index"] === "number" ? d["summary_index"] : summaryIndex,
-                thread_id: readString(d["thread_id"]),
-                turn_id: readString(d["turn_id"])
-              },
-              event
-            )
-          );
-        }
-        break;
-      case "usage.update": {
+      if (event.kind === "stop.request") {
         results.push(
           makeEvent(
-            "usage.update",
+            "stop.request",
             "info",
-            "system",
+            "agent:root",
             {
-              thread_id: readString(d["thread_id"]),
-              turn_id: readString(d["turn_id"]),
-              usage: typeof d["usage"] === "object" && d["usage"] !== null ? d["usage"] : void 0,
-              delta: typeof d["delta"] === "object" && d["delta"] !== null ? d["delta"] : void 0
+              stop_hook_active: readBoolean(data["stop_hook_active"]) ?? false,
+              last_assistant_message: readString(
+                data["last_assistant_message"]
+              )
             },
             event
           )
         );
-        break;
+        return results;
       }
-      case "tool.delta": {
-        results.push(...ensureRunArray(event));
-        const toolUseId = resolveToolUseId(event, d);
-        const toolName = event.toolName ?? readString(d["tool_name"]) ?? "Unknown";
-        const parentId = toolCorrelation.lookupParent(toolUseId);
-        const chunk = readString(d["delta"]) ?? "";
-        const cumulative = toolCorrelation.appendDelta(toolUseId, chunk);
+      if (event.kind === "stop.failure") {
         results.push(
           makeEvent(
-            "tool.delta",
-            "info",
-            resolveToolActor(),
+            "stop.failure",
+            "error",
+            "system",
             {
-              tool_name: toolName,
-              tool_input: readObject(d["tool_input"]),
-              tool_use_id: toolUseId,
-              delta: cumulative
+              error_type: readString(data["error_type"]) ?? "unknown",
+              error_message: readString(data["error_message"])
             },
-            event,
-            toolUseCause(toolUseId, parentId)
+            event
           )
         );
-        break;
+        return results;
       }
-      case "tool.pre": {
-        results.push(...ensureRunArray(event));
-        runLifecycle.incrementCounter("tool_uses");
-        const toolUseId = resolveToolUseId(event, d);
-        const toolName = event.toolName ?? readString(d["tool_name"]) ?? "Unknown";
-        const fe = makeEvent(
-          "tool.pre",
-          "info",
-          resolveToolActor(),
-          {
-            tool_name: toolName,
-            tool_input: readObject(d["tool_input"]),
-            tool_use_id: toolUseId
-          },
-          event,
-          toolUseId ? { tool_use_id: toolUseId } : void 0
-        );
-        if (toolUseId) {
-          toolCorrelation.recordPre(toolUseId, fe.event_id);
-        }
-        results.push(fe);
-        if (toolName === "WebSearch") {
-          results.push(
-            makeEvent(
-              "web.search",
-              "info",
-              "system",
-              {
-                message: (() => {
-                  const query = readString(
-                    readObject(d["tool_input"])["query"]
-                  );
-                  return query ? `Searching web for "${query}".` : "Searching the web.";
-                })(),
-                phase: "started",
-                query: readString(readObject(d["tool_input"])["query"]),
-                item_id: toolUseId
-              },
-              event,
-              toolUseId ? { parent_event_id: fe.event_id, tool_use_id: toolUseId } : { parent_event_id: fe.event_id }
-            )
-          );
-        }
-        if (toolName === "TodoWrite" && fe.actor_id === "agent:root") {
-          rootPlan.set(extractTodoItems(readObject(d["tool_input"])));
-        }
-        if (isSubagentTool(toolName)) {
-          const input = readObject(d["tool_input"]);
-          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) toolCorrelation.forgetTool(toolUseId);
-        const parentId = toolCorrelation.lookupParent(toolUseId);
-        const toolName = event.toolName ?? readString(d["tool_name"]) ?? "Unknown";
-        const postEvent = makeEvent(
-          "tool.post",
-          "info",
-          resolveToolActor(),
-          {
-            tool_name: toolName,
-            tool_input: readObject(d["tool_input"]),
-            tool_use_id: toolUseId,
-            tool_response: d.tool_response
-          },
-          event,
-          toolUseCause(toolUseId, parentId)
-        );
-        results.push(postEvent);
-        if (toolName === "WebSearch") {
-          const response = readObject(d["tool_response"]);
-          const actionType = readString(response["type"]);
-          const query = readString(readObject(d["tool_input"])["query"]);
-          const url = readString(response["url"]);
-          const pattern = readString(response["pattern"]);
-          const queries = Array.isArray(response["queries"]) ? response["queries"] : void 0;
-          const message = actionType === "openPage" ? url ? `Opened search result ${url}.` : "Opened search result." : actionType === "findInPage" ? pattern ? `Found "${pattern}" in ${url ?? "the page"}.` : `Searched within ${url ?? "the page"}.` : actionType === "search" ? queries && queries.length > 1 ? `Ran ${queries.length} search queries.` : query ? `Searched web for "${query}".` : "Finished web search." : query ? `Finished web search for "${query}".` : "Finished web search.";
-          results.push(
-            makeEvent(
-              "web.search",
-              "info",
-              "system",
-              {
-                message,
-                phase: "completed",
-                query,
-                action_type: actionType,
-                url,
-                pattern,
-                queries,
-                item_id: toolUseId
-              },
-              event,
-              toolUseId ? { parent_event_id: postEvent.event_id, tool_use_id: toolUseId } : { parent_event_id: postEvent.event_id }
-            )
-          );
-        }
-        break;
-      }
-      case "tool.failure": {
-        results.push(...ensureRunArray(event));
-        runLifecycle.incrementCounter("tool_failures");
-        const toolUseId = resolveToolUseId(event, d);
-        if (toolUseId) toolCorrelation.forgetTool(toolUseId);
-        const parentId = toolCorrelation.lookupParent(toolUseId);
-        const toolName = event.toolName ?? readString(d["tool_name"]) ?? "Unknown";
+      if (event.kind === "permission.denied") {
         results.push(
           makeEvent(
-            "tool.failure",
-            "error",
-            resolveToolActor(),
+            "permission.denied",
+            "warn",
+            "system",
             {
-              tool_name: toolName,
-              tool_input: readObject(d["tool_input"]),
-              tool_use_id: toolUseId,
-              error: readString(d["error"]) ?? "Unknown error",
-              is_interrupt: readBoolean(d["is_interrupt"])
+              tool_name: event.toolName ?? readString(data["tool_name"]) ?? "Unknown",
+              tool_input: readObject(data["tool_input"]),
+              tool_use_id: readString(data["tool_use_id"]),
+              reason: readString(data["reason"])
             },
-            event,
-            toolUseCause(toolUseId, parentId)
+            event
           )
         );
-        break;
+        return results;
       }
-      case "permission.request": {
-        results.push(...ensureRunArray(event));
-        runLifecycle.incrementCounter("permission_requests");
-        const toolName = event.toolName ?? readString(d["tool_name"]) ?? "Unknown";
+      if (event.kind === "elicitation.request") {
         results.push(
           makeEvent(
-            "permission.request",
-            "info",
+            "elicitation.request",
+            "warn",
             "system",
             {
-              tool_name: toolName,
-              tool_input: readObject(d["tool_input"]),
-              tool_use_id: resolveToolUseId(event, d),
-              permission_suggestions: readSuggestionArray(
-                d["permission_suggestions"]
-              ),
-              network_context: typeof d["network_context"] === "object" && d["network_context"] !== null ? {
-                host: readString(
-                  d["network_context"]["host"]
-                ),
-                protocol: readString(
-                  d["network_context"]["protocol"]
-                )
-              } : void 0
+              mcp_server: readString(data["mcp_server"]) ?? "unknown",
+              form: data["form"]
             },
             event
           )
         );
-        break;
+        return results;
       }
-      case "stop.request": {
-        results.push(...ensureRunArray(event));
-        const stopEvt = makeEvent(
-          "stop.request",
+      if (event.kind === "elicitation.result") {
+        const action = readString(data["action"]);
+        const evt = makeEvent(
+          "elicitation.result",
           "info",
-          "agent:root",
+          "system",
           {
-            stop_hook_active: readBoolean(d["stop_hook_active"]) ?? false,
-            last_assistant_message: readString(d["last_assistant_message"])
+            mcp_server: readString(data["mcp_server"]) ?? "unknown",
+            ...action ? { action } : {},
+            content: readObject(data["content"])
           },
           event
         );
-        results.push(stopEvt);
-        break;
+        evt.ui = { collapsed_default: true };
+        results.push(evt);
       }
-      case "subagent.start": {
-        results.push(...ensureRunArray(event));
-        const agentId = event.agentId ?? readString(d["agent_id"]);
-        const agentType = event.agentType ?? readString(d["agent_type"]);
+      return results;
+    },
+    mapDecision(requestId, decision) {
+      const consumed = decisionCorrelation.consumeForDecision(requestId);
+      if (!consumed) return null;
+      const { parentEventId, originalKind } = consumed;
+      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(
+          requestId,
+          parentEventId,
+          decision,
+          "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(
+          requestId,
+          parentEventId,
+          decision,
+          "stop.decision",
+          data
+        );
+      }
+      return null;
+    }
+  };
+}
+
+// src/core/feed/internals/subagentProjection.ts
+function createSubagentProjection(args) {
+  const { ensureRunArray, makeEvent, runLifecycle, actors, subagents } = args;
+  return {
+    mapSubagentEvent(event, data) {
+      const results = ensureRunArray(event);
+      const agentId = event.agentId ?? readString(data["agent_id"]);
+      const agentType = event.agentType ?? readString(data["agent_type"]);
+      if (event.kind === "subagent.start") {
         if (agentId) {
           actors.ensureSubagent(agentId, agentType ?? "unknown");
           const currentRun = runLifecycle.getCurrentRun();
           if (currentRun) currentRun.actors.subagent_ids.push(agentId);
           subagents.pushActor(`subagent:${agentId}`);
         }
-        const description = subagents.consumePendingDescription() ?? readString(d["prompt"]);
+        const description = subagents.consumePendingDescription() ?? readString(data["prompt"]);
         results.push(
           makeEvent(
             "subagent.start",
@@ -8777,485 +8786,726 @@ function createFeedMapper(bootstrap) {
               agent_id: agentId ?? "",
               agent_type: agentType ?? "",
               description: description ?? void 0,
-              tool: readString(d["tool"]),
-              sender_thread_id: readString(d["sender_thread_id"]),
-              receiver_thread_id: readString(d["receiver_thread_id"]),
-              new_thread_id: readString(d["new_thread_id"]),
-              agent_status: readString(d["agent_status"])
+              tool: readString(data["tool"]),
+              sender_thread_id: readString(data["sender_thread_id"]),
+              receiver_thread_id: readString(data["receiver_thread_id"]),
+              new_thread_id: readString(data["new_thread_id"]),
+              agent_status: readString(data["agent_status"])
             },
             event
           )
         );
-        if (agentId && description) {
+        if (agentId && description)
           subagents.setDescription(agentId, description);
-        }
-        break;
+        return results;
       }
-      case "subagent.stop": {
-        results.push(...ensureRunArray(event));
-        const agentId = event.agentId ?? readString(d["agent_id"]);
-        if (agentId) {
-          subagents.popActor(`subagent:${agentId}`);
-        }
-        const subStopActorId = `subagent:${agentId ?? "unknown"}`;
-        const subStopEvt = makeEvent(
+      if (agentId) subagents.popActor(`subagent:${agentId}`);
+      results.push(
+        makeEvent(
           "subagent.stop",
           "info",
-          subStopActorId,
+          `subagent:${agentId ?? "unknown"}`,
           {
             agent_id: agentId ?? "",
-            agent_type: event.agentType ?? readString(d["agent_type"]) ?? "",
-            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"]),
+            agent_type: agentType ?? "",
+            stop_hook_active: readBoolean(data["stop_hook_active"]) ?? false,
+            agent_transcript_path: readString(data["agent_transcript_path"]),
+            last_assistant_message: readString(data["last_assistant_message"]),
             description: subagents.description(agentId ?? ""),
-            tool: readString(d["tool"]),
-            status: readString(d["status"]),
-            sender_thread_id: readString(d["sender_thread_id"]),
-            receiver_thread_id: readString(d["receiver_thread_id"]),
-            new_thread_id: readString(d["new_thread_id"]),
-            agent_status: readString(d["agent_status"])
+            tool: readString(data["tool"]),
+            status: readString(data["status"]),
+            sender_thread_id: readString(data["sender_thread_id"]),
+            receiver_thread_id: readString(data["receiver_thread_id"]),
+            new_thread_id: readString(data["new_thread_id"]),
+            agent_status: readString(data["agent_status"])
           },
           event
-        );
-        results.push(subStopEvt);
-        break;
-      }
-      case "notification": {
-        results.push(...ensureRunArray(event));
-        const notificationType = readString(d["notification_type"]);
-        const message = readString(d["message"]) ?? "";
-        const title = readString(d["title"]);
-        const reviewRoute = (data, runtimeEvent, ctx) => {
-          const item = readObject(data["item"]);
-          return [
+        )
+      );
+      return results;
+    }
+  };
+}
+
+// src/core/feed/internals/fileConfigProjection.ts
+function createFileConfigProjection(args) {
+  const { ensureRunArray, makeEvent } = args;
+  function collapsed(event) {
+    event.ui = { collapsed_default: true };
+    return event;
+  }
+  return {
+    mapFileConfigEvent(event, data) {
+      const results = ensureRunArray(event);
+      if (event.kind === "compact.pre") {
+        results.push(
+          collapsed(
             makeEvent(
-              "review.status",
+              "compact.pre",
               "info",
               "system",
               {
-                message: ctx.message,
-                phase: ctx.notificationType.endsWith(".completed") ? "completed" : "started",
-                review: readString(item["review"]),
-                item_id: readString(data["item_id"])
+                trigger: readString(data["trigger"]) ?? "auto",
+                custom_instructions: readString(data["custom_instructions"])
               },
-              runtimeEvent
+              event
             )
-          ];
-        };
-        const imageViewRoute = (data, runtimeEvent, ctx) => {
-          const item = readObject(data["item"]);
-          return [
+          )
+        );
+        return results;
+      }
+      if (event.kind === "setup") {
+        results.push(
+          collapsed(
             makeEvent(
-              "image.view",
+              "setup",
               "info",
               "system",
               {
-                message: ctx.message,
-                path: readString(item["path"]),
-                item_id: readString(data["item_id"])
+                trigger: readString(data["trigger"]) ?? "init"
               },
-              runtimeEvent
+              event
             )
-          ];
-        };
-        const contextCompactionRoute = (data, runtimeEvent, ctx) => [
+          )
+        );
+        return results;
+      }
+      if (event.kind === "config.change") {
+        results.push(
           makeEvent(
-            "context.compaction",
+            "config.change",
             "info",
             "system",
             {
-              message: ctx.message,
-              phase: ctx.notificationType.endsWith(".completed") ? "completed" : "started",
-              item_id: readString(data["item_id"])
+              source: readString(data["source"]) ?? "unknown",
+              file_path: readString(data["file_path"])
             },
-            runtimeEvent
+            event
           )
-        ];
-        const NOTIFICATION_ROUTES = {
-          "codex.error": (data, runtimeEvent, ctx) => [
-            makeEvent(
-              "runtime.error",
-              "error",
-              "system",
-              {
-                message: ctx.message,
-                title: ctx.title,
-                thread_id: readString(data["thread_id"]),
-                turn_id: readString(data["turn_id"]),
-                error_code: readString(data["error_code"]),
-                will_retry: readBoolean(data["will_retry"])
-              },
-              runtimeEvent
-            )
-          ],
-          "thread.status_changed": (data, runtimeEvent, ctx) => [
-            makeEvent(
-              "thread.status",
-              "info",
-              "system",
-              {
-                message: ctx.message,
-                thread_id: readString(data["thread_id"]),
-                status_type: readString(data["status_type"]),
-                active_flags: Array.isArray(data["active_flags"]) ? data["active_flags"] : void 0
-              },
-              runtimeEvent
-            )
-          ],
-          "turn.diff_updated": (data, runtimeEvent, ctx) => [
-            makeEvent(
-              "turn.diff",
-              "info",
-              "system",
-              {
-                message: ctx.message,
-                thread_id: readString(data["thread_id"]),
-                turn_id: readString(data["turn_id"]),
-                diff: readString(data["diff"]) ?? ""
-              },
-              runtimeEvent
-            )
-          ],
-          "server_request.resolved": (data, runtimeEvent, ctx) => {
-            const requestId = data["request_id"] !== void 0 ? String(data["request_id"]) : void 0;
-            const resolved = requestId ? decisionCorrelation.lookupResolved(requestId) : null;
-            return [
-              makeEvent(
-                "server.request.resolved",
-                "info",
-                "system",
-                {
-                  message: ctx.message,
-                  request_id: requestId,
-                  resolved_kind: resolved?.kind
-                },
-                runtimeEvent,
-                resolved ? { parent_event_id: resolved.event_id } : void 0
-              )
-            ];
-          },
-          "item.enteredReviewMode.started": reviewRoute,
-          "item.enteredReviewMode.completed": reviewRoute,
-          "item.exitedReviewMode.started": reviewRoute,
-          "item.exitedReviewMode.completed": reviewRoute,
-          "item.imageView.started": imageViewRoute,
-          "item.imageView.completed": imageViewRoute,
-          "item.contextCompaction.started": contextCompactionRoute,
-          "item.contextCompaction.completed": contextCompactionRoute,
-          "mcp_tool_call.progress": (_data, runtimeEvent, ctx) => [
+        );
+        return results;
+      }
+      if (event.kind === "compact.post") {
+        results.push(
+          collapsed(
             makeEvent(
-              "mcp.progress",
+              "compact.post",
               "info",
               "system",
               {
-                message: ctx.message,
-                title: ctx.title
+                trigger: readString(data["trigger"]) ?? "auto"
               },
-              runtimeEvent
+              event
             )
-          ],
-          "command_execution.terminal_interaction": (_data, runtimeEvent, ctx) => [
+          )
+        );
+        return results;
+      }
+      if (event.kind === "cwd.changed") {
+        results.push(
+          collapsed(
             makeEvent(
-              "terminal.input",
+              "cwd.changed",
               "info",
               "system",
               {
-                message: ctx.message,
-                input_preview: ctx.message
+                cwd: readString(data["cwd"]) ?? ""
               },
-              runtimeEvent
+              event
             )
-          ],
-          "skills.changed": (_data, runtimeEvent, ctx) => [
+          )
+        );
+        return results;
+      }
+      if (event.kind === "file.changed") {
+        results.push(
+          collapsed(
             makeEvent(
-              "skills.changed",
+              "file.changed",
               "info",
               "system",
               {
-                message: ctx.message
+                file_path: readString(data["file_path"]) ?? ""
               },
-              runtimeEvent
+              event
             )
-          ],
-          "skills.loaded": (_data, runtimeEvent, ctx) => {
-            const payload = typeof runtimeEvent.payload === "object" && runtimeEvent.payload !== null ? runtimeEvent.payload : null;
-            return [
-              makeEvent(
-                "skills.loaded",
-                "info",
-                "system",
-                {
-                  message: ctx.message,
-                  count: typeof payload?.["count"] === "number" ? payload["count"] : void 0,
-                  error_count: typeof payload?.["error_count"] === "number" ? payload["error_count"] : void 0
-                },
-                runtimeEvent
-              )
-            ];
-          }
-        };
-        const route = notificationType ? NOTIFICATION_ROUTES[notificationType] : void 0;
-        if (route && notificationType) {
+          )
+        );
+        return results;
+      }
+      return results;
+    }
+  };
+}
+
+// src/core/feed/internals/runSessionProjection.ts
+function mapPlanStepStatus(status) {
+  switch (status) {
+    case "inProgress":
+      return "in_progress";
+    case "completed":
+      return "completed";
+    case void 0:
+    default:
+      return "pending";
+  }
+}
+function createRunSessionProjection(args) {
+  const {
+    ensureRunArray,
+    makeEvent,
+    closeRunIntoEvent,
+    runLifecycle,
+    agentMessageStream,
+    rootPlan,
+    resolveToolActor,
+    currentScope
+  } = args;
+  return {
+    mapRunSessionEvent(event, data) {
+      const results = [];
+      if (event.kind === "session.start") {
+        agentMessageStream.clearPending();
+        const source = readString(data["source"]) ?? "startup";
+        runLifecycle.setSession({
+          session_id: event.sessionId,
+          started_at: event.timestamp,
+          source,
+          agent_type: readString(data["agent_type"])
+        });
+        if (source === "resume" || source === "clear" || source === "compact") {
           results.push(
-            ...route(d, event, {
-              notificationType,
-              message,
-              title
-            })
+            ...ensureRunArray(event, source)
           );
-          break;
         }
         results.push(
           makeEvent(
-            "notification",
+            "session.start",
             "info",
             "system",
             {
-              message,
-              title,
-              notification_type: notificationType
+              source,
+              agent_type: readString(data["agent_type"]),
+              model: readString(data["model"])
             },
             event
           )
         );
-        break;
-      }
-      case "compact.pre": {
-        results.push(...ensureRunArray(event));
-        const compactEvt = makeEvent(
-          "compact.pre",
-          "info",
-          "system",
-          {
-            trigger: readString(d["trigger"]) ?? "auto",
-            custom_instructions: readString(d["custom_instructions"])
-          },
-          event
-        );
-        compactEvt.ui = { collapsed_default: true };
-        results.push(compactEvt);
-        break;
+        return results;
       }
-      case "setup": {
-        results.push(...ensureRunArray(event));
-        const setupEvt = makeEvent(
-          "setup",
-          "info",
-          "system",
-          {
-            trigger: readString(d["trigger"]) ?? "init"
-          },
-          event
+      if (event.kind === "session.end") {
+        agentMessageStream.clearPending();
+        const closeEvt = closeRunIntoEvent(event, "completed");
+        if (closeEvt) results.push(closeEvt);
+        results.push(
+          makeEvent(
+            "session.end",
+            "info",
+            "system",
+            {
+              reason: readString(data["reason"]) ?? "unknown"
+            },
+            event
+          )
         );
-        setupEvt.ui = { collapsed_default: true };
-        results.push(setupEvt);
-        break;
+        runLifecycle.endSession(event.timestamp);
+        return results;
       }
-      case "teammate.idle": {
-        results.push(...ensureRunArray(event));
-        const idleEvt = makeEvent(
-          "teammate.idle",
-          "info",
-          "system",
-          {
-            teammate_name: readString(d["teammate_name"]) ?? "",
-            team_name: readString(d["team_name"]) ?? ""
-          },
-          event
+      if (event.kind === "user.prompt") {
+        const prompt = readString(data["prompt"]) ?? "";
+        results.push(
+          ...ensureRunArray(event, "user_prompt_submit", prompt.slice(0, 80))
         );
-        idleEvt.ui = { collapsed_default: true };
-        results.push(idleEvt);
-        break;
-      }
-      case "task.completed": {
-        results.push(...ensureRunArray(event));
         results.push(
           makeEvent(
-            "task.completed",
+            "user.prompt",
             "info",
-            "system",
+            "user",
             {
-              task_id: readString(d["task_id"]) ?? "",
-              task_subject: readString(d["task_subject"]) ?? "",
-              task_description: readString(d["task_description"]),
-              teammate_name: readString(d["teammate_name"]),
-              team_name: readString(d["team_name"])
+              prompt,
+              cwd: event.context.cwd,
+              permission_mode: event.context.permissionMode ?? readString(data["permission_mode"])
             },
             event
           )
         );
-        break;
+        return results;
+      }
+      if (event.kind === "turn.start") {
+        agentMessageStream.clearPending();
+        const prompt = readString(data["prompt"]);
+        results.push(
+          ...ensureRunArray(
+            event,
+            prompt ? "user_prompt_submit" : "other",
+            prompt?.slice(0, 80)
+          )
+        );
+        if (prompt) {
+          results.push(
+            makeEvent(
+              "user.prompt",
+              "info",
+              "user",
+              {
+                prompt,
+                cwd: event.context.cwd,
+                permission_mode: event.context.permissionMode
+              },
+              event
+            )
+          );
+        }
+        return results;
+      }
+      if (event.kind === "message.delta") {
+        agentMessageStream.appendPendingDelta(
+          readString(data["item_id"]),
+          readString(data["delta"]) ?? "",
+          resolveToolActor(),
+          currentScope()
+        );
+        return results;
+      }
+      if (event.kind === "message.complete") {
+        results.push(...ensureRunArray(event));
+        const ev = agentMessageStream.emitCompleted({
+          itemId: readString(data["item_id"]),
+          messageText: readString(data["message"]),
+          fallbackActorId: resolveToolActor(),
+          fallbackScope: currentScope(),
+          runtimeEvent: event
+        });
+        if (ev) results.push(ev);
+        return results;
+      }
+      if (event.kind === "turn.complete") {
+        if (!runLifecycle.getCurrentRun()) {
+          agentMessageStream.clearPending();
+          return results;
+        }
+        const stopEvt = makeEvent(
+          "stop.request",
+          "info",
+          "agent:root",
+          {
+            stop_hook_active: false
+          },
+          event
+        );
+        results.push(stopEvt);
+        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);
+        return results;
       }
-      case "config.change": {
-        results.push(...ensureRunArray(event));
+      if (event.kind === "plan.delta") {
+        const planSteps = data["plan"];
+        if (Array.isArray(planSteps) && planSteps.length > 0) {
+          const next = 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",
+                "info",
+                "system",
+                {
+                  todo_id: "plan",
+                  patch: { status: "doing" }
+                },
+                event
+              )
+            );
+          }
+        }
         results.push(
           makeEvent(
-            "config.change",
+            "plan.update",
             "info",
             "system",
             {
-              source: readString(d["source"]) ?? "unknown",
-              file_path: readString(d["file_path"])
+              explanation: readString(data["explanation"]) ?? null,
+              delta: readString(data["delta"]),
+              item_id: readString(data["item_id"]),
+              thread_id: readString(data["thread_id"]),
+              turn_id: readString(data["turn_id"]),
+              plan: Array.isArray(planSteps) ? planSteps : void 0
             },
             event
           )
         );
-        break;
+        return results;
       }
-      case "compact.post": {
-        results.push(...ensureRunArray(event));
-        const evt = makeEvent(
-          "compact.post",
-          "info",
-          "system",
-          {
-            trigger: readString(d["trigger"]) ?? "auto"
-          },
-          event
-        );
-        evt.ui = { collapsed_default: true };
-        results.push(evt);
-        break;
+      if (event.kind === "reasoning.delta") {
+        if (readString(data["phase"]) === "summary" && readString(data["delta"])) {
+          const summaryIndex = (() => {
+            const value = data["summary_index"] ?? data["content_index"];
+            return typeof value === "number" ? value : void 0;
+          })();
+          results.push(
+            makeEvent(
+              "reasoning.summary",
+              "info",
+              "agent:root",
+              {
+                message: agentMessageStream.appendReasoningSummary(
+                  readString(data["item_id"]),
+                  summaryIndex,
+                  readString(data["delta"]) ?? ""
+                ),
+                item_id: readString(data["item_id"]),
+                content_index: typeof data["content_index"] === "number" ? data["content_index"] : void 0,
+                summary_index: typeof data["summary_index"] === "number" ? data["summary_index"] : summaryIndex,
+                thread_id: readString(data["thread_id"]),
+                turn_id: readString(data["turn_id"])
+              },
+              event
+            )
+          );
+        }
+        return results;
       }
-      case "task.created": {
-        results.push(...ensureRunArray(event));
+      if (event.kind === "usage.update") {
         results.push(
           makeEvent(
-            "task.created",
+            "usage.update",
             "info",
             "system",
             {
-              task_id: readString(d["task_id"]) ?? "",
-              task_subject: readString(d["task_subject"]) ?? "",
-              task_description: readString(d["task_description"]),
-              teammate_name: readString(d["teammate_name"]),
-              team_name: readString(d["team_name"])
+              thread_id: readString(data["thread_id"]),
+              turn_id: readString(data["turn_id"]),
+              usage: typeof data["usage"] === "object" && data["usage"] !== null ? data["usage"] : void 0,
+              delta: typeof data["delta"] === "object" && data["delta"] !== null ? data["delta"] : void 0
             },
             event
           )
         );
-        break;
-      }
-      case "cwd.changed": {
-        results.push(...ensureRunArray(event));
-        const evt = makeEvent(
-          "cwd.changed",
-          "info",
-          "system",
-          {
-            cwd: readString(d["cwd"]) ?? ""
-          },
-          event
-        );
-        evt.ui = { collapsed_default: true };
-        results.push(evt);
-        break;
       }
-      case "file.changed": {
-        results.push(...ensureRunArray(event));
-        const evt = makeEvent(
-          "file.changed",
+      return results;
+    }
+  };
+}
+
+// src/core/feed/internals/statusProjection.ts
+function createStatusProjection(args) {
+  const { ensureRunArray, makeEvent } = args;
+  return {
+    mapStatusEvent(event, data) {
+      const results = ensureRunArray(event);
+      if (event.kind === "teammate.idle") {
+        const idleEvt = makeEvent(
+          "teammate.idle",
           "info",
           "system",
           {
-            file_path: readString(d["file_path"]) ?? ""
+            teammate_name: readString(data["teammate_name"]) ?? "",
+            team_name: readString(data["team_name"]) ?? ""
           },
           event
         );
-        evt.ui = { collapsed_default: true };
-        results.push(evt);
-        break;
-      }
-      case "stop.failure": {
-        results.push(...ensureRunArray(event));
-        results.push(
-          makeEvent(
-            "stop.failure",
-            "error",
-            "system",
-            {
-              error_type: readString(d["error_type"]) ?? "unknown",
-              error_message: readString(d["error_message"])
-            },
-            event
-          )
-        );
-        break;
+        idleEvt.ui = { collapsed_default: true };
+        results.push(idleEvt);
+        return results;
       }
-      case "permission.denied": {
-        results.push(...ensureRunArray(event));
+      if (event.kind === "task.created") {
         results.push(
           makeEvent(
-            "permission.denied",
-            "warn",
+            "task.created",
+            "info",
             "system",
             {
-              tool_name: event.toolName ?? readString(d["tool_name"]) ?? "Unknown",
-              tool_input: readObject(d["tool_input"]),
-              tool_use_id: readString(d["tool_use_id"]),
-              reason: readString(d["reason"])
+              task_id: readString(data["task_id"]) ?? "",
+              task_subject: readString(data["task_subject"]) ?? "",
+              task_description: readString(data["task_description"]),
+              teammate_name: readString(data["teammate_name"]),
+              team_name: readString(data["team_name"])
             },
             event
           )
         );
-        break;
+        return results;
       }
-      case "elicitation.request": {
-        results.push(...ensureRunArray(event));
+      if (event.kind === "task.completed") {
         results.push(
           makeEvent(
-            "elicitation.request",
-            "warn",
+            "task.completed",
+            "info",
             "system",
             {
-              mcp_server: readString(d["mcp_server"]) ?? "unknown",
-              form: d["form"]
+              task_id: readString(data["task_id"]) ?? "",
+              task_subject: readString(data["task_subject"]) ?? "",
+              task_description: readString(data["task_description"]),
+              teammate_name: readString(data["teammate_name"]),
+              team_name: readString(data["team_name"])
             },
             event
           )
         );
-        break;
-      }
-      case "elicitation.result": {
-        results.push(...ensureRunArray(event));
-        const action = readString(d["action"]);
-        const evt = makeEvent(
-          "elicitation.result",
-          "info",
-          "system",
-          {
-            mcp_server: readString(d["mcp_server"]) ?? "unknown",
-            ...action ? { action } : {},
-            content: readObject(d["content"])
-          },
-          event
-        );
-        evt.ui = { collapsed_default: true };
-        results.push(evt);
-        break;
       }
-      case "unknown": {
-        results.push(...ensureRunArray(event));
-        const unknownEvt = makeEvent(
-          "unknown.hook",
-          "debug",
-          "system",
-          {
-            hook_event_name: readString(
-              d["source_event_name"],
-              d["hook_event_name"],
-              event.hookName
-            ) ?? "unknown",
-            payload: d.payload ?? null
-          },
-          event
+      return results;
+    }
+  };
+}
+
+// src/core/feed/mapper.ts
+var RUN_SESSION_EVENT_KINDS = /* @__PURE__ */ new Set([
+  "session.start",
+  "session.end",
+  "user.prompt",
+  "turn.start",
+  "message.delta",
+  "message.complete",
+  "turn.complete",
+  "plan.delta",
+  "reasoning.delta",
+  "usage.update"
+]);
+var TOOL_EVENT_KINDS = /* @__PURE__ */ new Set([
+  "tool.delta",
+  "tool.pre",
+  "tool.post",
+  "tool.failure"
+]);
+var DECISION_EVENT_KINDS = /* @__PURE__ */ new Set([
+  "permission.request",
+  "stop.request",
+  "stop.failure",
+  "permission.denied",
+  "elicitation.request",
+  "elicitation.result"
+]);
+var SUBAGENT_EVENT_KINDS = /* @__PURE__ */ new Set([
+  "subagent.start",
+  "subagent.stop"
+]);
+var FILE_CONFIG_EVENT_KINDS = /* @__PURE__ */ new Set([
+  "compact.pre",
+  "setup",
+  "config.change",
+  "compact.post",
+  "cwd.changed",
+  "file.changed"
+]);
+var STATUS_EVENT_KINDS = /* @__PURE__ */ new Set([
+  "teammate.idle",
+  "task.completed",
+  "task.created"
+]);
+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 = runLifecycle.allocateSeq();
+    const runId = runLifecycle.getRunId();
+    const eventId = `${runId}:E${s}`;
+    const baseCause = {
+      hook_request_id: runtimeEvent.id,
+      transcript_path: runtimeEvent.context.transcriptPath,
+      ...cause
+    };
+    const fe = {
+      event_id: eventId,
+      seq: s,
+      ts: runtimeEvent.timestamp,
+      session_id: runtimeEvent.sessionId,
+      run_id: runId,
+      kind,
+      level,
+      actor_id: actorId,
+      cause: baseCause,
+      title: "",
+      display: runtimeEvent.display,
+      raw: runtimeEvent.payload,
+      data
+    };
+    fe.title = composeTitle(fe, runtimeEvent);
+    if (runtimeEvent.interaction.expectsDecision || kind === "permission.request" || kind === "stop.request") {
+      decisionCorrelation.recordRequest(runtimeEvent.id, eventId, kind);
+    }
+    return fe;
+  }
+  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)
         );
-        unknownEvt.ui = { collapsed_default: true };
-        results.push(unknownEvt);
-        break;
       }
     }
+  }
+  function closeRunIntoEvent(runtimeEvent, status) {
+    const closed = runLifecycle.closeRun(runtimeEvent.timestamp, status);
+    if (!closed) return null;
+    return makeEvent(
+      "run.end",
+      "info",
+      "system",
+      { status, counters: { ...closed.counters } },
+      runtimeEvent
+    );
+  }
+  function ensureRunArray(runtimeEvent, triggerType = "other", promptPreview) {
+    if (runLifecycle.getCurrentRun() && triggerType === "other") return [];
+    const results = [];
+    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",
+        "info",
+        "system",
+        { trigger: { type: triggerType, prompt_preview: promptPreview } },
+        runtimeEvent
+      )
+    );
+    return results;
+  }
+  function resolveToolActor() {
+    return subagents.peek() ?? "agent:root";
+  }
+  const toolProjection = createToolProjection({
+    ensureRunArray,
+    makeEvent,
+    runLifecycle,
+    toolCorrelation,
+    rootPlan,
+    subagents,
+    resolveToolActor
+  });
+  const notificationProjection = createNotificationProjection({
+    ensureRunArray,
+    makeEvent,
+    decisionCorrelation
+  });
+  const decisionProjection = createDecisionProjection({
+    ensureRunArray,
+    makeEvent,
+    runLifecycle,
+    decisionCorrelation
+  });
+  const subagentProjection = createSubagentProjection({
+    ensureRunArray,
+    makeEvent,
+    runLifecycle,
+    actors,
+    subagents
+  });
+  const fileConfigProjection = createFileConfigProjection({
+    ensureRunArray,
+    makeEvent
+  });
+  const statusProjection = createStatusProjection({
+    ensureRunArray,
+    makeEvent
+  });
+  const currentScope = () => subagents.currentScope();
+  const runSessionProjection = createRunSessionProjection({
+    ensureRunArray,
+    makeEvent,
+    closeRunIntoEvent,
+    runLifecycle,
+    agentMessageStream,
+    rootPlan,
+    resolveToolActor,
+    currentScope
+  });
+  function mapEvent(event) {
+    const d = event.data;
+    const eventKind2 = event.kind;
+    const results = [];
+    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 ev = agentMessageStream.emit({
+        runtimeEvent: event,
+        actorId,
+        scope,
+        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) {
+      results.push(
+        ...agentMessageStream.emitTranscriptMessages(
+          transcriptPath,
+          event,
+          resolveToolActor(),
+          currentScope()
+        )
+      );
+    }
+    if (RUN_SESSION_EVENT_KINDS.has(eventKind2)) {
+      results.push(...runSessionProjection.mapRunSessionEvent(event, d));
+    } else if (TOOL_EVENT_KINDS.has(eventKind2)) {
+      results.push(...toolProjection.mapToolEvent(event, d));
+    } else if (DECISION_EVENT_KINDS.has(eventKind2)) {
+      results.push(...decisionProjection.mapRequestEvent(event, d));
+    } else if (SUBAGENT_EVENT_KINDS.has(eventKind2)) {
+      results.push(...subagentProjection.mapSubagentEvent(event, d));
+    } else if (eventKind2 === "notification") {
+      results.push(...notificationProjection.mapNotification(event, d));
+    } else if (FILE_CONFIG_EVENT_KINDS.has(eventKind2)) {
+      results.push(...fileConfigProjection.mapFileConfigEvent(event, d));
+    } else if (STATUS_EVENT_KINDS.has(eventKind2)) {
+      results.push(...statusProjection.mapStatusEvent(event, d));
+    } else if (eventKind2 === "unknown") {
+      results.push(...ensureRunArray(event));
+      const unknownEvt = makeEvent(
+        "unknown.hook",
+        "debug",
+        "system",
+        {
+          hook_event_name: readString(
+            d["source_event_name"],
+            d["hook_event_name"],
+            event.hookName
+          ) ?? "unknown",
+          payload: d.payload ?? null
+        },
+        event
+      );
+      unknownEvt.ui = { collapsed_default: true };
+      results.push(unknownEvt);
+    }
     if (eventKind2 === "stop.request") {
       if (transcriptPath) agentMessageStream.drainTranscript(transcriptPath);
       emitFallbackMessage("stop.request", "agent:root", "root");
@@ -9268,74 +9518,7 @@ function createFeedMapper(bootstrap) {
     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 decisionProjection.mapDecision(requestId, decision);
   }
   return {
     mapEvent,
@@ -11231,17 +11414,52 @@ function createDashboardFeedOutbox(options = {}) {
     }
   };
 }
-function createDashboardFeedPublisher(options = {}) {
+
+// src/app/dashboard/pairedFeedPublisher.ts
+var DEFAULT_DRAIN_INTERVAL_MS = 1e3;
+function createPairedFeedPublisher(options = {}) {
   const readConfig2 = options.readConfig ?? (() => readDashboardClientConfig());
   const now = options.now ?? (() => Date.now());
   const onError = options.onError ?? (() => {
   });
+  const drainIntervalMs = options.drainIntervalMs ?? DEFAULT_DRAIN_INTERVAL_MS;
   let ownedOutbox = null;
+  let transport = null;
+  let drainTimer = null;
   function getOutbox() {
     if (options.outbox) return options.outbox;
     ownedOutbox ??= createDashboardFeedOutbox();
     return ownedOutbox;
   }
+  function clearDrainTimer() {
+    if (!drainTimer) return;
+    clearInterval(drainTimer);
+    drainTimer = null;
+  }
+  function drain(force = false) {
+    if (!transport) return;
+    const rows = getOutbox().pendingBatch({
+      limit: 100,
+      now: force ? Number.POSITIVE_INFINITY : now()
+    });
+    for (const row of rows) {
+      transport.sendFeedEvent({
+        deliverySeq: row.deliverySeq,
+        envelope: row.envelope
+      });
+      getOutbox().markAttempted({
+        deliverySeq: row.deliverySeq,
+        nextAttemptAt: now() + Math.min(3e4, (row.attempt + 1) * 1e3)
+      });
+    }
+  }
+  function startDrainTimer() {
+    clearDrainTimer();
+    const timer = setInterval(drain, drainIntervalMs);
+    timer.unref();
+    drainTimer = timer;
+    drain(true);
+  }
   return {
     publish(input) {
       if (input.feedEvents.length === 0) return;
@@ -11255,11 +11473,30 @@ function createDashboardFeedPublisher(options = {}) {
           feedEvents: input.feedEvents,
           emittedAt: now()
         });
+        drain();
       } catch (err) {
         onError(
-          `dashboard feed publish failed: ${err instanceof Error ? err.message : String(err)}`
+          `paired feed publish failed: ${err instanceof Error ? err.message : String(err)}`
         );
       }
+    },
+    attachTransport(nextTransport) {
+      transport = nextTransport;
+      startDrainTimer();
+    },
+    detachTransport() {
+      transport = null;
+      clearDrainTimer();
+    },
+    handleAck(frame) {
+      getOutbox().markAcked({
+        ...typeof frame.deliverySeq === "number" ? { deliverySeq: frame.deliverySeq } : {},
+        ...typeof frame.eventId === "string" ? { eventId: frame.eventId } : {}
+      });
+    },
+    close() {
+      this.detachTransport();
+      ownedOutbox?.close();
     }
   };
 }
@@ -11412,7 +11649,7 @@ async function runExec(options) {
   const runtimeFactory = options.runtimeFactory ?? createRuntime;
   const sessionStoreFactory = options.sessionStoreFactory ?? createSessionStore;
   const athenaSessionId = options.athenaSessionId ?? crypto2.randomUUID();
-  const dashboardFeedPublisher = options.dashboardFeedPublisher ?? createDashboardFeedPublisher();
+  const dashboardFeedPublisher = options.dashboardFeedPublisher ?? createPairedFeedPublisher();
   const dashboardOrigin = options.dashboardOrigin ?? "local";
   const output = createExecOutputWriter({
     json,
@@ -11781,6 +12018,207 @@ async function runExec(options) {
   return result;
 }
 
+// src/app/dashboard/instanceSocketClient.ts
+import { WebSocket as WebSocket2 } from "ws";
+var DEFAULT_HEARTBEAT_MS = 3e4;
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+function instanceSocketUrl(dashboardUrl, instanceId) {
+  const url = new URL(dashboardUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = `/api/instances/${encodeURIComponent(instanceId)}/socket`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+function createInstanceSocketClient(opts) {
+  const heartbeatMs = opts.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS;
+  const connectTimeoutMs = opts.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+  const log = opts.log ?? (() => {
+  });
+  const now = opts.now ?? (() => Date.now());
+  const makeWebSocket = opts.makeWebSocket ?? ((url, accessToken) => new WebSocket2(url, [accessToken]));
+  const frameHandlers = /* @__PURE__ */ new Set();
+  const closeHandlers = /* @__PURE__ */ new Set();
+  let ws = null;
+  let heartbeat = null;
+  let droppedSinceClose = 0;
+  function send(frame) {
+    if (!ws || ws.readyState !== ws.OPEN) {
+      droppedSinceClose += 1;
+      if (droppedSinceClose === 1) {
+        log(
+          "warn",
+          `instance socket dropped frame (socket not open): type=${frame.type}`
+        );
+      }
+      return;
+    }
+    droppedSinceClose = 0;
+    try {
+      ws.send(JSON.stringify(frame));
+    } catch (err) {
+      log(
+        "warn",
+        `instance socket send failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  function startHeartbeat() {
+    stopHeartbeat();
+    const interval = setInterval(() => {
+      send({ type: "ping", ts: now() });
+    }, heartbeatMs);
+    interval.unref();
+    heartbeat = interval;
+  }
+  function stopHeartbeat() {
+    if (heartbeat) {
+      clearInterval(heartbeat);
+      heartbeat = null;
+    }
+  }
+  function emitClose(reason) {
+    stopHeartbeat();
+    for (const handler of [...closeHandlers]) {
+      try {
+        handler(reason);
+      } catch {
+      }
+    }
+  }
+  function handleFrame(parsed) {
+    for (const handler of [...frameHandlers]) {
+      try {
+        handler(parsed);
+      } catch (err) {
+        log(
+          "warn",
+          `instance socket frame handler threw: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  async function connect2() {
+    if (ws) throw new Error("instance socket already connected");
+    const url = instanceSocketUrl(opts.dashboardUrl, opts.instanceId);
+    const next = makeWebSocket(url, opts.accessToken);
+    try {
+      await new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+          next.off("open", onOpen);
+          next.off("error", onError);
+          clearTimeout(timer);
+        };
+        const onOpen = () => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve();
+        };
+        const onError = (err) => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(new Error(`instance socket connect failed: ${err.message}`));
+        };
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(
+            new Error(
+              `instance socket connect failed: timed out after ${connectTimeoutMs}ms`
+            )
+          );
+        }, connectTimeoutMs);
+        next.once("open", onOpen);
+        next.once("error", onError);
+      });
+    } catch (err) {
+      next.on("error", () => {
+      });
+      try {
+        next.terminate();
+      } catch {
+      }
+      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 sendAssignmentAccepted(runId) {
+    send({ type: "assignment_accepted", runId });
+    log("info", `instance socket: assignment accepted runId=${runId}`);
+  }
+  function sendAssignmentRejected(input) {
+    send({ type: "assignment_rejected", ...input });
+    log(
+      "info",
+      `instance socket: assignment rejected runId=${input.runId} reason=${input.reason}`
+    );
+  }
+  function sendRunEvent(event) {
+    send({ type: "run_event", ...event });
+  }
+  function sendFeedEvent(event) {
+    send({ type: "feed_event", ...event });
+  }
+  function sendDecisionAck(input) {
+    send({ type: "decision_ack", ...input });
+  }
+  return {
+    connect: connect2,
+    close,
+    onFrame,
+    onClose,
+    sendAssignmentAccepted,
+    sendAssignmentRejected,
+    sendRunEvent,
+    sendFeedEvent,
+    sendDecisionAck
+  };
+}
+
 // src/app/bootstrap/harnessOverride.ts
 function normalizeHarnessOverride(value) {
   switch (value) {
@@ -11798,9 +12236,9 @@ function normalizeHarnessOverride(value) {
 }
 
 // src/app/dashboard/runStreamClient.ts
-import { WebSocket as WebSocket2 } from "ws";
+import { WebSocket as WebSocket3 } from "ws";
 var DEFAULT_RECONNECT_DELAYS_MS = [250, 1e3, 2e3, 5e3, 15e3];
-var DEFAULT_HEARTBEAT_MS = 3e4;
+var DEFAULT_HEARTBEAT_MS2 = 3e4;
 var DEFAULT_WATCHDOG_MS = 9e4;
 var DEFAULT_MAX_QUEUE_SIZE = 5e3;
 function createRunStreamClient(opts) {
@@ -11808,10 +12246,10 @@ function createRunStreamClient(opts) {
   });
   const now = opts.now ?? (() => Date.now());
   const reconnectDelays = opts.reconnectDelaysMs ?? DEFAULT_RECONNECT_DELAYS_MS;
-  const heartbeatMs = opts.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_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 WebSocket2(url));
+  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;
@@ -12078,9 +12516,79 @@ function createRunStreamClient(opts) {
   };
 }
 
+// src/app/dashboard/remoteRunEventPublisher.ts
+async function createRemoteRunEventPublisher({
+  runId,
+  callbackWsUrl,
+  callbackToken,
+  client,
+  log = () => {
+  },
+  now = Date.now,
+  createRunStreamClient: createRunStreamClientFn = createRunStreamClient,
+  runStreamConnectTimeoutMs = 5e3
+}) {
+  let runStream = null;
+  if (callbackWsUrl && callbackToken) {
+    const candidate = createRunStreamClientFn({
+      wsUrl: callbackWsUrl,
+      token: callbackToken,
+      log: (level, message) => log(level, `run-stream[${runId}]: ${message}`),
+      now
+    });
+    const timeoutPromise = new Promise((resolve) => {
+      const timer = setTimeout(
+        () => resolve("timeout"),
+        runStreamConnectTimeoutMs
+      );
+      timer.unref();
+    });
+    try {
+      const result = await Promise.race([
+        candidate.connect().then(() => "connected"),
+        timeoutPromise
+      ]);
+      if (result === "connected") {
+        runStream = candidate;
+      } else {
+        log(
+          "warn",
+          `run-stream[${runId}]: connect timed out after ${runStreamConnectTimeoutMs}ms; falling back to instance-socket relay`
+        );
+        void candidate.close("connect_timeout");
+      }
+    } catch (err) {
+      log(
+        "warn",
+        `run-stream[${runId}]: connect failed (${err instanceof Error ? err.message : String(err)}); falling back to instance-socket relay`
+      );
+    }
+  }
+  let legacySeq = 0;
+  return {
+    publish(kind, payload, ts) {
+      if (runStream) {
+        runStream.sendEvent({ ts, kind, payload });
+        return;
+      }
+      legacySeq += 1;
+      client.sendRunEvent({ runId, seq: legacySeq, ts, kind, payload });
+    },
+    async close() {
+      if (!runStream) return;
+      const drainTimeout = new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(), 1e4);
+        timer.unref();
+      });
+      await Promise.race([runStream.whenTerminated(), drainTimeout]);
+      await runStream.close("done");
+    }
+  };
+}
+
 // src/app/dashboard/remoteRunExecutor.ts
 var DEFAULT_MARKETPLACE_SLUG = "lespaceman/athena-workflow-marketplace";
-function parseRunSpec(value) {
+function parseRemoteRunSpec(value) {
   if (typeof value !== "object" || value === null) return null;
   const obj = value;
   const prompt = obj["prompt"];
@@ -12112,6 +12620,9 @@ function parseRunSpec(value) {
     callbackToken: typeof callbackToken === "string" && callbackToken.length > 0 ? callbackToken : void 0
   };
 }
+function isRemoteAssignmentAdmissible(frame) {
+  return parseRemoteRunSpec(frame.runSpec) !== null;
+}
 function workflowNameFromRef(ref) {
   if (!ref) return void 0;
   const [name] = ref.split("@", 1);
@@ -12193,7 +12704,7 @@ function mergeRunSpecEnvIntoWorkflow(workflow, env) {
 async function executeRemoteAssignment({
   frame,
   client,
-  projectDir: fallbackProjectDir = process.cwd(),
+  projectDir,
   log = () => {
   },
   runExecFn = runExec,
@@ -12212,57 +12723,22 @@ async function executeRemoteAssignment({
   const deferredFailedCompletion = {
     current: 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 spec = parseRemoteRunSpec(frame.runSpec);
+  const runEventPublisher = await createRemoteRunEventPublisher({
+    runId: frame.runId,
+    callbackWsUrl: spec?.callbackWsUrl,
+    callbackToken: spec?.callbackToken,
+    client,
+    log,
+    now,
+    createRunStreamClient: createRunStreamClientFn,
+    runStreamConnectTimeoutMs
+  });
   const send = (kind, payload, ts = now()) => {
     if (kind === "error" && typeof payload === "object" && payload !== null && typeof payload.message === "string") {
-      lastTerminalFailureMessage.current = payload.message;
-    }
-    if (runStream) {
-      runStream.sendEvent({ ts, kind, payload });
-      return;
+      lastTerminalFailureMessage.current = payload.message;
     }
-    legacySeq += 1;
-    client.sendRunEvent({
-      runId: frame.runId,
-      seq: legacySeq,
-      ts,
-      kind,
-      payload
-    });
+    runEventPublisher.publish(kind, payload, ts);
   };
   send("progress", { message: "assignment received" });
   try {
@@ -12270,7 +12746,6 @@ async function executeRemoteAssignment({
       send("error", { message: "remote assignment missing prompt" });
       return;
     }
-    const projectDir = spec.projectDir ?? fallbackProjectDir;
     let runtimeConfig;
     try {
       const workflowOverride = ensureRemoteWorkflowInstalled({
@@ -12396,15 +12871,202 @@ async function executeRemoteAssignment({
       });
     }
   } 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");
+    await runEventPublisher.close();
+  }
+}
+
+// src/infra/config/attachmentMirror.ts
+import crypto3 from "crypto";
+import fs21 from "fs";
+import os12 from "os";
+import path19 from "path";
+function attachmentMirrorPath(env = process.env) {
+  const home = env["HOME"] ?? os12.homedir();
+  return path19.join(home, ".config", "athena", "attachments.json");
+}
+function readAttachmentMirror(env = process.env) {
+  const file = attachmentMirrorPath(env);
+  let raw;
+  try {
+    raw = fs21.readFileSync(file, "utf-8");
+  } catch (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 = path19.dirname(file);
+  fs21.mkdirSync(dir, { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.${crypto3.randomBytes(4).toString("hex")}.tmp`;
+  const fd = fs21.openSync(tmp, "w", 384);
+  try {
+    fs21.writeSync(fd, JSON.stringify(validated, null, 2) + "\n");
+    fs21.fsyncSync(fd);
+  } finally {
+    fs21.closeSync(fd);
+  }
+  try {
+    fs21.renameSync(tmp, file);
+  } catch (err) {
+    try {
+      fs21.unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+  if (process.platform !== "win32") {
+    try {
+      fs21.chmodSync(dir, 448);
+      fs21.chmodSync(file, 384);
+    } catch {
+    }
+  }
+}
+function removeAttachmentMirror(env = process.env) {
+  const file = attachmentMirrorPath(env);
+  try {
+    fs21.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/attachmentReconciler.ts
+async function fetchDashboardAttachments({
+  dashboardUrl,
+  instanceId,
+  accessToken
+}) {
+  const url = new URL(dashboardUrl);
+  url.pathname = `/api/instances/${encodeURIComponent(instanceId)}/attachments`;
+  url.search = "";
+  url.hash = "";
+  const response = await fetch(url, {
+    headers: {
+      authorization: `Bearer ${accessToken}`,
+      accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(
+      `attachment reconciliation failed: ${response.status} ${response.statusText}`
+    );
+  }
+  const body = await response.json();
+  if (!Array.isArray(body.attachments)) {
+    throw new Error("attachment reconciliation failed: invalid response");
+  }
+  return normalizeAttachments(body.attachments);
+}
+function normalizeAttachments(raw) {
+  return raw.map((value, idx) => {
+    if (typeof value !== "object" || value === null) {
+      throw new Error(`attachments[${idx}] must be an object`);
+    }
+    const entry = value;
+    if (typeof entry["runnerId"] !== "string" || entry["runnerId"].length === 0) {
+      throw new Error(
+        `attachments[${idx}].runnerId must be a non-empty string`
+      );
     }
+    return {
+      runnerId: entry["runnerId"],
+      ...typeof entry["name"] === "string" ? { name: entry["name"] } : {},
+      ...typeof entry["executionTarget"] === "string" ? { executionTarget: entry["executionTarget"] } : {},
+      ...typeof entry["remoteInstanceId"] === "string" ? { remoteInstanceId: entry["remoteInstanceId"] } : {}
+    };
+  });
+}
+function createAttachmentReconciler(options) {
+  const fetchAttachments = options.fetchAttachments ?? fetchDashboardAttachments;
+  const now = options.now ?? (() => Date.now());
+  const currentInstances = /* @__PURE__ */ new Set();
+  let pushRevision = 0;
+  const latestPushByInstance = /* @__PURE__ */ new Map();
+  function write(instanceId, attachments) {
+    options.writeMirror({ instanceId, fetchedAt: now(), attachments });
   }
+  return {
+    async reconcileNow(input) {
+      const revisionAtStart = pushRevision;
+      const attachments = await fetchAttachments(input);
+      write(input.instanceId, attachments);
+      if (pushRevision !== revisionAtStart) {
+        const latestPush = latestPushByInstance.get(input.instanceId);
+        if (latestPush) write(input.instanceId, latestPush);
+      }
+      currentInstances.add(input.instanceId);
+    },
+    applyPush({ instanceId, attachments }) {
+      pushRevision += 1;
+      latestPushByInstance.set(instanceId, attachments);
+      write(instanceId, attachments);
+      currentInstances.add(instanceId);
+    },
+    isCurrent(instanceId) {
+      return currentInstances.has(instanceId);
+    },
+    markStale(instanceId) {
+      currentInstances.delete(instanceId);
+    }
+  };
 }
 
 // src/app/dashboard/dashboardDecisionInbox.ts
@@ -12557,29 +13219,15 @@ function createDashboardPairedExecution(options) {
       runHistory.shift();
     }
   }
-  function rejectAssignment(runId, reason) {
-    try {
-      client.sendRunEvent({
-        runId,
-        seq: 0,
-        ts: now(),
-        kind: "rejected",
-        payload: { reason }
-      });
-    } catch (err) {
-      log(
-        "warn",
-        `runtime daemon: failed to send rejected for ${runId}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
+  function rejectAssignment(runId, rejection) {
     recordRun({
       runId,
       startedAt: now(),
       endedAt: now(),
       status: "rejected",
-      error: reason
+      error: rejection.message
     });
-    log("warn", `run ${runId} rejected: ${reason}`);
+    log("warn", `run ${runId} rejected: ${rejection.message}`);
   }
   function handleDecision(frame) {
     decisionInbox.enqueue({
@@ -12599,22 +13247,24 @@ function createDashboardPairedExecution(options) {
     entry.record.status = "cancelled";
     entry.controller.abort();
   }
-  function handleAssignment(frame) {
+  function handleAssignment(frame, input = {}) {
     if (active.has(frame.runId)) {
-      rejectAssignment(
-        frame.runId,
-        `duplicate active assignment ${frame.runId}`
-      );
-      return;
+      const rejection = {
+        reason: "duplicate",
+        message: `duplicate active assignment ${frame.runId}`
+      };
+      rejectAssignment(frame.runId, rejection);
+      return { kind: "rejected", rejection };
     }
     const runnerKey = frame.runnerId;
     const bucket = activeByRunner.get(runnerKey) ?? /* @__PURE__ */ new Set();
     if (bucket.size >= maxConcurrentRuns) {
-      rejectAssignment(
-        frame.runId,
-        `runtime daemon at concurrency cap (${maxConcurrentRuns}) for runner ${runnerKey ?? "<legacy>"}`
-      );
-      return;
+      const rejection = {
+        reason: "local_capacity",
+        message: `runtime daemon at concurrency cap (${maxConcurrentRuns}) for runner ${runnerKey ?? "<legacy>"}`
+      };
+      rejectAssignment(frame.runId, rejection);
+      return { kind: "rejected", rejection };
     }
     const controller = new AbortController();
     const record = {
@@ -12628,7 +13278,7 @@ function createDashboardPairedExecution(options) {
     const promise = executor({
       frame,
       client,
-      projectDir,
+      projectDir: input.projectDir ?? projectDir,
       log,
       abortSignal: controller.signal,
       decisionInbox
@@ -12654,6 +13304,7 @@ function createDashboardPairedExecution(options) {
       }
     });
     active.set(frame.runId, { controller, promise, record, runnerKey });
+    return { kind: "accepted" };
   }
   return {
     handleFrame(frame) {
@@ -12671,6 +13322,10 @@ function createDashboardPairedExecution(options) {
       }
       return false;
     },
+    admitAssignment(frame, input) {
+      return handleAssignment(frame, input);
+    },
+    rejectAssignment,
     snapshot() {
       return {
         activeRuns: active.size,
@@ -12696,6 +13351,190 @@ function createDashboardPairedExecution(options) {
   };
 }
 
+// src/app/dashboard/remoteWorkspaceResolver.ts
+import fs22 from "fs";
+import os13 from "os";
+import path20 from "path";
+function resolveRemoteWorkspace(frame, options = {}) {
+  const spec = parseRemoteRunSpec(frame.runSpec);
+  if (!spec) {
+    return {
+      kind: "rejected",
+      rejection: {
+        reason: "workspace_unresolved",
+        message: "remote assignment missing prompt"
+      }
+    };
+  }
+  if (spec.projectDir) {
+    return validateProjectDir(spec.projectDir, options.env);
+  }
+  const sessionId = spec.athenaSessionId ?? spec.sessionId;
+  const runnerId = frame.runnerId ?? "legacy";
+  const deploymentSlug = deploymentSlugFromUrl(options.dashboardUrl);
+  const stateDir = daemonStatePaths(options.env).dir;
+  const projectDir = sessionId ? path20.join(
+    stateDir,
+    "remote-workspaces",
+    deploymentSlug,
+    sanitizePathSegment(runnerId),
+    "sessions",
+    sanitizePathSegment(sessionId)
+  ) : path20.join(
+    stateDir,
+    "remote-workspaces",
+    deploymentSlug,
+    sanitizePathSegment(runnerId),
+    "runs",
+    sanitizePathSegment(frame.runId)
+  );
+  try {
+    fs22.mkdirSync(projectDir, { recursive: true, mode: 448 });
+    if (process.platform !== "win32") {
+      try {
+        fs22.chmodSync(projectDir, 448);
+      } catch {
+      }
+    }
+  } catch (err) {
+    return {
+      kind: "rejected",
+      rejection: {
+        reason: "workspace_unresolved",
+        message: `failed to create remote workspace: ${err instanceof Error ? err.message : String(err)}`
+      }
+    };
+  }
+  return validateProjectDir(projectDir, options.env);
+}
+function validateProjectDir(projectDir, env = process.env) {
+  const resolved = path20.resolve(projectDir);
+  if (!path20.isAbsolute(projectDir)) {
+    return {
+      kind: "rejected",
+      rejection: {
+        reason: "workspace_invalid",
+        message: `remote workspace must be an absolute path: ${projectDir}`
+      }
+    };
+  }
+  const home = path20.resolve(env["HOME"] ?? os13.homedir());
+  if (resolved === home) {
+    return {
+      kind: "rejected",
+      rejection: {
+        reason: "workspace_invalid",
+        message: "remote workspace cannot be the user home directory"
+      }
+    };
+  }
+  let stat;
+  try {
+    stat = fs22.statSync(resolved);
+  } catch {
+    return {
+      kind: "rejected",
+      rejection: {
+        reason: "workspace_invalid",
+        message: `remote workspace does not exist: ${resolved}`
+      }
+    };
+  }
+  if (!stat.isDirectory()) {
+    return {
+      kind: "rejected",
+      rejection: {
+        reason: "workspace_invalid",
+        message: `remote workspace is not a directory: ${resolved}`
+      }
+    };
+  }
+  return { kind: "resolved", projectDir: resolved };
+}
+function deploymentSlugFromUrl(dashboardUrl) {
+  if (!dashboardUrl) return "unknown-dashboard";
+  try {
+    const url = new URL(dashboardUrl);
+    return sanitizePathSegment(url.host);
+  } catch {
+    return sanitizePathSegment(dashboardUrl);
+  }
+}
+function sanitizePathSegment(value) {
+  const cleaned = value.trim().replaceAll(/[^a-zA-Z0-9._-]+/g, "-").replaceAll(/^-+|-+$/g, "");
+  return cleaned.length > 0 ? cleaned : "unknown";
+}
+
+// src/app/dashboard/dashboardAssignmentIntake.ts
+function createDashboardAssignmentIntake(options) {
+  const log = options.log ?? (() => {
+  });
+  const resolveWorkspace = options.resolveWorkspace ?? ((frame) => resolveRemoteWorkspace(frame));
+  const pending = [];
+  let ready = false;
+  function handle(frame) {
+    if (!isRemoteAssignmentAdmissible(frame)) {
+      const rejection = {
+        reason: "malformed_assignment",
+        message: "remote assignment missing prompt"
+      };
+      options.execution.rejectAssignment(frame.runId, rejection);
+      options.client.sendAssignmentRejected({
+        runId: frame.runId,
+        ...rejection
+      });
+      return;
+    }
+    const workspace = resolveWorkspace(frame);
+    if (workspace.kind === "rejected") {
+      options.execution.rejectAssignment(frame.runId, workspace.rejection);
+      options.client.sendAssignmentRejected({
+        runId: frame.runId,
+        ...workspace.rejection
+      });
+      return;
+    }
+    const outcome = options.execution.admitAssignment(frame, {
+      projectDir: workspace.projectDir
+    });
+    if (outcome.kind === "accepted") {
+      options.client.sendAssignmentAccepted(frame.runId);
+      return;
+    }
+    options.client.sendAssignmentRejected({
+      runId: frame.runId,
+      ...outcome.rejection
+    });
+  }
+  function drain() {
+    if (!ready) return;
+    while (pending.length > 0) {
+      const frame = pending.shift();
+      if (frame) handle(frame);
+    }
+  }
+  return {
+    receive(frame) {
+      if (!ready) {
+        pending.push(frame);
+        log(
+          "debug",
+          `dashboard assignment buffered until attachments are current: runId=${frame.runId}`
+        );
+        return;
+      }
+      handle(frame);
+    },
+    markReady() {
+      ready = true;
+      drain();
+    },
+    markNotReady() {
+      ready = false;
+    }
+  };
+}
+
 // src/app/dashboard/runtimeDaemon.ts
 var DEFAULT_RECONNECT_DELAYS_MS2 = [1e3, 2e3, 5e3, 1e4, 3e4];
 var DEFAULT_MAX_CONCURRENT_RUNS2 = 1;
@@ -12704,7 +13543,6 @@ var DEFAULT_REFRESH_FAILURE_LIMIT = 5;
 var DEFAULT_REFRESH_FAILURE_WINDOW_MS = 5 * 6e4;
 var DEFAULT_REFRESH_COOLDOWN_MS = 5 * 6e4;
 var DEFAULT_RUN_HISTORY_LIMIT2 = 100;
-var DEFAULT_FEED_DRAIN_INTERVAL_MS = 1e3;
 function delay(ms) {
   return new Promise((resolve) => {
     const timer = setTimeout(resolve, ms);
@@ -12733,9 +13571,12 @@ async function runDashboardRuntimeDaemon(options = {}) {
   const runHistoryLimit = options.runHistoryLimit ?? DEFAULT_RUN_HISTORY_LIMIT2;
   const now = options.now ?? (() => Date.now());
   const writeMirror = options.writeMirror ?? writeAttachmentMirror;
-  const feedOutbox = options.feedOutbox ?? createDashboardFeedOutbox();
+  const pairedFeedPublisher = options.pairedFeedPublisher ?? createPairedFeedPublisher({
+    readConfig: readConfig2,
+    now,
+    drainIntervalMs: options.feedDrainIntervalMs
+  });
   const decisionInbox = options.decisionInbox ?? createDashboardDecisionInbox();
-  const feedDrainIntervalMs = options.feedDrainIntervalMs ?? DEFAULT_FEED_DRAIN_INTERVAL_MS;
   const retryInitialConnect = options.retryInitialConnect ?? true;
   const startedAt = now();
   let stopped = false;
@@ -12746,7 +13587,6 @@ async function runDashboardRuntimeDaemon(options = {}) {
   let currentDashboardUrl;
   let lastFrameAt;
   let refreshTimer = null;
-  let feedDrainTimer = null;
   const refreshFailures = [];
   let cooldownUntil = 0;
   const executionClient = {
@@ -12777,6 +13617,28 @@ async function runDashboardRuntimeDaemon(options = {}) {
     now,
     runHistoryLimit
   });
+  const attachmentReconciler = createAttachmentReconciler({
+    writeMirror,
+    ...options.fetchAttachments ? { fetchAttachments: options.fetchAttachments } : {},
+    now
+  });
+  const assignmentIntake = createDashboardAssignmentIntake({
+    client: {
+      sendAssignmentAccepted(runId) {
+        const current = client;
+        if (!current) return;
+        current.sendAssignmentAccepted(runId);
+      },
+      sendAssignmentRejected(input) {
+        const current = client;
+        if (!current) return;
+        current.sendAssignmentRejected(input);
+      }
+    },
+    execution: pairedExecution,
+    log,
+    resolveWorkspace: (frame) => resolveRemoteWorkspace(frame, { dashboardUrl: currentDashboardUrl })
+  });
   function nextReconnectDelay() {
     if (reconnectDelays.length === 0) return 0;
     const delayMs = reconnectDelays[Math.min(reconnectAttempt, reconnectDelays.length - 1)] ?? 0;
@@ -12789,35 +13651,6 @@ async function runDashboardRuntimeDaemon(options = {}) {
       refreshTimer = null;
     }
   }
-  function clearFeedDrainTimer() {
-    if (feedDrainTimer) {
-      clearInterval(feedDrainTimer);
-      feedDrainTimer = null;
-    }
-  }
-  function drainFeedOutbox() {
-    const current = client;
-    if (!current) return;
-    const rows = feedOutbox.pendingBatch({ limit: 100, now: now() });
-    for (const row of rows) {
-      current.sendFeedEvent({
-        deliverySeq: row.deliverySeq,
-        envelope: row.envelope
-      });
-      const retryDelayMs = Math.min(3e4, (row.attempt + 1) * 1e3);
-      feedOutbox.markAttempted({
-        deliverySeq: row.deliverySeq,
-        nextAttemptAt: now() + retryDelayMs
-      });
-    }
-  }
-  function startFeedDrainTimer() {
-    clearFeedDrainTimer();
-    const timer = setInterval(drainFeedOutbox, feedDrainIntervalMs);
-    timer.unref();
-    feedDrainTimer = timer;
-    drainFeedOutbox();
-  }
   function scheduleRefresh(expiresInSec) {
     clearRefreshTimer();
     if (!Number.isFinite(expiresInSec) || expiresInSec <= refreshLeadSec) {
@@ -12898,9 +13731,8 @@ async function runDashboardRuntimeDaemon(options = {}) {
       lastFrameAt = now();
       if (frame.type === "attachments.changed") {
         try {
-          writeMirror({
+          attachmentReconciler.applyPush({
             instanceId: token.instanceId,
-            fetchedAt: now(),
             attachments: frame.attachments.map((a) => ({
               runnerId: a.runnerId,
               ...a.name !== void 0 ? { name: a.name } : {},
@@ -12917,10 +13749,11 @@ async function runDashboardRuntimeDaemon(options = {}) {
         return;
       }
       if (frame.type === "feed_ack") {
-        feedOutbox.markAcked({
-          ...typeof frame.deliverySeq === "number" ? { deliverySeq: frame.deliverySeq } : {},
-          ...typeof frame.eventId === "string" ? { eventId: frame.eventId } : {}
-        });
+        pairedFeedPublisher.handleAck(frame);
+        return;
+      }
+      if (frame.type === "job_assignment") {
+        assignmentIntake.receive(frame);
         return;
       }
       pairedExecution.handleFrame(frame);
@@ -12929,19 +13762,35 @@ async function runDashboardRuntimeDaemon(options = {}) {
       if (stopped || client !== next) return;
       log("warn", `instance socket closed: ${reason}`);
       client = null;
+      assignmentIntake.markNotReady();
+      attachmentReconciler.markStale(token.instanceId);
       currentInstanceId = void 0;
       clearRefreshTimer();
-      clearFeedDrainTimer();
+      pairedFeedPublisher.detachTransport();
       void reconnectLoop();
     });
     await next.connect();
     client = next;
     lastSocketClient = next;
+    try {
+      await attachmentReconciler.reconcileNow({
+        dashboardUrl: config.dashboardUrl,
+        instanceId: token.instanceId,
+        accessToken: token.accessToken
+      });
+    } catch (err) {
+      client = null;
+      assignmentIntake.markNotReady();
+      attachmentReconciler.markStale(token.instanceId);
+      next.close("attachment reconciliation failed");
+      throw err;
+    }
     currentInstanceId = token.instanceId;
     currentDashboardUrl = config.dashboardUrl;
+    assignmentIntake.markReady();
     reconnectAttempt = 0;
     scheduleRefresh(token.expiresInSec);
-    startFeedDrainTimer();
+    pairedFeedPublisher.attachTransport(next);
     log("info", `dashboard runtime daemon connected as ${token.instanceId}`);
   }
   async function reconnectLoop() {
@@ -12996,7 +13845,7 @@ async function runDashboardRuntimeDaemon(options = {}) {
     async stop(reason = "stopped") {
       stopped = true;
       clearRefreshTimer();
-      clearFeedDrainTimer();
+      pairedFeedPublisher.close();
       const current = client;
       client = null;
       current?.close(reason);
@@ -13005,8 +13854,99 @@ async function runDashboardRuntimeDaemon(options = {}) {
   };
 }
 
+// src/infra/daemon/pidLock.ts
+import fs23 from "fs";
+function acquirePidLock(pidPath) {
+  const ownPid = process.pid;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      const fd = fs23.openSync(pidPath, "wx", 384);
+      try {
+        fs23.writeSync(fd, `${ownPid}
+`);
+        fs23.fsyncSync(fd);
+      } finally {
+        fs23.closeSync(fd);
+      }
+      return makeHandle(pidPath, ownPid);
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    const existing = readPidLock(pidPath);
+    if (existing.state === "held") {
+      throw new Error(
+        `dashboard daemon is already running as pid ${existing.pid} (lock at ${pidPath}). Use "drisp dashboard daemon stop" to terminate it.`
+      );
+    }
+    if (existing.state === "stale") {
+      try {
+        fs23.unlinkSync(pidPath);
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+      }
+      continue;
+    }
+  }
+  throw new Error(
+    `dashboard daemon: failed to acquire pid lock at ${pidPath} after retry`
+  );
+}
+function readPidLock(pidPath) {
+  let raw;
+  try {
+    raw = fs23.readFileSync(pidPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { state: "absent" };
+    }
+    throw err;
+  }
+  const pid = Number.parseInt(raw.trim(), 10);
+  if (!Number.isFinite(pid) || pid <= 0) {
+    return { state: "stale", pid: 0 };
+  }
+  if (!isProcessAlive(pid)) {
+    return { state: "stale", pid };
+  }
+  return { state: "held", pid };
+}
+function makeHandle(pidPath, pid) {
+  let released = false;
+  return {
+    pid,
+    release() {
+      if (released) return;
+      released = true;
+      try {
+        const raw = fs23.readFileSync(pidPath, "utf-8").trim();
+        if (raw === String(pid)) {
+          fs23.unlinkSync(pidPath);
+        }
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+        }
+      }
+    }
+  };
+}
+function isProcessAlive(pid) {
+  if (process.platform === "win32") {
+    return true;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM") {
+      return true;
+    }
+    return false;
+  }
+}
+
 // src/infra/daemon/udsIpc.ts
-import fs21 from "fs";
+import fs24 from "fs";
 import net2 from "net";
 
 // src/infra/daemon/udsFrameCodec.ts
@@ -13051,7 +13991,7 @@ async function startUdsServer(socketPath, handler, log) {
   });
   if (process.platform !== "win32") {
     try {
-      fs21.chmodSync(socketPath, 384);
+      fs24.chmodSync(socketPath, 384);
     } catch {
     }
   }
@@ -13061,7 +14001,7 @@ async function startUdsServer(socketPath, handler, log) {
         server.close(() => resolve());
       });
       try {
-        fs21.unlinkSync(socketPath);
+        fs24.unlinkSync(socketPath);
       } catch (err) {
         if (err.code !== "ENOENT") {
         }
@@ -13179,7 +14119,7 @@ async function sendUdsRequest(socketPath, request, options = {}) {
 async function unlinkStaleSocket(socketPath) {
   let stat;
   try {
-    stat = fs21.statSync(socketPath);
+    stat = fs24.statSync(socketPath);
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -13206,7 +14146,7 @@ async function unlinkStaleSocket(socketPath) {
       `uds path ${socketPath} is in use by another process; aborting`
     );
   }
-  fs21.unlinkSync(socketPath);
+  fs24.unlinkSync(socketPath);
 }
 
 export {
@@ -13226,7 +14166,7 @@ export {
   generateId,
   daemonStatePaths,
   ensureDaemonStateDir,
-  createDashboardFeedPublisher,
+  createPairedFeedPublisher,
   createDashboardDecisionInbox,
   createSessionStore,
   sessionsDir,
@@ -13275,9 +14215,13 @@ export {
   bootstrapRuntimeConfig,
   EXEC_EXIT_CODE,
   runExec,
-  normalizeHarnessOverride,
+  readAttachmentMirror,
+  writeAttachmentMirror,
+  removeAttachmentMirror,
   runDashboardRuntimeDaemon,
+  acquirePidLock,
+  readPidLock,
   startUdsServer,
   sendUdsRequest
 };
-//# sourceMappingURL=chunk-PC46SGTK.js.map
+//# sourceMappingURL=chunk-ZU7M6YZW.js.map