@schoolai/shipyard 3.12.0 → 3.13.0-rc.20260615.0

package/dist/{serve-2N7BIGRO.js → serve-3N7IHREI.js}

@@ -12,7 +12,7 @@ import {
   guardedSubscribe,
   makeInitialAttemptState,
   shutdownFileWatcherGuard
-} from "./chunk-3NML6IJM.js";
+} from "./chunk-7MVFHLYV.js";
 import {
   TRAILER_SCHEMA_VERSION,
   appendTrailerToMessage,
@@ -39,13 +39,13 @@ import {
   startPlanBackfillForDaemon,
   sync,
   validatePeerId
-} from "./chunk-GMMRLPGI.js";
+} from "./chunk-BUAEJNUG.js";
 import {
   loadAuthToken
 } from "./chunk-TFWDJCUJ.js";
 import {
   getDaemonVersion
-} from "./chunk-KJAEED3H.js";
+} from "./chunk-MR6HRO7R.js";
 import {
   collectPriorCrashDetail,
   getRecentWasmPanicMessages
@@ -167,7 +167,7 @@ import {
   translateWarningNotification,
   unresolveReviewThread,
   writeCursorApiKeyToVault
-} from "./chunk-Q6JQK2DR.js";
+} from "./chunk-OX3UY44R.js";
 import {
   buildNodeSpawnEnv,
   nodeSpawnEnvOverlay,
@@ -226,7 +226,7 @@ import {
   createAssetResolver,
   toSdkContent,
   toSdkPermissionMode
-} from "./chunk-LXFMCDAZ.js";
+} from "./chunk-RCEAMZVG.js";
 import {
   AGENT_IDS,
   AGENT_SYSTEM_CLAUDE_CODE,
@@ -369,6 +369,7 @@ import {
   isDiffEmpty,
   isPendingAgentParticipantId,
   isResourceResolutionMeta,
+  maybeCompressFrame,
   migrateAnnotationStore,
   migrateCredentialsVaultStore,
   migrateDiffCommentStore,
@@ -407,7 +408,7 @@ import {
   unsafeAssertSourceId,
   vizFileExtension,
   withPreferredRuntimeAuthMethod
-} from "./chunk-HUTIDJIT.js";
+} from "./chunk-IWBDVGD2.js";
 import {
   AuthGitHubCallbackRequestSchema,
   AuthGitHubCallbackResponseSchema,
@@ -420,6 +421,7 @@ import {
   BrowserCodeExchangeRequestSchema,
   BrowserCodeExchangeResponseSchema,
   BrowserCodeResponseSchema,
+  CONTROL_COMPRESSION_MIN_VERSION,
   CollabCreateRequestSchema,
   CollabCreateResponseSchema,
   CollabRoomConnection,
@@ -452,7 +454,7 @@ import {
   VaultKeyPutRequestSchema,
   VaultKeyPutResponseSchema,
   classifyClaudeCodeCompatibility
-} from "./chunk-LUKN75OT.js";
+} from "./chunk-M3WBYTB3.js";
 import {
   external_exports as external_exports2
 } from "./chunk-EHQITHQX.js";
@@ -5762,7 +5764,7 @@ function nanoid(size = 21) {
 }
 
 // src/services/bootstrap/signaling.ts
-var DAEMON_NPM_VERSION = true ? "3.12.0" : "unknown";
+var DAEMON_NPM_VERSION = true ? "3.13.0" : "unknown";
 function createDaemonSignaling(config) {
   const agentId = config.agentId ?? nanoid();
   function send(msg) {
@@ -13295,6 +13297,8 @@ var ROLE_PERMISSIONS = {
     "rewind_preview_request",
     "fetch_older",
     "permission_response",
+    "permission_response_codex",
+    "permission_response_cursor",
     "update_settings",
     "request_mcp_toggle",
     "request_skill_toggle",
@@ -13332,6 +13336,7 @@ var ROLE_PERMISSIONS = {
     "delete_annotation",
     "mark_annotation_delivered",
     "request_annotation_snapshot",
+    "request_viz_content_batch",
     "request_deliverables_snapshot",
     "request_task_state",
     "create_thread",
@@ -13403,6 +13408,7 @@ var ROLE_PERMISSIONS = {
     "delete_annotation",
     "mark_annotation_delivered",
     "request_annotation_snapshot",
+    "request_viz_content_batch",
     "request_deliverables_snapshot",
     "request_task_state",
     "create_thread",
@@ -13426,6 +13432,7 @@ var ROLE_PERMISSIONS = {
     "join_collab_room",
     "leave_collab_room",
     "request_annotation_snapshot",
+    "request_viz_content_batch",
     "request_deliverables_snapshot",
     "request_task_state",
     "list_threads",
@@ -13437,6 +13444,7 @@ var ROLE_PERMISSIONS = {
     "request_capabilities",
     "request_pr_data",
     "request_task_state",
+    "request_viz_content_batch",
     "join_collab_room",
     "leave_collab_room",
     "presence_update"
@@ -13474,6 +13482,7 @@ var TASK_SCOPED_CONTROL_TYPES = /* @__PURE__ */ new Set([
   "delete_annotation",
   "mark_annotation_delivered",
   "request_annotation_snapshot",
+  "request_viz_content_batch",
   "request_deliverables_snapshot",
   "request_task_state",
   "create_thread",
@@ -14786,6 +14795,7 @@ function routeMessage(msg, callbacks, sendControl, log) {
       callbacks.onUpdateThreadSettings(msg.taskId, msg.threadId, msg.settings);
       break;
     case "request_capabilities":
+      callbacks.onPeerProtocolVersion(msg.protocolVersion ?? 0);
       callbacks.onRequestCapabilities({ force: msg.force });
       break;
     case "request_skills":
@@ -14994,6 +15004,9 @@ function routeMessage(msg, callbacks, sendControl, log) {
     case "request_annotation_snapshot":
       callbacks.onRequestAnnotationSnapshot(msg.taskId);
       break;
+    case "request_viz_content_batch":
+      callbacks.onRequestVizContentBatch(msg.taskId);
+      break;
     case "request_deliverables_snapshot":
       callbacks.onRequestDeliverablesSnapshot(msg.taskId);
       break;
@@ -16295,6 +16308,8 @@ function dedupKeyForMessage(msg) {
       return JSON.stringify({ type: "plugin_data_response", requestId: msg.requestId });
     case "presence_state":
       return JSON.stringify({ type: "presence_state" });
+    case "capabilities":
+      return JSON.stringify({ type: "capabilities" });
     default:
       return void 0;
   }
@@ -19332,8 +19347,9 @@ function createSkillsTools(ctx) {
         "To use one, call load_skill with its name. Skills you already reach natively are omitted here",
         "(invoke those the normal way). Returns each skill's name, one-line description, and origin.",
         "",
-        "WHEN: before starting work, to see what curated capabilities exist; or when a native skill",
-        "mention came back empty (the skill is likely library-only \u2014 look for it here)."
+        "WHEN: before starting domain-specific work, to see whether the team already wrote down the",
+        "conventions for it (check skills first, then dive in); or when a native skill mention came",
+        "back empty (the skill is likely library-only \u2014 look for it here)."
       ].join("\n"),
       inputSchema: {},
       handler: async () => {
@@ -19462,12 +19478,14 @@ var COMMENTS_PROMPT_DOC = [
 var VISUALIZE_PROMPT_DOC = [
   "Call `read_me` before your first visualization in a session. It returns the theme, color palette, and constraints. Skipping it leads to broken colors (e.g. invisible text on dark backgrounds). Pass the `modules` parameter for your use case: chart, interactive, diagram, art, slides, review, table, recap, or plan.",
   "",
-  "**When to visualize proactively** \u2014 don't wait to be asked:",
+  "**When a picture beats a paragraph** \u2014 don't wait to be asked, but produce one when it changes what a reviewer understands, not by reflex:",
   "- Architecture or system design \u2192 Mermaid diagram",
   "- UI work or layout discussion \u2192 HTML mockup",
   "- Data modeling or performance \u2192 chart via Chart.js or D3 in HTML",
   "- State machines or workflows \u2192 Mermaid stateDiagram",
   "",
+  "When prose already carries the idea clearly, skip the diagram \u2014 one sharp explanation beats a chart nobody needed.",
+  "",
   "**Two tools:** `visualize` creates a file-backed visualization that renders inline immediately (returns slug + file path). `present({source:'slug', slug, target})` shows an existing visualization: `target:'inline'` returns a snapshot in conversation, `target:'canvas'` places a live element that auto-updates when the file changes."
 ].join("\n");
 var PRESENT_PROMPT_DOC = [
@@ -19516,16 +19534,16 @@ var TASK_TOOL_PROMPT_DOC = [
   'The `task` MCP tool covers three actions: `send_message` and `cancel` for sibling tasks (by ID \u2014 drive a spawned task with new instructions or stop it), and `snapshot` for your CURRENT task. Call `task({action:"snapshot"})` to read a live markdown view of your own todos, branch, cost, PR state, and recent deliverables \u2014 the same shape `create_task` returns for spawned siblings.'
 ].join("\n");
 var REGISTER_DELIVERABLE_PROMPT_DOC = [
-  "Use `register_deliverable` to record concrete artifacts the agent produces during a task \u2014 screenshots, videos, log files, markdown summaries, HTML dashboards, structured JSON results, AX-tree dumps, DOM snapshots, or any other proof of completion. Reviewers see these in the conversation dock's Deliverables tab and can open each one in a full-screen viewer.",
+  "Use `register_deliverable` to attach proof a reviewer can't get from the diff alone \u2014 a screenshot of the UI after your change, a green test-run log, a benchmark number, an AX-tree dump. Reviewers open these in the conversation dock's Deliverables tab. This is the \"don't ship blind\" half made concrete: the diff shows what changed; the deliverable shows it works.",
   "",
-  "**When to call:** any time you produce a verifiable artifact a reviewer would want to see \u2014 a Playwright screenshot proving a UI change works, a test-run log proving the suite passed, a markdown summary of what was decided. The point of Shipyard is velocity *with understanding*; deliverables are the understanding layer.",
+  "**When to call:** right after a change whose effect a reviewer can't verify by reading the diff \u2014 a UI tweak (attach the rendered screenshot), a fix you proved with a test (attach the passing run), a perf claim (attach the numbers). **When NOT to call:** when the diff *is* the proof. A pure refactor, a rename, a config edit \u2014 the change verifies itself; registering a deliverable just costs the reviewer attention.",
   "",
   "**Scoping:** when the task has structured todos (visible in `<task-list>`), scope the deliverable to the matching `todoItemId` (bare number, no `#`). For task-spanning artifacts, leave `todoItemId` null. For thread-scoped evidence, set `threadId`.",
   "",
   "**Required fields:** `kind` (one of `screenshot`, `video`, `log`, `markdown`, `html`, `json`, `ax-tree`, `dom-snapshot`, `other`), `title`, and exactly one of `assetId` or `filePath`."
 ].join("\n");
 var SKILLS_PROMPT_DOC = [
-  "Shipyard curates a set of skills for this task \u2014 reusable instructions for common workflows. Call `list_skills` to see what's available, then `load_skill({ name })` to retrieve a skill's full instructions (and a directory path for any sibling files it references). Some skills are also reachable through your own `/name` mentions; for anything in `list_skills`, `load_skill` always works."
+  "Shipyard curates a set of skills for this task \u2014 reusable, expert instructions for specific workflows. **Before starting domain-specific work, check skills first:** call `list_skills` to see what's available, then `load_skill({ name })` to pull a skill's full instructions (and a directory path for any sibling files it references) before you dive in. A relevant skill saves you re-deriving conventions the team already wrote down. Some skills are also reachable through your own `/name` mentions; for anything in `list_skills`, `load_skill` always works."
 ].join("\n");
 var HARNESS_TOOL_REGISTRY = [
   /** Comments — gate: all. */
@@ -19700,17 +19718,51 @@ var CURSOR_TOOLS = buildToolsBlock(
 function sharedIntro(shellWord) {
   return `# Shipyard
 
-Shipyard is a collaborative workspace. Your teammates see everything you produce \u2014 code diffs, comments, visualizations, tasks \u2014 in real time. They review your changes, leave feedback, and contribute to the work plan alongside you. You are a pair programmer, not a tool.
+You're a pair programmer on this team. Your job has two halves, and they matter equally:
+
+- **Ship fast** \u2014 do the work: write the code, run it, fix it, keep moving.
+- **Don't ship blind** \u2014 make your work legible *as you go*, so the people reviewing it see not just *what* changed but *why*, and can accept it with confidence.
+
+Everything Shipyard gives you \u2014 the diff, comments, visualizations, deliverables, the plan, the canvas \u2014 exists to serve the second half. You're not narrating for its own sake; you're keeping the people you work with in the loop at the speed you're working. **A change nobody can review isn't done.**
+
+Your teammates see everything you produce in real time, and they can act on it \u2014 edit the plan alongside you, comment on a diff hunk, add a task to the list. Treat what they do as direct input.
+
+Before anything else, the few rules that don't bend:
+
+- **Never launch browser tabs.** Don't use \`open\`, \`xdg-open\`, or ${shellWord} commands to open a URL \u2014 Shipyard renders everything the user needs to see.
+- **Confirm before anything outward-facing, irreversible, or tied to an identity** \u2014 publishing, posting, anything that consumes a token or attributes work to an account. Ask first.
+- **Rejection does not revert your code.** When a reviewer rejects, your changes stay on disk. Wait for their feedback before reattempting \u2014 don't undo or redo on your own.
+
+## Make your work legible
+
+After you do something, close the gap between what you did and what a reviewer can see \u2014 and reach for the tool only when there's a real gap:
+
+- **The reasoning behind a non-obvious change** belongs where they'll read it: a diff comment (\`add_comment\`) on the hunk. If the change speaks for itself, say nothing.
+- **A design, a data model, a flow, a comparison** is faster to grasp as a picture than a paragraph \u2014 a visualization (\`visualize\`, then \`present\`).
+- **Proof that something works that the diff can't show** \u2014 the UI after your change, a green test run, a performance number \u2014 is a deliverable (\`register_deliverable\`). When the diff *is* the proof, skip it.
+- **Multi-step work** becomes a task list the team watches and adds to \u2014 keep it current with your task-list tool (see Live State Resources for the exact verb your runtime uses).
+
+You don't need to be asked, and you don't need permission \u2014 this is how the job gets done. But each artifact costs a reviewer a moment of attention, so produce the one that changes what they understand. One sharp comment beats three diagrams. When in doubt, don't.
+
+You cannot preview your own visualizations \u2014 they render client-side only. Follow the constraints from \`read_me\` exactly.
 
-**How collaborators see your work** \u2014 your output renders as a reviewable artifact: response text, code diffs, inline comments (from \`add_comment\`), and visualizations (from \`visualize\` + \`present\`). Explain *why* you made each change \u2014 reviewers see the diff.
+## Choosing the right tool
 
-**How you receive collaborator input** \u2014 see "Live State Resources" below. Every aspect of the task (todos, branch state, canvas, plan, comments) is delivered as a structured resource block, not as ad-hoc events.
+A few boundaries are easy to get wrong \u2014 prefer the more specific option:
 
-Never use \`open\`, \`xdg-open\`, or ${shellWord} commands to launch browser tabs \u2014 Shipyard renders everything the user needs to see.
+- **Isolated or parallel work on its own branch** \u2192 a sibling task (\`create_task\`, which gets its own git worktree). A subagent (your runtime's subagent tool \u2014 see the agent-specific notes) shares *this* worktree and returns findings here \u2014 it's for read/research fan-out, not isolated build work.
+- **Sharing a preview** \u2192 \`publish\` to send it outside the session; \`present\` to show it inside.
+- **A recurring dashboard the user will return to** \u2192 a plugin. A one-off chart \u2192 a visualization.
 
-Rejection does not revert code changes. Wait for the reviewer's feedback before reattempting.
+These are preferences, not commands \u2014 you decide.
 
-You cannot preview your own visualizations \u2014 they render client-side only. Follow the constraints from \`read_me\` exactly.`;
+## The plan is a shared editor, not a document you publish
+
+When you propose a plan, it opens on the canvas as a **live collaborative editor** \u2014 rich text over a CRDT, with multiplayer cursors. Your teammates can **edit the plan text directly**, alongside your comments and theirs. So:
+
+- Write the plan to be *edited*, not just approved \u2014 clear sections a human can revise in place.
+- Between turns, re-read the \`<plan>\` resource: human edits to the plan text are intent, the same as a task they added or a comment they left. Build on them; don't overwrite them.
+- Comments and direct edits are two channels into the same document \u2014 answer the comments, absorb the edits.`;
 }
 var CLAUDE_LIVE_STATE = `## Live State Resources
 
@@ -19777,9 +19829,11 @@ When liveness flips back to \`bound\`, the resource re-emits on your next turn.
 
 When you call ExitPlanMode, your plan is published to the Shipyard canvas for collaborative review. You will receive a deny response \u2014 this is expected. Stay in plan mode and wait for reviewer feedback. The \`<plan>\` resource carries the current plan markdown, embedded \`<${XML_TAGS.COMMENT}>\` children for plan-anchored comments, and a \`<review>\` element when reviewers have approved or requested changes.
 
+**The plan is a live editor, not a static post.** It renders as a collaborative rich-text editor over a CRDT \u2014 your teammates can edit the plan text directly, not just comment on it. So the markdown in a later \`<plan>\` resource may differ from what you wrote: treat their edits as intent, the same as a task they added or a comment they left. Build on what they changed; don't silently revert it. Comments and direct edits are two channels into the same document.
+
 **While in plan mode** \u2014 place supporting visualizations on the canvas using \`present({source:'slug', slug, target:'canvas'})\`. Architecture diagrams, data models, and flow charts alongside the plan text help reviewers evaluate your design.
 
-Do not revise the plan unless reviewers request changes. When the \`<review decision="approve">\` element appears, call ExitPlanMode again to begin implementation.
+Do not revise the plan unless reviewers request changes \u2014 but absorbing a human's direct edit to the plan text is not "revising," it's accepting their contribution. When the \`<review decision="approve">\` element appears, call ExitPlanMode again to begin implementation.
 
 ### \`<${XML_TAGS.DEV_SERVERS}>\`
 
@@ -19807,11 +19861,19 @@ Prefer background execution to keep your main thread responsive to collaborators
 **Bash tool** \u2014 Use \`run_in_background: true\` for commands that may take more than 10 seconds: builds, installs, test suites, large git operations, network requests. Use \`TaskOutput\` to read results when notified. Keep short commands (git status, ls, cat) in the foreground.
 
 **Why this matters:** Foreground operations block everything. The only recovery from a stuck foreground operation is stopping the entire agent. Background-first execution avoids this and keeps you available for collaborator feedback.`;
+var SHARED_CLOSING = `## The rules that don't bend
+
+A reminder, because these are the ones that cost the most when missed:
+
+- **Never open browser tabs** \u2014 Shipyard renders everything; no \`open\` / \`xdg-open\`.
+- **Confirm before anything outward-facing, irreversible, or identity-tied** \u2014 publishing, posting, spending a token. Ask first.
+- **Rejection does not revert your code** \u2014 your changes stay on disk; wait for the reviewer's feedback before reattempting.`;
 var SHIPYARD_SYSTEM_PROMPT = [
   sharedIntro("shell"),
   CLAUDE_TOOLS,
   CLAUDE_LIVE_STATE,
-  CLAUDE_BACKGROUND
+  CLAUDE_BACKGROUND,
+  SHARED_CLOSING
 ].join("\n\n").trim();
 function buildCollabSystemPrompt(participants) {
   const roster = participants.map((p2) => `${p2.name} (${p2.role})`).join(", ");
@@ -19865,6 +19927,8 @@ When you are in plan-collaboration mode, publish your plan by wrapping it in a \
 
 The \`<plan>\` resource carries the current plan markdown, embedded \`<${XML_TAGS.COMMENT}>\` children for plan-anchored comments, and a \`<review>\` element when reviewers have approved or requested changes. Reviewer feedback arrives as \`<${XML_TAGS.COMMENT}>\` children of \`<plan>\` \u2014 reply to every one with \`add_comment\` \`mode: "reply"\` and \`parentCommentId\` set to the comment's \`id\`, same as on every other surface.
 
+**The plan is a live editor, not a static post.** Once published, it renders as a collaborative rich-text editor over a CRDT \u2014 your teammates can edit the plan text directly, not just comment. The markdown in a later \`<plan>\` resource may therefore differ from what you proposed: treat their edits as intent, the same as a comment they left. When you emit your next \`<proposed_plan>\` block, build on what they changed \u2014 carry their edits forward rather than reverting to your prior wording.
+
 **Iteration semantics** \u2014 to revise the plan, emit a fresh \`<proposed_plan>\` block in your next turn. Each new block is a complete replacement, not a patch \u2014 include everything the plan should contain. Emit at most one \`<proposed_plan>\` block per turn, and only when the plan is decision-complete.
 
 **Refining with the reviewer** \u2014 use \`request_user_input\` to ask multiple-choice questions during refinement (preferences, tradeoffs, and locked-in assumptions that materially change the plan). Don't ask questions you can answer from the repo \u2014 explore first via \`shell\` reads, then ask only when ambiguity is genuinely about intent.
@@ -19901,7 +19965,8 @@ var SHIPYARD_CODEX_SYSTEM_PROMPT = [
   sharedIntro("shell"),
   CODEX_TOOLS,
   CODEX_LIVE_STATE,
-  CODEX_NOTES
+  CODEX_NOTES,
+  SHARED_CLOSING
 ].join("\n\n").trim();
 var CURSOR_LIVE_STATE = `## Live State Resources
 
@@ -19937,6 +20002,8 @@ Authoritative snapshot of what's on the shared canvas. Each \`<element>\` carrie
 
 The \`<plan>\` resource carries the current plan markdown, embedded \`<${XML_TAGS.COMMENT}>\` children for plan-anchored comments, and a \`<review>\` element when reviewers have approved or requested changes. Reviewer feedback arrives as \`<${XML_TAGS.COMMENT}>\` children of \`<plan>\` \u2014 reply to every one with \`add_comment\` \`mode: "reply"\` and \`parentCommentId\` set to the comment's \`id\`, same as on every other surface.
 
+The plan text is a live collaborative editor \u2014 your teammates can edit it directly, not just comment. If the plan markdown in a later \`<plan>\` resource differs from what you remember, that is a human edit: treat it as intent, the same as a comment they left, and build on it rather than reverting it.
+
 ### \`<${XML_TAGS.DEV_SERVERS}>\` and \`<${XML_TAGS.TERMINALS}>\`
 
 Task-scoped snapshots of running processes. Use \`<${XML_TAGS.DEV_SERVERS}>\` to check whether a dev server is running before suggesting starting one. Use \`<${XML_TAGS.TERMINALS}>\` to find log files for active PTY sessions \u2014 when you need current terminal state, read the file at \`log="..."\` directly via \`Shell\` (e.g. \`tail -n 100\`), do not infer from possibly-stale \`<recent-output>\`.
@@ -19960,7 +20027,8 @@ var SHIPYARD_CURSOR_SYSTEM_PROMPT = [
   sharedIntro("`Shell`"),
   CURSOR_TOOLS,
   CURSOR_LIVE_STATE,
-  CURSOR_NOTES
+  CURSOR_NOTES,
+  SHARED_CLOSING
 ].join("\n\n").trim();
 
 // src/services/mcp/visibility-migrations.ts
@@ -22316,7 +22384,13 @@ function dispatchSpawn(decision, shell) {
       return shell.spawnClaude();
     case "spawn-cursor": {
       const sub = shell.spawnCursor();
-      if (shell.initialContent.length > 0) sub.pushMessage(shell.initialContent);
+      const firstTurnBlocks = shell.initialContent.length;
+      if (firstTurnBlocks > 0) sub.pushMessage(shell.initialContent);
+      shell.log({
+        event: "cursor_spawn_first_turn",
+        firstTurnPushed: firstTurnBlocks > 0,
+        firstTurnBlocks
+      });
       return sub;
     }
     case "reject-not-installed":
@@ -23080,11 +23154,12 @@ var RATCHET_THRESHOLDS = [10, 100, 1e3];
 var RATCHET_WINDOW_MS = 6e4;
 function createBestEffortSender(deps) {
   const dropsCounter = new RollingCounter(RATCHET_WINDOW_MS, RATCHET_THRESHOLDS);
-  const { guardedChannel, logAdapter, controlPeerId } = deps;
+  const { guardedChannel, logAdapter, controlPeerId, compress } = deps;
   return {
     send: (msg) => {
       const json = JSON.stringify(msg);
-      const result = guardedChannel.send(json, "best-effort");
+      const out = compress(json);
+      const result = guardedChannel.send(out, "best-effort");
       if (result !== "dropped" && result !== "drain-pending") return;
       const now = Date.now();
       const { thresholdCrossed } = dropsCounter.record(now);
@@ -26406,6 +26481,61 @@ function describeError(err3) {
 // src/services/channels/control-channel/task-callbacks.ts
 var TASK_INDEX_SNAPSHOT_MAX_BYTES = 9e5;
 var TASK_INDEX_SNAPSHOT_OVERSIZE_BYTES = 1048576;
+function buildSlimTaskIndex(tasks) {
+  const slimTasks = {};
+  for (const [taskId, record] of Object.entries(tasks)) {
+    slimTasks[taskId] = toTaskIndexEntry(record);
+  }
+  return slimTasks;
+}
+function measureJsonBytes(value) {
+  try {
+    return Buffer.byteLength(JSON.stringify(value), "utf-8");
+  } catch {
+    return 0;
+  }
+}
+function reportOversizedTaskIndexSnapshot(slimTasks, bytes, logAdapter) {
+  if (bytes <= TASK_INDEX_SNAPSHOT_OVERSIZE_BYTES) return;
+  const taskCount = Object.keys(slimTasks).length;
+  logAdapter({
+    event: "task_index_snapshot_oversized",
+    level: "error",
+    bytes,
+    taskCount,
+    limitBytes: TASK_INDEX_SNAPSHOT_OVERSIZE_BYTES
+  });
+  telemeter("task_index_snapshot_oversized", {
+    bytes,
+    taskCount,
+    limitBytes: TASK_INDEX_SNAPSHOT_OVERSIZE_BYTES
+  });
+}
+function emitTaskIndexSnapshot(args) {
+  const { tasks, version, partial, nextCursor, nextCursorId, totalCount } = args.result;
+  const slimTasks = buildSlimTaskIndex(tasks);
+  const message = {
+    type: "task_index_snapshot",
+    tasks: slimTasks,
+    version,
+    partial,
+    nextCursor,
+    nextCursorId,
+    totalCount
+  };
+  const bytes = measureJsonBytes(message);
+  args.controlHandler.sendControl(message);
+  reportOversizedTaskIndexSnapshot(slimTasks, bytes, args.logAdapter);
+  args.logAdapter({
+    event: "perf_task_index_snapshot_emit_done",
+    taskCount: Object.keys(slimTasks).length,
+    totalCount,
+    partial: partial === true,
+    cursorRequested: args.cursorRequested,
+    bytes,
+    durationMs: Date.now() - args.startedAt
+  });
+}
 function buildTaskCallbacks(deps) {
   const { daemon, getControlHandler, logAdapter, publishedArtifactStore, previewStateStore } = deps;
   const taskIndexInflightTtlMs = 250;
@@ -26490,7 +26620,8 @@ function buildTaskCallbacks(deps) {
         limit,
         sinceLastActivityAt: opts.sinceLastActivityAt ?? null,
         sinceLastId: opts.sinceLastId ?? null,
-        maxBytes: TASK_INDEX_SNAPSHOT_MAX_BYTES
+        maxBytes: TASK_INDEX_SNAPSHOT_MAX_BYTES,
+        includeTaskIds: cursorRequested ? [] : "favoriteTasks"
       });
       const cached = taskIndexInflightCache.get(fingerprint);
       const now = Date.now();
@@ -26502,80 +26633,54 @@ function buildTaskCallbacks(deps) {
         });
         return;
       }
-      logAdapter({
-        event: "perf_task_index_snapshot_emit_start",
-        cursorRequested,
-        activeOnly: opts.activeOnly === true
-      });
-      const resultPromise = daemon.taskStateStore.listTasksPaginated({
-        activeOnly: opts.activeOnly,
-        limit,
-        sinceLastActivityAt: opts.sinceLastActivityAt,
-        sinceLastId: opts.sinceLastId,
-        maxBytes: TASK_INDEX_SNAPSHOT_MAX_BYTES
-      });
-      taskIndexInflightCache.set(fingerprint, {
-        promise: resultPromise,
-        expiresAt: now + taskIndexInflightTtlMs * 4
+      const includeTaskIdsPromise = cursorRequested ? Promise.resolve(void 0) : daemon.userSettingsStore.getSettings().then((settings) => settings.favoriteTasks).catch((err3) => {
+        logAdapter({
+          event: "task_index_favorites_load_failed",
+          error: err3 instanceof Error ? err3.message : String(err3)
+        });
+        return void 0;
       });
-      resultPromise.then(({ tasks, version, partial, nextCursor, nextCursorId, totalCount }) => {
-        const slimTasks = {};
-        for (const [taskId, record] of Object.entries(tasks)) {
-          slimTasks[taskId] = toTaskIndexEntry(record);
-        }
-        const message = {
-          type: "task_index_snapshot",
-          tasks: slimTasks,
-          version,
-          partial,
-          nextCursor,
-          nextCursorId,
-          totalCount
-        };
-        let bytes = 0;
-        try {
-          bytes = Buffer.byteLength(JSON.stringify(message), "utf-8");
-        } catch {
-        }
-        getControlHandler().sendControl(message);
-        if (bytes > TASK_INDEX_SNAPSHOT_OVERSIZE_BYTES) {
-          const taskCount = Object.keys(slimTasks).length;
-          logAdapter({
-            event: "task_index_snapshot_oversized",
-            level: "error",
-            bytes,
-            taskCount,
-            limitBytes: TASK_INDEX_SNAPSHOT_OVERSIZE_BYTES
-          });
-          telemeter("task_index_snapshot_oversized", {
-            bytes,
-            taskCount,
-            limitBytes: TASK_INDEX_SNAPSHOT_OVERSIZE_BYTES
-          });
-        }
+      const requestPromise = includeTaskIdsPromise.then((includeTaskIds) => {
         logAdapter({
-          event: "perf_task_index_snapshot_emit_done",
-          taskCount: Object.keys(slimTasks).length,
-          totalCount,
-          partial: partial === true,
+          event: "perf_task_index_snapshot_emit_start",
           cursorRequested,
-          bytes,
-          durationMs: Date.now() - startedAt
+          activeOnly: opts.activeOnly === true
+        });
+        return daemon.taskStateStore.listTasksPaginated({
+          activeOnly: opts.activeOnly,
+          limit,
+          sinceLastActivityAt: opts.sinceLastActivityAt,
+          sinceLastId: opts.sinceLastId,
+          includeTaskIds,
+          maxBytes: TASK_INDEX_SNAPSHOT_MAX_BYTES
+        });
+      }).then((result) => {
+        emitTaskIndexSnapshot({
+          result,
+          controlHandler: getControlHandler(),
+          logAdapter,
+          cursorRequested,
+          startedAt
         });
         const settled = taskIndexInflightCache.get(fingerprint);
-        if (settled?.promise === resultPromise) {
+        if (settled?.promise === requestPromise) {
           settled.expiresAt = Date.now() + taskIndexInflightTtlMs;
         }
       }).catch((err3) => {
         logAdapter({
-          event: "task_state_store_list_failed",
+          event: "task_index_request_failed",
           error: err3 instanceof Error ? err3.message : String(err3)
         });
         const failed = taskIndexInflightCache.get(fingerprint);
-        if (failed?.promise === resultPromise) {
+        if (failed?.promise === requestPromise) {
           taskIndexInflightCache.delete(fingerprint);
         }
       });
+      taskIndexInflightCache.set(fingerprint, {
+        promise: requestPromise,
+        expiresAt: now + taskIndexInflightTtlMs * 4
+      });
+      void requestPromise;
     },
     onRequestReviewTasks: () => {
       daemon.taskStateStore.listTasks().then((all) => {
@@ -27042,6 +27147,10 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
     chunk: true,
     logAdapter
   });
+  let peerProtocolVersion = 0;
+  function maybeCompress(json) {
+    return maybeCompressFrame(json, peerProtocolVersion >= CONTROL_COMPRESSION_MIN_VERSION);
+  }
   function guardedSend(data) {
     const result = guardedChannel.send(data);
     if (result === "dropped" || result === "drain-pending") {
@@ -27240,6 +27349,9 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
         daemon.taskManager.applyThreadSettings(taskId, threadId, applied);
         logAdapter({ event: "thread_settings_updated", taskId, threadId, settings: applied });
       },
+      onPeerProtocolVersion: (version) => {
+        peerProtocolVersion = version;
+      },
       onRequestCapabilities: ({ force } = {}) => {
         if (force) {
           void deps.capabilityRefresh.refreshFull("force_request");
@@ -27795,6 +27907,16 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
           });
         });
       },
+      onRequestVizContentBatch: (taskId) => {
+        daemon.attachVizWatcher(taskId);
+        daemon.pushTaskVizContent(taskId, (msg) => controlHandler.sendControl(msg)).catch((err3) => {
+          logAdapter({
+            event: "request_viz_content_batch_push_failed",
+            taskId,
+            error: err3 instanceof Error ? err3.message : String(err3)
+          });
+        });
+      },
       onCreateThread: (opts) => handleCreateThread({
         opts,
         daemon,
@@ -28176,7 +28298,8 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
     receiveCursor: aloReceiveCursor,
     rawSend: (json) => {
       try {
-        const result = guardedChannel.send(json);
+        const out = maybeCompress(json);
+        const result = guardedChannel.send(out);
         if (result === "dropped" || result === "drain-pending") {
           const now = Date.now();
           const { thresholdCrossed } = rawSendDropsCounter.record(now);
@@ -28228,7 +28351,16 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
       error: err3 instanceof Error ? err3.message : String(err3)
     });
   });
-  const bestEffort = createBestEffortSender({ guardedChannel, logAdapter, controlPeerId });
+  const bestEffort = createBestEffortSender({
+    guardedChannel,
+    logAdapter,
+    controlPeerId,
+    /**
+     * Pass the compression gate so best-effort messages are also compressed for
+     * v139+ peers. `maybeCompress` is a no-op for pre-v139 peers (safe default).
+     */
+    compress: maybeCompress
+  });
   const aloSend = (msg) => {
     if (classifyCriticality(msg) === "best-effort") {
       bestEffort.send(msg);
@@ -28945,57 +29077,74 @@ function handleMessageChannel(opts) {
       }).catch(() => {
       });
     }
-    if (msg.maxMessages && msg.sinceSeqNo === 0) {
-      const limit = msg.maxMessages;
-      store.getMessagesBefore(channelId, Number.POSITIVE_INFINITY, limit).then(({ messages: page }) => {
-        const outgoing = {
-          type: "catch_up_chunk",
-          messages: page,
-          cursor: null
-        };
-        send(JSON.stringify(outgoing));
-        finalizeCatchUp();
-        logSubscribeDone(page.length);
-      }).catch((err3) => {
-        flushBufferedMessages();
-        sendError(formatError2(err3));
-        logSubscribeDone(0);
-      });
-    } else if (msg.maxMessages) {
-      store.getMessagesPaginated(channelId, msg.sinceSeqNo, msg.maxMessages).then(({ messages, nextSeqNo }) => {
-        const outgoing = {
-          type: "catch_up_chunk",
-          messages,
-          cursor: nextSeqNo
-        };
-        send(JSON.stringify(outgoing));
-        if (nextSeqNo === null) finalizeCatchUp();
-        else flushBufferedMessages();
-        logSubscribeDone(messages.length);
-      }).catch((err3) => {
-        flushBufferedMessages();
-        sendError(formatError2(err3));
-        logSubscribeDone(0);
-      });
-    } else {
-      store.getMessagesSince(channelId, msg.sinceSeqNo).then((messages) => {
-        const outgoing = { type: "catch_up", messages };
-        send(JSON.stringify(outgoing));
-        finalizeCatchUp();
-        logSubscribeDone(messages.length);
-      }).catch((err3) => {
-        flushBufferedMessages();
-        sendError(formatError2(err3));
-        logSubscribeDone(0);
-      });
-    }
+    void taskManager.getTask(taskId).then((task) => {
+      const clearedAtSeqNo = task?.clearedAtSeqNo;
+      const sinceSeqNo = clearedAtSeqNo == null ? msg.sinceSeqNo : Math.max(msg.sinceSeqNo, clearedAtSeqNo + 1);
+      if (msg.maxMessages && msg.sinceSeqNo === 0 && clearedAtSeqNo == null) {
+        const limit = msg.maxMessages;
+        store.getMessagesBefore(channelId, Number.POSITIVE_INFINITY, limit).then(({ messages: page }) => {
+          const outgoing = {
+            type: "catch_up_chunk",
+            messages: page,
+            cursor: null
+          };
+          send(JSON.stringify(outgoing));
+          finalizeCatchUp();
+          logSubscribeDone(page.length);
+        }).catch((err3) => {
+          flushBufferedMessages();
+          sendError(formatError2(err3));
+          logSubscribeDone(0);
+        });
+      } else if (msg.maxMessages) {
+        store.getMessagesPaginated(channelId, sinceSeqNo, msg.maxMessages).then(({ messages, nextSeqNo }) => {
+          const outgoing = {
+            type: "catch_up_chunk",
+            messages,
+            cursor: nextSeqNo
+          };
+          send(JSON.stringify(outgoing));
+          if (nextSeqNo === null) finalizeCatchUp();
+          else flushBufferedMessages();
+          logSubscribeDone(messages.length);
+        }).catch((err3) => {
+          flushBufferedMessages();
+          sendError(formatError2(err3));
+          logSubscribeDone(0);
+        });
+      } else {
+        store.getMessagesSince(channelId, sinceSeqNo).then((messages) => {
+          const outgoing = { type: "catch_up", messages };
+          send(JSON.stringify(outgoing));
+          finalizeCatchUp();
+          logSubscribeDone(messages.length);
+        }).catch((err3) => {
+          flushBufferedMessages();
+          sendError(formatError2(err3));
+          logSubscribeDone(0);
+        });
+      }
+    }).catch((err3) => {
+      flushBufferedMessages();
+      sendError(formatError2(err3));
+      logSubscribeDone(0);
+    });
   }
   function handleFetchOlder(msg) {
-    store.getMessagesBefore(channelId, msg.beforeSeqNo, msg.limit).then(({ messages, hasMore }) => {
+    taskManager.getTask(taskId).then((task) => {
+      const clearedAtSeqNo = task?.clearedAtSeqNo ?? -1;
+      return store.getMessagesBefore(channelId, msg.beforeSeqNo, msg.limit).then((page) => ({
+        ...page,
+        clearedAtSeqNo
+      }));
+    }).then(({ messages, hasMore, clearedAtSeqNo }) => {
+      const visibleMessages = messages.filter((m2) => m2.seqNo > clearedAtSeqNo);
+      const oldestVisibleSeqNo = visibleMessages[0]?.seqNo ?? null;
+      const visibleHasMore = visibleMessages.length === messages.length && hasMore && oldestVisibleSeqNo !== null && oldestVisibleSeqNo > clearedAtSeqNo + 1;
       const outgoing = {
         type: "older_messages",
-        messages,
-        hasMore
+        messages: visibleMessages,
+        hasMore: visibleHasMore
       };
       send(JSON.stringify(outgoing));
     }).catch((err3) => {
@@ -37508,9 +37657,14 @@ ${block.preview}` : `[File: ${block.filename}]`
     }
   }
 }
+function resolveEntryRole(msg) {
+  if (msg.content.some((block) => block.type === "tool_result")) return "user";
+  return msg.senderKind === "human" ? "user" : "assistant";
+}
 function portableMessageToEntry(msg, sessionId, parentUuid) {
   const apiContent = msg.content.map(portableBlockToApiContent).filter((c) => c !== null);
-  if (msg.senderKind === "human") {
+  const role = resolveEntryRole(msg);
+  if (role === "user") {
     const entry2 = {
       type: "user",
       uuid: msg.messageId,
@@ -38555,7 +38709,11 @@ import { randomUUID as randomUUID12 } from "crypto";
 import { copyFile, rm as fsRm, stat as fsStat3, mkdir as mkdir17 } from "fs/promises";
 import { basename as basename9, extname as extname2, join as join50, resolve as resolve8, sep as sep3 } from "path";
 var TOOL_DESCRIPTION2 = [
-  "Register a proof-of-work deliverable for this task. Call this after producing an artifact (screenshot, video, log, markdown document, AX tree, DOM snapshot) so reviewers can see verifiable evidence of what the agent produced.",
+  "Register a proof-of-work deliverable for this task \u2014 proof a reviewer cannot get from the diff alone.",
+  "",
+  "WHEN: right after a change whose effect is not visible in the diff \u2014 a UI change (attach the rendered screenshot), a fix you proved by running tests (attach the passing log), a performance claim (attach the numbers), an accessibility audit (attach the AX tree).",
+  "WHEN NOT: when the diff IS the proof \u2014 a refactor, a rename, a config edit verifies itself. Registering a deliverable then just costs the reviewer attention.",
+  "EXAMPLE: after adding a PATCH route and confirming it returns 200, register the test-run log so the reviewer sees it passed without re-running it.",
   "",
   "SCOPING:",
   "  When the current task has a structured todo list (visible in the <task-list> resource), scope the deliverable to the specific todoItemId it proves. This gives reviewers granular evidence per task step.",
@@ -39742,11 +39900,12 @@ var VISUALIZE_DESCRIPTION = [
   "",
   "Provide content inline OR pass file_path to import from disk.",
   "",
-  "WHEN to create proactively (don't wait to be asked):",
+  "WHEN a picture beats a paragraph (don't wait to be asked, but produce one when it changes what a reviewer understands \u2014 not by reflex):",
   "- Architecture or system design -> mermaid",
   "- UI work or layout -> html mockup",
   "- Data or performance -> html with Chart.js/D3",
-  "- State machines or workflows -> mermaid stateDiagram"
+  "- State machines or workflows -> mermaid stateDiagram",
+  "When prose already carries the idea, skip the diagram."
 ].join("\n");
 var PRESENT_DESCRIPTION = [
   "Display something somewhere.",
@@ -40139,7 +40298,21 @@ async function guardTaskTarget(args, callingTaskId, ctx) {
 }
 async function handleSendMessage(taskId, prompt, title, callingTaskId, ctx) {
   try {
-    await ctx.taskManager.handleUserMessage(taskId, [{ type: "text", text: prompt }]);
+    const callingSessionId = ctx.taskManager.getTaskState(callingTaskId)?.sessionId;
+    if (!callingSessionId) {
+      return errorResult("send_message failed: calling task has no active agent session.");
+    }
+    const agentParticipantId = buildAgentParticipantId(callingSessionId, ctx.agentSystem);
+    await ctx.taskManager.handleUserMessage(
+      taskId,
+      [{ type: "text", text: `[From agent \xB7 task ${callingTaskId}]: ${prompt}` }],
+      void 0,
+      void 0,
+      agentParticipantId,
+      void 0,
+      void 0,
+      "agent"
+    );
   } catch (err3) {
     const message = err3 instanceof Error ? err3.message : String(err3);
     logger.error({
@@ -49800,6 +49973,7 @@ function buildHarnessTools(ctx) {
   };
   const taskControlCtx = {
     callingTaskId: taskIdRef,
+    agentSystem: ctx.agentSystem,
     taskManager: ctx.taskManager,
     taskStateStore: ctx.taskStateStore,
     getWorktreeRunner: ctx.getWorktreeRunner,
@@ -52655,6 +52829,7 @@ var McpCoordinator = class {
     }
     this.#timer.cancelAll();
     this.#deps.reauthOrchestrator.cancelAll();
+    this.#deps.broadcaster.dispose();
     await Promise.all([this.#deps.proxyTransport.dispose(), this.#deps.stdioTransport.dispose()]);
   }
   /** ===== private helpers ===== */
@@ -54728,22 +54903,165 @@ function defaultRequestId() {
   return `reauth-${Date.now()}-${Math.random().toString(36).slice(2)}`;
 }
 
+// src/services/event-batching.ts
+var EVENT_BATCHING = {
+  /**
+   * Comments: sliding window for review comment bursts.
+   * 20 s idle matches observed user typing cadence in review sessions (#2218).
+   */
+  comments: { idleMs: 2e4, maxWindowMs: 6e4 },
+  /**
+   * Resources: sliding window for file/plan/git/task pushes.
+   *
+   * Inverted in Wave 4 of the unified context-delivery refactor from 20s
+   * to 100ms. The 20s window made agent-triggered updates (TaskCreate /
+   * TaskUpdate, structured-task mutations, etc.) invisible to the agent
+   * for up to 20s after the tool call returned — the agent's next turn
+   * would be reasoning on stale state. 100ms still coalesces within-tick
+   * bursts and absorbs CRDT keystroke storms via each resolver's existing
+   * projection cache (task-metadata, branch, canvas all gate no-op
+   * re-emissions before the timer ever sees them).
+   *
+   * `maxWindowMs` retains the 60s cap as a guardrail for pathological
+   * never-quiet sources.
+   */
+  resources: { idleMs: 100, maxWindowMs: 6e4 },
+  /** Messages: sliding window for collab message micro-batching. */
+  messages: { idleMs: 250, maxWindowMs: 3e4 },
+  /**
+   * MCP broadcaster: coalesce FSM-transition storms during MCP churn.
+   *
+   * Idle 150 ms, max 250 ms — the toggle-feel contract today is ~50 ms via
+   * the direct `pushWorkspaceMcpStateSnapshot` path in `applyWorkspaceMcpToggle`
+   * (which bypasses this debounce entirely). This window only applies to
+   * daemon-internal FSM transitions that fire during background MCP churn
+   * (reconnects, auth probes, plugin reloads). 250 ms max keeps the UI snappy
+   * while collapsing the ~900 sends / 10s burst seen during MCP churn.
+   */
+  mcp: { idleMs: 150, maxWindowMs: 250 }
+};
+var MAX_COLLAB_BATCH_SIZE = 4;
+var SlidingWindowTimer = class {
+  #config;
+  #onFlush;
+  #timer = null;
+  #windowStart = null;
+  #lastScheduleAt = null;
+  #disposed = false;
+  constructor(config, onFlush) {
+    this.#config = config;
+    this.#onFlush = onFlush;
+  }
+  /**
+   * Schedule or reschedule the flush timer.
+   *
+   * - First call in a window: records `windowStart`, starts idle timer.
+   * - Subsequent calls: resets idle timer (sliding window).
+   * - If `maxWindowMs` exceeded: fires flush immediately.
+   */
+  schedule() {
+    if (this.#disposed) return;
+    if (this.#windowStart === null) {
+      this.#windowStart = Date.now();
+    } else if (Date.now() - this.#windowStart >= this.#config.maxWindowMs) {
+      this.#clearTimer();
+      this.#windowStart = null;
+      this.#lastScheduleAt = null;
+      this.#onFlush();
+      return;
+    }
+    this.#clearTimer();
+    this.#lastScheduleAt = Date.now();
+    this.#timer = setTimeout(() => {
+      this.#timer = null;
+      this.#windowStart = null;
+      this.#lastScheduleAt = null;
+      this.#onFlush();
+    }, this.#config.idleMs);
+  }
+  /** Cancel the pending timer without resetting the window. */
+  cancel() {
+    this.#clearTimer();
+  }
+  /** Reset the window start (call after draining the batch). */
+  reset() {
+    this.#windowStart = null;
+    this.#lastScheduleAt = null;
+  }
+  /**
+   * Epoch-ms at which the idle timer will fire, or null if no timer is
+   * scheduled. Tracks the most recent `schedule()` call (sliding window),
+   * not the original windowStart — used by ResourcePushManager to emit
+   * accurate `flushAt` values for all dirty URIs after each timer slide.
+   */
+  get nextFireAt() {
+    if (this.#timer === null || this.#lastScheduleAt === null) return null;
+    return this.#lastScheduleAt + this.#config.idleMs;
+  }
+  /** Permanently shut down. */
+  dispose() {
+    this.#clearTimer();
+    this.#windowStart = null;
+    this.#lastScheduleAt = null;
+    this.#disposed = true;
+  }
+  #clearTimer() {
+    if (this.#timer !== null) {
+      clearTimeout(this.#timer);
+      this.#timer = null;
+    }
+  }
+};
+
 // src/services/mcp/push/status-broadcaster.ts
 var StatusBroadcaster = class {
   #deps;
+  /** Latest coalesced payload — replaced on every broadcast() call. */
+  #pending = null;
+  #timer;
+  /** Serial flush promise — deferred per Invariant #11 (no sync re-entry). */
+  #flushInProgress = Promise.resolve();
+  #disposed = false;
   constructor(deps) {
     this.#deps = deps;
+    this.#timer = new SlidingWindowTimer(EVENT_BATCHING.mcp, () => {
+      this.#flushInProgress = this.#flushInProgress.then(() => this.#flush());
+    });
   }
   /**
-   * Push the entire current snapshot to all peers.
+   * Schedule a coalesced broadcast of the current snapshot to all peers.
    *
    * `disabledNames` is the live workspace VISIBILITY set from the coordinator.
    * Required per-call — without it every FSM transition re-broadcasts
    * `visible:true` and silently clobbers a persisted workspace-disable (the
    * #4203 regression). It arrives per-call rather than at construction so the
    * broadcaster stays a thin push adapter with no visibility-state of its own.
+   *
+   * Multiple calls within the 150ms idle / 250ms max window collapse to one
+   * delivery of the LATEST pair.
    */
   broadcast(servers, disabledNames) {
+    if (this.#disposed) return;
+    this.#pending = { servers, disabledNames };
+    this.#timer.schedule();
+  }
+  /**
+   * Permanently shut down. Cancels the pending timer and discards any
+   * coalesced snapshot — the next channel attach re-pushes fresh MCP state
+   * via `attach-snapshot.ts:78` (`sendMcpStatusSnapshot`), so a discarded
+   * pending snapshot self-heals on reconnect.
+   */
+  dispose() {
+    this.#timer.dispose();
+    this.#pending = null;
+    this.#disposed = true;
+  }
+  #flush() {
+    if (this.#disposed) return Promise.resolve();
+    const snapshot = this.#pending;
+    this.#pending = null;
+    if (snapshot === null) return Promise.resolve();
+    const { servers, disabledNames } = snapshot;
     try {
       this.#deps.send({ type: "mcp_server_status", servers });
     } catch (err3) {
@@ -54762,6 +55080,7 @@ var StatusBroadcaster = class {
         error: err3 instanceof Error ? err3.message : String(err3)
       });
     }
+    return Promise.resolve();
   }
 };
 
@@ -66250,6 +66569,7 @@ var VisualizationFileWatcher = class {
           title: effect.title,
           content: effect.content
         });
+        this.#updateCanvasElementContent(effect);
         break;
       }
       case "persist_registry":
@@ -66468,7 +66788,7 @@ var VisualizationFileWatcher = class {
       title: effect.title,
       content
     });
-    const data = { slug: effect.slug, title: effect.title };
+    const data = { slug: effect.slug, title: effect.title, content };
     const nodeId = this.#deps.canvasRepo.createElement(effect.taskId, {
       type: effect.vizType,
       x: position.x,
@@ -66481,6 +66801,23 @@ var VisualizationFileWatcher = class {
     const followUp = this.registry.setCanvasElementId(effect.slug, `${nodeId}`);
     await this.executeEffects(followUp);
   }
+  /**
+   * Mirror the latest viz HTML into the canvas CRDT element's `data.content`
+   * on hot-reload so the inline-content reload fallback (`html-element.tsx`)
+   * stays current. Reads the existing element to preserve `slug`/`title`, then
+   * writes the merged `data` blob. A missing element (evicted/raced) is a
+   * no-op — the `viz_content` control push already covers the live path.
+   */
+  #updateCanvasElementContent(effect) {
+    const elements = this.#deps.canvasRepo.getElements(effect.taskId);
+    const target = elements.find((el) => `${el.id}` === effect.elementId);
+    if (!target) return;
+    const existing = target.data.data;
+    const existingData = typeof existing === "object" && existing !== null && !Array.isArray(existing) ? existing : {};
+    this.#deps.canvasRepo.updateElement(effect.taskId, target.id, {
+      data: { ...existingData, slug: effect.slug, title: effect.title, content: effect.content }
+    });
+  }
   async #handleFileChange(filePath) {
     let content;
     try {
@@ -74257,105 +74594,6 @@ function drainPendingRuntimeSwitch(ctx, taskId) {
   );
 }
 
-// src/services/event-batching.ts
-var EVENT_BATCHING = {
-  /**
-   * Comments: sliding window for review comment bursts.
-   * 20 s idle matches observed user typing cadence in review sessions (#2218).
-   */
-  comments: { idleMs: 2e4, maxWindowMs: 6e4 },
-  /**
-   * Resources: sliding window for file/plan/git/task pushes.
-   *
-   * Inverted in Wave 4 of the unified context-delivery refactor from 20s
-   * to 100ms. The 20s window made agent-triggered updates (TaskCreate /
-   * TaskUpdate, structured-task mutations, etc.) invisible to the agent
-   * for up to 20s after the tool call returned — the agent's next turn
-   * would be reasoning on stale state. 100ms still coalesces within-tick
-   * bursts and absorbs CRDT keystroke storms via each resolver's existing
-   * projection cache (task-metadata, branch, canvas all gate no-op
-   * re-emissions before the timer ever sees them).
-   *
-   * `maxWindowMs` retains the 60s cap as a guardrail for pathological
-   * never-quiet sources.
-   */
-  resources: { idleMs: 100, maxWindowMs: 6e4 },
-  /** Messages: sliding window for collab message micro-batching. */
-  messages: { idleMs: 250, maxWindowMs: 3e4 }
-};
-var MAX_COLLAB_BATCH_SIZE = 4;
-var SlidingWindowTimer = class {
-  #config;
-  #onFlush;
-  #timer = null;
-  #windowStart = null;
-  #lastScheduleAt = null;
-  #disposed = false;
-  constructor(config, onFlush) {
-    this.#config = config;
-    this.#onFlush = onFlush;
-  }
-  /**
-   * Schedule or reschedule the flush timer.
-   *
-   * - First call in a window: records `windowStart`, starts idle timer.
-   * - Subsequent calls: resets idle timer (sliding window).
-   * - If `maxWindowMs` exceeded: fires flush immediately.
-   */
-  schedule() {
-    if (this.#disposed) return;
-    if (this.#windowStart === null) {
-      this.#windowStart = Date.now();
-    } else if (Date.now() - this.#windowStart >= this.#config.maxWindowMs) {
-      this.#clearTimer();
-      this.#windowStart = null;
-      this.#lastScheduleAt = null;
-      this.#onFlush();
-      return;
-    }
-    this.#clearTimer();
-    this.#lastScheduleAt = Date.now();
-    this.#timer = setTimeout(() => {
-      this.#timer = null;
-      this.#windowStart = null;
-      this.#lastScheduleAt = null;
-      this.#onFlush();
-    }, this.#config.idleMs);
-  }
-  /** Cancel the pending timer without resetting the window. */
-  cancel() {
-    this.#clearTimer();
-  }
-  /** Reset the window start (call after draining the batch). */
-  reset() {
-    this.#windowStart = null;
-    this.#lastScheduleAt = null;
-  }
-  /**
-   * Epoch-ms at which the idle timer will fire, or null if no timer is
-   * scheduled. Tracks the most recent `schedule()` call (sliding window),
-   * not the original windowStart — used by ResourcePushManager to emit
-   * accurate `flushAt` values for all dirty URIs after each timer slide.
-   */
-  get nextFireAt() {
-    if (this.#timer === null || this.#lastScheduleAt === null) return null;
-    return this.#lastScheduleAt + this.#config.idleMs;
-  }
-  /** Permanently shut down. */
-  dispose() {
-    this.#clearTimer();
-    this.#windowStart = null;
-    this.#lastScheduleAt = null;
-    this.#disposed = true;
-  }
-  #clearTimer() {
-    if (this.#timer !== null) {
-      clearTimeout(this.#timer);
-      this.#timer = null;
-    }
-  }
-};
-
 // src/services/collab/collab-message-queue.ts
 var UNKNOWN_PARTICIPANT = "__unknown__";
 function formatCollabBatch(batch) {
@@ -78346,6 +78584,8 @@ var Thread = class {
   #sendControlMessage;
   #streamDelta = new ThreadStreamDeltaForwarder();
   #latestSettings = {};
+  #lastApiUsage = null;
+  #lastTurnResult = null;
   /**
    * Last values pushed to the live subprocess. Reset to undefined whenever
    * a fresh subprocess is attached (settings get applied via spawn options
@@ -79227,6 +79467,7 @@ var Thread = class {
       return;
     }
     if (event.type === "api_usage_snapshot") {
+      this.#lastApiUsage = event;
       this.#callbacks.onSubprocessEvent?.(event);
       return;
     }
@@ -79365,6 +79606,7 @@ var Thread = class {
         this.#recovery.resetRetriesOnTurnComplete();
         this.#cursorRecovery.reset();
         this.#rateLimitFlap.noteRecoveredOnTurnComplete((event.result.outputTokens ?? 0) > 0);
+        this.#emitThreadTurnStats(event.result);
         this.#manager.notifyTurnComplete();
         break;
       case "sdk_error":
@@ -79498,6 +79740,27 @@ var Thread = class {
     }
     this.#callbacks.onSubprocessEvent?.(event);
   }
+  #emitThreadTurnStats(result) {
+    if (!this.#config.permissionThreadId) return;
+    const prevResult = this.#lastTurnResult;
+    this.#lastTurnResult = result;
+    const stats = buildTurnStatsMessage(
+      this.#config.permissionTaskId ?? this.#config.threadId,
+      result,
+      null,
+      this.#lastApiUsage,
+      prevResult,
+      void 0,
+      this.#latestSettings.model ?? void 0,
+      null
+    );
+    this.#lastApiUsage = null;
+    if (stats.type !== "turn_stats") return;
+    this.#sendControlMessage?.({
+      ...stats,
+      threadId: this.#config.permissionThreadId
+    });
+  }
 };
 
 // src/services/plan/plan-handler.ts
@@ -79511,7 +79774,12 @@ import { dirname as dirname34, join as join72 } from "path";
 var SETTLE_BUDGET_MS = 2e3;
 async function ensurePlanDocRebuilt(deps) {
   try {
-    if (await settleAndCheckContent(deps)) return { kind: "has-content" };
+    const verdict = await settleAndCheckContent(deps);
+    if (verdict === "has-content") return { kind: "has-content" };
+    if (verdict === "storage-error") {
+      deps.log({ event: "plan_lazy_rebuild_storage_error", taskId: deps.taskId });
+      return { kind: "storage-error" };
+    }
     const sources = await gatherBackfillSources(
       deps.taskRecord,
       deps.taskId,
@@ -79553,7 +79821,9 @@ async function settleAndCheckContent(deps) {
     await sync(doc).waitForSync({ kind: "storage", timeout: SETTLE_BUDGET_MS });
   } catch {
   }
-  return deps.planRepo.getContent(deps.taskId).trim() !== "";
+  if (deps.planRepo.getContent(deps.taskId).trim() !== "") return "has-content";
+  const onDisk = await (deps.hasOnDiskDoc?.() ?? deps.planRepo.hasOnDiskDoc(deps.taskId));
+  return onDisk === true ? "storage-error" : "absent";
 }
 
 // src/services/plan/plan-detection-policy.ts
@@ -79622,6 +79892,21 @@ var PlanFileBridge = class _PlanFileBridge {
   #disposed = false;
   #hasAttachedContent = false;
   #writeBackInProgress = null;
+  /**
+   * Pending FM-8 re-attach scheduled after a recoverable wasm panic. Cancelled
+   * on dispose so a torn-down bridge never re-attaches against a dead task.
+   */
+  #reattachTimer = null;
+  /**
+   * One-shot loop guard: true while a panic-recovery re-attach is scheduled or
+   * running. The re-attach itself calls `updateContent`, which can panic again
+   * (on-disk chunks still poisoned). Without this gate that second panic would
+   * schedule a third re-attach, and so on — a hot recovery loop. Reset only when
+   * the re-attach finishes, so a single bounded retry fires per poisoning and a
+   * persistently-poisoned doc falls back to the next real file-change event (the
+   * prior recovery cadence), never a spin.
+   */
+  #reattachAfterPanicInFlight = false;
   static WRITE_BACK_DEBOUNCE_MS = 1e3;
   static FILE_READ_DEBOUNCE_MS = 500;
   #lastFileReadTime = 0;
@@ -79664,6 +79949,10 @@ var PlanFileBridge = class _PlanFileBridge {
    */
   async attach(filePath) {
     if (this.#disposed) return;
+    if (this.#reattachTimer) {
+      clearTimeout(this.#reattachTimer);
+      this.#reattachTimer = null;
+    }
     void this.#dirWatcher?.unsubscribe();
     this.#dirWatcher = null;
     this.#crdtUnsub?.();
@@ -79905,10 +80194,46 @@ var PlanFileBridge = class _PlanFileBridge {
           callSite: "plan-file-bridge.updateContent",
           errorMessage: err3 instanceof Error ? err3.message : String(err3)
         });
+        this.#scheduleReattachAfterPanic();
       }
       return err3;
     }
   }
+  /**
+   * FM-8: re-attach to the current file after a recoverable wasm panic so the
+   * fresh (post-eviction) CRDT is repopulated immediately. One-shot per
+   * poisoning via `#reattachAfterPanicInFlight` — a re-attach that panics again
+   * does NOT reschedule; recovery then falls back to the next real file-change
+   * event. No-op when disposed, when there is no file to re-read, or when a
+   * re-attach is already pending/running.
+   */
+  #scheduleReattachAfterPanic() {
+    if (this.#disposed || !this.#filePath || this.#reattachAfterPanicInFlight) return;
+    this.#reattachAfterPanicInFlight = true;
+    const filePath = this.#filePath;
+    this.#reattachTimer = setTimeout(() => {
+      this.#reattachTimer = null;
+      if (this.#disposed) {
+        this.#reattachAfterPanicInFlight = false;
+        return;
+      }
+      this.#config.log({
+        event: "plan_bridge_reattach_after_panic",
+        taskId: this.#config.taskId,
+        filePath
+      });
+      this.attach(filePath).catch((err3) => {
+        this.#config.log({
+          event: "plan_bridge_reattach_after_panic_failed",
+          taskId: this.#config.taskId,
+          filePath,
+          error: err3 instanceof Error ? err3.message : String(err3)
+        });
+      }).finally(() => {
+        this.#reattachAfterPanicInFlight = false;
+      });
+    }, 0);
+  }
   /**
    * Subscribe to CRDT changes (from browser edits arriving via WebRTC).
    * Debounced write-back to the plan file on disk.
@@ -80016,6 +80341,10 @@ var PlanFileBridge = class _PlanFileBridge {
       clearTimeout(this.#writeBackTimer);
       this.#writeBackTimer = null;
     }
+    if (this.#reattachTimer) {
+      clearTimeout(this.#reattachTimer);
+      this.#reattachTimer = null;
+    }
   }
   /**
    * Test-only: seed internal state so `flushWriteBack` can be exercised
@@ -84597,6 +84926,7 @@ function dispatchToCompactionSM(event, profile, now) {
 // src/services/task/orchestrator/task-event-dispatch.ts
 var AUTO_COMPACTION_CANCEL_DELAY_MS = 3e3;
 var AUTO_COMPACTION_REARM_DELTA = 0.05;
+var TASK_SNAPSHOT_URI_PREFIX2 = "shipyard://task-snapshot/";
 var AUTO_COMPACTION_MESSAGE_CEILING = 3e3;
 function decideAutoCompaction(params) {
   if (params.threshold === null) return { kind: "noop" };
@@ -84830,9 +85160,21 @@ function handleToolResultEcho(ctx, event) {
   ctx.resolveStructuredTaskCreates(event.content);
   ctx.handleWorktreeToolResults(event.content);
   ctx.handleSubagentToolResults(event.content);
+  trackTaskSnapshotLinksFromToolResults(ctx, event.content);
   ctx.trackPlanFileCreation(event.content);
   ctx.triggerCommitScan();
 }
+function trackTaskSnapshotLinksFromToolResults(ctx, content) {
+  for (const block of content) {
+    if (block.type !== "tool_result" || typeof block.content !== "string") continue;
+    if (!block.content.includes(TASK_SNAPSHOT_URI_PREFIX2)) continue;
+    for (const uri of extractToolResultResourceUris(block.content)) {
+      if (uri.startsWith(TASK_SNAPSHOT_URI_PREFIX2)) {
+        ctx.trackTaskSnapshotResource(uri);
+      }
+    }
+  }
+}
 function resolveCompactionEvents(ctx) {
   const parsed = AgentIdSchema.safeParse(ctx.getRuntimeId());
   if (!parsed.success) return null;
@@ -87164,6 +87506,12 @@ function applyDepEdgeAdditions(merged, depEdges) {
     }
   }
 }
+function findOverlayTask(overlay, taskId) {
+  return overlay?.userTasks.find((task) => task.id === taskId);
+}
+function getStructuredTaskForUpdate(tasks, overlay, taskId) {
+  return tasks.get(taskId) ?? findOverlayTask(overlay, taskId);
+}
 function applyCapabilitiesOverrides(merged, overrides) {
   if (!overrides) return;
   for (const [id, caps] of Object.entries(overrides)) {
@@ -87487,22 +87835,16 @@ var StructuredTaskTracker = class {
       }
       return false;
     }
-    const existing = this.#structuredTasks.get(taskId);
+    const existing = getStructuredTaskForUpdate(
+      this.#structuredTasks,
+      this.#currentOverlay,
+      taskId
+    );
     if (existing) {
       const prevStatus = existing.status;
       const updated = applyStructuredTaskChanges(existing, changes);
       this.#structuredTasks.set(taskId, updated);
-      if (prevStatus !== "in_progress" && updated.status === "in_progress") {
-        const caps = this.#resolveEffectiveCaps(taskId, updated);
-        this.#maybeFireItemActivated(taskId, caps);
-      }
-      return true;
-    }
-    const overlayTask = this.#currentOverlay?.userTasks.find((t) => t.id === taskId);
-    if (overlayTask) {
-      const prevStatus = overlayTask.status;
-      const updated = applyStructuredTaskChanges(overlayTask, changes);
-      this.#structuredTasks.set(taskId, updated);
+      this.#applyReciprocalDependencyChanges(taskId, changes);
       if (prevStatus !== "in_progress" && updated.status === "in_progress") {
         const caps = this.#resolveEffectiveCaps(taskId, updated);
         this.#maybeFireItemActivated(taskId, caps);
@@ -87516,6 +87858,36 @@ var StructuredTaskTracker = class {
     });
     return false;
   }
+  #applyReciprocalDependencyChanges(taskId, changes) {
+    for (const blockedTaskId of changes.addBlocks ?? []) {
+      const blockedTask = getStructuredTaskForUpdate(
+        this.#structuredTasks,
+        this.#currentOverlay,
+        blockedTaskId
+      );
+      if (blockedTask && !blockedTask.blockedBy.includes(taskId)) {
+        this.#structuredTasks.set(blockedTaskId, {
+          ...blockedTask,
+          blockedBy: [...blockedTask.blockedBy, taskId],
+          updatedAt: Date.now()
+        });
+      }
+    }
+    for (const prerequisiteTaskId of changes.addBlockedBy ?? []) {
+      const prerequisiteTask = getStructuredTaskForUpdate(
+        this.#structuredTasks,
+        this.#currentOverlay,
+        prerequisiteTaskId
+      );
+      if (prerequisiteTask && !prerequisiteTask.blocks.includes(taskId)) {
+        this.#structuredTasks.set(prerequisiteTaskId, {
+          ...prerequisiteTask,
+          blocks: [...prerequisiteTask.blocks, taskId],
+          updatedAt: Date.now()
+        });
+      }
+    }
+  }
   resolveStructuredTaskCreates(content) {
     this.#deps.log({
       event: "debug_resolve_creates",
@@ -88971,6 +89343,10 @@ var UsageTracker = class {
 };
 
 // src/services/task/orchestrator/task.ts
+var WORKTREE_ESCAPE_WARNING = "Working directory is now outside the Shipyard-managed worktree \u2014 the Changes tab will be empty until you return (cd back, or ExitWorktree).";
+function isOutsideTaskWorktreeRoot(newCwd, originalCwd) {
+  return originalCwd != null && newCwd !== originalCwd && !newCwd.startsWith(`${originalCwd}/`);
+}
 var Task = class {
   #deps;
   #threads = /* @__PURE__ */ new Map();
@@ -88984,6 +89360,7 @@ var Task = class {
   /** Task-level state */
   #cwd;
   #originalCwd;
+  #cwdEscapeWarningActive = false;
   #latestSettings = {};
   #pendingMessageMeta = [];
   #pendingWorktreeToolUseIds = /* @__PURE__ */ new Set();
@@ -90469,8 +90846,9 @@ var Task = class {
     return ack;
   }
   /**
-   * Clear the session: stop the agent, wipe conversation history, and reset to cold_idle.
-   * The next user message will start a completely fresh session.
+   * Clear visible session state and reset to cold_idle. The JSONL transcript
+   * stays on disk; subscribers hide prior rows via TaskRecord.clearedAtSeqNo.
+   * The next user message will start a completely fresh SDK session.
    */
   clearSession() {
     this.#deps.log({ event: "clear_session", taskId: this.#deps.taskId });
@@ -90499,11 +90877,18 @@ var Task = class {
     this.#getPrimary().enqueueAsync(async () => {
       this.#compaction.reset();
       await this.#sideThreads.dispose();
+      let clearedAtSeqNo = -1;
+      let markerPersisted = false;
       try {
-        await this.#deps.store.truncateAfter(this.#deps.channelId, -1);
+        const messages = await this.#deps.store.getMessages(this.#deps.channelId);
+        clearedAtSeqNo = messages.at(-1)?.seqNo ?? -1;
+        await this.#deps.taskStateStore.setClearedAtSeqNo(this.#deps.taskId, clearedAtSeqNo, {
+          broadcast: false
+        });
+        markerPersisted = true;
       } catch (err3) {
         this.#deps.log({
-          event: "clear_session_truncate_failed",
+          event: "clear_session_marker_failed",
           taskId: this.#deps.taskId,
           error: err3 instanceof Error ? err3.message : String(err3)
         });
@@ -90517,9 +90902,11 @@ var Task = class {
           error: err3 instanceof Error ? err3.message : String(err3)
         });
       }
+      if (!markerPersisted) return;
       this.#broadcastToAllPeers?.({
         type: "session_cleared",
-        taskId: this.#deps.taskId
+        taskId: this.#deps.taskId,
+        clearedAtSeqNo
       });
     });
   }
@@ -91009,6 +91396,26 @@ var Task = class {
       prevCwd: prevCwd ?? null,
       originalCwd: this.#originalCwd ?? null
     });
+    this.#applyCwdEscapeWarning(newCwd);
+  }
+  #applyCwdEscapeWarning(newCwd) {
+    const originalCwd = this.#originalCwd;
+    const escaped = isOutsideTaskWorktreeRoot(newCwd, originalCwd);
+    if (escaped) {
+      if (this.#cwdEscapeWarningActive) return;
+      this.#cwdEscapeWarningActive = true;
+      this.#deps.log({
+        event: "worktree_escaped_task_root",
+        taskId: this.#deps.taskId,
+        newCwd,
+        originalCwd: originalCwd ?? null
+      });
+      this.#handleTaskError(WORKTREE_ESCAPE_WARNING, "sdk_error");
+      return;
+    }
+    if (!this.#cwdEscapeWarningActive) return;
+    this.#cwdEscapeWarningActive = false;
+    this.#broadcastToAllPeers?.({ type: "task_error_cleared", taskId: this.#deps.taskId });
   }
   #trackPlanFileFromToolUse(content) {
     trackPlanFileFromToolUse(content, (path5) => this.#planHandler.trackCreatedFile(path5));
@@ -91211,6 +91618,7 @@ var Task = class {
         this.#pushManager.track(buildDevServersUri(this.#deps.taskId));
         this.#pushManager.track(buildTerminalsUri(this.#deps.taskId));
       },
+      trackTaskSnapshotResource: (uri) => this.#pushManager.track(uri),
       pushManagerTurnStart: () => this.#pushManager.onTurnStart(),
       pushManagerTurnEnd: () => this.#pushManager.onTurnEnd(),
       broadcastSessionMcps: (mcpServers) => this.#broadcastSessionMcps(mcpServers),
@@ -91929,7 +92337,7 @@ async function persistUserMessageAtChokepoint(args) {
       messageId: randomUUID24(),
       channelId: args.channelId,
       participantId: args.participantId ?? buildHumanParticipantId(args.userId),
-      senderKind: "human",
+      senderKind: args.senderKind ?? "human",
       content: stripBlobResourcesForStorage(args.content),
       timestamp: Date.now(),
       ...persistedCorrelationId !== void 0 && { correlationId: persistedCorrelationId },
@@ -93416,7 +93824,7 @@ var TaskManager = class {
     });
     return task;
   }
-  async handleUserMessage(taskId, content, settings, cwd, participantId, senderDisplayName, correlationId) {
+  async handleUserMessage(taskId, content, settings, cwd, participantId, senderDisplayName, correlationId, senderKind = "human") {
     const task = await this.#ensureTaskForUserMessage(taskId);
     if (cwd && cwd !== task.cwd) {
       if (task.mode === "review" && !task.cwd) {
@@ -93446,6 +93854,7 @@ var TaskManager = class {
       settings: normalizedSettings,
       latestSettings: task.orchestrator.latestSettings,
       participantId,
+      senderKind,
       correlationId
     });
     task.orchestrator.handleUserMessage(
@@ -94061,20 +94470,21 @@ function fingerprintSkillRows(rows) {
 }
 
 // src/services/task-snapshot-resource-resolver.ts
-var TASK_SNAPSHOT_URI_PREFIX2 = "shipyard://task-snapshot/";
+var TASK_SNAPSHOT_URI_PREFIX3 = "shipyard://task-snapshot/";
 var PREVIEW_CHARS = 240;
+var HUMAN_STEERING_LIMIT = 3;
 var TASK_ID_SEGMENT_PATTERN = /^[A-Za-z0-9_-]+$/;
 function buildTaskSnapshotResourceUri(taskId) {
   if (!TASK_ID_SEGMENT_PATTERN.test(taskId)) {
     throw new Error(`Invalid taskId for task-snapshot URI: ${taskId}`);
   }
-  return `${TASK_SNAPSHOT_URI_PREFIX2}${taskId}`;
+  return `${TASK_SNAPSHOT_URI_PREFIX3}${taskId}`;
 }
 function parseTaskSnapshotResourceUri(uri) {
-  if (!uri.startsWith(TASK_SNAPSHOT_URI_PREFIX2)) {
+  if (!uri.startsWith(TASK_SNAPSHOT_URI_PREFIX3)) {
     throw new Error(`Invalid task-snapshot URI: ${uri}`);
   }
-  const taskId = uri.slice(TASK_SNAPSHOT_URI_PREFIX2.length);
+  const taskId = uri.slice(TASK_SNAPSHOT_URI_PREFIX3.length);
   if (!TASK_ID_SEGMENT_PATTERN.test(taskId)) {
     throw new Error(`Invalid task-snapshot URI: ${uri}`);
   }
@@ -94112,9 +94522,23 @@ function renderTaskSnapshot(ctx) {
   lines.push(`| planFilePath | ${ctx.planFilePath ?? "(none)"} |`);
   lines.push(`| lastAssistantTurnPreview | ${ctx.lastAssistantTurnPreview ?? "(none)"} |`);
   lines.push(`| deliverableCount | ${ctx.deliverables.length} |`);
+  lines.push(...renderHumanSteeringSection(ctx.humanSteering));
+  lines.push(...renderApprovedPlanSection(ctx.approvedPlanSummary));
   lines.push(...renderDeliverablesSection(ctx.deliverables));
   return lines.join("\n");
 }
+function renderHumanSteeringSection(steering) {
+  if (steering.length === 0) return [];
+  const out = ["", "## Human steering", ""];
+  for (const item of steering) {
+    out.push(`- ${formatTimestamp(item.timestamp)}: ${escapeListItem(item.text)}`);
+  }
+  return out;
+}
+function renderApprovedPlanSection(summary) {
+  if (!summary) return [];
+  return ["", "## Approved plan", "", escapeListItem(summary)];
+}
 function renderDeliverablesSection(deliverables) {
   if (deliverables.length === 0) return [];
   const out = [
@@ -94135,6 +94559,9 @@ function renderDeliverablesSection(deliverables) {
 function escapeCell(text) {
   return text.replace(/\|/g, "\\|").replace(/\n/g, " ");
 }
+function escapeListItem(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
 function extractTaskSnapshotDigest(ctx) {
   const r = ctx.record;
   const ci = ctx.ci ? `${ctx.ci.passing}/${ctx.ci.failing}/${ctx.ci.pending}` : "";
@@ -94169,6 +94596,8 @@ function extractTaskSnapshotDigest(ctx) {
     ctx.awaitingPlanApproval,
     ctx.planFilePath,
     ctx.lastAssistantTurnPreview,
+    ctx.humanSteering.map((m2) => `${m2.seqNo}:${m2.text}`).join(","),
+    ctx.approvedPlanSummary,
     /**
      * Deliverable digest: count + ordered (id, kind) tuples joined to a
      * single string so the digest array stays primitive-typed. Registration
@@ -94248,7 +94677,25 @@ function findLastAssistantPreview(messages) {
   }
   return null;
 }
+function findRecentHumanSteering(messages, opts) {
+  const humanMessages = messages.filter((m2) => m2.senderKind === "human");
+  const steering = opts.hasEarlierMessages ? humanMessages : humanMessages.slice(1);
+  return steering.map((m2) => {
+    const text = collectMessageText(m2);
+    if (!text) return null;
+    return { seqNo: m2.seqNo, timestamp: m2.timestamp, text: previewSlice(text) };
+  }).filter((m2) => m2 !== null).slice(-HUMAN_STEERING_LIMIT);
+}
+function summarizeApprovedPlan(markdown) {
+  if (!markdown) return null;
+  const firstMeaningfulLine = markdown.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
+  if (!firstMeaningfulLine) return null;
+  return previewSlice(firstMeaningfulLine.replace(/^#{1,6}\s+/, ""));
+}
 function collectAgentText(m2) {
+  return collectMessageText(m2);
+}
+function collectMessageText(m2) {
   const parts = [];
   for (const block of m2.content) {
     if (block.type === "text" && block.text) parts.push(block.text);
@@ -94396,6 +94843,8 @@ function wireTaskSnapshotResource(deps) {
       mergeable: prSummary.mergeable,
       branchName,
       lastAssistantTurnPreview: findLastAssistantPreview(tail.messages),
+      humanSteering: findRecentHumanSteering(tail.messages, { hasEarlierMessages: tail.hasMore }),
+      approvedPlanSummary: planDetection?.approved === true ? summarizeApprovedPlan(planDetection.originalMarkdown) : null,
       deliverables
     };
   }
@@ -95464,6 +95913,7 @@ async function createDaemon(deps) {
     return dispatchSpawn(decision, {
       onEvent,
       initialContent: initialContent ?? [],
+      log: deps.log,
       spawnClaude,
       spawnCursor,
       spawnCodex: () => {
@@ -100175,4 +100625,4 @@ export {
   decideWorkspaceScope,
   serve
 };
-//# sourceMappingURL=serve-2N7BIGRO.js.map
+//# sourceMappingURL=serve-3N7IHREI.js.map