tesseract-agent 0.4.3 → 0.4.6

package/dist-bundle/cli.js

@@ -11517,8 +11517,8 @@ var capitalizeFirstCharacter, error28;
 var init_lt = __esm({
   "../../node_modules/zod/v4/locales/lt.js"() {
     init_util();
-    capitalizeFirstCharacter = (text) => {
-      return text.charAt(0).toUpperCase() + text.slice(1);
+    capitalizeFirstCharacter = (text2) => {
+      return text2.charAt(0).toUpperCase() + text2.slice(1);
     };
     error28 = () => {
       const Sizable = {
@@ -19350,6 +19350,213 @@ var init_cron_tools = __esm({
   }
 });
 
+// ../../packages/agent-core/dist/design-tokens.js
+function colorVar(name, c) {
+  return c.cssVar ?? `--color-${name}`;
+}
+function tokensToCss(tokens) {
+  const lines = [
+    "/* GENERATED from design-system/tokens.json \u2014 do not edit by hand. */",
+    ":root {"
+  ];
+  const push = (k, v) => lines.push(`  ${k}: ${v};`);
+  for (const [name, c] of Object.entries(tokens.colors ?? {}))
+    push(colorVar(name, c), c.value);
+  for (const [role, fam] of Object.entries(tokens.typography?.fontFamilies ?? {}))
+    push(`--font-${role}`, fam);
+  for (const [step, s] of Object.entries(tokens.typography?.scale ?? {}))
+    push(`--text-${step}`, s.size);
+  for (const [name, w] of Object.entries(tokens.typography?.weights ?? {}))
+    push(`--weight-${name}`, String(w));
+  for (const [step, v] of Object.entries(tokens.spacing ?? {}))
+    push(`--space-${step}`, v);
+  for (const [name, v] of Object.entries(tokens.radius ?? {}))
+    push(`--radius-${name}`, v);
+  for (const [name, v] of Object.entries(tokens.shadow ?? {}))
+    push(`--shadow-${name}`, v);
+  lines.push("}", "");
+  return lines.join("\n");
+}
+function getTokenPath(tokens, dotPath) {
+  let cur = tokens;
+  for (const key2 of dotPath.split(".")) {
+    if (cur == null || typeof cur !== "object")
+      return void 0;
+    cur = cur[key2];
+  }
+  return cur;
+}
+function setTokenPath(tokens, dotPath, value) {
+  const keys = dotPath.split(".").filter(Boolean);
+  if (keys.length === 0)
+    throw new Error("empty token path");
+  const root = { ...tokens };
+  let cur = root;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = keys[i];
+    const next = cur[k];
+    cur[k] = next && typeof next === "object" ? { ...next } : {};
+    cur = cur[k];
+  }
+  cur[keys[keys.length - 1]] = value;
+  return root;
+}
+var DESIGN_DIR, TOKENS_FILE, TOKENS_CSS_FILE, DESIGN_CLAUDE_MD, ColorToken, TypeStep, Component, DesignTokensSchema;
+var init_design_tokens = __esm({
+  "../../packages/agent-core/dist/design-tokens.js"() {
+    "use strict";
+    init_zod();
+    DESIGN_DIR = "design-system";
+    TOKENS_FILE = "design-system/tokens.json";
+    TOKENS_CSS_FILE = "design-system/tokens.css";
+    DESIGN_CLAUDE_MD = "design-system/CLAUDE.md";
+    ColorToken = external_exports.object({ value: external_exports.string(), cssVar: external_exports.string().optional(), role: external_exports.string().optional() });
+    TypeStep = external_exports.object({ size: external_exports.string(), lineHeight: external_exports.string().optional(), weight: external_exports.number().optional() });
+    Component = external_exports.object({
+      selectorHint: external_exports.string().optional(),
+      sourceFiles: external_exports.array(external_exports.string()).optional(),
+      tokensUsed: external_exports.array(external_exports.string()).optional()
+    });
+    DesignTokensSchema = external_exports.object({
+      $schema: external_exports.string().optional(),
+      meta: external_exports.object({
+        name: external_exports.string().optional(),
+        framework: external_exports.enum(["tailwind", "css", "css-modules", "unknown"]).optional(),
+        generatedAt: external_exports.string().optional()
+      }).optional(),
+      colors: external_exports.record(external_exports.string(), ColorToken).optional(),
+      typography: external_exports.object({
+        fontFamilies: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+        scale: external_exports.record(external_exports.string(), TypeStep).optional(),
+        weights: external_exports.record(external_exports.string(), external_exports.number()).optional()
+      }).optional(),
+      spacing: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+      radius: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+      shadow: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+      components: external_exports.record(external_exports.string(), Component).optional()
+    });
+  }
+});
+
+// ../../packages/agent-core/dist/design-tools.js
+import { tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join as join4, resolve as resolve2, relative as relative2, isAbsolute as isAbsolute2 } from "node:path";
+function within(root, p) {
+  const rel = relative2(resolve2(root), resolve2(p));
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
+}
+async function loadTokens(root) {
+  try {
+    const parsed = DesignTokensSchema.safeParse(JSON.parse(await readFile(join4(root, TOKENS_FILE), "utf8")));
+    return parsed.success ? parsed.data : {};
+  } catch {
+    return {};
+  }
+}
+async function saveTokens(root, tokens, regenerateCss) {
+  const tokensAbs = join4(root, TOKENS_FILE);
+  const cssAbs = join4(root, TOKENS_CSS_FILE);
+  if (!within(root, tokensAbs) || !within(root, cssAbs))
+    throw new Error("refusing to write outside the project root");
+  await mkdir(join4(root, DESIGN_DIR), { recursive: true });
+  await writeFile(tokensAbs, JSON.stringify(tokens, null, 2) + "\n", "utf8");
+  if (regenerateCss)
+    await writeFile(cssAbs, tokensToCss(tokens), "utf8");
+}
+function buildDesignTools(deps) {
+  const needRoot = () => {
+    const root = deps.getProjectDir();
+    if (!root)
+      throw new Error("No project directory is open.");
+    return root;
+  };
+  return [
+    tool2("read_design_tokens", "Read the project design system from design-system/tokens.json (colors, typography, spacing, radius, shadow, components). Call this ONCE when you need token values \u2014 do not guess hardcoded hex/sizes.", { section: external_exports.enum(["all", "colors", "typography", "spacing", "radius", "shadow", "components"]).optional().describe("Limit to one section (default: all)") }, async (args) => {
+      const tokens = await loadTokens(needRoot());
+      const out = !args.section || args.section === "all" ? tokens : { [args.section]: tokens[args.section] ?? {} };
+      return text(JSON.stringify(out, null, 2));
+    }),
+    tool2("write_design_token", 'Set one or more design tokens by dot-path (e.g. "colors.primary.value" = "#d97757", "spacing.2" = "0.5rem") and regenerate design-system/tokens.css. Batch related edits in one call. Path-guarded to the project root.', {
+      edits: external_exports.array(external_exports.object({
+        path: external_exports.string().describe("Dot-path into tokens.json, e.g. colors.primary.value"),
+        value: external_exports.union([external_exports.string(), external_exports.number()]).describe("The new value")
+      })).describe("Edits to apply"),
+      regenerateCss: external_exports.boolean().optional().describe("Regenerate tokens.css from the result (default: true)")
+    }, async (args) => {
+      const root = needRoot();
+      let tokens = await loadTokens(root);
+      for (const e of args.edits)
+        tokens = setTokenPath(tokens, e.path, e.value);
+      const validated = DesignTokensSchema.safeParse(tokens);
+      if (!validated.success)
+        return text(`Edit produced an invalid tokens document: ${validated.error.message}`, true);
+      const regen = args.regenerateCss !== false;
+      await saveTokens(root, validated.data, regen);
+      return text(`Updated ${args.edits.length} token(s): ${args.edits.map((e) => e.path).join(", ")}${regen ? " and regenerated tokens.css" : ""}.`);
+    }),
+    tool2("capture_element_styles", "Read the computed CSS of an element on the live preview by CSS selector (cheap \u2014 returns text, not a screenshot). Use to learn what styles/tokens an element currently uses before editing.", {
+      selector: external_exports.string().describe("CSS selector of the element to inspect"),
+      properties: external_exports.array(external_exports.string()).optional().describe("CSS properties to read (default: a common set)")
+    }, async (args) => {
+      const props = args.properties?.length ? args.properties : STYLE_PROPS;
+      const expr = `(() => { const el = document.querySelector(${JSON.stringify(args.selector)}); if (!el) return { error: 'no element matches ${JSON.stringify(args.selector)}' }; const cs = getComputedStyle(el); const out = {}; for (const p of ${JSON.stringify(props)}) out[p] = cs.getPropertyValue(p).trim(); return { tag: el.tagName.toLowerCase(), styles: out }; })()`;
+      try {
+        const result = await deps.driveBrowser("evaluate", { expression: expr });
+        return text(typeof result === "string" ? result : JSON.stringify(result, null, 2));
+      } catch (err) {
+        return text(`Could not read styles (is a preview open?): ${err instanceof Error ? err.message : String(err)}`, true);
+      }
+    }),
+    tool2("notify_preview_ready", "Announce that a live preview / dev server / build is now running and reachable at a URL. Call this once the app is up (e.g. after starting a web build) \u2014 the desktop opens it in the device canvas, the mobile client shows it in-chat, and a build-ready push is sent.", {
+      url: external_exports.string().describe("The reachable preview URL, e.g. http://localhost:3000"),
+      kind: external_exports.enum(["web", "mobile"]).optional().describe("Framing hint (default: web)")
+    }, async (args) => {
+      deps.notifyPreviewReady?.(args.url, args.kind);
+      return text(`Preview announced: ${args.url}`);
+    }),
+    tool2("list_components", "List the design-system components recorded in tokens.json (name, source files, tokens used).", {}, async () => {
+      const comps = (await loadTokens(needRoot())).components ?? {};
+      const names = Object.keys(comps);
+      if (!names.length)
+        return text('No components recorded yet. Run the "Import Design System" skill to populate them.');
+      return text(names.map((n) => {
+        const c = comps[n];
+        const src = c.sourceFiles?.length ? ` (${c.sourceFiles.join(", ")})` : "";
+        const used = c.tokensUsed?.length ? ` \u2014 uses ${c.tokensUsed.join(", ")}` : "";
+        return `- ${n}${src}${used}`;
+      }).join("\n"));
+    })
+  ];
+}
+var STYLE_PROPS, text;
+var init_design_tools = __esm({
+  "../../packages/agent-core/dist/design-tools.js"() {
+    "use strict";
+    init_zod();
+    init_design_tokens();
+    STYLE_PROPS = [
+      "color",
+      "background-color",
+      "font-family",
+      "font-size",
+      "font-weight",
+      "line-height",
+      "letter-spacing",
+      "padding",
+      "margin",
+      "border",
+      "border-radius",
+      "box-shadow",
+      "width",
+      "height",
+      "display",
+      "gap"
+    ];
+    text = (t, isError = false) => ({ content: [{ type: "text", text: t }], ...isError ? { isError: true } : {} });
+  }
+});
+
 // ../../packages/agent-core/dist/narrator.js
 var COALESCE_MS, LOG_CAP, ACT_CAP, NARRATE_CAP, Narrator;
 var init_narrator = __esm({
@@ -19449,13 +19656,13 @@ ${s.log.map((l) => `- ${l}`).join("\n")}` : "",
 ${activity}`,
             "One-line status of what it is doing now:"
           ].filter(Boolean).join("\n\n");
-          const text = (await cfg2.complete({ system, prompt, maxTokens: 40 }))?.trim().replace(/^["']|["']$/g, "");
-          if (text && text !== s.lastText) {
-            s.lastText = text;
-            s.log.push(text);
+          const text2 = (await cfg2.complete({ system, prompt, maxTokens: 40 }))?.trim().replace(/^["']|["']$/g, "");
+          if (text2 && text2 !== s.lastText) {
+            s.lastText = text2;
+            s.log.push(text2);
             if (s.log.length > LOG_CAP)
               s.log.shift();
-            this.emit(id, text, cfg2.engineLabel);
+            this.emit(id, text2, cfg2.engineLabel);
           }
         } catch {
         } finally {
@@ -19562,12 +19769,12 @@ var init_trace_store = __esm({
 
 // ../../packages/agent-core/dist/session-transfer.js
 import { homedir } from "node:os";
-import { join as join4, dirname as dirname3, sep, resolve as resolve2 } from "node:path";
-import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+import { join as join5, dirname as dirname3, sep, resolve as resolve3 } from "node:path";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, readdir } from "node:fs/promises";
 import { existsSync } from "node:fs";
 function isInside(parent, child) {
-  const p = resolve2(parent);
-  const c = resolve2(child);
+  const p = resolve3(parent);
+  const c = resolve3(child);
   return c === p || c.startsWith(p + sep);
 }
 function cwdHash(cwd) {
@@ -19581,13 +19788,13 @@ function sanitizeProjectDir(cwd) {
   return s.length <= MAX_PROJECT_DIR_LEN ? s : `${s.slice(0, MAX_PROJECT_DIR_LEN)}-${cwdHash(cwd)}`;
 }
 function projectsRoot() {
-  return join4(homedir(), ".claude", "projects");
+  return join5(homedir(), ".claude", "projects");
 }
 function sessionDir(cwd) {
-  return join4(projectsRoot(), sanitizeProjectDir(cwd));
+  return join5(projectsRoot(), sanitizeProjectDir(cwd));
 }
 function sessionFile(cwd, sessionId) {
-  return join4(sessionDir(cwd), `${sessionId}.jsonl`);
+  return join5(sessionDir(cwd), `${sessionId}.jsonl`);
 }
 async function walkFiles(root) {
   const out = [];
@@ -19596,7 +19803,7 @@ async function walkFiles(root) {
     for (const e of entries) {
       const rel = prefix ? `${prefix}/${e.name}` : e.name;
       if (e.isDirectory())
-        await rec(join4(dir, e.name), rel);
+        await rec(join5(dir, e.name), rel);
       else if (e.isFile())
         out.push(rel);
     }
@@ -19608,13 +19815,13 @@ async function exportSession(sessionId, fromCwd) {
   const file2 = sessionFile(fromCwd, sessionId);
   if (!existsSync(file2))
     return null;
-  const raw = await readFile(file2, "utf-8");
+  const raw = await readFile2(file2, "utf-8");
   const lines = raw.split("\n").filter((l) => l.trim().length > 0);
   const sidecar = [];
-  const sideDir = join4(sessionDir(fromCwd), sessionId);
+  const sideDir = join5(sessionDir(fromCwd), sessionId);
   if (existsSync(sideDir)) {
     for (const rel of await walkFiles(sideDir)) {
-      sidecar.push({ rel, data: await readFile(join4(sideDir, rel.split("/").join(sep))) });
+      sidecar.push({ rel, data: await readFile2(join5(sideDir, rel.split("/").join(sep))) });
     }
   }
   return { sessionId, fromCwd, lines, sidecar };
@@ -19622,22 +19829,22 @@ async function exportSession(sessionId, fromCwd) {
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function rekey(text, fromCwd, toCwd) {
-  return text.replace(new RegExp(escapeRe(fromCwd) + '(?=["/\\\\]|$)', "g"), () => toCwd);
+function rekey(text2, fromCwd, toCwd) {
+  return text2.replace(new RegExp(escapeRe(fromCwd) + '(?=["/\\\\]|$)', "g"), () => toCwd);
 }
 async function importSession(exp, toCwd) {
   const destDir = sessionDir(toCwd);
-  await mkdir(destDir, { recursive: true });
-  const destFile = join4(destDir, `${exp.sessionId}.jsonl`);
-  await writeFile(destFile, exp.lines.map((l) => rekey(l, exp.fromCwd, toCwd)).join("\n") + "\n");
-  const sideRoot = join4(destDir, exp.sessionId);
+  await mkdir2(destDir, { recursive: true });
+  const destFile = join5(destDir, `${exp.sessionId}.jsonl`);
+  await writeFile2(destFile, exp.lines.map((l) => rekey(l, exp.fromCwd, toCwd)).join("\n") + "\n");
+  const sideRoot = join5(destDir, exp.sessionId);
   for (const s of exp.sidecar) {
-    const dest = join4(sideRoot, s.rel.split("/").join(sep));
+    const dest = join5(sideRoot, s.rel.split("/").join(sep));
     if (!isInside(sideRoot, dest))
       continue;
-    await mkdir(dirname3(dest), { recursive: true });
+    await mkdir2(dirname3(dest), { recursive: true });
     const data = s.rel.endsWith(".jsonl") || s.rel.endsWith(".json") ? Buffer.from(rekey(s.data.toString("utf-8"), exp.fromCwd, toCwd), "utf-8") : s.data;
-    await writeFile(dest, data);
+    await writeFile2(dest, data);
   }
   return destFile;
 }
@@ -19656,7 +19863,7 @@ var init_session_transfer = __esm({
 });
 
 // ../../packages/agent-core/dist/session-store.js
-import { readFile as readFile2, stat } from "node:fs/promises";
+import { readFile as readFile3, stat } from "node:fs/promises";
 import { listSessions, getSessionMessages, forkSession } from "@anthropic-ai/claude-agent-sdk";
 function toSessionInfo(s) {
   const fromFirst = stripPromptPrefix(s.firstPrompt ?? "").slice(0, 80);
@@ -19702,9 +19909,9 @@ function transcriptMatches(raw, q) {
   }
   return false;
 }
-function stripPromptPrefix(text) {
+function stripPromptPrefix(text2) {
   const isMetadata = (l) => l.startsWith("I'm working on the page:") || l.startsWith("Selected elements:") || l.startsWith("Element ") || l.startsWith("  DOM Path:") || l.startsWith("  XPath:") || l.startsWith("  CSS:") || l.startsWith("  HTML:") || l.startsWith("  Text:") || l.startsWith("  Position:") || l.startsWith("Use the xpath") || l.startsWith("[") && l.includes("image(s) attached");
-  const userLines = text.split("\n").filter((l) => !isMetadata(l));
+  const userLines = text2.split("\n").filter((l) => !isMetadata(l));
   return userLines.join("\n").trim();
 }
 function extractBlocks(message) {
@@ -19723,13 +19930,13 @@ function extractBlocks(message) {
       continue;
     const b = block;
     if (b.type === "thinking" && typeof b.thinking === "string") {
-      const text = b.thinking.trim();
-      if (text)
-        blocks.push({ kind: "thinking", content: text });
+      const text2 = b.thinking.trim();
+      if (text2)
+        blocks.push({ kind: "thinking", content: text2 });
     } else if (b.type === "text" && typeof b.text === "string") {
-      const text = b.text.trim();
-      if (text && !text.startsWith("<ide_") && !text.startsWith("<system-reminder>")) {
-        blocks.push({ kind: "text", content: text });
+      const text2 = b.text.trim();
+      if (text2 && !text2.startsWith("<ide_") && !text2.startsWith("<system-reminder>")) {
+        blocks.push({ kind: "text", content: text2 });
       }
     } else if (b.type === "tool_use") {
       const name = b.name ?? "tool";
@@ -19821,7 +20028,7 @@ var init_session_store = __esm({
               const file2 = sessionFile(s.cwd, s.sessionId);
               const st = await stat(file2);
               if (st.size <= SEARCH_MAX_FILE_BYTES) {
-                const raw = await readFile2(file2, "utf-8");
+                const raw = await readFile3(file2, "utf-8");
                 if (transcriptMatches(raw, q))
                   out.push(info);
               }
@@ -19891,11 +20098,11 @@ var init_log = __esm({
 });
 
 // ../../packages/agent-core/dist/session-usage.js
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { homedir as homedir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function tokenFromCredsBlob(raw) {
   try {
     const j = JSON.parse(raw);
@@ -19909,7 +20116,7 @@ async function tokenFromConfigDir(dir) {
   if (!d)
     return null;
   try {
-    return tokenFromCredsBlob(await readFile3(join5(d, ".credentials.json"), "utf8"));
+    return tokenFromCredsBlob(await readFile4(join6(d, ".credentials.json"), "utf8"));
   } catch {
     return null;
   }
@@ -19924,7 +20131,7 @@ async function resolveOauthToken(env) {
   const ambientTok = process.env.CLAUDE_CODE_OAUTH_TOKEN?.trim();
   if (ambientTok)
     return ambientTok;
-  const fromAmbientDir = await tokenFromConfigDir(process.env.CLAUDE_CONFIG_DIR ?? join5(homedir2(), ".claude"));
+  const fromAmbientDir = await tokenFromConfigDir(process.env.CLAUDE_CONFIG_DIR ?? join6(homedir2(), ".claude"));
   if (fromAmbientDir)
     return fromAmbientDir;
   if (process.platform === "darwin") {
@@ -20042,11 +20249,11 @@ var init_session_usage = __esm({
 
 // ../../packages/agent-core/dist/agent-manager.js
 import { query, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
-import { writeFile as writeFile2, mkdir as mkdir2, readFile as readFile4 } from "node:fs/promises";
+import { writeFile as writeFile3, mkdir as mkdir3, readFile as readFile5 } from "node:fs/promises";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { tmpdir } from "node:os";
-import { join as join6, dirname as dirname4 } from "node:path";
-import { existsSync as existsSync2 } from "node:fs";
+import { join as join7, dirname as dirname4 } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { createServer } from "node:net";
@@ -20054,7 +20261,7 @@ import { spawn, execSync } from "node:child_process";
 function findClaudeCliJs() {
   const require2 = createRequire(import.meta.url);
   const sdkMain = require2.resolve("@anthropic-ai/claude-agent-sdk");
-  const cliJs = join6(dirname4(sdkMain), "cli.js");
+  const cliJs = join7(dirname4(sdkMain), "cli.js");
   if (!existsSync2(cliJs)) {
     throw new Error(`Claude Agent SDK cli.js not found at ${cliJs}. The installed SDK version may not ship cli.js \u2014 apps/host/package.json pins @anthropic-ai/claude-agent-sdk to a version that includes it.`);
   }
@@ -20158,15 +20365,15 @@ ${plan}`;
   }
 }
 function flattenToolResultContent(content) {
-  let text = "";
+  let text2 = "";
   if (typeof content === "string")
-    text = content;
+    text2 = content;
   else if (Array.isArray(content)) {
-    text = content.filter((b) => b && typeof b === "object" && b.type === "text").map((b) => String(b.text ?? "")).join("\n");
+    text2 = content.filter((b) => b && typeof b === "object" && b.type === "text").map((b) => String(b.text ?? "")).join("\n");
   }
-  if (text.length > TOOL_RESULT_CAP)
-    return { text: text.slice(0, TOOL_RESULT_CAP), truncated: true };
-  return { text, truncated: false };
+  if (text2.length > TOOL_RESULT_CAP)
+    return { text: text2.slice(0, TOOL_RESULT_CAP), truncated: true };
+  return { text: text2, truncated: false };
 }
 function extractImages(content) {
   if (!Array.isArray(content))
@@ -20209,7 +20416,7 @@ function editedPathOf(toolInput) {
 }
 async function snapshotFile(path5) {
   try {
-    const buf = await readFile4(path5);
+    const buf = await readFile5(path5);
     if (buf.length > EDIT_PREVIEW_CAP)
       return { noPreview: true };
     if (buf.subarray(0, 8192).includes(0))
@@ -20229,12 +20436,42 @@ function sourcesEqual(a, b) {
       return false;
   return true;
 }
+function buildMobileClause(dir) {
+  try {
+    let fw = "";
+    let runCmd = "";
+    if (existsSync2(join7(dir, "pubspec.yaml"))) {
+      fw = "Flutter";
+      runCmd = "flutter run -d chrome";
+    } else if (existsSync2(join7(dir, "package.json"))) {
+      const pkg = JSON.parse(readFileSync3(join7(dir, "package.json"), "utf8"));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.expo) {
+        fw = "Expo";
+        runCmd = "npx expo start --web";
+      } else if (deps["react-native"]) {
+        fw = "React Native";
+        runCmd = "npm run web (react-native-web)";
+      }
+    }
+    if (!fw)
+      return "";
+    return `
+
+MOBILE (${fw}):
+- For a fast live preview, run the app AS WEB (\`${runCmd}\`) and tell the user the localhost URL \u2014 Tesseract shows it in a phone-framed canvas where elements can be picked and edited. Use a real device/simulator only when native-specific behavior matters.`;
+  } catch {
+    return "";
+  }
+}
 var cachedNodeExe, HUMAN_READABLE_FIELDS, TOOL_RESULT_CAP, MAX_RESULT_IMAGES, MAX_IMAGE_BASE64, PERMISSION_MODES, EDIT_PREVIEW_CAP, AsyncMessagePump, IDLE_REAP_MS, MODERATE_IDLE_MS, STEER_COALESCE_MS, AgentManager;
 var init_agent_manager = __esm({
   "../../packages/agent-core/dist/agent-manager.js"() {
     "use strict";
     init_dist();
     init_cron_tools();
+    init_design_tools();
+    init_design_tokens();
     init_narrator();
     init_plan_splitter();
     init_trace_store();
@@ -20277,7 +20514,7 @@ var init_agent_manager = __esm({
             if (this.closed) {
               return Promise.resolve({ value: void 0, done: true });
             }
-            return new Promise((resolve8) => this.resolvers.push(resolve8));
+            return new Promise((resolve9) => this.resolvers.push(resolve9));
           },
           return: () => {
             this.end();
@@ -20303,6 +20540,10 @@ var init_agent_manager = __esm({
       /** requestId → the originating browser-cli socket, for unicast responses.
        *  browser-cli is one-shot, so the entry is deleted on the first write. */
       pendingResponses = /* @__PURE__ */ new Map();
+      /** Resolvers for HOST-originated browser requests (design tools), keyed by
+       *  requestId — disjoint from pendingResponses (browser-cli sockets). Resolved by
+       *  sendBrowserResponse when the host replies. */
+      pendingBrowserResolvers = /* @__PURE__ */ new Map();
       /** requestId → a parked canUseTool decision. The Promise resolves when the
        *  client replies with chat:permission (→ respondToPermission) or the turn is
        *  aborted (→ deny). `suggestions` is echoed back as updatedPermissions when the
@@ -20415,8 +20656,8 @@ var init_agent_manager = __esm({
         this.send = send2;
         this.onBrowserRequest = onBrowserRequest;
         const __dirname = dirname4(fileURLToPath(import.meta.url));
-        this.browserCliPath = join6(__dirname, "browser-cli.js");
-        this.narrator = new Narrator((sessionId, text, engineLabel) => this.send({ type: "agent:narration", sessionId, text, ...engineLabel ? { engineLabel } : {} }, this.liveSessions.get(sessionId)?.origin));
+        this.browserCliPath = join7(__dirname, "browser-cli.js");
+        this.narrator = new Narrator((sessionId, text2, engineLabel) => this.send({ type: "agent:narration", sessionId, text: text2, ...engineLabel ? { engineLabel } : {} }, this.liveSessions.get(sessionId)?.origin));
       }
       /** Inject (or clear) the cheap model used for the live status narration. The
        *  host resolves creds and builds the completion fn (keeping secrets host-side). */
@@ -20443,7 +20684,7 @@ var init_agent_manager = __esm({
        * (no shared-socket "which session?" race) with ZERO changes to browser-cli.
        */
       startSessionListener(live) {
-        return new Promise((resolve8) => {
+        return new Promise((resolve9) => {
           const server = createServer((socket2) => {
             live.ipcSockets.add(socket2);
             let buffer = "";
@@ -20475,11 +20716,21 @@ var init_agent_manager = __esm({
             const addr = server.address();
             live.ipcPort = typeof addr === "object" && addr ? addr.port : 0;
             log("Session IPC listener on port", live.ipcPort, "for", live.sessionId || live.clientRequestId || "(pending)");
-            resolve8();
+            resolve9();
           });
         });
       }
       sendBrowserResponse(requestId, result, error51) {
+        const pending = this.pendingBrowserResolvers.get(requestId);
+        if (pending) {
+          this.pendingBrowserResolvers.delete(requestId);
+          clearTimeout(pending.timer);
+          if (error51)
+            pending.reject(new Error(error51));
+          else
+            pending.resolve(result);
+          return;
+        }
         const socket2 = this.pendingResponses.get(requestId);
         if (!socket2)
           return;
@@ -20489,6 +20740,28 @@ var init_agent_manager = __esm({
         } catch {
         }
       }
+      /** Drive THIS session's connected browser from host-side tool code and await the
+       *  result (mirrors the browser-cli round-trip, but in-process). Used by the design
+       *  MCP tools (capture_element_styles). Rejects after 15s if the host never replies
+       *  (e.g. no preview open). Reuses the existing onBrowserRequest/sendBrowserResponse
+       *  pair — the host neither knows nor cares the requestId originated here. */
+      requestBrowser(live, action, params) {
+        return new Promise((resolve9, reject) => {
+          const requestId = `design:${randomUUID2()}`;
+          const timer = setTimeout(() => {
+            this.pendingBrowserResolvers.delete(requestId);
+            reject(new Error("browser request timed out"));
+          }, 15e3);
+          this.pendingBrowserResolvers.set(requestId, { resolve: resolve9, reject, timer });
+          try {
+            this.onBrowserRequest(requestId, action, params, live.browserId, live.windowId);
+          } catch (err) {
+            this.pendingBrowserResolvers.delete(requestId);
+            clearTimeout(timer);
+            reject(err instanceof Error ? err : new Error(String(err)));
+          }
+        });
+      }
       /** Resolve a parked canUseTool decision (client replied with chat:permission).
        *  No-op if the request is unknown (already resolved / aborted). On "allow &
        *  don't ask again" (persist) we hand the SDK its own suggested permission
@@ -20595,9 +20868,9 @@ var init_agent_manager = __esm({
         const transcripts = [];
         for (const sid of sessionIds) {
           const msgs = await this.sessionStore.getSessionMessages(sid).catch(() => []);
-          const text = msgs.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n").slice(0, PER_SOURCE_CAP);
-          if (text.trim())
-            transcripts.push(text);
+          const text2 = msgs.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n").slice(0, PER_SOURCE_CAP);
+          if (text2.trim())
+            transcripts.push(text2);
         }
         if (transcripts.length === 0)
           return;
@@ -20676,6 +20949,11 @@ ${t}`)
         const cli = `ELECTRON_RUN_AS_NODE=1 "${process.execPath}" "${this.browserCliPath}"`;
         const pageInfo = url2 ? `
 The user's current browser tab is: ${url2}` : "";
+        const designClause = this.projectDir && existsSync2(join7(this.projectDir, TOKENS_FILE)) ? `
+
+DESIGN SYSTEM:
+- This project has a design system at design-system/tokens.json. For any UI you build or edit, use those tokens (colors, spacing, typography, radius) \u2014 call read_design_tokens to read values, set them with write_design_token, and NEVER hardcode hex/sizes that duplicate a token.` : "";
+        const mobileClause = this.projectDir ? buildMobileClause(this.projectDir) : "";
         return `You are Fineguide Tesseract, an AI assistant helping developers inspect and fix web pages.
 You have direct access to the browser connected to this conversation via CLI tools. Use the Bash tool to call them:${pageInfo}
 
@@ -20692,19 +20970,19 @@ CRITICAL RULES:
 - Use screenshot to see the visual state.
 - When element selectors are provided, use click or evaluate to interact.
 - You can read and edit project source files if a project directory is configured.
-- Always confirm before making destructive changes to source files.`;
+- Always confirm before making destructive changes to source files.${designClause}${mobileClause}`;
       }
       async sendMessage(params) {
         if (params.images && params.images.length > 0) {
-          const imgDir = join6(tmpdir(), "ccb-images");
-          await mkdir2(imgDir, { recursive: true });
+          const imgDir = join7(tmpdir(), "ccb-images");
+          await mkdir3(imgDir, { recursive: true });
           const paths = [];
           for (let i = 0; i < params.images.length; i++) {
             const match = params.images[i].match(/^data:image\/(\w+);base64,(.+)$/);
             if (match) {
               const ext = match[1] === "jpeg" ? "jpg" : match[1];
-              const filePath = join6(imgDir, `img-${process.pid}-${Date.now()}-${randomUUID2().slice(0, 8)}-${i}.${ext}`);
-              await writeFile2(filePath, Buffer.from(match[2], "base64"));
+              const filePath = join7(imgDir, `img-${process.pid}-${Date.now()}-${randomUUID2().slice(0, 8)}-${i}.${ext}`);
+              await writeFile3(filePath, Buffer.from(match[2], "base64"));
               paths.push(filePath);
             }
           }
@@ -20713,8 +20991,8 @@ CRITICAL RULES:
           }
         }
         if (params.files && params.files.length > 0) {
-          const fileDir = join6(tmpdir(), "ccb-files");
-          await mkdir2(fileDir, { recursive: true });
+          const fileDir = join7(tmpdir(), "ccb-files");
+          await mkdir3(fileDir, { recursive: true });
           const paths = [];
           for (let i = 0; i < params.files.length; i++) {
             const f = params.files[i];
@@ -20722,8 +21000,8 @@ CRITICAL RULES:
             if (!match)
               continue;
             const safe = (f.name || `file-${i}`).replace(/[^\w.\-]+/g, "_").slice(-100);
-            const filePath = join6(fileDir, `${process.pid}-${Date.now()}-${randomUUID2().slice(0, 8)}-${i}-${safe}`);
-            await writeFile2(filePath, Buffer.from(match[1], "base64"));
+            const filePath = join7(fileDir, `${process.pid}-${Date.now()}-${randomUUID2().slice(0, 8)}-${i}-${safe}`);
+            await writeFile3(filePath, Buffer.from(match[1], "base64"));
             paths.push(filePath);
           }
           if (paths.length > 0) {
@@ -20901,6 +21179,15 @@ CRITICAL RULES:
                   const cronTools = buildCronTools({ store: this.cronStore, pushEnabled: this.cronToolsDeps.pushEnabled, dispatchPush: this.cronToolsDeps.dispatchPush, getSessionId: () => live.sessionId || void 0 });
                   mcp["tesseract-cron"] = createSdkMcpServer({ name: "tesseract-cron", version: "0.1.0", tools: cronTools });
                 }
+                if (this.projectDir) {
+                  const designTools = buildDesignTools({
+                    getProjectDir: () => this.projectDir,
+                    driveBrowser: (action, params2) => this.requestBrowser(live, action, params2),
+                    getSessionId: () => live.sessionId || void 0,
+                    notifyPreviewReady: (url2, kind) => this.send({ type: "agent:preview_ready", sessionId: live.sessionId, previewUrl: url2, kind, ts: Date.now() }, live.origin)
+                  });
+                  mcp["tesseract-design"] = createSdkMcpServer({ name: "tesseract-design", version: "0.1.0", tools: designTools });
+                }
                 return Object.keys(mcp).length > 0 ? { mcpServers: mcp } : {};
               })(),
               // Skills (Epic H): a local plugin bundling the enabled ClawHub skills, so the SDK
@@ -20914,20 +21201,20 @@ CRITICAL RULES:
               // in acceptEdits, everything risky in default/auto). We park a Promise and
               // resolve it when the client replies via chat:permission (respondToPermission),
               // or deny on abort so an interrupted turn never leaks a pending decision.
-              canUseTool: (toolName, input, opts) => new Promise((resolve8) => {
+              canUseTool: (toolName, input, opts) => new Promise((resolve9) => {
                 const requestId = randomUUID2();
                 const onAbort = () => {
                   if (this.pendingPermissions.delete(requestId)) {
-                    resolve8({ behavior: "deny", message: "Interrupted.", interrupt: true });
+                    resolve9({ behavior: "deny", message: "Interrupted.", interrupt: true });
                   }
                 };
                 const cleanup2 = () => opts.signal.removeEventListener("abort", onAbort);
                 if (opts.signal.aborted) {
-                  resolve8({ behavior: "deny", message: "Interrupted.", interrupt: true });
+                  resolve9({ behavior: "deny", message: "Interrupted.", interrupt: true });
                   return;
                 }
                 opts.signal.addEventListener("abort", onAbort, { once: true });
-                this.pendingPermissions.set(requestId, { resolve: resolve8, suggestions: opts.suggestions, cleanup: cleanup2, origin: live.origin });
+                this.pendingPermissions.set(requestId, { resolve: resolve9, suggestions: opts.suggestions, cleanup: cleanup2, origin: live.origin });
                 const evt = {
                   type: "agent:permission_request",
                   sessionId: live.sessionId,
@@ -20953,19 +21240,19 @@ CRITICAL RULES:
               // M5 H6 — an MCP server requesting user input (a form, or url-based OAuth).
               // Default is auto-cancel; we park a Promise and raise an inline card, then
               // resolve it from chat:elicitation (respondToElicitation). Mirrors canUseTool.
-              onElicitation: (request, opts) => new Promise((resolve8) => {
+              onElicitation: (request, opts) => new Promise((resolve9) => {
                 const requestId = randomUUID2();
                 const onAbort = () => {
                   if (this.pendingElicitations.delete(requestId))
-                    resolve8({ action: "cancel" });
+                    resolve9({ action: "cancel" });
                 };
                 const cleanup2 = () => opts.signal.removeEventListener("abort", onAbort);
                 if (opts.signal.aborted) {
-                  resolve8({ action: "cancel" });
+                  resolve9({ action: "cancel" });
                   return;
                 }
                 opts.signal.addEventListener("abort", onAbort, { once: true });
-                this.pendingElicitations.set(requestId, { resolve: resolve8, cleanup: cleanup2, origin: live.origin });
+                this.pendingElicitations.set(requestId, { resolve: resolve9, cleanup: cleanup2, origin: live.origin });
                 const evt = {
                   type: "agent:elicitation_request",
                   sessionId: live.sessionId,
@@ -21185,26 +21472,26 @@ CRITICAL RULES:
                     emit({ type: "chat:stream", sessionId: sid, delta: event.delta.thinking, messageId: message.uuid, kind: "thinking", ...parentField });
                   }
                   if (event.delta?.type === "text_delta" && event.delta.text) {
-                    const text = event.delta.text;
-                    if (/<(?:tool_call|tool_result|function_calls|antml:function_calls)[\s>]/i.test(text)) {
+                    const text2 = event.delta.text;
+                    if (/<(?:tool_call|tool_result|function_calls|antml:function_calls)[\s>]/i.test(text2)) {
                       insideXmlByKey.set(key2, true);
                       break;
                     }
                     if (insideXmlByKey.get(key2)) {
-                      if (/<\/(?:tool_call|tool_result|function_calls|antml:function_calls)\s*>/i.test(text)) {
+                      if (/<\/(?:tool_call|tool_result|function_calls|antml:function_calls)\s*>/i.test(text2)) {
                         insideXmlByKey.set(key2, false);
                       }
                       break;
                     }
-                    if (/<\/?(?:invoke|antml:invoke|antml:parameter)[\s>]/.test(text))
+                    if (/<\/?(?:invoke|antml:invoke|antml:parameter)[\s>]/.test(text2))
                       break;
-                    if (/<parameter\s+name=/.test(text))
+                    if (/<parameter\s+name=/.test(text2))
                       break;
-                    if (/^\s*<\/(?:parameter|invoke|function_calls)>\s*$/.test(text))
+                    if (/^\s*<\/(?:parameter|invoke|function_calls)>\s*$/.test(text2))
                       break;
                     if (parentToolUseId === void 0)
                       turnStreamed = true;
-                    emit({ type: "chat:stream", sessionId: sid, delta: text, messageId: message.uuid, kind: "text", ...parentField });
+                    emit({ type: "chat:stream", sessionId: sid, delta: text2, messageId: message.uuid, kind: "text", ...parentField });
                   }
                   if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
                     const acc = blockAcc.get(key2);
@@ -21447,11 +21734,11 @@ Compacted earlier context.` });
                   case "files_persisted":
                     break;
                   default: {
-                    const text = extractHumanReadable(m);
+                    const text2 = extractHumanReadable(m);
                     const header = systemHeader("system", subtype);
-                    const body = text ? `${header}
+                    const body = text2 ? `${header}
 
-${text}` : header;
+${text2}` : header;
                     emit({ type: "agent:tool_use", sessionId: sid, toolName: "_notice_", summary: body });
                     log("best-effort surfaced unknown system subtype:", subtype ?? "?");
                     break;
@@ -21487,12 +21774,12 @@ ${text}` : header;
                       const tn = toolNameByUseId.get(toolUseId);
                       if (tn === "Edit" || tn === "Write" || tn === "MultiEdit" || tn === "NotebookEdit")
                         continue;
-                      const { text, truncated } = flattenToolResultContent(blk.content);
+                      const { text: text2, truncated } = flattenToolResultContent(blk.content);
                       const images = extractImages(blk.content);
                       const isError = blk.is_error === true;
-                      if (!text && images.length === 0 && !isError)
+                      if (!text2 && images.length === 0 && !isError)
                         continue;
-                      emit({ type: "agent:tool_result", sessionId: sid, toolUseId, isError, output: text, images, truncated, ...agentId ? { agentId } : {} });
+                      emit({ type: "agent:tool_result", sessionId: sid, toolUseId, isError, output: text2, images, truncated, ...agentId ? { agentId } : {} });
                     } else if (blk?.type === "web_search_tool_result") {
                       const toolUseId = blk.tool_use_id;
                       if (!toolUseId)
@@ -21509,11 +21796,11 @@ ${text}` : header;
                 break;
               default: {
                 const m = message;
-                const text = extractHumanReadable(m);
+                const text2 = extractHumanReadable(m);
                 const header = systemHeader(m.type || "unknown");
-                const body = text ? `${header}
+                const body = text2 ? `${header}
 
-${text}` : header;
+${text2}` : header;
                 emit({ type: "agent:tool_use", sessionId: sid, toolName: "_notice_", summary: body });
                 log("best-effort surfaced unknown SDK message type:", m.type || "?");
                 break;
@@ -21818,6 +22105,8 @@ Element ${i + 1}:`);
             parts.push(`  XPath: ${a.xpath}`, `  CSS: ${a.selector}`, `  HTML: ${a.htmlSnippet}`);
             if (a.textPreview)
               parts.push(`  Text: "${a.textPreview}"`);
+            if (a.sourceLoc)
+              parts.push(`  Source: ${a.sourceLoc.file}:${a.sourceLoc.line}${a.sourceLoc.column != null ? `:${a.sourceLoc.column}` : ""} (edit the element here)`);
           }
         }
         return parts.join("\n");
@@ -21830,15 +22119,23 @@ Element ${i + 1}:`);
 var dist_exports = {};
 __export(dist_exports, {
   AgentManager: () => AgentManager,
+  DESIGN_CLAUDE_MD: () => DESIGN_CLAUDE_MD,
+  DESIGN_DIR: () => DESIGN_DIR,
+  DesignTokensSchema: () => DesignTokensSchema,
   SessionStore: () => SessionStore,
+  TOKENS_CSS_FILE: () => TOKENS_CSS_FILE,
+  TOKENS_FILE: () => TOKENS_FILE,
   buildClaudeNarrationLlm: () => buildClaudeNarrationLlm,
   exportSession: () => exportSession,
+  getTokenPath: () => getTokenPath,
   importSession: () => importSession,
   log: () => log,
   resolveOauthToken: () => resolveOauthToken,
   sanitizeProjectDir: () => sanitizeProjectDir,
   sessionDir: () => sessionDir,
   sessionFile: () => sessionFile,
+  setTokenPath: () => setTokenPath,
+  tokensToCss: () => tokensToCss,
   transferSession: () => transferSession
 });
 var init_dist2 = __esm({
@@ -21849,6 +22146,7 @@ var init_dist2 = __esm({
     init_session_usage();
     init_session_transfer();
     init_log();
+    init_design_tokens();
   }
 });
 
@@ -23056,11 +23354,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve8) {
-      resolve8(value);
+    return value instanceof P ? value : new P(function(resolve9) {
+      resolve9(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve8, reject) {
+  return new (P || (P = Promise))(function(resolve9, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -23076,7 +23374,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -23267,14 +23565,14 @@ function __asyncValues(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve8, reject) {
-        v = o[n](v), settle(resolve8, reject, v.done, v.value);
+      return new Promise(function(resolve9, reject) {
+        v = o[n](v), settle(resolve9, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve8, reject, d, v) {
+  function settle(resolve9, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve8({ value: v2, done: d });
+      resolve9({ value: v2, done: d });
     }, reject);
   }
 }
@@ -23552,8 +23850,8 @@ var require_build = __commonJS({
     var BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
     var BASE64URL_REGEX = /^[a-zA-Z0-9-_]+$/;
     var Utf8Converter = class {
-      static fromString(text) {
-        const s = unescape(encodeURIComponent(text));
+      static fromString(text2) {
+        const s = unescape(encodeURIComponent(text2));
         const uintArray = new Uint8Array(s.length);
         for (let i = 0; i < s.length; i++) {
           uintArray[i] = s.charCodeAt(i);
@@ -23581,11 +23879,11 @@ var require_build = __commonJS({
         }
         return res;
       }
-      static fromString(text, littleEndian = false) {
-        const res = new ArrayBuffer(text.length * 2);
+      static fromString(text2, littleEndian = false) {
+        const res = new ArrayBuffer(text2.length * 2);
         const dataView = new DataView(res);
-        for (let i = 0; i < text.length; i++) {
-          dataView.setUint16(i * 2, text.charCodeAt(i), littleEndian);
+        for (let i = 0; i < text2.length; i++) {
+          dataView.setUint16(i * 2, text2.charCodeAt(i), littleEndian);
         }
         return res;
       }
@@ -23682,18 +23980,18 @@ var require_build = __commonJS({
       static ToBase64Url(data) {
         return this.ToBase64(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
       }
-      static FromUtf8String(text, encoding = _Convert.DEFAULT_UTF8_ENCODING) {
+      static FromUtf8String(text2, encoding = _Convert.DEFAULT_UTF8_ENCODING) {
         switch (encoding) {
           case "ascii":
-            return this.FromBinary(text);
+            return this.FromBinary(text2);
           case "utf8":
-            return Utf8Converter.fromString(text);
+            return Utf8Converter.fromString(text2);
           case "utf16":
           case "utf16be":
-            return Utf16Converter.fromString(text);
+            return Utf16Converter.fromString(text2);
           case "utf16le":
           case "usc2":
-            return Utf16Converter.fromString(text, true);
+            return Utf16Converter.fromString(text2, true);
           default:
             throw new Error(`Unknown type of encoding '${encoding}'`);
         }
@@ -23714,11 +24012,11 @@ var require_build = __commonJS({
             throw new Error(`Unknown type of encoding '${encoding}'`);
         }
       }
-      static FromBinary(text) {
-        const stringLength = text.length;
+      static FromBinary(text2) {
+        const stringLength = text2.length;
         const resultView = new Uint8Array(stringLength);
         for (let i = 0; i < stringLength; i++) {
-          resultView[i] = text.charCodeAt(i);
+          resultView[i] = text2.charCodeAt(i);
         }
         return resultView.buffer;
       }
@@ -23764,8 +24062,8 @@ var require_build = __commonJS({
       static ToUtf16String(buffer, littleEndian = false) {
         return Utf16Converter.toString(buffer, littleEndian);
       }
-      static FromUtf16String(text, littleEndian = false) {
-        return Utf16Converter.fromString(text, littleEndian);
+      static FromUtf16String(text2, littleEndian = false) {
+        return Utf16Converter.fromString(text2, littleEndian);
       }
       static Base64Padding(base643) {
         const padCount = 4 - base643.length % 4;
@@ -27526,15 +27824,15 @@ var require_sequence = __commonJS({
       }
       return normalized;
     }
-    function encodeAscii(text) {
-      const bytes = new Uint8Array(text.length);
-      for (let i = 0; i < text.length; i++) {
-        bytes[i] = text.charCodeAt(i) & 255;
+    function encodeAscii(text2) {
+      const bytes = new Uint8Array(text2.length);
+      for (let i = 0; i < text2.length; i++) {
+        bytes[i] = text2.charCodeAt(i) & 255;
       }
       return bytes;
     }
-    function encodeUtf8(text) {
-      return new TextEncoder().encode(text);
+    function encodeUtf8(text2) {
+      return new TextEncoder().encode(text2);
     }
     function toPatternBytes(pattern, options) {
       if (typeof pattern === "string") {
@@ -28909,15 +29207,15 @@ var require_binary = __commonJS({
       }
       return result;
     }
-    function decode3(text) {
-      const result = new Uint8Array(text.length);
-      for (let i = 0; i < text.length; i++) {
-        result[i] = text.charCodeAt(i) & 255;
+    function decode3(text2) {
+      const result = new Uint8Array(text2.length);
+      for (let i = 0; i < text2.length; i++) {
+        result[i] = text2.charCodeAt(i) & 255;
       }
       return result;
     }
-    function is(text) {
-      return typeof text === "string";
+    function is(text2) {
+      return typeof text2 === "string";
     }
     exports.binary = { encode: encode3, decode: decode3, is };
   }
@@ -28952,31 +29250,31 @@ var require_hex = __commonJS({
         throw new TypeError("Hex separators must be non-empty strings");
       }
     }
-    function matchSeparator(text, index, separators) {
+    function matchSeparator(text2, index, separators) {
       for (const separator of separators) {
-        if (text.startsWith(separator, index)) {
+        if (text2.startsWith(separator, index)) {
           return separator;
         }
       }
       return void 0;
     }
-    function detectCase(text) {
-      const hasUpper = /[A-F]/.test(text);
-      const hasLower = /[a-f]/.test(text);
+    function detectCase(text2) {
+      const hasUpper = /[A-F]/.test(text2);
+      const hasLower = /[a-f]/.test(text2);
       return hasUpper && !hasLower ? "upper" : "lower";
     }
-    function detectLineSeparator(text) {
-      const match = /\r\n|\n/.exec(text);
+    function detectLineSeparator(text2) {
+      const match = /\r\n|\n/.exec(text2);
       if (!match) {
         return void 0;
       }
       return match[0] === "\r\n" ? "\r\n" : "\n";
     }
-    function compactForDetection(text) {
-      return text.replace(/[^0-9a-f]/gi, "");
+    function compactForDetection(text2) {
+      return text2.replace(/[^0-9a-f]/gi, "");
     }
-    function detectGroup(text) {
-      const segments = text.match(/[0-9A-Fa-f]+|[^0-9A-Fa-f]+/g) ?? [];
+    function detectGroup(text2) {
+      const segments = text2.match(/[0-9A-Fa-f]+|[^0-9A-Fa-f]+/g) ?? [];
       if (segments.length < 3) {
         return void 0;
       }
@@ -29004,8 +29302,8 @@ var require_hex = __commonJS({
         separator
       };
     }
-    function detectFormat(text) {
-      const trimmed = text.trim();
+    function detectFormat(text2) {
+      const trimmed = text2.trim();
       const prefix = /^0x/i.test(trimmed) ? "0x" : "";
       const body = prefix ? trimmed.slice(2) : trimmed;
       const lineSeparator = detectLineSeparator(body);
@@ -29030,13 +29328,13 @@ var require_hex = __commonJS({
       }
       return format2;
     }
-    function normalizeText(text, options) {
+    function normalizeText(text2, options) {
       const allowPrefix = options.allowPrefix ?? true;
       const separators = [...resolveSeparators(options)].sort((left, right) => right.length - left.length);
       for (const separator of separators) {
         validateSeparator(separator);
       }
-      let working = text.trim();
+      let working = text2.trim();
       if (/^0x/i.test(working)) {
         if (!allowPrefix) {
           throw new TypeError("Hexadecimal text must not include a 0x prefix");
@@ -29087,15 +29385,15 @@ var require_hex = __commonJS({
       }
       return chunks.join(group.separator);
     }
-    function normalize2(text, options = {}) {
-      return normalizeText(text, options);
+    function normalize2(text2, options = {}) {
+      return normalizeText(text2, options);
     }
-    function is(text, options = {}) {
-      if (typeof text !== "string") {
+    function is(text2, options = {}) {
+      if (typeof text2 !== "string") {
         return false;
       }
       try {
-        normalize2(text, options);
+        normalize2(text2, options);
         return true;
       } catch {
         return false;
@@ -29105,8 +29403,8 @@ var require_hex = __commonJS({
       const bytes = (0, index_js_1.toUint8Array)(data);
       const casing = options.case ?? "lower";
       const pairs = Array.from(bytes, (byte) => {
-        const text = byte.toString(16).padStart(2, "0");
-        return casing === "upper" ? text.toUpperCase() : text;
+        const text2 = byte.toString(16).padStart(2, "0");
+        return casing === "upper" ? text2.toUpperCase() : text2;
       });
       let body = "";
       if (options.line) {
@@ -29125,19 +29423,19 @@ var require_hex = __commonJS({
       }
       return `${options.prefix ?? ""}${body}`;
     }
-    function decode3(text, options = {}) {
-      const normalized = normalize2(text, options);
+    function decode3(text2, options = {}) {
+      const normalized = normalize2(text2, options);
       const result = new Uint8Array(normalized.length / 2);
       for (let i = 0; i < normalized.length; i += 2) {
         result[i / 2] = Number.parseInt(normalized.slice(i, i + 2), 16);
       }
       return result;
     }
-    function parse3(text, options = {}) {
-      const normalized = normalize2(text, options);
+    function parse3(text2, options = {}) {
+      const normalized = normalize2(text2, options);
       return {
         bytes: decode3(normalized),
-        format: detectFormat(text),
+        format: detectFormat(text2),
         normalized
       };
     }
@@ -29165,8 +29463,8 @@ var require_utf8 = __commonJS({
     exports.encode = encode3;
     exports.decode = decode3;
     var index_js_1 = require_bytes();
-    function encode3(text) {
-      return new TextEncoder().encode(text);
+    function encode3(text2) {
+      return new TextEncoder().encode(text2);
     }
     function decode3(data) {
       return new TextDecoder("utf-8", { fatal: false }).decode((0, index_js_1.toUint8Array)(data));
@@ -29184,11 +29482,11 @@ var require_utf16 = __commonJS({
     exports.encode = encode3;
     exports.decode = decode3;
     var index_js_1 = require_bytes();
-    function encode3(text, options = {}) {
-      const result = new ArrayBuffer(text.length * 2);
+    function encode3(text2, options = {}) {
+      const result = new ArrayBuffer(text2.length * 2);
       const view = new DataView(result);
-      for (let i = 0; i < text.length; i++) {
-        view.setUint16(i * 2, text.charCodeAt(i), options.littleEndian ?? false);
+      for (let i = 0; i < text2.length; i++) {
+        view.setUint16(i * 2, text2.charCodeAt(i), options.littleEndian ?? false);
       }
       return new Uint8Array(result);
     }
@@ -29222,18 +29520,18 @@ var require_base64 = __commonJS({
     function nodeBuffer() {
       return globalThis.Buffer;
     }
-    function normalize2(text) {
-      return text.replace(/[\n\r\t ]/g, "");
+    function normalize2(text2) {
+      return text2.replace(/[\n\r\t ]/g, "");
     }
-    function pad(text) {
-      const remainder = text.length % 4;
-      return remainder ? text + "=".repeat(4 - remainder) : text;
+    function pad(text2) {
+      const remainder = text2.length % 4;
+      return remainder ? text2 + "=".repeat(4 - remainder) : text2;
     }
-    function is(text) {
-      if (typeof text !== "string") {
+    function is(text2) {
+      if (typeof text2 !== "string") {
         return false;
       }
-      const normalized = normalize2(text);
+      const normalized = normalize2(text2);
       return normalized === "" || BASE64_REGEX.test(normalized);
     }
     function encode3(data, _options) {
@@ -29244,8 +29542,8 @@ var require_base64 = __commonJS({
       }
       return btoa((0, binary_js_1.encode)(bytes));
     }
-    function decode3(text, _options) {
-      const normalized = normalize2(text);
+    function decode3(text2, _options) {
+      const normalized = normalize2(text2);
       if (!is(normalized)) {
         throw new TypeError("Input is not valid Base64 text");
       }
@@ -29271,17 +29569,17 @@ var require_base64url = __commonJS({
     exports.decode = decode3;
     var base64_js_1 = require_base64();
     var BASE64URL_REGEX = /^[A-Za-z0-9_-]*$/;
-    function normalize2(text) {
-      return text.replace(/[\n\r\t ]/g, "");
+    function normalize2(text2) {
+      return text2.replace(/[\n\r\t ]/g, "");
     }
-    function is(text) {
-      return typeof text === "string" && BASE64URL_REGEX.test(normalize2(text));
+    function is(text2) {
+      return typeof text2 === "string" && BASE64URL_REGEX.test(normalize2(text2));
     }
     function encode3(data, _options) {
       return base64_js_1.base64.encode(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
     }
-    function decode3(text, _options) {
-      const normalized = normalize2(text);
+    function decode3(text2, _options) {
+      const normalized = normalize2(text2);
       if (!is(normalized)) {
         throw new TypeError("Input is not valid Base64Url text");
       }
@@ -29402,8 +29700,8 @@ var require_ip_converter = __commonJS({
         }
         return ip;
       }
-      static parseCIDR(text) {
-        const [addr, prefixStr] = text.split("/");
+      static parseCIDR(text2) {
+        const [addr, prefixStr] = text2.split("/");
         const prefix = parseInt(prefixStr, 10);
         if (this.isIPv4(addr)) {
           if (prefix < 0 || prefix > 32) {
@@ -29456,9 +29754,9 @@ var require_ip_converter = __commonJS({
         }
         return this.decodeIP(encoding_1.hex.encode(buf));
       }
-      static fromString(text) {
-        if (text.includes("/")) {
-          const [addr, prefix] = this.parseCIDR(text);
+      static fromString(text2) {
+        if (text2.includes("/")) {
+          const [addr, prefix] = this.parseCIDR(text2);
           const maskBytes = new Uint8Array(addr.length);
           let bitsLeft = prefix;
           for (let i = 0; i < maskBytes.length; i++) {
@@ -29475,7 +29773,7 @@ var require_ip_converter = __commonJS({
           out.set(maskBytes, addr.length);
           return out.buffer;
         }
-        const bytes = this.isIPv4(text) ? this.parseIPv4(text) : this.parseIPv6(text);
+        const bytes = this.isIPv4(text2) ? this.parseIPv4(text2) : this.parseIPv6(text2);
         return new Uint8Array(bytes).buffer;
       }
     };
@@ -34286,11 +34584,11 @@ function __metadata2(metadataKey, metadataValue) {
 }
 function __awaiter2(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve8) {
-      resolve8(value);
+    return value instanceof P ? value : new P(function(resolve9) {
+      resolve9(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve8, reject) {
+  return new (P || (P = Promise))(function(resolve9, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -34306,7 +34604,7 @@ function __awaiter2(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -34484,14 +34782,14 @@ function __asyncValues2(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve8, reject) {
-        v = o[n](v), settle(resolve8, reject, v.done, v.value);
+      return new Promise(function(resolve9, reject) {
+        v = o[n](v), settle(resolve9, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve8, reject, d, v) {
+  function settle(resolve9, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve8({ value: v2, done: d });
+      resolve9({ value: v2, done: d });
     }, reject);
   }
 }
@@ -37155,24 +37453,24 @@ var require_x509_cjs = __commonJS({
     names.register("I", "2.5.4.43");
     names.register("SN", "2.5.4.4");
     names.register("T", "2.5.4.12");
-    function replaceUnknownCharacter(text, char) {
+    function replaceUnknownCharacter(text2, char) {
       return `\\${pvtsutils.Convert.ToHex(pvtsutils.Convert.FromUtf8String(char)).toUpperCase()}`;
     }
     function escape2(data) {
       return data.replace(/([,+"\\<>;])/g, "\\$1").replace(/^([ #])/, "\\$1").replace(/([ ]$)/, "\\$1").replace(/([\r\n\t])/, replaceUnknownCharacter);
     }
     var Name = class _Name {
-      static isASCII(text) {
-        for (let i = 0; i < text.length; i++) {
-          const code = text.charCodeAt(i);
+      static isASCII(text2) {
+        for (let i = 0; i < text2.length; i++) {
+          const code = text2.charCodeAt(i);
           if (code > 255) {
             return false;
           }
         }
         return true;
       }
-      static isPrintableString(text) {
-        return /^[A-Za-z0-9 '()+,-./:=?]*$/g.test(text);
+      static isPrintableString(text2) {
+        return /^[A-Za-z0-9 '()+,-./:=?]*$/g.test(text2);
       }
       constructor(data, extraNames = {}) {
         this.extraNames = new NameIdentifier();
@@ -40394,7 +40692,6 @@ var init_stun = __esm({
 // ../../packages/host-core/dist/peer-link/quic-transport.js
 var quic_transport_exports = {};
 __export(quic_transport_exports, {
-  QUIC_ENABLED: () => QUIC_ENABLED,
   discoverSrflx: () => discoverSrflx,
   makeQuicSocket: () => makeQuicSocket,
   nudgePunch: () => nudgePunch,
@@ -40404,7 +40701,6 @@ __export(quic_transport_exports, {
 import { webcrypto } from "node:crypto";
 import { createHmac } from "node:crypto";
 import { EventEmitter } from "node:events";
-import { QUICClient, QUICServer, QUICSocket, events as quicEvents } from "@matrixai/quic";
 function serverCrypto() {
   const key2 = webcrypto.getRandomValues(new Uint8Array(32));
   return {
@@ -40487,12 +40783,14 @@ function pinningVerify(expectedFingerprint256) {
   };
 }
 async function makeQuicSocket(localPort) {
-  const socket2 = new QUICSocket({});
+  const { QUICSocket: QUICSocketCtor } = await loadQuic();
+  const socket2 = new QUICSocketCtor({});
   await socket2.start({ host: "0.0.0.0", port: localPort, reuseAddr: true });
   return socket2;
 }
 async function quicDialLink(opts) {
-  const client = await QUICClient.createQUICClient({
+  const { QUICClient: QUICClientCtor } = await loadQuic();
+  const client = await QUICClientCtor.createQUICClient({
     socket: opts.socket,
     host: opts.host,
     port: opts.port,
@@ -40505,7 +40803,8 @@ async function quicDialLink(opts) {
   return link;
 }
 async function startQuicServerOnSocket(opts) {
-  const server = new QUICServer({
+  const { QUICServer: QUICServerCtor, events: quicEvents } = await loadQuic();
+  const server = new QUICServerCtor({
     crypto: serverCrypto(),
     config: { applicationProtos: ALPN, key: opts.identity.key, cert: opts.identity.cert, verifyPeer: false },
     socket: opts.socket
@@ -40523,7 +40822,7 @@ async function startQuicServerOnSocket(opts) {
 function discoverSrflx(socket2, stunHost, stunPort, timeoutMs = 3e3) {
   const dgramSock = socket2.socket;
   const { packet, txId } = encodeBindingRequest();
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const timer = setTimeout(() => {
       dgramSock.removeListener("message", onMsg);
       reject(new Error("quic: STUN timeout"));
@@ -40533,7 +40832,7 @@ function discoverSrflx(socket2, stunHost, stunPort, timeoutMs = 3e3) {
       if (mapped) {
         clearTimeout(timer);
         dgramSock.removeListener("message", onMsg);
-        resolve8(`${mapped.ip}:${mapped.port}`);
+        resolve9(`${mapped.ip}:${mapped.port}`);
       }
     };
     dgramSock.on("message", onMsg);
@@ -40554,14 +40853,15 @@ async function nudgePunch(socket2, peerIp, peerPort, count = 12, intervalMs = 10
     await new Promise((r) => setTimeout(r, intervalMs));
   }
 }
-var QUIC_ENABLED, ALPN, clientCrypto;
+var ALPN, quicModP, loadQuic, clientCrypto;
 var init_quic_transport = __esm({
   "../../packages/host-core/dist/peer-link/quic-transport.js"() {
     "use strict";
     init_transport();
     init_stun();
-    QUIC_ENABLED = process.env.CCB_P2P_QUIC === "1";
     ALPN = ["tesseract-peer"];
+    quicModP = null;
+    loadQuic = () => quicModP ??= import("@matrixai/quic");
     clientCrypto = {
       ops: { randomBytes: async (data) => {
         webcrypto.getRandomValues(new Uint8Array(data));
@@ -41641,17 +41941,17 @@ var require_main = __commonJS({
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync12 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 import { createHash as createHash5 } from "node:crypto";
 import { spawn as spawn7 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { homedir as homedir14 } from "node:os";
-import { dirname as dirname16, join as join32, resolve as resolve7 } from "node:path";
+import { dirname as dirname16, join as join33, resolve as resolve8 } from "node:path";
 import { createInterface } from "node:readline/promises";
 
 // ../../packages/host-core/dist/control-link.js
 import { hostname as hostname3, homedir as homedir10 } from "node:os";
-import { join as join25, basename as basename5 } from "node:path";
+import { join as join26, basename as basename5 } from "node:path";
 import { mkdirSync as mkdirSync9 } from "node:fs";
 
 // ../../node_modules/ws/wrapper.mjs
@@ -41699,7 +41999,7 @@ function isInsideRoot(p, root) {
 }
 
 // ../../packages/host-core/dist/daemon-agent.js
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 
 // ../../packages/host-core/dist/agent-backend.js
 async function createClaudeCodeBackend(send2, onBrowserRequest, loadPluginRuntime2) {
@@ -41768,10 +42068,10 @@ var CliAgentBackend = class {
   id;
   capabilities;
   live = /* @__PURE__ */ new Map();
-  constructor(adapter, send2, resolve8) {
+  constructor(adapter, send2, resolve9) {
     this.adapter = adapter;
     this.send = send2;
-    this.resolve = resolve8;
+    this.resolve = resolve9;
     this.id = adapter.id;
     this.capabilities = adapter.capabilities;
   }
@@ -42039,9 +42339,9 @@ var geminiAdapter = {
   },
   translate(event, raw, emit, ctx) {
     const o = asObj3(event);
-    const text = o ? typeof o.response === "string" ? o.response : bestEffortText(o) : typeof event === "string" ? event : raw;
-    if (text)
-      emit({ type: "chat:stream", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, delta: text, messageId: ctx.messageId, kind: "text" });
+    const text2 = o ? typeof o.response === "string" ? o.response : bestEffortText(o) : typeof event === "string" ? event : raw;
+    if (text2)
+      emit({ type: "chat:stream", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, delta: text2, messageId: ctx.messageId, kind: "text" });
     const tools = o?.tools;
     if (Array.isArray(tools)) {
       for (const t of tools) {
@@ -42067,25 +42367,25 @@ var openclawAdapter = {
   translate(event, raw, emit, ctx) {
     const o = asObj4(event);
     const result = asObj4(o?.result) ?? o;
-    let text = "";
+    let text2 = "";
     const payloads = result?.payloads;
     if (Array.isArray(payloads)) {
-      text = payloads.map((p) => {
+      text2 = payloads.map((p) => {
         const t = asObj4(p)?.text;
         return typeof t === "string" ? t : "";
       }).filter(Boolean).join("\n");
     }
-    if (!text) {
+    if (!text2) {
       const fav = asObj4(result?.meta)?.finalAssistantVisibleText;
       if (typeof fav === "string")
-        text = fav;
+        text2 = fav;
     }
-    if (!text)
-      text = o ? bestEffortText(result ?? o) : typeof event === "string" ? event : raw;
-    if (text)
-      emit({ type: "chat:stream", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, delta: text, messageId: ctx.messageId, kind: "text" });
+    if (!text2)
+      text2 = o ? bestEffortText(result ?? o) : typeof event === "string" ? event : raw;
+    if (text2)
+      emit({ type: "chat:stream", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, delta: text2, messageId: ctx.messageId, kind: "text" });
     const status2 = typeof o?.status === "string" ? o.status : void 0;
-    if (!text && status2 && status2 !== "ok" && status2 !== "accepted") {
+    if (!text2 && status2 && status2 !== "ok" && status2 !== "accepted") {
       const summary = typeof o?.summary === "string" && o.summary ? o.summary : `OpenClaw run ${status2}.`;
       emit({ type: "chat:error", sessionId: ctx.sessionId, clientRequestId: ctx.clientRequestId, error: summary });
     }
@@ -42133,7 +42433,7 @@ init_dist2();
 
 // ../../packages/host-core/dist/plugin-tools.js
 import { existsSync as existsSync3 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // ../../packages/plugin-host/dist/discovery.js
 import fs2 from "node:fs";
@@ -42303,8 +42603,8 @@ function createOpenClawAdapter(pluginId, config2, secretResolver, registry2) {
     pluginId,
     config: config2,
     secret: (envKey2) => secretResolver(pluginId, envKey2),
-    registerTool: (tool2) => {
-      const got = typeof tool2 === "function" ? tool2({}) : tool2;
+    registerTool: (tool3) => {
+      const got = typeof tool3 === "function" ? tool3({}) : tool3;
       const arr = Array.isArray(got) ? got : got ? [got] : [];
       for (const t of arr) {
         const c = convertTool(t);
@@ -42373,10 +42673,10 @@ var HostPluginApi = class {
   secret(envKey2) {
     return this.secretResolver(this.pluginId, envKey2);
   }
-  registerTool(tool2) {
+  registerTool(tool3) {
     const prefix = this.pluginId.replace(/[^a-zA-Z0-9_]/g, "_");
-    const name = tool2.name.startsWith(`${prefix}_`) ? tool2.name : `${prefix}_${tool2.name}`;
-    this.registry.tools.push({ ...tool2, name });
+    const name = tool3.name.startsWith(`${prefix}_`) ? tool3.name : `${prefix}_${tool3.name}`;
+    this.registry.tools.push({ ...tool3, name });
   }
   registerHook(reg) {
     this.registry.hooks.push(reg);
@@ -42481,7 +42781,7 @@ async function loadPluginRuntime(opts) {
 }
 function buildDaemonPluginLoader(pluginsDir) {
   return async () => {
-    const scan = join7(pluginsDir, "node_modules");
+    const scan = join8(pluginsDir, "node_modules");
     if (!existsSync3(scan))
       return { tools: [], hooks: [], engines: [] };
     writeOpenClawShim(pluginsDir);
@@ -42493,18 +42793,18 @@ function buildDaemonPluginLoader(pluginsDir) {
 }
 
 // ../../packages/host-core/dist/credentials.js
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync4, renameSync as renameSync3, chmodSync } from "node:fs";
-import { join as join8 } from "node:path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync4, renameSync as renameSync3, chmodSync } from "node:fs";
+import { join as join9 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 function daemonDir() {
-  return process.env.CCB_DAEMON_DIR ?? join8(homedir3(), ".tesseract", "daemon");
+  return process.env.CCB_DAEMON_DIR ?? join9(homedir3(), ".tesseract", "daemon");
 }
 function credentialsPath() {
-  return join8(daemonDir(), "credentials.json");
+  return join9(daemonDir(), "credentials.json");
 }
 function readCredentials() {
   try {
-    const c = JSON.parse(readFileSync3(credentialsPath(), "utf-8"));
+    const c = JSON.parse(readFileSync4(credentialsPath(), "utf-8"));
     if (c.accessToken && c.refreshSecret && c.dtid && c.deviceId && c.userId && c.backendOrigin && c.apiOrigin) {
       return c;
     }
@@ -42808,13 +43108,13 @@ async function closeEnginePage(browserId) {
 }
 
 // ../../packages/host-core/dist/daemon-settings.js
-import { readFileSync as readFileSync6 } from "node:fs";
-import { join as join13 } from "node:path";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { join as join14 } from "node:path";
 
 // ../../packages/host-core/dist/runners/resolve.js
-import { readFileSync as readFileSync4, existsSync as existsSync6, statSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { readFileSync as readFileSync5, existsSync as existsSync6, statSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 
 // ../../packages/shared/dist/ws-protocol.js
@@ -42837,6 +43137,8 @@ var MIRRORED_AGENT_EVENTS = /* @__PURE__ */ new Set([
   // plan review — co-viewers see the sectioned plan
   "agent:narration",
   // live status strip — co-viewers see "what it's doing now"
+  "agent:preview_ready",
+  // co-viewers (incl. mobile) see the preview the moment it's ready
   "agent:elicitation_complete",
   // M5 — co-viewers clear a resolved url-mode card
   "chat:echoed",
@@ -43286,22 +43588,22 @@ import { createRequire as createRequire2 } from "node:module";
 import { randomUUID as randomUUID4, createHash } from "node:crypto";
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join9, dirname as dirname5, sep as sep2 } from "node:path";
+import { join as join10, dirname as dirname5, sep as sep2 } from "node:path";
 import { request as httpRequest } from "node:http";
 var requireFromHere = createRequire2(import.meta.url);
 var ROUTER_PORT = 8787;
 var BIND_HOST = "127.0.0.1";
 var ROUTER_TOKEN = randomUUID4();
-var routerHomeDir = join9(homedir4(), ".tesseract", "router-home");
+var routerHomeDir = join10(homedir4(), ".tesseract", "router-home");
 var lastConfigHash = "";
 var running = false;
 var starting = null;
 function configPath() {
-  return join9(routerHomeDir, ".claude-code-router", "config.json");
+  return join10(routerHomeDir, ".claude-code-router", "config.json");
 }
 function ccrCliPath() {
   const pkg = requireFromHere.resolve("@musistudio/claude-code-router/package.json");
-  const cli = join9(dirname5(pkg), "dist", "cli.js");
+  const cli = join10(dirname5(pkg), "dist", "cli.js");
   return cli.replace(`app.asar${sep2}`, `app.asar.unpacked${sep2}`);
 }
 var cachedNodeExe2;
@@ -43391,39 +43693,39 @@ function buildRouterConfig(d) {
   };
 }
 function writeConfig(cfg2) {
-  const dir = join9(routerHomeDir, ".claude-code-router");
+  const dir = join10(routerHomeDir, ".claude-code-router");
   if (!existsSync5(dir))
     mkdirSync3(dir, { recursive: true });
   writeFileSync4(configPath(), JSON.stringify(cfg2, null, 2), { mode: 384 });
 }
 function ccr(args, timeout = 8e3) {
   const { exe, asNode } = nodeExe();
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     execFile2(exe, [ccrCliPath(), ...args], { env: ccrEnv(asNode), timeout }, (err, stdout, stderr) => {
-      resolve8({ ok: !err, out: `${stdout || ""}${stderr || ""}` });
+      resolve9({ ok: !err, out: `${stdout || ""}${stderr || ""}` });
     });
   });
 }
 function waitHealthy(timeoutMs = 8e3) {
   const deadline = Date.now() + timeoutMs;
-  const ping = () => new Promise((resolve8) => {
+  const ping = () => new Promise((resolve9) => {
     const req = httpRequest({ host: BIND_HOST, port: ROUTER_PORT, path: "/", method: "GET", timeout: 1e3 }, (res) => {
       res.resume();
-      resolve8(true);
+      resolve9(true);
     });
-    req.on("error", () => resolve8(false));
+    req.on("error", () => resolve9(false));
     req.on("timeout", () => {
       req.destroy();
-      resolve8(false);
+      resolve9(false);
     });
     req.end();
   });
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const tick = async () => {
       if (await ping())
-        return resolve8(true);
+        return resolve9(true);
       if (Date.now() > deadline)
-        return resolve8(false);
+        return resolve9(false);
       setTimeout(() => void tick(), 400);
     };
     void tick();
@@ -43463,13 +43765,13 @@ function routerEndpointSync(desired) {
 }
 
 // ../../packages/host-core/dist/runners/resolve.js
-var runnerHomeBase = join10(homedir5(), ".tesseract", "runner-home");
+var runnerHomeBase = join11(homedir5(), ".tesseract", "runner-home");
 function materializeClaudeAuthHome(contents) {
   const id = createHash2("sha256").update(contents).digest("hex").slice(0, 16);
-  const home = join10(runnerHomeBase, id);
+  const home = join11(runnerHomeBase, id);
   try {
     mkdirSync4(home, { recursive: true });
-    writeFileSync5(join10(home, ".credentials.json"), contents, { mode: 384 });
+    writeFileSync5(join11(home, ".credentials.json"), contents, { mode: 384 });
   } catch {
   }
   return home;
@@ -43519,7 +43821,7 @@ function resolveRunnerEnv(spec) {
   return { ANTHROPIC_BASE_URL: endpoint.baseUrl, ANTHROPIC_AUTH_TOKEN: endpoint.authToken, ANTHROPIC_API_KEY: "" };
 }
 function overridePath() {
-  return join10(process.env.CCB_TESSERACT_DIR ?? join10(homedir5(), ".tesseract"), "runners.json");
+  return join11(process.env.CCB_TESSERACT_DIR ?? join11(homedir5(), ".tesseract"), "runners.json");
 }
 var cache2 = null;
 var cachedMtime = -1;
@@ -43533,7 +43835,7 @@ function readOverride() {
     }
     const m = statSync(p).mtimeMs;
     if (cachedMtime !== m) {
-      cache2 = JSON.parse(readFileSync4(p, "utf-8"));
+      cache2 = JSON.parse(readFileSync5(p, "utf-8"));
       cachedMtime = m;
     }
   } catch {
@@ -43560,11 +43862,11 @@ function resolveOverrideEngineEnv() {
 }
 
 // ../../packages/host-core/dist/runners/pool.js
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync6, existsSync as existsSync7, statSync as statSync2, mkdirSync as mkdirSync5, chmodSync as chmodSync2, renameSync as renameSync4 } from "node:fs";
-import { join as join11 } from "node:path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync7, statSync as statSync2, mkdirSync as mkdirSync5, chmodSync as chmodSync2, renameSync as renameSync4 } from "node:fs";
+import { join as join12 } from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 function poolPath() {
-  return join11(daemonDir(), "runner-configs.json");
+  return join12(daemonDir(), "runner-configs.json");
 }
 var cache3 = null;
 var cachedMtime2 = -1;
@@ -43581,7 +43883,7 @@ function load() {
     }
     const m = statSync2(p).mtimeMs;
     if (cachedMtime2 !== m || !cache3) {
-      const parsed = JSON.parse(readFileSync5(p, "utf-8"));
+      const parsed = JSON.parse(readFileSync6(p, "utf-8"));
       cache3 = parsed && parsed.version === 1 && Array.isArray(parsed.configs) ? parsed : emptyStore();
       cachedMtime2 = m;
     }
@@ -43747,7 +44049,7 @@ function setActiveConfig(id) {
 // ../../packages/host-core/dist/daemon-engine-spawn.js
 import { execFileSync } from "node:child_process";
 import { homedir as homedir6 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function envKey(id) {
   return id.toUpperCase().replace(/[^A-Z0-9]/g, "_");
 }
@@ -43758,10 +44060,10 @@ function augmentedPath() {
     "/opt/homebrew/bin",
     "/usr/bin",
     "/bin",
-    join12(homedir6(), ".local", "bin"),
-    join12(homedir6(), "bin"),
-    join12(homedir6(), ".bun", "bin"),
-    join12(homedir6(), ".npm-global", "bin")
+    join13(homedir6(), ".local", "bin"),
+    join13(homedir6(), "bin"),
+    join13(homedir6(), ".bun", "bin"),
+    join13(homedir6(), ".npm-global", "bin")
   ];
   const seen = /* @__PURE__ */ new Set();
   const parts = [];
@@ -43774,9 +44076,9 @@ function augmentedPath() {
   return parts.join(sep7);
 }
 function which(bin, path5) {
-  const tool2 = process.platform === "win32" ? "where" : "which";
+  const tool3 = process.platform === "win32" ? "where" : "which";
   try {
-    const out = execFileSync(tool2, [bin], { env: { ...process.env, PATH: path5 }, timeout: 4e3, encoding: "utf-8" });
+    const out = execFileSync(tool3, [bin], { env: { ...process.env, PATH: path5 }, timeout: 4e3, encoding: "utf-8" });
     return out.split(/\r?\n/).map((l) => l.trim()).find(Boolean) || void 0;
   } catch {
     return void 0;
@@ -43818,14 +44120,14 @@ function readDaemonEngineSpawn(engineId) {
   return readDaemonAgentSettings().engineSpawn?.[engineId] ?? resolveDaemonEngineSpawn(engineId);
 }
 function agentSettingsPath() {
-  return join13(daemonDir(), "agent-settings.json");
+  return join14(daemonDir(), "agent-settings.json");
 }
 function readDaemonSchedulingEnabled() {
   return readDaemonAgentSettings().schedulingEnabled === true;
 }
 function readDaemonAgentSettings() {
   try {
-    return JSON.parse(readFileSync6(agentSettingsPath(), "utf-8"));
+    return JSON.parse(readFileSync7(agentSettingsPath(), "utf-8"));
   } catch {
     const snap = {};
     const raw = process.env.CCB_MCP_SERVERS;
@@ -43932,7 +44234,7 @@ function buildSharedBackend(engineId) {
     },
     resolver,
     // Daemon plugins (review #3): operator-controlled <daemonDir>/plugins, env-var secrets.
-    buildDaemonPluginLoader(join14(daemonDir(), "plugins"))
+    buildDaemonPluginLoader(join15(daemonDir(), "plugins"))
   ).then((b) => {
     if (token !== buildToken)
       return b;
@@ -43983,16 +44285,16 @@ function refreshDaemonScheduling(b) {
   }
   b.configureScheduling({
     enabled,
-    file: join14(dir, "scheduled_tasks.json"),
+    file: join15(dir, "scheduled_tasks.json"),
     // projectDir omitted ⇒ fires track the daemon's currently-open project (setConfig).
     isOwner: schedulingLock ? () => schedulingLock.isOwner() : void 0
   });
 }
 
 // ../../packages/host-core/dist/fs-remote.js
-import { readdir as readdir2, readFile as readFile5, writeFile as writeFile3, mkdir as mkdir3, cp, rm, rename as renameAsync, stat as stat2 } from "node:fs/promises";
+import { readdir as readdir2, readFile as readFile6, writeFile as writeFile4, mkdir as mkdir4, cp, rm, rename as renameAsync, stat as stat2 } from "node:fs/promises";
 import { openSync as openSync2, readSync, closeSync as closeSync2, statSync as statSync3, existsSync as existsSync8, watch } from "node:fs";
-import { basename as basename2, dirname as dirname6, join as join15, relative as relative2, resolve as resolve3, sep as sep3, isAbsolute as isAbsolute2 } from "node:path";
+import { basename as basename2, dirname as dirname6, join as join16, relative as relative3, resolve as resolve4, sep as sep3, isAbsolute as isAbsolute3 } from "node:path";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 var execFileAsync = promisify2(execFile3);
@@ -44039,12 +44341,12 @@ async function listAllFilesUnder(dir) {
           return;
         if (ent.name === ".DS_Store")
           continue;
-        const full = join15(d, ent.name);
+        const full = join16(d, ent.name);
         if (ent.isDirectory()) {
           if (!LISTALL_SKIP_DIRS.has(ent.name))
             await walk(full);
         } else if (ent.isFile())
-          out.push(relative2(dir, full).split(sep3).join("/"));
+          out.push(relative3(dir, full).split(sep3).join("/"));
       }
     };
     await walk(dir);
@@ -44155,18 +44457,18 @@ function resolveParent(raw, root) {
   if (raw === "" || raw === "~")
     return root;
   if (raw.startsWith("~/"))
-    return join15(root, raw.slice(2));
-  return isAbsolute2(raw) ? raw : join15(root, raw);
+    return join16(root, raw.slice(2));
+  return isAbsolute3(raw) ? raw : join16(root, raw);
 }
 function resolveUniqueName(dir, name) {
-  const direct = join15(dir, name);
+  const direct = join16(dir, name);
   if (!existsSync8(direct))
     return direct;
   const dot = name.lastIndexOf(".");
   const base = dot > 0 ? name.slice(0, dot) : name;
   const ext = dot > 0 ? name.slice(dot) : "";
   for (let i = 2; i < 1e4; i++) {
-    const candidate = join15(dir, `${base} ${i}${ext}`);
+    const candidate = join16(dir, `${base} ${i}${ext}`);
     if (!existsSync8(candidate))
       return candidate;
   }
@@ -44183,7 +44485,7 @@ async function readRemoteBytes(root, path5) {
       return { error: "Not a file" };
     if (s.size > REMOTE_READ_CAP)
       return { error: `File is too large to read whole over the network (${(s.size / 1024 / 1024).toFixed(1)} MB) \u2014 open it locally.` };
-    return { bytes: await readFile5(path5), size: s.size };
+    return { bytes: await readFile6(path5), size: s.size };
   } catch (err) {
     return { error: String(err.message) };
   }
@@ -44198,7 +44500,7 @@ async function runRemoteFsOp(root, op, args) {
       try {
         const entries = (await readdir2(dir, { withFileTypes: true })).filter((e) => e.name !== ".DS_Store");
         const ignored = await gitIgnoredNames(dir, entries.map((e) => e.name));
-        return entries.map((e) => ({ name: e.name, path: join15(dir, e.name), isDir: e.isDirectory(), ignored: ignored.has(e.name) })).sort((x, y) => x.isDir === y.isDir ? x.name.localeCompare(y.name) : x.isDir ? -1 : 1);
+        return entries.map((e) => ({ name: e.name, path: join16(dir, e.name), isDir: e.isDirectory(), ignored: ignored.has(e.name) })).sort((x, y) => x.isDir === y.isDir ? x.name.localeCompare(y.name) : x.isDir ? -1 : 1);
       } catch {
         return [];
       }
@@ -44224,7 +44526,7 @@ async function runRemoteFsOp(root, op, args) {
         const s = statSync3(p);
         if (s.size > TEXT_SIZE_LIMIT)
           return { error: "File too large for text view." };
-        return { content: await readFile5(p, "utf-8") };
+        return { content: await readFile6(p, "utf-8") };
       } catch (err) {
         return { error: String(err.message) };
       }
@@ -44235,8 +44537,8 @@ async function runRemoteFsOp(root, op, args) {
       if (!isInsideRoot(p, root))
         return OUTSIDE("write");
       try {
-        await mkdir3(dirname6(p), { recursive: true });
-        await writeFile3(p, content, "utf-8");
+        await mkdir4(dirname6(p), { recursive: true });
+        await writeFile4(p, content, "utf-8");
         return { ok: true };
       } catch (err) {
         return { ok: false, error: String(err.message) };
@@ -44248,8 +44550,8 @@ async function runRemoteFsOp(root, op, args) {
       if (!isInsideRoot(p, root))
         return OUTSIDE("write");
       try {
-        await mkdir3(dirname6(p), { recursive: true });
-        await writeFile3(p, Buffer.from(base643, "base64"));
+        await mkdir4(dirname6(p), { recursive: true });
+        await writeFile4(p, Buffer.from(base643, "base64"));
         return { ok: true };
       } catch (err) {
         return { ok: false, error: String(err.message) };
@@ -44301,7 +44603,7 @@ async function runRemoteFsOp(root, op, args) {
         const s = statSync3(p);
         if (s.size > REMOTE_READ_CAP)
           return { error: `File is too large to read whole over the network (${(s.size / 1024 / 1024).toFixed(1)} MB) \u2014 open it locally.` };
-        return { base64: (await readFile5(p)).toString("base64"), size: s.size };
+        return { base64: (await readFile6(p)).toString("base64"), size: s.size };
       } catch (err) {
         return { error: String(err.message) };
       }
@@ -44311,13 +44613,13 @@ async function runRemoteFsOp(root, op, args) {
       const name = String(a[1] ?? "").trim();
       if (!validName(name))
         return { ok: false, error: "Invalid project name." };
-      const target = join15(parent, name);
+      const target = join16(parent, name);
       if (!isInsideRoot(target, root))
         return { ok: false, error: "Refusing to create a project outside the shared root." };
       if (existsSync8(target))
         return { ok: false, error: `A folder named "${name}" already exists.` };
       try {
-        await mkdir3(target, { recursive: true });
+        await mkdir4(target, { recursive: true });
         return { ok: true, path: target };
       } catch (err) {
         return { ok: false, error: String(err.message) };
@@ -44331,14 +44633,14 @@ async function runRemoteFsOp(root, op, args) {
         return { ok: false, error: "Invalid name." };
       if (!isInsideRoot(parent, root))
         return OUTSIDE("create");
-      const target = join15(parent, name);
+      const target = join16(parent, name);
       if (existsSync8(target))
         return { ok: false, error: `"${name}" already exists.` };
       try {
         if (op === "createFile")
-          await writeFile3(target, "", "utf-8");
+          await writeFile4(target, "", "utf-8");
         else
-          await mkdir3(target);
+          await mkdir4(target);
         return { ok: true, path: target };
       } catch (err) {
         return { ok: false, error: String(err.message) };
@@ -44351,7 +44653,7 @@ async function runRemoteFsOp(root, op, args) {
         return { ok: false, error: "Invalid name." };
       if (!isInsideRoot(oldPath, root))
         return OUTSIDE("rename");
-      const newPath = join15(dirname6(oldPath), newName);
+      const newPath = join16(dirname6(oldPath), newName);
       if (existsSync8(newPath))
         return { ok: false, error: `A file named "${newName}" already exists.` };
       try {
@@ -44367,7 +44669,7 @@ async function runRemoteFsOp(root, op, args) {
         return { ok: false, error: "Bad request" };
       if (!isInsideRoot(p, root))
         return OUTSIDE("delete");
-      if (resolve3(p) === resolve3(root))
+      if (resolve4(p) === resolve4(root))
         return { ok: false, error: "Refusing to delete the shared root." };
       try {
         await rm(p, { recursive: true, force: false });
@@ -44413,7 +44715,7 @@ async function runRemoteFsOp(root, op, args) {
         const s = await stat2(p);
         if (!s.isDirectory())
           return { error: "not_dir" };
-        return { root: resolve3(p), name: basename2(p) };
+        return { root: resolve4(p), name: basename2(p) };
       } catch {
         return { error: "not_found" };
       }
@@ -44421,14 +44723,14 @@ async function runRemoteFsOp(root, op, args) {
     case "currentRoot":
       return { root, name: basename2(root) };
     case "homeDir":
-      return { root: resolve3(root), name: basename2(root) };
+      return { root: resolve4(root), name: basename2(root) };
     default:
       return { error: `Unsupported fs op: ${op}` };
   }
 }
 var remoteWatches = /* @__PURE__ */ new Map();
 function watchRemoteRoot(root, key2, onChange) {
-  const resolved = resolve3(root);
+  const resolved = resolve4(root);
   const existing = remoteWatches.get(resolved);
   if (existing) {
     existing.listeners.set(key2, onChange);
@@ -44443,7 +44745,7 @@ function watchRemoteRoot(root, key2, onChange) {
       const rel = String(filename);
       if (rel.split(sep3).some((seg) => IGNORED.has(seg)))
         return;
-      pending.add(join15(resolved, rel));
+      pending.add(join16(resolved, rel));
       if (timer)
         clearTimeout(timer);
       timer = setTimeout(() => {
@@ -44688,15 +44990,15 @@ function dynamicMetrics() {
 }
 
 // ../../packages/host-core/dist/fs-transfer.js
-import { readdir as readdir3, lstat, mkdir as mkdir4, chmod, rm as rm2, readlink, symlink, stat as stat3 } from "node:fs/promises";
+import { readdir as readdir3, lstat, mkdir as mkdir5, chmod, rm as rm2, readlink, symlink, stat as stat3 } from "node:fs/promises";
 import { openSync as openSync3, readSync as readSync2, closeSync as closeSync3, existsSync as existsSync9, createWriteStream } from "node:fs";
-import { dirname as dirname7, join as join17, relative as relative4, sep as sep5 } from "node:path";
+import { dirname as dirname7, join as join18, relative as relative5, sep as sep5 } from "node:path";
 
 // ../../packages/host-core/dist/active-link/paths.js
 import { homedir as homedir7 } from "node:os";
-import { join as join16, relative as relative3, sep as sep4 } from "node:path";
+import { join as join17, relative as relative4, sep as sep4 } from "node:path";
 function activeLinkEnabled() {
-  return process.env.CCB_ACTIVE_LINK === "1";
+  return process.env.CCB_ACTIVE_LINK !== "0";
 }
 var HEAVY_DIRS = /* @__PURE__ */ new Set([
   ".git",
@@ -44717,10 +45019,10 @@ function isExcludedName(name) {
   return HEAVY_DIRS.has(name) || ALWAYS_SKIP.has(name);
 }
 function toPosixRel(root, abs) {
-  return relative3(root, abs).split(sep4).join("/");
+  return relative4(root, abs).split(sep4).join("/");
 }
 function fromPosixRel(root, rel) {
-  return join16(root, rel.split("/").join(sep4));
+  return join17(root, rel.split("/").join(sep4));
 }
 function isExcludedAbs(abs, root) {
   const rel = toPosixRel(root, abs);
@@ -44729,10 +45031,10 @@ function isExcludedAbs(abs, root) {
   return rel.split("/").some(isExcludedName);
 }
 function activeLinkRoot() {
-  return process.env.CCB_ACTIVE_LINK_DIR ?? join16(homedir7(), ".tesseract", "active-link");
+  return process.env.CCB_ACTIVE_LINK_DIR ?? join17(homedir7(), ".tesseract", "active-link");
 }
 function linkStateDir(linkId) {
-  return join16(activeLinkRoot(), linkId);
+  return join17(activeLinkRoot(), linkId);
 }
 
 // ../../packages/host-core/dist/fs-transfer.js
@@ -44745,9 +45047,9 @@ function clearTimer(t) {
   return null;
 }
 function uniqueDir(parent, name) {
-  let candidate = join17(parent, name);
+  let candidate = join18(parent, name);
   for (let i = 2; existsSync9(candidate) && i < 1e4; i++)
-    candidate = join17(parent, `${name} ${i}`);
+    candidate = join18(parent, `${name} ${i}`);
   return candidate;
 }
 var producers = /* @__PURE__ */ new Map();
@@ -44790,8 +45092,8 @@ async function buildManifest(root, followSymlinks, excludeHeavy) {
         continue;
       if (e.isDirectory() && excludeHeavy && HEAVY_DIRS.has(e.name))
         continue;
-      const abs = join17(dir, e.name);
-      const rel = relative4(root, abs).split(sep5).join("/");
+      const abs = join18(dir, e.name);
+      const rel = relative5(root, abs).split(sep5).join("/");
       const st = await lstat(abs).catch(() => null);
       if (!st)
         continue;
@@ -44851,17 +45153,17 @@ async function startOutboundTransfer(msg, controllerClientId, ownHostId2, hostRo
     totalBytes: manifest.totalBytes,
     dirs: manifest.dirs
   }, { hostId: toHost });
-  const waitWindow = () => state.sentBytes - state.ackedBytes < MAX_INFLIGHT ? Promise.resolve() : new Promise((resolve8) => {
-    state.wake = resolve8;
+  const waitWindow = () => state.sentBytes - state.ackedBytes < MAX_INFLIGHT ? Promise.resolve() : new Promise((resolve9) => {
+    state.wake = resolve9;
   });
   for (let fileIx = 0; fileIx < manifest.files.length && !state.cancelled; fileIx++) {
     const f = manifest.files[fileIx];
     if (f.kind === "symlink") {
-      const target = await readlink(join17(srcPath, f.rel.split("/").join(sep5))).catch(() => "");
+      const target = await readlink(join18(srcPath, f.rel.split("/").join(sep5))).catch(() => "");
       send2({ type: "fs:transferChunk", transferId, toHost, fileIx, rel: f.rel, mode: f.mode, kind: "symlink", offset: 0, base64: Buffer.from(target, "utf-8").toString("base64"), eof: true }, { hostId: toHost });
       continue;
     }
-    const abs = join17(srcPath, f.rel.split("/").join(sep5));
+    const abs = join18(srcPath, f.rel.split("/").join(sep5));
     let fd = null;
     try {
       fd = openSync3(abs, "r");
@@ -44973,7 +45275,7 @@ async function beginInboundTransfer(msg, hostRoot, send2) {
     failNoState("Invalid destination name.");
     return;
   }
-  let destRoot = join17(parent, msg.destName);
+  let destRoot = join18(parent, msg.destName);
   let createdRoot = false;
   if (existsSync9(destRoot)) {
     if (msg.onCollision === "abort") {
@@ -45013,11 +45315,11 @@ async function beginInboundTransfer(msg, hostRoot, send2) {
     return;
   }
   try {
-    await mkdir4(destRoot, { recursive: true });
+    await mkdir5(destRoot, { recursive: true });
     for (const d of msg.dirs) {
-      const abs = join17(destRoot, d.rel.split("/").join(sep5));
+      const abs = join18(destRoot, d.rel.split("/").join(sep5));
       if (isInsideRoot(abs, destRoot))
-        await mkdir4(abs, { recursive: true }).catch(() => {
+        await mkdir5(abs, { recursive: true }).catch(() => {
         });
     }
   } catch (e) {
@@ -45029,7 +45331,7 @@ async function writeInboundChunk(msg, send2) {
   if (!s || s.cancelled)
     return;
   armConsumerWatchdog(msg.transferId, send2);
-  const abs = join17(s.destRoot, msg.rel.split("/").join(sep5));
+  const abs = join18(s.destRoot, msg.rel.split("/").join(sep5));
   if (msg.rel.includes("..") || !isInsideRoot(abs, s.destRoot)) {
     failConsumer(msg.transferId, `Refusing a path outside the destination: ${msg.rel}`, send2);
     return;
@@ -45037,9 +45339,9 @@ async function writeInboundChunk(msg, send2) {
   try {
     if (msg.kind === "symlink") {
       const target = Buffer.from(msg.base64, "base64").toString("utf-8");
-      const resolved = join17(dirname7(abs), target);
+      const resolved = join18(dirname7(abs), target);
       if (isInsideRoot(resolved, s.destRoot)) {
-        await mkdir4(dirname7(abs), { recursive: true }).catch(() => {
+        await mkdir5(dirname7(abs), { recursive: true }).catch(() => {
         });
         await symlink(target, abs).catch(() => {
         });
@@ -45052,14 +45354,14 @@ async function writeInboundChunk(msg, send2) {
     if (s.curIx !== msg.fileIx || !s.curStream) {
       if (s.curStream)
         await new Promise((r) => s.curStream.end(r));
-      await mkdir4(dirname7(abs), { recursive: true }).catch(() => {
+      await mkdir5(dirname7(abs), { recursive: true }).catch(() => {
       });
       s.curStream = createWriteStream(abs);
       s.curIx = msg.fileIx;
     }
     if (msg.base64) {
       const buf = Buffer.from(msg.base64, "base64");
-      await new Promise((resolve8, reject) => s.curStream.write(buf, (err) => err ? reject(err) : resolve8()));
+      await new Promise((resolve9, reject) => s.curStream.write(buf, (err) => err ? reject(err) : resolve9()));
       s.bytesDone += buf.length;
     }
     if (msg.eof) {
@@ -45113,7 +45415,7 @@ function cancelTransfersForClient(clientId, send2) {
 
 // ../../packages/host-core/dist/peer-link/index.js
 import { homedir as homedir8 } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 
 // ../../packages/host-core/dist/peer-link/manager.js
 import { randomBytes as randomBytes2 } from "node:crypto";
@@ -45122,15 +45424,15 @@ import { randomBytes as randomBytes2 } from "node:crypto";
 var import_selfsigned = __toESM(require_selfsigned(), 1);
 import tls from "node:tls";
 import { X509Certificate } from "node:crypto";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "node:fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "node:fs";
 import { dirname as dirname8 } from "node:path";
 function fingerprintOf(certPem) {
   return new X509Certificate(certPem).fingerprint256;
 }
 async function loadOrCreateIdentity(certPath, keyPath) {
   if (existsSync10(certPath) && existsSync10(keyPath)) {
-    const cert = readFileSync7(certPath, "utf8");
-    const key2 = readFileSync7(keyPath, "utf8");
+    const cert = readFileSync8(certPath, "utf8");
+    const key2 = readFileSync8(keyPath, "utf8");
     return { cert, key: key2, fingerprint256: fingerprintOf(cert) };
   }
   const tenYears = new Date(Date.now() + 10 * 365 * 24 * 60 * 60 * 1e3);
@@ -45147,7 +45449,7 @@ async function loadOrCreateIdentity(certPath, keyPath) {
   return { cert: pems.cert, key: pems.private, fingerprint256: fingerprintOf(pems.cert) };
 }
 function pinnedConnect(opts) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     let settled = false;
     const done = (err, sock) => {
       if (settled)
@@ -45160,7 +45462,7 @@ function pinnedConnect(opts) {
         }
         reject(err);
       } else
-        resolve8(sock);
+        resolve9(sock);
     };
     const socket2 = tls.connect({
       host: opts.host,
@@ -45276,6 +45578,11 @@ var PeerLinkManager = class {
   quicSrflx = null;
   quicInitP = null;
   quicKeepalive = null;
+  /** Set once if the QUIC native dep (@matrixai/quic) can't be loaded on this host —
+   *  e.g. the desktop app doesn't ship it, or an arch with no prebuilt binding. The
+   *  QUIC tier then no-ops permanently and the TCP tiers carry every link (fail-closed,
+   *  exactly what the lazy-load design in quic-transport.ts promises). */
+  quicUnavailable = false;
   constructor(certPath, keyPath) {
     this.certPath = certPath;
     this.keyPath = keyPath;
@@ -45322,22 +45629,28 @@ var PeerLinkManager = class {
       return;
     const stunPort = Number(process.env.CCB_STUN_PORT ?? 3478);
     const identity = await this.identity();
-    const q = await Promise.resolve().then(() => (init_quic_transport(), quic_transport_exports));
-    const socket2 = await q.makeQuicSocket(this.udpPort);
-    this.quicSocket = socket2;
-    await q.startQuicServerOnSocket({ socket: socket2, identity, onStream: (bs) => this.acceptInbound(bs, "punch") });
-    const refresh = async () => {
-      try {
-        const s = await q.discoverSrflx(socket2, stunHost, stunPort);
-        const i = s.lastIndexOf(":");
-        this.quicSrflx = { type: "srflx", ip: s.slice(0, i), port: Number(s.slice(i + 1)), proto: "udp", priority: 40 };
-      } catch {
-      }
-    };
-    await refresh();
-    this.quicKeepalive = setInterval(() => {
-      void refresh();
-    }, 2e4);
+    try {
+      const q = await Promise.resolve().then(() => (init_quic_transport(), quic_transport_exports));
+      const socket2 = await q.makeQuicSocket(this.udpPort);
+      this.quicSocket = socket2;
+      await q.startQuicServerOnSocket({ socket: socket2, identity, onStream: (bs) => this.acceptInbound(bs, "punch") });
+      const refresh = async () => {
+        try {
+          const s = await q.discoverSrflx(socket2, stunHost, stunPort);
+          const i = s.lastIndexOf(":");
+          this.quicSrflx = { type: "srflx", ip: s.slice(0, i), port: Number(s.slice(i + 1)), proto: "udp", priority: 40 };
+        } catch {
+        }
+      };
+      await refresh();
+      this.quicKeepalive = setInterval(() => {
+        void refresh();
+      }, 2e4);
+    } catch (e) {
+      this.quicUnavailable = true;
+      this.quicSocket = null;
+      console.warn(`[peer-link] QUIC tier unavailable \u2014 using TCP tiers only: ${e?.message ?? e}`);
+    }
   }
   async nudgeQuic(peer) {
     if (!this.quicSocket)
@@ -45367,7 +45680,7 @@ var PeerLinkManager = class {
     if (this.server)
       return this.listenPort;
     this.server = createListener(identity, LISTEN_PORT, (sock) => this.acceptInbound(sock, "reverse"));
-    await new Promise((resolve8) => this.server.once("listening", () => resolve8()));
+    await new Promise((resolve9) => this.server.once("listening", () => resolve9()));
     const addr = this.server.address();
     if (addr && typeof addr === "object")
       this.listenPort = addr.port;
@@ -45434,12 +45747,12 @@ var PeerLinkManager = class {
    *  peer to dial in. Resolves with the authed link, or rejects on timeout. */
   awaitInbound(token, peerHostId) {
     const h = toHex(token);
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const timer = setTimeout(() => {
         this.pendingInbound.delete(h);
         reject(new Error("peer-link: inbound dial-in timeout"));
       }, INBOUND_WAIT_MS);
-      this.pendingInbound.set(h, { peerHostId, resolve: resolve8, reject, timer });
+      this.pendingInbound.set(h, { peerHostId, resolve: resolve9, reject, timer });
     });
   }
   /** Obey one `p2p:go` (initiator OR unsolicited responder): dial the peer's
@@ -45453,7 +45766,7 @@ var PeerLinkManager = class {
   async handleGo(msg) {
     const token = Buffer.from(msg.token, "hex");
     const udp = msg.peerCandidates.filter((c) => c.proto === "udp");
-    const quicOn = this.quicEnabled() && udp.length > 0;
+    const quicOn = this.quicEnabled() && udp.length > 0 && !this.quicUnavailable;
     if (msg.role === "listen") {
       if (quicOn) {
         await this.initQuic();
@@ -45466,7 +45779,7 @@ var PeerLinkManager = class {
     ];
     if (quicOn)
       attempts.push(this.quicDial(msg, token, udp[0]));
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       let done = false, failed = 0;
       const errs = [];
       for (const p of attempts) {
@@ -45480,7 +45793,7 @@ var PeerLinkManager = class {
           }
           done = true;
           this.cache(msg.peerHostId, l);
-          resolve8(l);
+          resolve9(l);
         }, (e) => {
           errs.push(e);
           if (++failed === attempts.length && !done)
@@ -45531,7 +45844,7 @@ var PeerLinkManager = class {
     const myFingerprint = (await this.identity()).fingerprint256;
     const rid = randomBytes2(8).toString("hex");
     const myCandidates = gatherTcpCandidates(this.listenPort, this.observedIp);
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       let settled = false;
       const overall = setTimeout(() => finish(new Error("peer-link: rendezvous timeout")), RENDEZVOUS_TIMEOUT_MS);
       const finish = (err, link) => {
@@ -45543,7 +45856,7 @@ var PeerLinkManager = class {
         if (err || !link)
           reject(err ?? new Error("peer-link: no link"));
         else
-          resolve8(link);
+          resolve9(link);
       };
       this.pendingOpens.set(rid, {
         // Our attempt failed: tell the broker (it forwards `failed` to the peer +
@@ -45613,8 +45926,8 @@ var PeerLinkManager = class {
 // ../../packages/host-core/dist/peer-link/index.js
 var P2P_ENABLED = process.env.CCB_P2P !== "0";
 function identityPaths() {
-  const dir = process.env.CCB_P2P_DIR ?? join18(homedir8(), ".tesseract");
-  return { certPath: join18(dir, "peer-cert.pem"), keyPath: join18(dir, "peer-key.pem") };
+  const dir = process.env.CCB_P2P_DIR ?? join19(homedir8(), ".tesseract");
+  return { certPath: join19(dir, "peer-cert.pem"), keyPath: join19(dir, "peer-key.pem") };
 }
 var manager = null;
 function peerLinkManager() {
@@ -45629,14 +45942,14 @@ async function openPeerLink(peerHostId, ctx) {
 }
 
 // ../../packages/host-core/dist/active-link/engine.js
-import { lstat as lstat6, readlink as readlink4, rm as rm3, mkdir as mkdir6, symlink as symlink2, rename as rename2, utimes as utimes2, writeFile as writeFile4 } from "node:fs/promises";
+import { lstat as lstat6, readlink as readlink4, rm as rm3, mkdir as mkdir7, symlink as symlink2, rename as rename2, utimes as utimes2, writeFile as writeFile5 } from "node:fs/promises";
 import { existsSync as existsSync12 } from "node:fs";
-import { dirname as dirname12, join as join23, resolve as resolve6 } from "node:path";
+import { dirname as dirname12, join as join24, resolve as resolve7 } from "node:path";
 
 // ../../packages/host-core/dist/active-link/blocks.js
 import { createHash as createHash3 } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { open, mkdir as mkdir5, rename, chmod as chmod2, utimes, unlink } from "node:fs/promises";
+import { open, mkdir as mkdir6, rename, chmod as chmod2, utimes, unlink } from "node:fs/promises";
 import { dirname as dirname9 } from "node:path";
 var CHUNK3 = 1024 * 1024;
 var MAX_INFLIGHT2 = 8 * CHUNK3;
@@ -45648,16 +45961,16 @@ function hashString(s) {
   return createHash3("sha256").update(s, "utf-8").digest("hex");
 }
 function hashFile(abs) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const h = createHash3("sha256");
     const rs = createReadStream(abs);
     rs.on("data", (d) => h.update(d));
-    rs.on("end", () => resolve8(h.digest("hex")));
+    rs.on("end", () => resolve9(h.digest("hex")));
     rs.on("error", reject);
   });
 }
 function hashFileBlocks(abs) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const whole = createHash3("sha256");
     const blocks = [];
     let cur = createHash3("sha256");
@@ -45684,7 +45997,7 @@ function hashFileBlocks(abs) {
     rs.on("end", () => {
       if (curLen > 0)
         blocks.push(cur.digest("hex"));
-      resolve8({ wholeHash: whole.digest("hex"), blocks, size });
+      resolve9({ wholeHash: whole.digest("hex"), blocks, size });
     });
     rs.on("error", reject);
   });
@@ -45715,8 +46028,8 @@ var SendWindow = class {
   wait() {
     if (this.cancelled || this.sent - this.acked < this.maxInflight)
       return Promise.resolve();
-    return new Promise((resolve8) => {
-      this.wake = resolve8;
+    return new Promise((resolve9) => {
+      this.wake = resolve9;
     });
   }
   cancel() {
@@ -45765,7 +46078,7 @@ var StagingWriter = class {
   }
   async ensureOpen() {
     if (!this.fh) {
-      await mkdir5(dirname9(this.stagingPath), { recursive: true });
+      await mkdir6(dirname9(this.stagingPath), { recursive: true });
       this.fh = await open(this.stagingPath, "w");
     }
     return this.fh;
@@ -45795,7 +46108,7 @@ var StagingWriter = class {
     });
     await fh.close();
     this.fh = null;
-    await mkdir5(dirname9(dest), { recursive: true });
+    await mkdir6(dirname9(dest), { recursive: true });
     await chmod2(this.stagingPath, mode & 511).catch(() => {
     });
     const secs = mtimeMs / 1e3;
@@ -45828,7 +46141,7 @@ var BlockAssembler = class {
     this.stagingPath = stagingPath;
   }
   async open() {
-    await mkdir5(dirname9(this.stagingPath), { recursive: true });
+    await mkdir6(dirname9(this.stagingPath), { recursive: true });
     this.fh = await open(this.stagingPath, "w");
   }
   /** Write a received block at its byte offset (index * CHUNK). */
@@ -45872,7 +46185,7 @@ var BlockAssembler = class {
       });
       return false;
     }
-    await mkdir5(dirname9(dest), { recursive: true });
+    await mkdir6(dirname9(dest), { recursive: true });
     await chmod2(this.stagingPath, mode & 511).catch(() => {
     });
     const secs = mtimeMs / 1e3;
@@ -45895,8 +46208,8 @@ var BlockAssembler = class {
 };
 
 // ../../packages/host-core/dist/active-link/manifest.js
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7, existsSync as existsSync11, renameSync as renameSync5 } from "node:fs";
-import { join as join19 } from "node:path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7, existsSync as existsSync11, renameSync as renameSync5 } from "node:fs";
+import { join as join20 } from "node:path";
 
 // ../../packages/host-core/dist/active-link/reconcile.js
 var ABSENT = { kind: "absent", t: -Infinity, hash: "" };
@@ -45932,11 +46245,11 @@ var LinkManifest = class {
     this.dir = dir;
   }
   file() {
-    return join19(this.dir, "manifest.json");
+    return join20(this.dir, "manifest.json");
   }
   load() {
     try {
-      const raw = JSON.parse(readFileSync8(this.file(), "utf-8"));
+      const raw = JSON.parse(readFileSync9(this.file(), "utf-8"));
       this.records = new Map(Object.entries(raw.records ?? {}));
       this.tombstones = new Map(Object.entries(raw.tombstones ?? {}));
     } catch {
@@ -46034,7 +46347,7 @@ var LinkManifest = class {
 
 // ../../packages/host-core/dist/active-link/scanner.js
 import { readdir as readdir4, lstat as lstat2, readlink as readlink2 } from "node:fs/promises";
-import { join as join20, sep as sep6 } from "node:path";
+import { join as join21, sep as sep6 } from "node:path";
 async function walkRels(root, extraIgnore) {
   const out = [];
   async function rec(dir) {
@@ -46049,7 +46362,7 @@ async function walkRels(root, extraIgnore) {
         continue;
       if (e.isDirectory() && HEAVY_DIRS.has(e.name))
         continue;
-      const abs = join20(dir, e.name);
+      const abs = join21(dir, e.name);
       if (extraIgnore?.(abs))
         continue;
       if (e.isDirectory())
@@ -46088,7 +46401,7 @@ async function scanTree(root, prior, allow, extraIgnore) {
   return { records };
 }
 function absOf(root, rel) {
-  return join20(root, rel.split("/").join(sep6));
+  return join21(root, rel.split("/").join(sep6));
 }
 
 // ../../packages/host-core/dist/active-link/gitignore.js
@@ -47151,7 +47464,7 @@ var NodeFsHandler = class {
         this._addToNodeFs(path5, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -47160,7 +47473,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve8(void 0);
+        resolve9(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -47304,11 +47617,11 @@ function createPattern(matcher) {
       if (matcher.path === string4)
         return true;
       if (matcher.recursive) {
-        const relative7 = sysPath2.relative(matcher.path, string4);
-        if (!relative7) {
+        const relative8 = sysPath2.relative(matcher.path, string4);
+        if (!relative8) {
           return false;
         }
-        return !relative7.startsWith("..") && !sysPath2.isAbsolute(relative7);
+        return !relative8.startsWith("..") && !sysPath2.isAbsolute(relative8);
       }
       return false;
     };
@@ -48016,8 +48329,8 @@ var LinkWatcher = class {
     this.fsw.on("unlinkDir", onEvent);
     this.fsw.on("error", () => {
     });
-    await new Promise((resolve8) => {
-      this.fsw.once("ready", () => resolve8());
+    await new Promise((resolve9) => {
+      this.fsw.once("ready", () => resolve9());
     });
   }
   enqueue(abs) {
@@ -48105,7 +48418,7 @@ var ActiveLinkEngine = class {
   }
   async start() {
     this.emit({ type: "status", linkId: this.opts.linkId, state: "scanning" });
-    await rm3(join23(this.stateDir, ".staging"), { recursive: true, force: true }).catch(() => {
+    await rm3(join24(this.stateDir, ".staging"), { recursive: true, force: true }).catch(() => {
     });
     this.manifest.load();
     await this.reconcileScan();
@@ -48498,20 +48811,20 @@ var ActiveLinkEngine = class {
    *  file so the path still exists — recorded as a FILE matching disk so the local
    *  watcher doesn't churn. The target is containment-checked, never dereferenced. */
   async applySymlink(rel, dest, target, mtimeMs, mode) {
-    const resolved = resolve6(dirname12(dest), target);
+    const resolved = resolve7(dirname12(dest), target);
     if (!isInsideRoot(resolved, this.opts.localRoot))
       return;
     const hash2 = hashString(target);
     const secs = mtimeMs / 1e3;
     try {
-      await mkdir6(dirname12(dest), { recursive: true });
+      await mkdir7(dirname12(dest), { recursive: true });
       await rm3(dest, { force: true, recursive: true });
       try {
         await symlink2(target, dest);
         this.manifest.setRecord(rel, { kind: "symlink", mtimeMs, size: 0, mode, hash: hash2, blocks: [] });
       } catch {
         const buf = Buffer.from(target, "utf-8");
-        await writeFile4(dest, buf);
+        await writeFile5(dest, buf);
         await utimes2(dest, secs, secs).catch(() => {
         });
         this.manifest.setRecord(rel, { kind: "file", mtimeMs, size: buf.length, mode, hash: hash2, blocks: [hash2] });
@@ -48554,7 +48867,7 @@ var ActiveLinkEngine = class {
       return;
     if (fromRec && fromRec.kind === "file") {
       try {
-        await mkdir6(dirname12(toAbs), { recursive: true });
+        await mkdir7(dirname12(toAbs), { recursive: true });
         await rename2(fromAbs, toAbs);
         const secs = mtimeMs / 1e3;
         await utimes2(toAbs, secs, secs).catch(() => {
@@ -48729,7 +49042,7 @@ var ActiveLinkEngine = class {
     this.inboundWatchdog.clear();
   }
   stagingPath(rel, tag) {
-    return join23(this.stateDir, ".staging", `${hashString(rel)}.${tag}`);
+    return join24(this.stateDir, ".staging", `${hashString(rel)}.${tag}`);
   }
   pruneSuppress() {
     const now = this.now();
@@ -48754,14 +49067,14 @@ var ActiveLinkEngine = class {
 };
 
 // ../../packages/host-core/dist/active-link/config.js
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, existsSync as existsSync13, renameSync as renameSync6, watch as watch3 } from "node:fs";
-import { join as join24 } from "node:path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, existsSync as existsSync13, renameSync as renameSync6, watch as watch3 } from "node:fs";
+import { join as join25 } from "node:path";
 function configPath2() {
-  return join24(activeLinkRoot(), "links.json");
+  return join25(activeLinkRoot(), "links.json");
 }
 function loadLinkConfigs() {
   try {
-    const raw = JSON.parse(readFileSync9(configPath2(), "utf-8"));
+    const raw = JSON.parse(readFileSync10(configPath2(), "utf-8"));
     if (!Array.isArray(raw.links))
       return [];
     return raw.links.filter((c) => c && c.linkId && c.localRoot && c.peerHostId);
@@ -48782,9 +49095,42 @@ function writeAll(links) {
 }
 function saveLinkConfig(cfg2) {
   const links = loadLinkConfigs().filter((c) => c.linkId !== cfg2.linkId);
-  links.push({ linkId: cfg2.linkId, localRoot: cfg2.localRoot, peerHostId: cfg2.peerHostId, ...cfg2.initiated ? { initiated: true } : {} });
+  links.push({
+    linkId: cfg2.linkId,
+    localRoot: cfg2.localRoot,
+    peerHostId: cfg2.peerHostId,
+    ...cfg2.initiated ? { initiated: true } : {},
+    ...cfg2.workspaceLinkId ? { workspaceLinkId: cfg2.workspaceLinkId } : {},
+    ...cfg2.remoteParent ? { remoteParent: cfg2.remoteParent } : {},
+    ...cfg2.remoteSubfolder ? { remoteSubfolder: cfg2.remoteSubfolder } : {}
+  });
   writeAll(links);
 }
+function pendingPath() {
+  return join25(activeLinkRoot(), "pending-deprovisions.json");
+}
+function loadPendingDeprovisions() {
+  try {
+    const raw = JSON.parse(readFileSync10(pendingPath(), "utf-8"));
+    return Array.isArray(raw.pending) ? raw.pending.filter((p) => p && p.linkId && p.peerHostId) : [];
+  } catch {
+    return [];
+  }
+}
+function writePending(pending) {
+  try {
+    const dir = activeLinkRoot();
+    if (!existsSync13(dir))
+      mkdirSync8(dir, { recursive: true });
+    const tmp = `${pendingPath()}.tmp`;
+    writeFileSync9(tmp, JSON.stringify({ pending }, null, 2));
+    renameSync6(tmp, pendingPath());
+  } catch {
+  }
+}
+function removePendingDeprovision(linkId) {
+  writePending(loadPendingDeprovisions().filter((p) => p.linkId !== linkId));
+}
 function removeLinkConfig(linkId) {
   writeAll(loadLinkConfigs().filter((c) => c.linkId !== linkId));
 }
@@ -49437,6 +49783,7 @@ function resumeActiveLinks() {
       if (cfg2.initiated && isHostOnline(cfg2.peerHostId))
         sendActiveLinkProvision(cfg2);
     }
+    flushPendingDeprovisions();
   } catch (e) {
     console.warn("[active-link] resume failed:", e.message);
   }
@@ -49445,11 +49792,21 @@ function isHostOnline(hostId) {
   return serverHosts.some((h) => h.hostId === hostId && h.online);
 }
 function sendActiveLinkProvision(cfg2) {
-  send("activelink", { type: "provision", linkId: cfg2.linkId, fromHost: ownHostId(), projectName: basename5(cfg2.localRoot) }, { hostId: cfg2.peerHostId });
+  send("activelink", {
+    type: "provision",
+    linkId: cfg2.linkId,
+    fromHost: ownHostId(),
+    projectName: cfg2.remoteSubfolder ?? basename5(cfg2.localRoot),
+    ...cfg2.remoteParent ? { remoteParent: cfg2.remoteParent } : {},
+    ...cfg2.remoteSubfolder ? { remoteSubfolder: cfg2.remoteSubfolder } : {},
+    ...cfg2.workspaceLinkId ? { workspaceLinkId: cfg2.workspaceLinkId } : {}
+  }, { hostId: cfg2.peerHostId });
 }
 function safeFolderName(name) {
   const cleaned = name.replace(/[/\\]/g, "-").replace(/\.\.+/g, ".").trim();
-  return cleaned || "project";
+  if (!cleaned || /^\.+$/.test(cleaned))
+    return "project";
+  return cleaned;
 }
 function provisionActiveLinkMirror(payload) {
   if (!activeLinkEnabled())
@@ -49461,9 +49818,17 @@ function provisionActiveLinkMirror(payload) {
     resumeActiveLinks();
     return;
   }
-  let localRoot = join25(HOST_ROOT, "Tesseract Mirrors", safeFolderName(projectName));
+  const workspaceLinkId = typeof payload.workspaceLinkId === "string" ? payload.workspaceLinkId : void 0;
+  const remoteParent = typeof payload.remoteParent === "string" ? payload.remoteParent : void 0;
+  const remoteSubfolder = typeof payload.remoteSubfolder === "string" ? payload.remoteSubfolder : void 0;
+  let localRoot;
+  if (remoteParent && remoteSubfolder) {
+    localRoot = join26(remoteParent, safeFolderName(remoteSubfolder));
+  } else {
+    localRoot = join26(HOST_ROOT, "Tesseract Mirrors", safeFolderName(projectName));
+  }
   if (loadLinkConfigs().some((c) => c.localRoot === localRoot && c.linkId !== linkId)) {
-    localRoot = join25(HOST_ROOT, "Tesseract Mirrors", `${safeFolderName(projectName)}-${linkId.slice(0, 6)}`);
+    localRoot = `${localRoot}-${linkId.slice(0, 6)}`;
   }
   if (!isInsideRoot(localRoot, HOST_ROOT))
     return;
@@ -49471,9 +49836,31 @@ function provisionActiveLinkMirror(payload) {
     mkdirSync9(localRoot, { recursive: true });
   } catch {
   }
-  saveLinkConfig({ linkId, localRoot, peerHostId: fromHost });
+  saveLinkConfig({
+    linkId,
+    localRoot,
+    peerHostId: fromHost,
+    ...workspaceLinkId ? { workspaceLinkId } : {},
+    ...remoteParent ? { remoteParent } : {},
+    ...remoteSubfolder ? { remoteSubfolder } : {}
+  });
   resumeActiveLinks();
 }
+function flushPendingDeprovisions() {
+  for (const d of loadPendingDeprovisions()) {
+    if (isHostOnline(d.peerHostId))
+      send("activelink", { type: "deprovision", linkId: d.linkId, fromHost: ownHostId() }, { hostId: d.peerHostId });
+  }
+}
+function deprovisionActiveLinkMirror(payload) {
+  const { linkId, fromHost } = payload;
+  if (typeof linkId !== "string")
+    return;
+  void disconnectActiveLink(linkId);
+  removeLinkConfig(linkId);
+  if (typeof fromHost === "string")
+    send("activelink", { type: "deprovisionAck", linkId }, { hostId: fromHost });
+}
 function handleActiveLinkChannel(payload, inbound) {
   if (!inbound)
     return;
@@ -49481,8 +49868,12 @@ function handleActiveLinkChannel(payload, inbound) {
     const p = payload;
     if (p?.type === "provision")
       provisionActiveLinkMirror(p);
+    else if (p?.type === "deprovision")
+      deprovisionActiveLinkMirror(p);
+    else if (p?.type === "deprovisionAck" && typeof p.linkId === "string")
+      removePendingDeprovision(p.linkId);
   } catch (e) {
-    console.warn("[active-link] provision failed:", e.message);
+    console.warn("[active-link] channel handler failed:", e.message);
   }
 }
 async function beginOutboundTransfer(p, clientId) {
@@ -49498,8 +49889,8 @@ async function beginOutboundTransfer(p, clientId) {
 }
 var fsWaiters = /* @__PURE__ */ new Map();
 function rejectAllFsWaiters() {
-  for (const [, resolve8] of fsWaiters)
-    resolve8({ error: "Disconnected from the remote machine." });
+  for (const [, resolve9] of fsWaiters)
+    resolve9({ error: "Disconnected from the remote machine." });
   fsWaiters.clear();
 }
 function clientIdFor(msg) {
@@ -49834,7 +50225,8 @@ function stopHeartbeat() {
 function registerAsHost() {
   void ensureP2pReady();
   const kind = process.env.CCB_HOST_KIND === "cloud" ? "cloud" : void 0;
-  send("host", { type: "host:register", name: hostname3(), platform: process.platform, deviceId, caps: ["agent", "fs", "term"], ...kind ? { kind } : {}, ...staticMetrics(hostVersion), ...p2pAdvert ?? {} });
+  const name = kind === "cloud" ? "Cloud agent" : hostname3();
+  send("host", { type: "host:register", name, platform: process.platform, deviceId, caps: ["agent", "fs", "term"], ...kind ? { kind } : {}, ...staticMetrics(hostVersion), ...p2pAdvert ?? {} });
   if (!heartbeat)
     heartbeat = setInterval(() => send("host", { type: "host:heartbeat", ...dynamicMetrics() }), 2e4);
 }
@@ -50132,8 +50524,8 @@ async function startLocalServer(opts) {
   const log3 = opts.log ?? (() => {
   });
   const wss = new import_websocket_server.default({ host: "127.0.0.1", port: 0 });
-  await new Promise((resolve8, reject) => {
-    wss.once("listening", resolve8);
+  await new Promise((resolve9, reject) => {
+    wss.once("listening", resolve9);
     wss.once("error", reject);
   });
   const addr = wss.address();
@@ -50368,8 +50760,8 @@ async function startLocalServer(opts) {
 }
 
 // ../../packages/host-core/dist/daemon-runtime.js
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync10, existsSync as existsSync15, mkdirSync as mkdirSync10, unlinkSync as unlinkSync2, chmodSync as chmodSync3 } from "node:fs";
-import { join as join26 } from "node:path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync10, existsSync as existsSync15, mkdirSync as mkdirSync10, unlinkSync as unlinkSync2, chmodSync as chmodSync3 } from "node:fs";
+import { join as join27 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 import { randomBytes as randomBytes3 } from "node:crypto";
 
@@ -50436,8 +50828,8 @@ async function runDaemon(opts = {}) {
   const VERSION = opts.version ?? process.env.CCB_DAEMON_VERSION ?? "dev";
   const TAG = opts.tag ?? "host-daemon";
   const log3 = (...args) => console.log(`[${TAG} ${(/* @__PURE__ */ new Date()).toISOString()}]`, ...args);
-  const pidfile = () => join26(daemonDir(), "daemon.lock");
-  const statusFile = () => join26(daemonDir(), "status.json");
+  const pidfile = () => join27(daemonDir(), "daemon.lock");
+  const statusFile = () => join27(daemonDir(), "status.json");
   const isAlive2 = (pid) => {
     try {
       process.kill(pid, 0);
@@ -50450,7 +50842,7 @@ async function runDaemon(opts = {}) {
     const f = pidfile();
     try {
       if (existsSync15(f)) {
-        const prev = Number(readFileSync10(f, "utf-8").trim());
+        const prev = Number(readFileSync11(f, "utf-8").trim());
         if (prev && prev !== process.pid && isAlive2(prev))
           return false;
       }
@@ -50467,14 +50859,14 @@ async function runDaemon(opts = {}) {
   function releaseLock() {
     try {
       const f = pidfile();
-      if (existsSync15(f) && Number(readFileSync10(f, "utf-8").trim()) === process.pid)
+      if (existsSync15(f) && Number(readFileSync11(f, "utf-8").trim()) === process.pid)
         unlinkSync2(f);
     } catch {
     }
   }
   function writeStatus(s) {
     try {
-      writeFileSync10(statusFile(), JSON.stringify({ pid: process.pid, version: VERSION, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...localInfo ?? {}, ...s }));
+      writeFileSync10(statusFile(), JSON.stringify({ pid: process.pid, version: VERSION, execPath: process.execPath, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...localInfo ?? {}, ...s }));
       chmodSync3(statusFile(), 384);
     } catch {
     }
@@ -50537,7 +50929,7 @@ async function runDaemon(opts = {}) {
         if (r.status === 401) {
           log3("device token no longer valid \u2014 dropping to local-only on restart");
           try {
-            unlinkSync2(join26(daemonDir(), "credentials.json"));
+            unlinkSync2(join27(daemonDir(), "credentials.json"));
           } catch {
           }
           shutdown(0);
@@ -50583,7 +50975,7 @@ import { platform as platform2 } from "node:os";
 
 // ../../packages/host-core/dist/service/launchd.js
 import { writeFileSync as writeFileSync11, existsSync as existsSync16, mkdirSync as mkdirSync11, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname13, join as join27 } from "node:path";
+import { dirname as dirname13, join as join28 } from "node:path";
 import { homedir as homedir12, userInfo } from "node:os";
 
 // ../../packages/host-core/dist/service/exec.js
@@ -50591,10 +50983,10 @@ import { execFile as execFile5, spawn as spawn5 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 var run = promisify4(execFile5);
 function runInherit(cmd, args) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const p = spawn5(cmd, args, { stdio: "inherit" });
-    p.on("error", () => resolve8());
-    p.on("close", () => resolve8());
+    p.on("error", () => resolve9());
+    p.on("close", () => resolve9());
   });
 }
 
@@ -50607,10 +50999,10 @@ function xml(s) {
 }
 function makeLaunchd(instanceId) {
   const label = SERVICE_LABEL_BASE + (instanceId ? `.${instanceId}` : "");
-  const plistPath = () => join27(homedir12(), "Library", "LaunchAgents", `${label}.plist`);
+  const plistPath = () => join28(homedir12(), "Library", "LaunchAgents", `${label}.plist`);
   const domainTarget = () => `gui/${userInfo().uid}`;
   const serviceTarget = () => `${domainTarget()}/${label}`;
-  const logFile = () => join27(daemonDir(), "daemon.log");
+  const logFile = () => join28(daemonDir(), "daemon.log");
   function buildPlist(spec) {
     const args = [spec.exec, ...spec.args].map((a) => `      <string>${xml(a)}</string>`).join("\n");
     const env = Object.entries(spec.env).map(([k, v]) => `      <key>${xml(k)}</key>
@@ -50703,7 +51095,7 @@ ${env}
 
 // ../../packages/host-core/dist/service/systemd.js
 import { writeFileSync as writeFileSync12, existsSync as existsSync17, mkdirSync as mkdirSync12, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname14, join as join28 } from "node:path";
+import { dirname as dirname14, join as join29 } from "node:path";
 import { homedir as homedir13, userInfo as userInfo2 } from "node:os";
 function shq(s) {
   return `"${s.replace(/(["\\$`])/g, "\\$1")}"`;
@@ -50711,8 +51103,8 @@ function shq(s) {
 function makeSystemd(instanceId) {
   const unit = `tesseract-host${instanceId ? `-${instanceId}` : ""}.service`;
   const unitPath = () => {
-    const base = process.env.XDG_CONFIG_HOME || join28(homedir13(), ".config");
-    return join28(base, "systemd", "user", unit);
+    const base = process.env.XDG_CONFIG_HOME || join29(homedir13(), ".config");
+    return join29(base, "systemd", "user", unit);
   };
   function buildUnit(spec) {
     const execStart = [spec.exec, ...spec.args].map(shq).join(" ");
@@ -50783,11 +51175,11 @@ WantedBy=default.target
 
 // ../../packages/host-core/dist/service/windows.js
 import { writeFileSync as writeFileSync13, existsSync as existsSync18, mkdirSync as mkdirSync13, unlinkSync as unlinkSync5 } from "node:fs";
-import { dirname as dirname15, join as join29 } from "node:path";
+import { dirname as dirname15, join as join30 } from "node:path";
 function makeWindowsTask(instanceId) {
   const task = `Fineguide\\TesseractHost${instanceId ? `-${instanceId}` : ""}`;
-  const wrapperPath = () => join29(daemonDir(), `run-host${instanceId ? `-${instanceId}` : ""}.cmd`);
-  const logFile = () => join29(daemonDir(), "daemon.log");
+  const wrapperPath = () => join30(daemonDir(), `run-host${instanceId ? `-${instanceId}` : ""}.cmd`);
+  const logFile = () => join30(daemonDir(), "daemon.log");
   function buildWrapper(spec) {
     const env = Object.entries(spec.env).map(([k, v]) => `set "${k}=${v}"`).join("\r\n");
     const cmd = [spec.exec, ...spec.args].map((a) => `"${a}"`).join(" ");
@@ -50866,7 +51258,7 @@ function getServiceController(instanceId) {
 var import_qrcode_terminal = __toESM(require_main(), 1);
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync as existsSync19, rmSync } from "node:fs";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 
 // src/config.ts
 import { hostname as hostname4 } from "node:os";
@@ -50898,7 +51290,7 @@ var BS = String.fromCharCode(8);
 var ERASE = BS + " " + BS;
 function ask(question) {
   const { stdin, stdout } = process;
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     stdout.write(question);
     stdin.setEncoding("utf8");
     if (!stdin.isTTY || typeof stdin.setRawMode !== "function") {
@@ -50911,7 +51303,7 @@ function ask(question) {
           stdin.pause();
           let line = data.slice(0, nl);
           if (line.endsWith(CR)) line = line.slice(0, -1);
-          resolve8(line.trim());
+          resolve9(line.trim());
         }
       };
       stdin.resume();
@@ -50926,7 +51318,7 @@ function ask(question) {
       stdin.pause();
       stdin.removeListener("data", onData);
       stdout.write(LF);
-      resolve8(buf.trim());
+      resolve9(buf.trim());
     }
     function onData(chunk) {
       for (const ch of chunk) {
@@ -50982,7 +51374,7 @@ function persist2(api, relay, deviceId2, dt) {
 async function login(opts) {
   const api = (opts.api ?? DEFAULT_API).replace(/\/$/, "");
   const relay = (opts.relay ?? defaultRelay(api)).replace(/\/$/, "");
-  const deviceId2 = readCredentials()?.deviceId ?? randomUUID6().slice(0, 8);
+  const deviceId2 = readCredentials()?.deviceId ?? process.env.CCB_DEVICE_ID ?? randomUUID6().slice(0, 8);
   const label = opts.name ?? defaultLabel();
   if (opts.token) {
     const dt = await fetchJson(`${api}/auth/device-token`, {
@@ -51043,7 +51435,7 @@ async function logout() {
   }
   for (const f of ["credentials.json", "status.json", "daemon.lock"]) {
     try {
-      const p = join30(daemonDir(), f);
+      const p = join31(daemonDir(), f);
       if (existsSync19(p)) rmSync(p);
     } catch {
     }
@@ -51105,7 +51497,7 @@ async function fetchLatest() {
   }
 }
 function installVersion(target) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const npm = process.platform === "win32" ? "npm.cmd" : "npm";
     log2(`installing tesseract-agent@${target} \u2026`);
     let child;
@@ -51113,20 +51505,20 @@ function installVersion(target) {
       child = spawn6(npm, ["install", "-g", `tesseract-agent@${target}`], { stdio: ["ignore", "inherit", "inherit"] });
     } catch (e) {
       log2("npm spawn threw:", e instanceof Error ? e.message : String(e));
-      resolve8(false);
+      resolve9(false);
       return;
     }
     child.on("error", (e) => {
       log2("npm not runnable:", e.message);
-      resolve8(false);
+      resolve9(false);
     });
     child.on("close", (code) => {
       if (code === 0) {
         log2(`installed ${target}`);
-        resolve8(true);
+        resolve9(true);
       } else {
         log2(`npm install exited ${code} \u2014 staying on the current version`);
-        resolve8(false);
+        resolve9(false);
       }
     });
   });
@@ -51167,9 +51559,9 @@ function startSelfUpdater(current) {
 }
 
 // src/service.ts
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 import { platform as platform3 } from "node:os";
-import { existsSync as existsSync20, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync12 } from "node:fs";
 function controller(instanceId) {
   const c = getServiceController(instanceId);
   if (!c) {
@@ -51182,7 +51574,7 @@ function buildSpec(cliEntry) {
     exec: process.execPath,
     args: [cliEntry, "run"],
     env: { CCB_DAEMON_DIR: daemonDir() },
-    logPath: join31(daemonDir(), "daemon.log")
+    logPath: join32(daemonDir(), "daemon.log")
   };
 }
 var isAlive = (pid) => {
@@ -51194,10 +51586,10 @@ var isAlive = (pid) => {
   }
 };
 function runningDaemonInfo() {
-  const lock = join31(daemonDir(), "daemon.lock");
+  const lock = join32(daemonDir(), "daemon.lock");
   try {
     if (!existsSync20(lock)) return null;
-    const pid = Number(readFileSync11(lock, "utf-8").trim());
+    const pid = Number(readFileSync12(lock, "utf-8").trim());
     if (!pid || !isAlive(pid)) return null;
     return { pid, device: readCredentials()?.deviceId };
   } catch {
@@ -51233,8 +51625,8 @@ async function logs(instanceId, follow) {
 // src/cli.ts
 function pkgVersion() {
   try {
-    const p = join32(dirname16(fileURLToPath2(import.meta.url)), "..", "package.json");
-    return JSON.parse(readFileSync12(p, "utf8")).version ?? "0.0.0";
+    const p = join33(dirname16(fileURLToPath2(import.meta.url)), "..", "package.json");
+    return JSON.parse(readFileSync13(p, "utf8")).version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }
@@ -51285,7 +51677,6 @@ function applyRunFlags(rest, flags) {
   }
   if (flags["no-active-link"] === true) process.env.CCB_ACTIVE_LINK = "0";
   else if (flags["active-link"] === true) process.env.CCB_ACTIVE_LINK = "1";
-  else if (process.env.CCB_ACTIVE_LINK === void 0) process.env.CCB_ACTIVE_LINK = "1";
 }
 async function superviseDaemon(cliEntry) {
   let stopping = false;
@@ -51400,7 +51791,7 @@ async function linkCommand(rest, flags) {
     return;
   }
   if (sub === "add") {
-    const folder = rest[1] && !rest[1].startsWith("--") ? resolve7(rest[1]) : void 0;
+    const folder = rest[1] && !rest[1].startsWith("--") ? resolve8(rest[1]) : void 0;
     const peer = typeof flags.peer === "string" ? flags.peer : void 0;
     if (!folder || !peer) {
       console.error("Usage: tesseract-agent link add <folder> --peer <hostId> (--name <shared> | --id <sharedId>)");
@@ -51497,7 +51888,7 @@ async function main() {
       process.exit(1);
     }
     instance = flags.instance;
-    process.env.CCB_DAEMON_DIR = join32(homedir14(), ".tesseract", `daemon-${instance}`);
+    process.env.CCB_DAEMON_DIR = join33(homedir14(), ".tesseract", `daemon-${instance}`);
   }
   const force = flags.yes === true || flags.force === true;
   const cliEntry = fileURLToPath2(import.meta.url);