pubblue 0.6.8 → 0.7.0

package/dist/live-daemon-entry.js

@@ -2,22 +2,29 @@ import {
   CHANNELS,
   CONTROL_CHANNEL,
   PubApiClient,
-  PubApiError,
+  buildClaudeArgs,
+  buildSessionBriefing,
   createClaudeCodeBridgeRunner,
+  createClaudeSdkBridgeRunner,
   createOpenClawBridgeRunner,
   decodeMessage,
   encodeMessage,
   errorMessage,
   latestCliVersionPath,
   makeAckMessage,
+  makeDeliveryReceiptMessage,
+  makeEventMessage,
   parseAckMessage,
   readLatestCliVersion,
-  shouldAcknowledgeMessage
-} from "./chunk-AZQD654L.js";
+  resolveClaudeCodePath,
+  resolveOpenClawRuntime,
+  shouldAcknowledgeMessage,
+  writeLiveSessionContentFile
+} from "./chunk-5ODXW2EM.js";
 
 // src/lib/live-daemon.ts
+import { randomUUID } from "crypto";
 import * as fs from "fs";
-import * as net from "net";
 import * as path from "path";
 
 // ../shared/ack-routing-core.ts
@@ -27,67 +34,946 @@ function resolveAckChannel(input) {
   return null;
 }
 
-// src/lib/live-daemon-answer.ts
-function createAnswer(peer, browserOffer, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    let resolved = false;
-    const done = (sdp, type) => {
-      if (resolved) return;
-      resolved = true;
+// src/lib/live-command-handler.ts
+import { spawn } from "child_process";
+
+// ../shared/command-protocol-core.ts
+var COMMAND_PROTOCOL_VERSION = 1;
+var COMMAND_MANIFEST_MAX_FUNCTIONS = 64;
+function makeCommandResultMessage(payload) {
+  return makeEventMessage("command.result", payload);
+}
+function readRecord(input) {
+  return input && typeof input === "object" && !Array.isArray(input) ? input : null;
+}
+function readString(input) {
+  return typeof input === "string" && input.trim().length > 0 ? input : void 0;
+}
+function readReturnType(input) {
+  if (input === "void" || input === "text" || input === "json") return input;
+  return void 0;
+}
+function readFiniteNumber(input) {
+  if (typeof input !== "number" || !Number.isFinite(input)) return void 0;
+  return input;
+}
+function readStringArray(input) {
+  if (!Array.isArray(input)) return void 0;
+  const values = input.filter((entry) => typeof entry === "string");
+  return values.length === input.length ? values : void 0;
+}
+function readStringRecord(input) {
+  const record = readRecord(input);
+  if (!record) return void 0;
+  const values = Object.entries(record).filter((entry) => {
+    const [_key, value] = entry;
+    return typeof value === "string";
+  });
+  if (values.length !== Object.keys(record).length) return void 0;
+  return Object.fromEntries(values);
+}
+function parseExecutor(input) {
+  const record = readRecord(input);
+  if (!record) return void 0;
+  const kind = readString(record.kind);
+  if (!kind) return void 0;
+  if (kind === "exec") {
+    const command = readString(record.command);
+    if (!command) return void 0;
+    return {
+      kind: "exec",
+      command,
+      args: readStringArray(record.args),
+      cwd: readString(record.cwd),
+      timeoutMs: readFiniteNumber(record.timeoutMs),
+      env: readStringRecord(record.env)
+    };
+  }
+  if (kind === "shell") {
+    const script = readString(record.script);
+    if (!script) return void 0;
+    return {
+      kind: "shell",
+      script,
+      shell: readString(record.shell),
+      cwd: readString(record.cwd),
+      timeoutMs: readFiniteNumber(record.timeoutMs)
+    };
+  }
+  if (kind === "agent") {
+    const prompt = readString(record.prompt);
+    if (!prompt) return void 0;
+    const providerRaw = readString(record.provider);
+    const provider = providerRaw === "claude-code" || providerRaw === "openclaw" || providerRaw === "auto" ? providerRaw : void 0;
+    const outputRaw = readString(record.output);
+    const output = outputRaw === "json" || outputRaw === "text" ? outputRaw : void 0;
+    return {
+      kind: "agent",
+      prompt,
+      provider,
+      timeoutMs: readFiniteNumber(record.timeoutMs),
+      output
+    };
+  }
+  return void 0;
+}
+function parseFunctionSpec(input, fallbackName) {
+  const record = readRecord(input);
+  if (!record) return null;
+  const name = readString(record.name) ?? fallbackName;
+  if (!name) return null;
+  return {
+    name,
+    returns: readReturnType(record.returns),
+    timeoutMs: readFiniteNumber(record.timeoutMs),
+    description: readString(record.description),
+    executor: parseExecutor(record.executor)
+  };
+}
+function parseFunctionList(input) {
+  if (Array.isArray(input)) {
+    return input.map((entry) => parseFunctionSpec(entry)).filter((entry) => entry !== null).slice(0, COMMAND_MANIFEST_MAX_FUNCTIONS);
+  }
+  const record = readRecord(input);
+  if (!record) return [];
+  return Object.entries(record).map(([name, value]) => parseFunctionSpec(value, name)).filter((entry) => entry !== null).slice(0, COMMAND_MANIFEST_MAX_FUNCTIONS);
+}
+function parseMetaRecord(msg) {
+  return msg.type === "event" && msg.meta ? readRecord(msg.meta) : null;
+}
+function parseCommandInvokeMessage(msg) {
+  if (msg.type !== "event" || msg.data !== "command.invoke") return null;
+  const meta = parseMetaRecord(msg);
+  if (!meta) return null;
+  const callId = readString(meta.callId);
+  const name = readString(meta.name);
+  if (!callId || !name) return null;
+  return {
+    v: readFiniteNumber(meta.v) ?? COMMAND_PROTOCOL_VERSION,
+    callId,
+    name,
+    args: readRecord(meta.args) ?? void 0,
+    timeoutMs: readFiniteNumber(meta.timeoutMs)
+  };
+}
+function parseCommandCancelMessage(msg) {
+  if (msg.type !== "event" || msg.data !== "command.cancel") return null;
+  const meta = parseMetaRecord(msg);
+  if (!meta) return null;
+  const callId = readString(meta.callId);
+  if (!callId) return null;
+  return {
+    v: readFiniteNumber(meta.v) ?? COMMAND_PROTOCOL_VERSION,
+    callId,
+    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;
+var DEFAULT_COMMAND_TIMEOUT_MS = 15e3;
+var DEFAULT_MAX_OUTPUT_BYTES = 256 * 1024;
+var DEFAULT_MAX_CONCURRENT = 6;
+function readPositiveNumberEnv(key, fallback) {
+  const value = process.env[key];
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+}
+function readRuntimeConfig() {
+  return {
+    defaultTimeoutMs: readPositiveNumberEnv(
+      "PUBBLUE_COMMAND_DEFAULT_TIMEOUT_MS",
+      DEFAULT_COMMAND_TIMEOUT_MS
+    ),
+    maxOutputBytes: readPositiveNumberEnv(
+      "PUBBLUE_COMMAND_MAX_OUTPUT_BYTES",
+      DEFAULT_MAX_OUTPUT_BYTES
+    ),
+    maxConcurrent: readPositiveNumberEnv("PUBBLUE_COMMAND_MAX_CONCURRENT", DEFAULT_MAX_CONCURRENT)
+  };
+}
+function readArgPath(args, path2) {
+  const parts = path2.split(".");
+  let value = args;
+  for (const part of parts) {
+    if (!value || typeof value !== "object") return void 0;
+    value = value[part];
+  }
+  return value;
+}
+function interpolateTemplate(input, args) {
+  return input.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (_match, path2) => {
+    const value = readArgPath(args, path2);
+    if (value === void 0 || value === null) return "";
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+    return JSON.stringify(value);
+  });
+}
+function buildCommandError(code, message, retryable = false) {
+  return { code, message, retryable };
+}
+function toCommandReturnValue(output, returnType) {
+  if (returnType === "void") return null;
+  if (returnType === "json") {
+    const trimmed = output.trim();
+    if (trimmed.length === 0) return {};
+    return JSON.parse(trimmed);
+  }
+  return output;
+}
+async function executeProcessCommand(params) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(params.command, params.args, {
+      cwd: params.cwd,
+      env: { ...process.env, ...params.env ?? {} },
+      signal: params.signal,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
       clearTimeout(timeout);
-      resolve(JSON.stringify({ sdp, type }));
+      fn();
     };
-    const offer = JSON.parse(browserOffer);
-    peer.setRemoteDescription(offer.sdp, offer.type);
-    peer.onLocalDescription((sdp, type) => {
-      done(sdp, type);
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish(() => reject(new Error(`Command timed out after ${params.timeoutMs}ms`)));
+    }, params.timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      if (settled) return;
+      stdout += chunk.toString("utf-8");
+      if (stdout.length > params.maxOutputBytes) {
+        child.kill("SIGTERM");
+        finish(() => reject(new Error(`stdout exceeded ${params.maxOutputBytes} bytes`)));
+      }
     });
-    peer.onGatheringStateChange((state) => {
-      if (state === "complete" && !resolved) {
-        const desc = peer.localDescription();
-        if (desc) done(desc.sdp, desc.type);
+    child.stderr.on("data", (chunk) => {
+      if (settled) return;
+      stderr += chunk.toString("utf-8");
+      if (stderr.length > params.maxOutputBytes) {
+        child.kill("SIGTERM");
+        finish(() => reject(new Error(`stderr exceeded ${params.maxOutputBytes} bytes`)));
       }
     });
+    child.on("error", (error) => {
+      finish(() => reject(error));
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        finish(() => resolve({ stdout, stderr }));
+        return;
+      }
+      const detail = stderr.trim().length > 0 ? stderr.trim() : `exit code ${code}`;
+      finish(() => reject(new Error(detail)));
+    });
+  });
+}
+async function executeShellCommand(params) {
+  const shell = params.shell?.trim() || "/bin/sh";
+  return await executeProcessCommand({
+    command: shell,
+    args: ["-lc", params.script],
+    cwd: params.cwd,
+    timeoutMs: params.timeoutMs,
+    maxOutputBytes: params.maxOutputBytes,
+    signal: params.signal
+  });
+}
+function readClaudeAssistantOutput(line) {
+  if (!line.trim().startsWith("{")) return "";
+  try {
+    const event = JSON.parse(line);
+    if (typeof event.text === "string") return event.text;
+    if (event.delta && typeof event.delta.text === "string") return event.delta.text;
+    if (event.message && event.message.role === "assistant" && typeof event.message.content === "string") {
+      return event.message.content;
+    }
+    return "";
+  } catch (_error) {
+    return "";
+  }
+}
+async function executeClaudeAgentCommand(params) {
+  const claudePath = resolveClaudeCodePath(process.env);
+  const args = buildClaudeArgs(params.prompt, null, null, process.env);
+  if (!args.includes("--max-turns")) {
+    args.push("--max-turns", "4");
+  }
+  const cwd = process.env.CLAUDE_CODE_CWD?.trim() || process.env.PUBBLUE_PROJECT_ROOT || void 0;
+  const outputText = await new Promise((resolve, reject) => {
+    const child = spawn(claudePath, args, {
+      cwd,
+      env: { ...process.env },
+      signal: params.signal,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      fn();
+    };
     const timeout = setTimeout(() => {
-      if (resolved) return;
-      const desc = peer.localDescription();
-      if (desc) {
-        done(desc.sdp, desc.type);
-      } else {
-        resolved = true;
-        reject(new Error(`Timed out after ${timeoutMs}ms`));
+      child.kill("SIGTERM");
+      finish(() => reject(new Error(`Agent command timed out after ${params.timeoutMs}ms`)));
+    }, params.timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+      if (stdout.length > params.maxOutputBytes) {
+        child.kill("SIGTERM");
+        finish(() => reject(new Error(`stdout exceeded ${params.maxOutputBytes} bytes`)));
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+      if (stderr.length > params.maxOutputBytes) {
+        child.kill("SIGTERM");
+        finish(() => reject(new Error(`stderr exceeded ${params.maxOutputBytes} bytes`)));
+      }
+    });
+    child.on("error", (error) => {
+      finish(() => reject(error));
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        const detail = stderr.trim().length > 0 ? stderr.trim() : `exit code ${code}`;
+        finish(() => reject(new Error(detail)));
+        return;
+      }
+      const lines = stdout.split(/\r?\n/);
+      const chunks = lines.map(readClaudeAssistantOutput).filter((entry) => entry.length > 0);
+      const joined = chunks.join("").trim();
+      finish(() => resolve(joined.length > 0 ? joined : stdout.trim()));
+    });
+  });
+  if (params.output === "json") {
+    const trimmed = outputText.trim();
+    if (trimmed.length === 0) return {};
+    return JSON.parse(trimmed);
+  }
+  return outputText;
+}
+async function executeOpenClawAgentCommand(params) {
+  const runtime = resolveOpenClawRuntime(process.env);
+  const invocationArgs = [
+    "agent",
+    "--local",
+    "--session-id",
+    runtime.sessionId,
+    "-m",
+    params.prompt
+  ];
+  const command = runtime.openclawPath.endsWith(".js") ? process.execPath : runtime.openclawPath;
+  const args = runtime.openclawPath.endsWith(".js") ? [runtime.openclawPath, ...invocationArgs] : invocationArgs;
+  const result = await executeProcessCommand({
+    command,
+    args,
+    cwd: process.env.PUBBLUE_PROJECT_ROOT || process.cwd(),
+    timeoutMs: params.timeoutMs,
+    maxOutputBytes: params.maxOutputBytes,
+    signal: params.signal
+  });
+  const output = result.stdout.trim();
+  if (params.output === "json") {
+    return output.length === 0 ? {} : JSON.parse(output);
+  }
+  return output;
+}
+function normalizeFunctionSpec(input) {
+  return {
+    ...input,
+    returns: input.returns === "text" || input.returns === "json" ? input.returns : "void"
+  };
+}
+function createLiveCommandHandler(params) {
+  const runtime = readRuntimeConfig();
+  const boundFunctions = /* @__PURE__ */ new Map();
+  const running = /* @__PURE__ */ new Map();
+  const recentResults = /* @__PURE__ */ new Map();
+  function buildCancelledResult(callId, startedAt) {
+    return {
+      v: COMMAND_PROTOCOL_VERSION,
+      callId,
+      ok: false,
+      error: buildCommandError("COMMAND_CANCELLED", "Command execution was cancelled."),
+      durationMs: Date.now() - startedAt
+    };
+  }
+  function getSpec(name) {
+    return boundFunctions.get(name) ?? null;
+  }
+  async function sendResult(payload) {
+    recentResults.set(payload.callId, {
+      payload,
+      expiresAt: Date.now() + DEFAULT_RECENT_RESULT_TTL_MS
+    });
+    await params.sendCommandMessage(makeCommandResultMessage(payload));
+  }
+  async function executeFunction(spec, args, abortSignal) {
+    const executor = spec.executor;
+    if (!executor) {
+      throw new Error(`Function "${spec.name}" is missing executor definition.`);
+    }
+    const timeoutMs = (typeof executor.timeoutMs === "number" && executor.timeoutMs > 0 ? executor.timeoutMs : void 0) ?? (typeof spec.timeoutMs === "number" && spec.timeoutMs > 0 ? spec.timeoutMs : void 0) ?? runtime.defaultTimeoutMs;
+    const returnType = spec.returns === "json" || spec.returns === "text" ? spec.returns : "void";
+    if (executor.kind === "exec") {
+      const command = interpolateTemplate(executor.command, args);
+      const commandArgs = (executor.args ?? []).map((entry) => interpolateTemplate(entry, args));
+      const cwd = executor.cwd ? interpolateTemplate(executor.cwd, args) : void 0;
+      const env = executor.env ? Object.fromEntries(
+        Object.entries(executor.env).map(([key, value]) => [
+          key,
+          interpolateTemplate(value, args)
+        ])
+      ) : void 0;
+      const result = await executeProcessCommand({
+        command,
+        args: commandArgs,
+        cwd,
+        env,
+        timeoutMs,
+        maxOutputBytes: runtime.maxOutputBytes,
+        signal: abortSignal
+      });
+      return toCommandReturnValue(result.stdout, returnType);
+    }
+    if (executor.kind === "shell") {
+      const script = interpolateTemplate(executor.script, args);
+      const cwd = executor.cwd ? interpolateTemplate(executor.cwd, args) : void 0;
+      const result = await executeShellCommand({
+        script,
+        shell: executor.shell,
+        cwd,
+        timeoutMs,
+        maxOutputBytes: runtime.maxOutputBytes,
+        signal: abortSignal
+      });
+      return toCommandReturnValue(result.stdout, returnType);
+    }
+    const agentSpec = executor;
+    const prompt = interpolateTemplate(agentSpec.prompt, args);
+    const output = agentSpec.output === "json" ? "json" : "text";
+    const provider = agentSpec.provider && agentSpec.provider !== "auto" ? agentSpec.provider : params.bridgeMode === "openclaw" ? "openclaw" : "claude-code";
+    if (provider === "openclaw") {
+      return await executeOpenClawAgentCommand({
+        prompt,
+        timeoutMs,
+        output,
+        maxOutputBytes: runtime.maxOutputBytes,
+        signal: abortSignal
+      });
+    }
+    return await executeClaudeAgentCommand({
+      prompt,
+      timeoutMs,
+      output,
+      maxOutputBytes: runtime.maxOutputBytes,
+      signal: abortSignal
+    });
+  }
+  function bindFunctions(functions) {
+    boundFunctions.clear();
+    for (const entry of functions) {
+      const normalized = normalizeFunctionSpec(entry);
+      if (!normalized.executor) {
+        params.debugLog(`commands skipped "${normalized.name}" \u2014 missing executor`);
+        continue;
+      }
+      boundFunctions.set(normalized.name, normalized);
+    }
+    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;
+    const existing = recentResults.get(message.callId);
+    if (existing && existing.expiresAt > Date.now()) {
+      await sendResult(existing.payload);
+      return;
+    }
+    if (running.has(message.callId)) return;
+    if (running.size >= runtime.maxConcurrent) {
+      await sendResult({
+        v: COMMAND_PROTOCOL_VERSION,
+        callId: message.callId,
+        ok: false,
+        error: buildCommandError("MAX_CONCURRENCY", "Too many commands are already running."),
+        durationMs: 0
+      });
+      return;
+    }
+    const spec = getSpec(message.name);
+    if (!spec) {
+      params.debugLog(`commands invoke COMMAND_NOT_FOUND "${message.name}"`);
+      await sendResult({
+        v: COMMAND_PROTOCOL_VERSION,
+        callId: message.callId,
+        ok: false,
+        error: buildCommandError(
+          "COMMAND_NOT_FOUND",
+          `Command "${message.name}" is not registered.`
+        ),
+        durationMs: 0
+      });
+      return;
+    }
+    params.debugLog(
+      `commands invoke "${message.name}" callId=${message.callId} args=${JSON.stringify(message.args ?? {}).slice(0, 200)}`
+    );
+    const abort = new AbortController();
+    const startedAt = Date.now();
+    running.set(message.callId, { abort, startedAt, cancelled: false });
+    try {
+      const value = await executeFunction(spec, message.args ?? {}, abort.signal);
+      const active = running.get(message.callId);
+      if (abort.signal.aborted || active?.cancelled) {
+        params.debugLog(
+          `commands invoke "${message.name}" cancelled after ${Date.now() - startedAt}ms`
+        );
+        await sendResult(buildCancelledResult(message.callId, startedAt));
+        return;
+      }
+      const durationMs = Date.now() - startedAt;
+      params.debugLog(
+        `commands invoke "${message.name}" ok=${true} duration=${durationMs}ms value=${JSON.stringify(value).slice(0, 200)}`
+      );
+      await sendResult({
+        v: COMMAND_PROTOCOL_VERSION,
+        callId: message.callId,
+        ok: true,
+        value: spec.returns === "void" ? null : value,
+        durationMs
+      });
+    } catch (error) {
+      const detail = error instanceof Error && error.message.trim().length > 0 ? error.message : "Command execution failed";
+      if (abort.signal.aborted || running.get(message.callId)?.cancelled) {
+        await sendResult(buildCancelledResult(message.callId, startedAt));
+        return;
+      }
+      const durationMs = Date.now() - startedAt;
+      params.debugLog(
+        `commands invoke "${message.name}" FAILED duration=${durationMs}ms error=${detail.slice(0, 300)}`
+      );
+      await sendResult({
+        v: COMMAND_PROTOCOL_VERSION,
+        callId: message.callId,
+        ok: false,
+        error: buildCommandError("COMMAND_EXECUTION_FAILED", detail),
+        durationMs
+      });
+    } finally {
+      running.delete(message.callId);
+    }
+  }
+  async function handleCancel(message) {
+    if (!message) return;
+    const active = running.get(message.callId);
+    if (!active) return;
+    active.cancelled = true;
+    active.abort.abort();
+  }
+  async function handleBridgeMessage(message) {
+    if (message.type !== "event") return;
+    params.debugLog(
+      `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 invoke = parseCommandInvokeMessage(message);
+    if (invoke) {
+      await handleInvoke(invoke);
+      return;
+    }
+    const cancel = parseCommandCancelMessage(message);
+    if (cancel) {
+      await handleCancel(cancel);
+    }
+  }
+  return {
+    bindFromHtml(html) {
+      bindFromHtml(html);
+    },
+    stop() {
+      for (const [callId, active] of running) {
+        active.abort.abort();
+        running.delete(callId);
+      }
+    },
+    async onMessage(message) {
+      await handleBridgeMessage(message).catch((error) => {
+        params.markError("command handler failed", error);
+      });
+    }
+  };
+}
+
+// ../shared/webrtc-negotiation-core.ts
+function createAgentAnswerFromBrowserOffer(peer, browserOffer, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timeout = null;
+    const finish = (description) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      resolve(encodeSessionDescription(description));
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      reject(error);
+    };
+    peer.onLocalDescription((sdp, type) => {
+      finish(assertSessionDescription({ sdp, type }, "Agent local description"));
+    });
+    peer.onGatheringStateChange((state) => {
+      if (state !== "complete" || settled) return;
+      const local = peer.getLocalDescription();
+      if (!local) return;
+      finish(assertSessionDescription(local, "Agent local description"));
+    });
+    try {
+      const parsedOffer = parseSessionDescription(browserOffer, "Browser offer");
+      peer.setRemoteDescription(parsedOffer.sdp, parsedOffer.type);
+    } catch (error) {
+      fail(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
+    timeout = setTimeout(() => {
+      const local = peer.getLocalDescription();
+      if (local) {
+        finish(assertSessionDescription(local, "Agent local description"));
+        return;
+      }
+      fail(new Error(`Timed out after ${timeoutMs}ms`));
     }, timeoutMs);
   });
 }
+function parseSessionDescription(descriptionJson, label = "Session description") {
+  let parsed;
+  try {
+    parsed = JSON.parse(descriptionJson);
+  } catch {
+    throw new Error(`${label} is not valid JSON`);
+  }
+  return assertSessionDescription(parsed, label);
+}
+function encodeSessionDescription(description) {
+  const normalized = assertSessionDescription(description, "Session description");
+  return JSON.stringify({ sdp: normalized.sdp, type: normalized.type });
+}
+function assertSessionDescription(value, label) {
+  if (!value || typeof value !== "object") {
+    throw new Error(`${label} must be an object with sdp/type`);
+  }
+  const maybeSdp = value.sdp;
+  const maybeType = value.type;
+  if (typeof maybeSdp !== "string" || maybeSdp.length === 0) {
+    throw new Error(`${label} must include a non-empty sdp`);
+  }
+  if (typeof maybeType !== "string" || maybeType.length === 0) {
+    throw new Error(`${label} must include a non-empty type`);
+  }
+  return { sdp: maybeSdp, type: maybeType };
+}
+
+// src/lib/live-daemon-answer.ts
+function createAnswer(peer, browserOffer, timeoutMs) {
+  return createAgentAnswerFromBrowserOffer(
+    {
+      setRemoteDescription: (sdp, type) => {
+        peer.setRemoteDescription(sdp, type);
+      },
+      onLocalDescription: (cb) => {
+        peer.onLocalDescription((sdp, type) => cb(sdp, type));
+      },
+      onGatheringStateChange: (cb) => {
+        peer.onGatheringStateChange((state) => cb(state));
+      },
+      getLocalDescription: () => peer.localDescription()
+    },
+    browserOffer,
+    timeoutMs
+  );
+}
+
+// src/lib/live-daemon-ipc-handler.ts
+function createDaemonIpcHandler(params) {
+  return async function handleIpcRequest(req) {
+    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 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);
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+          let targetDc;
+          try {
+            targetDc = params.openDataChannel(channel);
+            await params.waitForChannelOpen(targetDc);
+          } catch (error) {
+            params.markError(
+              `channel "${channel}" failed to open (attempt ${attempt}/${maxAttempts})`,
+              error
+            );
+            lastError = `Channel "${channel}" not open: ${error instanceof Error ? error.message : String(error)}`;
+            continue;
+          }
+          const waitForAck = shouldAcknowledgeMessage(channel, msg) ? params.waitForDeliveryAck(msg.id, channel, params.writeAckTimeoutMs) : null;
+          try {
+            if (msg.type === "binary" && binaryPayload) {
+              targetDc.sendMessage(
+                encodeMessage({
+                  ...msg,
+                  meta: { ...msg.meta || {}, size: binaryPayload.length }
+                })
+              );
+              targetDc.sendMessageBinary(binaryPayload);
+            } else {
+              targetDc.sendMessage(encodeMessage(msg));
+            }
+          } catch (error) {
+            if (waitForAck) params.settlePendingAck(msg.id, channel, false);
+            params.markError(
+              `failed to send message on channel "${channel}" (attempt ${attempt}/${maxAttempts})`,
+              error
+            );
+            lastError = `Failed to send on channel "${channel}": ${error instanceof Error ? error.message : String(error)}`;
+            continue;
+          }
+          if (waitForAck) {
+            const acked = await waitForAck;
+            if (!acked) {
+              params.markError(
+                `delivery ack timeout for message ${msg.id} on "${channel}" (attempt ${attempt}/${maxAttempts})`
+              );
+              lastError = `Delivery not confirmed for message ${msg.id} within ${params.writeAckTimeoutMs}ms.`;
+              continue;
+            }
+          }
+          return { ok: true, delivered: true };
+        }
+        return {
+          ok: false,
+          error: lastError ?? `Failed to send on channel "${channel}" after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`
+        };
+      }
+      case "read": {
+        const channel = req.params.channel;
+        const buffered = params.getBufferedMessages();
+        let msgs;
+        if (channel) {
+          msgs = buffered.filter((m) => m.channel === channel);
+          params.setBufferedMessages(buffered.filter((m) => m.channel !== channel));
+        } else {
+          msgs = [...buffered];
+          params.setBufferedMessages([]);
+        }
+        return { ok: true, messages: msgs };
+      }
+      case "channels": {
+        const chList = params.getChannels().map((name) => ({ name, direction: "bidi" }));
+        return { ok: true, channels: chList };
+      }
+      case "status": {
+        return {
+          ok: true,
+          connected: params.getConnected(),
+          signalingConnected: params.getSignalingConnected(),
+          activeSlug: params.getActiveSlug(),
+          uptime: params.getUptimeSeconds(),
+          channels: params.getChannels(),
+          bufferedMessages: params.getBufferedMessages().length,
+          lastError: params.getLastError(),
+          bridgeMode: params.getBridgeMode(),
+          bridge: params.getBridgeStatus()
+        };
+      }
+      case "active-slug": {
+        return { ok: true, slug: params.getActiveSlug() };
+      }
+      case "close": {
+        params.shutdown();
+        return { ok: true };
+      }
+      default:
+        return { ok: false, error: `Unknown method: ${req.method}` };
+    }
+  };
+}
+
+// src/lib/live-daemon-ipc-server.ts
+import * as net from "net";
+function createDaemonIpcServer(handler) {
+  return net.createServer((conn) => {
+    let data = "";
+    conn.on("data", (chunk) => {
+      data += chunk.toString();
+      const newlineIdx = data.indexOf("\n");
+      if (newlineIdx === -1) return;
+      const line = data.slice(0, newlineIdx);
+      data = data.slice(newlineIdx + 1);
+      let request;
+      try {
+        request = JSON.parse(line);
+      } catch {
+        conn.write(`${JSON.stringify({ ok: false, error: "Invalid JSON" })}
+`);
+        return;
+      }
+      handler(request).then((response) => conn.write(`${JSON.stringify(response)}
+`)).catch((err) => conn.write(`${JSON.stringify({ ok: false, error: errorMessage(err) })}
+`));
+    });
+  });
+}
+
+// src/lib/live-prompt-content.ts
+var CANVAS_COMMAND_PROTOCOL_GUIDE_MARKDOWN = [
+  "## Canvas Command Channel",
+  "Use this when canvas UI interactions need local refetches, side effects, or rerunning local tools without regenerating the whole canvas.",
+  "",
+  "### Protocol",
+  "1. Put a command manifest in the HTML:",
+  "```html",
+  '<script type="application/pubblue-command-manifest+json">',
+  "{",
+  '  "manifestId": "mail-ui",',
+  '  "functions": [',
+  "    {",
+  '      "name": "archiveEmail",',
+  '      "returns": "void",',
+  '      "executor": {',
+  '        "kind": "exec",',
+  '        "command": "gog",',
+  '        "args": ["archive", "{{emailId}}"]',
+  "      }",
+  "    },",
+  "    {",
+  '      "name": "getEmail",',
+  '      "returns": "json",',
+  '      "executor": {',
+  '        "kind": "exec",',
+  '        "command": "gog",',
+  '        "args": ["get", "{{emailId}}", "--json"]',
+  "      }",
+  "    },",
+  "    {",
+  '      "name": "summarizeEmail",',
+  '      "returns": "text",',
+  '      "executor": {',
+  '        "kind": "agent",',
+  '        "prompt": "Summarize email {{emailId}}"',
+  "      }",
+  "    }",
+  "  ]",
+  "}",
+  "</script>",
+  "```",
+  "2. In canvas JS, call actions with `await pubblue.command(name, args)` or `await pubblue.commands.<name>(args)`.",
+  "3. Return semantics:",
+  '   - `returns: "void"` for side effects (resolves `null`).',
+  '   - `returns: "text" | "json"` for payload responses (promise resolves with value; errors reject).'
+].join("\n");
 
 // src/lib/live-daemon-shared.ts
 function buildBridgeInstructions(mode) {
-  if (mode === "claude-code") {
+  if (mode === "claude-code" || mode === "claude-sdk") {
     return {
-      replyHint: 'Reply by running: pubblue write "<your reply>"',
-      canvasHint: "Canvas update: pubblue write -c canvas -f /path/to/file.html",
+      replyHint: 'Reply command: pubblue write "<your reply>"',
+      canvasHint: "Canvas command: pubblue write -c canvas -f /path/to/file.html",
       systemPrompt: [
-        "You are in a live P2P session with a user.",
-        "The canvas is an iframe visible to the user alongside the chat.",
-        "Always `use pubblue write` for all communication with the user."
-      ].join("\n")
+        "You are in a live pub.blue session with a user.",
+        "The user sees chat and a canvas iframe.",
+        "Always communicate by running `pubblue write` commands.",
+        "Use canvas for output; use chat for short replies.",
+        "Canvas supports inline local calls for interactive visualizations that may require refetching data or rerunning local tools.",
+        "When needed, include command-manifest actions so browser interactions can call the daemon and receive results back in canvas.",
+        "Follow the Canvas Command Channel protocol from the session briefing exactly."
+      ].join("\n"),
+      commandProtocolGuide: CANVAS_COMMAND_PROTOCOL_GUIDE_MARKDOWN
     };
   }
   return {
-    replyHint: 'Reply by running: write "<your reply>"',
-    canvasHint: "Canvas update: write -c canvas -f /path/to/file.html",
-    systemPrompt: null
+    replyHint: 'Reply command: write "<your reply>"',
+    canvasHint: "Canvas command: write -c canvas -f /path/to/file.html",
+    systemPrompt: null,
+    commandProtocolGuide: CANVAS_COMMAND_PROTOCOL_GUIDE_MARKDOWN
   };
 }
 var OFFER_TIMEOUT_MS = 1e4;
-var SIGNAL_POLL_WAITING_MS = 5e3;
-var SIGNAL_POLL_CONNECTED_MS = 15e3;
 var LOCAL_CANDIDATE_FLUSH_MS = 2e3;
 var WRITE_ACK_TIMEOUT_MS = 5e3;
-var NOT_CONNECTED_WRITE_ERROR = "No browser connected. Ask the user to open the pub URL first, then retry.";
-function getLiveWriteReadinessError(isConnected) {
-  return isConnected ? null : NOT_CONNECTED_WRITE_ERROR;
+var PING_INTERVAL_MS = 1e4;
+var PONG_TIMEOUT_MS = 15e3;
+function getLiveWriteReadinessError(isReady) {
+  return isReady ? null : "Live session is not established yet. Wait for browser connect and initial context sync, then retry.";
 }
 function shouldRecoverForBrowserOfferChange(params) {
   const { incomingBrowserOffer, lastAppliedBrowserOffer } = params;
@@ -95,57 +981,250 @@ function shouldRecoverForBrowserOfferChange(params) {
   if (!lastAppliedBrowserOffer) return false;
   return incomingBrowserOffer !== lastAppliedBrowserOffer;
 }
-var MAX_CANVAS_PERSIST_SIZE = 100 * 1024;
-function getStickyCanvasHtml(stickyOutbound, canvasChannel) {
-  const msg = stickyOutbound.get(canvasChannel);
-  if (!msg) return null;
-  if (msg.type !== "html") return null;
-  const html = msg.data;
-  if (!html) return null;
-  if (new TextEncoder().encode(html).byteLength > MAX_CANVAS_PERSIST_SIZE) return null;
-  return html;
+
+// src/lib/live-daemon-signaling.ts
+import { ConvexClient } from "convex/browser";
+import { makeFunctionReference } from "convex/server";
+
+// src/lib/live-signaling.ts
+function decideSignalingUpdate(params) {
+  const { live, activeSlug, lastAppliedBrowserOffer, lastBrowserCandidateCount } = params;
+  if (!live) {
+    return { type: "noop", nextBrowserCandidateCount: lastBrowserCandidateCount };
+  }
+  if (live.browserOffer && !live.agentAnswer) {
+    const shouldRecover = !lastAppliedBrowserOffer || shouldRecoverForBrowserOfferChange({
+      incomingBrowserOffer: live.browserOffer,
+      lastAppliedBrowserOffer
+    });
+    if (shouldRecover) {
+      return {
+        type: "recover",
+        slug: live.slug,
+        browserOffer: live.browserOffer,
+        nextBrowserCandidateCount: 0
+      };
+    }
+    return { type: "noop", nextBrowserCandidateCount: lastBrowserCandidateCount };
+  }
+  if (live.browserOffer && live.agentAnswer && live.slug === activeSlug) {
+    if (live.browserCandidates.length > lastBrowserCandidateCount) {
+      return {
+        type: "apply-browser-candidates",
+        candidatePayloads: live.browserCandidates.slice(lastBrowserCandidateCount),
+        nextBrowserCandidateCount: live.browserCandidates.length
+      };
+    }
+  }
+  return { type: "noop", nextBrowserCandidateCount: lastBrowserCandidateCount };
 }
-function getSignalPollDelayMs(params) {
-  const baseDelay = params.hasActiveConnection ? SIGNAL_POLL_CONNECTED_MS : SIGNAL_POLL_WAITING_MS;
-  if (params.retryAfterSeconds === void 0) return baseDelay;
-  if (!Number.isFinite(params.retryAfterSeconds) || params.retryAfterSeconds <= 0) {
-    return baseDelay;
+
+// src/lib/live-daemon-signaling.ts
+var LIVE_SIGNAL_QUERY = makeFunctionReference("pubs:getLiveForAgentByApiKey");
+function parseLiveSnapshot(result) {
+  if (result === null || result === void 0) return null;
+  if (typeof result !== "object") {
+    throw new Error("Invalid signaling snapshot: expected object or null");
   }
-  return Math.max(baseDelay, Math.ceil(params.retryAfterSeconds * 1e3));
+  const live = result;
+  if (typeof live.slug !== "string") throw new Error("Invalid signaling snapshot: missing slug");
+  if (!Array.isArray(live.browserCandidates)) {
+    throw new Error("Invalid signaling snapshot: missing browserCandidates");
+  }
+  if (!Array.isArray(live.agentCandidates)) {
+    throw new Error("Invalid signaling snapshot: missing agentCandidates");
+  }
+  if (typeof live.createdAt !== "number") {
+    throw new Error("Invalid signaling snapshot: missing timestamps");
+  }
+  return {
+    slug: live.slug,
+    status: live.status,
+    browserOffer: live.browserOffer,
+    agentAnswer: live.agentAnswer,
+    browserCandidates: live.browserCandidates,
+    agentCandidates: live.agentCandidates,
+    createdAt: live.createdAt
+  };
+}
+function createSignalingController(params) {
+  const {
+    apiClient: apiClient2,
+    daemonSessionId,
+    debugLog,
+    markError,
+    isStopped,
+    getActiveSlug,
+    getLastAppliedBrowserOffer,
+    getLastBrowserCandidateCount,
+    setLastBrowserCandidateCount,
+    onRecover,
+    onApplyBrowserCandidates
+  } = params;
+  let signalingClient = null;
+  let signalingUnsubscribe = null;
+  let connectionStateUnsubscribe = null;
+  let signalingQueue = Promise.resolve();
+  let signalingConnectionKnown = false;
+  let signalingConnectionOpen = false;
+  function status() {
+    return { known: signalingConnectionKnown, open: signalingConnectionOpen };
+  }
+  function observeSignalingConnectionState(state) {
+    if (!signalingConnectionKnown) {
+      signalingConnectionKnown = true;
+      signalingConnectionOpen = state.isWebSocketConnected;
+      debugLog(
+        `signaling websocket initial state: ${state.isWebSocketConnected ? "connected" : "disconnected"}`
+      );
+      return;
+    }
+    if (state.isWebSocketConnected !== signalingConnectionOpen) {
+      signalingConnectionOpen = state.isWebSocketConnected;
+      if (state.isWebSocketConnected) {
+        debugLog("signaling websocket reconnected");
+      } else {
+        markError(
+          `signaling websocket disconnected (retries=${state.connectionRetries}, connections=${state.connectionCount})`
+        );
+      }
+    }
+  }
+  async function handleSignalingSnapshot(live) {
+    const decision = decideSignalingUpdate({
+      live,
+      activeSlug: getActiveSlug(),
+      lastAppliedBrowserOffer: getLastAppliedBrowserOffer(),
+      lastBrowserCandidateCount: getLastBrowserCandidateCount()
+    });
+    setLastBrowserCandidateCount(decision.nextBrowserCandidateCount);
+    if (decision.type === "recover") {
+      await onRecover(decision.slug, decision.browserOffer);
+      return;
+    }
+    if (decision.type === "apply-browser-candidates") {
+      await onApplyBrowserCandidates(decision.candidatePayloads);
+    }
+  }
+  function enqueueSignalingSnapshot(live) {
+    signalingQueue = signalingQueue.then(async () => {
+      if (isStopped()) return;
+      await handleSignalingSnapshot(live);
+    }).catch((error) => {
+      markError("failed to process signaling snapshot", error);
+    });
+  }
+  function start() {
+    if (signalingClient) return;
+    signalingClient = new ConvexClient(apiClient2.getConvexCloudUrl(), {
+      onServerDisconnectError: (message) => {
+        markError(`signaling server disconnect: ${message}`);
+      }
+    });
+    connectionStateUnsubscribe = signalingClient.subscribeToConnectionState((state) => {
+      observeSignalingConnectionState({
+        isWebSocketConnected: state.isWebSocketConnected,
+        connectionCount: state.connectionCount,
+        connectionRetries: state.connectionRetries
+      });
+    });
+    const unsubscribe = signalingClient.onUpdate(
+      LIVE_SIGNAL_QUERY,
+      { apiKey: apiClient2.getApiKey(), daemonSessionId },
+      (result) => {
+        let live;
+        try {
+          live = parseLiveSnapshot(result);
+        } catch (error) {
+          markError("received malformed signaling snapshot", error);
+          return;
+        }
+        enqueueSignalingSnapshot(live);
+      },
+      (error) => {
+        markError("signaling subscription failed", error);
+      }
+    );
+    signalingUnsubscribe = () => unsubscribe();
+  }
+  async function stop() {
+    if (signalingUnsubscribe) {
+      signalingUnsubscribe();
+      signalingUnsubscribe = null;
+    }
+    if (connectionStateUnsubscribe) {
+      connectionStateUnsubscribe();
+      connectionStateUnsubscribe = null;
+    }
+    if (signalingClient) {
+      await signalingClient.close().catch((error) => {
+        debugLog("failed to close signaling client cleanly", error);
+      });
+      signalingClient = null;
+    }
+    signalingConnectionKnown = false;
+    signalingConnectionOpen = false;
+  }
+  return {
+    start,
+    stop,
+    status
+  };
 }
 
 // src/lib/live-daemon.ts
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var HEALTH_CHECK_INTERVAL_MS = 60 * 60 * 1e3;
-var PERSIST_TIMEOUT_MS = 3e3;
+var OUTBOUND_SEND_MAX_ATTEMPTS = 2;
+var MAX_SEEN_INBOUND_MESSAGES = 1e4;
+var MAX_BUFFERED_MESSAGES = 200;
 async function startDaemon(config) {
   const { apiClient: apiClient2, socketPath: socketPath2, infoPath: infoPath2, cliVersion: cliVersion2, agentName: agentName2 } = config;
   const ndc = await import("node-datachannel");
   const buffer = { messages: [] };
   const startTime = Date.now();
+  const daemonSessionId = randomUUID();
   let stopped = false;
-  let connected = false;
+  let browserConnected = false;
+  let bridgePrimed = false;
+  let bridgePriming = null;
+  let bridgeAbort = null;
   let recovering = false;
   let activeSlug = null;
   let lastAppliedBrowserOffer = null;
   let lastBrowserCandidateCount = 0;
   let lastSentCandidateCount = 0;
   const localCandidates = [];
-  const stickyOutboundByChannel = /* @__PURE__ */ new Map();
   const pendingOutboundAcks = /* @__PURE__ */ new Map();
   const pendingDeliveryAcks = /* @__PURE__ */ new Map();
   let peer = null;
   let channels = /* @__PURE__ */ new Map();
   let pendingInboundBinaryMeta = /* @__PURE__ */ new Map();
-  let pollingTimer = null;
+  let inboundStreams = /* @__PURE__ */ new Map();
+  let seenInboundMessageKeys = /* @__PURE__ */ new Set();
+  let commandProcessingQueue = Promise.resolve();
   let heartbeatTimer = null;
   let localCandidateInterval = null;
   let localCandidateStopTimer = null;
   let healthCheckTimer = null;
+  let pingTimer = null;
+  let pongTimeout = null;
   let lastError = null;
   const debugEnabled = process.env.PUBBLUE_LIVE_DEBUG === "1";
   const versionFilePath = latestCliVersionPath();
   let bridgeRunner = null;
+  const commandHandler = createLiveCommandHandler({
+    bridgeMode: config.bridgeMode,
+    debugLog: (message, error) => debugLog(message, error),
+    markError,
+    sendCommandMessage: async (msg) => {
+      if (!isLiveConnected()) return false;
+      return sendOutboundMessageWithAck(CHANNELS.COMMAND, msg, {
+        context: 'command outbound on "command"',
+        maxAttempts: OUTBOUND_SEND_MAX_ATTEMPTS
+      });
+    }
+  });
   function debugLog(message, error) {
     if (!debugEnabled) return;
     const detail = error === void 0 ? "" : ` | ${error instanceof Error ? `${error.name}: ${error.message}` : typeof error === "string" ? error : JSON.stringify(error)}`;
@@ -155,11 +1234,8 @@ async function startDaemon(config) {
     lastError = error === void 0 ? message : `${message}: ${errorMessage(error)}`;
     debugLog(message, error);
   }
-  function clearPollingTimer() {
-    if (pollingTimer) {
-      clearTimeout(pollingTimer);
-      pollingTimer = null;
-    }
+  function isLiveConnected() {
+    return browserConnected && bridgePrimed;
   }
   function clearLocalCandidateTimers() {
     if (localCandidateInterval) {
@@ -183,13 +1259,49 @@ async function startDaemon(config) {
       heartbeatTimer = null;
     }
   }
+  function startPingPong() {
+    stopPingPong();
+    pingTimer = setInterval(() => {
+      if (!browserConnected || stopped) {
+        stopPingPong();
+        return;
+      }
+      const controlDc = channels.get(CONTROL_CHANNEL);
+      if (!controlDc) return;
+      try {
+        controlDc.sendMessage(encodeMessage(makeEventMessage("ping")));
+        if (pongTimeout) clearTimeout(pongTimeout);
+        pongTimeout = setTimeout(() => {
+          if (!browserConnected || stopped) return;
+          debugLog("pong timeout \u2014 treating as disconnected");
+          handleConnectionClosed("pong-timeout");
+        }, PONG_TIMEOUT_MS);
+      } catch (error) {
+        debugLog("ping send failed", error);
+      }
+    }, PING_INTERVAL_MS);
+  }
+  function stopPingPong() {
+    if (pingTimer) {
+      clearInterval(pingTimer);
+      pingTimer = null;
+    }
+    if (pongTimeout) {
+      clearTimeout(pongTimeout);
+      pongTimeout = null;
+    }
+  }
   function runHealthCheck() {
     if (stopped) return;
     if (cliVersion2) {
-      const latest = readLatestCliVersion(versionFilePath);
-      if (latest && latest !== cliVersion2) {
-        markError(`detected CLI upgrade (${cliVersion2} \u2192 ${latest}); shutting down`);
-        void shutdown();
+      try {
+        const latest = readLatestCliVersion(versionFilePath);
+        if (latest && latest !== cliVersion2) {
+          markError(`detected CLI upgrade (${cliVersion2} \u2192 ${latest}); shutting down`);
+          void shutdown();
+        }
+      } catch (error) {
+        markError("health check failed to read latest CLI version", error);
       }
     }
   }
@@ -198,20 +1310,109 @@ async function startDaemon(config) {
     healthCheckTimer = setInterval(runHealthCheck, HEALTH_CHECK_INTERVAL_MS);
     runHealthCheck();
   }
+  function appendBufferedMessage(entry) {
+    if (entry.channel === CHANNELS.CANVAS || entry.channel === CHANNELS.COMMAND) return;
+    buffer.messages.push(entry);
+    if (buffer.messages.length > MAX_BUFFERED_MESSAGES) {
+      buffer.messages.splice(0, buffer.messages.length - MAX_BUFFERED_MESSAGES);
+    }
+  }
+  function handleConnectionClosed(reason) {
+    debugLog(`connection closed: ${reason}`);
+    const hadConnection = browserConnected || bridgePrimed;
+    browserConnected = false;
+    bridgePrimed = false;
+    bridgePriming = null;
+    if (bridgeAbort) {
+      bridgeAbort.abort();
+      bridgeAbort = null;
+    }
+    if (!hadConnection) return;
+    buffer.messages = [];
+    failPendingAcks();
+    stopPingPong();
+  }
+  function emitDeliveryStatus(params) {
+    if (!params.messageId || params.channel === CONTROL_CHANNEL) return;
+    const controlDc = channels.get(CONTROL_CHANNEL);
+    const messageDc = channels.get(params.channel);
+    const encoded = encodeMessage(
+      makeDeliveryReceiptMessage({
+        messageId: params.messageId,
+        channel: params.channel,
+        stage: params.stage,
+        error: params.error
+      })
+    );
+    try {
+      if (controlDc?.isOpen()) {
+        controlDc.sendMessage(encoded);
+        return;
+      }
+      if (messageDc?.isOpen()) {
+        messageDc.sendMessage(encoded);
+      }
+    } catch (error) {
+      debugLog("failed to emit delivery status", error);
+    }
+  }
   function setupChannel(name, dc) {
     channels.set(name, dc);
     dc.onOpen(() => {
       if (name === CONTROL_CHANNEL) flushQueuedAcks();
     });
+    dc.onClosed(() => {
+      channels.delete(name);
+      pendingInboundBinaryMeta.delete(name);
+      inboundStreams.delete(name);
+      debugLog(`datachannel "${name}" closed`);
+    });
+    dc.onError((err) => {
+      debugLog(`datachannel "${name}" error: ${err}`);
+    });
     dc.onMessage((data) => {
       if (typeof data === "string") {
         const msg = decodeMessage(data);
         if (!msg) return;
         const ack = parseAckMessage(msg);
         if (ack) {
-          settlePendingAck(ack.messageId, true);
+          settlePendingAck(ack.messageId, ack.channel, true);
           return;
         }
+        if (msg.type === "event" && msg.data === "pong") {
+          if (pongTimeout) {
+            clearTimeout(pongTimeout);
+            pongTimeout = null;
+          }
+          return;
+        }
+        const duplicate = isDuplicateInboundMessage(name, msg.id);
+        if (duplicate) {
+          if (msg.type === "binary" && !msg.data) {
+            pendingInboundBinaryMeta.set(name, msg);
+            return;
+          }
+          if (shouldAcknowledgeMessage(name, msg)) {
+            queueAck(msg.id, name);
+          }
+          return;
+        }
+        if (msg.type === "stream-start") {
+          inboundStreams.set(name, { streamId: msg.id });
+        }
+        if (msg.type === "stream-end") {
+          const stream = inboundStreams.get(name);
+          const requestedStreamId = typeof msg.meta?.streamId === "string" ? msg.meta.streamId : void 0;
+          if (!stream) {
+          } else if (!requestedStreamId || requestedStreamId === stream.streamId) {
+            emitDeliveryStatus({
+              channel: name,
+              messageId: stream.streamId,
+              stage: "received"
+            });
+            inboundStreams.delete(name);
+          }
+        }
         if (msg.type === "binary" && !msg.data) {
           pendingInboundBinaryMeta.set(name, msg);
           return;
@@ -219,33 +1420,71 @@ async function startDaemon(config) {
         if (shouldAcknowledgeMessage(name, msg)) {
           queueAck(msg.id, name);
         }
-        buffer.messages.push({ channel: name, msg, timestamp: Date.now() });
+        if (name === CHANNELS.COMMAND) {
+          commandProcessingQueue = commandProcessingQueue.then(() => commandHandler.onMessage(msg)).catch((error) => {
+            markError("command message processing failed", error);
+          });
+          return;
+        }
+        appendBufferedMessage({ channel: name, msg, timestamp: Date.now() });
         bridgeRunner?.enqueue([{ channel: name, msg }]);
+        if (name !== CONTROL_CHANNEL && (msg.type === "text" || msg.type === "html" || msg.type === "binary" && !!msg.data)) {
+          emitDeliveryStatus({ channel: name, messageId: msg.id, stage: "received" });
+        }
         return;
       }
       const pendingMeta = pendingInboundBinaryMeta.get(name);
+      const activeStream = inboundStreams.get(name);
       if (pendingMeta) pendingInboundBinaryMeta.delete(name);
+      if (name === CHANNELS.COMMAND) {
+        return;
+      }
       const binMsg = pendingMeta ? {
         id: pendingMeta.id,
         type: "binary",
         data: data.toString("base64"),
-        meta: { ...pendingMeta.meta, size: data.length }
+        meta: {
+          ...pendingMeta.meta,
+          ...activeStream ? { streamId: activeStream.streamId } : {},
+          size: data.length
+        }
       } : {
         id: `bin-${Date.now()}`,
         type: "binary",
         data: data.toString("base64"),
-        meta: { size: data.length }
+        meta: {
+          ...activeStream ? { streamId: activeStream.streamId } : {},
+          size: data.length
+        }
       };
+      if (isDuplicateInboundMessage(name, binMsg.id)) {
+        if (shouldAcknowledgeMessage(name, binMsg)) {
+          queueAck(binMsg.id, name);
+        }
+        return;
+      }
       if (shouldAcknowledgeMessage(name, binMsg)) {
         queueAck(binMsg.id, name);
       }
-      buffer.messages.push({ channel: name, msg: binMsg, timestamp: Date.now() });
+      appendBufferedMessage({ channel: name, msg: binMsg, timestamp: Date.now() });
       bridgeRunner?.enqueue([{ channel: name, msg: binMsg }]);
+      if (!activeStream) {
+        emitDeliveryStatus({ channel: name, messageId: binMsg.id, stage: "received" });
+      }
     });
   }
   function getAckKey(messageId, channel) {
     return `${channel}:${messageId}`;
   }
+  function isDuplicateInboundMessage(channel, messageId) {
+    const key = `${channel}:${messageId}`;
+    if (seenInboundMessageKeys.has(key)) return true;
+    seenInboundMessageKeys.add(key);
+    if (seenInboundMessageKeys.size > MAX_SEEN_INBOUND_MESSAGES) {
+      seenInboundMessageKeys.clear();
+    }
+    return false;
+  }
   function queueAck(messageId, channel) {
     pendingOutboundAcks.set(getAckKey(messageId, channel), { messageId, channel });
     flushQueuedAcks();
@@ -283,27 +1522,34 @@ async function startDaemon(config) {
       }
     }
   }
-  function waitForDeliveryAck(messageId, timeoutMs) {
+  function waitForDeliveryAck(messageId, channel, timeoutMs) {
     return new Promise((resolve) => {
+      const key = getAckKey(messageId, channel);
+      const existing = pendingDeliveryAcks.get(key);
+      if (existing) {
+        clearTimeout(existing.timeout);
+        pendingDeliveryAcks.delete(key);
+      }
       const timeout = setTimeout(() => {
-        pendingDeliveryAcks.delete(messageId);
+        pendingDeliveryAcks.delete(key);
         resolve(false);
       }, timeoutMs);
-      pendingDeliveryAcks.set(messageId, { resolve, timeout });
+      pendingDeliveryAcks.set(key, { resolve, timeout });
     });
   }
-  function settlePendingAck(messageId, received) {
-    const pending = pendingDeliveryAcks.get(messageId);
+  function settlePendingAck(messageId, channel, received) {
+    const key = getAckKey(messageId, channel);
+    const pending = pendingDeliveryAcks.get(key);
     if (!pending) return;
     clearTimeout(pending.timeout);
-    pendingDeliveryAcks.delete(messageId);
+    pendingDeliveryAcks.delete(key);
     pending.resolve(received);
   }
   function failPendingAcks() {
-    for (const [messageId, pending] of pendingDeliveryAcks) {
+    for (const [ackKey, pending] of pendingDeliveryAcks) {
       clearTimeout(pending.timeout);
       pending.resolve(false);
-      pendingDeliveryAcks.delete(messageId);
+      pendingDeliveryAcks.delete(ackKey);
     }
   }
   function openDataChannel(name) {
@@ -331,30 +1577,45 @@ async function startDaemon(config) {
       });
     });
   }
-  function maybePersistStickyOutbound(channel, msg) {
-    if (channel !== CHANNELS.CANVAS) return;
-    if (msg.type === "event" && msg.data === "hide") {
-      stickyOutboundByChannel.delete(channel);
-      return;
-    }
-    if (msg.type !== "html") return;
-    stickyOutboundByChannel.set(channel, {
-      ...msg,
-      meta: msg.meta ? { ...msg.meta } : void 0
-    });
-  }
-  async function replayStickyOutboundMessages() {
-    if (!connected || recovering || stopped) return;
-    for (const [channel, msg] of stickyOutboundByChannel) {
+  async function sendOutboundMessageWithAck(channel, msg, options) {
+    const maxAttempts = options?.maxAttempts ?? OUTBOUND_SEND_MAX_ATTEMPTS;
+    const context = options?.context ?? `channel "${channel}"`;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      if (stopped || !browserConnected) return false;
+      let targetDc;
       try {
-        let targetDc = channels.get(channel);
-        if (!targetDc) targetDc = openDataChannel(channel);
-        await waitForChannelOpen(targetDc, 3e3);
-        targetDc.sendMessage(encodeMessage(msg));
+        targetDc = channels.get(channel) ?? openDataChannel(channel);
+        await waitForChannelOpen(targetDc);
       } catch (error) {
-        debugLog(`sticky outbound replay failed for channel ${channel}`, error);
+        markError(`${context} failed to open (attempt ${attempt}/${maxAttempts})`, error);
+        continue;
       }
+      const waitForAck = shouldAcknowledgeMessage(channel, msg) ? waitForDeliveryAck(msg.id, channel, WRITE_ACK_TIMEOUT_MS) : null;
+      try {
+        if (msg.type === "binary" && options?.binaryPayload) {
+          targetDc.sendMessage(
+            encodeMessage({
+              ...msg,
+              meta: { ...msg.meta || {}, size: options.binaryPayload.length }
+            })
+          );
+          targetDc.sendMessageBinary(options.binaryPayload);
+        } else {
+          targetDc.sendMessage(encodeMessage(msg));
+        }
+      } catch (error) {
+        if (waitForAck) settlePendingAck(msg.id, channel, false);
+        markError(`${context} failed to send (attempt ${attempt}/${maxAttempts})`, error);
+        continue;
+      }
+      if (!waitForAck) return true;
+      const acked = await waitForAck;
+      if (acked) return true;
+      markError(
+        `${context} delivery ack timeout for message ${msg.id} (attempt ${attempt}/${maxAttempts})`
+      );
     }
+    return false;
   }
   function attachPeerHandlers(currentPeer) {
     currentPeer.onLocalCandidate((candidate, mid) => {
@@ -364,15 +1625,21 @@ async function startDaemon(config) {
     currentPeer.onStateChange((state) => {
       if (stopped || currentPeer !== peer) return;
       if (state === "connected") {
-        connected = true;
+        browserConnected = true;
         flushQueuedAcks();
-        void replayStickyOutboundMessages();
+        startPingPong();
+        void ensureBridgePrimed();
         return;
       }
       if (state === "disconnected" || state === "failed" || state === "closed") {
-        const wasConnected = connected;
-        connected = false;
-        if (wasConnected) void persistCanvasContent();
+        handleConnectionClosed(`peer-state:${state}`);
+      }
+    });
+    currentPeer.onIceStateChange((state) => {
+      if (stopped || currentPeer !== peer) return;
+      debugLog(`ICE state: ${state}`);
+      if ((state === "disconnected" || state === "failed") && browserConnected) {
+        handleConnectionClosed(`ice-state:${state}`);
       }
     });
     currentPeer.onDataChannel((dc) => {
@@ -387,6 +1654,8 @@ async function startDaemon(config) {
     peer = nextPeer;
     channels = /* @__PURE__ */ new Map();
     pendingInboundBinaryMeta = /* @__PURE__ */ new Map();
+    inboundStreams = /* @__PURE__ */ new Map();
+    seenInboundMessageKeys = /* @__PURE__ */ new Set();
     attachPeerHandlers(nextPeer);
   }
   function closeCurrentPeer() {
@@ -400,6 +1669,8 @@ async function startDaemon(config) {
     }
     channels.clear();
     pendingInboundBinaryMeta.clear();
+    inboundStreams.clear();
+    seenInboundMessageKeys.clear();
     if (peer) {
       try {
         peer.close();
@@ -410,13 +1681,19 @@ async function startDaemon(config) {
     }
   }
   function resetNegotiationState() {
-    connected = false;
+    browserConnected = false;
+    bridgePrimed = false;
+    bridgePriming = null;
+    buffer.messages = [];
     failPendingAcks();
+    stopPingPong();
     lastAppliedBrowserOffer = null;
     lastBrowserCandidateCount = 0;
     lastSentCandidateCount = 0;
     localCandidates.length = 0;
     clearLocalCandidateTimers();
+    inboundStreams.clear();
+    seenInboundMessageKeys.clear();
   }
   function startLocalCandidateFlush(slug) {
     clearLocalCandidateTimers();
@@ -424,7 +1701,7 @@ async function startDaemon(config) {
       if (localCandidates.length <= lastSentCandidateCount) return;
       const newOnes = localCandidates.slice(lastSentCandidateCount);
       lastSentCandidateCount = localCandidates.length;
-      await apiClient2.signalAnswer({ slug, candidates: newOnes }).catch((error) => {
+      await apiClient2.signalAnswer({ slug, daemonSessionId, candidates: newOnes }).catch((error) => {
         debugLog("failed to publish local ICE candidates", error);
       });
     }, LOCAL_CANDIDATE_FLUSH_MS);
@@ -436,7 +1713,6 @@ async function startDaemon(config) {
     if (recovering) return;
     recovering = true;
     try {
-      await persistCanvasContent();
       await stopBridge();
       closeCurrentPeer();
       createPeer();
@@ -445,71 +1721,42 @@ async function startDaemon(config) {
       const answer = await createAnswer(peer, browserOffer, OFFER_TIMEOUT_MS);
       lastAppliedBrowserOffer = browserOffer;
       activeSlug = slug;
-      await apiClient2.signalAnswer({ slug, answer, agentName: agentName2 });
+      await apiClient2.signalAnswer({ slug, daemonSessionId, answer, agentName: agentName2 });
       startLocalCandidateFlush(slug);
-      void startBridge();
     } catch (error) {
       markError("failed to handle incoming live request", error);
     } finally {
       recovering = false;
     }
   }
-  function scheduleNextPoll(delayMs) {
-    if (stopped) return;
-    clearPollingTimer();
-    pollingTimer = setTimeout(() => {
-      void runPollingLoop();
-    }, delayMs);
-  }
-  async function pollSignalingOnce() {
-    const live = await apiClient2.getPendingLive();
-    if (!live) {
-      return;
-    }
-    if (live.browserOffer && !live.agentAnswer) {
-      if (shouldRecoverForBrowserOfferChange({
-        incomingBrowserOffer: live.browserOffer,
-        lastAppliedBrowserOffer
-      }) || !lastAppliedBrowserOffer) {
-        await handleIncomingLive(live.slug, live.browserOffer);
-        return;
-      }
-    }
-    if (live.browserOffer && live.agentAnswer && live.slug === activeSlug) {
-      if (live.browserCandidates.length > lastBrowserCandidateCount) {
-        const newCandidates = live.browserCandidates.slice(lastBrowserCandidateCount);
-        lastBrowserCandidateCount = live.browserCandidates.length;
-        for (const c of newCandidates) {
-          try {
-            const parsed = JSON.parse(c);
-            if (typeof parsed.candidate !== "string") continue;
-            const sdpMid = typeof parsed.sdpMid === "string" ? parsed.sdpMid : "0";
-            if (!peer) continue;
-            peer.addRemoteCandidate(parsed.candidate, sdpMid);
-          } catch (error) {
-            debugLog("failed to parse/apply browser ICE candidate", error);
-          }
-        }
-      }
-    }
-  }
-  async function runPollingLoop() {
-    if (stopped) return;
-    let retryAfterSeconds;
-    try {
-      await pollSignalingOnce();
-    } catch (error) {
-      if (error instanceof PubApiError && error.status === 429) {
-        retryAfterSeconds = error.retryAfterSeconds;
+  async function applyBrowserCandidates(candidatePayloads) {
+    for (const c of candidatePayloads) {
+      try {
+        const parsed = JSON.parse(c);
+        if (typeof parsed.candidate !== "string") continue;
+        const sdpMid = typeof parsed.sdpMid === "string" ? parsed.sdpMid : "0";
+        if (!peer) continue;
+        peer.addRemoteCandidate(parsed.candidate, sdpMid);
+      } catch (error) {
+        debugLog("failed to parse/apply browser ICE candidate", error);
       }
-      markError("signaling poll failed", error);
     }
-    const baseDelay = getSignalPollDelayMs({
-      hasActiveConnection: connected,
-      retryAfterSeconds
-    });
-    scheduleNextPoll(baseDelay);
   }
+  const signaling = createSignalingController({
+    apiClient: apiClient2,
+    daemonSessionId,
+    debugLog,
+    markError,
+    isStopped: () => stopped,
+    getActiveSlug: () => activeSlug,
+    getLastAppliedBrowserOffer: () => lastAppliedBrowserOffer,
+    getLastBrowserCandidateCount: () => lastBrowserCandidateCount,
+    setLastBrowserCandidateCount: (count) => {
+      lastBrowserCandidateCount = count;
+    },
+    onRecover: handleIncomingLive,
+    onApplyBrowserCandidates: applyBrowserCandidates
+  });
   if (fs.existsSync(socketPath2)) {
     let stale = true;
     try {
@@ -530,36 +1777,46 @@ async function startDaemon(config) {
       throw new Error(`Daemon already running (socket: ${socketPath2})`);
     }
   }
-  await apiClient2.goOnline();
+  await apiClient2.goOnline({ daemonSessionId, agentName: agentName2 });
   heartbeatTimer = setInterval(async () => {
     if (stopped) return;
     try {
-      await apiClient2.heartbeat();
+      await apiClient2.heartbeat({ daemonSessionId });
     } catch (error) {
       markError("heartbeat failed", error);
     }
   }, HEARTBEAT_INTERVAL_MS);
-  const ipcServer = net.createServer((conn) => {
-    let data = "";
-    conn.on("data", (chunk) => {
-      data += chunk.toString();
-      const newlineIdx = data.indexOf("\n");
-      if (newlineIdx === -1) return;
-      const line = data.slice(0, newlineIdx);
-      data = data.slice(newlineIdx + 1);
-      let request;
-      try {
-        request = JSON.parse(line);
-      } catch {
-        conn.write(`${JSON.stringify({ ok: false, error: "Invalid JSON" })}
-`);
-        return;
-      }
-      handleIpcRequest(request).then((response) => conn.write(`${JSON.stringify(response)}
-`)).catch((err) => conn.write(`${JSON.stringify({ ok: false, error: errorMessage(err) })}
-`));
-    });
+  const handleIpcRequest = createDaemonIpcHandler({
+    apiClient: apiClient2,
+    bindCanvasCommands: (html) => commandHandler.bindFromHtml(html),
+    getConnected: () => isLiveConnected(),
+    getSignalingConnected: () => {
+      const state = signaling.status();
+      return state.known ? state.open : null;
+    },
+    getActiveSlug: () => activeSlug,
+    getUptimeSeconds: () => Math.floor((Date.now() - startTime) / 1e3),
+    getChannels: () => [...channels.keys()],
+    getBufferedMessages: () => buffer.messages,
+    setBufferedMessages: (messages) => {
+      buffer.messages = messages;
+    },
+    getLastError: () => lastError,
+    getBridgeMode: () => config.bridgeMode ?? null,
+    getBridgeStatus: () => bridgeRunner?.status() ?? null,
+    getWriteReadinessError: () => getLiveWriteReadinessError(isLiveConnected()),
+    openDataChannel,
+    waitForChannelOpen,
+    waitForDeliveryAck,
+    settlePendingAck,
+    markError,
+    shutdown: () => {
+      void shutdown();
+    },
+    writeAckTimeoutMs: WRITE_ACK_TIMEOUT_MS,
+    writeAckMaxAttempts: OUTBOUND_SEND_MAX_ATTEMPTS
   });
+  const ipcServer = createDaemonIpcServer(handleIpcRequest);
   ipcServer.listen(socketPath2);
   const infoDir = path.dirname(infoPath2);
   if (!fs.existsSync(infoDir)) fs.mkdirSync(infoDir, { recursive: true });
@@ -568,74 +1825,115 @@ async function startDaemon(config) {
     JSON.stringify({ pid: process.pid, socketPath: socketPath2, startedAt: startTime, cliVersion: cliVersion2 })
   );
   startHealthCheckTimer();
-  scheduleNextPoll(0);
-  function sendOnChannel(channel, msg) {
-    if (stopped || !connected) return;
-    let targetDc = channels.get(channel);
-    if (!targetDc) {
-      try {
-        targetDc = openDataChannel(channel);
-      } catch (error) {
-        debugLog(`bridge sendOnChannel: failed to open channel ${channel}`, error);
-        return;
-      }
-    }
-    try {
-      if (targetDc.isOpen()) {
-        targetDc.sendMessage(encodeMessage(msg));
-      }
-    } catch (error) {
-      debugLog(`bridge sendOnChannel failed for ${channel}`, error);
+  signaling.start();
+  async function sendOnChannel(channel, msg) {
+    if (stopped || !isLiveConnected()) return false;
+    return sendOutboundMessageWithAck(channel, msg, {
+      context: `bridge outbound on "${channel}"`,
+      maxAttempts: OUTBOUND_SEND_MAX_ATTEMPTS
+    });
+  }
+  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,
+      content
+    }) : void 0;
+    return buildSessionBriefing(
+      params.slug,
+      {
+        title: pub.title,
+        contentType: pub.contentType,
+        isPublic: pub.isPublic,
+        canvasContentFilePath
+      },
+      params.instructions
+    );
   }
-  async function startBridge() {
-    if (stopped || !activeSlug) return;
-    if (!config.bridgeMode) return;
+  async function startBridge(slug) {
+    if (stopped) return;
+    if (!config.bridgeMode) {
+      throw new Error("Bridge mode is required for live session bootstrap.");
+    }
+    if (activeSlug !== slug) return;
     await stopBridge();
+    const abort = new AbortController();
+    bridgeAbort = abort;
     const instructions = buildBridgeInstructions(config.bridgeMode);
-    const bridgeConfig = { slug: activeSlug, sendMessage: sendOnChannel, debugLog, instructions };
-    try {
-      bridgeRunner = config.bridgeMode === "claude-code" ? await createClaudeCodeBridgeRunner(bridgeConfig) : await createOpenClawBridgeRunner(bridgeConfig);
-    } catch (error) {
-      markError("bridge runner failed to start", error);
+    const sessionBriefing = await buildInitialSessionBriefing({ slug, instructions });
+    const bridgeConfig = {
+      slug,
+      sessionBriefing,
+      sendMessage: sendOnChannel,
+      onDeliveryUpdate: ({
+        channel,
+        messageId,
+        stage,
+        error
+      }) => {
+        emitDeliveryStatus({ channel, messageId, stage, error });
+      },
+      debugLog,
+      instructions
+    };
+    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;
     }
+    bridgeRunner = runner;
+  }
+  async function ensureBridgePrimed() {
+    if (stopped || !browserConnected || bridgePrimed || bridgePriming || !activeSlug) return;
+    const slug = activeSlug;
+    const primePromise = (async () => {
+      try {
+        await startBridge(slug);
+        if (stopped || !browserConnected || activeSlug !== slug) return;
+        bridgePrimed = true;
+        debugLog(`bridge primed for "${slug}"`);
+      } catch (error) {
+        bridgePrimed = false;
+        markError(`failed to prime bridge session for "${slug}"`, error);
+      } finally {
+        bridgePriming = null;
+      }
+    })();
+    bridgePriming = primePromise;
+    await primePromise;
   }
   async function stopBridge() {
+    bridgePrimed = false;
+    bridgePriming = null;
+    if (bridgeAbort) {
+      bridgeAbort.abort();
+      bridgeAbort = null;
+    }
     if (bridgeRunner) {
       await bridgeRunner.stop();
       bridgeRunner = null;
     }
   }
-  async function persistCanvasContent() {
-    if (!activeSlug) return;
-    const html = getStickyCanvasHtml(stickyOutboundByChannel, CHANNELS.CANVAS);
-    if (!html) return;
-    try {
-      const timeout = new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("persist timeout")), PERSIST_TIMEOUT_MS)
-      );
-      await Promise.race([
-        apiClient2.update({ slug: activeSlug, content: html, filename: "canvas.html" }),
-        timeout
-      ]);
-    } catch (error) {
-      debugLog("failed to persist canvas content", error);
-    }
-  }
   async function cleanup() {
     if (stopped) return;
     stopped = true;
-    clearPollingTimer();
     clearLocalCandidateTimers();
     clearHealthCheckTimer();
     clearHeartbeatTimer();
+    stopPingPong();
+    await signaling.stop();
     try {
-      await apiClient2.goOffline();
+      await apiClient2.goOffline({ daemonSessionId });
     } catch (error) {
       debugLog("failed to go offline", error);
     }
-    await persistCanvasContent();
     await stopBridge();
+    commandHandler.stop();
     closeCurrentPeer();
     ipcServer.close();
     try {
@@ -649,107 +1947,27 @@ async function startDaemon(config) {
       debugLog("failed to remove daemon info file during cleanup", error);
     }
   }
-  async function shutdown() {
+  let shuttingDown = false;
+  async function shutdown(exitCode = 0) {
+    if (shuttingDown) return;
+    shuttingDown = true;
     await cleanup();
-    process.exit(0);
+    process.exit(exitCode);
   }
   process.on("SIGTERM", () => {
-    void shutdown();
+    void shutdown(0);
   });
   process.on("SIGINT", () => {
-    void shutdown();
+    void shutdown(0);
+  });
+  process.on("uncaughtException", (error) => {
+    markError("uncaught exception in daemon", error);
+    void shutdown(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    markError("unhandled rejection in daemon", reason);
+    void shutdown(1);
   });
-  async function handleIpcRequest(req) {
-    switch (req.method) {
-      case "write": {
-        const channel = req.params.channel || CHANNELS.CHAT;
-        const readinessError = getLiveWriteReadinessError(connected);
-        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;
-        let targetDc = channels.get(channel);
-        if (!targetDc) targetDc = openDataChannel(channel);
-        try {
-          await waitForChannelOpen(targetDc);
-        } catch (error) {
-          markError(`channel "${channel}" failed to open`, error);
-          return { ok: false, error: `Channel "${channel}" not open: ${errorMessage(error)}` };
-        }
-        const waitForAck = shouldAcknowledgeMessage(channel, msg) ? waitForDeliveryAck(msg.id, WRITE_ACK_TIMEOUT_MS) : null;
-        try {
-          if (msg.type === "binary" && binaryPayload) {
-            targetDc.sendMessage(
-              encodeMessage({
-                ...msg,
-                meta: { ...msg.meta || {}, size: binaryPayload.length }
-              })
-            );
-            targetDc.sendMessageBinary(binaryPayload);
-          } else {
-            targetDc.sendMessage(encodeMessage(msg));
-          }
-        } catch (error) {
-          if (waitForAck) settlePendingAck(msg.id, false);
-          markError(`failed to send message on channel "${channel}"`, error);
-          return {
-            ok: false,
-            error: `Failed to send on channel "${channel}": ${errorMessage(error)}`
-          };
-        }
-        if (waitForAck) {
-          const acked = await waitForAck;
-          if (!acked) {
-            markError(`delivery ack timeout for message ${msg.id}`);
-            return {
-              ok: false,
-              error: `Delivery not confirmed for message ${msg.id} within ${WRITE_ACK_TIMEOUT_MS}ms.`
-            };
-          }
-        }
-        maybePersistStickyOutbound(channel, msg);
-        return { ok: true, delivered: true };
-      }
-      case "read": {
-        const channel = req.params.channel;
-        let msgs;
-        if (channel) {
-          msgs = buffer.messages.filter((m) => m.channel === channel);
-          buffer.messages = buffer.messages.filter((m) => m.channel !== channel);
-        } else {
-          msgs = [...buffer.messages];
-          buffer.messages = [];
-        }
-        return { ok: true, messages: msgs };
-      }
-      case "channels": {
-        const chList = [...channels.keys()].map((name) => ({ name, direction: "bidi" }));
-        return { ok: true, channels: chList };
-      }
-      case "status": {
-        return {
-          ok: true,
-          connected,
-          activeSlug,
-          uptime: Math.floor((Date.now() - startTime) / 1e3),
-          channels: [...channels.keys()],
-          bufferedMessages: buffer.messages.length,
-          lastError,
-          bridgeMode: config.bridgeMode ?? null,
-          bridge: bridgeRunner?.status() ?? null
-        };
-      }
-      case "active-slug": {
-        return { ok: true, slug: activeSlug };
-      }
-      case "close": {
-        void shutdown();
-        return { ok: true };
-      }
-      default:
-        return { ok: false, error: `Unknown method: ${req.method}` };
-    }
-  }
 }
 
 // src/live-daemon-entry.ts