@goondocks/myco 0.18.0 → 0.19.0

package/dist/{main-6PY3ITQ5.js → main-EIKBLOUL.js}

@@ -15,16 +15,18 @@ import {
   getEmbeddingQueueDepth,
   getUnembedded,
   markEmbedded
-} from "./chunk-DLFDBKEV.js";
+} from "./chunk-OZF5EURR.js";
 import {
   loadSecrets,
+  readJsonConfig,
   readSecrets,
+  resolveHomeConfigPath,
   writeSecret
-} from "./chunk-RJMXDUMA.js";
+} from "./chunk-EM63ZFKA.js";
 import {
   Anthropic,
   createEmbeddingProvider
-} from "./chunk-KWTOCJLB.js";
+} from "./chunk-LLJMDXO2.js";
 import {
   buildTaskInstruction,
   closeOpenBatches,
@@ -72,24 +74,24 @@ import {
   setResponseSummary,
   updateCandidate,
   updateNotificationStatus
-} from "./chunk-JDI4DPWD.js";
+} from "./chunk-RXROZBSK.js";
 import {
   fullTextSearch,
   hydrateSearchResults
-} from "./chunk-NZI7WBZI.js";
+} from "./chunk-2DF4OZ2D.js";
 import {
   copyTaskToUser,
   deleteUserTask,
   loadAllTasks,
   validateTaskName,
   writeUserTask
-} from "./chunk-RAV5YMRU.js";
+} from "./chunk-3TPD6HEF.js";
 import {
   AgentTaskSchema,
   registerAgent,
   resolveDefinitionsDir,
   taskFromParsed
-} from "./chunk-NI23QCHB.js";
+} from "./chunk-AELJ4PS5.js";
 import {
   listTurnsByRun
 } from "./chunk-QLCD77AN.js";
@@ -105,24 +107,24 @@ import {
   cleanStaleBuffers,
   listBufferSessionIds
 } from "./chunk-V7XG6V6C.js";
-import "./chunk-IB76KGBY.js";
-import "./chunk-55QEICRO.js";
+import "./chunk-POEPHBQK.js";
+import "./chunk-N77K772N.js";
 import "./chunk-SAKJMNSR.js";
 import "./chunk-WYOE4IAX.js";
 import {
   checkLocalProvider
-} from "./chunk-75AZFBFW.js";
+} from "./chunk-YPWF322W.js";
 import {
   LmStudioBackend,
   OllamaBackend
-} from "./chunk-CML4MCYF.js";
+} from "./chunk-KSXTNYXO.js";
 import {
   countSpores,
   getSpore,
   insertSpore,
   listSpores,
   updateSporeStatus
-} from "./chunk-7OYXB2NM.js";
+} from "./chunk-REN37KYI.js";
 import {
   closeSession,
   countSessions,
@@ -133,7 +135,7 @@ import {
   listSessions,
   updateSession,
   upsertSession
-} from "./chunk-U7GJTVSX.js";
+} from "./chunk-2OO3BRFK.js";
 import {
   backfillUnsynced,
   countDeadLettered,
@@ -149,13 +151,13 @@ import {
   pruneOld,
   retryDeadLettered,
   syncRow
-} from "./chunk-O3TRN3RC.js";
+} from "./chunk-INWD6AIQ.js";
 import {
   EMBEDDING_DIMENSIONS,
   REST_SETTABLE_STATUSES,
   SCHEMA_VERSION,
   createSchema
-} from "./chunk-OW433Q4C.js";
+} from "./chunk-2LN2BBKA.js";
 import {
   CONFIG_FILENAME,
   MycoConfigSchema,
@@ -164,7 +166,7 @@ import {
   updateBackupConfig,
   updateConfig,
   updateTeamConfig
-} from "./chunk-2V7HR7HB.js";
+} from "./chunk-MDEUXYJG.js";
 import {
   closeDatabase,
   getDatabase,
@@ -173,13 +175,13 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   resolveCliEntryPath
-} from "./chunk-BUIR3JWM.js";
+} from "./chunk-CYBC2HZ3.js";
 import {
   getPluginVersion
-} from "./chunk-EO2RQW4S.js";
+} from "./chunk-2CKDAFSX.js";
 import {
   loadManifests
-} from "./chunk-FABWUX5G.js";
+} from "./chunk-UVKQ62II.js";
 import {
   findPackageRoot
 } from "./chunk-LPUQPDC2.js";
@@ -201,7 +203,7 @@ import {
   MS_PER_SECOND,
   MYCO_GLOBAL_DIR,
   NPM_PACKAGE_NAME,
-  NPM_REGISTRY_URL,
+  NPM_REGISTRY_BASE_URL,
   POWER_ACTIVE_INTERVAL_MS,
   POWER_DEEP_SLEEP_THRESHOLD_MS,
   POWER_IDLE_THRESHOLD_MS,
@@ -228,6 +230,7 @@ import {
   UPDATE_CHECK_INTERVAL_HOURS,
   UPDATE_CONFIG_PATH,
   UPDATE_ERROR_PATH,
+  UPDATE_PACKAGES,
   UPDATE_SCRIPT_DELAY_SECONDS,
   UPDATE_STAMP_FILENAME,
   USER_AGENT_ID,
@@ -235,18 +238,18 @@ import {
   USER_TASK_SOURCE,
   epochSeconds,
   estimateTokens
-} from "./chunk-CKJAWZQE.js";
+} from "./chunk-W4VHC2ES.js";
 import {
   LOG_KINDS,
   kindToComponent
 } from "./chunk-E7NUADTQ.js";
 import {
   require_dist
-} from "./chunk-D7TYRPRM.js";
-import "./chunk-E4VLWIJC.js";
+} from "./chunk-6LQIMRTC.js";
+import "./chunk-ODXLRR4U.js";
 import {
   external_exports
-} from "./chunk-GDY63YAW.js";
+} from "./chunk-U6PF3YII.js";
 import {
   __toESM
 } from "./chunk-PZUWP5VK.js";
@@ -372,7 +375,7 @@ var DaemonServer = class {
     this.router.add(method, routePath, handler);
   }
   async start(port = 0) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       this.server = http.createServer((req, res) => this.handleRequest(req, res));
       this.server.on("error", reject);
       this.server.listen(port, "127.0.0.1", () => {
@@ -380,20 +383,20 @@ var DaemonServer = class {
         this.port = addr.port;
         this.writeDaemonJson();
         this.logger.info(LOG_KINDS.DAEMON_PORT, "Server started", { port: this.port, dashboard: `http://localhost:${this.port}/` });
-        resolve();
+        resolve3();
       });
     });
   }
   async stop() {
-    return new Promise((resolve) => {
+    return new Promise((resolve3) => {
       this.removeDaemonJson();
       if (this.server) {
         this.server.close(() => {
           this.logger.info(LOG_KINDS.DAEMON_START, "Server stopped");
-          resolve();
+          resolve3();
         });
       } else {
-        resolve();
+        resolve3();
       }
     });
   }
@@ -541,14 +544,14 @@ var DaemonServer = class {
   }
 };
 function readBody(req) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     let data = "";
     req.on("data", (chunk) => {
       data += chunk;
     });
     req.on("end", () => {
       try {
-        resolve(data ? JSON.parse(data) : {});
+        resolve3(data ? JSON.parse(data) : {});
       } catch (e) {
         reject(e);
       }
@@ -628,11 +631,11 @@ async function resolvePort(configPort, vaultPath) {
   return 0;
 }
 function isPortAvailable(port) {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const server = net.createServer();
-    server.once("error", () => resolve(false));
+    server.once("error", () => resolve3(false));
     server.once("listening", () => {
-      server.close(() => resolve(true));
+      server.close(() => resolve3(true));
     });
     server.listen(port, "127.0.0.1");
   });
@@ -641,6 +644,53 @@ function isPortAvailable(port) {
 // src/symbionts/adapter.ts
 import fs3 from "fs";
 import path3 from "path";
+
+// src/symbionts/parsers/standard-jsonl.ts
+var IMAGE_TEXT_REF_PATTERN = /\[Image: source: [^\]]+\]\n*/g;
+var StandardJsonlParser = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  parseTurns(content) {
+    const lines = content.split("\n").filter(Boolean);
+    const turns = [];
+    let current = null;
+    for (const line of lines) {
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const role = entry[this.opts.roleField];
+      const timestamp = this.opts.extractTimestamp ? entry.timestamp ?? "" : "";
+      if (role === "user") {
+        if (entry.isMeta === true) continue;
+        const msg = entry.message;
+        const blocks = Array.isArray(msg?.content) ? msg.content : [];
+        const hasText = blocks.some((b) => b.type === "text" && b.text?.trim());
+        if (!hasText) continue;
+        if (current) turns.push(current);
+        const rawPrompt = blocks.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
+        const promptText = (this.opts.stripImageTextRefs ? rawPrompt.replace(IMAGE_TEXT_REF_PATTERN, "") : rawPrompt).trim().slice(0, PROMPT_PREVIEW_CHARS);
+        const images = blocks.filter((b) => b.type === "image" && b.source?.type === "base64" && b.source.data).map((b) => ({ data: b.source.data, mediaType: b.source.media_type ?? "image/png" }));
+        current = { prompt: promptText, toolCount: 0, timestamp, ...images.length > 0 ? { images } : {} };
+      } else if (role === "assistant" && current) {
+        const msg = entry.message;
+        if (Array.isArray(msg?.content)) {
+          const textParts = msg.content.filter((b) => b.type === "text" && b.text).map((b) => b.text);
+          const text = textParts.join("\n").trim();
+          if (text) current.aiResponse = text;
+          current.toolCount += msg.content.filter((b) => b.type === "tool_use").length;
+        }
+      }
+    }
+    if (current) turns.push(current);
+    return turns;
+  }
+};
+
+// src/symbionts/adapter.ts
 function findJsonlInSubdirs(baseDir, sessionId) {
   try {
     for (const entry of fs3.readdirSync(baseDir, { withFileTypes: true })) {
@@ -685,44 +735,8 @@ var EXT_TO_MIME = {
 function mimeTypeForExtension(ext) {
   return EXT_TO_MIME[ext.toLowerCase()] ?? "image/png";
 }
-var IMAGE_TEXT_REF_PATTERN = /\[Image: source: [^\]]+\]\n*/g;
 function parseJsonlTurns(content, opts) {
-  const lines = content.split("\n").filter(Boolean);
-  const turns = [];
-  let current = null;
-  for (const line of lines) {
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    const role = entry[opts.roleField];
-    const timestamp = opts.extractTimestamp ? entry.timestamp ?? "" : "";
-    if (role === "user") {
-      if (entry.isMeta === true) continue;
-      const msg = entry.message;
-      const blocks = Array.isArray(msg?.content) ? msg.content : [];
-      const hasText = blocks.some((b) => b.type === "text" && b.text?.trim());
-      if (!hasText && opts.skipToolResultUsers) continue;
-      if (!hasText) continue;
-      if (current) turns.push(current);
-      const rawPrompt = blocks.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
-      const promptText = (opts.stripImageTextRefs ? rawPrompt.replace(IMAGE_TEXT_REF_PATTERN, "") : rawPrompt).trim().slice(0, PROMPT_PREVIEW_CHARS);
-      const images = blocks.filter((b) => b.type === "image" && b.source?.type === "base64" && b.source.data).map((b) => ({ data: b.source.data, mediaType: b.source.media_type ?? "image/png" }));
-      current = { prompt: promptText, toolCount: 0, timestamp, ...images.length > 0 ? { images } : {} };
-    } else if (role === "assistant" && current) {
-      const msg = entry.message;
-      if (Array.isArray(msg?.content)) {
-        const textParts = msg.content.filter((b) => b.type === "text" && b.text).map((b) => b.text);
-        const text = textParts.join("\n").trim();
-        if (text) current.aiResponse = text;
-        current.toolCount += msg.content.filter((b) => b.type === "tool_use").length;
-      }
-    }
-  }
-  if (current) turns.push(current);
-  return turns;
+  return new StandardJsonlParser(opts).parseTurns(content);
 }
 
 // src/symbionts/claude-code.ts
@@ -876,10 +890,100 @@ function parseCursorText(content) {
   return turns;
 }
 
+// src/symbionts/parsers/codex-jsonl.ts
+function parseDataUrl(url) {
+  const match = url.match(/^data:([^;]+);base64,(.+)$/);
+  if (!match) return null;
+  return { mediaType: match[1], data: match[2] };
+}
+var IMAGE_WRAPPER_TAG = /^<\/?image\b[^>]*>$/;
+var CODEX_PROMPT_MARKER = "## My request for Codex:\n";
+function cleanCodexPromptText(text) {
+  if (IMAGE_WRAPPER_TAG.test(text.trim())) return "";
+  const idx = text.indexOf(CODEX_PROMPT_MARKER);
+  if (idx !== -1) return text.slice(idx + CODEX_PROMPT_MARKER.length);
+  return text;
+}
+var CodexJsonlParser = class {
+  parseTurns(content) {
+    const lines = content.split("\n").filter(Boolean);
+    const turns = [];
+    let current = null;
+    for (const line of lines) {
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.type !== "response_item") continue;
+      const payload = entry.payload;
+      if (!payload) continue;
+      const payloadType = payload.type;
+      const timestamp = entry.timestamp ?? "";
+      if (payloadType === "function_call") {
+        if (current) current.toolCount++;
+        continue;
+      }
+      if (payloadType !== "message") continue;
+      const role = payload.role;
+      const blocks = Array.isArray(payload.content) ? payload.content : [];
+      if (role === "user") {
+        const textParts = blocks.filter((b) => b.type === "input_text" && b.text?.trim()).map((b) => cleanCodexPromptText(b.text)).filter((t) => t.trim());
+        if (textParts.length === 0) continue;
+        if (current) turns.push(current);
+        const promptText = textParts.join("\n").trim().slice(0, PROMPT_PREVIEW_CHARS);
+        const images = [];
+        for (const b of blocks) {
+          if (b.type === "input_image" && b.image_url) {
+            const parsed = parseDataUrl(b.image_url);
+            if (parsed) images.push(parsed);
+          }
+        }
+        current = { prompt: promptText, toolCount: 0, timestamp, ...images.length > 0 ? { images } : {} };
+      } else if (role === "assistant" && current) {
+        const textParts = blocks.filter((b) => b.type === "output_text" && b.text).map((b) => b.text);
+        const text = textParts.join("\n").trim();
+        if (text) current.aiResponse = text;
+      }
+    }
+    if (current) turns.push(current);
+    return turns;
+  }
+};
+
 // src/symbionts/codex.ts
+import fs5 from "fs";
 import path6 from "path";
 import os3 from "os";
 var TRANSCRIPT_BASE2 = path6.join(os3.homedir(), ".codex");
+var codexParser = new CodexJsonlParser();
+function findCodexTranscript(baseDir, sessionId) {
+  const sessionsDir = path6.join(baseDir, "sessions");
+  try {
+    return scanForSessionFile(sessionsDir, sessionId);
+  } catch {
+    return null;
+  }
+}
+function scanForSessionFile(dir, sessionId) {
+  let entries;
+  try {
+    entries = fs5.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    const fullPath = path6.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const found = scanForSessionFile(fullPath, sessionId);
+      if (found) return found;
+    } else if (entry.isFile() && entry.name.includes(sessionId) && entry.name.endsWith(".jsonl")) {
+      return fullPath;
+    }
+  }
+  return null;
+}
 var codexAdapter = {
   name: "codex",
   displayName: "Codex",
@@ -893,18 +997,12 @@ var codexAdapter = {
     toolInput: "tool_input",
     toolOutput: "tool_output"
   },
-  findTranscript: (sessionId) => findJsonlInSubdirs(TRANSCRIPT_BASE2, sessionId),
-  // Codex uses 'role' field (like Cursor), not 'type' (like Claude Code)
-  parseTurns: (content) => parseJsonlTurns(content, {
-    roleField: "role",
-    extractTimestamp: false,
-    skipToolResultUsers: false,
-    stripImageTextRefs: false
-  })
+  findTranscript: (sessionId) => findCodexTranscript(TRANSCRIPT_BASE2, sessionId),
+  parseTurns: (content) => codexParser.parseTurns(content)
 };
 
 // src/symbionts/gemini.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path7 from "path";
 import os4 from "os";
 var GEMINI_TMP = path7.join(os4.homedir(), ".gemini", "tmp");
@@ -924,15 +1022,15 @@ var geminiAdapter = {
   },
   findTranscript(sessionId) {
     try {
-      for (const project of fs5.readdirSync(GEMINI_TMP, { withFileTypes: true })) {
+      for (const project of fs6.readdirSync(GEMINI_TMP, { withFileTypes: true })) {
         if (!project.isDirectory()) continue;
         const chatsDir = path7.join(GEMINI_TMP, project.name, "chats");
         try {
-          for (const file of fs5.readdirSync(chatsDir)) {
+          for (const file of fs6.readdirSync(chatsDir)) {
             if (!file.endsWith(".json")) continue;
             if (file.includes(sessionId.slice(0, 8))) {
               try {
-                const data = JSON.parse(fs5.readFileSync(path7.join(chatsDir, file), "utf-8"));
+                const data = JSON.parse(fs6.readFileSync(path7.join(chatsDir, file), "utf-8"));
                 if (data.sessionId === sessionId) {
                   return path7.join(chatsDir, file);
                 }
@@ -986,7 +1084,7 @@ function parseGeminiJson(content) {
 }
 
 // src/symbionts/windsurf.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path8 from "path";
 import os5 from "os";
 var TRANSCRIPT_DIR = path8.join(os5.homedir(), ".windsurf", "transcripts");
@@ -1009,7 +1107,7 @@ var windsurfAdapter = {
   findTranscript(sessionId) {
     const candidate = path8.join(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
     try {
-      fs6.accessSync(candidate);
+      fs7.accessSync(candidate);
       return candidate;
     } catch {
       return null;
@@ -1144,7 +1242,7 @@ function normalizeResponseParts(response) {
 }
 
 // src/symbionts/registry.ts
-import fs7 from "fs";
+import fs8 from "fs";
 var ALL_ADAPTERS = [
   claudeCodeAdapter,
   cursorAdapter,
@@ -1167,7 +1265,7 @@ var SymbiontRegistry = class {
       const filePath = adapter.findTranscript(sessionId);
       if (!filePath) continue;
       try {
-        const content = fs7.readFileSync(filePath, "utf-8");
+        const content = fs8.readFileSync(filePath, "utf-8");
         const turns = adapter.parseTurns(content);
         if (turns.length > 0) {
           return { turns, source: adapter.name };
@@ -1201,7 +1299,7 @@ var SymbiontRegistry = class {
    */
   parseTurnsFromPath(filePath) {
     try {
-      const content = fs7.readFileSync(filePath, "utf-8");
+      const content = fs8.readFileSync(filePath, "utf-8");
       const active = this.detectActiveAgent();
       const orderedAdapters = active ? [active, ...this.adapters.filter((a) => a !== active)] : this.adapters;
       for (const adapter of orderedAdapters) {
@@ -1601,7 +1699,7 @@ async function handleRestart(deps, body) {
 
 // src/daemon/update-checker.ts
 var import_yaml = __toESM(require_dist(), 1);
-import fs8 from "fs";
+import fs9 from "fs";
 import path9 from "path";
 import { execFileSync } from "child_process";
 import semver from "semver";
@@ -1638,7 +1736,7 @@ function defaultUpdateConfig() {
 }
 function readUpdateConfig() {
   try {
-    const raw = fs8.readFileSync(UPDATE_CONFIG_PATH, "utf-8");
+    const raw = fs9.readFileSync(UPDATE_CONFIG_PATH, "utf-8");
     const parsed = import_yaml.default.parse(raw);
     const channel = RELEASE_CHANNELS.includes(parsed?.channel) ? parsed.channel : DEFAULT_RELEASE_CHANNEL;
     const check_interval_hours = typeof parsed?.check_interval_hours === "number" && parsed.check_interval_hours > 0 ? parsed.check_interval_hours : UPDATE_CHECK_INTERVAL_HOURS;
@@ -1648,20 +1746,38 @@ function readUpdateConfig() {
   }
 }
 function writeUpdateConfig(config) {
-  fs8.mkdirSync(MYCO_GLOBAL_DIR, { recursive: true });
-  fs8.writeFileSync(UPDATE_CONFIG_PATH, import_yaml.default.stringify(config), "utf-8");
+  fs9.mkdirSync(MYCO_GLOBAL_DIR, { recursive: true });
+  fs9.writeFileSync(UPDATE_CONFIG_PATH, import_yaml.default.stringify(config), "utf-8");
 }
 function readCachedCheck() {
   try {
-    const raw = fs8.readFileSync(UPDATE_CHECK_CACHE_PATH, "utf-8");
-    return JSON.parse(raw);
+    const raw = fs9.readFileSync(UPDATE_CHECK_CACHE_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && "packages" in parsed && parsed.packages) {
+      return parsed;
+    }
+    const legacy = parsed;
+    if (typeof legacy.checked_at === "string" && typeof legacy.latest_stable === "string") {
+      return {
+        checked_at: legacy.checked_at,
+        channel: RELEASE_CHANNELS.includes(legacy.channel) ? legacy.channel : DEFAULT_RELEASE_CHANNEL,
+        packages: {
+          myco: {
+            package_name: NPM_PACKAGE_NAME,
+            latest_stable: legacy.latest_stable,
+            latest_beta: legacy.latest_beta ?? null
+          }
+        }
+      };
+    }
+    return null;
   } catch {
     return null;
   }
 }
 function clearCachedCheck() {
   try {
-    fs8.unlinkSync(UPDATE_CHECK_CACHE_PATH);
+    fs9.unlinkSync(UPDATE_CHECK_CACHE_PATH);
   } catch {
   }
 }
@@ -1672,6 +1788,9 @@ function isCacheStale(cache, intervalHours) {
   const ageMs = Date.now() - checkedAt;
   return ageMs > intervalHours * MS_PER_HOUR;
 }
+function packageRegistryUrl(packageName) {
+  return `${NPM_REGISTRY_BASE_URL}/${encodeURIComponent(packageName)}`;
+}
 function resolveTargetVersion(distTags, channel) {
   const stable = distTags.latest;
   const beta = distTags.beta ?? null;
@@ -1681,62 +1800,133 @@ function resolveTargetVersion(distTags, channel) {
   const higher = semver.gt(beta, stable) ? beta : stable;
   return higher;
 }
-function buildCheckResult(currentVersion, cache, config, error) {
-  const targetVersion = resolveTargetVersion(
-    { latest: cache.latest_stable, beta: cache.latest_beta ?? void 0 },
-    cache.channel
+function resolveTargetVersionFromCache(pkg, channel) {
+  return resolveTargetVersion(
+    { latest: pkg.latest_stable, beta: pkg.latest_beta ?? void 0 },
+    channel
   );
-  const update_available = semver.valid(currentVersion) !== null && semver.valid(targetVersion) !== null && semver.gt(targetVersion, currentVersion);
+}
+function buildInstalledPackageVersions(globalPrefix, currentVersion) {
+  const installed = {
+    myco: currentVersion,
+    "myco-team": null,
+    "myco-collective": null
+  };
+  if (globalPrefix === null) return installed;
+  for (const pkg of UPDATE_PACKAGES) {
+    const version = getInstalledVersion(globalPrefix, pkg.packageName);
+    if (pkg.id === "myco") {
+      installed.myco = version ?? currentVersion;
+      continue;
+    }
+    installed[pkg.id] = version;
+  }
+  return installed;
+}
+function buildPackageResults(currentVersion, cache, channel, globalPrefix) {
+  const installedVersions = buildInstalledPackageVersions(globalPrefix, currentVersion);
+  return UPDATE_PACKAGES.map((pkg) => {
+    const cached = cache.packages[pkg.id];
+    const installedVersion = installedVersions[pkg.id];
+    const latestVersion = cached ? resolveTargetVersionFromCache(cached, channel) : null;
+    const updateAvailable = installedVersion !== null && latestVersion !== null && semver.valid(installedVersion) !== null && semver.valid(latestVersion) !== null && semver.gt(latestVersion, installedVersion);
+    return {
+      id: pkg.id,
+      display_name: pkg.displayName,
+      package_name: pkg.packageName,
+      installed: installedVersion !== null,
+      installed_version: installedVersion,
+      latest_version: latestVersion,
+      latest_stable: cached?.latest_stable ?? null,
+      latest_beta: cached?.latest_beta ?? null,
+      update_available: updateAvailable
+    };
+  });
+}
+function buildCheckResult(currentVersion, cache, config, error, globalPrefix) {
+  const packages = buildPackageResults(currentVersion, cache, cache.channel, globalPrefix);
+  const primaryPackage = packages.find((pkg) => pkg.id === "myco");
+  const targetVersion = primaryPackage?.latest_version ?? currentVersion;
+  const latestStable = primaryPackage?.latest_stable ?? currentVersion;
+  const latestBeta = primaryPackage?.latest_beta ?? null;
+  const updateAvailable = packages.some((pkg) => pkg.installed && pkg.update_available);
   return {
-    update_available,
+    update_available: updateAvailable,
     running_version: currentVersion,
     latest_version: targetVersion,
-    latest_stable: cache.latest_stable,
-    latest_beta: cache.latest_beta,
+    latest_stable: latestStable,
+    latest_beta: latestBeta,
     channel: cache.channel,
     check_interval_hours: config.check_interval_hours,
     last_check: cache.checked_at,
-    error
+    error,
+    packages
   };
 }
 function resolveGlobalPrefix() {
   return execFileSync("npm", ["prefix", "-g"], { encoding: "utf-8", timeout: 5e3 }).trim();
 }
-function getInstalledVersion(globalPrefix) {
+function getInstalledVersion(globalPrefix, packageName = NPM_PACKAGE_NAME) {
   try {
     const pkgPath = path9.join(
       globalPrefix,
       "lib",
       "node_modules",
-      NPM_PACKAGE_NAME,
+      packageName,
       "package.json"
     );
-    const raw = fs8.readFileSync(pkgPath, "utf-8");
+    const raw = fs9.readFileSync(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
     return pkg.version ?? null;
   } catch {
     return null;
   }
 }
-async function checkForUpdate(currentVersion) {
+async function checkForUpdate(currentVersion, globalPrefix = null) {
   const config = readUpdateConfig();
   const existingCache = readCachedCheck();
-  let distTags;
-  let fetchError = null;
-  try {
-    const response = await fetch(NPM_REGISTRY_URL, {
-      signal: AbortSignal.timeout(REGISTRY_FETCH_TIMEOUT_MS)
-    });
-    if (!response.ok) {
-      throw new Error(`Registry responded with ${response.status}`);
+  const freshPackages = {};
+  const fetchErrors = [];
+  const registryChecks = await Promise.allSettled(
+    UPDATE_PACKAGES.map(async (pkg) => {
+      const response = await fetch(packageRegistryUrl(pkg.packageName), {
+        signal: AbortSignal.timeout(REGISTRY_FETCH_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        throw new Error(`${pkg.packageName}: registry responded with ${response.status}`);
+      }
+      const data = await response.json();
+      return {
+        id: pkg.id,
+        package_name: pkg.packageName,
+        latest_stable: data["dist-tags"].latest,
+        latest_beta: data["dist-tags"].beta ?? null
+      };
+    })
+  );
+  for (const result of registryChecks) {
+    if (result.status === "fulfilled") {
+      freshPackages[result.value.id] = {
+        package_name: result.value.package_name,
+        latest_stable: result.value.latest_stable,
+        latest_beta: result.value.latest_beta
+      };
+      continue;
     }
-    const data = await response.json();
-    distTags = data["dist-tags"];
-  } catch (err) {
-    fetchError = err instanceof Error ? err.message : String(err);
-    if (existingCache !== null) {
-      return buildCheckResult(currentVersion, existingCache, config, fetchError);
+    const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
+    fetchErrors.push(message);
+  }
+  if (existingCache !== null) {
+    for (const pkg of UPDATE_PACKAGES) {
+      if (freshPackages[pkg.id] !== void 0) continue;
+      const cached = existingCache.packages[pkg.id];
+      if (cached) {
+        freshPackages[pkg.id] = cached;
+      }
     }
+  }
+  if (Object.keys(freshPackages).length === 0) {
+    const fetchError = fetchErrors[0] ?? "registry fetch failed";
     return {
       update_available: false,
       running_version: currentVersion,
@@ -1746,47 +1936,49 @@ async function checkForUpdate(currentVersion) {
       channel: config.channel,
       check_interval_hours: config.check_interval_hours,
       last_check: (/* @__PURE__ */ new Date()).toISOString(),
-      error: fetchError
+      error: fetchError,
+      packages: buildPackageResults(
+        currentVersion,
+        { checked_at: (/* @__PURE__ */ new Date()).toISOString(), channel: config.channel, packages: {} },
+        config.channel,
+        globalPrefix
+      )
     };
   }
-  const latestStable = distTags.latest;
-  const latestBeta = distTags.beta ?? null;
-  const targetVersion = resolveTargetVersion(distTags, config.channel);
   const freshCache = {
     checked_at: (/* @__PURE__ */ new Date()).toISOString(),
-    current_version: currentVersion,
-    latest_stable: latestStable,
-    latest_beta: latestBeta,
-    channel: config.channel
+    channel: config.channel,
+    packages: freshPackages
   };
   try {
-    fs8.mkdirSync(path9.dirname(UPDATE_CHECK_CACHE_PATH), { recursive: true });
-    fs8.writeFileSync(UPDATE_CHECK_CACHE_PATH, JSON.stringify(freshCache, null, 2), "utf-8");
+    fs9.mkdirSync(path9.dirname(UPDATE_CHECK_CACHE_PATH), { recursive: true });
+    fs9.writeFileSync(UPDATE_CHECK_CACHE_PATH, JSON.stringify(freshCache, null, 2), "utf-8");
   } catch {
   }
-  return buildCheckResult(currentVersion, freshCache, config, null);
+  const error = fetchErrors.length > 0 ? fetchErrors.join("; ") : null;
+  return buildCheckResult(currentVersion, freshCache, config, error, globalPrefix);
 }
-function statusFromCache(currentVersion, cache, config) {
+function statusFromCache(currentVersion, cache, config, globalPrefix = null) {
   const resolvedCache = cache !== void 0 ? cache : readCachedCheck();
   if (resolvedCache === null) return null;
   const resolvedConfig = config !== void 0 ? config : readUpdateConfig();
-  return buildCheckResult(currentVersion, resolvedCache, resolvedConfig, null);
+  return buildCheckResult(currentVersion, resolvedCache, resolvedConfig, null, globalPrefix);
 }
 
 // src/daemon/update-installer.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import os6 from "os";
 import path10 from "path";
 import { spawn as spawn2 } from "child_process";
 function generateUpdateScript(params) {
-  const { targetVersion, projectRoot, vaultDir, mycoBinary } = params;
-  const packageSpec = `${NPM_PACKAGE_NAME}@${targetVersion}`;
+  const { packageSpecs, projectRoot, vaultDir, mycoBinary } = params;
+  const installArgs = packageSpecs.map((spec) => JSON.stringify(spec)).join(" ");
   const quotedProjectRoot = JSON.stringify(projectRoot);
   const quotedVaultDir = JSON.stringify(vaultDir);
   const quotedMycoBinary = JSON.stringify(mycoBinary);
   const quotedErrorPath = JSON.stringify(UPDATE_ERROR_PATH);
   const errorJson = JSON.stringify(
-    JSON.stringify({ error: `npm install failed for ${packageSpec}` })
+    JSON.stringify({ error: `npm install failed for ${packageSpecs.join(", ")}` })
   );
   return `#!/bin/sh
 set -e
@@ -1796,7 +1988,7 @@ MYCO=${quotedMycoBinary}
 sleep ${UPDATE_SCRIPT_DELAY_SECONDS}
 
 # Attempt the update
-if npm install -g ${packageSpec} 2>&1; then
+if npm install -g ${installArgs} 2>&1; then
   # Sync project files (gitignore, symbiont registration)
   "$MYCO" update --project ${quotedProjectRoot} || true
   # Clear any previous error
@@ -1815,7 +2007,7 @@ rm -f "$0"
 }
 function spawnDetachedScript(namePrefix, content) {
   const scriptPath = path10.join(os6.tmpdir(), `${namePrefix}-${Date.now()}.sh`);
-  fs9.writeFileSync(scriptPath, content, { encoding: "utf-8", mode: 493 });
+  fs10.writeFileSync(scriptPath, content, { encoding: "utf-8", mode: 493 });
   const child = spawn2("/bin/sh", [scriptPath], {
     detached: true,
     stdio: "ignore"
@@ -1824,7 +2016,7 @@ function spawnDetachedScript(namePrefix, content) {
   return scriptPath;
 }
 function spawnUpdateScript(params) {
-  fs9.mkdirSync(MYCO_GLOBAL_DIR, { recursive: true });
+  fs10.mkdirSync(MYCO_GLOBAL_DIR, { recursive: true });
   return spawnDetachedScript("myco-update", generateUpdateScript(params));
 }
 function generateRestartScript(params) {
@@ -1866,7 +2058,7 @@ function spawnRestartScript(params) {
 
 // src/daemon/api/update.ts
 import semver2 from "semver";
-import fs10 from "fs";
+import fs11 from "fs";
 import path11 from "path";
 var ChannelBodySchema = external_exports.object({
   channel: external_exports.enum(RELEASE_CHANNELS)
@@ -1877,7 +2069,7 @@ function createUpdateHandlers(deps) {
   function isStampCurrent() {
     try {
       const stampPath = path11.join(vaultDir, UPDATE_STAMP_FILENAME);
-      const stamp = fs10.readFileSync(stampPath, "utf-8").trim();
+      const stamp = fs11.readFileSync(stampPath, "utf-8").trim();
       return stamp === currentVersion;
     } catch {
       return false;
@@ -1914,10 +2106,10 @@ function createUpdateHandlers(deps) {
     const config = readUpdateConfig();
     const cache = readCachedCheck();
     if (isCacheStale(cache, config.check_interval_hours)) {
-      checkForUpdate(currentVersion).catch(() => {
+      checkForUpdate(currentVersion, globalPrefix).catch(() => {
       });
     }
-    const status = statusFromCache(currentVersion, cache, config);
+    const status = statusFromCache(currentVersion, cache, config, globalPrefix);
     if (!status) {
       return {
         body: {
@@ -1943,25 +2135,32 @@ function createUpdateHandlers(deps) {
         body: { error: "update_exempt", message: "Updates disabled in dev mode" }
       };
     }
-    const result = await checkForUpdate(currentVersion);
+    const result = await checkForUpdate(currentVersion, globalPrefix);
     return { body: { exempt: false, ...result } };
   }
   async function handleUpdateApply(_req) {
     if (isUpdateExempt()) {
       return { status: 400, body: { error: "update_exempt" } };
     }
-    const status = statusFromCache(currentVersion);
-    if (!status || !status.update_available) {
+    const status = statusFromCache(currentVersion, void 0, void 0, globalPrefix);
+    const packageSpecs = (status?.packages ?? []).filter((pkg) => pkg.installed && pkg.update_available && pkg.latest_version).map((pkg) => `${pkg.package_name}@${pkg.latest_version}`);
+    if (!status || packageSpecs.length === 0) {
       return { status: 400, body: { error: "no_update_available" } };
     }
     spawnUpdateScript({
-      targetVersion: status.latest_version,
+      packageSpecs,
       projectRoot,
       vaultDir,
       mycoBinary: resolveMycoBinary()
     });
     scheduleShutdown();
-    return { body: { status: "applying", version: status.latest_version } };
+    return {
+      body: {
+        status: "applying",
+        version: status.latest_version,
+        packages: packageSpecs
+      }
+    };
   }
   async function handleUpdateChannel(req) {
     const parsed = ChannelBodySchema.safeParse(req.body);
@@ -1972,7 +2171,7 @@ function createUpdateHandlers(deps) {
     const config = readUpdateConfig();
     writeUpdateConfig({ ...config, channel });
     clearCachedCheck();
-    const channelStatus = statusFromCache(currentVersion);
+    const channelStatus = statusFromCache(currentVersion, void 0, void 0, globalPrefix);
     if (!channelStatus) {
       return {
         body: {
@@ -2000,7 +2199,7 @@ function createUpdateHandlers(deps) {
 }
 
 // src/daemon/backup.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import path12 from "path";
 var BACKUP_TABLES = [
   "sessions",
@@ -2028,7 +2227,7 @@ function toSqlLiteral(value) {
   return `'${escapeSql(String(value))}'`;
 }
 function createBackup(db, backupDir, machineId) {
-  fs11.mkdirSync(backupDir, { recursive: true });
+  fs12.mkdirSync(backupDir, { recursive: true });
   const lines = [];
   const timestamp = epochSeconds();
   lines.push(`${BACKUP_HEADER_TEMPLATE}: machine_id=${machineId}, created_at=${timestamp}`);
@@ -2047,13 +2246,13 @@ function createBackup(db, backupDir, machineId) {
     lines.push("");
   }
   const filePath = path12.join(backupDir, `${machineId}${BACKUP_EXTENSION}`);
-  fs11.writeFileSync(filePath, lines.join("\n"), "utf-8");
+  fs12.writeFileSync(filePath, lines.join("\n"), "utf-8");
   return filePath;
 }
 function listBackups(backupDir) {
   let entries;
   try {
-    entries = fs11.readdirSync(backupDir);
+    entries = fs12.readdirSync(backupDir);
   } catch {
     return [];
   }
@@ -2061,7 +2260,7 @@ function listBackups(backupDir) {
   for (const entry of entries) {
     if (!BACKUP_FILENAME_PATTERN.test(entry)) continue;
     const filePath = path12.join(backupDir, entry);
-    const stat = fs11.statSync(filePath);
+    const stat = fs12.statSync(filePath);
     backups.push({
       machine_id: entry.slice(0, -BACKUP_EXTENSION.length),
       file_name: entry,
@@ -2073,7 +2272,7 @@ function listBackups(backupDir) {
 }
 var INSERT_REGEX = /^INSERT OR IGNORE INTO (\w+)\s+\(([^)]+)\)\s+VALUES\s+\((.+)\);$/;
 function parseBackupFile(backupPath) {
-  const content = fs11.readFileSync(backupPath, "utf-8");
+  const content = fs12.readFileSync(backupPath, "utf-8");
   const inserts = [];
   for (const line of content.split("\n")) {
     const match = INSERT_REGEX.exec(line);
@@ -2349,6 +2548,18 @@ var TeamSyncClient = class _TeamSyncClient {
     const res = await this.request("GET", "/config");
     return res;
   }
+  async getCollectiveStatus() {
+    const res = await this.request("GET", "/collective/status");
+    return res;
+  }
+  async getCollectiveSettings() {
+    const res = await this.request("GET", "/collective/settings");
+    return res;
+  }
+  async collectiveQuery(tool, args = {}) {
+    const res = await this.request("POST", "/collective/query", { tool, args });
+    return res;
+  }
   // ---------------------------------------------------------------------------
   // MCP token accessors
   // ---------------------------------------------------------------------------
@@ -2389,6 +2600,12 @@ var TeamSyncClient = class _TeamSyncClient {
 };
 
 // src/daemon/api/team-connect.ts
+var TEAM_CONFIG_DIR = ".myco-team";
+var TEAM_CONFIG_FILE = "config.json";
+function readInstalledTeamPackageVersion() {
+  const config = readJsonConfig(resolveHomeConfigPath(TEAM_CONFIG_DIR, TEAM_CONFIG_FILE));
+  return config?.package_version?.trim() || null;
+}
 function createTeamHandlers(deps) {
   const { vaultDir, machineId, logger } = deps;
   async function handleConnect(req) {
@@ -2443,6 +2660,7 @@ function createTeamHandlers(deps) {
     const client = deps.getTeamClient();
     const secrets = readSecrets(vaultDir);
     const hasApiKey = Boolean(secrets[TEAM_API_KEY_SECRET]);
+    const installedTeamPackageVersion = readInstalledTeamPackageVersion();
     let healthy = false;
     let healthError;
     if (client && config.team.enabled) {
@@ -2460,6 +2678,14 @@ function createTeamHandlers(deps) {
       deadLetterCount = countDeadLettered();
     } catch {
     }
+    let collectiveStatus = null;
+    if (client && config.team.enabled) {
+      try {
+        collectiveStatus = await client.getCollectiveStatus();
+      } catch {
+        collectiveStatus = null;
+      }
+    }
     return {
       body: {
         enabled: config.team.enabled,
@@ -2472,8 +2698,16 @@ function createTeamHandlers(deps) {
         dead_letter_count: deadLetterCount,
         machine_id: machineId,
         package_version: getPluginVersion(),
+        installed_team_package_version: installedTeamPackageVersion,
         deployed_worker_version: config.team.deployed_worker_version ?? null,
-        worker_update_available: config.team.enabled ? config.team.deployed_worker_version !== getPluginVersion() : false,
+        worker_update_available: config.team.enabled && Boolean(installedTeamPackageVersion) && config.team.deployed_worker_version !== installedTeamPackageVersion,
+        collective_connected: collectiveStatus?.connected ?? false,
+        collective_url: collectiveStatus?.collective_url ?? null,
+        collective_project_id: collectiveStatus?.project_id ?? null,
+        collective_last_settings_sync: collectiveStatus?.last_settings_sync ?? null,
+        collective_last_heartbeat: collectiveStatus?.last_heartbeat ?? null,
+        collective_capabilities: collectiveStatus?.capabilities ?? [],
+        collective_settings: collectiveStatus?.settings ?? {},
         schema_version: SCHEMA_VERSION,
         sync_protocol_version: SYNC_PROTOCOL_VERSION,
         mcp_token: client?.getMcpToken() ?? null,
@@ -2490,7 +2724,7 @@ function createTeamHandlers(deps) {
     return { body: { retried: count } };
   }
   async function handleUpgradeWorker(_req) {
-    const { upgradeWorker } = await import("./team-2ZFGTSIN.js");
+    const { upgradeWorker } = await import("./team-N6TXS2PF.js");
     logger.info("team-sync.upgrade.start", "Starting worker upgrade");
     const result = upgradeWorker(vaultDir);
     if (!result.success) {
@@ -2539,6 +2773,96 @@ function createTeamHandlers(deps) {
   return { handleConnect, handleDisconnect, handleStatus, handleBackfill, handleRetryFailed, handleUpgradeWorker, handleRotateMcpToken };
 }
 
+// src/daemon/api/collective.ts
+function createCollectiveHandlers(deps) {
+  async function requireTeamClient() {
+    const client = deps.getTeamClient();
+    if (!client) {
+      throw new Error("Team sync is not connected");
+    }
+    return client;
+  }
+  async function handleStatus(_req) {
+    try {
+      const client = await requireTeamClient();
+      return { body: await client.getCollectiveStatus() };
+    } catch (error) {
+      return {
+        status: 400,
+        body: { error: error instanceof Error ? error.message : String(error) }
+      };
+    }
+  }
+  async function handleSearch(req) {
+    try {
+      const client = await requireTeamClient();
+      const query = req.query.q;
+      if (!query) {
+        return { status: 400, body: { error: "Missing q parameter" } };
+      }
+      const project = req.query.project;
+      const limit = req.query.limit ? Number(req.query.limit) : void 0;
+      return {
+        body: await client.collectiveQuery("collective_search", { query, project, limit })
+      };
+    } catch (error) {
+      return {
+        status: 400,
+        body: { error: error instanceof Error ? error.message : String(error) }
+      };
+    }
+  }
+  async function handleProjects(_req) {
+    try {
+      const client = await requireTeamClient();
+      return {
+        body: await client.collectiveQuery("collective_projects", {})
+      };
+    } catch (error) {
+      return {
+        status: 400,
+        body: { error: error instanceof Error ? error.message : String(error) }
+      };
+    }
+  }
+  async function handleProject(req) {
+    try {
+      const client = await requireTeamClient();
+      const project = req.query.project;
+      if (!project) {
+        return { status: 400, body: { error: "Missing project parameter" } };
+      }
+      const includeDigest = req.query.include_digest === "true";
+      return {
+        body: await client.collectiveQuery("collective_project", { project, include_digest: includeDigest })
+      };
+    } catch (error) {
+      return {
+        status: 400,
+        body: { error: error instanceof Error ? error.message : String(error) }
+      };
+    }
+  }
+  async function handleSettings(_req) {
+    try {
+      const client = await requireTeamClient();
+      return { body: await client.getCollectiveSettings() };
+    } catch (error) {
+      return {
+        status: 400,
+        body: { error: error instanceof Error ? error.message : String(error) }
+      };
+    }
+  }
+  return {
+    handleStatus,
+    handleSearch,
+    handleProjects,
+    handleProject,
+    handleSettings
+  };
+}
+
 // src/daemon/api/session-lifecycle.ts
 var RegisterBody = external_exports.object({
   session_id: external_exports.string(),
@@ -2616,7 +2940,7 @@ function createSessionLifecycleHandlers(deps) {
 }
 
 // src/daemon/api/skills.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import path14 from "path";
 
 // src/db/queries/skill-usage.ts
@@ -2787,7 +3111,7 @@ function createSkillRecordDeleteHandler(deps) {
         const projectRoot = path14.resolve(vaultDir, "..");
         const skillDir = path14.resolve(projectRoot, ".agents", "skills", record.name);
         try {
-          fs12.rmSync(skillDir, { recursive: true, force: true });
+          fs13.rmSync(skillDir, { recursive: true, force: true });
         } catch (err) {
           logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to remove skill directory", { name: record.name, error: String(err) });
         }
@@ -3045,12 +3369,12 @@ async function handleGetModels(req) {
 
 // src/daemon/api/stats.ts
 import { createHash as createHash2 } from "crypto";
-import fs13 from "fs";
+import fs14 from "fs";
 import path15 from "path";
 function computeConfigHash(vaultDir) {
   try {
     const configPath = path15.join(vaultDir, CONFIG_FILENAME);
-    const raw = fs13.readFileSync(configPath, "utf-8");
+    const raw = fs14.readFileSync(configPath, "utf-8");
     return createHash2("md5").update(raw).digest("hex");
   } catch {
     return "";
@@ -3730,6 +4054,26 @@ async function handleGetDigest(req) {
 }
 
 // src/daemon/api/search.ts
+var SEARCH_NAMESPACE_RULES = [
+  { key: "all", value: void 0 },
+  { key: "session", value: "sessions" },
+  { key: "sessions", value: "sessions" },
+  { key: "spore", value: "spores" },
+  { key: "spores", value: "spores" },
+  { key: "plan", value: "plans" },
+  { key: "plans", value: "plans" },
+  { key: "artifact", value: "artifacts" },
+  { key: "artifacts", value: "artifacts" },
+  { key: "skill", value: "skill_records" },
+  { key: "skill_records", value: "skill_records" }
+];
+function normalizeSearchNamespace(value) {
+  if (!value) return void 0;
+  for (const rule of SEARCH_NAMESPACE_RULES) {
+    if (rule.key === value) return rule.value;
+  }
+  return value;
+}
 function createSearchHandler(deps) {
   return async function handleSearch(req) {
     const query = req.query.q;
@@ -3750,7 +4094,7 @@ function createSearchHandler(deps) {
       }
       return { body: { mode: "semantic", results: [], provider_unavailable: true } };
     }
-    const searchNamespace = namespace ?? type;
+    const searchNamespace = normalizeSearchNamespace(namespace ?? type);
     const vectorResults = deps.embeddingManager.searchVectors(queryVector, {
       namespace: searchNamespace,
       limit,
@@ -4403,6 +4747,13 @@ var EmbeddingManager = class {
   searchVectors(query, options) {
     return this.vectorStore.search(query, options);
   }
+  /**
+   * Compute pairwise cosine similarity between all vectors in a namespace.
+   * Used by the evolve instruction builder to find semantically overlapping skills.
+   */
+  pairwiseSimilarity(namespace, threshold) {
+    return this.vectorStore.pairwiseSimilarity(namespace, threshold);
+  }
   // -------------------------------------------------------------------------
   // Private helpers
   // -------------------------------------------------------------------------
@@ -4673,6 +5024,48 @@ var SqliteVecVectorStore = class {
     const rows = this.embeddedIdsStmt.all(namespace);
     return rows.map((r) => r.record_id);
   }
+  /**
+   * Compute pairwise cosine similarity between all vectors in a namespace.
+   * Returns pairs above the threshold, sorted by similarity DESC.
+   *
+   * Uses sqlite-vec's KNN search: for each vector, find the top-K nearest
+   * neighbors within the same namespace. O(n * K) where K is small.
+   */
+  pairwiseSimilarity(namespace, threshold = 0.5) {
+    this.validateNamespace(namespace);
+    const ns = namespace;
+    const allRows = this.db.prepare(
+      `SELECT record_id, embedding FROM vec_${ns}`
+    ).all();
+    if (allRows.length < 2) return [];
+    const pairs = [];
+    const seen = /* @__PURE__ */ new Set();
+    const searchStmt = this.searchStmts.get(ns);
+    for (const row of allRows) {
+      const results = searchStmt.all(
+        row.embedding,
+        // Use the raw embedding as the query vector
+        allRows.length
+        // K = all rows to get exhaustive comparison
+      );
+      for (const match of results) {
+        if (match.record_id === row.record_id) continue;
+        const pairKey = [row.record_id, match.record_id].sort().join("|");
+        if (seen.has(pairKey)) continue;
+        seen.add(pairKey);
+        const similarity = cosineDistanceToSimilarity(match.distance);
+        if (similarity >= threshold) {
+          pairs.push({
+            idA: row.record_id,
+            idB: match.record_id,
+            similarity: Math.round(similarity * 1e3) / 1e3
+          });
+        }
+      }
+    }
+    pairs.sort((a, b) => b.similarity - a.similarity);
+    return pairs;
+  }
   // -------------------------------------------------------------------------
   // Lifecycle
   // -------------------------------------------------------------------------
@@ -4810,6 +5203,12 @@ function planMetadata(row) {
     ...row.source_path != null ? { source_path: row.source_path } : {}
   };
 }
+function skillRecordMetadata(row) {
+  return {
+    ...row.status != null ? { status: row.status } : {},
+    ...row.name != null ? { name: row.name } : {}
+  };
+}
 function metadataFor(namespace, row) {
   switch (namespace) {
     case "sessions":
@@ -4820,6 +5219,8 @@ function metadataFor(namespace, row) {
       return planMetadata(row);
     case "artifacts":
       return emptyMetadata();
+    case "skill_records":
+      return skillRecordMetadata(row);
   }
 }
 var SqliteRecordSource = class {
@@ -4834,6 +5235,9 @@ var SqliteRecordSource = class {
     if (namespace === "spores") {
       return this.getUnembeddedActiveSpores(limit);
     }
+    if (namespace === "skill_records") {
+      return this.getUnembeddedActiveSkillRecords(limit);
+    }
     const rows = getUnembedded(namespace, limit);
     const db = getDatabase();
     return rows.map((row) => {
@@ -4880,6 +5284,12 @@ var SqliteRecordSource = class {
         ).all();
         return rows.map((r) => r.id);
       }
+      case "skill_records": {
+        const rows = db.prepare(
+          `SELECT id FROM skill_records WHERE status = ?`
+        ).all(ACTIVE_STATUS2);
+        return rows.map((r) => r.id);
+      }
     }
   }
   /**
@@ -4934,7 +5344,7 @@ var SqliteRecordSource = class {
     assertValidTable(namespace);
     const db = getDatabase();
     const contentFilter = namespace === "sessions" ? " AND summary IS NOT NULL" : "";
-    const statusFilter = namespace === "spores" ? ` AND status = '${ACTIVE_STATUS2}'` : "";
+    const statusFilter = namespace === "spores" || namespace === "skill_records" ? ` AND status = '${ACTIVE_STATUS2}'` : "";
     const row = db.prepare(
       `SELECT COUNT(*) AS cnt FROM ${namespace} WHERE embedded = 0${contentFilter}${statusFilter}`
     ).get();
@@ -4959,20 +5369,36 @@ var SqliteRecordSource = class {
       metadata: sporeMetadata(row)
     }));
   }
+  /** Custom query for skill_records: embedded=0 AND status='active'. */
+  getUnembeddedActiveSkillRecords(limit) {
+    const db = getDatabase();
+    const rows = db.prepare(
+      `SELECT id, description AS text, status, name
+       FROM skill_records
+       WHERE embedded = 0 AND status = ?
+       ORDER BY created_at ASC
+       LIMIT ?`
+    ).all(ACTIVE_STATUS2, limit);
+    return rows.map((row) => ({
+      id: String(row.id),
+      text: row.text,
+      metadata: skillRecordMetadata(row)
+    }));
+  }
 };
 
 // src/daemon/database/manager.ts
-import fs15 from "fs";
+import fs16 from "fs";
 
 // src/db/queries/database.ts
-import fs14 from "fs";
+import fs15 from "fs";
 function pragmaScalar(name) {
   const db = getDatabase();
   return db.pragma(name, { simple: true });
 }
 function safeFileSize(filePath) {
   try {
-    return fs14.statSync(filePath).size;
+    return fs15.statSync(filePath).size;
   } catch (err) {
     if (err.code === "ENOENT") return 0;
     throw err;
@@ -5244,7 +5670,7 @@ var DatabaseMaintenanceManager = class {
   }
   async vacuum() {
     const size_before = this.fileSize();
-    const stats = await fs15.promises.statfs(this.vaultDir);
+    const stats = await fs16.promises.statfs(this.vaultDir);
     const free_bytes = Number(stats.bavail) * Number(stats.bsize);
     const required_bytes = size_before * VACUUM_FREE_SPACE_MULTIPLIER;
     if (free_bytes < required_bytes) {
@@ -5292,7 +5718,7 @@ var DatabaseMaintenanceManager = class {
   }
   fileSize() {
     try {
-      return fs15.statSync(this.dbPath).size;
+      return fs16.statSync(this.dbPath).size;
     } catch {
       return 0;
     }
@@ -5685,6 +6111,9 @@ function testAnthropic() {
   return { ok: true };
 }
 
+// src/daemon/task-scheduling.ts
+import { resolve } from "path";
+
 // src/daemon/task-scheduler.ts
 function resolveSchedule(yamlSchedule, configOverride) {
   if (!configOverride?.schedule) return yamlSchedule;
@@ -5742,8 +6171,12 @@ async function registerScheduledTasks(powerManager, deps) {
     logger.info(LOG_KINDS.AGENT_RUN, "Scheduled agent tasks disabled globally (agent.scheduled_tasks_enabled: false)");
     return;
   }
-  const { loadAllTasks: loadAllTasks2 } = await import("./registry-O2NZLO3V.js");
+  const { loadAllTasks: loadAllTasks2 } = await import("./registry-X5FDGYXT.js");
   const allTasks = Array.from(loadAllTasks2(definitionsDir, vaultDir).values());
+  const taskAgentMap = /* @__PURE__ */ new Map();
+  for (const task of allTasks) {
+    taskAgentMap.set(task.name, task.agent);
+  }
   const initialLastRuns = {};
   try {
     const recentRuns = getDatabase().prepare(
@@ -5764,9 +6197,10 @@ async function registerScheduledTasks(powerManager, deps) {
       else runningTasks.delete(name);
     },
     runTask: async (taskName) => {
-      const { runAgent } = await import("./executor-NSPRTH4M.js");
+      const { runAgent } = await import("./executor-ICTRRUBY.js");
       const taskConfig = config.agent.tasks?.[taskName];
-      const built = buildTaskInstruction(taskName, taskConfig?.params);
+      const projectRoot = resolve(vaultDir, "..");
+      const built = buildTaskInstruction(taskName, taskConfig?.params, taskAgentMap.get(taskName), projectRoot, embeddingManager);
       if (isInstructionRequiredTask(taskName) && !built) {
         logger.info(
           LOG_KINDS.AGENT_RUN,
@@ -5933,7 +6367,7 @@ function createMcpProxyHandlers(deps) {
       name: USER_AGENT_NAME,
       created_at: now
     });
-    const { insertResolutionEvent } = await import("./resolution-events-XWYLLDRK.js");
+    const { insertResolutionEvent } = await import("./resolution-events-MVIZMONR.js");
     const resolutionId = `res-${randomBytes(RESOLUTION_ID_RANDOM_BYTES).toString("hex")}`;
     insertResolutionEvent({
       id: resolutionId,
@@ -6015,6 +6449,7 @@ function createMcpProxyHandlers(deps) {
 }
 
 // src/daemon/api/agent-runs.ts
+import { resolve as resolve2 } from "path";
 var AGENT_RUNS_DEFAULT_LIMIT = 50;
 var AgentRunBody = external_exports.object({
   task: external_exports.string().optional(),
@@ -6041,9 +6476,11 @@ function createAgentRunHandlers(deps) {
       let built;
       try {
         const taskParams = mycoConfig.agent.tasks?.[task]?.params;
-        built = buildTaskInstruction(task, taskParams);
+        const projectRoot = resolve2(vaultDir, "..");
+        built = buildTaskInstruction(task, taskParams, agentId, projectRoot, embeddingManager);
       } catch {
-        built = buildTaskInstruction(task);
+        const projectRoot = resolve2(vaultDir, "..");
+        built = buildTaskInstruction(task, void 0, agentId, projectRoot, embeddingManager);
       }
       instruction = built?.instruction;
       runContext = built?.context;
@@ -6058,7 +6495,7 @@ function createAgentRunHandlers(deps) {
         };
       }
     }
-    const { runAgent } = await import("./executor-NSPRTH4M.js");
+    const { runAgent } = await import("./executor-ICTRRUBY.js");
     const resultPromise = runAgent(vaultDir, {
       task,
       instruction,
@@ -6127,7 +6564,7 @@ function createAgentRunHandlers(deps) {
 }
 
 // src/daemon/api/attachments.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import path16 from "path";
 var ATTACHMENT_MEDIA_TYPES = {
   png: "image/png",
@@ -6151,7 +6588,7 @@ function createAttachmentHandler(deps) {
     const filePath = path16.join(vaultDir, "attachments", filename);
     let diskData;
     try {
-      diskData = fs16.readFileSync(filePath);
+      diskData = fs17.readFileSync(filePath);
     } catch {
       return { status: 404, body: { error: "not_found" } };
     }
@@ -6163,19 +6600,19 @@ function createAttachmentHandler(deps) {
 }
 
 // src/daemon/log-reconcile.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import path17 from "path";
 function reconcileLogBuffer(logDir, sinceTimestamp) {
   let replayed = 0;
   const files = [];
   for (let i = 3; i >= 1; i--) {
     const rotated = path17.join(logDir, `daemon.${i}.log`);
-    if (fs17.existsSync(rotated)) files.push(rotated);
+    if (fs18.existsSync(rotated)) files.push(rotated);
   }
   const current = path17.join(logDir, "daemon.log");
-  if (fs17.existsSync(current)) files.push(current);
+  if (fs18.existsSync(current)) files.push(current);
   for (const file of files) {
-    const content = fs17.readFileSync(file, "utf-8");
+    const content = fs18.readFileSync(file, "utf-8");
     for (const line of content.split("\n")) {
       if (!line.trim()) continue;
       try {
@@ -6454,7 +6891,7 @@ function registerPowerJobs(powerManager, deps) {
 }
 
 // src/daemon/reconciliation.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import path18 from "path";
 
 // src/daemon/event-handlers.ts
@@ -6627,7 +7064,7 @@ function createReconciler({ bufferDir, logger }) {
     const bufferPath = path18.join(bufferDir, `${sessionId}.jsonl`);
     let content;
     try {
-      content = fs18.readFileSync(bufferPath, "utf-8").trim();
+      content = fs19.readFileSync(bufferPath, "utf-8").trim();
     } catch {
       return;
     }
@@ -6696,7 +7133,7 @@ function createReconciler({ bufferDir, logger }) {
 }
 
 // src/daemon/stop-processing.ts
-import fs19 from "fs";
+import fs20 from "fs";
 
 // src/daemon/capture-images.ts
 var SESSION_SHORT_LEN = 6;
@@ -6733,6 +7170,78 @@ function captureBatchImages(input) {
   }
 }
 
+// src/daemon/plan-capture.ts
+import { createHash as createHash4 } from "crypto";
+import os7 from "os";
+import path19 from "path";
+function extractTaggedPlans(text, tags) {
+  const results = [];
+  for (const tag of tags) {
+    const regex = new RegExp(`<${tag}>\\n?([\\s\\S]*?)\\n?</${tag}>`, "g");
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+      const content = match[1].trim();
+      if (content) results.push({ tag, content });
+    }
+  }
+  return results;
+}
+var TRANSCRIPT_SOURCE_PREFIX = "transcript:";
+var FILE_WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "Write",
+  "Edit",
+  "Create",
+  "write",
+  "edit",
+  "patch",
+  "create"
+]);
+var HEADING_REGEX = /^#\s+(.+)$/m;
+var PLAN_ID_HASH_LENGTH = 16;
+function isInPlanDirectory(filePath, watchDirs, projectRoot) {
+  const abs = path19.isAbsolute(filePath) ? filePath : path19.resolve(projectRoot, filePath);
+  return watchDirs.some((dir) => {
+    const expanded = dir.startsWith("~/") ? path19.join(os7.homedir(), dir.slice(2)) : dir;
+    const absDir = path19.isAbsolute(expanded) ? expanded : path19.resolve(projectRoot, expanded);
+    const prefix = absDir.endsWith(path19.sep) ? absDir : absDir + path19.sep;
+    return abs === absDir || abs.startsWith(prefix);
+  });
+}
+function isPlanWriteEvent(toolName, toolInput, config) {
+  if (!FILE_WRITE_TOOLS.has(toolName)) return null;
+  const filePath = toolInput?.file_path ?? toolInput?.path ?? toolInput?.filePath;
+  if (typeof filePath !== "string") return null;
+  if (!isInPlanDirectory(filePath, config.watchDirs, config.projectRoot)) return null;
+  if (config.extensions?.length) {
+    const ext = path19.extname(filePath).toLowerCase();
+    if (!config.extensions.includes(ext)) return null;
+  }
+  return filePath;
+}
+function parsePlanTitle(content, filename) {
+  const match = HEADING_REGEX.exec(content);
+  if (match) return match[1].trim();
+  return filename ?? null;
+}
+function capturePlan(input) {
+  const now = Math.floor(Date.now() / 1e3);
+  const contentHash = createHash4(CONTENT_HASH_ALGORITHM).update(input.content).digest("hex");
+  const id = createHash4("md5").update(input.sourcePath).digest("hex").slice(0, PLAN_ID_HASH_LENGTH);
+  const title = parsePlanTitle(input.content, path19.basename(input.sourcePath));
+  return upsertPlan({
+    id,
+    title,
+    content: input.content,
+    source_path: input.sourcePath,
+    session_id: input.sessionId,
+    prompt_batch_id: input.promptBatchId ?? null,
+    content_hash: contentHash,
+    status: "active",
+    created_at: now,
+    updated_at: now
+  });
+}
+
 // src/daemon/skill-usage.ts
 import crypto from "crypto";
 var SKILL_USAGE_DETECTION_ENABLED = false;
@@ -6809,7 +7318,7 @@ function createStopProcessor(deps) {
     if (config.agent.summary_batch_interval <= 0) return;
     if (config.agent.event_tasks_enabled === false) return;
     try {
-      const { runAgent } = await import("./executor-NSPRTH4M.js");
+      const { runAgent } = await import("./executor-ICTRRUBY.js");
       runAgent(vaultDir, {
         task: "title-summary",
         instruction: `Process session ${sessionId} only`,
@@ -6899,7 +7408,7 @@ function createStopProcessor(deps) {
         let transcriptText = null;
         if (hookTranscriptPath) {
           try {
-            transcriptText = fs19.readFileSync(hookTranscriptPath, "utf-8");
+            transcriptText = fs20.readFileSync(hookTranscriptPath, "utf-8");
           } catch {
           }
         }
@@ -6925,6 +7434,33 @@ function createStopProcessor(deps) {
         logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to populate batch responses", { error: String(err) });
       }
     }
+    if (deps.planTags.length > 0) {
+      for (const turn of allTurns) {
+        if (!turn.aiResponse) continue;
+        const taggedPlans = extractTaggedPlans(turn.aiResponse, deps.planTags);
+        for (const { tag, content } of taggedPlans) {
+          try {
+            capturePlan({
+              sourcePath: `${TRANSCRIPT_SOURCE_PREFIX}${tag}`,
+              content,
+              sessionId,
+              promptBatchId: latestBatch?.id ?? null
+            });
+            logger.info(LOG_KINDS.CAPTURE_PLAN, "Plan captured from transcript tag", {
+              session_id: sessionId,
+              tag,
+              content_length: content.length
+            });
+          } catch (err) {
+            logger.warn(LOG_KINDS.CAPTURE_PLAN, "Failed to capture plan from transcript tag", {
+              session_id: sessionId,
+              tag,
+              error: err.message
+            });
+          }
+        }
+      }
+    }
     if (!hasTitle) {
       triggerTitleSummary(sessionId);
     }
@@ -7008,69 +7544,8 @@ function createStopProcessor(deps) {
 }
 
 // src/daemon/event-dispatch.ts
-import fs20 from "fs";
+import fs21 from "fs";
 import path20 from "path";
-
-// src/daemon/plan-capture.ts
-import { createHash as createHash4 } from "crypto";
-import os7 from "os";
-import path19 from "path";
-var FILE_WRITE_TOOLS = /* @__PURE__ */ new Set([
-  "Write",
-  "Edit",
-  "Create",
-  "write",
-  "edit",
-  "patch",
-  "create"
-]);
-var HEADING_REGEX = /^#\s+(.+)$/m;
-var PLAN_ID_HASH_LENGTH = 16;
-function isInPlanDirectory(filePath, watchDirs, projectRoot) {
-  const abs = path19.isAbsolute(filePath) ? filePath : path19.resolve(projectRoot, filePath);
-  return watchDirs.some((dir) => {
-    const expanded = dir.startsWith("~/") ? path19.join(os7.homedir(), dir.slice(2)) : dir;
-    const absDir = path19.isAbsolute(expanded) ? expanded : path19.resolve(projectRoot, expanded);
-    const prefix = absDir.endsWith(path19.sep) ? absDir : absDir + path19.sep;
-    return abs === absDir || abs.startsWith(prefix);
-  });
-}
-function isPlanWriteEvent(toolName, toolInput, config) {
-  if (!FILE_WRITE_TOOLS.has(toolName)) return null;
-  const filePath = toolInput?.file_path ?? toolInput?.path ?? toolInput?.filePath;
-  if (typeof filePath !== "string") return null;
-  if (!isInPlanDirectory(filePath, config.watchDirs, config.projectRoot)) return null;
-  if (config.extensions?.length) {
-    const ext = path19.extname(filePath).toLowerCase();
-    if (!config.extensions.includes(ext)) return null;
-  }
-  return filePath;
-}
-function parsePlanTitle(content, filename) {
-  const match = HEADING_REGEX.exec(content);
-  if (match) return match[1].trim();
-  return filename ?? null;
-}
-function capturePlan(input) {
-  const now = Math.floor(Date.now() / 1e3);
-  const contentHash = createHash4(CONTENT_HASH_ALGORITHM).update(input.content).digest("hex");
-  const id = createHash4("md5").update(input.sourcePath).digest("hex").slice(0, PLAN_ID_HASH_LENGTH);
-  const title = parsePlanTitle(input.content, path19.basename(input.sourcePath));
-  return upsertPlan({
-    id,
-    title,
-    content: input.content,
-    source_path: input.sourcePath,
-    session_id: input.sessionId,
-    prompt_batch_id: input.promptBatchId ?? null,
-    content_hash: contentHash,
-    status: "active",
-    created_at: now,
-    updated_at: now
-  });
-}
-
-// src/daemon/event-dispatch.ts
 var EventBody = external_exports.object({ type: external_exports.string(), session_id: external_exports.string() }).passthrough();
 function createEventDispatcher(deps) {
   const {
@@ -7163,7 +7638,7 @@ function createEventDispatcher(deps) {
       );
       if (planFilePath) {
         const captureSessionId = event.session_id;
-        fs20.promises.readFile(planFilePath, "utf-8").then((planContent) => {
+        fs21.promises.readFile(planFilePath, "utf-8").then((planContent) => {
           const latestBatch = getLatestBatch(captureSessionId);
           capturePlan({
             sourcePath: path20.relative(projectRoot, planFilePath),
@@ -7308,14 +7783,14 @@ function createEventDispatcher(deps) {
 }
 
 // src/daemon/main.ts
-import fs21 from "fs";
+import fs22 from "fs";
 import os8 from "os";
 import path21 from "path";
 function killStaleDaemon(vaultDir, logger) {
   const daemonJsonPath = path21.join(vaultDir, "daemon.json");
   try {
-    if (!fs21.existsSync(daemonJsonPath)) return;
-    const info = JSON.parse(fs21.readFileSync(daemonJsonPath, "utf-8"));
+    if (!fs22.existsSync(daemonJsonPath)) return;
+    const info = JSON.parse(fs22.readFileSync(daemonJsonPath, "utf-8"));
     if (!info.pid) return;
     if (info.pid === process.pid) return;
     try {
@@ -7324,7 +7799,7 @@ function killStaleDaemon(vaultDir, logger) {
       logger.info(LOG_KINDS.DAEMON_START, "Killed stale daemon", { pid: info.pid });
     } catch {
     }
-    fs21.unlinkSync(daemonJsonPath);
+    fs22.unlinkSync(daemonJsonPath);
   } catch {
   }
 }
@@ -7339,6 +7814,7 @@ async function main() {
   const config = loadConfig(vaultDir);
   const manifests = loadManifests();
   const symbiontPlanDirs = manifests.flatMap((m) => m.capture?.planDirs ?? []);
+  const symbiontPlanTags = [...new Set(manifests.flatMap((m) => m.capture?.planTags ?? []))];
   const projectRoot = process.cwd();
   let planWatchConfig = {
     watchDirs: [.../* @__PURE__ */ new Set([...symbiontPlanDirs, ...config.capture.plan_dirs ?? []])],
@@ -7357,6 +7833,9 @@ async function main() {
     embedding_provider: config.embedding.provider
   });
   logger.info(LOG_KINDS.CAPTURE_PLAN, "Plan watch directories", { dirs: planWatchConfig.watchDirs });
+  if (symbiontPlanTags.length > 0) {
+    logger.info(LOG_KINDS.CAPTURE_PLAN, "Plan transcript tags", { tags: symbiontPlanTags });
+  }
   const machineId = getMachineId(vaultDir);
   logger.info(LOG_KINDS.DAEMON_START, "Machine ID resolved", { machine_id: machineId });
   let globalPrefix = null;
@@ -7371,7 +7850,7 @@ async function main() {
   const devCliEntry = detectDevBuild(
     globalPrefix,
     process.argv[1],
-    fs21.realpathSync
+    fs22.realpathSync
   );
   if (devCliEntry) {
     setDevBuildCliEntry(devCliEntry);
@@ -7387,9 +7866,9 @@ async function main() {
   {
     const reasonPath = path21.join(vaultDir, RESTART_REASON_FILENAME);
     try {
-      if (fs21.existsSync(reasonPath)) {
-        const raw = JSON.parse(fs21.readFileSync(reasonPath, "utf-8"));
-        fs21.unlinkSync(reasonPath);
+      if (fs22.existsSync(reasonPath)) {
+        const raw = JSON.parse(fs22.readFileSync(reasonPath, "utf-8"));
+        fs22.unlinkSync(reasonPath);
         if (raw.reason === "version_sync" && raw.to_version) {
           const message = raw.local_update_ran ? "Restarted and updated local project hooks." : "Restarted to pick up the latest version.";
           notify(vaultDir, {
@@ -7447,7 +7926,7 @@ async function main() {
   const databaseManager = new DatabaseMaintenanceManager(vaultDbPath(vaultDir), vaultDir, logger);
   let definitionsDir;
   try {
-    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-SKKUMT5C.js");
+    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-VPE4RCIF.js");
     definitionsDir = resolveDefinitionsDir2();
     await registerBuiltInAgentsAndTasks(definitionsDir, vaultDir);
     logger.info(LOG_KINDS.AGENT_TASK, "Built-in agents and tasks registered");
@@ -7476,7 +7955,7 @@ async function main() {
     const root = findPackageRoot(path21.dirname(new URL(import.meta.url).pathname));
     if (root) {
       const candidate = path21.join(root, "dist", "ui");
-      if (fs21.existsSync(candidate)) uiDir = candidate;
+      if (fs22.existsSync(candidate)) uiDir = candidate;
     }
   }
   if (uiDir) {
@@ -7520,7 +7999,8 @@ async function main() {
     embeddingManager,
     logger,
     config,
-    vaultDir
+    vaultDir,
+    planTags: symbiontPlanTags
   });
   const sessionLifecycle = createSessionLifecycleHandlers({
     registry,
@@ -7684,6 +8164,14 @@ async function main() {
   server.registerRoute("POST", "/api/team/retry-failed", teamHandlers.handleRetryFailed);
   server.registerRoute("POST", "/api/team/upgrade-worker", teamHandlers.handleUpgradeWorker);
   server.registerRoute("POST", "/api/team/rotate-mcp-token", teamHandlers.handleRotateMcpToken);
+  const collectiveHandlers = createCollectiveHandlers({
+    getTeamClient: teamSync.getTeamClient
+  });
+  server.registerRoute("GET", "/api/collective/status", collectiveHandlers.handleStatus);
+  server.registerRoute("GET", "/api/collective/search", collectiveHandlers.handleSearch);
+  server.registerRoute("GET", "/api/collective/projects", collectiveHandlers.handleProjects);
+  server.registerRoute("GET", "/api/collective/project", collectiveHandlers.handleProject);
+  server.registerRoute("GET", "/api/collective/settings", collectiveHandlers.handleSettings);
   server.registerRoute("GET", "/api/search", createSearchHandler({ embeddingManager, getTeamClient: teamSync.getTeamClient, machineId }));
   server.registerRoute("GET", "/api/activity", handleGetFeed);
   server.registerRoute("GET", "/api/embedding/status", async () => handleGetEmbeddingStatus(vaultDir));
@@ -7756,4 +8244,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-6PY3ITQ5.js.map
+//# sourceMappingURL=main-EIKBLOUL.js.map