@prismer/runtime 2.0.3 → 2.0.5

package/dist/cli.js

@@ -154,6 +154,42 @@ import { fileURLToPath } from "url";
 import Database from "better-sqlite3";
 import * as YAML from "yaml";
 import { z as z3 } from "zod";
+function readPlainRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function sanitizeRoleSkillSlug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60) || "template";
+}
+function renderRoleTemplateSkill(skillName, agents, roleTemplate) {
+  const mcpServers = Array.isArray(roleTemplate?.mcpServers) ? roleTemplate.mcpServers : [];
+  const tools = /* @__PURE__ */ new Set();
+  for (const server of mcpServers) {
+    const rec = readPlainRecord(server);
+    const allowlist = Array.isArray(rec?.toolsAllowlist) ? rec.toolsAllowlist : [];
+    for (const tool of allowlist) {
+      if (typeof tool === "string" && tool.trim()) tools.add(tool.trim());
+    }
+  }
+  const allowedTools = [...tools].join(" ");
+  const roleTemplateSlug = JSON.stringify(readNonEmptyString(roleTemplate?.slug) ?? null);
+  return `---
+name: ${skillName}
+description: Role-template operating playbook projected from Prismer RoleTemplate.
+${allowedTools ? `allowed-tools: ${allowedTools}
+` : ""}metadata:
+  prismer:
+    source: role-template
+    roleTemplateSlug: ${roleTemplateSlug}
+---
+
+# Role Template Playbook
+
+${agents.trim()}
+`;
+}
 function parsePrismerGoals(value) {
   if (!Array.isArray(value)) return [];
   return value.map((entry) => {
@@ -563,13 +599,14 @@ function failure(status, body) {
     error: { code: "adapter_dispatch_failed", message: `Hermes ${status}: ${body || "<no body>"}` }
   };
 }
-async function consumeSse(body, task) {
+async function consumeSse(body, task, state) {
   const reader = body.getReader();
   const decoder = new TextDecoder();
   let buf = "";
   let deltas = "";
   let finalOutput;
   let lastProgress = 0;
+  let approvalRequested = false;
   for (; ; ) {
     const readStart = Date.now();
     const { value, done } = await reader.read();
@@ -618,6 +655,10 @@ async function consumeSse(body, task) {
         const next = Math.min(0.99, lastProgress + 0.05);
         lastProgress = next;
         const toolName = typeof payload.tool === "string" ? payload.tool : typeof payload.name === "string" ? payload.name : void 0;
+        if (eventName === "tool.started" && toolName === APPROVAL_TOOL_NAME) {
+          approvalRequested = true;
+          if (state) state.approvalRequested = true;
+        }
         const previewStr = typeof payload.preview === "string" ? payload.preview : payload.preview != null ? JSON.stringify(payload.preview).slice(0, 200) : void 0;
         task.onProgress?.({
           progress: next,
@@ -647,7 +688,53 @@ async function consumeSse(body, task) {
       }
     }
   }
-  return finalOutput && finalOutput.length > 0 ? finalOutput : deltas;
+  return {
+    output: finalOutput && finalOutput.length > 0 ? finalOutput : deltas,
+    approvalRequested
+  };
+}
+async function consumeChatCompletionsSse(body, task) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  let output = "";
+  let lastProgress = 0;
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    const events = buf.split("\n\n");
+    buf = events.pop() ?? "";
+    for (const ev of events) {
+      const dataLine = ev.match(/^data: (.+)$/m);
+      if (!dataLine) continue;
+      const raw = dataLine[1].trim();
+      if (raw === "[DONE]") continue;
+      let payload;
+      try {
+        payload = JSON.parse(raw);
+      } catch (err) {
+        process.stderr.write(
+          `[hermes-adapter] chat-completions SSE parse skipped: ${err.message}
+`
+        );
+        continue;
+      }
+      const delta = payload.choices?.[0]?.delta?.content;
+      if (typeof delta === "string") {
+        output += delta;
+      } else if (Array.isArray(delta)) {
+        for (const part of delta) {
+          if (part?.type === "text" && typeof part.text === "string") output += part.text;
+        }
+      }
+      if (output.length > 0 && lastProgress < 0.99) {
+        lastProgress = Math.min(0.99, lastProgress + 0.05);
+        task.onProgress?.({ progress: lastProgress, message: "streaming" });
+      }
+    }
+  }
+  return output;
 }
 async function checkHealth(baseUrl, apiKey) {
   try {
@@ -728,13 +815,14 @@ function pidAlive(pid) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var PRISMER_IM_SKILL_NAME, PRISMER_IM_SKILL_CONTENT, HermesProfileConfigSchema, hermesAdapter, HermesService;
+var PRISMER_IM_SKILL_NAME, PRISMER_ROLE_SKILL_PREFIX, PRISMER_IM_SKILL_CONTENT, HermesProfileConfigSchema, hermesAdapter, HermesService, APPROVAL_TOOL_NAME;
 var init_hermes = __esm({
   "src/adapters/hermes/index.ts"() {
     "use strict";
     init_contract();
     init_skill_loader2();
     PRISMER_IM_SKILL_NAME = "prismer-im-collab";
+    PRISMER_ROLE_SKILL_PREFIX = "prismer-role";
     PRISMER_IM_SKILL_CONTENT = `---
 name: prismer-im-collab
 description: Coordinate reliably in Prismer conversations, use workspace assets through bounded MCP tools, and keep task work on the board.
@@ -1047,6 +1135,7 @@ No @ needed; the human is the only other party.
         const startedAt = Date.now();
         let runId;
         const sysPrompt = typeof task.metadata?.systemPrompt === "string" ? task.metadata.systemPrompt : void 0;
+        this.installRoleTemplateSkill();
         const skillPrompt = await this.skillLoader.loadSystemPromptFragment().catch((err) => {
           process.stderr.write(
             `[hermes-adapter] failed to read skills for ${this.profileName}: ${err.message}
@@ -1054,7 +1143,21 @@ No @ needed; the human is the only other party.
           );
           return void 0;
         });
-        const instructions = [sysPrompt, skillPrompt].filter(Boolean).join("\n\n");
+        const outboxDir = typeof task.metadata?.prismerOutboxDir === "string" ? task.metadata.prismerOutboxDir : void 0;
+        const outboxDirective = outboxDir ? [
+          "[Outbox directive \u2014 MANDATORY, overrides any prior outbox path]",
+          "",
+          "For THIS turn ONLY, your active outbox is:",
+          `  ${outboxDir}`,
+          "",
+          "Any user-deliverable file (PDF, image, CSV, archive, doc) MUST be",
+          "written to that EXACT absolute path. Do NOT reuse the outbox path",
+          "from any previous turn \u2014 those directories no longer accept new",
+          "uploads. Do NOT copy files into the previous outbox; copy them",
+          "into the path above. Files outside this directory will not become",
+          'chat attachments and the user will see "no files were attached".'
+        ].join("\n") : "";
+        const instructions = [outboxDirective, sysPrompt, skillPrompt].filter(Boolean).join("\n\n");
         if (sysPrompt) {
           try {
             const profileDir = getHermesProfileDir(this.profileName);
@@ -1078,8 +1181,15 @@ No @ needed; the human is the only other party.
 `
           );
         }
+        const sseState = { approvalRequested: false };
         try {
           const nativeBridgePatch = await this.prepareNativeBridgePatch(task);
+          const imageRefs = (task.assetRefs ?? []).filter(
+            (r) => r.mime?.startsWith("image/")
+          );
+          if (imageRefs.length > 0) {
+            return await this.dispatchMultimodalChat(task, instructions, imageRefs, startedAt);
+          }
           const createRes = await fetch(`${this.baseUrl}/v1/runs`, {
             method: "POST",
             headers: {
@@ -1130,10 +1240,10 @@ No @ needed; the human is the only other party.
               }
             };
           }
-          const output = await consumeSse(eventsRes.body, task);
+          const sseResult = await consumeSse(eventsRes.body, task, sseState);
           return {
             ok: true,
-            output,
+            output: sseResult.output,
             metrics: { durationMs: Date.now() - startedAt },
             metadata: {
               hermes: this.bridgeSnapshot("dispatched", {
@@ -1141,7 +1251,13 @@ No @ needed; the human is the only other party.
                 runId,
                 baseUrl: this.baseUrl,
                 model: this.config.model
-              })
+              }),
+              // Surfaced to dispatch.ts so a subsequent reaper kill on this
+              // task is reclassified as `awaiting_human_approval` rather than
+              // `daemon_task_timeout`. Lives under a stable key (not under
+              // `hermes.*`) so non-hermes adapters can adopt the same signal
+              // later without bleeding hermes-specific metadata shape.
+              ...sseResult.approvalRequested ? { approvalRequested: true } : {}
             }
           };
         } catch (err) {
@@ -1151,6 +1267,7 @@ No @ needed; the human is the only other party.
           );
           const categorized = categorizeDispatchError(err, task.signal);
           const bridgeKind = categorized.error?.code === "task_cancelled" ? "cancelled" : "failed";
+          const approvalSignal = sseState.approvalRequested ? { approvalRequested: true } : {};
           return {
             ...categorized,
             metadata: {
@@ -1159,13 +1276,87 @@ No @ needed; the human is the only other party.
                 baseUrl: this.baseUrl,
                 model: this.config.model,
                 ...bridgeKind === "failed" ? { error: err.message } : {}
-              })
+              }),
+              ...approvalSignal
             }
           };
         } finally {
           if (runId && this.currentRunId === runId) this.currentRunId = void 0;
         }
       }
+      /**
+       * 14b rev.3 §3.0.4 — Hermes multimodal path.
+       *
+       * Builds an OpenAI-shape chat/completions body where the user message
+       * `content` is a multipart array (`{type:'text'}` + N × `{type:'image_url'}`).
+       * Hermes `_normalize_multimodal_content` (api_server.py:170) collapses the
+       * blocks into its native multimodal representation before routing into
+       * the agent pipeline.
+       *
+       * `image_url.url` is the cdn URL when the daemon's reachability probe said
+       * the upstream LLM can see it (D35 path A); otherwise it's a `data:` URI
+       * carrying the base64 bytes the daemon pre-fetched (D35 path B fallback).
+       * The adapter doesn't decide — `resolveAssetRefs` does, and the adapter
+       * just shuttles `cdnUrl ?? data:base64` into the wire.
+       */
+      async dispatchMultimodalChat(task, instructions, imageRefs, startedAt) {
+        const userContent = [{ type: "text", text: task.prompt }];
+        for (const r of imageRefs) {
+          const url = r.reachable === "cdn" && r.cdnUrl ? r.cdnUrl : r.base64 ? `data:${r.mime ?? "image/png"};base64,${r.base64}` : r.cdnUrl ?? "";
+          if (!url) {
+            userContent.push({
+              type: "text",
+              text: `[image attachment id=${r.assetId} mime=${r.mime ?? "unknown"} unavailable: cdn not reachable and bytes exceeded inline cap]`
+            });
+            continue;
+          }
+          userContent.push({ type: "image_url", image_url: { url, detail: "auto" } });
+        }
+        const messages = [];
+        if (instructions) messages.push({ role: "system", content: instructions });
+        messages.push({ role: "user", content: userContent });
+        const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.config.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            model: this.config.model,
+            messages,
+            stream: true
+          }),
+          signal: task.signal
+        });
+        if (!res.ok) {
+          const body = await res.text().catch(() => "");
+          return failure(res.status, body);
+        }
+        if (!res.body) {
+          return {
+            ok: false,
+            error: {
+              code: "adapter_dispatch_failed",
+              message: "Hermes /v1/chat/completions returned no body"
+            }
+          };
+        }
+        const output = await consumeChatCompletionsSse(res.body, task);
+        return {
+          ok: true,
+          output,
+          metrics: { durationMs: Date.now() - startedAt },
+          metadata: {
+            hermes: this.bridgeSnapshot("dispatched", {
+              endpoint: "/v1/chat/completions",
+              multimodal: true,
+              imageRefs: imageRefs.length,
+              baseUrl: this.baseUrl,
+              model: this.config.model
+            })
+          }
+        };
+      }
       async shutdown() {
         if (this.currentRunId) await this.stopRun(this.currentRunId);
       }
@@ -1187,6 +1378,25 @@ No @ needed; the human is the only other party.
         ]);
         return { ...kanbanPatch, ...goalsPatch };
       }
+      installRoleTemplateSkill() {
+        const roleTemplate = readPlainRecord(this.config.roleTemplate);
+        const hermesConfig = readPlainRecord(roleTemplate?.hermesConfig);
+        const agents = readNonEmptyString(hermesConfig?.agents);
+        if (!agents) return;
+        const slug = sanitizeRoleSkillSlug(readNonEmptyString(roleTemplate?.slug) ?? "template");
+        const skillName = `${PRISMER_ROLE_SKILL_PREFIX}-${slug}`;
+        const content = renderRoleTemplateSkill(skillName, agents, roleTemplate);
+        try {
+          const skillDir = join2(this.skillLoader.getSkillsRoot(), skillName);
+          mkdirSync(skillDir, { recursive: true });
+          writeFileSync(join2(skillDir, "SKILL.md"), content, "utf8");
+        } catch (err) {
+          process.stderr.write(
+            `[hermes-adapter] failed to install role-template skill ${skillName} for ${this.profileName}: ${err.message}
+`
+          );
+        }
+      }
       async prepareNativeKanbanPatch(task) {
         const sourceKind = typeof task.metadata?.sourceKind === "string" ? task.metadata.sourceKind : null;
         const parentTaskId = typeof task.metadata?.parentTaskId === "string" ? task.metadata.parentTaskId : null;
@@ -1295,6 +1505,7 @@ No @ needed; the human is the only other party.
         };
       }
     };
+    APPROVAL_TOOL_NAME = "prismer.approval.request_human_approval";
   }
 });
 
@@ -1327,8 +1538,61 @@ var init_skill_loader3 = __esm({
 
 // src/adapters/openclaw/index.ts
 import { z as z4 } from "zod";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
+function readPlainRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readNonEmptyString2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function sanitizeRoleSkillSlug2(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60) || "template";
+}
+function renderRoleTemplateSkill2(skillName, agents, roleTemplate) {
+  const mcpServers = Array.isArray(roleTemplate?.mcpServers) ? roleTemplate.mcpServers : [];
+  const tools = /* @__PURE__ */ new Set();
+  for (const server of mcpServers) {
+    const rec = readPlainRecord2(server);
+    const allowlist = Array.isArray(rec?.toolsAllowlist) ? rec.toolsAllowlist : [];
+    for (const tool of allowlist) {
+      if (typeof tool === "string" && tool.trim()) tools.add(tool.trim());
+    }
+  }
+  const allowedTools = [...tools].join(" ");
+  const roleTemplateSlug = JSON.stringify(readNonEmptyString2(roleTemplate?.slug) ?? null);
+  return `---
+name: ${skillName}
+description: Role-template operating playbook projected from Prismer RoleTemplate.
+${allowedTools ? `allowed-tools: ${allowedTools}
+` : ""}metadata:
+  prismer:
+    source: role-template
+    roleTemplateSlug: ${roleTemplateSlug}
+---
+
+# Role Template Playbook
+
+${agents.trim()}
+`;
+}
+function pickResponsesSource(ref) {
+  if (ref.reachable === "cdn" && ref.cdnUrl) {
+    return { type: "url", url: ref.cdnUrl };
+  }
+  if (ref.base64) {
+    return {
+      type: "base64",
+      data: ref.base64,
+      media_type: ref.mime ?? "application/octet-stream"
+    };
+  }
+  if (ref.cdnUrl) {
+    return { type: "url", url: ref.cdnUrl };
+  }
+  return null;
+}
 function getOpenClawSkillsDir(profile) {
   const config = OpenClawProfileConfigSchema.parse(profile.config);
   return resolveOpenClawSkillsDir(profile, config);
@@ -1349,12 +1613,13 @@ async function checkHealth2(baseUrl, apiKey) {
     return false;
   }
 }
-var OpenClawProfileConfigSchema, openclawAdapter, OpenClawService;
+var PRISMER_ROLE_SKILL_PREFIX2, OpenClawProfileConfigSchema, openclawAdapter, OpenClawService;
 var init_openclaw = __esm({
   "src/adapters/openclaw/index.ts"() {
     "use strict";
     init_contract();
     init_skill_loader3();
+    PRISMER_ROLE_SKILL_PREFIX2 = "prismer-role";
     OpenClawProfileConfigSchema = z4.object({
       /** OpenClaw chat-completions HTTP port. */
       port: z4.number().int().min(1).max(65535).default(18789),
@@ -1399,23 +1664,25 @@ var init_openclaw = __esm({
           );
         }
         const skillsDir = resolveOpenClawSkillsDir(profile, config);
-        return new OpenClawService(baseUrl, config.apiKey, config.model, new OpenClawSkillLoader(skillsDir));
+        return new OpenClawService(baseUrl, config.apiKey, config.model, config, new OpenClawSkillLoader(skillsDir));
       },
       async health() {
         return { available: true };
       }
     };
     OpenClawService = class {
-      constructor(baseUrl, apiKey, model, skillLoader) {
+      constructor(baseUrl, apiKey, model, config, skillLoader) {
         this.baseUrl = baseUrl;
         this.apiKey = apiKey;
         this.model = model;
+        this.config = config;
         this.skillLoader = skillLoader;
         this.id = baseUrl;
       }
       baseUrl;
       apiKey;
       model;
+      config;
       skillLoader;
       id;
       async healthy() {
@@ -1424,17 +1691,47 @@ var init_openclaw = __esm({
       async dispatch(task) {
         const startedAt = Date.now();
         const systemPrompt = typeof task.metadata?.systemPrompt === "string" ? task.metadata.systemPrompt : void 0;
+        this.installRoleTemplateSkill();
         const skillPrompt = await this.skillLoader.loadSystemPromptFragment().catch((err) => {
           process.stderr.write(`[openclaw-adapter] failed to read skills: ${err.message}
 `);
           return void 0;
         });
         const systemContent = [systemPrompt, skillPrompt].filter(Boolean).join("\n\n");
-        const messages = [];
-        if (systemContent) messages.push({ role: "system", content: systemContent });
-        messages.push({ role: "user", content: task.prompt });
+        const refs = task.assetRefs ?? [];
+        const imageRefs = refs.filter((r) => r.mime?.startsWith("image/"));
+        const fileRefs = refs.filter((r) => r.mime && !r.mime.startsWith("image/"));
+        const inputContent = [
+          { type: "input_text", text: task.prompt }
+        ];
+        for (const r of imageRefs) {
+          const source = pickResponsesSource(r);
+          if (!source) {
+            inputContent.push({
+              type: "input_text",
+              text: `[image attachment id=${r.assetId} unavailable: cdn unreachable and bytes exceeded inline cap]`
+            });
+            continue;
+          }
+          inputContent.push({ type: "input_image", source });
+        }
+        for (const r of fileRefs) {
+          const source = pickResponsesSource(r);
+          if (!source) {
+            inputContent.push({
+              type: "input_text",
+              text: `[file attachment id=${r.assetId} mime=${r.mime ?? "unknown"} unavailable]`
+            });
+            continue;
+          }
+          if (r.filename && source.type === "base64") {
+            source.filename = r.filename;
+          }
+          inputContent.push({ type: "input_file", source });
+        }
+        const input = [{ type: "message", role: "user", content: inputContent }];
         try {
-          const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+          const res = await fetch(`${this.baseUrl}/v1/responses`, {
             method: "POST",
             headers: {
               Authorization: `Bearer ${this.apiKey}`,
@@ -1442,7 +1739,11 @@ var init_openclaw = __esm({
             },
             body: JSON.stringify({
               model: this.model,
-              messages,
+              input,
+              // OpenClaw `/v1/responses` accepts top-level `instructions` for
+              // the system prompt — keeping it out of the user message
+              // preserves cleanish channel-context separation.
+              ...systemContent ? { instructions: systemContent } : {},
               stream: false
             }),
             signal: task.signal
@@ -1458,7 +1759,21 @@ var init_openclaw = __esm({
             };
           }
           const json = await res.json();
-          let output = json.choices?.[0]?.message?.content ?? "";
+          let output = "";
+          if (Array.isArray(json.output)) {
+            for (const item of json.output) {
+              if (item?.type === "message" && Array.isArray(item.content)) {
+                for (const part of item.content) {
+                  if (part?.type === "output_text" && typeof part.text === "string") {
+                    output += part.text;
+                  }
+                }
+              }
+            }
+          }
+          if (!output) {
+            output = json.choices?.[0]?.message?.content ?? "";
+          }
           const ERR_PREFIX_RE = /^Cannot read properties of undefined \(reading '[^']+'\)\s*\n+/;
           if (ERR_PREFIX_RE.test(output)) {
             process.stderr.write(
@@ -1476,6 +1791,25 @@ var init_openclaw = __esm({
           return categorizeDispatchError(err, task.signal);
         }
       }
+      installRoleTemplateSkill() {
+        const roleTemplate = readPlainRecord2(this.config.roleTemplate);
+        const openclawConfig = readPlainRecord2(roleTemplate?.openclawConfig);
+        const agents = readNonEmptyString2(openclawConfig?.agents);
+        if (!agents) return;
+        const slug = sanitizeRoleSkillSlug2(readNonEmptyString2(roleTemplate?.slug) ?? "template");
+        const skillName = `${PRISMER_ROLE_SKILL_PREFIX2}-${slug}`;
+        const content = renderRoleTemplateSkill2(skillName, agents, roleTemplate);
+        try {
+          const skillDir = join3(this.skillLoader.getSkillsRoot(), skillName);
+          mkdirSync2(skillDir, { recursive: true });
+          writeFileSync2(join3(skillDir, "SKILL.md"), content, "utf8");
+        } catch (err) {
+          process.stderr.write(
+            `[openclaw-adapter] failed to install role-template skill ${skillName}: ${err.message}
+`
+          );
+        }
+      }
     };
   }
 });
@@ -1911,7 +2245,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@prismer/runtime",
-      version: "2.0.3",
+      version: "2.0.5",
       description: "Prismer Cloud daemon runtime \u2014 TS-only adapter host for hosted IM agents",
       type: "module",
       main: "dist/index.js",
@@ -1945,6 +2279,7 @@ var require_package = __commonJS({
       },
       dependencies: {
         "@iarna/toml": "^2.2.5",
+        "@modelcontextprotocol/sdk": "^1.29.0",
         "better-sqlite3": "^11.8.0",
         commander: "^12.1.0",
         qrcode: "^1.5.4",
@@ -2006,7 +2341,7 @@ __export(util_exports, {
   warn: () => warn,
   writePidFile: () => writePidFile
 });
-import { existsSync as existsSync4, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
 import { join as join5 } from "path";
 function color(kind, text) {
   if (process.env.NO_COLOR === "1" || process.env.NO_COLOR === "true") return text;
@@ -2104,7 +2439,7 @@ function pidFilePath(paths) {
   return join5(paths.root, "daemon.pid");
 }
 function writePidFile(paths, pid) {
-  writeFileSync3(pidFilePath(paths), `${pid}
+  writeFileSync4(pidFilePath(paths), `${pid}
 `, "utf8");
 }
 function readPidFile(paths) {
@@ -2203,11 +2538,39 @@ async function syncAllAgentSkills(profiles, cloud, options = {}) {
 }
 async function syncInstalledSkillsForDispatch(profile, agentImUserId, cloud, signal) {
   if (!agentImUserId) return { synced: 0, skipped: 0, unchanged: 0 };
-  const data = await cloud.get(
+  let data = await cloud.get(
     `/api/im/skills/installed?agentId=${encodeURIComponent(agentImUserId)}`,
     { signal }
   );
-  const entries = normalizeInstalledSkills(data);
+  let entries = normalizeInstalledSkills(data);
+  if (entries.length === 0 && (profile.adapterName === "hermes" || profile.adapterName === "openclaw")) {
+    try {
+      const backfill = await cloud.request(
+        "POST",
+        `/api/im/agents/${encodeURIComponent(agentImUserId)}/skills/install-builtins`,
+        { body: {}, signal }
+      );
+      if (backfill.ok && backfill.data && typeof backfill.data === "object" && "data" in backfill.data) {
+        const installed = backfill.data.data?.installed ?? 0;
+        if (installed > 0) {
+          process.stdout.write(
+            `[daemon] skill sync: backfilled ${installed} built-in skills for agent ${agentImUserId.slice(-8)}
+`
+          );
+          data = await cloud.get(
+            `/api/im/skills/installed?agentId=${encodeURIComponent(agentImUserId)}`,
+            { signal }
+          );
+          entries = normalizeInstalledSkills(data);
+        }
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[daemon] skill sync: backfill skipped for ${agentImUserId.slice(-8)}: ${err.message}
+`
+      );
+    }
+  }
   const skillsRoot = resolveSkillsRoot(profile);
   if (!skillsRoot) return { synced: 0, skipped: 0, unchanged: 0 };
   let synced = 0;
@@ -2526,10 +2889,10 @@ import { spawnSync as spawnSync2 } from "child_process";
 import {
   copyFileSync,
   existsSync as existsSync5,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   readFileSync as readFileSync5,
   statSync,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
 import { homedir as homedir4 } from "os";
 import { dirname as dirname4, join as join6 } from "path";
@@ -3029,7 +3392,7 @@ init_openclaw();
 
 // src/config.ts
 import * as TOML from "@iarna/toml";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname2, join as join4 } from "path";
 import { z as z5 } from "zod";
@@ -3096,13 +3459,13 @@ function loadConfig(paths = resolvePaths()) {
 }
 function saveConfig(config, paths = resolvePaths()) {
   if (!existsSync2(paths.root)) {
-    mkdirSync2(paths.root, { recursive: true });
+    mkdirSync3(paths.root, { recursive: true });
   }
   if (!existsSync2(dirname2(paths.configFile))) {
-    mkdirSync2(dirname2(paths.configFile), { recursive: true });
+    mkdirSync3(dirname2(paths.configFile), { recursive: true });
   }
   ConfigSchema.parse(config);
-  writeFileSync2(paths.configFile, TOML.stringify(config), "utf8");
+  writeFileSync3(paths.configFile, TOML.stringify(config), "utf8");
 }
 function deriveWsUrl(httpBase) {
   const u = new URL(httpBase);
@@ -3365,15 +3728,15 @@ function runHooks(spec, opts) {
   }
   let backup;
   if (planned.kind === "directory") {
-    mkdirSync3(planned.path, { recursive: true });
+    mkdirSync4(planned.path, { recursive: true });
     const markerPath = join6(planned.path, "prismer.json");
     backup = backupIfExists(markerPath);
-    writeFileSync4(markerPath, JSON.stringify(prismerHookMarker(spec), null, 2) + "\n", "utf8");
+    writeFileSync5(markerPath, JSON.stringify(prismerHookMarker(spec), null, 2) + "\n", "utf8");
   } else {
-    mkdirSync3(dirname4(planned.path), { recursive: true });
+    mkdirSync4(dirname4(planned.path), { recursive: true });
     backup = backupIfExists(planned.path);
     const merged = mergeHookJson(planned.path, spec);
-    writeFileSync4(planned.path, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    writeFileSync5(planned.path, JSON.stringify(merged, null, 2) + "\n", "utf8");
   }
   return {
     ok: true,
@@ -3771,7 +4134,7 @@ function mapStatusToCode(status) {
 
 // src/sync/store.ts
 import Database2 from "better-sqlite3";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname5 } from "path";
 var MIGRATIONS = [
   {
@@ -3898,6 +4261,36 @@ var MIGRATIONS = [
       CREATE INDEX IF NOT EXISTS idx_asset_meta_seq
         ON asset_metadata_index(workspace_id, asset_index_seq);
     `
+  },
+  {
+    version: 4,
+    up: `
+      -- Wave 4 / W3 \xA74.3 \u2014 pending dispatch replies for crash recovery.
+      --
+      -- The two-phase reply protocol writes a row here BEFORE calling
+      -- POST /dispatch/:taskId/prepare so that a crash between prepare
+      -- and commit leaves a recoverable trail. On daemon cold-start, any
+      -- row with status='prepared' triggers an idempotent commit retry.
+      --
+      -- The server-side cutoff for orphaned 'prepared' rows is 1h
+      -- (PREPARED_REPLY_ORPHAN_MS in dispatch-reply.service.ts); rows
+      -- older than that will fail commit with DISPATCH_REPLY_INVALID_STATE
+      -- and must be reported to the user as 'dispatch lost'.
+      CREATE TABLE IF NOT EXISTS pending_dispatch_replies (
+        idempotency_key TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        reply_id TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        payload_json TEXT NOT NULL,
+        prepared_at INTEGER,
+        created_at INTEGER NOT NULL,
+        last_attempt_at INTEGER,
+        attempt_count INTEGER NOT NULL DEFAULT 0,
+        last_error TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_pending_reply_task ON pending_dispatch_replies (task_id);
+      CREATE INDEX IF NOT EXISTS idx_pending_reply_status ON pending_dispatch_replies (status, created_at);
+    `
   }
 ];
 function runSql(db, sql) {
@@ -3905,7 +4298,7 @@ function runSql(db, sql) {
 }
 function openLocalDb(path9) {
   if (path9 !== ":memory:" && !existsSync6(dirname5(path9))) {
-    mkdirSync4(dirname5(path9), { recursive: true });
+    mkdirSync5(dirname5(path9), { recursive: true });
   }
   const db = new Database2(path9);
   db.pragma("journal_mode = WAL");
@@ -4227,8 +4620,74 @@ function buildAgentCommand() {
     }
     getUI().ok("Skill install requested", `agent=${opts.agent} skill=${slugOrId}`);
   }, { code: "agent_install_skill_failed" }));
+  cmd.command("snapshot <imUserId>").description("Create an agent-level snapshot").option("--include-memory", "Include memory dump reference").option("--label <label>", "Snapshot label").option("--json", "Output JSON").action(runAction(async (imUserId, opts) => {
+    const cloud = makeCloudClient();
+    const data = await requestEnvelope(cloud, "POST", `/api/im/agents/${encodeURIComponent(imUserId)}/snapshot`, {
+      includeMemory: Boolean(opts.includeMemory),
+      label: opts.label
+    }, "agent_snapshot_failed");
+    if (opts.json) {
+      printJson(data);
+      return;
+    }
+    const rec = data;
+    getUI().ok("Snapshot created", String(rec.id ?? "<unknown>"));
+    getUI().line(`agent=${String(rec.agentImUserId ?? imUserId)} memory=${rec.includeMemory ? "included" : "stripped"}`);
+  }, { code: "agent_snapshot_failed" }));
+  cmd.command("publish <imUserId>").description("Publish an agent as an Agent Pack").requiredOption("--slug <slug>", "Agent Pack slug").option("--version <version>", "Package version", "1.0.0").option("--license <license>", "Package license", "proprietary").option("--title <title>", "Display title metadata").option("--description <description>", "Description metadata").option("--json", "Output JSON").action(runAction(async (imUserId, opts) => {
+    const cloud = makeCloudClient();
+    const data = await requestEnvelope(cloud, "POST", `/api/im/agents/${encodeURIComponent(imUserId)}/publish`, {
+      slug: opts.slug,
+      version: opts.version,
+      license: opts.license,
+      metadata: {
+        ...opts.title ? { title: opts.title } : {},
+        ...opts.description ? { description: opts.description } : {}
+      },
+      stripMemory: true
+    }, "agent_publish_failed");
+    if (opts.json) {
+      printJson(data);
+      return;
+    }
+    const rec = data;
+    getUI().ok("Agent Pack published", `${String(rec.slug ?? opts.slug)}@${String(rec.version ?? opts.version ?? "1.0.0")}`);
+    getUI().line(`package=${String(rec.id ?? "<unknown>")}`);
+  }, { code: "agent_publish_failed" }));
+  cmd.command("fork <packIdOrSlug>").description("Fork an Agent Pack into a workspace").requiredOption("--workspace-id <id>", "Target workspace id").option("--display-name <name>", "New agent display name").option("--json", "Output JSON").action(runAction(async (packIdOrSlug, opts) => {
+    const cloud = makeCloudClient();
+    const data = await requestEnvelope(cloud, "POST", `/api/im/agent-packs/${encodeURIComponent(packIdOrSlug)}/fork`, {
+      targetWorkspaceId: opts.workspaceId,
+      displayName: opts.displayName
+    }, "agent_fork_failed");
+    if (opts.json) {
+      printJson(data);
+      return;
+    }
+    const rec = data;
+    getUI().ok("Agent Pack forked", `newAgent=${String(rec.newImUserId ?? "<unknown>")}`);
+    getUI().line(`did=${String(rec.newDid ?? "not issued")}`);
+  }, { code: "agent_fork_failed" }));
   return cmd;
 }
+function makeCloudClient() {
+  const cfg = loadConfig(resolvePaths());
+  return new CloudClient({ baseUrl: cfg.cloud_api_base, apiKey: cfg.api_key });
+}
+async function requestEnvelope(cloud, method, path9, body, code) {
+  const res = await cloud.request(
+    method,
+    path9,
+    body === void 0 ? void 0 : { body }
+  );
+  if (!res.ok || res.data?.ok === false) {
+    const message = res.error?.message ?? res.data?.error?.message ?? "request failed";
+    exitWithError(`${path9} failed (${res.status === 0 ? "network error" : `HTTP ${res.status}`}): ${message}`, {
+      code: res.error?.code ?? res.data?.error?.code ?? code
+    });
+  }
+  return res.data && typeof res.data === "object" && "data" in res.data ? res.data.data : res.data;
+}
 function readLocalAgents(localDb) {
   const db = openLocalDb(localDb);
   try {
@@ -4333,13 +4792,13 @@ function whichBinary2(bin) {
 // src/cli/commands/asset.ts
 import { createHash as createHash2 } from "crypto";
 import { Command as Command3 } from "commander";
-import { existsSync as existsSync10, lstatSync, readdirSync, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync10, lstatSync, readdirSync, readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "fs";
 import { basename, dirname as dirname7, join as join10, relative } from "path";
 
 // src/asset-cache.ts
 import { createHash } from "crypto";
 import { promises as dnsp } from "dns";
-import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync6, renameSync, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
 import { isIP, isIPv4, isIPv6 } from "net";
 import { dirname as dirname6, join as join7 } from "path";
 import { Agent as UndiciAgent } from "undici";
@@ -4365,7 +4824,7 @@ var AssetCache = class {
     this.cacheDir = opts.cacheDir;
     this.maxBytes = opts.maxBytes ?? 5 * 1024 * 1024 * 1024;
     if (!existsSync7(this.cacheDir)) {
-      mkdirSync5(this.cacheDir, { recursive: true });
+      mkdirSync6(this.cacheDir, { recursive: true });
     }
   }
   /** Local file path for a content hash. Files split by first 2 chars for fs scaling. */
@@ -4440,10 +4899,10 @@ var AssetCache = class {
     }
     const localPath = this.pathFor(hash);
     if (!existsSync7(dirname6(localPath))) {
-      mkdirSync5(dirname6(localPath), { recursive: true });
+      mkdirSync6(dirname6(localPath), { recursive: true });
     }
     const tmpPath = `${localPath}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync5(tmpPath, buf);
+    writeFileSync6(tmpPath, buf);
     renameSync(tmpPath, localPath);
     const mime = res.headers.get("content-type");
     const now = Date.now();
@@ -4504,10 +4963,10 @@ var AssetCache = class {
     }
     const localPath = this.pathFor(hash);
     if (!existsSync7(dirname6(localPath))) {
-      mkdirSync5(dirname6(localPath), { recursive: true });
+      mkdirSync6(dirname6(localPath), { recursive: true });
     }
     const tmpPath = `${localPath}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync5(tmpPath, body);
+    writeFileSync6(tmpPath, body);
     renameSync(tmpPath, localPath);
     const now = Date.now();
     this.db.prepare(
@@ -4761,7 +5220,7 @@ async function fetchUrlWithGuards(rawUrl, opts) {
 }
 
 // src/daemon/asset/metadata-index.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
 import { join as join8 } from "path";
 var DEFAULT_LIMIT = 8;
 var PULL_PAGE_SIZE = 500;
@@ -4791,7 +5250,7 @@ var AssetMetadataIndex = class {
     this.cloud = opts.cloud;
     this.workspaceId = opts.workspaceId;
     if (!existsSync8(opts.workspaceStateDir)) {
-      mkdirSync6(opts.workspaceStateDir, { recursive: true });
+      mkdirSync7(opts.workspaceStateDir, { recursive: true });
     }
     this.cursorPath = join8(opts.workspaceStateDir, "asset-metadata-cursor.json");
   }
@@ -4812,7 +5271,7 @@ var AssetMetadataIndex = class {
       cursor,
       writtenAt: Date.now()
     };
-    writeFileSync6(this.cursorPath, JSON.stringify(payload, null, 2));
+    writeFileSync7(this.cursorPath, JSON.stringify(payload, null, 2));
   }
   /**
    * Pull incremental asset metadata changes since the persisted cursor and
@@ -4929,7 +5388,7 @@ var AssetMetadataIndex = class {
 };
 
 // src/daemon/asset/mirror.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
 import { join as join9 } from "path";
 function rowToBinding(row) {
   return {
@@ -4952,7 +5411,7 @@ var WorkspaceMirror = class {
     this.cloud = opts.cloud;
     this.workspaceId = opts.workspaceId;
     if (!existsSync9(opts.workspaceStateDir)) {
-      mkdirSync7(opts.workspaceStateDir, { recursive: true });
+      mkdirSync8(opts.workspaceStateDir, { recursive: true });
     }
     this.cursorPath = join9(opts.workspaceStateDir, "asset-cursor.json");
   }
@@ -4973,7 +5432,7 @@ var WorkspaceMirror = class {
       cursor,
       writtenAt: Date.now()
     };
-    writeFileSync7(this.cursorPath, JSON.stringify(payload, null, 2));
+    writeFileSync8(this.cursorPath, JSON.stringify(payload, null, 2));
   }
   /**
    * Pull workspace_file changes since the persisted cursor and upsert into
@@ -5411,7 +5870,7 @@ async function downloadAsset(assetId, outPath) {
     exitWithError(`asset download failed (${res.status}): ${errorMessage(body)}`);
   }
   const bytes = Buffer.from(await res.arrayBuffer());
-  writeFileSync8(outPath, bytes);
+  writeFileSync9(outPath, bytes);
 }
 function parseMetadata(raw) {
   if (!raw) return {};
@@ -6058,8 +6517,8 @@ function parsePositiveInt3(value) {
 // src/cli/commands/daemon.ts
 import { Command as Command8 } from "commander";
 import { spawn as spawn5 } from "child_process";
-import { createReadStream, existsSync as existsSync14, mkdirSync as mkdirSync9, openSync as openSync2, statSync as statSync4 } from "fs";
-import { setTimeout as sleep2 } from "timers/promises";
+import { createReadStream, existsSync as existsSync14, mkdirSync as mkdirSync10, openSync as openSync2, statSync as statSync4 } from "fs";
+import { setTimeout as sleep3 } from "timers/promises";
 import { join as join18 } from "path";
 
 // src/daemon/runner.ts
@@ -6067,7 +6526,7 @@ import { EventEmitter as EventEmitter3 } from "events";
 import { createRequire as createRequire2 } from "module";
 import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
 import { mkdir } from "fs/promises";
-import { homedir as homedir7, platform } from "os";
+import { homedir as homedir8, platform } from "os";
 import { join as join17 } from "path";
 
 // src/adapters/registry.ts
@@ -6548,6 +7007,262 @@ function createLogger(tag) {
 import { readFileSync as readFileSync10, promises as fsp3 } from "fs";
 import * as path2 from "path";
 init_skill_sync();
+
+// src/daemon/task-heartbeat.ts
+var TaskHeartbeat = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.intervalMs = opts.intervalMs ?? 15e3;
+    this.maxRetries = opts.maxRetries ?? 3;
+    this.retryBackoffMs = opts.retryBackoffMs ?? 100;
+    this.now = opts.now ?? Date.now;
+  }
+  opts;
+  timer;
+  version = 0;
+  taskId;
+  getPhase;
+  /** Tracks the last step time pushed via touchStep() — informational. */
+  lastStepAt;
+  intervalMs;
+  maxRetries;
+  retryBackoffMs;
+  now;
+  /**
+   * Begin heartbeating for `taskId`. `getPhase` is invoked at every tick to
+   * pick up the live phase string — adapters can mutate their phase state
+   * freely and the heartbeat will surface it on the next 15s boundary.
+   *
+   * Calling start() twice on the same instance replaces the active task
+   * (previous timer is cleared). Returns silently when already started for
+   * the same taskId.
+   */
+  start(taskId, getPhase) {
+    if (this.taskId === taskId && this.timer) return;
+    this.stop();
+    this.taskId = taskId;
+    this.getPhase = getPhase;
+    this.timer = setInterval(() => {
+      void this.push();
+    }, this.intervalMs);
+    this.timer.unref?.();
+  }
+  /**
+   * Stop the heartbeat loop. Idempotent.
+   */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    this.taskId = void 0;
+    this.getPhase = void 0;
+  }
+  /**
+   * Phase transition — push immediately AND update what the timer-driven
+   * tick will report next time. Adapter calls this whenever the lifecycle
+   * advances (thinking → tool_use → reasoning → responding → ...).
+   *
+   * No-op when no task is active.
+   */
+  setPhase(phase) {
+    if (!this.taskId) return;
+    this.getPhase = () => phase;
+    void this.push();
+  }
+  /**
+   * Mark "I just made observable progress." Updates lastStepAt; next push
+   * (timer-driven or setPhase-driven) carries it. Lightweight — no immediate
+   * send. Adapters call this around tool calls / token boundaries so the
+   * cloud reaper can distinguish "alive but slow" from "truly stuck".
+   */
+  touchStep() {
+    this.lastStepAt = this.now();
+  }
+  /**
+   * Manually trigger one heartbeat send (does not affect the timer). Mainly
+   * useful for tests that don't want to await a 15s tick. Returns the
+   * heartbeatVersion that was sent, or undefined if no task is active.
+   */
+  async forceTick() {
+    if (!this.taskId) return void 0;
+    return this.push();
+  }
+  /** Test helper: current heartbeatVersion (last value sent, may be 0 before first tick). */
+  get currentVersion() {
+    return this.version;
+  }
+  async push() {
+    if (!this.taskId || !this.getPhase) return void 0;
+    const taskId = this.taskId;
+    const phase = this.getPhase();
+    const heartbeatVersion = ++this.version;
+    const payload = {
+      taskId,
+      heartbeatVersion,
+      currentPhase: phase,
+      ...this.lastStepAt !== void 0 ? { lastStepAt: this.lastStepAt } : {}
+    };
+    const msg = envelope("task.heartbeat", payload);
+    let lastErr;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt += 1) {
+      try {
+        if (this.opts.ws.isOpen && !this.opts.ws.isOpen()) {
+          return heartbeatVersion;
+        }
+        this.opts.ws.send(msg);
+        return heartbeatVersion;
+      } catch (err) {
+        lastErr = err instanceof Error ? err : new Error(String(err));
+        if (attempt < this.maxRetries) {
+          const backoff = this.retryBackoffMs * Math.pow(2, attempt);
+          await sleep(backoff);
+        }
+      }
+    }
+    if (lastErr) {
+      try {
+        this.opts.onGiveUp?.(taskId, lastErr);
+      } catch {
+      }
+    }
+    return heartbeatVersion;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve3) => {
+    const handle = setTimeout(resolve3, ms);
+    handle.unref?.();
+  });
+}
+
+// src/daemon/step-recorder.ts
+var StepRecorder = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.reasoningThrottleMs = opts.reasoningThrottleMs ?? 500;
+    this.now = opts.now ?? Date.now;
+  }
+  opts;
+  seq = 0;
+  reasoningBuf = { texts: [], firstAt: 0 };
+  reasoningTimer;
+  reasoningThrottleMs;
+  now;
+  /** Push a phase transition step. Immediate (no throttle). */
+  recordPhaseChange(phase) {
+    this.emit("phase_change", { phase });
+  }
+  /**
+   * Push a tool-call step. Immediate.
+   *
+   * `toolCallId` is the daemon-side correlation id used to pair with the
+   * subsequent recordToolResult call. Free-form; adapter decides.
+   */
+  recordToolCall(toolName, input, toolCallId) {
+    this.emit("tool_call", {
+      toolName,
+      inputSummary: summarize2(input),
+      ...toolCallId ? { toolCallId } : {}
+    });
+  }
+  /** Push a tool-result step. Immediate. */
+  recordToolResult(toolCallId, output) {
+    this.emit("tool_result", {
+      toolCallId,
+      outputSummary: summarize2(output)
+    });
+  }
+  /**
+   * Buffer a reasoning chunk for batched dispatch. Multiple chunks within
+   * `reasoningThrottleMs` are concatenated and emitted as a single
+   * `reasoning_chunk` step when the timer fires.
+   */
+  recordReasoningChunk(text) {
+    if (!text) return;
+    if (this.reasoningBuf.texts.length === 0) {
+      this.reasoningBuf.firstAt = this.now();
+    }
+    this.reasoningBuf.texts.push(text);
+    if (this.reasoningTimer) return;
+    this.reasoningTimer = setTimeout(() => {
+      this.flushReasoning();
+    }, this.reasoningThrottleMs);
+    this.reasoningTimer.unref?.();
+  }
+  /** Push an error step. Immediate. */
+  recordError(message, payload) {
+    this.emit("error", { message, ...payload ?? {} });
+  }
+  /**
+   * Force any pending reasoning buffer out the door. Call on shutdown so
+   * trailing tokens aren't lost.
+   */
+  flush() {
+    this.flushReasoning();
+  }
+  /** Test helper. */
+  get currentSeq() {
+    return this.seq;
+  }
+  flushReasoning() {
+    if (this.reasoningTimer) {
+      clearTimeout(this.reasoningTimer);
+      this.reasoningTimer = void 0;
+    }
+    if (this.reasoningBuf.texts.length === 0) return;
+    const text = this.reasoningBuf.texts.join("");
+    const firstAt = this.reasoningBuf.firstAt;
+    this.reasoningBuf = { texts: [], firstAt: 0 };
+    this.emit("reasoning_chunk", { text }, firstAt);
+  }
+  emit(kind, payload, occurredAt) {
+    const frame = {
+      seq: ++this.seq,
+      kind,
+      payload,
+      occurredAt: occurredAt ?? this.now()
+    };
+    const msg = envelope("task.step.append", {
+      taskRunId: this.opts.taskRunId,
+      step: frame
+    });
+    try {
+      if (this.opts.ws.isOpen && !this.opts.ws.isOpen()) {
+        try {
+          this.opts.onSend?.(frame);
+        } catch {
+        }
+        return;
+      }
+      this.opts.ws.send(msg);
+      try {
+        this.opts.onSend?.(frame);
+      } catch {
+      }
+    } catch {
+    }
+  }
+};
+var MAX_SUMMARY_CHARS = 512;
+function summarize2(value) {
+  let text;
+  if (value == null) text = "";
+  else if (typeof value === "string") text = value;
+  else {
+    try {
+      text = JSON.stringify(value);
+    } catch {
+      text = String(value);
+    }
+  }
+  if (text.length > MAX_SUMMARY_CHARS) {
+    return `${text.slice(0, MAX_SUMMARY_CHARS)}\u2026(+${text.length - MAX_SUMMARY_CHARS} chars)`;
+  }
+  return text;
+}
+
+// src/daemon/dispatch.ts
 var DEFAULT_CONTEXT_MAX = 8e3;
 var GOAL_CONTEXT_MAX = 4;
 var MEMORY_DIGEST_MAX_BYTES = 4e3;
@@ -6563,6 +7278,8 @@ async function handleDispatch(payload, requestId, deps) {
   const { taskId, agentImUserId } = payload;
   let resolvedHashes = [];
   let reply;
+  let heartbeatRef;
+  let recorderRef;
   const outboxBase = deps.paths?.runsDir ? path2.join(deps.paths.runsDir, taskId) : null;
   const outboxDir = outboxBase ? path2.join(outboxBase, "_outbox") : null;
   const workDir = outboxBase ? path2.join(outboxBase, "workdir") : null;
@@ -6644,7 +7361,13 @@ async function handleDispatch(payload, requestId, deps) {
       resolvedHashes.push(...r.resolvedHashes);
       rewrittenContext = payload.context.map((e, i) => ({ ...e, content: r.texts[i] }));
     }
-    const assetResolution = await resolveAssetRefs(payload.assetRefs, deps.assetCache, taskId);
+    const assetResolution = await resolveAssetRefs(payload.assetRefs, deps.assetCache, taskId, {
+      cloud: deps.cloud,
+      enabled: deps.visionAux?.enabled !== false,
+      cacheDir: deps.visionAux?.cacheDir ?? (deps.paths ? path2.join(deps.paths.cacheDir, "vision-cache") : void 0),
+      timeoutMs: deps.visionAux?.timeoutMs,
+      signal: deps.signal
+    });
     resolvedHashes.push(...assetResolution.pinnedHashes);
     const basePrompt = composePrompt(
       rewrittenPrompt.text,
@@ -6679,9 +7402,44 @@ async function handleDispatch(payload, requestId, deps) {
     }
     const operatingPrinciples = resolveOperatingPrinciples(profile.config);
     const composedSystemPrompt = [profileSystemPrompt, operatingPrinciples].filter((part) => typeof part === "string" && part.length > 0).join("\n\n");
+    let activePhase = "thinking";
+    const heartbeat = new TaskHeartbeat({
+      ws: deps.ws,
+      onGiveUp: (tid, err) => process.stderr.write(
+        `[daemon] task.heartbeat give-up task=${tid}: ${err.message}
+`
+      )
+    });
+    heartbeatRef = heartbeat;
+    heartbeat.start(taskId, () => activePhase);
+    const recorder = new StepRecorder({ ws: deps.ws, taskRunId: taskId });
+    recorderRef = recorder;
+    recorder.recordPhaseChange(activePhase);
     const taskInput = {
       taskId,
       prompt: adapterPrompt,
+      heartbeat: {
+        setPhase: (phase) => {
+          activePhase = phase;
+          heartbeat.setPhase(phase);
+          recorder.recordPhaseChange(phase);
+        },
+        touchStep: () => heartbeat.touchStep()
+      },
+      recorder: {
+        recordPhaseChange: (phase) => {
+          activePhase = phase;
+          heartbeat.setPhase(phase);
+          recorder.recordPhaseChange(phase);
+        },
+        recordToolCall: (toolName, input, toolCallId) => recorder.recordToolCall(toolName, input, toolCallId),
+        recordToolResult: (toolCallId, output) => recorder.recordToolResult(toolCallId, output),
+        recordReasoningChunk: (text) => recorder.recordReasoningChunk(text),
+        recordError: (message, payload2) => recorder.recordError(message, payload2)
+      },
+      // 14b rev.3 §9 P3 — multimodal-aware adapters (Hermes, OpenClaw) pick
+      // up the resolved bytes/URLs here; text-only adapters ignore the field.
+      ...assetResolution.resolvedRefs.length > 0 ? { assetRefs: assetResolution.resolvedRefs } : {},
       metadata: {
         ...payload.metadata,
         conversationId: payload.conversationId,
@@ -6744,6 +7502,9 @@ async function handleDispatch(payload, requestId, deps) {
       }
     }
     const reaperAborted = deps.signal?.aborted && result.error?.code === "task_cancelled";
+    const approvalRequested = Boolean(
+      result.metadata?.approvalRequested
+    );
     let collectedAssetIds = [];
     if (deps.outboxWatcher && outboxDir) {
       try {
@@ -6755,14 +7516,23 @@ async function handleDispatch(payload, requestId, deps) {
       collectedAssetIds = deps.outboxWatcher.flushPending(taskId);
     }
     const reaperLimitMs = typeof payload.timeoutMs === "number" && payload.timeoutMs > 0 ? payload.timeoutMs : 5 * 6e4;
+    const finalError = approvalRequested ? {
+      code: "awaiting_human_approval",
+      message: "Agent requested human approval and is suspended pending decision. Cloud will redispatch with `approval.decided` once the human responds."
+    } : reaperAborted ? {
+      code: "daemon_task_timeout",
+      message: `Daemon-side reaper aborted after ${reaperLimitMs}ms inactivity (no progress events from adapter)`
+    } : result.error;
     reply = {
       taskId,
+      // When approval is pending we keep ok=false (the run did not produce a
+      // completion-style output) but the cloud-side handler treats the
+      // `awaiting_human_approval` code as non-terminal — task stays alive,
+      // no red failure pill, and the next dispatch (after the human decides)
+      // continues normally.
       ok: result.ok,
       output: result.output,
-      error: reaperAborted ? {
-        code: "daemon_task_timeout",
-        message: `Daemon-side reaper aborted after ${reaperLimitMs}ms inactivity (no progress events from adapter)`
-      } : result.error,
+      error: finalError,
       ...collectedAssetIds.length > 0 ? { assetIds: collectedAssetIds } : {},
       metrics: result.metrics,
       ...assetResolution.observability.length > 0 || urlObservations.length > 0 ? { assetObservability: [...assetResolution.observability, ...urlObservations] } : {}
@@ -6784,6 +7554,18 @@ async function handleDispatch(payload, requestId, deps) {
       }
     };
   } finally {
+    try {
+      recorderRef?.flush();
+    } catch (err) {
+      process.stderr.write(`[daemon] step recorder flush failed task=${taskId}: ${err.message}
+`);
+    }
+    try {
+      heartbeatRef?.stop();
+    } catch (err) {
+      process.stderr.write(`[daemon] heartbeat stop failed task=${taskId}: ${err.message}
+`);
+    }
     for (const hash of new Set(resolvedHashes)) {
       try {
         deps.assetCache.unpin(hash);
@@ -6860,6 +7642,10 @@ function isTextLikeMime(mime) {
   if (m.endsWith("+json") || m.endsWith("+xml") || m.endsWith("+csv")) return true;
   return false;
 }
+function isImageMime(mime) {
+  if (!mime) return false;
+  return mime.toLowerCase().split(";")[0].trim().startsWith("image/");
+}
 var HASH_REF_RE = /(?:^|\s)#([^\s#]+)/g;
 var HEX_COLOR_RE = /^[0-9a-fA-F]{3,8}$/;
 var FILE_EXT_RE = /\.[a-zA-Z0-9]{1,10}$/;
@@ -6938,8 +7724,34 @@ async function resolveHashRefs(prompt, assetIndex, cloud) {
   }
   return { text: result, resolutions };
 }
-async function resolveAssetRefs(refs, cache, taskId) {
-  const out = { promptBlocks: [], observability: [], pinnedHashes: [] };
+var ASSET_BASE64_INLINE_MAX_BYTES = 10 * 1024 * 1024;
+async function probeCdnReachable(cdnUrl, timeoutMs = 1500) {
+  try {
+    const u = new URL(cdnUrl);
+    if (u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname.startsWith("192.168.")) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  try {
+    const r = await fetch(cdnUrl, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (r.ok) return true;
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function resolveAssetRefs(refs, cache, taskId, visionAux) {
+  const out = {
+    promptBlocks: [],
+    observability: [],
+    pinnedHashes: [],
+    resolvedRefs: []
+  };
   if (!refs || refs.length === 0) return out;
   for (const ref of refs) {
     let cached;
@@ -7004,7 +7816,42 @@ async function resolveAssetRefs(refs, cache, taskId) {
         continue;
       }
     }
-    out.promptBlocks.push(formatUriOnlyAssetBlock(ref, effectiveMime, cached.localPath));
+    let reachable = "unknown";
+    let base64;
+    if (ref.cdnUrl) {
+      const ok2 = await probeCdnReachable(ref.cdnUrl);
+      if (ok2) {
+        reachable = "cdn";
+      }
+    }
+    if (reachable !== "cdn") {
+      try {
+        const buf = readFileSync10(cached.localPath);
+        if (buf.byteLength <= ASSET_BASE64_INLINE_MAX_BYTES) {
+          base64 = buf.toString("base64");
+          reachable = "base64";
+        } else {
+          reachable = "unknown";
+        }
+      } catch (err) {
+        const errMsg = `base64 fallback read failed: ${err.message}`;
+        logAssetResolveFailure(taskId, ref, errMsg, effectiveMime);
+      }
+    }
+    const resolvedRef = {
+      ...ref,
+      mime: effectiveMime,
+      localPath: cached.localPath,
+      base64,
+      reachable
+    };
+    out.resolvedRefs.push(resolvedRef);
+    if (isImageMime(effectiveMime) && visionAux?.enabled) {
+      const block = await describeImageAttachment(ref, effectiveMime, resolvedRef, visionAux, taskId);
+      out.promptBlocks.push(block);
+    } else {
+      out.promptBlocks.push(formatAttachmentReminderBlock(ref, effectiveMime));
+    }
     out.observability.push({
       assetId: ref.assetId,
       contentHash: ref.contentHash,
@@ -7015,6 +7862,110 @@ async function resolveAssetRefs(refs, cache, taskId) {
   }
   return out;
 }
+async function describeImageAttachment(ref, mime, resolved, opts, taskId) {
+  const cached = await readVisionAuxLocalCache(opts.cacheDir, ref.contentHash, mime);
+  if (cached) return formatVisionAuxBlock(ref, mime, cached.description, true);
+  const source = buildVisionAuxSource(resolved, mime);
+  if (!source) {
+    return formatVisionAuxUnavailableBlock(ref, mime, "no reachable URL or inline bytes");
+  }
+  try {
+    const description = await callVisionAux(ref, mime, source, opts);
+    await writeVisionAuxLocalCache(opts.cacheDir, ref.contentHash, mime, description);
+    return formatVisionAuxBlock(ref, mime, description.description, false);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(
+      `[daemon] vision-aux failed task=${taskId ?? "unknown"} assetId=${ref.assetId} hash=${ref.contentHash}: ${message}
+`
+    );
+    return formatVisionAuxUnavailableBlock(ref, mime, message);
+  }
+}
+function buildVisionAuxSource(resolved, mime) {
+  if (resolved.reachable === "cdn" && resolved.cdnUrl) return { kind: "url", url: resolved.cdnUrl };
+  if (resolved.base64 && mime) return { kind: "data_url", url: `data:${mime};base64,${resolved.base64}` };
+  return null;
+}
+async function callVisionAux(ref, mime, source, opts) {
+  const secret = process.env.VISION_AUX_INTERNAL_SECRET || process.env.INTERNAL_API_SECRET || process.env.PRISMER_INTERNAL_SECRET;
+  const headers = secret ? { "x-prismer-internal-secret": secret } : void 0;
+  const res = await opts.cloud.request(
+    "POST",
+    "/api/internal/vision-aux/describe",
+    {
+      body: {
+        assetId: ref.assetId,
+        contentHash: ref.contentHash,
+        mime: mime ?? ref.mime ?? "image/unknown",
+        source
+      },
+      headers,
+      timeoutMs: opts.timeoutMs ?? 12e3,
+      signal: opts.signal
+    }
+  );
+  const env = res.data;
+  if (!res.ok || env?.ok === false || !env?.data?.description) {
+    const message = res.error?.message || (typeof env?.error === "string" ? env.error : env?.error?.message) || env?.message || `HTTP ${res.status}`;
+    throw new Error(message);
+  }
+  const now = /* @__PURE__ */ new Date();
+  const ttlSec = Number.isFinite(env.data.cacheTtlSec) ? Number(env.data.cacheTtlSec) : 300;
+  return {
+    description: env.data.description,
+    modelUsed: env.data.modelUsed || "unknown",
+    provider: env.data.provider || "vision-aux",
+    generatedAt: now.toISOString(),
+    expiresAt: new Date(now.getTime() + Math.max(1, ttlSec) * 1e3).toISOString(),
+    mime: mime ?? ref.mime ?? "image/unknown"
+  };
+}
+async function readVisionAuxLocalCache(cacheDir, contentHash, mime) {
+  if (!cacheDir) return null;
+  const file = visionAuxCachePath(cacheDir, contentHash);
+  try {
+    const raw = await fsp3.readFile(file, "utf8");
+    const parsed = parseVisionAuxCache(raw);
+    if (!parsed) {
+      await fsp3.unlink(file).catch(() => void 0);
+      return null;
+    }
+    if (parsed.mime !== mime) return null;
+    const expiresAt = Date.parse(parsed.expiresAt);
+    if (!Number.isFinite(expiresAt) || expiresAt <= Date.now()) return null;
+    return parsed;
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      await fsp3.unlink(file).catch(() => void 0);
+    }
+    return null;
+  }
+}
+async function writeVisionAuxLocalCache(cacheDir, contentHash, mime, description) {
+  if (!cacheDir || !mime) return;
+  const file = visionAuxCachePath(cacheDir, contentHash);
+  await fsp3.mkdir(path2.dirname(file), { recursive: true });
+  await fsp3.writeFile(file, JSON.stringify({ ...description, mime }, null, 2), "utf8");
+}
+function visionAuxCachePath(cacheDir, contentHash) {
+  const safeHash = /^[a-f0-9]{32,128}$/i.test(contentHash) ? contentHash : createSafeCacheKey(contentHash);
+  return path2.join(cacheDir, `${safeHash}.json`);
+}
+function createSafeCacheKey(value) {
+  return Buffer.from(value).toString("base64url").slice(0, 128) || "unknown";
+}
+function parseVisionAuxCache(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.description === "string" && typeof parsed.modelUsed === "string" && typeof parsed.provider === "string" && typeof parsed.generatedAt === "string" && typeof parsed.expiresAt === "string" && typeof parsed.mime === "string") {
+      return parsed;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
 function logAssetResolveFailure(taskId, ref, error, mime = ref.mime) {
   const message = error.replace(/\s+/g, " ").slice(0, 500);
   process.stderr.write(
@@ -7029,8 +7980,19 @@ function formatInlineAssetBlock(ref, mime, body, strategy) {
 ${body}
 ---`;
 }
-function formatUriOnlyAssetBlock(ref, mime, localPath) {
-  return `[Attached file] id=${ref.assetId} mime=${mime ?? "unknown"} path=file://${localPath} \u2014 open with your read/parse tool when needed.`;
+function formatAttachmentReminderBlock(ref, mime) {
+  const name = ref.filename ? ` name=${ref.filename}` : "";
+  return `[Attached file] id=${ref.assetId} mime=${mime ?? "unknown"}${name} \u2014 the user uploaded this file; multimodal adapters receive the bytes directly.`;
+}
+function formatVisionAuxBlock(ref, mime, description, cached) {
+  const name = ref.filename ? `: ${ref.filename}` : "";
+  const cacheLabel = cached ? " local-cache" : "";
+  return `[Image attachment${name}] id=${ref.assetId} mime=${mime ?? "unknown"}${cacheLabel}
+${description.trim()}`;
+}
+function formatVisionAuxUnavailableBlock(ref, mime, reason) {
+  const name = ref.filename ? `: ${ref.filename}` : "";
+  return `[Image attachment${name}; description unavailable due to vision-aux error] id=${ref.assetId} mime=${mime ?? "unknown"} reason=${reason.slice(0, 180)}`;
 }
 function formatErrorAssetBlock(ref, mime, error) {
   return `[Attached file] id=${ref.assetId} mime=${mime ?? "unknown"} ERROR: ${error} \u2014 this file failed to load on the daemon side. Tell the user the specific error and ask them to re-upload or paste the content directly; do not guess at the cause.`;
@@ -7372,6 +8334,7 @@ import { createServer } from "http";
 import { randomUUID, createHash as createHash4, createHmac, timingSafeEqual as cryptoTimingSafeEqual } from "crypto";
 import { promises as fs2 } from "fs";
 import * as path3 from "path";
+import { homedir as homedir5 } from "os";
 
 // src/daemon/message-dispatch.ts
 var DEFAULT_TIMEOUT_MS = 6e4;
@@ -7582,6 +8545,11 @@ var LocalServer = class {
       void this.handleSnapshot(req, res);
       return;
     }
+    const agentDumpMatch = /^\/v1\/agents\/([^/]+)\/dump-state$/.exec(url);
+    if (req.method === "POST" && agentDumpMatch) {
+      void this.handleAgentDumpState(req, res, decodeURIComponent(agentDumpMatch[1]));
+      return;
+    }
     if (req.method === "POST" && url === "/local/asset/write") {
       void this.handleAssetWrite(req, res);
       return;
@@ -7646,14 +8614,62 @@ var LocalServer = class {
         error: "snapshot_failed",
         message: err instanceof Error ? err.message : String(err)
       });
-      return;
-    }
-    try {
-      const files = await walkAndDigest(root, root);
-      respond(res, 200, { rootPath: root, files });
+      return;
+    }
+    try {
+      const files = await walkAndDigest(root, root);
+      respond(res, 200, { rootPath: root, files });
+    } catch (err) {
+      respond(res, 500, {
+        error: "snapshot_failed",
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+    void req;
+  }
+  /**
+   * POST /v1/agents/:agentId/dump-state — agent-scoped daemon manifest.
+   *
+   * This is narrower than `/v1/snapshot`: it walks only the current agent's
+   * profile/work dirs so cloud can attach the result to IMAgentSnapshot without
+   * capturing unrelated agents hosted in the same daemon/container.
+   */
+  async handleAgentDumpState(req, res, agentId) {
+    const state = this.opts.getState();
+    const agent = state.hostedAgents.find((item) => item.imUserId === agentId);
+    if (!agent) {
+      respond(res, 404, { error: "agent_not_hosted", agentId });
+      return;
+    }
+    const roots = getAgentStateRoots(agent, this.opts.snapshotRoot ?? "/workspace");
+    try {
+      const manifests = await Promise.all(
+        roots.map(async (root) => {
+          const stat = await statOptional(root.rootPath);
+          if (!stat) return { ...root, exists: false, files: [] };
+          if (!stat.isDirectory()) return { ...root, exists: true, error: "not_directory", files: [] };
+          return { ...root, exists: true, files: await walkAndDigest(root.rootPath, root.rootPath) };
+        })
+      );
+      const files = manifests.flatMap(
+        (manifest) => manifest.files.map((file) => ({
+          ...file,
+          path: `${manifest.kind}/${file.path}`,
+          rootKind: manifest.kind,
+          rootPath: manifest.rootPath
+        }))
+      );
+      respond(res, 200, {
+        agentId,
+        adapterName: agent.adapterName,
+        dumpedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        roots: manifests,
+        files
+      });
     } catch (err) {
       respond(res, 500, {
-        error: "snapshot_failed",
+        error: "agent_dump_state_failed",
+        agentId,
         message: err instanceof Error ? err.message : String(err)
       });
     }
@@ -7930,6 +8946,39 @@ function validateAgentDispatchRequest(body) {
   if (payload.attachments != null && !Array.isArray(payload.attachments)) return "attachments must be an array";
   return null;
 }
+function getAgentStateRoots(agent, snapshotRoot) {
+  const profileName = sanitizeProfileName(agent.name || agent.imUserId);
+  const roots = [
+    {
+      kind: "workspace-agent",
+      rootPath: path3.join(snapshotRoot, "agents", agent.imUserId)
+    }
+  ];
+  if (agent.adapterName === "hermes" || agent.adapterName === "claude-code") {
+    roots.unshift({
+      kind: "hermes-profile",
+      rootPath: path3.join(process.env.HERMES_HOME || path3.join(homedir5(), ".hermes"), "profiles", profileName)
+    });
+  }
+  if (agent.adapterName === "openclaw") {
+    roots.unshift({
+      kind: "openclaw-profile",
+      rootPath: path3.join(process.env.OPENCLAW_HOME || path3.join(homedir5(), ".openclaw"), "profiles", profileName)
+    });
+  }
+  return roots;
+}
+function sanitizeProfileName(value) {
+  return value.replace(/[\\/]/g, "_").trim() || "default";
+}
+async function statOptional(rootPath) {
+  try {
+    return await fs2.stat(rootPath);
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
 async function walkAndDigest(root, current) {
   const out = [];
   let entries;
@@ -9717,7 +10766,7 @@ async function readJson3(req) {
 
 // src/daemon/asset/origin/drop-folder.ts
 import { promises as fs4 } from "fs";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 import * as path6 from "path";
 var DropFolderAdapter = class {
   kind = "drop-folder";
@@ -9725,7 +10774,7 @@ var DropFolderAdapter = class {
   rootDir;
   constructor(opts = {}) {
     this.workspaceDir = opts.workspaceDir;
-    this.rootDir = opts.rootDir ?? path6.join(opts.homeDir ?? homedir6(), ".prismer");
+    this.rootDir = opts.rootDir ?? path6.join(opts.homeDir ?? homedir7(), ".prismer");
   }
   /**
    * Long-lived async iterable wrapping `scanOnce` on a 1s polling interval.
@@ -9735,7 +10784,7 @@ var DropFolderAdapter = class {
     while (true) {
       const batch = await this.scanOnce(workspaceId);
       for (const obs of batch) yield obs;
-      await sleep(1e3);
+      await sleep2(1e3);
     }
   }
   /**
@@ -9884,7 +10933,7 @@ function mimeFromExtension(p) {
   const ext = path6.extname(p).toLowerCase();
   return MIME_BY_EXT[ext] ?? null;
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
@@ -10595,9 +11644,120 @@ function extensionOf(filename) {
   return idx >= 0 ? name.slice(idx) : "";
 }
 
+// src/daemon/asset/magic-bytes.ts
+var PDF_SIG = Buffer.from("%PDF-", "ascii");
+var PNG_SIG = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var JPEG_SIG = Buffer.from([255, 216, 255]);
+var GIF87 = Buffer.from("GIF87a", "ascii");
+var GIF89 = Buffer.from("GIF89a", "ascii");
+var ZIP_LOCAL = Buffer.from([80, 75, 3, 4]);
+var ZIP_EMPTY = Buffer.from([80, 75, 5, 6]);
+var ZIP_SPANNED = Buffer.from([80, 75, 7, 8]);
+function detectMagicBytes(bytes) {
+  const head = bytes.subarray(0, Math.min(bytes.length, 4096));
+  if (head.length === 0) return { detected: null, mime: null };
+  if (head.length >= PDF_SIG.length && head.subarray(0, PDF_SIG.length).equals(PDF_SIG)) {
+    return { detected: "pdf", mime: "application/pdf" };
+  }
+  if (head.length >= PNG_SIG.length && head.subarray(0, PNG_SIG.length).equals(PNG_SIG)) {
+    return { detected: "png", mime: "image/png" };
+  }
+  if (head.length >= JPEG_SIG.length && head.subarray(0, JPEG_SIG.length).equals(JPEG_SIG)) {
+    return { detected: "jpeg", mime: "image/jpeg" };
+  }
+  if (head.length >= GIF87.length && head.subarray(0, GIF87.length).equals(GIF87) || head.length >= GIF89.length && head.subarray(0, GIF89.length).equals(GIF89)) {
+    return { detected: "gif", mime: "image/gif" };
+  }
+  if (head.length >= 4 && (head.subarray(0, 4).equals(ZIP_LOCAL) || head.subarray(0, 4).equals(ZIP_EMPTY) || head.subarray(0, 4).equals(ZIP_SPANNED))) {
+    return { detected: "zip", mime: "application/zip" };
+  }
+  const text = head.toString("utf8");
+  const trimmed = text.trimStart();
+  if (/^<\?xml[^>]*>\s*<svg[\s>]/i.test(trimmed) || /^<svg[\s>]/i.test(trimmed)) {
+    return { detected: "svg", mime: "image/svg+xml" };
+  }
+  if (/^<(!doctype html|html[\s>])/i.test(trimmed)) {
+    return { detected: "html", mime: "text/html" };
+  }
+  if (/^[{[]/.test(trimmed)) {
+    return { detected: "json", mime: "application/json" };
+  }
+  if (looksLikePrintableText(head)) {
+    return { detected: "markdown-or-text", mime: "text/plain" };
+  }
+  return { detected: null, mime: null };
+}
+var ZIP_DERIVED_MIMES = /* @__PURE__ */ new Set([
+  "application/zip",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "application/vnd.oasis.opendocument.text",
+  "application/vnd.oasis.opendocument.spreadsheet",
+  "application/vnd.oasis.opendocument.presentation",
+  "application/epub+zip",
+  "application/java-archive"
+]);
+function mimeMismatchReason(detected, declared) {
+  if (detected.detected === null) return null;
+  const dec = (declared ?? "").toLowerCase().split(";")[0]?.trim() ?? "";
+  if (!dec || dec === "application/octet-stream") return null;
+  switch (detected.detected) {
+    case "pdf":
+      return dec === "application/pdf" ? null : `declared ${dec} but content is application/pdf`;
+    case "png":
+      return dec === "image/png" ? null : `declared ${dec} but content is image/png`;
+    case "jpeg":
+      return dec === "image/jpeg" || dec === "image/jpg" ? null : `declared ${dec} but content is image/jpeg`;
+    case "gif":
+      return dec === "image/gif" ? null : `declared ${dec} but content is image/gif`;
+    case "zip":
+      if (ZIP_DERIVED_MIMES.has(dec)) return null;
+      return `declared ${dec} but content is a ZIP-container (application/zip family)`;
+    case "svg":
+      if (dec === "image/svg+xml" || dec.startsWith("text/")) return null;
+      return `declared ${dec} but content is image/svg+xml`;
+    case "html":
+      if (dec === "text/html" || dec === "application/xhtml+xml" || dec.startsWith("text/")) return null;
+      if (dec === "application/pdf" || dec.startsWith("image/") || dec === "application/zip") {
+        return `declared ${dec} but content is text/html`;
+      }
+      return null;
+    case "json":
+      if (dec === "application/json" || dec.startsWith("text/")) return null;
+      if (dec === "application/pdf" || dec.startsWith("image/") || dec === "application/zip") {
+        return `declared ${dec} but content is application/json`;
+      }
+      return null;
+    case "markdown-or-text":
+      if (dec === "application/pdf" || dec.startsWith("image/") || dec === "application/zip") {
+        return `declared ${dec} but content is text (not a real ${dec} payload)`;
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+function looksLikePrintableText(buf) {
+  if (buf.length === 0) return false;
+  let printable = 0;
+  let total = 0;
+  for (let i = 0; i < buf.length; i++) {
+    const b = buf[i];
+    if (b === 0) return false;
+    total++;
+    if (b >= 32 && b <= 126 || b === 9 || b === 10 || b === 13 || // utf-8 lead bytes
+    b >= 128) {
+      printable++;
+    }
+  }
+  return total > 0 && printable / total >= 0.95;
+}
+
 // src/daemon/outbox-watcher.ts
 var DEFAULT_INTERVAL_MS = 2e3;
 var RESERVED_SUBDIR = "_uploaded";
+var REJECTED_SUBDIR = "_rejected";
 var OutboxWatcher = class {
   constructor(opts) {
     this.opts = opts;
@@ -10772,6 +11932,7 @@ var OutboxWatcher = class {
     for (const name of entries) {
       if (name.startsWith(".")) continue;
       if (name === RESERVED_SUBDIR) continue;
+      if (name === REJECTED_SUBDIR) continue;
       const full = path8.join(dir, name);
       let st;
       try {
@@ -10786,10 +11947,77 @@ var OutboxWatcher = class {
         await this.upload(full, st, kind, task);
         this.uploaded.add(key);
       } catch (err) {
-        this.log("warn", `upload ${full} failed: ${err.message}`);
+        const msg = err.message;
+        this.log("warn", `upload ${full} failed: ${msg}`);
+        if (/\bMIME_MISMATCH\b/i.test(msg) || /\bmime mismatch\b/i.test(msg)) {
+          await this.quarantine(dir, full).catch(
+            (moveErr) => this.log("warn", `quarantine ${full} failed: ${moveErr.message}`)
+          );
+          this.uploaded.add(key);
+          await this.reportMimeMismatchToCloud(task, full, msg).catch(
+            (reportErr) => this.log("warn", `report MIME_MISMATCH failed: ${reportErr.message}`)
+          );
+        }
       }
     }
   }
+  /**
+   * F2B — report an OUTBOX_MIME_MISMATCH task event to cloud so the task log
+   * gains an auditable record of the rejection. Without this, the failure is
+   * silent (file quarantined locally, agent unaware) and the next dispatch
+   * loops on the same bad strategy.
+   *
+   * Best-effort: every catch site swallows errors. We never want this
+   * upstream call to block local quarantine or trigger a retry loop, because
+   * the reject decision is already final by the time we get here.
+   *
+   * Endpoint contract: POST /api/im/tasks/:id/event
+   *   { code: 'OUTBOX_MIME_MISMATCH', payload: { file, daemonError }, message }
+   * Only callable when `task?.taskId` is known — pre-dispatch outbox files
+   * (no active task) are quarantined silently as before.
+   */
+  async reportMimeMismatchToCloud(task, filePath, daemonErrorMessage) {
+    if (!task?.taskId) return;
+    const fileName = path8.basename(filePath);
+    const reasonMatch = daemonErrorMessage.match(/MIME_MISMATCH[^:]*:\s*(.+)$/i);
+    const reason = reasonMatch?.[1] ? reasonMatch[1].trim() : daemonErrorMessage;
+    const body = {
+      code: "OUTBOX_MIME_MISMATCH",
+      payload: {
+        file: fileName,
+        reason,
+        daemonError: daemonErrorMessage
+      },
+      message: `Your output file ${fileName} was rejected because its bytes do not match the claimed format. Use a real library (e.g. reportlab for PDF, openpyxl for XLSX) instead of renaming an extension.`
+    };
+    const res = await this.opts.cloud.request("POST", `/api/im/tasks/${encodeURIComponent(task.taskId)}/event`, {
+      body
+    });
+    if (!res.ok) {
+      throw new Error(`cloud rejected event: ${res.status} ${res.error?.code ?? ""} ${res.error?.message ?? ""}`);
+    }
+  }
+  /**
+   * Move a file under `<dir>/_rejected/` so it stops being a scan candidate
+   * (the loop skips the reserved subdir) and operators can find the
+   * offending artifact. Filename collision is rare per task; on collision
+   * we append a millisecond suffix to keep the original observable.
+   */
+  async quarantine(dir, full) {
+    const rejectedDir = path8.join(dir, REJECTED_SUBDIR);
+    await fs5.mkdir(rejectedDir, { recursive: true });
+    const base = path8.basename(full);
+    let dest = path8.join(rejectedDir, base);
+    try {
+      await fs5.access(dest);
+      const ext = path8.extname(base);
+      const stem = base.slice(0, base.length - ext.length);
+      dest = path8.join(rejectedDir, `${stem}.${Date.now()}${ext}`);
+    } catch {
+    }
+    await fs5.rename(full, dest);
+    this.log("warn", `quarantined ${full} \u2192 ${dest}`);
+  }
   async upload(filePath, st, kind, task) {
     const wsId = this.opts.workspaceId();
     if (!wsId) {
@@ -10807,6 +12035,11 @@ var OutboxWatcher = class {
     if (!policy.ok) {
       throw new Error(`agent output rejected: ${policy.reason}`);
     }
+    const detection = detectMagicBytes(bytes);
+    const reason = mimeMismatchReason(detection, policy.mime);
+    if (reason) {
+      throw new Error(`MIME_MISMATCH for ${fileName}: ${reason}`);
+    }
     const metadata = {
       taskId: task.taskId,
       ...task.adapter ? { adapter: task.adapter } : {}
@@ -11160,6 +12393,350 @@ var WsClient = class extends EventEmitter2 {
   }
 };
 
+// src/daemon/pending-reply-cache.ts
+function fromRaw(r) {
+  return {
+    idempotencyKey: r.idempotency_key,
+    taskId: r.task_id,
+    replyId: r.reply_id,
+    status: r.status,
+    payloadJson: r.payload_json,
+    createdAt: r.created_at,
+    preparedAt: r.prepared_at,
+    lastAttemptAt: r.last_attempt_at,
+    attemptCount: r.attempt_count,
+    lastError: r.last_error
+  };
+}
+function createPendingReplyCache(db) {
+  const insert = db.prepare(
+    `INSERT OR REPLACE INTO pending_dispatch_replies
+       (idempotency_key, task_id, reply_id, status, payload_json,
+        prepared_at, created_at, last_attempt_at, attempt_count, last_error)
+     VALUES (?, ?, NULL, 'pending', ?, NULL, ?, NULL, 0, NULL)`
+  );
+  const markPreparedStmt = db.prepare(
+    `UPDATE pending_dispatch_replies
+       SET reply_id = ?, status = 'prepared', prepared_at = ?,
+           last_attempt_at = ?, attempt_count = attempt_count + 1,
+           last_error = NULL
+     WHERE idempotency_key = ?`
+  );
+  const markAttemptStmt = db.prepare(
+    `UPDATE pending_dispatch_replies
+       SET last_attempt_at = ?, attempt_count = attempt_count + 1,
+           last_error = ?
+     WHERE idempotency_key = ?`
+  );
+  const clearStmt = db.prepare(
+    `DELETE FROM pending_dispatch_replies WHERE idempotency_key = ?`
+  );
+  const listRecoveryStmt = db.prepare(
+    `SELECT * FROM pending_dispatch_replies
+     WHERE status IN ('pending', 'prepared')
+     ORDER BY created_at ASC`
+  );
+  const countStmt = db.prepare(
+    `SELECT status, COUNT(*) as cnt FROM pending_dispatch_replies
+     WHERE status IN ('pending','prepared') GROUP BY status`
+  );
+  const findStmt = db.prepare(
+    `SELECT * FROM pending_dispatch_replies WHERE idempotency_key = ?`
+  );
+  return {
+    savePending(idempotencyKey, taskId, payloadJson, now = Date.now()) {
+      insert.run(idempotencyKey, taskId, payloadJson, now);
+    },
+    markPrepared(idempotencyKey, replyId, now = Date.now()) {
+      markPreparedStmt.run(replyId, now, now, idempotencyKey);
+    },
+    markAttempt(idempotencyKey, now = Date.now(), error) {
+      markAttemptStmt.run(now, error ?? null, idempotencyKey);
+    },
+    clearPending(idempotencyKey) {
+      clearStmt.run(idempotencyKey);
+    },
+    listForRecovery() {
+      const rows = listRecoveryStmt.all();
+      return rows.map(fromRaw);
+    },
+    countByStatus() {
+      const rows = countStmt.all();
+      const result = { pending: 0, prepared: 0 };
+      for (const r of rows) {
+        if (r.status === "pending") result.pending = r.cnt;
+        else if (r.status === "prepared") result.prepared = r.cnt;
+      }
+      return result;
+    },
+    findByIdempotencyKey(idempotencyKey) {
+      const row = findStmt.get(idempotencyKey);
+      return row ? fromRaw(row) : null;
+    }
+  };
+}
+function generateIdempotencyKey() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  const bytes = new Uint8Array(16);
+  const cryptoNode = globalThis.crypto;
+  if (cryptoNode?.getRandomValues) {
+    cryptoNode.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+
+// src/daemon/dispatch-reply-transport.ts
+var DispatchReplyAbortedError = class extends Error {
+  constructor(replyId) {
+    super(`dispatch reply ${replyId} aborted by server reaper (likely >1h since prepare)`);
+    this.replyId = replyId;
+    this.name = "DispatchReplyAbortedError";
+  }
+  replyId;
+  code = "DISPATCH_REPLY_INVALID_STATE";
+};
+function defaultLog2(line) {
+  process.stderr.write(`${line}
+`);
+}
+async function sendDispatchReplyTwoPhase(args) {
+  const { taskId, payload, cloud, cache } = args;
+  const log8 = args.log ?? defaultLog2;
+  const idempotencyKey = args.idempotencyKey ?? generateIdempotencyKey();
+  const payloadJson = JSON.stringify({ ...payload, _taskId: taskId, _idempotencyKey: idempotencyKey });
+  cache.savePending(idempotencyKey, taskId, payloadJson);
+  const prepareRes = await cloud.request("POST", `/api/im/dispatch/${encodeURIComponent(taskId)}/prepare`, {
+    body: { ...payload, idempotencyKey },
+    timeoutMs: 3e4
+  });
+  if (!prepareRes.ok || !prepareRes.data) {
+    const errCode = prepareRes.error?.code ?? "unknown";
+    const errMsg = prepareRes.error?.message ?? `prepare failed (status=${prepareRes.status})`;
+    cache.markAttempt(idempotencyKey, Date.now(), `prepare: ${errCode}: ${errMsg}`);
+    throw new Error(`dispatch prepare failed: ${errCode}: ${errMsg}`);
+  }
+  const envelope2 = prepareRes.data;
+  const inner = "data" in envelope2 && envelope2.data ? envelope2.data : envelope2;
+  if (!inner || typeof inner.replyId !== "string") {
+    cache.markAttempt(idempotencyKey, Date.now(), "prepare: missing replyId in response");
+    throw new Error("dispatch prepare returned no replyId");
+  }
+  if ("ok" in envelope2 && envelope2.ok === false) {
+    const errCode = envelope2.error?.code ?? "prepare_failed";
+    const errMsg = envelope2.error?.message ?? "prepare ok=false";
+    cache.markAttempt(idempotencyKey, Date.now(), `prepare: ${errCode}: ${errMsg}`);
+    throw new Error(`dispatch prepare failed: ${errCode}: ${errMsg}`);
+  }
+  cache.markPrepared(idempotencyKey, inner.replyId);
+  log8(
+    `[daemon] dispatch.prepare task=${taskId} replyId=${inner.replyId} status=${inner.status} idem=${idempotencyKey}`
+  );
+  if (inner.status === "committed") {
+    cache.clearPending(idempotencyKey);
+    return {
+      taskId,
+      replyId: inner.replyId,
+      status: "committed",
+      alreadyCommitted: true
+    };
+  }
+  try {
+    const result = await commitDispatchReply({ taskId, replyId: inner.replyId, cloud, log: log8 });
+    cache.clearPending(idempotencyKey);
+    return { taskId, replyId: inner.replyId, ...result };
+  } catch (err) {
+    if (err instanceof DispatchReplyAbortedError) {
+      cache.clearPending(idempotencyKey);
+      log8(`[daemon] dispatch.commit aborted task=${taskId} replyId=${inner.replyId} \u2014 dispatch lost`);
+      return {
+        taskId,
+        replyId: inner.replyId,
+        status: "aborted",
+        alreadyCommitted: false
+      };
+    }
+    cache.markAttempt(idempotencyKey, Date.now(), `commit: ${err.message}`);
+    throw err;
+  }
+}
+async function commitDispatchReply(args) {
+  const log8 = args.log ?? defaultLog2;
+  const res = await args.cloud.request("POST", `/api/im/dispatch/${encodeURIComponent(args.taskId)}/commit`, {
+    body: { replyId: args.replyId },
+    timeoutMs: 3e4
+  });
+  if (!res.ok || !res.data) {
+    const code = res.error?.code ?? "unknown";
+    const msg = res.error?.message ?? `commit failed (status=${res.status})`;
+    if (code === "DISPATCH_REPLY_INVALID_STATE") {
+      throw new DispatchReplyAbortedError(args.replyId);
+    }
+    throw new Error(`dispatch commit failed: ${code}: ${msg}`);
+  }
+  const env = res.data;
+  const inner = "data" in env && env.data ? env.data : env;
+  if ("ok" in env && env.ok === false) {
+    const code = env.error?.code ?? "commit_failed";
+    if (code === "DISPATCH_REPLY_INVALID_STATE") {
+      throw new DispatchReplyAbortedError(args.replyId);
+    }
+    throw new Error(`dispatch commit failed: ${code}: ${env.error?.message ?? "commit ok=false"}`);
+  }
+  log8(
+    `[daemon] dispatch.commit task=${args.taskId} replyId=${args.replyId} alreadyCommitted=${inner.alreadyCommitted ?? false}`
+  );
+  return {
+    status: "committed",
+    alreadyCommitted: Boolean(inner.alreadyCommitted),
+    ...inner.messageId ? { messageId: inner.messageId } : {}
+  };
+}
+async function recoverPendingReplies(deps) {
+  const log8 = deps.log ?? defaultLog2;
+  const rows = deps.cache.listForRecovery();
+  if (rows.length === 0) {
+    return { attempted: 0, committed: 0, aborted: 0, failed: 0 };
+  }
+  log8(`[daemon] dispatch.recovery: ${rows.length} pending row(s) to replay`);
+  let committed = 0;
+  let aborted = 0;
+  let failed = 0;
+  for (const row of rows) {
+    try {
+      const result = await replayRow(row, deps);
+      if (result.status === "committed") committed += 1;
+      else if (result.status === "aborted") aborted += 1;
+    } catch (err) {
+      failed += 1;
+      log8(
+        `[daemon] dispatch.recovery FAIL idem=${row.idempotencyKey} task=${row.taskId}: ${err.message}`
+      );
+    }
+  }
+  log8(
+    `[daemon] dispatch.recovery done attempted=${rows.length} committed=${committed} aborted=${aborted} failed=${failed}`
+  );
+  return { attempted: rows.length, committed, aborted, failed };
+}
+async function replayRow(row, deps) {
+  const log8 = deps.log ?? defaultLog2;
+  if (row.status === "prepared" && row.replyId) {
+    try {
+      const result2 = await commitDispatchReply({
+        taskId: row.taskId,
+        replyId: row.replyId,
+        cloud: deps.cloud,
+        log: log8
+      });
+      deps.cache.clearPending(row.idempotencyKey);
+      return { status: result2.status };
+    } catch (err) {
+      if (err instanceof DispatchReplyAbortedError) {
+        deps.cache.clearPending(row.idempotencyKey);
+        return { status: "aborted" };
+      }
+      throw err;
+    }
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(row.payloadJson);
+  } catch (err) {
+    deps.cache.clearPending(row.idempotencyKey);
+    throw new Error(`pending row ${row.idempotencyKey} has unparseable payload: ${err.message}`);
+  }
+  const { _taskId, _idempotencyKey, ...payload } = parsed;
+  const result = await sendDispatchReplyTwoPhase({
+    taskId: row.taskId,
+    payload,
+    cloud: deps.cloud,
+    cache: deps.cache,
+    idempotencyKey: row.idempotencyKey,
+    log: deps.log
+  });
+  return { status: result.status };
+}
+
+// src/daemon/transport-probe.ts
+import { networkInterfaces } from "os";
+function isPrivateAddress(addr) {
+  if (!addr) return true;
+  const h = String(addr).trim().toLowerCase();
+  if (!h) return true;
+  if (h === "localhost" || h === "::1") return true;
+  const m = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(h);
+  if (m) {
+    const a = Number(m[1]);
+    const b = Number(m[2]);
+    if (a === 10) return true;
+    if (a === 127) return true;
+    if (a === 169 && b === 254) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 100 && b >= 64 && b <= 127) return true;
+    return false;
+  }
+  if (h.endsWith(".local")) return true;
+  if (h.endsWith(".localhost")) return true;
+  return false;
+}
+function buildTransportProbe(gatewayUrl) {
+  if (!gatewayUrl) {
+    return { transport: "ws", gatewayUrl: null, gatewayIsPrivate: true };
+  }
+  let host = null;
+  try {
+    host = new URL(gatewayUrl).hostname;
+  } catch {
+    host = null;
+  }
+  const gatewayIsPrivate = isPrivateAddress(host);
+  return {
+    transport: gatewayIsPrivate ? "ws" : "both",
+    gatewayUrl,
+    gatewayIsPrivate
+  };
+}
+function pickLocalIPv4() {
+  const nics = networkInterfaces();
+  let firstPrivate = null;
+  for (const list of Object.values(nics)) {
+    if (!list) continue;
+    for (const ni of list) {
+      if (ni.internal || ni.family !== "IPv4") continue;
+      if (!isPrivateAddress(ni.address)) return ni.address;
+      if (!firstPrivate) firstPrivate = ni.address;
+    }
+  }
+  return firstPrivate;
+}
+async function reportTransportProbe(cloud, daemonId, probe) {
+  const body = {
+    daemonId,
+    transport: probe.transport,
+    gatewayUrl: probe.gatewayUrl,
+    gatewayIsPrivate: probe.gatewayIsPrivate
+  };
+  const res = await cloud.request("POST", "/api/im/runtime/transport-report", {
+    body,
+    timeoutMs: 5e3
+  });
+  if (!res.ok) {
+    return {
+      ok: false,
+      status: res.status,
+      error: res.error?.message ?? `transport-report failed (${res.status})`
+    };
+  }
+  return { ok: true, status: res.status };
+}
+
 // src/daemon/runner.ts
 var DEFAULT_LOCAL_PORT = 3210;
 var log7 = createLogger("Daemon");
@@ -11208,6 +12785,14 @@ var Runner = class extends EventEmitter3 {
   // F16 (2026-05-20) — periodic skill resync timer (default 10min).
   skillResyncTimer;
   skillSyncInFlight = false;
+  // Wave-4 E7 — local cache of in-flight two-phase dispatch replies. Survives
+  // daemon crash so cold-start can resume `prepared` rows via idempotent
+  // commit (server enforces (taskId, idempotencyKey) UNIQUE).
+  pendingReplyCache;
+  // One-shot guard so we only recover on the first post-authenticated tick,
+  // not every reconnect (server-side commits are idempotent but the log noise
+  // and DB pressure of re-running on every redeclare is wasteful).
+  pendingReplyRecoveryDone = false;
   async start() {
     if (this.state !== "idle") throw new Error(`Runner already in state ${this.state}`);
     this.state = "starting";
@@ -11222,6 +12807,7 @@ var Runner = class extends EventEmitter3 {
     process.env.PRISMER_API_KEY = this.config.api_key;
     this.db = openLocalDb(this.paths.localDb);
     this.cloud = new CloudClient({ baseUrl: this.config.cloud_api_base, apiKey: this.config.api_key });
+    this.pendingReplyCache = createPendingReplyCache(this.db);
     this.assetCache = new AssetCache({
       db: this.db,
       cloud: this.cloud,
@@ -11828,6 +13414,19 @@ var Runner = class extends EventEmitter3 {
         process.stdout.write(`[daemon] ws authenticated, sending agent.host.declare (${this.hostedAgents.size} agents)
 `);
         this.sendDeclare();
+        if (!this.pendingReplyRecoveryDone) {
+          this.pendingReplyRecoveryDone = true;
+          void recoverPendingReplies({ cloud: this.cloud, cache: this.pendingReplyCache }).then((summary) => {
+            if (summary.attempted === 0) return;
+            process.stdout.write(
+              `[daemon] dispatch.recovery summary attempted=${summary.attempted} committed=${summary.committed} aborted=${summary.aborted} failed=${summary.failed}
+`
+            );
+          }).catch((err) => {
+            process.stderr.write(`[daemon] dispatch.recovery threw: ${err.message}
+`);
+          });
+        }
         return;
       }
       this.handleIncoming(msg);
@@ -11874,12 +13473,90 @@ var Runner = class extends EventEmitter3 {
       case "asset.changed":
         void this.onAssetChanged(msg.payload);
         return;
+      // v2.0 §4.8.1 (Wave 4-E4) — webhook reverse-channel RPC. Cloud's
+      // dispatchExternalMention pushes an AgentDispatchRequest plus an
+      // embedded `_rpcId`; the daemon runs the same handler as the
+      // HTTP /dispatch path and echoes the reply back over WS with the
+      // identical `_rpcId` so cloud's WsRpcService can settle the
+      // pending promise.
+      case "webhook.dispatch.request":
+        void this.onWebhookDispatch(msg.payload);
+        return;
       default:
         this.emit("unknown-message", msg);
     }
   }
+  /**
+   * v2.0 §4.8.1 — webhook dispatch over WS reverse channel.
+   *
+   * Acks via `webhook.dispatch.reply { _rpcId, ok, acceptedAt }` immediately
+   * after `handleAgentMessageDispatch()` returns its synchronous response
+   * — the actual reply (the agent's reply text/attachments) still flows
+   * through `postMessageDispatchReply()` which posts to
+   * `/api/im/dispatch/reply` after the adapter finishes. That mirrors the
+   * HTTP /dispatch contract: ack first, asynchronous final reply via the
+   * dispatch-reply REST endpoint.
+   *
+   * The `_rpcId` field is the only addition versus the HTTP path; we strip
+   * it before passing the payload to the dispatch handler so existing
+   * validation logic doesn't trip on an unknown field.
+   */
+  async onWebhookDispatch(payload) {
+    const rpcId = payload._rpcId;
+    if (!rpcId) {
+      process.stderr.write(`[daemon] webhook.dispatch.request without _rpcId \u2014 dropped
+`);
+      return;
+    }
+    const { _rpcId: _, ...request } = payload;
+    try {
+      const handle = handleAgentMessageDispatch(request, {
+        findAgent: (agentImUserId) => this.findMessageDispatchAgent(agentImUserId),
+        postReply: (replyPayload) => this.postMessageDispatchReply(replyPayload),
+        onError: (err, req) => {
+          process.stderr.write(
+            `[daemon] webhook.dispatch.request failed message=${req.messageId} agent=${req.mentionedAgentImUserId}: ${err instanceof Error ? err.stack ?? err.message : String(err)}
+`
+          );
+        }
+      });
+      this.ws.send({
+        type: "webhook.dispatch.reply",
+        payload: {
+          _rpcId: rpcId,
+          ok: handle.response.ok,
+          acceptedAt: handle.response.acceptedAt,
+          error: handle.response.error
+        }
+      });
+      void handle.done.catch((err) => {
+        process.stderr.write(
+          `[daemon] webhook.dispatch final reply failed message=${request.messageId}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      });
+    } catch (err) {
+      this.ws.send({
+        type: "webhook.dispatch.reply",
+        payload: {
+          _rpcId: rpcId,
+          ok: false,
+          error: {
+            code: "daemon_dispatch_failed",
+            message: err instanceof Error ? err.message : String(err)
+          }
+        }
+      });
+    }
+  }
   async onHostAcked(payload) {
     this.workspaceId = payload.workspaceId;
+    void this.reportTransport().catch((err) => {
+      process.stderr.write(
+        `[daemon] transport-probe report failed: ${err.message}
+`
+      );
+    });
     if (this.memoryWiring && this.workspaceId) {
       syncMemoryFromCloud(this.memoryWiring, this.cloud, [this.workspaceId]).catch(
         (err) => log7.error("Initial memory sync failed", err.message)
@@ -12061,14 +13738,68 @@ var Runner = class extends EventEmitter3 {
     };
   }
   async postMessageDispatchReply(payload) {
-    const res = await this.cloud.request("POST", "/api/im/dispatch/reply", {
-      auth: false,
-      body: payload,
-      timeoutMs: 3e4
-    });
-    if (!res.ok) {
-      throw new Error(res.error?.message ?? `dispatch reply failed (${res.status})`);
+    const taskId = `external:${payload.replyToMessageId}`;
+    try {
+      const result = await sendDispatchReplyTwoPhase({
+        taskId,
+        payload: {
+          conversationId: payload.conversationId,
+          replyToken: payload.replyToken,
+          replyToMessageId: payload.replyToMessageId,
+          agentImUserId: payload.agentImUserId,
+          status: payload.status,
+          ...payload.replyText !== void 0 ? { replyText: payload.replyText } : {},
+          ...payload.attachments ? { attachments: payload.attachments } : {},
+          assetIds: payload.attachments?.map((a) => a.assetId).filter((id) => typeof id === "string") ?? [],
+          completedAt: payload.completedAt,
+          ...payload.error ? { error: payload.error } : {}
+        },
+        cloud: this.cloud,
+        cache: this.pendingReplyCache
+      });
+      if (result.status === "aborted") {
+        throw new Error(`dispatch reply aborted by server reaper (replyId=${result.replyId})`);
+      }
+    } catch (err) {
+      throw new Error(
+        err.message?.length ? err.message : `dispatch reply failed`
+      );
+    }
+  }
+  /**
+   * v2.0 §4.8.1 (Wave 4-E4) — submit the transport-probe report. Called
+   * from `onHostAcked` so the daemon's container row exists in cloud
+   * before we POST to /runtime/transport-report.
+   *
+   * The gatewayUrl reported here is `http://<local-ipv4>:<localPort>`
+   * (typically `http://192.168.x.x:3210`). For a daemon without a local
+   * HTTP server (startLocalServer=false in tests) we still post the
+   * probe with `gatewayUrl=null` so cloud knows transport='ws' is the
+   * only path.
+   */
+  async reportTransport() {
+    const hasLocalServer = this.opts.startLocalServer !== false;
+    let gatewayUrl = null;
+    if (hasLocalServer) {
+      const localIp = pickLocalIPv4();
+      if (localIp) {
+        const port = this.opts.localPort ?? DEFAULT_LOCAL_PORT;
+        gatewayUrl = `http://${localIp}:${port}`;
+      }
     }
+    const probe = buildTransportProbe(gatewayUrl);
+    const result = await reportTransportProbe(this.cloud, this.config.daemon_id, probe);
+    if (!result.ok) {
+      process.stderr.write(
+        `[daemon] transport-probe report rejected status=${result.status} error=${result.error ?? "-"}
+`
+      );
+      return;
+    }
+    process.stdout.write(
+      `[daemon] transport-probe reported transport=${probe.transport} gateway=${probe.gatewayUrl ?? "null"} private=${probe.gatewayIsPrivate}
+`
+    );
   }
   onAgentChanged(payload) {
     const a = this.hostedAgents.get(payload.agentImUserId);
@@ -12511,7 +14242,7 @@ var Runner = class extends EventEmitter3 {
 function resolveUserAssetWorkspaceDir(workspaceId) {
   const override = process.env.PRISMER_ASSET_SYNC_ROOT;
   if (override) return join17(override, workspaceId);
-  const home = homedir7();
+  const home = homedir8();
   const desktop = join17(home, "Desktop");
   const base = existsSync13(desktop) ? desktop : home;
   return join17(base, "Prismer Assets", workspaceId);
@@ -12630,7 +14361,7 @@ function buildDaemonCommand() {
     while (!configExists(paths)) {
       if (stopRequested) return;
       getUI().info(`[daemon] waiting for ${paths.configFile} \u2014 run \`prismer setup\` to create it`);
-      await sleep2(5e3);
+      await sleep3(5e3);
     }
     runner = new Runner({
       startLocalServer: opts.localServer !== false,
@@ -12662,7 +14393,7 @@ function buildDaemonCommand() {
     if (existingPid && pidAlive2(existingPid)) {
       exitWithError(`Daemon already running (pid ${existingPid}). Use \`prismer daemon stop\` first.`);
     }
-    if (!existsSync14(paths.logsDir)) mkdirSync9(paths.logsDir, { recursive: true });
+    if (!existsSync14(paths.logsDir)) mkdirSync10(paths.logsDir, { recursive: true });
     const logFile = join18(paths.logsDir, "daemon.log");
     const fd = openSync2(logFile, "a");
     const args = [process.argv[1], "daemon", "run"];
@@ -12676,7 +14407,7 @@ function buildDaemonCommand() {
     child.unref();
     const deadline = Date.now() + 5e3;
     while (Date.now() < deadline) {
-      await sleep2(200);
+      await sleep3(200);
       const pid = readPidFile(paths);
       if (pid && pidAlive2(pid)) {
         if (opts.json) printJson({ ok: true, pid, logFile });
@@ -12710,7 +14441,7 @@ function buildDaemonCommand() {
         getUI().ok("Daemon stopped", `pid ${pid}`);
         return;
       }
-      await sleep2(200);
+      await sleep3(200);
     }
     process.stderr.write(`Daemon did not exit within timeout; pid ${pid} may still be alive.
 `);
@@ -12791,7 +14522,7 @@ async function tailFromEnd(path9, lines) {
 async function followFile(path9) {
   let offset = statSync4(path9).size;
   for (; ; ) {
-    await sleep2(1e3);
+    await sleep3(1e3);
     const size = statSync4(path9).size;
     if (size < offset) offset = 0;
     if (size === offset) continue;
@@ -12805,7 +14536,7 @@ async function followFile(path9) {
 init_util();
 import { Command as Command9 } from "commander";
 import { createReadStream as createReadStream2, existsSync as existsSync15 } from "fs";
-import { homedir as homedir8 } from "os";
+import { homedir as homedir9 } from "os";
 import { join as join19 } from "path";
 import { createInterface } from "readline";
 var DEFAULT_LIMIT2 = 50;
@@ -12838,7 +14569,7 @@ function buildEventsStatsCommand() {
     const events = await readEvents(file, filters);
     printJson({
       ok: true,
-      data: { stats: summarize2(events), count: events.length, limit: filters.limit },
+      data: { stats: summarize3(events), count: events.length, limit: filters.limit },
       checks: { file, exists: true, filters: cleanFilters(filters) }
     });
   });
@@ -12847,7 +14578,7 @@ function addEventOptions(cmd) {
   return cmd.option("--limit <n>", "Max events to return/read", parsePositiveInt4, DEFAULT_LIMIT2).option("--agent-id <id>", "Filter by agent id").option("--session-id <id>", "Filter by session id").option("--family <name>", "Filter by event family").option("--type <name>", "Filter by event type").option("--json", "Output JSON (default)");
 }
 function eventsPath() {
-  return join19(process.env.PRISMER_HOME ?? join19(homedir8(), ".prismer"), "para", "events.jsonl");
+  return join19(process.env.PRISMER_HOME ?? join19(homedir9(), ".prismer"), "para", "events.jsonl");
 }
 function unavailable(file) {
   return {
@@ -12895,7 +14626,7 @@ function field(event, names) {
   }
   return void 0;
 }
-function summarize2(events) {
+function summarize3(events) {
   const byFamily = {};
   const byType = {};
   const byAgentId = {};
@@ -13209,7 +14940,7 @@ import { Command as Command11 } from "commander";
 // src/pair.ts
 import { generateKeyPairSync } from "crypto";
 import { hostname as hostname2 } from "os";
-import { setTimeout as sleep3 } from "timers/promises";
+import { setTimeout as sleep4 } from "timers/promises";
 import qrcode from "qrcode";
 
 // src/daemon-id.ts
@@ -13296,7 +15027,7 @@ Scan with Lumin to approve, or open: ${offer.qrUrl}
   const pollIntervalMs = opts.pollIntervalMs ?? 5e3;
   for (let i = 0; i < maxAttempts; i += 1) {
     if (i > 0 || !localOnlyMode) {
-      await sleep3(pollIntervalMs);
+      await sleep4(pollIntervalMs);
     }
     const res = await cloud.request(
       "GET",
@@ -13377,7 +15108,7 @@ function buildPairCommand() {
 
 // src/cli/commands/profile.ts
 import { Command as Command12 } from "commander";
-import { existsSync as existsSync17, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
 import { tmpdir } from "os";
 import { join as join20 } from "path";
 import { spawnSync as spawnSync4 } from "child_process";
@@ -13504,7 +15235,7 @@ function buildProfileCommand() {
       `/api/im/agent_profiles/${encodeURIComponent(profileId)}`
     );
     const tmpFile = join20(tmpdir(), `prismer-profile-${profileId}.json`);
-    writeFileSync9(tmpFile, JSON.stringify(profile.config, null, 2), "utf8");
+    writeFileSync10(tmpFile, JSON.stringify(profile.config, null, 2), "utf8");
     const editor = process.env.EDITOR || "vi";
     const ed = spawnSync4(editor, [tmpFile], { stdio: "inherit" });
     if (ed.status !== 0) exitWithError(`editor exited ${ed.status}`, { code: "editor_failed" });
@@ -13545,10 +15276,10 @@ async function resolveDefaultWorkspaceId(cloud) {
 // src/cli/commands/reset.ts
 import { Command as Command13 } from "commander";
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, rmSync, renameSync as renameSync2 } from "fs";
-import { homedir as homedir9 } from "os";
-import { dirname as dirname11, join as join21 } from "path";
-import { setTimeout as sleep4 } from "timers/promises";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, rmSync, renameSync as renameSync2 } from "fs";
+import { homedir as homedir10 } from "os";
+import { dirname as dirname12, join as join21 } from "path";
+import { setTimeout as sleep5 } from "timers/promises";
 init_util();
 init_ui();
 function buildResetCommand() {
@@ -13601,8 +15332,8 @@ function buildResetCommand() {
         rmSync(paths.root, { recursive: true, force: true });
       } else {
         if (!archivePath) throw new Error("internal: archivePath missing");
-        if (!existsSync18(dirname11(archivePath))) {
-          mkdirSync10(dirname11(archivePath), { recursive: true });
+        if (!existsSync18(dirname12(archivePath))) {
+          mkdirSync11(dirname12(archivePath), { recursive: true });
         }
         renameSync2(paths.root, archivePath);
       }
@@ -13612,8 +15343,8 @@ function buildResetCommand() {
         rmSync(assetSyncRoot, { recursive: true, force: true });
       } else {
         if (!assetSyncArchivePath) throw new Error("internal: assetSyncArchivePath missing");
-        if (!existsSync18(dirname11(assetSyncArchivePath))) {
-          mkdirSync10(dirname11(assetSyncArchivePath), { recursive: true });
+        if (!existsSync18(dirname12(assetSyncArchivePath))) {
+          mkdirSync11(dirname12(assetSyncArchivePath), { recursive: true });
         }
         renameSync2(assetSyncRoot, assetSyncArchivePath);
       }
@@ -13623,13 +15354,13 @@ function buildResetCommand() {
         rmSync(hermesHome, { recursive: true, force: true });
       } else {
         if (!hermesArchivePath) throw new Error("internal: hermesArchivePath missing");
-        if (!existsSync18(dirname11(hermesArchivePath))) {
-          mkdirSync10(dirname11(hermesArchivePath), { recursive: true });
+        if (!existsSync18(dirname12(hermesArchivePath))) {
+          mkdirSync11(dirname12(hermesArchivePath), { recursive: true });
         }
         renameSync2(hermesHome, hermesArchivePath);
       }
     }
-    mkdirSync10(paths.root, { recursive: true });
+    mkdirSync11(paths.root, { recursive: true });
     if (opts.json) {
       printJson({ ok: true, reset: true, plan });
       return;
@@ -13678,7 +15409,7 @@ async function stopProcess(pid, timeoutMs, label) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (!pidAlive2(pid)) return;
-    await sleep4(100);
+    await sleep5(100);
   }
   try {
     process.kill(pid, "SIGKILL");
@@ -13688,7 +15419,7 @@ async function stopProcess(pid, timeoutMs, label) {
   const killDeadline = Date.now() + 1e3;
   while (Date.now() < killDeadline) {
     if (!pidAlive2(pid)) return;
-    await sleep4(100);
+    await sleep5(100);
   }
   throw new Error(`${label} pid ${pid} did not exit within ${timeoutMs + 1e3}ms`);
 }
@@ -13698,13 +15429,13 @@ function timestamp() {
 function resolveAssetSyncRoot() {
   const override = process.env.PRISMER_ASSET_SYNC_ROOT;
   if (override) return override;
-  const home = homedir9();
+  const home = homedir10();
   const desktop = join21(home, "Desktop");
   const base = existsSync18(desktop) ? desktop : home;
   return join21(base, "Prismer Assets");
 }
 function resolveHermesHome() {
-  return process.env.HERMES_HOME || join21(homedir9(), ".hermes");
+  return process.env.HERMES_HOME || join21(homedir10(), ".hermes");
 }
 function findHermesGatewayPids2() {
   try {
@@ -14259,7 +15990,7 @@ function buildSkillCommand() {
     const cloud = mkCloud6();
     const path9 = opts.agent ? `/api/im/agents/${encodeURIComponent(opts.agent)}/skills` : `/api/im/skills/${encodeURIComponent(slugOrId)}/install`;
     const body = opts.agent ? { skillId: slugOrId, workspaceId: opts.workspaceId, version: opts.version } : { workspaceId: opts.workspaceId, version: opts.version };
-    const data = await requestEnvelope(cloud, "POST", path9, body, "skill_install_failed");
+    const data = await requestEnvelope2(cloud, "POST", path9, body, "skill_install_failed");
     if (opts.json) {
       printJson(data);
       return;
@@ -14270,7 +16001,7 @@ function buildSkillCommand() {
     const cloud = mkCloud6();
     const path9 = opts.agent ? `/api/im/agents/${encodeURIComponent(opts.agent)}/skills` : `/api/im/skills/${encodeURIComponent(slugOrId)}/install`;
     const body = opts.agent ? { skillId: slugOrId, workspaceId: opts.workspaceId } : void 0;
-    const data = await requestEnvelope(cloud, "DELETE", path9, body, "skill_uninstall_failed");
+    const data = await requestEnvelope2(cloud, "DELETE", path9, body, "skill_uninstall_failed");
     if (opts.json) {
       printJson(data);
       return;
@@ -14323,7 +16054,7 @@ function mkCloud6() {
   const cfg = loadConfig(resolvePaths());
   return new CloudClient({ baseUrl: cfg.cloud_api_base, apiKey: cfg.api_key });
 }
-async function requestEnvelope(cloud, method, path9, body, code) {
+async function requestEnvelope2(cloud, method, path9, body, code) {
   const res = await cloud.request(method, path9, {
     body
   });
@@ -14473,6 +16204,7 @@ function buildStatusCommand() {
     let me = null;
     let devices = null;
     let agents = null;
+    let diagnose = null;
     try {
       const meRes = await cloud.request("GET", "/api/im/me", { timeoutMs: 3e3 });
       cloudOk = meRes.ok;
@@ -14485,19 +16217,33 @@ function buildStatusCommand() {
           if (Array.isArray(wsList) && wsList.length > 0) {
             const wsId = wsList[0]?.id;
             if (wsId) {
-              const devRes = await cloud.request("GET", `/api/workspace/runtime-installations?workspaceId=${encodeURIComponent(wsId)}&includeStopped=false`, { timeoutMs: 3e3 });
-              if (devRes.ok) {
-                const devBody = devRes.data;
-                devices = devBody?.data;
-              }
-              const agRes = await cloud.request("GET", `/api/im/workspaces/${encodeURIComponent(wsId)}/agents`, { timeoutMs: 3e3 });
-              if (agRes.ok) {
-                const agBody = agRes.data;
-                agents = agBody?.data;
+              const rtRes = await cloud.request("GET", `/api/im/workspaces/${encodeURIComponent(wsId)}/runtime`, { timeoutMs: 3e3 });
+              if (rtRes.ok) {
+                const rtBody = rtRes.data;
+                const snapshot = rtBody?.data;
+                if (snapshot && Array.isArray(snapshot.devices)) {
+                  devices = snapshot.devices;
+                  agents = snapshot.devices.flatMap((d) => d.agents ?? []);
+                }
               }
             }
           }
         }
+        const daemonId = cfg.daemon_id;
+        if (daemonId) {
+          try {
+            const diagRes = await cloud.request(
+              "GET",
+              `/api/im/runtime/diagnose?daemonId=${encodeURIComponent(daemonId)}`,
+              { timeoutMs: 3e3 }
+            );
+            if (diagRes.ok) {
+              const body = diagRes.data;
+              if (body?.data && typeof body.data === "object") diagnose = body.data;
+            }
+          } catch {
+          }
+        }
       }
     } catch {
       cloudOk = false;
@@ -14514,7 +16260,8 @@ function buildStatusCommand() {
         info: daemonStatus.info ?? {}
       },
       cloud: { base: cfg.cloud_api_base, reachable: cloudOk, me, devices, agents },
-      local
+      local,
+      diagnose
     };
     if (opts.json) {
       printJson(report);
@@ -14523,6 +16270,60 @@ function buildStatusCommand() {
     printPretty(report);
   });
 }
+function computeDeviceIcon(lastSeenAt, now) {
+  if (!lastSeenAt) return "\u25CB";
+  const age = now.getTime() - Date.parse(lastSeenAt);
+  if (!Number.isFinite(age) || age < 0) return "\u25CB";
+  if (age < 5 * 6e4) return "\u25CF";
+  if (age < 60 * 6e4) return "\u25D0";
+  return "\u25CB";
+}
+function computeAgentIcon(status, lastHeartbeat, now) {
+  const s = (status || "").toLowerCase();
+  if (s === "error" || s === "failed") return "\u25C6";
+  if (!lastHeartbeat) return s === "offline" ? "\u25CB" : "\u25D0";
+  const age = now.getTime() - Date.parse(lastHeartbeat);
+  if (!Number.isFinite(age) || age < 0 || age >= 60 * 6e4) return "\u25CB";
+  if (age >= 5 * 6e4) return "\u25D0";
+  return "\u25CF";
+}
+function pad(value, width) {
+  if (value.length >= width) return value.slice(0, width);
+  return value + " ".repeat(width - value.length);
+}
+function formatDeviceBindings(devices, now = /* @__PURE__ */ new Date()) {
+  const lines = [];
+  if (devices.length === 0) {
+    lines.push("  No paired devices.");
+    return lines;
+  }
+  const totalAgents = devices.reduce((s, d) => s + (d.agents?.length ?? 0), 0);
+  const devWord = devices.length === 1 ? "device" : "devices";
+  const agWord = totalAgents === 1 ? "agent" : "agents";
+  lines.push(`  Device & Agent Bindings (${devices.length} ${devWord} \xB7 ${totalAgents} ${agWord})`);
+  lines.push("");
+  for (let di = 0; di < devices.length; di++) {
+    const d = devices[di];
+    const dIcon = computeDeviceIcon(d.lastSeenAt, now);
+    const dName = pad(d.name || d.deviceId, 40);
+    const lastSeen = d.lastSeenAt ? formatRelative(d.lastSeenAt, now) : "never seen";
+    lines.push(`  ${dIcon} ${dName}  ${lastSeen}`);
+    const agents = d.agents ?? [];
+    for (let ai = 0; ai < agents.length; ai++) {
+      const a = agents[ai];
+      const isLast = ai === agents.length - 1;
+      const branch = isLast ? "\u2514\u2500" : "\u251C\u2500";
+      const aIcon = computeAgentIcon(a.status, a.lastHeartbeat, now);
+      const aName = pad(a.name || a.id, 24);
+      const aStatus = pad(a.status || "?", 8);
+      const aVersion = pad(a.version ? `v${a.version}` : "\u2014", 10);
+      const tail = a.currentTaskId ? `task=${a.currentTaskId}` : a.lastHeartbeat ? `\u2764 ${formatRelative(a.lastHeartbeat, now)}` : "";
+      lines.push(`     ${branch} ${aIcon} ${aName}  ${aStatus}  ${aVersion}  ${tail}`.trimEnd());
+    }
+    if (di < devices.length - 1) lines.push("");
+  }
+  return lines;
+}
 async function readDaemonStatus() {
   try {
     const res = await fetch("http://127.0.0.1:3210/healthz", {
@@ -14595,16 +16396,7 @@ function printPretty(report) {
   if (Array.isArray(report.cloud.devices) && report.cloud.devices.length > 0) {
     const devs = report.cloud.devices;
     ui.blank();
-    ui.line(`  Workspace Devices (${devs.length}):`);
-    for (const d of devs) {
-      const statusIcon = d.daemonStatus === "connected" ? "\u25CF" : "\u25CB";
-      const kind = d.runtimeKind === "docker" ? "Local" : "K8s";
-      const declared = d.hostedAgentSummary?.declared ?? 0;
-      ui.line(`    ${statusIcon} ${d.podName?.replace(/^daemon:/, "")?.slice(0, 28) ?? "?"}  kind=${kind}  agents=${declared}`);
-    }
-  }
-  if (Array.isArray(report.cloud.agents) && report.cloud.agents.length > 0) {
-    ui.line(`  Hosted agents: ${report.cloud.agents.length}`);
+    for (const ln of formatDeviceBindings(devs)) ui.line(ln);
   }
   if (report.local) {
     ui.blank();
@@ -14614,11 +16406,63 @@ function printPretty(report) {
   } else {
     warn("Local DB", "unavailable");
   }
+  if (report.diagnose) {
+    ui.blank();
+    ui.header("Cloud dispatch reachability");
+    ui.blank();
+    printDiagnose(report.diagnose, report.daemon.pid ?? null);
+  }
+}
+function printDiagnose(d, pid) {
+  const ui = getUI();
+  const heartbeatLine = d.lastHeartbeatAt ? `last heartbeat ${formatRelative(d.lastHeartbeatAt)}` : "no heartbeat seen";
+  if (d.wsAlive) {
+    ok("Daemon", `running${pid ? ` (pid ${pid})` : ""}`);
+    ok("Cloud WS", `connected (${heartbeatLine})`);
+  } else {
+    warn("Daemon", `running${pid ? ` (pid ${pid})` : ""} \u2014 not visible to cloud WS`);
+    fail("Cloud WS", `disconnected (${heartbeatLine})`);
+  }
+  if (d.gatewayUrl) {
+    if (d.gatewayIsPrivate) {
+      warn("HTTP gateway", `${d.gatewayUrl} (private IP \u2014 only reachable on same network)`);
+    } else if (d.httpReachable) {
+      ok(
+        "HTTP gateway",
+        `${d.gatewayUrl} (reachable${d.httpLatencyMs != null ? `, ${d.httpLatencyMs}ms` : ""})`
+      );
+    } else {
+      fail("HTTP gateway", `${d.gatewayUrl} (unreachable${d.httpError ? ` \u2014 ${d.httpError}` : ""})`);
+    }
+  } else {
+    ui.line("  HTTP gateway: not declared (WS-only daemon)");
+  }
+  const activeAgents = /* @__PURE__ */ (() => {
+    return 0;
+  })();
+  if (activeAgents > 0) {
+    ok("Active agents", String(activeAgents));
+  }
+  const recColour = d.recommendedTransport === "ws" ? ok : d.recommendedTransport === "http" ? warn : fail;
+  recColour("Recommended transport", d.recommendedTransport);
+  if (d.lastProbeAt) {
+    ui.line(`  Last transport probe: ${formatRelative(d.lastProbeAt)}`);
+  }
+}
+function formatRelative(iso, now = /* @__PURE__ */ new Date()) {
+  const ts = Date.parse(iso);
+  if (!Number.isFinite(ts)) return "unknown";
+  const diff = Math.max(0, now.getTime() - ts);
+  if (diff < 3e4) return "just now";
+  if (diff < 6e4) return `${Math.round(diff / 1e3)}s ago`;
+  if (diff < 36e5) return `${Math.round(diff / 6e4)}m ago`;
+  if (diff < 864e5) return `${Math.round(diff / 36e5)}h ago`;
+  return `${Math.round(diff / 864e5)}d ago`;
 }
 
 // src/cli/commands/task.ts
 import { Command as Command18 } from "commander";
-import { setTimeout as sleep5 } from "timers/promises";
+import { setTimeout as sleep6 } from "timers/promises";
 init_util();
 function describeStatus2(status) {
   return status === 0 ? "network error" : `HTTP ${status}`;
@@ -14701,7 +16545,7 @@ function unwrap2(raw) {
 async function pollUntilTerminal(cloud, taskId, timeoutMs) {
   const deadline = Date.now() + (timeoutMs ?? 5 * 6e4);
   while (Date.now() < deadline) {
-    await sleep5(1e3);
+    await sleep6(1e3);
     const res = await cloud.request(
       "GET",
       `/api/im/tasks/${encodeURIComponent(taskId)}`
@@ -14976,7 +16820,7 @@ async function readResponseError(res) {
 
 // src/cli/index.ts
 init_ui();
-var VERSION = "2.0.3";
+var VERSION = "2.0.5";
 function buildProgram() {
   const program = new Command20("prismer").description("Prismer Cloud daemon CLI (TS-only).").version(VERSION);
   program.addCommand(buildBannerCommand());