@goondocks/myco 0.18.1 → 0.19.0

package/dist/{main-5THODR77.js → main-EIKBLOUL.js}

@@ -15,16 +15,18 @@ import {
   getEmbeddingQueueDepth,
   getUnembedded,
   markEmbedded
-} from "./chunk-LSP5HYOO.js";
+} from "./chunk-OZF5EURR.js";
 import {
   loadSecrets,
+  readJsonConfig,
   readSecrets,
+  resolveHomeConfigPath,
   writeSecret
-} from "./chunk-RJMXDUMA.js";
+} from "./chunk-EM63ZFKA.js";
 import {
   Anthropic,
   createEmbeddingProvider
-} from "./chunk-TCSVDQF5.js";
+} from "./chunk-LLJMDXO2.js";
 import {
   buildTaskInstruction,
   closeOpenBatches,
@@ -72,24 +74,24 @@ import {
   setResponseSummary,
   updateCandidate,
   updateNotificationStatus
-} from "./chunk-C3EGL5JX.js";
+} from "./chunk-RXROZBSK.js";
 import {
   fullTextSearch,
   hydrateSearchResults
-} from "./chunk-TOER6RNC.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-TLK46KKD.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-TZAXQKO6.js";
+} from "./chunk-REN37KYI.js";
 import {
   closeSession,
   countSessions,
@@ -133,7 +135,7 @@ import {
   listSessions,
   updateSession,
   upsertSession
-} from "./chunk-RIDSOQDR.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-CURS2TNP.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-XWOQL4XN.js";
+} from "./chunk-CYBC2HZ3.js";
 import {
   getPluginVersion
-} from "./chunk-W7WENJ6F.js";
+} from "./chunk-2CKDAFSX.js";
 import {
   loadManifests
-} from "./chunk-DPSLJ242.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";
@@ -1749,7 +1752,25 @@ function writeUpdateConfig(config) {
 function readCachedCheck() {
   try {
     const raw = fs9.readFileSync(UPDATE_CHECK_CACHE_PATH, "utf-8");
-    return JSON.parse(raw);
+    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;
   }
@@ -1767,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;
@@ -1776,34 +1800,79 @@ 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 = fs9.readFileSync(pkgPath, "utf-8");
@@ -1813,25 +1882,51 @@ function getInstalledVersion(globalPrefix) {
     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,
@@ -1841,31 +1936,33 @@ 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 {
     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
@@ -1874,14 +1971,14 @@ 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
@@ -1891,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
@@ -2009,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: {
@@ -2038,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);
@@ -2067,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: {
@@ -2444,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
   // ---------------------------------------------------------------------------
@@ -2484,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) {
@@ -2538,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) {
@@ -2555,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,
@@ -2567,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,
@@ -2585,7 +2724,7 @@ function createTeamHandlers(deps) {
     return { body: { retried: count } };
   }
   async function handleUpgradeWorker(_req) {
-    const { upgradeWorker } = await import("./team-DPNP2RN7.js");
+    const { upgradeWorker } = await import("./team-N6TXS2PF.js");
     logger.info("team-sync.upgrade.start", "Starting worker upgrade");
     const result = upgradeWorker(vaultDir);
     if (!result.success) {
@@ -2634,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(),
@@ -3825,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;
@@ -3845,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,
@@ -5922,7 +6171,7 @@ 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) {
@@ -5948,7 +6197,7 @@ async function registerScheduledTasks(powerManager, deps) {
       else runningTasks.delete(name);
     },
     runTask: async (taskName) => {
-      const { runAgent } = await import("./executor-UYIZC3L5.js");
+      const { runAgent } = await import("./executor-ICTRRUBY.js");
       const taskConfig = config.agent.tasks?.[taskName];
       const projectRoot = resolve(vaultDir, "..");
       const built = buildTaskInstruction(taskName, taskConfig?.params, taskAgentMap.get(taskName), projectRoot, embeddingManager);
@@ -6118,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,
@@ -6246,7 +6495,7 @@ function createAgentRunHandlers(deps) {
         };
       }
     }
-    const { runAgent } = await import("./executor-UYIZC3L5.js");
+    const { runAgent } = await import("./executor-ICTRRUBY.js");
     const resultPromise = runAgent(vaultDir, {
       task,
       instruction,
@@ -7069,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-UYIZC3L5.js");
+      const { runAgent } = await import("./executor-ICTRRUBY.js");
       runAgent(vaultDir, {
         task: "title-summary",
         instruction: `Process session ${sessionId} only`,
@@ -7677,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");
@@ -7915,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));
@@ -7987,4 +8244,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-5THODR77.js.map
+//# sourceMappingURL=main-EIKBLOUL.js.map