@prismer/runtime 2.0.3 → 2.0.5

package/dist/index.cjs

@@ -166,6 +166,42 @@ var init_skill_loader2 = __esm({
 });
 
 // src/adapters/hermes/index.ts
+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) => {
@@ -575,13 +611,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();
@@ -630,6 +667,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,
@@ -659,7 +700,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 {
@@ -740,7 +827,7 @@ function pidAlive(pid) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var import_node_child_process, import_node_fs2, import_node_module, import_node_os, import_node_path2, import_node_url, import_better_sqlite3, YAML, import_zod, import_meta, PRISMER_IM_SKILL_NAME, PRISMER_IM_SKILL_CONTENT, HermesProfileConfigSchema, hermesAdapter, HermesService;
+var import_node_child_process, import_node_fs2, import_node_module, import_node_os, import_node_path2, import_node_url, import_better_sqlite3, YAML, import_zod, import_meta, 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";
@@ -757,6 +844,7 @@ var init_hermes = __esm({
     init_skill_loader2();
     import_meta = {};
     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.
@@ -1069,6 +1157,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}
@@ -1076,7 +1165,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);
@@ -1100,8 +1203,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: {
@@ -1152,10 +1262,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", {
@@ -1163,7 +1273,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) {
@@ -1173,6 +1289,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: {
@@ -1181,13 +1298,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);
       }
@@ -1209,6 +1400,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 = (0, import_node_path2.join)(this.skillLoader.getSkillsRoot(), skillName);
+          (0, import_node_fs2.mkdirSync)(skillDir, { recursive: true });
+          (0, import_node_fs2.writeFileSync)((0, import_node_path2.join)(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;
@@ -1317,6 +1527,7 @@ No @ needed; the human is the only other party.
         };
       }
     };
+    APPROVAL_TOOL_NAME = "prismer.approval.request_human_approval";
   }
 });
 
@@ -1348,6 +1559,58 @@ var init_skill_loader3 = __esm({
 });
 
 // src/adapters/openclaw/index.ts
+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);
@@ -1368,15 +1631,17 @@ async function checkHealth2(baseUrl, apiKey) {
     return false;
   }
 }
-var import_zod2, import_node_os2, import_node_path3, OpenClawProfileConfigSchema, openclawAdapter, OpenClawService;
+var import_zod2, import_node_fs3, import_node_os2, import_node_path3, PRISMER_ROLE_SKILL_PREFIX2, OpenClawProfileConfigSchema, openclawAdapter, OpenClawService;
 var init_openclaw = __esm({
   "src/adapters/openclaw/index.ts"() {
     "use strict";
     import_zod2 = require("zod");
+    import_node_fs3 = require("fs");
     import_node_os2 = require("os");
     import_node_path3 = require("path");
     init_contract();
     init_skill_loader3();
+    PRISMER_ROLE_SKILL_PREFIX2 = "prismer-role";
     OpenClawProfileConfigSchema = import_zod2.z.object({
       /** OpenClaw chat-completions HTTP port. */
       port: import_zod2.z.number().int().min(1).max(65535).default(18789),
@@ -1421,23 +1686,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() {
@@ -1446,17 +1713,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}`,
@@ -1464,7 +1761,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
@@ -1480,7 +1781,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(
@@ -1498,6 +1813,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 = (0, import_node_path3.join)(this.skillLoader.getSkillsRoot(), skillName);
+          (0, import_node_fs3.mkdirSync)(skillDir, { recursive: true });
+          (0, import_node_fs3.writeFileSync)((0, import_node_path3.join)(skillDir, "SKILL.md"), content, "utf8");
+        } catch (err) {
+          process.stderr.write(
+            `[openclaw-adapter] failed to install role-template skill ${skillName}: ${err.message}
+`
+          );
+        }
+      }
     };
   }
 });
@@ -1545,11 +1879,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;
@@ -1590,7 +1952,7 @@ async function syncInstalledSkillsForDispatch(profile, agentImUserId, cloud, sig
       continue;
     }
     const skillDir = (0, import_node_path8.join)(skillsRoot, slug);
-    await import_node_fs7.promises.mkdir(skillDir, { recursive: true });
+    await import_node_fs8.promises.mkdir(skillDir, { recursive: true });
     const localFiles = await walkLocalDir(skillDir);
     let dirty = false;
     let perFileFailures = 0;
@@ -1645,14 +2007,14 @@ async function syncInstalledSkillsForDispatch(profile, agentImUserId, cloud, sig
         perFileFailures++;
         continue;
       }
-      await import_node_fs7.promises.mkdir((0, import_node_path8.dirname)(targetPath), { recursive: true });
-      await import_node_fs7.promises.writeFile(targetPath, bytes);
+      await import_node_fs8.promises.mkdir((0, import_node_path8.dirname)(targetPath), { recursive: true });
+      await import_node_fs8.promises.writeFile(targetPath, bytes);
       localFiles.delete(file.path);
       dirty = true;
     }
     for (const orphan of localFiles.keys()) {
       try {
-        await import_node_fs7.promises.unlink((0, import_node_path8.join)(skillDir, orphan));
+        await import_node_fs8.promises.unlink((0, import_node_path8.join)(skillDir, orphan));
         dirty = true;
       } catch (err) {
         if (err.code !== "ENOENT") {
@@ -1765,7 +2127,7 @@ async function walkLocalDir(root) {
   async function walk2(dir) {
     let entries;
     try {
-      entries = await import_node_fs7.promises.readdir(dir, { withFileTypes: true });
+      entries = await import_node_fs8.promises.readdir(dir, { withFileTypes: true });
     } catch (err) {
       if (err.code === "ENOENT") return;
       throw err;
@@ -1776,7 +2138,7 @@ async function walkLocalDir(root) {
         await walk2(full);
       } else if (ent.isFile()) {
         try {
-          const buf = await import_node_fs7.promises.readFile(full);
+          const buf = await import_node_fs8.promises.readFile(full);
           const rel = (0, import_node_path8.relative)(root, full).split(import_node_path8.sep).join("/");
           out.set(rel, sha256Buffer(buf));
         } catch {
@@ -1850,11 +2212,11 @@ async function ackSkillSync(cloud, agentImUserId, input, signal) {
 `);
   }
 }
-var import_node_fs7, import_node_path8, import_node_crypto3, skillSyncWarnedProfiles;
+var import_node_fs8, import_node_path8, import_node_crypto3, skillSyncWarnedProfiles;
 var init_skill_sync = __esm({
   "src/daemon/skill-sync.ts"() {
     "use strict";
-    import_node_fs7 = require("fs");
+    import_node_fs8 = require("fs");
     import_node_path8 = require("path");
     import_node_crypto3 = require("crypto");
     init_hermes();
@@ -2295,7 +2657,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.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",
@@ -2329,6 +2691,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",
@@ -2486,21 +2849,21 @@ function pidFilePath(paths) {
   return (0, import_node_path12.join)(paths.root, "daemon.pid");
 }
 function writePidFile(paths, pid) {
-  (0, import_node_fs16.writeFileSync)(pidFilePath(paths), `${pid}
+  (0, import_node_fs17.writeFileSync)(pidFilePath(paths), `${pid}
 `, "utf8");
 }
 function readPidFile(paths) {
   const p = pidFilePath(paths);
-  if (!(0, import_node_fs16.existsSync)(p)) return void 0;
-  const raw = (0, import_node_fs16.readFileSync)(p, "utf8").trim();
+  if (!(0, import_node_fs17.existsSync)(p)) return void 0;
+  const raw = (0, import_node_fs17.readFileSync)(p, "utf8").trim();
   const pid = Number.parseInt(raw, 10);
   return Number.isFinite(pid) ? pid : void 0;
 }
 function clearPidFile(paths) {
   const p = pidFilePath(paths);
-  if ((0, import_node_fs16.existsSync)(p)) {
+  if ((0, import_node_fs17.existsSync)(p)) {
     try {
-      (0, import_node_fs16.unlinkSync)(p);
+      (0, import_node_fs17.unlinkSync)(p);
     } catch {
     }
   }
@@ -2513,11 +2876,11 @@ function pidAlive2(pid) {
     return false;
   }
 }
-var import_node_fs16, import_node_path12, DEFAULT_CLOUD_BASE_URL, ANSI, PKG_VERSION, RUNTIME_SUBTITLE;
+var import_node_fs17, import_node_path12, DEFAULT_CLOUD_BASE_URL, ANSI, PKG_VERSION, RUNTIME_SUBTITLE;
 var init_util = __esm({
   "src/cli/util.ts"() {
     "use strict";
-    import_node_fs16 = require("fs");
+    import_node_fs17 = require("fs");
     import_node_path12 = require("path");
     init_ui();
     DEFAULT_CLOUD_BASE_URL = "https://prismer.cloud";
@@ -2761,9 +3124,9 @@ var WsClient = class extends import_node_events.EventEmitter {
 
 // src/sync/store.ts
 var import_better_sqlite32 = __toESM(require("better-sqlite3"), 1);
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_path4 = require("path");
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 4;
 var MIGRATIONS = [
   {
     version: 1,
@@ -2889,14 +3252,44 @@ 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) {
   db["exec"](sql);
 }
 function openLocalDb(path9) {
-  if (path9 !== ":memory:" && !(0, import_node_fs3.existsSync)((0, import_node_path4.dirname)(path9))) {
-    (0, import_node_fs3.mkdirSync)((0, import_node_path4.dirname)(path9), { recursive: true });
+  if (path9 !== ":memory:" && !(0, import_node_fs4.existsSync)((0, import_node_path4.dirname)(path9))) {
+    (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(path9), { recursive: true });
   }
   const db = new import_better_sqlite32.default(path9);
   db.pragma("journal_mode = WAL");
@@ -3133,7 +3526,7 @@ function listRoleTemplates() {
 
 // src/config.ts
 var TOML = __toESM(require("@iarna/toml"), 1);
-var import_node_fs4 = require("fs");
+var import_node_fs5 = require("fs");
 var import_node_os3 = require("os");
 var import_node_path5 = require("path");
 var import_zod3 = require("zod");
@@ -3176,15 +3569,15 @@ function resolvePaths(home) {
   };
 }
 function configExists(paths = resolvePaths()) {
-  return (0, import_node_fs4.existsSync)(paths.configFile);
+  return (0, import_node_fs5.existsSync)(paths.configFile);
 }
 function loadConfig(paths = resolvePaths()) {
-  if (!(0, import_node_fs4.existsSync)(paths.configFile)) {
+  if (!(0, import_node_fs5.existsSync)(paths.configFile)) {
     throw new Error(
       `Config not found at ${paths.configFile}. Run \`prismer setup\` to create it.`
     );
   }
-  const raw = (0, import_node_fs4.readFileSync)(paths.configFile, "utf8");
+  const raw = (0, import_node_fs5.readFileSync)(paths.configFile, "utf8");
   const parsed = TOML.parse(raw);
   const merged = {
     ...parsed,
@@ -3199,14 +3592,14 @@ function loadConfig(paths = resolvePaths()) {
   return result.data;
 }
 function saveConfig(config, paths = resolvePaths()) {
-  if (!(0, import_node_fs4.existsSync)(paths.root)) {
-    (0, import_node_fs4.mkdirSync)(paths.root, { recursive: true });
+  if (!(0, import_node_fs5.existsSync)(paths.root)) {
+    (0, import_node_fs5.mkdirSync)(paths.root, { recursive: true });
   }
-  if (!(0, import_node_fs4.existsSync)((0, import_node_path5.dirname)(paths.configFile))) {
-    (0, import_node_fs4.mkdirSync)((0, import_node_path5.dirname)(paths.configFile), { recursive: true });
+  if (!(0, import_node_fs5.existsSync)((0, import_node_path5.dirname)(paths.configFile))) {
+    (0, import_node_fs5.mkdirSync)((0, import_node_path5.dirname)(paths.configFile), { recursive: true });
   }
   ConfigSchema.parse(config);
-  (0, import_node_fs4.writeFileSync)(paths.configFile, TOML.stringify(config), "utf8");
+  (0, import_node_fs5.writeFileSync)(paths.configFile, TOML.stringify(config), "utf8");
 }
 function deriveWsUrl(httpBase) {
   const u = new URL(httpBase);
@@ -3379,7 +3772,7 @@ function envelope(type, payload, requestId) {
 // src/asset-cache.ts
 var import_node_crypto2 = require("crypto");
 var import_node_dns = require("dns");
-var import_node_fs5 = require("fs");
+var import_node_fs6 = require("fs");
 var import_node_net = require("net");
 var import_node_path6 = require("path");
 var import_undici = require("undici");
@@ -3404,8 +3797,8 @@ var AssetCache = class {
     this.cloud = opts.cloud;
     this.cacheDir = opts.cacheDir;
     this.maxBytes = opts.maxBytes ?? 5 * 1024 * 1024 * 1024;
-    if (!(0, import_node_fs5.existsSync)(this.cacheDir)) {
-      (0, import_node_fs5.mkdirSync)(this.cacheDir, { recursive: true });
+    if (!(0, import_node_fs6.existsSync)(this.cacheDir)) {
+      (0, import_node_fs6.mkdirSync)(this.cacheDir, { recursive: true });
     }
   }
   /** Local file path for a content hash. Files split by first 2 chars for fs scaling. */
@@ -3415,7 +3808,7 @@ var AssetCache = class {
   get(hash) {
     const row = this.db.prepare("SELECT * FROM cached_assets WHERE content_hash = ?").get(hash);
     if (!row) return void 0;
-    if (!(0, import_node_fs5.existsSync)(row.local_path)) {
+    if (!(0, import_node_fs6.existsSync)(row.local_path)) {
       this.db.prepare("DELETE FROM cached_assets WHERE content_hash = ?").run(hash);
       return void 0;
     }
@@ -3479,12 +3872,12 @@ var AssetCache = class {
       throw new Error(`Asset hash mismatch for ${hash}: downloaded ${actualHash}`);
     }
     const localPath = this.pathFor(hash);
-    if (!(0, import_node_fs5.existsSync)((0, import_node_path6.dirname)(localPath))) {
-      (0, import_node_fs5.mkdirSync)((0, import_node_path6.dirname)(localPath), { recursive: true });
+    if (!(0, import_node_fs6.existsSync)((0, import_node_path6.dirname)(localPath))) {
+      (0, import_node_fs6.mkdirSync)((0, import_node_path6.dirname)(localPath), { recursive: true });
     }
     const tmpPath = `${localPath}.${process.pid}.${Date.now()}.tmp`;
-    (0, import_node_fs5.writeFileSync)(tmpPath, buf);
-    (0, import_node_fs5.renameSync)(tmpPath, localPath);
+    (0, import_node_fs6.writeFileSync)(tmpPath, buf);
+    (0, import_node_fs6.renameSync)(tmpPath, localPath);
     const mime = res.headers.get("content-type");
     const now = Date.now();
     this.db.prepare(
@@ -3543,12 +3936,12 @@ var AssetCache = class {
       return { cached: existing, finalUrl, durationMs: Date.now() - started };
     }
     const localPath = this.pathFor(hash);
-    if (!(0, import_node_fs5.existsSync)((0, import_node_path6.dirname)(localPath))) {
-      (0, import_node_fs5.mkdirSync)((0, import_node_path6.dirname)(localPath), { recursive: true });
+    if (!(0, import_node_fs6.existsSync)((0, import_node_path6.dirname)(localPath))) {
+      (0, import_node_fs6.mkdirSync)((0, import_node_path6.dirname)(localPath), { recursive: true });
     }
     const tmpPath = `${localPath}.${process.pid}.${Date.now()}.tmp`;
-    (0, import_node_fs5.writeFileSync)(tmpPath, body);
-    (0, import_node_fs5.renameSync)(tmpPath, localPath);
+    (0, import_node_fs6.writeFileSync)(tmpPath, body);
+    (0, import_node_fs6.renameSync)(tmpPath, localPath);
     const now = Date.now();
     this.db.prepare(
       `INSERT OR REPLACE INTO cached_assets
@@ -3576,7 +3969,7 @@ var AssetCache = class {
     if (actualHash !== hash) {
       throw new Error(`Asset hash mismatch for ${hash}: local file is ${actualHash}`);
     }
-    const size = (0, import_node_fs5.statSync)(localPath).size;
+    const size = (0, import_node_fs6.statSync)(localPath).size;
     const now = Date.now();
     this.db.prepare(
       `INSERT OR REPLACE INTO cached_assets
@@ -3604,7 +3997,7 @@ var AssetCache = class {
     for (const row of candidates) {
       if (total <= this.maxBytes) break;
       try {
-        if ((0, import_node_fs5.existsSync)(row.local_path)) (0, import_node_fs5.unlinkSync)(row.local_path);
+        if ((0, import_node_fs6.existsSync)(row.local_path)) (0, import_node_fs6.unlinkSync)(row.local_path);
       } catch {
       }
       this.db.prepare("DELETE FROM cached_assets WHERE content_hash = ?").run(row.content_hash);
@@ -3619,7 +4012,7 @@ function sha256(buf) {
   return (0, import_node_crypto2.createHash)("sha256").update(buf).digest("hex");
 }
 function readFileBuffer(path9) {
-  return (0, import_node_fs5.readFileSync)(path9);
+  return (0, import_node_fs6.readFileSync)(path9);
 }
 var DEFAULT_URL_FETCH_MAX_BYTES = 5 * 1024 * 1024;
 var DEFAULT_URL_FETCH_TIMEOUT_MS = 15e3;
@@ -3801,7 +4194,7 @@ async function fetchUrlWithGuards(rawUrl, opts) {
 }
 
 // src/daemon/asset/mirror.ts
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_path7 = require("path");
 function rowToBinding(row) {
   return {
@@ -3823,16 +4216,16 @@ var WorkspaceMirror = class {
     this.db = opts.db;
     this.cloud = opts.cloud;
     this.workspaceId = opts.workspaceId;
-    if (!(0, import_node_fs6.existsSync)(opts.workspaceStateDir)) {
-      (0, import_node_fs6.mkdirSync)(opts.workspaceStateDir, { recursive: true });
+    if (!(0, import_node_fs7.existsSync)(opts.workspaceStateDir)) {
+      (0, import_node_fs7.mkdirSync)(opts.workspaceStateDir, { recursive: true });
     }
     this.cursorPath = (0, import_node_path7.join)(opts.workspaceStateDir, "asset-cursor.json");
   }
   /** Persisted cursor for this workspace, or null on first run / corrupted file. */
   readCursor() {
-    if (!(0, import_node_fs6.existsSync)(this.cursorPath)) return null;
+    if (!(0, import_node_fs7.existsSync)(this.cursorPath)) return null;
     try {
-      const parsed = JSON.parse((0, import_node_fs6.readFileSync)(this.cursorPath, "utf8"));
+      const parsed = JSON.parse((0, import_node_fs7.readFileSync)(this.cursorPath, "utf8"));
       if (parsed.workspaceId !== this.workspaceId) return null;
       return parsed.cursor;
     } catch {
@@ -3845,7 +4238,7 @@ var WorkspaceMirror = class {
       cursor,
       writtenAt: Date.now()
     };
-    (0, import_node_fs6.writeFileSync)(this.cursorPath, JSON.stringify(payload, null, 2));
+    (0, import_node_fs7.writeFileSync)(this.cursorPath, JSON.stringify(payload, null, 2));
   }
   /**
    * Pull workspace_file changes since the persisted cursor and upsert into
@@ -4251,9 +4644,265 @@ function extractHttpUrls(text) {
 }
 
 // src/daemon/dispatch.ts
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var path = __toESM(require("path"), 1);
 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: summarize(input),
+      ...toolCallId ? { toolCallId } : {}
+    });
+  }
+  /** Push a tool-result step. Immediate. */
+  recordToolResult(toolCallId, output) {
+    this.emit("tool_result", {
+      toolCallId,
+      outputSummary: summarize(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 summarize(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;
@@ -4269,12 +4918,14 @@ async function handleDispatch(payload, requestId, deps) {
   const { taskId, agentImUserId } = payload;
   let resolvedHashes = [];
   let reply;
+  let heartbeatRef;
+  let recorderRef;
   const outboxBase = deps.paths?.runsDir ? path.join(deps.paths.runsDir, taskId) : null;
   const outboxDir = outboxBase ? path.join(outboxBase, "_outbox") : null;
   const workDir = outboxBase ? path.join(outboxBase, "workdir") : null;
   if (outboxDir) {
     try {
-      await import_node_fs8.promises.mkdir(outboxDir, { recursive: true });
+      await import_node_fs9.promises.mkdir(outboxDir, { recursive: true });
     } catch (err) {
       process.stderr.write(
         `[daemon] outbox provision failed task=${taskId} dir=${outboxDir}: ${err.message}
@@ -4284,7 +4935,7 @@ async function handleDispatch(payload, requestId, deps) {
   }
   if (workDir) {
     try {
-      await import_node_fs8.promises.mkdir(workDir, { recursive: true });
+      await import_node_fs9.promises.mkdir(workDir, { recursive: true });
     } catch (err) {
       process.stderr.write(
         `[daemon] workdir provision failed task=${taskId} dir=${workDir}: ${err.message}
@@ -4350,7 +5001,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 ? path.join(deps.paths.cacheDir, "vision-cache") : void 0),
+      timeoutMs: deps.visionAux?.timeoutMs,
+      signal: deps.signal
+    });
     resolvedHashes.push(...assetResolution.pinnedHashes);
     const basePrompt = composePrompt(
       rewrittenPrompt.text,
@@ -4385,9 +5042,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,
@@ -4450,6 +5142,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 {
@@ -4461,14 +5156,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] } : {}
@@ -4490,6 +5194,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);
@@ -4566,6 +5282,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}$/;
@@ -4644,8 +5364,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;
@@ -4674,7 +5420,7 @@ async function resolveAssetRefs(refs, cache, taskId) {
     const inlineCandidate = isTextLikeMime(effectiveMime);
     if (inlineCandidate) {
       try {
-        const buf = (0, import_node_fs8.readFileSync)(cached.localPath);
+        const buf = (0, import_node_fs9.readFileSync)(cached.localPath);
         let strategy;
         let body;
         if (buf.byteLength <= ASSET_INLINE_FULL_MAX_BYTES) {
@@ -4710,7 +5456,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 = (0, import_node_fs9.readFileSync)(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,
@@ -4721,6 +5502,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 import_node_fs9.promises.readFile(file, "utf8");
+    const parsed = parseVisionAuxCache(raw);
+    if (!parsed) {
+      await import_node_fs9.promises.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 import_node_fs9.promises.unlink(file).catch(() => void 0);
+    }
+    return null;
+  }
+}
+async function writeVisionAuxLocalCache(cacheDir, contentHash, mime, description) {
+  if (!cacheDir || !mime) return;
+  const file = visionAuxCachePath(cacheDir, contentHash);
+  await import_node_fs9.promises.mkdir(path.dirname(file), { recursive: true });
+  await import_node_fs9.promises.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 path.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(
@@ -4735,8 +5620,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.`;
@@ -5219,8 +6115,9 @@ var ServicePool = class {
 // src/daemon/local-server.ts
 var import_node_http = require("http");
 var import_node_crypto4 = require("crypto");
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var path2 = __toESM(require("path"), 1);
+var import_node_os5 = require("os");
 var LocalServer = class {
   constructor(opts) {
     this.opts = opts;
@@ -5332,6 +6229,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;
@@ -5382,7 +6284,7 @@ var LocalServer = class {
   async handleSnapshot(req, res) {
     const root = this.opts.snapshotRoot ?? "/workspace";
     try {
-      const st = await import_node_fs9.promises.stat(root);
+      const st = await import_node_fs10.promises.stat(root);
       if (!st.isDirectory()) {
         respond(res, 400, { error: "snapshot_root_not_directory", rootPath: root });
         return;
@@ -5409,6 +6311,54 @@ var LocalServer = class {
     }
     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: "agent_dump_state_failed",
+        agentId,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+    void req;
+  }
   /**
    * POST /local/asset/write — agent-gen adapter RPC.
    *
@@ -5680,11 +6630,44 @@ 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: path2.join(snapshotRoot, "agents", agent.imUserId)
+    }
+  ];
+  if (agent.adapterName === "hermes" || agent.adapterName === "claude-code") {
+    roots.unshift({
+      kind: "hermes-profile",
+      rootPath: path2.join(process.env.HERMES_HOME || path2.join((0, import_node_os5.homedir)(), ".hermes"), "profiles", profileName)
+    });
+  }
+  if (agent.adapterName === "openclaw") {
+    roots.unshift({
+      kind: "openclaw-profile",
+      rootPath: path2.join(process.env.OPENCLAW_HOME || path2.join((0, import_node_os5.homedir)(), ".openclaw"), "profiles", profileName)
+    });
+  }
+  return roots;
+}
+function sanitizeProfileName(value) {
+  return value.replace(/[\\/]/g, "_").trim() || "default";
+}
+async function statOptional(rootPath) {
+  try {
+    return await import_node_fs10.promises.stat(rootPath);
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
 async function walkAndDigest(root, current) {
   const out = [];
   let entries;
   try {
-    entries = await import_node_fs9.promises.readdir(current);
+    entries = await import_node_fs10.promises.readdir(current);
   } catch (err) {
     if (err.code === "ENOENT") return out;
     throw err;
@@ -5695,7 +6678,7 @@ async function walkAndDigest(root, current) {
     const rel = path2.relative(root, full);
     let st;
     try {
-      st = await import_node_fs9.promises.stat(full);
+      st = await import_node_fs10.promises.stat(full);
     } catch {
       continue;
     }
@@ -5706,7 +6689,7 @@ async function walkAndDigest(root, current) {
       continue;
     }
     if (!st.isFile()) continue;
-    const buf = await import_node_fs9.promises.readFile(full);
+    const buf = await import_node_fs10.promises.readFile(full);
     const sha2563 = (0, import_node_crypto4.createHash)("sha256").update(buf).digest("hex");
     out.push({
       path: rel,
@@ -5721,9 +6704,9 @@ async function walkAndDigest(root, current) {
 // src/daemon/runner.ts
 var import_node_events3 = require("events");
 var import_node_module2 = require("module");
-var import_node_fs15 = require("fs");
+var import_node_fs16 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_os6 = require("os");
+var import_node_os8 = require("os");
 var import_node_path11 = require("path");
 
 // src/adapters/claude-code/index.ts
@@ -7821,7 +8804,7 @@ function parsePrismerUri(uri) {
 }
 
 // src/daemon/asset/metadata-index.ts
-var import_node_fs10 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_path9 = require("path");
 var DEFAULT_LIMIT = 8;
 var PULL_PAGE_SIZE = 500;
@@ -7850,16 +8833,16 @@ var AssetMetadataIndex = class {
     this.db = opts.db;
     this.cloud = opts.cloud;
     this.workspaceId = opts.workspaceId;
-    if (!(0, import_node_fs10.existsSync)(opts.workspaceStateDir)) {
-      (0, import_node_fs10.mkdirSync)(opts.workspaceStateDir, { recursive: true });
+    if (!(0, import_node_fs11.existsSync)(opts.workspaceStateDir)) {
+      (0, import_node_fs11.mkdirSync)(opts.workspaceStateDir, { recursive: true });
     }
     this.cursorPath = (0, import_node_path9.join)(opts.workspaceStateDir, "asset-metadata-cursor.json");
   }
   /** Persisted cursor for this workspace, or 0 on first run / corrupted file. */
   readCursor() {
-    if (!(0, import_node_fs10.existsSync)(this.cursorPath)) return 0;
+    if (!(0, import_node_fs11.existsSync)(this.cursorPath)) return 0;
     try {
-      const parsed = JSON.parse((0, import_node_fs10.readFileSync)(this.cursorPath, "utf8"));
+      const parsed = JSON.parse((0, import_node_fs11.readFileSync)(this.cursorPath, "utf8"));
       if (parsed.workspaceId !== this.workspaceId) return 0;
       return parsed.cursor;
     } catch {
@@ -7872,7 +8855,7 @@ var AssetMetadataIndex = class {
       cursor,
       writtenAt: Date.now()
     };
-    (0, import_node_fs10.writeFileSync)(this.cursorPath, JSON.stringify(payload, null, 2));
+    (0, import_node_fs11.writeFileSync)(this.cursorPath, JSON.stringify(payload, null, 2));
   }
   /**
    * Pull incremental asset metadata changes since the persisted cursor and
@@ -7989,7 +8972,7 @@ var AssetMetadataIndex = class {
 };
 
 // src/daemon/asset/rpc.ts
-var import_node_fs11 = require("fs");
+var import_node_fs12 = require("fs");
 var ASSET_PATH_PREFIX = "/local/asset/";
 var MAX_READ_BYTES = 256 * 1024;
 var MAX_SEARCH_BYTES = 1024 * 1024;
@@ -8164,16 +9147,16 @@ function isTextLike(row) {
   );
 }
 function readFileRange(path9, offset, length) {
-  const sizeBytes = (0, import_node_fs11.statSync)(path9).size;
+  const sizeBytes = (0, import_node_fs12.statSync)(path9).size;
   if (offset >= sizeBytes) return { buffer: Buffer.alloc(0), bytesRead: 0, sizeBytes };
-  const fd = (0, import_node_fs11.openSync)(path9, "r");
+  const fd = (0, import_node_fs12.openSync)(path9, "r");
   try {
     const target = Math.min(length, sizeBytes - offset);
     const buffer = Buffer.alloc(target);
-    const bytesRead = (0, import_node_fs11.readSync)(fd, buffer, 0, target, offset);
+    const bytesRead = (0, import_node_fs12.readSync)(fd, buffer, 0, target, offset);
     return { buffer: buffer.subarray(0, bytesRead), bytesRead, sizeBytes };
   } finally {
-    (0, import_node_fs11.closeSync)(fd);
+    (0, import_node_fs12.closeSync)(fd);
   }
 }
 function respond3(res, status, body) {
@@ -8198,8 +9181,8 @@ async function readJson3(req) {
 }
 
 // src/daemon/asset/origin/drop-folder.ts
-var import_node_fs12 = require("fs");
-var import_node_os5 = require("os");
+var import_node_fs13 = require("fs");
+var import_node_os6 = require("os");
 var path5 = __toESM(require("path"), 1);
 var DropFolderAdapter = class {
   kind = "drop-folder";
@@ -8207,7 +9190,7 @@ var DropFolderAdapter = class {
   rootDir;
   constructor(opts = {}) {
     this.workspaceDir = opts.workspaceDir;
-    this.rootDir = opts.rootDir ?? path5.join(opts.homeDir ?? (0, import_node_os5.homedir)(), ".prismer");
+    this.rootDir = opts.rootDir ?? path5.join(opts.homeDir ?? (0, import_node_os6.homedir)(), ".prismer");
   }
   /**
    * Long-lived async iterable wrapping `scanOnce` on a 1s polling interval.
@@ -8217,7 +9200,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);
     }
   }
   /**
@@ -8231,7 +9214,7 @@ var DropFolderAdapter = class {
     const drop = this.dropDir(workspaceId);
     let entries = [];
     try {
-      entries = await import_node_fs12.promises.readdir(drop);
+      entries = await import_node_fs13.promises.readdir(drop);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
@@ -8240,12 +9223,12 @@ var DropFolderAdapter = class {
     for (const name of entries) {
       if (name.startsWith(".")) continue;
       const fullPath = path5.join(drop, name);
-      const stat = await import_node_fs12.promises.lstat(fullPath).catch(() => null);
+      const stat = await import_node_fs13.promises.lstat(fullPath).catch(() => null);
       if (!stat) continue;
       if (stat.isSymbolicLink()) continue;
       if (stat.isDirectory()) {
         for (const nested of await walk(fullPath)) {
-          const nstat = await import_node_fs12.promises.lstat(nested).catch(() => null);
+          const nstat = await import_node_fs13.promises.lstat(nested).catch(() => null);
           if (!nstat || !nstat.isFile()) continue;
           out.push(makeObservation(workspaceId, nested, drop, nstat.size, Math.floor(nstat.mtimeMs)));
         }
@@ -8270,7 +9253,7 @@ var DropFolderAdapter = class {
   }
   async fetch(obs) {
     const detail = obs.detail;
-    const bytes = await import_node_fs12.promises.readFile(detail.path);
+    const bytes = await import_node_fs13.promises.readFile(detail.path);
     return {
       bytes,
       mime: mimeFromExtension(detail.path),
@@ -8292,8 +9275,8 @@ var DropFolderAdapter = class {
       const rel = typeof detail.watchDir === "string" ? path5.relative(detail.watchDir, detail.path) : path5.basename(detail.path);
       const safeRel = rel && !rel.startsWith("..") && !path5.isAbsolute(rel) ? rel : path5.basename(detail.path);
       const destPath = path5.join(destDir, safeRel);
-      await import_node_fs12.promises.mkdir(path5.dirname(destPath), { recursive: true });
-      await import_node_fs12.promises.rename(detail.path, destPath);
+      await import_node_fs13.promises.mkdir(path5.dirname(destPath), { recursive: true });
+      await import_node_fs13.promises.rename(detail.path, destPath);
     } catch (err) {
       if (err.code === "ENOENT") return;
       throw err;
@@ -8321,11 +9304,11 @@ function makeObservation(workspaceId, filePath, watchDir, size, mtime) {
 }
 async function walk(root) {
   const out = [];
-  const entries = await import_node_fs12.promises.readdir(root).catch(() => []);
+  const entries = await import_node_fs13.promises.readdir(root).catch(() => []);
   for (const name of entries) {
     if (name.startsWith(".")) continue;
     const full = path5.join(root, name);
-    const stat = await import_node_fs12.promises.lstat(full).catch(() => null);
+    const stat = await import_node_fs13.promises.lstat(full).catch(() => null);
     if (!stat) continue;
     if (stat.isSymbolicLink()) continue;
     if (stat.isDirectory()) {
@@ -8366,7 +9349,7 @@ function mimeFromExtension(p) {
   const ext = path5.extname(p).toLowerCase();
   return MIME_BY_EXT[ext] ?? null;
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
@@ -8921,7 +9904,7 @@ function stringValue(obj, key) {
 }
 
 // src/daemon/outbox-watcher.ts
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 var path7 = __toESM(require("path"), 1);
 
 // src/daemon/asset/agent-output-policy.ts
@@ -9077,9 +10060,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;
@@ -9244,7 +10338,7 @@ var OutboxWatcher = class {
   async scanDir(dir, kind, task) {
     let entries = [];
     try {
-      entries = await import_node_fs13.promises.readdir(dir);
+      entries = await import_node_fs14.promises.readdir(dir);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") return;
@@ -9254,10 +10348,11 @@ var OutboxWatcher = class {
     for (const name of entries) {
       if (name.startsWith(".")) continue;
       if (name === RESERVED_SUBDIR) continue;
+      if (name === REJECTED_SUBDIR) continue;
       const full = path7.join(dir, name);
       let st;
       try {
-        st = await import_node_fs13.promises.stat(full);
+        st = await import_node_fs14.promises.stat(full);
       } catch {
         continue;
       }
@@ -9268,10 +10363,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 = path7.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 = path7.join(dir, REJECTED_SUBDIR);
+    await import_node_fs14.promises.mkdir(rejectedDir, { recursive: true });
+    const base = path7.basename(full);
+    let dest = path7.join(rejectedDir, base);
+    try {
+      await import_node_fs14.promises.access(dest);
+      const ext = path7.extname(base);
+      const stem = base.slice(0, base.length - ext.length);
+      dest = path7.join(rejectedDir, `${stem}.${Date.now()}${ext}`);
+    } catch {
+    }
+    await import_node_fs14.promises.rename(full, dest);
+    this.log("warn", `quarantined ${full} \u2192 ${dest}`);
+  }
   async upload(filePath, st, kind, task) {
     const wsId = this.opts.workspaceId();
     if (!wsId) {
@@ -9282,13 +10444,18 @@ var OutboxWatcher = class {
       this.log("warn", `skip ${filePath}: no active taskId (no dispatch/handoff received yet)`);
       return;
     }
-    const bytes = await import_node_fs13.promises.readFile(filePath);
+    const bytes = await import_node_fs14.promises.readFile(filePath);
     const fileName = path7.basename(filePath);
     const inferredMime = inferAgentOutputMime(fileName);
     const policy = validateAgentOutputAsset({ filename: fileName, mime: inferredMime, sizeBytes: bytes.length });
     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 } : {}
@@ -9324,7 +10491,7 @@ var OutboxWatcher = class {
 
 // src/daemon/shell-executor.ts
 var import_node_child_process4 = require("child_process");
-var import_node_fs14 = require("fs");
+var import_node_fs15 = require("fs");
 var import_node_path10 = require("path");
 var DEFAULT_OUTPUT_LIMIT = 256 * 1024;
 var DEFAULT_TIMEOUT = 6e4;
@@ -9361,7 +10528,7 @@ async function executeShellDispatch(payload, deps) {
   const command = readCommand(payload, execution);
   if (!command.trim()) return fail(payload.taskId, "shell_command_required", "Shell command is required");
   const cwd = resolveCwd(execution.cwd, deps.config.defaultCwd);
-  if (!(0, import_node_fs14.existsSync)(cwd)) return fail(payload.taskId, "shell_cwd_missing", `cwd does not exist: ${cwd}`);
+  if (!(0, import_node_fs15.existsSync)(cwd)) return fail(payload.taskId, "shell_cwd_missing", `cwd does not exist: ${cwd}`);
   const timeoutMs = Math.min(
     typeof payload.timeoutMs === "number" && payload.timeoutMs > 0 ? payload.timeoutMs : deps.config.maxTimeoutMs,
     deps.config.maxTimeoutMs
@@ -9492,6 +10659,352 @@ ${input.stderr}` : null
 
 // src/daemon/runner.ts
 init_skill_sync();
+
+// 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
+var import_node_os7 = require("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 = (0, import_node_os7.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 import_meta2 = {};
 var DEFAULT_LOCAL_PORT = 3210;
 var log7 = createLogger("Daemon");
@@ -9540,6 +11053,14 @@ var Runner = class extends import_node_events3.EventEmitter {
   // 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";
@@ -9554,6 +11075,7 @@ var Runner = class extends import_node_events3.EventEmitter {
     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,
@@ -9880,19 +11402,19 @@ var Runner = class extends import_node_events3.EventEmitter {
   sampleCgroupResources() {
     const baseline = { cpu: { usagePct: 0 }, mem: { usedBytes: 0, limitBytes: 0 } };
     try {
-      if (!(0, import_node_fs15.existsSync)("/sys/fs/cgroup/memory.current")) {
+      if (!(0, import_node_fs16.existsSync)("/sys/fs/cgroup/memory.current")) {
         return baseline;
       }
-      const memUsedRaw = (0, import_node_fs15.readFileSync)("/sys/fs/cgroup/memory.current", "utf-8").trim();
+      const memUsedRaw = (0, import_node_fs16.readFileSync)("/sys/fs/cgroup/memory.current", "utf-8").trim();
       const memUsed = Number.parseInt(memUsedRaw, 10);
       let memLimit = 0;
-      if ((0, import_node_fs15.existsSync)("/sys/fs/cgroup/memory.max")) {
-        const limitRaw = (0, import_node_fs15.readFileSync)("/sys/fs/cgroup/memory.max", "utf-8").trim();
+      if ((0, import_node_fs16.existsSync)("/sys/fs/cgroup/memory.max")) {
+        const limitRaw = (0, import_node_fs16.readFileSync)("/sys/fs/cgroup/memory.max", "utf-8").trim();
         memLimit = limitRaw === "max" ? 0 : Number.parseInt(limitRaw, 10) || 0;
       }
       let cpuUsagePct = 0;
-      if ((0, import_node_fs15.existsSync)("/sys/fs/cgroup/cpu.stat")) {
-        const statLines = (0, import_node_fs15.readFileSync)("/sys/fs/cgroup/cpu.stat", "utf-8").split("\n");
+      if ((0, import_node_fs16.existsSync)("/sys/fs/cgroup/cpu.stat")) {
+        const statLines = (0, import_node_fs16.readFileSync)("/sys/fs/cgroup/cpu.stat", "utf-8").split("\n");
         const usecLine = statLines.find((line) => line.startsWith("usage_usec "));
         if (usecLine) {
           const usec = Number.parseInt(usecLine.split(" ")[1] ?? "0", 10);
@@ -10070,10 +11592,10 @@ var Runner = class extends import_node_events3.EventEmitter {
     const rawJson = process.env.PRISMER_HOSTED_AGENT_JSON;
     let raw;
     if (rawFile) {
-      if (!(0, import_node_fs15.existsSync)(rawFile)) {
+      if (!(0, import_node_fs16.existsSync)(rawFile)) {
         throw new Error(`PRISMER_HOSTED_AGENT_FILE not found: ${rawFile}`);
       }
-      raw = (0, import_node_fs15.readFileSync)(rawFile, "utf8");
+      raw = (0, import_node_fs16.readFileSync)(rawFile, "utf8");
     } else if (rawJson) {
       raw = rawJson;
     }
@@ -10160,6 +11682,19 @@ var Runner = class extends import_node_events3.EventEmitter {
         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);
@@ -10169,7 +11704,7 @@ var Runner = class extends import_node_events3.EventEmitter {
     const payload = {
       daemonId: this.config.daemon_id,
       daemonVersion: this.opts.daemonVersion ?? "0.0.0",
-      platform: (0, import_node_os6.platform)() === "win32" ? "win32" : (0, import_node_os6.platform)() === "linux" ? "linux" : "darwin",
+      platform: (0, import_node_os8.platform)() === "win32" ? "win32" : (0, import_node_os8.platform)() === "linux" ? "linux" : "darwin",
       agents: Array.from(this.hostedAgents.values()).map((a) => ({
         imUserId: a.imUserId,
         name: a.name,
@@ -10206,12 +11741,90 @@ var Runner = class extends import_node_events3.EventEmitter {
       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)
@@ -10393,14 +12006,68 @@ var Runner = class extends import_node_events3.EventEmitter {
     };
   }
   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);
@@ -10843,9 +12510,9 @@ var Runner = class extends import_node_events3.EventEmitter {
 function resolveUserAssetWorkspaceDir(workspaceId) {
   const override = process.env.PRISMER_ASSET_SYNC_ROOT;
   if (override) return (0, import_node_path11.join)(override, workspaceId);
-  const home = (0, import_node_os6.homedir)();
+  const home = (0, import_node_os8.homedir)();
   const desktop = (0, import_node_path11.join)(home, "Desktop");
-  const base = (0, import_node_fs15.existsSync)(desktop) ? desktop : home;
+  const base = (0, import_node_fs16.existsSync)(desktop) ? desktop : home;
   return (0, import_node_path11.join)(base, "Prismer Assets", workspaceId);
 }
 function readTargetDaemonId(payload) {
@@ -10922,7 +12589,7 @@ function safeJsonParse(raw) {
 
 // src/pair.ts
 var import_node_crypto10 = require("crypto");
-var import_node_os7 = require("os");
+var import_node_os9 = require("os");
 var import_promises2 = require("timers/promises");
 var import_qrcode = __toESM(require("qrcode"), 1);
 async function pair(opts) {
@@ -10952,7 +12619,7 @@ async function pair(opts) {
     "/api/im/pair/offer",
     {
       auth: false,
-      body: { devicePub, deviceName: opts.deviceName ?? (0, import_node_os7.hostname)() }
+      body: { devicePub, deviceName: opts.deviceName ?? (0, import_node_os9.hostname)() }
     }
   );
   if (!offerRes.ok) {
@@ -11033,8 +12700,8 @@ var import_commander20 = require("commander");
 
 // src/cli/commands/adapter.ts
 var import_node_child_process5 = require("child_process");
-var import_node_fs17 = require("fs");
-var import_node_os8 = require("os");
+var import_node_fs18 = require("fs");
+var import_node_os10 = require("os");
 var import_node_path13 = require("path");
 var import_commander = require("commander");
 init_hermes();
@@ -11050,7 +12717,7 @@ var INSTALL_SPECS = {
     binary: "claude",
     hint: "Set ANTHROPIC_API_KEY in your shell profile, or rely on Claude Code OAuth login. Run `claude login` to sign in.",
     authHints: ["ANTHROPIC_API_KEY or Claude Code OAuth login (`claude login`)"],
-    hookTarget: { path: (0, import_node_path13.join)((0, import_node_os8.homedir)(), ".claude", "hooks.json"), kind: "json-file" }
+    hookTarget: { path: (0, import_node_path13.join)((0, import_node_os10.homedir)(), ".claude", "hooks.json"), kind: "json-file" }
   },
   openclaw: {
     name: "openclaw",
@@ -11059,7 +12726,7 @@ var INSTALL_SPECS = {
     binary: "openclaw",
     hint: "OpenClaw runs as a gateway. Configure ~/.openclaw/openclaw.json and start it with `openclaw gateway` before tasks dispatch.",
     authHints: ["~/.openclaw/openclaw.json gateway.auth.bearerTokens", "Prismer daemon api_key"],
-    hookTarget: { path: (0, import_node_path13.join)((0, import_node_os8.homedir)(), ".openclaw", "hooks"), kind: "directory" }
+    hookTarget: { path: (0, import_node_path13.join)((0, import_node_os10.homedir)(), ".openclaw", "hooks"), kind: "directory" }
   },
   codex: {
     name: "codex",
@@ -11068,7 +12735,7 @@ var INSTALL_SPECS = {
     binary: "codex",
     hint: "Set OPENAI_API_KEY in your shell profile. Verify with `codex --help`.",
     authHints: ["OPENAI_API_KEY or Codex CLI account login"],
-    hookTarget: { path: (0, import_node_path13.join)((0, import_node_os8.homedir)(), ".codex", "hooks.json"), kind: "json-file" }
+    hookTarget: { path: (0, import_node_path13.join)((0, import_node_os10.homedir)(), ".codex", "hooks.json"), kind: "json-file" }
   },
   hermes: {
     name: "hermes",
@@ -11077,7 +12744,7 @@ var INSTALL_SPECS = {
     binary: "hermes",
     hint: "Hermes runs as a long-lived HTTP gateway in your own Python venv. Start with `hermes -p <profile> gateway` after configuring ~/.hermes/.env.",
     authHints: ["~/.hermes/.env API_SERVER_KEY", "Hermes profile provider credentials"],
-    hookTarget: { path: (0, import_node_path13.join)((0, import_node_os8.homedir)(), ".hermes", "hooks.json"), kind: "json-file" }
+    hookTarget: { path: (0, import_node_path13.join)((0, import_node_os10.homedir)(), ".hermes", "hooks.json"), kind: "json-file" }
   }
 };
 function buildAdapterCommand() {
@@ -11292,15 +12959,15 @@ function runHooks(spec, opts) {
   }
   let backup;
   if (planned.kind === "directory") {
-    (0, import_node_fs17.mkdirSync)(planned.path, { recursive: true });
+    (0, import_node_fs18.mkdirSync)(planned.path, { recursive: true });
     const markerPath = (0, import_node_path13.join)(planned.path, "prismer.json");
     backup = backupIfExists(markerPath);
-    (0, import_node_fs17.writeFileSync)(markerPath, JSON.stringify(prismerHookMarker(spec), null, 2) + "\n", "utf8");
+    (0, import_node_fs18.writeFileSync)(markerPath, JSON.stringify(prismerHookMarker(spec), null, 2) + "\n", "utf8");
   } else {
-    (0, import_node_fs17.mkdirSync)((0, import_node_path13.dirname)(planned.path), { recursive: true });
+    (0, import_node_fs18.mkdirSync)((0, import_node_path13.dirname)(planned.path), { recursive: true });
     backup = backupIfExists(planned.path);
     const merged = mergeHookJson(planned.path, spec);
-    (0, import_node_fs17.writeFileSync)(planned.path, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    (0, import_node_fs18.writeFileSync)(planned.path, JSON.stringify(merged, null, 2) + "\n", "utf8");
   }
   return {
     ok: true,
@@ -11367,23 +13034,23 @@ function inspectAuthEnv(spec) {
         hints: spec.authHints ?? []
       };
     case "hermes": {
-      const envFile = (0, import_node_path13.join)((0, import_node_os8.homedir)(), ".hermes", ".env");
+      const envFile = (0, import_node_path13.join)((0, import_node_os10.homedir)(), ".hermes", ".env");
       return {
-        ok: (0, import_node_fs17.existsSync)(envFile) || Boolean(process.env.HERMES_API_KEY || process.env.API_SERVER_KEY),
+        ok: (0, import_node_fs18.existsSync)(envFile) || Boolean(process.env.HERMES_API_KEY || process.env.API_SERVER_KEY),
         present: [
           ...["HERMES_API_KEY", "API_SERVER_KEY"].filter((k) => Boolean(process.env[k])),
-          ...(0, import_node_fs17.existsSync)(envFile) ? [envFile] : []
+          ...(0, import_node_fs18.existsSync)(envFile) ? [envFile] : []
         ],
         hints: spec.authHints ?? []
       };
     }
     case "openclaw": {
-      const cfgFile = (0, import_node_path13.join)((0, import_node_os8.homedir)(), ".openclaw", "openclaw.json");
+      const cfgFile = (0, import_node_path13.join)((0, import_node_os10.homedir)(), ".openclaw", "openclaw.json");
       return {
-        ok: (0, import_node_fs17.existsSync)(cfgFile) || Boolean(process.env.OPENCLAW_API_KEY),
+        ok: (0, import_node_fs18.existsSync)(cfgFile) || Boolean(process.env.OPENCLAW_API_KEY),
         present: [
           ...["OPENCLAW_API_KEY"].filter((k) => Boolean(process.env[k])),
-          ...(0, import_node_fs17.existsSync)(cfgFile) ? [cfgFile] : []
+          ...(0, import_node_fs18.existsSync)(cfgFile) ? [cfgFile] : []
         ],
         hints: spec.authHints ?? []
       };
@@ -11398,16 +13065,16 @@ function inspectHook(spec) {
     return { supported: false, markerPresent: false };
   }
   if (spec.name === "openclaw") {
-    const jsonPath = (0, import_node_path13.join)((0, import_node_os8.homedir)(), ".openclaw", "hooks.json");
+    const jsonPath = (0, import_node_path13.join)((0, import_node_os10.homedir)(), ".openclaw", "hooks.json");
     const markerPath = (0, import_node_path13.join)(target.path, "prismer.json");
-    const jsonMarkerPresent = (0, import_node_fs17.existsSync)(jsonPath) && fileContainsPrismerMarker(jsonPath);
-    const dirMarkerPresent = (0, import_node_fs17.existsSync)(markerPath) && fileContainsPrismerMarker(markerPath);
+    const jsonMarkerPresent = (0, import_node_fs18.existsSync)(jsonPath) && fileContainsPrismerMarker(jsonPath);
+    const dirMarkerPresent = (0, import_node_fs18.existsSync)(markerPath) && fileContainsPrismerMarker(markerPath);
     return {
       supported: true,
       kind: "json-file-or-directory",
       path: target.path,
       jsonPath,
-      exists: (0, import_node_fs17.existsSync)(target.path) || (0, import_node_fs17.existsSync)(jsonPath),
+      exists: (0, import_node_fs18.existsSync)(target.path) || (0, import_node_fs18.existsSync)(jsonPath),
       markerPath,
       markerPresent: jsonMarkerPresent || dirMarkerPresent
     };
@@ -11418,12 +13085,12 @@ function inspectHook(spec) {
       supported: true,
       kind: target.kind,
       path: target.path,
-      exists: (0, import_node_fs17.existsSync)(target.path),
+      exists: (0, import_node_fs18.existsSync)(target.path),
       markerPath,
-      markerPresent: (0, import_node_fs17.existsSync)(markerPath) && fileContainsPrismerMarker(markerPath)
+      markerPresent: (0, import_node_fs18.existsSync)(markerPath) && fileContainsPrismerMarker(markerPath)
     };
   }
-  const exists = (0, import_node_fs17.existsSync)(target.path);
+  const exists = (0, import_node_fs18.existsSync)(target.path);
   if (!exists) {
     return {
       supported: true,
@@ -11459,14 +13126,14 @@ function prismerHookMarker(spec) {
 }
 function mergeHookJson(path9, spec) {
   const marker = prismerHookMarker(spec);
-  if (!(0, import_node_fs17.existsSync)(path9)) {
+  if (!(0, import_node_fs18.existsSync)(path9)) {
     return {
       prismer: marker
     };
   }
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs17.readFileSync)(path9, "utf8"));
+    parsed = JSON.parse((0, import_node_fs18.readFileSync)(path9, "utf8"));
   } catch (err) {
     throw new Error(`Cannot parse ${path9} as JSON: ${err.message}`);
   }
@@ -11490,17 +13157,17 @@ function mergeHookJson(path9, spec) {
   return next;
 }
 function backupIfExists(path9) {
-  if (!(0, import_node_fs17.existsSync)(path9)) return null;
+  if (!(0, import_node_fs18.existsSync)(path9)) return null;
   const suffix = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backup = `${path9}.bak.${suffix}`;
-  const stat = (0, import_node_fs17.statSync)(path9);
+  const stat = (0, import_node_fs18.statSync)(path9);
   if (stat.isDirectory()) return null;
-  (0, import_node_fs17.copyFileSync)(path9, backup);
+  (0, import_node_fs18.copyFileSync)(path9, backup);
   return backup;
 }
 function fileContainsPrismerMarker(path9) {
   try {
-    return (0, import_node_fs17.readFileSync)(path9, "utf8").includes("prismer-daemon-runtime");
+    return (0, import_node_fs18.readFileSync)(path9, "utf8").includes("prismer-daemon-runtime");
   } catch {
     return false;
   }
@@ -11860,8 +13527,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 {
@@ -11966,7 +13699,7 @@ function whichBinary2(bin) {
 // src/cli/commands/asset.ts
 var import_node_crypto11 = require("crypto");
 var import_commander3 = require("commander");
-var import_node_fs18 = require("fs");
+var import_node_fs19 = require("fs");
 var import_node_path14 = require("path");
 init_util();
 init_ui();
@@ -12139,8 +13872,8 @@ async function prefetchAssetBytes(opts) {
   return { considered: rows.length, fetched, bytes, failed };
 }
 async function uploadAssetPath(inputPath, opts) {
-  if (!(0, import_node_fs18.existsSync)(inputPath)) exitWithError(`path not found: ${inputPath}`);
-  const stat = (0, import_node_fs18.lstatSync)(inputPath);
+  if (!(0, import_node_fs19.existsSync)(inputPath)) exitWithError(`path not found: ${inputPath}`);
+  const stat = (0, import_node_fs19.lstatSync)(inputPath);
   if (stat.isSymbolicLink()) exitWithError(`refusing to upload symlink: ${inputPath}`);
   if (stat.isFile()) {
     return uploadAsset(inputPath, { ...opts, folderPath: normalizeFolderPath(opts.folderPath) });
@@ -12158,9 +13891,9 @@ async function uploadAssetPath(inputPath, opts) {
   return { ok: true, data: { count: items.length, items } };
 }
 async function uploadAsset(file, opts) {
-  if (!(0, import_node_fs18.existsSync)(file)) exitWithError(`file not found: ${file}`);
+  if (!(0, import_node_fs19.existsSync)(file)) exitWithError(`file not found: ${file}`);
   const cfg = loadConfig(resolvePaths());
-  const bytes = (0, import_node_fs18.readFileSync)(file);
+  const bytes = (0, import_node_fs19.readFileSync)(file);
   const contentHash = (0, import_node_crypto11.createHash)("sha256").update(bytes).digest("hex");
   const metadata = parseMetadata(opts.metadata);
   if (opts.taskId && metadata.taskId === void 0) metadata.taskId = opts.taskId;
@@ -12296,10 +14029,10 @@ async function putDirectAssetBytes(plan, bytes, mime) {
 }
 function listFilesRecursive(root) {
   const out = [];
-  for (const name of (0, import_node_fs18.readdirSync)(root)) {
+  for (const name of (0, import_node_fs19.readdirSync)(root)) {
     if (name.startsWith(".")) continue;
     const full = (0, import_node_path14.join)(root, name);
-    const stat = (0, import_node_fs18.lstatSync)(full);
+    const stat = (0, import_node_fs19.lstatSync)(full);
     if (stat.isSymbolicLink()) continue;
     if (stat.isDirectory()) {
       out.push(...listFilesRecursive(full));
@@ -12333,7 +14066,7 @@ async function downloadAsset(assetId, outPath) {
     exitWithError(`asset download failed (${res.status}): ${errorMessage(body)}`);
   }
   const bytes = Buffer.from(await res.arrayBuffer());
-  (0, import_node_fs18.writeFileSync)(outPath, bytes);
+  (0, import_node_fs19.writeFileSync)(outPath, bytes);
 }
 function parseMetadata(raw) {
   if (!raw) return {};
@@ -12732,7 +14465,7 @@ function buildCookbookCommand() {
     for (const suite of suites) {
       checks.push(...await runSuite(suite, cloud, opts));
     }
-    const summary = summarize(checks, Boolean(opts.strict));
+    const summary = summarize2(checks, Boolean(opts.strict));
     if (opts.json) {
       printJson(summary);
     } else {
@@ -12897,7 +14630,7 @@ function parseSuites(raw) {
   const expanded = selected.includes("all") ? ["status", "im", "task", "group", "asset", "sandbox"] : selected;
   return [...new Set(expanded)];
 }
-function summarize(checks, strict) {
+function summarize2(checks, strict) {
   const totals = { pass: 0, fail: 0, skip: 0 };
   for (const check of checks) totals[check.status] += 1;
   return {
@@ -12980,7 +14713,7 @@ function parsePositiveInt3(value) {
 // src/cli/commands/daemon.ts
 var import_commander8 = require("commander");
 var import_node_child_process7 = require("child_process");
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 var import_promises3 = require("timers/promises");
 var import_node_path15 = require("path");
 init_util();
@@ -13056,9 +14789,9 @@ function buildDaemonCommand() {
     if (existingPid && pidAlive2(existingPid)) {
       exitWithError(`Daemon already running (pid ${existingPid}). Use \`prismer daemon stop\` first.`);
     }
-    if (!(0, import_node_fs19.existsSync)(paths.logsDir)) (0, import_node_fs19.mkdirSync)(paths.logsDir, { recursive: true });
+    if (!(0, import_node_fs20.existsSync)(paths.logsDir)) (0, import_node_fs20.mkdirSync)(paths.logsDir, { recursive: true });
     const logFile = (0, import_node_path15.join)(paths.logsDir, "daemon.log");
-    const fd = (0, import_node_fs19.openSync)(logFile, "a");
+    const fd = (0, import_node_fs20.openSync)(logFile, "a");
     const args = [process.argv[1], "daemon", "run"];
     if (opts.port) args.push("--port", String(opts.port));
     if (opts.localServer === false) args.push("--no-local-server");
@@ -13142,7 +14875,7 @@ function buildDaemonCommand() {
   cmd.command("logs").description("Show daemon logs").option("--tail <n>", "Number of lines to show", (v) => Number.parseInt(v, 10), 80).option("--follow", "Follow log output").option("--json", "Accept --json for global flag compatibility (raw log bytes are streamed)").action(async (opts) => {
     const paths = resolvePaths();
     const logFile = (0, import_node_path15.join)(paths.logsDir, "daemon.log");
-    if (!(0, import_node_fs19.existsSync)(logFile)) {
+    if (!(0, import_node_fs20.existsSync)(logFile)) {
       exitWithError(`No daemon log found at ${logFile}. Start the daemon with \`prismer daemon start\`.`);
     }
     const lines = Math.max(1, opts.tail);
@@ -13183,13 +14916,13 @@ async function tailFromEnd(path9, lines) {
   }
 }
 async function followFile(path9) {
-  let offset = (0, import_node_fs19.statSync)(path9).size;
+  let offset = (0, import_node_fs20.statSync)(path9).size;
   for (; ; ) {
     await (0, import_promises3.setTimeout)(1e3);
-    const size = (0, import_node_fs19.statSync)(path9).size;
+    const size = (0, import_node_fs20.statSync)(path9).size;
     if (size < offset) offset = 0;
     if (size === offset) continue;
-    const stream = (0, import_node_fs19.createReadStream)(path9, { start: offset, end: size - 1, encoding: "utf8" });
+    const stream = (0, import_node_fs20.createReadStream)(path9, { start: offset, end: size - 1, encoding: "utf8" });
     for await (const chunk of stream) process.stdout.write(chunk);
     offset = size;
   }
@@ -13197,8 +14930,8 @@ async function followFile(path9) {
 
 // src/cli/commands/events.ts
 var import_commander9 = require("commander");
-var import_node_fs20 = require("fs");
-var import_node_os9 = require("os");
+var import_node_fs21 = require("fs");
+var import_node_os11 = require("os");
 var import_node_path16 = require("path");
 var import_node_readline = require("readline");
 init_util();
@@ -13206,7 +14939,7 @@ var DEFAULT_LIMIT2 = 50;
 function buildEventsCommand() {
   return addEventOptions(new import_commander9.Command("events").description("Read local PARA events from ~/.prismer/para/events.jsonl")).action(async (opts) => {
     const file = eventsPath();
-    if (!(0, import_node_fs20.existsSync)(file)) {
+    if (!(0, import_node_fs21.existsSync)(file)) {
       printJson(unavailable(file));
       process.exitCode = 1;
       return;
@@ -13223,7 +14956,7 @@ function buildEventsCommand() {
 function buildEventsStatsCommand() {
   return addEventOptions(new import_commander9.Command("events:stats").description("Summarize local PARA events from ~/.prismer/para/events.jsonl")).action(async (opts) => {
     const file = eventsPath();
-    if (!(0, import_node_fs20.existsSync)(file)) {
+    if (!(0, import_node_fs21.existsSync)(file)) {
       printJson(unavailable(file));
       process.exitCode = 1;
       return;
@@ -13232,7 +14965,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) }
     });
   });
@@ -13241,7 +14974,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 (0, import_node_path16.join)(process.env.PRISMER_HOME ?? (0, import_node_path16.join)((0, import_node_os9.homedir)(), ".prismer"), "para", "events.jsonl");
+  return (0, import_node_path16.join)(process.env.PRISMER_HOME ?? (0, import_node_path16.join)((0, import_node_os11.homedir)(), ".prismer"), "para", "events.jsonl");
 }
 function unavailable(file) {
   return {
@@ -13257,7 +14990,7 @@ function unavailable(file) {
 async function readEvents(file, filters) {
   const out = [];
   const rl = (0, import_node_readline.createInterface)({
-    input: (0, import_node_fs20.createReadStream)(file, { encoding: "utf8" }),
+    input: (0, import_node_fs21.createReadStream)(file, { encoding: "utf8" }),
     crlfDelay: Infinity
   });
   for await (const line of rl) {
@@ -13289,7 +15022,7 @@ function field(event, names) {
   }
   return void 0;
 }
-function summarize2(events) {
+function summarize3(events) {
   const byFamily = {};
   const byType = {};
   const byAgentId = {};
@@ -13327,7 +15060,7 @@ function parsePositiveInt4(v) {
 // src/cli/commands/memory.ts
 var import_better_sqlite35 = __toESM(require("better-sqlite3"), 1);
 var import_commander10 = require("commander");
-var import_node_fs21 = require("fs");
+var import_node_fs22 = require("fs");
 init_util();
 var LOCAL_BASE = process.env.PRISMER_DAEMON_URL ?? "http://127.0.0.1:3210";
 function buildMemoryCommand() {
@@ -13479,7 +15212,7 @@ function readCacheSnapshot(limit) {
   const paths = resolvePaths();
   const empty = {
     dbPath: paths.localDb,
-    dbExists: (0, import_node_fs21.existsSync)(paths.localDb),
+    dbExists: (0, import_node_fs22.existsSync)(paths.localDb),
     tables: {
       cached_assets: { exists: false, count: 0, sizeBytes: 0 },
       workspace_files_mirror: { exists: false, count: 0 }
@@ -13643,8 +15376,8 @@ function buildPairCommand() {
 
 // src/cli/commands/profile.ts
 var import_commander12 = require("commander");
-var import_node_fs22 = require("fs");
-var import_node_os10 = require("os");
+var import_node_fs23 = require("fs");
+var import_node_os12 = require("os");
 var import_node_path17 = require("path");
 var import_node_child_process8 = require("child_process");
 init_util();
@@ -13693,12 +15426,12 @@ function buildProfileCommand() {
     const profile = await cloud.get(
       `/api/im/agent_profiles/${encodeURIComponent(profileId)}`
     );
-    const tmpFile = (0, import_node_path17.join)((0, import_node_os10.tmpdir)(), `prismer-profile-${profileId}.json`);
-    (0, import_node_fs22.writeFileSync)(tmpFile, JSON.stringify(profile.config, null, 2), "utf8");
+    const tmpFile = (0, import_node_path17.join)((0, import_node_os12.tmpdir)(), `prismer-profile-${profileId}.json`);
+    (0, import_node_fs23.writeFileSync)(tmpFile, JSON.stringify(profile.config, null, 2), "utf8");
     const editor = process.env.EDITOR || "vi";
     const ed = (0, import_node_child_process8.spawnSync)(editor, [tmpFile], { stdio: "inherit" });
     if (ed.status !== 0) exitWithError(`editor exited ${ed.status}`, { code: "editor_failed" });
-    const newConfig = JSON.parse((0, import_node_fs22.readFileSync)(tmpFile, "utf8"));
+    const newConfig = JSON.parse((0, import_node_fs23.readFileSync)(tmpFile, "utf8"));
     const res = await cloud.request("PATCH", `/api/im/agent_profiles/${encodeURIComponent(profileId)}`, {
       body: { config: newConfig, version: profile.version }
     });
@@ -13720,8 +15453,8 @@ function mkCloud4() {
 function readJsonArg(arg) {
   if (arg.startsWith("@")) {
     const path9 = arg.slice(1);
-    if (!(0, import_node_fs22.existsSync)(path9)) throw new Error(`File not found: ${path9}`);
-    return JSON.parse((0, import_node_fs22.readFileSync)(path9, "utf8"));
+    if (!(0, import_node_fs23.existsSync)(path9)) throw new Error(`File not found: ${path9}`);
+    return JSON.parse((0, import_node_fs23.readFileSync)(path9, "utf8"));
   }
   return JSON.parse(arg);
 }
@@ -13735,8 +15468,8 @@ async function resolveDefaultWorkspaceId(cloud) {
 // src/cli/commands/reset.ts
 var import_commander13 = require("commander");
 var import_node_child_process9 = require("child_process");
-var import_node_fs23 = require("fs");
-var import_node_os11 = require("os");
+var import_node_fs24 = require("fs");
+var import_node_os13 = require("os");
 var import_node_path18 = require("path");
 var import_promises4 = require("timers/promises");
 init_util();
@@ -13754,15 +15487,15 @@ function buildResetCommand() {
     const hermesGatewayPids = findHermesGatewayPids2();
     const plan = {
       root: paths.root,
-      exists: (0, import_node_fs23.existsSync)(paths.root),
+      exists: (0, import_node_fs24.existsSync)(paths.root),
       runningPid,
       mode: opts.wipe ? "wipe" : "archive",
       archivePath,
       assetSyncRoot,
-      assetSyncExists: (0, import_node_fs23.existsSync)(assetSyncRoot),
+      assetSyncExists: (0, import_node_fs24.existsSync)(assetSyncRoot),
       assetSyncArchivePath,
       hermesHome,
-      hermesExists: (0, import_node_fs23.existsSync)(hermesHome),
+      hermesExists: (0, import_node_fs24.existsSync)(hermesHome),
       hermesArchivePath,
       hermesGatewayPids,
       willStopDaemon: runningPid !== null,
@@ -13786,40 +15519,40 @@ function buildResetCommand() {
     for (const gatewayPid of hermesGatewayPids) {
       await stopProcess(gatewayPid, opts.timeout ?? 5e3, "Hermes gateway");
     }
-    if ((0, import_node_fs23.existsSync)(paths.root)) {
+    if ((0, import_node_fs24.existsSync)(paths.root)) {
       if (opts.wipe) {
-        (0, import_node_fs23.rmSync)(paths.root, { recursive: true, force: true });
+        (0, import_node_fs24.rmSync)(paths.root, { recursive: true, force: true });
       } else {
         if (!archivePath) throw new Error("internal: archivePath missing");
-        if (!(0, import_node_fs23.existsSync)((0, import_node_path18.dirname)(archivePath))) {
-          (0, import_node_fs23.mkdirSync)((0, import_node_path18.dirname)(archivePath), { recursive: true });
+        if (!(0, import_node_fs24.existsSync)((0, import_node_path18.dirname)(archivePath))) {
+          (0, import_node_fs24.mkdirSync)((0, import_node_path18.dirname)(archivePath), { recursive: true });
         }
-        (0, import_node_fs23.renameSync)(paths.root, archivePath);
+        (0, import_node_fs24.renameSync)(paths.root, archivePath);
       }
     }
-    if ((0, import_node_fs23.existsSync)(assetSyncRoot)) {
+    if ((0, import_node_fs24.existsSync)(assetSyncRoot)) {
       if (opts.wipe) {
-        (0, import_node_fs23.rmSync)(assetSyncRoot, { recursive: true, force: true });
+        (0, import_node_fs24.rmSync)(assetSyncRoot, { recursive: true, force: true });
       } else {
         if (!assetSyncArchivePath) throw new Error("internal: assetSyncArchivePath missing");
-        if (!(0, import_node_fs23.existsSync)((0, import_node_path18.dirname)(assetSyncArchivePath))) {
-          (0, import_node_fs23.mkdirSync)((0, import_node_path18.dirname)(assetSyncArchivePath), { recursive: true });
+        if (!(0, import_node_fs24.existsSync)((0, import_node_path18.dirname)(assetSyncArchivePath))) {
+          (0, import_node_fs24.mkdirSync)((0, import_node_path18.dirname)(assetSyncArchivePath), { recursive: true });
         }
-        (0, import_node_fs23.renameSync)(assetSyncRoot, assetSyncArchivePath);
+        (0, import_node_fs24.renameSync)(assetSyncRoot, assetSyncArchivePath);
       }
     }
-    if ((0, import_node_fs23.existsSync)(hermesHome)) {
+    if ((0, import_node_fs24.existsSync)(hermesHome)) {
       if (opts.wipe) {
-        (0, import_node_fs23.rmSync)(hermesHome, { recursive: true, force: true });
+        (0, import_node_fs24.rmSync)(hermesHome, { recursive: true, force: true });
       } else {
         if (!hermesArchivePath) throw new Error("internal: hermesArchivePath missing");
-        if (!(0, import_node_fs23.existsSync)((0, import_node_path18.dirname)(hermesArchivePath))) {
-          (0, import_node_fs23.mkdirSync)((0, import_node_path18.dirname)(hermesArchivePath), { recursive: true });
+        if (!(0, import_node_fs24.existsSync)((0, import_node_path18.dirname)(hermesArchivePath))) {
+          (0, import_node_fs24.mkdirSync)((0, import_node_path18.dirname)(hermesArchivePath), { recursive: true });
         }
-        (0, import_node_fs23.renameSync)(hermesHome, hermesArchivePath);
+        (0, import_node_fs24.renameSync)(hermesHome, hermesArchivePath);
       }
     }
-    (0, import_node_fs23.mkdirSync)(paths.root, { recursive: true });
+    (0, import_node_fs24.mkdirSync)(paths.root, { recursive: true });
     if (opts.json) {
       printJson({ ok: true, reset: true, plan });
       return;
@@ -13888,13 +15621,13 @@ function timestamp() {
 function resolveAssetSyncRoot() {
   const override = process.env.PRISMER_ASSET_SYNC_ROOT;
   if (override) return override;
-  const home = (0, import_node_os11.homedir)();
+  const home = (0, import_node_os13.homedir)();
   const desktop = (0, import_node_path18.join)(home, "Desktop");
-  const base = (0, import_node_fs23.existsSync)(desktop) ? desktop : home;
+  const base = (0, import_node_fs24.existsSync)(desktop) ? desktop : home;
   return (0, import_node_path18.join)(base, "Prismer Assets");
 }
 function resolveHermesHome() {
-  return process.env.HERMES_HOME || (0, import_node_path18.join)((0, import_node_os11.homedir)(), ".hermes");
+  return process.env.HERMES_HOME || (0, import_node_path18.join)((0, import_node_os13.homedir)(), ".hermes");
 }
 function findHermesGatewayPids2() {
   try {
@@ -14124,10 +15857,10 @@ async function safeParseResponse(res) {
 
 // src/cli/commands/setup.ts
 var import_commander15 = require("commander");
-var import_node_os12 = require("os");
+var import_node_os14 = require("os");
 var import_node_child_process10 = require("child_process");
 var import_node_crypto12 = require("crypto");
-var import_node_fs24 = require("fs");
+var import_node_fs25 = require("fs");
 var import_node_http2 = require("http");
 init_util();
 init_ui();
@@ -14169,7 +15902,7 @@ function buildSetupCommand() {
       }
       const result = await pair({
         cloudBaseUrl,
-        deviceName: opts.deviceName ?? (0, import_node_os12.hostname)(),
+        deviceName: opts.deviceName ?? (0, import_node_os14.hostname)(),
         force: opts.force,
         paths,
         asUserEmail: opts.asUser
@@ -14186,13 +15919,13 @@ function buildSetupCommand() {
         apiKey = await mintDaemonApiKey({
           cloudBaseUrl,
           token: authToken,
-          deviceName: opts.deviceName ?? (0, import_node_os12.hostname)()
+          deviceName: opts.deviceName ?? (0, import_node_os14.hostname)()
         });
       }
       if (!apiKey && !authToken && !opts.check && opts.browser !== false) {
         apiKey = await runBrowserSetup({
           cloudBaseUrl,
-          deviceName: opts.deviceName ?? (0, import_node_os12.hostname)(),
+          deviceName: opts.deviceName ?? (0, import_node_os14.hostname)(),
           json: Boolean(opts.json)
         });
       }
@@ -14378,9 +16111,9 @@ function shouldArchiveLocalDb(previous, next) {
   return previous.api_key !== next.api_key || previous.cloud_api_base !== next.cloud_api_base || previous.daemon_id !== next.daemon_id;
 }
 function archiveLocalDb(localDbPath) {
-  if (!(0, import_node_fs24.existsSync)(localDbPath)) return;
+  if (!(0, import_node_fs25.existsSync)(localDbPath)) return;
   const archived = `${localDbPath}.${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.bak`;
-  (0, import_node_fs24.renameSync)(localDbPath, archived);
+  (0, import_node_fs25.renameSync)(localDbPath, archived);
 }
 async function mintDaemonApiKey(input) {
   const label = `Daemon: ${input.deviceName} ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`;
@@ -14449,7 +16182,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;
@@ -14460,7 +16193,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;
@@ -14513,7 +16246,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
   });
@@ -14632,7 +16365,7 @@ function printSkill(skill, includeContent) {
 
 // src/cli/commands/status.ts
 var import_commander17 = require("commander");
-var import_node_os13 = require("os");
+var import_node_os15 = require("os");
 init_util();
 init_ui();
 function buildStatusCommand() {
@@ -14663,6 +16396,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;
@@ -14675,19 +16409,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;
@@ -14704,7 +16452,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);
@@ -14713,6 +16462,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", {
@@ -14756,7 +16559,7 @@ function printPretty(report) {
   ui.blank();
   ok("Config", report.paths.config);
   if (report.daemon.running) {
-    const daemonName = report.cloud.me && typeof report.cloud.me === "object" ? report.cloud.me.user?.username ?? (0, import_node_os13.hostname)() : (0, import_node_os13.hostname)();
+    const daemonName = report.cloud.me && typeof report.cloud.me === "object" ? report.cloud.me.user?.username ?? (0, import_node_os15.hostname)() : (0, import_node_os15.hostname)();
     const ws = report.daemon.wsConnected ? "connected" : "pending";
     ok("Daemon", `${daemonName}  pid=${report.daemon.pid}  ws=${ws}`);
     if (report.daemon.info) {
@@ -14785,16 +16588,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();
@@ -14804,6 +16598,58 @@ 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`);
+    fail2("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 {
+      fail2("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 : fail2;
+  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
@@ -15166,7 +17012,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 import_commander20.Command("prismer").description("Prismer Cloud daemon CLI (TS-only).").version(VERSION);
   program.addCommand(buildBannerCommand());