@goondocks/myco 0.14.4 → 0.15.1

package/dist/{main-MVXPBP5Z.js → main-ADLCOYKM.js}

@@ -2,7 +2,7 @@ import { createRequire as __cr } from 'node:module'; const require = __cr(import
 import {
   DaemonLogger,
   LEVEL_ORDER
-} from "./chunk-ZESTWGJT.js";
+} from "./chunk-GYIA6XLB.js";
 import {
   closeOpenBatches,
   countBatchesBySession,
@@ -48,7 +48,7 @@ import {
   setResponseSummary,
   updateCandidate,
   updateNotificationStatus
-} from "./chunk-JJXVDCEX.js";
+} from "./chunk-75J2BR4P.js";
 import {
   fullTextSearch,
   hydrateSearchResults
@@ -65,36 +65,29 @@ import {
   getEmbeddingQueueDepth,
   getUnembedded,
   markEmbedded
-} from "./chunk-GMTWRMLP.js";
+} from "./chunk-TQO4PF5K.js";
 import {
   getMachineId
 } from "./chunk-ENWBFX7F.js";
 import {
   createEmbeddingProvider
-} from "./chunk-LD6U3L6O.js";
+} from "./chunk-2QMDRZPJ.js";
 import {
   copyTaskToUser,
   deleteUserTask,
   loadAllTasks,
   validateTaskName,
   writeUserTask
-} from "./chunk-KNTJOMWY.js";
+} from "./chunk-3MEOYXOW.js";
 import {
   AgentTaskSchema,
   registerAgent,
   resolveDefinitionsDir,
   taskFromParsed
-} from "./chunk-NVCGF2DS.js";
+} from "./chunk-X4XFJG6I.js";
 import {
   listTurnsByRun
 } from "./chunk-QLCD77AN.js";
-import {
-  loadSecrets,
-  readSecrets,
-  writeSecret
-} from "./chunk-RJMXDUMA.js";
-import "./chunk-BCKYVLUZ.js";
-import "./chunk-SAKJMNSR.js";
 import {
   checkLocalProvider
 } from "./chunk-GDCSPMH4.js";
@@ -104,21 +97,29 @@ import {
   listBufferSessionIds
 } from "./chunk-V7XG6V6C.js";
 import "./chunk-IB76KGBY.js";
-import "./chunk-TNCBMGWB.js";
+import "./chunk-RBFECYNA.js";
+import "./chunk-OKCSSDFC.js";
+import "./chunk-5YQ6VOFZ.js";
+import "./chunk-6GG2IVNV.js";
+import "./chunk-SAKJMNSR.js";
+import {
+  loadSecrets,
+  readSecrets,
+  writeSecret
+} from "./chunk-RJMXDUMA.js";
+import "./chunk-X5IXK5KO.js";
 import {
   LmStudioBackend,
   OllamaBackend
 } from "./chunk-HHZ3RTEI.js";
-import "./chunk-RBFECYNA.js";
-import "./chunk-OKCSSDFC.js";
-import "./chunk-5YQ6VOFZ.js";
 import {
   countSpores,
   getSpore,
   insertSpore,
+  listSporeIdsSince,
   listSpores,
   updateSporeStatus
-} from "./chunk-PX5KIOKY.js";
+} from "./chunk-SPJGJEFV.js";
 import {
   closeSession,
   countSessions,
@@ -129,33 +130,37 @@ import {
   listSessions,
   updateSession,
   upsertSession
-} from "./chunk-X34OFKYU.js";
+} from "./chunk-23FJUKCN.js";
 import {
   backfillUnsynced,
+  countDeadLettered,
   countPending,
   enqueueOutbox,
   getTeamMachineId,
+  incrementRetryCount,
   initTeamContext,
   isTeamSyncEnabled,
   listPending,
   markSent,
   markSourceRowsSynced,
   pruneOld,
+  retryDeadLettered,
   syncRow
-} from "./chunk-S66YG6QK.js";
+} from "./chunk-LF5Z62X6.js";
 import {
   EMBEDDING_DIMENSIONS,
   SCHEMA_VERSION,
   createSchema
-} from "./chunk-4VF6KQ2Z.js";
+} from "./chunk-DJQOYEK3.js";
 import {
   CONFIG_FILENAME,
   MycoConfigSchema,
+  getEnabledSymbiontNames,
   loadConfig,
   updateBackupConfig,
   updateConfig,
   updateTeamConfig
-} from "./chunk-PSYLKCWQ.js";
+} from "./chunk-4BQ5QE76.js";
 import {
   closeDatabase,
   getDatabase,
@@ -164,13 +169,13 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   resolveCliEntryPath
-} from "./chunk-UZ5Y6XMP.js";
+} from "./chunk-4O3QNM5I.js";
 import {
   getPluginVersion
-} from "./chunk-TFBAV3PV.js";
+} from "./chunk-BFM6AM6R.js";
 import {
   loadManifests
-} from "./chunk-QFMBZ72S.js";
+} from "./chunk-SV6UCB2Z.js";
 import {
   findPackageRoot
 } from "./chunk-LPUQPDC2.js";
@@ -229,14 +234,14 @@ import {
 import {
   LOG_KINDS,
   kindToComponent
-} from "./chunk-S6I62FAH.js";
+} from "./chunk-CUADDHHU.js";
 import {
   require_dist
 } from "./chunk-D7TYRPRM.js";
 import "./chunk-E4VLWIJC.js";
 import {
   external_exports
-} from "./chunk-KH64DHOY.js";
+} from "./chunk-GDY63YAW.js";
 import {
   __toESM
 } from "./chunk-PZUWP5VK.js";
@@ -1264,183 +1269,6 @@ function extractTurnsFromBuffer(events) {
   return turns;
 }
 
-// src/daemon/plan-capture.ts
-import { createHash as createHash2 } from "crypto";
-import os6 from "os";
-import path9 from "path";
-
-// src/db/queries/plans.ts
-var DEFAULT_LIST_LIMIT2 = 100;
-var DEFAULT_STATUS2 = "active";
-var DEFAULT_PROCESSED = 0;
-var PLAN_COLUMNS = [
-  "id",
-  "status",
-  "author",
-  "title",
-  "content",
-  "source_path",
-  "tags",
-  "session_id",
-  "prompt_batch_id",
-  "content_hash",
-  "processed",
-  "embedded",
-  "created_at",
-  "updated_at",
-  "machine_id",
-  "synced_at"
-];
-var SELECT_COLUMNS = PLAN_COLUMNS.join(", ");
-function toPlanRow(row) {
-  return {
-    id: row.id,
-    status: row.status,
-    author: row.author ?? null,
-    title: row.title ?? null,
-    content: row.content ?? null,
-    source_path: row.source_path ?? null,
-    tags: row.tags ?? null,
-    session_id: row.session_id ?? null,
-    prompt_batch_id: row.prompt_batch_id ?? null,
-    content_hash: row.content_hash ?? null,
-    processed: row.processed,
-    embedded: row.embedded ?? 0,
-    created_at: row.created_at,
-    updated_at: row.updated_at ?? null,
-    machine_id: row.machine_id ?? "local",
-    synced_at: row.synced_at ?? null
-  };
-}
-function upsertPlan(data) {
-  const db = getDatabase();
-  db.prepare(
-    `INSERT INTO plans (
-       id, status, author, title, content,
-       source_path, tags, session_id, prompt_batch_id, content_hash,
-       processed, created_at, updated_at, machine_id
-     ) VALUES (
-       ?, ?, ?, ?, ?,
-       ?, ?, ?, ?, ?,
-       ?, ?, ?, ?
-     )
-     ON CONFLICT (id) DO UPDATE SET
-       status          = EXCLUDED.status,
-       author          = EXCLUDED.author,
-       title           = EXCLUDED.title,
-       content         = EXCLUDED.content,
-       source_path     = EXCLUDED.source_path,
-       tags            = EXCLUDED.tags,
-       session_id      = EXCLUDED.session_id,
-       prompt_batch_id = EXCLUDED.prompt_batch_id,
-       content_hash    = EXCLUDED.content_hash,
-       processed       = EXCLUDED.processed,
-       updated_at      = EXCLUDED.updated_at,
-       embedded        = CASE
-         WHEN EXCLUDED.content_hash != plans.content_hash THEN 0
-         ELSE plans.embedded
-       END`
-  ).run(
-    data.id,
-    data.status ?? DEFAULT_STATUS2,
-    data.author ?? null,
-    data.title ?? null,
-    data.content ?? null,
-    data.source_path ?? null,
-    data.tags ?? null,
-    data.session_id ?? null,
-    data.prompt_batch_id ?? null,
-    data.content_hash ?? null,
-    data.processed ?? DEFAULT_PROCESSED,
-    data.created_at,
-    data.updated_at ?? null,
-    data.machine_id ?? getTeamMachineId()
-  );
-  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();
-  const conditions = [];
-  const params = [];
-  if (options.status !== void 0) {
-    conditions.push(`status = ?`);
-    params.push(options.status);
-  }
-  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const limit = options.limit ?? DEFAULT_LIST_LIMIT2;
-  params.push(limit);
-  const rows = db.prepare(
-    `SELECT ${SELECT_COLUMNS}
-     FROM plans
-     ${where}
-     ORDER BY created_at DESC
-     LIMIT ?`
-  ).all(...params);
-  return rows.map(toPlanRow);
-}
-function listPlansBySession(sessionId) {
-  const db = getDatabase();
-  const rows = db.prepare(
-    `SELECT ${SELECT_COLUMNS}
-     FROM plans
-     WHERE session_id = ?
-     ORDER BY created_at DESC`
-  ).all(sessionId);
-  return rows.map(toPlanRow);
-}
-
-// src/daemon/plan-capture.ts
-var FILE_WRITE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "Create"]);
-var HEADING_REGEX = /^#\s+(.+)$/m;
-var PLAN_ID_HASH_LENGTH = 16;
-function isInPlanDirectory(filePath, watchDirs, projectRoot) {
-  const abs = path9.isAbsolute(filePath) ? filePath : path9.resolve(projectRoot, filePath);
-  return watchDirs.some((dir) => {
-    const expanded = dir.startsWith("~/") ? path9.join(os6.homedir(), dir.slice(2)) : dir;
-    const absDir = path9.isAbsolute(expanded) ? expanded : path9.resolve(projectRoot, expanded);
-    const prefix = absDir.endsWith(path9.sep) ? absDir : absDir + path9.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;
-  if (typeof filePath !== "string") return null;
-  if (!isInPlanDirectory(filePath, config.watchDirs, config.projectRoot)) return null;
-  if (config.extensions?.length) {
-    const ext = path9.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 = createHash2(CONTENT_HASH_ALGORITHM).update(input.content).digest("hex");
-  const id = createHash2("md5").update(input.sourcePath).digest("hex").slice(0, PLAN_ID_HASH_LENGTH);
-  const title = parsePlanTitle(input.content, path9.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/api/config.ts
 function mergeConfigSections(current, incoming) {
   return {
@@ -1470,6 +1298,33 @@ async function handlePutConfig(vaultDir, body) {
   const updated = updateConfig(vaultDir, (current) => mergeConfigSections(current, result.data));
   return { body: updated };
 }
+function createPlanDirHandlers(deps) {
+  const { vaultDir, symbiontPlanDirsByAgent, symbiontPlanDirs } = deps;
+  async function handleGetPlanDirs(_req) {
+    return {
+      body: {
+        symbiont: symbiontPlanDirsByAgent,
+        custom: deps.planWatchConfig.watchDirs.filter((d) => !symbiontPlanDirs.includes(d))
+      }
+    };
+  }
+  async function handleUpdatePlanDirs(req) {
+    const body = req.body;
+    if (!Array.isArray(body.plan_dirs)) {
+      return { status: 400, body: { error: "plan_dirs must be an array" } };
+    }
+    const updated = updateConfig(vaultDir, (cfg) => ({
+      ...cfg,
+      capture: { ...cfg.capture, plan_dirs: body.plan_dirs }
+    }));
+    deps.setPlanWatchConfig({
+      ...deps.planWatchConfig,
+      watchDirs: [.../* @__PURE__ */ new Set([...symbiontPlanDirs, ...body.plan_dirs])]
+    });
+    return { body: { custom: updated.capture.plan_dirs } };
+  }
+  return { handleGetPlanDirs, handleUpdatePlanDirs };
+}
 
 // src/db/queries/logs.ts
 var DEFAULT_PAGE_SIZE = 100;
@@ -1667,6 +1522,19 @@ async function handleLogDetail(req) {
     }
   };
 }
+var ExternalLogBody = external_exports.object({
+  level: external_exports.enum(["debug", "info", "warn", "error"]),
+  component: external_exports.string(),
+  message: external_exports.string(),
+  data: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+});
+function createLogIngestionHandler(logger) {
+  return async (req) => {
+    const { level, component, message, data } = ExternalLogBody.parse(req.body);
+    logger.log(level, LOG_KINDS.MCP_EVENT, message, { ...data, mcp_component: component });
+    return { body: { ok: true } };
+  };
+}
 function formatEntry(entry) {
   return {
     ...entry,
@@ -1705,7 +1573,7 @@ async function handleRestart(deps, body) {
 // src/daemon/update-checker.ts
 var import_yaml = __toESM(require_dist(), 1);
 import fs8 from "fs";
-import path10 from "path";
+import path9 from "path";
 import semver from "semver";
 var REGISTRY_FETCH_TIMEOUT_MS = 1e4;
 function isUpdateExempt() {
@@ -1822,7 +1690,7 @@ async function checkForUpdate(currentVersion) {
     channel: config.channel
   };
   try {
-    fs8.mkdirSync(path10.dirname(UPDATE_CHECK_CACHE_PATH), { recursive: true });
+    fs8.mkdirSync(path9.dirname(UPDATE_CHECK_CACHE_PATH), { recursive: true });
     fs8.writeFileSync(UPDATE_CHECK_CACHE_PATH, JSON.stringify(freshCache, null, 2), "utf-8");
   } catch {
   }
@@ -1837,8 +1705,8 @@ function statusFromCache(currentVersion, cache, config) {
 
 // src/daemon/update-installer.ts
 import fs9 from "fs";
-import os7 from "os";
-import path11 from "path";
+import os6 from "os";
+import path10 from "path";
 import { spawn as spawn2 } from "child_process";
 function generateUpdateScript(params) {
   const { targetVersion, projectRoot, vaultDir } = params;
@@ -1877,7 +1745,7 @@ rm -f "$0"
 function spawnUpdateScript(params) {
   fs9.mkdirSync(MYCO_GLOBAL_DIR, { recursive: true });
   const scriptName = `myco-update-${Date.now()}.sh`;
-  const scriptPath = path11.join(os7.tmpdir(), scriptName);
+  const scriptPath = path10.join(os6.tmpdir(), scriptName);
   const script = generateUpdateScript(params);
   fs9.writeFileSync(scriptPath, script, { encoding: "utf-8", mode: 493 });
   const child = spawn2("/bin/sh", [scriptPath], {
@@ -1983,7 +1851,7 @@ function createUpdateHandlers(deps) {
 
 // src/daemon/backup.ts
 import fs10 from "fs";
-import path12 from "path";
+import path11 from "path";
 var BACKUP_TABLES = [
   "sessions",
   "prompt_batches",
@@ -2027,7 +1895,7 @@ function createBackup(db, backupDir, machineId) {
     }
     lines.push("");
   }
-  const filePath = path12.join(backupDir, `${machineId}${BACKUP_EXTENSION}`);
+  const filePath = path11.join(backupDir, `${machineId}${BACKUP_EXTENSION}`);
   fs10.writeFileSync(filePath, lines.join("\n"), "utf-8");
   return filePath;
 }
@@ -2041,7 +1909,7 @@ function listBackups(backupDir) {
   const backups = [];
   for (const entry of entries) {
     if (!entry.endsWith(BACKUP_EXTENSION)) continue;
-    const filePath = path12.join(backupDir, entry);
+    const filePath = path11.join(backupDir, entry);
     const stat = fs10.statSync(filePath);
     backups.push({
       machine_id: entry.slice(0, -BACKUP_EXTENSION.length),
@@ -2138,6 +2006,7 @@ function restoreBackup(db, backupPath) {
 }
 
 // src/daemon/api/backup.ts
+import path12 from "path";
 function createBackupHandlers(deps) {
   async function handleCreateBackup(_req) {
     const filePath = createBackup(deps.db, deps.backupDir, deps.machineId);
@@ -2192,6 +2061,19 @@ function createBackupHandlers(deps) {
     handleRestore
   };
 }
+function createBackupConfigHandlers(deps) {
+  const { vaultDir } = deps;
+  async function handleGetBackupConfig() {
+    const cfg = loadConfig(vaultDir);
+    return { body: { dir: cfg.backup.dir ?? null, default_dir: path12.resolve(vaultDir, "backups") } };
+  }
+  async function handlePutBackupConfig(req) {
+    const { dir } = req.body;
+    updateBackupConfig(vaultDir, { dir: dir || void 0 });
+    return { body: { dir: dir || null } };
+  }
+  return { handleGetBackupConfig, handlePutBackupConfig };
+}
 
 // src/daemon/team-sync.ts
 var TeamSyncClient = class {
@@ -2303,15 +2185,15 @@ var TeamSyncClient = class {
       "Content-Type": "application/json"
     };
   }
-  async request(method, path16, body) {
-    const res = await this.fetchFn(`${this.workerUrl}${path16}`, {
+  async request(method, path21, body) {
+    const res = await this.fetchFn(`${this.workerUrl}${path21}`, {
       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} ${path16} failed: ${res.status} ${text}`);
+      throw new Error(`Team sync request ${method} ${path21} failed: ${res.status} ${text}`);
     }
     return res.json();
   }
@@ -2383,8 +2265,10 @@ function createTeamHandlers(deps) {
       }
     }
     let pendingCount = 0;
+    let deadLetterCount = 0;
     try {
       pendingCount = countPending();
+      deadLetterCount = countDeadLettered();
     } catch {
     }
     return {
@@ -2396,437 +2280,1013 @@ function createTeamHandlers(deps) {
         healthy,
         health_error: healthError,
         pending_sync_count: pendingCount,
+        dead_letter_count: deadLetterCount,
         machine_id: machineId,
         package_version: getPluginVersion(),
+        deployed_worker_version: config.team.deployed_worker_version ?? null,
+        worker_update_available: config.team.enabled ? config.team.deployed_worker_version !== getPluginVersion() : false,
         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;
-var PROGRESS_TTL_MS = 5 * 60 * 1e3;
-var ProgressTracker = class {
-  entries = /* @__PURE__ */ new Map();
-  /**
-   * Create a new tracked operation. Returns the existing token if an
-   * operation of the same type is already running (duplicate prevention).
-   * Throws if the maximum concurrent operations limit is reached.
-   */
-  /**
-   * Create a new tracked operation or return existing one.
-   * Returns `{ token, isNew }` — if `isNew` is false, the operation
-   * was already running and the caller should NOT launch it again.
-   * Throws if the maximum concurrent operations limit is reached.
-   */
-  create(type) {
-    this.cleanup();
-    for (const entry of this.entries.values()) {
-      if (entry.type === type && entry.status === "running") {
-        return { token: entry.token, isNew: false };
+  async function handleBackfill(_req) {
+    const count = backfillUnsynced(machineId);
+    return { body: { enqueued: count } };
+  }
+  async function handleRetryFailed(_req) {
+    const count = retryDeadLettered();
+    return { body: { retried: count } };
+  }
+  async function handleUpgradeWorker(_req) {
+    const { upgradeWorker } = await import("./team-TG5WZXWO.js");
+    const result = upgradeWorker(vaultDir);
+    if (!result.success) {
+      return { status: 500, body: { error: result.error } };
+    }
+    if (result.worker_url && deps.getTeamClient()) {
+      const secrets = readSecrets(vaultDir);
+      const apiKey = secrets[TEAM_API_KEY_SECRET];
+      if (apiKey) {
+        deps.setTeamClient(new TeamSyncClient({
+          workerUrl: result.worker_url,
+          apiKey,
+          machineId,
+          syncProtocolVersion: SYNC_PROTOCOL_VERSION
+        }));
       }
     }
-    const runningCount = [...this.entries.values()].filter((e) => e.status === "running").length;
-    if (runningCount >= MAX_CONCURRENT_OPERATIONS) {
-      throw new Error(`Maximum concurrent operations reached (${MAX_CONCURRENT_OPERATIONS})`);
-    }
-    const token = randomUUID();
-    const now = Date.now();
-    this.entries.set(token, {
-      token,
-      type,
-      status: "running",
-      created: now,
-      updated: now
-    });
-    return { token, isNew: true };
-  }
-  /**
-   * Update progress for a tracked operation.
-   */
-  update(token, data) {
-    const entry = this.entries.get(token);
-    if (!entry) return;
-    if (data.percent !== void 0) entry.percent = data.percent;
-    if (data.message !== void 0) entry.message = data.message;
-    if (data.status !== void 0) entry.status = data.status;
-    entry.updated = Date.now();
-  }
-  /**
-   * Get the current state of a tracked operation.
-   */
-  get(token) {
-    return this.entries.get(token);
-  }
-  /**
-   * Check whether any operations are currently running.
-   */
-  hasActiveOperations() {
-    for (const entry of this.entries.values()) {
-      if (entry.status === "running") return true;
-    }
-    return false;
-  }
-  /**
-   * Remove completed/failed entries older than PROGRESS_TTL_MS.
-   */
-  cleanup() {
-    const cutoff = Date.now() - PROGRESS_TTL_MS;
-    for (const [token, entry] of this.entries) {
-      if (entry.status !== "running" && entry.updated < cutoff) {
-        this.entries.delete(token);
-      }
-    }
-  }
-};
-async function handleGetProgress(tracker, token) {
-  const entry = tracker.get(token);
-  if (!entry) {
-    return { status: 404, body: { error: "not_found", message: "Progress token not found" } };
+    return { body: result };
   }
-  return { body: entry };
+  return { handleConnect, handleDisconnect, handleStatus, handleBackfill, handleRetryFailed, handleUpgradeWorker };
 }
 
-// src/daemon/api/models.ts
-var MODEL_LIST_TIMEOUT_MS = 5e3;
-var ANTHROPIC_MODELS = [
-  "claude-opus-4-6",
-  "claude-sonnet-4-6",
-  "claude-haiku-4-5-20251001"
-];
-var EMBEDDING_PATTERNS = [
-  "embed",
-  "bge-",
-  "nomic-embed",
-  "e5-",
-  "gte-",
-  "granite-embedding"
-];
-function filterEmbeddingModels(models) {
-  return models.filter((m) => {
-    const name = m.toLowerCase();
-    return EMBEDDING_PATTERNS.some((p) => name.includes(p));
-  });
-}
-function filterLlmModels(models) {
-  return models.filter((m) => {
-    const name = m.toLowerCase();
-    return !EMBEDDING_PATTERNS.some((p) => name.includes(p));
-  });
-}
-async function handleGetModels(req) {
-  const provider = req.query.provider;
-  const type = req.query.type;
-  if (!provider) {
-    return { status: 400, body: { error: "provider query parameter required" } };
-  }
-  let models = [];
-  try {
-    if (provider === "ollama") {
-      const backend = new OllamaBackend({ base_url: req.query.base_url });
-      models = await backend.listModels(MODEL_LIST_TIMEOUT_MS);
-    } else if (provider === "lm-studio" || provider === "openai-compatible") {
-      const backend = new LmStudioBackend({ base_url: req.query.base_url });
-      models = await backend.listModels(MODEL_LIST_TIMEOUT_MS);
-    } else if (provider === "anthropic") {
-      models = ANTHROPIC_MODELS;
-    }
-  } catch {
+// src/daemon/api/session-lifecycle.ts
+var RegisterBody = external_exports.object({
+  session_id: external_exports.string(),
+  agent: external_exports.string().optional(),
+  branch: external_exports.string().optional(),
+  started_at: external_exports.string().optional()
+});
+var UnregisterBody = external_exports.object({ session_id: external_exports.string() });
+function createSessionLifecycleHandlers(deps) {
+  const {
+    registry,
+    sessionBuffers,
+    reconciler,
+    stopProcessor,
+    server,
+    powerManager,
+    machineId,
+    logger,
+    config,
+    vaultDir
+  } = deps;
+  async function handleRegister(req) {
+    powerManager.recordActivity();
+    const { session_id, agent, branch, started_at } = RegisterBody.parse(req.body);
+    const resolvedStartedAt = started_at ?? (/* @__PURE__ */ new Date()).toISOString();
+    registry.register(session_id, { started_at: resolvedStartedAt, branch });
+    server.updateDaemonJsonSessions(registry.sessions);
+    const now = epochSeconds();
+    const startedEpoch = Math.floor(new Date(resolvedStartedAt).getTime() / 1e3);
+    upsertSession({
+      id: session_id,
+      agent: agent ?? "claude-code",
+      user: null,
+      project_root: process.cwd(),
+      branch: branch ?? null,
+      started_at: startedEpoch,
+      created_at: now,
+      status: "active",
+      machine_id: machineId
+    });
+    updateSession(session_id, { ended_at: null, status: "active" });
+    reconciler.reconcileSession(session_id);
+    logger.info(LOG_KINDS.LIFECYCLE_REGISTER, "Session registered", { session_id, branch, started_at: started_at ?? null });
+    notify(vaultDir, {
+      domain: "sessions",
+      type: "session.started",
+      title: "Session started",
+      message: branch ? `Branch: ${branch}` : void 0,
+      link: `/sessions/${session_id}`,
+      metadata: { sessionId: session_id, agent: agent ?? "claude-code", branch }
+    }, config);
+    return { body: { ok: true, sessions: registry.sessions } };
   }
-  if (type === "embedding") {
-    models = filterEmbeddingModels(models);
-  } else if (type === "llm") {
-    models = filterLlmModels(models);
+  async function handleUnregister(req) {
+    const { session_id } = UnregisterBody.parse(req.body);
+    registry.unregister(session_id);
+    const bufferDir = `${vaultDir}/buffer`;
+    cleanStaleBuffers(bufferDir, STALE_BUFFER_MAX_AGE_MS, session_id);
+    closeSession(session_id, epochSeconds());
+    sessionBuffers.delete(session_id);
+    stopProcessor.clearSession(session_id);
+    reconciler.clearSession(session_id);
+    server.updateDaemonJsonSessions(registry.sessions);
+    logger.info(LOG_KINDS.LIFECYCLE_UNREGISTER, "Session unregistered", { session_id });
+    notify(vaultDir, {
+      domain: "sessions",
+      type: "session.ended",
+      title: "Session ended",
+      link: `/sessions/${session_id}`,
+      metadata: { sessionId: session_id }
+    }, config);
+    return { body: { ok: true, sessions: registry.sessions } };
   }
-  return { body: { provider, models } };
+  return { handleRegister, handleUnregister };
 }
 
-// src/daemon/api/stats.ts
-import { createHash as createHash3 } from "crypto";
+// src/daemon/api/skills.ts
 import fs11 from "fs";
 import path13 from "path";
-function computeConfigHash(vaultDir) {
-  try {
-    const configPath = path13.join(vaultDir, CONFIG_FILENAME);
-    const raw = fs11.readFileSync(configPath, "utf-8");
-    return createHash3("md5").update(raw).digest("hex");
-  } catch {
-    return "";
-  }
-}
 
-// src/db/queries/activities.ts
-var DEFAULT_SUCCESS = 1;
-var DEFAULT_PROCESSED2 = 0;
-var ACTIVITY_COLUMNS = [
+// src/db/queries/skill-usage.ts
+var USAGE_COLUMNS = [
   "id",
+  "skill_id",
   "session_id",
-  "prompt_batch_id",
-  "tool_name",
-  "tool_input",
-  "tool_output_summary",
-  "file_path",
-  "files_affected",
-  "duration_ms",
-  "success",
-  "error_message",
-  "timestamp",
-  "processed",
-  "content_hash",
-  "created_at"
+  "machine_id",
+  "detected_at"
 ];
-var SELECT_COLUMNS2 = ACTIVITY_COLUMNS.join(", ");
-function toActivityRow(row) {
+var SELECT_COLUMNS = USAGE_COLUMNS.join(", ");
+function toUsageRow(row) {
   return {
     id: row.id,
+    skill_id: row.skill_id,
     session_id: row.session_id,
-    prompt_batch_id: row.prompt_batch_id ?? null,
-    tool_name: row.tool_name,
-    tool_input: row.tool_input ?? null,
-    tool_output_summary: row.tool_output_summary ?? null,
-    file_path: row.file_path ?? null,
-    files_affected: row.files_affected ?? null,
-    duration_ms: row.duration_ms ?? null,
-    success: row.success,
-    error_message: row.error_message ?? null,
-    timestamp: row.timestamp,
-    processed: row.processed,
-    content_hash: row.content_hash ?? null,
-    created_at: row.created_at
+    machine_id: row.machine_id ?? getTeamMachineId(),
+    detected_at: row.detected_at
   };
 }
-function insertActivityWithBatch(data) {
+function insertSkillUsage(data) {
   const db = getDatabase();
-  const info = db.prepare(
-    `INSERT INTO activities (
-       session_id, prompt_batch_id, tool_name, tool_input,
-       tool_output_summary, file_path, files_affected, duration_ms,
-       success, error_message, timestamp, processed,
-       content_hash, created_at
+  db.prepare(
+    `INSERT INTO skill_usage (
+       id, skill_id, session_id, machine_id, detected_at
      ) VALUES (
-       ?,
-       (SELECT id FROM prompt_batches WHERE session_id = ? AND ended_at IS NULL ORDER BY id DESC LIMIT 1),
-       ?, ?,
-       ?, ?, ?, ?,
-       ?, ?, ?, ?,
-       ?, ?
+       ?, ?, ?, ?, ?
      )`
   ).run(
+    data.id,
+    data.skill_id,
     data.session_id,
-    data.session_id,
-    data.tool_name,
-    data.tool_input ?? null,
-    data.tool_output_summary ?? null,
-    data.file_path ?? null,
-    data.files_affected ?? null,
-    data.duration_ms ?? null,
-    data.success ?? DEFAULT_SUCCESS,
-    data.error_message ?? null,
-    data.timestamp,
-    DEFAULT_PROCESSED2,
-    data.content_hash ?? null,
-    data.created_at
+    data.machine_id ?? getTeamMachineId(),
+    data.detected_at
   );
-  const activityId = Number(info.lastInsertRowid);
-  const toolName = data.tool_name;
-  const toolInput = data.tool_input ?? null;
-  const filePath = data.file_path ?? null;
-  if (toolName || toolInput || filePath) {
-    db.prepare(
-      "INSERT INTO activities_fts(rowid, tool_name, tool_input, file_path) VALUES (?, ?, ?, ?)"
-    ).run(activityId, toolName ?? "", toolInput ?? "", filePath ?? "");
-  }
-  return toActivityRow(
-    db.prepare(`SELECT ${SELECT_COLUMNS2} FROM activities WHERE id = ?`).get(activityId)
+  const row = toUsageRow(
+    db.prepare(`SELECT ${SELECT_COLUMNS} FROM skill_usage WHERE id = ?`).get(data.id)
   );
+  return row;
 }
-function listActivitiesByBatch(batchId) {
-  const db = getDatabase();
-  const rows = db.prepare(
-    `SELECT ${SELECT_COLUMNS2}
-     FROM activities
-     WHERE prompt_batch_id = ?
-     ORDER BY timestamp ASC`
-  ).all(batchId);
-  return rows.map(toActivityRow);
-}
-function countActivities(sessionId) {
+function hasUsageForSkillAndSession(skillId, sessionId) {
   const db = getDatabase();
   const row = db.prepare(
-    `SELECT COUNT(*) AS count FROM activities WHERE session_id = ?`
-  ).get(sessionId);
-  return row.count;
-}
-
-// src/db/queries/attachments.ts
-var ATTACHMENT_COLUMNS = [
-  "id",
-  "session_id",
-  "prompt_batch_id",
-  "file_path",
-  "media_type",
-  "description",
-  "data",
-  "content_hash",
-  "created_at"
-];
-var ATTACHMENT_LIST_COLUMNS = [
-  "id",
-  "session_id",
-  "prompt_batch_id",
-  "file_path",
-  "media_type",
-  "description",
-  "content_hash",
-  "created_at"
-];
-var SELECT_COLUMNS3 = ATTACHMENT_COLUMNS.join(", ");
-var SELECT_LIST_COLUMNS = ATTACHMENT_LIST_COLUMNS.join(", ");
-function toAttachmentBase(row) {
-  return {
-    id: row.id,
-    session_id: row.session_id,
-    prompt_batch_id: row.prompt_batch_id ?? null,
-    file_path: row.file_path,
-    media_type: row.media_type ?? null,
-    description: row.description ?? null,
-    content_hash: row.content_hash ?? null,
-    created_at: row.created_at
-  };
-}
-function toAttachmentRow(row) {
-  return { ...toAttachmentBase(row), data: row.data ?? null };
-}
-function toAttachmentListRow(row) {
-  return toAttachmentBase(row);
-}
-function insertAttachment(data) {
-  const db = getDatabase();
-  const info = db.prepare(
-    `INSERT INTO attachments (${SELECT_COLUMNS3})
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT (id) DO NOTHING`
-  ).run(
-    data.id,
-    data.session_id,
-    data.prompt_batch_id ?? null,
-    data.file_path,
-    data.media_type ?? null,
-    data.description ?? null,
-    data.data ?? null,
-    data.content_hash ?? null,
-    data.created_at
-  );
-  if (info.changes === 0) return void 0;
-  return toAttachmentRow(
-    db.prepare(`SELECT ${SELECT_COLUMNS3} FROM attachments WHERE id = ?`).get(data.id)
-  );
-}
-function listAttachmentsBySession(sessionId) {
-  const db = getDatabase();
-  const rows = db.prepare(
-    `SELECT ${SELECT_LIST_COLUMNS} FROM attachments WHERE session_id = ? ORDER BY created_at ASC`
-  ).all(sessionId);
-  return rows.map(toAttachmentListRow);
+    `SELECT 1 FROM skill_usage WHERE skill_id = ? AND session_id = ? LIMIT 1`
+  ).get(skillId, sessionId);
+  return row !== void 0;
 }
-function getAttachmentByFilePath(filePath) {
+function countUsageForSkill(skillId) {
   const db = getDatabase();
   const row = db.prepare(
-    `SELECT ${SELECT_COLUMNS3} FROM attachments WHERE file_path = ? LIMIT 1`
-  ).get(filePath);
-  return row ? toAttachmentRow(row) : null;
+    `SELECT COUNT(*) as count FROM skill_usage WHERE skill_id = ?`
+  ).get(skillId);
+  return row.count;
 }
 
-// src/daemon/api/sessions.ts
-var DEFAULT_LIST_LIMIT3 = 50;
+// src/daemon/api/skills.ts
 var DEFAULT_LIST_OFFSET = 0;
-async function handleListSessions(req) {
-  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT3;
-  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET;
+async function handleListCandidates(req) {
   const status = req.query.status || void 0;
-  const agent = req.query.agent || void 0;
-  const search = req.query.search || void 0;
-  const filterOpts = { status, agent, search };
-  const sessions = listSessions({ ...filterOpts, limit, offset }).map((s) => ({
-    id: s.id,
-    date: new Date(s.started_at * 1e3).toISOString().slice(0, 10),
-    title: s.title || s.id.slice(0, 8),
-    status: s.status,
-    agent: s.agent,
-    prompt_count: s.prompt_count,
-    tool_count: s.tool_count,
-    started_at: s.started_at,
-    ended_at: s.ended_at
-  }));
-  const total = countSessions(filterOpts);
-  return { body: { sessions, total, offset, limit } };
+  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT;
+  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET;
+  const { items: candidates, total } = listCandidatesWithCount({ status, limit, offset });
+  return { status: 200, body: { candidates, total } };
 }
-async function handleGetSession(req) {
-  const session = getSession(req.params.id);
-  if (!session) return { status: 404, body: { error: "not_found" } };
-  const promptCount = countBatchesBySession(session.id);
-  const toolCount = countActivities(session.id);
-  return { body: { ...session, prompt_count: promptCount, tool_count: toolCount } };
+async function handleGetCandidate(req) {
+  const candidate = getCandidate(req.params.id);
+  if (!candidate) {
+    return { status: 404, body: { error: `Not found: ${req.params.id}` } };
+  }
+  return { status: 200, body: { candidate } };
 }
-async function handleGetSessionBatches(req) {
-  const batches = listBatchesBySession(req.params.id);
-  return { body: batches };
+async function handleUpdateCandidate(req) {
+  const id = req.params.id;
+  const body = req.body;
+  if (!body) return { status: 400, body: { error: "Request body required" } };
+  const { status, topic, rationale, confidence, source_ids, skill_id } = body;
+  const updated = updateCandidate(id, {
+    ...status !== void 0 ? { status } : {},
+    ...topic !== void 0 ? { topic } : {},
+    ...rationale !== void 0 ? { rationale } : {},
+    ...confidence !== void 0 ? { confidence } : {},
+    ...source_ids !== void 0 ? { source_ids } : {},
+    ...skill_id !== void 0 ? { skill_id } : {},
+    updated_at: epochSeconds()
+  });
+  if (!updated) return { status: 404, body: { error: `Candidate not found: ${id}` } };
+  return { status: 200, body: { candidate: updated } };
 }
-async function handleGetBatchActivities(req) {
-  const batchId = Number(req.params.id);
-  if (isNaN(batchId)) return { status: 400, body: { error: "invalid_batch_id" } };
-  const activities = listActivitiesByBatch(batchId);
-  return { body: activities };
+async function handleListSkillRecords(req) {
+  const status = req.query.status || void 0;
+  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT;
+  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET;
+  const { items: records, total } = listSkillRecordsWithCount({ status, limit, offset });
+  return { status: 200, body: { records, total } };
 }
-async function handleGetSessionAttachments(req) {
-  const attachments = listAttachmentsBySession(req.params.id);
-  return { body: attachments };
+async function handleGetSkillRecord(req) {
+  const idOrName = req.params.id;
+  const record = getSkillRecord(idOrName) ?? getSkillRecordByName(idOrName);
+  if (!record) {
+    return { status: 404, body: { error: `Not found: ${idOrName}` } };
+  }
+  const lineage = listLineageForSkill(record.id);
+  const usage_total = countUsageForSkill(record.id);
+  const latestSnapshot = lineage[0]?.content_snapshot;
+  const frontmatterFields = {};
+  if (latestSnapshot) {
+    const fmMatch = latestSnapshot.match(/^---\n([\s\S]*?)\n---/);
+    if (fmMatch) {
+      for (const line of fmMatch[1].split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx > 0) {
+          const key = line.slice(0, colonIdx).trim();
+          const val = line.slice(colonIdx + 1).trim();
+          if (key && val) frontmatterFields[key] = val;
+        }
+      }
+    }
+  }
+  return { status: 200, body: { ...record, lineage, usage_total, frontmatter: frontmatterFields } };
 }
-async function handleGetSessionPlans(req) {
-  const plans = listPlansBySession(req.params.id);
-  return { body: plans };
+async function handleDeleteCandidate(req) {
+  const id = req.params.id;
+  const deleted = deleteCandidate(id);
+  if (!deleted) return { status: 404, body: { error: `Not found: ${id}` } };
+  return { status: 200, body: { deleted: true, id } };
 }
-
-// src/daemon/api/mycelium.ts
-var DEFAULT_LIST_LIMIT4 = 50;
-var DEFAULT_LIST_OFFSET2 = 0;
-var DEFAULT_GRAPH_DEPTH = 1;
-var MAX_GRAPH_DEPTH = 3;
-var SPORE_NAME_PREVIEW_CHARS = 60;
-var EXCLUDED_GRAPH_EDGE_TYPES = /* @__PURE__ */ new Set(["HAS_BATCH", "EXTRACTED_FROM"]);
-async function handleListSpores(req) {
-  const agentId = req.query.agent_id;
-  const type = req.query.type;
-  const status = req.query.status;
-  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT4;
-  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET2;
-  const search = req.query.search || void 0;
-  const filterOpts = {
-    ...agentId ? { agent_id: agentId } : {},
-    observation_type: type,
-    status,
-    search
-  };
-  const spores = listSpores({ ...filterOpts, limit, offset });
-  const total = countSpores(filterOpts);
-  return { body: { spores, total, offset, limit } };
+async function handleDeleteSkillRecord(req) {
+  const idOrName = req.params.id;
+  const result = deleteSkillRecordCascade(idOrName);
+  if (!result) return { status: 404, body: { error: `Not found: ${idOrName}` } };
+  if (isTeamSyncEnabled()) {
+    try {
+      enqueueOutbox({
+        table_name: "skill_records",
+        row_id: result.id,
+        operation: "delete",
+        payload: JSON.stringify({ id: result.id, name: result.name }),
+        machine_id: getTeamMachineId(),
+        created_at: epochSeconds()
+      });
+    } catch (err) {
+      console.warn("[team-sync] Failed to enqueue skill record deletion:", err instanceof Error ? err.message : err);
+    }
+  }
+  return { status: 200, body: { deleted: true, id: result.id, name: result.name } };
 }
-async function handleGetSpore(req) {
-  const spore = getSpore(req.params.id);
-  if (!spore) return { status: 404, body: { error: "not_found" } };
-  return { body: spore };
+function createSkillRecordDeleteHandler(deps) {
+  const { vaultDir, logger } = deps;
+  return async function handleDeleteSkillRecordWithCleanup(req) {
+    const result = await handleDeleteSkillRecord(req);
+    if (result.body?.deleted) {
+      const record = result.body;
+      if (record.name) {
+        const projectRoot = path13.resolve(vaultDir, "..");
+        const skillDir = path13.resolve(projectRoot, ".agents", "skills", record.name);
+        try {
+          fs11.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) });
+        }
+        try {
+          const { syncSkillSymlinks } = await import("./installer-BTUNKWOU.js");
+          syncSkillSymlinks(projectRoot, record.name, { remove: true });
+        } catch (err) {
+          logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to remove skill symlinks", { name: record.name, error: String(err) });
+        }
+      }
+    }
+    return result;
+  };
 }
-async function handleListEntities(req) {
-  const agentId = req.query.agent_id ?? DEFAULT_AGENT_ID;
+
+// src/daemon/team-sync-init.ts
+function initTeamSync(deps) {
+  const { config, machineId, logger, vaultDir, serverVersion } = deps;
+  let teamClient = null;
+  if (config.team.enabled && config.team.worker_url) {
+    const secrets = readSecrets(vaultDir);
+    const teamApiKey = secrets[TEAM_API_KEY_SECRET];
+    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: serverVersion
+      }).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);
+    }
+  }
+  return {
+    getTeamClient: () => teamClient,
+    setTeamClient: (client) => {
+      teamClient = client;
+    },
+    registerFlushJob: (powerManager) => {
+      if (!config.team.enabled) return;
+      const logDeadLettered = (ids) => {
+        if (ids.length > 0) {
+          logger.error(LOG_KINDS.TEAM_SYNC_DEAD_LETTER, `Dead-lettered ${ids.length} records after max retries`, { ids });
+        }
+      };
+      powerManager.register({
+        name: "team-sync-flush",
+        runIn: ["active", "idle", "sleep"],
+        preventsDeepSleep: () => countPending() > 0,
+        fn: async () => {
+          const client = teamClient;
+          if (!client) return;
+          const pending = listPending();
+          if (pending.length === 0) return;
+          try {
+            logger.info(LOG_KINDS.TEAM_SYNC_START, "Flushing outbox", { count: pending.length });
+            const result = await client.pushBatch(pending);
+            const now = epochSeconds();
+            const failedIds = new Set(result.errors.map((e) => e.id));
+            const sentRecords = pending.filter((r) => !failedIds.has(String(r.row_id)));
+            const sentIds = sentRecords.map((r) => r.id);
+            if (sentIds.length > 0) {
+              markSent(sentIds, now);
+              markSourceRowsSynced(sentRecords, now);
+            }
+            if (result.errors.length > 0) {
+              const failedOutboxIds = pending.filter((r) => failedIds.has(String(r.row_id))).map((r) => r.id);
+              const deadLettered = incrementRetryCount(failedOutboxIds, now);
+              logger.warn(LOG_KINDS.TEAM_SYNC_RETRY, `Retrying ${failedOutboxIds.length} records`, {
+                errors: result.errors.slice(0, 5)
+              });
+              logDeadLettered(deadLettered);
+            }
+            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) {
+            try {
+              const now = epochSeconds();
+              const allIds = pending.map((r) => r.id);
+              const deadLettered = incrementRetryCount(allIds, now);
+              logger.warn(LOG_KINDS.TEAM_SYNC_RETRY, `Batch failed, retrying ${allIds.length} records`, {
+                error: err.message
+              });
+              logDeadLettered(deadLettered);
+            } catch {
+            }
+            logger.error(LOG_KINDS.TEAM_SYNC_ERROR, "Outbox flush failed", { error: err.message });
+          }
+        }
+      });
+    }
+  };
+}
+
+// src/daemon/api/progress.ts
+import { randomUUID } from "crypto";
+var MAX_CONCURRENT_OPERATIONS = 10;
+var PROGRESS_TTL_MS = 5 * 60 * 1e3;
+var ProgressTracker = class {
+  entries = /* @__PURE__ */ new Map();
+  /**
+   * Create a new tracked operation. Returns the existing token if an
+   * operation of the same type is already running (duplicate prevention).
+   * Throws if the maximum concurrent operations limit is reached.
+   */
+  /**
+   * Create a new tracked operation or return existing one.
+   * Returns `{ token, isNew }` — if `isNew` is false, the operation
+   * was already running and the caller should NOT launch it again.
+   * Throws if the maximum concurrent operations limit is reached.
+   */
+  create(type) {
+    this.cleanup();
+    for (const entry of this.entries.values()) {
+      if (entry.type === type && entry.status === "running") {
+        return { token: entry.token, isNew: false };
+      }
+    }
+    const runningCount = [...this.entries.values()].filter((e) => e.status === "running").length;
+    if (runningCount >= MAX_CONCURRENT_OPERATIONS) {
+      throw new Error(`Maximum concurrent operations reached (${MAX_CONCURRENT_OPERATIONS})`);
+    }
+    const token = randomUUID();
+    const now = Date.now();
+    this.entries.set(token, {
+      token,
+      type,
+      status: "running",
+      created: now,
+      updated: now
+    });
+    return { token, isNew: true };
+  }
+  /**
+   * Update progress for a tracked operation.
+   */
+  update(token, data) {
+    const entry = this.entries.get(token);
+    if (!entry) return;
+    if (data.percent !== void 0) entry.percent = data.percent;
+    if (data.message !== void 0) entry.message = data.message;
+    if (data.status !== void 0) entry.status = data.status;
+    entry.updated = Date.now();
+  }
+  /**
+   * Get the current state of a tracked operation.
+   */
+  get(token) {
+    return this.entries.get(token);
+  }
+  /**
+   * Check whether any operations are currently running.
+   */
+  hasActiveOperations() {
+    for (const entry of this.entries.values()) {
+      if (entry.status === "running") return true;
+    }
+    return false;
+  }
+  /**
+   * Remove completed/failed entries older than PROGRESS_TTL_MS.
+   */
+  cleanup() {
+    const cutoff = Date.now() - PROGRESS_TTL_MS;
+    for (const [token, entry] of this.entries) {
+      if (entry.status !== "running" && entry.updated < cutoff) {
+        this.entries.delete(token);
+      }
+    }
+  }
+};
+async function handleGetProgress(tracker, token) {
+  const entry = tracker.get(token);
+  if (!entry) {
+    return { status: 404, body: { error: "not_found", message: "Progress token not found" } };
+  }
+  return { body: entry };
+}
+
+// src/daemon/api/models.ts
+var MODEL_LIST_TIMEOUT_MS = 5e3;
+var ANTHROPIC_MODELS = [
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5-20251001"
+];
+var EMBEDDING_PATTERNS = [
+  "embed",
+  "bge-",
+  "nomic-embed",
+  "e5-",
+  "gte-",
+  "granite-embedding"
+];
+function filterEmbeddingModels(models) {
+  return models.filter((m) => {
+    const name = m.toLowerCase();
+    return EMBEDDING_PATTERNS.some((p) => name.includes(p));
+  });
+}
+function filterLlmModels(models) {
+  return models.filter((m) => {
+    const name = m.toLowerCase();
+    return !EMBEDDING_PATTERNS.some((p) => name.includes(p));
+  });
+}
+async function handleGetModels(req) {
+  const provider = req.query.provider;
+  const type = req.query.type;
+  if (!provider) {
+    return { status: 400, body: { error: "provider query parameter required" } };
+  }
+  let models = [];
+  try {
+    if (provider === "ollama") {
+      const backend = new OllamaBackend({ base_url: req.query.base_url });
+      models = await backend.listModels(MODEL_LIST_TIMEOUT_MS);
+    } else if (provider === "lm-studio" || provider === "openai-compatible") {
+      const backend = new LmStudioBackend({ base_url: req.query.base_url });
+      models = await backend.listModels(MODEL_LIST_TIMEOUT_MS);
+    } else if (provider === "anthropic") {
+      models = ANTHROPIC_MODELS;
+    }
+  } catch {
+  }
+  if (type === "embedding") {
+    models = filterEmbeddingModels(models);
+  } else if (type === "llm") {
+    models = filterLlmModels(models);
+  }
+  return { body: { provider, models } };
+}
+
+// src/daemon/api/stats.ts
+import { createHash as createHash2 } from "crypto";
+import fs12 from "fs";
+import path14 from "path";
+function computeConfigHash(vaultDir) {
+  try {
+    const configPath = path14.join(vaultDir, CONFIG_FILENAME);
+    const raw = fs12.readFileSync(configPath, "utf-8");
+    return createHash2("md5").update(raw).digest("hex");
+  } catch {
+    return "";
+  }
+}
+function createLiveStatsHandler(deps) {
+  return async () => {
+    const stats = gatherStats(deps.vaultDir, { active_sessions: deps.registry.sessions });
+    stats.daemon.pid = process.pid;
+    stats.daemon.port = deps.server.port;
+    stats.daemon.version = deps.server.version;
+    stats.daemon.uptime_seconds = Math.floor(process.uptime());
+    return { body: { ...stats, config_hash: deps.configHash.get() } };
+  };
+}
+
+// src/db/queries/activities.ts
+var DEFAULT_SUCCESS = 1;
+var DEFAULT_PROCESSED = 0;
+var ACTIVITY_COLUMNS = [
+  "id",
+  "session_id",
+  "prompt_batch_id",
+  "tool_name",
+  "tool_input",
+  "tool_output_summary",
+  "file_path",
+  "files_affected",
+  "duration_ms",
+  "success",
+  "error_message",
+  "timestamp",
+  "processed",
+  "content_hash",
+  "created_at"
+];
+var SELECT_COLUMNS2 = ACTIVITY_COLUMNS.join(", ");
+function toActivityRow(row) {
+  return {
+    id: row.id,
+    session_id: row.session_id,
+    prompt_batch_id: row.prompt_batch_id ?? null,
+    tool_name: row.tool_name,
+    tool_input: row.tool_input ?? null,
+    tool_output_summary: row.tool_output_summary ?? null,
+    file_path: row.file_path ?? null,
+    files_affected: row.files_affected ?? null,
+    duration_ms: row.duration_ms ?? null,
+    success: row.success,
+    error_message: row.error_message ?? null,
+    timestamp: row.timestamp,
+    processed: row.processed,
+    content_hash: row.content_hash ?? null,
+    created_at: row.created_at
+  };
+}
+function insertActivityWithBatch(data) {
+  const db = getDatabase();
+  const info = db.prepare(
+    `INSERT INTO activities (
+       session_id, prompt_batch_id, tool_name, tool_input,
+       tool_output_summary, file_path, files_affected, duration_ms,
+       success, error_message, timestamp, processed,
+       content_hash, created_at
+     ) VALUES (
+       ?,
+       (SELECT id FROM prompt_batches WHERE session_id = ? AND ended_at IS NULL ORDER BY id DESC LIMIT 1),
+       ?, ?,
+       ?, ?, ?, ?,
+       ?, ?, ?, ?,
+       ?, ?
+     )`
+  ).run(
+    data.session_id,
+    data.session_id,
+    data.tool_name,
+    data.tool_input ?? null,
+    data.tool_output_summary ?? null,
+    data.file_path ?? null,
+    data.files_affected ?? null,
+    data.duration_ms ?? null,
+    data.success ?? DEFAULT_SUCCESS,
+    data.error_message ?? null,
+    data.timestamp,
+    DEFAULT_PROCESSED,
+    data.content_hash ?? null,
+    data.created_at
+  );
+  const activityId = Number(info.lastInsertRowid);
+  const toolName = data.tool_name;
+  const toolInput = data.tool_input ?? null;
+  const filePath = data.file_path ?? null;
+  if (toolName || toolInput || filePath) {
+    db.prepare(
+      "INSERT INTO activities_fts(rowid, tool_name, tool_input, file_path) VALUES (?, ?, ?, ?)"
+    ).run(activityId, toolName ?? "", toolInput ?? "", filePath ?? "");
+  }
+  return toActivityRow(
+    db.prepare(`SELECT ${SELECT_COLUMNS2} FROM activities WHERE id = ?`).get(activityId)
+  );
+}
+function listActivitiesByBatch(batchId) {
+  const db = getDatabase();
+  const rows = db.prepare(
+    `SELECT ${SELECT_COLUMNS2}
+     FROM activities
+     WHERE prompt_batch_id = ?
+     ORDER BY timestamp ASC`
+  ).all(batchId);
+  return rows.map(toActivityRow);
+}
+function countActivities(sessionId) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT COUNT(*) AS count FROM activities WHERE session_id = ?`
+  ).get(sessionId);
+  return row.count;
+}
+
+// src/db/queries/attachments.ts
+var ATTACHMENT_COLUMNS = [
+  "id",
+  "session_id",
+  "prompt_batch_id",
+  "file_path",
+  "media_type",
+  "description",
+  "data",
+  "content_hash",
+  "created_at"
+];
+var ATTACHMENT_LIST_COLUMNS = [
+  "id",
+  "session_id",
+  "prompt_batch_id",
+  "file_path",
+  "media_type",
+  "description",
+  "content_hash",
+  "created_at"
+];
+var SELECT_COLUMNS3 = ATTACHMENT_COLUMNS.join(", ");
+var SELECT_LIST_COLUMNS = ATTACHMENT_LIST_COLUMNS.join(", ");
+function toAttachmentBase(row) {
+  return {
+    id: row.id,
+    session_id: row.session_id,
+    prompt_batch_id: row.prompt_batch_id ?? null,
+    file_path: row.file_path,
+    media_type: row.media_type ?? null,
+    description: row.description ?? null,
+    content_hash: row.content_hash ?? null,
+    created_at: row.created_at
+  };
+}
+function toAttachmentRow(row) {
+  return { ...toAttachmentBase(row), data: row.data ?? null };
+}
+function toAttachmentListRow(row) {
+  return toAttachmentBase(row);
+}
+function insertAttachment(data) {
+  const db = getDatabase();
+  const info = db.prepare(
+    `INSERT INTO attachments (${SELECT_COLUMNS3})
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT (id) DO NOTHING`
+  ).run(
+    data.id,
+    data.session_id,
+    data.prompt_batch_id ?? null,
+    data.file_path,
+    data.media_type ?? null,
+    data.description ?? null,
+    data.data ?? null,
+    data.content_hash ?? null,
+    data.created_at
+  );
+  if (info.changes === 0) return void 0;
+  return toAttachmentRow(
+    db.prepare(`SELECT ${SELECT_COLUMNS3} FROM attachments WHERE id = ?`).get(data.id)
+  );
+}
+function listAttachmentsBySession(sessionId) {
+  const db = getDatabase();
+  const rows = db.prepare(
+    `SELECT ${SELECT_LIST_COLUMNS} FROM attachments WHERE session_id = ? ORDER BY created_at ASC`
+  ).all(sessionId);
+  return rows.map(toAttachmentListRow);
+}
+function getAttachmentByFilePath(filePath) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT ${SELECT_COLUMNS3} FROM attachments WHERE file_path = ? LIMIT 1`
+  ).get(filePath);
+  return row ? toAttachmentRow(row) : null;
+}
+
+// src/db/queries/plans.ts
+var DEFAULT_LIST_LIMIT2 = 100;
+var DEFAULT_STATUS2 = "active";
+var DEFAULT_PROCESSED2 = 0;
+var PLAN_COLUMNS = [
+  "id",
+  "status",
+  "author",
+  "title",
+  "content",
+  "source_path",
+  "tags",
+  "session_id",
+  "prompt_batch_id",
+  "content_hash",
+  "processed",
+  "embedded",
+  "created_at",
+  "updated_at",
+  "machine_id",
+  "synced_at"
+];
+var SELECT_COLUMNS4 = PLAN_COLUMNS.join(", ");
+function toPlanRow(row) {
+  return {
+    id: row.id,
+    status: row.status,
+    author: row.author ?? null,
+    title: row.title ?? null,
+    content: row.content ?? null,
+    source_path: row.source_path ?? null,
+    tags: row.tags ?? null,
+    session_id: row.session_id ?? null,
+    prompt_batch_id: row.prompt_batch_id ?? null,
+    content_hash: row.content_hash ?? null,
+    processed: row.processed,
+    embedded: row.embedded ?? 0,
+    created_at: row.created_at,
+    updated_at: row.updated_at ?? null,
+    machine_id: row.machine_id ?? "local",
+    synced_at: row.synced_at ?? null
+  };
+}
+function upsertPlan(data) {
+  const db = getDatabase();
+  db.prepare(
+    `INSERT INTO plans (
+       id, status, author, title, content,
+       source_path, tags, session_id, prompt_batch_id, content_hash,
+       processed, created_at, updated_at, machine_id
+     ) VALUES (
+       ?, ?, ?, ?, ?,
+       ?, ?, ?, ?, ?,
+       ?, ?, ?, ?
+     )
+     ON CONFLICT (id) DO UPDATE SET
+       status          = EXCLUDED.status,
+       author          = EXCLUDED.author,
+       title           = EXCLUDED.title,
+       content         = EXCLUDED.content,
+       source_path     = EXCLUDED.source_path,
+       tags            = EXCLUDED.tags,
+       session_id      = EXCLUDED.session_id,
+       prompt_batch_id = EXCLUDED.prompt_batch_id,
+       content_hash    = EXCLUDED.content_hash,
+       processed       = EXCLUDED.processed,
+       updated_at      = EXCLUDED.updated_at,
+       embedded        = CASE
+         WHEN EXCLUDED.content_hash != plans.content_hash THEN 0
+         ELSE plans.embedded
+       END`
+  ).run(
+    data.id,
+    data.status ?? DEFAULT_STATUS2,
+    data.author ?? null,
+    data.title ?? null,
+    data.content ?? null,
+    data.source_path ?? null,
+    data.tags ?? null,
+    data.session_id ?? null,
+    data.prompt_batch_id ?? null,
+    data.content_hash ?? null,
+    data.processed ?? DEFAULT_PROCESSED2,
+    data.created_at,
+    data.updated_at ?? null,
+    data.machine_id ?? getTeamMachineId()
+  );
+  const row = toPlanRow(
+    db.prepare(`SELECT ${SELECT_COLUMNS4} FROM plans WHERE id = ?`).get(data.id)
+  );
+  syncRow("plans", row);
+  return row;
+}
+function listPlans(options = {}) {
+  const db = getDatabase();
+  const conditions = [];
+  const params = [];
+  if (options.status !== void 0) {
+    conditions.push(`status = ?`);
+    params.push(options.status);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = options.limit ?? DEFAULT_LIST_LIMIT2;
+  params.push(limit);
+  const rows = db.prepare(
+    `SELECT ${SELECT_COLUMNS4}
+     FROM plans
+     ${where}
+     ORDER BY created_at DESC
+     LIMIT ?`
+  ).all(...params);
+  return rows.map(toPlanRow);
+}
+function listPlansBySession(sessionId) {
+  const db = getDatabase();
+  const rows = db.prepare(
+    `SELECT ${SELECT_COLUMNS4}
+     FROM plans
+     WHERE session_id = ?
+     ORDER BY created_at DESC`
+  ).all(sessionId);
+  return rows.map(toPlanRow);
+}
+
+// src/daemon/jobs/session-cleanup.ts
+import { unlink, glob } from "fs/promises";
+async function cleanupAfterSessionCascade(sessionId, result, embeddingManager, vaultDir) {
+  try {
+    embeddingManager.onRemoved("sessions", sessionId);
+  } catch {
+  }
+  for (const sporeId of result.deletedSporeIds) {
+    try {
+      embeddingManager.onRemoved("spores", sporeId);
+    } catch {
+    }
+  }
+  try {
+    for await (const f of glob(`sessions/**/session-${sessionId}.md`, { cwd: vaultDir })) {
+      await unlink(`${vaultDir}/${f}`).catch(() => {
+      });
+    }
+  } catch {
+  }
+  for (const sporeId of result.deletedSporeIds) {
+    try {
+      for await (const f of glob(`spores/**/${sporeId}*.md`, { cwd: vaultDir })) {
+        await unlink(`${vaultDir}/${f}`).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  for (const filePath of result.deletedAttachmentPaths) {
+    try {
+      await unlink(filePath);
+    } catch {
+    }
+  }
+}
+
+// src/daemon/api/sessions.ts
+var DEFAULT_LIST_LIMIT3 = 50;
+var DEFAULT_LIST_OFFSET2 = 0;
+async function handleListSessions(req) {
+  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT3;
+  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET2;
+  const status = req.query.status || void 0;
+  const agent = req.query.agent || void 0;
+  const search = req.query.search || void 0;
+  const filterOpts = { status, agent, search };
+  const sessions = listSessions({ ...filterOpts, limit, offset }).map((s) => ({
+    id: s.id,
+    date: new Date(s.started_at * 1e3).toISOString().slice(0, 10),
+    title: s.title || s.id.slice(0, 8),
+    status: s.status,
+    agent: s.agent,
+    prompt_count: s.prompt_count,
+    tool_count: s.tool_count,
+    started_at: s.started_at,
+    ended_at: s.ended_at
+  }));
+  const total = countSessions(filterOpts);
+  return { body: { sessions, total, offset, limit } };
+}
+async function handleGetSession(req) {
+  const session = getSession(req.params.id);
+  if (!session) return { status: 404, body: { error: "not_found" } };
+  const promptCount = countBatchesBySession(session.id);
+  const toolCount = countActivities(session.id);
+  return { body: { ...session, prompt_count: promptCount, tool_count: toolCount } };
+}
+async function handleGetSessionBatches(req) {
+  const batches = listBatchesBySession(req.params.id);
+  return { body: batches };
+}
+async function handleGetBatchActivities(req) {
+  const batchId = Number(req.params.id);
+  if (isNaN(batchId)) return { status: 400, body: { error: "invalid_batch_id" } };
+  const activities = listActivitiesByBatch(batchId);
+  return { body: activities };
+}
+async function handleGetSessionAttachments(req) {
+  const attachments = listAttachmentsBySession(req.params.id);
+  return { body: attachments };
+}
+async function handleGetSessionPlans(req) {
+  const plans = listPlansBySession(req.params.id);
+  return { body: plans };
+}
+function createSessionMutationHandlers(deps) {
+  const { embeddingManager, vaultDir, logger } = deps;
+  async function handleDeleteSession(req) {
+    const sessionId = req.params.id;
+    const result = deleteSessionCascade(sessionId);
+    if (!result.deleted) return { status: 404, body: { error: "Session not found" } };
+    cleanupAfterSessionCascade(sessionId, result, embeddingManager, vaultDir).catch(() => {
+    });
+    logger.info(LOG_KINDS.API_SESSION_DELETE, "Session cascade deleted", {
+      session_id: sessionId,
+      counts: result.counts
+    });
+    return { body: { ok: true, counts: result.counts } };
+  }
+  async function handleGetSessionImpact(req) {
+    const sessionId = req.params.id;
+    const session = getSession(sessionId);
+    if (!session) return { status: 404, body: { error: "Session not found" } };
+    const impact = getSessionImpact(sessionId);
+    return { body: impact };
+  }
+  return { handleDeleteSession, handleGetSessionImpact };
+}
+
+// src/daemon/api/mycelium.ts
+var DEFAULT_LIST_LIMIT4 = 50;
+var DEFAULT_LIST_OFFSET3 = 0;
+var DEFAULT_GRAPH_DEPTH = 1;
+var MAX_GRAPH_DEPTH = 3;
+var SPORE_NAME_PREVIEW_CHARS = 60;
+var EXCLUDED_GRAPH_EDGE_TYPES = /* @__PURE__ */ new Set(["HAS_BATCH", "EXTRACTED_FROM"]);
+async function handleListSpores(req) {
+  const agentId = req.query.agent_id;
+  const type = req.query.type;
+  const status = req.query.status;
+  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT4;
+  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET3;
+  const search = req.query.search || void 0;
+  const filterOpts = {
+    ...agentId ? { agent_id: agentId } : {},
+    observation_type: type,
+    status,
+    search
+  };
+  const spores = listSpores({ ...filterOpts, limit, offset });
+  const total = countSpores(filterOpts);
+  return { body: { spores, total, offset, limit } };
+}
+async function handleGetSpore(req) {
+  const spore = getSpore(req.params.id);
+  if (!spore) return { status: 404, body: { error: "not_found" } };
+  return { body: spore };
+}
+async function handleListEntities(req) {
+  const agentId = req.query.agent_id ?? DEFAULT_AGENT_ID;
   const type = req.query.type;
   const mentioned_in = req.query.mentioned_in;
   const note_type = req.query.note_type;
   const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT4;
-  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET2;
+  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET3;
   const entities = listEntities({
     agent_id: agentId,
     type,
@@ -3272,12 +3732,18 @@ async function handleGetFeed(req) {
 }
 
 // src/daemon/api/symbionts.ts
-async function handleListSymbionts() {
+async function handleListSymbionts(vaultDir) {
   const manifests = loadManifests();
+  let enabledNames = null;
+  try {
+    enabledNames = getEnabledSymbiontNames(loadConfig(vaultDir));
+  } catch {
+  }
   const symbionts = manifests.map((m) => ({
     name: m.name,
     displayName: m.displayName,
     binary: m.binary,
+    enabled: enabledNames ? enabledNames.has(m.name) : true,
     ...m.resumeCommand ? { resumeCommand: m.resumeCommand } : {}
   }));
   return { body: { symbionts } };
@@ -3322,7 +3788,7 @@ async function handleEmbeddingReembedStale(manager) {
 }
 
 // src/daemon/embedding/manager.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var ACTIVE_STATUS = "active";
 var EmbeddingManager = class {
   constructor(vectorStore, embeddingProvider, recordSource, logger) {
@@ -3335,7 +3801,7 @@ var EmbeddingManager = class {
   // Private helpers
   // -------------------------------------------------------------------------
   contentHash(text) {
-    return createHash4(CONTENT_HASH_ALGORITHM).update(text).digest("hex");
+    return createHash3(CONTENT_HASH_ALGORITHM).update(text).digest("hex");
   }
   // -------------------------------------------------------------------------
   // Write-path event handlers
@@ -4513,200 +4979,559 @@ function testCloud() {
   return { ok: true };
 }
 
-// src/db/queries/skill-usage.ts
-var USAGE_COLUMNS = [
-  "id",
-  "skill_id",
-  "session_id",
-  "machine_id",
-  "detected_at"
-];
-var SELECT_COLUMNS4 = USAGE_COLUMNS.join(", ");
-function toUsageRow(row) {
+// src/daemon/task-scheduler.ts
+function resolveSchedule(yamlSchedule, configOverride) {
+  if (!configOverride?.schedule) return yamlSchedule;
   return {
-    id: row.id,
-    skill_id: row.skill_id,
-    session_id: row.session_id,
-    machine_id: row.machine_id ?? getTeamMachineId(),
-    detected_at: row.detected_at
+    enabled: configOverride.schedule.enabled ?? yamlSchedule.enabled,
+    intervalSeconds: configOverride.schedule.intervalSeconds ?? yamlSchedule.intervalSeconds,
+    runIn: configOverride.schedule.runIn ?? yamlSchedule.runIn,
+    preCondition: configOverride.schedule.preCondition ?? yamlSchedule.preCondition
   };
 }
-function insertSkillUsage(data) {
-  const db = getDatabase();
-  db.prepare(
-    `INSERT INTO skill_usage (
-       id, skill_id, session_id, machine_id, detected_at
-     ) VALUES (
-       ?, ?, ?, ?, ?
-     )`
-  ).run(
-    data.id,
-    data.skill_id,
-    data.session_id,
-    data.machine_id ?? getTeamMachineId(),
-    data.detected_at
-  );
-  const row = toUsageRow(
-    db.prepare(`SELECT ${SELECT_COLUMNS4} FROM skill_usage WHERE id = ?`).get(data.id)
-  );
-  return row;
-}
-function hasUsageForSkillAndSession(skillId, sessionId) {
-  const db = getDatabase();
-  const row = db.prepare(
-    `SELECT 1 FROM skill_usage WHERE skill_id = ? AND session_id = ? LIMIT 1`
-  ).get(skillId, sessionId);
-  return row !== void 0;
-}
-function countUsageForSkill(skillId) {
-  const db = getDatabase();
-  const row = db.prepare(
-    `SELECT COUNT(*) as count FROM skill_usage WHERE skill_id = ?`
-  ).get(skillId);
-  return row.count;
+function buildScheduledJobs(tasks, configOverrides, context, initialLastRuns) {
+  const jobs = [];
+  for (const task of tasks) {
+    if (!task.schedule) continue;
+    const override = configOverrides[task.name];
+    const effective = resolveSchedule(task.schedule, override);
+    if (!effective.enabled) continue;
+    let lastRun = initialLastRuns?.[task.name] ?? 0;
+    const intervalMs = effective.intervalSeconds * 1e3;
+    jobs.push({
+      name: `scheduled:${task.name}`,
+      runIn: effective.runIn,
+      fn: async () => {
+        if (!context) return;
+        if (context.isTaskRunning(task.name)) return;
+        if (Date.now() - lastRun < intervalMs) return;
+        if (effective.preCondition) {
+          const check = context.preConditions[effective.preCondition];
+          if (!check) return;
+          if (!check()) return;
+        }
+        try {
+          context.setTaskRunning(task.name, true);
+          await context.runTask(task.name);
+        } finally {
+          lastRun = Date.now();
+          context.setTaskRunning(task.name, false);
+        }
+      }
+    });
+  }
+  return jobs;
 }
 
-// src/daemon/api/skills.ts
-var DEFAULT_LIST_OFFSET3 = 0;
-async function handleListCandidates(req) {
-  const status = req.query.status || void 0;
-  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT;
-  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET3;
-  const { items: candidates, total } = listCandidatesWithCount({ status, limit, offset });
-  return { status: 200, body: { candidates, total } };
-}
-async function handleGetCandidate(req) {
-  const candidate = getCandidate(req.params.id);
-  if (!candidate) {
-    return { status: 404, body: { error: `Not found: ${req.params.id}` } };
+// src/agent/instruction-builders.ts
+var SKILL_GENERATE_TASK = "skill-generate";
+var SKILL_EVOLVE_TASK = "skill-evolve";
+function buildSkillGenerateInstruction() {
+  const candidates = listCandidates({ status: "approved", limit: 1 });
+  if (candidates.length === 0) return void 0;
+  const c = candidates[0];
+  const parts = [
+    `candidate_id: ${c.id}`,
+    `topic: ${c.topic}`,
+    `confidence: ${c.confidence}`,
+    `rationale: ${c.rationale}`,
+    "",
+    "## Source Material"
+  ];
+  let sourceIds = [];
+  try {
+    sourceIds = JSON.parse(c.source_ids || "[]");
+  } catch {
+  }
+  for (const src of sourceIds) {
+    if (src.type === "spore") {
+      const spore = getSpore(src.id);
+      if (spore) {
+        parts.push(`
+### Spore: ${src.id} (${spore.observation_type}, importance ${spore.importance})`);
+        parts.push(spore.content);
+        if (spore.context) parts.push(`Context: ${spore.context}`);
+        if (spore.tags) parts.push(`Tags: ${spore.tags}`);
+      }
+    } else if (src.type === "session") {
+      const session = getSession(src.id);
+      if (session) {
+        parts.push(`
+### Session: ${src.id}`);
+        if (session.title) parts.push(`Title: ${session.title}`);
+        if (session.summary) parts.push(session.summary);
+      }
+    }
   }
-  return { status: 200, body: { candidate } };
-}
-async function handleUpdateCandidate(req) {
-  const id = req.params.id;
-  const body = req.body;
-  if (!body) return { status: 400, body: { error: "Request body required" } };
-  const { status, topic, rationale, confidence, source_ids, skill_id } = body;
-  const updated = updateCandidate(id, {
-    ...status !== void 0 ? { status } : {},
-    ...topic !== void 0 ? { topic } : {},
-    ...rationale !== void 0 ? { rationale } : {},
-    ...confidence !== void 0 ? { confidence } : {},
-    ...source_ids !== void 0 ? { source_ids } : {},
-    ...skill_id !== void 0 ? { skill_id } : {},
-    updated_at: epochSeconds()
-  });
-  if (!updated) return { status: 404, body: { error: `Candidate not found: ${id}` } };
-  return { status: 200, body: { candidate: updated } };
+  return parts.join("\n");
 }
-async function handleListSkillRecords(req) {
-  const status = req.query.status || void 0;
-  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT;
-  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET3;
-  const { items: records, total } = listSkillRecordsWithCount({ status, limit, offset });
-  return { status: 200, body: { records, total } };
+var SKILL_EVOLVE_DEFAULT_ASSESS_INTERVAL_HOURS = 24;
+var SKILL_EVOLVE_DEFAULT_MAX_SKILLS_PER_RUN = 5;
+function buildSkillEvolveInstruction(params) {
+  const assessIntervalHours = Number(params?.assess_interval_hours ?? SKILL_EVOLVE_DEFAULT_ASSESS_INTERVAL_HOURS);
+  const maxSkillsPerRun = Number(params?.max_skills_per_run ?? SKILL_EVOLVE_DEFAULT_MAX_SKILLS_PER_RUN);
+  const now = epochSeconds();
+  const intervalSeconds = assessIntervalHours * 3600;
+  const allSkills = listSkillRecords({ status: "active", limit: 100 });
+  const needsAssessment = [];
+  for (const skill of allSkills) {
+    let props = {};
+    try {
+      props = JSON.parse(skill.properties || "{}");
+    } catch {
+      props = {};
+    }
+    const lastAssessedAt = typeof props.last_assessed_at === "number" ? props.last_assessed_at : 0;
+    const knowledgeWatermark = typeof props.knowledge_watermark === "number" ? props.knowledge_watermark : 0;
+    if (lastAssessedAt > 0 && now - lastAssessedAt < intervalSeconds) continue;
+    const newSporeIds = listSporeIdsSince(knowledgeWatermark, 10);
+    if (newSporeIds.length === 0) continue;
+    const lineage = listLineageForSkill(skill.id, 1);
+    if (lineage.length === 0) continue;
+    needsAssessment.push({
+      id: skill.id,
+      name: skill.name,
+      generation: skill.generation,
+      description: skill.description,
+      contentSnapshot: lineage[0].content_snapshot,
+      newSporeIds
+    });
+    if (needsAssessment.length >= maxSkillsPerRun) {
+      break;
+    }
+  }
+  if (needsAssessment.length === 0) {
+    return "No skills need assessment. All active skills are current or were recently assessed. Report skip via vault_report and finish.";
+  }
+  const parts = [
+    `${needsAssessment.length} skill(s) need assessment.`,
+    `assess_interval_hours: ${assessIntervalHours}`,
+    `max_skills_per_run: ${maxSkillsPerRun}`
+  ];
+  for (const skill of needsAssessment) {
+    parts.push("");
+    parts.push("---");
+    parts.push(`## Skill: ${skill.name} (gen ${skill.generation})`);
+    parts.push(`id: ${skill.id}`);
+    parts.push(`description: ${skill.description}`);
+    parts.push(`new_spore_ids: ${JSON.stringify(skill.newSporeIds)}`);
+    parts.push("");
+    parts.push("### Current Content");
+    parts.push("");
+    parts.push(skill.contentSnapshot);
+  }
+  return parts.join("\n");
+}
+function buildTaskInstruction(taskName, taskParams) {
+  switch (taskName) {
+    case SKILL_GENERATE_TASK:
+      return buildSkillGenerateInstruction();
+    case SKILL_EVOLVE_TASK:
+      return buildSkillEvolveInstruction(taskParams);
+    default:
+      return void 0;
+  }
 }
-async function handleGetSkillRecord(req) {
-  const idOrName = req.params.id;
-  const record = getSkillRecord(idOrName) ?? getSkillRecordByName(idOrName);
-  if (!record) {
-    return { status: 404, body: { error: `Not found: ${idOrName}` } };
+
+// src/daemon/task-scheduling.ts
+async function registerScheduledTasks(powerManager, deps) {
+  const { definitionsDir, vaultDir, embeddingManager, logger, config } = deps;
+  const runningTasks = /* @__PURE__ */ new Set();
+  if (!definitionsDir) {
+    logger.warn(LOG_KINDS.AGENT_ERROR, "Skipping dynamic task scheduling \u2014 definitions directory unavailable");
+    return;
+  }
+  if (config.agent.scheduled_tasks_enabled === false) {
+    logger.info(LOG_KINDS.AGENT_RUN, "Scheduled agent tasks disabled globally (agent.scheduled_tasks_enabled: false)");
+    return;
+  }
+  const { loadAllTasks: loadAllTasks2 } = await import("./registry-DHWVHXWY.js");
+  const allTasks = Array.from(loadAllTasks2(definitionsDir, vaultDir).values());
+  const initialLastRuns = {};
+  try {
+    const recentRuns = getDatabase().prepare(
+      `SELECT task, MAX(completed_at) as last_completed
+       FROM agent_runs
+       WHERE status IN ('completed', 'failed') AND completed_at IS NOT NULL
+       GROUP BY task`
+    ).all();
+    for (const row of recentRuns) {
+      initialLastRuns[row.task] = row.last_completed * 1e3;
+    }
+  } catch {
   }
-  const lineage = listLineageForSkill(record.id);
-  const usage_total = countUsageForSkill(record.id);
-  const latestSnapshot = lineage[0]?.content_snapshot;
-  const frontmatterFields = {};
-  if (latestSnapshot) {
-    const fmMatch = latestSnapshot.match(/^---\n([\s\S]*?)\n---/);
-    if (fmMatch) {
-      for (const line of fmMatch[1].split("\n")) {
-        const colonIdx = line.indexOf(":");
-        if (colonIdx > 0) {
-          const key = line.slice(0, colonIdx).trim();
-          const val = line.slice(colonIdx + 1).trim();
-          if (key && val) frontmatterFields[key] = val;
+  const scheduledContext = {
+    isTaskRunning: (name) => runningTasks.has(name),
+    setTaskRunning: (name, running) => {
+      if (running) runningTasks.add(name);
+      else runningTasks.delete(name);
+    },
+    runTask: async (taskName) => {
+      const { runAgent } = await import("./executor-4OXDK4ZA.js");
+      const taskConfig = config.agent.tasks?.[taskName];
+      const instruction = buildTaskInstruction(taskName, taskConfig?.params);
+      const result = await runAgent(vaultDir, { task: taskName, instruction, embeddingManager });
+      logger.info(LOG_KINDS.AGENT_RUN, `Scheduled task ${taskName} completed`, {
+        status: result.status,
+        runId: result.runId
+      });
+      if (result.status === "failed") {
+        notify(vaultDir, {
+          domain: "agents",
+          type: "agent.task.failure",
+          title: `Task failed: ${taskName}`,
+          message: result.error ?? "Unknown error",
+          link: `/agent?run=${result.runId}`,
+          metadata: { taskName, runId: result.runId }
+        }, config);
+      } else if (result.status === "completed") {
+        notify(vaultDir, {
+          domain: "agents",
+          type: "agent.task.success",
+          title: `Task completed: ${taskName}`,
+          link: `/agent?run=${result.runId}`,
+          metadata: { taskName, runId: result.runId }
+        }, config);
+        const { countToolCallsByRun } = await import("./turns-3ZQAF6HF.js");
+        const counts = countToolCallsByRun(result.runId, ["vault_create_spore", "vault_write_digest"]);
+        const sporeCount = counts["vault_create_spore"] ?? 0;
+        const digestCount = counts["vault_write_digest"] ?? 0;
+        if (sporeCount > 0) {
+          notify(vaultDir, {
+            domain: "mycelium",
+            type: "mycelium.spore.created",
+            title: sporeCount === 1 ? "Extracted 1 observation" : `Extracted ${sporeCount} observations`,
+            message: `From ${taskName} run`,
+            link: "/mycelium?tab=spores",
+            metadata: { count: sporeCount, taskName, runId: result.runId }
+          }, config);
         }
+        if (digestCount > 0) {
+          notify(vaultDir, {
+            domain: "mycelium",
+            type: "mycelium.digest.completed",
+            title: `Digest updated (${digestCount} ${digestCount === 1 ? "tier" : "tiers"})`,
+            link: "/mycelium?tab=digest",
+            metadata: { tierCount: digestCount, taskName, runId: result.runId }
+          }, config);
+        }
+      }
+    },
+    preConditions: {
+      "has-unprocessed-batches": () => {
+        const row = getDatabase().prepare(
+          "SELECT 1 FROM prompt_batches WHERE processed = 0 LIMIT 1"
+        ).get();
+        return row !== void 0;
+      },
+      "has-active-skills": () => {
+        return countSkillRecords({ status: "active" }) > 0;
+      },
+      "has-approved-candidates": () => {
+        return countCandidates({ status: "approved" }) > 0;
       }
     }
+  };
+  const scheduledJobs = buildScheduledJobs(
+    allTasks,
+    config.agent.tasks ?? {},
+    scheduledContext,
+    initialLastRuns
+  );
+  for (const job of scheduledJobs) {
+    powerManager.register(job);
   }
-  return { status: 200, body: { ...record, lineage, usage_total, frontmatter: frontmatterFields } };
+  logger.info(LOG_KINDS.DAEMON_START, `Registered ${scheduledJobs.length} scheduled task(s)`, {
+    tasks: scheduledJobs.map((j) => j.name)
+  });
 }
-async function handleDeleteCandidate(req) {
-  const id = req.params.id;
-  const deleted = deleteCandidate(id);
-  if (!deleted) return { status: 404, body: { error: `Not found: ${id}` } };
-  return { status: 200, body: { deleted: true, id } };
+
+// src/db/queries/team-members.ts
+function listTeamMembers() {
+  return getDatabase().prepare(
+    `SELECT id, "user", role, joined, tags
+     FROM team_members
+     ORDER BY id ASC`
+  ).all();
 }
-async function handleDeleteSkillRecord(req) {
-  const idOrName = req.params.id;
-  const result = deleteSkillRecordCascade(idOrName);
-  if (!result) return { status: 404, body: { error: `Not found: ${idOrName}` } };
-  if (isTeamSyncEnabled()) {
+
+// src/daemon/api/mcp-proxy.ts
+var SPORE_ID_RANDOM_BYTES = 4;
+var RESOLUTION_ID_RANDOM_BYTES = 8;
+var RememberBody = external_exports.object({
+  content: external_exports.string(),
+  type: external_exports.string().optional(),
+  tags: external_exports.array(external_exports.string()).optional()
+});
+var SupersedeBody = external_exports.object({
+  old_spore_id: external_exports.string(),
+  new_spore_id: external_exports.string(),
+  reason: external_exports.string().optional()
+});
+function createMcpProxyHandlers(deps) {
+  const { machineId, embeddingManager } = deps;
+  async function handleRemember(req) {
+    const { content, type, tags } = RememberBody.parse(req.body);
+    const { randomBytes } = await import("crypto");
+    const observationType = type ?? "discovery";
+    const id = `${observationType}-${randomBytes(SPORE_ID_RANDOM_BYTES).toString("hex")}`;
+    const now = epochSeconds();
+    registerAgent({
+      id: USER_AGENT_ID,
+      name: USER_AGENT_NAME,
+      created_at: now
+    });
+    const spore = insertSpore({
+      id,
+      agent_id: USER_AGENT_ID,
+      machine_id: machineId,
+      observation_type: observationType,
+      content,
+      tags: tags ? tags.join(", ") : null,
+      created_at: now
+    });
+    embeddingManager.onContentWritten("spores", spore.id, content, {
+      status: "active",
+      observation_type: observationType
+    }).catch(() => {
+    });
+    return {
+      body: {
+        id: spore.id,
+        observation_type: spore.observation_type,
+        status: spore.status,
+        created_at: spore.created_at
+      }
+    };
+  }
+  async function handleSupersede(req) {
+    const { old_spore_id, new_spore_id, reason } = SupersedeBody.parse(req.body);
+    const { randomBytes } = await import("crypto");
+    const now = epochSeconds();
+    updateSporeStatus(old_spore_id, "superseded", now);
     try {
-      enqueueOutbox({
-        table_name: "skill_records",
-        row_id: result.id,
-        operation: "delete",
-        payload: JSON.stringify({ id: result.id, name: result.name }),
-        machine_id: getTeamMachineId(),
-        created_at: epochSeconds()
+      embeddingManager.onStatusChanged("spores", old_spore_id, "superseded");
+    } catch {
+    }
+    registerAgent({
+      id: USER_AGENT_ID,
+      name: USER_AGENT_NAME,
+      created_at: now
+    });
+    const { insertResolutionEvent } = await import("./resolution-events-DBCRVZGU.js");
+    const resolutionId = `res-${randomBytes(RESOLUTION_ID_RANDOM_BYTES).toString("hex")}`;
+    insertResolutionEvent({
+      id: resolutionId,
+      agent_id: USER_AGENT_ID,
+      machine_id: machineId,
+      spore_id: old_spore_id,
+      action: "supersede",
+      new_spore_id,
+      reason: reason ?? null,
+      created_at: now
+    });
+    return {
+      body: {
+        old_spore: old_spore_id,
+        new_spore: new_spore_id,
+        status: "superseded"
+      }
+    };
+  }
+  async function handlePlans(req) {
+    const statusFilter = req.query.status === "all" ? void 0 : req.query.status;
+    const limit = req.query.limit ? Number(req.query.limit) : void 0;
+    const rows = listPlans({ status: statusFilter, limit });
+    const plans = rows.map((row) => {
+      const content = row.content ?? "";
+      const checked = (content.match(/- \[x\]/gi) ?? []).length;
+      const unchecked = (content.match(/- \[ \]/g) ?? []).length;
+      const total = checked + unchecked;
+      const progress = total === 0 ? "N/A" : `${checked}/${total}`;
+      return {
+        id: row.id,
+        title: row.title,
+        status: row.status,
+        progress,
+        tags: row.tags ? row.tags.split(",").map((t) => t.trim()) : [],
+        created_at: row.created_at
+      };
+    });
+    return { body: { plans } };
+  }
+  async function handleSessions(req) {
+    const limit = req.query.limit ? Number(req.query.limit) : 20;
+    const status = req.query.status;
+    const rows = listSessions({ limit, status });
+    const sessions = rows.map((row) => ({
+      id: row.id,
+      agent: row.agent,
+      user: row.user,
+      branch: row.branch,
+      started_at: row.started_at,
+      ended_at: row.ended_at,
+      status: row.status,
+      title: row.title,
+      summary: (row.summary ?? "").slice(0, 300),
+      prompt_count: row.prompt_count,
+      tool_count: row.tool_count,
+      parent_session_id: row.parent_session_id
+    }));
+    return { body: { sessions } };
+  }
+  async function handleTeam(_req) {
+    const rows = listTeamMembers();
+    const members = rows.map((row) => ({
+      id: row.id,
+      user: row.user,
+      role: row.role,
+      joined: row.joined,
+      tags: row.tags ? row.tags.split(",").map((t) => t.trim()) : []
+    }));
+    return { body: { members } };
+  }
+  return {
+    handleRemember,
+    handleSupersede,
+    handlePlans,
+    handleSessions,
+    handleTeam
+  };
+}
+
+// src/daemon/api/agent-runs.ts
+var AGENT_RUNS_DEFAULT_LIMIT = 50;
+var AgentRunBody = external_exports.object({
+  task: external_exports.string().optional(),
+  instruction: external_exports.string().optional(),
+  agentId: external_exports.string().optional()
+});
+function createAgentRunHandlers(deps) {
+  const { vaultDir, embeddingManager, logger } = deps;
+  async function handleRun(req) {
+    const { task, instruction: rawInstruction, agentId } = AgentRunBody.parse(req.body);
+    let instruction = rawInstruction;
+    if (task && !instruction) {
+      try {
+        const mycoConfig = loadConfig(vaultDir);
+        const taskParams = mycoConfig.agent.tasks?.[task]?.params;
+        instruction = buildTaskInstruction(task, taskParams);
+      } catch {
+        instruction = buildTaskInstruction(task);
+      }
+    }
+    const { runAgent } = await import("./executor-4OXDK4ZA.js");
+    const resultPromise = runAgent(vaultDir, { task, instruction, agentId, embeddingManager });
+    const effectiveAgentId = agentId ?? "myco-agent";
+    const runId = getLatestRunId(effectiveAgentId, task);
+    resultPromise.then((result) => {
+      if (result.status === "failed") {
+        logger.error(LOG_KINDS.AGENT_ERROR, "Agent run failed", {
+          runId: result.runId,
+          error: result.error ?? "No error message",
+          phases: result.phases?.map((p) => `${p.name}:${p.status}`) ?? []
+        });
+      } else {
+        logger.info(LOG_KINDS.AGENT_RUN, "Agent run completed", {
+          runId: result.runId,
+          status: result.status,
+          phases: result.phases?.map((p) => `${p.name}:${p.status}`) ?? []
+        });
+      }
+    }).catch((err) => {
+      logger.error(LOG_KINDS.AGENT_ERROR, "Agent run threw unhandled error", {
+        error: err.message ?? String(err),
+        stack: err.stack?.split("\n").slice(0, 3).join(" | ")
       });
-    } catch (err) {
-      console.warn("[team-sync] Failed to enqueue skill record deletion:", err instanceof Error ? err.message : err);
+    });
+    return { body: { ok: true, message: "Agent started", runId } };
+  }
+  async function handleListRuns(req) {
+    const limit = req.query.limit ? Number(req.query.limit) : AGENT_RUNS_DEFAULT_LIMIT;
+    const offset = req.query.offset ? Number(req.query.offset) : 0;
+    const agentId = req.query.agentId || void 0;
+    const status = req.query.status || void 0;
+    const task = req.query.task || void 0;
+    const search = req.query.search || void 0;
+    const filterOpts = { agent_id: agentId, status, task, search };
+    const runs = listRuns({ ...filterOpts, limit, offset });
+    const total = countRuns(filterOpts);
+    return { body: { runs, total, offset, limit } };
+  }
+  async function handleGetRun(req) {
+    const run = getRun(req.params.id);
+    if (!run) {
+      return { status: 404, body: { error: "Run not found" } };
     }
+    return { body: { run } };
+  }
+  async function handleGetRunReports(req) {
+    const reports = listReports(req.params.id);
+    return { body: { reports } };
+  }
+  async function handleGetRunTurns(req) {
+    const turns = listTurnsByRun(req.params.id);
+    return { body: turns };
   }
-  return { status: 200, body: { deleted: true, id: result.id, name: result.name } };
+  return {
+    handleRun,
+    handleListRuns,
+    handleGetRun,
+    handleGetRunReports,
+    handleGetRunTurns
+  };
 }
 
-// src/daemon/skill-usage.ts
-import crypto from "crypto";
-var SKILL_USAGE_DETECTION_ENABLED = false;
-var MAX_ACTIVE_SKILLS_CHECK = 1e3;
-function detectSkillUsage(sessionId, transcriptContent) {
-  if (transcriptContent.includes("vault_write_skill")) return;
-  if (!SKILL_USAGE_DETECTION_ENABLED) return;
-  const activeSkills = listSkillRecords({ status: "active", limit: MAX_ACTIVE_SKILLS_CHECK });
-  if (activeSkills.length === 0) return;
-  const skillPatterns = activeSkills.map((skill) => ({
-    skill,
-    pattern: new RegExp(
-      `skills/${escapeRegex(skill.name)}/SKILL\\.md|<skill[^>]*name=["']${escapeRegex(skill.name)}["']`
-    )
-  }));
-  const now = epochSeconds();
-  for (const { skill, pattern } of skillPatterns) {
+// src/daemon/api/attachments.ts
+import fs13 from "fs";
+import path15 from "path";
+var ATTACHMENT_MEDIA_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp"
+};
+function createAttachmentHandler(deps) {
+  const { vaultDir } = deps;
+  async function handleGetAttachment(req) {
+    const filename = req.params.filename;
+    if (filename.includes("..") || filename.includes("/")) {
+      return { status: 400, body: { error: "invalid_filename" } };
+    }
+    const att = getAttachmentByFilePath(filename);
+    if (att?.data) {
+      const contentType2 = att.media_type ?? "application/octet-stream";
+      return { status: 200, headers: { "Content-Type": contentType2 }, body: att.data };
+    }
+    const filePath = path15.join(vaultDir, "attachments", filename);
+    let diskData;
     try {
-      if (!pattern.test(transcriptContent)) continue;
-      if (hasUsageForSkillAndSession(skill.id, sessionId)) continue;
-      insertSkillUsage({
-        id: crypto.randomUUID(),
-        skill_id: skill.id,
-        session_id: sessionId,
-        detected_at: now
-      });
-      incrementSkillUsageCount(skill.id, now);
+      diskData = fs13.readFileSync(filePath);
     } catch {
+      return { status: 404, body: { error: "not_found" } };
     }
+    const ext = path15.extname(filename).slice(1).toLowerCase();
+    const contentType = ATTACHMENT_MEDIA_TYPES[ext] ?? "application/octet-stream";
+    return { status: 200, headers: { "Content-Type": contentType }, body: diskData };
   }
-}
-function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return { handleGetAttachment };
 }
 
 // src/daemon/log-reconcile.ts
-import fs12 from "fs";
-import path14 from "path";
+import fs14 from "fs";
+import path16 from "path";
 function reconcileLogBuffer(logDir, sinceTimestamp) {
   let replayed = 0;
   const files = [];
   for (let i = 3; i >= 1; i--) {
-    const rotated = path14.join(logDir, `daemon.${i}.log`);
-    if (fs12.existsSync(rotated)) files.push(rotated);
+    const rotated = path16.join(logDir, `daemon.${i}.log`);
+    if (fs14.existsSync(rotated)) files.push(rotated);
   }
-  const current = path14.join(logDir, "daemon.log");
-  if (fs12.existsSync(current)) files.push(current);
+  const current = path16.join(logDir, "daemon.log");
+  if (fs14.existsSync(current)) files.push(current);
   for (const file of files) {
-    const content = fs12.readFileSync(file, "utf-8");
+    const content = fs14.readFileSync(file, "utf-8");
     for (const line of content.split("\n")) {
       if (!line.trim()) continue;
       try {
@@ -4740,6 +5565,7 @@ var PowerManager = class {
   running = false;
   config;
   logger;
+  deepSleepHeld = false;
   constructor(config) {
     this.config = config;
     this.logger = config.logger;
@@ -4749,6 +5575,7 @@ var PowerManager = class {
   }
   recordActivity() {
     this.lastActivity = Date.now();
+    this.deepSleepHeld = false;
     if (this.state === "deep_sleep") {
       this.logger.info(LOG_KINDS.POWER_STATE, "Waking from deep sleep");
       this.state = "active";
@@ -4780,7 +5607,17 @@ var PowerManager = class {
     const idleMs = Date.now() - this.lastActivity;
     let target;
     if (idleMs >= this.config.deepSleepThresholdMs) {
-      target = "deep_sleep";
+      const blocker = this.jobs.find((j) => j.preventsDeepSleep?.());
+      if (blocker) {
+        target = "sleep";
+        if (!this.deepSleepHeld) {
+          this.deepSleepHeld = true;
+          this.logger.info(LOG_KINDS.POWER_STATE, "Deep sleep held", { by: blocker.name });
+        }
+      } else {
+        target = "deep_sleep";
+        this.deepSleepHeld = false;
+      }
     } else if (idleMs >= this.config.sleepThresholdMs) {
       target = "sleep";
     } else if (idleMs >= this.config.idleThresholdMs) {
@@ -4829,87 +5666,6 @@ var PowerManager = class {
   }
 };
 
-// src/daemon/task-scheduler.ts
-function resolveSchedule(yamlSchedule, configOverride) {
-  if (!configOverride?.schedule) return yamlSchedule;
-  return {
-    enabled: configOverride.schedule.enabled ?? yamlSchedule.enabled,
-    intervalSeconds: configOverride.schedule.intervalSeconds ?? yamlSchedule.intervalSeconds,
-    runIn: configOverride.schedule.runIn ?? yamlSchedule.runIn,
-    preCondition: configOverride.schedule.preCondition ?? yamlSchedule.preCondition
-  };
-}
-function buildScheduledJobs(tasks, configOverrides, context, initialLastRuns) {
-  const jobs = [];
-  for (const task of tasks) {
-    if (!task.schedule) continue;
-    const override = configOverrides[task.name];
-    const effective = resolveSchedule(task.schedule, override);
-    if (!effective.enabled) continue;
-    let lastRun = initialLastRuns?.[task.name] ?? 0;
-    const intervalMs = effective.intervalSeconds * 1e3;
-    jobs.push({
-      name: `scheduled:${task.name}`,
-      runIn: effective.runIn,
-      fn: async () => {
-        if (!context) return;
-        if (context.isTaskRunning(task.name)) return;
-        if (Date.now() - lastRun < intervalMs) return;
-        if (effective.preCondition) {
-          const check = context.preConditions[effective.preCondition];
-          if (!check) return;
-          if (!check()) return;
-        }
-        try {
-          context.setTaskRunning(task.name, true);
-          await context.runTask(task.name);
-        } finally {
-          lastRun = Date.now();
-          context.setTaskRunning(task.name, false);
-        }
-      }
-    });
-  }
-  return jobs;
-}
-
-// src/daemon/jobs/session-cleanup.ts
-import { unlink, glob } from "fs/promises";
-async function cleanupAfterSessionCascade(sessionId, result, embeddingManager, vaultDir) {
-  try {
-    embeddingManager.onRemoved("sessions", sessionId);
-  } catch {
-  }
-  for (const sporeId of result.deletedSporeIds) {
-    try {
-      embeddingManager.onRemoved("spores", sporeId);
-    } catch {
-    }
-  }
-  try {
-    for await (const f of glob(`sessions/**/session-${sessionId}.md`, { cwd: vaultDir })) {
-      await unlink(`${vaultDir}/${f}`).catch(() => {
-      });
-    }
-  } catch {
-  }
-  for (const sporeId of result.deletedSporeIds) {
-    try {
-      for await (const f of glob(`spores/**/${sporeId}*.md`, { cwd: vaultDir })) {
-        await unlink(`${vaultDir}/${f}`).catch(() => {
-        });
-      }
-    } catch {
-    }
-  }
-  for (const filePath of result.deletedAttachmentPaths) {
-    try {
-      await unlink(filePath);
-    } catch {
-    }
-  }
-}
-
 // src/daemon/jobs/session-maintenance.ts
 var STALE_SESSION_THRESHOLD_S = STALE_SESSION_THRESHOLD_MS / MS_PER_SECOND;
 function completeStaleActiveSessions(registeredSessionIds) {
@@ -4965,11 +5721,65 @@ async function runSessionMaintenance(deps) {
   }
 }
 
-// src/daemon/main.ts
-import fs13 from "fs";
-import os8 from "os";
-import path15 from "path";
-var AGENT_RUNS_DEFAULT_LIMIT = 50;
+// src/daemon/power-jobs.ts
+function registerPowerJobs(powerManager, deps) {
+  const { embeddingManager, registry, logger, config, db, backupDir, machineId, vaultDir } = deps;
+  let reconcileRunning = false;
+  powerManager.register({
+    name: "embedding-reconcile",
+    runIn: ["active", "idle"],
+    fn: async () => {
+      if (reconcileRunning) return;
+      reconcileRunning = true;
+      try {
+        await embeddingManager.reconcile(EMBEDDING_BATCH_SIZE);
+      } finally {
+        reconcileRunning = false;
+      }
+    }
+  });
+  powerManager.register({
+    name: "session-maintenance",
+    runIn: ["active", "idle", "sleep"],
+    fn: () => runSessionMaintenance({
+      logger,
+      registeredSessionIds: () => registry.sessions,
+      embeddingManager,
+      vaultDir
+    })
+  });
+  powerManager.register({
+    name: "log-retention",
+    runIn: ["idle", "sleep"],
+    fn: async () => {
+      const retentionDays = config.daemon.log_retention_days;
+      const cutoff = new Date(Date.now() - retentionDays * MS_PER_DAY).toISOString();
+      const deleted = deleteOldLogs(cutoff);
+      if (deleted > 0) {
+        logger.info(LOG_KINDS.LOG_RETENTION, `Deleted ${deleted} log entries older than ${retentionDays} days`, { deleted, retention_days: retentionDays });
+      }
+    }
+  });
+  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 });
+      }
+    }
+  });
+}
+
+// src/daemon/reconciliation.ts
+import fs15 from "fs";
+import path17 from "path";
+
+// src/daemon/event-handlers.ts
 var TOOL_INPUT_STORE_LIMIT = 4e3;
 var TOOL_OUTPUT_STORE_LIMIT = 2e3;
 var TITLE_PREVIEW_CHARS = 80;
@@ -4981,7 +5791,6 @@ function isSystemMessage(prompt) {
   const trimmed = prompt.trimStart();
   return SYSTEM_MESSAGE_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
 }
-var REPLAYABLE_EVENT_TYPES = /* @__PURE__ */ new Set(["user_prompt", "tool_use", "tool_failure"]);
 function handleUserPrompt(sessionId, prompt) {
   const now = epochSeconds();
   closeOpenBatches(sessionId, now);
@@ -5069,179 +5878,218 @@ function handleStopFailure(sessionId, error, errorDetails) {
     tool_output_summary: errorDetails?.slice(0, TOOL_OUTPUT_STORE_LIMIT) ?? null,
     success: 0,
     error_message: error?.slice(0, TOOL_OUTPUT_STORE_LIMIT) ?? null,
-    timestamp: now,
-    created_at: now
-  });
-}
-function handleTaskCompleted(sessionId, taskId, taskSubject, taskDescription) {
-  const now = epochSeconds();
-  insertActivityWithBatch({
-    session_id: sessionId,
-    tool_name: "task_completed",
-    tool_input: JSON.stringify({ task_id: taskId, task_subject: taskSubject, task_description: taskDescription }).slice(0, TOOL_INPUT_STORE_LIMIT),
-    tool_output_summary: taskSubject?.slice(0, TOOL_OUTPUT_STORE_LIMIT) ?? null,
-    timestamp: now,
-    created_at: now
-  });
-}
-function handleCompact(sessionId, phase, trigger, compactSummary) {
-  const now = epochSeconds();
-  insertActivityWithBatch({
-    session_id: sessionId,
-    tool_name: `${phase}_compact`,
-    tool_input: trigger ? JSON.stringify({ trigger }).slice(0, TOOL_INPUT_STORE_LIMIT) : null,
-    tool_output_summary: compactSummary?.slice(0, TOOL_OUTPUT_STORE_LIMIT) ?? null,
-    timestamp: now,
-    created_at: now
-  });
-}
-function killStaleDaemon(vaultDir, logger) {
-  const daemonJsonPath = path15.join(vaultDir, "daemon.json");
-  try {
-    if (!fs13.existsSync(daemonJsonPath)) return;
-    const info = JSON.parse(fs13.readFileSync(daemonJsonPath, "utf-8"));
-    if (!info.pid) return;
-    if (info.pid === process.pid) return;
-    try {
-      process.kill(info.pid, 0);
-      process.kill(info.pid, "SIGTERM");
-      logger.info(LOG_KINDS.DAEMON_START, "Killed stale daemon", { pid: info.pid });
-    } catch {
-    }
-    fs13.unlinkSync(daemonJsonPath);
-  } catch {
-  }
-}
-async function main() {
-  const vaultArg = process.argv.find((_, i) => process.argv[i - 1] === "--vault");
-  if (!vaultArg) {
-    process.stderr.write("Usage: mycod --vault <path>\n");
-    process.exit(1);
-  }
-  const vaultDir = path15.resolve(vaultArg);
-  loadSecrets(vaultDir);
-  const config = loadConfig(vaultDir);
-  const manifests = loadManifests();
-  const symbiontPlanDirs = manifests.flatMap((m) => m.capture?.planDirs ?? []);
-  const projectRoot = process.cwd();
-  let planWatchConfig = {
-    watchDirs: [.../* @__PURE__ */ new Set([...symbiontPlanDirs, ...config.capture.plan_dirs ?? []])],
-    projectRoot,
-    extensions: config.capture.artifact_extensions
-  };
-  const logger = new DaemonLogger(path15.join(vaultDir, "logs"), {
-    level: config.daemon.log_level
-  });
-  killStaleDaemon(vaultDir, logger);
-  logger.info(LOG_KINDS.DAEMON_CONFIG, "Config loaded", {
-    vault: vaultDir,
-    embedding_provider: config.embedding.provider
+    timestamp: now,
+    created_at: now
   });
-  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, machineId);
-  registerBuiltinDomains();
-  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({
-      timestamp,
-      level,
-      kind,
-      component,
-      message,
-      data: Object.keys(rest).length > 0 ? JSON.stringify(rest) : null,
-      session_id: rest.session_id ?? null
-    });
+}
+function handleTaskCompleted(sessionId, taskId, taskSubject, taskDescription) {
+  const now = epochSeconds();
+  insertActivityWithBatch({
+    session_id: sessionId,
+    tool_name: "task_completed",
+    tool_input: JSON.stringify({ task_id: taskId, task_subject: taskSubject, task_description: taskDescription }).slice(0, TOOL_INPUT_STORE_LIMIT),
+    tool_output_summary: taskSubject?.slice(0, TOOL_OUTPUT_STORE_LIMIT) ?? null,
+    timestamp: now,
+    created_at: now
   });
-  const lastLogTimestamp = getMaxTimestamp();
-  if (lastLogTimestamp) {
-    const logDir = path15.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 });
+}
+function handleCompact(sessionId, phase, trigger, compactSummary) {
+  const now = epochSeconds();
+  insertActivityWithBatch({
+    session_id: sessionId,
+    tool_name: `${phase}_compact`,
+    tool_input: trigger ? JSON.stringify({ trigger }).slice(0, TOOL_INPUT_STORE_LIMIT) : null,
+    tool_output_summary: compactSummary?.slice(0, TOOL_OUTPUT_STORE_LIMIT) ?? null,
+    timestamp: now,
+    created_at: now
+  });
+}
+
+// src/daemon/reconciliation.ts
+var REPLAYABLE_EVENT_TYPES = /* @__PURE__ */ new Set(["user_prompt", "tool_use", "tool_failure"]);
+function createReconciler({ bufferDir, logger }) {
+  const reconciledSessions = /* @__PURE__ */ new Set();
+  function replayEvent(sessionId, event) {
+    if (event.type === "user_prompt") {
+      if (isSystemMessage(String(event.prompt ?? ""))) return null;
+      handleUserPrompt(sessionId, String(event.prompt ?? ""));
+      return "prompt";
     }
+    if (event.type === "tool_use") {
+      handleToolUse(
+        sessionId,
+        String(event.tool_name ?? ""),
+        event.tool_input,
+        typeof event.output_preview === "string" ? event.output_preview : void 0
+      );
+      return "activity";
+    }
+    if (event.type === "tool_failure") {
+      handleToolFailure(
+        sessionId,
+        String(event.tool_name ?? ""),
+        event.tool_input,
+        typeof event.error === "string" ? event.error : void 0,
+        !!event.is_interrupt
+      );
+      return "activity";
+    }
+    return null;
   }
-  const vectorsDbPath = path15.join(vaultDir, "vectors.db");
-  const vectorStore = new SqliteVecVectorStore(vectorsDbPath);
-  const llmProvider = createEmbeddingProvider(config.embedding);
-  const embeddingProvider = new EmbeddingProviderAdapter(llmProvider, config.embedding);
-  const recordSource = new SqliteRecordSource();
-  const embeddingManager = new EmbeddingManager(vectorStore, embeddingProvider, recordSource, logger);
-  logger.info(LOG_KINDS.EMBEDDING_EMBED, "EmbeddingManager initialized", { vectors_db: vectorsDbPath });
-  let definitionsDir;
-  try {
-    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-WQKVWL5D.js");
-    definitionsDir = resolveDefinitionsDir2();
-    await registerBuiltInAgentsAndTasks(definitionsDir, vaultDir);
-    logger.info(LOG_KINDS.AGENT_TASK, "Built-in agents and tasks registered");
-  } catch (err) {
-    logger.warn(LOG_KINDS.AGENT_ERROR, "Failed to register built-in agents/tasks", { error: err.message });
-  }
-  try {
-    const staleDb = getDatabase();
-    const staleRows = staleDb.prepare(
-      `SELECT id FROM agent_runs WHERE status = 'running'`
-    ).all();
-    if (staleRows.length > 0) {
-      staleDb.prepare(
-        `UPDATE agent_runs SET status = 'failed', completed_at = ?, error = 'Daemon restarted while run was in progress' WHERE status = 'running'`
-      ).run(epochSeconds());
-      logger.info(LOG_KINDS.AGENT_RUN, "Cleaned stale running agent runs", {
-        count: staleRows.length,
-        ids: staleRows.map((r) => r.id)
+  function reconcileSession(sessionId) {
+    if (reconciledSessions.has(sessionId)) return;
+    reconciledSessions.add(sessionId);
+    const bufferPath = path17.join(bufferDir, `${sessionId}.jsonl`);
+    let content;
+    try {
+      content = fs15.readFileSync(bufferPath, "utf-8").trim();
+    } catch {
+      return;
+    }
+    if (!content) return;
+    if (!getSession(sessionId)) {
+      logger.debug(LOG_KINDS.LIFECYCLE_RECONCILE, "Skipping reconciliation for deleted session", { session_id: sessionId });
+      return;
+    }
+    const allEvents = content.split("\n").map((line) => JSON.parse(line));
+    const existingBatchCount = listBatchesBySession(sessionId).length;
+    let promptsSeen = 0;
+    let replayStartIndex = -1;
+    for (let i = 0; i < allEvents.length; i++) {
+      const e = allEvents[i];
+      if (e.type === "user_prompt" && !isSystemMessage(String(e.prompt ?? ""))) {
+        promptsSeen++;
+        if (promptsSeen === existingBatchCount + 1) {
+          replayStartIndex = i;
+          break;
+        }
+      }
+    }
+    if (replayStartIndex === -1) return;
+    const eventsToReplay = allEvents.slice(replayStartIndex).filter(
+      (e) => REPLAYABLE_EVENT_TYPES.has(String(e.type))
+    );
+    let promptsRecovered = 0;
+    let activitiesRecovered = 0;
+    for (const event of eventsToReplay) {
+      try {
+        const result = replayEvent(sessionId, event);
+        if (result === "prompt") promptsRecovered++;
+        else if (result === "activity") activitiesRecovered++;
+      } catch (err) {
+        logger.warn(LOG_KINDS.LIFECYCLE_RECONCILE, "Reconciliation: failed to replay event", {
+          type: String(event.type),
+          error: String(err)
+        });
+      }
+    }
+    if (promptsRecovered > 0 || activitiesRecovered > 0) {
+      logger.info(LOG_KINDS.LIFECYCLE_RECONCILE, "Buffer reconciliation complete", {
+        session_id: sessionId,
+        prompts_recovered: promptsRecovered,
+        activities_recovered: activitiesRecovered
       });
     }
-  } catch (err) {
-    logger.warn(LOG_KINDS.AGENT_ERROR, "Failed to clean stale runs", { error: err.message });
   }
-  let uiDir = null;
-  {
-    const root = findPackageRoot(path15.dirname(new URL(import.meta.url).pathname));
-    if (root) {
-      const candidate = path15.join(root, "dist", "ui");
-      if (fs13.existsSync(candidate)) uiDir = candidate;
+  function runStartupReconciliation() {
+    const startupCleanedCount = cleanStaleBuffers(bufferDir, STALE_BUFFER_MAX_AGE_MS);
+    if (startupCleanedCount > 0) {
+      logger.info(LOG_KINDS.CAPTURE_BUFFER, "Buffer cleanup complete", { stale_removed: startupCleanedCount });
+    }
+    for (const sessionId of listBufferSessionIds(bufferDir)) {
+      try {
+        reconcileSession(sessionId);
+      } catch (err) {
+        logger.warn(LOG_KINDS.LIFECYCLE_RECONCILE, "Startup reconciliation failed", { session_id: sessionId, error: String(err) });
+      }
     }
   }
-  if (uiDir) {
-    logger.debug(LOG_KINDS.DAEMON_START, "Static UI directory found", { path: uiDir });
+  function clearSession(sessionId) {
+    reconciledSessions.delete(sessionId);
   }
-  const powerManager = new PowerManager({
-    idleThresholdMs: POWER_IDLE_THRESHOLD_MS,
-    sleepThresholdMs: POWER_SLEEP_THRESHOLD_MS,
-    deepSleepThresholdMs: POWER_DEEP_SLEEP_THRESHOLD_MS,
-    activeIntervalMs: POWER_ACTIVE_INTERVAL_MS,
-    sleepIntervalMs: POWER_SLEEP_INTERVAL_MS,
-    logger
-  });
-  const server = new DaemonServer({
-    vaultDir,
-    logger,
-    uiDir: uiDir ?? void 0
-    // Don't record activity on every HTTP request — UI polling (every 3-10s)
-    // would prevent the PowerManager from ever reaching 'idle' state, blocking
-    // all idle-only scheduled tasks (skill-survey, skill-generate, skill-evolve).
-    // Activity is recorded on meaningful events below (session register, prompt capture, etc.).
-  });
-  const registry = new SessionRegistry({
-    gracePeriod: 0,
-    onEmpty: () => {
-    }
-  });
-  const transcriptMiner = new TranscriptMiner({
-    additionalAdapters: config.capture.transcript_paths.map(
-      (p) => createPerProjectAdapter(p, claudeCodeAdapter.parseTurns)
+  return { reconcileSession, replayEvent, runStartupReconciliation, clearSession };
+}
+
+// src/daemon/stop-processing.ts
+import fs16 from "fs";
+
+// src/daemon/skill-usage.ts
+import crypto from "crypto";
+var SKILL_USAGE_DETECTION_ENABLED = false;
+var MAX_ACTIVE_SKILLS_CHECK = 1e3;
+function detectSkillUsage(sessionId, transcriptContent) {
+  if (transcriptContent.includes("vault_write_skill")) return;
+  if (!SKILL_USAGE_DETECTION_ENABLED) return;
+  const activeSkills = listSkillRecords({ status: "active", limit: MAX_ACTIVE_SKILLS_CHECK });
+  if (activeSkills.length === 0) return;
+  const skillPatterns = activeSkills.map((skill) => ({
+    skill,
+    pattern: new RegExp(
+      `skills/${escapeRegex(skill.name)}/SKILL\\.md|<skill[^>]*name=["']${escapeRegex(skill.name)}["']`
     )
-  });
+  }));
+  const now = epochSeconds();
+  for (const { skill, pattern } of skillPatterns) {
+    try {
+      if (!pattern.test(transcriptContent)) continue;
+      if (hasUsageForSkillAndSession(skill.id, sessionId)) continue;
+      insertSkillUsage({
+        id: crypto.randomUUID(),
+        skill_id: skill.id,
+        session_id: sessionId,
+        detected_at: now
+      });
+      incrementSkillUsageCount(skill.id, now);
+    } catch {
+    }
+  }
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/daemon/stop-processing.ts
+function enrichTurnsWithToolMetadata(turns, events) {
+  if (events.length === 0 || turns.length === 0) return;
+  const toolEvents = events.filter((e) => e.type === "tool_use");
+  if (toolEvents.length === 0) return;
+  let cursor = 0;
+  for (let i = 0; i < turns.length; i++) {
+    const turnEnd = i + 1 < turns.length ? turns[i + 1].timestamp : null;
+    const breakdown = {};
+    const files = /* @__PURE__ */ new Set();
+    while (cursor < toolEvents.length) {
+      const ts = String(toolEvents[cursor].timestamp ?? "");
+      if (turnEnd !== null && ts >= turnEnd) break;
+      const evt = toolEvents[cursor];
+      const toolName = String(evt.tool_name ?? evt.tool ?? "unknown");
+      breakdown[toolName] = (breakdown[toolName] ?? 0) + 1;
+      const input = evt.tool_input;
+      const filePath = input?.file_path ?? input?.path;
+      if (typeof filePath === "string") files.add(filePath);
+      cursor++;
+    }
+    if (Object.keys(breakdown).length > 0) {
+      turns[i].toolBreakdown = breakdown;
+      if (files.size > 0) turns[i].files = [...files];
+    }
+  }
+}
+function createStopProcessor(deps) {
+  const { registry, sessionBuffers, transcriptMiner, embeddingManager, logger, config, vaultDir } = deps;
   let activeStopProcessing = null;
   const sessionTitleCache = /* @__PURE__ */ new Map();
+  const StopBody = external_exports.object({
+    session_id: external_exports.string(),
+    user: external_exports.string().optional(),
+    transcript_path: external_exports.string().optional(),
+    last_assistant_message: external_exports.string().optional()
+  });
   async function triggerTitleSummary(sessionId) {
     if (config.agent.summary_batch_interval <= 0) return;
+    if (config.agent.event_tasks_enabled === false) return;
     try {
-      const { runAgent } = await import("./executor-HKNINUWO.js");
+      const { runAgent } = await import("./executor-4OXDK4ZA.js");
       runAgent(vaultDir, {
         task: "title-summary",
         instruction: `Process session ${sessionId} only`,
@@ -5250,166 +6098,277 @@ async function main() {
     } catch {
     }
   }
-  const bufferDir = path15.join(vaultDir, "buffer");
-  const sessionBuffers = /* @__PURE__ */ new Map();
-  const startupCleanedCount = cleanStaleBuffers(bufferDir, STALE_BUFFER_MAX_AGE_MS);
-  if (startupCleanedCount > 0) {
-    logger.info(LOG_KINDS.CAPTURE_BUFFER, "Buffer cleanup complete", { stale_removed: startupCleanedCount });
-  }
-  const reconciledSessions = /* @__PURE__ */ new Set();
-  for (const sessionId of listBufferSessionIds(bufferDir)) {
-    try {
-      reconcileSession(sessionId);
-    } catch (err) {
-      logger.warn(LOG_KINDS.LIFECYCLE_RECONCILE, "Startup reconciliation failed", { session_id: sessionId, error: String(err) });
+  async function processStopEvent(sessionId, user, sessionMeta, hookTranscriptPath, lastAssistantMessage) {
+    const transcriptResult = transcriptMiner.getAllTurnsWithSource(sessionId, hookTranscriptPath);
+    let allTurns = transcriptResult.turns;
+    let turnSource = transcriptResult.source;
+    const bufferEvents = sessionBuffers.get(sessionId)?.readAll() ?? [];
+    if (allTurns.length === 0) {
+      allTurns = extractTurnsFromBuffer(bufferEvents);
+      turnSource = "buffer";
+    } else if (bufferEvents.length > 0) {
+      const lastTranscriptTs = allTurns[allTurns.length - 1].timestamp;
+      if (lastTranscriptTs) {
+        const newerEvents = bufferEvents.filter(
+          (e) => String(e.timestamp ?? "") > lastTranscriptTs
+        );
+        if (newerEvents.length > 0) {
+          const bufferTurns = extractTurnsFromBuffer(newerEvents);
+          allTurns = [...allTurns, ...bufferTurns];
+          turnSource = `${transcriptResult.source}+buffer`;
+          logger.info(LOG_KINDS.PROCESSOR_TRANSCRIPT, "Appended buffer turns missing from transcript", {
+            session_id: sessionId,
+            transcriptTurns: transcriptResult.turns.length,
+            bufferTurns: bufferTurns.length
+          });
+        }
+      }
     }
-  }
-  function replayEvent(sessionId, event) {
-    if (event.type === "user_prompt") {
-      if (isSystemMessage(String(event.prompt ?? ""))) return null;
-      handleUserPrompt(sessionId, String(event.prompt ?? ""));
-      return "prompt";
+    if (lastAssistantMessage && allTurns.length > 0) {
+      const lastTurn = allTurns[allTurns.length - 1];
+      if (!lastTurn.aiResponse) {
+        lastTurn.aiResponse = lastAssistantMessage;
+      }
     }
-    if (event.type === "tool_use") {
-      handleToolUse(
-        sessionId,
-        String(event.tool_name ?? ""),
-        event.tool_input,
-        typeof event.output_preview === "string" ? event.output_preview : void 0
-      );
-      return "activity";
+    enrichTurnsWithToolMetadata(allTurns, bufferEvents);
+    const imageCount = allTurns.reduce((sum, t) => sum + (t.images?.length ?? 0), 0);
+    logger.debug(LOG_KINDS.PROCESSOR_TRANSCRIPT, "Transcript parsed", {
+      session_id: sessionId,
+      turn_count: allTurns.length,
+      image_count: imageCount
+    });
+    const latestBatch = getLatestBatch(sessionId);
+    if (lastAssistantMessage && latestBatch && !latestBatch.response_summary) {
+      try {
+        setResponseSummary(latestBatch.id, lastAssistantMessage);
+      } catch (err) {
+        logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to set response_summary on latest batch", { error: String(err) });
+      }
     }
-    if (event.type === "tool_failure") {
-      handleToolFailure(
-        sessionId,
-        String(event.tool_name ?? ""),
-        event.tool_input,
-        typeof event.error === "string" ? event.error : void 0,
-        !!event.is_interrupt
-      );
-      return "activity";
+    closeOpenBatches(sessionId, epochSeconds());
+    const existingSession = getSession(sessionId);
+    const hasTitle = existingSession?.title !== null && existingSession?.title !== void 0;
+    if (!hasTitle) {
+      let title = sessionTitleCache.get(sessionId) ?? null;
+      if (!title) {
+        const firstBatch = listBatchesBySession(sessionId, { limit: 1 })[0];
+        if (firstBatch?.user_prompt) {
+          title = firstBatch.user_prompt.slice(0, TITLE_PREVIEW_CHARS);
+          if (firstBatch.user_prompt.length > TITLE_PREVIEW_CHARS) {
+            title += "...";
+          }
+          sessionTitleCache.set(sessionId, title);
+        }
+      }
     }
-    return null;
-  }
-  function reconcileSession(sessionId) {
-    if (reconciledSessions.has(sessionId)) return;
-    reconciledSessions.add(sessionId);
-    const bufferPath = path15.join(bufferDir, `${sessionId}.jsonl`);
-    if (!fs13.existsSync(bufferPath)) return;
-    const content = fs13.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 });
-      return;
+    const currentSession = getSession(sessionId);
+    const transcriptPromptCount = allTurns.length;
+    const transcriptToolCount = allTurns.reduce((sum, t) => sum + t.toolCount, 0);
+    const updateFields = {
+      transcript_path: hookTranscriptPath ?? null,
+      prompt_count: Math.max(transcriptPromptCount, currentSession?.prompt_count ?? 0),
+      tool_count: Math.max(transcriptToolCount, currentSession?.tool_count ?? 0)
+    };
+    if (user) updateFields.user = user;
+    if (!hasTitle && sessionTitleCache.has(sessionId)) {
+      updateFields.title = sessionTitleCache.get(sessionId);
     }
-    const allEvents = content.split("\n").map((line) => JSON.parse(line));
-    const existingBatchCount = listBatchesBySession(sessionId).length;
-    let promptsSeen = 0;
-    let replayStartIndex = -1;
-    for (let i = 0; i < allEvents.length; i++) {
-      const e = allEvents[i];
-      if (e.type === "user_prompt" && !isSystemMessage(String(e.prompt ?? ""))) {
-        promptsSeen++;
-        if (promptsSeen === existingBatchCount + 1) {
-          replayStartIndex = i;
-          break;
+    updateSession(sessionId, updateFields);
+    if (SKILL_USAGE_DETECTION_ENABLED) {
+      try {
+        let transcriptText = null;
+        if (hookTranscriptPath) {
+          try {
+            transcriptText = fs16.readFileSync(hookTranscriptPath, "utf-8");
+          } catch {
+          }
+        }
+        if (!transcriptText && allTurns.length > 0) {
+          transcriptText = allTurns.map((t) => [t.prompt ?? "", t.aiResponse ?? ""].join(" ")).join("\n");
         }
+        if (transcriptText) {
+          detectSkillUsage(sessionId, transcriptText);
+        }
+      } catch {
       }
     }
-    if (replayStartIndex === -1) return;
-    const eventsToReplay = allEvents.slice(replayStartIndex).filter(
-      (e) => REPLAYABLE_EVENT_TYPES.has(String(e.type))
-    );
-    let promptsRecovered = 0;
-    let activitiesRecovered = 0;
-    for (const event of eventsToReplay) {
+    const responses = [];
+    for (let i = 0; i < allTurns.length; i++) {
+      if (allTurns[i].aiResponse) {
+        responses.push({ turnIndex: i + 1, response: allTurns[i].aiResponse });
+      }
+    }
+    if (responses.length > 0) {
       try {
-        const result = replayEvent(sessionId, event);
-        if (result === "prompt") promptsRecovered++;
-        else if (result === "activity") activitiesRecovered++;
+        populateBatchResponses(sessionId, responses);
       } catch (err) {
-        logger.warn(LOG_KINDS.LIFECYCLE_RECONCILE, "Reconciliation: failed to replay event", {
-          type: String(event.type),
-          error: String(err)
-        });
+        logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to populate batch responses", { error: String(err) });
       }
     }
-    if (promptsRecovered > 0 || activitiesRecovered > 0) {
-      logger.info(LOG_KINDS.LIFECYCLE_RECONCILE, "Buffer reconciliation complete", {
-        session_id: sessionId,
-        prompts_recovered: promptsRecovered,
-        activities_recovered: activitiesRecovered
-      });
+    if (!hasTitle) {
+      triggerTitleSummary(sessionId);
+    }
+    const sessionShort = sessionId.slice(-6);
+    for (let i = 0; i < allTurns.length; i++) {
+      const turn = allTurns[i];
+      if (!turn.images?.length) continue;
+      const isLastTurn = i === allTurns.length - 1;
+      let resolvedBatchId = null;
+      let resolvedPromptNumber = i + 1;
+      if (isLastTurn && latestBatch) {
+        resolvedBatchId = latestBatch.id;
+        resolvedPromptNumber = latestBatch.prompt_number ?? resolvedPromptNumber;
+      } else if (turn.prompt) {
+        try {
+          const match = findBatchByPromptPrefix(sessionId, turn.prompt);
+          if (match) {
+            resolvedBatchId = match.id;
+            resolvedPromptNumber = match.prompt_number;
+          }
+        } catch {
+        }
+      }
+      for (let j = 0; j < turn.images.length; j++) {
+        const img = turn.images[j];
+        const ext = extensionForMimeType(img.mediaType);
+        const filename = `${sessionShort}-t${resolvedPromptNumber}-${j + 1}.${ext}`;
+        const imageBuffer = Buffer.from(img.data, "base64");
+        try {
+          insertAttachment({
+            id: `${sessionShort}-b${resolvedPromptNumber}-${j + 1}`,
+            session_id: sessionId,
+            prompt_batch_id: resolvedBatchId ?? void 0,
+            file_path: filename,
+            media_type: img.mediaType,
+            data: imageBuffer,
+            created_at: epochSeconds()
+          });
+          logger.debug(LOG_KINDS.CAPTURE_ATTACHMENT, "Image stored in DB", { filename, batch: resolvedPromptNumber });
+        } catch (err) {
+          logger.warn(LOG_KINDS.CAPTURE_ATTACHMENT, "Failed to record attachment", { error: String(err) });
+        }
+      }
     }
+    logger.info(LOG_KINDS.PROCESSOR_SESSION, "Session captured", {
+      session_id: sessionId,
+      turns: allTurns.length,
+      source: turnSource,
+      title: existingSession?.title ?? sessionTitleCache.get(sessionId) ?? "(untitled)"
+    });
   }
-  const RegisterBody = external_exports.object({
-    session_id: external_exports.string(),
-    agent: external_exports.string().optional(),
-    branch: external_exports.string().optional(),
-    started_at: external_exports.string().optional()
-  });
-  const UnregisterBody = external_exports.object({ session_id: external_exports.string() });
-  const EventBody = external_exports.object({ type: external_exports.string(), session_id: external_exports.string() }).passthrough();
-  const StopBody = external_exports.object({
-    session_id: external_exports.string(),
-    user: external_exports.string().optional(),
-    transcript_path: external_exports.string().optional(),
-    last_assistant_message: external_exports.string().optional()
-  });
-  server.registerRoute("POST", "/sessions/register", async (req) => {
-    powerManager.recordActivity();
-    const { session_id, agent, branch, started_at } = RegisterBody.parse(req.body);
-    const resolvedStartedAt = started_at ?? (/* @__PURE__ */ new Date()).toISOString();
-    registry.register(session_id, { started_at: resolvedStartedAt, branch });
-    server.updateDaemonJsonSessions(registry.sessions);
-    const now = epochSeconds();
-    const startedEpoch = Math.floor(new Date(resolvedStartedAt).getTime() / 1e3);
-    upsertSession({
-      id: session_id,
-      agent: agent ?? "claude-code",
-      user: null,
-      project_root: process.cwd(),
-      branch: branch ?? null,
-      started_at: startedEpoch,
-      created_at: now,
-      status: "active",
-      machine_id: machineId
+  const handleStopRoute = async (req) => {
+    const { session_id: sessionId, user, transcript_path: hookTranscriptPath, last_assistant_message: lastAssistantMessage } = StopBody.parse(req.body);
+    if (!registry.getSession(sessionId)) {
+      registry.register(sessionId, { started_at: (/* @__PURE__ */ new Date()).toISOString() });
+      logger.debug(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, "Auto-registered session from stop event", { session_id: sessionId });
+    }
+    const sessionMeta = registry.getSession(sessionId);
+    logger.info(LOG_KINDS.HOOKS_STOP, "Stop received", {
+      session_id: sessionId,
+      has_transcript_path: !!hookTranscriptPath,
+      has_response: !!lastAssistantMessage
     });
-    updateSession(session_id, { ended_at: null, status: "active" });
-    reconcileSession(session_id);
-    logger.info(LOG_KINDS.LIFECYCLE_REGISTER, "Session registered", { session_id, branch, started_at: started_at ?? null });
-    notify(vaultDir, {
-      domain: "sessions",
-      type: "session.started",
-      title: "Session started",
-      message: branch ? `Branch: ${branch}` : void 0,
-      link: `/sessions/${session_id}`,
-      metadata: { sessionId: session_id, agent: agent ?? "claude-code", branch }
-    }, config);
-    return { body: { ok: true, sessions: registry.sessions } };
+    logger.debug(LOG_KINDS.HOOKS_STOP, "Stop event detail", {
+      session_id: sessionId,
+      transcript_path: hookTranscriptPath ?? null,
+      last_message_preview: lastAssistantMessage?.slice(0, LOG_MESSAGE_PREVIEW_CHARS) ?? null
+    });
+    const run = () => processStopEvent(sessionId, user, sessionMeta, hookTranscriptPath, lastAssistantMessage).catch((err) => {
+      logger.error(LOG_KINDS.PROCESSOR_SESSION, "Stop processing failed", { session_id: sessionId, error: err.message });
+    });
+    const prev = activeStopProcessing ?? Promise.resolve();
+    activeStopProcessing = prev.then(run).finally(() => {
+      activeStopProcessing = null;
+    });
+    return { body: { ok: true } };
+  };
+  return {
+    handleStopRoute,
+    clearSession: (sessionId) => {
+      sessionTitleCache.delete(sessionId);
+    },
+    getActiveProcessing: () => activeStopProcessing,
+    triggerTitleSummary
+  };
+}
+
+// src/daemon/event-dispatch.ts
+import fs17 from "fs";
+import path19 from "path";
+
+// src/daemon/plan-capture.ts
+import { createHash as createHash4 } from "crypto";
+import os7 from "os";
+import path18 from "path";
+var FILE_WRITE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "Create"]);
+var HEADING_REGEX = /^#\s+(.+)$/m;
+var PLAN_ID_HASH_LENGTH = 16;
+function isInPlanDirectory(filePath, watchDirs, projectRoot) {
+  const abs = path18.isAbsolute(filePath) ? filePath : path18.resolve(projectRoot, filePath);
+  return watchDirs.some((dir) => {
+    const expanded = dir.startsWith("~/") ? path18.join(os7.homedir(), dir.slice(2)) : dir;
+    const absDir = path18.isAbsolute(expanded) ? expanded : path18.resolve(projectRoot, expanded);
+    const prefix = absDir.endsWith(path18.sep) ? absDir : absDir + path18.sep;
+    return abs === absDir || abs.startsWith(prefix);
   });
-  server.registerRoute("POST", "/sessions/unregister", async (req) => {
-    const { session_id } = UnregisterBody.parse(req.body);
-    registry.unregister(session_id);
-    cleanStaleBuffers(bufferDir, STALE_BUFFER_MAX_AGE_MS, session_id);
-    closeSession(session_id, epochSeconds());
-    sessionBuffers.delete(session_id);
-    sessionTitleCache.delete(session_id);
-    reconciledSessions.delete(session_id);
-    server.updateDaemonJsonSessions(registry.sessions);
-    logger.info(LOG_KINDS.LIFECYCLE_UNREGISTER, "Session unregistered", { session_id });
-    notify(vaultDir, {
-      domain: "sessions",
-      type: "session.ended",
-      title: "Session ended",
-      link: `/sessions/${session_id}`,
-      metadata: { sessionId: session_id }
-    }, config);
-    return { body: { ok: true, sessions: registry.sessions } };
+}
+function isPlanWriteEvent(toolName, toolInput, config) {
+  if (!FILE_WRITE_TOOLS.has(toolName)) return null;
+  const filePath = toolInput?.file_path ?? toolInput?.path;
+  if (typeof filePath !== "string") return null;
+  if (!isInPlanDirectory(filePath, config.watchDirs, config.projectRoot)) return null;
+  if (config.extensions?.length) {
+    const ext = path18.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, path18.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
   });
-  server.registerRoute("POST", "/events", async (req) => {
+}
+
+// src/daemon/event-dispatch.ts
+var EventBody = external_exports.object({ type: external_exports.string(), session_id: external_exports.string() }).passthrough();
+function createEventDispatcher(deps) {
+  const {
+    registry,
+    sessionBuffers,
+    powerManager,
+    logger,
+    machineId,
+    config,
+    vaultDir,
+    reconcileSession,
+    planWatchConfig,
+    triggerTitleSummary
+  } = deps;
+  const projectRoot = process.cwd();
+  return async (req) => {
     const validated = EventBody.parse(req.body);
-    const event = { ...validated, timestamp: validated.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() };
+    const event = {
+      ...validated,
+      timestamp: validated.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
     logger.debug(LOG_KINDS.HOOKS_EVENT, "Event received", { type: event.type, session_id: event.session_id });
     if (!registry.getSession(event.session_id)) {
       registry.register(event.session_id, { started_at: event.timestamp });
@@ -5427,6 +6386,7 @@ async function main() {
       reconcileSession(event.session_id);
     }
     if (!sessionBuffers.has(event.session_id)) {
+      const bufferDir = path19.join(vaultDir, "buffer");
       sessionBuffers.set(event.session_id, new EventBuffer(bufferDir, event.session_id));
     }
     sessionBuffers.get(event.session_id).append(event);
@@ -5470,10 +6430,10 @@ async function main() {
       );
       if (planFilePath) {
         const captureSessionId = event.session_id;
-        fs13.promises.readFile(planFilePath, "utf-8").then((planContent) => {
+        fs17.promises.readFile(planFilePath, "utf-8").then((planContent) => {
           const latestBatch = getLatestBatch(captureSessionId);
           capturePlan({
-            sourcePath: path15.relative(projectRoot, planFilePath),
+            sourcePath: path19.relative(projectRoot, planFilePath),
             content: planContent,
             sessionId: captureSessionId,
             promptBatchId: latestBatch?.id ?? null
@@ -5611,224 +6571,205 @@ async function main() {
       }
     }
     return { body: { ok: true } };
-  });
-  server.registerRoute("POST", "/events/stop", async (req) => {
-    const { session_id: sessionId, user, transcript_path: hookTranscriptPath, last_assistant_message: lastAssistantMessage } = StopBody.parse(req.body);
-    if (!registry.getSession(sessionId)) {
-      registry.register(sessionId, { started_at: (/* @__PURE__ */ new Date()).toISOString() });
-      logger.debug(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, "Auto-registered session from stop event", { session_id: sessionId });
+  };
+}
+
+// src/daemon/main.ts
+import fs18 from "fs";
+import os8 from "os";
+import path20 from "path";
+function killStaleDaemon(vaultDir, logger) {
+  const daemonJsonPath = path20.join(vaultDir, "daemon.json");
+  try {
+    if (!fs18.existsSync(daemonJsonPath)) return;
+    const info = JSON.parse(fs18.readFileSync(daemonJsonPath, "utf-8"));
+    if (!info.pid) return;
+    if (info.pid === process.pid) return;
+    try {
+      process.kill(info.pid, 0);
+      process.kill(info.pid, "SIGTERM");
+      logger.info(LOG_KINDS.DAEMON_START, "Killed stale daemon", { pid: info.pid });
+    } catch {
     }
-    const sessionMeta = registry.getSession(sessionId);
-    logger.info(LOG_KINDS.HOOKS_STOP, "Stop received", {
-      session_id: sessionId,
-      has_transcript_path: !!hookTranscriptPath,
-      has_response: !!lastAssistantMessage
-    });
-    logger.debug(LOG_KINDS.HOOKS_STOP, "Stop event detail", {
-      session_id: sessionId,
-      transcript_path: hookTranscriptPath ?? null,
-      last_message_preview: lastAssistantMessage?.slice(0, LOG_MESSAGE_PREVIEW_CHARS) ?? null
-    });
-    const run = () => processStopEvent(sessionId, user, sessionMeta, hookTranscriptPath, lastAssistantMessage).catch((err) => {
-      logger.error(LOG_KINDS.PROCESSOR_SESSION, "Stop processing failed", { session_id: sessionId, error: err.message });
-    });
-    const prev = activeStopProcessing ?? Promise.resolve();
-    activeStopProcessing = prev.then(run).finally(() => {
-      activeStopProcessing = null;
-    });
-    return { body: { ok: true } };
+    fs18.unlinkSync(daemonJsonPath);
+  } catch {
+  }
+}
+async function main() {
+  const vaultArg = process.argv.find((_, i) => process.argv[i - 1] === "--vault");
+  if (!vaultArg) {
+    process.stderr.write("Usage: mycod --vault <path>\n");
+    process.exit(1);
+  }
+  const vaultDir = path20.resolve(vaultArg);
+  loadSecrets(vaultDir);
+  const config = loadConfig(vaultDir);
+  const manifests = loadManifests();
+  const symbiontPlanDirs = manifests.flatMap((m) => m.capture?.planDirs ?? []);
+  const projectRoot = process.cwd();
+  let planWatchConfig = {
+    watchDirs: [.../* @__PURE__ */ new Set([...symbiontPlanDirs, ...config.capture.plan_dirs ?? []])],
+    projectRoot,
+    extensions: config.capture.artifact_extensions
+  };
+  const logger = new DaemonLogger(path20.join(vaultDir, "logs"), {
+    level: config.daemon.log_level
   });
-  function enrichTurnsWithToolMetadata(turns, events) {
-    if (events.length === 0 || turns.length === 0) return;
-    const toolEvents = events.filter((e) => e.type === "tool_use");
-    if (toolEvents.length === 0) return;
-    let cursor = 0;
-    for (let i = 0; i < turns.length; i++) {
-      const turnEnd = i + 1 < turns.length ? turns[i + 1].timestamp : null;
-      const breakdown = {};
-      const files = /* @__PURE__ */ new Set();
-      while (cursor < toolEvents.length) {
-        const ts = String(toolEvents[cursor].timestamp ?? "");
-        if (turnEnd !== null && ts >= turnEnd) break;
-        const evt = toolEvents[cursor];
-        const toolName = String(evt.tool_name ?? evt.tool ?? "unknown");
-        breakdown[toolName] = (breakdown[toolName] ?? 0) + 1;
-        const input = evt.tool_input;
-        const filePath = input?.file_path ?? input?.path;
-        if (typeof filePath === "string") files.add(filePath);
-        cursor++;
-      }
-      if (Object.keys(breakdown).length > 0) {
-        turns[i].toolBreakdown = breakdown;
-        if (files.size > 0) turns[i].files = [...files];
-      }
-    }
+  if (config.daemon.log_level === "debug") {
+    process.env.MYCO_AGENT_DEBUG = "1";
   }
-  async function processStopEvent(sessionId, user, sessionMeta, hookTranscriptPath, lastAssistantMessage) {
-    const transcriptResult = transcriptMiner.getAllTurnsWithSource(sessionId, hookTranscriptPath);
-    let allTurns = transcriptResult.turns;
-    let turnSource = transcriptResult.source;
-    const bufferEvents = sessionBuffers.get(sessionId)?.readAll() ?? [];
-    if (allTurns.length === 0) {
-      allTurns = extractTurnsFromBuffer(bufferEvents);
-      turnSource = "buffer";
-    } else if (bufferEvents.length > 0) {
-      const lastTranscriptTs = allTurns[allTurns.length - 1].timestamp;
-      if (lastTranscriptTs) {
-        const newerEvents = bufferEvents.filter(
-          (e) => String(e.timestamp ?? "") > lastTranscriptTs
-        );
-        if (newerEvents.length > 0) {
-          const bufferTurns = extractTurnsFromBuffer(newerEvents);
-          allTurns = [...allTurns, ...bufferTurns];
-          turnSource = `${transcriptResult.source}+buffer`;
-          logger.info(LOG_KINDS.PROCESSOR_TRANSCRIPT, "Appended buffer turns missing from transcript", {
-            session_id: sessionId,
-            transcriptTurns: transcriptResult.turns.length,
-            bufferTurns: bufferTurns.length
-          });
-        }
-      }
-    }
-    if (lastAssistantMessage && allTurns.length > 0) {
-      const lastTurn = allTurns[allTurns.length - 1];
-      if (!lastTurn.aiResponse) {
-        lastTurn.aiResponse = lastAssistantMessage;
-      }
-    }
-    enrichTurnsWithToolMetadata(allTurns, bufferEvents);
-    const imageCount = allTurns.reduce((sum, t) => sum + (t.images?.length ?? 0), 0);
-    logger.debug(LOG_KINDS.PROCESSOR_TRANSCRIPT, "Transcript parsed", {
-      session_id: sessionId,
-      turn_count: allTurns.length,
-      image_count: imageCount
+  killStaleDaemon(vaultDir, logger);
+  logger.info(LOG_KINDS.DAEMON_CONFIG, "Config loaded", {
+    vault: vaultDir,
+    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, machineId);
+  registerBuiltinDomains();
+  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({
+      timestamp,
+      level,
+      kind,
+      component,
+      message,
+      data: Object.keys(rest).length > 0 ? JSON.stringify(rest) : null,
+      session_id: rest.session_id ?? null
     });
-    const latestBatch = getLatestBatch(sessionId);
-    if (lastAssistantMessage && latestBatch && !latestBatch.response_summary) {
-      try {
-        setResponseSummary(latestBatch.id, lastAssistantMessage);
-      } catch (err) {
-        logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to set response_summary on latest batch", { error: String(err) });
-      }
-    }
-    closeOpenBatches(sessionId, epochSeconds());
-    const existingSession = getSession(sessionId);
-    const hasTitle = existingSession?.title !== null && existingSession?.title !== void 0;
-    if (!hasTitle) {
-      let title = sessionTitleCache.get(sessionId) ?? null;
-      if (!title) {
-        const firstBatch = listBatchesBySession(sessionId, { limit: 1 })[0];
-        if (firstBatch?.user_prompt) {
-          title = firstBatch.user_prompt.slice(0, TITLE_PREVIEW_CHARS);
-          if (firstBatch.user_prompt.length > TITLE_PREVIEW_CHARS) {
-            title += "...";
-          }
-          sessionTitleCache.set(sessionId, title);
-        }
-      }
-    }
-    const currentSession = getSession(sessionId);
-    const transcriptPromptCount = allTurns.length;
-    const transcriptToolCount = allTurns.reduce((sum, t) => sum + t.toolCount, 0);
-    const updateFields = {
-      transcript_path: hookTranscriptPath ?? null,
-      prompt_count: Math.max(transcriptPromptCount, currentSession?.prompt_count ?? 0),
-      tool_count: Math.max(transcriptToolCount, currentSession?.tool_count ?? 0)
-    };
-    if (user) updateFields.user = user;
-    if (!hasTitle && sessionTitleCache.has(sessionId)) {
-      updateFields.title = sessionTitleCache.get(sessionId);
-    }
-    updateSession(sessionId, updateFields);
-    if (SKILL_USAGE_DETECTION_ENABLED) {
-      try {
-        let transcriptText = null;
-        if (hookTranscriptPath) {
-          try {
-            transcriptText = fs13.readFileSync(hookTranscriptPath, "utf-8");
-          } catch {
-          }
-        }
-        if (!transcriptText && allTurns.length > 0) {
-          transcriptText = allTurns.map((t) => [t.prompt ?? "", t.aiResponse ?? ""].join(" ")).join("\n");
-        }
-        if (transcriptText) {
-          detectSkillUsage(sessionId, transcriptText);
-        }
-      } catch {
-      }
-    }
-    const responses = [];
-    for (let i = 0; i < allTurns.length; i++) {
-      if (allTurns[i].aiResponse) {
-        responses.push({ turnIndex: i + 1, response: allTurns[i].aiResponse });
-      }
-    }
-    if (responses.length > 0) {
-      try {
-        populateBatchResponses(sessionId, responses);
-      } catch (err) {
-        logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to populate batch responses", { error: String(err) });
-      }
+  });
+  const lastLogTimestamp = getMaxTimestamp();
+  if (lastLogTimestamp) {
+    const logDir = path20.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 });
     }
-    if (!hasTitle) {
-      triggerTitleSummary(sessionId);
+  }
+  const vectorsDbPath = path20.join(vaultDir, "vectors.db");
+  const vectorStore = new SqliteVecVectorStore(vectorsDbPath);
+  const llmProvider = createEmbeddingProvider(config.embedding);
+  const embeddingProvider = new EmbeddingProviderAdapter(llmProvider, config.embedding);
+  const recordSource = new SqliteRecordSource();
+  const embeddingManager = new EmbeddingManager(vectorStore, embeddingProvider, recordSource, logger);
+  logger.info(LOG_KINDS.EMBEDDING_EMBED, "EmbeddingManager initialized", { vectors_db: vectorsDbPath });
+  let definitionsDir;
+  try {
+    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-WC4U5NM5.js");
+    definitionsDir = resolveDefinitionsDir2();
+    await registerBuiltInAgentsAndTasks(definitionsDir, vaultDir);
+    logger.info(LOG_KINDS.AGENT_TASK, "Built-in agents and tasks registered");
+  } catch (err) {
+    logger.warn(LOG_KINDS.AGENT_ERROR, "Failed to register built-in agents/tasks", { error: err.message });
+  }
+  try {
+    const staleDb = getDatabase();
+    const staleRows = staleDb.prepare(
+      `SELECT id FROM agent_runs WHERE status = 'running'`
+    ).all();
+    if (staleRows.length > 0) {
+      staleDb.prepare(
+        `UPDATE agent_runs SET status = 'failed', completed_at = ?, error = 'Daemon restarted while run was in progress' WHERE status = 'running'`
+      ).run(epochSeconds());
+      logger.info(LOG_KINDS.AGENT_RUN, "Cleaned stale running agent runs", {
+        count: staleRows.length,
+        ids: staleRows.map((r) => r.id)
+      });
     }
-    const sessionShort = sessionId.slice(-6);
-    for (let i = 0; i < allTurns.length; i++) {
-      const turn = allTurns[i];
-      if (!turn.images?.length) continue;
-      const isLastTurn = i === allTurns.length - 1;
-      let resolvedBatchId = null;
-      let resolvedPromptNumber = i + 1;
-      if (isLastTurn && latestBatch) {
-        resolvedBatchId = latestBatch.id;
-        resolvedPromptNumber = latestBatch.prompt_number ?? resolvedPromptNumber;
-      } else if (turn.prompt) {
-        try {
-          const match = findBatchByPromptPrefix(sessionId, turn.prompt);
-          if (match) {
-            resolvedBatchId = match.id;
-            resolvedPromptNumber = match.prompt_number;
-          }
-        } catch {
-        }
-      }
-      for (let j = 0; j < turn.images.length; j++) {
-        const img = turn.images[j];
-        const ext = extensionForMimeType(img.mediaType);
-        const filename = `${sessionShort}-t${resolvedPromptNumber}-${j + 1}.${ext}`;
-        const imageBuffer = Buffer.from(img.data, "base64");
-        try {
-          insertAttachment({
-            id: `${sessionShort}-b${resolvedPromptNumber}-${j + 1}`,
-            session_id: sessionId,
-            prompt_batch_id: resolvedBatchId ?? void 0,
-            file_path: filename,
-            media_type: img.mediaType,
-            data: imageBuffer,
-            created_at: epochSeconds()
-          });
-          logger.debug(LOG_KINDS.CAPTURE_ATTACHMENT, "Image stored in DB", { filename, batch: resolvedPromptNumber });
-        } catch (err) {
-          logger.warn(LOG_KINDS.CAPTURE_ATTACHMENT, "Failed to record attachment", { error: String(err) });
-        }
-      }
+  } catch (err) {
+    logger.warn(LOG_KINDS.AGENT_ERROR, "Failed to clean stale runs", { error: err.message });
+  }
+  let uiDir = null;
+  {
+    const root = findPackageRoot(path20.dirname(new URL(import.meta.url).pathname));
+    if (root) {
+      const candidate = path20.join(root, "dist", "ui");
+      if (fs18.existsSync(candidate)) uiDir = candidate;
     }
-    logger.info(LOG_KINDS.PROCESSOR_SESSION, "Session captured", {
-      session_id: sessionId,
-      turns: allTurns.length,
-      source: turnSource,
-      title: existingSession?.title ?? sessionTitleCache.get(sessionId) ?? "(untitled)"
-    });
   }
+  if (uiDir) {
+    logger.debug(LOG_KINDS.DAEMON_START, "Static UI directory found", { path: uiDir });
+  }
+  const powerManager = new PowerManager({
+    idleThresholdMs: POWER_IDLE_THRESHOLD_MS,
+    sleepThresholdMs: POWER_SLEEP_THRESHOLD_MS,
+    deepSleepThresholdMs: POWER_DEEP_SLEEP_THRESHOLD_MS,
+    activeIntervalMs: POWER_ACTIVE_INTERVAL_MS,
+    sleepIntervalMs: POWER_SLEEP_INTERVAL_MS,
+    logger
+  });
+  const server = new DaemonServer({
+    vaultDir,
+    logger,
+    uiDir: uiDir ?? void 0
+    // Don't record activity on every HTTP request — UI polling (every 3-10s)
+    // would prevent the PowerManager from ever reaching 'idle' state, blocking
+    // all idle-only scheduled tasks (skill-survey, skill-generate, skill-evolve).
+    // Activity is recorded on meaningful events below (session register, prompt capture, etc.).
+  });
+  const registry = new SessionRegistry({
+    gracePeriod: 0,
+    onEmpty: () => {
+    }
+  });
+  const transcriptMiner = new TranscriptMiner({
+    additionalAdapters: config.capture.transcript_paths.map(
+      (p) => createPerProjectAdapter(p, claudeCodeAdapter.parseTurns)
+    )
+  });
+  const bufferDir = path20.join(vaultDir, "buffer");
+  const sessionBuffers = /* @__PURE__ */ new Map();
+  const reconciler = createReconciler({ bufferDir, logger });
+  reconciler.runStartupReconciliation();
+  const stopProcessor = createStopProcessor({
+    registry,
+    sessionBuffers,
+    transcriptMiner,
+    embeddingManager,
+    logger,
+    config,
+    vaultDir
+  });
+  const sessionLifecycle = createSessionLifecycleHandlers({
+    registry,
+    sessionBuffers,
+    reconciler,
+    stopProcessor,
+    server,
+    powerManager,
+    machineId,
+    logger,
+    config,
+    vaultDir
+  });
+  server.registerRoute("POST", "/sessions/register", sessionLifecycle.handleRegister);
+  server.registerRoute("POST", "/sessions/unregister", sessionLifecycle.handleUnregister);
+  const eventDispatcher = createEventDispatcher({
+    registry,
+    sessionBuffers,
+    powerManager,
+    logger,
+    machineId,
+    config,
+    vaultDir,
+    reconcileSession: reconciler.reconcileSession,
+    planWatchConfig,
+    triggerTitleSummary: stopProcessor.triggerTitleSummary
+  });
+  server.registerRoute("POST", "/events", eventDispatcher);
+  server.registerRoute("POST", "/events/stop", stopProcessor.handleStopRoute);
   const contextDeps = { embeddingManager, config, logger };
   server.registerRoute("POST", "/context", createSessionContextHandler(contextDeps));
   server.registerRoute("POST", "/context/prompt", createPromptContextHandler(contextDeps));
   const progressTracker = new ProgressTracker();
   let configHash = computeConfigHash(vaultDir);
   server.registerRoute("GET", "/api/config", async () => handleGetConfig(vaultDir));
-  server.registerRoute("GET", "/api/symbionts", handleListSymbionts);
+  server.registerRoute("GET", "/api/symbionts", async () => handleListSymbionts(vaultDir));
   server.registerRoute("PUT", "/api/config", async (req) => {
     const result = await handlePutConfig(vaultDir, req.body);
     if (!result.status || result.status < 400) {
@@ -5841,46 +6782,31 @@ async function main() {
     const dirs = m.capture?.planDirs ?? [];
     if (dirs.length > 0) symbiontPlanDirsByAgent[m.displayName] = dirs;
   }
-  server.registerRoute("GET", "/api/config/plan-dirs", async () => {
-    return { body: { symbiont: symbiontPlanDirsByAgent, custom: planWatchConfig.watchDirs.filter((d) => !symbiontPlanDirs.includes(d)) } };
-  });
-  server.registerRoute("POST", "/api/config/plan-dirs", async (req) => {
-    const body = req.body;
-    if (!Array.isArray(body.plan_dirs)) {
-      return { status: 400, body: { error: "plan_dirs must be an array" } };
+  const planDirHandlers = createPlanDirHandlers({
+    vaultDir,
+    symbiontPlanDirsByAgent,
+    symbiontPlanDirs,
+    planWatchConfig,
+    setPlanWatchConfig: (cfg) => {
+      planWatchConfig = cfg;
     }
-    const updated = updateConfig(vaultDir, (cfg) => ({
-      ...cfg,
-      capture: { ...cfg.capture, plan_dirs: body.plan_dirs }
-    }));
-    planWatchConfig = { ...planWatchConfig, watchDirs: [.../* @__PURE__ */ new Set([...symbiontPlanDirs, ...body.plan_dirs])] };
-    return { body: { custom: updated.capture.plan_dirs } };
-  });
-  server.registerRoute("GET", "/api/stats", async () => {
-    const stats = gatherStats(vaultDir, { active_sessions: registry.sessions });
-    stats.daemon.pid = process.pid;
-    stats.daemon.port = server.port;
-    stats.daemon.version = server.version;
-    stats.daemon.uptime_seconds = Math.floor(process.uptime());
-    return { body: { ...stats, config_hash: configHash } };
   });
+  server.registerRoute("GET", "/api/config/plan-dirs", planDirHandlers.handleGetPlanDirs);
+  server.registerRoute("POST", "/api/config/plan-dirs", planDirHandlers.handleUpdatePlanDirs);
+  const configHashRef = { get: () => configHash };
+  server.registerRoute("GET", "/api/stats", createLiveStatsHandler({
+    vaultDir,
+    registry,
+    server,
+    configHash: configHashRef
+  }));
   server.registerRoute("GET", "/api/logs/search", handleLogSearch);
   server.registerRoute("GET", "/api/logs/stream", handleLogStream);
   server.registerRoute("GET", "/api/logs/:id", handleLogDetail);
-  const ExternalLogBody = external_exports.object({
-    level: external_exports.enum(["debug", "info", "warn", "error"]),
-    component: external_exports.string(),
-    message: external_exports.string(),
-    data: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
-  });
-  server.registerRoute("POST", "/api/log", async (req) => {
-    const { level, component, message, data } = ExternalLogBody.parse(req.body);
-    logger.log(level, LOG_KINDS.MCP_EVENT, message, { ...data, mcp_component: component });
-    return { body: { ok: true } };
-  });
+  server.registerRoute("POST", "/api/log", createLogIngestionHandler(logger));
   server.registerRoute("GET", "/api/models", async (req) => handleGetModels(req));
   server.registerRoute("POST", "/api/restart", async (req) => handleRestart({ vaultDir, progressTracker }, req.body));
-  const updateProjectRoot = path15.dirname(vaultDir);
+  const updateProjectRoot = path20.dirname(vaultDir);
   const updateHandlers = createUpdateHandlers({
     vaultDir,
     projectRoot: updateProjectRoot,
@@ -5898,162 +6824,34 @@ async function main() {
   server.registerRoute("GET", "/api/progress/:token", async (req) => handleGetProgress(progressTracker, req.params.token));
   server.registerRoute("GET", "/api/sessions", handleListSessions);
   server.registerRoute("GET", "/api/sessions/:id", handleGetSession);
-  server.registerRoute("GET", "/api/sessions/:id/impact", async (req) => {
-    const sessionId = req.params.id;
-    const session = getSession(sessionId);
-    if (!session) return { status: 404, body: { error: "Session not found" } };
-    const impact = getSessionImpact(sessionId);
-    return { body: impact };
-  });
-  server.registerRoute("DELETE", "/api/sessions/:id", async (req) => {
-    const sessionId = req.params.id;
-    const result = deleteSessionCascade(sessionId);
-    if (!result.deleted) return { status: 404, body: { error: "Session not found" } };
-    cleanupAfterSessionCascade(sessionId, result, embeddingManager, vaultDir).catch(() => {
-    });
-    logger.info(LOG_KINDS.API_SESSION_DELETE, "Session cascade deleted", {
-      session_id: sessionId,
-      counts: result.counts
-    });
-    return { body: { ok: true, counts: result.counts } };
-  });
+  const sessionMutations = createSessionMutationHandlers({ embeddingManager, vaultDir, logger });
+  server.registerRoute("GET", "/api/sessions/:id/impact", sessionMutations.handleGetSessionImpact);
+  server.registerRoute("DELETE", "/api/sessions/:id", sessionMutations.handleDeleteSession);
   server.registerRoute("GET", "/api/sessions/:id/batches", handleGetSessionBatches);
   server.registerRoute("GET", "/api/batches/:id/activities", handleGetBatchActivities);
   server.registerRoute("GET", "/api/sessions/:id/attachments", handleGetSessionAttachments);
   server.registerRoute("GET", "/api/sessions/:id/plans", handleGetSessionPlans);
-  server.registerRoute("GET", "/api/skill-candidates", handleListCandidates);
-  server.registerRoute("GET", "/api/skill-candidates/:id", handleGetCandidate);
-  server.registerRoute("PUT", "/api/skill-candidates/:id", handleUpdateCandidate);
-  server.registerRoute("GET", "/api/skill-records", handleListSkillRecords);
-  server.registerRoute("GET", "/api/skill-records/:id", handleGetSkillRecord);
-  server.registerRoute("DELETE", "/api/skill-candidates/:id", handleDeleteCandidate);
-  server.registerRoute("DELETE", "/api/skill-records/:id", async (req) => {
-    const result = await handleDeleteSkillRecord(req);
-    if (result.body?.deleted) {
-      const record = result.body;
-      if (record.name) {
-        const projectRoot2 = path15.resolve(vaultDir, "..");
-        const skillDir = path15.resolve(projectRoot2, ".agents", "skills", record.name);
-        try {
-          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) });
-        }
-        try {
-          const { syncSkillSymlinks } = await import("./installer-25TSX4SR.js");
-          syncSkillSymlinks(projectRoot2, record.name, { remove: true });
-        } catch (err) {
-          logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to remove skill symlinks", { name: record.name, error: String(err) });
-        }
-      }
-    }
-    return result;
-  });
-  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 = {
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    webp: "image/webp"
-  };
-  server.registerRoute("GET", "/api/attachments/:filename", async (req) => {
-    const filename = req.params.filename;
-    if (filename.includes("..") || filename.includes("/")) {
-      return { status: 400, body: { error: "invalid_filename" } };
-    }
-    const att = getAttachmentByFilePath(filename);
-    if (att?.data) {
-      const contentType2 = att.media_type ?? "application/octet-stream";
-      return { status: 200, headers: { "Content-Type": contentType2 }, body: att.data };
-    }
-    const filePath = path15.join(vaultDir, "attachments", filename);
-    let diskData;
-    try {
-      diskData = fs13.readFileSync(filePath);
-    } catch {
-      return { status: 404, body: { error: "not_found" } };
-    }
-    const ext = path15.extname(filename).slice(1).toLowerCase();
-    const contentType = ATTACHMENT_MEDIA_TYPES[ext] ?? "application/octet-stream";
-    return { status: 200, headers: { "Content-Type": contentType }, body: diskData };
-  });
-  function buildSkillGenerateInstruction() {
-    const candidates = listCandidates({ status: "approved", limit: 1 });
-    if (candidates.length > 0) {
-      return `Generate skill for candidate id=${candidates[0].id} topic="${candidates[0].topic}"`;
-    }
-    return void 0;
-  }
-  const AgentRunBody = external_exports.object({
-    task: external_exports.string().optional(),
-    instruction: external_exports.string().optional(),
-    agentId: external_exports.string().optional()
-  });
-  server.registerRoute("POST", "/api/agent/run", async (req) => {
-    const { task, instruction: rawInstruction, agentId } = AgentRunBody.parse(req.body);
-    let instruction = rawInstruction;
-    if (task === "skill-generate" && !instruction) {
-      instruction = buildSkillGenerateInstruction();
-    }
-    const { runAgent } = await import("./executor-HKNINUWO.js");
-    const resultPromise = runAgent(vaultDir, { task, instruction, agentId, embeddingManager });
-    const effectiveAgentId = agentId ?? "myco-agent";
-    const runId = getLatestRunId(effectiveAgentId, task);
-    resultPromise.then((result) => {
-      if (result.status === "failed") {
-        logger.error(LOG_KINDS.AGENT_ERROR, "Agent run failed", {
-          runId: result.runId,
-          error: result.error ?? "No error message",
-          phases: result.phases?.map((p) => `${p.name}:${p.status}`) ?? []
-        });
-      } else {
-        logger.info(LOG_KINDS.AGENT_RUN, "Agent run completed", {
-          runId: result.runId,
-          status: result.status,
-          phases: result.phases?.map((p) => `${p.name}:${p.status}`) ?? []
-        });
-      }
-    }).catch((err) => {
-      logger.error(LOG_KINDS.AGENT_ERROR, "Agent run threw unhandled error", {
-        error: err.message ?? String(err),
-        stack: err.stack?.split("\n").slice(0, 3).join(" | ")
-      });
-    });
-    return { body: { ok: true, message: "Agent started", runId } };
-  });
-  server.registerRoute("GET", "/api/agent/runs", async (req) => {
-    const limit = req.query.limit ? Number(req.query.limit) : AGENT_RUNS_DEFAULT_LIMIT;
-    const offset = req.query.offset ? Number(req.query.offset) : 0;
-    const agentId = req.query.agentId || void 0;
-    const status = req.query.status || void 0;
-    const task = req.query.task || void 0;
-    const search = req.query.search || void 0;
-    const filterOpts = { agent_id: agentId, status, task, search };
-    const runs = listRuns({ ...filterOpts, limit, offset });
-    const total = countRuns(filterOpts);
-    return { body: { runs, total, offset, limit } };
-  });
-  server.registerRoute("GET", "/api/agent/runs/:id", async (req) => {
-    const run = getRun(req.params.id);
-    if (!run) {
-      return { status: 404, body: { error: "Run not found" } };
-    }
-    return { body: { run } };
-  });
-  server.registerRoute("GET", "/api/agent/runs/:id/reports", async (req) => {
-    const reports = listReports(req.params.id);
-    return { body: { reports } };
-  });
-  server.registerRoute("GET", "/api/agent/runs/:id/turns", async (req) => {
-    const turns = listTurnsByRun(req.params.id);
-    return { body: turns };
-  });
+  server.registerRoute("GET", "/api/skill-candidates", handleListCandidates);
+  server.registerRoute("GET", "/api/skill-candidates/:id", handleGetCandidate);
+  server.registerRoute("PUT", "/api/skill-candidates/:id", handleUpdateCandidate);
+  server.registerRoute("GET", "/api/skill-records", handleListSkillRecords);
+  server.registerRoute("GET", "/api/skill-records/:id", handleGetSkillRecord);
+  server.registerRoute("DELETE", "/api/skill-candidates/:id", handleDeleteCandidate);
+  server.registerRoute("DELETE", "/api/skill-records/:id", createSkillRecordDeleteHandler({ vaultDir, logger }));
+  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 attachments = createAttachmentHandler({ vaultDir });
+  server.registerRoute("GET", "/api/attachments/:filename", attachments.handleGetAttachment);
+  const agentRunHandlers = createAgentRunHandlers({ vaultDir, embeddingManager, logger });
+  server.registerRoute("POST", "/api/agent/run", agentRunHandlers.handleRun);
+  server.registerRoute("GET", "/api/agent/runs", agentRunHandlers.handleListRuns);
+  server.registerRoute("GET", "/api/agent/runs/:id", agentRunHandlers.handleGetRun);
+  server.registerRoute("GET", "/api/agent/runs/:id/reports", agentRunHandlers.handleGetRunReports);
+  server.registerRoute("GET", "/api/agent/runs/:id/turns", agentRunHandlers.handleGetRunTurns);
   server.registerRoute("GET", "/api/agent/tasks", async (req) => handleListTasks(req, vaultDir));
   server.registerRoute("GET", "/api/agent/tasks/:id", async (req) => handleGetTask(req, vaultDir));
   server.registerRoute("GET", "/api/agent/tasks/:id/yaml", async (req) => handleGetTaskYaml(req, vaultDir));
@@ -6065,207 +6863,36 @@ async function main() {
   server.registerRoute("PUT", "/api/agent/tasks/:id/config", async (req) => handleUpdateTaskConfig(req, vaultDir));
   server.registerRoute("GET", "/api/providers", async () => handleGetProviders());
   server.registerRoute("POST", "/api/providers/test", async (req) => handleTestProvider(req));
-  const SPORE_ID_RANDOM_BYTES = 4;
-  const RESOLUTION_ID_RANDOM_BYTES = 8;
-  const RememberBody = external_exports.object({
-    content: external_exports.string(),
-    type: external_exports.string().optional(),
-    tags: external_exports.array(external_exports.string()).optional()
-  });
-  server.registerRoute("POST", "/api/mcp/remember", async (req) => {
-    const { content, type, tags } = RememberBody.parse(req.body);
-    const { randomBytes } = await import("crypto");
-    const observationType = type ?? "discovery";
-    const id = `${observationType}-${randomBytes(SPORE_ID_RANDOM_BYTES).toString("hex")}`;
-    const now = epochSeconds();
-    registerAgent({
-      id: USER_AGENT_ID,
-      name: USER_AGENT_NAME,
-      created_at: now
-    });
-    const spore = insertSpore({
-      id,
-      agent_id: USER_AGENT_ID,
-      machine_id: machineId,
-      observation_type: observationType,
-      content,
-      tags: tags ? tags.join(", ") : null,
-      created_at: now
-    });
-    embeddingManager.onContentWritten("spores", spore.id, content, {
-      status: "active",
-      observation_type: observationType
-    }).catch(() => {
-    });
-    return {
-      body: {
-        id: spore.id,
-        observation_type: spore.observation_type,
-        status: spore.status,
-        created_at: spore.created_at
-      }
-    };
-  });
-  server.registerRoute("GET", "/api/mcp/plans", async (req) => {
-    const statusFilter = req.query.status === "all" ? void 0 : req.query.status;
-    const limit = req.query.limit ? Number(req.query.limit) : void 0;
-    const rows = listPlans({ status: statusFilter, limit });
-    const plans = rows.map((row) => {
-      const content = row.content ?? "";
-      const checked = (content.match(/- \[x\]/gi) ?? []).length;
-      const unchecked = (content.match(/- \[ \]/g) ?? []).length;
-      const total = checked + unchecked;
-      const progress = total === 0 ? "N/A" : `${checked}/${total}`;
-      return {
-        id: row.id,
-        title: row.title,
-        status: row.status,
-        progress,
-        tags: row.tags ? row.tags.split(",").map((t) => t.trim()) : [],
-        created_at: row.created_at
-      };
-    });
-    return { body: { plans } };
-  });
-  server.registerRoute("GET", "/api/mcp/sessions", async (req) => {
-    const limit = req.query.limit ? Number(req.query.limit) : 20;
-    const status = req.query.status;
-    const rows = listSessions({ limit, status });
-    const sessions = rows.map((row) => ({
-      id: row.id,
-      agent: row.agent,
-      user: row.user,
-      branch: row.branch,
-      started_at: row.started_at,
-      ended_at: row.ended_at,
-      status: row.status,
-      title: row.title,
-      summary: (row.summary ?? "").slice(0, 300),
-      prompt_count: row.prompt_count,
-      tool_count: row.tool_count,
-      parent_session_id: row.parent_session_id
-    }));
-    return { body: { sessions } };
-  });
-  server.registerRoute("GET", "/api/mcp/team", async () => {
-    const teamDb = getDatabase();
-    const rows = teamDb.prepare(
-      `SELECT id, "user", role, joined, tags
-       FROM team_members
-       ORDER BY id ASC`
-    ).all();
-    const members = rows.map((row) => ({
-      id: row.id,
-      user: row.user,
-      role: row.role ?? null,
-      joined: row.joined ?? null,
-      tags: row.tags ? row.tags.split(",").map((t) => t.trim()) : []
-    }));
-    return { body: { members } };
-  });
-  const SupersedeBody = external_exports.object({
-    old_spore_id: external_exports.string(),
-    new_spore_id: external_exports.string(),
-    reason: external_exports.string().optional()
-  });
-  server.registerRoute("POST", "/api/mcp/supersede", async (req) => {
-    const { old_spore_id, new_spore_id, reason } = SupersedeBody.parse(req.body);
-    const { randomBytes } = await import("crypto");
-    const now = epochSeconds();
-    updateSporeStatus(old_spore_id, "superseded", now);
-    try {
-      embeddingManager.onStatusChanged("spores", old_spore_id, "superseded");
-    } catch {
-    }
-    registerAgent({
-      id: USER_AGENT_ID,
-      name: USER_AGENT_NAME,
-      created_at: now
-    });
-    const { insertResolutionEvent } = await import("./resolution-events-5EVUEWHS.js");
-    const resolutionId = `res-${randomBytes(RESOLUTION_ID_RANDOM_BYTES).toString("hex")}`;
-    insertResolutionEvent({
-      id: resolutionId,
-      agent_id: USER_AGENT_ID,
-      machine_id: machineId,
-      spore_id: old_spore_id,
-      action: "supersede",
-      new_spore_id,
-      reason: reason ?? null,
-      created_at: now
-    });
-    return {
-      body: {
-        old_spore: old_spore_id,
-        new_spore: new_spore_id,
-        status: "superseded"
-      }
-    };
-  });
+  const mcpProxy = createMcpProxyHandlers({ machineId, embeddingManager });
+  server.registerRoute("POST", "/api/mcp/remember", mcpProxy.handleRemember);
+  server.registerRoute("POST", "/api/mcp/supersede", mcpProxy.handleSupersede);
+  server.registerRoute("GET", "/api/mcp/plans", mcpProxy.handlePlans);
+  server.registerRoute("GET", "/api/mcp/sessions", mcpProxy.handleSessions);
+  server.registerRoute("GET", "/api/mcp/team", mcpProxy.handleTeam);
   const rawBackupDir = config.backup.dir;
-  const backupDir = rawBackupDir ? path15.resolve(rawBackupDir.startsWith("~/") ? path15.join(os8.homedir(), rawBackupDir.slice(2)) : rawBackupDir) : path15.resolve(vaultDir, "backups");
+  const backupDir = rawBackupDir ? path20.resolve(rawBackupDir.startsWith("~/") ? path20.join(os8.homedir(), rawBackupDir.slice(2)) : rawBackupDir) : path20.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: path15.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 backupConfigHandlers = createBackupConfigHandlers({ vaultDir });
+  server.registerRoute("GET", "/api/backup/config", backupConfigHandlers.handleGetBackupConfig);
+  server.registerRoute("PUT", "/api/backup/config", backupConfigHandlers.handlePutBackupConfig);
+  const teamSync = initTeamSync({ config, machineId, logger, vaultDir, serverVersion: server.version });
   const teamHandlers = createTeamHandlers({
     vaultDir,
     machineId,
-    getTeamClient: () => teamClient,
-    setTeamClient: (c) => {
-      teamClient = c;
-    }
+    getTeamClient: teamSync.getTeamClient,
+    setTeamClient: teamSync.setTeamClient
   });
   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("POST", "/api/team/backfill", teamHandlers.handleBackfill);
+  server.registerRoute("POST", "/api/team/retry-failed", teamHandlers.handleRetryFailed);
+  server.registerRoute("POST", "/api/team/upgrade-worker", teamHandlers.handleUpgradeWorker);
+  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));
   server.registerRoute("GET", "/api/embedding/details", async () => handleEmbeddingDetails(embeddingManager));
@@ -6298,204 +6925,14 @@ async function main() {
       logger.warn(LOG_KINDS.DAEMON_CONFIG, "Failed to persist auto-derived port", { error: err.message });
     }
   }
-  let reconcileRunning = false;
-  powerManager.register({
-    name: "embedding-reconcile",
-    runIn: ["active", "idle"],
-    fn: async () => {
-      if (reconcileRunning) return;
-      reconcileRunning = true;
-      try {
-        await embeddingManager.reconcile(EMBEDDING_BATCH_SIZE);
-      } finally {
-        reconcileRunning = false;
-      }
-    }
-  });
-  powerManager.register({
-    name: "session-maintenance",
-    runIn: ["active", "idle", "sleep"],
-    fn: () => runSessionMaintenance({
-      logger,
-      registeredSessionIds: () => registry.sessions,
-      embeddingManager,
-      vaultDir
-    })
-  });
-  powerManager.register({
-    name: "log-retention",
-    runIn: ["idle", "sleep"],
-    fn: async () => {
-      const retentionDays = config.daemon.log_retention_days;
-      const cutoff = new Date(Date.now() - retentionDays * MS_PER_DAY).toISOString();
-      const deleted = deleteOldLogs(cutoff);
-      if (deleted > 0) {
-        logger.info(LOG_KINDS.LOG_RETENTION, `Deleted ${deleted} log entries older than ${retentionDays} days`, { deleted, retention_days: retentionDays });
-      }
-    }
-  });
-  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 sentRecords = pending.filter((r) => !failedIds.has(String(r.row_id)));
-            const sentIds = sentRecords.map((r) => r.id);
-            if (sentIds.length > 0) {
-              const now = epochSeconds();
-              markSent(sentIds, now);
-              markSourceRowsSynced(sentRecords, now);
-            }
-          }
-          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 });
-        }
-      }
-    });
-  }
-  {
-    const runningTasks = /* @__PURE__ */ new Set();
-    if (definitionsDir) {
-      const { loadAllTasks: loadAllTasks2 } = await import("./registry-2XQMCPA6.js");
-      const allTasks = Array.from(loadAllTasks2(definitionsDir, vaultDir).values());
-      const initialLastRuns = {};
-      try {
-        const recentRuns = getDatabase().prepare(
-          `SELECT task, MAX(completed_at) as last_completed
-           FROM agent_runs
-           WHERE status IN ('completed', 'failed') AND completed_at IS NOT NULL
-           GROUP BY task`
-        ).all();
-        for (const row of recentRuns) {
-          initialLastRuns[row.task] = row.last_completed * 1e3;
-        }
-      } catch {
-      }
-      const scheduledContext = {
-        isTaskRunning: (name) => runningTasks.has(name),
-        setTaskRunning: (name, running) => {
-          if (running) runningTasks.add(name);
-          else runningTasks.delete(name);
-        },
-        runTask: async (taskName) => {
-          const { runAgent } = await import("./executor-HKNINUWO.js");
-          const instruction = taskName === "skill-generate" ? buildSkillGenerateInstruction() : void 0;
-          const result = await runAgent(vaultDir, { task: taskName, instruction, embeddingManager });
-          logger.info(LOG_KINDS.AGENT_RUN, `Scheduled task ${taskName} completed`, {
-            status: result.status,
-            runId: result.runId
-          });
-          if (result.status === "failed") {
-            notify(vaultDir, {
-              domain: "agents",
-              type: "agent.task.failure",
-              title: `Task failed: ${taskName}`,
-              message: result.error ?? "Unknown error",
-              link: `/agent?run=${result.runId}`,
-              metadata: { taskName, runId: result.runId }
-            }, config);
-          } else if (result.status === "completed") {
-            notify(vaultDir, {
-              domain: "agents",
-              type: "agent.task.success",
-              title: `Task completed: ${taskName}`,
-              link: `/agent?run=${result.runId}`,
-              metadata: { taskName, runId: result.runId }
-            }, config);
-            const { countToolCallsByRun } = await import("./turns-3ZQAF6HF.js");
-            const counts = countToolCallsByRun(result.runId, ["vault_create_spore", "vault_write_digest"]);
-            const sporeCount = counts["vault_create_spore"] ?? 0;
-            const digestCount = counts["vault_write_digest"] ?? 0;
-            if (sporeCount > 0) {
-              notify(vaultDir, {
-                domain: "mycelium",
-                type: "mycelium.spore.created",
-                title: sporeCount === 1 ? "Extracted 1 observation" : `Extracted ${sporeCount} observations`,
-                message: `From ${taskName} run`,
-                link: "/mycelium?tab=spores",
-                metadata: { count: sporeCount, taskName, runId: result.runId }
-              }, config);
-            }
-            if (digestCount > 0) {
-              notify(vaultDir, {
-                domain: "mycelium",
-                type: "mycelium.digest.completed",
-                title: `Digest updated (${digestCount} ${digestCount === 1 ? "tier" : "tiers"})`,
-                link: "/mycelium?tab=digest",
-                metadata: { tierCount: digestCount, taskName, runId: result.runId }
-              }, config);
-            }
-          }
-        },
-        preConditions: {
-          "has-unprocessed-batches": () => {
-            const row = getDatabase().prepare(
-              "SELECT 1 FROM prompt_batches WHERE processed = 0 LIMIT 1"
-            ).get();
-            return row !== void 0;
-          },
-          "has-active-skills": () => {
-            return countSkillRecords({ status: "active" }) > 0;
-          },
-          "has-approved-candidates": () => {
-            return countCandidates({ status: "approved" }) > 0;
-          }
-        }
-      };
-      const scheduledJobs = buildScheduledJobs(
-        allTasks,
-        config.agent.tasks ?? {},
-        scheduledContext,
-        initialLastRuns
-      );
-      for (const job of scheduledJobs) {
-        powerManager.register(job);
-      }
-      logger.info(LOG_KINDS.DAEMON_START, `Registered ${scheduledJobs.length} scheduled task(s)`, {
-        tasks: scheduledJobs.map((j) => j.name)
-      });
-    } else {
-      logger.warn(LOG_KINDS.AGENT_ERROR, "Skipping dynamic task scheduling \u2014 definitions directory unavailable");
-    }
-  }
+  registerPowerJobs(powerManager, { embeddingManager, registry, logger, config, db, backupDir, machineId, vaultDir });
+  teamSync.registerFlushJob(powerManager);
+  await registerScheduledTasks(powerManager, { definitionsDir, vaultDir, embeddingManager, logger, config });
   powerManager.start();
   const shutdown = async (signal) => {
     logger.info(LOG_KINDS.DAEMON_START, `${signal} received`);
     powerManager.stop();
+    const activeStopProcessing = stopProcessor.getActiveProcessing();
     if (activeStopProcessing) {
       logger.info(LOG_KINDS.DAEMON_START, "Waiting for active stop processing to complete...");
       await activeStopProcessing;
@@ -6522,4 +6959,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-MVXPBP5Z.js.map
+//# sourceMappingURL=main-ADLCOYKM.js.map