@goondocks/myco 0.13.0 → 0.14.1

package/dist/{main-25MKYYKO.js → main-XUQRWNJ7.js}

@@ -3,42 +3,27 @@ import {
   DaemonLogger,
   LEVEL_ORDER
 } from "./chunk-ZESTWGJT.js";
-import {
-  withTaskConfig
-} from "./chunk-SODRR3HE.js";
-import {
-  EMBEDDABLE_TABLES,
-  EMBEDDABLE_TEXT_COLUMNS,
-  assertValidTable,
-  clearEmbedded,
-  gatherStats,
-  getEmbeddingQueueDepth,
-  getUnembedded,
-  markEmbedded
-} from "./chunk-T77674VB.js";
-import {
-  getMachineId
-} from "./chunk-ENWBFX7F.js";
-import {
-  createEmbeddingProvider
-} from "./chunk-LD6U3L6O.js";
 import {
   closeOpenBatches,
   countBatchesBySession,
   countCandidates,
+  countNotifications,
   countRuns,
   countSkillRecords,
   createBatchLineage,
   deleteCandidate,
   deleteSkillRecordCascade,
+  dismissAllNotifications,
   errorMessage,
   findBatchByPromptPrefix,
+  getAllDomains,
   getCandidate,
   getDigestExtract,
   getEntity,
   getGraphForNode,
   getLatestBatch,
   getLatestRunId,
+  getNotification,
   getRun,
   getSkillRecord,
   getSkillRecordByName,
@@ -51,19 +36,42 @@ import {
   listDigestExtracts,
   listEntities,
   listLineageForSkill,
+  listNotifications,
   listReports,
   listRuns,
   listSkillRecords,
   listSkillRecordsWithCount,
-  listTurnsByRun,
+  markAllRead,
+  notify,
   populateBatchResponses,
+  register,
   setResponseSummary,
-  updateCandidate
-} from "./chunk-5BK6M6X5.js";
+  updateCandidate,
+  updateNotificationStatus
+} from "./chunk-JJXVDCEX.js";
 import {
   fullTextSearch,
   hydrateSearchResults
 } from "./chunk-DTE3SHYK.js";
+import {
+  withTaskConfig
+} from "./chunk-SODRR3HE.js";
+import {
+  EMBEDDABLE_TABLES,
+  EMBEDDABLE_TEXT_COLUMNS,
+  assertValidTable,
+  clearEmbedded,
+  gatherStats,
+  getEmbeddingQueueDepth,
+  getUnembedded,
+  markEmbedded
+} from "./chunk-QB2UTRQE.js";
+import {
+  getMachineId
+} from "./chunk-ENWBFX7F.js";
+import {
+  createEmbeddingProvider
+} from "./chunk-LD6U3L6O.js";
 import {
   copyTaskToUser,
   deleteUserTask,
@@ -77,12 +85,15 @@ import {
   resolveDefinitionsDir,
   taskFromParsed
 } from "./chunk-NVCGF2DS.js";
+import {
+  listTurnsByRun
+} from "./chunk-QLCD77AN.js";
 import {
   loadSecrets,
   readSecrets,
   writeSecret
 } from "./chunk-RJMXDUMA.js";
-import "./chunk-TFGGH6UB.js";
+import "./chunk-RUDOGKWF.js";
 import "./chunk-SAKJMNSR.js";
 import {
   checkLocalProvider
@@ -107,7 +118,7 @@ import {
   insertSpore,
   listSpores,
   updateSporeStatus
-} from "./chunk-LPISXFM4.js";
+} from "./chunk-PX5KIOKY.js";
 import {
   closeSession,
   countSessions,
@@ -118,7 +129,7 @@ import {
   listSessions,
   updateSession,
   upsertSession
-} from "./chunk-JBFFAGJK.js";
+} from "./chunk-X34OFKYU.js";
 import {
   backfillUnsynced,
   countPending,
@@ -128,14 +139,15 @@ import {
   isTeamSyncEnabled,
   listPending,
   markSent,
+  markSourceRowsSynced,
   pruneOld,
   syncRow
-} from "./chunk-NRT2ZRUG.js";
+} from "./chunk-S66YG6QK.js";
 import {
   EMBEDDING_DIMENSIONS,
   SCHEMA_VERSION,
   createSchema
-} from "./chunk-NCVR636M.js";
+} from "./chunk-4VF6KQ2Z.js";
 import {
   CONFIG_FILENAME,
   MycoConfigSchema,
@@ -143,7 +155,7 @@ import {
   updateBackupConfig,
   updateConfig,
   updateTeamConfig
-} from "./chunk-W3T3QDBN.js";
+} from "./chunk-PSYLKCWQ.js";
 import {
   closeDatabase,
   getDatabase,
@@ -152,10 +164,10 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   resolveCliEntryPath
-} from "./chunk-VQEXXS56.js";
+} from "./chunk-NYTEHLVI.js";
 import {
   getPluginVersion
-} from "./chunk-EUQQVKGQ.js";
+} from "./chunk-CCKPBAKJ.js";
 import {
   loadManifests
 } from "./chunk-QFMBZ72S.js";
@@ -390,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,
@@ -1439,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) {
@@ -4143,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;
@@ -4993,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) => {
@@ -5091,7 +5241,7 @@ async function main() {
   async function triggerTitleSummary(sessionId) {
     if (config.agent.summary_batch_interval <= 0) return;
     try {
-      const { runAgent } = await import("./executor-TCAXFOIS.js");
+      const { runAgent } = await import("./executor-4DKCQN3A.js");
       runAgent(vaultDir, {
         task: "title-summary",
         instruction: `Process session ${sessionId} only`,
@@ -5228,6 +5378,14 @@ async function main() {
     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) => {
@@ -5240,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) => {
@@ -5836,7 +6001,7 @@ async function main() {
     if (task === "skill-generate" && !instruction) {
       instruction = buildSkillGenerateInstruction();
     }
-    const { runAgent } = await import("./executor-TCAXFOIS.js");
+    const { runAgent } = await import("./executor-4DKCQN3A.js");
     const resultPromise = runAgent(vaultDir, { task, instruction, agentId, embeddingManager });
     const effectiveAgentId = agentId ?? "myco-agent";
     const runId = getLatestRunId(effectiveAgentId, task);
@@ -6017,7 +6182,7 @@ async function main() {
       name: USER_AGENT_NAME,
       created_at: now
     });
-    const { insertResolutionEvent } = await import("./resolution-events-BZYMUQ53.js");
+    const { insertResolutionEvent } = await import("./resolution-events-5EVUEWHS.js");
     const resolutionId = `res-${randomBytes(RESOLUTION_ID_RANDOM_BYTES).toString("hex")}`;
     insertResolutionEvent({
       id: resolutionId,
@@ -6108,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) {
@@ -6189,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) {
@@ -6237,13 +6412,54 @@ async function main() {
           else runningTasks.delete(name);
         },
         runTask: async (taskName) => {
-          const { runAgent } = await import("./executor-TCAXFOIS.js");
+          const { runAgent } = await import("./executor-4DKCQN3A.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": () => {
@@ -6306,4 +6522,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-25MKYYKO.js.map
+//# sourceMappingURL=main-XUQRWNJ7.js.map