pubblue 0.6.4 → 0.6.9

package/dist/live-daemon-entry.js

@@ -1,10 +1,2022 @@
 import {
-  startDaemon
-} from "./chunk-QFJDLFK5.js";
-import {
+  CHANNELS,
+  CONTROL_CHANNEL,
   PubApiClient,
-  errorMessage
-} from "./chunk-JXEXE632.js";
+  buildClaudeArgs,
+  buildSessionBriefing,
+  createClaudeCodeBridgeRunner,
+  createOpenClawBridgeRunner,
+  decodeMessage,
+  encodeMessage,
+  errorMessage,
+  latestCliVersionPath,
+  makeAckMessage,
+  makeDeliveryReceiptMessage,
+  makeEventMessage,
+  parseAckMessage,
+  readLatestCliVersion,
+  resolveClaudeCodePath,
+  resolveOpenClawRuntime,
+  shouldAcknowledgeMessage,
+  writeLiveSessionContentFile
+} from "./chunk-JSX5KHV3.js";
+
+// src/lib/live-daemon.ts
+import { randomUUID } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+
+// ../shared/ack-routing-core.ts
+function resolveAckChannel(input) {
+  if (input.messageChannelOpen) return input.messageChannel;
+  if (input.controlChannelOpen) return CONTROL_CHANNEL;
+  return null;
+}
+
+// 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 makeCommandBindResultMessage(payload) {
+  return makeEventMessage("command.bind.result", payload);
+}
+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 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);
+  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)
+  };
+}
+
+// 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);
+      fn();
+    };
+    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`)));
+      }
+    });
+    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(() => {
+      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 sendBindResult(payload) {
+    await params.sendCommandMessage(makeCommandBindResultMessage(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
+    });
+  }
+  async function handleBind(message) {
+    params.debugLog(
+      `command:bind manifestId=${message.manifestId} functions=[${message.functions.map((f) => f.name).join(", ")}]`
+    );
+    const accepted = [];
+    const rejected = [];
+    boundFunctions.clear();
+    for (const entry of message.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.`
+        });
+        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
+    });
+  }
+  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(`command: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(
+      `command: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(
+          `command: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)}`
+      );
+      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(
+        `command: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(
+      `command: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);
+      return;
+    }
+    const cancel = parseCommandCancelMessage(message);
+    if (cancel) {
+      await handleCancel(cancel);
+    }
+  }
+  return {
+    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 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);
+        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;
+            }
+          }
+          params.trackOutboundMessage(channel, msg);
+          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") {
+    return {
+      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 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 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 LOCAL_CANDIDATE_FLUSH_MS = 2e3;
+var WRITE_ACK_TIMEOUT_MS = 5e3;
+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;
+  if (!incomingBrowserOffer) return false;
+  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";
+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 };
+}
+
+// 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");
+  }
+  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" || typeof live.expiresAt !== "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,
+    expiresAt: live.expiresAt
+  };
+}
+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 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 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 pendingOutboundAcks = /* @__PURE__ */ new Map();
+  const pendingDeliveryAcks = /* @__PURE__ */ new Map();
+  let peer = null;
+  let channels = /* @__PURE__ */ new Map();
+  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 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;
+      const sent = await 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) {
+    if (!debugEnabled) return;
+    const detail = error === void 0 ? "" : ` | ${error instanceof Error ? `${error.name}: ${error.message}` : typeof error === "string" ? error : JSON.stringify(error)}`;
+    console.error(`[pubblue-agent] ${message}${detail}`);
+  }
+  function markError(message, error) {
+    lastError = error === void 0 ? message : `${message}: ${errorMessage(error)}`;
+    debugLog(message, error);
+  }
+  function isLiveConnected() {
+    return browserConnected && bridgePrimed;
+  }
+  function clearLocalCandidateTimers() {
+    if (localCandidateInterval) {
+      clearInterval(localCandidateInterval);
+      localCandidateInterval = null;
+    }
+    if (localCandidateStopTimer) {
+      clearTimeout(localCandidateStopTimer);
+      localCandidateStopTimer = null;
+    }
+  }
+  function clearHealthCheckTimer() {
+    if (healthCheckTimer) {
+      clearInterval(healthCheckTimer);
+      healthCheckTimer = null;
+    }
+  }
+  function clearHeartbeatTimer() {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      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) {
+      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);
+      }
+    }
+  }
+  function startHealthCheckTimer() {
+    clearHealthCheckTimer();
+    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 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);
+    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, 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;
+        }
+        if (shouldAcknowledgeMessage(name, msg)) {
+          queueAck(msg.id, name);
+        }
+        if (name === CHANNELS.COMMAND) {
+          void commandHandler.onMessage(msg);
+          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,
+          ...activeStream ? { streamId: activeStream.streamId } : {},
+          size: data.length
+        }
+      } : {
+        id: `bin-${Date.now()}`,
+        type: "binary",
+        data: data.toString("base64"),
+        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);
+      }
+      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();
+  }
+  function flushQueuedAcks() {
+    const controlDc = channels.get(CONTROL_CHANNEL);
+    for (const [ackKey, ack] of pendingOutboundAcks) {
+      const messageDc = channels.get(ack.channel);
+      const targetChannel = resolveAckChannel({
+        controlChannelOpen: Boolean(controlDc?.isOpen()),
+        messageChannelOpen: Boolean(messageDc?.isOpen()),
+        messageChannel: ack.channel
+      });
+      if (!targetChannel) continue;
+      const encodedAck = encodeMessage(makeAckMessage(ack.messageId, ack.channel));
+      const primaryDc = targetChannel === CONTROL_CHANNEL ? controlDc : messageDc;
+      try {
+        if (primaryDc?.isOpen()) {
+          primaryDc.sendMessage(encodedAck);
+          pendingOutboundAcks.delete(ackKey);
+          continue;
+        }
+      } catch (error) {
+        markError("failed to flush queued ack on primary channel", error);
+      }
+      const fallbackChannel = targetChannel === ack.channel ? CONTROL_CHANNEL : ack.channel;
+      const fallbackDc = fallbackChannel === CONTROL_CHANNEL ? controlDc : messageDc;
+      try {
+        if (fallbackDc?.isOpen()) {
+          fallbackDc.sendMessage(encodedAck);
+          pendingOutboundAcks.delete(ackKey);
+        }
+      } catch (error) {
+        markError("failed to flush queued ack on fallback channel", error);
+      }
+    }
+  }
+  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(key);
+        resolve(false);
+      }, timeoutMs);
+      pendingDeliveryAcks.set(key, { resolve, timeout });
+    });
+  }
+  function settlePendingAck(messageId, channel, received) {
+    const key = getAckKey(messageId, channel);
+    const pending = pendingDeliveryAcks.get(key);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    pendingDeliveryAcks.delete(key);
+    pending.resolve(received);
+  }
+  function failPendingAcks() {
+    for (const [ackKey, pending] of pendingDeliveryAcks) {
+      clearTimeout(pending.timeout);
+      pending.resolve(false);
+      pendingDeliveryAcks.delete(ackKey);
+    }
+  }
+  function openDataChannel(name) {
+    if (!peer) throw new Error("PeerConnection not initialized");
+    const existing = channels.get(name);
+    if (existing) return existing;
+    const dc = peer.createDataChannel(name, { ordered: true });
+    setupChannel(name, dc);
+    return dc;
+  }
+  async function waitForChannelOpen(dc, timeoutMs = 5e3) {
+    if (dc.isOpen()) return;
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const timeout = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        reject(new Error("DataChannel open timed out"));
+      }, timeoutMs);
+      dc.onOpen(() => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+  }
+  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 {
+        targetDc = channels.get(channel) ?? openDataChannel(channel);
+        await waitForChannelOpen(targetDc);
+      } catch (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) => {
+      if (stopped || currentPeer !== peer) return;
+      localCandidates.push(JSON.stringify({ candidate, sdpMid: mid }));
+    });
+    currentPeer.onStateChange((state) => {
+      if (stopped || currentPeer !== peer) return;
+      if (state === "connected") {
+        browserConnected = true;
+        flushQueuedAcks();
+        startPingPong();
+        void ensureBridgePrimed();
+        return;
+      }
+      if (state === "disconnected" || state === "failed" || state === "closed") {
+        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) => {
+      if (stopped || currentPeer !== peer) return;
+      setupChannel(dc.getLabel(), dc);
+    });
+  }
+  function createPeer() {
+    const nextPeer = new ndc.PeerConnection("agent", {
+      iceServers: ["stun:stun.l.google.com:19302", "stun:stun1.l.google.com:19302"]
+    });
+    peer = nextPeer;
+    channels = /* @__PURE__ */ new Map();
+    pendingInboundBinaryMeta = /* @__PURE__ */ new Map();
+    inboundStreams = /* @__PURE__ */ new Map();
+    seenInboundMessageKeys = /* @__PURE__ */ new Set();
+    attachPeerHandlers(nextPeer);
+  }
+  function closeCurrentPeer() {
+    failPendingAcks();
+    for (const dc of channels.values()) {
+      try {
+        dc.close();
+      } catch (error) {
+        debugLog("failed to close data channel cleanly", error);
+      }
+    }
+    channels.clear();
+    pendingInboundBinaryMeta.clear();
+    inboundStreams.clear();
+    seenInboundMessageKeys.clear();
+    if (peer) {
+      try {
+        peer.close();
+      } catch (error) {
+        debugLog("failed to close peer connection cleanly", error);
+      }
+      peer = null;
+    }
+  }
+  function resetNegotiationState() {
+    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();
+    localCandidateInterval = setInterval(async () => {
+      if (localCandidates.length <= lastSentCandidateCount) return;
+      const newOnes = localCandidates.slice(lastSentCandidateCount);
+      lastSentCandidateCount = localCandidates.length;
+      await apiClient2.signalAnswer({ slug, daemonSessionId, candidates: newOnes }).catch((error) => {
+        debugLog("failed to publish local ICE candidates", error);
+      });
+    }, LOCAL_CANDIDATE_FLUSH_MS);
+    localCandidateStopTimer = setTimeout(() => {
+      clearLocalCandidateTimers();
+    }, 3e4);
+  }
+  async function handleIncomingLive(slug, browserOffer) {
+    if (recovering) return;
+    recovering = true;
+    try {
+      const previousCanvasSnapshot = getActiveCanvasSnapshot();
+      if (previousCanvasSnapshot && previousCanvasSnapshot.slug !== slug) {
+        void queuePersistCanvasSnapshot(previousCanvasSnapshot, `session-switch:${slug}`);
+      }
+      await stopBridge();
+      closeCurrentPeer();
+      createPeer();
+      resetNegotiationState();
+      if (!peer) throw new Error("PeerConnection not initialized");
+      const answer = await createAnswer(peer, browserOffer, OFFER_TIMEOUT_MS);
+      lastAppliedBrowserOffer = browserOffer;
+      activeSlug = slug;
+      await apiClient2.signalAnswer({ slug, daemonSessionId, answer, agentName: agentName2 });
+      startLocalCandidateFlush(slug);
+    } catch (error) {
+      markError("failed to handle incoming live request", error);
+    } finally {
+      recovering = false;
+    }
+  }
+  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);
+      }
+    }
+  }
+  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 {
+      const raw = fs.readFileSync(infoPath2, "utf-8");
+      const info = JSON.parse(raw);
+      process.kill(info.pid, 0);
+      stale = false;
+    } catch (error) {
+      debugLog("stale socket check failed (assuming stale)", error);
+    }
+    if (stale) {
+      try {
+        fs.unlinkSync(socketPath2);
+      } catch (error) {
+        debugLog("failed to remove stale daemon socket", error);
+      }
+    } else {
+      throw new Error(`Daemon already running (socket: ${socketPath2})`);
+    }
+  }
+  await apiClient2.goOnline({ daemonSessionId, agentName: agentName2 });
+  heartbeatTimer = setInterval(async () => {
+    if (stopped) return;
+    try {
+      await apiClient2.heartbeat({ daemonSessionId });
+    } catch (error) {
+      markError("heartbeat failed", error);
+    }
+  }, HEARTBEAT_INTERVAL_MS);
+  const handleIpcRequest = createDaemonIpcHandler({
+    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,
+    trackOutboundMessage,
+    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 });
+  fs.writeFileSync(
+    infoPath2,
+    JSON.stringify({ pid: process.pid, socketPath: socketPath2, startedAt: startTime, cliVersion: cliVersion2 })
+  );
+  startHealthCheckTimer();
+  signaling.start();
+  async function sendOnChannel(channel, msg) {
+    if (stopped || !isLiveConnected()) return false;
+    const sent = await 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 : "";
+    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(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 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-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 cleanup() {
+    if (stopped) return;
+    stopped = true;
+    clearLocalCandidateTimers();
+    clearHealthCheckTimer();
+    clearHeartbeatTimer();
+    stopPingPong();
+    await signaling.stop();
+    await queuePersistCanvasSnapshot(getActiveCanvasSnapshot(), "daemon-shutdown");
+    try {
+      await apiClient2.goOffline({ daemonSessionId });
+    } catch (error) {
+      debugLog("failed to go offline", error);
+    }
+    await stopBridge();
+    commandHandler.stop();
+    closeCurrentPeer();
+    ipcServer.close();
+    try {
+      fs.unlinkSync(socketPath2);
+    } catch (error) {
+      debugLog("failed to remove daemon socket during cleanup", error);
+    }
+    try {
+      fs.unlinkSync(infoPath2);
+    } catch (error) {
+      debugLog("failed to remove daemon info file during cleanup", error);
+    }
+  }
+  let shuttingDown = false;
+  async function shutdown(exitCode = 0) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    await cleanup();
+    process.exit(exitCode);
+  }
+  process.on("SIGTERM", () => {
+    void shutdown(0);
+  });
+  process.on("SIGINT", () => {
+    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);
+  });
+}
 
 // src/live-daemon-entry.ts
 var baseUrl = process.env.PUBBLUE_DAEMON_BASE_URL;
@@ -13,7 +2025,12 @@ var socketPath = process.env.PUBBLUE_DAEMON_SOCKET;
 var infoPath = process.env.PUBBLUE_DAEMON_INFO;
 var cliVersion = process.env.PUBBLUE_CLI_VERSION;
 var agentName = process.env.PUBBLUE_DAEMON_AGENT_NAME;
-var bridgeMode = process.env.PUBBLUE_DAEMON_BRIDGE_MODE || "openclaw";
+var bridgeModeRaw = process.env.PUBBLUE_DAEMON_BRIDGE_MODE;
+if (!bridgeModeRaw) {
+  console.error("Missing PUBBLUE_DAEMON_BRIDGE_MODE env var.");
+  process.exit(1);
+}
+var bridgeMode = bridgeModeRaw;
 if (!baseUrl || !apiKey || !socketPath || !infoPath) {
   console.error("Missing required env vars for daemon.");
   process.exit(1);