@rubytech/create-sitedesk-code 0.1.507 → 0.1.508

package/payload/server/server.js

@@ -1824,10 +1824,10 @@ var serveStatic = (options = { root: "" }) => {
 };
 
 // server/index.ts
-import { readFileSync as readFileSync47, existsSync as existsSync46, watchFile, readdirSync as readdirSync28, statSync as statSync20 } from "fs";
+import { readFileSync as readFileSync48, existsSync as existsSync47, watchFile, readdirSync as readdirSync29, statSync as statSync21 } from "fs";
 import { spawn as spawn3 } from "child_process";
-import { createHash as createHash7 } from "crypto";
-import { resolve as resolve45, join as join47, basename as basename14 } from "path";
+import { createHash as createHash8 } from "crypto";
+import { resolve as resolve45, join as join48, basename as basename14 } from "path";
 import { homedir as homedir4 } from "os";
 
 // server/lib/route-cache-watchers.ts
@@ -16522,7 +16522,7 @@ var session_upload_default = app17;
 
 // server/routes/admin/agents.ts
 import { resolve as resolve23 } from "path";
-import { readdirSync as readdirSync21, readFileSync as readFileSync32, existsSync as existsSync30, rmSync as rmSync2 } from "fs";
+import { readdirSync as readdirSync22, readFileSync as readFileSync33, existsSync as existsSync31, rmSync as rmSync2, renameSync as renameSync9, mkdirSync as mkdirSync7, writeFileSync as writeFileSync13 } from "fs";
 
 // server/routes/admin/_account-scope.ts
 function accountDirForSession(cacheKey) {
@@ -16549,12 +16549,390 @@ async function authorizeAccountWrite(c, accountId) {
   return { ok: true, via: "session" };
 }
 
+// ../services/claude-session-manager/src/tool-surface.ts
+import { readFileSync as readFileSync32, readdirSync as readdirSync21, statSync as statSync15, existsSync as existsSync30 } from "fs";
+import { createHash as createHash5 } from "crypto";
+import { join as join33 } from "path";
+
+// ../services/claude-session-manager/src/canonical-tool-names.ts
+function canonicalToolName(plugin, tool) {
+  return `mcp__plugin_${plugin}_${plugin}__${tool}`;
+}
+function qualifyShortToolName(plugin, tool) {
+  return `mcp__${plugin}__${tool}`;
+}
+
+// ../services/claude-session-manager/src/tool-surface.ts
+var RISK_CLASSES = ["read", "write_local", "exec", "external"];
+var ToolSurfaceError = class extends Error {
+  constructor(reason, detail) {
+    super(`${reason}: ${detail}`);
+    this.reason = reason;
+    this.detail = detail;
+    this.name = "ToolSurfaceError";
+  }
+};
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+function extractFrontmatter(raw, pluginDir) {
+  const m = raw.match(FRONTMATTER_RE);
+  if (!m) {
+    throw new ToolSurfaceError("frontmatter-missing", `${pluginDir}/PLUGIN.md has no '---' delimited frontmatter`);
+  }
+  return m[1];
+}
+function parseToolsBlock(frontmatter, pluginDir) {
+  const lines = frontmatter.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (/^tools:\s*\[\s*\]\s*$/.test(line)) return [];
+    if (/^tools:\s*$/.test(line)) {
+      i++;
+      break;
+    }
+    i++;
+  }
+  if (i >= lines.length) return [];
+  const out = [];
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    if (typeof current.name !== "string" || current.name.length === 0) {
+      throw new ToolSurfaceError("tool-name-missing", `${pluginDir}/PLUGIN.md has a tool entry with no name`);
+    }
+    if (typeof current.publicAllowlist !== "boolean") {
+      if (current.publicAllowlist === void 0) {
+        throw new ToolSurfaceError(
+          "public-allowlist-missing",
+          `${pluginDir}/${current.name} \u2014 every tool must declare publicAllowlist: <true|false>`
+        );
+      }
+      throw new ToolSurfaceError(
+        "public-allowlist-not-boolean",
+        `${pluginDir}/${current.name} \u2014 publicAllowlist must be a YAML boolean (true|false), got ${JSON.stringify(current.publicAllowlist)}`
+      );
+    }
+    if (typeof current.adminAllowlist !== "boolean") {
+      if (current.adminAllowlist === void 0) {
+        throw new ToolSurfaceError(
+          "admin-allowlist-missing",
+          `${pluginDir}/${current.name} \u2014 every tool must declare adminAllowlist: <true|false>`
+        );
+      }
+      throw new ToolSurfaceError(
+        "admin-allowlist-not-boolean",
+        `${pluginDir}/${current.name} \u2014 adminAllowlist must be a YAML boolean (true|false), got ${JSON.stringify(current.adminAllowlist)}`
+      );
+    }
+    if (current.riskClass === void 0) {
+      throw new ToolSurfaceError(
+        "risk-class-missing",
+        `${pluginDir}/${current.name} \u2014 every tool must declare riskClass: <${RISK_CLASSES.join("|")}>`
+      );
+    }
+    if (!RISK_CLASSES.includes(current.riskClass)) {
+      throw new ToolSurfaceError(
+        "risk-class-invalid",
+        `${pluginDir}/${current.name} \u2014 riskClass must be one of ${RISK_CLASSES.join("|")}, got ${JSON.stringify(current.riskClass)}`
+      );
+    }
+    out.push(current);
+    current = null;
+  };
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length === 0) continue;
+    if (/^[A-Za-z_]/.test(line)) break;
+    const newEntry = line.match(/^\s+-\s+name:\s*(.+?)\s*$/);
+    if (newEntry) {
+      flush();
+      current = { name: newEntry[1] };
+      continue;
+    }
+    const orphanListItem = line.match(/^\s+-\s+(?!name:)/);
+    if (orphanListItem) {
+      throw new ToolSurfaceError("tool-name-missing", `${pluginDir}/PLUGIN.md tool entry lacks a name field`);
+    }
+    const publicAllow = line.match(/^\s+publicAllowlist:\s*(.+?)\s*$/);
+    if (publicAllow && current) {
+      const v = publicAllow[1].trim();
+      if (v === "true") current.publicAllowlist = true;
+      else if (v === "false") current.publicAllowlist = false;
+      else current.publicAllowlist = v;
+      continue;
+    }
+    const adminAllow = line.match(/^\s+adminAllowlist:\s*(.+?)\s*$/);
+    if (adminAllow && current) {
+      const v = adminAllow[1].trim();
+      if (v === "true") current.adminAllowlist = true;
+      else if (v === "false") current.adminAllowlist = false;
+      else current.adminAllowlist = v;
+      continue;
+    }
+    const risk = line.match(/^\s+riskClass:\s*(.+?)\s*$/);
+    if (risk && current) {
+      current.riskClass = risk[1].trim();
+      continue;
+    }
+  }
+  flush();
+  return out;
+}
+function parseHiddenBlock(frontmatter, pluginDir) {
+  const lines = frontmatter.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    if (/^hidden:\s*$/.test(lines[i])) {
+      i++;
+      break;
+    }
+    i++;
+  }
+  if (i >= lines.length) return [];
+  const out = [];
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    if (current.riskClass === void 0) {
+      throw new ToolSurfaceError(
+        "risk-class-missing",
+        `${pluginDir}/${current.name} \u2014 every hidden tool must declare riskClass: <${RISK_CLASSES.join("|")}>`
+      );
+    }
+    if (!RISK_CLASSES.includes(current.riskClass)) {
+      throw new ToolSurfaceError(
+        "risk-class-invalid",
+        `${pluginDir}/${current.name} \u2014 hidden riskClass must be one of ${RISK_CLASSES.join("|")}, got ${JSON.stringify(current.riskClass)}`
+      );
+    }
+    out.push(current);
+    current = null;
+  };
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length === 0) continue;
+    if (/^[A-Za-z_]/.test(line)) break;
+    const newEntry = line.match(/^\s+-\s+name:\s*(.+?)\s*$/);
+    if (newEntry) {
+      flush();
+      current = { name: newEntry[1] };
+      continue;
+    }
+    const bareItem = line.match(/^\s+-\s+(.+?)\s*$/);
+    if (bareItem) {
+      throw new ToolSurfaceError(
+        "hidden-tool-name-missing",
+        `${pluginDir}/PLUGIN.md hidden entry "${bareItem[1]}" is a bare name \u2014 declare it as "- name: ${bareItem[1]}" with a riskClass`
+      );
+    }
+    const risk = line.match(/^\s+riskClass:\s*(.+?)\s*$/);
+    if (risk && current) {
+      current.riskClass = risk[1].trim();
+      continue;
+    }
+  }
+  flush();
+  return out;
+}
+function parseMcpBlock(frontmatter, pluginDir) {
+  const lines = frontmatter.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    if (/^mcp:\s*$/.test(lines[i])) {
+      i++;
+      break;
+    }
+    i++;
+  }
+  if (i >= lines.length) return null;
+  let command = null;
+  const args = [];
+  const env = {};
+  let envHasEntry = false;
+  let mode = "top";
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length === 0) continue;
+    if (/^[A-Za-z_]/.test(line)) break;
+    const topCommand = line.match(/^\s\s(command):\s*(.+?)\s*$/);
+    const topArgsHeader = line.match(/^\s\s(args):\s*$/);
+    const topEnvHeader = line.match(/^\s\s(env):\s*$/);
+    if (topCommand) {
+      command = topCommand[2];
+      mode = "top";
+      continue;
+    }
+    if (topArgsHeader) {
+      mode = "args";
+      continue;
+    }
+    if (topEnvHeader) {
+      mode = "env";
+      continue;
+    }
+    if (mode === "args") {
+      const item = line.match(/^\s+-\s+(.+?)\s*$/);
+      if (item) {
+        args.push(item[1]);
+        continue;
+      }
+    }
+    if (mode === "env") {
+      const kv = line.match(/^\s+([A-Za-z_][A-Za-z0-9_]*):\s*(.+?)\s*$/);
+      if (kv) {
+        env[kv[1]] = kv[2];
+        envHasEntry = true;
+        continue;
+      }
+    }
+  }
+  if (command === null) {
+    throw new ToolSurfaceError("mcp-command-missing", `${pluginDir}/PLUGIN.md mcp: block has no command`);
+  }
+  const desc = { command, args };
+  if (envHasEntry) desc.env = env;
+  return desc;
+}
+function loadToolSurface(pluginsRoots) {
+  const roots = Array.isArray(pluginsRoots) ? pluginsRoots : [pluginsRoots];
+  for (const r of roots) {
+    if (!existsSync30(r)) throw new ToolSurfaceError("plugins-root-missing", r);
+  }
+  const admin = /* @__PURE__ */ new Set();
+  const pub = /* @__PURE__ */ new Set();
+  const all = /* @__PURE__ */ new Set();
+  const mcpServers = /* @__PURE__ */ new Map();
+  const riskByTool = /* @__PURE__ */ new Map();
+  const manifestPaths = /* @__PURE__ */ new Map();
+  const loadOne = (pluginsRoot, plugin) => {
+    const pluginDir = join33(pluginsRoot, plugin);
+    try {
+      if (!statSync15(pluginDir).isDirectory()) return;
+    } catch {
+      return;
+    }
+    const manifestPath = join33(pluginDir, "PLUGIN.md");
+    if (!existsSync30(manifestPath)) return;
+    const raw = readFileSync32(manifestPath, "utf-8");
+    const frontmatter = extractFrontmatter(raw, plugin);
+    const tools = parseToolsBlock(frontmatter, plugin);
+    if (tools.length === 0) return;
+    const mcp = parseMcpBlock(frontmatter, plugin);
+    if (!mcp) {
+      throw new ToolSurfaceError(
+        "mcp-block-missing",
+        `${plugin}/PLUGIN.md declares tools but no mcp: block; spawns would --allowed-tools mcp__${plugin}__* with no registered server`
+      );
+    }
+    if (mcpServers.has(plugin)) {
+      const priorPath = manifestPaths.get(plugin);
+      if (!priorPath) {
+        throw new ToolSurfaceError(
+          "mcp-plugin-duplicate-no-prior-path",
+          `${plugin}: mcpServers has entry but manifestPaths is missing \u2014 invariant violated, both maps must be written together`
+        );
+      }
+      const priorSha = createHash5("sha256").update(readFileSync32(priorPath)).digest("hex").slice(0, 8);
+      const newSha = createHash5("sha256").update(raw).digest("hex").slice(0, 8);
+      throw new ToolSurfaceError(
+        "mcp-plugin-duplicate",
+        `${plugin} declared by more than one plugins root: ${priorPath} (sha=${priorSha}) vs ${manifestPath} (sha=${newSha})`
+      );
+    }
+    mcpServers.set(plugin, mcp);
+    manifestPaths.set(plugin, manifestPath);
+    for (const t of tools) {
+      const canonical = canonicalToolName(plugin, t.name);
+      all.add(canonical);
+      riskByTool.set(canonical, t.riskClass);
+      if (t.adminAllowlist) admin.add(canonical);
+      if (t.publicAllowlist) pub.add(qualifyShortToolName(plugin, t.name));
+    }
+    for (const h of parseHiddenBlock(frontmatter, plugin)) {
+      const canonical = canonicalToolName(plugin, h.name);
+      all.add(canonical);
+      riskByTool.set(canonical, h.riskClass);
+    }
+  };
+  for (const root of roots) {
+    const entries2 = readdirSync21(root).sort();
+    for (const plugin of entries2) {
+      const pluginDir = join33(root, plugin);
+      loadOne(root, plugin);
+      const subRoot = join33(pluginDir, "plugins");
+      let subEntries;
+      try {
+        if (!statSync15(subRoot).isDirectory()) continue;
+        subEntries = readdirSync21(subRoot).sort();
+      } catch {
+        continue;
+      }
+      for (const sub of subEntries) {
+        loadOne(subRoot, sub);
+      }
+    }
+  }
+  return { admin, public: pub, all, mcpServers, riskByTool };
+}
+
+// server/lib/agent-risk.ts
+var BUILTIN_TOOL_RISK = {
+  Bash: "exec",
+  Task: "exec",
+  Skill: "exec",
+  Edit: "write_local",
+  MultiEdit: "write_local",
+  Write: "write_local",
+  Read: "read",
+  Glob: "read",
+  Grep: "read",
+  WebFetch: "external",
+  WebSearch: "external"
+};
+var SEVERITY = {
+  read: 0,
+  write_local: 1,
+  exec: 2,
+  external: 2
+};
+var AGENT_CLASS = {
+  read: "green",
+  write_local: "amber",
+  exec: "red",
+  external: "red"
+};
+function agentRiskClass(tools, riskByTool) {
+  const byTool = [];
+  const unresolved = [];
+  let worst = null;
+  let worstTool = null;
+  for (const tool of tools) {
+    const cls = BUILTIN_TOOL_RISK[tool] ?? riskByTool.get(tool) ?? null;
+    byTool.push({ tool, risk: cls });
+    if (cls === null) {
+      unresolved.push(tool);
+      continue;
+    }
+    if (worst === null || SEVERITY[cls] > SEVERITY[worst]) {
+      worst = cls;
+      worstTool = tool;
+    }
+  }
+  if (unresolved.length > 0) {
+    return { risk: "red", worstTool: unresolved[0], unresolved, byTool };
+  }
+  if (worst === null) {
+    return { risk: "red", worstTool: null, unresolved, byTool };
+  }
+  return { risk: AGENT_CLASS[worst], worstTool, unresolved, byTool };
+}
+
 // server/routes/admin/agents.ts
 var SLUG_UNSAFE = (s) => s.includes("/") || s.includes("..") || s.includes("\\");
 function subdirs(dir) {
-  if (!existsSync30(dir)) return [];
+  if (!existsSync31(dir)) return [];
   try {
-    return readdirSync21(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    return readdirSync22(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
   }
@@ -16569,34 +16947,148 @@ function splitFrontmatter(text) {
   }
   return { fm, body: text.slice(m[0].length) };
 }
-function listSpecialists(accountDir) {
+var SPECIALISTS_DIR = ["specialists", "agents"];
+var QUARANTINE_DIR = ["specialists", "agents-disabled"];
+var DISABLED_STORE = "agents-disabled.json";
+function loadRiskSurface() {
+  const roots = [resolve23(PLATFORM_ROOT, "plugins"), resolve23(PLATFORM_ROOT, "..", "premium-plugins")].filter((r) => existsSync31(r));
+  try {
+    return { riskByTool: loadToolSurface(roots).riskByTool, failed: null };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[admin/agents] op=risk-surface status=load-failed reason="${msg}"`);
+    return { riskByTool: /* @__PURE__ */ new Map(), failed: msg };
+  }
+}
+function readDisabledStoreStrict(accountDir) {
+  const p = resolve23(accountDir, DISABLED_STORE);
+  if (!existsSync31(p)) return /* @__PURE__ */ new Set();
+  const parsed = JSON.parse(readFileSync33(p, "utf-8"));
+  if (!Array.isArray(parsed.disabled)) throw new Error("disabled is not an array");
+  return new Set(parsed.disabled.filter((x) => typeof x === "string"));
+}
+function readDisabledStore(accountDir) {
+  try {
+    return readDisabledStoreStrict(accountDir);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[admin/agents] op=disabled-store status=parse-failed reason="${msg}"`);
+    return /* @__PURE__ */ new Set();
+  }
+}
+function shippedSourceDirs(accountDir) {
+  return [
+    resolve23(accountDir, ...SPECIALISTS_DIR),
+    resolve23(accountDir, ...QUARANTINE_DIR),
+    resolve23(PLATFORM_ROOT, "templates", "specialists", "agents")
+  ];
+}
+function writeDisabledStore(accountDir, disabled) {
+  writeFileSync13(
+    resolve23(accountDir, DISABLED_STORE),
+    `${JSON.stringify({ disabled: [...disabled].sort() }, null, 2)}
+`,
+    { mode: 384 }
+  );
+}
+function listShipped(accountDir, riskByTool, disabled, riskSurfaceFailed) {
+  const dirs = shippedSourceDirs(accountDir);
+  const names = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    if (!existsSync31(dir)) continue;
+    try {
+      for (const entry of readdirSync22(dir)) if (entry.endsWith(".md")) names.add(entry);
+    } catch (err) {
+      console.error(`[admin/agents] op=list-shipped read-failed dir=${dir} error="${err}"`);
+    }
+  }
+  const shipped = [];
+  let shippedSkipped = 0;
+  for (const filename of [...names].sort()) {
+    const source = dirs.find((d) => existsSync31(resolve23(d, filename)));
+    if (!source) continue;
+    try {
+      const { fm } = splitFrontmatter(readFileSync33(resolve23(source, filename), "utf-8"));
+      if (!fm.name) {
+        shippedSkipped++;
+        console.error(`[admin/agents] op=list-shipped-skip file=${filename} reason=no-name`);
+        continue;
+      }
+      const tools = parseToolsLine(fm.tools);
+      const r = classify(tools, riskByTool, riskSurfaceFailed);
+      shipped.push({
+        slug: filename.replace(/\.md$/, ""),
+        displayName: fm.name,
+        kind: "specialist",
+        origin: "shipped",
+        plugin: "",
+        description: fm.description ?? "",
+        risk: r.risk,
+        worstTool: r.worstTool,
+        unresolved: r.unresolved,
+        toolCount: tools.length,
+        // The DIRECTORY is the ground truth, not the store. `spawn-context.ts`
+        // reads the live dir, so a file found in quarantine is not dispatchable
+        // whatever the JSON says, and a file found live IS dispatchable even if
+        // the store claims otherwise. The store only answers for a bundled-only
+        // agent, which has no account copy in either directory to look at.
+        disabled: source === dirs[1] || source === dirs[2] && disabled.has(filename)
+      });
+    } catch (err) {
+      shippedSkipped++;
+      console.error(`[admin/agents] op=list-shipped-skip file=${filename} error="${err}"`);
+    }
+  }
+  return { shipped, shippedSkipped };
+}
+function parseToolsLine(raw) {
+  return raw ? raw.split(",").map((t) => t.trim()).filter(Boolean) : [];
+}
+function classify(tools, riskByTool, riskSurfaceFailed) {
+  if (riskSurfaceFailed) {
+    return { risk: "red", worstTool: null, unresolved: [], byTool: tools.map((t) => ({ tool: t, risk: null })) };
+  }
+  return agentRiskClass(tools, riskByTool);
+}
+function listSpecialists(accountDir, riskByTool, riskSurfaceFailed) {
   const pluginsDir = resolve23(accountDir, "plugins");
   const specialists = [];
   let specialistsSkipped = 0;
   for (const plugin of subdirs(pluginsDir).sort()) {
     const agentsDirP = resolve23(pluginsDir, plugin, "agents");
-    if (!existsSync30(agentsDirP)) continue;
+    if (!existsSync31(agentsDirP)) continue;
     let entries2;
     try {
-      entries2 = readdirSync21(agentsDirP, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+      entries2 = readdirSync22(agentsDirP, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     } catch {
       continue;
     }
     for (const entry of entries2) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
       try {
-        const { fm } = splitFrontmatter(readFileSync32(resolve23(agentsDirP, entry.name), "utf-8"));
+        const { fm } = splitFrontmatter(readFileSync33(resolve23(agentsDirP, entry.name), "utf-8"));
         if (!fm.name) {
           specialistsSkipped++;
           console.error(`[admin/agents] op=list-specialist-skip plugin=${plugin} file=${entry.name}`);
           continue;
         }
+        const specialistTools = parseToolsLine(fm.tools);
+        const r = classify(specialistTools, riskByTool, riskSurfaceFailed);
         specialists.push({
           slug: entry.name.replace(/\.md$/, ""),
           displayName: fm.name,
           kind: "specialist",
+          origin: "specialist",
           plugin,
-          description: fm.description ?? ""
+          description: fm.description ?? "",
+          risk: r.risk,
+          worstTool: r.worstTool,
+          unresolved: r.unresolved,
+          toolCount: specialistTools.length,
+          // A user-created specialist lives under the account plugins tree,
+          // which provisioning never rewrites, so the quarantine mechanism
+          // does not apply to it.
+          disabled: false
         });
       } catch {
         specialistsSkipped++;
@@ -16619,24 +17111,31 @@ app18.get("/", requireAdminSession, (c) => {
     console.error("[admin/agents] op=list auth-rejected reason=no-account-for-session");
     return c.json({ error: "Account not found for session" }, 401);
   }
+  const { riskByTool, failed: riskSurfaceFailed } = loadRiskSurface();
+  const disabled = readDisabledStore(account.accountDir);
   const agents = [];
   let skipped = 0;
   const agentsDir = resolve23(account.accountDir, "agents");
-  if (existsSync30(agentsDir)) {
+  if (existsSync31(agentsDir)) {
     try {
-      const entries2 = readdirSync21(agentsDir, { withFileTypes: true });
+      const entries2 = readdirSync22(agentsDir, { withFileTypes: true });
       for (const entry of entries2.sort((a, b) => a.name.localeCompare(b.name))) {
         if (!entry.isDirectory()) continue;
         if (entry.name === "admin") continue;
         const configPath2 = resolve23(agentsDir, entry.name, "config.json");
-        if (!existsSync30(configPath2)) continue;
+        if (!existsSync31(configPath2)) continue;
         try {
-          const config = JSON.parse(readFileSync32(configPath2, "utf-8"));
+          const config = JSON.parse(readFileSync33(configPath2, "utf-8"));
           agents.push({
             slug: entry.name,
             displayName: config.displayName ?? entry.name,
             status: config.status ?? "unknown",
-            kind: "public"
+            kind: "public",
+            origin: "public",
+            risk: null,
+            worstTool: null,
+            unresolved: [],
+            disabled: false
           });
         } catch {
           skipped++;
@@ -16647,9 +17146,25 @@ app18.get("/", requireAdminSession, (c) => {
       console.error(`[admin/agents] failed to scan agents directory: ${err}`);
     }
   }
-  const { specialists, specialistsSkipped } = listSpecialists(account.accountDir);
-  console.log(`[admin/agents] op=list accountId=${account.accountId.slice(0, 8)} agents=${agents.length} specialists=${specialists.length} skipped=${skipped} specialistsSkipped=${specialistsSkipped}`);
-  return c.json({ agents: [...agents, ...specialists], accountId: account.accountId, skipped, specialistsSkipped });
+  const { specialists, specialistsSkipped } = listSpecialists(account.accountDir, riskByTool, riskSurfaceFailed !== null);
+  const { shipped, shippedSkipped } = listShipped(account.accountDir, riskByTool, disabled, riskSurfaceFailed !== null);
+  const rows = [...agents, ...specialists, ...shipped];
+  const acct = account.accountId.slice(0, 8);
+  for (const row of rows) {
+    if (row.risk === null) continue;
+    console.log(
+      `[admin/agents] op=classify account=${acct} agent=${row.slug} origin=${row.origin} risk=${row.risk} worstTool=${row.worstTool ?? "none"} tools=${row.toolCount} unresolved=${row.unresolved.length > 0 ? row.unresolved.join(",") : "none"} disabled=${row.disabled}`
+    );
+  }
+  console.log(`[admin/agents] op=list accountId=${acct} agents=${agents.length} specialists=${specialists.length} shipped=${shipped.length} skipped=${skipped} specialistsSkipped=${specialistsSkipped} shippedSkipped=${shippedSkipped}`);
+  return c.json({
+    agents: rows,
+    accountId: account.accountId,
+    skipped,
+    specialistsSkipped,
+    shippedSkipped,
+    riskSurfaceFailed: riskSurfaceFailed !== null
+  });
 });
 app18.get("/:slug", requireAdminSession, (c) => {
   const slug = c.req.param("slug");
@@ -16659,34 +17174,72 @@ app18.get("/:slug", requireAdminSession, (c) => {
     return c.json({ error: "Account not found for session" }, 401);
   }
   if (SLUG_UNSAFE(slug)) return c.json({ error: "Invalid agent slug" }, 400);
+  if (c.req.query("origin") === "shipped") {
+    const dirs = shippedSourceDirs(account.accountDir);
+    const source = dirs.find((d) => existsSync31(resolve23(d, `${slug}.md`)));
+    if (!source) return c.json({ error: "Agent not found" }, 404);
+    const { fm, body } = splitFrontmatter(readFileSync33(resolve23(source, `${slug}.md`), "utf-8"));
+    const { riskByTool, failed } = loadRiskSurface();
+    const tools = parseToolsLine(fm.tools);
+    const r = classify(tools, riskByTool, failed !== null);
+    console.log(`[admin/agents] op=detail accountId=${account.accountId.slice(0, 8)} slug=${slug} kind=specialist origin=shipped risk=${r.risk}`);
+    return c.json({
+      agent: {
+        kind: "specialist",
+        origin: "shipped",
+        slug,
+        displayName: fm.name ?? slug,
+        description: fm.description ?? "",
+        summary: fm.summary ?? "",
+        model: fm.model ?? null,
+        tools,
+        systemPrompt: body.trim(),
+        skills: [],
+        risk: r.risk,
+        worstTool: r.worstTool,
+        unresolved: r.unresolved,
+        byTool: r.byTool,
+        disabled: readDisabledStore(account.accountDir).has(`${slug}.md`)
+      }
+    });
+  }
   const pluginParam = c.req.query("plugin");
   if (pluginParam) {
     if (SLUG_UNSAFE(pluginParam)) return c.json({ error: "Invalid plugin" }, 400);
     const file = resolve23(account.accountDir, "plugins", pluginParam, "agents", `${slug}.md`);
-    if (!existsSync30(file)) return c.json({ error: "Agent not found" }, 404);
-    const { fm, body } = splitFrontmatter(readFileSync32(file, "utf-8"));
+    if (!existsSync31(file)) return c.json({ error: "Agent not found" }, 404);
+    const { fm, body } = splitFrontmatter(readFileSync33(file, "utf-8"));
     const skills = subdirs(resolve23(account.accountDir, "plugins", pluginParam, "skills"));
-    console.log(`[admin/agents] op=detail accountId=${account.accountId.slice(0, 8)} slug=${slug} kind=specialist plugin=${pluginParam}`);
+    const { riskByTool, failed } = loadRiskSurface();
+    const tools = parseToolsLine(fm.tools);
+    const r = classify(tools, riskByTool, failed !== null);
+    console.log(`[admin/agents] op=detail accountId=${account.accountId.slice(0, 8)} slug=${slug} kind=specialist plugin=${pluginParam} risk=${r.risk}`);
     return c.json({
       agent: {
         kind: "specialist",
+        origin: "specialist",
         slug,
         displayName: fm.name ?? slug,
         description: fm.description ?? "",
         summary: fm.summary ?? "",
         model: fm.model ?? null,
-        tools: fm.tools ? fm.tools.split(",").map((t) => t.trim()).filter(Boolean) : [],
+        tools,
         systemPrompt: body.trim(),
-        skills
+        skills,
+        risk: r.risk,
+        worstTool: r.worstTool,
+        unresolved: r.unresolved,
+        byTool: r.byTool,
+        disabled: false
       }
     });
   }
   const agentDir = resolve23(account.accountDir, "agents", slug);
   const configPath2 = resolve23(agentDir, "config.json");
-  if (!existsSync30(configPath2)) return c.json({ error: "Agent not found" }, 404);
+  if (!existsSync31(configPath2)) return c.json({ error: "Agent not found" }, 404);
   let config;
   try {
-    config = JSON.parse(readFileSync32(configPath2, "utf-8"));
+    config = JSON.parse(readFileSync33(configPath2, "utf-8"));
   } catch {
     console.error(`[admin/agents] op=detail slug=${slug} error="config.json parse failed"`);
     return c.json({ error: "Agent config unreadable" }, 500);
@@ -16696,8 +17249,8 @@ app18.get("/:slug", requireAdminSession, (c) => {
   for (const { file, key } of OWNED_DOCS) {
     const p = resolve23(agentDir, file);
     try {
-      if (existsSync30(p)) {
-        docs[key] = readFileSync32(p, "utf-8");
+      if (existsSync31(p)) {
+        docs[key] = readFileSync33(p, "utf-8");
         present[key] = true;
       } else {
         docs[key] = "";
@@ -16726,6 +17279,84 @@ app18.get("/:slug", requireAdminSession, (c) => {
     }
   });
 });
+async function resolveWritableAccount(c, op, slug) {
+  const accountIdParam = c.req.query("accountId") ?? "";
+  if (!accountIdParam) {
+    console.error(`[admin/agents] op=${op} rejected reason=missing-accountId slug=${slug}`);
+    return { status: 400, error: "accountId is required" };
+  }
+  const account = validateAccountId2(accountIdParam);
+  if (!account) {
+    console.error(`[admin/agents] op=${op} rejected reason=unknown-accountId accountId=${accountIdParam.slice(0, 8)} slug=${slug}`);
+    return { status: 400, error: "Unknown accountId" };
+  }
+  const authz = await authorizeAccountWrite(c, account.accountId);
+  if (!authz.ok) {
+    console.error(`[admin/agents] op=${op} rejected reason=${authz.reason} accountId=${account.accountId.slice(0, 8)} slug=${slug}`);
+    return { status: 403, error: "Not authorized for this account" };
+  }
+  return account;
+}
+app18.post("/:slug/disable", async (c) => {
+  const slug = c.req.param("slug");
+  if (SLUG_UNSAFE(slug)) return c.json({ error: "Invalid agent slug" }, 400);
+  const resolved = await resolveWritableAccount(c, "disable", slug);
+  if ("status" in resolved) return c.json({ error: resolved.error }, resolved.status);
+  const filename = `${slug}.md`;
+  const live = resolve23(resolved.accountDir, ...SPECIALISTS_DIR, filename);
+  const quarantined = resolve23(resolved.accountDir, ...QUARANTINE_DIR, filename);
+  if (!shippedSourceDirs(resolved.accountDir).some((d) => existsSync31(resolve23(d, filename)))) {
+    console.error(`[admin/agents] op=disable accountId=${resolved.accountId.slice(0, 8)} slug=${slug} outcome=failed reason=not-a-shipped-agent`);
+    return c.json({ error: "Only a shipped agent can be disabled" }, 404);
+  }
+  let moved = false;
+  try {
+    const disabled = readDisabledStoreStrict(resolved.accountDir);
+    if (existsSync31(live)) {
+      mkdirSync7(resolve23(resolved.accountDir, ...QUARANTINE_DIR), { recursive: true });
+      renameSync9(live, quarantined);
+      moved = true;
+    }
+    disabled.add(filename);
+    writeDisabledStore(resolved.accountDir, disabled);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[admin/agents] op=disable accountId=${resolved.accountId.slice(0, 8)} slug=${slug} outcome=failed reason="${msg}"`);
+    return c.json({ error: `Disable failed, disabled store unreadable or unwritable: ${msg}` }, 500);
+  }
+  console.log(`[admin/agents] op=disable accountId=${resolved.accountId.slice(0, 8)} slug=${slug} outcome=ok moved=${moved}`);
+  return c.json({ ok: true, moved });
+});
+app18.post("/:slug/enable", async (c) => {
+  const slug = c.req.param("slug");
+  if (SLUG_UNSAFE(slug)) return c.json({ error: "Invalid agent slug" }, 400);
+  const resolved = await resolveWritableAccount(c, "enable", slug);
+  if ("status" in resolved) return c.json({ error: resolved.error }, resolved.status);
+  const filename = `${slug}.md`;
+  const live = resolve23(resolved.accountDir, ...SPECIALISTS_DIR, filename);
+  const quarantined = resolve23(resolved.accountDir, ...QUARANTINE_DIR, filename);
+  let restored = false;
+  try {
+    const disabled = readDisabledStoreStrict(resolved.accountDir);
+    if (!existsSync31(quarantined) && !disabled.has(filename)) {
+      console.error(`[admin/agents] op=enable accountId=${resolved.accountId.slice(0, 8)} slug=${slug} outcome=failed reason=not-disabled`);
+      return c.json({ error: "This agent is not disabled" }, 404);
+    }
+    if (existsSync31(quarantined)) {
+      mkdirSync7(resolve23(resolved.accountDir, ...SPECIALISTS_DIR), { recursive: true });
+      renameSync9(quarantined, live);
+      restored = true;
+    }
+    disabled.delete(filename);
+    writeDisabledStore(resolved.accountDir, disabled);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[admin/agents] op=enable accountId=${resolved.accountId.slice(0, 8)} slug=${slug} outcome=failed reason="${msg}"`);
+    return c.json({ error: `Enable failed: ${msg}` }, 500);
+  }
+  console.log(`[admin/agents] op=enable accountId=${resolved.accountId.slice(0, 8)} slug=${slug} outcome=ok restored=${restored}`);
+  return c.json({ ok: true, restored });
+});
 app18.delete("/:slug", async (c) => {
   const slug = c.req.param("slug");
   if (slug === "admin") {
@@ -16750,7 +17381,7 @@ app18.delete("/:slug", async (c) => {
     return c.json({ error: "Not authorized for this account" }, 403);
   }
   const agentDir = resolve23(account.accountDir, "agents", slug);
-  if (!existsSync30(agentDir)) {
+  if (!existsSync31(agentDir)) {
     return c.json({ error: "Agent not found" }, 404);
   }
   try {
@@ -16793,7 +17424,7 @@ app18.post("/:slug/project", async (c) => {
     return c.json({ error: "Not authorized for this account" }, 403);
   }
   const agentDir = resolve23(account.accountDir, "agents", slug);
-  if (!existsSync30(agentDir)) {
+  if (!existsSync31(agentDir)) {
     return c.json({ error: "Agent not found on disk" }, 404);
   }
   try {
@@ -16809,7 +17440,7 @@ var agents_default = app18;
 // server/routes/admin/sessions.ts
 import crypto2 from "crypto";
 import { resolve as resolvePath } from "path";
-import { existsSync as existsSync31, mkdirSync as mkdirSync7, createWriteStream } from "fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync8, createWriteStream } from "fs";
 
 // ../lib/admin-conversation-purge/src/index.ts
 async function purgeAdminConversationJsonls(args) {
@@ -16956,7 +17587,7 @@ var pickComponentBytes = (..._args) => null;
 function openResumeStreamLog(accountId, sessionId) {
   const dir = resolvePath(ACCOUNTS_DIR, accountId, "resume-logs");
   try {
-    mkdirSync7(dir, { recursive: true });
+    mkdirSync8(dir, { recursive: true });
   } catch {
   }
   return createWriteStream(resolvePath(dir, `${sessionId}.log`), { flags: "a" });
@@ -16969,7 +17600,7 @@ function validateAndShapeAttachments(raws, conversationAccountId, sessionId, mes
     let reason = null;
     if (!a.attachmentId || !a.filename || !a.mimeType || !a.storagePath) reason = "schema-fail";
     else if (a.accountId !== conversationAccountId) reason = "account-mismatch";
-    else if (!existsSync31(a.storagePath)) reason = "missing-file";
+    else if (!existsSync32(a.storagePath)) reason = "missing-file";
     if (reason) {
       invalid++;
       try {
@@ -17495,8 +18126,8 @@ app19.put("/:id/label", requireAdminSession, async (c) => {
 var sessions_default = app19;
 
 // app/lib/claude-agent/spawn-context.ts
-import { existsSync as existsSync32, readFileSync as readFileSync33, readdirSync as readdirSync22, statSync as statSync15 } from "fs";
-import { dirname as dirname12, resolve as resolve24, join as join33 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync34, readdirSync as readdirSync23, statSync as statSync16 } from "fs";
+import { dirname as dirname12, resolve as resolve24, join as join34 } from "path";
 async function resolveOwnerProfileBlock(accountId, userId) {
   if (!userId) return { ok: false, reason: "missing-user-id" };
   try {
@@ -17537,14 +18168,14 @@ function frontmatterField(manifest, field2) {
 function extractPluginToolDescriptions(pluginDir) {
   const out = /* @__PURE__ */ new Map();
   const candidates = [
-    join33(pluginDir, "mcp/dist/index.js"),
-    join33(pluginDir, "mcp/src/index.ts")
+    join34(pluginDir, "mcp/dist/index.js"),
+    join34(pluginDir, "mcp/src/index.ts")
   ];
   let raw = null;
   for (const path3 of candidates) {
-    if (!existsSync32(path3)) continue;
+    if (!existsSync33(path3)) continue;
     try {
-      raw = readFileSync33(path3, "utf-8");
+      raw = readFileSync34(path3, "utf-8");
       break;
     } catch {
     }
@@ -17594,25 +18225,25 @@ function parseSkillPathsFromFrontmatter(fm) {
 function listPluginDirs(accountPluginsDir) {
   const out = /* @__PURE__ */ new Map();
   const platformPlugins = resolve24(PLATFORM_ROOT, "plugins");
-  if (existsSync32(platformPlugins)) {
-    for (const name of readdirSync22(platformPlugins)) {
-      const dir = join33(platformPlugins, name);
+  if (existsSync33(platformPlugins)) {
+    for (const name of readdirSync23(platformPlugins)) {
+      const dir = join34(platformPlugins, name);
       try {
-        if (statSync15(dir).isDirectory()) out.set(name, dir);
+        if (statSync16(dir).isDirectory()) out.set(name, dir);
       } catch {
       }
     }
   }
   const premiumRoot = resolve24(dirname12(PLATFORM_ROOT), "premium-plugins");
-  if (existsSync32(premiumRoot)) {
-    for (const bundle of readdirSync22(premiumRoot)) {
-      const bundlePlugins = join33(premiumRoot, bundle, "plugins");
-      if (!existsSync32(bundlePlugins)) continue;
+  if (existsSync33(premiumRoot)) {
+    for (const bundle of readdirSync23(premiumRoot)) {
+      const bundlePlugins = join34(premiumRoot, bundle, "plugins");
+      if (!existsSync33(bundlePlugins)) continue;
       try {
-        for (const name of readdirSync22(bundlePlugins)) {
-          const dir = join33(bundlePlugins, name);
+        for (const name of readdirSync23(bundlePlugins)) {
+          const dir = join34(bundlePlugins, name);
           try {
-            if (statSync15(dir).isDirectory()) out.set(name, dir);
+            if (statSync16(dir).isDirectory()) out.set(name, dir);
           } catch {
           }
         }
@@ -17620,13 +18251,13 @@ function listPluginDirs(accountPluginsDir) {
       }
     }
   }
-  if (accountPluginsDir && existsSync32(accountPluginsDir)) {
+  if (accountPluginsDir && existsSync33(accountPluginsDir)) {
     try {
-      for (const name of readdirSync22(accountPluginsDir)) {
+      for (const name of readdirSync23(accountPluginsDir)) {
         if (out.has(name)) continue;
-        const dir = join33(accountPluginsDir, name);
+        const dir = join34(accountPluginsDir, name);
         try {
-          if (statSync15(dir).isDirectory()) out.set(name, dir);
+          if (statSync16(dir).isDirectory()) out.set(name, dir);
         } catch {
         }
       }
@@ -17639,11 +18270,11 @@ function accountPluginsDirFor(accountId) {
   return resolve24(PLATFORM_ROOT, "..", "data/accounts", accountId, "plugins");
 }
 function listAccountPluginNames(accountPluginsDir) {
-  if (!existsSync32(accountPluginsDir)) return [];
+  if (!existsSync33(accountPluginsDir)) return [];
   try {
-    return readdirSync22(accountPluginsDir).filter((name) => {
+    return readdirSync23(accountPluginsDir).filter((name) => {
       try {
-        return statSync15(join33(accountPluginsDir, name)).isDirectory();
+        return statSync16(join34(accountPluginsDir, name)).isDirectory();
       } catch {
         return false;
       }
@@ -17654,9 +18285,9 @@ function listAccountPluginNames(accountPluginsDir) {
 }
 function readEnabledPlugins(accountId) {
   const accountFile = resolve24(PLATFORM_ROOT, "..", "data/accounts", accountId, "account.json");
-  if (!existsSync32(accountFile)) return /* @__PURE__ */ new Set();
+  if (!existsSync33(accountFile)) return /* @__PURE__ */ new Set();
   try {
-    const parsed = JSON.parse(readFileSync33(accountFile, "utf-8"));
+    const parsed = JSON.parse(readFileSync34(accountFile, "utf-8"));
     return new Set(
       Array.isArray(parsed.enabledPlugins) ? parsed.enabledPlugins.filter((p) => typeof p === "string") : []
     );
@@ -17665,10 +18296,10 @@ function readEnabledPlugins(accountId) {
   }
 }
 function readFrontmatter(path3) {
-  if (!existsSync32(path3)) return null;
+  if (!existsSync33(path3)) return null;
   let raw;
   try {
-    raw = readFileSync33(path3, "utf-8");
+    raw = readFileSync34(path3, "utf-8");
   } catch {
     return null;
   }
@@ -17686,7 +18317,7 @@ function computeActivePlugins(accountId) {
   for (const name of emitNames) {
     const dir = pluginDirs.get(name);
     if (!dir) continue;
-    const fm = readFrontmatter(join33(dir, "PLUGIN.md"));
+    const fm = readFrontmatter(join34(dir, "PLUGIN.md"));
     if (!fm) continue;
     const description = frontmatterField(`---
 ${fm}
@@ -17703,7 +18334,7 @@ ${fm}
       `plugin-manifest-tool-coverage plugin=${name} tools=${tools.length} with-desc=${withDesc}`
     );
     if (toolNames.length > 0 && descMap.size === 0) {
-      const hasSource = existsSync32(join33(dir, "mcp/dist/index.js")) || existsSync32(join33(dir, "mcp/src/index.ts"));
+      const hasSource = existsSync33(join34(dir, "mcp/dist/index.js")) || existsSync33(join34(dir, "mcp/src/index.ts"));
       if (hasSource) {
         console.warn(
           `[spawn-context] WARN plugin=${name} mcp source present but tool-description regex matched zero entries \u2014 SDK upgrade may have changed the registration shape`
@@ -17713,7 +18344,7 @@ ${fm}
     const skillPaths = parseSkillPathsFromFrontmatter(fm);
     const skills = [];
     for (const relPath of skillPaths) {
-      const skillPath = join33(dir, relPath);
+      const skillPath = join34(dir, relPath);
       const skillFm = readFrontmatter(skillPath);
       if (!skillFm) continue;
       const skillName = frontmatterField(`---
@@ -17730,10 +18361,10 @@ ${skillFm}
 }
 function computeSpecialistDomains(accountId) {
   const specialistsDir = resolve24(PLATFORM_ROOT, "..", "data/accounts", accountId, "specialists", "agents");
-  if (!existsSync32(specialistsDir)) return [];
+  if (!existsSync33(specialistsDir)) return [];
   let entries2;
   try {
-    entries2 = readdirSync22(specialistsDir);
+    entries2 = readdirSync23(specialistsDir);
   } catch {
     return [];
   }
@@ -17757,7 +18388,7 @@ function computeSpecialistDomains(accountId) {
   const out = [];
   for (const file of entries2.sort()) {
     if (!file.endsWith(".md")) continue;
-    const fm = readFrontmatter(join33(specialistsDir, file));
+    const fm = readFrontmatter(join34(specialistsDir, file));
     if (!fm) continue;
     const wrapped = `---
 ${fm}
@@ -17776,10 +18407,10 @@ ${fm}
 }
 function computeDormantPlugins(accountId) {
   const accountFile = resolve24(PLATFORM_ROOT, "..", "data/accounts", accountId, "account.json");
-  if (!existsSync32(accountFile)) return [];
+  if (!existsSync33(accountFile)) return [];
   let enabled;
   try {
-    const raw = readFileSync33(accountFile, "utf-8");
+    const raw = readFileSync34(accountFile, "utf-8");
     const parsed = JSON.parse(raw);
     enabled = new Set(
       Array.isArray(parsed.enabledPlugins) ? parsed.enabledPlugins.filter((p) => typeof p === "string") : []
@@ -17791,10 +18422,10 @@ function computeDormantPlugins(accountId) {
     return [];
   }
   const pluginsDir = resolve24(PLATFORM_ROOT, "plugins");
-  if (!existsSync32(pluginsDir)) return [];
+  if (!existsSync33(pluginsDir)) return [];
   let entries2;
   try {
-    entries2 = readdirSync22(pluginsDir);
+    entries2 = readdirSync23(pluginsDir);
   } catch {
     return [];
   }
@@ -17802,10 +18433,10 @@ function computeDormantPlugins(accountId) {
   for (const name of entries2) {
     if (enabled.has(name)) continue;
     const manifestPath = resolve24(pluginsDir, name, "PLUGIN.md");
-    if (!existsSync32(manifestPath)) continue;
+    if (!existsSync33(manifestPath)) continue;
     let manifest;
     try {
-      manifest = readFileSync33(manifestPath, "utf-8");
+      manifest = readFileSync34(manifestPath, "utf-8");
     } catch {
       continue;
     }
@@ -17819,13 +18450,13 @@ function computeDormantPlugins(accountId) {
 }
 
 // server/routes/admin/claude-sessions.ts
-import { existsSync as existsSync33, readFileSync as readFileSync34 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync35 } from "fs";
 import { resolve as resolve25 } from "path";
 function readTunnelState(brandConfigDir) {
   const statePath = `${process.env.HOME ?? ""}/${brandConfigDir}/cloudflared/tunnel.state`;
-  if (!existsSync33(statePath)) return null;
+  if (!existsSync34(statePath)) return null;
   try {
-    const parsed = JSON.parse(readFileSync34(statePath, "utf-8"));
+    const parsed = JSON.parse(readFileSync35(statePath, "utf-8"));
     const tunnelId = typeof parsed.tunnelId === "string" ? parsed.tunnelId : null;
     const tunnelName = typeof parsed.tunnelName === "string" ? parsed.tunnelName : null;
     const domain = typeof parsed.domain === "string" ? parsed.domain : null;
@@ -17839,7 +18470,7 @@ function resolveTunnelUrl() {
   const platformRoot5 = process.env.MAXY_PLATFORM_ROOT ?? process.env.PLATFORM_ROOT ?? resolve25(process.cwd(), "..");
   let brand;
   try {
-    brand = JSON.parse(readFileSync34(resolve25(platformRoot5, "config", "brand.json"), "utf-8"));
+    brand = JSON.parse(readFileSync35(resolve25(platformRoot5, "config", "brand.json"), "utf-8"));
   } catch {
     return null;
   }
@@ -18152,11 +18783,11 @@ app22.get("/", requireAdminSession, async (c) => {
 var events_default = app22;
 
 // server/routes/admin/files.ts
-import { createReadStream as createReadStream2, createWriteStream as createWriteStream2, existsSync as existsSync34 } from "fs";
+import { createReadStream as createReadStream2, createWriteStream as createWriteStream2, existsSync as existsSync35 } from "fs";
 import { readdir as readdir4, readFile as readFile7, stat as stat6, mkdir as mkdir4, unlink as unlink3, rename as rename2, rmdir } from "fs/promises";
 import { realpathSync as realpathSync7 } from "fs";
 import { randomUUID as randomUUID10 } from "crypto";
-import { basename as basename11, dirname as dirname13, join as join35, relative as relative5, resolve as resolve27, sep as sep8 } from "path";
+import { basename as basename11, dirname as dirname13, join as join36, relative as relative5, resolve as resolve27, sep as sep8 } from "path";
 import { Readable as Readable2 } from "stream";
 
 // ../lib/graph-trash/src/index.ts
@@ -18474,7 +19105,7 @@ async function cascadeDeleteDocument(params) {
 
 // app/lib/file-index.ts
 import * as fsp from "fs/promises";
-import { resolve as resolve26, relative as relative4, join as join34, basename as basename10, extname as extname2, sep as sep7 } from "path";
+import { resolve as resolve26, relative as relative4, join as join35, basename as basename10, extname as extname2, sep as sep7 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -18556,7 +19187,7 @@ async function extractPdf(absolute) {
   return stdout.trim();
 }
 async function ocrPdf(absolute) {
-  const outPdf = join34(tmpdir2(), `file-index-ocr-${process.pid}-${Date.now()}.pdf`);
+  const outPdf = join35(tmpdir2(), `file-index-ocr-${process.pid}-${Date.now()}.pdf`);
   try {
     await execFileAsync2(
       "ocrmypdf",
@@ -18618,7 +19249,7 @@ async function readDisplayName(absolute) {
   const stem = dot === -1 ? base : base.slice(0, dot);
   if (base === `${stem}.meta.json`) return null;
   try {
-    const raw = await fsp.readFile(join34(dir, `${stem}.meta.json`), "utf-8");
+    const raw = await fsp.readFile(join35(dir, `${stem}.meta.json`), "utf-8");
     const meta = JSON.parse(raw);
     const dn = meta.displayName ?? meta.filename;
     return typeof dn === "string" && dn.length > 0 ? dn : null;
@@ -18639,7 +19270,7 @@ async function walkSubtree(root, dataRoot, out) {
   for (const entry of entries2) {
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory() && entry.name === ".uploads-tmp") continue;
-    const abs = join34(root, entry.name);
+    const abs = join35(root, entry.name);
     if (entry.isDirectory()) {
       const sub = await walkSubtree(abs, dataRoot, out);
       if (!sub.clean) clean = false;
@@ -19012,7 +19643,7 @@ var UPLOAD_TMP_DIR = ".uploads-tmp";
 var UUID_RE4 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 async function readMeta(absDir, baseName) {
   try {
-    const raw = await readFile7(join35(absDir, `${baseName}.meta.json`), "utf8");
+    const raw = await readFile7(join36(absDir, `${baseName}.meta.json`), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.filename === "string") {
       return { filename: parsed.filename, mimeType: typeof parsed.mimeType === "string" ? parsed.mimeType : void 0 };
@@ -19067,7 +19698,7 @@ async function servableFilesIn(dirAbs, uuid) {
 }
 async function enrich(absolute, entry, accountNames) {
   if (entry.kind === "directory" && UUID_RE4.test(entry.name)) {
-    const dirAbs = join35(absolute, entry.name);
+    const dirAbs = join36(absolute, entry.name);
     const meta = await readMeta(dirAbs, entry.name);
     if (meta?.filename) {
       const servable = await servableFilesIn(dirAbs, entry.name);
@@ -19076,7 +19707,7 @@ async function enrich(absolute, entry, accountNames) {
         let size = null;
         let modifiedAt = entry.modifiedAt;
         try {
-          const st = await stat6(join35(dirAbs, innerName));
+          const st = await stat6(join36(dirAbs, innerName));
           size = st.size;
           modifiedAt = st.mtime.toISOString();
         } catch {
@@ -19269,7 +19900,7 @@ app23.get("/", requireAdminSession, async (c) => {
       const childRel = relPath === "" || relPath === "." ? name : `${relPath}/${name}`;
       const protectedEntry = isProtectedFromDeletion(childRel).protected;
       try {
-        const entryPath = join35(absolute, name);
+        const entryPath = join36(absolute, name);
         const s = await stat6(entryPath);
         entries2.push({
           name,
@@ -19298,7 +19929,7 @@ app23.get("/", requireAdminSession, async (c) => {
     const displayPath = buildDisplayPath(relPath, accountNames);
     if (groupReq || isAccountRoot(relPath)) {
       const acctId = relPath.split("/")[1] ?? accountId;
-      const schemaMd = await readFile7(join35(absolute, "SCHEMA.md"), "utf8").catch(() => null);
+      const schemaMd = await readFile7(join36(absolute, "SCHEMA.md"), "utf8").catch(() => null);
       const groups = classifyAccountRoot(schemaMd, entries2.map((e) => e.name));
       console.error(
         `[data-schema] op=classify account=${acctId} status=${groups.parsed ? "ok" : "parse-failed"} reason=${groups.reason} entries=${entries2.length} home=${groups.home.join(",") || "none"} system=${groups.system.length} unknown=${groups.unknown.join(",") || "none"}`
@@ -19336,7 +19967,7 @@ app23.get("/", requireAdminSession, async (c) => {
       for (const name of homeDirs) {
         const base = byName.get(name);
         try {
-          const dirents = await readdir4(join35(absolute, name), { withFileTypes: true });
+          const dirents = await readdir4(join36(absolute, name), { withFileTypes: true });
           const visible = dirents.filter((d) => !d.name.startsWith("."));
           visible.sort((a, b) => {
             const ad = a.isDirectory() ? 0 : 1;
@@ -19401,7 +20032,7 @@ app23.get("/download", requireAdminSession, async (c) => {
       console.error(`[data] op=scratchpad-no-session sessionId="${sessionId.slice(0, 8)}\u2026"`);
       return c.json({ error: "Not found" }, 404);
     }
-    const meta = readSidecarMeta(join35(projectDir, `${sessionId}.meta.json`));
+    const meta = readSidecarMeta(join36(projectDir, `${sessionId}.meta.json`));
     if (!meta.accountId || meta.accountId !== accountId) {
       console.error(`[data] account-scope-blocked root="scratchpad" sessionId="${sessionId.slice(0, 8)}\u2026" account=${accountId.slice(0, 8)}\u2026`);
       return c.json({ error: "Not found" }, 404);
@@ -19496,7 +20127,7 @@ async function* walkRegularFiles(dirAbsolute) {
   const dirents = await readdir4(dirAbsolute, { withFileTypes: true });
   for (const d of dirents) {
     if (d.isSymbolicLink()) continue;
-    const child = join35(dirAbsolute, d.name);
+    const child = join36(dirAbsolute, d.name);
     if (d.isDirectory()) {
       yield* walkRegularFiles(child);
       continue;
@@ -19606,7 +20237,7 @@ async function resolveUploadTarget(c, accountId, uid) {
   const base = resolveOwnAccountWrite(rawDir, accountId, "POST /api/admin/files/upload");
   if (!base.ok) return { ok: false, status: base.status, error: base.error };
   const relDir = relpath ? dirname13(relpath) : ".";
-  const destRel = relDir === "." ? base.relative : join35(base.relative, relDir);
+  const destRel = relDir === "." ? base.relative : join36(base.relative, relDir);
   if (crossesForeignAccountPartition(destRel, accountId)) {
     console.error(`[data] account-scope-blocked endpoint="POST /api/admin/files/upload" path="${destRel}" account=${accountId.slice(0, 8)}\u2026`);
     return { ok: false, status: 404, error: "Not found" };
@@ -19680,7 +20311,7 @@ app23.post("/upload", requireAdminSession, async (c) => {
     });
     await unlink3(tmpPath).catch(() => {
     });
-    const tempRemoved = !existsSync34(tmpPath);
+    const tempRemoved = !existsSync35(tmpPath);
     console.error(`[data-upload] op=cleanup uid=${uid} tempRemoved=${tempRemoved}`);
   };
   const reader = body.getReader();
@@ -19754,7 +20385,7 @@ async function discardChunkUpload(uploadId, state) {
   });
   await unlink3(state.tmpPath).catch(() => {
   });
-  const tempRemoved = !existsSync34(state.tmpPath);
+  const tempRemoved = !existsSync35(state.tmpPath);
   console.error(`[data-upload] op=cleanup uid=${uploadId} tempRemoved=${tempRemoved}`);
 }
 async function writeChunkBody(body, out, alreadyReceived, ceiling) {
@@ -19983,7 +20614,7 @@ app23.delete("/", requireAdminSession, async (c) => {
     const dot = base.lastIndexOf(".");
     const stem = dot === -1 ? base : base.slice(0, dot);
     const containerDir = dirname13(absolute);
-    const sidecarPath = UUID_RE4.test(stem) && base !== `${stem}.meta.json` ? join35(containerDir, `${stem}.meta.json`) : null;
+    const sidecarPath = UUID_RE4.test(stem) && base !== `${stem}.meta.json` ? join36(containerDir, `${stem}.meta.json`) : null;
     const isAttachmentContainer = UUID_RE4.test(stem) && basename11(containerDir) === stem;
     await unlink3(absolute);
     if (sidecarPath) {
@@ -19993,7 +20624,7 @@ app23.delete("/", requireAdminSession, async (c) => {
       }
     }
     if (isAttachmentContainer) {
-      await unlink3(join35(containerDir, `${stem}${EXTRACTED_TEXT_SUFFIX}`)).catch(() => {
+      await unlink3(join36(containerDir, `${stem}${EXTRACTED_TEXT_SUFFIX}`)).catch(() => {
       });
       await rmdir(containerDir).catch(() => {
       });
@@ -20172,7 +20803,7 @@ function applyBacklinkBoost(hits) {
 }
 
 // ../lib/graph-search/src/dedup.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 var DEFAULT_LAYERS = [
   "nodeId",
   "slug",
@@ -20199,7 +20830,7 @@ function readContentHash(props) {
   const content = props["content"];
   const source = typeof compiled === "string" && compiled.length > 0 ? compiled : typeof content === "string" && content.length > 0 ? content : null;
   if (source === null) return null;
-  return createHash5("sha256").update(source).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(source).digest("hex").slice(0, 16);
 }
 function dedup(hits, layers = DEFAULT_LAYERS) {
   const sorted = [...hits].sort((a, b) => b.score - a.score);
@@ -21102,8 +21733,8 @@ function isHiddenByDefault(label) {
 
 // server/lib/top-level-labels.ts
 var import_dist5 = __toESM(require_dist4(), 1);
-import { readdirSync as readdirSync23, readFileSync as readFileSync35 } from "fs";
-import { join as join36, resolve as resolve28 } from "path";
+import { readdirSync as readdirSync24, readFileSync as readFileSync36 } from "fs";
+import { join as join37, resolve as resolve28 } from "path";
 var STATIC_TOP_LEVEL_LABELS = Object.freeze(
   /* @__PURE__ */ new Set([
     // Base-schema infra (schema-base.md has no top-level section).
@@ -21207,7 +21838,7 @@ function parseTopLevelLabels(content) {
 }
 function resolveReferencesDir() {
   if (process.env.MAXY_PLATFORM_ROOT) {
-    return join36(process.env.MAXY_PLATFORM_ROOT, "plugins", "memory", "references");
+    return join37(process.env.MAXY_PLATFORM_ROOT, "plugins", "memory", "references");
   }
   return resolve28(import.meta.dirname, "../../../plugins/memory/references");
 }
@@ -21215,9 +21846,9 @@ function parseTableTopLevelLabels(referencesDir) {
   const labels = /* @__PURE__ */ new Set();
   const contributingFiles = [];
   try {
-    const fileNames = readdirSync23(referencesDir).filter((f) => f.startsWith("schema-") && f.endsWith(".md")).sort();
+    const fileNames = readdirSync24(referencesDir).filter((f) => f.startsWith("schema-") && f.endsWith(".md")).sort();
     for (const fileName of fileNames) {
-      const content = readFileSync35(join36(referencesDir, fileName), "utf-8");
+      const content = readFileSync36(join37(referencesDir, fileName), "utf-8");
       const parsed = parseTopLevelLabels(content);
       if (parsed.length > 0) contributingFiles.push(fileName);
       for (const label of parsed) labels.add(label);
@@ -22375,7 +23006,7 @@ var graph_default_view_default = app29;
 // server/routes/admin/sidebar-artefacts.ts
 import { readdir as readdir5, stat as stat7 } from "fs/promises";
 import { resolve as resolve29, relative as relative6, isAbsolute as isAbsolute2, sep as sep9, basename as basename12 } from "path";
-import { existsSync as existsSync35 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 var LIMIT = 50;
 var ADMIN_AGENT_FILES = ["IDENTITY.md", "SOUL.md", "KNOWLEDGE.md"];
 function toDataRootRelPath(absPath) {
@@ -22487,7 +23118,7 @@ async function fetchAgentTemplateRows(accountDir) {
 async function unionSpecialistFilenames(overrideDir, bundledDir) {
   const names = /* @__PURE__ */ new Set();
   for (const dir of [overrideDir, bundledDir]) {
-    if (!existsSync35(dir)) continue;
+    if (!existsSync36(dir)) continue;
     try {
       const entries2 = await readdir5(dir);
       for (const entry of entries2) {
@@ -22502,7 +23133,7 @@ async function unionSpecialistFilenames(overrideDir, bundledDir) {
 }
 async function readAgentTemplateRow(inp) {
   let chosenPath = null;
-  if (existsSync35(inp.overridePath)) {
+  if (existsSync36(inp.overridePath)) {
     try {
       validateFilePathInAccount(inp.overridePath, inp.overrideRoot);
       chosenPath = inp.overridePath;
@@ -22513,7 +23144,7 @@ async function readAgentTemplateRow(inp) {
       );
       return null;
     }
-  } else if (existsSync35(inp.bundledPath)) {
+  } else if (existsSync36(inp.bundledPath)) {
     if (!isWithin(inp.bundledPath, inp.bundledRoot)) {
       console.error(
         `[admin/sidebar-artefacts] agent-template-read-failed agent=${inp.displayName} kind=${inp.logName} error="bundled path outside PLATFORM_ROOT"`
@@ -22555,19 +23186,19 @@ function isWithin(target, root) {
 var sidebar_artefacts_default = app30;
 
 // server/channel-session-override.ts
-import { readFileSync as readFileSync36, writeFileSync as writeFileSync13, renameSync as renameSync9 } from "fs";
-import { join as join37 } from "path";
+import { readFileSync as readFileSync37, writeFileSync as writeFileSync14, renameSync as renameSync10 } from "fs";
+import { join as join38 } from "path";
 var FILE2 = "channel-session-override.json";
 var UUID3 = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 function channelOverridePath(accountDir) {
-  return join37(accountDir, FILE2);
+  return join38(accountDir, FILE2);
 }
 function senderKey(channel, senderId) {
   return `${channel}:${senderId}`;
 }
 function readRaw2(accountDir) {
   try {
-    return JSON.parse(readFileSync36(channelOverridePath(accountDir), "utf8"));
+    return JSON.parse(readFileSync37(channelOverridePath(accountDir), "utf8"));
   } catch {
     return null;
   }
@@ -22589,8 +23220,8 @@ function writeChannelOverrideId(accountDir, channel, senderId, sessionId) {
   bySender[senderKey(channel, senderId)] = sessionId;
   const path3 = channelOverridePath(accountDir);
   const tmp = `${path3}.${process.pid}.tmp`;
-  writeFileSync13(tmp, JSON.stringify({ bySender }, null, 2), "utf8");
-  renameSync9(tmp, path3);
+  writeFileSync14(tmp, JSON.stringify({ bySender }, null, 2), "utf8");
+  renameSync10(tmp, path3);
 }
 function clearChannelOverrideForSession(accountDir, sessionId) {
   const raw = readRaw2(accountDir);
@@ -22605,8 +23236,8 @@ function clearChannelOverrideForSession(accountDir, sessionId) {
   if (cleared.length === 0) return [];
   const path3 = channelOverridePath(accountDir);
   const tmp = `${path3}.${process.pid}.tmp`;
-  writeFileSync13(tmp, JSON.stringify({ bySender: kept }, null, 2), "utf8");
-  renameSync9(tmp, path3);
+  writeFileSync14(tmp, JSON.stringify({ bySender: kept }, null, 2), "utf8");
+  renameSync10(tmp, path3);
   return cleared;
 }
 
@@ -22956,24 +23587,24 @@ var session_rc_spawn_default = app36;
 import { randomUUID as randomUUID12 } from "crypto";
 
 // server/wa-descriptor.ts
-import { resolve as resolve30, join as join38 } from "path";
+import { resolve as resolve30, join as join39 } from "path";
 function waGatewayUrl() {
   return `http://127.0.0.1:${process.env.MAXY_UI_INTERNAL_PORT ?? ""}`;
 }
 function waServerPath() {
-  return process.env.MAXY_WA_CHANNEL_SERVER_PATH ?? resolve30(process.env.MAXY_PLATFORM_ROOT ?? join38(__dirname, ".."), "services/whatsapp-channel/dist/server.js");
+  return process.env.MAXY_WA_CHANNEL_SERVER_PATH ?? resolve30(process.env.MAXY_PLATFORM_ROOT ?? join39(__dirname, ".."), "services/whatsapp-channel/dist/server.js");
 }
 function waChannelDescriptor(senderId) {
   return { senderId, gatewayUrl: waGatewayUrl(), serverPath: waServerPath() };
 }
 
 // server/telegram-descriptor.ts
-import { resolve as resolve31, join as join39 } from "path";
+import { resolve as resolve31, join as join40 } from "path";
 function telegramGatewayUrl() {
   return `http://127.0.0.1:${process.env.MAXY_UI_INTERNAL_PORT ?? ""}`;
 }
 function telegramServerPath() {
-  return process.env.MAXY_TELEGRAM_CHANNEL_SERVER_PATH ?? resolve31(process.env.MAXY_PLATFORM_ROOT ?? join39(__dirname, ".."), "services/telegram-channel/dist/server.js");
+  return process.env.MAXY_TELEGRAM_CHANNEL_SERVER_PATH ?? resolve31(process.env.MAXY_PLATFORM_ROOT ?? join40(__dirname, ".."), "services/telegram-channel/dist/server.js");
 }
 function telegramChannelDescriptor(senderId) {
   return { senderId, gatewayUrl: telegramGatewayUrl(), serverPath: telegramServerPath() };
@@ -23257,14 +23888,14 @@ app38.get("/", async (c) => {
 var system_stats_default = app38;
 
 // server/routes/admin/health.ts
-import { existsSync as existsSync36, readFileSync as readFileSync37 } from "fs";
-import { resolve as resolve32, join as join40 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync38 } from "fs";
+import { resolve as resolve32, join as join41 } from "path";
 var PLATFORM_ROOT6 = process.env.MAXY_PLATFORM_ROOT ?? resolve32(process.cwd(), "..");
 var brandHostname = "maxy";
-var brandJsonPath = join40(PLATFORM_ROOT6, "config", "brand.json");
-if (existsSync36(brandJsonPath)) {
+var brandJsonPath = join41(PLATFORM_ROOT6, "config", "brand.json");
+if (existsSync37(brandJsonPath)) {
   try {
-    const brand = JSON.parse(readFileSync37(brandJsonPath, "utf-8"));
+    const brand = JSON.parse(readFileSync38(brandJsonPath, "utf-8"));
     if (brand.hostname) brandHostname = brand.hostname;
   } catch {
   }
@@ -23273,8 +23904,8 @@ var VERSION_FILE = resolve32(PLATFORM_ROOT6, `config/.${brandHostname}-version`)
 var PROCESS_STARTED_AT = (/* @__PURE__ */ new Date()).toISOString();
 var PROBE_TIMEOUT_MS = 1e3;
 function readVersion() {
-  if (!existsSync36(VERSION_FILE)) return "unknown";
-  return readFileSync37(VERSION_FILE, "utf-8").trim() || "unknown";
+  if (!existsSync37(VERSION_FILE)) return "unknown";
+  return readFileSync38(VERSION_FILE, "utf-8").trim() || "unknown";
 }
 async function probeConversationDb() {
   let session;
@@ -24050,8 +24681,8 @@ app46.post("/launch", requireAdminSession, async (c) => {
 var browser_default = app46;
 
 // server/routes/admin/calendar.ts
-import { existsSync as existsSync37 } from "fs";
-import { join as join42 } from "path";
+import { existsSync as existsSync38 } from "fs";
+import { join as join43 } from "path";
 
 // server/lib/calendar-ics.ts
 var CRLF = "\r\n";
@@ -24150,8 +24781,8 @@ function countVEvents(ics) {
 }
 
 // server/lib/calendar-availability.ts
-import { readFileSync as readFileSync38 } from "fs";
-import { join as join41 } from "path";
+import { readFileSync as readFileSync39 } from "fs";
+import { join as join42 } from "path";
 var AVAILABILITY_FILENAME = "calendar-availability.json";
 var REQUIRED_KEYS = [
   "timezone",
@@ -24160,10 +24791,10 @@ var REQUIRED_KEYS = [
   "weekly"
 ];
 function readAvailabilityConfig(accountDir) {
-  const path3 = join41(accountDir, AVAILABILITY_FILENAME);
+  const path3 = join42(accountDir, AVAILABILITY_FILENAME);
   let raw;
   try {
-    raw = readFileSync38(path3, "utf-8");
+    raw = readFileSync39(path3, "utf-8");
   } catch {
     throw new Error(`availability not configured: ${path3} not found`);
   }
@@ -24522,7 +25153,7 @@ app47.get("/booking-link", requireAdminSession, (c) => {
       console.error('[calendar] op=booking-link-fail err="no account configured"');
       return c.json({ bookingDomain: null });
     }
-    if (!existsSync37(join42(account.accountDir, AVAILABILITY_FILENAME))) {
+    if (!existsSync38(join43(account.accountDir, AVAILABILITY_FILENAME))) {
       console.log("[calendar] op=booking-link bookingDomain=none source=availability-config");
       return c.json({ bookingDomain: null });
     }
@@ -24724,7 +25355,7 @@ app48.delete("/:eventId", requireAdminSession, async (c) => {
 var routines_default = app48;
 
 // server/routes/admin/skills.ts
-import { existsSync as existsSync38, readdirSync as readdirSync24, readFileSync as readFileSync39, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync39, readdirSync as readdirSync25, readFileSync as readFileSync40, rmSync as rmSync3 } from "fs";
 import { resolve as resolve33 } from "path";
 var app49 = new Hono();
 var NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
@@ -24748,9 +25379,9 @@ function stripQuotes(s) {
   return s;
 }
 function subdirs2(dir) {
-  if (!existsSync38(dir)) return [];
+  if (!existsSync39(dir)) return [];
   try {
-    return readdirSync24(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    return readdirSync25(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
   }
@@ -24771,11 +25402,11 @@ app49.get("/", requireAdminSession, async (c) => {
       const skillsDir = resolve33(pluginsDir, plugin, "skills");
       for (const skill of subdirs2(skillsDir)) {
         const skillMd = resolve33(skillsDir, skill, "SKILL.md");
-        if (!existsSync38(skillMd)) continue;
+        if (!existsSync39(skillMd)) continue;
         try {
-          const { frontmatter } = splitSkillMd(readFileSync39(skillMd, "utf-8"));
+          const { frontmatter } = splitSkillMd(readFileSync40(skillMd, "utf-8"));
           const refsDir = resolve33(skillsDir, skill, "references");
-          const refCount = existsSync38(refsDir) ? readdirSync24(refsDir, { withFileTypes: true }).filter((e) => e.isFile()).length : 0;
+          const refCount = existsSync39(refsDir) ? readdirSync25(refsDir, { withFileTypes: true }).filter((e) => e.isFile()).length : 0;
           skills.push({ plugin, skill, description: frontmatter.description, refCount });
         } catch (err) {
           console.error(`[admin:skills] op=list-skip plugin=${plugin} skill=${skill} reason="${err instanceof Error ? err.message : String(err)}"`);
@@ -24799,13 +25430,13 @@ app49.get("/:plugin/:skill", requireAdminSession, async (c) => {
   }
   const skillDir = resolve33(acct.accountDir, "plugins", plugin, "skills", skill);
   const skillMd = resolve33(skillDir, "SKILL.md");
-  const found = existsSync38(skillMd);
+  const found = existsSync39(skillMd);
   console.log(`[admin:skills] op=get plugin=${plugin} skill=${skill} found=${found}`);
   if (!found) return c.json({ error: "Skill not found" }, 404);
   try {
-    const { frontmatter, body } = splitSkillMd(readFileSync39(skillMd, "utf-8"));
+    const { frontmatter, body } = splitSkillMd(readFileSync40(skillMd, "utf-8"));
     const refsDir = resolve33(skillDir, "references");
-    const references = existsSync38(refsDir) ? readdirSync24(refsDir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name).sort() : [];
+    const references = existsSync39(refsDir) ? readdirSync25(refsDir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name).sort() : [];
     return c.json({ skill: { plugin, skill, frontmatter, body, references } });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -24825,7 +25456,7 @@ app49.delete("/:plugin/:skill", requireAdminSession, async (c) => {
   const pluginDir = resolve33(acct.accountDir, "plugins", plugin);
   const skillsDir = resolve33(pluginDir, "skills");
   const skillDir = resolve33(skillsDir, skill);
-  if (!existsSync38(resolve33(skillDir, "SKILL.md"))) {
+  if (!existsSync39(resolve33(skillDir, "SKILL.md"))) {
     console.error(`[admin:skills] op=delete outcome=rejected reason=not-found plugin=${plugin} skill=${skill}`);
     return c.json({ error: "Skill not found" }, 404);
   }
@@ -24833,7 +25464,7 @@ app49.delete("/:plugin/:skill", requireAdminSession, async (c) => {
     rmSync3(skillDir, { recursive: true, force: true });
     const pluginDirRemoved = subdirs2(skillsDir).length === 0;
     if (pluginDirRemoved) rmSync3(pluginDir, { recursive: true, force: true });
-    const skillDirGone = !existsSync38(skillDir);
+    const skillDirGone = !existsSync39(skillDir);
     if (!skillDirGone) {
       console.error(`[admin:skills] op=delete plugin=${plugin} skill=${skill} outcome=rejected reason=rm-incomplete skillDirGone=false`);
       return c.json({ error: "Delete did not remove the skill directory" }, 503);
@@ -25243,20 +25874,20 @@ app54.post("/", requireAdminSession, async (c) => {
 var task_time_adjust_default = app54;
 
 // app/lib/admin-roster.ts
-import { existsSync as existsSync39, readdirSync as readdirSync25, readFileSync as readFileSync40 } from "fs";
+import { existsSync as existsSync40, readdirSync as readdirSync26, readFileSync as readFileSync41 } from "fs";
 import { resolve as resolve34 } from "path";
 function readHouseAdminUserIds(accountsDir = ACCOUNTS_DIR) {
   let entries2;
   try {
-    entries2 = readdirSync25(accountsDir);
+    entries2 = readdirSync26(accountsDir);
   } catch {
     return [];
   }
   for (const entry of entries2) {
     const cfgPath = resolve34(accountsDir, entry, "account.json");
-    if (!existsSync39(cfgPath)) continue;
+    if (!existsSync40(cfgPath)) continue;
     try {
-      const cfg = JSON.parse(readFileSync40(cfgPath, "utf-8"));
+      const cfg = JSON.parse(readFileSync41(cfgPath, "utf-8"));
       if (cfg.role !== "house") continue;
       if (!Array.isArray(cfg.admins)) return [];
       return cfg.admins.map(
@@ -25435,7 +26066,7 @@ app56.get("/", requireAdminSession, async (c) => {
 var admin_users_list_default = app56;
 
 // server/routes/admin/activity.ts
-import { readdirSync as readdirSync26 } from "fs";
+import { readdirSync as readdirSync27 } from "fs";
 var app57 = new Hono();
 var TAG47 = "[activity]";
 function resolveHouseAccountId(accounts) {
@@ -25451,7 +26082,7 @@ function requestToken() {
 var short = (id) => id ? id.slice(0, 8) : "unset";
 function countAccountDirsOnDisk() {
   try {
-    return readdirSync26(ACCOUNTS_DIR, { withFileTypes: true }).filter(
+    return readdirSync27(ACCOUNTS_DIR, { withFileTypes: true }).filter(
       (e) => e.isDirectory() && !e.name.startsWith(".")
     ).length;
   } catch {
@@ -25855,7 +26486,7 @@ app61.route("/request-magic-link", request_magic_link_default);
 var access_default = app61;
 
 // server/routes/sites.ts
-import { existsSync as existsSync40, readFileSync as readFileSync41, realpathSync as realpathSync8, statSync as statSync17 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync42, realpathSync as realpathSync8, statSync as statSync18 } from "fs";
 import { resolve as resolve36 } from "path";
 var SAFE_SEG_RE = /^[a-z0-9_][a-z0-9_.-]{0,99}$/i;
 var MIME = {
@@ -25921,7 +26552,7 @@ app62.get("/:rel{.*}", (c) => {
   }
   let stat11;
   try {
-    stat11 = existsSync40(filePath) ? statSync17(filePath) : null;
+    stat11 = existsSync41(filePath) ? statSync18(filePath) : null;
   } catch {
     stat11 = null;
   }
@@ -25940,7 +26571,7 @@ app62.get("/:rel{.*}", (c) => {
     console.error(`[sites] path-traversal-rejected path=${reqPath} reason=escape status=403`);
     return c.text("Forbidden", 403);
   }
-  if (!existsSync40(filePath)) {
+  if (!existsSync41(filePath)) {
     console.error(`[sites] not-found path=${reqPath} status=404`);
     return c.text("Not found", 404);
   }
@@ -25959,7 +26590,7 @@ app62.get("/:rel{.*}", (c) => {
   }
   let body;
   try {
-    body = readFileSync41(realPath);
+    body = readFileSync42(realPath);
   } catch (err) {
     const code = err?.code;
     if (code === "EISDIR") {
@@ -25995,7 +26626,7 @@ var sites_default = app62;
 
 // app/lib/visitor-token.ts
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync42, writeFileSync as writeFileSync14 } from "fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync43, writeFileSync as writeFileSync15 } from "fs";
 import { dirname as dirname14 } from "path";
 var TOKEN_PREFIX = "v1.";
 var SECRET_BYTES = 32;
@@ -26004,7 +26635,7 @@ var cachedSecret = null;
 function getSecret() {
   if (cachedSecret) return cachedSecret;
   try {
-    const hex2 = readFileSync42(VISITOR_TOKEN_SECRET_FILE, "utf-8").trim();
+    const hex2 = readFileSync43(VISITOR_TOKEN_SECRET_FILE, "utf-8").trim();
     if (hex2.length === SECRET_BYTES * 2) {
       cachedSecret = Buffer.from(hex2, "hex");
       return cachedSecret;
@@ -26013,12 +26644,12 @@ function getSecret() {
   }
   const fresh = randomBytes(SECRET_BYTES).toString("hex");
   try {
-    mkdirSync8(dirname14(VISITOR_TOKEN_SECRET_FILE), { recursive: true, mode: 448 });
-    writeFileSync14(VISITOR_TOKEN_SECRET_FILE, fresh, { mode: 384, flag: "wx" });
+    mkdirSync9(dirname14(VISITOR_TOKEN_SECRET_FILE), { recursive: true, mode: 448 });
+    writeFileSync15(VISITOR_TOKEN_SECRET_FILE, fresh, { mode: 384, flag: "wx" });
     console.log(`[visitor-token] secret minted path=${VISITOR_TOKEN_SECRET_FILE}`);
   } catch {
   }
-  const hex = readFileSync42(VISITOR_TOKEN_SECRET_FILE, "utf-8").trim();
+  const hex = readFileSync43(VISITOR_TOKEN_SECRET_FILE, "utf-8").trim();
   cachedSecret = Buffer.from(hex, "hex");
   return cachedSecret;
 }
@@ -26071,8 +26702,8 @@ var VISITOR_COOKIE_NAME = "mxy_v";
 var VISITOR_COOKIE_MAX_AGE_SECONDS = Math.floor(DEFAULT_TTL_MS / 1e3);
 
 // app/lib/brand-config.ts
-import { existsSync as existsSync41, readFileSync as readFileSync43 } from "fs";
-import { join as join43 } from "path";
+import { existsSync as existsSync42, readFileSync as readFileSync44 } from "fs";
+import { join as join44 } from "path";
 var cached2 = null;
 var cachedAttempted = false;
 function readBrandConfig() {
@@ -26080,10 +26711,10 @@ function readBrandConfig() {
   cachedAttempted = true;
   const platformRoot5 = process.env.MAXY_PLATFORM_ROOT;
   if (!platformRoot5) return null;
-  const brandPath = join43(platformRoot5, "config", "brand.json");
-  if (!existsSync41(brandPath)) return null;
+  const brandPath = join44(platformRoot5, "config", "brand.json");
+  if (!existsSync42(brandPath)) return null;
   try {
-    cached2 = JSON.parse(readFileSync43(brandPath, "utf-8"));
+    cached2 = JSON.parse(readFileSync44(brandPath, "utf-8"));
     return cached2;
   } catch {
     return null;
@@ -26581,13 +27212,13 @@ var visitor_event_default = app65;
 
 // server/routes/session.ts
 import { resolve as resolve37 } from "path";
-import { existsSync as existsSync42, writeFileSync as writeFileSync15, mkdirSync as mkdirSync9 } from "fs";
+import { existsSync as existsSync43, writeFileSync as writeFileSync16, mkdirSync as mkdirSync10 } from "fs";
 var UUID_RE5 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function writeBrandingCache(accountId, agentSlug, branding) {
   try {
     const cacheDir = resolve37(MAXY_DIR, "branding-cache", accountId);
-    mkdirSync9(cacheDir, { recursive: true });
-    writeFileSync15(resolve37(cacheDir, `${agentSlug}.json`), JSON.stringify(branding), "utf-8");
+    mkdirSync10(cacheDir, { recursive: true });
+    writeFileSync16(resolve37(cacheDir, `${agentSlug}.json`), JSON.stringify(branding), "utf-8");
   } catch (err) {
     console.error(`[branding] cache write failed: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -26665,7 +27296,7 @@ app66.post("/", async (c) => {
   let agentConfig = null;
   if (account) {
     const agentDir = resolve37(account.accountDir, "agents", agentSlug);
-    if (!existsSync42(agentDir) || !existsSync42(resolve37(agentDir, "config.json"))) {
+    if (!existsSync43(agentDir) || !existsSync43(resolve37(agentDir, "config.json"))) {
       return c.json({ error: "Agent not found" }, 404);
     }
     agentConfig = resolveAgentConfig(account.accountDir, agentSlug);
@@ -26925,7 +27556,7 @@ var calendar_public_default = app67;
 // server/routes/portal-fetch.ts
 import { createReadStream as createReadStream3 } from "fs";
 import { stat as stat8, readFile as readFile9, realpath } from "fs/promises";
-import { join as join44, resolve as resolve38, sep as sep10 } from "path";
+import { join as join45, resolve as resolve38, sep as sep10 } from "path";
 import { Readable as Readable3 } from "stream";
 var app68 = new Hono();
 var TAG50 = "[portal-fetch]";
@@ -26998,7 +27629,7 @@ function isValidAccountId2(value) {
 }
 async function readExposeFolders2(accountDir) {
   try {
-    const cfg = JSON.parse(await readFile9(join44(accountDir, "data-portal.json"), "utf8"));
+    const cfg = JSON.parse(await readFile9(join45(accountDir, "data-portal.json"), "utf8"));
     return Array.isArray(cfg?.exposeFolders) ? cfg.exposeFolders.filter((f) => typeof f === "string") : [];
   } catch {
     return [];
@@ -27007,7 +27638,7 @@ async function readExposeFolders2(accountDir) {
 async function resolveFetchTarget(accountDir, relPath, ownerId) {
   let schemaText = null;
   try {
-    schemaText = await readFile9(join44(accountDir, "SCHEMA.md"), "utf8");
+    schemaText = await readFile9(join45(accountDir, "SCHEMA.md"), "utf8");
   } catch {
     schemaText = null;
   }
@@ -27177,8 +27808,8 @@ function startTimeEntryCensus(openSession, opts = {}) {
 }
 
 // app/lib/ledger-census.ts
-import { readdirSync as readdirSync27, readFileSync as readFileSync44, statSync as statSync18 } from "fs";
-import { join as join45 } from "path";
+import { readdirSync as readdirSync28, readFileSync as readFileSync45, statSync as statSync19 } from "fs";
+import { join as join46 } from "path";
 
 // ../lib/ledger-core/dist/reconcile.js
 var LEDGER_INDEX_NAMES = [
@@ -27226,16 +27857,16 @@ var DAY_MS = 864e5;
 function countWriteRejects24h(logDir, now) {
   let entries2;
   try {
-    entries2 = readdirSync27(logDir).filter((f) => f.startsWith("mcp-ledger-") && f.endsWith(".log"));
+    entries2 = readdirSync28(logDir).filter((f) => f.startsWith("mcp-ledger-") && f.endsWith(".log"));
   } catch {
     return 0;
   }
   let total = 0;
   for (const name of entries2) {
-    const path3 = join45(logDir, name);
+    const path3 = join46(logDir, name);
     try {
-      if (now - statSync18(path3).mtimeMs > DAY_MS) continue;
-      for (const line of readFileSync44(path3, "utf8").split("\n")) {
+      if (now - statSync19(path3).mtimeMs > DAY_MS) continue;
+      for (const line of readFileSync45(path3, "utf8").split("\n")) {
         if (line.includes("[graph-write] reject")) total += 1;
       }
     } catch {
@@ -27730,8 +28361,8 @@ async function migrateUploads(opts = {}) {
 
 // app/lib/migrate-admin-webchat-sidecars.ts
 import { readdir as readdir7, readFile as readFile10, rename as rename4, writeFile as writeFile5, unlink as unlink4 } from "fs/promises";
-import { existsSync as existsSync43 } from "fs";
-import { join as join46 } from "path";
+import { existsSync as existsSync44 } from "fs";
+import { join as join47 } from "path";
 var ADMIN_ROLE2 = "admin";
 var WEBCHAT_CHANNEL2 = "webchat";
 var SESSION_META_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.meta\.json$/i;
@@ -27760,7 +28391,7 @@ async function writeRaw(path3, obj) {
     await rename4(tmp, path3);
   } catch (err) {
     try {
-      if (existsSync43(tmp)) await unlink4(tmp);
+      if (existsSync44(tmp)) await unlink4(tmp);
     } catch {
     }
     throw err;
@@ -27776,7 +28407,7 @@ async function collectLiveSidecars(projectsRoot) {
   }
   for (const slug of slugs) {
     if (!slug.isDirectory()) continue;
-    const slugDir = join46(projectsRoot, slug.name);
+    const slugDir = join47(projectsRoot, slug.name);
     let entries2;
     try {
       entries2 = await readdir7(slugDir, { withFileTypes: true });
@@ -27785,9 +28416,9 @@ async function collectLiveSidecars(projectsRoot) {
     }
     for (const entry of entries2) {
       if (entry.isFile() && SESSION_META_RE.test(entry.name)) {
-        out.push(join46(slugDir, entry.name));
+        out.push(join47(slugDir, entry.name));
       } else if (entry.isDirectory() && entry.name === "subagents") {
-        const subDir = join46(slugDir, entry.name);
+        const subDir = join47(slugDir, entry.name);
         let subs;
         try {
           subs = await readdir7(subDir, { withFileTypes: true });
@@ -27795,7 +28426,7 @@ async function collectLiveSidecars(projectsRoot) {
           continue;
         }
         for (const s of subs) {
-          if (s.isFile() && SESSION_META_RE.test(s.name)) out.push(join46(subDir, s.name));
+          if (s.isFile() && SESSION_META_RE.test(s.name)) out.push(join47(subDir, s.name));
         }
       }
     }
@@ -27807,7 +28438,7 @@ function shortId(path3) {
   return base.slice(0, 8);
 }
 async function migrateAdminWebchatSidecars(opts = {}) {
-  const projectsRoot = opts.projectsRoot ?? (process.env.CLAUDE_CONFIG_DIR ? join46(process.env.CLAUDE_CONFIG_DIR, "projects") : null) ?? "";
+  const projectsRoot = opts.projectsRoot ?? (process.env.CLAUDE_CONFIG_DIR ? join47(process.env.CLAUDE_CONFIG_DIR, "projects") : null) ?? "";
   const usersFile = opts.usersFile ?? USERS_FILE;
   const accountId = opts.accountId ?? resolveAccount()?.accountId ?? null;
   const resolveName = opts.resolveName ?? defaultResolveName;
@@ -30510,14 +31141,14 @@ function warnOnChannelAdminBindingDrift() {
 }
 
 // server/lib/booking-site-accounts.ts
-import { existsSync as existsSync44, readFileSync as readFileSync45 } from "fs";
+import { existsSync as existsSync45, readFileSync as readFileSync46 } from "fs";
 import { resolve as resolve43 } from "path";
 function listBookingSiteAccounts(accounts) {
   return accounts.filter((a) => {
     const availPath = resolve43(a.accountDir, "calendar-availability.json");
-    if (!existsSync44(availPath)) return false;
+    if (!existsSync45(availPath)) return false;
     try {
-      const cfg = JSON.parse(readFileSync45(availPath, "utf-8"));
+      const cfg = JSON.parse(readFileSync46(availPath, "utf-8"));
       return typeof cfg.bookingDbName === "string" && cfg.bookingDbName.length > 0;
     } catch {
       return false;
@@ -30554,8 +31185,8 @@ function broadcastAdminShutdown(reason) {
 }
 
 // ../lib/entitlement/src/index.ts
-import { createPublicKey, createHash as createHash6, verify as cryptoVerify } from "crypto";
-import { existsSync as existsSync45, readFileSync as readFileSync46, statSync as statSync19 } from "fs";
+import { createPublicKey, createHash as createHash7, verify as cryptoVerify } from "crypto";
+import { existsSync as existsSync46, readFileSync as readFileSync47, statSync as statSync20 } from "fs";
 import { resolve as resolve44 } from "path";
 
 // ../lib/entitlement/src/canonicalize.ts
@@ -30604,10 +31235,10 @@ function resolveEntitlement(brand, account) {
     return logResolved(implicitTrust(account), null);
   }
   const entitlementPath = resolve44(brand.configDir, "entitlement.json");
-  if (!existsSync45(entitlementPath)) {
+  if (!existsSync46(entitlementPath)) {
     return logResolved(anonymousFallback("missing"), { reason: "missing" });
   }
-  const stat11 = statSync19(entitlementPath);
+  const stat11 = statSync20(entitlementPath);
   const key = memoKey(stat11.mtimeMs, account);
   if (memo && memo.key === key) {
     return memo.result;
@@ -30619,13 +31250,13 @@ function resolveEntitlement(brand, account) {
 function verifyAndResolve(brand, entitlementPath, account) {
   let pubkeyPem;
   try {
-    pubkeyPem = readFileSync46(pubkeyPath(brand), "utf-8");
+    pubkeyPem = readFileSync47(pubkeyPath(brand), "utf-8");
   } catch (err) {
     return logResolved(anonymousFallback("pubkey-missing"), {
       reason: "pubkey-missing"
     });
   }
-  const pubkeyHash = createHash6("sha256").update(pubkeyPem).digest("hex");
+  const pubkeyHash = createHash7("sha256").update(pubkeyPem).digest("hex");
   if (pubkeyHash !== PUBKEY_SHA256) {
     return logResolved(anonymousFallback("pubkey-tamper"), {
       reason: "pubkey-tamper"
@@ -30633,7 +31264,7 @@ function verifyAndResolve(brand, entitlementPath, account) {
   }
   let envelope;
   try {
-    envelope = JSON.parse(readFileSync46(entitlementPath, "utf-8"));
+    envelope = JSON.parse(readFileSync47(entitlementPath, "utf-8"));
   } catch {
     return logResolved(anonymousFallback("malformed"), { reason: "malformed" });
   }
@@ -30795,14 +31426,14 @@ function clientFrom(c) {
 }
 installMediaDownloadGuard();
 var PLATFORM_ROOT8 = process.env.MAXY_PLATFORM_ROOT || "";
-var BRAND_JSON_PATH = PLATFORM_ROOT8 ? join47(PLATFORM_ROOT8, "config", "brand.json") : "";
+var BRAND_JSON_PATH = PLATFORM_ROOT8 ? join48(PLATFORM_ROOT8, "config", "brand.json") : "";
 var BRAND = { productName: "Maxy", hostname: "maxy", configDir: ".maxy", marketingUrl: "https://getmaxy.com" };
-if (BRAND_JSON_PATH && !existsSync46(BRAND_JSON_PATH)) {
+if (BRAND_JSON_PATH && !existsSync47(BRAND_JSON_PATH)) {
   console.error(`[brand] WARNING: brand.json not found at ${BRAND_JSON_PATH} \u2014 using Maxy defaults`);
 }
-if (BRAND_JSON_PATH && existsSync46(BRAND_JSON_PATH)) {
+if (BRAND_JSON_PATH && existsSync47(BRAND_JSON_PATH)) {
   try {
-    const parsed = JSON.parse(readFileSync47(BRAND_JSON_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync48(BRAND_JSON_PATH, "utf-8"));
     BRAND = { ...BRAND, ...parsed };
   } catch (err) {
     console.error(`[brand] Failed to parse brand.json: ${err.message}`);
@@ -30834,11 +31465,11 @@ var brandLoginOpts = {
   appleTouchIconPath: brandAppIcon512Path,
   themeColor: BRAND.defaultColors?.primary
 };
-var ALIAS_DOMAINS_PATH = join47(homedir4(), BRAND.configDir, "alias-domains.json");
+var ALIAS_DOMAINS_PATH = join48(homedir4(), BRAND.configDir, "alias-domains.json");
 function loadAliasDomains() {
   try {
-    if (!existsSync46(ALIAS_DOMAINS_PATH)) return null;
-    const parsed = JSON.parse(readFileSync47(ALIAS_DOMAINS_PATH, "utf-8"));
+    if (!existsSync47(ALIAS_DOMAINS_PATH)) return null;
+    const parsed = JSON.parse(readFileSync48(ALIAS_DOMAINS_PATH, "utf-8"));
     if (!Array.isArray(parsed)) {
       console.error("[alias-domains] malformed alias-domains.json \u2014 expected array");
       return null;
@@ -30913,7 +31544,7 @@ var waGateway = new WaGateway({
   fetchStandingRules: fetchAccountStandingRules,
   resolveSessionOverride: (accountId, senderId) => resolveChannelOverride(accountId, "whatsapp", senderId),
   gatewayUrl: `http://127.0.0.1:${process.env.MAXY_UI_INTERNAL_PORT ?? ""}`,
-  serverPath: process.env.MAXY_WA_CHANNEL_SERVER_PATH ?? resolve45(process.env.MAXY_PLATFORM_ROOT ?? join47(__dirname, ".."), "services/whatsapp-channel/dist/server.js"),
+  serverPath: process.env.MAXY_WA_CHANNEL_SERVER_PATH ?? resolve45(process.env.MAXY_PLATFORM_ROOT ?? join48(__dirname, ".."), "services/whatsapp-channel/dist/server.js"),
   // Task 751 / 1390 — file delivery on the native channel. `maxyAccountId` (the
   // path-validation scope) is the sender's effective SESSION account, resolved
   // once at the inbound gate and threaded here via the gateway's per-sender doc
@@ -30928,13 +31559,13 @@ var waGateway = new WaGateway({
       caption,
       accountId,
       maxyAccountId,
-      platformRoot: resolve45(process.env.MAXY_PLATFORM_ROOT ?? join47(__dirname, ".."))
+      platformRoot: resolve45(process.env.MAXY_PLATFORM_ROOT ?? join48(__dirname, ".."))
     });
     return result.ok ? { ok: true, messageId: result.messageId } : { ok: false, error: result.error };
   },
   ensureChannelSession: async ({ accountId, effectiveAccountId, senderId, role, personId, gatewayUrl, serverPath, passive, text, msgId, ownerSelfPhone, replyContext }) => {
     if (passive) {
-      const phoneHash = createHash7("sha256").update(senderId).digest("hex").slice(0, 12);
+      const phoneHash = createHash8("sha256").update(senderId).digest("hex").slice(0, 12);
       const prompt = (text ?? "").trim();
       if (prompt.length === 0) {
         console.error(`[wa-passive] op=dropped account=${effectiveAccountId} phoneHash=${phoneHash} msgId=${msgId ?? "none"} reason=empty-text`);
@@ -31046,7 +31677,7 @@ function runDuplicateSenderAudit() {
   try {
     const configDir2 = process.env.CLAUDE_CONFIG_DIR;
     if (!configDir2) return;
-    const projectsRoot = join47(configDir2, "projects");
+    const projectsRoot = join48(configDir2, "projects");
     const records = [];
     for (const { path: jsonlPath, isSubagent, archived } of enumerateJsonls(projectsRoot)) {
       if (isSubagent || archived) continue;
@@ -31621,14 +32252,14 @@ app69.get("/agent-assets/:slug/:filename", (c) => {
     console.error(`[agent-assets] path-traversal-rejected slug=${slug} file=${filename}`);
     return c.text("Forbidden", 403);
   }
-  if (!existsSync46(filePath)) {
+  if (!existsSync47(filePath)) {
     console.error(`[agent-assets] serve slug=${slug} file=${filename} status=404`);
     return c.text("Not found", 404);
   }
   const ext = "." + filename.split(".").pop()?.toLowerCase();
   const contentType = IMAGE_MIME[ext] || "application/octet-stream";
   console.log(`[agent-assets] serve slug=${slug} file=${filename} status=200`);
-  const body = readFileSync47(filePath);
+  const body = readFileSync48(filePath);
   return c.body(body, 200, {
     "Content-Type": contentType,
     "Cache-Control": "public, max-age=3600"
@@ -31651,14 +32282,14 @@ app69.get("/generated/:filename", (c) => {
     console.error(`[generated] serve file=${filename} status=403`);
     return c.text("Forbidden", 403);
   }
-  if (!existsSync46(filePath)) {
+  if (!existsSync47(filePath)) {
     console.error(`[generated] serve file=${filename} status=404`);
     return c.text("Not found", 404);
   }
   const ext = "." + filename.split(".").pop()?.toLowerCase();
   const contentType = IMAGE_MIME[ext] || "application/octet-stream";
   console.log(`[generated] serve file=${filename} status=200`);
-  const body = readFileSync47(filePath);
+  const body = readFileSync48(filePath);
   return c.body(body, 200, {
     "Content-Type": contentType,
     "Cache-Control": "public, max-age=86400"
@@ -31671,9 +32302,9 @@ app69.route("/v", visitor_consent_default);
 var htmlCache = /* @__PURE__ */ new Map();
 var brandLogoPath = "/brand/maxy-monochrome.png";
 var brandIconPath = "/brand/maxy-monochrome.png";
-if (BRAND_JSON_PATH && existsSync46(BRAND_JSON_PATH)) {
+if (BRAND_JSON_PATH && existsSync47(BRAND_JSON_PATH)) {
   try {
-    const fullBrand = JSON.parse(readFileSync47(BRAND_JSON_PATH, "utf-8"));
+    const fullBrand = JSON.parse(readFileSync48(BRAND_JSON_PATH, "utf-8"));
     if (fullBrand.assets?.logo) brandLogoPath = `/brand/${fullBrand.assets.logo}`;
     brandIconPath = fullBrand.assets?.icon ? `/brand/${fullBrand.assets.icon}` : brandLogoPath;
   } catch {
@@ -31700,11 +32331,11 @@ var brandScript = `<script>window.__BRAND__=${JSON.stringify({
 var brandThemeColor = BRAND.defaultColors?.primary ?? "#000000";
 var brandBackgroundColor = BRAND.defaultColors?.background ?? "#ffffff";
 var brandAppIconsExist = [brandAppIcon192Path, brandAppIcon512Path, brandMaskableIconPath].every(
-  (p) => existsSync46(resolve45(process.cwd(), "public", p.replace(/^\//, "")))
+  (p) => existsSync47(resolve45(process.cwd(), "public", p.replace(/^\//, "")))
 );
 var SW_SOURCE = (() => {
   try {
-    return readFileSync47(resolve45(process.cwd(), "public", "sw.js"), "utf-8");
+    return readFileSync48(resolve45(process.cwd(), "public", "sw.js"), "utf-8");
   } catch {
     return null;
   }
@@ -31712,9 +32343,9 @@ var SW_SOURCE = (() => {
 function readInstalledVersion() {
   try {
     if (!PLATFORM_ROOT8) return "unknown";
-    const versionFile = join47(PLATFORM_ROOT8, "config", `.${BRAND.hostname}-version`);
-    if (!existsSync46(versionFile)) return "unknown";
-    const content = readFileSync47(versionFile, "utf-8").trim();
+    const versionFile = join48(PLATFORM_ROOT8, "config", `.${BRAND.hostname}-version`);
+    if (!existsSync47(versionFile)) return "unknown";
+    const content = readFileSync48(versionFile, "utf-8").trim();
     return content || "unknown";
   } catch {
     return "unknown";
@@ -31755,7 +32386,7 @@ var clientErrorReporterScript = `<script>
 function cachedHtml(file) {
   let html = htmlCache.get(file);
   if (!html) {
-    html = readFileSync47(resolve45(process.cwd(), "public", file), "utf-8");
+    html = readFileSync48(resolve45(process.cwd(), "public", file), "utf-8");
     const productNameEsc = escapeHtml(BRAND.productName);
     html = html.replace(/<title>([^<]*)<\/title>/, (_match, inner) => `<title>${escapeHtml(inner).replace(/Maxy/g, productNameEsc)}</title>`);
     html = html.replace('href="/favicon.ico"', `href="${escapeHtml(brandFaviconPath)}"`);
@@ -31772,13 +32403,13 @@ ${clientErrorReporterScript}
   return html;
 }
 function loadBrandingCache(agentSlug) {
-  const configDir2 = join47(homedir4(), BRAND.configDir);
+  const configDir2 = join48(homedir4(), BRAND.configDir);
   try {
     const accountId = getDefaultAccountId();
     if (!accountId) return null;
-    const cachePath = join47(configDir2, "branding-cache", accountId, `${agentSlug}.json`);
-    if (!existsSync46(cachePath)) return null;
-    return JSON.parse(readFileSync47(cachePath, "utf-8"));
+    const cachePath = join48(configDir2, "branding-cache", accountId, `${agentSlug}.json`);
+    if (!existsSync47(cachePath)) return null;
+    return JSON.parse(readFileSync48(cachePath, "utf-8"));
   } catch {
     return null;
   }
@@ -31873,7 +32504,7 @@ app69.use("/vnc-popout.html", logViewerFetch);
 app69.get("/vnc-popout.html", (c) => {
   let html = htmlCache.get("vnc-popout.html");
   if (!html) {
-    html = readFileSync47(resolve45(process.cwd(), "public", "vnc-popout.html"), "utf-8");
+    html = readFileSync48(resolve45(process.cwd(), "public", "vnc-popout.html"), "utf-8");
     const name = escapeHtml(BRAND.productName);
     html = html.replace("<title>Browser \u2014 Maxy</title>", `<title>${name}</title>`);
     html = html.replace("</head>", `  ${brandScript}
@@ -32025,10 +32656,10 @@ var hostname = process.env.HOSTNAME ?? "127.0.0.1";
 var httpServer = serve({ fetch: app69.fetch, port, hostname });
 console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
 {
-  const reconcilePlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join47(__dirname, "..");
+  const reconcilePlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join48(__dirname, "..");
   const reconcileScript = resolve45(reconcilePlatformRoot, "plugins/scheduling/mcp/dist/scripts/reconcile-bookings.js");
   const runReconcile = (ctx) => {
-    if (!existsSync46(reconcileScript)) return;
+    if (!existsSync47(reconcileScript)) return;
     try {
       const child = spawn3(process.execPath, [reconcileScript], {
         env: { ...process.env, PLATFORM_ROOT: reconcilePlatformRoot },
@@ -32048,7 +32679,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
     detached: true,
     run: runReconcile
   });
-  const reconcileStatePath = join47(MAXY_DIR, "booking-reconcile-state.json");
+  const reconcileStatePath = join48(MAXY_DIR, "booking-reconcile-state.json");
   registerLoop({
     name: "calendar-reconcile-liveness",
     intervalMs: 6e5,
@@ -32066,7 +32697,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
 }
 {
   const DREAM_CYCLE_SWEEP_INTERVAL_MS = 36e5;
-  const dreamPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join47(__dirname, "..");
+  const dreamPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join48(__dirname, "..");
   const dreamSweepScript = resolve45(dreamPlatformRoot, "plugins/memory/mcp/dist/scripts/dream-cycle-sweep.js");
   registerLoop({
     name: "dream-cycle-sweep",
@@ -32074,7 +32705,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
     firstRunDelayMs: 3e4,
     detached: true,
     run: (ctx) => {
-      if (!existsSync46(dreamSweepScript)) return;
+      if (!existsSync47(dreamSweepScript)) return;
       try {
         const child = spawn3(process.execPath, [dreamSweepScript], {
           env: { ...process.env, PLATFORM_ROOT: dreamPlatformRoot },
@@ -32090,11 +32721,11 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
   });
 }
 {
-  const outlookPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join47(__dirname, "..");
+  const outlookPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join48(__dirname, "..");
   const outlookScript = resolve45(outlookPlatformRoot, "plugins/outlook/mcp/dist/scripts/complete-registration.js");
   const OUTLOOK_COMPLETE_INTERVAL_MS = 3e4;
   const runOutlookComplete = (ctx) => {
-    if (!existsSync46(outlookScript)) return;
+    if (!existsSync47(outlookScript)) return;
     try {
       const child = spawn3(process.execPath, [outlookScript], {
         env: { ...process.env, PLATFORM_ROOT: outlookPlatformRoot },
@@ -32116,20 +32747,20 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
   });
 }
 {
-  const auditRoot = process.env.MAXY_PLATFORM_ROOT ?? join47(__dirname, "..");
+  const auditRoot = process.env.MAXY_PLATFORM_ROOT ?? join48(__dirname, "..");
   const strandedAccountsDir = resolve45(auditRoot, "..", "data/accounts");
   const STRANDED_AUDIT_INTERVAL_MS = 3e5;
   const STRANDED_AGE_MS = 16 * 6e4;
   const STRANDED_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
   const runStrandedAudit = () => {
     try {
-      if (!existsSync46(strandedAccountsDir)) return;
+      if (!existsSync47(strandedAccountsDir)) return;
       const now = Date.now();
-      for (const name of readdirSync28(strandedAccountsDir)) {
+      for (const name of readdirSync29(strandedAccountsDir)) {
         if (!STRANDED_UUID_RE.test(name)) continue;
         const pendingPath2 = resolve45(strandedAccountsDir, name, "secrets/outlook/pending-devicecode.enc");
-        if (!existsSync46(pendingPath2)) continue;
-        const ageMs2 = now - statSync20(pendingPath2).mtimeMs;
+        if (!existsSync47(pendingPath2)) continue;
+        const ageMs2 = now - statSync21(pendingPath2).mtimeMs;
         if (ageMs2 > STRANDED_AGE_MS) {
           console.error(`[outlook-mcp] devicecode-stranded account=${name} ageSec=${Math.floor(ageMs2 / 1e3)}`);
         }
@@ -32146,7 +32777,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
   });
 }
 {
-  const googleRoot = process.env.MAXY_PLATFORM_ROOT ?? join47(__dirname, "..");
+  const googleRoot = process.env.MAXY_PLATFORM_ROOT ?? join48(__dirname, "..");
   const googleAccountsDir = resolve45(googleRoot, "..", "data/accounts");
   const GOOGLE_PENDING_AUDIT_INTERVAL_MS = 3e5;
   const runGooglePendingAuditSafe = () => {
@@ -32165,7 +32796,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
   const googleAuditScript = resolve45(googleRoot, "plugins/google/mcp/dist/scripts/account-audit.js");
   const GOOGLE_ACCOUNT_AUDIT_INTERVAL_MS = 36e5;
   const runGoogleAccountAudit = (ctx) => {
-    if (!existsSync46(googleAuditScript)) return;
+    if (!existsSync47(googleAuditScript)) return;
     try {
       const child = spawn3(process.execPath, [googleAuditScript], {
         env: { ...process.env, PLATFORM_ROOT: googleRoot },
@@ -32190,7 +32821,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
   });
 }
 {
-  const auditPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join47(__dirname, "..");
+  const auditPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join48(__dirname, "..");
   const STORAGE_AUDIT_INTERVAL_MS = 3e5;
   const runStorageAuditSafe = () => runStorageAudit(auditPlatformRoot).catch((err) => {
     console.error(`[storage-audit] error="${err.message}"`);
@@ -32236,7 +32867,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
   });
 }
 {
-  const publishPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join47(__dirname, "..");
+  const publishPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join48(__dirname, "..");
   const publishScript = resolve45(publishPlatformRoot, "plugins/scheduling/mcp/dist/scripts/publish-availability.js");
   const PUBLISH_INTERVAL_MS = 3e5;
   const bookingAccounts = () => {
@@ -32248,7 +32879,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
     }
   };
   const spawnPublish = (account, ctx) => {
-    if (!existsSync46(publishScript)) return;
+    if (!existsSync47(publishScript)) return;
     try {
       const child = spawn3(process.execPath, [publishScript], {
         env: {
@@ -32270,8 +32901,8 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
     const availPath = resolve45(account.accountDir, "calendar-availability.json");
     let hasBookingSite = false;
     try {
-      if (existsSync46(availPath)) {
-        const cfg = JSON.parse(readFileSync47(availPath, "utf-8"));
+      if (existsSync47(availPath)) {
+        const cfg = JSON.parse(readFileSync48(availPath, "utf-8"));
         hasBookingSite = typeof cfg.bookingDbName === "string" && cfg.bookingDbName.length > 0;
       }
     } catch {
@@ -32279,9 +32910,9 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
     if (!hasBookingSite) return;
     const statePath = resolve45(account.accountDir, "state", "booking-availability", "last-publish.json");
     let lastSuccessAt = null;
-    if (existsSync46(statePath)) {
+    if (existsSync47(statePath)) {
       try {
-        const rec = JSON.parse(readFileSync47(statePath, "utf-8"));
+        const rec = JSON.parse(readFileSync48(statePath, "utf-8"));
         lastSuccessAt = rec.lastSuccessAt ?? null;
       } catch {
         console.error(`[calendar-availability] op=audit accountId=${account.accountId} snapshotAgeMs=na reason=bad-state-file`);
@@ -32313,12 +32944,12 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
 startTimeEntryCensus(() => getSession());
 startLedgerCensus(() => getSession());
 {
-  const auditPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join47(__dirname, "..");
+  const auditPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join48(__dirname, "..");
   const auditScript = resolve45(auditPlatformRoot, "plugins/connector/mcp/dist/scripts/audit-connectors.js");
   const auditLogDir = process.env.LOG_DIR ?? LOG_DIR;
   const CONNECTOR_AUDIT_INTERVAL_MS = 3e5;
   const runConnectorAudit = (ctx) => {
-    if (!existsSync46(auditScript)) return;
+    if (!existsSync47(auditScript)) return;
     try {
       const child = spawn3(process.execPath, [auditScript], {
         env: { ...process.env, PLATFORM_ROOT: auditPlatformRoot, LOG_DIR: auditLogDir },
@@ -32438,11 +33069,11 @@ try {
 var ADMINUSER_RECONCILE_INTERVAL_MS = 60 * 60 * 1e3;
 async function runAdminUserReconcileTick() {
   try {
-    if (!existsSync46(USERS_FILE)) {
+    if (!existsSync47(USERS_FILE)) {
       console.error("[adminuser-self-heal] skip reason=no-users-file");
       return;
     }
-    const usersRaw = readFileSync47(USERS_FILE, "utf-8").trim();
+    const usersRaw = readFileSync48(USERS_FILE, "utf-8").trim();
     if (!usersRaw) {
       console.error("[adminuser-self-heal] skip reason=empty-users-file");
       return;
@@ -32489,8 +33120,8 @@ registerLoop({
 });
 var USERS_RECONCILE_INTERVAL_MS = 60 * 60 * 1e3;
 function countUsersRows() {
-  if (!existsSync46(USERS_FILE)) return 0;
-  const raw = readFileSync47(USERS_FILE, "utf-8").trim();
+  if (!existsSync47(USERS_FILE)) return 0;
+  const raw = readFileSync48(USERS_FILE, "utf-8").trim();
   if (!raw) return 0;
   const users = JSON.parse(raw);
   return users.filter((u) => typeof u.userId === "string").length;
@@ -32623,7 +33254,7 @@ if (bootAccountConfig?.whatsapp) {
 }
 init({
   configDir: configDirForWhatsApp,
-  platformRoot: resolve45(process.env.MAXY_PLATFORM_ROOT ?? join47(__dirname, "..")),
+  platformRoot: resolve45(process.env.MAXY_PLATFORM_ROOT ?? join48(__dirname, "..")),
   accountConfig: bootAccountConfig,
   onMessage: async (msg) => {
     if (isObserveAccount(msg.accountId)) {