@goondocks/myco 0.12.10 → 0.14.0

package/dist/{main-CMWNMCW2.js → main-IZ277SHB.js}

@@ -3,119 +3,151 @@ import {
   DaemonLogger,
   LEVEL_ORDER
 } from "./chunk-ZESTWGJT.js";
-import {
-  withTaskConfig
-} from "./chunk-M5XWW7UI.js";
-import {
-  EMBEDDABLE_TABLES,
-  EMBEDDABLE_TEXT_COLUMNS,
-  assertValidTable,
-  clearEmbedded,
-  gatherStats,
-  getEmbeddingQueueDepth,
-  getUnembedded,
-  markEmbedded
-} from "./chunk-MCARJFBA.js";
-import {
-  getMachineId
-} from "./chunk-ENWBFX7F.js";
-import {
-  createEmbeddingProvider
-} from "./chunk-JHLALJPB.js";
 import {
   closeOpenBatches,
+  countBatchesBySession,
+  countCandidates,
+  countNotifications,
   countRuns,
+  countSkillRecords,
   createBatchLineage,
+  deleteCandidate,
+  deleteSkillRecordCascade,
+  dismissAllNotifications,
   errorMessage,
   findBatchByPromptPrefix,
+  getAllDomains,
+  getCandidate,
   getDigestExtract,
   getEntity,
   getGraphForNode,
   getLatestBatch,
+  getLatestRunId,
+  getNotification,
   getRun,
-  getRunningRun,
+  getSkillRecord,
+  getSkillRecordByName,
   incrementActivityCount,
+  incrementSkillUsageCount,
   insertBatchStateless,
   listBatchesBySession,
+  listCandidates,
+  listCandidatesWithCount,
   listDigestExtracts,
   listEntities,
+  listLineageForSkill,
+  listNotifications,
   listReports,
   listRuns,
-  listTurnsByRun,
+  listSkillRecords,
+  listSkillRecordsWithCount,
+  markAllRead,
+  notify,
   populateBatchResponses,
-  setResponseSummary
-} from "./chunk-TCGOSLW6.js";
+  register,
+  setResponseSummary,
+  updateCandidate,
+  updateNotificationStatus
+} from "./chunk-JJXVDCEX.js";
 import {
   fullTextSearch,
   hydrateSearchResults
-} from "./chunk-D4M2AV65.js";
+} from "./chunk-DTE3SHYK.js";
+import {
+  withTaskConfig
+} from "./chunk-SODRR3HE.js";
+import {
+  EMBEDDABLE_TABLES,
+  EMBEDDABLE_TEXT_COLUMNS,
+  assertValidTable,
+  clearEmbedded,
+  gatherStats,
+  getEmbeddingQueueDepth,
+  getUnembedded,
+  markEmbedded
+} from "./chunk-745SWTQX.js";
+import {
+  getMachineId
+} from "./chunk-ENWBFX7F.js";
+import {
+  createEmbeddingProvider
+} from "./chunk-LD6U3L6O.js";
 import {
   copyTaskToUser,
   deleteUserTask,
   loadAllTasks,
   validateTaskName,
   writeUserTask
-} from "./chunk-D4ESHOOJ.js";
+} from "./chunk-KNTJOMWY.js";
 import {
   AgentTaskSchema,
   registerAgent,
   resolveDefinitionsDir,
   taskFromParsed
-} from "./chunk-7NBDELZB.js";
+} from "./chunk-NVCGF2DS.js";
+import {
+  listTurnsByRun
+} from "./chunk-QLCD77AN.js";
+import {
+  loadSecrets,
+  readSecrets,
+  writeSecret
+} from "./chunk-RJMXDUMA.js";
+import "./chunk-SBVDG5JP.js";
+import "./chunk-SAKJMNSR.js";
 import {
   checkLocalProvider
-} from "./chunk-YRUJ5KGV.js";
+} from "./chunk-GDCSPMH4.js";
 import {
   EventBuffer,
   cleanStaleBuffers,
   listBufferSessionIds
 } from "./chunk-V7XG6V6C.js";
 import "./chunk-IB76KGBY.js";
-import "./chunk-J3L2RTYK.js";
-import "./chunk-SW62AX75.js";
-import "./chunk-QL2RBFIC.js";
-import {
-  loadSecrets,
-  readSecrets,
-  writeSecret
-} from "./chunk-RJMXDUMA.js";
-import "./chunk-SFC4GXEN.js";
-import "./chunk-SAKJMNSR.js";
+import "./chunk-TNCBMGWB.js";
 import {
   LmStudioBackend,
   OllamaBackend
-} from "./chunk-LUQBT2Y4.js";
+} from "./chunk-HHZ3RTEI.js";
+import "./chunk-RBFECYNA.js";
+import "./chunk-OKCSSDFC.js";
+import "./chunk-5YQ6VOFZ.js";
 import {
   countSpores,
   getSpore,
   insertSpore,
   listSpores,
   updateSporeStatus
-} from "./chunk-Q2AYS2QE.js";
+} from "./chunk-PX5KIOKY.js";
 import {
   closeSession,
   countSessions,
   deleteSessionCascade,
   getSession,
   getSessionImpact,
+  incrementSessionToolCount,
   listSessions,
   updateSession,
   upsertSession
-} from "./chunk-JROOQQH6.js";
+} from "./chunk-X34OFKYU.js";
 import {
   backfillUnsynced,
   countPending,
+  enqueueOutbox,
+  getTeamMachineId,
   initTeamContext,
+  isTeamSyncEnabled,
   listPending,
   markSent,
+  markSourceRowsSynced,
   pruneOld,
   syncRow
-} from "./chunk-4VSNNMEU.js";
+} from "./chunk-S66YG6QK.js";
 import {
   EMBEDDING_DIMENSIONS,
   SCHEMA_VERSION,
   createSchema
-} from "./chunk-PW5QVY44.js";
+} from "./chunk-4VF6KQ2Z.js";
 import {
   CONFIG_FILENAME,
   MycoConfigSchema,
@@ -123,7 +155,7 @@ import {
   updateBackupConfig,
   updateConfig,
   updateTeamConfig
-} from "./chunk-OAGY5APE.js";
+} from "./chunk-PSYLKCWQ.js";
 import {
   closeDatabase,
   getDatabase,
@@ -132,14 +164,23 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   resolveCliEntryPath
-} from "./chunk-SVQAPEYH.js";
+} from "./chunk-UWXJCLCK.js";
+import {
+  getPluginVersion
+} from "./chunk-ZKXW46HZ.js";
+import {
+  loadManifests
+} from "./chunk-QFMBZ72S.js";
+import {
+  findPackageRoot
+} from "./chunk-LPUQPDC2.js";
 import {
   CONTENT_HASH_ALGORITHM,
   DAEMON_EVICT_POLL_MS,
   DAEMON_EVICT_TIMEOUT_MS,
   DEAD_SESSION_MAX_PROMPTS,
   DEFAULT_AGENT_ID,
-  DEFAULT_MACHINE_ID,
+  DEFAULT_LIST_LIMIT,
   DEFAULT_RELEASE_CHANNEL,
   EMBEDDING_BATCH_SIZE,
   EXCLUDED_SPORE_STATUSES,
@@ -184,20 +225,11 @@ import {
   USER_TASK_SOURCE,
   epochSeconds,
   estimateTokens
-} from "./chunk-PIRWYDOH.js";
+} from "./chunk-TRA3R4EC.js";
 import {
   LOG_KINDS,
   kindToComponent
 } from "./chunk-S6I62FAH.js";
-import {
-  getPluginVersion
-} from "./chunk-FYGFMIS6.js";
-import {
-  loadManifests
-} from "./chunk-QFMBZ72S.js";
-import {
-  findPackageRoot
-} from "./chunk-LPUQPDC2.js";
 import {
   require_dist
 } from "./chunk-D7TYRPRM.js";
@@ -370,7 +402,7 @@ var DaemonServer = class {
     if (match) {
       this.onRequest?.();
       try {
-        const body = req.method === "POST" || req.method === "PUT" ? await readBody(req) : void 0;
+        const body = req.method === "POST" || req.method === "PUT" || req.method === "PATCH" ? await readBody(req) : void 0;
         const result = await match.handler({
           body,
           query: match.query,
@@ -1238,7 +1270,7 @@ import os6 from "os";
 import path9 from "path";
 
 // src/db/queries/plans.ts
-var DEFAULT_LIST_LIMIT = 100;
+var DEFAULT_LIST_LIMIT2 = 100;
 var DEFAULT_STATUS2 = "active";
 var DEFAULT_PROCESSED = 0;
 var PLAN_COLUMNS = [
@@ -1276,7 +1308,7 @@ function toPlanRow(row) {
     embedded: row.embedded ?? 0,
     created_at: row.created_at,
     updated_at: row.updated_at ?? null,
-    machine_id: row.machine_id ?? DEFAULT_MACHINE_ID,
+    machine_id: row.machine_id ?? "local",
     synced_at: row.synced_at ?? null
   };
 }
@@ -1322,7 +1354,7 @@ function upsertPlan(data) {
     data.processed ?? DEFAULT_PROCESSED,
     data.created_at,
     data.updated_at ?? null,
-    data.machine_id ?? DEFAULT_MACHINE_ID
+    data.machine_id ?? getTeamMachineId()
   );
   const row = toPlanRow(
     db.prepare(`SELECT ${SELECT_COLUMNS} FROM plans WHERE id = ?`).get(data.id)
@@ -1339,7 +1371,7 @@ function listPlans(options = {}) {
     params.push(options.status);
   }
   const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const limit = options.limit ?? DEFAULT_LIST_LIMIT;
+  const limit = options.limit ?? DEFAULT_LIST_LIMIT2;
   params.push(limit);
   const rows = db.prepare(
     `SELECT ${SELECT_COLUMNS}
@@ -1419,7 +1451,8 @@ function mergeConfigSections(current, incoming) {
     agent: { ...current.agent, ...incoming.agent },
     context: { ...current.context, ...incoming.context },
     backup: { ...current.backup, ...incoming.backup },
-    team: { ...current.team, ...incoming.team }
+    team: { ...current.team, ...incoming.team },
+    notifications: { ...current.notifications, ...incoming.notifications }
   };
 }
 async function handleGetConfig(vaultDir) {
@@ -2621,6 +2654,13 @@ function listActivitiesByBatch(batchId) {
   ).all(batchId);
   return rows.map(toActivityRow);
 }
+function countActivities(sessionId) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT COUNT(*) AS count FROM activities WHERE session_id = ?`
+  ).get(sessionId);
+  return row.count;
+}
 
 // src/db/queries/attachments.ts
 var ATTACHMENT_COLUMNS = [
@@ -2702,10 +2742,10 @@ function getAttachmentByFilePath(filePath) {
 }
 
 // src/daemon/api/sessions.ts
-var DEFAULT_LIST_LIMIT2 = 50;
+var DEFAULT_LIST_LIMIT3 = 50;
 var DEFAULT_LIST_OFFSET = 0;
 async function handleListSessions(req) {
-  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT2;
+  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT3;
   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;
@@ -2728,7 +2768,9 @@ async function handleListSessions(req) {
 async function handleGetSession(req) {
   const session = getSession(req.params.id);
   if (!session) return { status: 404, body: { error: "not_found" } };
-  return { body: session };
+  const promptCount = countBatchesBySession(session.id);
+  const toolCount = countActivities(session.id);
+  return { body: { ...session, prompt_count: promptCount, tool_count: toolCount } };
 }
 async function handleGetSessionBatches(req) {
   const batches = listBatchesBySession(req.params.id);
@@ -2750,7 +2792,7 @@ async function handleGetSessionPlans(req) {
 }
 
 // src/daemon/api/mycelium.ts
-var DEFAULT_LIST_LIMIT3 = 50;
+var DEFAULT_LIST_LIMIT4 = 50;
 var DEFAULT_LIST_OFFSET2 = 0;
 var DEFAULT_GRAPH_DEPTH = 1;
 var MAX_GRAPH_DEPTH = 3;
@@ -2760,7 +2802,7 @@ 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 limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT4;
   const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET2;
   const search = req.query.search || void 0;
   const filterOpts = {
@@ -2783,7 +2825,7 @@ async function handleListEntities(req) {
   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 limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT4;
   const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET2;
   const entities = listEntities({
     agent_id: agentId,
@@ -4114,6 +4156,142 @@ var SqliteRecordSource = class {
   }
 };
 
+// src/notifications/domains.ts
+function registerBuiltinDomains() {
+  register({
+    domain: "agents",
+    label: "Agent Tasks",
+    types: [
+      { id: "agent.task.success", label: "Task completed", defaultMode: "banner", defaultLevel: "success" },
+      { id: "agent.task.failure", label: "Task failed", defaultMode: "banner", defaultLevel: "error" }
+    ]
+  });
+  register({
+    domain: "sessions",
+    label: "Sessions",
+    types: [
+      { id: "session.started", label: "Session started", defaultMode: "summary", defaultLevel: "info" },
+      { id: "session.ended", label: "Session ended", defaultMode: "summary", defaultLevel: "info" }
+    ]
+  });
+  register({
+    domain: "skills",
+    label: "Skills",
+    types: [
+      { id: "skill.surveyed", label: "Skill candidate surveyed", defaultMode: "summary", defaultLevel: "info" },
+      { id: "skill.created", label: "Skill created", defaultMode: "banner", defaultLevel: "success" },
+      { id: "skill.evolved", label: "Skill evolved", defaultMode: "banner", defaultLevel: "info" }
+    ]
+  });
+  register({
+    domain: "mycelium",
+    label: "Mycelium",
+    types: [
+      { id: "mycelium.digest.completed", label: "Digest cycle completed", defaultMode: "summary", defaultLevel: "info" },
+      { id: "mycelium.spore.created", label: "New spore extracted", defaultMode: "summary", defaultLevel: "info" }
+    ]
+  });
+}
+
+// src/daemon/api/notifications.ts
+var CreateNotificationBody = external_exports.object({
+  domain: external_exports.string().min(1),
+  type: external_exports.string().min(1),
+  level: external_exports.enum(["info", "success", "warning", "error"]).optional(),
+  title: external_exports.string().min(1),
+  message: external_exports.string().optional(),
+  mode: external_exports.enum(["banner", "summary"]).optional(),
+  link: external_exports.string().optional(),
+  metadata: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+});
+var UpdateStatusBody = external_exports.object({
+  status: external_exports.enum(["read", "dismissed"])
+});
+async function handleListNotifications(_vaultDir, query) {
+  const status = query.status;
+  const domain = query.domain;
+  const mode = query.mode;
+  const limit = query.limit ? Number(query.limit) : void 0;
+  const offset = query.offset ? Number(query.offset) : void 0;
+  const items = listNotifications({ status, domain, mode, limit, offset });
+  const unreadCount = countNotifications("unread");
+  return {
+    body: {
+      items: items.map(parseNotificationRow),
+      unread_count: unreadCount
+    }
+  };
+}
+async function handleCreateNotification(vaultDir, body) {
+  const parsed = CreateNotificationBody.safeParse(body);
+  if (!parsed.success) {
+    return { status: 400, body: { error: "validation_failed", issues: parsed.error.issues } };
+  }
+  const { domain, type, title, message, link, metadata } = parsed.data;
+  const config = loadConfig(vaultDir);
+  if (!config.notifications.enabled) {
+    return { body: { ok: true, suppressed: true, reason: "notifications_disabled" } };
+  }
+  const domainConfig = config.notifications.domains[domain];
+  if (domainConfig && !domainConfig.enabled) {
+    return { body: { ok: true, suppressed: true, reason: "domain_disabled" } };
+  }
+  const id = notify(vaultDir, {
+    domain,
+    type,
+    title,
+    message,
+    link,
+    metadata,
+    level: parsed.data.level,
+    mode: parsed.data.mode
+  }, config);
+  if (!id) {
+    return { body: { ok: true, suppressed: true, reason: "unknown" } };
+  }
+  return {
+    body: {
+      ok: true,
+      id,
+      notification: parseNotificationRow(getNotification(id))
+    }
+  };
+}
+async function handleUpdateNotification(_vaultDir, id, body) {
+  const parsed = UpdateStatusBody.safeParse(body);
+  if (!parsed.success) {
+    return { status: 400, body: { error: "validation_failed", issues: parsed.error.issues } };
+  }
+  const updated = updateNotificationStatus(id, parsed.data.status);
+  if (!updated) {
+    return { status: 404, body: { error: "not_found" } };
+  }
+  return { body: { ok: true } };
+}
+async function handleDismissAll(_vaultDir, body) {
+  const domain = body?.domain;
+  const count = dismissAllNotifications(domain);
+  return { body: { ok: true, dismissed: count } };
+}
+async function handleMarkAllRead(_vaultDir, body) {
+  const domain = body?.domain;
+  const count = markAllRead(domain);
+  return { body: { ok: true, marked: count } };
+}
+async function handleGetRegistry() {
+  return { body: { domains: getAllDomains() } };
+}
+async function handleUnreadCount() {
+  return { body: { count: countNotifications("unread") } };
+}
+function parseNotificationRow(row) {
+  if (!row) return null;
+  return {
+    ...row,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null
+  };
+}
+
 // src/daemon/api/agent-tasks.ts
 var import_yaml2 = __toESM(require_dist(), 1);
 var HTTP_OK = 200;
@@ -4335,6 +4513,186 @@ function testCloud() {
   return { ok: true };
 }
 
+// src/db/queries/skill-usage.ts
+var USAGE_COLUMNS = [
+  "id",
+  "skill_id",
+  "session_id",
+  "machine_id",
+  "detected_at"
+];
+var SELECT_COLUMNS4 = USAGE_COLUMNS.join(", ");
+function toUsageRow(row) {
+  return {
+    id: row.id,
+    skill_id: row.skill_id,
+    session_id: row.session_id,
+    machine_id: row.machine_id ?? getTeamMachineId(),
+    detected_at: row.detected_at
+  };
+}
+function insertSkillUsage(data) {
+  const db = getDatabase();
+  db.prepare(
+    `INSERT INTO skill_usage (
+       id, skill_id, session_id, machine_id, detected_at
+     ) VALUES (
+       ?, ?, ?, ?, ?
+     )`
+  ).run(
+    data.id,
+    data.skill_id,
+    data.session_id,
+    data.machine_id ?? getTeamMachineId(),
+    data.detected_at
+  );
+  const row = toUsageRow(
+    db.prepare(`SELECT ${SELECT_COLUMNS4} FROM skill_usage WHERE id = ?`).get(data.id)
+  );
+  return row;
+}
+function hasUsageForSkillAndSession(skillId, sessionId) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT 1 FROM skill_usage WHERE skill_id = ? AND session_id = ? LIMIT 1`
+  ).get(skillId, sessionId);
+  return row !== void 0;
+}
+function countUsageForSkill(skillId) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT COUNT(*) as count FROM skill_usage WHERE skill_id = ?`
+  ).get(skillId);
+  return row.count;
+}
+
+// src/daemon/api/skills.ts
+var DEFAULT_LIST_OFFSET3 = 0;
+async function handleListCandidates(req) {
+  const status = req.query.status || void 0;
+  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT;
+  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET3;
+  const { items: candidates, total } = listCandidatesWithCount({ status, limit, offset });
+  return { status: 200, body: { candidates, total } };
+}
+async function handleGetCandidate(req) {
+  const candidate = getCandidate(req.params.id);
+  if (!candidate) {
+    return { status: 404, body: { error: `Not found: ${req.params.id}` } };
+  }
+  return { status: 200, body: { candidate } };
+}
+async function handleUpdateCandidate(req) {
+  const id = req.params.id;
+  const body = req.body;
+  if (!body) return { status: 400, body: { error: "Request body required" } };
+  const { status, topic, rationale, confidence, source_ids, skill_id } = body;
+  const updated = updateCandidate(id, {
+    ...status !== void 0 ? { status } : {},
+    ...topic !== void 0 ? { topic } : {},
+    ...rationale !== void 0 ? { rationale } : {},
+    ...confidence !== void 0 ? { confidence } : {},
+    ...source_ids !== void 0 ? { source_ids } : {},
+    ...skill_id !== void 0 ? { skill_id } : {},
+    updated_at: epochSeconds()
+  });
+  if (!updated) return { status: 404, body: { error: `Candidate not found: ${id}` } };
+  return { status: 200, body: { candidate: updated } };
+}
+async function handleListSkillRecords(req) {
+  const status = req.query.status || void 0;
+  const limit = req.query.limit ? Number(req.query.limit) : DEFAULT_LIST_LIMIT;
+  const offset = req.query.offset ? Number(req.query.offset) : DEFAULT_LIST_OFFSET3;
+  const { items: records, total } = listSkillRecordsWithCount({ status, limit, offset });
+  return { status: 200, body: { records, total } };
+}
+async function handleGetSkillRecord(req) {
+  const idOrName = req.params.id;
+  const record = getSkillRecord(idOrName) ?? getSkillRecordByName(idOrName);
+  if (!record) {
+    return { status: 404, body: { error: `Not found: ${idOrName}` } };
+  }
+  const lineage = listLineageForSkill(record.id);
+  const usage_total = countUsageForSkill(record.id);
+  const latestSnapshot = lineage[0]?.content_snapshot;
+  const frontmatterFields = {};
+  if (latestSnapshot) {
+    const fmMatch = latestSnapshot.match(/^---\n([\s\S]*?)\n---/);
+    if (fmMatch) {
+      for (const line of fmMatch[1].split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx > 0) {
+          const key = line.slice(0, colonIdx).trim();
+          const val = line.slice(colonIdx + 1).trim();
+          if (key && val) frontmatterFields[key] = val;
+        }
+      }
+    }
+  }
+  return { status: 200, body: { ...record, lineage, usage_total, frontmatter: frontmatterFields } };
+}
+async function handleDeleteCandidate(req) {
+  const id = req.params.id;
+  const deleted = deleteCandidate(id);
+  if (!deleted) return { status: 404, body: { error: `Not found: ${id}` } };
+  return { status: 200, body: { deleted: true, id } };
+}
+async function handleDeleteSkillRecord(req) {
+  const idOrName = req.params.id;
+  const result = deleteSkillRecordCascade(idOrName);
+  if (!result) return { status: 404, body: { error: `Not found: ${idOrName}` } };
+  if (isTeamSyncEnabled()) {
+    try {
+      enqueueOutbox({
+        table_name: "skill_records",
+        row_id: result.id,
+        operation: "delete",
+        payload: JSON.stringify({ id: result.id, name: result.name }),
+        machine_id: getTeamMachineId(),
+        created_at: epochSeconds()
+      });
+    } catch (err) {
+      console.warn("[team-sync] Failed to enqueue skill record deletion:", err instanceof Error ? err.message : err);
+    }
+  }
+  return { status: 200, body: { deleted: true, id: result.id, name: result.name } };
+}
+
+// src/daemon/skill-usage.ts
+import crypto from "crypto";
+var SKILL_USAGE_DETECTION_ENABLED = false;
+var MAX_ACTIVE_SKILLS_CHECK = 1e3;
+function detectSkillUsage(sessionId, transcriptContent) {
+  if (transcriptContent.includes("vault_write_skill")) return;
+  if (!SKILL_USAGE_DETECTION_ENABLED) return;
+  const activeSkills = listSkillRecords({ status: "active", limit: MAX_ACTIVE_SKILLS_CHECK });
+  if (activeSkills.length === 0) return;
+  const skillPatterns = activeSkills.map((skill) => ({
+    skill,
+    pattern: new RegExp(
+      `skills/${escapeRegex(skill.name)}/SKILL\\.md|<skill[^>]*name=["']${escapeRegex(skill.name)}["']`
+    )
+  }));
+  const now = epochSeconds();
+  for (const { skill, pattern } of skillPatterns) {
+    try {
+      if (!pattern.test(transcriptContent)) continue;
+      if (hasUsageForSkillAndSession(skill.id, sessionId)) continue;
+      insertSkillUsage({
+        id: crypto.randomUUID(),
+        skill_id: skill.id,
+        session_id: sessionId,
+        detected_at: now
+      });
+      incrementSkillUsageCount(skill.id, now);
+    } catch {
+    }
+  }
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // src/daemon/log-reconcile.ts
 import fs12 from "fs";
 import path14 from "path";
@@ -4471,6 +4829,50 @@ var PowerManager = class {
   }
 };
 
+// src/daemon/task-scheduler.ts
+function resolveSchedule(yamlSchedule, configOverride) {
+  if (!configOverride?.schedule) return yamlSchedule;
+  return {
+    enabled: configOverride.schedule.enabled ?? yamlSchedule.enabled,
+    intervalSeconds: configOverride.schedule.intervalSeconds ?? yamlSchedule.intervalSeconds,
+    runIn: configOverride.schedule.runIn ?? yamlSchedule.runIn,
+    preCondition: configOverride.schedule.preCondition ?? yamlSchedule.preCondition
+  };
+}
+function buildScheduledJobs(tasks, configOverrides, context, initialLastRuns) {
+  const jobs = [];
+  for (const task of tasks) {
+    if (!task.schedule) continue;
+    const override = configOverrides[task.name];
+    const effective = resolveSchedule(task.schedule, override);
+    if (!effective.enabled) continue;
+    let lastRun = initialLastRuns?.[task.name] ?? 0;
+    const intervalMs = effective.intervalSeconds * 1e3;
+    jobs.push({
+      name: `scheduled:${task.name}`,
+      runIn: effective.runIn,
+      fn: async () => {
+        if (!context) return;
+        if (context.isTaskRunning(task.name)) return;
+        if (Date.now() - lastRun < intervalMs) return;
+        if (effective.preCondition) {
+          const check = context.preConditions[effective.preCondition];
+          if (!check) return;
+          if (!check()) return;
+        }
+        try {
+          context.setTaskRunning(task.name, true);
+          await context.runTask(task.name);
+        } finally {
+          lastRun = Date.now();
+          context.setTaskRunning(task.name, false);
+        }
+      }
+    });
+  }
+  return jobs;
+}
+
 // src/daemon/jobs/session-cleanup.ts
 import { unlink, glob } from "fs/promises";
 async function cleanupAfterSessionCascade(sessionId, result, embeddingManager, vaultDir) {
@@ -4587,7 +4989,8 @@ function handleUserPrompt(sessionId, prompt) {
     session_id: sessionId,
     user_prompt: prompt ?? null,
     started_at: now,
-    created_at: now
+    created_at: now,
+    machine_id: getTeamMachineId()
   });
   const promptNumber = batch.prompt_number;
   try {
@@ -4613,6 +5016,7 @@ function handleToolUse(sessionId, toolName, toolInput, toolOutput) {
   if (activity.prompt_batch_id !== null) {
     incrementActivityCount(activity.prompt_batch_id);
   }
+  incrementSessionToolCount(sessionId);
 }
 function handleStopBatches(sessionId) {
   closeOpenBatches(sessionId, epochSeconds());
@@ -4738,6 +5142,7 @@ async function main() {
   logger.info(LOG_KINDS.DAEMON_START, "Machine ID resolved", { machine_id: machineId });
   const db = initDatabase(vaultDbPath(vaultDir));
   createSchema(db, machineId);
+  registerBuiltinDomains();
   logger.info(LOG_KINDS.DAEMON_START, "SQLite initialized", { vault: vaultDir });
   initTeamContext(config.team.enabled, machineId);
   logger.setPersistFn((entry) => {
@@ -4767,9 +5172,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 });
+  let definitionsDir;
   try {
-    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-BQ4X4K3F.js");
-    const definitionsDir = resolveDefinitionsDir2();
+    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-WQKVWL5D.js");
+    definitionsDir = resolveDefinitionsDir2();
     await registerBuiltInAgentsAndTasks(definitionsDir, vaultDir);
     logger.info(LOG_KINDS.AGENT_TASK, "Built-in agents and tasks registered");
   } catch (err) {
@@ -4814,8 +5220,11 @@ async function main() {
   const server = new DaemonServer({
     vaultDir,
     logger,
-    uiDir: uiDir ?? void 0,
-    onRequest: () => powerManager.recordActivity()
+    uiDir: uiDir ?? void 0
+    // Don't record activity on every HTTP request — UI polling (every 3-10s)
+    // would prevent the PowerManager from ever reaching 'idle' state, blocking
+    // all idle-only scheduled tasks (skill-survey, skill-generate, skill-evolve).
+    // Activity is recorded on meaningful events below (session register, prompt capture, etc.).
   });
   const registry = new SessionRegistry({
     gracePeriod: 0,
@@ -4831,10 +5240,8 @@ async function main() {
   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-LKDWMGC7.js");
+      const { runAgent } = await import("./executor-W5MKZH7B.js");
       runAgent(vaultDir, {
         task: "title-summary",
         instruction: `Process session ${sessionId} only`,
@@ -4950,6 +5357,7 @@ async function main() {
     last_assistant_message: external_exports.string().optional()
   });
   server.registerRoute("POST", "/sessions/register", async (req) => {
+    powerManager.recordActivity();
     const { session_id, agent, branch, started_at } = RegisterBody.parse(req.body);
     const resolvedStartedAt = started_at ?? (/* @__PURE__ */ new Date()).toISOString();
     registry.register(session_id, { started_at: resolvedStartedAt, branch });
@@ -4964,11 +5372,20 @@ async function main() {
       branch: branch ?? null,
       started_at: startedEpoch,
       created_at: now,
-      status: "active"
+      status: "active",
+      machine_id: machineId
     });
     updateSession(session_id, { ended_at: null, status: "active" });
     reconcileSession(session_id);
     logger.info(LOG_KINDS.LIFECYCLE_REGISTER, "Session registered", { session_id, branch, started_at: started_at ?? null });
+    notify(vaultDir, {
+      domain: "sessions",
+      type: "session.started",
+      title: "Session started",
+      message: branch ? `Branch: ${branch}` : void 0,
+      link: `/sessions/${session_id}`,
+      metadata: { sessionId: session_id, agent: agent ?? "claude-code", branch }
+    }, config);
     return { body: { ok: true, sessions: registry.sessions } };
   });
   server.registerRoute("POST", "/sessions/unregister", async (req) => {
@@ -4981,6 +5398,13 @@ async function main() {
     reconciledSessions.delete(session_id);
     server.updateDaemonJsonSessions(registry.sessions);
     logger.info(LOG_KINDS.LIFECYCLE_UNREGISTER, "Session unregistered", { session_id });
+    notify(vaultDir, {
+      domain: "sessions",
+      type: "session.ended",
+      title: "Session ended",
+      link: `/sessions/${session_id}`,
+      metadata: { sessionId: session_id }
+    }, config);
     return { body: { ok: true, sessions: registry.sessions } };
   });
   server.registerRoute("POST", "/events", async (req) => {
@@ -4997,7 +5421,8 @@ async function main() {
         agent: event.agent ?? "claude-code",
         status: "active",
         started_at: startedEpoch,
-        created_at: now
+        created_at: now,
+        machine_id: machineId
       });
       reconcileSession(event.session_id);
     }
@@ -5006,6 +5431,7 @@ async function main() {
     }
     sessionBuffers.get(event.session_id).append(event);
     if (event.type === "user_prompt") {
+      powerManager.recordActivity();
       const promptText = String(event.prompt ?? "");
       if (isSystemMessage(promptText)) {
         logger.debug(LOG_KINDS.HOOKS_PROMPT, "Skipped system-injected message", {
@@ -5301,16 +5727,37 @@ async function main() {
         }
       }
     }
+    const currentSession = getSession(sessionId);
+    const transcriptPromptCount = allTurns.length;
+    const transcriptToolCount = allTurns.reduce((sum, t) => sum + t.toolCount, 0);
     const updateFields = {
       transcript_path: hookTranscriptPath ?? null,
-      prompt_count: allTurns.length,
-      tool_count: allTurns.reduce((sum, t) => sum + t.toolCount, 0)
+      prompt_count: Math.max(transcriptPromptCount, currentSession?.prompt_count ?? 0),
+      tool_count: Math.max(transcriptToolCount, currentSession?.tool_count ?? 0)
     };
     if (user) updateFields.user = user;
     if (!hasTitle && sessionTitleCache.has(sessionId)) {
       updateFields.title = sessionTitleCache.get(sessionId);
     }
     updateSession(sessionId, updateFields);
+    if (SKILL_USAGE_DETECTION_ENABLED) {
+      try {
+        let transcriptText = null;
+        if (hookTranscriptPath) {
+          try {
+            transcriptText = fs13.readFileSync(hookTranscriptPath, "utf-8");
+          } catch {
+          }
+        }
+        if (!transcriptText && allTurns.length > 0) {
+          transcriptText = allTurns.map((t) => [t.prompt ?? "", t.aiResponse ?? ""].join(" ")).join("\n");
+        }
+        if (transcriptText) {
+          detectSkillUsage(sessionId, transcriptText);
+        }
+      } catch {
+      }
+    }
     const responses = [];
     for (let i = 0; i < allTurns.length; i++) {
       if (allTurns[i].aiResponse) {
@@ -5474,6 +5921,34 @@ async function main() {
   server.registerRoute("GET", "/api/batches/:id/activities", handleGetBatchActivities);
   server.registerRoute("GET", "/api/sessions/:id/attachments", handleGetSessionAttachments);
   server.registerRoute("GET", "/api/sessions/:id/plans", handleGetSessionPlans);
+  server.registerRoute("GET", "/api/skill-candidates", handleListCandidates);
+  server.registerRoute("GET", "/api/skill-candidates/:id", handleGetCandidate);
+  server.registerRoute("PUT", "/api/skill-candidates/:id", handleUpdateCandidate);
+  server.registerRoute("GET", "/api/skill-records", handleListSkillRecords);
+  server.registerRoute("GET", "/api/skill-records/:id", handleGetSkillRecord);
+  server.registerRoute("DELETE", "/api/skill-candidates/:id", handleDeleteCandidate);
+  server.registerRoute("DELETE", "/api/skill-records/:id", async (req) => {
+    const result = await handleDeleteSkillRecord(req);
+    if (result.body?.deleted) {
+      const record = result.body;
+      if (record.name) {
+        const projectRoot2 = path15.resolve(vaultDir, "..");
+        const skillDir = path15.resolve(projectRoot2, ".agents", "skills", record.name);
+        try {
+          fs13.rmSync(skillDir, { recursive: true, force: true });
+        } catch (err) {
+          logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to remove skill directory", { name: record.name, error: String(err) });
+        }
+        try {
+          const { syncSkillSymlinks } = await import("./installer-25TSX4SR.js");
+          syncSkillSymlinks(projectRoot2, record.name, { remove: true });
+        } catch (err) {
+          logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to remove skill symlinks", { name: record.name, error: String(err) });
+        }
+      }
+    }
+    return result;
+  });
   server.registerRoute("GET", "/api/spores", handleListSpores);
   server.registerRoute("GET", "/api/spores/:id", handleGetSpore);
   server.registerRoute("GET", "/api/entities", handleListEntities);
@@ -5508,18 +5983,28 @@ async function main() {
     const contentType = ATTACHMENT_MEDIA_TYPES[ext] ?? "application/octet-stream";
     return { status: 200, headers: { "Content-Type": contentType }, body: diskData };
   });
+  function buildSkillGenerateInstruction() {
+    const candidates = listCandidates({ status: "approved", limit: 1 });
+    if (candidates.length > 0) {
+      return `Generate skill for candidate id=${candidates[0].id} topic="${candidates[0].topic}"`;
+    }
+    return void 0;
+  }
   const AgentRunBody = external_exports.object({
     task: external_exports.string().optional(),
     instruction: external_exports.string().optional(),
     agentId: external_exports.string().optional()
   });
   server.registerRoute("POST", "/api/agent/run", async (req) => {
-    const { task, instruction, agentId } = AgentRunBody.parse(req.body);
-    const { runAgent } = await import("./executor-LKDWMGC7.js");
+    const { task, instruction: rawInstruction, agentId } = AgentRunBody.parse(req.body);
+    let instruction = rawInstruction;
+    if (task === "skill-generate" && !instruction) {
+      instruction = buildSkillGenerateInstruction();
+    }
+    const { runAgent } = await import("./executor-W5MKZH7B.js");
     const resultPromise = runAgent(vaultDir, { task, instruction, agentId, embeddingManager });
     const effectiveAgentId = agentId ?? "myco-agent";
-    const latestRun = getRunningRun(effectiveAgentId);
-    const runId = latestRun?.id;
+    const runId = getLatestRunId(effectiveAgentId, task);
     resultPromise.then((result) => {
       if (result.status === "failed") {
         logger.error(LOG_KINDS.AGENT_ERROR, "Agent run failed", {
@@ -5601,6 +6086,7 @@ async function main() {
     const spore = insertSpore({
       id,
       agent_id: USER_AGENT_ID,
+      machine_id: machineId,
       observation_type: observationType,
       content,
       tags: tags ? tags.join(", ") : null,
@@ -5696,11 +6182,12 @@ async function main() {
       name: USER_AGENT_NAME,
       created_at: now
     });
-    const { insertResolutionEvent } = await import("./resolution-events-WZHPQQMN.js");
+    const { insertResolutionEvent } = await import("./resolution-events-5EVUEWHS.js");
     const resolutionId = `res-${randomBytes(RESOLUTION_ID_RANDOM_BYTES).toString("hex")}`;
     insertResolutionEvent({
       id: resolutionId,
       agent_id: USER_AGENT_ID,
+      machine_id: machineId,
       spore_id: old_spore_id,
       action: "supersede",
       new_spore_id,
@@ -5786,6 +6273,13 @@ 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/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));
+  server.registerRoute("POST", "/api/notifications/dismiss-all", async (req) => handleDismissAll(vaultDir, req.body));
+  server.registerRoute("POST", "/api/notifications/mark-all-read", async (req) => handleMarkAllRead(vaultDir, req.body));
+  server.registerRoute("GET", "/api/notifications/registry", async () => handleGetRegistry());
+  server.registerRoute("GET", "/api/notifications/unread-count", async () => handleUnreadCount());
   await server.evictExistingDaemon();
   const resolvedPort = await resolvePort(config.daemon.port, vaultDir);
   if (resolvedPort === 0) {
@@ -5828,43 +6322,6 @@ async function main() {
       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-LKDWMGC7.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"],
@@ -5904,9 +6361,12 @@ async function main() {
           const result = await client.pushBatch(pending);
           if (result.synced > 0 || result.skipped > 0) {
             const failedIds = new Set(result.errors.map((e) => e.id));
-            const sentIds = pending.filter((r) => !failedIds.has(String(r.row_id))).map((r) => r.id);
+            const sentRecords = pending.filter((r) => !failedIds.has(String(r.row_id)));
+            const sentIds = sentRecords.map((r) => r.id);
             if (sentIds.length > 0) {
-              markSent(sentIds, epochSeconds());
+              const now = epochSeconds();
+              markSent(sentIds, now);
+              markSourceRowsSynced(sentRecords, now);
             }
           }
           if (result.errors.length > 0) {
@@ -5927,6 +6387,111 @@ async function main() {
       }
     });
   }
+  {
+    const runningTasks = /* @__PURE__ */ new Set();
+    if (definitionsDir) {
+      const { loadAllTasks: loadAllTasks2 } = await import("./registry-2XQMCPA6.js");
+      const allTasks = Array.from(loadAllTasks2(definitionsDir, vaultDir).values());
+      const initialLastRuns = {};
+      try {
+        const recentRuns = getDatabase().prepare(
+          `SELECT task, MAX(completed_at) as last_completed
+           FROM agent_runs
+           WHERE status IN ('completed', 'failed') AND completed_at IS NOT NULL
+           GROUP BY task`
+        ).all();
+        for (const row of recentRuns) {
+          initialLastRuns[row.task] = row.last_completed * 1e3;
+        }
+      } catch {
+      }
+      const scheduledContext = {
+        isTaskRunning: (name) => runningTasks.has(name),
+        setTaskRunning: (name, running) => {
+          if (running) runningTasks.add(name);
+          else runningTasks.delete(name);
+        },
+        runTask: async (taskName) => {
+          const { runAgent } = await import("./executor-W5MKZH7B.js");
+          const instruction = taskName === "skill-generate" ? buildSkillGenerateInstruction() : void 0;
+          const result = await runAgent(vaultDir, { task: taskName, instruction, embeddingManager });
+          logger.info(LOG_KINDS.AGENT_RUN, `Scheduled task ${taskName} completed`, {
+            status: result.status,
+            runId: result.runId
+          });
+          if (result.status === "failed") {
+            notify(vaultDir, {
+              domain: "agents",
+              type: "agent.task.failure",
+              title: `Task failed: ${taskName}`,
+              message: result.error ?? "Unknown error",
+              link: `/agent?run=${result.runId}`,
+              metadata: { taskName, runId: result.runId }
+            }, config);
+          } else if (result.status === "completed") {
+            notify(vaultDir, {
+              domain: "agents",
+              type: "agent.task.success",
+              title: `Task completed: ${taskName}`,
+              link: `/agent?run=${result.runId}`,
+              metadata: { taskName, runId: result.runId }
+            }, config);
+            const { countToolCallsByRun } = await import("./turns-3ZQAF6HF.js");
+            const counts = countToolCallsByRun(result.runId, ["vault_create_spore", "vault_write_digest"]);
+            const sporeCount = counts["vault_create_spore"] ?? 0;
+            const digestCount = counts["vault_write_digest"] ?? 0;
+            if (sporeCount > 0) {
+              notify(vaultDir, {
+                domain: "mycelium",
+                type: "mycelium.spore.created",
+                title: sporeCount === 1 ? "Extracted 1 observation" : `Extracted ${sporeCount} observations`,
+                message: `From ${taskName} run`,
+                link: "/mycelium?tab=spores",
+                metadata: { count: sporeCount, taskName, runId: result.runId }
+              }, config);
+            }
+            if (digestCount > 0) {
+              notify(vaultDir, {
+                domain: "mycelium",
+                type: "mycelium.digest.completed",
+                title: `Digest updated (${digestCount} ${digestCount === 1 ? "tier" : "tiers"})`,
+                link: "/mycelium?tab=digest",
+                metadata: { tierCount: digestCount, taskName, runId: result.runId }
+              }, config);
+            }
+          }
+        },
+        preConditions: {
+          "has-unprocessed-batches": () => {
+            const row = getDatabase().prepare(
+              "SELECT 1 FROM prompt_batches WHERE processed = 0 LIMIT 1"
+            ).get();
+            return row !== void 0;
+          },
+          "has-active-skills": () => {
+            return countSkillRecords({ status: "active" }) > 0;
+          },
+          "has-approved-candidates": () => {
+            return countCandidates({ status: "approved" }) > 0;
+          }
+        }
+      };
+      const scheduledJobs = buildScheduledJobs(
+        allTasks,
+        config.agent.tasks ?? {},
+        scheduledContext,
+        initialLastRuns
+      );
+      for (const job of scheduledJobs) {
+        powerManager.register(job);
+      }
+      logger.info(LOG_KINDS.DAEMON_START, `Registered ${scheduledJobs.length} scheduled task(s)`, {
+        tasks: scheduledJobs.map((j) => j.name)
+      });
+    } else {
+      logger.warn(LOG_KINDS.AGENT_ERROR, "Skipping dynamic task scheduling \u2014 definitions directory unavailable");
+    }
+  }
   powerManager.start();
   const shutdown = async (signal) => {
     logger.info(LOG_KINDS.DAEMON_START, `${signal} received`);
@@ -5957,4 +6522,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-CMWNMCW2.js.map
+//# sourceMappingURL=main-IZ277SHB.js.map