tesseract-agent 0.4.12 → 0.4.14

package/dist-bundle/cli.js

@@ -19350,91 +19350,1679 @@ var init_cron_tools = __esm({
   }
 });
 
-// ../../packages/agent-core/dist/design-tokens.js
-function colorVar(name, c) {
-  return c.cssVar ?? `--color-${name}`;
+// ../../packages/shared/dist/ws-protocol.js
+var MIRRORED_AGENT_EVENTS;
+var init_ws_protocol = __esm({
+  "../../packages/shared/dist/ws-protocol.js"() {
+    "use strict";
+    MIRRORED_AGENT_EVENTS = /* @__PURE__ */ new Set([
+      "chat:stream",
+      "agent:tool_use",
+      "agent:tool_result",
+      // M4 H10 — co-viewers must see tool OUTPUT, not just the call
+      "agent:file_edit",
+      "chat:complete",
+      "chat:error",
+      "agent:status",
+      "agent:mode_changed",
+      // M4 H11 — co-viewer run-mode badge must flip on plan/edit
+      "agent:session_state",
+      // M4 H11 — co-viewer spinner must clear on idle
+      "agent:todos",
+      // plan sidebar — co-viewers see the live checklist
+      "agent:plan_sections",
+      // 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",
+      "chat:scheduled_fired"
+      // cron — co-viewers see the synthetic "Scheduled" user turn
+      // NOT mirrored: agent:capabilities (host-local model/MCP metadata — mirroring
+      // would stomp a co-viewer's own picker with the driver's host); session:forked
+      // and agent:context_usage are driver-only correlation/host-local replies.
+    ]);
+  }
+});
+
+// ../../packages/shared/dist/frame.js
+var init_frame = __esm({
+  "../../packages/shared/dist/frame.js"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/dist/plans.js
+var NO_QUOTAS, NO_FEATURES, PLAN_CATALOG;
+var init_plans = __esm({
+  "../../packages/shared/dist/plans.js"() {
+    "use strict";
+    NO_QUOTAS = { computeHours: 0, storageGb: 0, egressGb: 0 };
+    NO_FEATURES = {
+      sync: false,
+      mobile: false,
+      cloudWorkspace: false,
+      cloudServer: false,
+      remoteAgents: false,
+      voice: false,
+      team: false,
+      parallelAgents: false,
+      advancedBrowser: false,
+      hosting: false,
+      plugins: false,
+      scheduling: false,
+      api: false,
+      sso: false,
+      seats: 1,
+      maxMachines: 1
+    };
+    PLAN_CATALOG = [
+      {
+        id: "free",
+        name: "Free",
+        monthlyUsd: 0,
+        tagline: "Your machine, your phone, your voice.",
+        features: [
+          "Unlimited agent usage",
+          "Full IDE: editor, files, agent, browser tool",
+          "Voice mode",
+          "Mobile app \u2014 reach your computer from your phone",
+          "Cloud workspace \u2014 your machine and recent projects in one view",
+          "One machine",
+          "Deploy to your own machine or server",
+          "Community support"
+        ],
+        featurePolicy: { ...NO_FEATURES, voice: true, mobile: true, cloudWorkspace: true },
+        quotas: { ...NO_QUOTAS }
+      },
+      {
+        id: "standard",
+        name: "Pro",
+        monthlyUsd: 20,
+        tagline: "Your workspace, everywhere.",
+        features: [
+          "Everything in Free",
+          "Unlimited machines \u2014 run agents on all of them",
+          "Tesseract cloud server \u2014 a managed always-on agent in the cloud",
+          "Deploy to the cloud \u2014 your app on a *.tesseract.dev URL",
+          "Includes ~1 always-on service + 20 GB storage + 100 GB bandwidth (overage metered)",
+          "Sync settings across your devices",
+          "Email support"
+        ],
+        featurePolicy: {
+          ...NO_FEATURES,
+          sync: true,
+          mobile: true,
+          cloudWorkspace: true,
+          cloudServer: true,
+          remoteAgents: true,
+          voice: true,
+          hosting: true,
+          plugins: true,
+          scheduling: true,
+          maxMachines: 0
+        },
+        // ~1 small always-on service (~720 compute-hours/mo, rounded) + 20 GB storage + 100 GB egress.
+        quotas: { computeHours: 750, storageGb: 20, egressGb: 100 }
+      },
+      {
+        id: "pro",
+        name: "Team",
+        monthlyUsd: 40,
+        perSeat: true,
+        tagline: "For teams shipping together.",
+        features: [
+          "Everything in Pro, per seat",
+          "Team seats + shared workspaces",
+          "Parallel agents",
+          "Advanced browser automation",
+          "API access",
+          "SSO, audit logs, centralized billing",
+          "Pooled cloud hosting \u2014 bigger shared quota",
+          "Priority support"
+        ],
+        featurePolicy: {
+          sync: true,
+          mobile: true,
+          cloudWorkspace: true,
+          cloudServer: true,
+          remoteAgents: true,
+          voice: true,
+          team: true,
+          parallelAgents: true,
+          advancedBrowser: true,
+          hosting: true,
+          plugins: true,
+          scheduling: true,
+          api: true,
+          sso: true,
+          seats: 2,
+          maxMachines: 0
+        },
+        // Pooled across the team — ~4× Pro's starter quota.
+        quotas: { computeHours: 3e3, storageGb: 100, egressGb: 500 }
+      }
+    ];
+  }
+});
+
+// ../../packages/shared/dist/slug.js
+var init_slug = __esm({
+  "../../packages/shared/dist/slug.js"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/dist/hosting.js
+var init_hosting = __esm({
+  "../../packages/shared/dist/hosting.js"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/dist/cloud-agent.js
+var init_cloud_agent = __esm({
+  "../../packages/shared/dist/cloud-agent.js"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/dist/settings.js
+var MODEL_OPTIONS;
+var init_settings = __esm({
+  "../../packages/shared/dist/settings.js"() {
+    "use strict";
+    MODEL_OPTIONS = [
+      { id: "claude-opus-4-8", label: "Claude Opus 4.8" },
+      { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
+      { id: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5" }
+    ];
+  }
+});
+
+// ../../packages/shared/dist/engines.js
+function engineById(id) {
+  return ENGINE_CATALOG[id];
+}
+var ENGINE_CATALOG, ENGINE_IDS;
+var init_engines = __esm({
+  "../../packages/shared/dist/engines.js"() {
+    "use strict";
+    init_settings();
+    ENGINE_CATALOG = {
+      "claude-code": {
+        id: "claude-code",
+        label: "Claude Code",
+        description: "Anthropic's Claude Code \u2014 the default engine, deepest tool + browser integration.",
+        cliBinary: "claude",
+        // Claude's token is injected via CLAUDE_CODE_OAUTH_TOKEN, so oauth needs no auth file.
+        supportedModes: ["oauth", "apiKey", "localCli"],
+        apiKeyEnv: "ANTHROPIC_API_KEY",
+        models: MODEL_OPTIONS,
+        capabilities: { permissionGating: true, browserControl: true, liveRunMode: true, resume: true, fork: true, contextUsage: true, scheduling: true },
+        homepageUrl: "https://docs.claude.com/en/docs/claude-code",
+        installCommand: "npm install -g @anthropic-ai/claude-code",
+        installHint: "Bundled with the app; install the standalone CLI for local-instance mode."
+      },
+      "openai-codex": {
+        id: "openai-codex",
+        label: "OpenAI Codex",
+        description: "OpenAI's Codex CLI. Sign in with ChatGPT or use an API key.",
+        cliBinary: "codex",
+        supportedModes: ["oauth", "apiKey", "localCli"],
+        apiKeyEnv: "OPENAI_API_KEY",
+        authFileRel: "auth.json",
+        // under $CODEX_HOME
+        models: [
+          { id: "gpt-5.5-codex", label: "GPT-5.5 Codex" },
+          { id: "gpt-5.5", label: "GPT-5.5" }
+        ],
+        capabilities: { permissionGating: false, browserControl: false, liveRunMode: false, resume: true },
+        homepageUrl: "https://developers.openai.com/codex/cli",
+        installCommand: "npm install -g @openai/codex",
+        installHint: "npm i -g @openai/codex (or brew install codex)"
+      },
+      opencode: {
+        id: "opencode",
+        label: "OpenCode",
+        description: "Open-source agent over 75+ providers. Log in per provider.",
+        cliBinary: "opencode",
+        supportedModes: ["oauth", "apiKey", "localCli"],
+        // OpenCode reads provider keys from env / its own auth.json; no single apiKeyEnv.
+        authFileRel: "auth.json",
+        // under ~/.local/share/opencode
+        models: [],
+        // provider+model is configured inside OpenCode; "" ⇒ its default
+        capabilities: { permissionGating: false, browserControl: false, liveRunMode: false, resume: true },
+        homepageUrl: "https://opencode.ai",
+        installCommand: "npm install -g opencode-ai",
+        installHint: "npm i -g opencode-ai (see opencode.ai/docs)"
+      },
+      "gemini-cli": {
+        id: "gemini-cli",
+        label: "Gemini CLI",
+        description: "Google's Gemini CLI. Sign in with Google or use a Gemini API key.",
+        cliBinary: "gemini",
+        supportedModes: ["oauth", "apiKey", "localCli"],
+        apiKeyEnv: "GEMINI_API_KEY",
+        models: [
+          { id: "gemini-3.1-pro", label: "Gemini 3.1 Pro" },
+          { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" }
+        ],
+        capabilities: { permissionGating: false, browserControl: false, liveRunMode: false, resume: false },
+        homepageUrl: "https://github.com/google-gemini/gemini-cli",
+        installCommand: "npm install -g @google/gemini-cli",
+        installHint: "npm i -g @google/gemini-cli"
+      },
+      openclaw: {
+        id: "openclaw",
+        label: "OpenClaw",
+        description: "OpenClaw runtime \u2014 runs your installed channels, model providers, and plugins natively.",
+        cliBinary: "openclaw",
+        // OpenClaw manages its own provider auth (`openclaw onboard` / openclaw.json), so the
+        // only mode is "use the installed, already-onboarded CLI" — like OpenCode.
+        supportedModes: ["localCli"],
+        models: [],
+        // provider+model is configured inside OpenClaw; '' ⇒ its default
+        capabilities: { permissionGating: false, browserControl: false, liveRunMode: false, resume: false },
+        homepageUrl: "https://docs.openclaw.ai",
+        installCommand: "npm install -g openclaw",
+        installHint: "npm i -g openclaw, then run `openclaw onboard` (see docs.openclaw.ai)"
+      }
+    };
+    ENGINE_IDS = Object.keys(ENGINE_CATALOG);
+  }
+});
+
+// ../../packages/shared/dist/providers.js
+function providerById(id) {
+  return PROVIDER_CATALOG[id];
 }
-function tokensToCss(tokens) {
-  const lines = [
+var PROVIDER_CATALOG, PROVIDER_IDS, NATIVE_PROVIDER_IDS;
+var init_providers = __esm({
+  "../../packages/shared/dist/providers.js"() {
+    "use strict";
+    PROVIDER_CATALOG = {
+      anthropic: {
+        id: "anthropic",
+        label: "Anthropic",
+        description: "Claude models, direct from Anthropic. The native backend for Claude Code.",
+        baseUrl: "https://api.anthropic.com",
+        api: "anthropic-messages",
+        claudeNative: true,
+        authEnvVars: ["ANTHROPIC_API_KEY"],
+        authModes: ["oauth", "apiKey"],
+        models: [
+          { id: "claude-opus-4-8", label: "Claude Opus 4.8", role: "main" },
+          { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", role: "main" },
+          { id: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5", role: "fast" }
+        ],
+        homepageUrl: "https://docs.claude.com/en/docs/about-claude/models"
+      },
+      openai: {
+        id: "openai",
+        label: "OpenAI",
+        description: "OpenAI models. The native backend for the Codex engine.",
+        baseUrl: "https://api.openai.com/v1",
+        api: "openai-completions",
+        claudeNative: false,
+        authEnvVars: ["OPENAI_API_KEY"],
+        authModes: ["oauth", "apiKey"],
+        models: [
+          { id: "gpt-5.5-codex", label: "GPT-5.5 Codex", role: "main" },
+          { id: "gpt-5.5", label: "GPT-5.5", role: "main" }
+        ],
+        homepageUrl: "https://platform.openai.com/docs/models"
+      },
+      google: {
+        id: "google",
+        label: "Google Gemini",
+        description: "Gemini models. The native backend for the Gemini engine.",
+        baseUrl: "https://generativelanguage.googleapis.com",
+        api: "gemini",
+        claudeNative: false,
+        authEnvVars: ["GEMINI_API_KEY"],
+        authModes: ["oauth", "apiKey"],
+        models: [
+          { id: "gemini-3.1-pro", label: "Gemini 3.1 Pro", role: "main" },
+          { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash", role: "fast" }
+        ],
+        homepageUrl: "https://ai.google.dev/gemini-api/docs/models"
+      },
+      openrouter: {
+        id: "openrouter",
+        label: "OpenRouter",
+        description: "One key, hundreds of models. Exposes an Anthropic-compatible route \u2014 no proxy needed for Claude Code.",
+        // OpenAI-style base; the Anthropic-compatible base is `…/api` (no `/v1`).
+        baseUrl: "https://openrouter.ai/api/v1",
+        anthropicBaseUrl: "https://openrouter.ai/api",
+        api: "openai-completions",
+        claudeNative: true,
+        authEnvVars: ["OPENROUTER_API_KEY"],
+        headers: {
+          "HTTP-Referer": "https://app.tesseract.dev",
+          "X-Title": "Tesseract"
+        },
+        authModes: ["apiKey"],
+        // Any OpenRouter slug is valid; these are stable starters (free entry in UI).
+        models: [
+          { id: "deepseek/deepseek-chat", label: "DeepSeek Chat", role: "fast" },
+          { id: "deepseek/deepseek-r1", label: "DeepSeek R1", role: "main" },
+          { id: "google/gemini-2.5-flash", label: "Gemini 2.5 Flash", role: "fast" },
+          { id: "google/gemini-2.5-pro", label: "Gemini 2.5 Pro", role: "main" }
+        ],
+        homepageUrl: "https://openrouter.ai/docs"
+      },
+      ollama: {
+        id: "ollama",
+        label: "Ollama (local)",
+        description: "Run open models locally. No API key. Models are discovered from your running Ollama.",
+        baseUrl: "http://127.0.0.1:11434",
+        api: "ollama",
+        claudeNative: false,
+        authEnvVars: [],
+        authModes: ["apiKey"],
+        // optional bearer for remote Ollama; usually none
+        models: [],
+        dynamicModels: true,
+        homepageUrl: "https://ollama.com",
+        installCommand: "curl -fsSL https://ollama.com/install.sh | sh"
+      },
+      deepseek: {
+        id: "deepseek",
+        label: "DeepSeek",
+        description: "DeepSeek Chat + Reasoner. Cheap and capable. Reached via the proxy for Claude Code.",
+        baseUrl: "https://api.deepseek.com",
+        api: "openai-completions",
+        claudeNative: false,
+        authEnvVars: ["DEEPSEEK_API_KEY"],
+        authModes: ["apiKey"],
+        models: [
+          { id: "deepseek-chat", label: "DeepSeek Chat", role: "fast" },
+          { id: "deepseek-reasoner", label: "DeepSeek Reasoner", role: "main" }
+        ],
+        homepageUrl: "https://api-docs.deepseek.com"
+      },
+      moonshot: {
+        id: "moonshot",
+        label: "Kimi (Moonshot)",
+        description: "Kimi K2 models. Use the coding endpoint (Anthropic-compatible, no proxy) or the OpenAI endpoint.",
+        // Default to the OpenAI-style endpoint; the per-credential `baseUrl` can switch
+        // to the Anthropic-compatible coding endpoint below.
+        baseUrl: "https://api.moonshot.ai/v1",
+        anthropicBaseUrl: "https://api.kimi.com/coding/",
+        api: "openai-completions",
+        claudeNative: true,
+        authEnvVars: ["MOONSHOT_API_KEY", "KIMI_API_KEY"],
+        authModes: ["apiKey"],
+        models: [
+          { id: "kimi-code", label: "Kimi Code (coding endpoint)", role: "main" },
+          { id: "kimi-k2.5", label: "Kimi K2.5", role: "main" },
+          { id: "kimi-k2-thinking", label: "Kimi K2 Thinking", role: "main" }
+        ],
+        homepageUrl: "https://platform.moonshot.ai/docs"
+      },
+      "custom-openai": {
+        id: "custom-openai",
+        label: "Custom (OpenAI-compatible)",
+        description: "Any OpenAI-compatible endpoint (LM Studio, llama.cpp, vLLM, a private gateway). Set the base URL per key.",
+        baseUrl: "",
+        api: "openai-completions",
+        claudeNative: false,
+        authEnvVars: ["OPENAI_API_KEY"],
+        authModes: ["apiKey"],
+        models: [],
+        homepageUrl: "https://platform.openai.com/docs/api-reference"
+      },
+      litellm: {
+        id: "litellm",
+        label: "LiteLLM Proxy",
+        description: "Your LiteLLM proxy fronting 100+ providers. Point it at the anthropic route for direct Claude Code use.",
+        baseUrl: "",
+        anthropicBaseUrl: "",
+        api: "openai-completions",
+        // Configurable: LiteLLM can expose an Anthropic-shaped route. Treated as
+        // claudeNative so users can point Claude Code straight at it.
+        claudeNative: true,
+        authEnvVars: ["LITELLM_API_KEY"],
+        authModes: ["apiKey"],
+        models: [],
+        homepageUrl: "https://docs.litellm.ai/docs/simple_proxy"
+      }
+    };
+    PROVIDER_IDS = Object.keys(PROVIDER_CATALOG);
+    NATIVE_PROVIDER_IDS = ["anthropic", "openai", "google"];
+  }
+});
+
+// ../../packages/shared/dist/runtimes.js
+var RUNTIME_CATALOG, RUNTIME_IDS;
+var init_runtimes = __esm({
+  "../../packages/shared/dist/runtimes.js"() {
+    "use strict";
+    init_engines();
+    RUNTIME_CATALOG = [
+      ...ENGINE_IDS.map((id) => ({
+        id,
+        label: ENGINE_CATALOG[id].label,
+        cliBinary: ENGINE_CATALOG[id].cliBinary,
+        installCommand: ENGINE_CATALOG[id].installCommand,
+        kind: "engine"
+      })),
+      { id: "ollama", label: "Ollama", cliBinary: "ollama", installCommand: "curl -fsSL https://ollama.com/install.sh | sh", kind: "tool" },
+      { id: "ccr", label: "Claude Code Router", cliBinary: "ccr", installCommand: "npm install -g @musistudio/claude-code-router", kind: "tool" }
+    ];
+    RUNTIME_IDS = RUNTIME_CATALOG.map((r) => r.id);
+  }
+});
+
+// ../../packages/shared/dist/runner-configs.js
+var init_runner_configs = __esm({
+  "../../packages/shared/dist/runner-configs.js"() {
+    "use strict";
+    init_providers();
+  }
+});
+
+// ../../packages/shared/dist/rotation.js
+function refreshCredentials(creds, now) {
+  return creds.map((c) => {
+    if (c.status === "cooldown" && (c.cooldownUntil == null || c.cooldownUntil <= now)) {
+      return { ...c, status: "active", cooldownUntil: void 0 };
+    }
+    if (c.status === "active" && c.expiresAt != null && c.expiresAt <= now) {
+      return { ...c, status: "expired" };
+    }
+    return c;
+  });
+}
+function selectRotatable(items, now, isUsable = () => true) {
+  const usable = refreshCredentials(items, now).filter((c) => c.status === "active" && (c.expiresAt == null || c.expiresAt > now) && isUsable(c));
+  if (usable.length === 0)
+    return void 0;
+  return usable.sort((a, b) => a.priority - b.priority || (a.lastUsedAt ?? 0) - (b.lastUsedAt ?? 0))[0];
+}
+function classifyError(raw) {
+  const s = raw.toLowerCase();
+  if (/\b429\b|rate[ _-]?limit|too many requests/.test(s))
+    return "rate_limit";
+  if (/quota|insufficient[_ ]?quota|credit|billing|payment required|\b402\b|usage limit|exceeded your/.test(s))
+    return "quota_exceeded";
+  if (/expired|token (?:has )?expired|refresh|re-?authenticate|session expired/.test(s))
+    return "auth_expired";
+  if (/\b401\b|\b403\b|invalid (?:api )?key|unauthorized|invalid token|authentication/.test(s))
+    return "invalid_key";
+  if (/\beai_again\b|\benotfound\b|getaddrinfo|network is unreachable|\benetunreach\b|\benetdown\b|offline|no address associated|dns/.test(s))
+    return "network_down";
+  if (/\beconnreset\b|\beconnrefused\b|\betimedout\b|\bepipe\b|socket hang ?up|connection (?:closed|reset|error|aborted)|\b50[0234]\b|\b529\b|overloaded|service unavailable|bad gateway|gateway time-?out|temporarily unavailable/.test(s))
+    return "transient";
+  return "unknown";
+}
+function recordFailure(creds, id, errorCode, now, opts) {
+  if (errorCode === "unknown" || errorCode === "transient" || errorCode === "network_down") {
+    return { next: creds, advanced: false };
+  }
+  let advanced = false;
+  const next = creds.map((c) => {
+    if (c.id !== id)
+      return c;
+    advanced = true;
+    const consecutiveFailures = (c.consecutiveFailures ?? 0) + 1;
+    if (errorCode === "auth_expired") {
+      return { ...c, status: "expired", lastErrorCode: errorCode, consecutiveFailures };
+    }
+    if (errorCode === "invalid_key") {
+      return { ...c, status: "revoked", lastErrorCode: errorCode, consecutiveFailures };
+    }
+    const backoff = Math.min(COOLDOWN_BASE_MS * 2 ** (consecutiveFailures - 1), COOLDOWN_MAX_MS);
+    const cooldownUntil = opts?.cooldownUntil ?? now + backoff;
+    return { ...c, status: "cooldown", cooldownUntil, lastErrorCode: errorCode, consecutiveFailures };
+  });
+  return { next, advanced };
+}
+function recordSuccess(creds, id, now) {
+  return creds.map((c) => c.id === id ? { ...c, status: "active", cooldownUntil: void 0, consecutiveFailures: 0, lastUsedAt: now, lastErrorCode: void 0 } : c);
+}
+var COOLDOWN_BASE_MS, COOLDOWN_MAX_MS;
+var init_rotation = __esm({
+  "../../packages/shared/dist/rotation.js"() {
+    "use strict";
+    COOLDOWN_BASE_MS = 6e4;
+    COOLDOWN_MAX_MS = 36e5;
+  }
+});
+
+// ../../packages/shared/dist/design-tokens.js
+function isObj(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isToken(node) {
+  return isObj(node) && "$value" in node;
+}
+function tessExt(token) {
+  const ext = token.$extensions?.["com.tesseract"];
+  return isObj(ext) ? ext : void 0;
+}
+function walkTokens(tree) {
+  const out = [];
+  const rec = (node, path5) => {
+    if (!isObj(node))
+      return;
+    if (isToken(node)) {
+      out.push({ path: path5, token: node });
+      return;
+    }
+    for (const key2 of Object.keys(node)) {
+      if (key2.startsWith("$"))
+        continue;
+      rec(node[key2], [...path5, key2]);
+    }
+  };
+  rec(tree, []);
+  return out;
+}
+function stringifyValue(v) {
+  if (v == null)
+    return "";
+  if (Array.isArray(v))
+    return v.map((x) => isObj(x) ? JSON.stringify(x) : String(x)).join(", ");
+  if (isObj(v))
+    return JSON.stringify(v);
+  return String(v);
+}
+function flattenForDisplay(tree) {
+  return walkTokens(tree).map(({ path: path5, token }) => {
+    const dark = tessExt(token)?.modes?.dark;
+    return {
+      path: path5,
+      dotPath: path5.join("."),
+      group: path5.slice(0, -1).join(" \xB7 "),
+      label: path5[path5.length - 1] ?? "",
+      type: token.$type,
+      value: stringifyValue(token.$value),
+      isColor: token.$type === "color",
+      darkValue: dark === void 0 ? void 0 : stringifyValue(dark)
+    };
+  });
+}
+function kebab(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function tokenCssVarName(path5, token) {
+  const override = token ? tessExt(token)?.cssVar : void 0;
+  if (override)
+    return override.startsWith("--") ? override : `--${override}`;
+  for (const { match, prefix } of VAR_ALIASES) {
+    if (match.length <= path5.length && match.every((seg, i) => path5[i] === seg)) {
+      const rest = path5.slice(match.length).map(kebab).filter(Boolean);
+      return ["--" + prefix, ...rest].join("-");
+    }
+  }
+  return ["--token", ...path5.map(kebab).filter(Boolean)].join("-");
+}
+function categoryRank(top) {
+  const i = CATEGORY_ORDER.indexOf(top ?? "");
+  return i === -1 ? CATEGORY_ORDER.length : i;
+}
+function shadowToCss(v) {
+  const s = (k, d = "0") => v[k] == null ? d : String(v[k]);
+  const inset = v.inset ? "inset " : "";
+  return `${inset}${s("offsetX")} ${s("offsetY")} ${s("blur")} ${s("spread")} ${s("color", "#000")}`.replace(/\s+/g, " ").trim();
+}
+function cssValue(type, v) {
+  if (Array.isArray(v)) {
+    if (type === "fontFamily") {
+      return v.map((f) => typeof f === "string" && /\s/.test(f) && !/^["']/.test(f) ? `"${f}"` : String(f)).join(", ");
+    }
+    return v.map((x) => isObj(x) ? shadowToCss(x) : String(x)).join(", ");
+  }
+  if (isObj(v))
+    return shadowToCss(v);
+  return String(v);
+}
+function tokensToCss(input) {
+  const tokens = normalizeTokens(input);
+  const rows = walkTokens(tokens);
+  const ordered = rows.map((r, i) => ({ r, i })).sort((a, b) => categoryRank(a.r.path[0]) - categoryRank(b.r.path[0]) || a.i - b.i).map((x) => x.r);
+  const root = [];
+  const dark = [];
+  for (const { path: path5, token } of ordered) {
+    const name = tokenCssVarName(path5, token);
+    root.push(`  ${name}: ${cssValue(token.$type, token.$value)};`);
+    const d = tessExt(token)?.modes?.dark;
+    if (d !== void 0)
+      dark.push(`  ${name}: ${cssValue(token.$type, d)};`);
+  }
+  const out = [
     "/* GENERATED from design-system/tokens.json \u2014 do not edit by hand. */",
-    ":root {"
+    ":root {",
+    ...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");
+  if (dark.length)
+    out.push("", ".dark {", ...dark, "}");
+  out.push("");
+  return out.join("\n");
 }
-function getTokenPath(tokens, dotPath) {
+function getTokenSegments(tokens, segments) {
   let cur = tokens;
-  for (const key2 of dotPath.split(".")) {
-    if (cur == null || typeof cur !== "object")
+  for (const key2 of segments) {
+    if (!isObj(cur))
       return void 0;
     cur = cur[key2];
   }
   return cur;
 }
-function setTokenPath(tokens, dotPath, value) {
-  const keys = dotPath.split(".").filter(Boolean);
-  if (keys.length === 0)
+function getTokenPath(tokens, dotPath) {
+  return getTokenSegments(tokens, dotPath.split(".").filter(Boolean));
+}
+function setTokenSegments(tokens, segments, value) {
+  if (segments.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];
+  for (let i = 0; i < segments.length - 1; i++) {
+    const k = segments[i];
     const next = cur[k];
-    cur[k] = next && typeof next === "object" ? { ...next } : {};
+    cur[k] = isObj(next) ? { ...next } : {};
     cur = cur[k];
   }
-  cur[keys[keys.length - 1]] = value;
+  cur[segments[segments.length - 1]] = value;
   return root;
 }
-var DESIGN_DIR, TOKENS_FILE, TOKENS_CSS_FILE, DESIGN_CLAUDE_MD, ColorToken, TypeStep, Component, DesignTokensSchema;
+function setTokenPath(tokens, dotPath, value) {
+  return setTokenSegments(tokens, dotPath.split(".").filter(Boolean), value);
+}
+function makeToken(value, type) {
+  const tok = { $value: value };
+  if (type)
+    tok.$type = type;
+  return tok;
+}
+function splitFamily(s) {
+  if (Array.isArray(s))
+    return s;
+  if (typeof s === "string")
+    return s.split(",").map((x) => x.trim()).filter(Boolean);
+  return String(s ?? "");
+}
+function isLightDarkPair(n) {
+  if ("$value" in n)
+    return false;
+  const scalar = (v) => typeof v === "string" || typeof v === "number";
+  const keys = Object.keys(n).filter((k) => !k.startsWith("$"));
+  return keys.length > 0 && keys.includes("light") && keys.every((k) => k === "light" || k === "dark") && scalar(n.light) && (n.dark === void 0 || scalar(n.dark));
+}
+function isLegacyColorLeaf(v) {
+  return isObj(v) && typeof v.value === "string" && !("$value" in v);
+}
+function canonicalizeNode(node, inheritedType) {
+  if (typeof node === "string" || typeof node === "number" || Array.isArray(node)) {
+    return makeToken(node, inheritedType);
+  }
+  if (!isObj(node))
+    return void 0;
+  if (isLightDarkPair(node)) {
+    const modes = {};
+    for (const k of Object.keys(node))
+      if (k !== "light" && !k.startsWith("$"))
+        modes[k] = node[k];
+    const tok = makeToken(node.light, node.$type ?? inheritedType);
+    if (Object.keys(modes).length)
+      tok.$extensions = { "com.tesseract": { modes } };
+    return tok;
+  }
+  if ("$value" in node) {
+    const tok = { $value: node.$value };
+    const t = node.$type ?? inheritedType;
+    if (t)
+      tok.$type = t;
+    if (typeof node.$description === "string")
+      tok.$description = node.$description;
+    if (isObj(node.$extensions))
+      tok.$extensions = node.$extensions;
+    return tok;
+  }
+  if (inheritedType === "color" && isLegacyColorLeaf(node)) {
+    const tok = makeToken(node.value, "color");
+    if (node.role)
+      tok.$description = node.role;
+    if (node.cssVar)
+      tok.$extensions = { "com.tesseract": { cssVar: node.cssVar } };
+    return tok;
+  }
+  return canonicalizeGroup(node, inheritedType);
+}
+function canonicalizeGroup(node, inheritedType) {
+  const groupType = node.$type ?? inheritedType;
+  const g = {};
+  if (typeof node.$type === "string")
+    g.$type = node.$type;
+  if (typeof node.$description === "string")
+    g.$description = node.$description;
+  if (isObj(node.$extensions))
+    g.$extensions = node.$extensions;
+  for (const key2 of Object.keys(node)) {
+    if (key2.startsWith("$"))
+      continue;
+    const child = canonicalizeNode(node[key2], groupType);
+    if (child !== void 0)
+      g[key2] = child;
+  }
+  return g;
+}
+function normalizeColorGroup(src) {
+  const g = { $type: "color" };
+  if (typeof src.$description === "string")
+    g.$description = src.$description;
+  for (const key2 of Object.keys(src)) {
+    if (key2.startsWith("$"))
+      continue;
+    const v = src[key2];
+    if (isLegacyColorLeaf(v)) {
+      const tok = makeToken(v.value, "color");
+      if (v.role)
+        tok.$description = v.role;
+      if (v.cssVar)
+        tok.$extensions = { "com.tesseract": { cssVar: v.cssVar } };
+      g[key2] = tok;
+    } else {
+      const child = canonicalizeNode(v, "color");
+      if (child !== void 0)
+        g[key2] = child;
+    }
+  }
+  return g;
+}
+function hasTokens(g) {
+  return Object.keys(g).some((k) => !k.startsWith("$"));
+}
+function normalizeTypography(src) {
+  const g = {};
+  if (typeof src.$description === "string")
+    g.$description = src.$description;
+  if (isObj(src.fontFamilies)) {
+    const ff = { $type: "fontFamily" };
+    for (const [k, val] of Object.entries(src.fontFamilies))
+      ff[k] = makeToken(splitFamily(val), "fontFamily");
+    g.fontFamily = ff;
+  }
+  if (isObj(src.scale)) {
+    const sizes = { $type: "dimension" };
+    const leading = { $type: "lineHeight" };
+    const weights = { $type: "fontWeight" };
+    for (const [k, step] of Object.entries(src.scale)) {
+      if (!isObj(step))
+        continue;
+      if (step.size != null)
+        sizes[k] = makeToken(step.size, "dimension");
+      if (step.lineHeight != null)
+        leading[k] = makeToken(step.lineHeight, "lineHeight");
+      if (step.weight != null)
+        weights[k] = makeToken(step.weight, "fontWeight");
+    }
+    g.fontSize = sizes;
+    if (hasTokens(leading))
+      g.lineHeight = leading;
+    if (hasTokens(weights))
+      g.fontWeight = weights;
+  }
+  if (isObj(src.weights)) {
+    const w = isObj(g.fontWeight) ? g.fontWeight : { $type: "fontWeight" };
+    for (const [k, val] of Object.entries(src.weights))
+      w[k] = makeToken(val, "fontWeight");
+    g.fontWeight = w;
+  }
+  const TYPE_HINT = {
+    fontFamily: "fontFamily",
+    fontSize: "dimension",
+    fontWeight: "fontWeight",
+    lineHeight: "lineHeight",
+    letterSpacing: "letterSpacing"
+  };
+  for (const key2 of Object.keys(src)) {
+    if (key2.startsWith("$"))
+      continue;
+    if (key2 === "fontFamilies" || key2 === "scale" || key2 === "weights")
+      continue;
+    if (g[key2] !== void 0)
+      continue;
+    if (isObj(src[key2]))
+      g[key2] = canonicalizeGroup(src[key2], TYPE_HINT[key2]);
+  }
+  return g;
+}
+function normalizeDimensionGroup(src, dtype) {
+  const g = { $type: src.$type ?? dtype };
+  if (typeof src.$description === "string")
+    g.$description = src.$description;
+  for (const key2 of Object.keys(src)) {
+    if (key2.startsWith("$"))
+      continue;
+    const child = canonicalizeNode(src[key2], g.$type);
+    if (child !== void 0)
+      g[key2] = child;
+  }
+  return g;
+}
+function normalizeTokens(raw) {
+  if (!isObj(raw))
+    return {};
+  const out = {};
+  out.$schema = typeof raw.$schema === "string" ? raw.$schema : DTCG_SCHEMA_URL;
+  const meta4 = isObj(raw.$meta) ? raw.$meta : isObj(raw.meta) ? raw.meta : void 0;
+  if (meta4)
+    out.$meta = { ...meta4 };
+  const comps = isObj(raw.$components) ? raw.$components : isObj(raw.components) ? raw.components : void 0;
+  if (comps)
+    out.$components = comps;
+  const colorSrc = isObj(raw.color) ? raw.color : isObj(raw.colors) ? raw.colors : void 0;
+  if (colorSrc)
+    out.color = normalizeColorGroup(colorSrc);
+  if (isObj(raw.typography))
+    out.typography = normalizeTypography(raw.typography);
+  if (isObj(raw.spacing))
+    out.spacing = normalizeDimensionGroup(raw.spacing, "dimension");
+  if (isObj(raw.radius))
+    out.radius = normalizeDimensionGroup(raw.radius, "dimension");
+  if (isObj(raw.shadow))
+    out.shadow = normalizeDimensionGroup(raw.shadow, "shadow");
+  for (const key2 of Object.keys(raw)) {
+    if (key2.startsWith("$") || KNOWN_TOP.has(key2))
+      continue;
+    if (isObj(raw[key2]))
+      out[key2] = canonicalizeGroup(raw[key2], void 0);
+  }
+  return out;
+}
+function applyDesignPack(current, packTokens, info, opts) {
+  const cur = normalizeTokens(current);
+  const pack = normalizeTokens(packTokens);
+  const { mode } = opts;
+  const writeLeaves = (base, keep) => {
+    let acc = base;
+    for (const { path: path5, token } of walkTokens(pack)) {
+      if (keep && !keep(path5))
+        continue;
+      acc = setTokenSegments(acc, path5, token);
+    }
+    return acc;
+  };
+  let out;
+  if (mode === "replace") {
+    out = { $schema: pack.$schema ?? cur.$schema ?? DTCG_SCHEMA_URL };
+    if (cur.$meta)
+      out.$meta = cur.$meta;
+    if (cur.$components)
+      out.$components = cur.$components;
+    for (const k of Object.keys(pack))
+      if (!k.startsWith("$"))
+        out[k] = pack[k];
+  } else if (mode === "palette") {
+    out = writeLeaves(cur, (p) => p[0] === "color" || p[0] === "typography" && p[1] === "fontFamily");
+  } else {
+    out = writeLeaves(cur);
+  }
+  const prevMeta = isObj(out.$meta) ? out.$meta : {};
+  return { ...out, $meta: { ...prevMeta, theme: { id: info.id, name: info.name, appliedMode: mode } } };
+}
+function parseColorToRgb(v) {
+  const s = v.trim();
+  const hex3 = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(s);
+  if (hex3)
+    return [parseInt(hex3[1] + hex3[1], 16), parseInt(hex3[2] + hex3[2], 16), parseInt(hex3[3] + hex3[3], 16)];
+  const hex68 = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})(?:[0-9a-f]{2})?$/i.exec(s);
+  if (hex68)
+    return [parseInt(hex68[1], 16), parseInt(hex68[2], 16), parseInt(hex68[3], 16)];
+  const hsl = /^(-?\d+(?:\.\d+)?)\s*[, ]\s*(-?\d+(?:\.\d+)?)%\s*[, ]\s*(-?\d+(?:\.\d+)?)%$/.exec(s);
+  if (hsl)
+    return hslToRgb(parseFloat(hsl[1]), parseFloat(hsl[2]), parseFloat(hsl[3]));
+  return null;
+}
+function hslToRgb(h, s, l) {
+  h = (h % 360 + 360) % 360;
+  s /= 100;
+  l /= 100;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r = 0, g = 0, b = 0;
+  if (h < 60)
+    [r, g, b] = [c, x, 0];
+  else if (h < 120)
+    [r, g, b] = [x, c, 0];
+  else if (h < 180)
+    [r, g, b] = [0, c, x];
+  else if (h < 240)
+    [r, g, b] = [0, x, c];
+  else if (h < 300)
+    [r, g, b] = [x, 0, c];
+  else
+    [r, g, b] = [c, 0, x];
+  return [Math.round((r + m) * 255), Math.round((g + m) * 255), Math.round((b + m) * 255)];
+}
+function relLuminance([r, g, b]) {
+  const lin = (c) => {
+    const cs = c / 255;
+    return cs <= 0.03928 ? cs / 12.92 : Math.pow((cs + 0.055) / 1.055, 2.4);
+  };
+  return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+}
+function contrastRatio(a, b) {
+  const ca = parseColorToRgb(a), cb = parseColorToRgb(b);
+  if (!ca || !cb)
+    return 0;
+  const la = relLuminance(ca), lb = relLuminance(cb);
+  const hi = Math.max(la, lb), lo = Math.min(la, lb);
+  return (hi + 0.05) / (lo + 0.05);
+}
+function setNested(obj, segs, value) {
+  let cur = obj;
+  for (let i = 0; i < segs.length - 1; i++) {
+    const k = segs[i];
+    if (!isObj(cur[k]))
+      cur[k] = {};
+    cur = cur[k];
+  }
+  cur[segs[segs.length - 1]] = value;
+}
+function tokensToTailwindTheme(input) {
+  const tokens = normalizeTokens(input);
+  const extend2 = {};
+  for (const { path: path5, token } of walkTokens(tokens)) {
+    const bucket = TW_BUCKETS.find((b) => b.match.length <= path5.length && b.match.every((seg, i) => path5[i] === seg));
+    if (!bucket)
+      continue;
+    const rest = path5.slice(bucket.match.length).map(kebab).filter(Boolean);
+    if (rest.length === 0)
+      continue;
+    const ref = `var(${tokenCssVarName(path5, token)})`;
+    if (!extend2[bucket.key])
+      extend2[bucket.key] = {};
+    if (bucket.flat)
+      extend2[bucket.key][rest.join("-")] = ref;
+    else
+      setNested(extend2[bucket.key], rest, ref);
+  }
+  return { extend: extend2 };
+}
+function tokensToTailwindConfig(input) {
+  const theme = tokensToTailwindTheme(input);
+  return [
+    "// GENERATED from design-system/tokens.json \u2014 do not edit by hand.",
+    "// Spread `theme.extend` into your tailwind.config; values reference the vars in tokens.css.",
+    `export const theme = ${JSON.stringify(theme, null, 2)};`,
+    "export default theme;",
+    ""
+  ].join("\n");
+}
+function leafSignature(token) {
+  const modes = tessExt(token)?.modes;
+  if (!modes || typeof modes !== "object")
+    return JSON.stringify([token.$value]);
+  const sorted = {};
+  for (const k of Object.keys(modes).sort())
+    sorted[k] = modes[k];
+  return JSON.stringify([token.$value, sorted]);
+}
+function indexLeaves(t) {
+  const m = /* @__PURE__ */ new Map();
+  for (const { path: path5, token } of walkTokens(t)) {
+    m.set(path5.join("."), { sig: leafSignature(token), disp: stringifyValue(token.$value) });
+  }
+  return m;
+}
+function diffTokens(prev, next) {
+  const a = indexLeaves(normalizeTokens(prev));
+  const b = indexLeaves(normalizeTokens(next));
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const k of b.keys())
+    if (!a.has(k))
+      added.push(k);
+  for (const [k, va] of a) {
+    const vb = b.get(k);
+    if (!vb) {
+      removed.push(k);
+      continue;
+    }
+    if (va.sig !== vb.sig)
+      changed.push({ path: k, from: va.disp, to: vb.disp });
+  }
+  added.sort();
+  removed.sort();
+  changed.sort((x, y) => x.path < y.path ? -1 : x.path > y.path ? 1 : 0);
+  return { added, removed, changed };
+}
+function bumpVersion(prev, level = "patch") {
+  const m = typeof prev === "string" ? /^(\d+)\.(\d+)\.(\d+)/.exec(prev.trim()) : null;
+  if (!m)
+    return "1.0.0";
+  let [maj, min, pat] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  if (level === "major") {
+    maj += 1;
+    min = 0;
+    pat = 0;
+  } else if (level === "minor") {
+    min += 1;
+    pat = 0;
+  } else
+    pat += 1;
+  return `${maj}.${min}.${pat}`;
+}
+var DESIGN_DIR, TOKENS_FILE, TOKENS_CSS_FILE, DESIGN_CLAUDE_MD, DTCG_SCHEMA_URL, DTCG_TYPES, VAR_ALIASES, CATEGORY_ORDER, KNOWN_TOP, TW_BUCKETS;
 var init_design_tokens = __esm({
-  "../../packages/agent-core/dist/design-tokens.js"() {
+  "../../packages/shared/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({
+    DTCG_SCHEMA_URL = "https://design-tokens.github.io/community-group/format/";
+    DTCG_TYPES = [
+      "color",
+      "dimension",
+      "fontFamily",
+      "fontWeight",
+      "duration",
+      "cubicBezier",
+      "number",
+      "shadow",
+      "strokeStyle",
+      "border",
+      "transition",
+      "gradient",
+      "typography",
+      "lineHeight",
+      "letterSpacing"
+    ];
+    VAR_ALIASES = [
+      { match: ["typography", "fontFamily"], prefix: "font" },
+      { match: ["typography", "fontSize"], prefix: "text" },
+      { match: ["typography", "fontWeight"], prefix: "weight" },
+      { match: ["typography", "lineHeight"], prefix: "leading" },
+      { match: ["typography", "letterSpacing"], prefix: "tracking" },
+      { match: ["color"], prefix: "color" },
+      { match: ["colors"], prefix: "color" },
+      { match: ["spacing"], prefix: "space" },
+      { match: ["radius"], prefix: "radius" },
+      { match: ["shadow"], prefix: "shadow" },
+      { match: ["motion", "duration"], prefix: "duration" },
+      { match: ["motion", "easing"], prefix: "ease" }
+    ];
+    CATEGORY_ORDER = ["color", "typography", "spacing", "radius", "shadow", "motion"];
+    KNOWN_TOP = /* @__PURE__ */ new Set(["meta", "components", "color", "colors", "typography", "spacing", "radius", "shadow"]);
+    TW_BUCKETS = [
+      { match: ["typography", "fontFamily"], key: "fontFamily", flat: true },
+      { match: ["typography", "fontSize"], key: "fontSize", flat: true },
+      { match: ["typography", "fontWeight"], key: "fontWeight", flat: true },
+      { match: ["typography", "lineHeight"], key: "lineHeight", flat: true },
+      { match: ["typography", "letterSpacing"], key: "letterSpacing", flat: true },
+      { match: ["color"], key: "colors", flat: false },
+      { match: ["colors"], key: "colors", flat: false },
+      { match: ["spacing"], key: "spacing", flat: true },
+      { match: ["radius"], key: "borderRadius", flat: true },
+      { match: ["shadow"], key: "boxShadow", flat: true },
+      { match: ["motion", "duration"], key: "transitionDuration", flat: true },
+      { match: ["motion", "easing"], key: "transitionTimingFunction", flat: true }
+    ];
+  }
+});
+
+// ../../packages/shared/dist/snapshot.js
+var SNAPSHOT_MAX_TEXT_BYTES, SNAPSHOT_MAX_BINARY_BYTES, SNAPSHOT_MAX_TOTAL_BYTES;
+var init_snapshot = __esm({
+  "../../packages/shared/dist/snapshot.js"() {
+    "use strict";
+    SNAPSHOT_MAX_TEXT_BYTES = 512 * 1024;
+    SNAPSHOT_MAX_BINARY_BYTES = 4 * 1024 * 1024;
+    SNAPSHOT_MAX_TOTAL_BYTES = 24 * 1024 * 1024;
+  }
+});
+
+// ../../packages/shared/dist/index.js
+var init_dist2 = __esm({
+  "../../packages/shared/dist/index.js"() {
+    "use strict";
+    init_ws_protocol();
+    init_frame();
+    init_plans();
+    init_slug();
+    init_hosting();
+    init_cloud_agent();
+    init_engines();
+    init_providers();
+    init_runtimes();
+    init_runner_configs();
+    init_rotation();
+    init_settings();
+    init_design_tokens();
+    init_snapshot();
+  }
+});
+
+// ../../packages/agent-core/dist/design-tokens.js
+var TokenValueSchema, NodeSchema, DtcgTokensSchema, DesignTokensSchema;
+var init_design_tokens2 = __esm({
+  "../../packages/agent-core/dist/design-tokens.js"() {
+    "use strict";
+    init_zod();
+    init_dist2();
+    TokenValueSchema = external_exports.union([
+      external_exports.string(),
+      external_exports.number(),
+      external_exports.array(external_exports.string()),
+      external_exports.record(external_exports.string(), external_exports.unknown()),
+      external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown()))
+    ]);
+    NodeSchema = external_exports.lazy(() => external_exports.union([
+      external_exports.object({ $value: TokenValueSchema }).catchall(external_exports.unknown()),
+      // token: must carry $value
+      external_exports.record(external_exports.string(), external_exports.unknown())
+      // group: any record of nodes
+    ]));
+    DtcgTokensSchema = 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()
-    });
+      $meta: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+      $components: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+    }).catchall(NodeSchema);
+    DesignTokensSchema = DtcgTokensSchema;
+  }
+});
+
+// ../../packages/design-packs/dist/types.js
+var DESIGN_PACK_SCHEMA;
+var init_types = __esm({
+  "../../packages/design-packs/dist/types.js"() {
+    "use strict";
+    DESIGN_PACK_SCHEMA = "https://tesseract.fineguide.ai/schemas/design-pack/v1";
+  }
+});
+
+// ../../packages/design-packs/dist/packs/_build.js
+function buildPack(s) {
+  const dual = (lv) => ({ $value: lv[0], $extensions: { "com.tesseract": { modes: { dark: lv[1] } } } });
+  const val = (v) => Array.isArray(v) ? dual(v) : { $value: v };
+  const r = s.radius ?? { sm: "6px", md: "10px", lg: "16px" };
+  const sh = s.shadow ?? {
+    sm: "0 1px 2px rgb(0 0 0 / 0.06)",
+    md: "0 4px 12px rgb(0 0 0 / 0.08)",
+    lg: "0 12px 32px rgb(0 0 0 / 0.12)"
+  };
+  const b = s.baseFontPx ?? 16;
+  const tokens = {
+    $schema: "https://design-tokens.github.io/community-group/format/",
+    color: {
+      $type: "color",
+      brand: {
+        primary: val(s.brandPrimary),
+        onPrimary: val(s.onPrimary),
+        ...s.brandAccent ? { accent: val(s.brandAccent) } : {}
+      },
+      surface: { page: dual(s.page), card: dual(s.card) },
+      text: { primary: dual(s.textPrimary), secondary: dual(s.textSecondary), muted: dual(s.textMuted) },
+      border: { default: dual(s.border) }
+    },
+    typography: {
+      fontFamily: {
+        $type: "fontFamily",
+        sans: { $value: s.sans },
+        ...s.display ? { display: { $value: s.display } } : {},
+        mono: { $value: s.mono ?? ["ui-monospace", "SFMono-Regular", "Menlo", "monospace"] }
+      },
+      fontSize: {
+        $type: "dimension",
+        sm: { $value: `${b - 2}px` },
+        base: { $value: `${b}px` },
+        lg: { $value: `${b + 2}px` },
+        xl: { $value: `${b + 8}px` },
+        "2xl": { $value: `${b + 16}px` }
+      },
+      fontWeight: { $type: "fontWeight", normal: { $value: 400 }, medium: { $value: 500 }, bold: { $value: 700 } }
+    },
+    spacing: {
+      $type: "dimension",
+      xs: { $value: "4px" },
+      sm: { $value: "8px" },
+      md: { $value: "16px" },
+      lg: { $value: "24px" },
+      xl: { $value: "40px" }
+    },
+    radius: { $type: "dimension", sm: { $value: r.sm }, md: { $value: r.md }, lg: { $value: r.lg }, full: { $value: "9999px" } },
+    shadow: { $type: "shadow", sm: { $value: sh.sm }, md: { $value: sh.md }, lg: { $value: sh.lg } }
+  };
+  return { $packSchema: DESIGN_PACK_SCHEMA, id: s.id, name: s.name, description: s.description, style: s.style, tokens };
+}
+var init_build = __esm({
+  "../../packages/design-packs/dist/packs/_build.js"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// ../../packages/design-packs/dist/packs/clean-minimal.js
+var clean_minimal_default;
+var init_clean_minimal = __esm({
+  "../../packages/design-packs/dist/packs/clean-minimal.js"() {
+    "use strict";
+    init_build();
+    clean_minimal_default = buildPack({
+      id: "clean-minimal",
+      name: "Clean Minimal",
+      description: "Warm off-white, soft stone neutrals, restrained. The safe default.",
+      style: "minimal",
+      // Warm neutral (2026 "Cloud Dancer" direction) + a brand that flips light↔dark so the CTA
+      // stays visible: near-black button in light, near-white button in dark.
+      brandPrimary: ["#1c1917", "#f5f5f4"],
+      onPrimary: ["#ffffff", "#1c1917"],
+      page: ["#faf9f7", "#0b0b0a"],
+      card: ["#ffffff", "#161513"],
+      textPrimary: ["#1c1917", "#fafaf9"],
+      textSecondary: ["#57534e", "#a8a29e"],
+      textMuted: ["#79716b", "#8a847c"],
+      border: ["#e7e5e4", "#292524"],
+      sans: ["Inter", "-apple-system", "BlinkMacSystemFont", "Segoe UI", "sans-serif"],
+      radius: { sm: "6px", md: "8px", lg: "12px" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/corporate-trust.js
+var corporate_trust_default;
+var init_corporate_trust = __esm({
+  "../../packages/design-packs/dist/packs/corporate-trust.js"() {
+    "use strict";
+    init_build();
+    corporate_trust_default = buildPack({
+      id: "corporate-trust",
+      name: "Corporate Trust",
+      description: "Professional blue/slate, structured, trust signals.",
+      style: "corporate",
+      brandPrimary: "#1d4ed8",
+      onPrimary: "#ffffff",
+      brandAccent: "#0ea5e9",
+      page: ["#ffffff", "#0b1220"],
+      card: ["#f8fafc", "#0f1a2e"],
+      textPrimary: ["#0f172a", "#e2e8f0"],
+      textSecondary: ["#475569", "#94a3b8"],
+      textMuted: ["#7e8ba1", "#64748b"],
+      border: ["#e2e8f0", "#1e293b"],
+      sans: ["Inter", "-apple-system", "Segoe UI", "sans-serif"],
+      radius: { sm: "4px", md: "8px", lg: "12px" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/refined-brutalist.js
+var refined_brutalist_default;
+var init_refined_brutalist = __esm({
+  "../../packages/design-packs/dist/packs/refined-brutalist.js"() {
+    "use strict";
+    init_build();
+    refined_brutalist_default = buildPack({
+      id: "refined-brutalist",
+      name: "Refined Brutalist",
+      description: "Raw grotesk type, visible grid, hard edges, high accessible contrast.",
+      style: "brutalist",
+      brandPrimary: ["#000000", "#ffffff"],
+      onPrimary: ["#ffffff", "#000000"],
+      brandAccent: "#ff3b00",
+      page: ["#ffffff", "#000000"],
+      card: ["#f4f4f4", "#0c0c0c"],
+      textPrimary: ["#000000", "#ffffff"],
+      textSecondary: ["#333333", "#cccccc"],
+      textMuted: ["#666666", "#999999"],
+      border: ["#000000", "#ffffff"],
+      sans: ["Space Grotesk", "Arial", "Helvetica", "sans-serif"],
+      mono: ["Space Mono", "ui-monospace", "monospace"],
+      radius: { sm: "0px", md: "0px", lg: "0px" },
+      shadow: { sm: "2px 2px 0 #000", md: "4px 4px 0 #000", lg: "8px 8px 0 #000" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/editorial.js
+var editorial_default;
+var init_editorial = __esm({
+  "../../packages/design-packs/dist/packs/editorial.js"() {
+    "use strict";
+    init_build();
+    editorial_default = buildPack({
+      id: "editorial",
+      name: "Editorial",
+      description: "Serif display, classical art-converging, magazine layout.",
+      style: "editorial",
+      brandPrimary: ["#1a1a1a", "#f0ece4"],
+      onPrimary: ["#ffffff", "#1a1a1a"],
+      brandAccent: ["#9a3412", "#e0794a"],
+      page: ["#fbfaf7", "#1a1714"],
+      card: ["#ffffff", "#221d19"],
+      textPrimary: ["#1a1a1a", "#f0ece4"],
+      textSecondary: ["#57534e", "#a8a29e"],
+      textMuted: ["#78716c", "#857b6e"],
+      border: ["#e7e2d8", "#2a2520"],
+      sans: ["Georgia", "Cambria", "Times New Roman", "serif"],
+      display: ["Playfair Display", "Georgia", "serif"],
+      radius: { sm: "2px", md: "4px", lg: "6px" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/soft-clay-playful.js
+var soft_clay_playful_default;
+var init_soft_clay_playful = __esm({
+  "../../packages/design-packs/dist/packs/soft-clay-playful.js"() {
+    "use strict";
+    init_build();
+    soft_clay_playful_default = buildPack({
+      id: "soft-clay-playful",
+      name: "Soft / Clay Playful",
+      description: "Rounded claymorphism, friendly, bright violet accents.",
+      style: "playful",
+      brandPrimary: "#7c3aed",
+      onPrimary: "#ffffff",
+      brandAccent: "#f59e0b",
+      page: ["#fffdf9", "#15131a"],
+      card: ["#ffffff", "#1d1a24"],
+      textPrimary: ["#2e1065", "#f5f3ff"],
+      textSecondary: ["#6d28d9", "#c4b5fd"],
+      textMuted: ["#8b5cf6", "#8b7fb0"],
+      border: ["#ede9fe", "#2e2640"],
+      sans: ["Quicksand", "Nunito", "-apple-system", "sans-serif"],
+      radius: { sm: "12px", md: "20px", lg: "28px" },
+      shadow: { sm: "0 2px 6px rgb(124 58 237 / 0.12)", md: "0 8px 20px rgb(124 58 237 / 0.16)", lg: "0 16px 40px rgb(124 58 237 / 0.20)" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/premium-dark.js
+var premium_dark_default;
+var init_premium_dark = __esm({
+  "../../packages/design-packs/dist/packs/premium-dark.js"() {
+    "use strict";
+    init_build();
+    premium_dark_default = buildPack({
+      id: "premium-dark",
+      name: "Premium Dark",
+      description: "Dark-first, high-end gold accent, luxe restraint.",
+      style: "dark",
+      brandPrimary: "#e5b567",
+      onPrimary: "#1a1408",
+      brandAccent: "#f5d491",
+      page: ["#0a0a0b", "#070708"],
+      card: ["#161618", "#1c1c1f"],
+      textPrimary: ["#fafafa", "#fafafa"],
+      textSecondary: ["#a1a1aa", "#a1a1aa"],
+      textMuted: ["#71717a", "#71717a"],
+      border: ["#27272a", "#2c2c30"],
+      sans: ["Inter", "-apple-system", "Segoe UI", "sans-serif"],
+      radius: { sm: "6px", md: "10px", lg: "14px" },
+      shadow: { sm: "0 1px 2px rgb(0 0 0 / 0.5)", md: "0 6px 16px rgb(0 0 0 / 0.55)", lg: "0 16px 40px rgb(0 0 0 / 0.6)" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/glass-aurora.js
+var glass_aurora_default;
+var init_glass_aurora = __esm({
+  "../../packages/design-packs/dist/packs/glass-aurora.js"() {
+    "use strict";
+    init_build();
+    glass_aurora_default = buildPack({
+      id: "glass-aurora",
+      name: "Glass / Aurora",
+      description: "Translucent frosted layers, soft gradients and glow.",
+      style: "glass",
+      brandPrimary: "#4f46e5",
+      onPrimary: "#ffffff",
+      brandAccent: "#22d3ee",
+      page: ["#f8fafc", "#0b1020"],
+      card: ["#ffffff", "#111735"],
+      textPrimary: ["#0f172a", "#e7ecff"],
+      textSecondary: ["#475569", "#aab4d4"],
+      textMuted: ["#7e8ba1", "#6b7494"],
+      border: ["#e2e8f0", "#23294a"],
+      sans: ["Inter", "-apple-system", "Segoe UI", "sans-serif"],
+      radius: { sm: "10px", md: "16px", lg: "24px" },
+      shadow: { sm: "0 1px 2px rgb(79 70 229 / 0.10)", md: "0 8px 24px rgb(79 70 229 / 0.14)", lg: "0 20px 48px rgb(79 70 229 / 0.18)" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/dopamine-pop.js
+var dopamine_pop_default;
+var init_dopamine_pop = __esm({
+  "../../packages/design-packs/dist/packs/dopamine-pop.js"() {
+    "use strict";
+    init_build();
+    dopamine_pop_default = buildPack({
+      id: "dopamine-pop",
+      name: "Dopamine Pop",
+      description: "Confident, accessible full-color system. Bold and energetic.",
+      style: "dopamine",
+      brandPrimary: "#7e22ce",
+      onPrimary: "#ffffff",
+      brandAccent: "#f59e0b",
+      page: ["#fffaf5", "#190a18"],
+      card: ["#ffffff", "#241023"],
+      textPrimary: ["#3b0764", "#fdf4ff"],
+      textSecondary: ["#7e22ce", "#e9d5ff"],
+      textMuted: ["#a855f7", "#9b6fb5"],
+      border: ["#f5d0fe", "#3b1d49"],
+      sans: ["Plus Jakarta Sans", "Inter", "-apple-system", "sans-serif"],
+      radius: { sm: "8px", md: "14px", lg: "22px" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/retro-y2k.js
+var retro_y2k_default;
+var init_retro_y2k = __esm({
+  "../../packages/design-packs/dist/packs/retro-y2k.js"() {
+    "use strict";
+    init_build();
+    retro_y2k_default = buildPack({
+      id: "retro-y2k",
+      name: "Retro / Y2K",
+      description: "Nostalgic, grain-textured, vibrant and chunky.",
+      style: "retro",
+      brandPrimary: "#b91c1c",
+      onPrimary: "#fdf6ec",
+      brandAccent: "#f59e0b",
+      page: ["#fdf6ec", "#1b1410"],
+      card: ["#fffaf0", "#241a13"],
+      textPrimary: ["#1c1917", "#f5ede0"],
+      textSecondary: ["#57534e", "#bcae9c"],
+      textMuted: ["#78716c", "#8a7c6a"],
+      border: ["#e7d9c2", "#352a1d"],
+      sans: ["Space Grotesk", "Arial", "sans-serif"],
+      display: ["Space Grotesk", "Impact", "sans-serif"],
+      radius: { sm: "4px", md: "8px", lg: "14px" },
+      shadow: { sm: "3px 3px 0 rgb(28 25 23 / 0.9)", md: "5px 5px 0 rgb(28 25 23 / 0.9)", lg: "8px 8px 0 rgb(28 25 23 / 0.9)" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/warm-organic.js
+var warm_organic_default;
+var init_warm_organic = __esm({
+  "../../packages/design-packs/dist/packs/warm-organic.js"() {
+    "use strict";
+    init_build();
+    warm_organic_default = buildPack({
+      id: "warm-organic",
+      name: "Warm Organic",
+      description: "Earth tones, natural, calm. Wellness and hospitality.",
+      style: "organic",
+      brandPrimary: "#7c5c43",
+      onPrimary: "#ffffff",
+      brandAccent: "#84cc16",
+      page: ["#faf6f1", "#1a1512"],
+      card: ["#fffdf9", "#221b16"],
+      textPrimary: ["#2b211a", "#efe7dd"],
+      textSecondary: ["#6b5b4d", "#c4b3a3"],
+      textMuted: ["#877564", "#8a7868"],
+      border: ["#e8ddcf", "#33291f"],
+      sans: ["Source Sans 3", "Source Sans Pro", "-apple-system", "sans-serif"],
+      radius: { sm: "8px", md: "14px", lg: "20px" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/luxury-elegant.js
+var luxury_elegant_default;
+var init_luxury_elegant = __esm({
+  "../../packages/design-packs/dist/packs/luxury-elegant.js"() {
+    "use strict";
+    init_build();
+    luxury_elegant_default = buildPack({
+      id: "luxury-elegant",
+      name: "Luxury Elegant",
+      description: "Muted, fine serif, gold-on-black, refined restraint.",
+      style: "luxury",
+      brandPrimary: ["#11100f", "#d4af37"],
+      onPrimary: ["#d4af37", "#11100f"],
+      brandAccent: "#b08d57",
+      page: ["#faf9f7", "#0e0d0c"],
+      card: ["#ffffff", "#171513"],
+      textPrimary: ["#1a1816", "#f3efe9"],
+      textSecondary: ["#57514a", "#b8ada0"],
+      textMuted: ["#8a8278", "#7c7468"],
+      border: ["#e8e2d8", "#2a251f"],
+      sans: ["Cormorant Garamond", "Garamond", "Georgia", "serif"],
+      display: ["Cormorant Garamond", "Didot", "Georgia", "serif"],
+      radius: { sm: "2px", md: "4px", lg: "8px" },
+      shadow: { sm: "0 1px 2px rgb(0 0 0 / 0.05)", md: "0 6px 18px rgb(0 0 0 / 0.07)", lg: "0 18px 44px rgb(0 0 0 / 0.10)" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/bento-tech.js
+var bento_tech_default;
+var init_bento_tech = __esm({
+  "../../packages/design-packs/dist/packs/bento-tech.js"() {
+    "use strict";
+    init_build();
+    bento_tech_default = buildPack({
+      id: "bento-tech",
+      name: "Bento Tech",
+      description: "Crisp modular bento rhythm, grid-forward, product-led.",
+      style: "tech",
+      brandPrimary: "#2563eb",
+      onPrimary: "#ffffff",
+      brandAccent: "#06b6d4",
+      page: ["#f6f7f9", "#0c0e12"],
+      card: ["#ffffff", "#13161c"],
+      textPrimary: ["#0b0e14", "#e9edf5"],
+      textSecondary: ["#3f4756", "#9aa4b8"],
+      textMuted: ["#6f7892", "#6b7488"],
+      border: ["#e6e8ee", "#1d212b"],
+      sans: ["Geist", "Inter", "-apple-system", "sans-serif"],
+      mono: ["Geist Mono", "ui-monospace", "monospace"],
+      radius: { sm: "8px", md: "12px", lg: "16px" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/fintech-emerald.js
+var fintech_emerald_default;
+var init_fintech_emerald = __esm({
+  "../../packages/design-packs/dist/packs/fintech-emerald.js"() {
+    "use strict";
+    init_build();
+    fintech_emerald_default = buildPack({
+      id: "fintech-emerald",
+      name: "Fintech Emerald",
+      description: "Fresh emerald, growth-and-trust. Fintech, health, sustainability.",
+      style: "fresh",
+      // Emerald shifts lighter in dark (emerald-700 → emerald-400) so the CTA pops on a deep
+      // green-black, per modern light/dark accent practice.
+      brandPrimary: ["#047857", "#34d399"],
+      onPrimary: ["#ffffff", "#022c22"],
+      brandAccent: ["#0d9488", "#5eead4"],
+      page: ["#f7faf8", "#07120d"],
+      card: ["#ffffff", "#0e1a14"],
+      textPrimary: ["#0a1f17", "#e6f5ee"],
+      textSecondary: ["#3f5a4f", "#9cc3b3"],
+      textMuted: ["#6a8579", "#728d80"],
+      border: ["#dcebe3", "#1a2a22"],
+      sans: ["Inter", "-apple-system", "Segoe UI", "sans-serif"],
+      radius: { sm: "8px", md: "12px", lg: "18px" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/packs/sunset-coral.js
+var sunset_coral_default;
+var init_sunset_coral = __esm({
+  "../../packages/design-packs/dist/packs/sunset-coral.js"() {
+    "use strict";
+    init_build();
+    sunset_coral_default = buildPack({
+      id: "sunset-coral",
+      name: "Sunset Coral",
+      description: "Warm coral + amber, energetic but friendly. Lifestyle, creative, DTC.",
+      style: "sunset",
+      // Coral deepens for white legibility in light, brightens in dark; amber as the warm accent.
+      brandPrimary: ["#d23b1e", "#ff8a6b"],
+      onPrimary: ["#ffffff", "#3d0f06"],
+      brandAccent: ["#f59e0b", "#fcd34d"],
+      page: ["#fff8f4", "#1a0f0a"],
+      card: ["#ffffff", "#251510"],
+      textPrimary: ["#2b1610", "#fdeee6"],
+      textSecondary: ["#6b4133", "#d6a795"],
+      textMuted: ["#9a6f5e", "#9a786a"],
+      border: ["#f4ddd0", "#3a221a"],
+      sans: ["Plus Jakarta Sans", "Inter", "-apple-system", "sans-serif"],
+      radius: { sm: "10px", md: "16px", lg: "22px" }
+    });
+  }
+});
+
+// ../../packages/design-packs/dist/index.js
+function getPack(id) {
+  return PACKS_BY_ID[id];
+}
+var PACKS, PACKS_BY_ID;
+var init_dist3 = __esm({
+  "../../packages/design-packs/dist/index.js"() {
+    "use strict";
+    init_types();
+    init_clean_minimal();
+    init_corporate_trust();
+    init_refined_brutalist();
+    init_editorial();
+    init_soft_clay_playful();
+    init_premium_dark();
+    init_glass_aurora();
+    init_dopamine_pop();
+    init_retro_y2k();
+    init_warm_organic();
+    init_luxury_elegant();
+    init_bento_tech();
+    init_fintech_emerald();
+    init_sunset_coral();
+    PACKS = [
+      clean_minimal_default,
+      corporate_trust_default,
+      fintech_emerald_default,
+      refined_brutalist_default,
+      editorial_default,
+      soft_clay_playful_default,
+      premium_dark_default,
+      glass_aurora_default,
+      dopamine_pop_default,
+      sunset_coral_default,
+      retro_y2k_default,
+      warm_organic_default,
+      luxury_elegant_default,
+      bento_tech_default
+    ];
+    PACKS_BY_ID = Object.fromEntries(PACKS.map((p) => [p.id, p]));
   }
 });
 
@@ -19448,8 +21036,8 @@ function within(root, p) {
 }
 async function loadTokens(root) {
   try {
-    const parsed = DesignTokensSchema.safeParse(JSON.parse(await readFile(join4(root, TOKENS_FILE), "utf8")));
-    return parsed.success ? parsed.data : {};
+    const norm = normalizeTokens(JSON.parse(await readFile(join4(root, TOKENS_FILE), "utf8")));
+    return DesignTokensSchema.safeParse(norm).success ? norm : {};
   } catch {
     return {};
   }
@@ -19472,28 +21060,64 @@ function buildDesignTools(deps) {
     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) => {
+    tool2("read_design_tokens", "Read the project design system from design-system/tokens.json in W3C DTCG format (color, 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", "color", "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] ?? {} };
+      const key2 = args.section === "components" ? "$components" : args.section;
+      const out = !args.section || args.section === "all" ? tokens : { [args.section]: tokens[key2] ?? {} };
       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.', {
+    tool2("write_design_token", 'Set one or more design tokens by DTCG dot-path (e.g. "color.brand.primary.$value" = "#d97757", "spacing.md.$value" = "0.5rem") and regenerate design-system/tokens.css. Token leaves carry $value; set a group $type once (e.g. "color.$type" = "color"). 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")
+        path: external_exports.string().optional().describe("DTCG dot-path into tokens.json, e.g. color.brand.primary.$value"),
+        segments: external_exports.array(external_exports.string()).optional().describe("Explicit path segments \u2014 use instead of path when a key contains a dot (e.g. a $extensions vendor key)"),
+        value: external_exports.union([external_exports.string(), external_exports.number(), external_exports.array(external_exports.string())]).describe("The new value (array for fontFamily)")
       })).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);
+      for (const e of args.edits) {
+        if (e.segments?.length)
+          tokens = setTokenSegments(tokens, e.segments, e.value);
+        else if (e.path)
+          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" : ""}.`);
+      await saveTokens(root, tokens, regen);
+      const names = args.edits.map((e) => e.path ?? e.segments?.join(".") ?? "?").join(", ");
+      return text(`Updated ${args.edits.length} token(s): ${names}${regen ? " and regenerated tokens.css" : ""}.`);
+    }),
+    tool2("apply_design_pack", `Apply a curated design pack (a full color+typography+spacing+radius+shadow vibe, light+dark) to the project design system and regenerate tokens.css. Pass packId for a bundled pack (${PACK_IDS}) OR an inline DTCG tokens document. mode: merge (override only the paths the pack defines, keep the rest incl. components \u2014 default), replace (swap the whole token tree, keep $meta/$components), palette (recolour + change font families only).`, {
+      packId: external_exports.string().optional().describe('Bundled pack id, e.g. "premium-dark"'),
+      tokens: DesignTokensSchema.optional().describe("Inline DTCG tokens to apply instead of a bundled pack"),
+      name: external_exports.string().optional().describe("Display name when applying inline tokens"),
+      mode: external_exports.enum(["merge", "replace", "palette"]).optional().describe("Apply strategy (default: merge)")
+    }, async (args) => {
+      const root = needRoot();
+      const mode = args.mode ?? "merge";
+      let packTokens;
+      let info;
+      if (args.packId) {
+        const pack = getPack(args.packId);
+        if (!pack)
+          return text(`Unknown packId "${args.packId}". Bundled: ${PACK_IDS}.`, true);
+        packTokens = pack.tokens;
+        info = { id: pack.id, name: pack.name };
+      } else if (args.tokens) {
+        packTokens = args.tokens;
+        info = { id: "inline", name: args.name ?? "Custom pack" };
+      } else {
+        return text("Provide either packId or tokens.", true);
+      }
+      const result = applyDesignPack(await loadTokens(root), packTokens, info, { mode });
+      const validated = DesignTokensSchema.safeParse(result);
+      if (!validated.success)
+        return text(`Applying the pack produced an invalid document: ${validated.error.message}`, true);
+      await saveTokens(root, result, true);
+      return text(`Applied "${info.name}" (${mode}) 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"),
@@ -19516,7 +21140,7 @@ function buildDesignTools(deps) {
       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 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.');
@@ -19529,12 +21153,14 @@ function buildDesignTools(deps) {
     })
   ];
 }
-var STYLE_PROPS, text;
+var PACK_IDS, STYLE_PROPS, text;
 var init_design_tools = __esm({
   "../../packages/agent-core/dist/design-tools.js"() {
     "use strict";
     init_zod();
-    init_design_tokens();
+    init_design_tokens2();
+    init_dist3();
+    PACK_IDS = PACKS.map((p) => p.id).join(", ");
     STYLE_PROPS = [
       "color",
       "background-color",
@@ -19796,6 +21422,23 @@ function sessionDir(cwd) {
 function sessionFile(cwd, sessionId) {
   return join5(sessionDir(cwd), `${sessionId}.jsonl`);
 }
+async function resolveSessionFile(sessionId, projectDir) {
+  if (projectDir) {
+    const direct = sessionFile(projectDir, sessionId);
+    if (existsSync(direct))
+      return direct;
+  }
+  const target = `${sessionId}.jsonl`;
+  const projects = await readdir(projectsRoot(), { withFileTypes: true }).catch(() => []);
+  for (const dir of projects) {
+    if (!dir.isDirectory())
+      continue;
+    const candidate = join5(projectsRoot(), dir.name, target);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
 async function walkFiles(root) {
   const out = [];
   async function rec(dir, prefix) {
@@ -20073,9 +21716,10 @@ var init_session_store = __esm({
        *  WITHOUT file-history/undo snapshots (SDK behavior). */
       async forkSession(sessionId, opts) {
         try {
+          const upToMessageId = opts?.upToMessageId ?? await this.lastResumableMessageId(sessionId, opts?.projectDir);
           const result = await forkSession(sessionId, {
             ...opts?.projectDir ? { dir: opts.projectDir } : {},
-            ...opts?.upToMessageId ? { upToMessageId: opts.upToMessageId } : {},
+            ...upToMessageId ? { upToMessageId } : {},
             ...opts?.title ? { title: opts.title } : {}
           });
           return result.sessionId;
@@ -20083,6 +21727,51 @@ var init_session_store = __esm({
           return null;
         }
       }
+      /** The uuid of the last transcript message after which NO tool_use is left without
+       *  its tool_result — the safe point to fork at. Reads the same on-disk `.jsonl` the
+       *  SDK fork copies (filtering sidechains identically) and pairs tool_use ids against
+       *  tool_result ids. Returns undefined when the transcript already ends balanced
+       *  (fork everything) or it can't be read (best-effort: fall back to a full fork). */
+      async lastResumableMessageId(sessionId, projectDir) {
+        try {
+          const file2 = await resolveSessionFile(sessionId, projectDir);
+          if (!file2)
+            return void 0;
+          const raw = await readFile3(file2, "utf-8");
+          const outstanding = /* @__PURE__ */ new Set();
+          let lastBalancedUuid;
+          for (const line of raw.split("\n")) {
+            const t = line.trim();
+            if (!t)
+              continue;
+            let e;
+            try {
+              e = JSON.parse(t);
+            } catch {
+              continue;
+            }
+            if (e.isSidechain === true)
+              continue;
+            const content = e.message?.content;
+            if (Array.isArray(content)) {
+              for (const b of content) {
+                if (!b || typeof b !== "object")
+                  continue;
+                const blk = b;
+                if (blk.type === "tool_use" && typeof blk.id === "string")
+                  outstanding.add(blk.id);
+                else if (blk.type === "tool_result" && typeof blk.tool_use_id === "string")
+                  outstanding.delete(blk.tool_use_id);
+              }
+            }
+            if (typeof e.uuid === "string" && outstanding.size === 0)
+              lastBalancedUuid = e.uuid;
+          }
+          return outstanding.size === 0 ? void 0 : lastBalancedUuid;
+        } catch {
+          return void 0;
+        }
+      }
     };
   }
 });
@@ -20471,7 +22160,7 @@ var init_agent_manager = __esm({
     init_dist();
     init_cron_tools();
     init_design_tools();
-    init_design_tokens();
+    init_design_tokens2();
     init_narrator();
     init_plan_splitter();
     init_trace_store();
@@ -22129,24 +23818,42 @@ __export(dist_exports, {
   AgentManager: () => AgentManager,
   DESIGN_CLAUDE_MD: () => DESIGN_CLAUDE_MD,
   DESIGN_DIR: () => DESIGN_DIR,
+  DTCG_TYPES: () => DTCG_TYPES,
   DesignTokensSchema: () => DesignTokensSchema,
+  DtcgTokensSchema: () => DtcgTokensSchema,
   SessionStore: () => SessionStore,
   TOKENS_CSS_FILE: () => TOKENS_CSS_FILE,
   TOKENS_FILE: () => TOKENS_FILE,
+  applyDesignPack: () => applyDesignPack,
   buildClaudeNarrationLlm: () => buildClaudeNarrationLlm,
+  bumpVersion: () => bumpVersion,
+  contrastRatio: () => contrastRatio,
+  diffTokens: () => diffTokens,
   exportSession: () => exportSession,
+  flattenForDisplay: () => flattenForDisplay,
   getTokenPath: () => getTokenPath,
+  getTokenSegments: () => getTokenSegments,
   importSession: () => importSession,
+  isToken: () => isToken,
   log: () => log,
+  normalizeTokens: () => normalizeTokens,
+  parseColorToRgb: () => parseColorToRgb,
   resolveOauthToken: () => resolveOauthToken,
+  resolveSessionFile: () => resolveSessionFile,
   sanitizeProjectDir: () => sanitizeProjectDir,
   sessionDir: () => sessionDir,
   sessionFile: () => sessionFile,
   setTokenPath: () => setTokenPath,
+  setTokenSegments: () => setTokenSegments,
+  stringifyValue: () => stringifyValue,
+  tokenCssVarName: () => tokenCssVarName,
   tokensToCss: () => tokensToCss,
-  transferSession: () => transferSession
+  tokensToTailwindConfig: () => tokensToTailwindConfig,
+  tokensToTailwindTheme: () => tokensToTailwindTheme,
+  transferSession: () => transferSession,
+  walkTokens: () => walkTokens
 });
-var init_dist2 = __esm({
+var init_dist4 = __esm({
   "../../packages/agent-core/dist/index.js"() {
     "use strict";
     init_agent_manager();
@@ -22154,7 +23861,7 @@ var init_dist2 = __esm({
     init_session_usage();
     init_session_transfer();
     init_log();
-    init_design_tokens();
+    init_design_tokens2();
   }
 });
 
@@ -41954,12 +43661,12 @@ 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 join33, resolve as resolve8 } from "node:path";
+import { dirname as dirname17, 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 join26, basename as basename5 } from "node:path";
+import { join as join26, basename as basename6 } from "node:path";
 import { mkdirSync as mkdirSync9 } from "node:fs";
 
 // ../../node_modules/ws/wrapper.mjs
@@ -42011,7 +43718,7 @@ import { join as join15 } from "node:path";
 
 // ../../packages/host-core/dist/agent-backend.js
 async function createClaudeCodeBackend(send2, onBrowserRequest, loadPluginRuntime2) {
-  const { AgentManager: AgentManager2, SessionStore: SessionStore2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+  const { AgentManager: AgentManager2, SessionStore: SessionStore2, resolveSessionFile: resolveSessionFile2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports));
   const manager2 = new AgentManager2(send2, onBrowserRequest);
   const store = new SessionStore2();
   const refreshPlugins = async (projectDir) => {
@@ -42037,6 +43744,8 @@ async function createClaudeCodeBackend(send2, onBrowserRequest, loadPluginRuntim
     listSessions: (projectDir) => store.getSessions(projectDir),
     searchSessions: (query2, projectDir) => store.searchSessions(query2, projectDir),
     getMessages: (sessionId) => store.getSessionMessages(sessionId),
+    isSessionBusy: (sessionId) => manager2.isSessionBusy(sessionId),
+    resolveSessionFile: (sessionId, projectDir) => resolveSessionFile2(sessionId, projectDir),
     setConfig: (projectDir) => {
       manager2.setConfig(projectDir);
       void refreshPlugins(projectDir);
@@ -42437,7 +44146,7 @@ async function createBackend(engineId, send2, onBrowserRequest, resolver, loadPl
 }
 
 // ../../packages/host-core/dist/daemon-agent.js
-init_dist2();
+init_dist4();
 
 // ../../packages/host-core/dist/plugin-tools.js
 import { existsSync as existsSync3 } from "node:fs";
@@ -42789,12 +44498,12 @@ async function loadPluginRuntime(opts) {
 }
 function buildDaemonPluginLoader(pluginsDir) {
   return async () => {
-    const scan = join8(pluginsDir, "node_modules");
-    if (!existsSync3(scan))
+    const scan2 = join8(pluginsDir, "node_modules");
+    if (!existsSync3(scan2))
       return { tools: [], hooks: [], engines: [] };
     writeOpenClawShim(pluginsDir);
     return loadPluginRuntime({
-      roots: [{ dir: scan, trusted: true, relaxHardlink: true }],
+      roots: [{ dir: scan2, trusted: true, relaxHardlink: true }],
       secretResolver: (_pluginId, envKey2) => process.env[envKey2]
     });
   };
@@ -43120,477 +44829,14 @@ import { readFileSync as readFileSync7 } from "node:fs";
 import { join as join14 } from "node:path";
 
 // ../../packages/host-core/dist/runners/resolve.js
+init_dist2();
 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 join11 } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 
-// ../../packages/shared/dist/ws-protocol.js
-var MIRRORED_AGENT_EVENTS = /* @__PURE__ */ new Set([
-  "chat:stream",
-  "agent:tool_use",
-  "agent:tool_result",
-  // M4 H10 — co-viewers must see tool OUTPUT, not just the call
-  "agent:file_edit",
-  "chat:complete",
-  "chat:error",
-  "agent:status",
-  "agent:mode_changed",
-  // M4 H11 — co-viewer run-mode badge must flip on plan/edit
-  "agent:session_state",
-  // M4 H11 — co-viewer spinner must clear on idle
-  "agent:todos",
-  // plan sidebar — co-viewers see the live checklist
-  "agent:plan_sections",
-  // 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",
-  "chat:scheduled_fired"
-  // cron — co-viewers see the synthetic "Scheduled" user turn
-  // NOT mirrored: agent:capabilities (host-local model/MCP metadata — mirroring
-  // would stomp a co-viewer's own picker with the driver's host); session:forked
-  // and agent:context_usage are driver-only correlation/host-local replies.
-]);
-
-// ../../packages/shared/dist/plans.js
-var NO_QUOTAS = { computeHours: 0, storageGb: 0, egressGb: 0 };
-var NO_FEATURES = {
-  sync: false,
-  mobile: false,
-  cloudWorkspace: false,
-  cloudServer: false,
-  remoteAgents: false,
-  voice: false,
-  team: false,
-  parallelAgents: false,
-  advancedBrowser: false,
-  hosting: false,
-  plugins: false,
-  scheduling: false,
-  api: false,
-  sso: false,
-  seats: 1,
-  maxMachines: 1
-};
-var PLAN_CATALOG = [
-  {
-    id: "free",
-    name: "Free",
-    monthlyUsd: 0,
-    tagline: "Your machine, your phone, your voice.",
-    features: [
-      "Unlimited agent usage",
-      "Full IDE: editor, files, agent, browser tool",
-      "Voice mode",
-      "Mobile app \u2014 reach your computer from your phone",
-      "Cloud workspace \u2014 your machine and recent projects in one view",
-      "One machine",
-      "Deploy to your own machine or server",
-      "Community support"
-    ],
-    featurePolicy: { ...NO_FEATURES, voice: true, mobile: true, cloudWorkspace: true },
-    quotas: { ...NO_QUOTAS }
-  },
-  {
-    id: "standard",
-    name: "Pro",
-    monthlyUsd: 20,
-    tagline: "Your workspace, everywhere.",
-    features: [
-      "Everything in Free",
-      "Unlimited machines \u2014 run agents on all of them",
-      "Tesseract cloud server \u2014 a managed always-on agent in the cloud",
-      "Deploy to the cloud \u2014 your app on a *.tesseract.dev URL",
-      "Includes ~1 always-on service + 20 GB storage + 100 GB bandwidth (overage metered)",
-      "Sync settings across your devices",
-      "Email support"
-    ],
-    featurePolicy: {
-      ...NO_FEATURES,
-      sync: true,
-      mobile: true,
-      cloudWorkspace: true,
-      cloudServer: true,
-      remoteAgents: true,
-      voice: true,
-      hosting: true,
-      plugins: true,
-      scheduling: true,
-      maxMachines: 0
-    },
-    // ~1 small always-on service (~720 compute-hours/mo, rounded) + 20 GB storage + 100 GB egress.
-    quotas: { computeHours: 750, storageGb: 20, egressGb: 100 }
-  },
-  {
-    id: "pro",
-    name: "Team",
-    monthlyUsd: 40,
-    perSeat: true,
-    tagline: "For teams shipping together.",
-    features: [
-      "Everything in Pro, per seat",
-      "Team seats + shared workspaces",
-      "Parallel agents",
-      "Advanced browser automation",
-      "API access",
-      "SSO, audit logs, centralized billing",
-      "Pooled cloud hosting \u2014 bigger shared quota",
-      "Priority support"
-    ],
-    featurePolicy: {
-      sync: true,
-      mobile: true,
-      cloudWorkspace: true,
-      cloudServer: true,
-      remoteAgents: true,
-      voice: true,
-      team: true,
-      parallelAgents: true,
-      advancedBrowser: true,
-      hosting: true,
-      plugins: true,
-      scheduling: true,
-      api: true,
-      sso: true,
-      seats: 2,
-      maxMachines: 0
-    },
-    // Pooled across the team — ~4× Pro's starter quota.
-    quotas: { computeHours: 3e3, storageGb: 100, egressGb: 500 }
-  }
-];
-
-// ../../packages/shared/dist/settings.js
-var MODEL_OPTIONS = [
-  { id: "claude-opus-4-8", label: "Claude Opus 4.8" },
-  { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
-  { id: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5" }
-];
-
-// ../../packages/shared/dist/engines.js
-var ENGINE_CATALOG = {
-  "claude-code": {
-    id: "claude-code",
-    label: "Claude Code",
-    description: "Anthropic's Claude Code \u2014 the default engine, deepest tool + browser integration.",
-    cliBinary: "claude",
-    // Claude's token is injected via CLAUDE_CODE_OAUTH_TOKEN, so oauth needs no auth file.
-    supportedModes: ["oauth", "apiKey", "localCli"],
-    apiKeyEnv: "ANTHROPIC_API_KEY",
-    models: MODEL_OPTIONS,
-    capabilities: { permissionGating: true, browserControl: true, liveRunMode: true, resume: true, fork: true, contextUsage: true, scheduling: true },
-    homepageUrl: "https://docs.claude.com/en/docs/claude-code",
-    installCommand: "npm install -g @anthropic-ai/claude-code",
-    installHint: "Bundled with the app; install the standalone CLI for local-instance mode."
-  },
-  "openai-codex": {
-    id: "openai-codex",
-    label: "OpenAI Codex",
-    description: "OpenAI's Codex CLI. Sign in with ChatGPT or use an API key.",
-    cliBinary: "codex",
-    supportedModes: ["oauth", "apiKey", "localCli"],
-    apiKeyEnv: "OPENAI_API_KEY",
-    authFileRel: "auth.json",
-    // under $CODEX_HOME
-    models: [
-      { id: "gpt-5.5-codex", label: "GPT-5.5 Codex" },
-      { id: "gpt-5.5", label: "GPT-5.5" }
-    ],
-    capabilities: { permissionGating: false, browserControl: false, liveRunMode: false, resume: true },
-    homepageUrl: "https://developers.openai.com/codex/cli",
-    installCommand: "npm install -g @openai/codex",
-    installHint: "npm i -g @openai/codex (or brew install codex)"
-  },
-  opencode: {
-    id: "opencode",
-    label: "OpenCode",
-    description: "Open-source agent over 75+ providers. Log in per provider.",
-    cliBinary: "opencode",
-    supportedModes: ["oauth", "apiKey", "localCli"],
-    // OpenCode reads provider keys from env / its own auth.json; no single apiKeyEnv.
-    authFileRel: "auth.json",
-    // under ~/.local/share/opencode
-    models: [],
-    // provider+model is configured inside OpenCode; "" ⇒ its default
-    capabilities: { permissionGating: false, browserControl: false, liveRunMode: false, resume: true },
-    homepageUrl: "https://opencode.ai",
-    installCommand: "npm install -g opencode-ai",
-    installHint: "npm i -g opencode-ai (see opencode.ai/docs)"
-  },
-  "gemini-cli": {
-    id: "gemini-cli",
-    label: "Gemini CLI",
-    description: "Google's Gemini CLI. Sign in with Google or use a Gemini API key.",
-    cliBinary: "gemini",
-    supportedModes: ["oauth", "apiKey", "localCli"],
-    apiKeyEnv: "GEMINI_API_KEY",
-    models: [
-      { id: "gemini-3.1-pro", label: "Gemini 3.1 Pro" },
-      { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" }
-    ],
-    capabilities: { permissionGating: false, browserControl: false, liveRunMode: false, resume: false },
-    homepageUrl: "https://github.com/google-gemini/gemini-cli",
-    installCommand: "npm install -g @google/gemini-cli",
-    installHint: "npm i -g @google/gemini-cli"
-  },
-  openclaw: {
-    id: "openclaw",
-    label: "OpenClaw",
-    description: "OpenClaw runtime \u2014 runs your installed channels, model providers, and plugins natively.",
-    cliBinary: "openclaw",
-    // OpenClaw manages its own provider auth (`openclaw onboard` / openclaw.json), so the
-    // only mode is "use the installed, already-onboarded CLI" — like OpenCode.
-    supportedModes: ["localCli"],
-    models: [],
-    // provider+model is configured inside OpenClaw; '' ⇒ its default
-    capabilities: { permissionGating: false, browserControl: false, liveRunMode: false, resume: false },
-    homepageUrl: "https://docs.openclaw.ai",
-    installCommand: "npm install -g openclaw",
-    installHint: "npm i -g openclaw, then run `openclaw onboard` (see docs.openclaw.ai)"
-  }
-};
-var ENGINE_IDS = Object.keys(ENGINE_CATALOG);
-function engineById(id) {
-  return ENGINE_CATALOG[id];
-}
-
-// ../../packages/shared/dist/providers.js
-var PROVIDER_CATALOG = {
-  anthropic: {
-    id: "anthropic",
-    label: "Anthropic",
-    description: "Claude models, direct from Anthropic. The native backend for Claude Code.",
-    baseUrl: "https://api.anthropic.com",
-    api: "anthropic-messages",
-    claudeNative: true,
-    authEnvVars: ["ANTHROPIC_API_KEY"],
-    authModes: ["oauth", "apiKey"],
-    models: [
-      { id: "claude-opus-4-8", label: "Claude Opus 4.8", role: "main" },
-      { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", role: "main" },
-      { id: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5", role: "fast" }
-    ],
-    homepageUrl: "https://docs.claude.com/en/docs/about-claude/models"
-  },
-  openai: {
-    id: "openai",
-    label: "OpenAI",
-    description: "OpenAI models. The native backend for the Codex engine.",
-    baseUrl: "https://api.openai.com/v1",
-    api: "openai-completions",
-    claudeNative: false,
-    authEnvVars: ["OPENAI_API_KEY"],
-    authModes: ["oauth", "apiKey"],
-    models: [
-      { id: "gpt-5.5-codex", label: "GPT-5.5 Codex", role: "main" },
-      { id: "gpt-5.5", label: "GPT-5.5", role: "main" }
-    ],
-    homepageUrl: "https://platform.openai.com/docs/models"
-  },
-  google: {
-    id: "google",
-    label: "Google Gemini",
-    description: "Gemini models. The native backend for the Gemini engine.",
-    baseUrl: "https://generativelanguage.googleapis.com",
-    api: "gemini",
-    claudeNative: false,
-    authEnvVars: ["GEMINI_API_KEY"],
-    authModes: ["oauth", "apiKey"],
-    models: [
-      { id: "gemini-3.1-pro", label: "Gemini 3.1 Pro", role: "main" },
-      { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash", role: "fast" }
-    ],
-    homepageUrl: "https://ai.google.dev/gemini-api/docs/models"
-  },
-  openrouter: {
-    id: "openrouter",
-    label: "OpenRouter",
-    description: "One key, hundreds of models. Exposes an Anthropic-compatible route \u2014 no proxy needed for Claude Code.",
-    // OpenAI-style base; the Anthropic-compatible base is `…/api` (no `/v1`).
-    baseUrl: "https://openrouter.ai/api/v1",
-    anthropicBaseUrl: "https://openrouter.ai/api",
-    api: "openai-completions",
-    claudeNative: true,
-    authEnvVars: ["OPENROUTER_API_KEY"],
-    headers: {
-      "HTTP-Referer": "https://app.tesseract.dev",
-      "X-Title": "Tesseract"
-    },
-    authModes: ["apiKey"],
-    // Any OpenRouter slug is valid; these are stable starters (free entry in UI).
-    models: [
-      { id: "deepseek/deepseek-chat", label: "DeepSeek Chat", role: "fast" },
-      { id: "deepseek/deepseek-r1", label: "DeepSeek R1", role: "main" },
-      { id: "google/gemini-2.5-flash", label: "Gemini 2.5 Flash", role: "fast" },
-      { id: "google/gemini-2.5-pro", label: "Gemini 2.5 Pro", role: "main" }
-    ],
-    homepageUrl: "https://openrouter.ai/docs"
-  },
-  ollama: {
-    id: "ollama",
-    label: "Ollama (local)",
-    description: "Run open models locally. No API key. Models are discovered from your running Ollama.",
-    baseUrl: "http://127.0.0.1:11434",
-    api: "ollama",
-    claudeNative: false,
-    authEnvVars: [],
-    authModes: ["apiKey"],
-    // optional bearer for remote Ollama; usually none
-    models: [],
-    dynamicModels: true,
-    homepageUrl: "https://ollama.com",
-    installCommand: "curl -fsSL https://ollama.com/install.sh | sh"
-  },
-  deepseek: {
-    id: "deepseek",
-    label: "DeepSeek",
-    description: "DeepSeek Chat + Reasoner. Cheap and capable. Reached via the proxy for Claude Code.",
-    baseUrl: "https://api.deepseek.com",
-    api: "openai-completions",
-    claudeNative: false,
-    authEnvVars: ["DEEPSEEK_API_KEY"],
-    authModes: ["apiKey"],
-    models: [
-      { id: "deepseek-chat", label: "DeepSeek Chat", role: "fast" },
-      { id: "deepseek-reasoner", label: "DeepSeek Reasoner", role: "main" }
-    ],
-    homepageUrl: "https://api-docs.deepseek.com"
-  },
-  moonshot: {
-    id: "moonshot",
-    label: "Kimi (Moonshot)",
-    description: "Kimi K2 models. Use the coding endpoint (Anthropic-compatible, no proxy) or the OpenAI endpoint.",
-    // Default to the OpenAI-style endpoint; the per-credential `baseUrl` can switch
-    // to the Anthropic-compatible coding endpoint below.
-    baseUrl: "https://api.moonshot.ai/v1",
-    anthropicBaseUrl: "https://api.kimi.com/coding/",
-    api: "openai-completions",
-    claudeNative: true,
-    authEnvVars: ["MOONSHOT_API_KEY", "KIMI_API_KEY"],
-    authModes: ["apiKey"],
-    models: [
-      { id: "kimi-code", label: "Kimi Code (coding endpoint)", role: "main" },
-      { id: "kimi-k2.5", label: "Kimi K2.5", role: "main" },
-      { id: "kimi-k2-thinking", label: "Kimi K2 Thinking", role: "main" }
-    ],
-    homepageUrl: "https://platform.moonshot.ai/docs"
-  },
-  "custom-openai": {
-    id: "custom-openai",
-    label: "Custom (OpenAI-compatible)",
-    description: "Any OpenAI-compatible endpoint (LM Studio, llama.cpp, vLLM, a private gateway). Set the base URL per key.",
-    baseUrl: "",
-    api: "openai-completions",
-    claudeNative: false,
-    authEnvVars: ["OPENAI_API_KEY"],
-    authModes: ["apiKey"],
-    models: [],
-    homepageUrl: "https://platform.openai.com/docs/api-reference"
-  },
-  litellm: {
-    id: "litellm",
-    label: "LiteLLM Proxy",
-    description: "Your LiteLLM proxy fronting 100+ providers. Point it at the anthropic route for direct Claude Code use.",
-    baseUrl: "",
-    anthropicBaseUrl: "",
-    api: "openai-completions",
-    // Configurable: LiteLLM can expose an Anthropic-shaped route. Treated as
-    // claudeNative so users can point Claude Code straight at it.
-    claudeNative: true,
-    authEnvVars: ["LITELLM_API_KEY"],
-    authModes: ["apiKey"],
-    models: [],
-    homepageUrl: "https://docs.litellm.ai/docs/simple_proxy"
-  }
-};
-var PROVIDER_IDS = Object.keys(PROVIDER_CATALOG);
-var NATIVE_PROVIDER_IDS = ["anthropic", "openai", "google"];
-function providerById(id) {
-  return PROVIDER_CATALOG[id];
-}
-
-// ../../packages/shared/dist/runtimes.js
-var RUNTIME_CATALOG = [
-  ...ENGINE_IDS.map((id) => ({
-    id,
-    label: ENGINE_CATALOG[id].label,
-    cliBinary: ENGINE_CATALOG[id].cliBinary,
-    installCommand: ENGINE_CATALOG[id].installCommand,
-    kind: "engine"
-  })),
-  { id: "ollama", label: "Ollama", cliBinary: "ollama", installCommand: "curl -fsSL https://ollama.com/install.sh | sh", kind: "tool" },
-  { id: "ccr", label: "Claude Code Router", cliBinary: "ccr", installCommand: "npm install -g @musistudio/claude-code-router", kind: "tool" }
-];
-var RUNTIME_IDS = RUNTIME_CATALOG.map((r) => r.id);
-
-// ../../packages/shared/dist/rotation.js
-var COOLDOWN_BASE_MS = 6e4;
-var COOLDOWN_MAX_MS = 36e5;
-function refreshCredentials(creds, now) {
-  return creds.map((c) => {
-    if (c.status === "cooldown" && (c.cooldownUntil == null || c.cooldownUntil <= now)) {
-      return { ...c, status: "active", cooldownUntil: void 0 };
-    }
-    if (c.status === "active" && c.expiresAt != null && c.expiresAt <= now) {
-      return { ...c, status: "expired" };
-    }
-    return c;
-  });
-}
-function selectRotatable(items, now, isUsable = () => true) {
-  const usable = refreshCredentials(items, now).filter((c) => c.status === "active" && (c.expiresAt == null || c.expiresAt > now) && isUsable(c));
-  if (usable.length === 0)
-    return void 0;
-  return usable.sort((a, b) => a.priority - b.priority || (a.lastUsedAt ?? 0) - (b.lastUsedAt ?? 0))[0];
-}
-function classifyError(raw) {
-  const s = raw.toLowerCase();
-  if (/\b429\b|rate[ _-]?limit|too many requests/.test(s))
-    return "rate_limit";
-  if (/quota|insufficient[_ ]?quota|credit|billing|payment required|\b402\b|usage limit|exceeded your/.test(s))
-    return "quota_exceeded";
-  if (/expired|token (?:has )?expired|refresh|re-?authenticate|session expired/.test(s))
-    return "auth_expired";
-  if (/\b401\b|\b403\b|invalid (?:api )?key|unauthorized|invalid token|authentication/.test(s))
-    return "invalid_key";
-  if (/\beai_again\b|\benotfound\b|getaddrinfo|network is unreachable|\benetunreach\b|\benetdown\b|offline|no address associated|dns/.test(s))
-    return "network_down";
-  if (/\beconnreset\b|\beconnrefused\b|\betimedout\b|\bepipe\b|socket hang ?up|connection (?:closed|reset|error|aborted)|\b50[0234]\b|\b529\b|overloaded|service unavailable|bad gateway|gateway time-?out|temporarily unavailable/.test(s))
-    return "transient";
-  return "unknown";
-}
-function recordFailure(creds, id, errorCode, now, opts) {
-  if (errorCode === "unknown" || errorCode === "transient" || errorCode === "network_down") {
-    return { next: creds, advanced: false };
-  }
-  let advanced = false;
-  const next = creds.map((c) => {
-    if (c.id !== id)
-      return c;
-    advanced = true;
-    const consecutiveFailures = (c.consecutiveFailures ?? 0) + 1;
-    if (errorCode === "auth_expired") {
-      return { ...c, status: "expired", lastErrorCode: errorCode, consecutiveFailures };
-    }
-    if (errorCode === "invalid_key") {
-      return { ...c, status: "revoked", lastErrorCode: errorCode, consecutiveFailures };
-    }
-    const backoff = Math.min(COOLDOWN_BASE_MS * 2 ** (consecutiveFailures - 1), COOLDOWN_MAX_MS);
-    const cooldownUntil = opts?.cooldownUntil ?? now + backoff;
-    return { ...c, status: "cooldown", cooldownUntil, lastErrorCode: errorCode, consecutiveFailures };
-  });
-  return { next, advanced };
-}
-function recordSuccess(creds, id, now) {
-  return creds.map((c) => c.id === id ? { ...c, status: "active", cooldownUntil: void 0, consecutiveFailures: 0, lastUsedAt: now, lastErrorCode: void 0 } : c);
-}
-
 // ../../packages/host-core/dist/runners/proxy-router.js
+init_dist2();
 import { spawn as spawn3, execFile as execFile2, execSync as execSync2 } from "node:child_process";
 import { createRequire as createRequire2 } from "node:module";
 import { randomUUID as randomUUID4, createHash } from "node:crypto";
@@ -43870,6 +45116,7 @@ function resolveOverrideEngineEnv() {
 }
 
 // ../../packages/host-core/dist/runners/pool.js
+init_dist2();
 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";
@@ -44055,6 +45302,7 @@ function setActiveConfig(id) {
 }
 
 // ../../packages/host-core/dist/daemon-engine-spawn.js
+init_dist2();
 import { execFileSync } from "node:child_process";
 import { homedir as homedir6 } from "node:os";
 import { join as join13 } from "node:path";
@@ -44788,6 +46036,123 @@ function unwatchAllRemote() {
   remoteWatches.clear();
 }
 
+// ../../packages/host-core/dist/session-watch.js
+import { watch as watch2 } from "node:fs";
+import { dirname as dirname7, basename as basename3 } from "node:path";
+var DEBOUNCE_MS = 120;
+var BUSY_GRACE_MS = 2e3;
+var watches = /* @__PURE__ */ new Map();
+var sessionToFile = /* @__PURE__ */ new Map();
+async function watchSession(sessionId, key2, projectDir, deps) {
+  let filePath = sessionToFile.get(sessionId);
+  if (!filePath) {
+    const resolved = await deps.resolveFile?.(sessionId, projectDir);
+    if (!resolved)
+      return;
+    filePath = resolved;
+    sessionToFile.set(sessionId, filePath);
+  }
+  const baseline = await deps.getMessages(sessionId).then((m) => m.length).catch(() => 0);
+  const existing = watches.get(filePath);
+  if (existing) {
+    existing.listeners.set(key2, { emittedCount: baseline, deps });
+    return;
+  }
+  const fileName = basename3(filePath);
+  const fw = {
+    watcher: void 0,
+    sessionId,
+    listeners: /* @__PURE__ */ new Map([[key2, { emittedCount: baseline, deps }]]),
+    timer: null,
+    lastBusyAt: 0
+  };
+  try {
+    fw.watcher = watch2(dirname7(filePath), (_event, changed) => {
+      if (changed && basename3(String(changed)) !== fileName)
+        return;
+      scheduleScan(filePath);
+    });
+  } catch {
+    return;
+  }
+  watches.set(filePath, fw);
+}
+function unwatchSession(sessionId, key2) {
+  const filePath = sessionToFile.get(sessionId);
+  if (!filePath)
+    return;
+  const fw = watches.get(filePath);
+  if (!fw)
+    return;
+  fw.listeners.delete(key2);
+  if (fw.listeners.size === 0)
+    closeWatch(filePath);
+}
+function unwatchSessionClient(key2) {
+  for (const [filePath, fw] of [...watches]) {
+    if (fw.listeners.delete(key2) && fw.listeners.size === 0)
+      closeWatch(filePath);
+  }
+}
+function unwatchAllSessions() {
+  for (const [filePath] of [...watches])
+    closeWatch(filePath);
+}
+function closeWatch(filePath) {
+  const fw = watches.get(filePath);
+  if (!fw)
+    return;
+  if (fw.timer)
+    clearTimeout(fw.timer);
+  try {
+    fw.watcher.close();
+  } catch {
+  }
+  watches.delete(filePath);
+  sessionToFile.delete(fw.sessionId);
+}
+function scheduleScan(filePath) {
+  const fw = watches.get(filePath);
+  if (!fw)
+    return;
+  if (fw.timer)
+    clearTimeout(fw.timer);
+  fw.timer = setTimeout(() => {
+    fw.timer = null;
+    void scan(filePath);
+  }, DEBOUNCE_MS);
+}
+async function scan(filePath) {
+  const fw = watches.get(filePath);
+  if (!fw)
+    return;
+  const { sessionId } = fw;
+  const any2 = fw.listeners.values().next().value;
+  if (!any2)
+    return;
+  const busy = any2.deps.isSessionBusy?.(sessionId) === true;
+  const now = Date.now();
+  if (busy)
+    fw.lastBusyAt = now;
+  const inGrace = busy || now - fw.lastBusyAt < BUSY_GRACE_MS;
+  const messages = await any2.deps.getMessages(sessionId).catch(() => null);
+  if (!messages)
+    return;
+  const len = messages.length;
+  for (const [key2, listener] of fw.listeners) {
+    if (inGrace) {
+      listener.emittedCount = len;
+      continue;
+    }
+    if (len < listener.emittedCount) {
+      listener.deps.emit(key2, { type: "session:messages", sessionId, messages });
+    } else if (len > listener.emittedCount) {
+      listener.deps.emit(key2, { type: "session:appended", sessionId, messages: messages.slice(listener.emittedCount) });
+    }
+    listener.emittedCount = len;
+  }
+}
+
 // ../../packages/host-core/dist/fs-datachannel-host.js
 var SCTP_BUF = 16 * 1024 * 1024;
 var ndcPromise = null;
@@ -45000,7 +46365,7 @@ function dynamicMetrics() {
 // ../../packages/host-core/dist/fs-transfer.js
 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 join18, relative as relative5, sep as sep5 } from "node:path";
+import { dirname as dirname8, 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";
@@ -45347,9 +46712,9 @@ async function writeInboundChunk(msg, send2) {
   try {
     if (msg.kind === "symlink") {
       const target = Buffer.from(msg.base64, "base64").toString("utf-8");
-      const resolved = join18(dirname7(abs), target);
+      const resolved = join18(dirname8(abs), target);
       if (isInsideRoot(resolved, s.destRoot)) {
-        await mkdir5(dirname7(abs), { recursive: true }).catch(() => {
+        await mkdir5(dirname8(abs), { recursive: true }).catch(() => {
         });
         await symlink(target, abs).catch(() => {
         });
@@ -45362,7 +46727,7 @@ async function writeInboundChunk(msg, send2) {
     if (s.curIx !== msg.fileIx || !s.curStream) {
       if (s.curStream)
         await new Promise((r) => s.curStream.end(r));
-      await mkdir5(dirname7(abs), { recursive: true }).catch(() => {
+      await mkdir5(dirname8(abs), { recursive: true }).catch(() => {
       });
       s.curStream = createWriteStream(abs);
       s.curIx = msg.fileIx;
@@ -45433,7 +46798,7 @@ var import_selfsigned = __toESM(require_selfsigned(), 1);
 import tls from "node:tls";
 import { X509Certificate } from "node:crypto";
 import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "node:fs";
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname9 } from "node:path";
 function fingerprintOf(certPem) {
   return new X509Certificate(certPem).fingerprint256;
 }
@@ -45446,7 +46811,7 @@ async function loadOrCreateIdentity(certPath, keyPath) {
   const tenYears = new Date(Date.now() + 10 * 365 * 24 * 60 * 60 * 1e3);
   const pems = await (0, import_selfsigned.generate)([{ name: "commonName", value: "tesseract-peer" }], { keySize: 2048, notAfterDate: tenYears, algorithm: "sha256" });
   try {
-    mkdirSync6(dirname8(certPath), { recursive: true });
+    mkdirSync6(dirname9(certPath), { recursive: true });
   } catch {
   }
   try {
@@ -45952,13 +47317,13 @@ 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 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 join24, resolve as resolve7 } from "node:path";
+import { dirname as dirname13, 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 mkdir6, rename, chmod as chmod2, utimes, unlink } from "node:fs/promises";
-import { dirname as dirname9 } from "node:path";
+import { dirname as dirname10 } from "node:path";
 var CHUNK3 = 1024 * 1024;
 var MAX_INFLIGHT2 = 8 * CHUNK3;
 var IDLE_MS2 = 6e4;
@@ -46086,7 +47451,7 @@ var StagingWriter = class {
   }
   async ensureOpen() {
     if (!this.fh) {
-      await mkdir6(dirname9(this.stagingPath), { recursive: true });
+      await mkdir6(dirname10(this.stagingPath), { recursive: true });
       this.fh = await open(this.stagingPath, "w");
     }
     return this.fh;
@@ -46116,7 +47481,7 @@ var StagingWriter = class {
     });
     await fh.close();
     this.fh = null;
-    await mkdir6(dirname9(dest), { recursive: true });
+    await mkdir6(dirname10(dest), { recursive: true });
     await chmod2(this.stagingPath, mode & 511).catch(() => {
     });
     const secs = mtimeMs / 1e3;
@@ -46149,7 +47514,7 @@ var BlockAssembler = class {
     this.stagingPath = stagingPath;
   }
   async open() {
-    await mkdir6(dirname9(this.stagingPath), { recursive: true });
+    await mkdir6(dirname10(this.stagingPath), { recursive: true });
     this.fh = await open(this.stagingPath, "w");
   }
   /** Write a received block at its byte offset (index * CHUNK). */
@@ -46193,7 +47558,7 @@ var BlockAssembler = class {
       });
       return false;
     }
-    await mkdir6(dirname9(dest), { recursive: true });
+    await mkdir6(dirname10(dest), { recursive: true });
     await chmod2(this.stagingPath, mode & 511).catch(() => {
     });
     const secs = mtimeMs / 1e3;
@@ -46771,10 +48136,10 @@ var ReaddirpStream = class extends Readable {
   }
   async _formatEntry(dirent, path5) {
     let entry;
-    const basename6 = this._isDirent ? dirent.name : dirent;
+    const basename7 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path5, basename6));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
+      const fullPath = presolve(pjoin(path5, basename7));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename7 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -47313,9 +48678,9 @@ var NodeFsHandler = class {
   _watchWithNodeFs(path5, listener) {
     const opts = this.fsw.options;
     const directory = sysPath.dirname(path5);
-    const basename6 = sysPath.basename(path5);
+    const basename7 = sysPath.basename(path5);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename6);
+    parent.add(basename7);
     const absolutePath = sysPath.resolve(path5);
     const options = {
       persistent: opts.persistent
@@ -47325,7 +48690,7 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path5, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -47347,11 +48712,11 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname17 = sysPath.dirname(file2);
-    const basename6 = sysPath.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname17);
+    const dirname18 = sysPath.dirname(file2);
+    const basename7 = sysPath.basename(file2);
+    const parent = this.fsw._getWatchedDir(dirname18);
     let prevStats = stats;
-    if (parent.has(basename6))
+    if (parent.has(basename7))
       return;
     const listener = async (path5, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -47376,9 +48741,9 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname17, basename6);
+          this.fsw._remove(dirname18, basename7);
         }
-      } else if (parent.has(basename6)) {
+      } else if (parent.has(basename7)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -48302,7 +49667,7 @@ var FSWatcher = class extends EventEmitter2 {
     return stream;
   }
 };
-function watch2(paths, options = {}) {
+function watch3(paths, options = {}) {
   const watcher = new FSWatcher(options);
   watcher.add(paths);
   return watcher;
@@ -48320,7 +49685,7 @@ var LinkWatcher = class {
     this.debounceMs = opts.debounceMs ?? 500;
   }
   async start() {
-    this.fsw = watch2(this.opts.root, {
+    this.fsw = watch3(this.opts.root, {
       ignoreInitial: true,
       // the engine does its own hashing scan on start
       followSymlinks: false,
@@ -48819,13 +50184,13 @@ 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 = resolve7(dirname12(dest), target);
+    const resolved = resolve7(dirname13(dest), target);
     if (!isInsideRoot(resolved, this.opts.localRoot))
       return;
     const hash2 = hashString(target);
     const secs = mtimeMs / 1e3;
     try {
-      await mkdir7(dirname12(dest), { recursive: true });
+      await mkdir7(dirname13(dest), { recursive: true });
       await rm3(dest, { force: true, recursive: true });
       try {
         await symlink2(target, dest);
@@ -48875,7 +50240,7 @@ var ActiveLinkEngine = class {
       return;
     if (fromRec && fromRec.kind === "file") {
       try {
-        await mkdir7(dirname12(toAbs), { recursive: true });
+        await mkdir7(dirname13(toAbs), { recursive: true });
         await rename2(fromAbs, toAbs);
         const secs = mtimeMs / 1e3;
         await utimes2(toAbs, secs, secs).catch(() => {
@@ -49075,7 +50440,7 @@ var ActiveLinkEngine = class {
 };
 
 // ../../packages/host-core/dist/active-link/config.js
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, existsSync as existsSync13, renameSync as renameSync6, watch as watch3 } from "node:fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, existsSync as existsSync13, renameSync as renameSync6, watch as watch4 } from "node:fs";
 import { join as join25 } from "node:path";
 function configPath2() {
   return join25(activeLinkRoot(), "links.json");
@@ -49149,7 +50514,7 @@ function watchLinkConfigs(onChange) {
   let timer = null;
   let watcher = null;
   try {
-    watcher = watch3(dir, (_evt, file2) => {
+    watcher = watch4(dir, (_evt, file2) => {
       if (file2 && file2 !== "links.json")
         return;
       if (timer)
@@ -49287,7 +50652,7 @@ function routeInboundLinkFrame(frame) {
 }
 
 // ../../packages/host-core/dist/control-link.js
-init_dist2();
+init_dist4();
 
 // ../../packages/host-core/dist/pty-manager.js
 import { existsSync as existsSync14 } from "node:fs";
@@ -49531,6 +50896,7 @@ function clampDim(v, dflt) {
 }
 
 // ../../packages/host-core/dist/control-link.js
+init_dist2();
 var SERVER_HOST_ID = "server";
 var cfg = null;
 var deviceId = "";
@@ -49804,7 +51170,7 @@ function sendActiveLinkProvision(cfg2) {
     type: "provision",
     linkId: cfg2.linkId,
     fromHost: ownHostId(),
-    projectName: cfg2.remoteSubfolder ?? basename5(cfg2.localRoot),
+    projectName: cfg2.remoteSubfolder ?? basename6(cfg2.localRoot),
     ...cfg2.remoteParent ? { remoteParent: cfg2.remoteParent } : {},
     ...cfg2.remoteSubfolder ? { remoteSubfolder: cfg2.remoteSubfolder } : {},
     ...cfg2.workspaceLinkId ? { workspaceLinkId: cfg2.workspaceLinkId } : {}
@@ -50011,6 +51377,20 @@ async function handleInboundAgent(msg, driverClientId) {
       send("agent", { type: "session:messages", sessionId: msg.sessionId, messages }, route2);
       break;
     }
+    case "session:watch":
+      if (driverClientId) {
+        void watchSession(msg.sessionId, driverClientId, msg.projectDir, {
+          getMessages: (sid) => b.getMessages(sid),
+          isSessionBusy: (sid) => b.isSessionBusy?.(sid) ?? false,
+          resolveFile: (sid, dir) => b.resolveSessionFile?.(sid, dir) ?? Promise.resolve(null),
+          emit: (key2, m) => send("agent", m, { clientId: key2 })
+        });
+      }
+      break;
+    case "session:unwatch":
+      if (driverClientId)
+        unwatchSession(msg.sessionId, driverClientId);
+      break;
     case "session:fork": {
       const newId = await b.forkSession?.(msg.sessionId, { projectDir: msg.projectDir, upToMessageId: msg.upToMessageId, title: msg.title }).catch(() => null);
       if (newId)
@@ -50133,6 +51513,7 @@ async function serveInboundTerm(p, driverClientId) {
 }
 function releaseDriver(clientId) {
   unwatchRemoteClient(clientId);
+  unwatchSessionClient(clientId);
   releaseClientPtys(clientId);
   releaseDcClient(clientId);
   for (const [sid, cid] of [...driverBySession]) {
@@ -50165,6 +51546,7 @@ function teardownHostRole() {
   driverBySession.clear();
   driverByRequest.clear();
   unwatchAllRemote();
+  unwatchAllSessions();
   releaseRemotePtys();
   try {
     hostBackend?.reclaim("critical");
@@ -50527,6 +51909,7 @@ function stopControlLink() {
 }
 
 // ../../packages/host-core/dist/local-server.js
+init_dist2();
 var connSeq = 0;
 async function startLocalServer(opts) {
   const log3 = opts.log ?? (() => {
@@ -50583,6 +51966,7 @@ async function startLocalServer(opts) {
     });
     ws.on("close", () => {
       unregisterSink();
+      unwatchSessionClient(loopbackOrigin);
       clearBrowserOrigin(loopbackOrigin);
       if (heldSessions.size) {
         const b = peekSharedBackend();
@@ -50641,6 +52025,17 @@ async function startLocalServer(opts) {
           send2("agent", { type: "session:messages", sessionId: msg.sessionId, messages });
           break;
         }
+        case "session:watch":
+          void watchSession(msg.sessionId, loopbackOrigin, msg.projectDir, {
+            getMessages: (sid) => b.getMessages(sid),
+            isSessionBusy: (sid) => b.isSessionBusy?.(sid) ?? false,
+            resolveFile: (sid, dir) => b.resolveSessionFile?.(sid, dir) ?? Promise.resolve(null),
+            emit: (_key, m) => send2("agent", m)
+          });
+          break;
+        case "session:unwatch":
+          unwatchSession(msg.sessionId, loopbackOrigin);
+          break;
         case "session:fork": {
           const newId = await b.forkSession?.(msg.sessionId, { projectDir: msg.projectDir, upToMessageId: msg.upToMessageId, title: msg.title }).catch(() => null);
           if (newId)
@@ -50983,7 +52378,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 join28 } from "node:path";
+import { dirname as dirname14, join as join28 } from "node:path";
 import { homedir as homedir12, userInfo } from "node:os";
 
 // ../../packages/host-core/dist/service/exec.js
@@ -51050,8 +52445,8 @@ ${env}
   }
   return {
     async install(spec) {
-      mkdirSync11(dirname13(plistPath()), { recursive: true });
-      mkdirSync11(dirname13(spec.logPath), { recursive: true });
+      mkdirSync11(dirname14(plistPath()), { recursive: true });
+      mkdirSync11(dirname14(spec.logPath), { recursive: true });
       writeFileSync11(plistPath(), buildPlist(spec));
       await run("launchctl", ["bootout", serviceTarget()]).catch(() => {
       });
@@ -51103,7 +52498,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 join29 } from "node:path";
+import { dirname as dirname15, join as join29 } from "node:path";
 import { homedir as homedir13, userInfo as userInfo2 } from "node:os";
 function shq(s) {
   return `"${s.replace(/(["\\$`])/g, "\\$1")}"`;
@@ -51137,8 +52532,8 @@ WantedBy=default.target
   }
   return {
     async install(spec) {
-      mkdirSync12(dirname14(unitPath()), { recursive: true });
-      mkdirSync12(dirname14(spec.logPath), { recursive: true });
+      mkdirSync12(dirname15(unitPath()), { recursive: true });
+      mkdirSync12(dirname15(spec.logPath), { recursive: true });
       writeFileSync12(unitPath(), buildUnit(spec));
       await run("loginctl", ["enable-linger", userInfo2().username]).catch(() => {
       });
@@ -51183,7 +52578,7 @@ 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 join30 } from "node:path";
+import { dirname as dirname16, join as join30 } from "node:path";
 function makeWindowsTask(instanceId) {
   const task = `Fineguide\\TesseractHost${instanceId ? `-${instanceId}` : ""}`;
   const wrapperPath = () => join30(daemonDir(), `run-host${instanceId ? `-${instanceId}` : ""}.cmd`);
@@ -51198,8 +52593,8 @@ start "" /b ${cmd} >> "${spec.logPath}" 2>&1\r
   }
   return {
     async install(spec) {
-      mkdirSync13(dirname15(spec.logPath), { recursive: true });
-      mkdirSync13(dirname15(wrapperPath()), { recursive: true });
+      mkdirSync13(dirname16(spec.logPath), { recursive: true });
+      mkdirSync13(dirname16(wrapperPath()), { recursive: true });
       writeFileSync13(wrapperPath(), buildWrapper(spec));
       await run("schtasks", ["/Create", "/TN", task, "/SC", "ONLOGON", "/RL", "LIMITED", "/F", "/TR", `"${wrapperPath()}"`]);
       await run("schtasks", ["/Run", "/TN", task]).catch(() => {
@@ -51633,7 +53028,7 @@ async function logs(instanceId, follow) {
 // src/cli.ts
 function pkgVersion() {
   try {
-    const p = join33(dirname16(fileURLToPath2(import.meta.url)), "..", "package.json");
+    const p = join33(dirname17(fileURLToPath2(import.meta.url)), "..", "package.json");
     return JSON.parse(readFileSync13(p, "utf8")).version ?? "0.0.0";
   } catch {
     return "0.0.0";