pubblue 0.6.9 → 0.7.0

package/dist/index.js

@@ -12,6 +12,8 @@ import {
   getConfigDir,
   getTelegramMiniAppUrl,
   isClaudeCodeAvailableInEnv,
+  isClaudeSdkAvailableInEnv,
+  isClaudeSdkImportable,
   isOpenClawAvailable,
   liveInfoDir,
   liveInfoPath,
@@ -21,11 +23,12 @@ import {
   resolveOpenClawHome,
   resolveOpenClawWorkspaceDir,
   runClaudeCodeBridgeStartupProbe,
+  runClaudeSdkBridgeStartupProbe,
   runOpenClawBridgeStartupProbe,
   saveConfig,
   toCliFailure,
   writeLatestCliVersion
-} from "./chunk-JSX5KHV3.js";
+} from "./chunk-5ODXW2EM.js";
 
 // src/program.ts
 import { Command } from "commander";
@@ -507,10 +510,10 @@ async function ensureNodeDatachannelAvailable() {
 }
 function parseBridgeMode(raw) {
   const normalized = raw.trim().toLowerCase();
-  if (normalized === "openclaw" || normalized === "claude-code") {
+  if (normalized === "openclaw" || normalized === "claude-code" || normalized === "claude-sdk") {
     return normalized;
   }
-  throw new Error(`--bridge must be one of: openclaw, claude-code. Received: ${raw}`);
+  throw new Error(`--bridge must be one of: openclaw, claude-code, claude-sdk. Received: ${raw}`);
 }
 function describeConfiguredPath(key, env) {
   const configured = env[key]?.trim();
@@ -542,6 +545,39 @@ var BRIDGE_PROVIDERS = [
       ];
     }
   },
+  {
+    mode: "claude-sdk",
+    priority: 75,
+    detect(env) {
+      const cliAvailable = isClaudeSdkAvailableInEnv(env);
+      if (!cliAvailable) {
+        return {
+          available: false,
+          detail: `Claude CLI not detected (${describeConfiguredPath("CLAUDE_CODE_PATH", env)})`
+        };
+      }
+      return {
+        available: true,
+        detail: `Claude CLI detected; SDK import checked at startup (${describeConfiguredPath("CLAUDE_CODE_PATH", env)})`
+      };
+    },
+    async startupProbe(env) {
+      const sdkAvailable = await isClaudeSdkImportable();
+      if (!sdkAvailable) {
+        throw new Error(
+          "Claude Agent SDK (@anthropic-ai/claude-agent-sdk) is not importable. Install it or use --bridge claude-code."
+        );
+      }
+      const runtime = await runClaudeSdkBridgeStartupProbe(env);
+      const cwd = runtime.cwd || env.PUBBLUE_PROJECT_ROOT || process.cwd();
+      return [
+        `Claude executable: ${runtime.claudePath}`,
+        `Claude SDK: available`,
+        `Claude cwd: ${cwd}`,
+        'Claude SDK communication via `pubblue write "pong"`: OK'
+      ];
+    }
+  },
   {
     mode: "claude-code",
     priority: 50,
@@ -955,7 +991,9 @@ function formatPreflightError(params) {
   }
   lines.push("", "Debug tips:");
   lines.push("- Run `pubblue configure` to inspect saved CLI configuration.");
-  lines.push("- Use `pubblue start --bridge openclaw|claude-code` to force a bridge mode.");
+  lines.push(
+    "- Use `pubblue start --bridge openclaw|claude-code|claude-sdk` to force a bridge mode."
+  );
   return lines.join("\n");
 }
 async function runStartPreflight(opts) {
@@ -1059,7 +1097,7 @@ async function runStartPreflight(opts) {
 // package.json
 var package_default = {
   name: "pubblue",
-  version: "0.6.9",
+  version: "0.7.0",
   description: "CLI for publishing and visualizing AI-agent output via pub.blue",
   type: "module",
   bin: {
@@ -1077,6 +1115,9 @@ var package_default = {
     convex: "^1.19.0",
     "node-datachannel": "^0.32.0"
   },
+  optionalDependencies: {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.0"
+  },
   devDependencies: {
     "@types/node": "22.10.2",
     tsup: "^8.3.6",
@@ -1136,7 +1177,7 @@ function printLocalRuntimeSummary() {
   }
 }
 function registerStartCommand(program2) {
-  program2.command("start").description("Start the agent daemon (registers presence, awaits live requests)").requiredOption("--agent-name <name>", "Agent display name shown to the browser user").option("--bridge <mode>", "Bridge mode: openclaw|claude-code").action(async (opts) => {
+  program2.command("start").description("Start the agent daemon (registers presence, awaits live requests)").requiredOption("--agent-name <name>", "Agent display name shown to the browser user").option("--bridge <mode>", "Bridge mode: openclaw|claude-code|claude-sdk").action(async (opts) => {
     writeLatestCliVersion(CLI_VERSION);
     const preflight = await runStartPreflight({ bridge: opts.bridge });
     const { runtimeConfig, bridgeMode, bridgeProcessEnv } = preflight;
@@ -1423,9 +1464,6 @@ function registerDoctorCommand(program2) {
       if (live.status !== "active") {
         fail(`API reports live is not active (status: ${live.status})`);
       }
-      if (live.expiresAt <= Date.now()) {
-        fail("API reports live is expired.");
-      }
       if (typeof live.browserOffer !== "string" || live.browserOffer.length === 0) {
         fail("browser offer was not published.");
       }
@@ -1499,7 +1537,7 @@ function registerDoctorCommand(program2) {
 
 // src/commands/pubs.ts
 function registerPubCommands(program2) {
-  program2.command("create").description("Create a new pub").argument("[file]", "Path to the file (reads stdin if omitted)").option("--slug <slug>", "Custom slug for the URL").option("--title <title>", "Title for the pub").option("--public", "Make the pub public").option("--private", "Make the pub private (default)").option("--expires <duration>", "Auto-delete after duration (e.g. 1h, 24h, 7d)").action(
+  program2.command("create").description("Create a new pub").argument("[file]", "Path to the file (reads stdin if omitted)").option("--slug <slug>", "Custom slug for the URL").option("--title <title>", "Title for the pub").option("--public", "Make the pub public").option("--private", "Make the pub private (default)").action(
     async (fileArg, opts) => {
       const client = createClient();
       let content;
@@ -1521,15 +1559,11 @@ function registerPubCommands(program2) {
         filename,
         title: opts.title,
         slug: opts.slug,
-        isPublic: resolvedVisibility ?? false,
-        expiresIn: opts.expires
+        isPublic: resolvedVisibility ?? false
       });
       console.log(`Created: ${result.url}`);
       const tmaUrl = getTelegramMiniAppUrl(result.slug);
       if (tmaUrl) console.log(`Telegram: ${tmaUrl}`);
-      if (result.expiresAt) {
-        console.log(`  Expires: ${new Date(result.expiresAt).toISOString()}`);
-      }
     }
   );
   program2.command("get").description("Get details of a pub").argument("<slug>", "Slug of the pub").option("--content", "Output raw content to stdout (no metadata, pipeable)").action(async (slug, opts) => {
@@ -1543,14 +1577,12 @@ function registerPubCommands(program2) {
     if (pub.contentType) console.log(`  Type:    ${pub.contentType}`);
     if (pub.title) console.log(`  Title:   ${pub.title}`);
     console.log(`  Status:  ${formatVisibility(pub.isPublic)}`);
-    if (pub.expiresAt) console.log(`  Expires: ${new Date(pub.expiresAt).toISOString()}`);
     console.log(`  Created: ${new Date(pub.createdAt).toLocaleDateString()}`);
     console.log(`  Updated: ${new Date(pub.updatedAt).toLocaleDateString()}`);
     if (pub.content) console.log(`  Size:    ${pub.content.length} bytes`);
     if (pub.live) {
       console.log(`  Live: ${pub.live.status}`);
       console.log(`    Connected: ${pub.live.hasConnection ? "yes" : "no"}`);
-      console.log(`    Expires:   ${new Date(pub.live.expiresAt).toISOString()}`);
     }
   });
   program2.command("update").description("Update a pub's content and/or metadata").argument("<slug>", "Slug of the pub to update").option("--file <file>", "New content from file").option("--title <title>", "New title").option("--public", "Make the pub public").option("--private", "Make the pub private").option("--slug <newSlug>", "Rename the slug").action(
@@ -1590,11 +1622,10 @@ function registerPubCommands(program2) {
     }
     for (const pub of pubs) {
       const date = new Date(pub.createdAt).toLocaleDateString();
-      const expires = pub.expiresAt ? ` expires:${new Date(pub.expiresAt).toISOString()}` : "";
       const contentLabel = pub.contentType ? `[${pub.contentType}]` : "[no content]";
       const sessionLabel = pub.live?.status === "active" ? " [live]" : "";
       console.log(
-        `  ${pub.slug}  ${contentLabel}  ${formatVisibility(pub.isPublic)}  ${date}${expires}${sessionLabel}`
+        `  ${pub.slug}  ${contentLabel}  ${formatVisibility(pub.isPublic)}  ${date}${sessionLabel}`
       );
     }
   });

package/dist/live-daemon-entry.js

@@ -5,6 +5,7 @@ import {
   buildClaudeArgs,
   buildSessionBriefing,
   createClaudeCodeBridgeRunner,
+  createClaudeSdkBridgeRunner,
   createOpenClawBridgeRunner,
   decodeMessage,
   encodeMessage,
@@ -19,7 +20,7 @@ import {
   resolveOpenClawRuntime,
   shouldAcknowledgeMessage,
   writeLiveSessionContentFile
-} from "./chunk-JSX5KHV3.js";
+} from "./chunk-5ODXW2EM.js";
 
 // src/lib/live-daemon.ts
 import { randomUUID } from "crypto";
@@ -39,9 +40,6 @@ import { spawn } from "child_process";
 // ../shared/command-protocol-core.ts
 var COMMAND_PROTOCOL_VERSION = 1;
 var COMMAND_MANIFEST_MAX_FUNCTIONS = 64;
-function makeCommandBindResultMessage(payload) {
-  return makeEventMessage("command.bind.result", payload);
-}
 function makeCommandResultMessage(payload) {
   return makeEventMessage("command.result", payload);
 }
@@ -143,18 +141,6 @@ function parseFunctionList(input) {
 function parseMetaRecord(msg) {
   return msg.type === "event" && msg.meta ? readRecord(msg.meta) : null;
 }
-function parseCommandBindMessage(msg) {
-  if (msg.type !== "event" || msg.data !== "command.bind") return null;
-  const meta = parseMetaRecord(msg);
-  if (!meta) return null;
-  const manifestId = readString(meta.manifestId);
-  if (!manifestId) return null;
-  return {
-    v: readFiniteNumber(meta.v) ?? COMMAND_PROTOCOL_VERSION,
-    manifestId,
-    functions: parseFunctionList(meta.functions)
-  };
-}
 function parseCommandInvokeMessage(msg) {
   if (msg.type !== "event" || msg.data !== "command.invoke") return null;
   const meta = parseMetaRecord(msg);
@@ -182,6 +168,28 @@ function parseCommandCancelMessage(msg) {
     reason: readString(meta.reason)
   };
 }
+var MANIFEST_SCRIPT_RE = /<script\s[^>]*type\s*=\s*["']application\/pubblue-command-manifest\+json["'][^>]*>([\s\S]*?)<\/script>/i;
+function extractManifestFromHtml(html) {
+  const match = MANIFEST_SCRIPT_RE.exec(html);
+  if (!match?.[1]) return null;
+  const raw = match[1].trim();
+  if (raw.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const record = parsed;
+  const manifestId = typeof record.manifestId === "string" && record.manifestId.length > 0 ? record.manifestId : `manifest-${Date.now().toString(36)}`;
+  const functions = parseFunctionList(record.functions);
+  return {
+    v: typeof record.version === "number" ? record.version : 1,
+    manifestId,
+    functions
+  };
+}
 
 // src/lib/live-command-handler.ts
 var DEFAULT_RECENT_RESULT_TTL_MS = 12e4;
@@ -433,9 +441,6 @@ function createLiveCommandHandler(params) {
     });
     await params.sendCommandMessage(makeCommandResultMessage(payload));
   }
-  async function sendBindResult(payload) {
-    await params.sendCommandMessage(makeCommandBindResultMessage(payload));
-  }
   async function executeFunction(spec, args, abortSignal) {
     const executor = spec.executor;
     if (!executor) {
@@ -498,39 +503,27 @@ function createLiveCommandHandler(params) {
       signal: abortSignal
     });
   }
-  async function handleBind(message) {
-    params.debugLog(
-      `command:bind manifestId=${message.manifestId} functions=[${message.functions.map((f) => f.name).join(", ")}]`
-    );
-    const accepted = [];
-    const rejected = [];
+  function bindFunctions(functions) {
     boundFunctions.clear();
-    for (const entry of message.functions) {
+    for (const entry of functions) {
       const normalized = normalizeFunctionSpec(entry);
       if (!normalized.executor) {
-        params.debugLog(`command:bind rejected "${normalized.name}" \u2014 missing executor`);
-        rejected.push({
-          name: normalized.name,
-          code: "INVALID_FUNCTION",
-          message: `Function "${normalized.name}" is missing executor definition.`
-        });
+        params.debugLog(`commands skipped "${normalized.name}" \u2014 missing executor`);
         continue;
       }
       boundFunctions.set(normalized.name, normalized);
-      accepted.push({
-        name: normalized.name,
-        returns: normalized.returns ?? "void"
-      });
     }
-    params.debugLog(
-      `command:bind result accepted=[${accepted.map((a) => a.name).join(", ")}] rejected=[${rejected.map((r) => r.name).join(", ")}]`
-    );
-    await sendBindResult({
-      v: COMMAND_PROTOCOL_VERSION,
-      manifestId: message.manifestId,
-      accepted,
-      rejected
-    });
+    params.debugLog(`commands bound=[${[...boundFunctions.keys()].join(", ")}]`);
+  }
+  function bindFromHtml(html) {
+    const manifest = extractManifestFromHtml(html);
+    if (!manifest) {
+      boundFunctions.clear();
+      params.debugLog("commands no manifest found in HTML, cleared bindings");
+      return;
+    }
+    params.debugLog(`commands manifestId=${manifest.manifestId}`);
+    bindFunctions(manifest.functions);
   }
   async function handleInvoke(message) {
     if (!message) return;
@@ -552,7 +545,7 @@ function createLiveCommandHandler(params) {
     }
     const spec = getSpec(message.name);
     if (!spec) {
-      params.debugLog(`command:invoke COMMAND_NOT_FOUND "${message.name}"`);
+      params.debugLog(`commands invoke COMMAND_NOT_FOUND "${message.name}"`);
       await sendResult({
         v: COMMAND_PROTOCOL_VERSION,
         callId: message.callId,
@@ -566,7 +559,7 @@ function createLiveCommandHandler(params) {
       return;
     }
     params.debugLog(
-      `command:invoke "${message.name}" callId=${message.callId} args=${JSON.stringify(message.args ?? {}).slice(0, 200)}`
+      `commands invoke "${message.name}" callId=${message.callId} args=${JSON.stringify(message.args ?? {}).slice(0, 200)}`
     );
     const abort = new AbortController();
     const startedAt = Date.now();
@@ -576,14 +569,14 @@ function createLiveCommandHandler(params) {
       const active = running.get(message.callId);
       if (abort.signal.aborted || active?.cancelled) {
         params.debugLog(
-          `command:invoke "${message.name}" cancelled after ${Date.now() - startedAt}ms`
+          `commands invoke "${message.name}" cancelled after ${Date.now() - startedAt}ms`
         );
         await sendResult(buildCancelledResult(message.callId, startedAt));
         return;
       }
       const durationMs = Date.now() - startedAt;
       params.debugLog(
-        `command:invoke "${message.name}" ok=${true} duration=${durationMs}ms value=${JSON.stringify(value).slice(0, 200)}`
+        `commands invoke "${message.name}" ok=${true} duration=${durationMs}ms value=${JSON.stringify(value).slice(0, 200)}`
       );
       await sendResult({
         v: COMMAND_PROTOCOL_VERSION,
@@ -600,7 +593,7 @@ function createLiveCommandHandler(params) {
       }
       const durationMs = Date.now() - startedAt;
       params.debugLog(
-        `command:invoke "${message.name}" FAILED duration=${durationMs}ms error=${detail.slice(0, 300)}`
+        `commands invoke "${message.name}" FAILED duration=${durationMs}ms error=${detail.slice(0, 300)}`
       );
       await sendResult({
         v: COMMAND_PROTOCOL_VERSION,
@@ -623,18 +616,13 @@ function createLiveCommandHandler(params) {
   async function handleBridgeMessage(message) {
     if (message.type !== "event") return;
     params.debugLog(
-      `command:message type=${message.type} data=${typeof message.data === "string" ? message.data.slice(0, 120) : "?"}`
+      `commands message type=${message.type} data=${typeof message.data === "string" ? message.data.slice(0, 120) : "?"}`
     );
     for (const [callId, result] of recentResults) {
       if (result.expiresAt <= Date.now()) {
         recentResults.delete(callId);
       }
     }
-    const bind = parseCommandBindMessage(message);
-    if (bind) {
-      await handleBind(bind);
-      return;
-    }
     const invoke = parseCommandInvokeMessage(message);
     if (invoke) {
       await handleInvoke(invoke);
@@ -646,6 +634,9 @@ function createLiveCommandHandler(params) {
     }
   }
   return {
+    bindFromHtml(html) {
+      bindFromHtml(html);
+    },
     stop() {
       for (const [callId, active] of running) {
         active.abort.abort();
@@ -757,9 +748,26 @@ function createDaemonIpcHandler(params) {
     switch (req.method) {
       case "write": {
         const channel = req.params.channel || "chat";
+        const msg = req.params.msg;
+        if (channel === CHANNELS.CANVAS && msg.type === "html" && typeof msg.data === "string") {
+          const slug = params.getActiveSlug();
+          if (!slug) return { ok: false, error: "No active live session." };
+          try {
+            await params.apiClient.update({
+              slug,
+              content: msg.data,
+              filename: "live-canvas.html"
+            });
+            params.bindCanvasCommands(msg.data);
+            return { ok: true, delivered: true };
+          } catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            params.markError(`failed to persist canvas HTML for "${slug}"`, error);
+            return { ok: false, error: `Canvas update failed: ${errMsg}` };
+          }
+        }
         const readinessError = params.getWriteReadinessError();
         if (readinessError) return { ok: false, error: readinessError };
-        const msg = req.params.msg;
         const binaryBase64 = typeof req.params.binaryBase64 === "string" ? req.params.binaryBase64 : void 0;
         const binaryPayload = msg.type === "binary" && binaryBase64 ? Buffer.from(binaryBase64, "base64") : void 0;
         const maxAttempts = Math.max(1, params.writeAckMaxAttempts);
@@ -809,7 +817,6 @@ function createDaemonIpcHandler(params) {
               continue;
             }
           }
-          params.trackOutboundMessage(channel, msg);
           return { ok: true, delivered: true };
         }
         return {
@@ -937,7 +944,7 @@ var CANVAS_COMMAND_PROTOCOL_GUIDE_MARKDOWN = [
 
 // src/lib/live-daemon-shared.ts
 function buildBridgeInstructions(mode) {
-  if (mode === "claude-code") {
+  if (mode === "claude-code" || mode === "claude-sdk") {
     return {
       replyHint: 'Reply command: pubblue write "<your reply>"',
       canvasHint: "Canvas command: pubblue write -c canvas -f /path/to/file.html",
@@ -974,13 +981,6 @@ function shouldRecoverForBrowserOfferChange(params) {
   if (!lastAppliedBrowserOffer) return false;
   return incomingBrowserOffer !== lastAppliedBrowserOffer;
 }
-function readCanvasHtmlFromOutbound(params) {
-  if (params.channel !== CHANNELS.CANVAS) return null;
-  if (params.msg.type !== "html") return null;
-  if (typeof params.msg.data !== "string") return null;
-  if (params.msg.data.length === 0) return null;
-  return params.msg.data;
-}
 
 // src/lib/live-daemon-signaling.ts
 import { ConvexClient } from "convex/browser";
@@ -1034,7 +1034,7 @@ function parseLiveSnapshot(result) {
   if (!Array.isArray(live.agentCandidates)) {
     throw new Error("Invalid signaling snapshot: missing agentCandidates");
   }
-  if (typeof live.createdAt !== "number" || typeof live.expiresAt !== "number") {
+  if (typeof live.createdAt !== "number") {
     throw new Error("Invalid signaling snapshot: missing timestamps");
   }
   return {
@@ -1044,8 +1044,7 @@ function parseLiveSnapshot(result) {
     agentAnswer: live.agentAnswer,
     browserCandidates: live.browserCandidates,
     agentCandidates: live.agentCandidates,
-    createdAt: live.createdAt,
-    expiresAt: live.expiresAt
+    createdAt: live.createdAt
   };
 }
 function createSignalingController(params) {
@@ -1203,9 +1202,7 @@ async function startDaemon(config) {
   let pendingInboundBinaryMeta = /* @__PURE__ */ new Map();
   let inboundStreams = /* @__PURE__ */ new Map();
   let seenInboundMessageKeys = /* @__PURE__ */ new Set();
-  let lastCanvasSnapshot = null;
-  let lastPersistedCanvasSnapshot = null;
-  let persistCanvasQueue = Promise.resolve();
+  let commandProcessingQueue = Promise.resolve();
   let heartbeatTimer = null;
   let localCandidateInterval = null;
   let localCandidateStopTimer = null;
@@ -1222,14 +1219,10 @@ async function startDaemon(config) {
     markError,
     sendCommandMessage: async (msg) => {
       if (!isLiveConnected()) return false;
-      const sent = await sendOutboundMessageWithAck(CHANNELS.COMMAND, msg, {
+      return sendOutboundMessageWithAck(CHANNELS.COMMAND, msg, {
         context: 'command outbound on "command"',
         maxAttempts: OUTBOUND_SEND_MAX_ATTEMPTS
       });
-      if (sent) {
-        trackOutboundMessage(CHANNELS.COMMAND, msg);
-      }
-      return sent;
     }
   });
   function debugLog(message, error) {
@@ -1324,46 +1317,8 @@ async function startDaemon(config) {
       buffer.messages.splice(0, buffer.messages.length - MAX_BUFFERED_MESSAGES);
     }
   }
-  function getActiveCanvasSnapshot() {
-    if (!activeSlug || !lastCanvasSnapshot) return null;
-    if (lastCanvasSnapshot.slug !== activeSlug) return null;
-    return lastCanvasSnapshot;
-  }
-  function isSameCanvasSnapshot(a, b) {
-    if (!a || !b) return false;
-    return a.slug === b.slug && a.html === b.html;
-  }
-  function queuePersistCanvasSnapshot(snapshot, reason) {
-    if (!snapshot) return Promise.resolve();
-    if (isSameCanvasSnapshot(lastPersistedCanvasSnapshot, snapshot)) return Promise.resolve();
-    persistCanvasQueue = persistCanvasQueue.then(async () => {
-      if (isSameCanvasSnapshot(lastPersistedCanvasSnapshot, snapshot)) return;
-      try {
-        await apiClient2.update({
-          slug: snapshot.slug,
-          content: snapshot.html,
-          filename: "live-canvas.html"
-        });
-        lastPersistedCanvasSnapshot = snapshot;
-        debugLog(`persisted latest canvas for "${snapshot.slug}" (${reason})`);
-      } catch (error) {
-        markError(`failed to persist latest canvas for "${snapshot.slug}" (${reason})`, error);
-        if (!debugEnabled) {
-          console.error(
-            `[pubblue-agent] failed to persist latest canvas for "${snapshot.slug}" (${reason}): ${errorMessage(error)}`
-          );
-        }
-      }
-    });
-    return persistCanvasQueue;
-  }
-  function trackOutboundMessage(channel, msg) {
-    const html = readCanvasHtmlFromOutbound({ channel, msg });
-    if (!html || !activeSlug) return;
-    lastCanvasSnapshot = { slug: activeSlug, html };
-  }
   function handleConnectionClosed(reason) {
-    void queuePersistCanvasSnapshot(getActiveCanvasSnapshot(), reason);
+    debugLog(`connection closed: ${reason}`);
     const hadConnection = browserConnected || bridgePrimed;
     browserConnected = false;
     bridgePrimed = false;
@@ -1466,7 +1421,9 @@ async function startDaemon(config) {
           queueAck(msg.id, name);
         }
         if (name === CHANNELS.COMMAND) {
-          void commandHandler.onMessage(msg);
+          commandProcessingQueue = commandProcessingQueue.then(() => commandHandler.onMessage(msg)).catch((error) => {
+            markError("command message processing failed", error);
+          });
           return;
         }
         appendBufferedMessage({ channel: name, msg, timestamp: Date.now() });
@@ -1756,10 +1713,6 @@ async function startDaemon(config) {
     if (recovering) return;
     recovering = true;
     try {
-      const previousCanvasSnapshot = getActiveCanvasSnapshot();
-      if (previousCanvasSnapshot && previousCanvasSnapshot.slug !== slug) {
-        void queuePersistCanvasSnapshot(previousCanvasSnapshot, `session-switch:${slug}`);
-      }
       await stopBridge();
       closeCurrentPeer();
       createPeer();
@@ -1834,6 +1787,8 @@ async function startDaemon(config) {
     }
   }, HEARTBEAT_INTERVAL_MS);
   const handleIpcRequest = createDaemonIpcHandler({
+    apiClient: apiClient2,
+    bindCanvasCommands: (html) => commandHandler.bindFromHtml(html),
     getConnected: () => isLiveConnected(),
     getSignalingConnected: () => {
       const state = signaling.status();
@@ -1854,7 +1809,6 @@ async function startDaemon(config) {
     waitForChannelOpen,
     waitForDeliveryAck,
     settlePendingAck,
-    trackOutboundMessage,
     markError,
     shutdown: () => {
       void shutdown();
@@ -1874,18 +1828,17 @@ async function startDaemon(config) {
   signaling.start();
   async function sendOnChannel(channel, msg) {
     if (stopped || !isLiveConnected()) return false;
-    const sent = await sendOutboundMessageWithAck(channel, msg, {
+    return sendOutboundMessageWithAck(channel, msg, {
       context: `bridge outbound on "${channel}"`,
       maxAttempts: OUTBOUND_SEND_MAX_ATTEMPTS
     });
-    if (sent) {
-      trackOutboundMessage(channel, msg);
-    }
-    return sent;
   }
   async function buildInitialSessionBriefing(params) {
     const pub = await apiClient2.get(params.slug);
     const content = typeof pub.content === "string" ? pub.content : "";
+    if (content.length > 0) {
+      commandHandler.bindFromHtml(content);
+    }
     const canvasContentFilePath = content.length > 0 ? writeLiveSessionContentFile({
       slug: params.slug,
       contentType: pub.contentType,
@@ -1928,7 +1881,7 @@ async function startDaemon(config) {
       debugLog,
       instructions
     };
-    const runner = config.bridgeMode === "claude-code" ? await createClaudeCodeBridgeRunner(bridgeConfig, abort.signal) : await createOpenClawBridgeRunner(bridgeConfig);
+    const runner = config.bridgeMode === "claude-sdk" ? await createClaudeSdkBridgeRunner(bridgeConfig, abort.signal) : config.bridgeMode === "claude-code" ? await createClaudeCodeBridgeRunner(bridgeConfig, abort.signal) : await createOpenClawBridgeRunner(bridgeConfig);
     if (stopped || activeSlug !== slug || abort.signal.aborted) {
       await runner.stop();
       return;
@@ -1974,7 +1927,6 @@ async function startDaemon(config) {
     clearHeartbeatTimer();
     stopPingPong();
     await signaling.stop();
-    await queuePersistCanvasSnapshot(getActiveCanvasSnapshot(), "daemon-shutdown");
     try {
       await apiClient2.goOffline({ daemonSessionId });
     } catch (error) {