@goondocks/myco 0.9.0 → 0.10.0

package/dist/{main-BMCL7CPO.js → main-PVX6R3I6.js}

@@ -2,7 +2,7 @@ import { createRequire as __cr } from 'node:module'; const require = __cr(import
 import {
   DaemonLogger,
   LEVEL_ORDER
-} from "./chunk-2T7RPVPP.js";
+} from "./chunk-ZESTWGJT.js";
 import {
   EMBEDDABLE_TABLES,
   EMBEDDABLE_TEXT_COLUMNS,
@@ -12,13 +12,16 @@ import {
   getEmbeddingQueueDepth,
   getUnembedded,
   markEmbedded
-} from "./chunk-QIK2XSDQ.js";
+} from "./chunk-MSXYUXZR.js";
 import {
   withTaskConfig
 } from "./chunk-M5XWW7UI.js";
+import {
+  getMachineId
+} from "./chunk-ENWBFX7F.js";
 import {
   createEmbeddingProvider
-} from "./chunk-JYOOJCPQ.js";
+} from "./chunk-MKKXCCQ5.js";
 import {
   closeOpenBatches,
   countRuns,
@@ -41,45 +44,47 @@ import {
   listTurnsByRun,
   populateBatchResponses,
   setResponseSummary
-} from "./chunk-OXZSXYAT.js";
+} from "./chunk-FFQES5MC.js";
 import {
   fullTextSearch,
   hydrateSearchResults
-} from "./chunk-PT5IC642.js";
+} from "./chunk-W6HI4CCS.js";
 import {
   copyTaskToUser,
   deleteUserTask,
   loadAllTasks,
   validateTaskName,
   writeUserTask
-} from "./chunk-BUSP3OJB.js";
+} from "./chunk-ZMW6KQX2.js";
 import {
   AgentTaskSchema,
   registerAgent,
   resolveDefinitionsDir,
   taskFromParsed
-} from "./chunk-JMJJEQ3P.js";
+} from "./chunk-5LPERML5.js";
 import {
   checkLocalProvider
-} from "./chunk-DCXRSSBP.js";
+} from "./chunk-C3AEZ3BZ.js";
 import {
   EventBuffer,
   cleanStaleBuffers,
   listBufferSessionIds
 } from "./chunk-V7XG6V6C.js";
 import "./chunk-IB76KGBY.js";
-import "./chunk-46PWOKSI.js";
-import "./chunk-RJ6ZQKG5.js";
-import "./chunk-KYLDNM7H.js";
+import "./chunk-AEJS57ZK.js";
+import "./chunk-5QERXFH7.js";
+import "./chunk-FPMEIN2W.js";
 import {
-  loadSecrets
-} from "./chunk-FFAYUQ5N.js";
+  loadSecrets,
+  readSecrets,
+  writeSecret
+} from "./chunk-RJMXDUMA.js";
 import {
   SymbiontRegistry,
   claudeCodeAdapter,
   createPerProjectAdapter,
   extensionForMimeType
-} from "./chunk-KB4DGYIY.js";
+} from "./chunk-WXSJKESH.js";
 import "./chunk-SAKJMNSR.js";
 import {
   loadManifests
@@ -87,14 +92,14 @@ import {
 import {
   LmStudioBackend,
   OllamaBackend
-} from "./chunk-UBZPD4HN.js";
+} from "./chunk-5SDH75YC.js";
 import {
   countSpores,
   getSpore,
   insertSpore,
   listSpores,
   updateSporeStatus
-} from "./chunk-3K5WGSJ4.js";
+} from "./chunk-U7UUJ4FD.js";
 import {
   closeSession,
   countSessions,
@@ -104,17 +109,29 @@ import {
   listSessions,
   updateSession,
   upsertSession
-} from "./chunk-4LPQ26CK.js";
+} from "./chunk-CUDM5YJY.js";
+import {
+  backfillUnsynced,
+  countPending,
+  initTeamContext,
+  listPending,
+  markSent,
+  pruneOld,
+  syncRow
+} from "./chunk-XLY3REL3.js";
 import {
   EMBEDDING_DIMENSIONS,
+  SCHEMA_VERSION,
   createSchema
-} from "./chunk-KV4OC4H3.js";
+} from "./chunk-WZZH3YXJ.js";
 import {
   CONFIG_FILENAME,
   MycoConfigSchema,
   loadConfig,
-  updateConfig
-} from "./chunk-MHSCMET3.js";
+  updateBackupConfig,
+  updateConfig,
+  updateTeamConfig
+} from "./chunk-MAZOVVDU.js";
 import {
   require_dist
 } from "./chunk-D7TYRPRM.js";
@@ -128,13 +145,16 @@ import {
   initDatabase,
   vaultDbPath
 } from "./chunk-MYX5NCRH.js";
-import "./chunk-TRUJLI6K.js";
+import {
+  resolveCliEntryPath
+} from "./chunk-YZMNEIFI.js";
 import {
   CONTENT_HASH_ALGORITHM,
   DAEMON_EVICT_POLL_MS,
   DAEMON_EVICT_TIMEOUT_MS,
   DEAD_SESSION_MAX_PROMPTS,
   DEFAULT_AGENT_ID,
+  DEFAULT_MACHINE_ID,
   EMBEDDING_BATCH_SIZE,
   EXCLUDED_SPORE_STATUSES,
   FEED_DEFAULT_LIMIT,
@@ -157,19 +177,24 @@ import {
   SEARCH_SIMILARITY_THRESHOLD,
   STALE_BUFFER_MAX_AGE_MS,
   STALE_SESSION_THRESHOLD_MS,
+  SYNC_PROTOCOL_VERSION,
+  TEAM_API_KEY_SECRET,
+  TEAM_HEALTH_TIMEOUT_MS,
+  TEAM_SEARCH_TIMEOUT_MS,
+  TEAM_SOURCE_PREFIX,
   USER_AGENT_ID,
   USER_AGENT_NAME,
   USER_TASK_SOURCE,
   epochSeconds,
   estimateTokens
-} from "./chunk-5VZ52A4T.js";
+} from "./chunk-76ZO5RGT.js";
 import {
   LOG_KINDS,
   kindToComponent
-} from "./chunk-WGTCA2NU.js";
+} from "./chunk-S6I62FAH.js";
 import {
   getPluginVersion
-} from "./chunk-PB6TOLRQ.js";
+} from "./chunk-G2LQBFE3.js";
 import {
   findPackageRoot
 } from "./chunk-LPUQPDC2.js";
@@ -633,7 +658,9 @@ var PLAN_COLUMNS = [
   "processed",
   "embedded",
   "created_at",
-  "updated_at"
+  "updated_at",
+  "machine_id",
+  "synced_at"
 ];
 var SELECT_COLUMNS = PLAN_COLUMNS.join(", ");
 function toPlanRow(row) {
@@ -651,7 +678,9 @@ function toPlanRow(row) {
     processed: row.processed,
     embedded: row.embedded ?? 0,
     created_at: row.created_at,
-    updated_at: row.updated_at ?? null
+    updated_at: row.updated_at ?? null,
+    machine_id: row.machine_id ?? DEFAULT_MACHINE_ID,
+    synced_at: row.synced_at ?? null
   };
 }
 function upsertPlan(data) {
@@ -660,11 +689,11 @@ function upsertPlan(data) {
     `INSERT INTO plans (
        id, status, author, title, content,
        source_path, tags, session_id, prompt_batch_id, content_hash,
-       processed, created_at, updated_at
+       processed, created_at, updated_at, machine_id
      ) VALUES (
        ?, ?, ?, ?, ?,
        ?, ?, ?, ?, ?,
-       ?, ?, ?
+       ?, ?, ?, ?
      )
      ON CONFLICT (id) DO UPDATE SET
        status          = EXCLUDED.status,
@@ -695,11 +724,14 @@ function upsertPlan(data) {
     data.content_hash ?? null,
     data.processed ?? DEFAULT_PROCESSED,
     data.created_at,
-    data.updated_at ?? null
+    data.updated_at ?? null,
+    data.machine_id ?? DEFAULT_MACHINE_ID
   );
-  return toPlanRow(
+  const row = toPlanRow(
     db.prepare(`SELECT ${SELECT_COLUMNS} FROM plans WHERE id = ?`).get(data.id)
   );
+  syncRow("plans", row);
+  return row;
 }
 function listPlans(options = {}) {
   const db = getDatabase();
@@ -787,7 +819,9 @@ function mergeConfigSections(current, incoming) {
     embedding: { ...current.embedding, ...incoming.embedding },
     capture: { ...current.capture, ...incoming.capture },
     agent: { ...current.agent, ...incoming.agent },
-    context: { ...current.context, ...incoming.context }
+    context: { ...current.context, ...incoming.context },
+    backup: { ...current.backup, ...incoming.backup },
+    team: { ...current.team, ...incoming.team }
   };
 }
 async function handleGetConfig(vaultDir) {
@@ -1025,8 +1059,8 @@ async function handleRestart(deps, body) {
       body: { status: "busy", message: "Active operations in progress. Use force=true to override." }
     };
   }
-  const mycoCmd = process.env.MYCO_CMD || "myco";
-  const shellCmd = `sleep ${RESTART_CHILD_DELAY_SECONDS} && ${mycoCmd} daemon --vault ${deps.vaultDir}`;
+  const { execPath, cliEntry } = resolveCliEntryPath();
+  const shellCmd = `sleep ${RESTART_CHILD_DELAY_SECONDS} && ${execPath} ${cliEntry} daemon --vault ${deps.vaultDir}`;
   const child = spawn("/bin/sh", ["-c", shellCmd], {
     detached: true,
     stdio: "ignore"
@@ -1038,6 +1072,431 @@ async function handleRestart(deps, body) {
   return { body: { status: "restarting" } };
 }
 
+// src/daemon/backup.ts
+import fs3 from "fs";
+import path4 from "path";
+var BACKUP_TABLES = [
+  "sessions",
+  "prompt_batches",
+  "spores",
+  "entities",
+  "graph_edges",
+  "entity_mentions",
+  "resolution_events",
+  "plans",
+  "artifacts",
+  "digest_extracts",
+  "team_members"
+];
+var BACKUP_EXTENSION = ".sql";
+var BACKUP_HEADER_TEMPLATE = "-- Myco backup";
+function escapeSql(value) {
+  return value.replace(/'/g, "''");
+}
+function toSqlLiteral(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (typeof value === "number") return String(value);
+  if (Buffer.isBuffer(value)) return `X'${value.toString("hex")}'`;
+  return `'${escapeSql(String(value))}'`;
+}
+function createBackup(db, backupDir, machineId) {
+  fs3.mkdirSync(backupDir, { recursive: true });
+  const lines = [];
+  const timestamp = epochSeconds();
+  lines.push(`${BACKUP_HEADER_TEMPLATE}: machine_id=${machineId}, created_at=${timestamp}`);
+  lines.push(`-- Protocol version: ${SYNC_PROTOCOL_VERSION}`);
+  lines.push("");
+  for (const table of BACKUP_TABLES) {
+    const rows = db.prepare(`SELECT * FROM ${table}`).all();
+    if (rows.length === 0) continue;
+    lines.push(`-- Table: ${table} (${rows.length} rows)`);
+    const columns = Object.keys(rows[0]);
+    const columnList = columns.map((c) => `"${c}"`).join(", ");
+    for (const row of rows) {
+      const values = columns.map((c) => toSqlLiteral(row[c])).join(", ");
+      lines.push(`INSERT OR IGNORE INTO ${table} (${columnList}) VALUES (${values});`);
+    }
+    lines.push("");
+  }
+  const filePath = path4.join(backupDir, `${machineId}${BACKUP_EXTENSION}`);
+  fs3.writeFileSync(filePath, lines.join("\n"), "utf-8");
+  return filePath;
+}
+function listBackups(backupDir) {
+  let entries;
+  try {
+    entries = fs3.readdirSync(backupDir);
+  } catch {
+    return [];
+  }
+  const backups = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(BACKUP_EXTENSION)) continue;
+    const filePath = path4.join(backupDir, entry);
+    const stat = fs3.statSync(filePath);
+    backups.push({
+      machine_id: entry.slice(0, -BACKUP_EXTENSION.length),
+      file_name: entry,
+      size_bytes: stat.size,
+      modified_at: stat.mtime.toISOString()
+    });
+  }
+  return backups.sort((a, b) => b.modified_at.localeCompare(a.modified_at));
+}
+var INSERT_REGEX = /^INSERT OR IGNORE INTO (\w+)\s+\(([^)]+)\)\s+VALUES\s+\((.+)\);$/;
+function parseBackupFile(backupPath) {
+  const content = fs3.readFileSync(backupPath, "utf-8");
+  const inserts = [];
+  for (const line of content.split("\n")) {
+    const match = INSERT_REGEX.exec(line);
+    if (!match) continue;
+    inserts.push({
+      table: match[1],
+      columns: match[2].split(",").map((c) => c.trim().replace(/"/g, "")),
+      valueSql: match[3]
+    });
+  }
+  return inserts;
+}
+function restorePreview(db, backupPath) {
+  const inserts = parseBackupFile(backupPath);
+  const counts = /* @__PURE__ */ new Map();
+  db.pragma("foreign_keys = OFF");
+  db.exec("SAVEPOINT restore_preview");
+  try {
+    for (const insert of inserts) {
+      if (!counts.has(insert.table)) {
+        counts.set(insert.table, { new: 0, existing: 0 });
+      }
+      const tableCounts = counts.get(insert.table);
+      try {
+        const columnList = insert.columns.map((c) => `"${c}"`).join(", ");
+        const stmt = `INSERT OR IGNORE INTO ${insert.table} (${columnList}) VALUES (${insert.valueSql})`;
+        const result = db.prepare(stmt).run();
+        if (result.changes > 0) {
+          tableCounts.new++;
+        } else {
+          tableCounts.existing++;
+        }
+      } catch {
+        tableCounts.existing++;
+      }
+    }
+  } finally {
+    db.exec("ROLLBACK TO restore_preview");
+    db.exec("RELEASE restore_preview");
+    db.pragma("foreign_keys = ON");
+  }
+  return Array.from(counts.entries()).map(([table, c]) => ({
+    table,
+    new: c.new,
+    existing: c.existing
+  }));
+}
+function restoreBackup(db, backupPath) {
+  const inserts = parseBackupFile(backupPath);
+  const counts = /* @__PURE__ */ new Map();
+  db.pragma("foreign_keys = OFF");
+  try {
+    const runRestore = db.transaction(() => {
+      for (const insert of inserts) {
+        if (!counts.has(insert.table)) {
+          counts.set(insert.table, { new: 0, existing: 0 });
+        }
+        const tableCounts = counts.get(insert.table);
+        const columnList = insert.columns.map((c) => `"${c}"`).join(", ");
+        const stmt = `INSERT OR IGNORE INTO ${insert.table} (${columnList}) VALUES (${insert.valueSql})`;
+        const result = db.prepare(stmt).run();
+        if (result.changes > 0) {
+          tableCounts.new++;
+        } else {
+          tableCounts.existing++;
+        }
+      }
+    });
+    runRestore();
+  } finally {
+    db.pragma("foreign_keys = ON");
+  }
+  const tables = Array.from(counts.entries()).map(([table, c]) => ({
+    table,
+    new: c.new,
+    existing: c.existing
+  }));
+  const total_restored = tables.reduce((sum, t) => sum + t.new, 0);
+  const total_skipped = tables.reduce((sum, t) => sum + t.existing, 0);
+  return { tables, total_restored, total_skipped };
+}
+
+// src/daemon/api/backup.ts
+function createBackupHandlers(deps) {
+  async function handleCreateBackup(_req) {
+    const filePath = createBackup(deps.db, deps.backupDir, deps.machineId);
+    const backups = listBackups(deps.backupDir);
+    const created = backups.find((b) => b.machine_id === deps.machineId);
+    return {
+      body: {
+        file_path: filePath,
+        machine_id: deps.machineId,
+        size_bytes: created?.size_bytes ?? 0
+      }
+    };
+  }
+  async function handleListBackups(_req) {
+    const backups = listBackups(deps.backupDir);
+    return { body: { backups } };
+  }
+  async function handleRestorePreview(req) {
+    const { machine_id } = req.body;
+    if (!machine_id) {
+      return { status: 400, body: { error: "missing_machine_id" } };
+    }
+    const backups = listBackups(deps.backupDir);
+    const backup = backups.find((b) => b.machine_id === machine_id);
+    if (!backup) {
+      return { status: 404, body: { error: "backup_not_found" } };
+    }
+    const backupPath = `${deps.backupDir}/${backup.file_name}`;
+    const tables = restorePreview(deps.db, backupPath);
+    const total_new = tables.reduce((sum, t) => sum + t.new, 0);
+    const total_existing = tables.reduce((sum, t) => sum + t.existing, 0);
+    return { body: { machine_id, tables, total_new, total_existing } };
+  }
+  async function handleRestore(req) {
+    const { machine_id } = req.body;
+    if (!machine_id) {
+      return { status: 400, body: { error: "missing_machine_id" } };
+    }
+    const backups = listBackups(deps.backupDir);
+    const backup = backups.find((b) => b.machine_id === machine_id);
+    if (!backup) {
+      return { status: 404, body: { error: "backup_not_found" } };
+    }
+    const backupPath = `${deps.backupDir}/${backup.file_name}`;
+    const result = restoreBackup(deps.db, backupPath);
+    return { body: { machine_id, ...result } };
+  }
+  return {
+    handleCreateBackup,
+    handleListBackups,
+    handleRestorePreview,
+    handleRestore
+  };
+}
+
+// src/daemon/team-sync.ts
+var TeamSyncClient = class {
+  workerUrl;
+  apiKey;
+  machineId;
+  syncProtocolVersion;
+  fetchFn;
+  constructor(options) {
+    this.workerUrl = options.workerUrl.replace(/\/+$/, "");
+    this.apiKey = options.apiKey;
+    this.machineId = options.machineId;
+    this.syncProtocolVersion = options.syncProtocolVersion;
+    this.fetchFn = options.fetch ?? globalThis.fetch;
+  }
+  /**
+   * Register this machine with the team worker.
+   */
+  async connect(info) {
+    const res = await this.request("POST", "/connect", {
+      ...info,
+      machine_id: this.machineId,
+      sync_protocol_version: this.syncProtocolVersion
+    });
+    return res;
+  }
+  /**
+   * Push a batch of outbox records to the team worker.
+   *
+   * @returns the number of records accepted by the worker.
+   */
+  async pushBatch(records) {
+    const res = await this.request("POST", "/sync", {
+      machine_id: this.machineId,
+      sync_protocol_version: this.syncProtocolVersion,
+      records: records.map((r) => {
+        const data = typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload;
+        return {
+          table: r.table_name,
+          id: String(r.row_id),
+          machine_id: r.machine_id,
+          operation: r.operation,
+          data,
+          content_hash: data.content_hash ?? null
+        };
+      })
+    });
+    return res;
+  }
+  /**
+   * Search team knowledge across all connected machines.
+   *
+   * Uses AbortController for timeout enforcement.
+   */
+  async search(query, options = {}) {
+    const timeoutMs = options.timeoutMs ?? TEAM_SEARCH_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const params = new URLSearchParams({ q: query });
+      if (options.limit) params.set("limit", String(options.limit));
+      if (options.tables) params.set("tables", options.tables.join(","));
+      const res = await this.fetchFn(`${this.workerUrl}/search?${params}`, {
+        method: "GET",
+        headers: this.headers(),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        throw new Error(`Team search failed: ${res.status} ${res.statusText}`);
+      }
+      return await res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Check worker health.
+   */
+  async health() {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TEAM_HEALTH_TIMEOUT_MS);
+    try {
+      const res = await this.fetchFn(`${this.workerUrl}/health`, {
+        method: "GET",
+        headers: this.headers(),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        throw new Error(`Health check failed: ${res.status} ${res.statusText}`);
+      }
+      return await res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Get team configuration from the worker.
+   */
+  async getConfig() {
+    const res = await this.request("GET", "/config");
+    return res;
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  headers() {
+    return {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async request(method, path8, body) {
+    const res = await this.fetchFn(`${this.workerUrl}${path8}`, {
+      method,
+      headers: this.headers(),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Team sync request ${method} ${path8} failed: ${res.status} ${text}`);
+    }
+    return res.json();
+  }
+};
+
+// src/daemon/api/team-connect.ts
+function createTeamHandlers(deps) {
+  const { vaultDir, machineId } = deps;
+  async function handleConnect(req) {
+    const { url, api_key } = req.body;
+    if (!url || !api_key) {
+      return {
+        status: 400,
+        body: { error: "missing_fields", message: "Both url and api_key are required" }
+      };
+    }
+    try {
+      new URL(url);
+    } catch {
+      return {
+        status: 400,
+        body: { error: "invalid_url", message: "Invalid worker URL" }
+      };
+    }
+    const client = new TeamSyncClient({
+      workerUrl: url,
+      apiKey: api_key,
+      machineId,
+      syncProtocolVersion: SYNC_PROTOCOL_VERSION
+    });
+    try {
+      await client.health();
+    } catch (err) {
+      return {
+        status: 502,
+        body: {
+          error: "connection_failed",
+          message: `Could not connect to team worker: ${err.message}`
+        }
+      };
+    }
+    updateTeamConfig(vaultDir, {
+      enabled: true,
+      worker_url: url
+    });
+    writeSecret(vaultDir, TEAM_API_KEY_SECRET, api_key);
+    deps.setTeamClient(client);
+    const config = loadConfig(vaultDir);
+    return { body: { connected: true, team: config.team } };
+  }
+  async function handleDisconnect(_req) {
+    updateTeamConfig(vaultDir, { enabled: false });
+    deps.setTeamClient(null);
+    return { body: { connected: false } };
+  }
+  async function handleStatus(_req) {
+    const config = loadConfig(vaultDir);
+    const client = deps.getTeamClient();
+    const secrets = readSecrets(vaultDir);
+    const hasApiKey = Boolean(secrets[TEAM_API_KEY_SECRET]);
+    let healthy = false;
+    let healthError;
+    if (client && config.team.enabled) {
+      try {
+        await client.health();
+        healthy = true;
+      } catch (err) {
+        healthError = err.message;
+      }
+    }
+    let pendingCount = 0;
+    try {
+      pendingCount = countPending();
+    } catch {
+    }
+    return {
+      body: {
+        enabled: config.team.enabled,
+        worker_url: config.team.worker_url ?? null,
+        has_api_key: hasApiKey,
+        api_key: secrets[TEAM_API_KEY_SECRET] ?? null,
+        healthy,
+        health_error: healthError,
+        pending_sync_count: pendingCount,
+        machine_id: machineId,
+        package_version: getPluginVersion(),
+        schema_version: SCHEMA_VERSION,
+        sync_protocol_version: SYNC_PROTOCOL_VERSION
+      }
+    };
+  }
+  return { handleConnect, handleDisconnect, handleStatus };
+}
+
 // src/daemon/api/progress.ts
 import { randomUUID } from "crypto";
 var MAX_CONCURRENT_OPERATIONS = 10;
@@ -1179,12 +1638,12 @@ async function handleGetModels(req) {
 
 // src/daemon/api/stats.ts
 import { createHash as createHash3 } from "crypto";
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 function computeConfigHash(vaultDir) {
   try {
-    const configPath = path4.join(vaultDir, CONFIG_FILENAME);
-    const raw = fs3.readFileSync(configPath, "utf-8");
+    const configPath = path5.join(vaultDir, CONFIG_FILENAME);
+    const raw = fs4.readFileSync(configPath, "utf-8");
     return createHash3("md5").update(raw).digest("hex");
   } catch {
     return "";
@@ -1574,6 +2033,86 @@ async function handleGetGraph(req) {
     }
   };
 }
+var FULL_GRAPH_NODE_LIMIT = 500;
+async function handleGetFullGraph(_req) {
+  const db = getDatabase();
+  const entityRows = db.prepare(
+    `SELECT id, type, name, properties, status, first_seen as created_at
+     FROM entities WHERE agent_id = ? LIMIT ?`
+  ).all(DEFAULT_AGENT_ID, FULL_GRAPH_NODE_LIMIT);
+  const sporeRows = db.prepare(
+    `SELECT id, observation_type, status, content, properties, created_at
+     FROM spores WHERE agent_id = ? AND status = 'active' LIMIT ?`
+  ).all(DEFAULT_AGENT_ID, FULL_GRAPH_NODE_LIMIT);
+  const sessionRows = db.prepare(
+    `SELECT id, title, summary, status, started_at as created_at
+     FROM sessions ORDER BY created_at DESC LIMIT ?`
+  ).all(FULL_GRAPH_NODE_LIMIT);
+  const allIds = /* @__PURE__ */ new Set();
+  for (const r of [...entityRows, ...sporeRows, ...sessionRows]) {
+    allIds.add(r.id);
+  }
+  const excludedTypes = Array.from(EXCLUDED_GRAPH_EDGE_TYPES).map(() => "?").join(", ");
+  const allIdsList = Array.from(allIds);
+  const idPlaceholders = allIdsList.map(() => "?").join(", ");
+  const edgeRows = db.prepare(
+    `SELECT source_id, source_type, target_id, target_type, type, confidence
+     FROM graph_edges
+     WHERE agent_id = ?
+       AND type NOT IN (${excludedTypes})
+       AND source_id IN (${idPlaceholders})
+       AND target_id IN (${idPlaceholders})`
+  ).all(DEFAULT_AGENT_ID, ...Array.from(EXCLUDED_GRAPH_EDGE_TYPES), ...allIdsList, ...allIdsList);
+  const filteredEdges = edgeRows;
+  const mentionCounts = /* @__PURE__ */ new Map();
+  const entityIdArray = entityRows.map((r) => r.id);
+  if (entityIdArray.length > 0) {
+    const placeholders = entityIdArray.map(() => "?").join(", ");
+    const mentionRows = db.prepare(
+      `SELECT entity_id, COUNT(*) as count FROM entity_mentions
+       WHERE entity_id IN (${placeholders}) GROUP BY entity_id`
+    ).all(...entityIdArray);
+    for (const row of mentionRows) {
+      mentionCounts.set(row.entity_id, Number(row.count));
+    }
+  }
+  const nodes = [
+    ...entityRows.map((n) => ({
+      id: n.id,
+      name: n.name,
+      type: n.type,
+      status: n.status ?? void 0,
+      created_at: n.created_at,
+      properties: n.properties ?? void 0,
+      mention_count: mentionCounts.get(n.id) ?? 0
+    })),
+    ...sporeRows.map((n) => ({
+      id: n.id,
+      name: (n.content ?? "").slice(0, SPORE_NAME_PREVIEW_CHARS),
+      type: "spore",
+      status: n.status ?? void 0,
+      created_at: n.created_at,
+      content: n.content,
+      properties: n.properties ?? void 0,
+      observation_type: n.observation_type
+    })),
+    ...sessionRows.map((n) => ({
+      id: n.id,
+      name: n.title ?? `Session ${n.id.slice(-6)}`,
+      type: "session",
+      status: n.status ?? void 0,
+      created_at: n.created_at,
+      content: n.summary ?? void 0
+    }))
+  ];
+  const edges = filteredEdges.map((e) => ({
+    source_id: e.source_id,
+    target_id: e.target_id,
+    label: e.type,
+    weight: e.confidence
+  }));
+  return { body: { nodes, edges } };
+}
 async function handleGetDigest(req) {
   const agentId = req.query.agent_id ?? DEFAULT_AGENT_ID;
   const extracts = listDigestExtracts(agentId);
@@ -1590,14 +2129,14 @@ function createSearchHandler(deps) {
     const limit = Number(req.query.limit) || SEARCH_RESULTS_DEFAULT_LIMIT;
     const namespace = req.query.namespace;
     if (mode === "fts") {
-      const results2 = fullTextSearch(query, { type, limit });
-      return { body: { mode: "fts", results: results2 } };
+      const results = fullTextSearch(query, { type, limit });
+      return { body: { mode: "fts", results } };
     }
     const queryVector = await deps.embeddingManager.embedQuery(query);
     if (queryVector === null) {
       if (mode === "auto") {
-        const results2 = fullTextSearch(query, { type, limit });
-        return { body: { mode: "fts", results: results2, fallback: true } };
+        const results = fullTextSearch(query, { type, limit });
+        return { body: { mode: "fts", results, fallback: true } };
       }
       return { body: { mode: "semantic", results: [], provider_unavailable: true } };
     }
@@ -1607,8 +2146,25 @@ function createSearchHandler(deps) {
       limit,
       threshold: SEARCH_SIMILARITY_THRESHOLD
     });
-    const results = hydrateSearchResults(vectorResults);
-    return { body: { mode: "semantic", results } };
+    const localResults = hydrateSearchResults(vectorResults).map((r) => ({
+      ...r,
+      source: "local"
+    }));
+    const teamClient = deps.getTeamClient?.();
+    let teamResults = [];
+    if (teamClient) {
+      try {
+        const teamResponse = await teamClient.search(query, { limit });
+        teamResults = teamResponse.results.map((r) => ({
+          ...r,
+          source: `${TEAM_SOURCE_PREFIX}${r.machine_id}`
+        }));
+      } catch {
+      }
+    }
+    const dedupedTeam = deps.machineId ? teamResults.filter((r) => r.machine_id !== deps.machineId) : teamResults;
+    const merged = [...localResults, ...dedupedTeam].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, limit);
+    return { body: { mode: "semantic", results: merged } };
   };
 }
 
@@ -2903,19 +3459,19 @@ function testCloud() {
 }
 
 // src/daemon/log-reconcile.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs5 from "fs";
+import path6 from "path";
 function reconcileLogBuffer(logDir, sinceTimestamp) {
   let replayed = 0;
   const files = [];
   for (let i = 3; i >= 1; i--) {
-    const rotated = path5.join(logDir, `daemon.${i}.log`);
-    if (fs4.existsSync(rotated)) files.push(rotated);
+    const rotated = path6.join(logDir, `daemon.${i}.log`);
+    if (fs5.existsSync(rotated)) files.push(rotated);
   }
-  const current = path5.join(logDir, "daemon.log");
-  if (fs4.existsSync(current)) files.push(current);
+  const current = path6.join(logDir, "daemon.log");
+  if (fs5.existsSync(current)) files.push(current);
   for (const file of files) {
-    const content = fs4.readFileSync(file, "utf-8");
+    const content = fs5.readFileSync(file, "utf-8");
     for (const line of content.split("\n")) {
       if (!line.trim()) continue;
       try {
@@ -3131,8 +3687,8 @@ async function runSessionMaintenance(deps) {
 }
 
 // src/daemon/main.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 var AGENT_RUNS_DEFAULT_LIMIT = 50;
 var TOOL_INPUT_STORE_LIMIT = 4e3;
 var TOOL_OUTPUT_STORE_LIMIT = 2e3;
@@ -3258,10 +3814,10 @@ function handleCompact(sessionId, phase, trigger, compactSummary) {
   });
 }
 function killStaleDaemon(vaultDir, logger) {
-  const daemonJsonPath = path6.join(vaultDir, "daemon.json");
+  const daemonJsonPath = path7.join(vaultDir, "daemon.json");
   try {
-    if (!fs5.existsSync(daemonJsonPath)) return;
-    const info = JSON.parse(fs5.readFileSync(daemonJsonPath, "utf-8"));
+    if (!fs6.existsSync(daemonJsonPath)) return;
+    const info = JSON.parse(fs6.readFileSync(daemonJsonPath, "utf-8"));
     if (!info.pid) return;
     if (info.pid === process.pid) return;
     try {
@@ -3270,7 +3826,7 @@ function killStaleDaemon(vaultDir, logger) {
       logger.info(LOG_KINDS.DAEMON_START, "Killed stale daemon", { pid: info.pid });
     } catch {
     }
-    fs5.unlinkSync(daemonJsonPath);
+    fs6.unlinkSync(daemonJsonPath);
   } catch {
   }
 }
@@ -3280,7 +3836,7 @@ async function main() {
     process.stderr.write("Usage: mycod --vault <path>\n");
     process.exit(1);
   }
-  const vaultDir = path6.resolve(vaultArg);
+  const vaultDir = path7.resolve(vaultArg);
   loadSecrets(vaultDir);
   const config = loadConfig(vaultDir);
   const manifests = loadManifests();
@@ -3291,7 +3847,7 @@ async function main() {
     projectRoot,
     extensions: config.capture.artifact_extensions
   };
-  const logger = new DaemonLogger(path6.join(vaultDir, "logs"), {
+  const logger = new DaemonLogger(path7.join(vaultDir, "logs"), {
     level: config.daemon.log_level
   });
   killStaleDaemon(vaultDir, logger);
@@ -3300,9 +3856,12 @@ async function main() {
     embedding_provider: config.embedding.provider
   });
   logger.info(LOG_KINDS.CAPTURE_PLAN, "Plan watch directories", { dirs: planWatchConfig.watchDirs });
+  const machineId = getMachineId(vaultDir);
+  logger.info(LOG_KINDS.DAEMON_START, "Machine ID resolved", { machine_id: machineId });
   const db = initDatabase(vaultDbPath(vaultDir));
-  createSchema(db);
+  createSchema(db, machineId);
   logger.info(LOG_KINDS.DAEMON_START, "SQLite initialized", { vault: vaultDir });
+  initTeamContext(config.team.enabled, machineId);
   logger.setPersistFn((entry) => {
     const { timestamp, level, kind, component, message, ...rest } = entry;
     insertLogEntry({
@@ -3317,13 +3876,13 @@ async function main() {
   });
   const lastLogTimestamp = getMaxTimestamp();
   if (lastLogTimestamp) {
-    const logDir = path6.join(vaultDir, "logs");
+    const logDir = path7.join(vaultDir, "logs");
     const replayedCount = reconcileLogBuffer(logDir, lastLogTimestamp);
     if (replayedCount > 0) {
       logger.info(LOG_KINDS.DAEMON_RECONCILE, `Replayed ${replayedCount} log entries from buffer`, { replayed: replayedCount });
     }
   }
-  const vectorsDbPath = path6.join(vaultDir, "vectors.db");
+  const vectorsDbPath = path7.join(vaultDir, "vectors.db");
   const vectorStore = new SqliteVecVectorStore(vectorsDbPath);
   const llmProvider = createEmbeddingProvider(config.embedding);
   const embeddingProvider = new EmbeddingProviderAdapter(llmProvider, config.embedding);
@@ -3331,7 +3890,7 @@ async function main() {
   const embeddingManager = new EmbeddingManager(vectorStore, embeddingProvider, recordSource, logger);
   logger.info(LOG_KINDS.EMBEDDING_EMBED, "EmbeddingManager initialized", { vectors_db: vectorsDbPath });
   try {
-    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-SH67XD54.js");
+    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-GKXR5ONU.js");
     const definitionsDir = resolveDefinitionsDir2();
     await registerBuiltInAgentsAndTasks(definitionsDir, vaultDir);
     logger.info(LOG_KINDS.AGENT_TASK, "Built-in agents and tasks registered");
@@ -3357,10 +3916,10 @@ async function main() {
   }
   let uiDir = null;
   {
-    const root = findPackageRoot(path6.dirname(new URL(import.meta.url).pathname));
+    const root = findPackageRoot(path7.dirname(new URL(import.meta.url).pathname));
     if (root) {
-      const candidate = path6.join(root, "dist", "ui");
-      if (fs5.existsSync(candidate)) uiDir = candidate;
+      const candidate = path7.join(root, "dist", "ui");
+      if (fs6.existsSync(candidate)) uiDir = candidate;
     }
   }
   if (uiDir) {
@@ -3397,7 +3956,7 @@ async function main() {
     const running = getRunningRun(DEFAULT_AGENT_ID);
     if (running) return;
     try {
-      const { runAgent } = await import("./executor-ONSDHPGX.js");
+      const { runAgent } = await import("./executor-A5C5KDLP.js");
       runAgent(vaultDir, {
         task: "title-summary",
         instruction: `Process session ${sessionId} only`,
@@ -3406,7 +3965,7 @@ async function main() {
     } catch {
     }
   }
-  const bufferDir = path6.join(vaultDir, "buffer");
+  const bufferDir = path7.join(vaultDir, "buffer");
   const sessionBuffers = /* @__PURE__ */ new Map();
   const startupCleanedCount = cleanStaleBuffers(bufferDir, STALE_BUFFER_MAX_AGE_MS);
   if (startupCleanedCount > 0) {
@@ -3450,9 +4009,9 @@ async function main() {
   function reconcileSession(sessionId) {
     if (reconciledSessions.has(sessionId)) return;
     reconciledSessions.add(sessionId);
-    const bufferPath = path6.join(bufferDir, `${sessionId}.jsonl`);
-    if (!fs5.existsSync(bufferPath)) return;
-    const content = fs5.readFileSync(bufferPath, "utf-8").trim();
+    const bufferPath = path7.join(bufferDir, `${sessionId}.jsonl`);
+    if (!fs6.existsSync(bufferPath)) return;
+    const content = fs6.readFileSync(bufferPath, "utf-8").trim();
     if (!content) return;
     if (!getSession(sessionId)) {
       logger.debug(LOG_KINDS.LIFECYCLE_RECONCILE, "Skipping reconciliation for deleted session", { session_id: sessionId });
@@ -3606,10 +4165,10 @@ async function main() {
       );
       if (planFilePath) {
         const captureSessionId = event.session_id;
-        fs5.promises.readFile(planFilePath, "utf-8").then((planContent) => {
+        fs6.promises.readFile(planFilePath, "utf-8").then((planContent) => {
           const latestBatch = getLatestBatch(captureSessionId);
           capturePlan({
-            sourcePath: path6.relative(projectRoot, planFilePath),
+            sourcePath: path7.relative(projectRoot, planFilePath),
             content: planContent,
             sessionId: captureSessionId,
             promptBatchId: latestBatch?.id ?? null
@@ -4024,6 +4583,7 @@ async function main() {
   server.registerRoute("GET", "/api/spores", handleListSpores);
   server.registerRoute("GET", "/api/spores/:id", handleGetSpore);
   server.registerRoute("GET", "/api/entities", handleListEntities);
+  server.registerRoute("GET", "/api/graph", handleGetFullGraph);
   server.registerRoute("GET", "/api/graph/:id", handleGetGraph);
   server.registerRoute("GET", "/api/digest", handleGetDigest);
   const ATTACHMENT_MEDIA_TYPES = {
@@ -4043,14 +4603,14 @@ async function main() {
       const contentType2 = att.media_type ?? "application/octet-stream";
       return { status: 200, headers: { "Content-Type": contentType2 }, body: att.data };
     }
-    const filePath = path6.join(vaultDir, "attachments", filename);
+    const filePath = path7.join(vaultDir, "attachments", filename);
     let diskData;
     try {
-      diskData = fs5.readFileSync(filePath);
+      diskData = fs6.readFileSync(filePath);
     } catch {
       return { status: 404, body: { error: "not_found" } };
     }
-    const ext = path6.extname(filename).slice(1).toLowerCase();
+    const ext = path7.extname(filename).slice(1).toLowerCase();
     const contentType = ATTACHMENT_MEDIA_TYPES[ext] ?? "application/octet-stream";
     return { status: 200, headers: { "Content-Type": contentType }, body: diskData };
   });
@@ -4061,7 +4621,7 @@ async function main() {
   });
   server.registerRoute("POST", "/api/agent/run", async (req) => {
     const { task, instruction, agentId } = AgentRunBody.parse(req.body);
-    const { runAgent } = await import("./executor-ONSDHPGX.js");
+    const { runAgent } = await import("./executor-A5C5KDLP.js");
     const resultPromise = runAgent(vaultDir, { task, instruction, agentId, embeddingManager });
     const effectiveAgentId = agentId ?? "myco-agent";
     const latestRun = getRunningRun(effectiveAgentId);
@@ -4242,7 +4802,7 @@ async function main() {
       name: USER_AGENT_NAME,
       created_at: now
     });
-    const { insertResolutionEvent } = await import("./resolution-events-TFEQPVKS.js");
+    const { insertResolutionEvent } = await import("./resolution-events-UPHJJLDQ.js");
     const resolutionId = `res-${randomBytes(RESOLUTION_ID_RANDOM_BYTES).toString("hex")}`;
     insertResolutionEvent({
       id: resolutionId,
@@ -4261,7 +4821,69 @@ async function main() {
       }
     };
   });
-  server.registerRoute("GET", "/api/search", createSearchHandler({ embeddingManager }));
+  const backupDir = config.backup.dir ? path7.resolve(config.backup.dir) : path7.resolve(vaultDir, "backups");
+  const backupHandlers = createBackupHandlers({ db, backupDir, machineId });
+  server.registerRoute("POST", "/api/backup", backupHandlers.handleCreateBackup);
+  server.registerRoute("GET", "/api/backups", backupHandlers.handleListBackups);
+  server.registerRoute("POST", "/api/restore/preview", backupHandlers.handleRestorePreview);
+  server.registerRoute("POST", "/api/restore", backupHandlers.handleRestore);
+  server.registerRoute("GET", "/api/backup/config", async () => {
+    const cfg = loadConfig(vaultDir);
+    return { body: { dir: cfg.backup.dir ?? null, default_dir: path7.resolve(vaultDir, "backups") } };
+  });
+  server.registerRoute("PUT", "/api/backup/config", async (req) => {
+    const { dir } = req.body;
+    updateBackupConfig(vaultDir, { dir: dir || void 0 });
+    return { body: { dir: dir || null } };
+  });
+  let teamClient = null;
+  if (config.team.enabled && config.team.worker_url) {
+    const secrets = readSecrets(vaultDir);
+    const teamApiKey = secrets["MYCO_TEAM_API_KEY"];
+    if (teamApiKey) {
+      teamClient = new TeamSyncClient({
+        workerUrl: config.team.worker_url,
+        apiKey: teamApiKey,
+        machineId,
+        syncProtocolVersion: SYNC_PROTOCOL_VERSION
+      });
+      logger.info(LOG_KINDS.TEAM_SYNC_START, "Team sync client initialized", { worker_url: config.team.worker_url });
+      teamClient.connect({
+        machine_id: machineId,
+        version: server.version
+      }).then(() => {
+        logger.info(LOG_KINDS.TEAM_SYNC_START, "Node registered with team worker");
+      }).catch((err) => {
+        logger.warn(LOG_KINDS.TEAM_SYNC_ERROR, "Node registration failed (will retry on next flush)", { error: err.message });
+      });
+      setTimeout(() => {
+        try {
+          const backfilled = backfillUnsynced(machineId);
+          if (backfilled > 0) {
+            logger.info(LOG_KINDS.TEAM_SYNC_START, `Backfilled ${backfilled} unsynced records into outbox`);
+          }
+        } catch (err) {
+          logger.error(LOG_KINDS.TEAM_SYNC_ERROR, "Backfill failed", { error: err.message });
+        }
+      }, 0);
+    }
+  }
+  const teamHandlers = createTeamHandlers({
+    vaultDir,
+    machineId,
+    getTeamClient: () => teamClient,
+    setTeamClient: (c) => {
+      teamClient = c;
+    }
+  });
+  server.registerRoute("POST", "/api/team/connect", teamHandlers.handleConnect);
+  server.registerRoute("POST", "/api/team/disconnect", teamHandlers.handleDisconnect);
+  server.registerRoute("GET", "/api/team/status", teamHandlers.handleStatus);
+  server.registerRoute("POST", "/api/team/backfill", async () => {
+    const count = backfillUnsynced(machineId);
+    return { body: { enqueued: count } };
+  });
+  server.registerRoute("GET", "/api/search", createSearchHandler({ embeddingManager, getTeamClient: () => teamClient, machineId }));
   server.registerRoute("GET", "/api/activity", handleGetFeed);
   server.registerRoute("GET", "/api/embedding/status", async () => handleGetEmbeddingStatus(vaultDir));
   server.registerRoute("GET", "/api/embedding/details", async () => handleEmbeddingDetails(embeddingManager));
@@ -4335,7 +4957,7 @@ async function main() {
         lastAgentRun = Date.now();
         try {
           logger.info(LOG_KINDS.AGENT_AUTO_RUN, "Unprocessed batches found, starting agent", { count });
-          const { runAgent } = await import("./executor-ONSDHPGX.js");
+          const { runAgent } = await import("./executor-A5C5KDLP.js");
           const runResult = await runAgent(vaultDir, { embeddingManager });
           logger.info(LOG_KINDS.AGENT_RUN, "Agent run completed", { status: runResult.status, runId: runResult.runId });
         } catch (err) {
@@ -4360,6 +4982,56 @@ async function main() {
       }
     }
   });
+  powerManager.register({
+    name: "auto-backup",
+    runIn: ["idle", "sleep"],
+    fn: async () => {
+      try {
+        logger.info(LOG_KINDS.BACKUP_START, "Auto-backup starting");
+        const filePath = createBackup(db, backupDir, machineId);
+        logger.info(LOG_KINDS.BACKUP_COMPLETE, "Auto-backup complete", { file_path: filePath });
+      } catch (err) {
+        logger.error(LOG_KINDS.BACKUP_ERROR, "Auto-backup failed", { error: err.message });
+      }
+    }
+  });
+  if (config.team.enabled) {
+    powerManager.register({
+      name: "team-sync-flush",
+      runIn: ["active", "idle"],
+      fn: async () => {
+        const client = teamClient;
+        if (!client) return;
+        try {
+          const pending = listPending();
+          if (pending.length === 0) return;
+          logger.info(LOG_KINDS.TEAM_SYNC_START, "Flushing outbox", { count: pending.length });
+          const result = await client.pushBatch(pending);
+          if (result.synced > 0 || result.skipped > 0) {
+            const failedIds = new Set(result.errors.map((e) => e.id));
+            const sentIds = pending.filter((r) => !failedIds.has(String(r.row_id))).map((r) => r.id);
+            if (sentIds.length > 0) {
+              markSent(sentIds, epochSeconds());
+            }
+          }
+          if (result.errors.length > 0) {
+            logger.warn(LOG_KINDS.TEAM_SYNC_ERROR, `Sync errors: ${result.errors.length}`, {
+              errors: result.errors.slice(0, 5)
+            });
+          }
+          pruneOld();
+          logger.info(LOG_KINDS.TEAM_SYNC_COMPLETE, "Outbox flush complete", {
+            synced: result.synced,
+            skipped: result.skipped,
+            errors: result.errors.length,
+            total: pending.length
+          });
+        } catch (err) {
+          logger.error(LOG_KINDS.TEAM_SYNC_ERROR, "Outbox flush failed", { error: err.message });
+        }
+      }
+    });
+  }
   powerManager.start();
   const shutdown = async (signal) => {
     logger.info(LOG_KINDS.DAEMON_START, `${signal} received`);
@@ -4390,4 +5062,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-BMCL7CPO.js.map
+//# sourceMappingURL=main-PVX6R3I6.js.map