bazilion 0.1.0 → 0.2.0

package/dist/daemon.js

@@ -9,7 +9,7 @@ var __export = (target, all) => {
 import { serve } from "@hono/node-server";
 
 // ../daemon/src/app.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 
 // ../daemon/src/lib/middleware-auth.ts
 import { getCookie } from "hono/cookie";
@@ -541,12 +541,32 @@ Fill this in during your first conversation. Make it yours.
 `;
 var DEFAULT_BOOTSTRAP = `# BOOTSTRAP.md \u2014 First Run
 
-You just woke up. There is no memory yet \u2014 that's normal.
+You just woke up. There is no memory yet \u2014 that's normal. This is a multi-turn
+ritual: ask ONE question per turn and wait for the human's reply before moving
+on. Do not race through it. Do not call any tool until the ritual is finished.
+
+## The ritual
+
+**Turn 1 (right now):** Greet the human warmly and ask a single opening
+question \u2014 what should they call you, or what should you focus on for them.
+Do NOT call any tool yet. Just reply with greeting + one question.
+
+**Turn 2+:** Continue with one more question per turn to fill in the rest of
+your identity \u2014 vibe (warm / sharp / playful / calm / \u2026), an emoji that
+feels right. Each turn is acknowledging the previous answer + at most one
+new question. Skip a turn when you already have enough.
 
-## What to do
-1. Ask your human who they are and what they want to call you.
-2. Call the \`home_write\` tool with \`file: "IDENTITY.md"\` and new content that captures your name, vibe, and emoji. Do NOT use the generic \`edit\` / \`write\` tools for this \u2014 those land in your workspace, not your private home, and would collide with other agents.
-3. Call \`bootstrap_done\` when finished \u2014 it removes this file so it does not appear in future sessions.
+**Final turn:** Once you have everything (Name, Vibe, Emoji), call \`home_write\`
+with \`file: "IDENTITY.md"\` and the populated content. Do NOT use the generic
+\`edit\` / \`write\` tools \u2014 those land in the shared workspace.
+
+Then call \`bootstrap_done\` to retire this ritual file. After that, future
+sessions skip the bootstrap and start from IDENTITY.md directly.
+
+## Hard rules
+- Do not invent a name on your own. Ask the human and use what they say.
+- Do not call \`home_write\` or \`bootstrap_done\` on your very first reply.
+- One question per turn. Wait for the human to answer.
 `;
 
 // ../daemon/src/core/profile/create.ts
@@ -774,6 +794,9 @@ function openDb(path) {
     }
   };
 }
+function inTx(db, fn) {
+  return db.raw.transaction(fn)();
+}
 
 // ../daemon/src/core/db/migrate.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
@@ -810,11 +833,11 @@ function runMigrations(db) {
 function deleteGroup(db, paths, id) {
   const g = get2(db, id, paths);
   if (!g) throw new Error(`group not found: ${id}`);
-  const members = list(db, { includeArchived: true }).filter((a) => a.groupId === id);
-  if (members.length > 0) {
-    const names = members.map((a) => `${a.name} (${a.id.slice(0, 8)})`).join(", ");
+  const members2 = list(db, { includeArchived: true }).filter((a) => a.groupId === id);
+  if (members2.length > 0) {
+    const names = members2.map((a) => `${a.name} (${a.id.slice(0, 8)})`).join(", ");
     throw new Error(
-      `cannot delete group "${id}": ${members.length} agent(s) still belong to it: ${names}. Move or archive them first.`
+      `cannot delete group "${id}": ${members2.length} agent(s) still belong to it: ${names}. Move or archive them first.`
     );
   }
   remove2(db, id);
@@ -851,6 +874,123 @@ function resolvePaths(home) {
 
 // ../daemon/src/core/profile/delete.ts
 import { existsSync as existsSync5, rmSync as rmSync2 } from "fs";
+
+// ../daemon/src/core/repos/profileGroups.ts
+var profileGroups_exports = {};
+__export(profileGroups_exports, {
+  findReferencingProfile: () => findReferencingProfile,
+  get: () => get4,
+  insert: () => insert4,
+  list: () => list5,
+  members: () => members,
+  remove: () => remove5,
+  replaceMembers: () => replaceMembers,
+  update: () => update2
+});
+function toProfileGroup(r) {
+  return {
+    id: r.id,
+    name: r.name,
+    userMd: r.user_md,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at
+  };
+}
+function toMember(r) {
+  return {
+    profileGroupId: r.profile_group_id,
+    position: r.position,
+    profileId: r.profile_id,
+    agentName: r.agent_name,
+    modelOverride: r.model_override,
+    reasoningLevel: r.reasoning_level
+  };
+}
+function insert4(db, p) {
+  const now = Date.now();
+  db.raw.run(
+    `INSERT INTO profile_groups (id, name, user_md, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?)`,
+    [p.id, p.name, p.userMd, now, now]
+  );
+  return { ...p, createdAt: now, updatedAt: now };
+}
+function get4(db, id) {
+  const row = db.raw.query("SELECT * FROM profile_groups WHERE id = ?").get(id);
+  return row ? toProfileGroup(row) : null;
+}
+function list5(db) {
+  return db.raw.query(
+    `SELECT pg.*, COALESCE(m.cnt, 0) AS member_count
+       FROM profile_groups pg
+       LEFT JOIN (
+         SELECT profile_group_id, COUNT(*) AS cnt
+         FROM profile_group_members
+         GROUP BY profile_group_id
+       ) m ON m.profile_group_id = pg.id
+       ORDER BY pg.created_at ASC`
+  ).all().map((r) => ({ ...toProfileGroup(r), memberCount: r.member_count }));
+}
+function update2(db, id, patch) {
+  const sets = [];
+  const args = [];
+  if (Object.hasOwn(patch, "name")) {
+    sets.push("name = ?");
+    args.push(patch.name);
+  }
+  if (Object.hasOwn(patch, "userMd")) {
+    sets.push("user_md = ?");
+    args.push(patch.userMd ?? null);
+  }
+  if (sets.length === 0) return;
+  sets.push("updated_at = ?");
+  args.push(Date.now());
+  args.push(id);
+  db.raw.run(`UPDATE profile_groups SET ${sets.join(", ")} WHERE id = ?`, args);
+}
+function remove5(db, id) {
+  db.raw.run("DELETE FROM profile_groups WHERE id = ?", [id]);
+}
+function members(db, profileGroupId) {
+  return db.raw.query(
+    `SELECT * FROM profile_group_members
+       WHERE profile_group_id = ?
+       ORDER BY position ASC`
+  ).all(profileGroupId).map(toMember);
+}
+function findReferencingProfile(db, profileId) {
+  return db.raw.query(
+    `SELECT DISTINCT pg.id AS id, pg.name AS name
+       FROM profile_groups pg
+       JOIN profile_group_members m ON m.profile_group_id = pg.id
+       WHERE m.profile_id = ?`
+  ).all(profileId);
+}
+function replaceMembers(db, profileGroupId, newMembers) {
+  const tx = db.raw.transaction(() => {
+    db.raw.run("DELETE FROM profile_group_members WHERE profile_group_id = ?", [profileGroupId]);
+    const stmt = db.raw.query(
+      `INSERT INTO profile_group_members
+       (profile_group_id, position, profile_id, agent_name, model_override, reasoning_level)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    for (let i = 0; i < newMembers.length; i++) {
+      const m = newMembers[i];
+      if (!m) continue;
+      stmt.run(
+        profileGroupId,
+        i,
+        m.profileId,
+        m.agentName,
+        m.modelOverride ?? null,
+        m.reasoningLevel ?? null
+      );
+    }
+  });
+  tx();
+}
+
+// ../daemon/src/core/profile/delete.ts
 function deleteProfile(db, id) {
   const profile = get3(db, id);
   if (!profile) throw new Error(`profile not found: ${id}`);
@@ -861,6 +1001,13 @@ function deleteProfile(db, id) {
       `cannot delete profile "${id}": ${agents.length} agent(s) still reference it: ${names}. Delete or re-profile them first.`
     );
   }
+  const refGroups = findReferencingProfile(db, id);
+  if (refGroups.length > 0) {
+    const names = refGroups.map((g) => `${g.name} (${g.id})`).join(", ");
+    throw new Error(
+      `cannot delete profile "${id}": ${refGroups.length} profile group(s) still reference it: ${names}. Remove the member(s) first.`
+    );
+  }
   remove3(db, id);
   if (existsSync5(profile.dir)) {
     rmSync2(profile.dir, { recursive: true, force: true });
@@ -900,9 +1047,157 @@ function updateProfile(db, paths, id, input) {
   return updated;
 }
 
+// ../daemon/src/core/profile-group/spawn.ts
+import { readdirSync as readdirSync3, rmSync as rmSync4 } from "fs";
+
+// ../daemon/src/core/profile-group/rm-with-retry.ts
+import { rmSync as rmSync3 } from "fs";
+var DEFAULT_RM_RETRY_DELAYS_MS = [100, 500, 2e3];
+async function rmWithRetry(target, opts = {}) {
+  const rm = opts.rm ?? ((p) => rmSync3(p, { recursive: true, force: true }));
+  const delays = opts.delays ?? DEFAULT_RM_RETRY_DELAYS_MS;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  for (let attempt = 0; attempt <= delays.length; attempt++) {
+    try {
+      rm(target);
+      return true;
+    } catch {
+      if (attempt === delays.length) return false;
+      const delay = delays[attempt] ?? 0;
+      await sleep(delay);
+    }
+  }
+  return false;
+}
+
+// ../daemon/src/core/profile-group/spawn.ts
+var SpawnProfileGroupError = class extends Error {
+  name = "SpawnProfileGroupError";
+  orphanAgentIds;
+  cause;
+  constructor(message, orphanAgentIds, cause) {
+    super(message);
+    this.orphanAgentIds = orphanAgentIds;
+    this.cause = cause;
+  }
+};
+function resolveMemberNames(existing, members2) {
+  const taken = new Set(existing);
+  const out = [];
+  for (const m of members2) {
+    let candidate = m.agentName;
+    let n = 2;
+    while (taken.has(candidate)) {
+      candidate = `${m.agentName}-${n}`;
+      n++;
+    }
+    taken.add(candidate);
+    out.push(candidate);
+  }
+  return out;
+}
+async function spawnProfileGroup(db, paths, input) {
+  const template = get4(db, input.profileGroupId);
+  if (!template) {
+    throw new Error(`profile group not found: ${input.profileGroupId}`);
+  }
+  const members2 = members(db, input.profileGroupId);
+  const missing = [];
+  for (const m of members2) {
+    if (!get3(db, m.profileId)) missing.push(m.profileId);
+  }
+  if (missing.length > 0) {
+    throw new Error(`profile group spawn: missing profiles: ${missing.join(", ")}`);
+  }
+  const targetSlug = input.groupSlug ?? DEFAULT_GROUP_ID;
+  const targetGroupExists = !!get2(db, targetSlug, paths);
+  const existingNames = new Set(
+    targetGroupExists ? db.raw.query("SELECT name FROM agents WHERE group_id = ?").all(targetSlug).map((r) => r.name) : []
+  );
+  const resolvedNames = resolveMemberNames(existingNames, members2);
+  const beforeAgentDirs = new Set(safeReaddir(paths.agentsDir));
+  const beforeGroupDirs = new Set(safeReaddir(paths.groupsDir));
+  let groupCreated = false;
+  const created = [];
+  try {
+    inTx(db, () => {
+      if (!targetGroupExists) {
+        registerGroup(db, { id: targetSlug, name: targetSlug }, paths);
+        groupCreated = true;
+      }
+      const seedUserMd = input.userMd ?? template.userMd ?? null;
+      if (groupCreated && seedUserMd) {
+        setUserMd(db, targetSlug, seedUserMd);
+      }
+      for (let i = 0; i < members2.length; i++) {
+        const member = members2[i];
+        const name = resolvedNames[i];
+        if (!member || !name) continue;
+        const agent = spawnAgent(db, paths, {
+          profileId: member.profileId,
+          name,
+          modelOverride: member.modelOverride,
+          reasoningLevel: member.reasoningLevel ?? "medium",
+          groupId: targetSlug
+        });
+        created.push({ id: agent.id, name: agent.name });
+      }
+    });
+    return { groupSlug: targetSlug, agents: created, orphanAgentIds: [] };
+  } catch (err) {
+    const newAgentDirs = safeReaddir(paths.agentsDir).filter((d) => !beforeAgentDirs.has(d));
+    const orphans = [];
+    for (const dir of newAgentDirs) {
+      if (!await rmWithRetry(paths.agentDir(dir))) {
+        orphans.push(dir);
+      }
+    }
+    const newGroupDirs = safeReaddir(paths.groupsDir).filter((d) => !beforeGroupDirs.has(d));
+    for (const slug of newGroupDirs) {
+      try {
+        rmSync4(paths.groupDir(slug), { recursive: true, force: true });
+      } catch (cleanupErr) {
+        console.error(`spawnProfileGroup: failed to clean up group dir ${slug}`, cleanupErr);
+      }
+    }
+    for (const id of orphans) {
+      console.error(`spawnProfileGroup: orphan agent dir left on disk: ${paths.agentDir(id)}`);
+    }
+    const original = err instanceof Error ? err.message : String(err);
+    const message = orphans.length > 0 ? `${original} (orphan agent dirs: ${orphans.join(", ")})` : original;
+    throw new SpawnProfileGroupError(message, orphans, err);
+  }
+}
+function safeReaddir(dir) {
+  try {
+    return readdirSync3(dir);
+  } catch {
+    return [];
+  }
+}
+
 // ../daemon/src/core/services.ts
 var SERVICES = [
   // --- LLM providers (configured via API keys / URLs) ---
+  // Top 3: openai-codex (ChatGPT OAuth), openai (API key), anthropic.
+  // Everything else in rough popularity order; locals last.
+  {
+    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: "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: "anthropic",
     displayName: "Anthropic",
@@ -918,23 +1213,6 @@ var SERVICES = [
       }
     ]
   },
-  {
-    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)",
@@ -977,6 +1255,27 @@ var SERVICES = [
     hint: "Authenticates via AWS SDK env (AWS_PROFILE or AWS_ACCESS_KEY_ID/SECRET)",
     fields: []
   },
+  {
+    id: "github-copilot",
+    displayName: "GitHub Copilot",
+    category: "provider",
+    hint: "Use a GitHub Copilot subscription to call Claude/GPT/Gemini via Copilot",
+    fields: [
+      {
+        envVar: "COPILOT_GITHUB_TOKEN",
+        kind: "secret",
+        label: "GitHub token",
+        description: "Generic GH_TOKEN/GITHUB_TOKEN are ignored \u2014 set this scoped variable explicitly (or run `bazilion auth copilot login` once available)."
+      }
+    ]
+  },
+  {
+    id: "deepseek",
+    displayName: "DeepSeek",
+    category: "provider",
+    hint: "DeepSeek V4 Flash / Pro \xB7 platform.deepseek.com",
+    fields: [{ envVar: "DEEPSEEK_API_KEY", kind: "secret", label: "API key" }]
+  },
   {
     id: "mistral",
     displayName: "Mistral",
@@ -984,6 +1283,13 @@ var SERVICES = [
     hint: "mistral.ai",
     fields: [{ envVar: "MISTRAL_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: "groq",
     displayName: "Groq",
@@ -998,11 +1304,46 @@ var SERVICES = [
     fields: [{ envVar: "CEREBRAS_API_KEY", kind: "secret", label: "API key" }]
   },
   {
-    id: "xai",
-    displayName: "xAI",
+    id: "fireworks",
+    displayName: "Fireworks AI",
     category: "provider",
-    hint: "Grok \xB7 x.ai",
-    fields: [{ envVar: "XAI_API_KEY", kind: "secret", label: "API key" }]
+    hint: "DeepSeek/GLM/Kimi via fireworks.ai",
+    fields: [{ envVar: "FIREWORKS_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "together",
+    displayName: "Together AI",
+    category: "provider",
+    hint: "Open-weight models \xB7 together.ai",
+    fields: [{ envVar: "TOGETHER_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "moonshotai",
+    displayName: "Moonshot AI",
+    category: "provider",
+    hint: "Kimi K2/K2.5/K2.6 \xB7 platform.moonshot.ai",
+    fields: [{ envVar: "MOONSHOT_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "kimi-coding",
+    displayName: "Kimi Coding",
+    category: "provider",
+    hint: "Coding-tuned Kimi endpoint \xB7 platform.moonshot.cn",
+    fields: [{ envVar: "KIMI_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "minimax",
+    displayName: "MiniMax",
+    category: "provider",
+    hint: "MiniMax M2 family \xB7 platform.minimaxi.com",
+    fields: [{ envVar: "MINIMAX_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "xiaomi",
+    displayName: "Xiaomi MiMo",
+    category: "provider",
+    hint: "API billing endpoint \xB7 platform.xiaomimimo.com",
+    fields: [{ envVar: "XIAOMI_API_KEY", kind: "secret", label: "API key" }]
   },
   {
     id: "zai",
@@ -1017,6 +1358,27 @@ var SERVICES = [
     hint: "Inference endpoints \xB7 huggingface.co",
     fields: [{ envVar: "HF_TOKEN", kind: "secret", label: "Access token", placeholder: "hf_..." }]
   },
+  {
+    id: "cloudflare-ai-gateway",
+    displayName: "Cloudflare AI Gateway",
+    category: "provider",
+    hint: "Per-gateway routing to OpenAI/Anthropic/Workers AI",
+    fields: [
+      { envVar: "CLOUDFLARE_API_KEY", kind: "secret", label: "API key" },
+      { envVar: "CLOUDFLARE_ACCOUNT_ID", kind: "config", label: "Account ID" },
+      { envVar: "CLOUDFLARE_GATEWAY_ID", kind: "config", label: "Gateway ID" }
+    ]
+  },
+  {
+    id: "cloudflare-workers-ai",
+    displayName: "Cloudflare Workers AI",
+    category: "provider",
+    hint: "Inference on Cloudflare Workers \xB7 ai.cloudflare.com",
+    fields: [
+      { envVar: "CLOUDFLARE_API_KEY", kind: "secret", label: "API key" },
+      { envVar: "CLOUDFLARE_ACCOUNT_ID", kind: "config", label: "Account ID" }
+    ]
+  },
   {
     id: "openrouter",
     displayName: "OpenRouter",
@@ -1040,6 +1402,13 @@ var SERVICES = [
       }
     ]
   },
+  {
+    id: "opencode",
+    displayName: "OpenCode",
+    category: "provider",
+    hint: "OpenAI-compatible proxy from the OpenCode CLI",
+    fields: [{ envVar: "OPENCODE_API_KEY", kind: "secret", label: "API key" }]
+  },
   {
     id: "lmstudio",
     displayName: "LM Studio",
@@ -1078,11 +1447,54 @@ var SERVICES = [
       }
     ]
   },
+  {
+    id: "llamacpp",
+    displayName: "llama.cpp",
+    category: "provider",
+    hint: "Local inference \xB7 llama.cpp llama-server (OpenAI-compat /v1 endpoint)",
+    fields: [
+      {
+        envVar: "LLAMACPP_URL",
+        kind: "config",
+        label: "Endpoint URL",
+        placeholder: "http://127.0.0.1:8080/v1"
+      },
+      {
+        envVar: "LLAMACPP_API_KEY",
+        kind: "secret",
+        label: "API key (only if started with --api-key)",
+        description: "llama-server runs without auth by default. Set this only if you launched the server with the `--api-key KEY` flag."
+      }
+    ]
+  },
   // --- Ancillary services (web search, etc) ---
+  {
+    id: "firecrawl",
+    displayName: "Firecrawl",
+    category: "service",
+    group: "Web Search",
+    hint: "web_fetch fallback for JS-heavy/blocked pages \xB7 firecrawl.dev (free tier available)",
+    fields: [
+      {
+        envVar: "FIRECRAWL_API_KEY",
+        kind: "secret",
+        label: "API key",
+        placeholder: "fc-...",
+        description: "When set, web_fetch automatically falls back to Firecrawl if the primary Readability extraction yields too little content."
+      },
+      {
+        envVar: "FIRECRAWL_URL",
+        kind: "config",
+        label: "Base URL (optional, for self-hosted)",
+        placeholder: "https://api.firecrawl.dev"
+      }
+    ]
+  },
   {
     id: "brave-search",
     displayName: "Brave Search",
     category: "service",
+    group: "Web Search",
     hint: "Web search tool \xB7 free tier at brave.com/search/api/",
     fields: [{ envVar: "BRAVE_API_KEY", kind: "secret", label: "API key", placeholder: "BSA..." }]
   },
@@ -1090,6 +1502,7 @@ var SERVICES = [
     id: "searxng",
     displayName: "SearXNG",
     category: "service",
+    group: "Web Search",
     hint: "Self-hosted meta-search engine \xB7 searxng.org",
     fields: [
       {
@@ -1164,7 +1577,7 @@ var messages_exports = {};
 __export(messages_exports, {
   drainUnreadForAgent: () => drainUnreadForAgent,
   findReplies: () => findReplies,
-  get: () => get4,
+  get: () => get5,
   listInbox: () => listInbox,
   listRecipientsWithUnread: () => listRecipientsWithUnread,
   markRead: () => markRead,
@@ -1200,7 +1613,7 @@ function send(db, input) {
     readAt: null
   };
 }
-function get4(db, id) {
+function get5(db, id) {
   const row = db.raw.query("SELECT * FROM messages WHERE id = ?").get(id);
   return row ? toMessage(row) : null;
 }
@@ -1338,9 +1751,9 @@ function openSecrets(db, password) {
 // ../daemon/src/core/repos/skillMeta.ts
 var skillMeta_exports = {};
 __export(skillMeta_exports, {
-  get: () => get5,
+  get: () => get6,
   listAll: () => listAll2,
-  remove: () => remove5,
+  remove: () => remove6,
   upsert: () => upsert
 });
 function toMeta(r) {
@@ -1350,7 +1763,7 @@ function toMeta(r) {
     importedAt: r.imported_at
   };
 }
-function get5(db, name) {
+function get6(db, name) {
   const row = db.raw.query("SELECT * FROM skill_meta WHERE name = ?").get(name);
   return row ? toMeta(row) : null;
 }
@@ -1358,7 +1771,7 @@ function listAll2(db) {
   return db.raw.query("SELECT * FROM skill_meta ORDER BY name ASC").all().map(toMeta);
 }
 function upsert(db, input) {
-  const existing = get5(db, input.name);
+  const existing = get6(db, input.name);
   const source = input.source !== void 0 ? input.source : existing?.source ?? null;
   const importedAt = input.importedAt !== void 0 ? input.importedAt : existing?.importedAt ?? null;
   db.raw.run(
@@ -1369,19 +1782,19 @@ function upsert(db, input) {
   );
   return { name: input.name, source, importedAt };
 }
-function remove5(db, name) {
+function remove6(db, name) {
   db.raw.run("DELETE FROM skill_meta WHERE name = ?", [name]);
 }
 
 // ../daemon/src/core/repos/triggers.ts
 var triggers_exports = {};
 __export(triggers_exports, {
-  get: () => get6,
-  insert: () => insert4,
+  get: () => get7,
+  insert: () => insert5,
   listEnabled: () => listEnabled2,
   listForAgent: () => listForAgent,
   markFired: () => markFired,
-  remove: () => remove6,
+  remove: () => remove7,
   setEnabled: () => setEnabled2
 });
 import { randomUUID as randomUUID3 } from "crypto";
@@ -1398,7 +1811,7 @@ function toTrigger(r) {
     createdAt: r.created_at
   };
 }
-function insert4(db, input) {
+function insert5(db, input) {
   const id = randomUUID3();
   const now = Date.now();
   const enabled = input.enabled === false ? 0 : 1;
@@ -1420,7 +1833,7 @@ function insert4(db, input) {
     createdAt: now
   };
 }
-function get6(db, id) {
+function get7(db, id) {
   const row = db.raw.query("SELECT * FROM agent_triggers WHERE id = ?").get(id);
   return row ? toTrigger(row) : null;
 }
@@ -1443,7 +1856,7 @@ function setEnabled2(db, id, enabled) {
 function markFired(db, id, when = Date.now()) {
   db.raw.run("UPDATE agent_triggers SET last_fired_at = ? WHERE id = ?", [when, id]);
 }
-function remove6(db, id) {
+function remove7(db, id) {
   db.raw.run("DELETE FROM agent_triggers WHERE id = ?", [id]);
 }
 
@@ -1452,9 +1865,9 @@ var webTokens_exports = {};
 __export(webTokens_exports, {
   create: () => create,
   findActiveByToken: () => findActiveByToken,
-  get: () => get7,
+  get: () => get8,
   hashToken: () => hashToken,
-  list: () => list5,
+  list: () => list6,
   markUsed: () => markUsed,
   revoke: () => revoke
 });
@@ -1486,11 +1899,11 @@ function create(db, label) {
     meta: { id, label, createdAt: now, lastUsedAt: null, revokedAt: null }
   };
 }
-function list5(db, opts) {
+function list6(db, opts) {
   const sql = opts?.includeRevoked ? "SELECT * FROM web_tokens ORDER BY created_at ASC" : "SELECT * FROM web_tokens WHERE revoked_at IS NULL ORDER BY created_at ASC";
   return db.raw.query(sql).all().map(toToken);
 }
-function get7(db, id) {
+function get8(db, id) {
   const row = db.raw.query("SELECT * FROM web_tokens WHERE id = ?").get(id);
   return row ? toToken(row) : null;
 }
@@ -1516,7 +1929,9 @@ function revoke(db, id, when = Date.now()) {
 import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
 function readAuthFile(authFile) {
   if (!existsSync6(authFile)) {
-    throw new Error(`${authFile} not found. Start the daemon (\`bazilion serve\`) \u2014 it auto-bootstraps on first run.`);
+    throw new Error(
+      `${authFile} not found. Start the daemon (\`bazilion serve\`) \u2014 it auto-bootstraps on first run.`
+    );
   }
   const raw = readFileSync4(authFile, "utf8");
   const parsed = JSON.parse(raw);
@@ -1543,7 +1958,7 @@ function mergeSecretsIntoEnv(db, password, env = process.env) {
 }
 
 // ../daemon/src/core/skills/import.ts
-import { cpSync, existsSync as existsSync7, mkdtempSync, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync2 } from "fs";
+import { cpSync, existsSync as existsSync7, mkdtempSync, readdirSync as readdirSync4, rmSync as rmSync5, 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";
@@ -1599,11 +2014,11 @@ function extractZipSafely(zipPath) {
     }
     zip.extractAllTo(root, true);
   } catch (err) {
-    rmSync3(root, { recursive: true, force: true });
+    rmSync5(root, { recursive: true, force: true });
     throw err;
   }
   let effectiveSource = root;
-  const topEntries = readdirSync3(root, { withFileTypes: true });
+  const topEntries = readdirSync4(root, { withFileTypes: true });
   if (topEntries.length === 1 && topEntries[0]?.isDirectory()) {
     effectiveSource = join8(root, topEntries[0].name);
   }
@@ -1630,7 +2045,7 @@ function importSkills(paths, input) {
   try {
     return importSkillsFromDir(paths, source, input);
   } finally {
-    if (tempRoot) rmSync3(tempRoot, { recursive: true, force: true });
+    if (tempRoot) rmSync5(tempRoot, { recursive: true, force: true });
   }
 }
 function importSkillsFromDir(paths, source, input) {
@@ -1638,7 +2053,7 @@ function importSkillsFromDir(paths, source, input) {
   if (existsSync7(join8(source, "SKILL.md"))) {
     candidates.push({ name: basename(source), dir: source });
   } else {
-    const entries = readdirSync3(source, { withFileTypes: true });
+    const entries = readdirSync4(source, { withFileTypes: true });
     for (const e of entries) {
       if (!e.isDirectory()) continue;
       const skillDir = join8(source, e.name);
@@ -1724,7 +2139,7 @@ function isActiveAgent(agentId) {
 }
 
 // ../daemon/src/runtime/auth/openai-codex.ts
-import { loginOpenAICodex, refreshOpenAICodexToken } from "@mariozechner/pi-ai/oauth";
+import { loginOpenAICodex, refreshOpenAICodexToken } from "@earendil-works/pi-ai/oauth";
 var OPENAI_CODEX_SECRET_KEY = "OPENAI_CODEX_OAUTH";
 var REFRESH_MARGIN_MS = 6e4;
 function readCredentials(db, authToken) {
@@ -1800,9 +2215,9 @@ var DEFAULT_HEARTBEAT_EVERY_SEC = 30 * 60;
 import {
   existsSync as existsSync8,
   mkdirSync as mkdirSync4,
-  readdirSync as readdirSync4,
+  readdirSync as readdirSync5,
   readFileSync as readFileSync6,
-  rmSync as rmSync4,
+  rmSync as rmSync6,
   statSync as statSync3,
   writeFileSync as writeFileSync4
 } from "fs";
@@ -1812,9 +2227,9 @@ import { dirname as dirname2, join as join9 } from "path";
 import {
   existsSync as existsSync9,
   mkdirSync as mkdirSync5,
-  readdirSync as readdirSync5,
+  readdirSync as readdirSync6,
   readFileSync as readFileSync7,
-  rmSync as rmSync5,
+  rmSync as rmSync7,
   statSync as statSync4,
   writeFileSync as writeFileSync5
 } from "fs";
@@ -1847,7 +2262,7 @@ function safeKey(root, key) {
 }
 function walkMd(dir, prefix, out) {
   if (!existsSync9(dir)) return;
-  for (const e of readdirSync5(dir, { withFileTypes: true })) {
+  for (const e of readdirSync6(dir, { withFileTypes: true })) {
     if (e.name.startsWith(".")) continue;
     const full = join10(dir, e.name);
     const key = prefix ? `${prefix}/${e.name}` : e.name;
@@ -1922,7 +2337,7 @@ function qmdBackend(root) {
     },
     async remove(key) {
       const path = safeKey(root, key);
-      if (existsSync9(path)) rmSync5(path);
+      if (existsSync9(path)) rmSync7(path);
       const store = await getStore(root);
       await store.update();
     }
@@ -1990,7 +2405,7 @@ function piMessagesToProviderView(messages) {
 }
 
 // ../daemon/src/runtime/pi/session.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readdirSync as readdirSync8, statSync as statSync6 } from "fs";
 import { basename as basename2, join as join14 } from "path";
 import {
   AuthStorage,
@@ -1999,14 +2414,14 @@ import {
   ModelRegistry,
   SessionManager,
   SettingsManager
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 
 // ../daemon/src/runtime/providers/pi-adapter.ts
 import {
   getModel,
   streamSimple,
   Type
-} from "@mariozechner/pi-ai";
+} from "@earendil-works/pi-ai";
 function defaultBaseUrlFor(providerName) {
   switch (providerName) {
     case "lmstudio":
@@ -2343,6 +2758,10 @@ function loadProviderConfigFromEnv(env = process.env, oauth) {
     ollama: {
       ...env.OLLAMA_URL !== void 0 ? { baseURL: env.OLLAMA_URL } : {},
       ...env.OLLAMA_API_KEY !== void 0 ? { apiKey: env.OLLAMA_API_KEY } : {}
+    },
+    llamacpp: {
+      ...env.LLAMACPP_URL !== void 0 ? { baseURL: env.LLAMACPP_URL } : {},
+      ...env.LLAMACPP_API_KEY !== void 0 ? { apiKey: env.LLAMACPP_API_KEY } : {}
     }
   };
   if (env.ANTHROPIC_API_KEY || env.ANTHROPIC_OAUTH_TOKEN) {
@@ -2365,6 +2784,28 @@ function loadProviderConfigFromEnv(env = process.env, oauth) {
   if (env.HF_TOKEN) config.huggingface = { apiKey: env.HF_TOKEN };
   if (env.OPENROUTER_API_KEY) config.openrouter = { apiKey: env.OPENROUTER_API_KEY };
   if (env.AI_GATEWAY_API_KEY) config.vercelAiGateway = { apiKey: env.AI_GATEWAY_API_KEY };
+  if (env.DEEPSEEK_API_KEY) config.deepseek = { apiKey: env.DEEPSEEK_API_KEY };
+  if (env.FIREWORKS_API_KEY) config.fireworks = { apiKey: env.FIREWORKS_API_KEY };
+  if (env.TOGETHER_API_KEY) config.together = { apiKey: env.TOGETHER_API_KEY };
+  if (env.MOONSHOT_API_KEY) config.moonshotai = { apiKey: env.MOONSHOT_API_KEY };
+  if (env.KIMI_API_KEY) config.kimiCoding = { apiKey: env.KIMI_API_KEY };
+  if (env.MINIMAX_API_KEY) config.minimax = { apiKey: env.MINIMAX_API_KEY };
+  if (env.XIAOMI_API_KEY) config.xiaomi = { apiKey: env.XIAOMI_API_KEY };
+  if (env.OPENCODE_API_KEY) config.opencode = { apiKey: env.OPENCODE_API_KEY };
+  if (env.COPILOT_GITHUB_TOKEN) config.githubCopilot = { apiKey: env.COPILOT_GITHUB_TOKEN };
+  if (env.CLOUDFLARE_API_KEY && env.CLOUDFLARE_ACCOUNT_ID) {
+    config.cloudflareWorkersAi = {
+      apiKey: env.CLOUDFLARE_API_KEY,
+      accountId: env.CLOUDFLARE_ACCOUNT_ID
+    };
+    if (env.CLOUDFLARE_GATEWAY_ID) {
+      config.cloudflareAiGateway = {
+        apiKey: env.CLOUDFLARE_API_KEY,
+        accountId: env.CLOUDFLARE_ACCOUNT_ID,
+        gatewayId: env.CLOUDFLARE_GATEWAY_ID
+      };
+    }
+  }
   if (oauth && hasCredentials(oauth.db, oauth.authToken)) {
     config.openaiCodex = oauth;
   }
@@ -2523,6 +2964,113 @@ var PROVIDERS = {
     }),
     hint: "AI_GATEWAY_API_KEY"
   },
+  deepseek: {
+    configured: (c) => !!c.deepseek,
+    build: (c) => piProvider({
+      providerName: "deepseek",
+      fallbackApi: "openai-completions",
+      apiKey: c.deepseek?.apiKey,
+      baseUrl: c.deepseek?.baseURL
+    }),
+    hint: "DEEPSEEK_API_KEY"
+  },
+  fireworks: {
+    configured: (c) => !!c.fireworks,
+    build: (c) => piProvider({
+      providerName: "fireworks",
+      fallbackApi: "anthropic-messages",
+      apiKey: c.fireworks?.apiKey,
+      baseUrl: c.fireworks?.baseURL
+    }),
+    hint: "FIREWORKS_API_KEY"
+  },
+  together: {
+    configured: (c) => !!c.together,
+    build: (c) => piProvider({
+      providerName: "together",
+      fallbackApi: "openai-completions",
+      apiKey: c.together?.apiKey,
+      baseUrl: c.together?.baseURL
+    }),
+    hint: "TOGETHER_API_KEY"
+  },
+  moonshotai: {
+    configured: (c) => !!c.moonshotai,
+    build: (c) => piProvider({
+      providerName: "moonshotai",
+      fallbackApi: "openai-completions",
+      apiKey: c.moonshotai?.apiKey,
+      baseUrl: c.moonshotai?.baseURL
+    }),
+    hint: "MOONSHOT_API_KEY"
+  },
+  "kimi-coding": {
+    configured: (c) => !!c.kimiCoding,
+    build: (c) => piProvider({
+      providerName: "kimi-coding",
+      fallbackApi: "anthropic-messages",
+      apiKey: c.kimiCoding?.apiKey,
+      baseUrl: c.kimiCoding?.baseURL
+    }),
+    hint: "KIMI_API_KEY"
+  },
+  minimax: {
+    configured: (c) => !!c.minimax,
+    build: (c) => piProvider({
+      providerName: "minimax",
+      fallbackApi: "anthropic-messages",
+      apiKey: c.minimax?.apiKey,
+      baseUrl: c.minimax?.baseURL
+    }),
+    hint: "MINIMAX_API_KEY"
+  },
+  xiaomi: {
+    configured: (c) => !!c.xiaomi,
+    build: (c) => piProvider({
+      providerName: "xiaomi",
+      fallbackApi: "openai-completions",
+      apiKey: c.xiaomi?.apiKey,
+      baseUrl: c.xiaomi?.baseURL
+    }),
+    hint: "XIAOMI_API_KEY"
+  },
+  opencode: {
+    configured: (c) => !!c.opencode,
+    build: (c) => piProvider({
+      providerName: "opencode",
+      fallbackApi: "openai-completions",
+      apiKey: c.opencode?.apiKey,
+      baseUrl: c.opencode?.baseURL
+    }),
+    hint: "OPENCODE_API_KEY"
+  },
+  "github-copilot": {
+    configured: (c) => !!c.githubCopilot,
+    build: (c) => piProvider({
+      providerName: "github-copilot",
+      fallbackApi: "anthropic-messages",
+      apiKey: c.githubCopilot?.apiKey
+    }),
+    hint: "COPILOT_GITHUB_TOKEN (generic GH_TOKEN/GITHUB_TOKEN are ignored)"
+  },
+  "cloudflare-ai-gateway": {
+    configured: (c) => !!c.cloudflareAiGateway,
+    build: (c) => piProvider({
+      providerName: "cloudflare-ai-gateway",
+      fallbackApi: "anthropic-messages",
+      apiKey: c.cloudflareAiGateway?.apiKey
+    }),
+    hint: "CLOUDFLARE_API_KEY + CLOUDFLARE_ACCOUNT_ID + CLOUDFLARE_GATEWAY_ID"
+  },
+  "cloudflare-workers-ai": {
+    configured: (c) => !!c.cloudflareWorkersAi,
+    build: (c) => piProvider({
+      providerName: "cloudflare-workers-ai",
+      fallbackApi: "openai-completions",
+      apiKey: c.cloudflareWorkersAi?.apiKey
+    }),
+    hint: "CLOUDFLARE_API_KEY + CLOUDFLARE_ACCOUNT_ID"
+  },
   lmstudio: {
     configured: () => true,
     build: (c) => piProvider({
@@ -2542,12 +3090,26 @@ var PROVIDERS = {
       baseUrl: c.ollama?.baseURL ?? "http://127.0.0.1:11434/v1"
     }),
     hint: "OLLAMA_URL (default http://127.0.0.1:11434/v1)"
+  },
+  llamacpp: {
+    // Like lmstudio/ollama, always considered "configured" — the daemon
+    // can't tell if llama-server is actually running until a request hits
+    // it. Falls back to the documented default port + a placeholder
+    // apiKey (llama-server ignores it unless --api-key was passed).
+    configured: () => true,
+    build: (c) => piProvider({
+      providerName: "llamacpp",
+      fallbackApi: "openai-completions",
+      apiKey: c.llamacpp?.apiKey ?? "no-key",
+      baseUrl: c.llamacpp?.baseURL ?? "http://127.0.0.1:8080/v1"
+    }),
+    hint: "LLAMACPP_URL (default http://127.0.0.1:8080/v1)"
   }
 };
 function createProviderRegistry(config, opts = {}) {
   const cache = /* @__PURE__ */ new Map();
   const enabledSet = opts.enabledSet;
-  function get8(name) {
+  function get9(name) {
     const cached = cache.get(name);
     if (cached) return cached;
     const entry = PROVIDERS[name];
@@ -2579,7 +3141,7 @@ function createProviderRegistry(config, opts = {}) {
       }
       const providerName = modelString.slice(0, idx);
       const model = modelString.slice(idx + 1);
-      return { provider: get8(providerName), model };
+      return { provider: get9(providerName), model };
     },
     list() {
       return Object.entries(PROVIDERS).filter(([name, entry]) => {
@@ -2606,13 +3168,11 @@ var CONTEXT_FILE_ORDER = [
   "SOUL.md",
   "TOOLS.md",
   "IDENTITY.md",
-  "HEARTBEAT.md",
-  "BOOTSTRAP.md"
+  "HEARTBEAT.md"
 ];
 function buildSystemPrompt(agent) {
   const parts = [];
   const contextBlocks = [];
-  let bootstrapPresent = false;
   for (const file of CONTEXT_FILE_ORDER) {
     const path = join11(agent.agent.dir, file);
     if (!existsSync10(path)) continue;
@@ -2621,23 +3181,39 @@ function buildSystemPrompt(agent) {
     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."
-    );
+  const bootstrapPath = join11(agent.agent.dir, "BOOTSTRAP.md");
+  if (existsSync10(bootstrapPath)) {
+    const bootstrap2 = readFileSync8(bootstrapPath, "utf8").trimEnd();
+    if (bootstrap2) {
+      parts.push(
+        [
+          "# First-Run Ritual",
+          "",
+          "This is your first session. The document below is **conversational guidance**, not a checklist to execute in one shot. It describes a multi-turn Q&A you should have with the human, one question per turn.",
+          "",
+          "## Hard rules",
+          "- Your first reply is ONLY a greeting + ONE question. No tool calls. Wait for the human to answer.",
+          "- Each subsequent turn: at most one new question. Wait between turns.",
+          "- Only after the ritual is complete (you have enough to write IDENTITY.md): call `home_write` once, then `bootstrap_done`.",
+          "",
+          "## BOOTSTRAP.md",
+          "",
+          bootstrap2
+        ].join("\n")
+      );
+    }
   }
   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.",
+      "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) live in this home, plus BOOTSTRAP.md when you are still in your first-run ritual.",
       "",
       "- 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`.",
@@ -2664,13 +3240,19 @@ You have access to the following skills: ${agent.skills.join(", ")}.`
     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.
+Shared context about the human you're working with in this group. Both you and the human curate it. To update: call \`user_md_get\` (returns current content + an etag), merge your change into the full text, then call \`user_md_write\` with the merged content and the etag. Use this for STABLE user-specific facts (preferences, role, working hours, how they like to be addressed) \u2014 and to CORRECT stale entries when the human tells you something different from what's recorded. For project knowledge use \`memory_write\` instead; for personal notes about yourself use \`home_write\` on IDENTITY.md. **Do NOT send peer messages announcing USER.md changes \u2014 every agent in the group sees the new content in their system prompt on their next turn automatically.**
 
 ${agent.group.userMd.trim()}`
     );
+  } else {
+    parts.push(
+      `# About the User
+
+This group's USER.md is empty. As you learn STABLE facts about the human (preferences, role, working hours, how they like to be addressed), populate it via \`user_md_get\` then \`user_md_write\` (always get first \u2014 you need the etag). Reserve this for things you're confident are durable \u2014 project knowledge belongs in \`memory_write\`, personal notes about yourself in \`home_write\` on IDENTITY.md. **Do NOT send peer messages announcing USER.md changes \u2014 every agent in the group sees the new content in their system prompt on their next turn automatically.**`
+    );
   }
   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."
+    "# 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. **Do NOT send peer messages announcing memory writes \u2014 every agent has access to the same store via `memory_search` and will find your note when they need it.**"
   );
   return parts.join("\n\n---\n\n");
 }
@@ -2679,7 +3261,7 @@ ${agent.group.userMd.trim()}`
 import { Type as Type2 } from "typebox";
 
 // ../daemon/src/runtime/tools/bootstrap.ts
-import { existsSync as existsSync11, rmSync as rmSync6 } from "fs";
+import { existsSync as existsSync11, rmSync as rmSync8 } from "fs";
 import { join as join12 } from "path";
 function bootstrapTool(agentDir) {
   return {
@@ -2691,7 +3273,7 @@ function bootstrapTool(agentDir) {
     async invoke() {
       const path = join12(agentDir, "BOOTSTRAP.md");
       if (existsSync11(path)) {
-        rmSync6(path);
+        rmSync8(path);
         return "BOOTSTRAP.md removed. Bootstrap is complete.";
       }
       return "BOOTSTRAP.md was already removed.";
@@ -2700,7 +3282,7 @@ function bootstrapTool(agentDir) {
 }
 
 // ../daemon/src/runtime/tools/home.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync9, statSync as statSync5, writeFileSync as writeFileSync6 } from "fs";
+import { readdirSync as readdirSync7, readFileSync as readFileSync9, statSync as statSync5, writeFileSync as writeFileSync6 } from "fs";
 import { join as join13 } from "path";
 var HOME_FILES_READABLE = [
   "IDENTITY.md",
@@ -2792,7 +3374,7 @@ function homeTools(agentDir) {
         if (entries.length === 0) {
           const dirEntries = (() => {
             try {
-              return readdirSync6(agentDir);
+              return readdirSync7(agentDir);
             } catch {
               return [];
             }
@@ -2811,7 +3393,7 @@ function memoryTools(memory) {
     {
       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".',
+        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. For STABLE facts about the human you\'re working with (their preferences, role, working hours, how they like to be addressed) use `user_md_get` then `user_md_write` \u2014 those land in every agent\'s system prompt directly. Key is a path-like string with a markdown extension, e.g. "auth-flow.md" or "decisions/2026-05-migration.md".',
         parameters: {
           type: "object",
           properties: {
@@ -2897,7 +3479,7 @@ function messagingTools(host2, fromAgentId) {
     {
       def: {
         name: "send_message",
-        description: "Send a message to another agent. Use the recipient's agent id (UUID).",
+        description: `Send a message to another agent. Use the recipient's agent id (UUID). Use this ONLY for things the recipient needs to ACT on: delegating a task, asking a peer for information you cannot get yourself, escalating a decision. Do NOT use it for status updates or to announce changes to group-shared resources \u2014 USER.md and the group memory backend both propagate to every agent in the group automatically on their next turn, so messages like "I updated USER.md" or "I wrote a new memory note" are pure noise and will trigger an inbox-wake loop on the recipient.`,
         parameters: {
           type: "object",
           properties: {
@@ -3001,6 +3583,64 @@ function messagingTools(host2, fromAgentId) {
   ];
 }
 
+// ../daemon/src/runtime/tools/user-md.ts
+function userMdTools(host2, groupId) {
+  return [
+    {
+      def: {
+        name: "user_md_get",
+        description: "Read the group-shared USER.md (facts every agent in the group knows about the human). Returns the current content followed by an `etag:` line \u2014 you MUST pass that etag back as `if_match` on the next `user_md_write` so the daemon can detect concurrent edits by other agents in the group. Always call this immediately before any `user_md_write`.",
+        parameters: {
+          type: "object",
+          properties: {}
+        }
+      },
+      async invoke() {
+        const { content, etag } = await host2.get(groupId);
+        const body = content.length > 0 ? content : "(USER.md is empty)";
+        return `${body}
+
+---
+etag: ${etag}`;
+      }
+    },
+    {
+      def: {
+        name: "user_md_write",
+        description: "Replace the group-shared USER.md with new content. Use this for STABLE user-specific facts (preferences, role, working hours, how the human likes to be addressed). MANDATORY workflow: (1) call `user_md_get` first, (2) integrate your change into the full content preserving everything unrelated, (3) call `user_md_write` with the merged content and the etag you got from `user_md_get`. If another agent in the group wrote to USER.md between your get and write, this returns an etag-mismatch error \u2014 just call `user_md_get` again and retry the merge. The full result must fit under 12 KB. For project knowledge use `memory_write`; for notes about yourself use `home_write` on IDENTITY.md.",
+        parameters: {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "Full new contents of USER.md (this is a complete replacement, NOT an append). Include everything you want to keep."
+            },
+            if_match: {
+              type: "string",
+              description: "The etag returned by your most recent `user_md_get`. The write fails if USER.md changed in the meantime."
+            }
+          },
+          required: ["content", "if_match"]
+        }
+      },
+      async invoke(args) {
+        const content = String(args.content ?? "");
+        const ifMatch = String(args.if_match ?? "");
+        if (!ifMatch) {
+          throw new Error(
+            'user_md_write: "if_match" is required \u2014 call user_md_get first to obtain the current etag.'
+          );
+        }
+        const { etag, totalBytes } = await host2.write(groupId, content, ifMatch);
+        return `wrote USER.md (${totalBytes} bytes, new etag: ${etag})`;
+      }
+    }
+  ];
+}
+
+// ../daemon/src/runtime/tools/web.ts
+import { fetch as undiciFetch2 } from "undici";
+
 // ../daemon/src/runtime/tools/web-extract.ts
 import { Readability } from "@mozilla/readability";
 import { parseHTML } from "linkedom";
@@ -3081,7 +3721,7 @@ function extractReadable(html, url, mode) {
 // ../daemon/src/runtime/tools/web-ssrf.ts
 import { lookup as dnsLookupCb } from "dns";
 import { lookup as dnsLookup } from "dns/promises";
-import { Agent } from "undici";
+import { Agent, fetch as undiciFetch } from "undici";
 var SsrFBlockedError = class extends Error {
   constructor(message) {
     super(message);
@@ -3190,7 +3830,7 @@ async function closeDispatcher(d) {
   }
 }
 async function guardedFetch(opts) {
-  const fetcher = opts.fetchImpl ?? globalThis.fetch;
+  const fetcher = opts.fetchImpl ?? undiciFetch;
   const maxRedirects = opts.maxRedirects ?? 3;
   const abortController = new AbortController();
   const timeoutId = opts.timeoutMs ? setTimeout(() => abortController.abort(new Error("timeout")), opts.timeoutMs) : null;
@@ -3271,7 +3911,10 @@ var DEFAULT_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7_2) AppleWe
 var DEFAULT_CACHE_TTL_MS = 15 * 6e4;
 var DEFAULT_CACHE_MAX = 100;
 var DEFAULT_MAX_LENGTH = 2e4;
-var DEFAULT_TIMEOUT_MS = 2e4;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_BODY_BYTES = 3 * 1024 * 1024;
+var FIRECRAWL_FALLBACK_THRESHOLD = 200;
+var FIRECRAWL_DEFAULT_URL = "https://api.firecrawl.dev";
 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();
 }
@@ -3305,6 +3948,92 @@ async function searxngSearch(query, limit, baseURL, fetchFn) {
     snippet: r.content ?? ""
   }));
 }
+function describeError(err) {
+  if (!(err instanceof Error)) return String(err);
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set();
+  let cur = err;
+  while (cur instanceof Error && !seen.has(cur)) {
+    seen.add(cur);
+    const code = cur.code;
+    parts.push(code ? `[${code}] ${cur.message}` : cur.message);
+    cur = cur.cause;
+  }
+  return parts.join(" \u2014 cause: ");
+}
+async function readBodyCapped(res, maxBytes) {
+  const ct = res.headers.get("content-type") ?? "";
+  const charset = /charset=([^;]+)/i.exec(ct)?.[1]?.trim().toLowerCase() || "utf-8";
+  const decoder = new TextDecoder(charset, { fatal: false });
+  const reader = res.body?.getReader();
+  if (!reader) {
+    const text = await res.text();
+    if (text.length > maxBytes) return { text: text.slice(0, maxBytes), truncated: true };
+    return { text, truncated: false };
+  }
+  const chunks = [];
+  let total = 0;
+  let truncated = false;
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    if (total + value.byteLength > maxBytes) {
+      const keep = maxBytes - total;
+      if (keep > 0) chunks.push(value.subarray(0, keep));
+      truncated = true;
+      try {
+        await reader.cancel();
+      } catch {
+      }
+      break;
+    }
+    chunks.push(value);
+    total += value.byteLength;
+  }
+  const sum = chunks.reduce((s, c) => s + c.byteLength, 0);
+  const merged = new Uint8Array(sum);
+  let off = 0;
+  for (const c of chunks) {
+    merged.set(c, off);
+    off += c.byteLength;
+  }
+  return { text: decoder.decode(merged), truncated };
+}
+async function firecrawlScrape(url, mode, env, fetchFn, timeoutMs) {
+  const apiKey = env.FIRECRAWL_API_KEY;
+  if (!apiKey) return null;
+  const base = (env.FIRECRAWL_URL ?? FIRECRAWL_DEFAULT_URL).replace(/\/$/, "");
+  const ac = new AbortController();
+  const t = setTimeout(() => ac.abort(new Error("firecrawl timeout")), timeoutMs);
+  try {
+    const res = await fetchFn(`${base}/v1/scrape`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`,
+        accept: "application/json"
+      },
+      body: JSON.stringify({
+        url,
+        formats: ["markdown"],
+        onlyMainContent: true
+      }),
+      signal: ac.signal
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    if (!body.success || !body.data?.markdown) return null;
+    const md = body.data.markdown;
+    const title = body.data.metadata?.title;
+    const text = mode === "text" ? markdownToPlain(md) : md;
+    return title ? { text, title } : { text };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(t);
+  }
+}
 function cacheGet(cache, key) {
   const entry = cache.get(key);
   if (!entry) return null;
@@ -3325,12 +4054,14 @@ function cacheSet(cache, key, value, ttlMs, maxEntries) {
   }
 }
 function webTools(opts) {
-  const fetchFn = opts?.fetchImpl ?? fetch;
+  const fetchFn = opts?.fetchImpl ?? undiciFetch2;
   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 maxBodyBytes = opts?.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+  const firecrawlDisabled = opts?.firecrawlDisabled ?? false;
   const cache = /* @__PURE__ */ new Map();
   return [
     {
@@ -3368,7 +4099,7 @@ function webTools(opts) {
     {
       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.",
+        description: "Fetch a URL and return its readable content. HTML is extracted via Readability and converted to markdown. When the primary extraction returns near-empty content from a 2xx HTML page (typical of JS-only shells), the tool automatically retries via Firecrawl if FIRECRAWL_API_KEY is configured. Results are cached for 15 minutes.",
         parameters: {
           type: "object",
           properties: {
@@ -3394,7 +4125,7 @@ function webTools(opts) {
         const cacheKey = `${mode}|${url}`;
         const cached = cacheGet(cache, cacheKey);
         if (cached) return formatOutput(cached, maxLen);
-        let result;
+        let result = null;
         try {
           result = await guardedFetch({
             url,
@@ -3409,18 +4140,14 @@ function webTools(opts) {
               }
             }
           });
-        } 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}`);
+            throw new Error(`${result.response.status} ${result.response.statusText}`);
           }
           const ct = result.response.headers.get("content-type") ?? "";
-          const body = await result.response.text();
+          const isHtml = ct.includes("text/html") || ct.includes("xhtml");
+          const { text: body, truncated } = await readBodyCapped(result.response, maxBodyBytes);
           let extracted;
-          if (ct.includes("text/html") || ct.includes("xhtml")) {
+          if (isHtml) {
             extracted = extractReadable(body, result.finalUrl, mode);
           } else if (ct.includes("application/json")) {
             try {
@@ -3431,10 +4158,32 @@ function webTools(opts) {
           } else {
             extracted = { text: body };
           }
+          if (isHtml && !firecrawlDisabled && extracted.text.length < FIRECRAWL_FALLBACK_THRESHOLD) {
+            const rescued = await firecrawlScrape(result.finalUrl, mode, env, fetchFn, timeoutMs);
+            if (rescued) {
+              extracted = {
+                ...rescued,
+                text: `${rescued.text}
+
+[content rendered via Firecrawl fallback \u2014 primary extraction returned ${extracted.text.length} chars]`
+              };
+            }
+          }
+          if (truncated) {
+            extracted = {
+              ...extracted,
+              text: `${extracted.text}
+
+[raw body truncated at ${maxBodyBytes} bytes before extraction \u2014 page exceeded the size cap]`
+            };
+          }
           cacheSet(cache, cacheKey, extracted, cacheTtlMs, cacheMax);
           return formatOutput(extracted, maxLen);
+        } catch (err) {
+          if (err instanceof SsrFBlockedError) throw new Error(`web_fetch: ${err.message}`);
+          throw new Error(`web_fetch: ${describeError(err)}`);
         } finally {
-          await result.release();
+          if (result) await result.release();
         }
       }
     }
@@ -3481,13 +4230,16 @@ function createBazilionCustomTools(opts) {
   if (opts.messagingHost) {
     handlers.push(...messagingTools(opts.messagingHost, opts.agent.agent.id));
   }
+  if (opts.userMdHost) {
+    handlers.push(...userMdTools(opts.userMdHost, opts.agent.group.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 { agent, paths, env, memory, enabledProviders, messagingHost, userMdHost, 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`);
@@ -3524,12 +4276,17 @@ async function createBazilionSession(opts) {
   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 }
+    retry: {
+      enabled: true,
+      maxRetries: 2,
+      baseDelayMs: 500,
+      provider: { maxRetryDelayMs: 8e3 }
+    }
   });
   const bazilionPrompt = buildSystemPrompt(agent);
   const resourceLoader = createBazilionResourceLoader(bazilionPrompt);
   await resourceLoader.reload();
-  const customTools = createBazilionCustomTools({ agent, memory, messagingHost, env });
+  const customTools = createBazilionCustomTools({ agent, memory, messagingHost, userMdHost, env });
   const allowedTools = [...BUILTIN_TOOL_NAMES, ...customTools.map((t) => t.name)];
   const { session } = await createAgentSession({
     cwd,
@@ -3692,7 +4449,7 @@ function loadSessionHead(agent, paths) {
 function findMostRecent(sessionDir) {
   if (!existsSync12(sessionDir)) return null;
   let newest = null;
-  for (const entry of readdirSync7(sessionDir)) {
+  for (const entry of readdirSync8(sessionDir)) {
     if (!entry.endsWith(".jsonl")) continue;
     const path = join14(sessionDir, entry);
     try {
@@ -3705,7 +4462,8 @@ function findMostRecent(sessionDir) {
 }
 
 // ../daemon/src/runtime/providers/catalog.ts
-import { getModels as piGetModels } from "@mariozechner/pi-ai";
+import { getModels as piGetModels } from "@earendil-works/pi-ai";
+import { fetch as undiciFetch3 } from "undici";
 var REGISTRY_TO_PI = {
   bedrock: "amazon-bedrock",
   "azure-openai": "azure-openai-responses"
@@ -3716,6 +4474,8 @@ function liveEndpointFor(providerName, env) {
       return env.LMSTUDIO_URL ?? "http://127.0.0.1:1234/v1";
     case "ollama":
       return env.OLLAMA_URL ?? "http://127.0.0.1:11434/v1";
+    case "llamacpp":
+      return env.LLAMACPP_URL ?? "http://127.0.0.1:8080/v1";
     case "openrouter":
       return "https://openrouter.ai/api/v1";
     case "vercel-ai-gateway":
@@ -3746,7 +4506,7 @@ async function fetchModelsFrom(baseURL, apiKey, signal) {
   try {
     const headers = { accept: "application/json" };
     if (apiKey) headers.authorization = `Bearer ${apiKey}`;
-    const res = await fetch(`${baseURL.replace(/\/$/, "")}/models`, { headers, signal });
+    const res = await undiciFetch3(`${baseURL.replace(/\/$/, "")}/models`, { headers, signal });
     if (!res.ok) return { models: [], error: `${res.status} ${res.statusText}` };
     const body = await res.json();
     const ids = (body?.data ?? []).map((m) => m.id).filter((id) => !!id);
@@ -3819,7 +4579,9 @@ async function* spawnWorkerTurn(spec, opts = {}) {
     env: opts.env ?? process.env,
     stdio: ["pipe", "pipe", "inherit", "ipc"]
   });
-  if (opts.messagingHost) attachIpcHandler(child, opts.messagingHost);
+  if (opts.messagingHost || opts.userMdHost) {
+    attachIpcHandler(child, opts.messagingHost, opts.userMdHost);
+  }
   child.stdin?.write(JSON.stringify(spec));
   child.stdin?.end();
   const grace = opts.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
@@ -3899,10 +4661,10 @@ function parseFrame(line) {
     return { kind: "fatal", error: `worker emitted malformed frame: ${line.slice(0, 200)}` };
   }
 }
-function attachIpcHandler(child, host2) {
+function attachIpcHandler(child, messagingHost, userMdHost) {
   child.on("message", (msg) => {
     if (!isIpcRequest(msg)) return;
-    void dispatch(msg, host2).then((reply) => {
+    void dispatch(msg, messagingHost, userMdHost).then((reply) => {
       try {
         child.send?.(reply);
       } catch {
@@ -3915,25 +4677,48 @@ function isIpcRequest(msg) {
   const m = msg;
   return m.type === "rpc" && typeof m.id === "string" && typeof m.method === "string";
 }
-async function dispatch(req, host2) {
+function requireMessagingHost(host2, method) {
+  if (!host2) throw new Error(`worker called messaging method "${method}" without a messagingHost`);
+  return host2;
+}
+function requireUserMdHost(host2, method) {
+  if (!host2) throw new Error(`worker called user_md method "${method}" without a userMdHost`);
+  return host2;
+}
+async function dispatch(req, messagingHost, userMdHost) {
   try {
     let result;
     switch (req.method) {
       case "agentExists":
-        result = await host2.agentExists(req.args.agentId);
+        result = await requireMessagingHost(messagingHost, req.method).agentExists(req.args.agentId);
         break;
       case "sendMessage":
-        result = await host2.sendMessage(req.args);
+        result = await requireMessagingHost(messagingHost, req.method).sendMessage(req.args);
         break;
       case "listInbox":
-        result = await host2.listInbox(req.args.agentId, { unreadOnly: req.args.unreadOnly });
+        result = await requireMessagingHost(messagingHost, req.method).listInbox(req.args.agentId, {
+          unreadOnly: req.args.unreadOnly
+        });
         break;
       case "markRead":
-        await host2.markRead(req.args.messageId);
+        await requireMessagingHost(messagingHost, req.method).markRead(req.args.messageId);
         result = null;
         break;
       case "findReplies":
-        result = await host2.findReplies(req.args.agentId, req.args.replyTo);
+        result = await requireMessagingHost(messagingHost, req.method).findReplies(
+          req.args.agentId,
+          req.args.replyTo
+        );
+        break;
+      case "userMdGet":
+        result = await requireUserMdHost(userMdHost, req.method).get(req.args.groupId);
+        break;
+      case "userMdWrite":
+        result = await requireUserMdHost(userMdHost, req.method).write(
+          req.args.groupId,
+          req.args.content,
+          req.args.ifMatch
+        );
         break;
     }
     return { type: "rpc-reply", id: req.id, ok: true, result };
@@ -3986,6 +4771,40 @@ function createDbMessagingHost(db) {
   };
 }
 
+// ../daemon/src/lib/user-md-host.ts
+import { createHash as createHash2 } from "crypto";
+var USER_MD_MAX_BYTES = 12e3;
+function computeEtag(content) {
+  return createHash2("sha256").update(content, "utf8").digest("hex").slice(0, 16);
+}
+function createDbUserMdHost(db, paths) {
+  return {
+    get(groupId) {
+      const group = groups_exports.get(db, groupId, paths);
+      if (!group) throw new Error(`group not found: ${groupId}`);
+      return { content: group.userMd, etag: computeEtag(group.userMd) };
+    },
+    write(groupId, content, ifMatch) {
+      const group = groups_exports.get(db, groupId, paths);
+      if (!group) throw new Error(`group not found: ${groupId}`);
+      const currentEtag = computeEtag(group.userMd);
+      if (currentEtag !== ifMatch) {
+        throw new Error(
+          `etag mismatch \u2014 USER.md was updated by another agent. Current etag is ${currentEtag} (you passed ${ifMatch}). Call user_md_get again to re-read, merge your change, and retry.`
+        );
+      }
+      const bytes = Buffer.byteLength(content, "utf8");
+      if (bytes > USER_MD_MAX_BYTES) {
+        throw new Error(
+          `USER.md would exceed the ${USER_MD_MAX_BYTES}-byte cap (you tried to write ${bytes}). Trim your content or ask the human to compact via the web UI.`
+        );
+      }
+      groups_exports.setUserMd(db, groupId, content);
+      return { etag: computeEtag(content), totalBytes: bytes };
+    }
+  };
+}
+
 // ../daemon/src/lib/agent-turn.ts
 async function* runAgentTurn(agentId, message, opts = {}) {
   const { db, paths, authToken } = getCtx();
@@ -3993,13 +4812,14 @@ async function* runAgentTurn(agentId, message, opts = {}) {
   const enabledProviders = Array.from(providerState_exports.listEnabled(db));
   const env = mergeSecretsIntoEnv(db, authToken);
   const messagingHost = createDbMessagingHost(db);
+  const userMdHost = createDbUserMdHost(db, paths);
   const { apiKey } = await resolveAgentApiKey(db, authToken, agent);
   const controller = opts.controller ?? new AbortController();
   registerAgent(agentId, controller);
   try {
     for await (const frame of spawnWorkerTurn(
       { agent, message, enabledProviders, apiKey },
-      { signal: controller.signal, env, messagingHost }
+      { signal: controller.signal, env, messagingHost, userMdHost }
     )) {
       yield frame;
     }
@@ -4345,7 +5165,7 @@ async function authMiddleware(c, next) {
 }
 
 // ../daemon/src/routes/agents.ts
-import { existsSync as existsSync15, readdirSync as readdirSync8, readFileSync as readFileSync10, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync15, readdirSync as readdirSync9, readFileSync as readFileSync10, rmSync as rmSync9 } from "fs";
 import { join as join15 } from "path";
 
 // ../../packages/api-types/src/entities.ts
@@ -4892,10 +5712,10 @@ agentsRouter.post("/:id/chat/reset", (c) => {
   const sessionsDir = join15(paths.agentDir(agent.id), "sessions");
   let deleted = 0;
   if (existsSync15(sessionsDir)) {
-    for (const file of readdirSync8(sessionsDir)) {
+    for (const file of readdirSync9(sessionsDir)) {
       if (!file.endsWith(".jsonl")) continue;
       try {
-        rmSync7(join15(sessionsDir, file));
+        rmSync9(join15(sessionsDir, file));
         deleted++;
       } catch {
       }
@@ -5136,6 +5956,7 @@ configRouter.get("/services", (c) => {
     id: svc.id,
     displayName: svc.displayName,
     ...svc.hint ? { hint: svc.hint } : {},
+    ...svc.group ? { group: svc.group } : {},
     fields: resolveFieldStates(svc, configValues, secretValues)
   }));
   const body = { services };
@@ -5270,7 +6091,7 @@ function knownProviderRegistryNames() {
 // ../daemon/src/routes/groups.ts
 import { join as join16 } from "path";
 import { Hono as Hono4 } from "hono";
-var USER_MD_MAX_BYTES = 12e3;
+var USER_MD_MAX_BYTES2 = 12e3;
 var groupsRouter = new Hono4();
 groupsRouter.get("/", (c) => {
   const { db, paths } = getCtx();
@@ -5309,8 +6130,8 @@ groupsRouter.put("/:id/user-md", async (c) => {
   if (!body || typeof body.userMd !== "string") {
     return c.json({ error: "userMd (string) is required" }, 400);
   }
-  if (Buffer.byteLength(body.userMd, "utf8") > USER_MD_MAX_BYTES) {
-    return c.json({ error: `userMd exceeds ${USER_MD_MAX_BYTES}-byte cap` }, 413);
+  if (Buffer.byteLength(body.userMd, "utf8") > USER_MD_MAX_BYTES2) {
+    return c.json({ error: `userMd exceeds ${USER_MD_MAX_BYTES2}-byte cap` }, 413);
   }
   const { db, paths } = getCtx();
   const g = groups_exports.get(db, c.req.param("id"), paths);
@@ -5586,11 +6407,147 @@ miscRouter.delete("/tokens/:id", (c) => {
   return c.body(null, 204);
 });
 
+// ../daemon/src/routes/profile-groups.ts
+import { Hono as Hono7 } from "hono";
+var profileGroupsRouter = new Hono7();
+profileGroupsRouter.get("/", (c) => {
+  const { db } = getCtx();
+  return c.json(profileGroups_exports.list(db));
+});
+profileGroupsRouter.get("/:id", (c) => {
+  const { db } = getCtx();
+  const id = c.req.param("id");
+  const group = profileGroups_exports.get(db, id);
+  if (!group) return c.json({ error: `profile group not found: ${id}` }, 404);
+  const body = {
+    group,
+    members: profileGroups_exports.members(db, id)
+  };
+  return c.json(body);
+});
+profileGroupsRouter.post("/", async (c) => {
+  const raw = await c.req.json().catch(() => null);
+  if (!raw) return c.json({ error: "invalid JSON body" }, 400);
+  const id = typeof raw.id === "string" ? raw.id : "";
+  if (!id) return c.json({ error: "id is required" }, 400);
+  try {
+    validateSlug(id);
+  } catch (err) {
+    return c.json({ error: err.message }, 400);
+  }
+  const { db } = getCtx();
+  if (profileGroups_exports.get(db, id)) {
+    return c.json({ error: `profile group already exists: ${id}` }, 409);
+  }
+  const name = typeof raw.name === "string" && raw.name.length > 0 ? raw.name : id;
+  const userMd = typeof raw.userMd === "string" ? raw.userMd : null;
+  try {
+    const inserted = profileGroups_exports.insert(db, { id, name, userMd });
+    return c.json(inserted, 201);
+  } catch (err) {
+    return c.json({ error: err.message }, 400);
+  }
+});
+profileGroupsRouter.patch("/:id", async (c) => {
+  const raw = await c.req.json().catch(() => null);
+  if (!raw) return c.json({ error: "invalid JSON body" }, 400);
+  const { db } = getCtx();
+  const id = c.req.param("id");
+  if (!profileGroups_exports.get(db, id)) {
+    return c.json({ error: `profile group not found: ${id}` }, 404);
+  }
+  const patch = {};
+  if (Object.hasOwn(raw, "name") && typeof raw.name === "string") {
+    patch.name = raw.name;
+  }
+  if (Object.hasOwn(raw, "userMd")) {
+    patch.userMd = raw.userMd === null ? null : typeof raw.userMd === "string" ? raw.userMd : null;
+  }
+  profileGroups_exports.update(db, id, patch);
+  return c.json(profileGroups_exports.get(db, id));
+});
+profileGroupsRouter.put("/:id/members", async (c) => {
+  const raw = await c.req.json().catch(() => null);
+  if (!raw || !Array.isArray(raw.members)) {
+    return c.json({ error: "members array is required" }, 400);
+  }
+  const { db } = getCtx();
+  const id = c.req.param("id");
+  if (!profileGroups_exports.get(db, id)) {
+    return c.json({ error: `profile group not found: ${id}` }, 404);
+  }
+  const cleaned = [];
+  const missingProfiles = [];
+  for (let i = 0; i < raw.members.length; i++) {
+    const m = raw.members[i];
+    if (!m || typeof m.profileId !== "string" || typeof m.agentName !== "string") {
+      return c.json({ error: `member ${i}: profileId and agentName are required strings` }, 400);
+    }
+    if (!profiles_exports.get(db, m.profileId)) {
+      missingProfiles.push(m.profileId);
+      continue;
+    }
+    const modelOverride = m.modelOverride === null ? null : typeof m.modelOverride === "string" ? m.modelOverride : null;
+    const reasoningLevel = m.reasoningLevel === null ? null : typeof m.reasoningLevel === "string" && REASONING_LEVELS.includes(m.reasoningLevel) ? m.reasoningLevel : null;
+    cleaned.push({
+      profileId: m.profileId,
+      agentName: m.agentName,
+      modelOverride,
+      reasoningLevel
+    });
+  }
+  if (missingProfiles.length > 0) {
+    return c.json({ error: `missing profiles: ${[...new Set(missingProfiles)].join(", ")}` }, 400);
+  }
+  profileGroups_exports.replaceMembers(db, id, cleaned);
+  return c.json({ members: profileGroups_exports.members(db, id) });
+});
+profileGroupsRouter.delete("/:id", (c) => {
+  const { db } = getCtx();
+  const id = c.req.param("id");
+  if (!profileGroups_exports.get(db, id)) {
+    return c.json({ error: `profile group not found: ${id}` }, 404);
+  }
+  profileGroups_exports.remove(db, id);
+  return c.body(null, 204);
+});
+profileGroupsRouter.post("/:id/spawn", async (c) => {
+  const raw = await c.req.json().catch(() => ({}));
+  const body = raw ?? {};
+  const groupSlug = typeof body.groupSlug === "string" ? body.groupSlug : void 0;
+  const userMd = typeof body.userMd === "string" ? body.userMd : void 0;
+  const { db, paths } = getCtx();
+  const id = c.req.param("id");
+  try {
+    const result = await spawnProfileGroup(db, paths, {
+      profileGroupId: id,
+      groupSlug,
+      userMd
+    });
+    const response = {
+      groupSlug: result.groupSlug,
+      agents: result.agents
+    };
+    if (result.orphanAgentIds.length > 0) response.orphanAgentIds = result.orphanAgentIds;
+    return c.json(response);
+  } catch (err) {
+    if (err instanceof SpawnProfileGroupError) {
+      return c.json({ error: err.message, orphanAgentIds: err.orphanAgentIds }, 500);
+    }
+    const msg = err.message;
+    if (msg.startsWith("profile group not found")) return c.json({ error: msg }, 404);
+    if (msg.startsWith("profile group spawn: missing profiles")) {
+      return c.json({ error: msg }, 400);
+    }
+    return c.json({ error: msg }, 500);
+  }
+});
+
 // ../daemon/src/routes/profiles.ts
 import { existsSync as existsSync17, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
 import { join as join18 } from "path";
-import { Hono as Hono7 } from "hono";
-var profilesRouter = new Hono7();
+import { Hono as Hono8 } from "hono";
+var profilesRouter = new Hono8();
 profilesRouter.get("/", (c) => {
   const { db } = getCtx();
   const profiles = profiles_exports.list(db);
@@ -5721,12 +6678,12 @@ function toSkillsMode(v) {
 }
 
 // ../daemon/src/routes/skills.ts
-import { existsSync as existsSync18, mkdtempSync as mkdtempSync2, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync18, mkdtempSync as mkdtempSync2, rmSync as rmSync10, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "os";
 import { join as join19 } from "path";
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 var MAX_ZIP_BYTES = 50 * 1024 * 1024;
-var skillsRouter = new Hono8();
+var skillsRouter = new Hono9();
 skillsRouter.get("/", (c) => {
   const { db, paths } = getCtx();
   const out = [];
@@ -5753,7 +6710,7 @@ skillsRouter.delete("/:name", (c) => {
   const name = c.req.param("name");
   const dir = paths.skillDir(name);
   if (!existsSync18(dir)) return c.json({ error: `skill not found: ${name}` }, 404);
-  rmSync8(dir, { recursive: true, force: true });
+  rmSync10(dir, { recursive: true, force: true });
   skillMeta_exports.remove(db, name);
   return c.body(null, 204);
 });
@@ -5776,7 +6733,7 @@ skillsRouter.post("/import", async (c) => {
   } catch (err) {
     return c.json({ error: err.message }, 400);
   } finally {
-    if (input.tempZipPath) rmSync8(input.tempZipPath, { recursive: true, force: true });
+    if (input.tempZipPath) rmSync10(input.tempZipPath, { recursive: true, force: true });
   }
 });
 async function parseImportInput(request) {
@@ -5820,8 +6777,8 @@ async function parseImportInput(request) {
 }
 
 // ../daemon/src/routes/triggers.ts
-import { Hono as Hono9 } from "hono";
-var triggersRouter = new Hono9();
+import { Hono as Hono10 } from "hono";
+var triggersRouter = new Hono10();
 triggersRouter.delete("/:id", (c) => {
   const { db } = getCtx();
   const id = c.req.param("id");
@@ -5843,10 +6800,11 @@ triggersRouter.patch("/:id", async (c) => {
 
 // ../daemon/src/app.ts
 function createApp() {
-  const app2 = new Hono10();
+  const app2 = new Hono11();
   app2.use("*", authMiddleware);
   app2.route("/api/agents", agentsRouter);
   app2.route("/api/groups", groupsRouter);
+  app2.route("/api/profile-groups", profileGroupsRouter);
   app2.route("/api/profiles", profilesRouter);
   app2.route("/api/skills", skillsRouter);
   app2.route("/api/triggers", triggersRouter);