@goondocks/myco 0.6.4 → 0.9.0

package/dist/main-BMCL7CPO.js

@@ -0,0 +1,4393 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  DaemonLogger,
+  LEVEL_ORDER
+} from "./chunk-2T7RPVPP.js";
+import {
+  EMBEDDABLE_TABLES,
+  EMBEDDABLE_TEXT_COLUMNS,
+  assertValidTable,
+  clearEmbedded,
+  gatherStats,
+  getEmbeddingQueueDepth,
+  getUnembedded,
+  markEmbedded
+} from "./chunk-QIK2XSDQ.js";
+import {
+  withTaskConfig
+} from "./chunk-M5XWW7UI.js";
+import {
+  createEmbeddingProvider
+} from "./chunk-JYOOJCPQ.js";
+import {
+  closeOpenBatches,
+  countRuns,
+  createBatchLineage,
+  errorMessage,
+  findBatchByPromptPrefix,
+  getDigestExtract,
+  getEntity,
+  getGraphForNode,
+  getLatestBatch,
+  getRun,
+  getRunningRun,
+  incrementActivityCount,
+  insertBatchStateless,
+  listBatchesBySession,
+  listDigestExtracts,
+  listEntities,
+  listReports,
+  listRuns,
+  listTurnsByRun,
+  populateBatchResponses,
+  setResponseSummary
+} from "./chunk-OXZSXYAT.js";
+import {
+  fullTextSearch,
+  hydrateSearchResults
+} from "./chunk-PT5IC642.js";
+import {
+  copyTaskToUser,
+  deleteUserTask,
+  loadAllTasks,
+  validateTaskName,
+  writeUserTask
+} from "./chunk-BUSP3OJB.js";
+import {
+  AgentTaskSchema,
+  registerAgent,
+  resolveDefinitionsDir,
+  taskFromParsed
+} from "./chunk-JMJJEQ3P.js";
+import {
+  checkLocalProvider
+} from "./chunk-DCXRSSBP.js";
+import {
+  EventBuffer,
+  cleanStaleBuffers,
+  listBufferSessionIds
+} from "./chunk-V7XG6V6C.js";
+import "./chunk-IB76KGBY.js";
+import "./chunk-46PWOKSI.js";
+import "./chunk-RJ6ZQKG5.js";
+import "./chunk-KYLDNM7H.js";
+import {
+  loadSecrets
+} from "./chunk-FFAYUQ5N.js";
+import {
+  SymbiontRegistry,
+  claudeCodeAdapter,
+  createPerProjectAdapter,
+  extensionForMimeType
+} from "./chunk-KB4DGYIY.js";
+import "./chunk-SAKJMNSR.js";
+import {
+  loadManifests
+} from "./chunk-5PEUFJ6U.js";
+import {
+  LmStudioBackend,
+  OllamaBackend
+} from "./chunk-UBZPD4HN.js";
+import {
+  countSpores,
+  getSpore,
+  insertSpore,
+  listSpores,
+  updateSporeStatus
+} from "./chunk-3K5WGSJ4.js";
+import {
+  closeSession,
+  countSessions,
+  deleteSessionCascade,
+  getSession,
+  getSessionImpact,
+  listSessions,
+  updateSession,
+  upsertSession
+} from "./chunk-4LPQ26CK.js";
+import {
+  EMBEDDING_DIMENSIONS,
+  createSchema
+} from "./chunk-KV4OC4H3.js";
+import {
+  CONFIG_FILENAME,
+  MycoConfigSchema,
+  loadConfig,
+  updateConfig
+} from "./chunk-MHSCMET3.js";
+import {
+  require_dist
+} from "./chunk-D7TYRPRM.js";
+import "./chunk-E4VLWIJC.js";
+import {
+  external_exports
+} from "./chunk-KH64DHOY.js";
+import {
+  closeDatabase,
+  getDatabase,
+  initDatabase,
+  vaultDbPath
+} from "./chunk-MYX5NCRH.js";
+import "./chunk-TRUJLI6K.js";
+import {
+  CONTENT_HASH_ALGORITHM,
+  DAEMON_EVICT_POLL_MS,
+  DAEMON_EVICT_TIMEOUT_MS,
+  DEAD_SESSION_MAX_PROMPTS,
+  DEFAULT_AGENT_ID,
+  EMBEDDING_BATCH_SIZE,
+  EXCLUDED_SPORE_STATUSES,
+  FEED_DEFAULT_LIMIT,
+  LOG_CONTEXT_PREVIEW_CHARS,
+  LOG_MESSAGE_PREVIEW_CHARS,
+  LOG_PROMPT_PREVIEW_CHARS,
+  MS_PER_DAY,
+  MS_PER_SECOND,
+  POWER_ACTIVE_INTERVAL_MS,
+  POWER_DEEP_SLEEP_THRESHOLD_MS,
+  POWER_IDLE_THRESHOLD_MS,
+  POWER_SLEEP_INTERVAL_MS,
+  POWER_SLEEP_THRESHOLD_MS,
+  PROMPT_CONTEXT_MAX_TOKENS,
+  PROMPT_CONTEXT_MIN_LENGTH,
+  PROMPT_CONTEXT_MIN_SIMILARITY,
+  PROMPT_PREVIEW_CHARS,
+  PROMPT_VECTOR_OVER_FETCH,
+  SEARCH_RESULTS_DEFAULT_LIMIT,
+  SEARCH_SIMILARITY_THRESHOLD,
+  STALE_BUFFER_MAX_AGE_MS,
+  STALE_SESSION_THRESHOLD_MS,
+  USER_AGENT_ID,
+  USER_AGENT_NAME,
+  USER_TASK_SOURCE,
+  epochSeconds,
+  estimateTokens
+} from "./chunk-5VZ52A4T.js";
+import {
+  LOG_KINDS,
+  kindToComponent
+} from "./chunk-WGTCA2NU.js";
+import {
+  getPluginVersion
+} from "./chunk-PB6TOLRQ.js";
+import {
+  findPackageRoot
+} from "./chunk-LPUQPDC2.js";
+import {
+  __toESM
+} from "./chunk-PZUWP5VK.js";
+
+// src/daemon/server.ts
+import http from "http";
+import fs2 from "fs";
+import path2 from "path";
+
+// src/daemon/router.ts
+var Router = class {
+  routes = [];
+  add(method, pattern, handler) {
+    const type = pattern.includes(":") ? "param" : pattern.endsWith("/*") ? "prefix" : "exact";
+    const segments = type === "param" ? pattern.split("/") : void 0;
+    this.routes.push({ method, pattern, handler, type, segments });
+  }
+  /**
+   * Match a request against registered routes.
+   * Priority: exact > parameterized > prefix. Within parameterized routes,
+   * first-registered wins if multiple patterns match at the same depth.
+   */
+  match(method, rawUrl) {
+    const url = new URL(rawUrl, "http://localhost");
+    const pathname = url.pathname;
+    const query = {};
+    url.searchParams.forEach((v, k) => {
+      query[k] = v;
+    });
+    let paramMatch;
+    let prefixMatch;
+    for (const route of this.routes) {
+      if (route.method !== method) continue;
+      if (route.type === "exact" && route.pattern === pathname) {
+        return { handler: route.handler, params: {}, query, pathname };
+      }
+      if (route.type === "param" && !paramMatch && route.segments) {
+        const parts = pathname.split("/");
+        if (parts.length === route.segments.length) {
+          const params = {};
+          let matched = true;
+          for (let i = 0; i < route.segments.length; i++) {
+            if (route.segments[i].startsWith(":")) {
+              params[route.segments[i].slice(1)] = parts[i];
+            } else if (route.segments[i] !== parts[i]) {
+              matched = false;
+              break;
+            }
+          }
+          if (matched) {
+            paramMatch = { handler: route.handler, params, query, pathname };
+          }
+        }
+      }
+      if (route.type === "prefix" && !prefixMatch) {
+        const prefix = route.pattern.slice(0, -1);
+        if (pathname.startsWith(prefix)) {
+          prefixMatch = { handler: route.handler, params: {}, query, pathname };
+        }
+      }
+    }
+    return paramMatch ?? prefixMatch;
+  }
+};
+
+// src/daemon/static.ts
+import fs from "fs";
+import path from "path";
+var HASHED_ASSET_PREFIX = "/assets/";
+var IMMUTABLE_CACHE = "public, max-age=31536000, immutable";
+var NO_CACHE = "no-cache";
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf"
+};
+function resolveStaticFile(uiDir, pathname) {
+  const relative = pathname.startsWith("/") ? pathname.slice(1) : pathname;
+  const resolved = path.resolve(uiDir, relative || "index.html");
+  if (!resolved.startsWith(path.resolve(uiDir))) {
+    return void 0;
+  }
+  if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
+    const ext = path.extname(resolved);
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+    const cacheControl = pathname.startsWith(HASHED_ASSET_PREFIX) ? IMMUTABLE_CACHE : NO_CACHE;
+    return { filePath: resolved, contentType, cacheControl };
+  }
+  const indexPath = path.join(uiDir, "index.html");
+  if (fs.existsSync(indexPath)) {
+    return { filePath: indexPath, contentType: "text/html", cacheControl: NO_CACHE };
+  }
+  return void 0;
+}
+
+// src/daemon/server.ts
+var DEFAULT_STATUS = 200;
+var DaemonServer = class {
+  port = 0;
+  version;
+  uiDir;
+  server = null;
+  vaultDir;
+  logger;
+  router = new Router();
+  onRequest;
+  constructor(config) {
+    this.vaultDir = config.vaultDir;
+    this.logger = config.logger;
+    this.uiDir = config.uiDir ?? null;
+    this.onRequest = config.onRequest ?? null;
+    this.version = getPluginVersion();
+    this.registerDefaultRoutes();
+  }
+  registerRoute(method, routePath, handler) {
+    this.router.add(method, routePath, handler);
+  }
+  async start(port = 0) {
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer((req, res) => this.handleRequest(req, res));
+      this.server.on("error", reject);
+      this.server.listen(port, "127.0.0.1", () => {
+        const addr = this.server.address();
+        this.port = addr.port;
+        this.writeDaemonJson();
+        this.logger.info(LOG_KINDS.DAEMON_PORT, "Server started", { port: this.port, dashboard: `http://localhost:${this.port}/` });
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    return new Promise((resolve) => {
+      this.removeDaemonJson();
+      if (this.server) {
+        this.server.close(() => {
+          this.logger.info(LOG_KINDS.DAEMON_START, "Server stopped");
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  registerDefaultRoutes() {
+    this.registerRoute("GET", "/health", async () => ({
+      body: {
+        myco: true,
+        version: this.version,
+        pid: process.pid,
+        uptime: process.uptime()
+      }
+    }));
+  }
+  async handleRequest(req, res) {
+    const match = this.router.match(req.method, req.url);
+    if (match) {
+      this.onRequest?.();
+      try {
+        const body = req.method === "POST" || req.method === "PUT" ? await readBody(req) : void 0;
+        const result = await match.handler({
+          body,
+          query: match.query,
+          params: match.params,
+          pathname: match.pathname
+        });
+        const status = result.status ?? DEFAULT_STATUS;
+        if (Buffer.isBuffer(result.body)) {
+          res.writeHead(status, result.headers ?? {});
+          res.end(result.body);
+          return;
+        }
+        const headers = { "Content-Type": "application/json", ...result.headers };
+        res.writeHead(status, headers);
+        res.end(JSON.stringify(result.body));
+      } catch (error) {
+        this.logger.error(LOG_KINDS.SERVER_ERROR, "Request handler error", {
+          path: req.url,
+          error: error.message
+        });
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: error.message }));
+      }
+      return;
+    }
+    if (this.uiDir && req.method === "GET") {
+      const pathname = new URL(req.url, "http://localhost").pathname;
+      const result = resolveStaticFile(this.uiDir, pathname);
+      if (result) {
+        try {
+          const content = await fs2.promises.readFile(result.filePath);
+          res.writeHead(200, {
+            "Content-Type": result.contentType,
+            "Cache-Control": result.cacheControl
+          });
+          res.end(content);
+        } catch {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "not found" }));
+        }
+        return;
+      }
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "not found" }));
+  }
+  updateDaemonJsonSessions(sessions) {
+    const jsonPath = path2.join(this.vaultDir, "daemon.json");
+    try {
+      const info = JSON.parse(fs2.readFileSync(jsonPath, "utf-8"));
+      info.sessions = sessions;
+      fs2.writeFileSync(jsonPath, JSON.stringify(info, null, 2));
+    } catch {
+    }
+  }
+  /**
+   * Kill any existing daemon for this vault before taking over.
+   * Prevents orphaned daemons when spawned from worktrees or plugin upgrades.
+   * Must be called BEFORE resolvePort() so the old daemon releases the port.
+   */
+  async evictExistingDaemon() {
+    const jsonPath = path2.join(this.vaultDir, "daemon.json");
+    let existingPid;
+    try {
+      const content = fs2.readFileSync(jsonPath, "utf-8");
+      const info = JSON.parse(content);
+      if (typeof info.pid === "number" && info.pid !== process.pid) {
+        existingPid = info.pid;
+      }
+    } catch {
+    }
+    if (!existingPid) return;
+    try {
+      process.kill(existingPid, 0);
+    } catch {
+      return;
+    }
+    this.logger.info(LOG_KINDS.DAEMON_START, "Evicting existing daemon", { pid: existingPid });
+    try {
+      process.kill(existingPid, "SIGTERM");
+    } catch {
+      return;
+    }
+    const deadline = Date.now() + DAEMON_EVICT_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, DAEMON_EVICT_POLL_MS));
+      try {
+        process.kill(existingPid, 0);
+      } catch {
+        return;
+      }
+    }
+    this.logger.warn(LOG_KINDS.DAEMON_START, "Evicted daemon did not exit in time, sending SIGKILL", { pid: existingPid });
+    try {
+      process.kill(existingPid, "SIGKILL");
+    } catch {
+      return;
+    }
+    await new Promise((r) => setTimeout(r, DAEMON_EVICT_POLL_MS));
+    try {
+      process.kill(existingPid, 0);
+    } catch {
+      return;
+    }
+    this.logger.warn(LOG_KINDS.DAEMON_START, "Evicted daemon still alive after SIGKILL", { pid: existingPid });
+  }
+  writeDaemonJson() {
+    const info = {
+      pid: process.pid,
+      port: this.port,
+      started: (/* @__PURE__ */ new Date()).toISOString(),
+      sessions: []
+    };
+    const jsonPath = path2.join(this.vaultDir, "daemon.json");
+    fs2.writeFileSync(jsonPath, JSON.stringify(info, null, 2));
+  }
+  removeDaemonJson() {
+    const jsonPath = path2.join(this.vaultDir, "daemon.json");
+    try {
+      const content = fs2.readFileSync(jsonPath, "utf-8");
+      const info = JSON.parse(content);
+      if (info.pid !== process.pid) return;
+      fs2.unlinkSync(jsonPath);
+    } catch {
+    }
+  }
+};
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk;
+    });
+    req.on("end", () => {
+      try {
+        resolve(data ? JSON.parse(data) : {});
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+// src/daemon/lifecycle.ts
+var SessionRegistry = class {
+  _sessions = /* @__PURE__ */ new Map();
+  graceTimer = null;
+  gracePeriod;
+  onEmpty;
+  constructor(options) {
+    this.gracePeriod = options.gracePeriod;
+    this.onEmpty = options.onEmpty;
+  }
+  get sessions() {
+    return [...this._sessions.keys()];
+  }
+  register(sessionId, metadata) {
+    if (!this._sessions.has(sessionId)) {
+      this._sessions.set(sessionId, metadata ?? { started_at: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+    this.cancelGrace();
+  }
+  getSession(sessionId) {
+    const meta = this._sessions.get(sessionId);
+    if (!meta) return void 0;
+    return { id: sessionId, ...meta };
+  }
+  unregister(sessionId) {
+    this._sessions.delete(sessionId);
+    if (this._sessions.size === 0) {
+      this.startGrace();
+    }
+  }
+  destroy() {
+    this.cancelGrace();
+    this._sessions.clear();
+  }
+  startGrace() {
+    this.cancelGrace();
+    this.graceTimer = setTimeout(() => {
+      if (this._sessions.size === 0) {
+        this.onEmpty();
+      }
+    }, this.gracePeriod * 1e3);
+  }
+  cancelGrace() {
+    if (this.graceTimer) {
+      clearTimeout(this.graceTimer);
+      this.graceTimer = null;
+    }
+  }
+};
+
+// src/daemon/port.ts
+import { createHash } from "crypto";
+import net from "net";
+var PORT_RANGE_START = 19200;
+var PORT_RANGE_SIZE = 1e4;
+var PORT_RETRY_COUNT = 10;
+function derivePort(vaultPath) {
+  const hash = createHash("md5").update(vaultPath).digest();
+  const num = hash.readUInt16LE(0);
+  return PORT_RANGE_START + num % PORT_RANGE_SIZE;
+}
+async function resolvePort(configPort, vaultPath) {
+  const basePort = configPort ?? derivePort(vaultPath);
+  for (let offset = 0; offset < PORT_RETRY_COUNT; offset++) {
+    const candidate = basePort + offset;
+    if (candidate > 65535) break;
+    if (await isPortAvailable(candidate)) return candidate;
+  }
+  return 0;
+}
+function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+
+// src/capture/transcript-miner.ts
+var TranscriptMiner = class {
+  registry;
+  constructor(config) {
+    this.registry = new SymbiontRegistry(config?.additionalAdapters);
+  }
+  /**
+   * Extract all conversation turns for a session.
+   * Convenience wrapper — delegates to getAllTurnsWithSource.
+   */
+  getAllTurns(sessionId) {
+    return this.getAllTurnsWithSource(sessionId).turns;
+  }
+  /**
+   * Extract turns using the hook-provided transcript path first (fast, no scanning),
+   * then fall back to adapter registry scanning if the path isn't provided.
+   */
+  getAllTurnsWithSource(sessionId, transcriptPath) {
+    if (transcriptPath) {
+      const result2 = this.registry.parseTurnsFromPath(transcriptPath);
+      if (result2) return result2;
+    }
+    const result = this.registry.getTranscriptTurns(sessionId);
+    if (result) return result;
+    return { turns: [], source: "none" };
+  }
+};
+function extractTurnsFromBuffer(events) {
+  const turns = [];
+  let current = null;
+  for (const event of events) {
+    const type = event.type;
+    if (type === "user_prompt") {
+      if (current) turns.push(current);
+      current = {
+        prompt: String(event.prompt ?? "").slice(0, PROMPT_PREVIEW_CHARS),
+        toolCount: 0,
+        timestamp: String(event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString())
+      };
+    } else if (type === "tool_use") {
+      if (current) current.toolCount++;
+    }
+  }
+  if (current) turns.push(current);
+  return turns;
+}
+
+// src/daemon/plan-capture.ts
+import { createHash as createHash2 } from "crypto";
+import path3 from "path";
+
+// src/db/queries/plans.ts
+var DEFAULT_LIST_LIMIT = 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"
+];
+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
+  };
+}
+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
+     ) 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
+  );
+  return toPlanRow(
+    db.prepare(`SELECT ${SELECT_COLUMNS} FROM plans WHERE id = ?`).get(data.id)
+  );
+}
+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_LIMIT;
+  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 = path3.isAbsolute(filePath) ? filePath : path3.resolve(projectRoot, filePath);
+  return watchDirs.some((dir) => {
+    const absDir = path3.resolve(projectRoot, dir);
+    const prefix = absDir.endsWith(path3.sep) ? absDir : absDir + path3.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 = path3.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, path3.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 {
+    ...current,
+    daemon: { ...current.daemon, ...incoming.daemon },
+    embedding: { ...current.embedding, ...incoming.embedding },
+    capture: { ...current.capture, ...incoming.capture },
+    agent: { ...current.agent, ...incoming.agent },
+    context: { ...current.context, ...incoming.context }
+  };
+}
+async function handleGetConfig(vaultDir) {
+  const config = loadConfig(vaultDir);
+  return { body: config };
+}
+async function handlePutConfig(vaultDir, body) {
+  const result = MycoConfigSchema.safeParse(body);
+  if (!result.success) {
+    return {
+      status: 400,
+      body: { error: "validation_failed", issues: result.error.issues }
+    };
+  }
+  const updated = updateConfig(vaultDir, (current) => mergeConfigSections(current, result.data));
+  return { body: updated };
+}
+
+// src/db/queries/logs.ts
+var DEFAULT_PAGE_SIZE = 100;
+var DEFAULT_STREAM_LIMIT = 200;
+function toLogEntryRow(row) {
+  return {
+    id: row.id,
+    timestamp: row.timestamp,
+    level: row.level,
+    kind: row.kind,
+    component: row.component,
+    message: row.message,
+    data: row.data ?? null,
+    session_id: row.session_id ?? null
+  };
+}
+function levelsAtOrAbove(minLevel) {
+  const minOrder = LEVEL_ORDER[minLevel] ?? 0;
+  return Object.keys(LEVEL_ORDER).filter(
+    (l) => LEVEL_ORDER[l] >= minOrder
+  );
+}
+function insertLogEntry(entry) {
+  const db = getDatabase();
+  const info = db.prepare(
+    `INSERT INTO log_entries (timestamp, level, kind, component, message, data, session_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    entry.timestamp,
+    entry.level,
+    entry.kind,
+    entry.component,
+    entry.message,
+    entry.data,
+    entry.session_id
+  );
+  return info.lastInsertRowid;
+}
+function searchLogs(params) {
+  const db = getDatabase();
+  const page = params.page ?? 1;
+  const pageSize = params.page_size ?? DEFAULT_PAGE_SIZE;
+  const offset = (page - 1) * pageSize;
+  const conditions = [];
+  const queryParams = [];
+  if (params.q !== void 0 && params.q.length > 0) {
+    conditions.push(`le.id IN (SELECT rowid FROM log_entries_fts WHERE log_entries_fts MATCH ?)`);
+    queryParams.push(params.q);
+  }
+  if (params.level !== void 0 && params.level.length > 0) {
+    const levels = levelsAtOrAbove(params.level);
+    if (levels.length > 0) {
+      conditions.push(`le.level IN (SELECT value FROM json_each(?))`);
+      queryParams.push(JSON.stringify(levels));
+    }
+  }
+  if (params.component !== void 0 && params.component.length > 0) {
+    const components = params.component.split(",").map((c) => c.trim()).filter(Boolean);
+    if (components.length > 0) {
+      conditions.push(`le.component IN (SELECT value FROM json_each(?))`);
+      queryParams.push(JSON.stringify(components));
+    }
+  }
+  if (params.kind !== void 0 && params.kind.length > 0) {
+    conditions.push(`le.kind = ?`);
+    queryParams.push(params.kind);
+  }
+  if (params.session_id !== void 0 && params.session_id.length > 0) {
+    conditions.push(`le.session_id = ?`);
+    queryParams.push(params.session_id);
+  }
+  if (params.from !== void 0 && params.from.length > 0) {
+    conditions.push(`le.timestamp >= ?`);
+    queryParams.push(params.from);
+  }
+  if (params.to !== void 0 && params.to.length > 0) {
+    conditions.push(`le.timestamp <= ?`);
+    queryParams.push(params.to);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const countRow = db.prepare(
+    `SELECT COUNT(*) as count FROM log_entries le ${where}`
+  ).get(...queryParams);
+  const rows = db.prepare(
+    `SELECT le.id, le.timestamp, le.level, le.kind, le.component, le.message, le.data, le.session_id
+     FROM log_entries le
+     ${where}
+     ORDER BY le.timestamp DESC, le.id DESC
+     LIMIT ?
+     OFFSET ?`
+  ).all(...queryParams, pageSize, offset);
+  return {
+    entries: rows.map(toLogEntryRow),
+    total: countRow.count,
+    page,
+    page_size: pageSize
+  };
+}
+function getLogsSince(sinceId, limit) {
+  const db = getDatabase();
+  const effectiveLimit = limit ?? DEFAULT_STREAM_LIMIT;
+  const rows = db.prepare(
+    `SELECT id, timestamp, level, kind, component, message, data, session_id
+     FROM log_entries
+     WHERE id > ?
+     ORDER BY id ASC
+     LIMIT ?`
+  ).all(sinceId, effectiveLimit);
+  const entries = rows.map(toLogEntryRow);
+  const cursor = entries.length > 0 ? entries[entries.length - 1].id : sinceId;
+  return { entries, cursor };
+}
+function getLogEntry(id) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT id, timestamp, level, kind, component, message, data, session_id
+     FROM log_entries
+     WHERE id = ?`
+  ).get(id);
+  if (!row) return null;
+  return toLogEntryRow(row);
+}
+function deleteOldLogs(beforeTimestamp) {
+  const db = getDatabase();
+  const info = db.prepare(
+    `DELETE FROM log_entries WHERE timestamp < ?`
+  ).run(beforeTimestamp);
+  return info.changes;
+}
+function getMaxTimestamp() {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT MAX(timestamp) as max_ts FROM log_entries`
+  ).get();
+  return row.max_ts;
+}
+
+// src/daemon/api/log-explorer.ts
+async function handleLogSearch(req) {
+  const { q, level, component, kind, session_id, from, to, page, page_size } = req.query;
+  const result = searchLogs({
+    q: q || void 0,
+    level: level || void 0,
+    component: component || void 0,
+    kind: kind || void 0,
+    session_id: session_id || void 0,
+    from: from || void 0,
+    to: to || void 0,
+    page: page ? parseInt(page, 10) : void 0,
+    page_size: page_size ? parseInt(page_size, 10) : void 0
+  });
+  return {
+    body: {
+      entries: result.entries.map(formatEntry),
+      total: result.total,
+      page: result.page,
+      page_size: result.page_size
+    }
+  };
+}
+async function handleLogStream(req) {
+  const sinceStr = req.query.since;
+  const limitStr = req.query.limit;
+  const sinceId = sinceStr ? parseInt(sinceStr, 10) : 0;
+  const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+  const result = getLogsSince(sinceId, limit);
+  return {
+    body: {
+      entries: result.entries.map(formatEntry),
+      cursor: result.cursor
+    }
+  };
+}
+async function handleLogDetail(req) {
+  const id = parseInt(req.params.id, 10);
+  if (isNaN(id)) return { status: 400, body: { error: "Invalid log entry ID" } };
+  const entry = getLogEntry(id);
+  if (!entry) return { status: 404, body: { error: "Log entry not found" } };
+  const parsed = entry.data ? JSON.parse(entry.data) : {};
+  const resolved = {};
+  if (entry.session_id) {
+    try {
+      const session = getSession(entry.session_id);
+      if (session) {
+        resolved.session_title = session.title ?? null;
+      }
+    } catch {
+    }
+  }
+  return {
+    body: {
+      ...entry,
+      data: parsed,
+      resolved
+    }
+  };
+}
+function formatEntry(entry) {
+  return {
+    ...entry,
+    data: entry.data ? JSON.parse(entry.data) : null
+  };
+}
+
+// src/daemon/api/restart.ts
+import { spawn } from "child_process";
+var RestartBodySchema = external_exports.object({
+  force: external_exports.boolean().optional()
+}).optional();
+var RESTART_RESPONSE_FLUSH_MS = 500;
+var RESTART_CHILD_DELAY_SECONDS = 3;
+async function handleRestart(deps, body) {
+  const parsed = RestartBodySchema.safeParse(body);
+  const force = parsed.success ? parsed.data?.force : false;
+  if (!force && deps.progressTracker.hasActiveOperations()) {
+    return {
+      status: 409,
+      body: { status: "busy", message: "Active operations in progress. Use force=true to override." }
+    };
+  }
+  const mycoCmd = process.env.MYCO_CMD || "myco";
+  const shellCmd = `sleep ${RESTART_CHILD_DELAY_SECONDS} && ${mycoCmd} daemon --vault ${deps.vaultDir}`;
+  const child = spawn("/bin/sh", ["-c", shellCmd], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  setTimeout(() => {
+    process.kill(process.pid, "SIGTERM");
+  }, RESTART_RESPONSE_FLUSH_MS);
+  return { body: { status: "restarting" } };
+}
+
+// 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 createHash3 } from "crypto";
+import fs3 from "fs";
+import path4 from "path";
+function computeConfigHash(vaultDir) {
+  try {
+    const configPath = path4.join(vaultDir, CONFIG_FILENAME);
+    const raw = fs3.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 = [
+  "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_PROCESSED2,
+    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);
+}
+
+// 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/daemon/api/sessions.ts
+var DEFAULT_LIST_LIMIT2 = 50;
+var DEFAULT_LIST_OFFSET = 0;
+async function handleListSessions(req) {
+  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT2;
+  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET;
+  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" } };
+  return { body: session };
+}
+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 };
+}
+
+// src/daemon/api/mycelium.ts
+var DEFAULT_LIST_LIMIT3 = 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_LIMIT3;
+  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 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_LIMIT3;
+  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET2;
+  const entities = listEntities({
+    agent_id: agentId,
+    type,
+    mentioned_in,
+    note_type,
+    limit,
+    offset
+  });
+  return { body: { entities } };
+}
+async function handleGetGraph(req) {
+  const depth = Math.min(Number(req.query.depth) || DEFAULT_GRAPH_DEPTH, MAX_GRAPH_DEPTH);
+  const center = getEntity(req.params.id);
+  if (!center) return { status: 404, body: { error: "not_found" } };
+  const graph = getGraphForNode(req.params.id, "entity", { depth });
+  const filteredEdges = graph.edges.filter(
+    (e) => !EXCLUDED_GRAPH_EDGE_TYPES.has(e.type)
+  );
+  const graphDb = getDatabase();
+  const entityIds = /* @__PURE__ */ new Set();
+  const sporeIds = /* @__PURE__ */ new Set();
+  const sessionIds = /* @__PURE__ */ new Set();
+  for (const edge of filteredEdges) {
+    for (const [id, type] of [
+      [edge.source_id, edge.source_type],
+      [edge.target_id, edge.target_type]
+    ]) {
+      switch (type) {
+        case "entity":
+          entityIds.add(id);
+          break;
+        case "spore":
+          sporeIds.add(id);
+          break;
+        case "session":
+          sessionIds.add(id);
+          break;
+      }
+    }
+  }
+  entityIds.add(center.id);
+  const entityIdArray = Array.from(entityIds);
+  let entityNodes = [];
+  if (entityIdArray.length > 0) {
+    const placeholders = entityIdArray.map(() => "?").join(", ");
+    entityNodes = graphDb.prepare(
+      `SELECT id, type, name, properties, status, first_seen as created_at
+       FROM entities WHERE id IN (${placeholders})`
+    ).all(...entityIdArray);
+  }
+  const sporeIdArray = Array.from(sporeIds);
+  let sporeNodes = [];
+  if (sporeIdArray.length > 0) {
+    const placeholders = sporeIdArray.map(() => "?").join(", ");
+    sporeNodes = graphDb.prepare(
+      `SELECT id, observation_type, status, content, properties, created_at
+       FROM spores WHERE id IN (${placeholders})`
+    ).all(...sporeIdArray);
+  }
+  const sessionIdArray = Array.from(sessionIds);
+  let sessionNodes = [];
+  if (sessionIdArray.length > 0) {
+    const placeholders = sessionIdArray.map(() => "?").join(", ");
+    sessionNodes = graphDb.prepare(
+      `SELECT id, title, summary, status, started_at as created_at
+       FROM sessions WHERE id IN (${placeholders})`
+    ).all(...sessionIdArray);
+  }
+  const mentionCounts = /* @__PURE__ */ new Map();
+  if (entityIdArray.length > 0) {
+    const placeholders = entityIdArray.map(() => "?").join(", ");
+    const mentionRows = graphDb.prepare(
+      `SELECT entity_id, COUNT(*) as count FROM entity_mentions
+       WHERE entity_id IN (${placeholders}) GROUP BY entity_id`
+    ).all(...entityIdArray);
+    for (const row of mentionRows) {
+      mentionCounts.set(row.entity_id, Number(row.count));
+    }
+  }
+  const allNodes = [
+    ...entityNodes.map((n) => ({
+      id: n.id,
+      name: n.name,
+      type: n.type,
+      status: n.status ?? void 0,
+      created_at: n.created_at,
+      properties: n.properties ?? void 0,
+      mention_count: mentionCounts.get(n.id) ?? 0
+    })),
+    ...sporeNodes.map((n) => ({
+      id: n.id,
+      name: (n.content ?? "").slice(0, SPORE_NAME_PREVIEW_CHARS),
+      type: "spore",
+      status: n.status ?? void 0,
+      created_at: n.created_at,
+      content: n.content,
+      properties: n.properties ?? void 0,
+      observation_type: n.observation_type
+    })),
+    ...sessionNodes.map((n) => ({
+      id: n.id,
+      name: n.title ?? `Session ${n.id.slice(-6)}`,
+      type: "session",
+      status: n.status ?? void 0,
+      created_at: n.created_at,
+      content: n.summary ?? void 0
+    }))
+  ];
+  const centerNode = allNodes.find((n) => n.id === center.id);
+  const uiEdges = filteredEdges.map((e) => ({
+    source_id: e.source_id,
+    target_id: e.target_id,
+    label: e.type,
+    weight: e.confidence
+  }));
+  return {
+    body: {
+      center: centerNode ?? { ...center, mention_count: mentionCounts.get(center.id) ?? 0 },
+      nodes: allNodes.filter((n) => n.id !== center.id),
+      edges: uiEdges,
+      depth
+    }
+  };
+}
+async function handleGetDigest(req) {
+  const agentId = req.query.agent_id ?? DEFAULT_AGENT_ID;
+  const extracts = listDigestExtracts(agentId);
+  return { body: { tiers: extracts } };
+}
+
+// src/daemon/api/search.ts
+function createSearchHandler(deps) {
+  return async function handleSearch(req) {
+    const query = req.query.q;
+    if (!query) return { status: 400, body: { error: "missing_query" } };
+    const mode = req.query.mode ?? "auto";
+    const type = req.query.type;
+    const limit = Number(req.query.limit) || SEARCH_RESULTS_DEFAULT_LIMIT;
+    const namespace = req.query.namespace;
+    if (mode === "fts") {
+      const results2 = fullTextSearch(query, { type, limit });
+      return { body: { mode: "fts", results: results2 } };
+    }
+    const queryVector = await deps.embeddingManager.embedQuery(query);
+    if (queryVector === null) {
+      if (mode === "auto") {
+        const results2 = fullTextSearch(query, { type, limit });
+        return { body: { mode: "fts", results: results2, fallback: true } };
+      }
+      return { body: { mode: "semantic", results: [], provider_unavailable: true } };
+    }
+    const searchNamespace = namespace ?? type;
+    const vectorResults = deps.embeddingManager.searchVectors(queryVector, {
+      namespace: searchNamespace,
+      limit,
+      threshold: SEARCH_SIMILARITY_THRESHOLD
+    });
+    const results = hydrateSearchResults(vectorResults);
+    return { body: { mode: "semantic", results } };
+  };
+}
+
+// src/daemon/api/context.ts
+var SessionContextBody = external_exports.object({
+  session_id: external_exports.string().optional(),
+  branch: external_exports.string().optional()
+});
+var PromptContextBody = external_exports.object({
+  prompt: external_exports.string(),
+  session_id: external_exports.string().optional()
+});
+function createSessionContextHandler(deps) {
+  return async function handleSessionContext(req) {
+    const { session_id, branch } = SessionContextBody.parse(req.body);
+    const { logger, config } = deps;
+    logger.debug(LOG_KINDS.CONTEXT_QUERY, "Session context query", { session_id });
+    try {
+      const parts = [];
+      const tier = config.context.digest_tier;
+      const extract = getDigestExtract(DEFAULT_AGENT_ID, tier);
+      if (extract) {
+        parts.push(extract.content);
+        logger.info(LOG_KINDS.CONTEXT_DIGEST, "Digest extract found", {
+          session_id,
+          tier,
+          content_length: extract.content.length,
+          generated_at: extract.generated_at
+        });
+      } else {
+        logger.debug(LOG_KINDS.CONTEXT_DIGEST, "No digest extract available", { session_id, tier });
+      }
+      if (branch) {
+        parts.push(`Branch:: \`${branch}\``);
+      }
+      parts.push(`Session:: \`${session_id}\``);
+      const source = extract ? "digest" : "basic";
+      const contextText = parts.join("\n\n");
+      const estimatedTokens = estimateTokens(contextText);
+      const preview = contextText.slice(0, LOG_CONTEXT_PREVIEW_CHARS);
+      logger.info(LOG_KINDS.CONTEXT_SESSION, "Session context injected", {
+        session_id,
+        source,
+        tier: extract ? tier : void 0,
+        text_length: contextText.length,
+        estimated_tokens: estimatedTokens,
+        generated_at: extract?.generated_at,
+        preview
+      });
+      logger.debug(LOG_KINDS.CONTEXT_SESSION, `Session context: "${preview}\u2026" (${estimatedTokens} est. tokens, source=${source}${extract ? `, tier=${tier}, generated=${extract.generated_at}` : ""})`, {
+        session_id
+      });
+      return {
+        body: {
+          text: contextText,
+          source,
+          ...extract ? { tier } : {}
+        }
+      };
+    } catch (error) {
+      logger.error(LOG_KINDS.CONTEXT_SESSION, "Session context failed", { error: error.message });
+      return { body: { text: "" } };
+    }
+  };
+}
+function createPromptContextHandler(deps) {
+  return async function handlePromptContext(req) {
+    const { prompt, session_id } = PromptContextBody.parse(req.body);
+    const { logger, config, embeddingManager } = deps;
+    if (!config.context.prompt_search) {
+      logger.debug(LOG_KINDS.CONTEXT_PROMPT, "Prompt search disabled by config", { session_id });
+      return { body: { text: "" } };
+    }
+    if (prompt.length < PROMPT_CONTEXT_MIN_LENGTH) {
+      logger.debug(LOG_KINDS.CONTEXT_PROMPT, "Prompt too short for search", {
+        session_id,
+        length: prompt.length,
+        min: PROMPT_CONTEXT_MIN_LENGTH
+      });
+      return { body: { text: "" } };
+    }
+    const maxSpores = config.context.prompt_max_spores;
+    if (maxSpores === 0) {
+      logger.debug(LOG_KINDS.CONTEXT_PROMPT, "Prompt spore injection disabled (max_spores=0)", { session_id });
+      return { body: { text: "" } };
+    }
+    const queryVector = await embeddingManager.embedQuery(prompt);
+    if (!queryVector) {
+      logger.debug(LOG_KINDS.CONTEXT_EMBED, "Embedding provider unavailable for prompt search", { session_id });
+      return { body: { text: "" } };
+    }
+    const vectorResults = embeddingManager.searchVectors(queryVector, {
+      namespace: "spores",
+      limit: maxSpores * PROMPT_VECTOR_OVER_FETCH,
+      threshold: PROMPT_CONTEXT_MIN_SIMILARITY
+    });
+    logger.debug(LOG_KINDS.CONTEXT_SEARCH, "Prompt vector search completed", {
+      session_id,
+      raw_results: vectorResults.length,
+      top_similarity: vectorResults[0]?.similarity
+    });
+    if (vectorResults.length === 0) {
+      return { body: { text: "" } };
+    }
+    const eligible = vectorResults.filter(
+      (r) => !EXCLUDED_SPORE_STATUSES.has(r.metadata.status)
+    );
+    if (eligible.length === 0) {
+      logger.debug(LOG_KINDS.CONTEXT_FILTER, "All spore results excluded by status filter", { session_id });
+      return { body: { text: "" } };
+    }
+    const topResults = eligible.slice(0, maxSpores);
+    const hydrated = hydrateSearchResults(topResults);
+    const spores = hydrated.filter((r) => r.type === "spore");
+    if (spores.length === 0) {
+      return { body: { text: "" } };
+    }
+    const text = formatSporeContext(spores);
+    const promptTokens = estimateTokens(text);
+    const titles = spores.map((s) => s.title);
+    logger.info(LOG_KINDS.CONTEXT_PROMPT, "Prompt context injected", {
+      session_id,
+      spore_count: spores.length,
+      scores: spores.map((s) => s.score.toFixed(3)),
+      spore_titles: titles,
+      estimated_tokens: promptTokens,
+      preview: text.slice(0, LOG_CONTEXT_PREVIEW_CHARS)
+    });
+    logger.debug(LOG_KINDS.CONTEXT_PROMPT, `Prompt context: ${spores.length} spores [${titles.join(", ")}] (~${promptTokens} tokens)`, {
+      session_id,
+      scores: spores.map((s) => s.score.toFixed(3))
+    });
+    return { body: { text } };
+  };
+}
+function formatSporeContext(spores) {
+  const header = "Relevant vault observations:";
+  let text = header;
+  let tokens = estimateTokens(text);
+  for (const spore of spores) {
+    const line = `
+- (${spore.title}) ${spore.preview}`;
+    const lineTokens = estimateTokens(line);
+    if (tokens + lineTokens > PROMPT_CONTEXT_MAX_TOKENS) break;
+    text += line;
+    tokens += lineTokens;
+  }
+  return text === header ? "" : text;
+}
+
+// src/db/queries/feed.ts
+function getActivityFeed(limit = FEED_DEFAULT_LIMIT) {
+  const db = getDatabase();
+  const rows = db.prepare(`
+    SELECT * FROM (
+      SELECT 'session' as type, id, COALESCE(title, 'Session ' || substr(id, 1, 8)) as summary,
+              COALESCE(ended_at, started_at) as timestamp
+       FROM sessions ORDER BY started_at DESC LIMIT ?
+    )
+
+    UNION ALL
+
+    SELECT * FROM (
+      SELECT 'agent_run' as type, id, task || ' \u2014 ' || status as summary,
+              COALESCE(completed_at, started_at) as timestamp
+       FROM agent_runs ORDER BY started_at DESC LIMIT ?
+    )
+
+    UNION ALL
+
+    SELECT * FROM (
+      SELECT 'spore' as type, id, observation_type || ': ' || substr(content, 1, 80) as summary,
+              created_at as timestamp
+       FROM spores WHERE status = 'active' ORDER BY created_at DESC LIMIT ?
+    )
+
+    ORDER BY timestamp DESC LIMIT ?
+  `).all(limit, limit, limit, limit);
+  return rows;
+}
+
+// src/daemon/api/feed.ts
+async function handleGetFeed(req) {
+  const limit = Number(req.query.limit) || FEED_DEFAULT_LIMIT;
+  const feed = getActivityFeed(limit);
+  return { body: feed };
+}
+
+// src/daemon/api/symbionts.ts
+async function handleListSymbionts() {
+  const manifests = loadManifests();
+  const symbionts = manifests.map((m) => ({
+    name: m.name,
+    displayName: m.displayName,
+    binary: m.binary
+  }));
+  return { body: { symbionts } };
+}
+
+// src/daemon/api/embedding.ts
+var EMBEDDING_STATUS_IDLE = "idle";
+var EMBEDDING_STATUS_PENDING = "pending";
+async function handleGetEmbeddingStatus(vaultDir) {
+  const config = loadConfig(vaultDir);
+  const { queue_depth, embedded_count } = getEmbeddingQueueDepth();
+  return {
+    body: {
+      provider: config.embedding.provider,
+      model: config.embedding.model,
+      base_url: config.embedding.base_url ?? null,
+      queue_depth,
+      embedded_count,
+      status: queue_depth === 0 ? EMBEDDING_STATUS_IDLE : EMBEDDING_STATUS_PENDING
+    }
+  };
+}
+function handleEmbeddingDetails(manager) {
+  const details = manager.getDetails();
+  return { body: details };
+}
+function handleEmbeddingRebuild(manager) {
+  const result = manager.rebuildAll();
+  return { body: result };
+}
+async function handleEmbeddingReconcile(manager) {
+  const result = await manager.reconcile(EMBEDDING_BATCH_SIZE);
+  return { body: result };
+}
+function handleEmbeddingCleanOrphans(manager) {
+  const result = manager.cleanOrphans();
+  return { body: result };
+}
+async function handleEmbeddingReembedStale(manager) {
+  const result = await manager.reembedStale(EMBEDDING_BATCH_SIZE);
+  return { body: result };
+}
+
+// src/daemon/embedding/manager.ts
+import { createHash as createHash4 } from "crypto";
+var ACTIVE_STATUS = "active";
+var EmbeddingManager = class {
+  constructor(vectorStore, embeddingProvider, recordSource, logger) {
+    this.vectorStore = vectorStore;
+    this.embeddingProvider = embeddingProvider;
+    this.recordSource = recordSource;
+    this.logger = logger;
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  contentHash(text) {
+    return createHash4(CONTENT_HASH_ALGORITHM).update(text).digest("hex");
+  }
+  // -------------------------------------------------------------------------
+  // Write-path event handlers
+  // -------------------------------------------------------------------------
+  /**
+   * Called when content is written (session note, spore, plan, artifact).
+   * Embeds the text and stores the vector. Fire-and-forget safe.
+   */
+  async onContentWritten(namespace, id, text, metadata) {
+    try {
+      const embedding = await this.embeddingProvider.embed(text);
+      if (embedding === null) {
+        this.logger.warn(LOG_KINDS.EMBEDDING_PROVIDER, "Provider unavailable, skipping embed", {
+          namespace,
+          id
+        });
+        return;
+      }
+      const hash = this.contentHash(text);
+      this.vectorStore.upsert(namespace, id, embedding, {
+        model: this.embeddingProvider.model,
+        provider: this.embeddingProvider.providerName,
+        dimensions: this.embeddingProvider.dimensions,
+        content_hash: hash,
+        embedded_at: epochSeconds(),
+        domain_metadata: metadata
+      });
+      this.recordSource.markEmbedded(namespace, id);
+      this.logger.debug(LOG_KINDS.EMBEDDING_EMBED, "Vector stored", { namespace, id });
+    } catch (err) {
+      this.logger.warn(LOG_KINDS.EMBEDDING_EMBED, "Failed to embed content", {
+        namespace,
+        id,
+        error: String(err)
+      });
+    }
+  }
+  /**
+   * Called when a spore's status changes (e.g., superseded, archived).
+   * Removes the vector for non-active statuses.
+   */
+  onStatusChanged(namespace, id, status) {
+    try {
+      if (status === ACTIVE_STATUS) return;
+      this.vectorStore.remove(namespace, id);
+      this.recordSource.clearEmbedded(namespace, id);
+      this.logger.debug(LOG_KINDS.EMBEDDING_CLEANUP, "Vector removed", {
+        namespace,
+        id,
+        reason: `status=${status}`
+      });
+    } catch (err) {
+      this.logger.warn(LOG_KINDS.EMBEDDING_CLEANUP, "Failed to remove vector on status change", {
+        namespace,
+        id,
+        status,
+        error: String(err)
+      });
+    }
+  }
+  /**
+   * Called when a record is deleted. Removes the vector.
+   * No clearEmbedded needed — the record itself is being deleted.
+   */
+  onRemoved(namespace, id) {
+    try {
+      this.vectorStore.remove(namespace, id);
+      this.logger.debug(LOG_KINDS.EMBEDDING_CLEANUP, "Vector removed", {
+        namespace,
+        id,
+        reason: "record deleted"
+      });
+    } catch (err) {
+      this.logger.warn(LOG_KINDS.EMBEDDING_CLEANUP, "Failed to remove vector on delete", {
+        namespace,
+        id,
+        error: String(err)
+      });
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Reconciliation
+  // -------------------------------------------------------------------------
+  /**
+   * Embed missing rows, re-embed stale vectors, and clean orphans across all namespaces.
+   * Called by the reconcile worker on a timer.
+   */
+  async reconcile(batchSize) {
+    const start = Date.now();
+    let embedded = 0;
+    let stale_reembedded = 0;
+    let orphans_cleaned = 0;
+    const currentModel = this.embeddingProvider.model;
+    for (const namespace of EMBEDDABLE_TABLES) {
+      const rows = this.recordSource.getEmbeddableRows(namespace, batchSize);
+      for (const row of rows) {
+        const embedding = await this.embeddingProvider.embed(row.text);
+        if (embedding === null) {
+          this.logger.warn(LOG_KINDS.EMBEDDING_PROVIDER, "Provider unavailable during reconcile, returning partial progress", {
+            namespace,
+            embedded
+          });
+          return {
+            embedded,
+            stale_reembedded,
+            orphans_cleaned,
+            duration_ms: Date.now() - start
+          };
+        }
+        const hash = this.contentHash(row.text);
+        this.vectorStore.upsert(namespace, row.id, embedding, {
+          model: currentModel,
+          provider: this.embeddingProvider.providerName,
+          dimensions: this.embeddingProvider.dimensions,
+          content_hash: hash,
+          embedded_at: epochSeconds(),
+          domain_metadata: row.metadata
+        });
+        this.recordSource.markEmbedded(namespace, row.id);
+        embedded++;
+      }
+      const staleIds = this.vectorStore.getStaleIds(namespace, currentModel, batchSize);
+      if (staleIds.length > 0) {
+        const records = this.recordSource.getRecordContent(namespace, staleIds);
+        const foundIds = new Set(records.map((r) => r.id));
+        for (const record of records) {
+          const embedding = await this.embeddingProvider.embed(record.text);
+          if (embedding === null) {
+            this.logger.warn(LOG_KINDS.EMBEDDING_PROVIDER, "Provider unavailable during stale re-embed, returning partial progress", {
+              namespace,
+              stale_reembedded
+            });
+            return {
+              embedded,
+              stale_reembedded,
+              orphans_cleaned,
+              duration_ms: Date.now() - start
+            };
+          }
+          this.vectorStore.upsert(namespace, record.id, embedding, {
+            model: currentModel,
+            provider: this.embeddingProvider.providerName,
+            dimensions: this.embeddingProvider.dimensions,
+            content_hash: this.contentHash(record.text),
+            embedded_at: epochSeconds(),
+            domain_metadata: record.metadata
+          });
+          stale_reembedded++;
+        }
+        for (const staleId of staleIds) {
+          if (!foundIds.has(staleId)) {
+            this.vectorStore.remove(namespace, staleId);
+            this.logger.warn(LOG_KINDS.EMBEDDING_CLEANUP, "Stale orphan vector cleaned", {
+              namespace,
+              id: staleId
+            });
+            orphans_cleaned++;
+          }
+        }
+      }
+      orphans_cleaned += this.sweepOrphans(namespace);
+    }
+    const duration_ms = Date.now() - start;
+    if (embedded > 0 || stale_reembedded > 0 || orphans_cleaned > 0) {
+      this.logger.info(LOG_KINDS.EMBEDDING_RECONCILE, "Reconcile cycle completed", {
+        embedded,
+        stale_reembedded,
+        orphans_cleaned,
+        duration_ms
+      });
+    }
+    return { embedded, stale_reembedded, orphans_cleaned, duration_ms };
+  }
+  /**
+   * Remove orphan vectors (vectors without corresponding active records).
+   */
+  cleanOrphans() {
+    let orphans_cleaned = 0;
+    for (const namespace of EMBEDDABLE_TABLES) {
+      orphans_cleaned += this.sweepOrphans(namespace);
+    }
+    return { orphans_cleaned };
+  }
+  // -------------------------------------------------------------------------
+  // Operations
+  // -------------------------------------------------------------------------
+  /**
+   * Clear all vectors and reset embedded flags.
+   * The reconcile worker picks up all rows on subsequent cycles.
+   */
+  rebuildAll() {
+    const { cleared } = this.vectorStore.clear();
+    this.recordSource.clearAllEmbedded();
+    this.logger.info(LOG_KINDS.EMBEDDING_REBUILD, "Rebuild started", { cleared });
+    return { queued: cleared };
+  }
+  /**
+   * Re-embed vectors that were created with a different model.
+   */
+  async reembedStale(batchSize) {
+    let reembedded = 0;
+    const currentModel = this.embeddingProvider.model;
+    for (const namespace of EMBEDDABLE_TABLES) {
+      const staleIds = this.vectorStore.getStaleIds(namespace, currentModel, batchSize);
+      if (staleIds.length === 0) continue;
+      const records = this.recordSource.getRecordContent(namespace, staleIds);
+      for (const record of records) {
+        const embedding = await this.embeddingProvider.embed(record.text);
+        if (embedding === null) {
+          this.logger.warn(LOG_KINDS.EMBEDDING_PROVIDER, "Provider unavailable during re-embed", {
+            namespace,
+            reembedded
+          });
+          return { reembedded };
+        }
+        const hash = this.contentHash(record.text);
+        this.vectorStore.upsert(namespace, record.id, embedding, {
+          model: currentModel,
+          provider: this.embeddingProvider.providerName,
+          dimensions: this.embeddingProvider.dimensions,
+          content_hash: hash,
+          embedded_at: epochSeconds(),
+          domain_metadata: record.metadata
+        });
+        reembedded++;
+      }
+    }
+    return { reembedded };
+  }
+  /**
+   * Get details for the operations UI: vector stats, pending counts, provider info.
+   */
+  getDetails() {
+    const stats = this.vectorStore.stats();
+    const pending = {};
+    for (const namespace of EMBEDDABLE_TABLES) {
+      pending[namespace] = this.recordSource.getPendingCount(namespace);
+    }
+    return {
+      ...stats,
+      pending,
+      provider: {
+        name: this.embeddingProvider.providerName,
+        model: this.embeddingProvider.model,
+        available: true
+        // If we got here, the manager was constructed with a provider
+      }
+    };
+  }
+  /**
+   * Pass-through for search handler — embed a query string.
+   */
+  async embedQuery(text) {
+    return this.embeddingProvider.embed(text);
+  }
+  /**
+   * Pass-through for search handler — similarity search via the vector store.
+   * Keeps the VectorStore private to the manager.
+   */
+  searchVectors(query, options) {
+    return this.vectorStore.search(query, options);
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  /**
+   * Sweep orphan vectors for a single namespace. Returns count removed.
+   *
+   * Compares vector IDs against active record IDs — vectors without a matching
+   * active record are removed. Does NOT short-circuit on count equality because
+   * equal counts can mask orphans (e.g., 3 orphan vectors + 3 active records
+   * missing vectors = same count, zero cleanup).
+   */
+  sweepOrphans(namespace) {
+    const embeddedIds = this.vectorStore.getEmbeddedIds(namespace);
+    if (embeddedIds.length === 0) return 0;
+    const activeIds = this.recordSource.getActiveRecordIds(namespace);
+    const activeSet = new Set(activeIds);
+    let cleaned = 0;
+    for (const vecId of embeddedIds) {
+      if (!activeSet.has(vecId)) {
+        this.vectorStore.remove(namespace, vecId);
+        this.logger.warn(LOG_KINDS.EMBEDDING_CLEANUP, "Orphan vector cleaned", {
+          namespace,
+          id: vecId
+        });
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+};
+
+// src/daemon/embedding/sqlite-vec-store.ts
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+var DEFAULT_SEARCH_LIMIT = 10;
+var DEFAULT_SIMILARITY_THRESHOLD = 0;
+var DEFAULT_META_MODEL = "unknown";
+var DEFAULT_META_PROVIDER = "unknown";
+var DEFAULT_META_CONTENT_HASH = "";
+var FILTERABLE_COLUMNS = /* @__PURE__ */ new Set(["model", "provider", "namespace"]);
+function cosineDistanceToSimilarity(distance) {
+  return 1 - distance;
+}
+var METADATA_TABLE = `
+  CREATE TABLE IF NOT EXISTS embedding_metadata (
+    namespace       TEXT NOT NULL,
+    record_id       TEXT NOT NULL,
+    model           TEXT NOT NULL,
+    provider        TEXT NOT NULL,
+    dimensions      INTEGER NOT NULL,
+    content_hash    TEXT NOT NULL,
+    embedded_at     INTEGER NOT NULL,
+    domain_metadata TEXT,
+    PRIMARY KEY (namespace, record_id)
+  )`;
+var METADATA_MODEL_INDEX = `
+  CREATE INDEX IF NOT EXISTS idx_emb_meta_model
+  ON embedding_metadata (namespace, model)`;
+function vecTableDDL(namespace) {
+  return `CREATE VIRTUAL TABLE IF NOT EXISTS vec_${namespace} USING vec0(
+    record_id TEXT PRIMARY KEY,
+    embedding float[${EMBEDDING_DIMENSIONS}] distance_metric=cosine
+  )`;
+}
+var SqliteVecVectorStore = class {
+  db;
+  // Cached prepared statements (lazy-initialized per namespace)
+  deleteVecStmts = /* @__PURE__ */ new Map();
+  insertVecStmts = /* @__PURE__ */ new Map();
+  upsertMetaStmt;
+  deleteMetaStmt;
+  searchStmts = /* @__PURE__ */ new Map();
+  statsCountStmt;
+  statsModelsStmt;
+  staleIdsStmt;
+  embeddedIdsStmt;
+  constructor(dbPath) {
+    this.db = new Database(dbPath ?? ":memory:");
+    sqliteVec.load(this.db);
+    this.db.pragma("journal_mode = WAL");
+    this.createSchema();
+    this.prepareStatements();
+  }
+  // -------------------------------------------------------------------------
+  // Schema
+  // -------------------------------------------------------------------------
+  createSchema() {
+    this.db.exec(METADATA_TABLE);
+    this.db.exec(METADATA_MODEL_INDEX);
+    for (const ns of EMBEDDABLE_TABLES) {
+      this.db.exec(vecTableDDL(ns));
+    }
+  }
+  prepareStatements() {
+    this.upsertMetaStmt = this.db.prepare(`
+      INSERT INTO embedding_metadata (namespace, record_id, model, provider, dimensions, content_hash, embedded_at, domain_metadata)
+      VALUES (@namespace, @record_id, @model, @provider, @dimensions, @content_hash, @embedded_at, @domain_metadata)
+      ON CONFLICT (namespace, record_id) DO UPDATE SET
+        model = excluded.model,
+        provider = excluded.provider,
+        dimensions = excluded.dimensions,
+        content_hash = excluded.content_hash,
+        embedded_at = excluded.embedded_at,
+        domain_metadata = excluded.domain_metadata
+    `);
+    this.deleteMetaStmt = this.db.prepare(
+      `DELETE FROM embedding_metadata WHERE namespace = ? AND record_id = ?`
+    );
+    this.statsCountStmt = this.db.prepare(
+      `SELECT COUNT(*) AS cnt FROM embedding_metadata WHERE namespace = ?`
+    );
+    this.statsModelsStmt = this.db.prepare(
+      `SELECT model, COUNT(*) AS cnt FROM embedding_metadata WHERE namespace = ? GROUP BY model`
+    );
+    this.staleIdsStmt = this.db.prepare(
+      `SELECT record_id FROM embedding_metadata WHERE namespace = ? AND model != ? LIMIT ?`
+    );
+    this.embeddedIdsStmt = this.db.prepare(
+      `SELECT record_id FROM embedding_metadata WHERE namespace = ?`
+    );
+    for (const ns of EMBEDDABLE_TABLES) {
+      this.deleteVecStmts.set(
+        ns,
+        this.db.prepare(`DELETE FROM vec_${ns} WHERE record_id = ?`)
+      );
+      this.insertVecStmts.set(
+        ns,
+        this.db.prepare(`INSERT INTO vec_${ns}(record_id, embedding) VALUES (?, ?)`)
+      );
+      this.searchStmts.set(
+        ns,
+        this.db.prepare(`
+          SELECT v.record_id, v.distance,
+                 em.model, em.provider, em.content_hash, em.embedded_at, em.domain_metadata
+          FROM vec_${ns} v
+          LEFT JOIN embedding_metadata em
+            ON em.namespace = '${ns}' AND em.record_id = v.record_id
+          WHERE v.embedding MATCH ?
+            AND k = ?
+          ORDER BY v.distance
+        `)
+      );
+    }
+  }
+  // -------------------------------------------------------------------------
+  // VectorStore interface
+  // -------------------------------------------------------------------------
+  upsert(namespace, id, embedding, metadata) {
+    this.validateNamespace(namespace);
+    const ns = namespace;
+    const vec = new Float32Array(embedding);
+    const txn = this.db.transaction(() => {
+      this.deleteVecStmts.get(ns).run(id);
+      this.insertVecStmts.get(ns).run(id, vec);
+      this.upsertMetaStmt.run({
+        namespace: ns,
+        record_id: id,
+        model: metadata?.["model"] ?? DEFAULT_META_MODEL,
+        provider: metadata?.["provider"] ?? DEFAULT_META_PROVIDER,
+        dimensions: embedding.length,
+        content_hash: metadata?.["content_hash"] ?? DEFAULT_META_CONTENT_HASH,
+        embedded_at: metadata?.["embedded_at"] ?? Date.now(),
+        domain_metadata: metadata?.["domain_metadata"] ? JSON.stringify(metadata["domain_metadata"]) : null
+      });
+    });
+    txn();
+  }
+  remove(namespace, id) {
+    this.validateNamespace(namespace);
+    const ns = namespace;
+    const txn = this.db.transaction(() => {
+      this.deleteVecStmts.get(ns).run(id);
+      this.deleteMetaStmt.run(ns, id);
+    });
+    txn();
+  }
+  clear(namespace) {
+    let cleared = 0;
+    const targets = namespace ? [this.validatedNamespace(namespace)] : [...EMBEDDABLE_TABLES];
+    const txn = this.db.transaction(() => {
+      for (const ns of targets) {
+        const countRow = this.db.prepare(`SELECT COUNT(*) as cnt FROM embedding_metadata WHERE namespace = ?`).get(ns);
+        cleared += countRow.cnt;
+        this.db.exec(`DELETE FROM vec_${ns}`);
+        this.db.prepare(`DELETE FROM embedding_metadata WHERE namespace = ?`).run(ns);
+      }
+    });
+    txn();
+    return { cleared };
+  }
+  /**
+   * KNN similarity search across one or all namespaces.
+   *
+   * Threshold filtering is applied **post-KNN**: sqlite-vec returns the top-k
+   * nearest neighbors first, then results below `threshold` are discarded.
+   * This means fewer than `limit` results may be returned when a threshold is set.
+   * This is standard KNN behavior, not a bug.
+   */
+  search(query, options) {
+    const limit = options?.limit ?? DEFAULT_SEARCH_LIMIT;
+    const threshold = options?.threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
+    const queryVec = new Float32Array(query);
+    const targets = options?.namespace ? [this.validatedNamespace(options.namespace)] : [...EMBEDDABLE_TABLES];
+    const hasFilters = options?.filters && Object.keys(options.filters).length > 0;
+    const results = [];
+    for (const ns of targets) {
+      let rows;
+      if (hasFilters) {
+        const { sql, params } = this.buildFilteredSearchQuery(
+          ns,
+          options.filters,
+          limit
+        );
+        const stmt = this.db.prepare(sql);
+        rows = stmt.all(queryVec, limit, ...params);
+      } else {
+        rows = this.searchStmts.get(ns).all(queryVec, limit);
+      }
+      for (const row of rows) {
+        const similarity = cosineDistanceToSimilarity(row.distance);
+        if (similarity >= threshold) {
+          results.push({
+            id: row.record_id,
+            namespace: ns,
+            similarity,
+            metadata: {
+              model: row.model,
+              provider: row.provider,
+              content_hash: row.content_hash,
+              embedded_at: row.embedded_at,
+              ...row.domain_metadata ? JSON.parse(row.domain_metadata) : {}
+            }
+          });
+        }
+      }
+    }
+    results.sort((a, b) => b.similarity - a.similarity);
+    return results.slice(0, limit);
+  }
+  stats(namespace) {
+    const targets = namespace ? [this.validatedNamespace(namespace)] : [...EMBEDDABLE_TABLES];
+    let total = 0;
+    const by_namespace = {};
+    const models = {};
+    for (const ns of targets) {
+      const countRow = this.statsCountStmt.get(ns);
+      const modelRows = this.statsModelsStmt.all(ns);
+      let stale = 0;
+      let maxModelCount = 0;
+      for (const mr of modelRows) {
+        models[mr.model] = (models[mr.model] ?? 0) + mr.cnt;
+        if (mr.cnt > maxModelCount) maxModelCount = mr.cnt;
+      }
+      stale = countRow.cnt - maxModelCount;
+      if (stale < 0) stale = 0;
+      by_namespace[ns] = { embedded: countRow.cnt, stale };
+      total += countRow.cnt;
+    }
+    return { total, by_namespace, models };
+  }
+  getStaleIds(namespace, currentModel, limit) {
+    this.validateNamespace(namespace);
+    const rows = this.staleIdsStmt.all(namespace, currentModel, limit);
+    return rows.map((r) => r.record_id);
+  }
+  getEmbeddedIds(namespace) {
+    this.validateNamespace(namespace);
+    const rows = this.embeddedIdsStmt.all(namespace);
+    return rows.map((r) => r.record_id);
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  close() {
+    this.db.close();
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  validateNamespace(namespace) {
+    if (!EMBEDDABLE_TABLES.includes(namespace)) {
+      throw new Error(
+        `Invalid namespace "${namespace}". Must be one of: ${EMBEDDABLE_TABLES.join(", ")}`
+      );
+    }
+  }
+  validatedNamespace(namespace) {
+    this.validateNamespace(namespace);
+    return namespace;
+  }
+  /**
+   * Build a filtered KNN query that JOINs vec results with embedding_metadata.
+   * Filters are applied as WHERE conditions on the metadata table.
+   */
+  buildFilteredSearchQuery(namespace, filters, _limit) {
+    const conditions = [];
+    const params = [];
+    for (const [key, value] of Object.entries(filters)) {
+      if (FILTERABLE_COLUMNS.has(key)) {
+        conditions.push(`em.${key} = ?`);
+        params.push(value);
+      }
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const sql = `
+      WITH knn AS (
+        SELECT record_id, distance
+        FROM vec_${namespace}
+        WHERE embedding MATCH ?
+          AND k = ?
+        ORDER BY distance
+      )
+      SELECT knn.record_id, knn.distance,
+             em.model, em.provider, em.content_hash, em.embedded_at, em.domain_metadata
+      FROM knn
+      INNER JOIN embedding_metadata em
+        ON em.namespace = '${namespace}' AND em.record_id = knn.record_id
+      ${whereClause}
+    `;
+    return { sql, params };
+  }
+};
+
+// src/intelligence/embeddings.ts
+async function generateEmbedding(backend, text) {
+  const raw = await backend.embed(text);
+  return {
+    embedding: normalize(raw.embedding),
+    model: raw.model,
+    dimensions: raw.dimensions
+  };
+}
+function normalize(vec) {
+  const magnitude = Math.sqrt(vec.reduce((sum, v) => sum + v * v, 0));
+  if (magnitude === 0) return vec;
+  return vec.map((v) => v / magnitude);
+}
+
+// src/daemon/embedding/provider-adapter.ts
+var AVAILABILITY_CACHE_TTL_MS = 5e3;
+var OLLAMA_DEFAULT_TAG = ":latest";
+var TAGGED_PROVIDERS = /* @__PURE__ */ new Set(["ollama"]);
+function normalizeModelName(model, provider) {
+  if (TAGGED_PROVIDERS.has(provider) && !model.includes(":")) {
+    return model + OLLAMA_DEFAULT_TAG;
+  }
+  return model;
+}
+var EmbeddingProviderAdapter = class {
+  constructor(provider, config) {
+    this.provider = provider;
+    this.model = normalizeModelName(config.model, config.provider);
+    this.providerName = config.provider;
+    this.dimensions = EMBEDDING_DIMENSIONS;
+  }
+  model;
+  providerName;
+  dimensions;
+  /** Cached availability state to avoid per-embed HTTP probes. */
+  cachedAvailable = null;
+  cachedAvailableAt = 0;
+  async embed(text) {
+    try {
+      const isUp = await this.checkAvailability();
+      if (!isUp) return null;
+      const result = await generateEmbedding(this.provider, text);
+      return result.embedding;
+    } catch {
+      this.cachedAvailable = null;
+      return null;
+    }
+  }
+  /** Check availability with a short TTL cache to avoid HTTP probes on every call. */
+  async checkAvailability() {
+    const now = Date.now();
+    if (this.cachedAvailable !== null && now - this.cachedAvailableAt < AVAILABILITY_CACHE_TTL_MS) {
+      return this.cachedAvailable;
+    }
+    this.cachedAvailable = await this.provider.isAvailable();
+    this.cachedAvailableAt = now;
+    return this.cachedAvailable;
+  }
+};
+
+// src/daemon/embedding/record-source.ts
+var ACTIVE_STATUS2 = "active";
+function sessionMetadata(row) {
+  return {
+    ...row.project_root != null ? { project_root: row.project_root } : {}
+  };
+}
+function sporeMetadata(row) {
+  return {
+    ...row.status != null ? { status: row.status } : {},
+    ...row.session_id != null ? { session_id: row.session_id } : {},
+    ...row.observation_type != null ? { observation_type: row.observation_type } : {}
+  };
+}
+function emptyMetadata() {
+  return {};
+}
+function planMetadata(row) {
+  return {
+    ...row.session_id != null ? { session_id: row.session_id } : {},
+    ...row.source_path != null ? { source_path: row.source_path } : {}
+  };
+}
+function metadataFor(namespace, row) {
+  switch (namespace) {
+    case "sessions":
+      return sessionMetadata(row);
+    case "spores":
+      return sporeMetadata(row);
+    case "plans":
+      return planMetadata(row);
+    case "artifacts":
+      return emptyMetadata();
+  }
+}
+var SqliteRecordSource = class {
+  /**
+   * Get rows that need embedding (embedded=0, content non-null).
+   *
+   * For spores: additionally filters WHERE status = 'active'.
+   * For sessions: delegates to getUnembedded (which filters summary IS NOT NULL).
+   */
+  getEmbeddableRows(namespace, limit) {
+    assertValidTable(namespace);
+    if (namespace === "spores") {
+      return this.getUnembeddedActiveSpores(limit);
+    }
+    const rows = getUnembedded(namespace, limit);
+    const db = getDatabase();
+    return rows.map((row) => {
+      const fullRow = db.prepare(`SELECT * FROM ${namespace} WHERE id = ?`).get(row.id);
+      return {
+        id: String(row.id),
+        text: row.text,
+        metadata: metadataFor(namespace, fullRow)
+      };
+    });
+  }
+  /**
+   * Get IDs of all records that should have embeddings.
+   *
+   * - sessions: those with a non-null summary
+   * - spores: those with status = 'active'
+   * - plans/artifacts: those with non-null content
+   */
+  getActiveRecordIds(namespace) {
+    assertValidTable(namespace);
+    const db = getDatabase();
+    switch (namespace) {
+      case "sessions": {
+        const rows = db.prepare(
+          `SELECT id FROM sessions WHERE summary IS NOT NULL`
+        ).all();
+        return rows.map((r) => r.id);
+      }
+      case "spores": {
+        const rows = db.prepare(
+          `SELECT id FROM spores WHERE status = ?`
+        ).all(ACTIVE_STATUS2);
+        return rows.map((r) => r.id);
+      }
+      case "plans": {
+        const rows = db.prepare(
+          `SELECT id FROM plans WHERE content IS NOT NULL`
+        ).all();
+        return rows.map((r) => r.id);
+      }
+      case "artifacts": {
+        const rows = db.prepare(
+          `SELECT id FROM artifacts WHERE content IS NOT NULL`
+        ).all();
+        return rows.map((r) => r.id);
+      }
+    }
+  }
+  /**
+   * Fetch content + metadata for specific record IDs.
+   *
+   * Returns same shape as getEmbeddableRows but for specific records.
+   * Empty ids array returns empty result.
+   */
+  getRecordContent(namespace, ids) {
+    assertValidTable(namespace);
+    if (ids.length === 0) return [];
+    const db = getDatabase();
+    const textCol = EMBEDDABLE_TEXT_COLUMNS[namespace];
+    const placeholders = ids.map(() => "?").join(", ");
+    const rows = db.prepare(
+      `SELECT *, ${textCol} AS text FROM ${namespace} WHERE id IN (${placeholders})`
+    ).all(...ids);
+    return rows.map((row) => ({
+      id: String(row.id),
+      text: row.text,
+      metadata: metadataFor(namespace, row)
+    }));
+  }
+  /** Mark a record as embedded. Delegates to existing helper. */
+  markEmbedded(namespace, id) {
+    markEmbedded(namespace, id);
+  }
+  /** Clear the embedded flag on a record. Delegates to existing helper. */
+  clearEmbedded(namespace, id) {
+    clearEmbedded(namespace, id);
+  }
+  /**
+   * Clear the embedded flag on all records, optionally scoped to a namespace.
+   *
+   * If namespace is omitted, clears all embeddable tables.
+   */
+  clearAllEmbedded(namespace) {
+    const db = getDatabase();
+    if (namespace !== void 0) {
+      assertValidTable(namespace);
+      db.prepare(`UPDATE ${namespace} SET embedded = 0`).run();
+      return;
+    }
+    for (const table of EMBEDDABLE_TABLES) {
+      db.prepare(`UPDATE ${table} SET embedded = 0`).run();
+    }
+  }
+  /**
+   * Count rows that need embedding — lightweight SELECT COUNT(*), no row materialization.
+   */
+  getPendingCount(namespace) {
+    assertValidTable(namespace);
+    const db = getDatabase();
+    const contentFilter = namespace === "sessions" ? " AND summary IS NOT NULL" : "";
+    const statusFilter = namespace === "spores" ? ` AND status = '${ACTIVE_STATUS2}'` : "";
+    const row = db.prepare(
+      `SELECT COUNT(*) AS cnt FROM ${namespace} WHERE embedded = 0${contentFilter}${statusFilter}`
+    ).get();
+    return Number(row.cnt);
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  /** Custom query for spores: embedded=0 AND status='active'. */
+  getUnembeddedActiveSpores(limit) {
+    const db = getDatabase();
+    const rows = db.prepare(
+      `SELECT id, content AS text, status, session_id, observation_type
+       FROM spores
+       WHERE embedded = 0 AND status = ?
+       ORDER BY created_at ASC
+       LIMIT ?`
+    ).all(ACTIVE_STATUS2, limit);
+    return rows.map((row) => ({
+      id: String(row.id),
+      text: row.text,
+      metadata: sporeMetadata(row)
+    }));
+  }
+};
+
+// src/daemon/api/agent-tasks.ts
+var import_yaml = __toESM(require_dist(), 1);
+var HTTP_OK = 200;
+var HTTP_CREATED = 201;
+var HTTP_BAD_REQUEST = 400;
+var HTTP_FORBIDDEN = 403;
+var HTTP_NOT_FOUND = 404;
+var HTTP_CONFLICT = 409;
+async function handleListTasks(req, vaultDir) {
+  const definitionsDir = resolveDefinitionsDir();
+  const allTasks = loadAllTasks(definitionsDir, vaultDir);
+  let tasks = Array.from(allTasks.values());
+  const sourceFilter = req.query?.source;
+  if (sourceFilter) {
+    tasks = tasks.filter((t) => t.source === sourceFilter);
+  }
+  return { status: HTTP_OK, body: { tasks } };
+}
+async function handleGetTask(req, vaultDir) {
+  const definitionsDir = resolveDefinitionsDir();
+  const allTasks = loadAllTasks(definitionsDir, vaultDir);
+  const task = allTasks.get(req.params.id);
+  if (!task) {
+    return { status: HTTP_NOT_FOUND, body: { error: "task_not_found" } };
+  }
+  return { status: HTTP_OK, body: { task } };
+}
+async function handleCreateTask(req, vaultDir) {
+  const result = AgentTaskSchema.safeParse(req.body);
+  if (!result.success) {
+    return {
+      status: HTTP_BAD_REQUEST,
+      body: { error: "validation_failed", issues: result.error.issues }
+    };
+  }
+  const parsed = result.data;
+  if (!validateTaskName(parsed.name)) {
+    return {
+      status: HTTP_BAD_REQUEST,
+      body: { error: "invalid_task_name", name: parsed.name }
+    };
+  }
+  const definitionsDir = resolveDefinitionsDir();
+  const allTasks = loadAllTasks(definitionsDir, vaultDir);
+  const existing = allTasks.get(parsed.name);
+  if (existing && existing.source === USER_TASK_SOURCE) {
+    return {
+      status: HTTP_CONFLICT,
+      body: { error: "task_already_exists", name: parsed.name }
+    };
+  }
+  const task = {
+    ...parsed,
+    isBuiltin: false,
+    source: USER_TASK_SOURCE
+  };
+  writeUserTask(vaultDir, task);
+  return { status: HTTP_CREATED, body: { task } };
+}
+async function handleCopyTask(req, vaultDir) {
+  const sourceName = req.params.id;
+  const newName = req.body?.name;
+  const definitionsDir = resolveDefinitionsDir();
+  if (newName !== void 0 && !validateTaskName(newName)) {
+    return {
+      status: HTTP_BAD_REQUEST,
+      body: { error: "invalid_task_name", name: newName }
+    };
+  }
+  try {
+    const copy = copyTaskToUser(definitionsDir, vaultDir, sourceName, newName);
+    return { status: HTTP_CREATED, body: { task: copy } };
+  } catch (err) {
+    const message = errorMessage(err);
+    if (message.includes("not found")) {
+      return { status: HTTP_NOT_FOUND, body: { error: "task_not_found", name: sourceName } };
+    }
+    return { status: HTTP_BAD_REQUEST, body: { error: "copy_failed", message } };
+  }
+}
+async function handleGetTaskYaml(req, vaultDir) {
+  const taskName = req.params.id;
+  const definitionsDir = resolveDefinitionsDir();
+  const allTasks = loadAllTasks(definitionsDir, vaultDir);
+  const task = allTasks.get(taskName);
+  if (!task) {
+    return { status: HTTP_NOT_FOUND, body: { error: "task_not_found", name: taskName } };
+  }
+  const { isBuiltin: _ib, source: _src, ...serializable } = task;
+  const yaml = (0, import_yaml.stringify)(serializable);
+  return { status: HTTP_OK, body: { yaml, source: task.source } };
+}
+async function handleUpdateTask(req, vaultDir) {
+  const taskName = req.params.id;
+  const definitionsDir = resolveDefinitionsDir();
+  const allTasks = loadAllTasks(definitionsDir, vaultDir);
+  const existing = allTasks.get(taskName);
+  if (!existing) {
+    return { status: HTTP_NOT_FOUND, body: { error: "task_not_found", name: taskName } };
+  }
+  if (existing.isBuiltin || existing.source !== USER_TASK_SOURCE) {
+    return { status: HTTP_FORBIDDEN, body: { error: "cannot_update_builtin", name: taskName } };
+  }
+  const body = req.body;
+  const yamlContent = body?.yaml;
+  if (typeof yamlContent !== "string") {
+    return { status: HTTP_BAD_REQUEST, body: { error: "missing_yaml_field" } };
+  }
+  try {
+    const parsed = AgentTaskSchema.parse((0, import_yaml.parse)(yamlContent));
+    const task = { ...taskFromParsed(parsed), isBuiltin: false, source: USER_TASK_SOURCE };
+    if (task.name !== taskName) {
+      return { status: HTTP_BAD_REQUEST, body: { error: "name_mismatch", expected: taskName, got: task.name } };
+    }
+    writeUserTask(vaultDir, task);
+    return { status: HTTP_OK, body: { task } };
+  } catch (err) {
+    const message = errorMessage(err);
+    return { status: HTTP_BAD_REQUEST, body: { error: "validation_failed", message } };
+  }
+}
+async function handleDeleteTask(req, vaultDir) {
+  const taskName = req.params.id;
+  const definitionsDir = resolveDefinitionsDir();
+  const allTasks = loadAllTasks(definitionsDir, vaultDir);
+  const task = allTasks.get(taskName);
+  if (!task) {
+    return { status: HTTP_NOT_FOUND, body: { error: "task_not_found", name: taskName } };
+  }
+  if (task.isBuiltin || task.source !== USER_TASK_SOURCE) {
+    return {
+      status: HTTP_FORBIDDEN,
+      body: { error: "cannot_delete_builtin", name: taskName }
+    };
+  }
+  deleteUserTask(vaultDir, taskName);
+  return { status: HTTP_OK, body: { deleted: taskName } };
+}
+async function handleGetTaskConfig(req, vaultDir) {
+  const taskId = req.params.id;
+  const config = loadConfig(vaultDir);
+  const taskConfig = config.agent.tasks?.[taskId] ?? null;
+  return { status: HTTP_OK, body: { taskId, config: taskConfig } };
+}
+async function handleUpdateTaskConfig(req, vaultDir) {
+  const taskId = req.params.id;
+  const body = req.body;
+  if (!body) {
+    return { status: HTTP_BAD_REQUEST, body: { error: "missing_body" } };
+  }
+  const updated = updateConfig(
+    vaultDir,
+    (config) => withTaskConfig(config, taskId, body)
+  );
+  return {
+    status: HTTP_OK,
+    body: { taskId, config: updated.agent.tasks?.[taskId] ?? null }
+  };
+}
+
+// src/daemon/api/providers.ts
+var HTTP_OK2 = 200;
+var HTTP_BAD_REQUEST2 = 400;
+async function handleGetProviders() {
+  const results = await Promise.allSettled([
+    detectLocalProviderInfo("ollama", OllamaBackend.DEFAULT_BASE_URL),
+    detectLocalProviderInfo("lmstudio", LmStudioBackend.DEFAULT_BASE_URL),
+    detectCloud()
+  ]);
+  const providers = results.map(
+    (r) => r.status === "fulfilled" ? r.value : { type: "unknown", available: false, models: [] }
+  );
+  return { status: HTTP_OK2, body: { providers } };
+}
+async function handleTestProvider(req) {
+  const body = req.body;
+  const type = body?.type;
+  if (!type || !["cloud", "ollama", "lmstudio"].includes(type)) {
+    return {
+      status: HTTP_BAD_REQUEST2,
+      body: { error: "type is required and must be one of: cloud, ollama, lmstudio" }
+    };
+  }
+  const baseUrl = body?.baseUrl;
+  const start = performance.now();
+  let result;
+  try {
+    if (type === "ollama") {
+      result = await testLocalProvider(new OllamaBackend({ base_url: baseUrl }), "Ollama", OllamaBackend.DEFAULT_BASE_URL, baseUrl);
+    } else if (type === "lmstudio") {
+      result = await testLocalProvider(new LmStudioBackend({ base_url: baseUrl }), "LM Studio", LmStudioBackend.DEFAULT_BASE_URL, baseUrl);
+    } else {
+      result = testCloud();
+    }
+  } catch (err) {
+    result = { ok: false, error: String(err) };
+  }
+  if (result.ok) {
+    result.latency_ms = Math.round(performance.now() - start);
+  }
+  return { status: HTTP_OK2, body: result };
+}
+async function detectLocalProviderInfo(type, defaultBaseUrl) {
+  const status = await checkLocalProvider(type);
+  const models = status.models.filter((m) => !/-ctx\d+/.test(m));
+  return { type, available: status.available, baseUrl: defaultBaseUrl, models };
+}
+async function detectCloud() {
+  return { type: "cloud", available: true, models: ANTHROPIC_MODELS };
+}
+async function testLocalProvider(backend, label, defaultBaseUrl, baseUrl) {
+  const available = await backend.isAvailable();
+  if (!available) {
+    return { ok: false, error: `${label} not reachable at ${baseUrl ?? defaultBaseUrl}` };
+  }
+  return { ok: true };
+}
+function testCloud() {
+  return { ok: true };
+}
+
+// src/daemon/log-reconcile.ts
+import fs4 from "fs";
+import path5 from "path";
+function reconcileLogBuffer(logDir, sinceTimestamp) {
+  let replayed = 0;
+  const files = [];
+  for (let i = 3; i >= 1; i--) {
+    const rotated = path5.join(logDir, `daemon.${i}.log`);
+    if (fs4.existsSync(rotated)) files.push(rotated);
+  }
+  const current = path5.join(logDir, "daemon.log");
+  if (fs4.existsSync(current)) files.push(current);
+  for (const file of files) {
+    const content = fs4.readFileSync(file, "utf-8");
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.timestamp > sinceTimestamp) {
+          const { timestamp, level, kind, component, message, ...rest } = entry;
+          insertLogEntry({
+            timestamp,
+            level,
+            kind: kind ?? `${component ?? "unknown"}.unknown`,
+            component: component ?? kindToComponent(kind ?? "unknown"),
+            message,
+            data: Object.keys(rest).length > 0 ? JSON.stringify(rest) : null,
+            session_id: rest.session_id ?? null
+          });
+          replayed++;
+        }
+      } catch {
+      }
+    }
+  }
+  return replayed;
+}
+
+// src/daemon/power.ts
+var PowerManager = class {
+  state = "active";
+  lastActivity = Date.now();
+  jobs = [];
+  timer = null;
+  running = false;
+  config;
+  logger;
+  constructor(config) {
+    this.config = config;
+    this.logger = config.logger;
+  }
+  register(job) {
+    this.jobs.push(job);
+  }
+  recordActivity() {
+    this.lastActivity = Date.now();
+    if (this.state === "deep_sleep") {
+      this.logger.info(LOG_KINDS.POWER_STATE, "Waking from deep sleep");
+      this.state = "active";
+      this.scheduleNextTick();
+    }
+  }
+  start() {
+    this.lastActivity = Date.now();
+    this.state = "active";
+    this.running = true;
+    this.scheduleNextTick();
+    this.logger.info(LOG_KINDS.POWER_STATE, "PowerManager started", {
+      jobs: this.jobs.map((j) => j.name)
+    });
+  }
+  stop() {
+    this.running = false;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.logger.info(LOG_KINDS.POWER_STATE, "PowerManager stopped");
+  }
+  getState() {
+    this.evaluateState();
+    return this.state;
+  }
+  evaluateState() {
+    const idleMs = Date.now() - this.lastActivity;
+    let target;
+    if (idleMs >= this.config.deepSleepThresholdMs) {
+      target = "deep_sleep";
+    } else if (idleMs >= this.config.sleepThresholdMs) {
+      target = "sleep";
+    } else if (idleMs >= this.config.idleThresholdMs) {
+      target = "idle";
+    } else {
+      target = "active";
+    }
+    if (target !== this.state) {
+      this.logger.info(LOG_KINDS.POWER_STATE, "Power state transition", {
+        from: this.state,
+        to: target,
+        idle_ms: idleMs
+      });
+      this.state = target;
+    }
+  }
+  scheduleNextTick() {
+    if (!this.running) return;
+    if (this.timer) clearTimeout(this.timer);
+    const interval = this.state === "sleep" ? this.config.sleepIntervalMs : this.config.activeIntervalMs;
+    this.timer = setTimeout(() => this.tick(), interval);
+  }
+  async tick() {
+    if (!this.running) return;
+    this.evaluateState();
+    if (this.state === "deep_sleep") {
+      this.logger.info(LOG_KINDS.POWER_STATE, "Entering deep sleep \u2014 timer stopped");
+      this.timer = null;
+      return;
+    }
+    const eligible = this.jobs.filter((j) => j.runIn.includes(this.state));
+    this.logger.debug(LOG_KINDS.POWER_TICK, "Tick", {
+      state: this.state,
+      jobs: eligible.map((j) => j.name)
+    });
+    for (const job of eligible) {
+      try {
+        await job.fn();
+      } catch (err) {
+        this.logger.error(LOG_KINDS.POWER_JOB_ERROR, `Job "${job.name}" failed`, {
+          error: err.message
+        });
+      }
+    }
+    this.scheduleNextTick();
+  }
+};
+
+// 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) {
+  const db = getDatabase();
+  const cutoff = epochSeconds() - STALE_SESSION_THRESHOLD_S;
+  const excludePlaceholders = registeredSessionIds.length > 0 ? `AND id NOT IN (${registeredSessionIds.map(() => "?").join(", ")})` : "";
+  const params = [cutoff, ...registeredSessionIds];
+  const info = db.prepare(
+    `UPDATE sessions
+     SET status = 'completed'
+     WHERE status = 'active'
+       AND COALESCE(
+         (SELECT MAX(pb.started_at) FROM prompt_batches pb WHERE pb.session_id = sessions.id),
+         sessions.started_at
+       ) < ?
+       ${excludePlaceholders}`
+  ).run(...params);
+  return info.changes;
+}
+function findDeadSessionIds(registeredSessionIds) {
+  const db = getDatabase();
+  const excludePlaceholders = registeredSessionIds.length > 0 ? `AND id NOT IN (${registeredSessionIds.map(() => "?").join(", ")})` : "";
+  const params = [DEAD_SESSION_MAX_PROMPTS, ...registeredSessionIds];
+  const rows = db.prepare(
+    `SELECT id FROM sessions
+     WHERE prompt_count <= ?
+       ${excludePlaceholders}`
+  ).all(...params);
+  return rows.map((r) => r.id);
+}
+async function runSessionMaintenance(deps) {
+  const { logger, registeredSessionIds, embeddingManager, vaultDir } = deps;
+  const registered = registeredSessionIds();
+  const completed = completeStaleActiveSessions(registered);
+  if (completed > 0) {
+    logger.info(LOG_KINDS.MAINTENANCE_SESSION, "Completed stale sessions", { count: completed });
+  }
+  const deadIds = findDeadSessionIds(registered);
+  if (deadIds.length === 0) return;
+  let deletedCount = 0;
+  for (const sessionId of deadIds) {
+    const result = deleteSessionCascade(sessionId);
+    if (!result.deleted) continue;
+    await cleanupAfterSessionCascade(sessionId, result, embeddingManager, vaultDir);
+    deletedCount++;
+    logger.info(LOG_KINDS.MAINTENANCE_SESSION, "Deleted dead session", {
+      session_id: sessionId,
+      counts: result.counts
+    });
+  }
+  if (deletedCount > 0) {
+    logger.info(LOG_KINDS.MAINTENANCE_SESSION, "Dead session cleanup complete", { deleted: deletedCount });
+  }
+}
+
+// src/daemon/main.ts
+import fs5 from "fs";
+import path6 from "path";
+var AGENT_RUNS_DEFAULT_LIMIT = 50;
+var TOOL_INPUT_STORE_LIMIT = 4e3;
+var TOOL_OUTPUT_STORE_LIMIT = 2e3;
+var TITLE_PREVIEW_CHARS = 80;
+var SYSTEM_MESSAGE_PREFIXES = [
+  "<task-notification>",
+  "<system-reminder>"
+];
+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);
+  const batch = insertBatchStateless({
+    session_id: sessionId,
+    user_prompt: prompt ?? null,
+    started_at: now,
+    created_at: now
+  });
+  const promptNumber = batch.prompt_number;
+  try {
+    createBatchLineage(DEFAULT_AGENT_ID, sessionId, batch.id, now);
+  } catch {
+  }
+  updateSession(sessionId, { prompt_count: promptNumber });
+  return { batchId: batch.id, promptNumber };
+}
+function handleToolUse(sessionId, toolName, toolInput, toolOutput) {
+  const now = epochSeconds();
+  const inputObj = toolInput;
+  const filePath = typeof inputObj?.file_path === "string" ? inputObj.file_path : null;
+  const activity = insertActivityWithBatch({
+    session_id: sessionId,
+    tool_name: toolName,
+    tool_input: toolInput ? JSON.stringify(toolInput).slice(0, TOOL_INPUT_STORE_LIMIT) : null,
+    tool_output_summary: toolOutput?.slice(0, TOOL_OUTPUT_STORE_LIMIT) ?? null,
+    file_path: filePath,
+    timestamp: now,
+    created_at: now
+  });
+  if (activity.prompt_batch_id !== null) {
+    incrementActivityCount(activity.prompt_batch_id);
+  }
+}
+function handleStopBatches(sessionId) {
+  closeOpenBatches(sessionId, epochSeconds());
+}
+function handleToolFailure(sessionId, toolName, toolInput, error, isInterrupt) {
+  const now = epochSeconds();
+  const inputObj = toolInput;
+  const filePath = typeof inputObj?.file_path === "string" ? inputObj.file_path : null;
+  const activity = insertActivityWithBatch({
+    session_id: sessionId,
+    tool_name: toolName,
+    tool_input: toolInput ? JSON.stringify(toolInput).slice(0, TOOL_INPUT_STORE_LIMIT) : null,
+    tool_output_summary: error?.slice(0, TOOL_OUTPUT_STORE_LIMIT) ?? null,
+    file_path: filePath,
+    success: 0,
+    error_message: error?.slice(0, TOOL_OUTPUT_STORE_LIMIT) ?? (isInterrupt ? "interrupted" : null),
+    timestamp: now,
+    created_at: now
+  });
+  if (activity.prompt_batch_id !== null) {
+    incrementActivityCount(activity.prompt_batch_id);
+  }
+}
+function handleSubagentStart(sessionId, agentId, agentType) {
+  const now = epochSeconds();
+  insertActivityWithBatch({
+    session_id: sessionId,
+    tool_name: "subagent_start",
+    tool_input: JSON.stringify({ agent_id: agentId, agent_type: agentType }).slice(0, TOOL_INPUT_STORE_LIMIT),
+    timestamp: now,
+    created_at: now
+  });
+}
+function handleSubagentStop(sessionId, agentId, agentType, lastAssistantMessage) {
+  const now = epochSeconds();
+  insertActivityWithBatch({
+    session_id: sessionId,
+    tool_name: "subagent_stop",
+    tool_input: JSON.stringify({ agent_id: agentId, agent_type: agentType }).slice(0, TOOL_INPUT_STORE_LIMIT),
+    tool_output_summary: lastAssistantMessage?.slice(0, TOOL_OUTPUT_STORE_LIMIT) ?? null,
+    timestamp: now,
+    created_at: now
+  });
+}
+function handleStopFailure(sessionId, error, errorDetails) {
+  const now = epochSeconds();
+  insertActivityWithBatch({
+    session_id: sessionId,
+    tool_name: "stop_failure",
+    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 = path6.join(vaultDir, "daemon.json");
+  try {
+    if (!fs5.existsSync(daemonJsonPath)) return;
+    const info = JSON.parse(fs5.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 {
+    }
+    fs5.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 = path6.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(path6.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
+  });
+  logger.info(LOG_KINDS.CAPTURE_PLAN, "Plan watch directories", { dirs: planWatchConfig.watchDirs });
+  const db = initDatabase(vaultDbPath(vaultDir));
+  createSchema(db);
+  logger.info(LOG_KINDS.DAEMON_START, "SQLite initialized", { vault: vaultDir });
+  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 lastLogTimestamp = getMaxTimestamp();
+  if (lastLogTimestamp) {
+    const logDir = path6.join(vaultDir, "logs");
+    const replayedCount = reconcileLogBuffer(logDir, lastLogTimestamp);
+    if (replayedCount > 0) {
+      logger.info(LOG_KINDS.DAEMON_RECONCILE, `Replayed ${replayedCount} log entries from buffer`, { replayed: replayedCount });
+    }
+  }
+  const vectorsDbPath = path6.join(vaultDir, "vectors.db");
+  const 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 });
+  try {
+    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-SH67XD54.js");
+    const 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)
+      });
+    }
+  } catch (err) {
+    logger.warn(LOG_KINDS.AGENT_ERROR, "Failed to clean stale runs", { error: err.message });
+  }
+  let uiDir = null;
+  {
+    const root = findPackageRoot(path6.dirname(new URL(import.meta.url).pathname));
+    if (root) {
+      const candidate = path6.join(root, "dist", "ui");
+      if (fs5.existsSync(candidate)) uiDir = candidate;
+    }
+  }
+  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,
+    onRequest: () => powerManager.recordActivity()
+  });
+  const registry = new SessionRegistry({
+    gracePeriod: 0,
+    onEmpty: () => {
+    }
+  });
+  const transcriptMiner = new TranscriptMiner({
+    additionalAdapters: config.capture.transcript_paths.map(
+      (p) => createPerProjectAdapter(p, claudeCodeAdapter.parseTurns)
+    )
+  });
+  let activeStopProcessing = null;
+  const sessionTitleCache = /* @__PURE__ */ new Map();
+  async function triggerTitleSummary(sessionId) {
+    if (config.agent.summary_batch_interval <= 0) return;
+    const running = getRunningRun(DEFAULT_AGENT_ID);
+    if (running) return;
+    try {
+      const { runAgent } = await import("./executor-ONSDHPGX.js");
+      runAgent(vaultDir, {
+        task: "title-summary",
+        instruction: `Process session ${sessionId} only`,
+        embeddingManager
+      }).catch((err) => logger.warn(LOG_KINDS.AGENT_ERROR, "Title-summary task failed", { error: String(err) }));
+    } catch {
+    }
+  }
+  const bufferDir = path6.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) });
+    }
+  }
+  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;
+  }
+  function reconcileSession(sessionId) {
+    if (reconciledSessions.has(sessionId)) return;
+    reconciledSessions.add(sessionId);
+    const bufferPath = path6.join(bufferDir, `${sessionId}.jsonl`);
+    if (!fs5.existsSync(bufferPath)) return;
+    const content = fs5.readFileSync(bufferPath, "utf-8").trim();
+    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
+      });
+    }
+  }
+  const RegisterBody = external_exports.object({
+    session_id: external_exports.string(),
+    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) => {
+    const { session_id, 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: "claude-code",
+      user: null,
+      project_root: process.cwd(),
+      branch: branch ?? null,
+      started_at: startedEpoch,
+      created_at: now,
+      status: "active"
+    });
+    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 });
+    return { body: { ok: true, sessions: registry.sessions } };
+  });
+  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 });
+    return { body: { ok: true, sessions: registry.sessions } };
+  });
+  server.registerRoute("POST", "/events", async (req) => {
+    const validated = EventBody.parse(req.body);
+    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 });
+      logger.debug(LOG_KINDS.LIFECYCLE_AUTO_REGISTER, "Auto-registered session from event", { session_id: event.session_id });
+      const now = epochSeconds();
+      const startedEpoch = Math.floor(new Date(event.timestamp).getTime() / 1e3);
+      upsertSession({
+        id: event.session_id,
+        agent: "claude-code",
+        status: "active",
+        started_at: startedEpoch,
+        created_at: now
+      });
+      reconcileSession(event.session_id);
+    }
+    if (!sessionBuffers.has(event.session_id)) {
+      sessionBuffers.set(event.session_id, new EventBuffer(bufferDir, event.session_id));
+    }
+    sessionBuffers.get(event.session_id).append(event);
+    if (event.type === "user_prompt") {
+      const promptText = String(event.prompt ?? "");
+      if (isSystemMessage(promptText)) {
+        logger.debug(LOG_KINDS.HOOKS_PROMPT, "Skipped system-injected message", {
+          session_id: event.session_id,
+          prefix: promptText.trimStart().slice(0, LOG_PROMPT_PREVIEW_CHARS)
+        });
+      } else {
+        logger.info(LOG_KINDS.HOOKS_PROMPT, "User prompt received", {
+          session_id: event.session_id,
+          prompt_preview: promptText.slice(0, LOG_PROMPT_PREVIEW_CHARS),
+          prompt_length: promptText.length
+        });
+        try {
+          const { batchId, promptNumber } = handleUserPrompt(event.session_id, promptText || void 0);
+          logger.debug(LOG_KINDS.CAPTURE_BATCH, "Batch opened", { session_id: event.session_id, batch_id: batchId, prompt_number: promptNumber });
+          const batchCount = promptNumber;
+          const summaryInterval = config.agent.summary_batch_interval;
+          if (summaryInterval > 0 && batchCount > 0 && batchCount % summaryInterval === 0) {
+            triggerTitleSummary(event.session_id);
+          }
+        } catch (err) {
+          logger.warn(LOG_KINDS.CAPTURE_BATCH, "Failed to open batch", { session_id: event.session_id, error: err.message });
+        }
+      }
+    }
+    if (event.type === "tool_use") {
+      const toolName = String(event.tool_name ?? "");
+      logger.debug(LOG_KINDS.HOOKS_TOOL, "Tool use event", {
+        session_id: event.session_id,
+        tool_name: toolName
+      });
+      const planFilePath = isPlanWriteEvent(
+        toolName,
+        event.tool_input,
+        planWatchConfig
+      );
+      if (planFilePath) {
+        const captureSessionId = event.session_id;
+        fs5.promises.readFile(planFilePath, "utf-8").then((planContent) => {
+          const latestBatch = getLatestBatch(captureSessionId);
+          capturePlan({
+            sourcePath: path6.relative(projectRoot, planFilePath),
+            content: planContent,
+            sessionId: captureSessionId,
+            promptBatchId: latestBatch?.id ?? null
+          });
+          logger.info(LOG_KINDS.CAPTURE_PLAN, "Plan captured", {
+            session_id: captureSessionId,
+            source_path: planFilePath
+          });
+        }).catch((err) => {
+          logger.warn(LOG_KINDS.CAPTURE_PLAN, "Failed to capture plan", {
+            error: err.message,
+            path: planFilePath
+          });
+        });
+      }
+      try {
+        handleToolUse(
+          event.session_id,
+          toolName,
+          event.tool_input,
+          typeof event.output_preview === "string" ? event.output_preview : void 0
+        );
+      } catch (err) {
+        logger.warn(LOG_KINDS.CAPTURE_ACTIVITY, "Failed to record activity", { session_id: event.session_id, error: err.message });
+      }
+    }
+    if (event.type === "tool_failure") {
+      const toolName = String(event.tool_name ?? "");
+      logger.info(LOG_KINDS.HOOKS_TOOL, "Tool failure event", {
+        session_id: event.session_id,
+        tool_name: toolName,
+        is_interrupt: !!event.is_interrupt
+      });
+      try {
+        handleToolFailure(
+          event.session_id,
+          toolName,
+          event.tool_input,
+          typeof event.error === "string" ? event.error : void 0,
+          !!event.is_interrupt
+        );
+      } catch (err) {
+        logger.warn(LOG_KINDS.CAPTURE_ACTIVITY, "Failed to record tool failure", { session_id: event.session_id, error: err.message });
+      }
+    }
+    if (event.type === "subagent_start") {
+      logger.info(LOG_KINDS.HOOKS_SUBAGENT, "Subagent start event", {
+        session_id: event.session_id,
+        agent_id: event.agent_id,
+        agent_type: event.agent_type
+      });
+      try {
+        handleSubagentStart(
+          event.session_id,
+          typeof event.agent_id === "string" ? event.agent_id : void 0,
+          typeof event.agent_type === "string" ? event.agent_type : void 0
+        );
+      } catch (err) {
+        logger.warn(LOG_KINDS.CAPTURE_ACTIVITY, "Failed to record subagent start", { session_id: event.session_id, error: err.message });
+      }
+    }
+    if (event.type === "subagent_stop") {
+      logger.info(LOG_KINDS.HOOKS_SUBAGENT, "Subagent stop event", {
+        session_id: event.session_id,
+        agent_id: event.agent_id,
+        agent_type: event.agent_type
+      });
+      try {
+        handleSubagentStop(
+          event.session_id,
+          typeof event.agent_id === "string" ? event.agent_id : void 0,
+          typeof event.agent_type === "string" ? event.agent_type : void 0,
+          typeof event.last_assistant_message === "string" ? event.last_assistant_message : void 0
+        );
+      } catch (err) {
+        logger.warn(LOG_KINDS.CAPTURE_ACTIVITY, "Failed to record subagent stop", { session_id: event.session_id, error: err.message });
+      }
+    }
+    if (event.type === "stop_failure") {
+      logger.warn(LOG_KINDS.HOOKS_STOP, "Stop failure event", {
+        session_id: event.session_id,
+        error: event.error
+      });
+      try {
+        handleStopFailure(
+          event.session_id,
+          typeof event.error === "string" ? event.error : void 0,
+          typeof event.error_details === "string" ? event.error_details : void 0
+        );
+      } catch (err) {
+        logger.warn(LOG_KINDS.CAPTURE_ACTIVITY, "Failed to record stop failure", { session_id: event.session_id, error: err.message });
+      }
+    }
+    if (event.type === "task_completed") {
+      logger.info(LOG_KINDS.HOOKS_EVENT, "Task completed event", {
+        session_id: event.session_id,
+        task_id: event.task_id,
+        task_subject: event.task_subject
+      });
+      try {
+        handleTaskCompleted(
+          event.session_id,
+          typeof event.task_id === "string" ? event.task_id : void 0,
+          typeof event.task_subject === "string" ? event.task_subject : void 0,
+          typeof event.task_description === "string" ? event.task_description : void 0
+        );
+      } catch (err) {
+        logger.warn(LOG_KINDS.CAPTURE_ACTIVITY, "Failed to record task completion", { session_id: event.session_id, error: err.message });
+      }
+    }
+    if (event.type === "pre_compact") {
+      logger.info(LOG_KINDS.HOOKS_EVENT, "Pre-compact event", { session_id: event.session_id });
+      try {
+        handleCompact(
+          event.session_id,
+          "pre",
+          typeof event.trigger === "string" ? event.trigger : void 0,
+          void 0
+        );
+      } catch (err) {
+        logger.warn(LOG_KINDS.CAPTURE_ACTIVITY, "Failed to record pre-compact", { session_id: event.session_id, error: err.message });
+      }
+    }
+    if (event.type === "post_compact") {
+      logger.info(LOG_KINDS.HOOKS_EVENT, "Post-compact event", { session_id: event.session_id });
+      try {
+        handleCompact(
+          event.session_id,
+          "post",
+          typeof event.trigger === "string" ? event.trigger : void 0,
+          typeof event.compact_summary === "string" ? event.compact_summary : void 0
+        );
+      } catch (err) {
+        logger.warn(LOG_KINDS.CAPTURE_ACTIVITY, "Failed to record post-compact", { session_id: event.session_id, error: err.message });
+      }
+    }
+    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 });
+    }
+    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 } };
+  });
+  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];
+      }
+    }
+  }
+  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
+    });
+    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 updateFields = {
+      transcript_path: hookTranscriptPath ?? null,
+      prompt_count: allTurns.length,
+      tool_count: allTurns.reduce((sum, t) => sum + t.toolCount, 0)
+    };
+    if (user) updateFields.user = user;
+    if (!hasTitle && sessionTitleCache.has(sessionId)) {
+      updateFields.title = sessionTitleCache.get(sessionId);
+    }
+    updateSession(sessionId, updateFields);
+    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) });
+      }
+    }
+    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 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("PUT", "/api/config", async (req) => {
+    const result = await handlePutConfig(vaultDir, req.body);
+    if (!result.status || result.status < 400) {
+      configHash = computeConfigHash(vaultDir);
+    }
+    return result;
+  });
+  const symbiontPlanDirsByAgent = {};
+  for (const m of manifests) {
+    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 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/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("GET", "/api/models", async (req) => handleGetModels(req));
+  server.registerRoute("POST", "/api/restart", async (req) => handleRestart({ vaultDir, progressTracker }, req.body));
+  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 } };
+  });
+  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/spores", handleListSpores);
+  server.registerRoute("GET", "/api/spores/:id", handleGetSpore);
+  server.registerRoute("GET", "/api/entities", handleListEntities);
+  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 = path6.join(vaultDir, "attachments", filename);
+    let diskData;
+    try {
+      diskData = fs5.readFileSync(filePath);
+    } catch {
+      return { status: 404, body: { error: "not_found" } };
+    }
+    const ext = path6.extname(filename).slice(1).toLowerCase();
+    const contentType = ATTACHMENT_MEDIA_TYPES[ext] ?? "application/octet-stream";
+    return { status: 200, headers: { "Content-Type": contentType }, body: diskData };
+  });
+  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, agentId } = AgentRunBody.parse(req.body);
+    const { runAgent } = await import("./executor-ONSDHPGX.js");
+    const resultPromise = runAgent(vaultDir, { task, instruction, agentId, embeddingManager });
+    const effectiveAgentId = agentId ?? "myco-agent";
+    const latestRun = getRunningRun(effectiveAgentId);
+    const runId = latestRun?.id;
+    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/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));
+  server.registerRoute("PUT", "/api/agent/tasks/:id", async (req) => handleUpdateTask(req, vaultDir));
+  server.registerRoute("POST", "/api/agent/tasks", async (req) => handleCreateTask(req, vaultDir));
+  server.registerRoute("POST", "/api/agent/tasks/:id/copy", async (req) => handleCopyTask(req, vaultDir));
+  server.registerRoute("DELETE", "/api/agent/tasks/:id", async (req) => handleDeleteTask(req, vaultDir));
+  server.registerRoute("GET", "/api/agent/tasks/:id/config", async (req) => handleGetTaskConfig(req, vaultDir));
+  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,
+      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-TFEQPVKS.js");
+    const resolutionId = `res-${randomBytes(RESOLUTION_ID_RANDOM_BYTES).toString("hex")}`;
+    insertResolutionEvent({
+      id: resolutionId,
+      agent_id: USER_AGENT_ID,
+      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"
+      }
+    };
+  });
+  server.registerRoute("GET", "/api/search", createSearchHandler({ embeddingManager }));
+  server.registerRoute("GET", "/api/activity", handleGetFeed);
+  server.registerRoute("GET", "/api/embedding/status", async () => handleGetEmbeddingStatus(vaultDir));
+  server.registerRoute("GET", "/api/embedding/details", async () => handleEmbeddingDetails(embeddingManager));
+  server.registerRoute("POST", "/api/embedding/rebuild", async () => handleEmbeddingRebuild(embeddingManager));
+  server.registerRoute("POST", "/api/embedding/reconcile", async () => handleEmbeddingReconcile(embeddingManager));
+  server.registerRoute("POST", "/api/embedding/clean-orphans", async () => handleEmbeddingCleanOrphans(embeddingManager));
+  server.registerRoute("POST", "/api/embedding/reembed-stale", async () => handleEmbeddingReembedStale(embeddingManager));
+  await server.evictExistingDaemon();
+  const resolvedPort = await resolvePort(config.daemon.port, vaultDir);
+  if (resolvedPort === 0) {
+    logger.warn(LOG_KINDS.DAEMON_PORT, "All preferred ports occupied, using ephemeral port");
+  }
+  await server.start(resolvedPort);
+  logger.info(LOG_KINDS.DAEMON_READY, "Daemon ready", { vault: vaultDir, port: server.port });
+  if (config.daemon.port === null && resolvedPort !== 0) {
+    try {
+      updateConfig(vaultDir, (c) => ({
+        ...c,
+        daemon: { ...c.daemon, port: resolvedPort }
+      }));
+      logger.info(LOG_KINDS.DAEMON_CONFIG, "Persisted auto-derived port to myco.yaml", { port: resolvedPort });
+    } catch (err) {
+      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
+    })
+  });
+  if (config.agent.auto_run) {
+    let agentRunning = false;
+    const agentIntervalMs = config.agent.interval_seconds * MS_PER_SECOND;
+    const lastRunRow = getDatabase().prepare(
+      `SELECT started_at FROM agent_runs WHERE agent_id = ? AND status IN ('completed', 'failed') ORDER BY started_at DESC LIMIT 1`
+    ).get(DEFAULT_AGENT_ID);
+    let lastAgentRun = lastRunRow ? lastRunRow.started_at * MS_PER_SECOND : 0;
+    powerManager.register({
+      name: "agent-auto-run",
+      runIn: ["active", "idle"],
+      fn: async () => {
+        if (agentRunning) return;
+        if (Date.now() - lastAgentRun < agentIntervalMs) return;
+        const agentDb = getDatabase();
+        const checkRow = agentDb.prepare("SELECT COUNT(*) as count FROM prompt_batches WHERE processed = 0").get();
+        const count = Number(checkRow.count);
+        if (count === 0) {
+          logger.debug(LOG_KINDS.AGENT_AUTO_RUN, "No unprocessed batches, skipping cycle");
+          return;
+        }
+        agentRunning = true;
+        lastAgentRun = Date.now();
+        try {
+          logger.info(LOG_KINDS.AGENT_AUTO_RUN, "Unprocessed batches found, starting agent", { count });
+          const { runAgent } = await import("./executor-ONSDHPGX.js");
+          const runResult = await runAgent(vaultDir, { embeddingManager });
+          logger.info(LOG_KINDS.AGENT_RUN, "Agent run completed", { status: runResult.status, runId: runResult.runId });
+        } catch (err) {
+          logger.error(LOG_KINDS.AGENT_ERROR, "Agent auto-run failed", { error: err.message });
+        } finally {
+          agentRunning = false;
+        }
+      }
+    });
+  } else {
+    logger.info(LOG_KINDS.AGENT_AUTO_RUN, "Auto-agent disabled (agent.auto_run = false)");
+  }
+  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.start();
+  const shutdown = async (signal) => {
+    logger.info(LOG_KINDS.DAEMON_START, `${signal} received`);
+    powerManager.stop();
+    if (activeStopProcessing) {
+      logger.info(LOG_KINDS.DAEMON_START, "Waiting for active stop processing to complete...");
+      await activeStopProcessing;
+    }
+    registry.destroy();
+    await server.stop();
+    vectorStore.close();
+    closeDatabase();
+    logger.close();
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+}
+export {
+  handleCompact,
+  handleStopBatches,
+  handleStopFailure,
+  handleSubagentStart,
+  handleSubagentStop,
+  handleTaskCompleted,
+  handleToolFailure,
+  handleToolUse,
+  handleUserPrompt,
+  main
+};
+//# sourceMappingURL=main-BMCL7CPO.js.map