@goondocks/myco 0.15.0 → 0.16.0

package/dist/{main-JB3R3DQE.js → main-VAU5UPY7.js}

@@ -2,8 +2,19 @@ import { createRequire as __cr } from 'node:module'; const require = __cr(import
 import {
   DaemonLogger,
   LEVEL_ORDER
-} from "./chunk-GYIA6XLB.js";
+} from "./chunk-MVBCON4D.js";
 import {
+  EMBEDDABLE_TABLES,
+  EMBEDDABLE_TEXT_COLUMNS,
+  assertValidTable,
+  clearEmbedded,
+  gatherStats,
+  getEmbeddingQueueDepth,
+  getUnembedded,
+  markEmbedded
+} from "./chunk-VQZPWCBH.js";
+import {
+  buildTaskInstruction,
   closeOpenBatches,
   countBatchesBySession,
   countCandidates,
@@ -30,8 +41,8 @@ import {
   incrementActivityCount,
   incrementSkillUsageCount,
   insertBatchStateless,
+  isInstructionRequiredTask,
   listBatchesBySession,
-  listCandidates,
   listCandidatesWithCount,
   listDigestExtracts,
   listEntities,
@@ -48,78 +59,71 @@ import {
   setResponseSummary,
   updateCandidate,
   updateNotificationStatus
-} from "./chunk-75J2BR4P.js";
+} from "./chunk-KYSLNB3C.js";
 import {
   fullTextSearch,
   hydrateSearchResults
-} from "./chunk-DTE3SHYK.js";
+} from "./chunk-UILSK6DK.js";
+import {
+  cleanupStagedSkill,
+  listStaleStagingDirs
+} from "./chunk-U5EW2VIQ.js";
 import {
   withTaskConfig
 } from "./chunk-SODRR3HE.js";
-import {
-  EMBEDDABLE_TABLES,
-  EMBEDDABLE_TEXT_COLUMNS,
-  assertValidTable,
-  clearEmbedded,
-  gatherStats,
-  getEmbeddingQueueDepth,
-  getUnembedded,
-  markEmbedded
-} from "./chunk-B3SF2CCW.js";
 import {
   getMachineId
 } from "./chunk-ENWBFX7F.js";
 import {
   createEmbeddingProvider
-} from "./chunk-DK5VEBB5.js";
+} from "./chunk-C3GNF7RJ.js";
 import {
   copyTaskToUser,
   deleteUserTask,
   loadAllTasks,
   validateTaskName,
   writeUserTask
-} from "./chunk-3MEOYXOW.js";
+} from "./chunk-D2NTFSVO.js";
 import {
   AgentTaskSchema,
   registerAgent,
   resolveDefinitionsDir,
   taskFromParsed
-} from "./chunk-X4XFJG6I.js";
+} from "./chunk-W7ZOOZMK.js";
 import {
   listTurnsByRun
 } from "./chunk-QLCD77AN.js";
 import {
   checkLocalProvider
-} from "./chunk-GDCSPMH4.js";
+} from "./chunk-6JZEAOLG.js";
 import {
   EventBuffer,
   cleanStaleBuffers,
   listBufferSessionIds
 } from "./chunk-V7XG6V6C.js";
 import "./chunk-IB76KGBY.js";
-import "./chunk-RBFECYNA.js";
-import "./chunk-OKCSSDFC.js";
-import "./chunk-5YQ6VOFZ.js";
-import "./chunk-GZ7MXWYX.js";
+import "./chunk-I3S6L7QC.js";
+import "./chunk-RPILIIYT.js";
+import "./chunk-DZWSHCAC.js";
+import "./chunk-OH334Y3J.js";
 import "./chunk-SAKJMNSR.js";
 import {
   loadSecrets,
   readSecrets,
   writeSecret
 } from "./chunk-RJMXDUMA.js";
-import "./chunk-X5IXK5KO.js";
+import "./chunk-TIAYBVSI.js";
 import {
   LmStudioBackend,
   OllamaBackend
-} from "./chunk-HHZ3RTEI.js";
+} from "./chunk-VWXDSDJU.js";
 import {
   countSpores,
   getSpore,
   insertSpore,
-  listSporeIdsSince,
   listSpores,
   updateSporeStatus
-} from "./chunk-SPJGJEFV.js";
+} from "./chunk-IRSNOBGD.js";
 import {
   closeSession,
   countSessions,
@@ -130,7 +134,7 @@ import {
   listSessions,
   updateSession,
   upsertSession
-} from "./chunk-23FJUKCN.js";
+} from "./chunk-WKAYMCPR.js";
 import {
   backfillUnsynced,
   countDeadLettered,
@@ -146,12 +150,13 @@ import {
   pruneOld,
   retryDeadLettered,
   syncRow
-} from "./chunk-LF5Z62X6.js";
+} from "./chunk-4JVHWBZF.js";
 import {
   EMBEDDING_DIMENSIONS,
+  REST_SETTABLE_STATUSES,
   SCHEMA_VERSION,
   createSchema
-} from "./chunk-DJQOYEK3.js";
+} from "./chunk-CJ2KTRWI.js";
 import {
   CONFIG_FILENAME,
   MycoConfigSchema,
@@ -160,7 +165,7 @@ import {
   updateBackupConfig,
   updateConfig,
   updateTeamConfig
-} from "./chunk-4BQ5QE76.js";
+} from "./chunk-XAXQ72L3.js";
 import {
   closeDatabase,
   getDatabase,
@@ -169,13 +174,13 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   resolveCliEntryPath
-} from "./chunk-R3YW7XVF.js";
+} from "./chunk-G6LM45FD.js";
 import {
   getPluginVersion
-} from "./chunk-OMZCVRX6.js";
+} from "./chunk-U255A3RE.js";
 import {
   loadManifests
-} from "./chunk-SV6UCB2Z.js";
+} from "./chunk-GSKXOCFG.js";
 import {
   findPackageRoot
 } from "./chunk-LPUQPDC2.js";
@@ -190,7 +195,6 @@ import {
   EMBEDDING_BATCH_SIZE,
   EXCLUDED_SPORE_STATUSES,
   FEED_DEFAULT_LIMIT,
-  LOG_CONTEXT_PREVIEW_CHARS,
   LOG_MESSAGE_PREVIEW_CHARS,
   LOG_PROMPT_PREVIEW_CHARS,
   MS_PER_DAY,
@@ -230,11 +234,11 @@ import {
   USER_TASK_SOURCE,
   epochSeconds,
   estimateTokens
-} from "./chunk-TRA3R4EC.js";
+} from "./chunk-34NHDRWI.js";
 import {
   LOG_KINDS,
   kindToComponent
-} from "./chunk-CUADDHHU.js";
+} from "./chunk-E7NUADTQ.js";
 import {
   require_dist
 } from "./chunk-D7TYRPRM.js";
@@ -1326,6 +1330,12 @@ function createPlanDirHandlers(deps) {
   return { handleGetPlanDirs, handleUpdatePlanDirs };
 }
 
+// src/utils/parse-csv-list.ts
+function parseCsvList(raw) {
+  if (!raw) return [];
+  return raw.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+}
+
 // src/db/queries/logs.ts
 var DEFAULT_PAGE_SIZE = 100;
 var DEFAULT_STREAM_LIMIT = 200;
@@ -1382,7 +1392,7 @@ function searchLogs(params) {
     }
   }
   if (params.component !== void 0 && params.component.length > 0) {
-    const components = params.component.split(",").map((c) => c.trim()).filter(Boolean);
+    const components = parseCsvList(params.component);
     if (components.length > 0) {
       conditions.push(`le.component IN (SELECT value FROM json_each(?))`);
       queryParams.push(JSON.stringify(components));
@@ -1437,6 +1447,19 @@ function getLogsSince(sinceId, limit) {
   const cursor = entries.length > 0 ? entries[entries.length - 1].id : sinceId;
   return { entries, cursor };
 }
+function getLogTail(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
+     ORDER BY id DESC
+     LIMIT ?`
+  ).all(effectiveLimit);
+  const entries = rows.map(toLogEntryRow).reverse();
+  const cursor = entries.length > 0 ? entries[entries.length - 1].id : 0;
+  return { entries, cursor };
+}
 function getLogEntry(id) {
   const db = getDatabase();
   const row = db.prepare(
@@ -1488,12 +1511,14 @@ async function handleLogSearch(req) {
 async function handleLogStream(req) {
   const sinceStr = req.query.since;
   const limitStr = req.query.limit;
-  const sinceId = sinceStr ? parseInt(sinceStr, 10) : 0;
+  const categoryFilter = req.query.category || void 0;
   const limit = limitStr ? parseInt(limitStr, 10) : void 0;
-  const result = getLogsSince(sinceId, limit);
+  const result = sinceStr === void 0 ? getLogTail(limit) : getLogsSince(parseInt(sinceStr, 10), limit);
+  const entries = result.entries.map(formatEntry);
+  const filtered = categoryFilter ? entries.filter((e) => e.category === categoryFilter) : entries;
   return {
     body: {
-      entries: result.entries.map(formatEntry),
+      entries: filtered,
       cursor: result.cursor
     }
   };
@@ -1536,8 +1561,11 @@ function createLogIngestionHandler(logger) {
   };
 }
 function formatEntry(entry) {
+  const dot = entry.kind.indexOf(".");
+  const category = dot > 0 ? entry.kind.slice(0, dot) : entry.kind;
   return {
     ...entry,
+    category,
     data: entry.data ? JSON.parse(entry.data) : null
   };
 }
@@ -2299,7 +2327,7 @@ function createTeamHandlers(deps) {
     return { body: { retried: count } };
   }
   async function handleUpgradeWorker(_req) {
-    const { upgradeWorker } = await import("./team-J62N7VMG.js");
+    const { upgradeWorker } = await import("./team-FWEVWYIY.js");
     const result = upgradeWorker(vaultDir);
     if (!result.success) {
       return { status: 500, body: { error: result.error } };
@@ -2457,10 +2485,13 @@ function countUsageForSkill(skillId) {
 // src/daemon/api/skills.ts
 var DEFAULT_LIST_OFFSET = 0;
 async function handleListCandidates(req) {
-  const status = req.query.status || void 0;
   const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT;
   const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET;
-  const { items: candidates, total } = listCandidatesWithCount({ status, limit, offset });
+  const { items: candidates, total } = listCandidatesWithCount({
+    statuses: parseCsvList(req.query.status),
+    limit,
+    offset
+  });
   return { status: 200, body: { candidates, total } };
 }
 async function handleGetCandidate(req) {
@@ -2470,11 +2501,22 @@ async function handleGetCandidate(req) {
   }
   return { status: 200, body: { candidate } };
 }
+var ALLOWED_REST_STATUSES = new Set(REST_SETTABLE_STATUSES);
 async function handleUpdateCandidate(req) {
   const id = req.params.id;
   const body = req.body;
   if (!body) return { status: 400, body: { error: "Request body required" } };
   const { status, topic, rationale, confidence, source_ids, skill_id } = body;
+  if (status !== void 0) {
+    if (typeof status !== "string" || !ALLOWED_REST_STATUSES.has(status)) {
+      return {
+        status: 400,
+        body: {
+          error: `Invalid status '${String(status)}'. REST callers may only set: ${[...ALLOWED_REST_STATUSES].join(", ")}. The 'generated' status is set internally by vault_finalize_skill after validation.`
+        }
+      };
+    }
+  }
   const updated = updateCandidate(id, {
     ...status !== void 0 ? { status } : {},
     ...topic !== void 0 ? { topic } : {},
@@ -2560,7 +2602,7 @@ function createSkillRecordDeleteHandler(deps) {
           logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to remove skill directory", { name: record.name, error: String(err) });
         }
         try {
-          const { syncSkillSymlinks } = await import("./installer-BTUNKWOU.js");
+          const { syncSkillSymlinks } = await import("./installer-AARSFXI6.js");
           syncSkillSymlinks(projectRoot, record.name, { remove: true });
         } catch (err) {
           logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to remove skill symlinks", { name: record.name, error: String(err) });
@@ -3582,19 +3624,19 @@ function createSessionContextHandler(deps) {
       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
-      });
+      logger.info(
+        LOG_KINDS.CONTEXT_SESSION,
+        `Session context: ${estimatedTokens} est. tokens, source=${source}${extract ? `, tier=${tier}` : ""}`,
+        {
+          session_id,
+          source,
+          tier: extract ? tier : void 0,
+          text_length: contextText.length,
+          estimated_tokens: estimatedTokens,
+          generated_at: extract?.generated_at,
+          injected_text: contextText
+        }
+      );
       return {
         body: {
           text: contextText,
@@ -3663,17 +3705,13 @@ function createPromptContextHandler(deps) {
     const text = formatSporeContext(spores);
     const promptTokens = estimateTokens(text);
     const titles = spores.map((s) => s.title);
-    logger.info(LOG_KINDS.CONTEXT_PROMPT, "Prompt context injected", {
+    logger.info(LOG_KINDS.CONTEXT_PROMPT, `Prompt context: ${spores.length} spores [${titles.join(", ")}] (~${promptTokens} tokens)`, {
       session_id,
       spore_count: spores.length,
-      scores: spores.map((s) => s.score.toFixed(3)),
       spore_titles: titles,
+      scores: spores.map((s) => s.score.toFixed(3)),
       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))
+      injected_text: text
     });
     return { body: { text } };
   };
@@ -3787,6 +3825,53 @@ async function handleEmbeddingReembedStale(manager) {
   return { body: result };
 }
 
+// src/daemon/database/types.ts
+var VACUUM_ERROR_CODE = "insufficient_disk_space";
+var VacuumPrecheckError = class extends Error {
+  constructor(required_bytes, free_bytes) {
+    super("VACUUM requires at least " + required_bytes + " bytes free; only " + free_bytes + " available");
+    this.required_bytes = required_bytes;
+    this.free_bytes = free_bytes;
+    this.name = "VacuumPrecheckError";
+  }
+};
+
+// src/daemon/api/database.ts
+async function handleDatabaseDetails(manager) {
+  const details = await manager.getDetails();
+  return { body: details };
+}
+async function handleDatabaseOptimize(manager) {
+  const result = await manager.optimize();
+  return { body: result };
+}
+async function handleDatabaseVacuum(manager) {
+  try {
+    const result = await manager.vacuum();
+    return { body: result };
+  } catch (err) {
+    if (err instanceof VacuumPrecheckError) {
+      return {
+        status: 409,
+        body: {
+          error: VACUUM_ERROR_CODE,
+          required_bytes: err.required_bytes,
+          free_bytes: err.free_bytes
+        }
+      };
+    }
+    throw err;
+  }
+}
+async function handleDatabaseReindex(manager) {
+  const result = await manager.reindex();
+  return { body: result };
+}
+async function handleDatabaseIntegrityCheck(manager) {
+  const result = await manager.integrityCheck();
+  return { body: result };
+}
+
 // src/daemon/embedding/manager.ts
 import { createHash as createHash3 } from "crypto";
 var ACTIVE_STATUS = "active";
@@ -4622,6 +4707,344 @@ var SqliteRecordSource = class {
   }
 };
 
+// src/daemon/database/manager.ts
+import fs14 from "fs";
+
+// src/db/queries/database.ts
+import fs13 from "fs";
+function pragmaScalar(name) {
+  const db = getDatabase();
+  return db.pragma(name, { simple: true });
+}
+function safeFileSize(filePath) {
+  try {
+    return fs13.statSync(filePath).size;
+  } catch (err) {
+    if (err.code === "ENOENT") return 0;
+    throw err;
+  }
+}
+function getDatabaseFileStats(dbPath) {
+  const size_bytes = safeFileSize(dbPath);
+  const wal_size_bytes = safeFileSize(dbPath + "-wal");
+  const page_size = Number(pragmaScalar("page_size"));
+  const page_count = Number(pragmaScalar("page_count"));
+  const freelist_count = Number(pragmaScalar("freelist_count"));
+  const fragmentation_pct = page_count > 0 ? freelist_count / page_count * 100 : 0;
+  return {
+    path: dbPath,
+    size_bytes,
+    wal_size_bytes,
+    page_size,
+    page_count,
+    freelist_count,
+    fragmentation_pct
+  };
+}
+function quoteIdent(name) {
+  return '"' + name.replace(/"/g, '""') + '"';
+}
+function getTablesBreakdown() {
+  const db = getDatabase();
+  const tableRows = db.prepare(
+    "SELECT name, sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+  ).all();
+  const userTableRows = tableRows.filter((row) => !(row.sql ?? "").startsWith("CREATE TABLE '"));
+  const indexCountRows = db.prepare(
+    "SELECT tbl_name, COUNT(*) AS cnt FROM sqlite_master WHERE type='index' GROUP BY tbl_name"
+  ).all();
+  const indexCountByTable = new Map(indexCountRows.map((r) => [r.tbl_name, Number(r.cnt)]));
+  const countsByTable = /* @__PURE__ */ new Map();
+  if (userTableRows.length > 0) {
+    const unionSql = userTableRows.map((_, i) => `SELECT ? AS t, COUNT(*) AS c FROM ${quoteIdent(userTableRows[i].name)}`).join(" UNION ALL ");
+    const params = userTableRows.map((row) => row.name);
+    try {
+      const rows = db.prepare(unionSql).all(...params);
+      for (const r of rows) {
+        countsByTable.set(r.t, Number(r.c ?? 0));
+      }
+    } catch {
+      for (const row of userTableRows) {
+        try {
+          const r = db.prepare(`SELECT COUNT(*) AS c FROM ${quoteIdent(row.name)}`).get();
+          countsByTable.set(row.name, Number(r.c ?? 0));
+        } catch {
+          countsByTable.set(row.name, 0);
+        }
+      }
+    }
+  }
+  return userTableRows.map((row) => ({
+    name: row.name,
+    rows: countsByTable.get(row.name) ?? 0,
+    index_count: indexCountByTable.get(row.name) ?? 0,
+    is_fts: (row.sql ?? "").toLowerCase().includes("fts5")
+  }));
+}
+function getIndexesList() {
+  const db = getDatabase();
+  const rows = db.prepare(
+    "SELECT name, tbl_name, sql FROM sqlite_master WHERE type='index' ORDER BY tbl_name, name"
+  ).all();
+  return rows.map((r) => {
+    const type = r.name.startsWith("sqlite_autoindex_") ? "auto" : "btree";
+    return {
+      name: r.name,
+      table: r.tbl_name,
+      type,
+      sql: r.sql
+    };
+  });
+}
+function getSchemaInfo() {
+  const journal_mode = String(pragmaScalar("journal_mode"));
+  const foreign_keys_raw = pragmaScalar("foreign_keys");
+  const foreign_keys = Number(foreign_keys_raw) === 1;
+  return {
+    version: SCHEMA_VERSION,
+    journal_mode,
+    foreign_keys
+  };
+}
+function getLastDatabaseLogTimestamp(kind) {
+  const db = getDatabase();
+  const row = db.prepare(
+    "SELECT timestamp FROM log_entries WHERE kind = ? ORDER BY id DESC LIMIT 1"
+  ).get(kind);
+  if (!row) return null;
+  const t = new Date(row.timestamp).getTime();
+  return Number.isFinite(t) ? t : null;
+}
+function getLastDatabaseLogTimestamps(kinds) {
+  const result = /* @__PURE__ */ new Map();
+  for (const k of kinds) result.set(k, null);
+  if (kinds.length === 0) return result;
+  const db = getDatabase();
+  const placeholders = kinds.map(() => "?").join(",");
+  const rows = db.prepare(
+    `SELECT kind, MAX(timestamp) AS latest FROM log_entries WHERE kind IN (${placeholders}) GROUP BY kind`
+  ).all(...kinds);
+  for (const row of rows) {
+    if (!row.latest) continue;
+    const t = new Date(row.latest).getTime();
+    result.set(row.kind, Number.isFinite(t) ? t : null);
+  }
+  return result;
+}
+function runVacuum() {
+  const db = getDatabase();
+  db.exec("VACUUM");
+}
+function runAnalyze() {
+  const db = getDatabase();
+  db.exec("ANALYZE");
+}
+function runReindex() {
+  const db = getDatabase();
+  db.exec("REINDEX");
+}
+function runIntegrityCheck() {
+  const db = getDatabase();
+  const rows = db.prepare("PRAGMA integrity_check").all();
+  const messages = rows.map((r) => r.integrity_check);
+  const ok = messages.length === 1 && messages[0] === "ok";
+  return {
+    status: ok ? "ok" : "issues",
+    issues: ok ? [] : messages
+  };
+}
+function runForeignKeyCheck() {
+  const db = getDatabase();
+  const rows = db.prepare("PRAGMA foreign_key_check").all();
+  return rows;
+}
+function runWalCheckpointTruncate() {
+  const db = getDatabase();
+  const rows = db.pragma("wal_checkpoint(TRUNCATE)");
+  const row = rows[0] ?? { busy: 0, log: 0, checkpointed: 0 };
+  return {
+    busy: Number(row.busy),
+    log: Number(row.log),
+    checkpointed: Number(row.checkpointed)
+  };
+}
+function runPragmaOptimize() {
+  const db = getDatabase();
+  db.pragma("optimize");
+}
+var FTS_TABLE_PATTERN = /^[a-z_][a-z0-9_]*_fts$/;
+function runFtsOptimize(ftsTableName) {
+  if (!FTS_TABLE_PATTERN.test(ftsTableName)) {
+    throw new Error("Invalid FTS5 table name: " + ftsTableName);
+  }
+  const db = getDatabase();
+  const row = db.prepare(
+    "SELECT sql FROM sqlite_master WHERE type='table' AND name=?"
+  ).get(ftsTableName);
+  if (!row || !(row.sql ?? "").toLowerCase().includes("fts5")) {
+    throw new Error("Not an FTS5 table: " + ftsTableName);
+  }
+  const quoted = '"' + ftsTableName + '"';
+  const optimizeSql = "INSERT INTO " + quoted + "(" + quoted + ") VALUES ('optimize')";
+  db.prepare(optimizeSql).run();
+}
+function listFtsTableNames() {
+  const db = getDatabase();
+  const rows = db.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND sql LIKE '%fts5%' ORDER BY name"
+  ).all();
+  return rows.map((r) => r.name).filter((name) => FTS_TABLE_PATTERN.test(name));
+}
+
+// src/daemon/database/manager.ts
+var VACUUM_FREE_SPACE_MULTIPLIER = 2;
+var DatabaseMaintenanceManager = class {
+  constructor(dbPath, vaultDir, logger) {
+    this.dbPath = dbPath;
+    this.vaultDir = vaultDir;
+    this.logger = logger;
+  }
+  async getDetails() {
+    const file = getDatabaseFileStats(this.dbPath);
+    const schema = getSchemaInfo();
+    const tables = getTablesBreakdown();
+    const indexes = getIndexesList();
+    const lastRuns = getLastDatabaseLogTimestamps([
+      LOG_KINDS.DATABASE_OPTIMIZE,
+      LOG_KINDS.DATABASE_VACUUM,
+      LOG_KINDS.DATABASE_INTEGRITY_CHECK,
+      LOG_KINDS.DATABASE_INTEGRITY_ISSUES
+    ]);
+    const optimizeMs = lastRuns.get(LOG_KINDS.DATABASE_OPTIMIZE) ?? null;
+    const vacuumMs = lastRuns.get(LOG_KINDS.DATABASE_VACUUM) ?? null;
+    const integrityOkMs = lastRuns.get(LOG_KINDS.DATABASE_INTEGRITY_CHECK) ?? null;
+    const integrityIssuesMs = lastRuns.get(LOG_KINDS.DATABASE_INTEGRITY_ISSUES) ?? null;
+    let last_integrity_check = null;
+    if (integrityOkMs !== null || integrityIssuesMs !== null) {
+      const okMs = integrityOkMs ?? 0;
+      const issuesMs = integrityIssuesMs ?? 0;
+      if (okMs >= issuesMs) {
+        last_integrity_check = { at: new Date(okMs).toISOString(), status: "ok" };
+      } else {
+        last_integrity_check = { at: new Date(issuesMs).toISOString(), status: "issues" };
+      }
+    }
+    return {
+      file,
+      schema,
+      tables,
+      indexes,
+      last_optimize_at: optimizeMs ? new Date(optimizeMs).toISOString() : null,
+      last_vacuum_at: vacuumMs ? new Date(vacuumMs).toISOString() : null,
+      last_integrity_check
+    };
+  }
+  async getLastOptimizeAt() {
+    return getLastDatabaseLogTimestamp(LOG_KINDS.DATABASE_OPTIMIZE);
+  }
+  async optimize() {
+    const startedAt = Date.now();
+    const completed = [];
+    const failed = [];
+    const steps = [
+      { name: "analyze", fn: runAnalyze },
+      { name: "pragma_optimize", fn: runPragmaOptimize },
+      ...listFtsTableNames().map((tbl) => ({
+        name: "fts_optimize:" + tbl,
+        fn: () => runFtsOptimize(tbl)
+      })),
+      // wal_checkpoint_truncate returns WalCheckpointResult; if busy !== 0 another
+      // reader blocked the checkpoint — log a warning but don't fail the step.
+      {
+        name: "wal_checkpoint_truncate",
+        fn: () => {
+          const result = runWalCheckpointTruncate();
+          if (result.busy !== 0) {
+            this.logger.warn(LOG_KINDS.DATABASE_ERROR, "wal_checkpoint blocked by reader", {
+              busy: result.busy,
+              log: result.log,
+              checkpointed: result.checkpointed
+            });
+          }
+        }
+      }
+    ];
+    for (const step of steps) {
+      const stepStart = Date.now();
+      try {
+        step.fn();
+        completed.push({ name: step.name, duration_ms: Date.now() - stepStart, ok: true });
+      } catch (err) {
+        const error = err.message;
+        failed.push({ name: step.name, duration_ms: Date.now() - stepStart, ok: false, error });
+        this.logger.warn(LOG_KINDS.DATABASE_ERROR, "optimize step failed: " + step.name, { error });
+      }
+    }
+    const duration_ms = Date.now() - startedAt;
+    this.logger.info(LOG_KINDS.DATABASE_OPTIMIZE, "Database optimize complete", {
+      completed: completed.length,
+      failed: failed.length,
+      duration_ms
+    });
+    return { actions_completed: completed, actions_failed: failed, duration_ms };
+  }
+  async vacuum() {
+    const size_before = this.fileSize();
+    const stats = await fs14.promises.statfs(this.vaultDir);
+    const free_bytes = Number(stats.bavail) * Number(stats.bsize);
+    const required_bytes = size_before * VACUUM_FREE_SPACE_MULTIPLIER;
+    if (free_bytes < required_bytes) {
+      throw new VacuumPrecheckError(required_bytes, free_bytes);
+    }
+    const startedAt = Date.now();
+    runVacuum();
+    const duration_ms = Date.now() - startedAt;
+    const size_after = this.fileSize();
+    const freed_bytes = size_before - size_after;
+    this.logger.info(LOG_KINDS.DATABASE_VACUUM, "Database vacuum complete", {
+      size_before,
+      size_after,
+      freed_bytes,
+      duration_ms
+    });
+    return { size_before, size_after, freed_bytes, duration_ms };
+  }
+  async reindex() {
+    const startedAt = Date.now();
+    runReindex();
+    const duration_ms = Date.now() - startedAt;
+    this.logger.info(LOG_KINDS.DATABASE_REINDEX, "Database reindex complete", { duration_ms });
+    return { duration_ms };
+  }
+  async integrityCheck() {
+    const startedAt = Date.now();
+    const integrity = runIntegrityCheck();
+    const fkViolations = runForeignKeyCheck();
+    const duration_ms = Date.now() - startedAt;
+    const status = integrity.status === "ok" && fkViolations.length === 0 ? "ok" : "issues";
+    const logKind = status === "ok" ? LOG_KINDS.DATABASE_INTEGRITY_CHECK : LOG_KINDS.DATABASE_INTEGRITY_ISSUES;
+    this.logger.info(logKind, "Database integrity check complete", {
+      status,
+      issue_count: integrity.issues.length,
+      fk_violations: fkViolations.length,
+      duration_ms
+    });
+    return {
+      status,
+      issues: integrity.issues,
+      fk_violations: fkViolations.length,
+      duration_ms
+    };
+  }
+  fileSize() {
+    try {
+      return fs14.statSync(this.dbPath).size;
+    } catch {
+      return 0;
+    }
+  }
+};
+
 // src/notifications/domains.ts
 function registerBuiltinDomains() {
   register({
@@ -5010,129 +5433,20 @@ function buildScheduledJobs(tasks, configOverrides, context, initialLastRuns) {
           if (!check) return;
           if (!check()) return;
         }
-        try {
-          context.setTaskRunning(task.name, true);
-          await context.runTask(task.name);
-        } finally {
-          lastRun = Date.now();
-          context.setTaskRunning(task.name, false);
-        }
+        const ctx = context;
+        ctx.setTaskRunning(task.name, true);
+        lastRun = Date.now();
+        void ctx.runTask(task.name).catch((err) => {
+          ctx.onTaskError?.(task.name, err);
+        }).finally(() => {
+          ctx.setTaskRunning(task.name, false);
+        });
       }
     });
   }
   return jobs;
 }
 
-// src/agent/instruction-builders.ts
-var SKILL_GENERATE_TASK = "skill-generate";
-var SKILL_EVOLVE_TASK = "skill-evolve";
-function buildSkillGenerateInstruction() {
-  const candidates = listCandidates({ status: "approved", limit: 1 });
-  if (candidates.length === 0) return void 0;
-  const c = candidates[0];
-  const parts = [
-    `candidate_id: ${c.id}`,
-    `topic: ${c.topic}`,
-    `confidence: ${c.confidence}`,
-    `rationale: ${c.rationale}`,
-    "",
-    "## Source Material"
-  ];
-  let sourceIds = [];
-  try {
-    sourceIds = JSON.parse(c.source_ids || "[]");
-  } catch {
-  }
-  for (const src of sourceIds) {
-    if (src.type === "spore") {
-      const spore = getSpore(src.id);
-      if (spore) {
-        parts.push(`
-### Spore: ${src.id} (${spore.observation_type}, importance ${spore.importance})`);
-        parts.push(spore.content);
-        if (spore.context) parts.push(`Context: ${spore.context}`);
-        if (spore.tags) parts.push(`Tags: ${spore.tags}`);
-      }
-    } else if (src.type === "session") {
-      const session = getSession(src.id);
-      if (session) {
-        parts.push(`
-### Session: ${src.id}`);
-        if (session.title) parts.push(`Title: ${session.title}`);
-        if (session.summary) parts.push(session.summary);
-      }
-    }
-  }
-  return parts.join("\n");
-}
-var SKILL_EVOLVE_DEFAULT_ASSESS_INTERVAL_HOURS = 24;
-var SKILL_EVOLVE_DEFAULT_MAX_SKILLS_PER_RUN = 5;
-function buildSkillEvolveInstruction(params) {
-  const assessIntervalHours = Number(params?.assess_interval_hours ?? SKILL_EVOLVE_DEFAULT_ASSESS_INTERVAL_HOURS);
-  const maxSkillsPerRun = Number(params?.max_skills_per_run ?? SKILL_EVOLVE_DEFAULT_MAX_SKILLS_PER_RUN);
-  const now = epochSeconds();
-  const intervalSeconds = assessIntervalHours * 3600;
-  const allSkills = listSkillRecords({ status: "active", limit: 100 });
-  const needsAssessment = [];
-  for (const skill of allSkills) {
-    let props = {};
-    try {
-      props = JSON.parse(skill.properties || "{}");
-    } catch {
-      props = {};
-    }
-    const lastAssessedAt = typeof props.last_assessed_at === "number" ? props.last_assessed_at : 0;
-    const knowledgeWatermark = typeof props.knowledge_watermark === "number" ? props.knowledge_watermark : 0;
-    if (lastAssessedAt > 0 && now - lastAssessedAt < intervalSeconds) continue;
-    const newSporeIds = listSporeIdsSince(knowledgeWatermark, 10);
-    if (newSporeIds.length === 0) continue;
-    const lineage = listLineageForSkill(skill.id, 1);
-    if (lineage.length === 0) continue;
-    needsAssessment.push({
-      id: skill.id,
-      name: skill.name,
-      generation: skill.generation,
-      description: skill.description,
-      contentSnapshot: lineage[0].content_snapshot,
-      newSporeIds
-    });
-    if (needsAssessment.length >= maxSkillsPerRun) {
-      break;
-    }
-  }
-  if (needsAssessment.length === 0) {
-    return "No skills need assessment. All active skills are current or were recently assessed. Report skip via vault_report and finish.";
-  }
-  const parts = [
-    `${needsAssessment.length} skill(s) need assessment.`,
-    `assess_interval_hours: ${assessIntervalHours}`,
-    `max_skills_per_run: ${maxSkillsPerRun}`
-  ];
-  for (const skill of needsAssessment) {
-    parts.push("");
-    parts.push("---");
-    parts.push(`## Skill: ${skill.name} (gen ${skill.generation})`);
-    parts.push(`id: ${skill.id}`);
-    parts.push(`description: ${skill.description}`);
-    parts.push(`new_spore_ids: ${JSON.stringify(skill.newSporeIds)}`);
-    parts.push("");
-    parts.push("### Current Content");
-    parts.push("");
-    parts.push(skill.contentSnapshot);
-  }
-  return parts.join("\n");
-}
-function buildTaskInstruction(taskName, taskParams) {
-  switch (taskName) {
-    case SKILL_GENERATE_TASK:
-      return buildSkillGenerateInstruction();
-    case SKILL_EVOLVE_TASK:
-      return buildSkillEvolveInstruction(taskParams);
-    default:
-      return void 0;
-  }
-}
-
 // src/daemon/task-scheduling.ts
 async function registerScheduledTasks(powerManager, deps) {
   const { definitionsDir, vaultDir, embeddingManager, logger, config } = deps;
@@ -5145,7 +5459,7 @@ async function registerScheduledTasks(powerManager, deps) {
     logger.info(LOG_KINDS.AGENT_RUN, "Scheduled agent tasks disabled globally (agent.scheduled_tasks_enabled: false)");
     return;
   }
-  const { loadAllTasks: loadAllTasks2 } = await import("./registry-DHWVHXWY.js");
+  const { loadAllTasks: loadAllTasks2 } = await import("./registry-5R3DLJQH.js");
   const allTasks = Array.from(loadAllTasks2(definitionsDir, vaultDir).values());
   const initialLastRuns = {};
   try {
@@ -5167,10 +5481,23 @@ async function registerScheduledTasks(powerManager, deps) {
       else runningTasks.delete(name);
     },
     runTask: async (taskName) => {
-      const { runAgent } = await import("./executor-7XOKS6HS.js");
+      const { runAgent } = await import("./executor-HP3Y64PD.js");
       const taskConfig = config.agent.tasks?.[taskName];
-      const instruction = buildTaskInstruction(taskName, taskConfig?.params);
-      const result = await runAgent(vaultDir, { task: taskName, instruction, embeddingManager });
+      const built = buildTaskInstruction(taskName, taskConfig?.params);
+      if (isInstructionRequiredTask(taskName) && !built) {
+        logger.info(
+          LOG_KINDS.AGENT_RUN,
+          `Scheduled task ${taskName} skipped \u2014 no work to do`,
+          { task: taskName, reason: "no-work" }
+        );
+        return;
+      }
+      const result = await runAgent(vaultDir, {
+        task: taskName,
+        instruction: built?.instruction,
+        runContext: built?.context,
+        embeddingManager
+      });
       logger.info(LOG_KINDS.AGENT_RUN, `Scheduled task ${taskName} completed`, {
         status: result.status,
         runId: result.runId
@@ -5230,6 +5557,11 @@ async function registerScheduledTasks(powerManager, deps) {
       "has-approved-candidates": () => {
         return countCandidates({ status: "approved" }) > 0;
       }
+    },
+    onTaskError: (taskName, err) => {
+      logger.error(LOG_KINDS.AGENT_ERROR, `Detached task "${taskName}" threw`, {
+        error: err instanceof Error ? err.message : String(err)
+      });
     }
   };
   const scheduledJobs = buildScheduledJobs(
@@ -5318,7 +5650,7 @@ function createMcpProxyHandlers(deps) {
       name: USER_AGENT_NAME,
       created_at: now
     });
-    const { insertResolutionEvent } = await import("./resolution-events-DBCRVZGU.js");
+    const { insertResolutionEvent } = await import("./resolution-events-CHOKR35X.js");
     const resolutionId = `res-${randomBytes(RESOLUTION_ID_RANDOM_BYTES).toString("hex")}`;
     insertResolutionEvent({
       id: resolutionId,
@@ -5411,17 +5743,37 @@ function createAgentRunHandlers(deps) {
   async function handleRun(req) {
     const { task, instruction: rawInstruction, agentId } = AgentRunBody.parse(req.body);
     let instruction = rawInstruction;
+    let runContext;
     if (task && !instruction) {
+      let built;
       try {
         const mycoConfig = loadConfig(vaultDir);
         const taskParams = mycoConfig.agent.tasks?.[task]?.params;
-        instruction = buildTaskInstruction(task, taskParams);
+        built = buildTaskInstruction(task, taskParams);
       } catch {
-        instruction = buildTaskInstruction(task);
+        built = buildTaskInstruction(task);
+      }
+      instruction = built?.instruction;
+      runContext = built?.context;
+      if (task && isInstructionRequiredTask(task) && !built) {
+        return {
+          body: {
+            ok: true,
+            message: `Task ${task} skipped \u2014 no work to do`,
+            status: "skipped",
+            reason: "no-work"
+          }
+        };
       }
     }
-    const { runAgent } = await import("./executor-7XOKS6HS.js");
-    const resultPromise = runAgent(vaultDir, { task, instruction, agentId, embeddingManager });
+    const { runAgent } = await import("./executor-HP3Y64PD.js");
+    const resultPromise = runAgent(vaultDir, {
+      task,
+      instruction,
+      agentId,
+      embeddingManager,
+      runContext
+    });
     const effectiveAgentId = agentId ?? "myco-agent";
     const runId = getLatestRunId(effectiveAgentId, task);
     resultPromise.then((result) => {
@@ -5483,7 +5835,7 @@ function createAgentRunHandlers(deps) {
 }
 
 // src/daemon/api/attachments.ts
-import fs13 from "fs";
+import fs15 from "fs";
 import path15 from "path";
 var ATTACHMENT_MEDIA_TYPES = {
   png: "image/png",
@@ -5507,7 +5859,7 @@ function createAttachmentHandler(deps) {
     const filePath = path15.join(vaultDir, "attachments", filename);
     let diskData;
     try {
-      diskData = fs13.readFileSync(filePath);
+      diskData = fs15.readFileSync(filePath);
     } catch {
       return { status: 404, body: { error: "not_found" } };
     }
@@ -5519,19 +5871,19 @@ function createAttachmentHandler(deps) {
 }
 
 // src/daemon/log-reconcile.ts
-import fs14 from "fs";
+import fs16 from "fs";
 import path16 from "path";
 function reconcileLogBuffer(logDir, sinceTimestamp) {
   let replayed = 0;
   const files = [];
   for (let i = 3; i >= 1; i--) {
     const rotated = path16.join(logDir, `daemon.${i}.log`);
-    if (fs14.existsSync(rotated)) files.push(rotated);
+    if (fs16.existsSync(rotated)) files.push(rotated);
   }
   const current = path16.join(logDir, "daemon.log");
-  if (fs14.existsSync(current)) files.push(current);
+  if (fs16.existsSync(current)) files.push(current);
   for (const file of files) {
-    const content = fs14.readFileSync(file, "utf-8");
+    const content = fs16.readFileSync(file, "utf-8");
     for (const line of content.split("\n")) {
       if (!line.trim()) continue;
       try {
@@ -5722,8 +6074,9 @@ async function runSessionMaintenance(deps) {
 }
 
 // src/daemon/power-jobs.ts
+var STAGING_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 function registerPowerJobs(powerManager, deps) {
-  const { embeddingManager, registry, logger, config, db, backupDir, machineId, vaultDir } = deps;
+  const { embeddingManager, registry, logger, config, db, backupDir, machineId, vaultDir, databaseManager } = deps;
   let reconcileRunning = false;
   powerManager.register({
     name: "embedding-reconcile",
@@ -5773,10 +6126,42 @@ function registerPowerJobs(powerManager, deps) {
       }
     }
   });
+  powerManager.register({
+    name: "database-optimize",
+    runIn: ["idle", "sleep"],
+    fn: async () => {
+      if (!config.maintenance?.auto_optimize) return;
+      const intervalMs = (config.maintenance.auto_optimize_interval_hours ?? 24) * MS_PER_HOUR;
+      const lastRun = await databaseManager.getLastOptimizeAt();
+      if (lastRun !== null && Date.now() - lastRun < intervalMs) return;
+      try {
+        await databaseManager.optimize();
+      } catch (err) {
+        logger.error(LOG_KINDS.DATABASE_ERROR, "Auto-optimize failed", {
+          error: err.message
+        });
+      }
+    }
+  });
+  powerManager.register({
+    name: "staging-gc",
+    runIn: ["idle", "sleep"],
+    fn: async () => {
+      const stale = listStaleStagingDirs(vaultDir, STAGING_MAX_AGE_MS);
+      if (stale.length === 0) return;
+      for (const candidateId of stale) {
+        cleanupStagedSkill(vaultDir, candidateId);
+      }
+      logger.info(LOG_KINDS.MAINTENANCE_STAGING_GC, "Staging GC swept stale skill drafts", {
+        count: stale.length,
+        candidate_ids: stale
+      });
+    }
+  });
 }
 
 // src/daemon/reconciliation.ts
-import fs15 from "fs";
+import fs17 from "fs";
 import path17 from "path";
 
 // src/daemon/event-handlers.ts
@@ -5942,7 +6327,7 @@ function createReconciler({ bufferDir, logger }) {
     const bufferPath = path17.join(bufferDir, `${sessionId}.jsonl`);
     let content;
     try {
-      content = fs15.readFileSync(bufferPath, "utf-8").trim();
+      content = fs17.readFileSync(bufferPath, "utf-8").trim();
     } catch {
       return;
     }
@@ -6011,7 +6396,7 @@ function createReconciler({ bufferDir, logger }) {
 }
 
 // src/daemon/stop-processing.ts
-import fs16 from "fs";
+import fs18 from "fs";
 
 // src/daemon/skill-usage.ts
 import crypto from "crypto";
@@ -6089,7 +6474,7 @@ function createStopProcessor(deps) {
     if (config.agent.summary_batch_interval <= 0) return;
     if (config.agent.event_tasks_enabled === false) return;
     try {
-      const { runAgent } = await import("./executor-7XOKS6HS.js");
+      const { runAgent } = await import("./executor-HP3Y64PD.js");
       runAgent(vaultDir, {
         task: "title-summary",
         instruction: `Process session ${sessionId} only`,
@@ -6179,7 +6564,7 @@ function createStopProcessor(deps) {
         let transcriptText = null;
         if (hookTranscriptPath) {
           try {
-            transcriptText = fs16.readFileSync(hookTranscriptPath, "utf-8");
+            transcriptText = fs18.readFileSync(hookTranscriptPath, "utf-8");
           } catch {
           }
         }
@@ -6234,7 +6619,7 @@ function createStopProcessor(deps) {
         const filename = `${sessionShort}-t${resolvedPromptNumber}-${j + 1}.${ext}`;
         const imageBuffer = Buffer.from(img.data, "base64");
         try {
-          insertAttachment({
+          const inserted = insertAttachment({
             id: `${sessionShort}-b${resolvedPromptNumber}-${j + 1}`,
             session_id: sessionId,
             prompt_batch_id: resolvedBatchId ?? void 0,
@@ -6243,7 +6628,9 @@ function createStopProcessor(deps) {
             data: imageBuffer,
             created_at: epochSeconds()
           });
-          logger.debug(LOG_KINDS.CAPTURE_ATTACHMENT, "Image stored in DB", { filename, batch: resolvedPromptNumber });
+          if (inserted) {
+            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) });
         }
@@ -6293,7 +6680,7 @@ function createStopProcessor(deps) {
 }
 
 // src/daemon/event-dispatch.ts
-import fs17 from "fs";
+import fs19 from "fs";
 import path19 from "path";
 
 // src/daemon/plan-capture.ts
@@ -6430,7 +6817,7 @@ function createEventDispatcher(deps) {
       );
       if (planFilePath) {
         const captureSessionId = event.session_id;
-        fs17.promises.readFile(planFilePath, "utf-8").then((planContent) => {
+        fs19.promises.readFile(planFilePath, "utf-8").then((planContent) => {
           const latestBatch = getLatestBatch(captureSessionId);
           capturePlan({
             sourcePath: path19.relative(projectRoot, planFilePath),
@@ -6575,14 +6962,14 @@ function createEventDispatcher(deps) {
 }
 
 // src/daemon/main.ts
-import fs18 from "fs";
+import fs20 from "fs";
 import os8 from "os";
 import path20 from "path";
 function killStaleDaemon(vaultDir, logger) {
   const daemonJsonPath = path20.join(vaultDir, "daemon.json");
   try {
-    if (!fs18.existsSync(daemonJsonPath)) return;
-    const info = JSON.parse(fs18.readFileSync(daemonJsonPath, "utf-8"));
+    if (!fs20.existsSync(daemonJsonPath)) return;
+    const info = JSON.parse(fs20.readFileSync(daemonJsonPath, "utf-8"));
     if (!info.pid) return;
     if (info.pid === process.pid) return;
     try {
@@ -6591,7 +6978,7 @@ function killStaleDaemon(vaultDir, logger) {
       logger.info(LOG_KINDS.DAEMON_START, "Killed stale daemon", { pid: info.pid });
     } catch {
     }
-    fs18.unlinkSync(daemonJsonPath);
+    fs20.unlinkSync(daemonJsonPath);
   } catch {
   }
 }
@@ -6615,6 +7002,9 @@ async function main() {
   const logger = new DaemonLogger(path20.join(vaultDir, "logs"), {
     level: config.daemon.log_level
   });
+  if (config.daemon.log_level === "debug") {
+    process.env.MYCO_AGENT_DEBUG = "1";
+  }
   killStaleDaemon(vaultDir, logger);
   logger.info(LOG_KINDS.DAEMON_CONFIG, "Config loaded", {
     vault: vaultDir,
@@ -6655,9 +7045,10 @@ async function main() {
   const recordSource = new SqliteRecordSource();
   const embeddingManager = new EmbeddingManager(vectorStore, embeddingProvider, recordSource, logger);
   logger.info(LOG_KINDS.EMBEDDING_EMBED, "EmbeddingManager initialized", { vectors_db: vectorsDbPath });
+  const databaseManager = new DatabaseMaintenanceManager(vaultDbPath(vaultDir), vaultDir, logger);
   let definitionsDir;
   try {
-    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-WC4U5NM5.js");
+    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-YQDG5GI5.js");
     definitionsDir = resolveDefinitionsDir2();
     await registerBuiltInAgentsAndTasks(definitionsDir, vaultDir);
     logger.info(LOG_KINDS.AGENT_TASK, "Built-in agents and tasks registered");
@@ -6686,7 +7077,7 @@ async function main() {
     const root = findPackageRoot(path20.dirname(new URL(import.meta.url).pathname));
     if (root) {
       const candidate = path20.join(root, "dist", "ui");
-      if (fs18.existsSync(candidate)) uiDir = candidate;
+      if (fs20.existsSync(candidate)) uiDir = candidate;
     }
   }
   if (uiDir) {
@@ -6797,6 +7188,7 @@ async function main() {
     server,
     configHash: configHashRef
   }));
+  server.registerRoute("GET", "/api/logs", handleLogStream);
   server.registerRoute("GET", "/api/logs/search", handleLogSearch);
   server.registerRoute("GET", "/api/logs/stream", handleLogStream);
   server.registerRoute("GET", "/api/logs/:id", handleLogDetail);
@@ -6897,6 +7289,11 @@ async function main() {
   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));
+  server.registerRoute("GET", "/api/database/details", async () => handleDatabaseDetails(databaseManager));
+  server.registerRoute("POST", "/api/database/optimize", async () => handleDatabaseOptimize(databaseManager));
+  server.registerRoute("POST", "/api/database/vacuum", async () => handleDatabaseVacuum(databaseManager));
+  server.registerRoute("POST", "/api/database/reindex", async () => handleDatabaseReindex(databaseManager));
+  server.registerRoute("POST", "/api/database/integrity-check", async () => handleDatabaseIntegrityCheck(databaseManager));
   server.registerRoute("GET", "/api/notifications", async (req) => handleListNotifications(vaultDir, req.query));
   server.registerRoute("POST", "/api/notifications", async (req) => handleCreateNotification(vaultDir, req.body));
   server.registerRoute("PATCH", "/api/notifications/:id", async (req) => handleUpdateNotification(vaultDir, req.params.id, req.body));
@@ -6922,7 +7319,7 @@ async function main() {
       logger.warn(LOG_KINDS.DAEMON_CONFIG, "Failed to persist auto-derived port", { error: err.message });
     }
   }
-  registerPowerJobs(powerManager, { embeddingManager, registry, logger, config, db, backupDir, machineId, vaultDir });
+  registerPowerJobs(powerManager, { embeddingManager, registry, logger, config, db, backupDir, machineId, vaultDir, databaseManager });
   teamSync.registerFlushJob(powerManager);
   await registerScheduledTasks(powerManager, { definitionsDir, vaultDir, embeddingManager, logger, config });
   powerManager.start();
@@ -6956,4 +7353,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-JB3R3DQE.js.map
+//# sourceMappingURL=main-VAU5UPY7.js.map