bazilion 0.0.0 → 0.1.0

package/dist/worker.js

@@ -0,0 +1,1830 @@
+#!/usr/bin/env node
+
+// ../daemon/src/runtime/worker/entry.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { join as join14 } from "path";
+
+// ../daemon/src/core/agent/delete.ts
+import { existsSync, rmSync } from "fs";
+
+// ../daemon/src/core/agent/spawn.ts
+import { randomUUID } from "crypto";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+
+// ../daemon/src/core/profile/load.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join } from "path";
+
+// ../daemon/src/core/profile/identity.ts
+import { readFileSync } from "fs";
+
+// ../daemon/src/core/group/register.ts
+import { existsSync as existsSync3, mkdirSync, statSync, symlinkSync } from "fs";
+import { resolve } from "path";
+
+// ../daemon/src/core/profile/create.ts
+import { mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// ../daemon/src/core/skills/discover.ts
+import { existsSync as existsSync4, readdirSync } from "fs";
+import { join as join3 } from "path";
+
+// ../daemon/src/core/db/client.ts
+import { DatabaseSync } from "sqlite";
+
+// ../daemon/src/core/db/migrate.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { dirname, join as join5 } from "path";
+import { fileURLToPath } from "url";
+var migrationsDir = join5(dirname(fileURLToPath(import.meta.url)), "migrations");
+
+// ../daemon/src/core/paths.ts
+import { homedir } from "os";
+import { join as join6 } from "path";
+function resolvePaths(home) {
+  const root = home ?? process.env.BAZILION_HOME ?? join6(homedir(), ".bazilion");
+  return {
+    home: root,
+    db: join6(root, "bazilion.db"),
+    authFile: join6(root, "auth.json"),
+    profilesDir: join6(root, "profiles"),
+    agentsDir: join6(root, "agents"),
+    skillsDir: join6(root, "skills"),
+    groupsDir: join6(root, "groups"),
+    logsDir: join6(root, "logs"),
+    profileDir(id) {
+      return join6(root, "profiles", id);
+    },
+    agentDir(id) {
+      return join6(root, "agents", id);
+    },
+    skillDir(name) {
+      return join6(root, "skills", name);
+    },
+    groupDir(slug) {
+      return join6(root, "groups", slug);
+    }
+  };
+}
+
+// ../daemon/src/core/profile/delete.ts
+import { existsSync as existsSync5, rmSync as rmSync2 } from "fs";
+
+// ../daemon/src/core/profile/update.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
+
+// ../daemon/src/core/services.ts
+var SERVICES = [
+  // --- LLM providers (configured via API keys / URLs) ---
+  {
+    id: "anthropic",
+    displayName: "Anthropic",
+    category: "provider",
+    hint: "Claude models \xB7 console.anthropic.com",
+    fields: [
+      { envVar: "ANTHROPIC_API_KEY", kind: "secret", label: "API key", placeholder: "sk-ant-..." },
+      {
+        envVar: "ANTHROPIC_OAUTH_TOKEN",
+        kind: "secret",
+        label: "OAuth token (alternative to API key)",
+        description: "Takes precedence over ANTHROPIC_API_KEY when set"
+      }
+    ]
+  },
+  {
+    id: "openai",
+    displayName: "OpenAI",
+    category: "provider",
+    hint: "GPT models \xB7 platform.openai.com",
+    fields: [{ envVar: "OPENAI_API_KEY", kind: "secret", label: "API key", placeholder: "sk-..." }]
+  },
+  {
+    id: "openai-codex",
+    displayName: "OpenAI ChatGPT (OAuth)",
+    category: "provider",
+    hint: "Use your ChatGPT Plus/Pro/Team account (same login as Codex CLI)",
+    // No form fields — credentials come from an OAuth flow. The /config page
+    // renders a Connect/Disconnect card using /api/auth/openai instead of the
+    // standard field inputs.
+    fields: []
+  },
+  {
+    id: "google",
+    displayName: "Google (Gemini)",
+    category: "provider",
+    hint: "Gemini models \xB7 ai.google.dev (free tier available)",
+    fields: [
+      { envVar: "GEMINI_API_KEY", kind: "secret", label: "API key", placeholder: "AIza..." }
+    ]
+  },
+  {
+    id: "google-vertex",
+    displayName: "Google Vertex AI",
+    category: "provider",
+    hint: "Authenticates via `gcloud auth application-default login`",
+    fields: [
+      {
+        envVar: "GOOGLE_CLOUD_PROJECT",
+        kind: "config",
+        label: "GCP project ID",
+        placeholder: "my-project-123456"
+      },
+      {
+        envVar: "GOOGLE_CLOUD_LOCATION",
+        kind: "config",
+        label: "GCP region",
+        placeholder: "us-central1"
+      }
+    ]
+  },
+  {
+    id: "azure-openai",
+    displayName: "Azure OpenAI",
+    category: "provider",
+    fields: [{ envVar: "AZURE_OPENAI_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "bedrock",
+    displayName: "Amazon Bedrock",
+    category: "provider",
+    hint: "Authenticates via AWS SDK env (AWS_PROFILE or AWS_ACCESS_KEY_ID/SECRET)",
+    fields: []
+  },
+  {
+    id: "mistral",
+    displayName: "Mistral",
+    category: "provider",
+    hint: "mistral.ai",
+    fields: [{ envVar: "MISTRAL_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "groq",
+    displayName: "Groq",
+    category: "provider",
+    hint: "Fast inference \xB7 groq.com",
+    fields: [{ envVar: "GROQ_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "cerebras",
+    displayName: "Cerebras",
+    category: "provider",
+    fields: [{ envVar: "CEREBRAS_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "xai",
+    displayName: "xAI",
+    category: "provider",
+    hint: "Grok \xB7 x.ai",
+    fields: [{ envVar: "XAI_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "zai",
+    displayName: "zAI",
+    category: "provider",
+    fields: [{ envVar: "ZAI_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "huggingface",
+    displayName: "Hugging Face",
+    category: "provider",
+    hint: "Inference endpoints \xB7 huggingface.co",
+    fields: [{ envVar: "HF_TOKEN", kind: "secret", label: "Access token", placeholder: "hf_..." }]
+  },
+  {
+    id: "openrouter",
+    displayName: "OpenRouter",
+    category: "provider",
+    hint: "Proxy for 200+ models \xB7 openrouter.ai",
+    fields: [
+      { envVar: "OPENROUTER_API_KEY", kind: "secret", label: "API key", placeholder: "sk-or-..." }
+    ]
+  },
+  {
+    id: "vercel-ai-gateway",
+    displayName: "Vercel AI Gateway",
+    category: "provider",
+    fields: [
+      { envVar: "AI_GATEWAY_API_KEY", kind: "secret", label: "API key" },
+      {
+        envVar: "AI_GATEWAY_BASE_URL",
+        kind: "config",
+        label: "Base URL (optional)",
+        placeholder: "https://ai-gateway.vercel.sh/v1"
+      }
+    ]
+  },
+  {
+    id: "lmstudio",
+    displayName: "LM Studio",
+    category: "provider",
+    hint: "Local inference \xB7 lmstudio.ai",
+    fields: [
+      {
+        envVar: "LMSTUDIO_URL",
+        kind: "config",
+        label: "Endpoint URL",
+        placeholder: "http://127.0.0.1:1234/v1"
+      },
+      {
+        envVar: "LMSTUDIO_API_KEY",
+        kind: "secret",
+        label: "API key (rarely needed)"
+      }
+    ]
+  },
+  {
+    id: "ollama",
+    displayName: "Ollama",
+    category: "provider",
+    hint: "Local inference \xB7 ollama.com",
+    fields: [
+      {
+        envVar: "OLLAMA_URL",
+        kind: "config",
+        label: "Endpoint URL",
+        placeholder: "http://127.0.0.1:11434/v1"
+      },
+      {
+        envVar: "OLLAMA_API_KEY",
+        kind: "secret",
+        label: "API key (rarely needed)"
+      }
+    ]
+  },
+  // --- Ancillary services (web search, etc) ---
+  {
+    id: "brave-search",
+    displayName: "Brave Search",
+    category: "service",
+    hint: "Web search tool \xB7 free tier at brave.com/search/api/",
+    fields: [{ envVar: "BRAVE_API_KEY", kind: "secret", label: "API key", placeholder: "BSA..." }]
+  },
+  {
+    id: "searxng",
+    displayName: "SearXNG",
+    category: "service",
+    hint: "Self-hosted meta-search engine \xB7 searxng.org",
+    fields: [
+      {
+        envVar: "SEARXNG_URL",
+        kind: "config",
+        label: "Instance URL",
+        placeholder: "https://searxng.example.com"
+      }
+    ]
+  }
+];
+var FIELD_INDEX = (() => {
+  const m = /* @__PURE__ */ new Map();
+  for (const service of SERVICES) {
+    for (const field of service.fields) {
+      m.set(field.envVar, { service, field });
+    }
+  }
+  return m;
+})();
+
+// ../daemon/src/core/repos/config.ts
+var CONFIG_KEYS = SERVICES.flatMap(
+  (s) => s.fields.filter((f) => f.kind === "config").map((f) => f.envVar)
+);
+var CONFIG_KEY_SET = new Set(CONFIG_KEYS);
+
+// ../daemon/src/core/repos/messages.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// ../daemon/src/core/repos/secrets.ts
+import { createCipheriv, createDecipheriv, pbkdf2Sync, randomBytes } from "crypto";
+
+// ../daemon/src/core/repos/triggers.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// ../daemon/src/core/repos/webTokens.ts
+import { createHash, randomBytes as randomBytes2, randomUUID as randomUUID4 } from "crypto";
+
+// ../daemon/src/core/secrets.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+
+// ../daemon/src/core/skills/import.ts
+import { cpSync, existsSync as existsSync7, mkdtempSync, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync2 } from "fs";
+import { tmpdir } from "os";
+import { basename, join as join8, resolve as resolve2, sep } from "path";
+import AdmZip from "adm-zip";
+
+// ../daemon/src/core/skills/parse.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { parse as parseYaml } from "yaml";
+
+// ../daemon/src/runtime/memory/qmd.ts
+import {
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync6,
+  rmSync as rmSync4,
+  statSync as statSync3,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { dirname as dirname2, join as join9 } from "path";
+import { createStore, extractSnippet } from "@tobilu/qmd";
+var INDEX_FILENAME = ".qmd-index.sqlite";
+var COLLECTION_NAME = "memory";
+var PATTERN = "**/*.md";
+var storeCache = /* @__PURE__ */ new Map();
+function getStore(dir) {
+  let p = storeCache.get(dir);
+  if (!p) {
+    p = createStore({
+      dbPath: join9(dir, INDEX_FILENAME),
+      config: {
+        collections: {
+          [COLLECTION_NAME]: { path: dir, pattern: PATTERN }
+        }
+      }
+    });
+    storeCache.set(dir, p);
+  }
+  return p;
+}
+function safeKey(root, key) {
+  if (key.includes("..") || key.startsWith("/") || key.includes("\0")) {
+    throw new Error(`unsafe memory key: ${key}`);
+  }
+  return join9(root, key);
+}
+function walkMd(dir, prefix, out) {
+  if (!existsSync8(dir)) return;
+  for (const e of readdirSync4(dir, { withFileTypes: true })) {
+    if (e.name.startsWith(".")) continue;
+    const full = join9(dir, e.name);
+    const key = prefix ? `${prefix}/${e.name}` : e.name;
+    if (e.isDirectory()) {
+      walkMd(full, key, out);
+    } else if (e.isFile() && e.name.endsWith(".md")) {
+      const stats = statSync3(full);
+      out.push({
+        key,
+        content: readFileSync6(full, "utf8"),
+        updatedAt: stats.mtimeMs
+      });
+    }
+  }
+}
+function qmdBackend(root) {
+  return {
+    async init() {
+      mkdirSync4(root, { recursive: true });
+      const store = await getStore(root);
+      await store.update();
+    },
+    async read(key) {
+      const path = safeKey(root, key);
+      if (!existsSync8(path)) {
+        throw new Error(`memory entry not found: ${key}`);
+      }
+      const stats = statSync3(path);
+      return {
+        key,
+        content: readFileSync6(path, "utf8"),
+        updatedAt: stats.mtimeMs
+      };
+    },
+    async write(key, content) {
+      const path = safeKey(root, key);
+      mkdirSync4(dirname2(path), { recursive: true });
+      writeFileSync4(path, content);
+      const stats = statSync3(path);
+      const store = await getStore(root);
+      await store.update();
+      return { key, content, updatedAt: stats.mtimeMs };
+    },
+    async search(query, opts) {
+      const limit = opts?.limit ?? 10;
+      const store = await getStore(root);
+      const results = await store.searchLex(query, {
+        limit,
+        collection: COLLECTION_NAME
+      });
+      const hits = [];
+      for (const r of results) {
+        const prefix = `${COLLECTION_NAME}/`;
+        const key = r.displayPath.startsWith(prefix) ? r.displayPath.slice(prefix.length) : r.displayPath;
+        let content = r.body ?? "";
+        if (!content) {
+          try {
+            content = readFileSync6(join9(root, key), "utf8");
+          } catch {
+            content = "";
+          }
+        }
+        const snippet = extractSnippet(content, query).snippet;
+        hits.push({ key, snippet, score: r.score });
+      }
+      return hits;
+    },
+    async list() {
+      const out = [];
+      walkMd(root, "", out);
+      return out.sort((a, b) => a.key.localeCompare(b.key));
+    },
+    async remove(key) {
+      const path = safeKey(root, key);
+      if (existsSync8(path)) rmSync4(path);
+      const store = await getStore(root);
+      await store.update();
+    }
+  };
+}
+
+// ../daemon/src/runtime/pi/events.ts
+function translatePiEvent(e) {
+  switch (e.type) {
+    case "message_start": {
+      if (e.message.role === "user") {
+        return [{ type: "user_message", text: stringifyContent(e.message.content) }];
+      }
+      return [];
+    }
+    case "message_update": {
+      const inner = e.assistantMessageEvent;
+      if (inner.type === "text_delta") {
+        return [{ type: "assistant_delta", delta: inner.delta }];
+      }
+      return [];
+    }
+    case "message_end": {
+      const m = e.message;
+      if (m.role !== "assistant") return [];
+      const out = [];
+      const text = extractAssistantText(m);
+      if (text) out.push({ type: "assistant_message", text });
+      for (const block of m.content ?? []) {
+        if (block.type === "toolCall") {
+          out.push({
+            type: "tool_call",
+            id: block.id,
+            name: block.name,
+            arguments: JSON.stringify(block.arguments ?? {})
+          });
+        }
+      }
+      const stopReason = m.stopReason;
+      if (stopReason === "aborted" || stopReason === "error") {
+        const errText = m.errorMessage ?? stopReason;
+        out.push({ type: "error", error: errText });
+      }
+      return out;
+    }
+    case "tool_execution_end": {
+      const text = extractToolResultText(e.result);
+      if (e.isError) {
+        return [{ type: "tool_error", id: e.toolCallId, name: e.toolName, error: text }];
+      }
+      return [{ type: "tool_result", id: e.toolCallId, name: e.toolName, result: text }];
+    }
+    default:
+      return [];
+  }
+}
+function extractAssistantText(m) {
+  let out = "";
+  for (const block of m.content ?? []) {
+    if (block.type === "text") out += block.text;
+  }
+  return out;
+}
+function extractAssistantToolCalls(m) {
+  const out = [];
+  for (const block of m.content ?? []) {
+    if (block.type === "toolCall") {
+      out.push({ id: block.id, name: block.name, arguments: JSON.stringify(block.arguments ?? {}) });
+    }
+  }
+  return out;
+}
+function extractToolResultText(result) {
+  const r = result;
+  if (!r?.content) return "";
+  let out = "";
+  for (const block of r.content) {
+    if (block.type === "text") out += block.text;
+  }
+  return out;
+}
+function stringifyContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let out = "";
+  for (const block of content) {
+    if (block.type === "text" && typeof block.text === "string") out += block.text;
+  }
+  return out;
+}
+function piMessagesToProviderView(messages) {
+  const out = [];
+  for (const m of messages) {
+    switch (m.role) {
+      case "user": {
+        out.push({ role: "user", content: stringifyContent(m.content) });
+        break;
+      }
+      case "assistant": {
+        const am = m;
+        const text = extractAssistantText(am);
+        const toolCalls = extractAssistantToolCalls(am);
+        const msg = { role: "assistant", content: text };
+        if (toolCalls.length > 0) msg.toolCalls = toolCalls;
+        out.push(msg);
+        break;
+      }
+      case "toolResult": {
+        const tr = m;
+        out.push({
+          role: "tool",
+          content: stringifyContent(tr.content),
+          toolCallId: tr.toolCallId,
+          toolName: tr.toolName
+        });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return out;
+}
+
+// ../daemon/src/runtime/pi/session.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
+import { basename as basename2, join as join13 } from "path";
+import {
+  AuthStorage,
+  createAgentSession,
+  createExtensionRuntime,
+  ModelRegistry,
+  SessionManager,
+  SettingsManager
+} from "@mariozechner/pi-coding-agent";
+
+// ../daemon/src/runtime/providers/pi-adapter.ts
+import {
+  getModel,
+  streamSimple,
+  Type
+} from "@mariozechner/pi-ai";
+function defaultBaseUrlFor(providerName) {
+  switch (providerName) {
+    case "lmstudio":
+      return process.env.LMSTUDIO_URL ?? "http://127.0.0.1:1234/v1";
+    case "ollama":
+      return process.env.OLLAMA_URL ?? "http://127.0.0.1:11434/v1";
+    default:
+      return "";
+  }
+}
+function buildModelLiteral(cfg, modelId) {
+  return {
+    id: modelId,
+    name: modelId,
+    api: cfg.fallbackApi,
+    provider: cfg.providerName,
+    baseUrl: cfg.baseUrl ?? defaultBaseUrlFor(cfg.providerName),
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 32768,
+    maxTokens: 4096
+  };
+}
+function resolveModel(cfg, modelId) {
+  const lookupName = cfg.piProviderName ?? cfg.providerName;
+  try {
+    const known = getModel(
+      lookupName,
+      modelId
+    );
+    if (known && typeof known === "object" && "api" in known) {
+      if (cfg.baseUrl) return { ...known, baseUrl: cfg.baseUrl };
+      return known;
+    }
+  } catch {
+  }
+  return buildModelLiteral(cfg, modelId);
+}
+
+// ../daemon/src/runtime/auth/openai-codex.ts
+import { loginOpenAICodex, refreshOpenAICodexToken } from "@mariozechner/pi-ai/oauth";
+
+// ../daemon/src/runtime/session/prompt.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join10 } from "path";
+var CONTEXT_FILE_ORDER = [
+  "AGENTS.md",
+  "SOUL.md",
+  "TOOLS.md",
+  "IDENTITY.md",
+  "HEARTBEAT.md",
+  "BOOTSTRAP.md"
+];
+function buildSystemPrompt(agent) {
+  const parts = [];
+  const contextBlocks = [];
+  let bootstrapPresent = false;
+  for (const file of CONTEXT_FILE_ORDER) {
+    const path = join10(agent.agent.dir, file);
+    if (!existsSync9(path)) continue;
+    const content = readFileSync7(path, "utf8").trimEnd();
+    if (!content) continue;
+    contextBlocks.push(`## ${file}
+
+${content}`);
+    if (file === "BOOTSTRAP.md") bootstrapPresent = true;
+  }
+  if (contextBlocks.length > 0) {
+    parts.push(`# Project Context
+
+${contextBlocks.join("\n\n")}`);
+  }
+  if (bootstrapPresent) {
+    parts.push(
+      "NOTE: This is your first session. After you have completed the bootstrap conversation, call the `bootstrap_done` tool to delete BOOTSTRAP.md."
+    );
+  }
+  parts.push(
+    [
+      "# Agent Home",
+      "",
+      "Your private home holds who you are \u2014 identity, soul, behaviour rules, wake-up routine. It is not shared with other agents and cannot be overwritten by them. The files above (IDENTITY.md, SOUL.md, AGENTS.md, TOOLS.md, HEARTBEAT.md, BOOTSTRAP.md) live in this home.",
+      "",
+      "- To change who you are (name, vibe, personality, how you behave): use `home_write`.",
+      "- To inspect exact wording of your own files: use `home_read` or `home_list`.",
+      "- To remember facts the user told you or things you learned: use `memory_write` \u2014 NOT `home_write`.",
+      "- To produce work output (code, docs, artefacts): use `write` / `edit` \u2014 those land in your workspace, not your home."
+    ].join("\n")
+  );
+  if (agent.skills.length > 0) {
+    parts.push(
+      `# Available Skills
+
+You have access to the following skills: ${agent.skills.join(", ")}.`
+    );
+  }
+  const groupLines = [
+    "# Group",
+    "",
+    `- ${agent.group.id} (${agent.group.name}): ${agent.group.path}`,
+    "",
+    "Your group is where work product lives \u2014 code, docs, artefacts, shared scratch. It may be shared with other agents in the same group. Your coding tools (`read`, `bash`, `edit`, `write`, `grep`, `find`, `ls`) are rooted at the group directory. Never use these tools to edit your identity/soul/behaviour files \u2014 those live in your home and are reached via `home_write` / `home_read`."
+  ];
+  parts.push(groupLines.join("\n"));
+  if (agent.group.userMd.trim()) {
+    parts.push(
+      `# About the User
+
+Read-only context about the human you're working with in this group. You cannot edit this \u2014 if it's wrong, say so and they will update it.
+
+${agent.group.userMd.trim()}`
+    );
+  }
+  parts.push(
+    "# Memory\n\nYou share a persistent memory backend with every other agent in this group. Use `memory_write` to remember things across sessions, and `memory_search` / `memory_read` / `memory_list` to recall them. This memory is for project knowledge \u2014 codebase notes, decisions, things the user told you about the work. For personal notes about yourself (preferences, persona quirks), use `home_write` on IDENTITY.md instead. Always check memory at the start of a session: another agent in the group may have already learned something useful."
+  );
+  return parts.join("\n\n---\n\n");
+}
+
+// ../daemon/src/runtime/pi/tools.ts
+import { Type as Type2 } from "typebox";
+
+// ../daemon/src/runtime/tools/bootstrap.ts
+import { existsSync as existsSync10, rmSync as rmSync5 } from "fs";
+import { join as join11 } from "path";
+function bootstrapTool(agentDir) {
+  return {
+    def: {
+      name: "bootstrap_done",
+      description: "Call this once you have finished your bootstrap conversation (introduced yourself, learned the user, updated IDENTITY.md). Removes BOOTSTRAP.md so it does not appear in future sessions.",
+      parameters: { type: "object", properties: {} }
+    },
+    async invoke() {
+      const path = join11(agentDir, "BOOTSTRAP.md");
+      if (existsSync10(path)) {
+        rmSync5(path);
+        return "BOOTSTRAP.md removed. Bootstrap is complete.";
+      }
+      return "BOOTSTRAP.md was already removed.";
+    }
+  };
+}
+
+// ../daemon/src/runtime/tools/home.ts
+import { readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join12 } from "path";
+var HOME_FILES_READABLE = [
+  "IDENTITY.md",
+  "SOUL.md",
+  "BOOTSTRAP.md",
+  "AGENTS.md",
+  "TOOLS.md",
+  "HEARTBEAT.md"
+];
+var HOME_FILES_WRITABLE = [
+  "IDENTITY.md",
+  "SOUL.md",
+  "AGENTS.md",
+  "TOOLS.md",
+  "HEARTBEAT.md"
+];
+function homeTools(agentDir) {
+  return [
+    {
+      def: {
+        name: "home_read",
+        description: "Read one of your own home files \u2014 your identity, soul, or behaviour rules. These files are private to you and are also injected into your system prompt; read them when you need to quote exact wording or check current state.",
+        parameters: {
+          type: "object",
+          properties: {
+            file: { type: "string", enum: [...HOME_FILES_READABLE] }
+          },
+          required: ["file"]
+        }
+      },
+      async invoke(args) {
+        const file = String(args.file ?? "");
+        if (!HOME_FILES_READABLE.includes(file)) {
+          throw new Error(
+            `home_read: "file" must be one of ${HOME_FILES_READABLE.join(", ")}; got "${file}"`
+          );
+        }
+        const path = join12(agentDir, file);
+        try {
+          return readFileSync8(path, "utf8");
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          throw new Error(`home_read: could not read ${file}: ${msg}`);
+        }
+      }
+    },
+    {
+      def: {
+        name: "home_write",
+        description: "Overwrite one of your own home files. Use this to update your name, personality, or persistent self-definition. Do NOT use this for work output (use `write` / `edit` \u2014 those land in your group's shared directory) or for facts you want to remember (use `memory_write`). BOOTSTRAP.md is not writable here; call `bootstrap_done` to retire it.",
+        parameters: {
+          type: "object",
+          properties: {
+            file: { type: "string", enum: [...HOME_FILES_WRITABLE] },
+            content: { type: "string", description: "new full file content" }
+          },
+          required: ["file", "content"]
+        }
+      },
+      async invoke(args) {
+        const file = String(args.file ?? "");
+        if (!HOME_FILES_WRITABLE.includes(file)) {
+          throw new Error(
+            `home_write: "file" must be one of ${HOME_FILES_WRITABLE.join(", ")}; got "${file}"`
+          );
+        }
+        const content = typeof args.content === "string" ? args.content : "";
+        const path = join12(agentDir, file);
+        writeFileSync5(path, content, "utf8");
+        return `wrote ${file} (${Buffer.byteLength(content, "utf8")} bytes)`;
+      }
+    },
+    {
+      def: {
+        name: "home_list",
+        description: "List your home files with their sizes.",
+        parameters: { type: "object", properties: {} }
+      },
+      async invoke() {
+        const entries = [];
+        for (const file of HOME_FILES_READABLE) {
+          const path = join12(agentDir, file);
+          try {
+            const s = statSync4(path);
+            entries.push(`${file} (${s.size}b)`);
+          } catch {
+          }
+        }
+        if (entries.length === 0) {
+          const dirEntries = (() => {
+            try {
+              return readdirSync5(agentDir);
+            } catch {
+              return [];
+            }
+          })();
+          return `(no home files found; agent dir contains: ${dirEntries.join(", ") || "nothing"})`;
+        }
+        return entries.join("\n");
+      }
+    }
+  ];
+}
+
+// ../daemon/src/runtime/tools/memory.ts
+function memoryTools(memory) {
+  return [
+    {
+      def: {
+        name: "memory_write",
+        description: 'Write or update a memory note in the GROUP-SHARED memory. All agents in this group can read what you write. Use it for project knowledge, codebase notes, decisions, and findings \u2014 anything other agents in the group should benefit from. For personal notes about yourself (preferences, persona), use `home_write` on IDENTITY.md instead. Key is a path-like string with a markdown extension, e.g. "auth-flow.md" or "people/alice.md".',
+        parameters: {
+          type: "object",
+          properties: {
+            key: { type: "string", description: "memory key (relative path)" },
+            content: { type: "string", description: "note content (plain text or markdown)" }
+          },
+          required: ["key", "content"]
+        }
+      },
+      async invoke(args) {
+        const key = String(args.key ?? "");
+        const content = String(args.content ?? "");
+        if (!key) throw new Error('memory_write: "key" is required');
+        const entry = await memory.write(key, content);
+        return `wrote ${entry.key} (${entry.content.length} bytes)`;
+      }
+    },
+    {
+      def: {
+        name: "memory_search",
+        description: "Search the group-shared memory by substring. Returns matching entry keys with short snippets around the match.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: { type: "string" },
+            limit: { type: "number", description: "max results (default 10)" }
+          },
+          required: ["query"]
+        }
+      },
+      async invoke(args) {
+        const query = String(args.query ?? "");
+        if (!query) throw new Error('memory_search: "query" is required');
+        const limit = typeof args.limit === "number" ? args.limit : 10;
+        const hits = await memory.search(query, { limit });
+        if (hits.length === 0) return "no matches";
+        return hits.map((h) => `${h.key}: ${h.snippet.replaceAll("\n", " ")}`).join("\n");
+      }
+    },
+    {
+      def: {
+        name: "memory_read",
+        description: "Read a single entry from the group-shared memory by key.",
+        parameters: {
+          type: "object",
+          properties: { key: { type: "string" } },
+          required: ["key"]
+        }
+      },
+      async invoke(args) {
+        const key = String(args.key ?? "");
+        if (!key) throw new Error('memory_read: "key" is required');
+        const entry = await memory.read(key);
+        return entry.content;
+      }
+    },
+    {
+      def: {
+        name: "memory_list",
+        description: "List every entry in the group-shared memory with its byte size.",
+        parameters: { type: "object", properties: {} }
+      },
+      async invoke() {
+        const all = await memory.list();
+        if (all.length === 0) return "(empty)";
+        return all.map((e) => `${e.key} (${e.content.length}b)`).join("\n");
+      }
+    }
+  ];
+}
+
+// ../daemon/src/runtime/tools/messaging.ts
+function decodeText(payload) {
+  try {
+    const parsed = JSON.parse(payload);
+    if (parsed && typeof parsed.text === "string") return parsed.text;
+  } catch {
+  }
+  return payload;
+}
+function messagingTools(host, fromAgentId) {
+  return [
+    {
+      def: {
+        name: "send_message",
+        description: "Send a message to another agent. Use the recipient's agent id (UUID).",
+        parameters: {
+          type: "object",
+          properties: {
+            to: { type: "string", description: "Recipient agent id" },
+            text: { type: "string", description: "Message text" },
+            reply_to: {
+              type: "string",
+              description: "Optional: id of the message you are replying to"
+            }
+          },
+          required: ["to", "text"]
+        }
+      },
+      async invoke(args) {
+        const to = String(args.to ?? "");
+        const text = String(args.text ?? "");
+        if (!to) throw new Error('send_message: "to" is required');
+        if (!text) throw new Error('send_message: "text" is required');
+        if (!await host.agentExists(to)) {
+          throw new Error(`send_message: agent not found: ${to}`);
+        }
+        const replyTo = typeof args.reply_to === "string" ? args.reply_to : null;
+        const { messageId } = await host.sendMessage({
+          from: fromAgentId,
+          to,
+          payload: JSON.stringify({ text }),
+          replyTo
+        });
+        return `sent message ${messageId}`;
+      }
+    },
+    {
+      def: {
+        name: "read_inbox",
+        description: "Read messages addressed to you. Marks unread messages as read by default.",
+        parameters: {
+          type: "object",
+          properties: {
+            include_read: {
+              type: "boolean",
+              description: "Also include already-read messages (default false)"
+            }
+          }
+        }
+      },
+      async invoke(args) {
+        const includeRead = args.include_read === true;
+        const messages = await host.listInbox(fromAgentId, { unreadOnly: !includeRead });
+        if (messages.length === 0) return "(no messages)";
+        const lines = [];
+        for (const m of messages) {
+          lines.push(`from ${m.fromAgentId} [${m.id}]: ${decodeText(m.payload)}`);
+          if (!m.readAt) await host.markRead(m.id);
+        }
+        return lines.join("\n");
+      }
+    },
+    {
+      def: {
+        name: "wait_for_reply",
+        description: "Block until a reply to a message you sent arrives, or until the timeout expires.",
+        parameters: {
+          type: "object",
+          properties: {
+            message_id: {
+              type: "string",
+              description: "id of the message you sent"
+            },
+            timeout_ms: {
+              type: "number",
+              description: "max wait in milliseconds (default 30000)"
+            },
+            poll_ms: {
+              type: "number",
+              description: "poll interval in milliseconds (default 200)"
+            }
+          },
+          required: ["message_id"]
+        }
+      },
+      async invoke(args) {
+        const messageId = String(args.message_id ?? "");
+        if (!messageId) throw new Error('wait_for_reply: "message_id" is required');
+        const timeout = typeof args.timeout_ms === "number" ? args.timeout_ms : 3e4;
+        const poll = typeof args.poll_ms === "number" ? args.poll_ms : 200;
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+          const replies = await host.findReplies(fromAgentId, messageId);
+          if (replies.length > 0) {
+            const r = replies[0];
+            if (r) {
+              if (!r.readAt) await host.markRead(r.id);
+              return `reply from ${r.fromAgentId} [${r.id}]: ${decodeText(r.payload)}`;
+            }
+          }
+          await new Promise((r) => setTimeout(r, poll));
+        }
+        return `no reply within ${timeout}ms`;
+      }
+    }
+  ];
+}
+
+// ../daemon/src/runtime/tools/web-extract.ts
+import { Readability } from "@mozilla/readability";
+import { parseHTML } from "linkedom";
+function decodeEntities(value) {
+  return value.replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16))).replace(/&#(\d+);/gi, (_, dec) => String.fromCharCode(Number.parseInt(dec, 10)));
+}
+function stripTags(value) {
+  return decodeEntities(value.replace(/<[^>]+>/g, ""));
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\r/g, "").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").replace(/[ \t]{2,}/g, " ").trim();
+}
+function htmlToMarkdown(html) {
+  const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = titleMatch ? normalizeWhitespace(stripTags(titleMatch[1] ?? "")) : void 0;
+  let text = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<noscript[\s\S]*?<\/noscript>/gi, "").replace(/<nav[\s\S]*?<\/nav>/gi, "").replace(/<header[\s\S]*?<\/header>/gi, "").replace(/<footer[\s\S]*?<\/footer>/gi, "");
+  text = text.replace(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, body) => {
+    const label = normalizeWhitespace(stripTags(body));
+    return label ? `[${label}](${href})` : href;
+  });
+  text = text.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (_, level, body) => {
+    const n = Math.max(1, Math.min(6, Number.parseInt(level, 10)));
+    return `
+${"#".repeat(n)} ${normalizeWhitespace(stripTags(body))}
+`;
+  });
+  text = text.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_, body) => {
+    const label = normalizeWhitespace(stripTags(body));
+    return label ? `
+- ${label}` : "";
+  });
+  text = text.replace(/<(br|hr)\s*\/?>/gi, "\n").replace(/<\/(p|div|section|article|tr|ul|ol|table|blockquote)>/gi, "\n");
+  text = stripTags(text);
+  return { text: normalizeWhitespace(text), title };
+}
+function markdownToPlain(md) {
+  let t = md;
+  t = t.replace(/!\[[^\]]*]\([^)]+\)/g, "");
+  t = t.replace(/\[([^\]]+)]\([^)]+\)/g, "$1");
+  t = t.replace(
+    /```[\s\S]*?```/g,
+    (block) => block.replace(/```[^\n]*\n?/g, "").replace(/```/g, "")
+  );
+  t = t.replace(/`([^`]+)`/g, "$1");
+  t = t.replace(/^#{1,6}\s+/gm, "");
+  t = t.replace(/^\s*[-*+]\s+/gm, "");
+  t = t.replace(/^\s*\d+\.\s+/gm, "");
+  return normalizeWhitespace(t);
+}
+function extractReadable(html, url, mode) {
+  const fallback = () => {
+    const r = htmlToMarkdown(html);
+    return mode === "text" ? { text: markdownToPlain(r.text), title: r.title } : r;
+  };
+  try {
+    const { document } = parseHTML(html);
+    try {
+      ;
+      document.baseURI = url;
+    } catch {
+    }
+    const parsed = new Readability(document, {
+      charThreshold: 0
+    }).parse();
+    if (!parsed?.content) return fallback();
+    const title = parsed.title || void 0;
+    if (mode === "text") {
+      const text = normalizeWhitespace(parsed.textContent ?? "");
+      return text ? { text, title } : fallback();
+    }
+    const rendered = htmlToMarkdown(parsed.content);
+    return { text: rendered.text, title: title ?? rendered.title };
+  } catch {
+    return fallback();
+  }
+}
+
+// ../daemon/src/runtime/tools/web-ssrf.ts
+import { lookup as dnsLookupCb } from "dns";
+import { lookup as dnsLookup } from "dns/promises";
+import { Agent } from "undici";
+var SsrFBlockedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SsrFBlockedError";
+  }
+};
+var BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "metadata.google.internal"]);
+var PRIVATE_IPV6_PREFIXES = ["fe80:", "fec0:", "fc", "fd"];
+function normalizeHostname(hostname) {
+  let h = hostname.trim().toLowerCase().replace(/\.$/, "");
+  if (h.startsWith("[") && h.endsWith("]")) h = h.slice(1, -1);
+  return h;
+}
+function parseIpv4(address) {
+  const parts = address.split(".");
+  if (parts.length !== 4) return null;
+  const nums = parts.map((p) => Number.parseInt(p, 10));
+  if (nums.some((n) => Number.isNaN(n) || n < 0 || n > 255)) return null;
+  return nums;
+}
+function isPrivateIpv4(parts) {
+  const [a, b] = parts;
+  if (a === 0 || a === 10 || a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  return false;
+}
+function isPrivateIpAddress(address) {
+  let norm = address.trim().toLowerCase();
+  if (norm.startsWith("[") && norm.endsWith("]")) norm = norm.slice(1, -1);
+  if (!norm) return false;
+  if (norm.startsWith("::ffff:")) {
+    const mapped = norm.slice("::ffff:".length);
+    const ipv42 = parseIpv4(mapped);
+    if (ipv42) return isPrivateIpv4(ipv42);
+  }
+  if (norm.includes(":")) {
+    if (norm === "::" || norm === "::1") return true;
+    return PRIVATE_IPV6_PREFIXES.some((p) => norm.startsWith(p));
+  }
+  const ipv4 = parseIpv4(norm);
+  return ipv4 ? isPrivateIpv4(ipv4) : false;
+}
+function isBlockedHostname(hostname) {
+  const h = normalizeHostname(hostname);
+  if (!h) return false;
+  if (BLOCKED_HOSTNAMES.has(h)) return true;
+  return h.endsWith(".localhost") || h.endsWith(".local") || h.endsWith(".internal");
+}
+function createPinnedLookup(hostname, addresses) {
+  const normalized = normalizeHostname(hostname);
+  const records = addresses.map((address) => ({
+    address,
+    family: address.includes(":") ? 6 : 4
+  }));
+  let index = 0;
+  return ((host, options, callback) => {
+    const cb = typeof options === "function" ? options : callback;
+    if (!cb) return;
+    if (normalizeHostname(host) !== normalized) {
+      if (typeof options === "function" || options === void 0) {
+        return dnsLookupCb(host, cb);
+      }
+      return dnsLookupCb(
+        host,
+        options,
+        cb
+      );
+    }
+    const opts = typeof options === "object" && options !== null ? options : {};
+    const family = typeof options === "number" ? options : opts.family ?? 0;
+    const candidates = family === 4 || family === 6 ? records.filter((r) => r.family === family) : records;
+    const usable = candidates.length > 0 ? candidates : records;
+    if (opts.all) {
+      cb(null, usable);
+      return;
+    }
+    const chosen = usable[index % usable.length];
+    if (!chosen) return;
+    index += 1;
+    cb(null, chosen.address, chosen.family);
+  });
+}
+async function resolveAndCheck(hostname) {
+  const norm = normalizeHostname(hostname);
+  if (!norm) throw new SsrFBlockedError("Invalid hostname");
+  if (isBlockedHostname(norm)) throw new SsrFBlockedError(`Blocked hostname: ${hostname}`);
+  if (isPrivateIpAddress(norm)) throw new SsrFBlockedError("Blocked: private IP literal");
+  const results = await dnsLookup(norm, { all: true });
+  if (results.length === 0) throw new SsrFBlockedError(`Cannot resolve: ${hostname}`);
+  for (const r of results) {
+    if (isPrivateIpAddress(r.address)) throw new SsrFBlockedError("Blocked: resolves to private IP");
+  }
+  return Array.from(new Set(results.map((r) => r.address)));
+}
+function isRedirectStatus(s) {
+  return s === 301 || s === 302 || s === 303 || s === 307 || s === 308;
+}
+async function closeDispatcher(d) {
+  if (!d) return;
+  try {
+    await d.close();
+  } catch {
+  }
+}
+async function guardedFetch(opts) {
+  const fetcher = opts.fetchImpl ?? globalThis.fetch;
+  const maxRedirects = opts.maxRedirects ?? 3;
+  const abortController = new AbortController();
+  const timeoutId = opts.timeoutMs ? setTimeout(() => abortController.abort(new Error("timeout")), opts.timeoutMs) : null;
+  if (opts.signal) {
+    if (opts.signal.aborted) abortController.abort(opts.signal.reason);
+    else
+      opts.signal.addEventListener("abort", () => abortController.abort(opts.signal?.reason), {
+        once: true
+      });
+  }
+  let current = opts.url;
+  const visited = /* @__PURE__ */ new Set();
+  let redirects = 0;
+  let dispatcher = null;
+  const release = async () => {
+    if (timeoutId) clearTimeout(timeoutId);
+    await closeDispatcher(dispatcher);
+    dispatcher = null;
+  };
+  while (true) {
+    let parsed;
+    try {
+      parsed = new URL(current);
+    } catch {
+      await release();
+      throw new Error("Invalid URL");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      await release();
+      throw new Error("Invalid URL: must be http or https");
+    }
+    const canPin = !opts.fetchImpl;
+    if (!opts.allowPrivate) {
+      const addrs = await resolveAndCheck(parsed.hostname);
+      await closeDispatcher(dispatcher);
+      dispatcher = canPin ? new Agent({ connect: { lookup: createPinnedLookup(parsed.hostname, addrs) } }) : null;
+    }
+    const init = {
+      ...opts.init ?? {},
+      redirect: "manual",
+      signal: abortController.signal
+    };
+    if (dispatcher) init.dispatcher = dispatcher;
+    let res;
+    try {
+      res = await fetcher(parsed.toString(), init);
+    } catch (err) {
+      await release();
+      throw err;
+    }
+    if (isRedirectStatus(res.status)) {
+      const loc = res.headers.get("location");
+      if (!loc) {
+        await release();
+        throw new Error(`Redirect ${res.status} missing Location header`);
+      }
+      redirects += 1;
+      if (redirects > maxRedirects) {
+        await release();
+        throw new Error(`Too many redirects (> ${maxRedirects})`);
+      }
+      const next = new URL(loc, parsed).toString();
+      if (visited.has(next)) {
+        await release();
+        throw new Error("Redirect loop");
+      }
+      visited.add(next);
+      void res.body?.cancel();
+      current = next;
+      continue;
+    }
+    return { response: res, finalUrl: parsed.toString(), release };
+  }
+}
+
+// ../daemon/src/runtime/tools/web.ts
+var DEFAULT_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";
+var DEFAULT_CACHE_TTL_MS = 15 * 6e4;
+var DEFAULT_CACHE_MAX = 100;
+var DEFAULT_MAX_LENGTH = 2e4;
+var DEFAULT_TIMEOUT_MS = 2e4;
+function stripHtml(s) {
+  return s.replace(/<[^>]*>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").trim();
+}
+async function braveSearch(query, limit, apiKey, fetchFn) {
+  const params = new URLSearchParams({ q: query, count: String(limit) });
+  const res = await fetchFn(`https://api.search.brave.com/res/v1/web/search?${params}`, {
+    headers: {
+      accept: "application/json",
+      "accept-encoding": "gzip",
+      "x-subscription-token": apiKey
+    }
+  });
+  if (!res.ok) throw new Error(`Brave Search: ${res.status} ${await res.text()}`);
+  const data = await res.json();
+  return (data.web?.results ?? []).slice(0, limit).map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.description ? stripHtml(r.description) : ""
+  }));
+}
+async function searxngSearch(query, limit, baseURL, fetchFn) {
+  const params = new URLSearchParams({ q: query, format: "json" });
+  const res = await fetchFn(`${baseURL}/search?${params}`, {
+    headers: { accept: "application/json" }
+  });
+  if (!res.ok) throw new Error(`SearXNG: ${res.status} ${await res.text()}`);
+  const data = await res.json();
+  return (data.results ?? []).slice(0, limit).map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.content ?? ""
+  }));
+}
+function cacheGet(cache, key) {
+  const entry = cache.get(key);
+  if (!entry) return null;
+  if (entry.expiresAt < Date.now()) {
+    cache.delete(key);
+    return null;
+  }
+  cache.delete(key);
+  cache.set(key, entry);
+  return entry.value;
+}
+function cacheSet(cache, key, value, ttlMs, maxEntries) {
+  cache.set(key, { value, expiresAt: Date.now() + ttlMs });
+  while (cache.size > maxEntries) {
+    const oldest = cache.keys().next().value;
+    if (!oldest) break;
+    cache.delete(oldest);
+  }
+}
+function webTools(opts) {
+  const fetchFn = opts?.fetchImpl ?? fetch;
+  const env = opts?.env ?? process.env;
+  const allowPrivate = opts?.allowPrivate ?? false;
+  const cacheTtlMs = opts?.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+  const cacheMax = opts?.cacheMax ?? DEFAULT_CACHE_MAX;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const cache = /* @__PURE__ */ new Map();
+  return [
+    {
+      def: {
+        name: "web_search",
+        description: "Search the internet. Returns a list of titles, URLs, and snippets. Requires BRAVE_API_KEY or SEARXNG_URL to be configured.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query" },
+            limit: { type: "number", description: "Max results to return (default 5)" }
+          },
+          required: ["query"]
+        }
+      },
+      async invoke(args) {
+        const query = String(args.query ?? "");
+        if (!query) throw new Error("web_search: query is required");
+        const limit = typeof args.limit === "number" ? args.limit : 5;
+        const braveKey = env.BRAVE_API_KEY;
+        if (braveKey) {
+          const results = await braveSearch(query, limit, braveKey, fetchFn);
+          return results.length === 0 ? "no results" : formatResults(results);
+        }
+        const searxngUrl = env.SEARXNG_URL;
+        if (searxngUrl) {
+          const results = await searxngSearch(query, limit, searxngUrl, fetchFn);
+          return results.length === 0 ? "no results" : formatResults(results);
+        }
+        throw new Error(
+          "web_search: no search backend configured. Set BRAVE_API_KEY (free at https://brave.com/search/api/) or SEARXNG_URL."
+        );
+      }
+    },
+    {
+      def: {
+        name: "web_fetch",
+        description: "Fetch a URL and return its readable content. HTML is extracted via Readability and converted to markdown. Results are cached for 15 minutes.",
+        parameters: {
+          type: "object",
+          properties: {
+            url: { type: "string", description: "The URL to fetch (http or https)" },
+            max_length: {
+              type: "number",
+              description: "Max characters to return (default 20000)"
+            },
+            extract_mode: {
+              type: "string",
+              enum: ["markdown", "text"],
+              description: 'Output format for HTML pages. Default "markdown".'
+            }
+          },
+          required: ["url"]
+        }
+      },
+      async invoke(args) {
+        const url = String(args.url ?? "");
+        if (!url) throw new Error("web_fetch: url is required");
+        const maxLen = typeof args.max_length === "number" ? args.max_length : DEFAULT_MAX_LENGTH;
+        const mode = args.extract_mode === "text" ? "text" : "markdown";
+        const cacheKey = `${mode}|${url}`;
+        const cached = cacheGet(cache, cacheKey);
+        if (cached) return formatOutput(cached, maxLen);
+        let result;
+        try {
+          result = await guardedFetch({
+            url,
+            fetchImpl: opts?.fetchImpl,
+            allowPrivate,
+            timeoutMs,
+            init: {
+              headers: {
+                "user-agent": DEFAULT_USER_AGENT,
+                accept: "text/html,application/xhtml+xml,application/json,text/plain,*/*",
+                "accept-language": "en-US,en;q=0.9"
+              }
+            }
+          });
+        } catch (err) {
+          if (err instanceof SsrFBlockedError) throw new Error(`web_fetch: ${err.message}`);
+          throw err;
+        }
+        try {
+          if (!result.response.ok) {
+            throw new Error(`web_fetch: ${result.response.status} ${result.response.statusText}`);
+          }
+          const ct = result.response.headers.get("content-type") ?? "";
+          const body = await result.response.text();
+          let extracted;
+          if (ct.includes("text/html") || ct.includes("xhtml")) {
+            extracted = extractReadable(body, result.finalUrl, mode);
+          } else if (ct.includes("application/json")) {
+            try {
+              extracted = { text: JSON.stringify(JSON.parse(body), null, 2) };
+            } catch {
+              extracted = { text: body };
+            }
+          } else {
+            extracted = { text: body };
+          }
+          cacheSet(cache, cacheKey, extracted, cacheTtlMs, cacheMax);
+          return formatOutput(extracted, maxLen);
+        } finally {
+          await result.release();
+        }
+      }
+    }
+  ];
+}
+function formatOutput(r, maxLen) {
+  const body = r.title ? `# ${r.title}
+
+${r.text}` : r.text;
+  if (body.length > maxLen) return `${body.slice(0, maxLen)}
+
+[truncated at ${maxLen} chars]`;
+  return body;
+}
+function formatResults(results) {
+  return results.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}
+   ${r.snippet}`).join("\n\n");
+}
+
+// ../daemon/src/runtime/pi/tools.ts
+function ourToolToPiTool(h) {
+  return {
+    name: h.def.name,
+    label: h.def.name,
+    description: h.def.description,
+    parameters: Type2.Unsafe(h.def.parameters),
+    async execute(_toolCallId, params) {
+      const text = await h.invoke(params);
+      return {
+        content: [{ type: "text", text }],
+        details: {}
+      };
+    }
+  };
+}
+function createBazilionCustomTools(opts) {
+  const handlers = [
+    ...memoryTools(opts.memory),
+    ...homeTools(opts.agent.agent.dir),
+    bootstrapTool(opts.agent.agent.dir),
+    ...webTools({ env: opts.env })
+  ];
+  if (opts.messagingHost) {
+    handlers.push(...messagingTools(opts.messagingHost, opts.agent.agent.id));
+  }
+  return handlers.map(ourToolToPiTool);
+}
+
+// ../daemon/src/runtime/pi/session.ts
+var BUILTIN_TOOL_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
+async function createBazilionSession(opts) {
+  const { agent, paths, env, memory, enabledProviders, messagingHost, refreshApiKey } = opts;
+  const { providerName, modelId } = splitModelString(agent.model);
+  if (enabledProviders.size > 0 && !enabledProviders.has(providerName)) {
+    throw new Error(`${providerName} provider is disabled \u2014 enable it on the /config page`);
+  }
+  const piProviderName = mapProviderName(providerName);
+  const model = resolveModel(
+    {
+      providerName,
+      piProviderName,
+      fallbackApi: pickFallbackApi(providerName),
+      baseUrl: resolveBaseUrl(providerName, env)
+    },
+    modelId
+  );
+  const apiKey = opts.apiKey ?? resolveApiKey(providerName, env);
+  const authStorage = AuthStorage.inMemory();
+  if (apiKey) {
+    authStorage.setRuntimeApiKey(piProviderName, apiKey);
+  }
+  const modelRegistry = ModelRegistry.inMemory(authStorage);
+  if (providerName === "lmstudio" || providerName === "ollama") {
+    modelRegistry.registerProvider(piProviderName, {
+      baseUrl: model.baseUrl,
+      api: "openai-completions",
+      authHeader: false,
+      apiKey: apiKey ?? "dummy"
+    });
+  }
+  const cwd = agent.group.path;
+  if (!existsSync11(cwd)) mkdirSync5(cwd, { recursive: true });
+  const sessionDir = join13(paths.agentDir(agent.agent.id), "sessions");
+  mkdirSync5(sessionDir, { recursive: true });
+  const existing = findMostRecent(sessionDir);
+  const sessionManager = existing ? SessionManager.open(existing, sessionDir, cwd) : SessionManager.create(cwd, sessionDir);
+  const settingsManager = SettingsManager.inMemory({
+    compaction: { enabled: false },
+    retry: { enabled: true, maxRetries: 2, baseDelayMs: 500, maxDelayMs: 8e3 }
+  });
+  const bazilionPrompt = buildSystemPrompt(agent);
+  const resourceLoader = createBazilionResourceLoader(bazilionPrompt);
+  await resourceLoader.reload();
+  const customTools = createBazilionCustomTools({ agent, memory, messagingHost, env });
+  const allowedTools = [...BUILTIN_TOOL_NAMES, ...customTools.map((t) => t.name)];
+  const { session } = await createAgentSession({
+    cwd,
+    agentDir: join13(paths.home, "pi"),
+    model,
+    thinkingLevel: toPiThinkingLevel(agent.reasoningLevel),
+    tools: allowedTools,
+    customTools,
+    sessionManager,
+    settingsManager,
+    authStorage,
+    modelRegistry,
+    resourceLoader
+  });
+  if (refreshApiKey) {
+    session.agent.getApiKey = async (requestedProvider) => {
+      if (requestedProvider !== piProviderName) return void 0;
+      try {
+        return await refreshApiKey(providerName);
+      } catch {
+        return void 0;
+      }
+    };
+  }
+  return {
+    session,
+    dispose() {
+      session.dispose();
+    }
+  };
+}
+function splitModelString(s) {
+  const idx = s.indexOf(":");
+  if (idx === -1) {
+    throw new Error(`invalid model string "${s}": expected "provider:model"`);
+  }
+  return { providerName: s.slice(0, idx), modelId: s.slice(idx + 1) };
+}
+function mapProviderName(name) {
+  if (name === "bedrock") return "amazon-bedrock";
+  return name;
+}
+function pickFallbackApi(providerName) {
+  switch (providerName) {
+    case "anthropic":
+      return "anthropic-messages";
+    case "google":
+      return "google-generative-ai";
+    case "google-vertex":
+      return "google-vertex";
+    case "azure-openai":
+      return "azure-openai-responses";
+    case "bedrock":
+      return "bedrock-converse-stream";
+    case "openai-codex":
+      return "openai-codex-responses";
+    default:
+      return "openai-completions";
+  }
+}
+function resolveBaseUrl(providerName, env) {
+  if (providerName === "lmstudio") return env.LMSTUDIO_URL ?? "http://127.0.0.1:1234/v1";
+  if (providerName === "ollama") return env.OLLAMA_URL ?? "http://127.0.0.1:11434/v1";
+  return void 0;
+}
+function resolveApiKey(providerName, env) {
+  switch (providerName) {
+    case "anthropic":
+      return env.ANTHROPIC_OAUTH_TOKEN ?? env.ANTHROPIC_API_KEY;
+    case "openai":
+      return env.OPENAI_API_KEY;
+    case "google":
+      return env.GEMINI_API_KEY;
+    case "mistral":
+      return env.MISTRAL_API_KEY;
+    case "groq":
+      return env.GROQ_API_KEY;
+    case "cerebras":
+      return env.CEREBRAS_API_KEY;
+    case "xai":
+      return env.XAI_API_KEY;
+    case "zai":
+      return env.ZAI_API_KEY;
+    case "huggingface":
+      return env.HF_TOKEN;
+    case "openrouter":
+      return env.OPENROUTER_API_KEY;
+    case "vercel-ai-gateway":
+      return env.AI_GATEWAY_API_KEY;
+    case "azure-openai":
+      return env.AZURE_OPENAI_API_KEY;
+    case "lmstudio":
+      return env.LMSTUDIO_API_KEY ?? "lm-studio";
+    case "ollama":
+      return env.OLLAMA_API_KEY ?? "ollama";
+    default:
+      return void 0;
+  }
+}
+function toPiThinkingLevel(level) {
+  switch (level) {
+    case "off":
+    case "minimal":
+    case "low":
+    case "medium":
+    case "high":
+    case "xhigh":
+      return level;
+    default:
+      return "medium";
+  }
+}
+function createBazilionResourceLoader(appendSystemPrompt) {
+  const extensions = { extensions: [], errors: [], runtime: createExtensionRuntime() };
+  return {
+    getExtensions: () => extensions,
+    getSkills: () => ({ skills: [], diagnostics: [] }),
+    getPrompts: () => ({ prompts: [], diagnostics: [] }),
+    getThemes: () => ({ themes: [], diagnostics: [] }),
+    getAgentsFiles: () => ({ agentsFiles: [] }),
+    getSystemPrompt: () => void 0,
+    getAppendSystemPrompt: () => appendSystemPrompt ? [appendSystemPrompt] : [],
+    extendResources: () => {
+    },
+    async reload() {
+    }
+  };
+}
+function findMostRecent(sessionDir) {
+  if (!existsSync11(sessionDir)) return null;
+  let newest = null;
+  for (const entry of readdirSync6(sessionDir)) {
+    if (!entry.endsWith(".jsonl")) continue;
+    const path = join13(sessionDir, entry);
+    try {
+      const s = statSync5(path);
+      if (!newest || s.mtimeMs > newest.mtimeMs) newest = { path, mtimeMs: s.mtimeMs };
+    } catch {
+    }
+  }
+  return newest?.path ?? null;
+}
+
+// ../daemon/src/runtime/worker/entry.ts
+function emit(frame) {
+  process.stdout.write(`${JSON.stringify(frame)}
+`);
+}
+async function readInput() {
+  const chunks = [];
+  for await (const c of process.stdin) chunks.push(c);
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) throw new Error("worker: empty stdin input");
+  const parsed = JSON.parse(raw);
+  if (!parsed.agent || typeof parsed.message !== "string" || !Array.isArray(parsed.enabledProviders)) {
+    throw new Error("worker: stdin must be {agent, message, enabledProviders}");
+  }
+  return parsed;
+}
+function createIpcMessagingHost() {
+  const pending = /* @__PURE__ */ new Map();
+  process.on("message", (msg) => {
+    if (!isIpcReply(msg)) return;
+    const entry = pending.get(msg.id);
+    if (!entry) return;
+    pending.delete(msg.id);
+    if (msg.ok) entry.resolve(msg.result);
+    else entry.reject(new Error(msg.error));
+  });
+  process.on("disconnect", () => {
+    for (const [, entry] of pending) entry.reject(new Error("worker IPC channel disconnected"));
+    pending.clear();
+  });
+  function call(method, args) {
+    if (!process.send) {
+      return Promise.reject(new Error("worker: no IPC channel \u2014 daemon must spawn with stdio:ipc"));
+    }
+    const id = randomUUID5();
+    const message = { type: "rpc", id, method, args };
+    return new Promise((resolve3, reject) => {
+      pending.set(id, {
+        resolve: (v) => resolve3(v),
+        reject
+      });
+      process.send?.(message, void 0, void 0, (err) => {
+        if (err) {
+          pending.delete(id);
+          reject(err);
+        }
+      });
+    });
+  }
+  return {
+    agentExists: (agentId) => call("agentExists", { agentId }),
+    sendMessage: (input) => call("sendMessage", input),
+    listInbox: (agentId, opts) => call("listInbox", { agentId, unreadOnly: opts.unreadOnly }),
+    markRead: async (messageId) => {
+      await call("markRead", { messageId });
+    },
+    findReplies: (agentId, replyTo) => call("findReplies", { agentId, replyTo })
+  };
+}
+function isIpcReply(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  return m.type === "rpc-reply" && typeof m.id === "string" && typeof m.ok === "boolean";
+}
+async function main() {
+  let aborted = false;
+  let abortSession = null;
+  const onSignal = () => {
+    aborted = true;
+    if (abortSession) {
+      abortSession();
+    } else {
+      try {
+        emit({ kind: "event", event: { type: "error", error: "cancelled" } });
+      } catch {
+      }
+      process.exit(0);
+    }
+  };
+  process.on("SIGTERM", onSignal);
+  process.on("SIGINT", onSignal);
+  const { agent, message, enabledProviders, apiKey } = await readInput();
+  const paths = resolvePaths();
+  const memory = qmdBackend(join14(agent.group.path, "memory"));
+  await memory.init();
+  const messagingHost = createIpcMessagingHost();
+  const { session, dispose } = await createBazilionSession({
+    agent,
+    paths,
+    env: process.env,
+    memory,
+    enabledProviders: new Set(enabledProviders),
+    messagingHost,
+    apiKey
+  });
+  abortSession = () => {
+    void session.abort();
+  };
+  const unsubscribe = session.subscribe((piEvent) => {
+    for (const ev of translatePiEvent(piEvent)) {
+      emit({ kind: "event", event: ev });
+    }
+  });
+  try {
+    await session.prompt(message);
+    await session.agent.waitForIdle();
+    emit({
+      kind: "done",
+      messages: piMessagesToProviderView(session.agent.state.messages)
+    });
+  } catch (err) {
+    if (!aborted) {
+      emit({ kind: "event", event: { type: "error", error: err.message } });
+    }
+    emit({ kind: "fatal", error: err.message });
+    process.exitCode = 1;
+  } finally {
+    unsubscribe();
+    process.off("SIGTERM", onSignal);
+    process.off("SIGINT", onSignal);
+    dispose();
+    try {
+      process.disconnect?.();
+    } catch {
+    }
+  }
+}
+main().catch((err) => {
+  try {
+    emit({ kind: "fatal", error: err?.message ?? String(err) });
+  } catch {
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=worker.js.map