@drisp/cli 0.5.10 → 0.5.13

package/dist/{chunk-RN5AVH3D.js → chunk-BUNMENOT.js}

@@ -216,7 +216,6 @@ function cleanupStaleSockets(sockDir) {
 
 // src/harnesses/claude/runtime/interactionRules.ts
 var DEFAULT_TIMEOUT_MS = 4e3;
-var PERMISSION_TIMEOUT_MS = 3e5;
 var DEFAULT_HINTS = {
   expectsDecision: false,
   defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
@@ -225,12 +224,12 @@ var DEFAULT_HINTS = {
 var RULES = {
   "permission.request": {
     expectsDecision: true,
-    defaultTimeoutMs: PERMISSION_TIMEOUT_MS,
+    defaultTimeoutMs: null,
     canBlock: true
   },
   "tool.pre": {
     expectsDecision: true,
-    defaultTimeoutMs: PERMISSION_TIMEOUT_MS,
+    defaultTimeoutMs: null,
     canBlock: true
   },
   "tool.post": {
@@ -390,7 +389,7 @@ var RULES = {
   },
   "elicitation.request": {
     expectsDecision: true,
-    defaultTimeoutMs: PERMISSION_TIMEOUT_MS,
+    defaultTimeoutMs: null,
     canBlock: true
   },
   "elicitation.result": {
@@ -5369,13 +5368,12 @@ function describeAction(a) {
 }
 
 // src/harnesses/codex/runtime/interactionRules.ts
-var APPROVAL_TIMEOUT_MS = 3e5;
 var DEFAULT_TIMEOUT_MS2 = 4e3;
 function getCodexInteractionHints(expectsDecision) {
   if (expectsDecision) {
     return {
       expectsDecision: true,
-      defaultTimeoutMs: APPROVAL_TIMEOUT_MS,
+      defaultTimeoutMs: null,
       canBlock: true
     };
   }
@@ -7167,15 +7165,10 @@ function loadPlugin(pluginDir) {
   }
   const mcpConfigPath = path12.join(pluginDir, ".mcp.json");
   const hasMcpConfig = fs14.existsSync(mcpConfigPath);
-  const entries = fs14.readdirSync(skillsDir, { withFileTypes: true });
   const commands2 = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillPath = path12.join(skillsDir, entry.name, "SKILL.md");
-    if (!fs14.existsSync(skillPath)) continue;
-    const content = fs14.readFileSync(skillPath, "utf-8");
-    const parsed = parseFrontmatter(content);
-    if (!parsed.frontmatter["user-invocable"]) continue;
+  const loadSkillFile = (skillPath) => {
+    const parsed = parseFrontmatter(fs14.readFileSync(skillPath, "utf-8"));
+    if (!parsed.frontmatter["user-invocable"]) return;
     commands2.push(
       skillToCommand(
         parsed.frontmatter,
@@ -7183,6 +7176,20 @@ function loadPlugin(pluginDir) {
         hasMcpConfig ? mcpConfigPath : void 0
       )
     );
+  };
+  for (const entry of fs14.readdirSync(skillsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const entryDir = path12.join(skillsDir, entry.name);
+    const directSkill = path12.join(entryDir, "SKILL.md");
+    if (fs14.existsSync(directSkill)) {
+      loadSkillFile(directSkill);
+      continue;
+    }
+    for (const nested of fs14.readdirSync(entryDir, { withFileTypes: true })) {
+      if (!nested.isDirectory()) continue;
+      const nestedSkill = path12.join(entryDir, nested.name, "SKILL.md");
+      if (fs14.existsSync(nestedSkill)) loadSkillFile(nestedSkill);
+    }
   }
   return commands2;
 }
@@ -7851,7 +7858,8 @@ function createTranscriptReader() {
 }
 
 // src/core/feed/internals/runLifecycle.ts
-function createRunLifecycle() {
+function createRunLifecycle(boundary) {
+  const { makeEvent, resetPerRunState } = boundary;
   let currentSession = null;
   let currentRun = null;
   let seq = 0;
@@ -7860,17 +7868,79 @@ function createRunLifecycle() {
     const sessId = currentSession?.session_id ?? "unknown";
     return `${sessId}:R${runSeq}`;
   }
+  function allocateSeq() {
+    return ++seq;
+  }
+  function getCurrentRun() {
+    return currentRun;
+  }
+  function closeRun(ts, status) {
+    if (!currentRun) return null;
+    currentRun.status = status;
+    currentRun.ended_at = ts;
+    const closed = currentRun;
+    currentRun = null;
+    return closed;
+  }
+  function openNewRun(ts, sessionId, triggerType, promptPreview) {
+    runSeq++;
+    currentRun = {
+      run_id: getRunId(),
+      session_id: sessionId,
+      started_at: ts,
+      trigger: { type: triggerType, prompt_preview: promptPreview },
+      status: "running",
+      actors: { root_agent_id: "agent:root", subagent_ids: [] },
+      counters: {
+        tool_uses: 0,
+        tool_failures: 0,
+        permission_requests: 0,
+        blocks: 0
+      }
+    };
+    return currentRun;
+  }
+  function closeRunIntoEvent(runtimeEvent, status) {
+    const closed = closeRun(runtimeEvent.timestamp, status);
+    if (!closed) return null;
+    return makeEvent(
+      "run.end",
+      "info",
+      "system",
+      { status, counters: { ...closed.counters } },
+      runtimeEvent
+    );
+  }
+  function beginRun(runtimeEvent, triggerType = "other", promptPreview) {
+    if (currentRun && triggerType === "other") return [];
+    const results = [];
+    const closeEvt = closeRunIntoEvent(runtimeEvent, "completed");
+    if (closeEvt) results.push(closeEvt);
+    resetPerRunState();
+    openNewRun(
+      runtimeEvent.timestamp,
+      runtimeEvent.sessionId,
+      triggerType,
+      promptPreview
+    );
+    results.push(
+      makeEvent(
+        "run.start",
+        "info",
+        "system",
+        { trigger: { type: triggerType, prompt_preview: promptPreview } },
+        runtimeEvent
+      )
+    );
+    return results;
+  }
   return {
-    allocateSeq() {
-      return ++seq;
-    },
+    allocateSeq,
     getRunId,
     getSession() {
       return currentSession;
     },
-    getCurrentRun() {
-      return currentRun;
-    },
+    getCurrentRun,
     setSession(session) {
       currentSession = session;
     },
@@ -7883,32 +7953,10 @@ function createRunLifecycle() {
     incrementCounter(name) {
       if (currentRun) currentRun.counters[name]++;
     },
-    closeRun(ts, status) {
-      if (!currentRun) return null;
-      currentRun.status = status;
-      currentRun.ended_at = ts;
-      const closed = currentRun;
-      currentRun = null;
-      return closed;
-    },
-    openNewRun(ts, sessionId, triggerType, promptPreview) {
-      runSeq++;
-      currentRun = {
-        run_id: getRunId(),
-        session_id: sessionId,
-        started_at: ts,
-        trigger: { type: triggerType, prompt_preview: promptPreview },
-        status: "running",
-        actors: { root_agent_id: "agent:root", subagent_ids: [] },
-        counters: {
-          tool_uses: 0,
-          tool_failures: 0,
-          permission_requests: 0,
-          blocks: 0
-        }
-      };
-      return currentRun;
-    },
+    closeRun,
+    openNewRun,
+    closeRunIntoEvent,
+    beginRun,
     restoreFrom(bootstrap) {
       for (const e of bootstrap.feedEvents) {
         if (e.seq > seq) seq = e.seq;
@@ -8028,6 +8076,34 @@ function createToolCorrelation() {
   };
 }
 
+// src/core/feed/internals/projection.ts
+function readString(...values) {
+  for (const value of values) {
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function readBoolean(...values) {
+  for (const value of values) {
+    if (typeof value === "boolean") return value;
+  }
+  return void 0;
+}
+function readObject(...values) {
+  for (const value of values) {
+    if (typeof value === "object" && value !== null) {
+      return value;
+    }
+  }
+  return {};
+}
+function readSuggestionArray(...values) {
+  for (const value of values) {
+    if (Array.isArray(value)) return value;
+  }
+  return void 0;
+}
+
 // src/core/feed/internals/agentMessageStream.ts
 function normalizeAgentMessage(message) {
   return message.replace(/\r\n/g, "\n").trimEnd();
@@ -8035,6 +8111,9 @@ function normalizeAgentMessage(message) {
 function agentMessageKey(actorId, scope) {
   return `${actorId}\0${scope}`;
 }
+function isStopEvent(kind) {
+  return kind === "stop.request" || kind === "subagent.stop";
+}
 function createAgentMessageStream(eventBuilder, transcriptReader) {
   const pendingMessages = /* @__PURE__ */ new Map();
   const lastAgentMessageByActorScope = /* @__PURE__ */ new Map();
@@ -8061,6 +8140,25 @@ function createAgentMessageStream(eventBuilder, transcriptReader) {
     lastAgentMessageByActorScope.set(key, normalized);
     return event;
   }
+  function emitTranscriptMessages(transcriptPath, runtimeEvent, actorId, scope) {
+    const msgs = transcriptReader.readNewAssistantMessages(transcriptPath);
+    const out = [];
+    for (const msg of msgs) {
+      const ev = emit({
+        runtimeEvent,
+        actorId,
+        scope,
+        message: msg.text,
+        source: "transcript",
+        model: msg.model
+      });
+      if (ev) out.push(ev);
+    }
+    return out;
+  }
+  function drainTranscript(transcriptPath) {
+    transcriptReader.readNewAssistantMessages(transcriptPath);
+  }
   return {
     emit,
     appendPendingDelta(itemId, delta, defaultActorId, defaultScope) {
@@ -8116,25 +8214,37 @@ function createAgentMessageStream(eventBuilder, transcriptReader) {
       }
       return out;
     },
-    emitTranscriptMessages(transcriptPath, runtimeEvent, actorId, scope) {
-      const msgs = transcriptReader.readNewAssistantMessages(transcriptPath);
-      const out = [];
-      for (const msg of msgs) {
-        const ev = emit({
-          runtimeEvent,
-          actorId,
-          scope,
-          message: msg.text,
-          source: "transcript",
-          model: msg.model
-        });
-        if (ev) out.push(ev);
-      }
-      return out;
+    emitTranscriptMessages,
+    replayBeforeEvent(runtimeEvent, actorId, scope) {
+      const transcriptPath = runtimeEvent.context.transcriptPath;
+      if (!transcriptPath || isStopEvent(runtimeEvent.kind)) return [];
+      return emitTranscriptMessages(
+        transcriptPath,
+        runtimeEvent,
+        actorId,
+        scope
+      );
     },
-    drainTranscript(transcriptPath) {
-      transcriptReader.readNewAssistantMessages(transcriptPath);
+    emitStopFallback(runtimeEvent, opts) {
+      const transcriptPath = runtimeEvent.context.transcriptPath;
+      if (transcriptPath) drainTranscript(transcriptPath);
+      if (opts.priorResults.some((r) => r.kind === "agent.message")) return [];
+      const message = readString(
+        runtimeEvent.data["last_assistant_message"]
+      );
+      if (!message) return [];
+      const parent = opts.priorResults.find((r) => r.kind === opts.parentKind);
+      const ev = emit({
+        runtimeEvent,
+        actorId: opts.actorId,
+        scope: opts.scope,
+        message,
+        source: "hook",
+        cause: parent ? { parent_event_id: parent.event_id } : void 0
+      });
+      return ev ? [ev] : [];
     },
+    drainTranscript,
     appendReasoningSummary(itemId, index, chunk) {
       const key = `${itemId ?? ""}:${index ?? 0}`;
       const next = `${reasoningSummaryByKey.get(key) ?? ""}${chunk}`;
@@ -8233,6 +8343,129 @@ function createTaskLifecycleTracker() {
   };
 }
 
+// src/core/feed/internals/taskStateTracker.ts
+function extractTodoItems(toolInput) {
+  const input = toolInput;
+  return Array.isArray(input?.todos) ? input.todos : [];
+}
+function mapPlanStepStatus(status) {
+  switch (status) {
+    case "inProgress":
+      return "in_progress";
+    case "completed":
+      return "completed";
+    case void 0:
+    default:
+      return "pending";
+  }
+}
+function createTaskStateTracker() {
+  const rootPlan = createRootPlanTracker();
+  const taskLifecycle = createTaskLifecycleTracker();
+  function applyToolPre(input) {
+    const { toolName, toolInput, actorId } = input;
+    if (toolName === "TodoWrite" && actorId === "agent:root") {
+      rootPlan.set(extractTodoItems(toolInput));
+    }
+    if (toolName === "TaskUpdate") {
+      const taskId = readString(toolInput["taskId"], toolInput["task_id"]);
+      const status = coerceTaskStatus(toolInput["status"]);
+      if (taskId && status) {
+        taskLifecycle.updateStatus({ taskId, status });
+      }
+    }
+  }
+  function applyToolPost(input) {
+    const { toolName, toolInput, toolResponse } = input;
+    if (toolName === "TaskCreate") {
+      const response = readObject(toolResponse);
+      const task = readObject(response["task"]);
+      const taskId = readString(task["id"], task["task_id"]);
+      const subject = readString(task["subject"], toolInput["subject"]);
+      if (taskId && subject) {
+        taskLifecycle.upsertCreated({
+          taskId,
+          subject,
+          description: readString(toolInput["description"]),
+          activeForm: readString(toolInput["activeForm"])
+        });
+      }
+    }
+    if (toolName === "TaskUpdate") {
+      const response = readObject(toolResponse);
+      const taskId = readString(
+        response["taskId"],
+        response["task_id"],
+        toolInput["taskId"],
+        toolInput["task_id"]
+      );
+      const status = coerceTaskStatus(
+        readObject(response["statusChange"])["to"] ?? toolInput["status"]
+      );
+      if (taskId && status) {
+        taskLifecycle.updateStatus({ taskId, status });
+      }
+    }
+  }
+  function applyTaskCreatedEvent(data) {
+    const taskId = readString(data["task_id"]);
+    const subject = readString(data["task_subject"]);
+    const description = readString(data["task_description"]);
+    if (taskId && subject) {
+      taskLifecycle.upsertCreated({ taskId, subject, description });
+    }
+  }
+  function applyTaskCompletedEvent(data) {
+    const taskId = readString(data["task_id"]);
+    const subject = readString(data["task_subject"]);
+    if (taskId) {
+      taskLifecycle.markCompleted({ taskId, subject });
+    }
+  }
+  return {
+    current() {
+      return [...rootPlan.current(), ...taskLifecycle.current()];
+    },
+    applyToolPre,
+    applyToolPost,
+    applyPlanDelta(planSteps) {
+      if (!Array.isArray(planSteps) || planSteps.length === 0) return false;
+      const next = planSteps.map((step) => ({
+        content: typeof step.step === "string" ? step.step : "",
+        status: mapPlanStepStatus(step.status)
+      }));
+      if (!rootPlan.differs(next)) return false;
+      rootPlan.set(next);
+      return true;
+    },
+    applyTaskCreatedEvent,
+    applyTaskCompletedEvent,
+    restore(feedEvents) {
+      for (const e of feedEvents) {
+        if (e.kind === "tool.pre") {
+          const data = e.data;
+          applyToolPre({
+            toolName: data.tool_name ?? "",
+            toolInput: readObject(data.tool_input),
+            actorId: e.actor_id
+          });
+        } else if (e.kind === "tool.post") {
+          const data = e.data;
+          applyToolPost({
+            toolName: data.tool_name ?? "",
+            toolInput: readObject(data.tool_input),
+            toolResponse: data.tool_response
+          });
+        } else if (e.kind === "task.created") {
+          applyTaskCreatedEvent(e.data);
+        } else if (e.kind === "task.completed") {
+          applyTaskCompletedEvent(e.data);
+        }
+      }
+    }
+  };
+}
+
 // src/core/feed/internals/subagentTracker.ts
 function createSubagentTracker() {
   const stack = [];
@@ -8275,44 +8508,57 @@ function createSubagentTracker() {
   };
 }
 
-// src/core/feed/internals/projection.ts
-function readString(...values) {
-  for (const value of values) {
-    if (typeof value === "string") return value;
-  }
-  return void 0;
-}
-function readBoolean(...values) {
-  for (const value of values) {
-    if (typeof value === "boolean") return value;
-  }
-  return void 0;
-}
-function readObject(...values) {
-  for (const value of values) {
-    if (typeof value === "object" && value !== null) {
-      return value;
-    }
-  }
-  return {};
-}
-function readSuggestionArray(...values) {
-  for (const value of values) {
-    if (Array.isArray(value)) return value;
-  }
-  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 : [];
+// src/core/feed/internals/subagentLifecycle.ts
+function createSubagentLifecycle(args) {
+  const { actors, runLifecycle } = args;
+  const tracker = createSubagentTracker();
+  const actorIdFor = (agentId) => `subagent:${agentId}`;
+  return {
+    observeToolInput(toolName, toolInput) {
+      if (!isSubagentTool(toolName)) return;
+      if (typeof toolInput["description"] === "string") {
+        tracker.recordPendingDescription(toolInput["description"]);
+      } else {
+        tracker.clearPendingDescription();
+      }
+    },
+    startSubagent({ agentId, agentType, fallbackDescription }) {
+      const description = tracker.consumePendingDescription() ?? fallbackDescription;
+      if (agentId) {
+        actors.ensureSubagent(agentId, agentType ?? "unknown");
+        const currentRun = runLifecycle.getCurrentRun();
+        if (currentRun) currentRun.actors.subagent_ids.push(agentId);
+        tracker.pushActor(actorIdFor(agentId));
+        if (description) tracker.setDescription(agentId, description);
+      }
+      return { actorId: "agent:root", description: description ?? void 0 };
+    },
+    stopSubagent(agentId) {
+      if (agentId) tracker.popActor(actorIdFor(agentId));
+      return {
+        actorId: actorIdFor(agentId ?? "unknown"),
+        description: tracker.description(agentId ?? "")
+      };
+    },
+    currentActor() {
+      return tracker.peek() ?? "agent:root";
+    },
+    currentScope() {
+      return tracker.currentScope();
+    },
+    actorIdFor,
+    clear() {
+      tracker.clear();
+    }
+  };
 }
+
+// src/core/feed/internals/toolProjection.ts
 function resolveToolUseId(event, record) {
   return event.toolUseId ?? record["tool_use_id"];
 }
@@ -8328,8 +8574,7 @@ function createToolProjection(args) {
     makeEvent,
     runLifecycle,
     toolCorrelation,
-    rootPlan,
-    taskLifecycle,
+    taskState,
     subagents,
     resolveToolActor
   } = args;
@@ -8426,23 +8671,12 @@ function createToolProjection(args) {
             webSearchStarted(event, data, toolUseId, preEvent.event_id)
           );
         }
-        if (toolName === "TodoWrite" && preEvent.actor_id === "agent:root") {
-          rootPlan.set(extractTodoItems(toolInput));
-        }
-        if (toolName === "TaskUpdate") {
-          const taskId = readString(toolInput["taskId"], toolInput["task_id"]);
-          const status = coerceTaskStatus(toolInput["status"]);
-          if (taskId && status) {
-            taskLifecycle.updateStatus({ taskId, status });
-          }
-        }
-        if (isSubagentTool(toolName)) {
-          if (typeof toolInput["description"] === "string") {
-            subagents.recordPendingDescription(toolInput["description"]);
-          } else {
-            subagents.clearPendingDescription();
-          }
-        }
+        taskState.applyToolPre({
+          toolName,
+          toolInput,
+          actorId: preEvent.actor_id
+        });
+        subagents.observeToolInput(toolName, toolInput);
         return results;
       }
       if (event.kind === "tool.post") {
@@ -8462,35 +8696,11 @@ function createToolProjection(args) {
           toolUseCause(toolUseId, parentId)
         );
         results.push(postEvent);
-        if (toolName === "TaskCreate") {
-          const response = readObject(data["tool_response"]);
-          const task = readObject(response["task"]);
-          const taskId = readString(task["id"], task["task_id"]);
-          const subject = readString(task["subject"], toolInput["subject"]);
-          if (taskId && subject) {
-            taskLifecycle.upsertCreated({
-              taskId,
-              subject,
-              description: readString(toolInput["description"]),
-              activeForm: readString(toolInput["activeForm"])
-            });
-          }
-        }
-        if (toolName === "TaskUpdate") {
-          const response = readObject(data["tool_response"]);
-          const taskId = readString(
-            response["taskId"],
-            response["task_id"],
-            toolInput["taskId"],
-            toolInput["task_id"]
-          );
-          const status = coerceTaskStatus(
-            readObject(response["statusChange"])["to"] ?? toolInput["status"]
-          );
-          if (taskId && status) {
-            taskLifecycle.updateStatus({ taskId, status });
-          }
-        }
+        taskState.applyToolPost({
+          toolName,
+          toolInput,
+          toolResponse: data.tool_response
+        });
         if (toolName === "WebSearch") {
           results.push(
             webSearchCompleted(event, data, toolUseId, postEvent.event_id)
@@ -8931,29 +9141,27 @@ function createDecisionProjection(args) {
 
 // src/core/feed/internals/subagentProjection.ts
 function createSubagentProjection(args) {
-  const { ensureRunArray, makeEvent, runLifecycle, actors, subagents } = args;
+  const { ensureRunArray, makeEvent, 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(data["prompt"]);
+        const { actorId: actorId2, description: description2 } = subagents.startSubagent({
+          agentId,
+          agentType,
+          fallbackDescription: readString(data["prompt"])
+        });
         results.push(
           makeEvent(
             "subagent.start",
             "info",
-            "agent:root",
+            actorId2,
             {
               agent_id: agentId ?? "",
               agent_type: agentType ?? "",
-              description: description ?? void 0,
+              description: description2 ?? void 0,
               tool: readString(data["tool"]),
               sender_thread_id: readString(data["sender_thread_id"]),
               receiver_thread_id: readString(data["receiver_thread_id"]),
@@ -8963,23 +9171,21 @@ function createSubagentProjection(args) {
             event
           )
         );
-        if (agentId && description)
-          subagents.setDescription(agentId, description);
         return results;
       }
-      if (agentId) subagents.popActor(`subagent:${agentId}`);
+      const { actorId, description } = subagents.stopSubagent(agentId);
       results.push(
         makeEvent(
           "subagent.stop",
           "info",
-          `subagent:${agentId ?? "unknown"}`,
+          actorId,
           {
             agent_id: agentId ?? "",
             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 ?? ""),
+            description,
             tool: readString(data["tool"]),
             status: readString(data["status"]),
             sender_thread_id: readString(data["sender_thread_id"]),
@@ -9160,17 +9366,6 @@ function createFileConfigProjection(args) {
 }
 
 // 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,
@@ -9178,7 +9373,7 @@ function createRunSessionProjection(args) {
     closeRunIntoEvent,
     runLifecycle,
     agentMessageStream,
-    rootPlan,
+    taskState,
     resolveToolActor,
     currentScope
   } = args;
@@ -9329,28 +9524,19 @@ function createRunSessionProjection(args) {
       }
       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 (taskState.applyPlanDelta(planSteps)) {
+          results.push(
+            makeEvent(
+              "todo.update",
+              "info",
+              "system",
+              {
+                todo_id: "plan",
+                patch: { status: "doing" }
+              },
+              event
+            )
           );
-          if (rootPlan.differs(next)) {
-            rootPlan.set(next);
-            results.push(
-              makeEvent(
-                "todo.update",
-                "info",
-                "system",
-                {
-                  todo_id: "plan",
-                  patch: { status: "doing" }
-                },
-                event
-              )
-            );
-          }
         }
         results.push(
           makeEvent(
@@ -9422,7 +9608,7 @@ function createRunSessionProjection(args) {
 
 // src/core/feed/internals/statusProjection.ts
 function createStatusProjection(args) {
-  const { ensureRunArray, makeEvent, taskLifecycle } = args;
+  const { ensureRunArray, makeEvent, taskState } = args;
   return {
     mapStatusEvent(event, data) {
       const results = ensureRunArray(event);
@@ -9445,13 +9631,7 @@ function createStatusProjection(args) {
         const taskId = readString(data["task_id"]) ?? "";
         const subject = readString(data["task_subject"]) ?? "";
         const description = readString(data["task_description"]);
-        if (taskId && subject) {
-          taskLifecycle.upsertCreated({
-            taskId,
-            subject,
-            description
-          });
-        }
+        taskState.applyTaskCreatedEvent(data);
         results.push(
           makeEvent(
             "task.created",
@@ -9472,7 +9652,7 @@ function createStatusProjection(args) {
       if (event.kind === "task.completed") {
         const taskId = readString(data["task_id"]) ?? "";
         const subject = readString(data["task_subject"]);
-        if (taskId) taskLifecycle.markCompleted({ taskId, subject });
+        taskState.applyTaskCompletedEvent(data);
         results.push(
           makeEvent(
             "task.completed",
@@ -9542,14 +9722,21 @@ var STATUS_EVENT_KINDS = /* @__PURE__ */ new Set([
   "task.created"
 ]);
 function createFeedMapper(bootstrap) {
-  const runLifecycle = createRunLifecycle();
+  const runLifecycle = createRunLifecycle({
+    makeEvent,
+    resetPerRunState: () => {
+      toolCorrelation.resetForNewRun();
+      decisionCorrelation.resetForNewRun();
+      agentMessageStream.resetForNewRun();
+      subagents.clear();
+    }
+  });
   const decisionCorrelation = createDecisionCorrelation();
   const toolCorrelation = createToolCorrelation();
   const transcriptReader = createTranscriptReader();
   const actors = new ActorRegistry();
-  const rootPlan = createRootPlanTracker();
-  const taskLifecycle = createTaskLifecycleTracker();
-  const subagents = createSubagentTracker();
+  const taskState = createTaskStateTracker();
+  const subagents = createSubagentLifecycle({ actors, runLifecycle });
   function makeEvent(kind, level, actorId, data, runtimeEvent, cause) {
     const s = runLifecycle.allocateSeq();
     const runId = runLifecycle.getRunId();
@@ -9584,117 +9771,21 @@ function createFeedMapper(bootstrap) {
     makeEvent,
     transcriptReader
   );
-  function replayTaskLifecycleToolEvent(e) {
-    if (e.kind !== "tool.pre" && e.kind !== "tool.post") return;
-    const data = e.data;
-    const toolInput = readObject(data.tool_input);
-    if (data.tool_name === "TaskCreate" && e.kind === "tool.post") {
-      const response = readObject(data.tool_response);
-      const task = readObject(response["task"]);
-      const taskId = readString(task["id"], task["task_id"]);
-      const subject = readString(task["subject"], toolInput["subject"]);
-      if (taskId && subject) {
-        taskLifecycle.upsertCreated({
-          taskId,
-          subject,
-          description: readString(toolInput["description"]),
-          activeForm: readString(toolInput["activeForm"])
-        });
-      }
-    }
-    if (data.tool_name === "TaskUpdate") {
-      const response = readObject(data.tool_response);
-      const status = coerceTaskStatus(
-        readObject(response["statusChange"])["to"] ?? toolInput["status"]
-      );
-      const taskId = readString(
-        response["taskId"],
-        response["task_id"],
-        toolInput["taskId"],
-        toolInput["task_id"]
-      );
-      if (taskId && status) {
-        taskLifecycle.updateStatus({ taskId, status });
-      }
-    }
-  }
   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)
-        );
-      }
-      replayTaskLifecycleToolEvent(e);
-      if (e.kind === "task.created") {
-        const data = e.data;
-        if (data.task_id && data.task_subject) {
-          taskLifecycle.upsertCreated({
-            taskId: data.task_id,
-            subject: data.task_subject,
-            description: data.task_description
-          });
-        }
-      }
-      if (e.kind === "task.completed") {
-        const data = e.data;
-        if (data.task_id) {
-          taskLifecycle.markCompleted({
-            taskId: data.task_id,
-            subject: data.task_subject
-          });
-        }
-      }
-    }
-  }
-  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;
+    taskState.restore(bootstrap.feedEvents);
   }
+  const ensureRunArray = runLifecycle.beginRun;
+  const closeRunIntoEvent = runLifecycle.closeRunIntoEvent;
   function resolveToolActor() {
-    return subagents.peek() ?? "agent:root";
+    return subagents.currentActor();
   }
   const toolProjection = createToolProjection({
     ensureRunArray,
     makeEvent,
     runLifecycle,
     toolCorrelation,
-    rootPlan,
-    taskLifecycle,
+    taskState,
     subagents,
     resolveToolActor
   });
@@ -9712,8 +9803,6 @@ function createFeedMapper(bootstrap) {
   const subagentProjection = createSubagentProjection({
     ensureRunArray,
     makeEvent,
-    runLifecycle,
-    actors,
     subagents
   });
   const fileConfigProjection = createFileConfigProjection({
@@ -9723,7 +9812,7 @@ function createFeedMapper(bootstrap) {
   const statusProjection = createStatusProjection({
     ensureRunArray,
     makeEvent,
-    taskLifecycle
+    taskState
   });
   const currentScope = () => subagents.currentScope();
   const runSessionProjection = createRunSessionProjection({
@@ -9732,7 +9821,7 @@ function createFeedMapper(bootstrap) {
     closeRunIntoEvent,
     runLifecycle,
     agentMessageStream,
-    rootPlan,
+    taskState,
     resolveToolActor,
     currentScope
   });
@@ -9740,33 +9829,13 @@ function createFeedMapper(bootstrap) {
     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()
-        )
-      );
-    }
+    results.push(
+      ...agentMessageStream.replayBeforeEvent(
+        event,
+        resolveToolActor(),
+        currentScope()
+      )
+    );
     if (RUN_SESSION_EVENT_KINDS.has(eventKind2)) {
       results.push(...runSessionProjection.mapRunSessionEvent(event, d));
     } else if (TOOL_EVENT_KINDS.has(eventKind2)) {
@@ -9801,13 +9870,25 @@ function createFeedMapper(bootstrap) {
       results.push(unknownEvt);
     }
     if (eventKind2 === "stop.request") {
-      if (transcriptPath) agentMessageStream.drainTranscript(transcriptPath);
-      emitFallbackMessage("stop.request", "agent:root", "root");
+      results.push(
+        ...agentMessageStream.emitStopFallback(event, {
+          actorId: "agent:root",
+          scope: "root",
+          parentKind: "stop.request",
+          priorResults: results
+        })
+      );
     }
     if (eventKind2 === "subagent.stop") {
       const agentId = readString(d["agent_id"]) ?? "unknown";
-      if (transcriptPath) agentMessageStream.drainTranscript(transcriptPath);
-      emitFallbackMessage("subagent.stop", `subagent:${agentId}`, "subagent");
+      results.push(
+        ...agentMessageStream.emitStopFallback(event, {
+          actorId: subagents.actorIdFor(agentId),
+          scope: "subagent",
+          parentKind: "subagent.stop",
+          priorResults: results
+        })
+      );
     }
     return results;
   }
@@ -9820,7 +9901,7 @@ function createFeedMapper(bootstrap) {
     getSession: () => runLifecycle.getSession(),
     getCurrentRun: () => runLifecycle.getCurrentRun(),
     getActors: () => actors.all(),
-    getTasks: () => [...rootPlan.current(), ...taskLifecycle.current()],
+    getTasks: () => taskState.current(),
     allocateSeq: () => runLifecycle.allocateSeq()
   };
 }
@@ -12422,8 +12503,32 @@ var VERBOSE_ONLY_KINDS = /* @__PURE__ */ new Set([
   "worktree.remove",
   "turn.diff",
   "usage.update",
-  "reasoning.summary"
+  "reasoning.summary",
+  // Codex protocol bookkeeping that churns the feed without conveying
+  // meaningful agent progress. `usage.update` (above) still feeds header
+  // token/context metrics via the raw event stream — only the rendered row
+  // is suppressed in the default (non-verbose) feed.
+  "thread.status",
+  "server.request.resolved"
+]);
+var VERBOSE_ONLY_NOTIFICATION_TYPES = /* @__PURE__ */ new Set([
+  "account.rate_limits_updated",
+  "account.updated",
+  "item.agentMessage.started",
+  "raw_response_item.completed",
+  "command_exec.output_delta",
+  "fuzzy_file_search.updated",
+  "fuzzy_file_search.completed",
+  "app.list_updated",
+  "thread_name",
+  "thread.archived",
+  "thread.unarchived",
+  "thread.realtime.transcript_delta",
+  "thread.realtime.output_audio_delta"
 ]);
+function isVerboseOnlyNotification(event) {
+  return event.kind === "notification" && typeof event.data.notification_type === "string" && VERBOSE_ONLY_NOTIFICATION_TYPES.has(event.data.notification_type);
+}
 function toRunStatus(event) {
   switch (event.data.status) {
     case "completed":
@@ -13212,6 +13317,9 @@ function shouldSkipEvent(event, verbose) {
   if (!verbose && event.kind === "stop.request" && !event.data.stop_hook_active) {
     return true;
   }
+  if (!verbose && isVerboseOnlyNotification(event)) {
+    return true;
+  }
   return false;
 }
 function mergedToolUseId(event, postByToolUseId) {
@@ -13871,7 +13979,7 @@ async function connect(opts) {
       const entry = pending.get(requestId);
       if (!entry) return;
       pending.delete(requestId);
-      clearTimeout(entry.timer);
+      if (entry.timer) clearTimeout(entry.timer);
       entry.resolve(parsed);
       return;
     }
@@ -13895,7 +14003,7 @@ async function connect(opts) {
       )
     );
     for (const [, p] of pending) {
-      clearTimeout(p.timer);
+      if (p.timer) clearTimeout(p.timer);
       p.reject(
         new GatewayProtocolError("connection closed", "connection_closed")
       );
@@ -13955,14 +14063,14 @@ async function connect(opts) {
       kind,
       payload
     };
-    const effectiveTimeoutMs = reqOpts?.timeoutMs ?? timeoutMs;
+    const effectiveTimeoutMs = reqOpts?.timeoutMs === void 0 ? timeoutMs : reqOpts.timeoutMs;
     const responsePromise = new Promise(
       (resolve, reject) => {
-        const timer = setTimeout(() => {
+        const timer = effectiveTimeoutMs === null ? void 0 : setTimeout(() => {
           pending.delete(requestId);
           reject(new GatewayProtocolError(`request ${kind} timed out`));
         }, effectiveTimeoutMs);
-        pending.set(requestId, { resolve, reject, timer });
+        pending.set(requestId, { resolve, reject, ...timer ? { timer } : {} });
       }
     );
     connection.send(envelope);
@@ -14218,7 +14326,6 @@ function writeGatewayClientConfig(config, env = process.env) {
 }
 
 // src/app/channels/sessionBridge.ts
-var RELAY_REQUEST_TIMEOUT_MS = 6 * 6e4;
 var RECONNECT_BACKOFF_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
 var SessionBridge = class {
   opts;
@@ -14370,9 +14477,9 @@ var SessionBridge = class {
       toolName: req.toolName,
       description: req.description,
       inputPreview: req.inputPreview,
-      ...req.ttlMs !== void 0 ? { ttlMs: req.ttlMs } : {}
+      ttlMs: req.ttlMs ?? null
     };
-    const overallTimeoutMs = req.ttlMs === null ? null : req.ttlMs ?? RELAY_REQUEST_TIMEOUT_MS;
+    const overallTimeoutMs = req.ttlMs ?? null;
     return this.requestWithReconnect("relay.permission.request", payload, overallTimeoutMs);
   }
   async relayQuestion(req) {
@@ -14381,9 +14488,9 @@ var SessionBridge = class {
       channelRequestId,
       title: req.title,
       questions: req.questions,
-      ...req.ttlMs !== void 0 ? { ttlMs: req.ttlMs } : {}
+      ttlMs: req.ttlMs ?? null
     };
-    const overallTimeoutMs = req.ttlMs === null ? null : req.ttlMs ?? RELAY_REQUEST_TIMEOUT_MS;
+    const overallTimeoutMs = req.ttlMs ?? null;
     return this.requestWithReconnect("relay.question.request", payload, overallTimeoutMs);
   }
   /**
@@ -14391,8 +14498,9 @@ var SessionBridge = class {
    * survives a transient WS disconnect: on `connection closed`, wait for
    * the bridge's reconnect to settle, then re-issue the same payload. The
    * server attaches the replay to the existing pending entry by
-   * `channelRequestId`, so adapters are not re-prompted. Bounded by the
-   * caller-provided overall timeout so a long outage still surfaces.
+   * `channelRequestId`, so adapters are not re-prompted. If the caller
+   * provided an explicit TTL, reconnect retries are bounded by that deadline;
+   * otherwise human-in-the-loop relays wait until answered or cancelled.
    */
   async requestWithReconnect(kind, payload, overallTimeoutMs) {
     const deadline = overallTimeoutMs === null ? null : Date.now() + overallTimeoutMs;
@@ -14404,9 +14512,7 @@ var SessionBridge = class {
       }
       try {
         return await client.request(kind, payload, {
-          // When unbounded, pass the largest safe setTimeout value so the
-          // inner request never self-cancels in any human time scale.
-          timeoutMs: remaining ?? 2147483647
+          timeoutMs: remaining
         });
       } catch (err) {
         if (err instanceof GatewayProtocolError && err.code === "connection_closed" && !this.stopped && (deadline === null || Date.now() < deadline)) {
@@ -15030,7 +15136,8 @@ async function runExec(options) {
   const runtimeFactory = options.runtimeFactory ?? createRuntime;
   const sessionStoreFactory = options.sessionStoreFactory ?? createSessionStore;
   const athenaSessionId = options.athenaSessionId ?? crypto2.randomUUID();
-  const dashboardFeedPublisher = options.dashboardFeedPublisher ?? createPairedFeedPublisher();
+  const ownedFeedPublisher = options.dashboardFeedPublisher ? null : createPairedFeedPublisher();
+  const dashboardFeedPublisher = options.dashboardFeedPublisher ?? ownedFeedPublisher;
   const dashboardOrigin = options.dashboardOrigin ?? "local";
   const output = createExecOutputWriter({
     json,
@@ -15399,6 +15506,7 @@ async function runExec(options) {
     }
     await bridge?.stop();
     store.close();
+    ownedFeedPublisher?.close();
   }
   const resolvedFinalMessage = resolveFinalMessage({
     streamMessage: streamFinalMessage,
@@ -16406,8 +16514,26 @@ function parseRemoteRunSpec(value) {
     callbackToken: typeof callbackToken === "string" && callbackToken.length > 0 ? callbackToken : void 0
   };
 }
-function isRemoteAssignmentAdmissible(frame) {
-  return parseRemoteRunSpec(frame.runSpec) !== null;
+function validateDashboardAssignment(frame) {
+  const spec = parseRemoteRunSpec(frame.runSpec);
+  if (!spec) {
+    return {
+      kind: "rejected",
+      rejection: {
+        reason: "malformed_assignment",
+        message: "remote assignment missing prompt"
+      }
+    };
+  }
+  return {
+    kind: "valid",
+    assignment: {
+      runId: frame.runId,
+      runnerId: frame.runnerId ?? "legacy",
+      spec,
+      frame
+    }
+  };
 }
 function workflowNameFromRef(ref) {
   if (!ref) return void 0;
@@ -16488,7 +16614,7 @@ function mergeRunSpecEnvIntoWorkflow(workflow, env) {
   };
 }
 async function executeRemoteAssignment({
-  frame,
+  assignment,
   client,
   projectDir,
   log = () => {
@@ -16511,11 +16637,11 @@ async function executeRemoteAssignment({
   const deferredFailedCompletion = {
     current: null
   };
-  const spec = parseRemoteRunSpec(frame.runSpec);
+  const { spec, runId, frame } = assignment;
   const runEventPublisher = await createRemoteRunEventPublisher({
-    runId: frame.runId,
-    callbackWsUrl: spec?.callbackWsUrl,
-    callbackToken: spec?.callbackToken,
+    runId,
+    callbackWsUrl: spec.callbackWsUrl,
+    callbackToken: spec.callbackToken,
     client,
     log,
     now,
@@ -16530,10 +16656,6 @@ async function executeRemoteAssignment({
   };
   send("progress", { message: "assignment received" });
   try {
-    if (!spec) {
-      send("error", { message: "remote assignment missing prompt" });
-      return;
-    }
     let artifactUploadSpec;
     try {
       artifactUploadSpec = parseArtifactUploadSpec(frame.runSpec);
@@ -16614,7 +16736,7 @@ async function executeRemoteAssignment({
         prompt: spec.prompt,
         projectDir,
         harness: runtimeConfig.harness,
-        athenaSessionId: spec.athenaSessionId ?? spec.sessionId ?? `athena-${frame.runId}`,
+        athenaSessionId: spec.athenaSessionId ?? spec.sessionId ?? `athena-${runId}`,
         adapterResumeSessionId: spec.adapterResumeSessionId,
         isolationConfig: runtimeConfig.isolationConfig,
         pluginMcpConfig: runtimeConfig.pluginMcpConfig,
@@ -16631,8 +16753,8 @@ async function executeRemoteAssignment({
         ...decisionInbox ? { dashboardDecisionInbox: decisionInbox } : {},
         ...dashboardFeedPublisher ? { dashboardFeedPublisher } : {},
         ...artifactUploadSpec ? {
-          beforeTerminalCompletion: async ({ result: result2, runId }) => {
-            const artifactRunId = runId ?? frame.runId;
+          beforeTerminalCompletion: async ({ result: result2, runId: runId2 }) => {
+            const artifactRunId = runId2 ?? assignment.runId;
             const { feedEvent } = await captureAndUploadArtifacts({
               spec: artifactUploadSpec,
               projectDir,
@@ -17042,54 +17164,55 @@ function createDashboardPairedExecution(options) {
     });
     log("warn", `run ${runId} rejected: ${rejection.message}`);
   }
-  function handleDecision(frame) {
+  function submitDashboardDecision(submission) {
     decisionInbox.enqueue({
-      athenaSessionId: frame.athenaSessionId,
-      requestId: frame.requestId,
-      decision: frame.decision,
+      athenaSessionId: submission.athenaSessionId,
+      requestId: submission.requestId,
+      decision: submission.decision,
       receivedAt: now()
     });
     client.sendDecisionAck({
-      athenaSessionId: frame.athenaSessionId,
-      requestId: frame.requestId
+      athenaSessionId: submission.athenaSessionId,
+      requestId: submission.requestId
     });
   }
-  function handleCancel(frame) {
-    const entry = active.get(frame.runId);
-    if (!entry) return;
+  function cancelRun(runId) {
+    const entry = active.get(runId);
+    if (!entry) return false;
     entry.record.status = "cancelled";
     entry.controller.abort();
+    return true;
   }
-  function handleAssignment(frame, input = {}) {
-    if (active.has(frame.runId)) {
+  function handleAssignment(assignment, input = {}) {
+    const { runId, runnerId } = assignment;
+    if (active.has(runId)) {
       const rejection = {
         reason: "duplicate",
-        message: `duplicate active assignment ${frame.runId}`
+        message: `duplicate active assignment ${runId}`
       };
-      rejectAssignment(frame.runId, rejection);
+      rejectAssignment(runId, rejection);
       return { kind: "rejected", rejection };
     }
-    const runnerKey = frame.runnerId;
-    const bucket = activeByRunner.get(runnerKey) ?? /* @__PURE__ */ new Set();
+    const bucket = activeByRunner.get(runnerId) ?? /* @__PURE__ */ new Set();
     if (bucket.size >= maxConcurrentRuns) {
       const rejection = {
         reason: "local_capacity",
-        message: `runtime daemon at concurrency cap (${maxConcurrentRuns}) for runner ${runnerKey ?? "<legacy>"}`
+        message: `runtime daemon at concurrency cap (${maxConcurrentRuns}) for runner ${runnerId}`
       };
-      rejectAssignment(frame.runId, rejection);
+      rejectAssignment(runId, rejection);
       return { kind: "rejected", rejection };
     }
     const controller = new AbortController();
     const record = {
-      runId: frame.runId,
+      runId,
       startedAt: now(),
       status: "running"
     };
     recordRun(record);
-    bucket.add(frame.runId);
-    activeByRunner.set(runnerKey, bucket);
+    bucket.add(runId);
+    activeByRunner.set(runnerId, bucket);
     const promise = executor({
-      frame,
+      assignment,
       client,
       projectDir: input.projectDir ?? projectDir,
       log,
@@ -17105,40 +17228,33 @@ function createDashboardPairedExecution(options) {
       record.error = err instanceof Error ? err.message : String(err);
       log(
         "error",
-        `run ${frame.runId} failed: ${err instanceof Error ? err.message : String(err)}`
+        `run ${runId} failed: ${err instanceof Error ? err.message : String(err)}`
       );
     }).finally(() => {
       record.endedAt = now();
       completedRuns += 1;
-      active.delete(frame.runId);
-      const remaining = activeByRunner.get(runnerKey);
+      active.delete(runId);
+      const remaining = activeByRunner.get(runnerId);
       if (remaining) {
-        remaining.delete(frame.runId);
-        if (remaining.size === 0) activeByRunner.delete(runnerKey);
+        remaining.delete(runId);
+        if (remaining.size === 0) activeByRunner.delete(runnerId);
       }
     });
-    active.set(frame.runId, { controller, promise, record, runnerKey });
+    active.set(runId, { controller, promise, record, runnerKey: runnerId });
     return { kind: "accepted" };
   }
   return {
-    handleFrame(frame) {
-      if (frame.type === "dashboard_decision") {
-        handleDecision(frame);
-        return true;
-      }
-      if (frame.type === "cancel") {
-        handleCancel(frame);
-        return true;
-      }
-      if (frame.type === "job_assignment") {
-        handleAssignment(frame);
-        return true;
-      }
-      return false;
-    },
-    admitAssignment(frame, input) {
-      return handleAssignment(frame, input);
+    // `job_assignment` is intentionally not handled here: the runtime daemon
+    // routes assignments through `DashboardAssignmentIntake`, which gates
+    // admission on attachment readiness and then calls `admitAssignment`
+    // directly. Run-control frames (`dashboard_decision`, `cancel`) are
+    // translated by `routeDashboardRunFrame` into `submitDashboardDecision`
+    // and `cancelRun` calls.
+    admitAssignment(assignment, input) {
+      return handleAssignment(assignment, input);
     },
+    cancelRun,
+    submitDashboardDecision,
     rejectAssignment,
     snapshot() {
       return {
@@ -17169,22 +17285,12 @@ function createDashboardPairedExecution(options) {
 import fs23 from "fs";
 import os13 from "os";
 import path21 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"
-      }
-    };
-  }
+function resolveRemoteWorkspace(assignment, options = {}) {
+  const { spec, runId, runnerId } = assignment;
   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 ? path21.join(
@@ -17200,7 +17306,7 @@ function resolveRemoteWorkspace(frame, options = {}) {
     deploymentSlug,
     sanitizePathSegment(runnerId),
     "runs",
-    sanitizePathSegment(frame.runId)
+    sanitizePathSegment(runId)
   );
   try {
     fs23.mkdirSync(projectDir, { recursive: true, mode: 448 });
@@ -17283,23 +17389,21 @@ function sanitizePathSegment(value) {
 function createDashboardAssignmentIntake(options) {
   const log = options.log ?? (() => {
   });
-  const resolveWorkspace = options.resolveWorkspace ?? ((frame) => resolveRemoteWorkspace(frame));
+  const resolveWorkspace = options.resolveWorkspace ?? ((assignment, context2) => resolveRemoteWorkspace(assignment, { dashboardUrl: context2.dashboardUrl }));
   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);
+  let context = null;
+  function handle(frame, readyContext) {
+    const validation = validateDashboardAssignment(frame);
+    if (validation.kind === "rejected") {
+      options.execution.rejectAssignment(frame.runId, validation.rejection);
       options.client.sendAssignmentRejected({
         runId: frame.runId,
-        ...rejection
+        ...validation.rejection
       });
       return;
     }
-    const workspace = resolveWorkspace(frame);
+    const assignment = validation.assignment;
+    const workspace = resolveWorkspace(assignment, readyContext);
     if (workspace.kind === "rejected") {
       options.execution.rejectAssignment(frame.runId, workspace.rejection);
       options.client.sendAssignmentRejected({
@@ -17308,7 +17412,7 @@ function createDashboardAssignmentIntake(options) {
       });
       return;
     }
-    const outcome = options.execution.admitAssignment(frame, {
+    const outcome = options.execution.admitAssignment(assignment, {
       projectDir: workspace.projectDir
     });
     if (outcome.kind === "accepted") {
@@ -17321,15 +17425,15 @@ function createDashboardAssignmentIntake(options) {
     });
   }
   function drain() {
-    if (!ready) return;
+    if (!context) return;
     while (pending.length > 0) {
       const frame = pending.shift();
-      if (frame) handle(frame);
+      if (frame) handle(frame, context);
     }
   }
   return {
     receive(frame) {
-      if (!ready) {
+      if (!context) {
         pending.push(frame);
         log(
           "debug",
@@ -17337,18 +17441,35 @@ function createDashboardAssignmentIntake(options) {
         );
         return;
       }
-      handle(frame);
+      handle(frame, context);
     },
-    markReady() {
-      ready = true;
+    markReady(nextContext) {
+      context = nextContext;
       drain();
     },
     markNotReady() {
-      ready = false;
+      context = null;
     }
   };
 }
 
+// src/app/dashboard/dashboardFrameRouter.ts
+function routeDashboardRunFrame(execution, frame) {
+  if (frame.type === "dashboard_decision") {
+    execution.submitDashboardDecision({
+      athenaSessionId: frame.athenaSessionId,
+      requestId: frame.requestId,
+      decision: frame.decision
+    });
+    return true;
+  }
+  if (frame.type === "cancel") {
+    execution.cancelRun(frame.runId);
+    return true;
+  }
+  return false;
+}
+
 // src/app/dashboard/runtimeDaemon.ts
 var DEFAULT_RECONNECT_DELAYS_MS2 = [1e3, 2e3, 5e3, 1e4, 3e4];
 var DEFAULT_MAX_CONCURRENT_RUNS2 = 1;
@@ -17452,7 +17573,7 @@ async function runDashboardRuntimeDaemon(options = {}) {
     },
     execution: pairedExecution,
     log,
-    resolveWorkspace: (frame) => resolveRemoteWorkspace(frame, { dashboardUrl: currentDashboardUrl })
+    resolveWorkspace: (assignment, context) => resolveRemoteWorkspace(assignment, { dashboardUrl: context.dashboardUrl })
   });
   function nextReconnectDelay() {
     if (reconnectDelays.length === 0) return 0;
@@ -17571,7 +17692,7 @@ async function runDashboardRuntimeDaemon(options = {}) {
         assignmentIntake.receive(frame);
         return;
       }
-      pairedExecution.handleFrame(frame);
+      routeDashboardRunFrame(pairedExecution, frame);
     });
     next.onClose((reason) => {
       if (stopped || client !== next) return;
@@ -17594,15 +17715,19 @@ async function runDashboardRuntimeDaemon(options = {}) {
         accessToken: token.accessToken
       });
     } catch (err) {
-      client = null;
-      assignmentIntake.markNotReady();
       attachmentReconciler.markStale(token.instanceId);
-      next.close("attachment reconciliation failed");
-      throw err;
+      log(
+        "warn",
+        `runtime daemon: attachment reconciliation failed; continuing with push-only mirror: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
+    if (stopped || client !== next) return;
     currentInstanceId = token.instanceId;
     currentDashboardUrl = config.dashboardUrl;
-    assignmentIntake.markReady();
+    assignmentIntake.markReady({
+      dashboardUrl: config.dashboardUrl,
+      instanceId: token.instanceId
+    });
     reconnectAttempt = 0;
     scheduleRefresh(token.expiresInSec);
     pairedFeedPublisher.attachTransport(next);
@@ -18062,4 +18187,4 @@ export {
   startUdsServer,
   sendUdsRequest
 };
-//# sourceMappingURL=chunk-RN5AVH3D.js.map
+//# sourceMappingURL=chunk-BUNMENOT.js.map