@goondocks/myco 0.19.6 → 0.20.0

package/dist/{main-RPJSS7PT.js → main-5S4MDCIO.js}

@@ -2,10 +2,10 @@ import { createRequire as __cr } from 'node:module'; const require = __cr(import
 import {
   DaemonLogger,
   LEVEL_ORDER
-} from "./chunk-DURKJTVO.js";
+} from "./chunk-3WOS4TAR.js";
 import {
   withTaskConfig
-} from "./chunk-GFR542SM.js";
+} from "./chunk-US4LNCAT.js";
 import {
   EMBEDDABLE_TABLES,
   EMBEDDABLE_TEXT_COLUMNS,
@@ -15,7 +15,7 @@ import {
   getEmbeddingQueueDepth,
   getUnembedded,
   markEmbedded
-} from "./chunk-VLGBWOBY.js";
+} from "./chunk-P3DN5EWW.js";
 import {
   getTeamPackageVersion,
   loadSecrets,
@@ -23,7 +23,7 @@ import {
   readSecrets,
   resolveVaultConfigPath,
   writeSecret
-} from "./chunk-FKBPXCH3.js";
+} from "./chunk-QS5TWZBL.js";
 import {
   buildTaskInstruction,
   closeOpenBatches,
@@ -53,6 +53,7 @@ import {
   incrementActivityCount,
   incrementSkillUsageCount,
   insertBatchStateless,
+  insertResolutionEvent,
   isInstructionRequiredTask,
   listBatchesBySession,
   listCandidatesWithCount,
@@ -71,24 +72,24 @@ import {
   setResponseSummary,
   updateCandidate,
   updateNotificationStatus
-} from "./chunk-P5VNHGVZ.js";
+} from "./chunk-L6XFAJIF.js";
 import {
   fullTextSearch,
   hydrateSearchResults
-} from "./chunk-7ONVLO43.js";
+} from "./chunk-5XIVBO25.js";
 import {
   copyTaskToUser,
   deleteUserTask,
   loadAllTasks,
   validateTaskName,
   writeUserTask
-} from "./chunk-KYH4V4ML.js";
+} from "./chunk-57O67XVF.js";
 import {
   AgentTaskSchema,
   registerAgent,
   resolveDefinitionsDir,
   taskFromParsed
-} from "./chunk-Q4QD6LJT.js";
+} from "./chunk-4M7EWPIA.js";
 import {
   listTurnsByRun
 } from "./chunk-6RFZWV4R.js";
@@ -99,7 +100,7 @@ import {
 import {
   Anthropic,
   createEmbeddingProvider
-} from "./chunk-3J6TUJSV.js";
+} from "./chunk-KHT24OWC.js";
 import {
   getMachineId
 } from "./chunk-ENWBFX7F.js";
@@ -109,84 +110,93 @@ import {
   listBufferSessionIds
 } from "./chunk-V7XG6V6C.js";
 import "./chunk-POEPHBQK.js";
-import "./chunk-NCBLB2C6.js";
+import "./chunk-YSNIAJ5D.js";
 import "./chunk-SAKJMNSR.js";
 import {
   SymbiontInstaller
-} from "./chunk-TMNFCUAD.js";
+} from "./chunk-4LCIKVDM.js";
 import {
   checkLocalProvider
-} from "./chunk-6ZDJXSEO.js";
+} from "./chunk-BPRIYNLE.js";
 import {
   LmStudioBackend,
   OllamaBackend
-} from "./chunk-PMT2LSTQ.js";
+} from "./chunk-FMRZ26U5.js";
 import {
   countSpores,
   getSpore,
   insertSpore,
   listSpores,
   updateSporeStatus
-} from "./chunk-FGKCE5AE.js";
+} from "./chunk-4YFKBL3F.js";
 import {
+  backfillUnsynced,
   closeSession,
+  countDeadLettered,
+  countPending,
   countSessions,
   deleteSessionCascade,
+  enqueueOutbox,
   getSession,
   getSessionImpact,
-  incrementSessionToolCount,
-  listSessions,
-  reactivateSessionIfCompleted,
-  updateSession,
-  upsertSession
-} from "./chunk-Q6OEZM3S.js";
-import {
-  backfillUnsynced,
-  countDeadLettered,
-  countPending,
-  enqueueOutbox,
   getTeamMachineId,
   incrementRetryCount,
+  incrementSessionToolCount,
   initTeamContext,
   isTeamSyncEnabled,
   listPending,
+  listSessions,
   markSent,
   markSourceRowsSynced,
   pruneOld,
+  reactivateSessionIfCompleted,
   retryDeadLettered,
-  syncRow
-} from "./chunk-AULBWINA.js";
+  syncRow,
+  updateSession,
+  upsertSession
+} from "./chunk-EVDQKYCG.js";
+import {
+  evaluateSessionCaptureRules,
+  readTranscriptMeta
+} from "./chunk-XL75KZGI.js";
 import {
   EMBEDDING_DIMENSIONS,
   REST_SETTABLE_STATUSES,
   SCHEMA_VERSION,
   createSchema
-} from "./chunk-6DDRJQ4X.js";
+} from "./chunk-MYOZLMB2.js";
 import {
   CONFIG_FILENAME,
   MycoConfigSchema,
+  deepMergeConfig,
   getEnabledSymbiontNames,
   loadConfig,
+  loadLocalConfig,
+  loadMergedConfig,
   updateBackupConfig,
   updateConfig,
+  updateLocalConfig,
   updateTeamConfig
-} from "./chunk-NKQZ73LL.js";
+} from "./chunk-SRXTSI25.js";
 import {
   closeDatabase,
   getDatabase,
   initDatabase,
   vaultDbPath
 } from "./chunk-MYX5NCRH.js";
+import {
+  unsetAtPath
+} from "./chunk-ZXZPJJN3.js";
 import {
   resolveCliEntryPath
-} from "./chunk-QH5HS54N.js";
+} from "./chunk-UOQQENDW.js";
 import {
   getPluginVersion
-} from "./chunk-ST2D3SGM.js";
+} from "./chunk-ACQ2AIEM.js";
 import {
   loadManifests,
   resolvePackageRoot
-} from "./chunk-UVKQ62II.js";
+} from "./chunk-NGROSFOH.js";
 import {
   findPackageRoot
 } from "./chunk-LPUQPDC2.js";
@@ -203,6 +213,7 @@ import {
   FEED_DEFAULT_LIMIT,
   LOG_MESSAGE_PREVIEW_CHARS,
   LOG_PROMPT_PREVIEW_CHARS,
+  MCP_SESSIONS_DEFAULT_LIMIT,
   MS_PER_DAY,
   MS_PER_HOUR,
   MS_PER_SECOND,
@@ -224,6 +235,7 @@ import {
   RESTART_RESPONSE_FLUSH_MS,
   SEARCH_RESULTS_DEFAULT_LIMIT,
   SEARCH_SIMILARITY_THRESHOLD,
+  SESSION_SUMMARY_PREVIEW_CHARS,
   STALE_BUFFER_MAX_AGE_MS,
   STALE_SESSION_THRESHOLD_MS,
   SYNC_PROTOCOL_VERSION,
@@ -243,7 +255,7 @@ import {
   USER_TASK_SOURCE,
   epochSeconds,
   estimateTokens
-} from "./chunk-I54KLC6H.js";
+} from "./chunk-FLLBJLHM.js";
 import {
   LOG_KINDS,
   kindToComponent
@@ -1377,76 +1389,121 @@ function extractTurnsFromBuffer(events) {
   return turns;
 }
 
-// src/daemon/api/config.ts
-function mergeConfigSections(current, incoming) {
-  return {
-    ...current,
-    daemon: { ...current.daemon, ...incoming.daemon },
-    embedding: { ...current.embedding, ...incoming.embedding },
-    capture: { ...current.capture, ...incoming.capture },
-    agent: { ...current.agent, ...incoming.agent },
-    context: { ...current.context, ...incoming.context },
-    backup: { ...current.backup, ...incoming.backup },
-    team: { ...current.team, ...incoming.team },
-    notifications: { ...current.notifications, ...incoming.notifications }
-  };
+// src/daemon/config-reactions/touched-paths.ts
+function enumerateLeafPaths(obj, prefix = "") {
+  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
+    return prefix ? [prefix] : [];
+  }
+  const out = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const next = prefix ? `${prefix}.${key}` : key;
+    out.push(...enumerateLeafPaths(value, next));
+  }
+  return out;
+}
+function computeTouchedPaths(patch, clear) {
+  const patchLeaves = patch && typeof patch === "object" ? enumerateLeafPaths(patch) : [];
+  const clearList = Array.isArray(clear) ? clear : [];
+  return [.../* @__PURE__ */ new Set([...patchLeaves, ...clearList])];
 }
+
+// src/daemon/api/config.ts
 async function handleGetConfig(vaultDir) {
   const config = loadConfig(vaultDir);
   return { body: config };
 }
-async function handlePutConfig(vaultDir, body) {
-  const result = MycoConfigSchema.safeParse(body);
-  if (!result.success) {
-    return {
-      status: 400,
-      body: { error: "validation_failed", issues: result.error.issues }
-    };
+async function handleGetMergedConfig(vaultDir) {
+  const config = loadMergedConfig(vaultDir);
+  return { body: config };
+}
+async function handleGetLocalConfig(vaultDir) {
+  return { body: loadLocalConfig(vaultDir) };
+}
+var SCOPED_CONFIG_SCOPES = ["project", "local"];
+function isScopedConfigScope(value) {
+  return typeof value === "string" && SCOPED_CONFIG_SCOPES.includes(value);
+}
+function validateClearList(clear) {
+  if (clear === void 0) return [];
+  if (!Array.isArray(clear)) {
+    return { status: 400, body: { error: "clear must be an array of dot-paths" } };
   }
-  const updated = updateConfig(vaultDir, (current) => mergeConfigSections(current, result.data));
-  return { body: updated };
+  const invalidEntry = clear.find((entry) => typeof entry !== "string" || entry.trim().length === 0);
+  if (invalidEntry !== void 0) {
+    return { status: 400, body: { error: "clear entries must be non-empty strings" } };
+  }
+  return clear;
 }
-function createPlanDirHandlers(deps) {
-  const { vaultDir, symbiontPlanDirsByAgent, symbiontPlanDirs } = deps;
-  async function handleGetPlanDirs(_req) {
-    const config = loadConfig(vaultDir);
-    return {
-      body: {
-        symbiont: symbiontPlanDirsByAgent,
-        custom: deps.planWatchConfig.watchDirs.filter((d) => !symbiontPlanDirs.includes(d)),
-        ignore_plan_dirs_in_git: config.capture.ignore_plan_dirs_in_git
-      }
-    };
+function pathsOverlap(a, b) {
+  return a === b || a.startsWith(`${b}.`) || b.startsWith(`${a}.`);
+}
+async function handlePutScopedConfig(vaultDir, body) {
+  const payload = body ?? {};
+  if (!isScopedConfigScope(payload.scope)) {
+    return { status: 400, body: { error: "scope must be project or local" } };
   }
-  async function handleUpdatePlanDirs(req) {
-    const body = req.body;
-    if (!Array.isArray(body.plan_dirs)) {
-      return { status: 400, body: { error: "plan_dirs must be an array" } };
-    }
-    if (body.ignore_plan_dirs_in_git !== void 0 && typeof body.ignore_plan_dirs_in_git !== "boolean") {
-      return { status: 400, body: { error: "ignore_plan_dirs_in_git must be a boolean" } };
-    }
-    const updated = updateConfig(vaultDir, (cfg) => ({
-      ...cfg,
-      capture: {
-        ...cfg.capture,
-        plan_dirs: body.plan_dirs,
-        ignore_plan_dirs_in_git: body.ignore_plan_dirs_in_git ?? cfg.capture.ignore_plan_dirs_in_git
+  const scope = payload.scope;
+  const patch = payload.patch ?? {};
+  const clearListOrError = validateClearList(payload.clear);
+  if (Array.isArray(clearListOrError) === false) return clearListOrError;
+  const clearList = clearListOrError;
+  if (typeof patch !== "object" || patch === null || Array.isArray(patch)) {
+    return { status: 400, body: { error: "patch must be an object" } };
+  }
+  const patchLeaves = enumerateLeafPaths(patch);
+  const hasPatch = patchLeaves.length > 0;
+  const hasClear = clearList.length > 0;
+  if (!hasPatch && !hasClear) {
+    return { status: 400, body: { error: "patch or clear required" } };
+  }
+  const overlap = patchLeaves.filter((leaf) => clearList.some((clearPath) => pathsOverlap(leaf, clearPath)));
+  if (overlap.length > 0) {
+    return { status: 400, body: { error: "patch_clear_overlap", keys: overlap } };
+  }
+  if (scope === "local") {
+    try {
+      const project = loadConfig(vaultDir);
+      const updated = updateLocalConfig(vaultDir, (local) => {
+        const working = structuredClone(local);
+        for (const key of clearList) unsetAtPath(working, key);
+        const nextLocal = deepMergeConfig(
+          working,
+          patch
+        );
+        const merged = deepMergeConfig(
+          project,
+          nextLocal
+        );
+        MycoConfigSchema.parse(merged);
+        return nextLocal;
+      });
+      return { body: updated };
+    } catch (err) {
+      if (err instanceof external_exports.ZodError) {
+        return { status: 400, body: { error: "validation_failed", issues: err.issues } };
       }
-    }));
-    deps.setPlanWatchConfig({
-      ...deps.planWatchConfig,
-      watchDirs: [.../* @__PURE__ */ new Set([...symbiontPlanDirs, ...body.plan_dirs])]
+      throw err;
+    }
+  }
+  try {
+    const updated = updateConfig(vaultDir, (current) => {
+      const working = structuredClone(current);
+      for (const key of clearList) unsetAtPath(working, key);
+      return deepMergeConfig(working, patch);
     });
-    deps.reconcileProjectFiles?.();
-    return {
-      body: {
-        custom: updated.capture.plan_dirs,
-        ignore_plan_dirs_in_git: updated.capture.ignore_plan_dirs_in_git
-      }
-    };
+    return { body: updated };
+  } catch (err) {
+    if (err instanceof external_exports.ZodError) {
+      return { status: 400, body: { error: "validation_failed", issues: err.issues } };
+    }
+    throw err;
+  }
+}
+function createPlanDirHandlers(deps) {
+  async function handleGetPlanDirs(_req) {
+    return { body: { symbiont: deps.symbiontPlanDirsByAgent } };
   }
-  return { handleGetPlanDirs, handleUpdatePlanDirs };
+  return { handleGetPlanDirs };
 }
 
 // src/utils/parse-csv-list.ts
@@ -2229,8 +2286,8 @@ function getConfiguredManifests(projectRoot, config) {
   }
   return allManifests.filter((manifest) => fs12.existsSync(path12.join(projectRoot, manifest.configDir)));
 }
-function reconcileConfiguredSymbionts(projectRoot, vaultDir = path12.join(projectRoot, ".myco")) {
-  const config = loadConfig(vaultDir);
+function reconcileConfiguredSymbionts(projectRoot, vaultDir = path12.join(projectRoot, ".myco"), preloadedConfig) {
+  const config = preloadedConfig ?? loadConfig(vaultDir);
   const manifests = getConfiguredManifests(projectRoot, config);
   const packageRoot = resolvePackageRoot();
   let updatedCount = 0;
@@ -2772,7 +2829,7 @@ function createTeamHandlers(deps) {
     return { body: { retried: count } };
   }
   async function handleUpgradeWorker(_req) {
-    const { upgradeWorker } = await import("./team-SNLC6FZM.js");
+    const { upgradeWorker } = await import("./team-3JKF7VAD.js");
     logger.info("team-sync.upgrade.start", "Starting worker upgrade");
     const result = upgradeWorker(vaultDir);
     if (!result.success) {
@@ -3164,7 +3221,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-WMTB4NCX.js");
+          const { syncSkillSymlinks } = await import("./installer-ZNK4JSQA.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) });
@@ -3714,6 +3771,14 @@ function upsertPlan(data) {
   syncRow("plans", row);
   return row;
 }
+function getPlan(id) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT ${SELECT_COLUMNS4} FROM plans WHERE id = ?`
+  ).get(id);
+  if (!row) return null;
+  return toPlanRow(row);
+}
 function listPlans(options = {}) {
   const db = getDatabase();
   const conditions = [];
@@ -3788,7 +3853,7 @@ async function triggerTitleSummary(sessionId, deps) {
   if (config.agent.summary_batch_interval <= 0) return;
   if (config.agent.event_tasks_enabled === false) return;
   try {
-    const { runAgent } = await import("./executor-NXNSUEMQ.js");
+    const { runAgent } = await import("./executor-ACDHGTRH.js");
     runAgent(vaultDir, {
       task: "title-summary",
       instruction: `Process session ${sessionId} only`,
@@ -5941,6 +6006,13 @@ function registerBuiltinDomains() {
       { id: "daemon.version_sync", label: "Version sync restart", defaultMode: "summary", defaultLevel: "info" }
     ]
   });
+  register({
+    domain: "settings",
+    label: "Settings",
+    types: [
+      { id: "settings.saved", label: "Settings saved", defaultMode: "banner", defaultLevel: "success" }
+    ]
+  });
 }
 
 // src/daemon/api/notifications.ts
@@ -6345,7 +6417,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-OCM4WAPJ.js");
+  const { loadAllTasks: loadAllTasks2 } = await import("./registry-MGJSJBAS.js");
   const allTasks = Array.from(loadAllTasks2(definitionsDir, vaultDir).values());
   const taskAgentMap = /* @__PURE__ */ new Map();
   for (const task of allTasks) {
@@ -6371,7 +6443,7 @@ async function registerScheduledTasks(powerManager, deps) {
       else runningTasks.delete(name);
     },
     runTask: async (taskName) => {
-      const { runAgent } = await import("./executor-NXNSUEMQ.js");
+      const { runAgent } = await import("./executor-ACDHGTRH.js");
       const taskConfig = config.agent.tasks?.[taskName];
       const projectRoot = resolve(vaultDir, "..");
       const built = buildTaskInstruction(taskName, taskConfig?.params, taskAgentMap.get(taskName), projectRoot, embeddingManager);
@@ -6487,6 +6559,7 @@ function listTeamMembers() {
 // src/daemon/api/mcp-proxy.ts
 var SPORE_ID_RANDOM_BYTES = 4;
 var RESOLUTION_ID_RANDOM_BYTES = 8;
+var MIN_CONSOLIDATE_SOURCES = 2;
 var RememberBody = external_exports.object({
   content: external_exports.string(),
   type: external_exports.string().optional(),
@@ -6497,19 +6570,53 @@ var SupersedeBody = external_exports.object({
   new_spore_id: external_exports.string(),
   reason: external_exports.string().optional()
 });
+function isoToEpochSeconds(iso) {
+  const ms = Date.parse(iso);
+  return Number.isNaN(ms) ? void 0 : Math.floor(ms / 1e3);
+}
+function registerMcpUserAgent(createdAt) {
+  registerAgent({
+    id: USER_AGENT_ID,
+    name: USER_AGENT_NAME,
+    created_at: createdAt
+  });
+}
+function toPlanProgress(content) {
+  const planContent = content ?? "";
+  const checked = (planContent.match(/- \[x\]/gi) ?? []).length;
+  const unchecked = (planContent.match(/- \[ \]/g) ?? []).length;
+  const total = checked + unchecked;
+  return total === 0 ? "N/A" : `${checked}/${total}`;
+}
+function toPlanTags(tags) {
+  return tags ? tags.split(",").map((tag) => tag.trim()) : [];
+}
+var ConsolidateBody = external_exports.object({
+  source_spore_ids: external_exports.array(external_exports.string()).min(MIN_CONSOLIDATE_SOURCES),
+  consolidated_content: external_exports.string().min(1),
+  observation_type: external_exports.string(),
+  tags: external_exports.array(external_exports.string()).optional(),
+  reason: external_exports.string().optional()
+});
 function createMcpProxyHandlers(deps) {
   const { machineId, embeddingManager } = deps;
+  function toPlanSummary(row) {
+    return {
+      id: row.id,
+      title: row.title,
+      status: row.status,
+      progress: toPlanProgress(row.content),
+      tags: toPlanTags(row.tags),
+      created_at: row.created_at
+    };
+  }
   async function handleRemember(req) {
     const { content, type, tags } = RememberBody.parse(req.body);
     const { randomBytes } = await import("crypto");
     const observationType = type ?? "discovery";
     const id = `${observationType}-${randomBytes(SPORE_ID_RANDOM_BYTES).toString("hex")}`;
     const now = epochSeconds();
-    registerAgent({
-      id: USER_AGENT_ID,
-      name: USER_AGENT_NAME,
-      created_at: now
-    });
+    registerMcpUserAgent(now);
     const spore = insertSpore({
       id,
       agent_id: USER_AGENT_ID,
@@ -6542,12 +6649,7 @@ function createMcpProxyHandlers(deps) {
       embeddingManager.onStatusChanged("spores", old_spore_id, "superseded");
     } catch {
     }
-    registerAgent({
-      id: USER_AGENT_ID,
-      name: USER_AGENT_NAME,
-      created_at: now
-    });
-    const { insertResolutionEvent } = await import("./resolution-events-PYLSI6QT.js");
+    registerMcpUserAgent(now);
     const resolutionId = `res-${randomBytes(RESOLUTION_ID_RANDOM_BYTES).toString("hex")}`;
     insertResolutionEvent({
       id: resolutionId,
@@ -6567,31 +6669,95 @@ function createMcpProxyHandlers(deps) {
       }
     };
   }
+  async function handleConsolidate(req) {
+    const { source_spore_ids, consolidated_content, observation_type, tags, reason } = ConsolidateBody.parse(req.body);
+    const { randomBytes } = await import("crypto");
+    const now = epochSeconds();
+    const newSporeId = `${observation_type}-${randomBytes(SPORE_ID_RANDOM_BYTES).toString("hex")}`;
+    const db = getDatabase();
+    registerMcpUserAgent(now);
+    const { wisdom, sourcesSuperseded } = db.transaction(() => {
+      const insertedWisdom = insertSpore({
+        id: newSporeId,
+        agent_id: USER_AGENT_ID,
+        machine_id: machineId,
+        observation_type,
+        content: consolidated_content,
+        tags: tags ? tags.join(", ") : null,
+        created_at: now
+      });
+      const supersededSourceIds = [];
+      for (const sourceId of source_spore_ids) {
+        updateSporeStatus(sourceId, "superseded", now);
+        insertResolutionEvent({
+          id: `res-${randomBytes(RESOLUTION_ID_RANDOM_BYTES).toString("hex")}`,
+          agent_id: USER_AGENT_ID,
+          machine_id: machineId,
+          spore_id: sourceId,
+          action: "consolidate",
+          new_spore_id: newSporeId,
+          reason: reason ?? null,
+          created_at: now
+        });
+        supersededSourceIds.push(sourceId);
+      }
+      return { wisdom: insertedWisdom, sourcesSuperseded: supersededSourceIds };
+    })();
+    embeddingManager.onContentWritten("spores", wisdom.id, consolidated_content, {
+      status: "active",
+      observation_type
+    }).catch(() => {
+    });
+    for (const sourceId of sourcesSuperseded) {
+      try {
+        embeddingManager.onStatusChanged("spores", sourceId, "superseded");
+      } catch {
+      }
+    }
+    return {
+      body: {
+        new_spore_id: newSporeId,
+        sources_superseded: sourcesSuperseded,
+        status: "consolidated",
+        created_at: now
+      }
+    };
+  }
   async function handlePlans(req) {
+    const id = typeof req.query.id === "string" ? req.query.id : void 0;
+    if (id) {
+      const row = getPlan(id);
+      if (!row) return { body: { plans: [] } };
+      return {
+        body: {
+          plans: [{
+            ...toPlanSummary(row),
+            content: row.content
+          }]
+        }
+      };
+    }
     const statusFilter = req.query.status === "all" ? void 0 : req.query.status;
     const limit = req.query.limit ? Number(req.query.limit) : void 0;
     const rows = listPlans({ status: statusFilter, limit });
-    const plans = rows.map((row) => {
-      const content = row.content ?? "";
-      const checked = (content.match(/- \[x\]/gi) ?? []).length;
-      const unchecked = (content.match(/- \[ \]/g) ?? []).length;
-      const total = checked + unchecked;
-      const progress = total === 0 ? "N/A" : `${checked}/${total}`;
-      return {
-        id: row.id,
-        title: row.title,
-        status: row.status,
-        progress,
-        tags: row.tags ? row.tags.split(",").map((t) => t.trim()) : [],
-        created_at: row.created_at
-      };
-    });
+    const plans = rows.map(toPlanSummary);
     return { body: { plans } };
   }
   async function handleSessions(req) {
-    const limit = req.query.limit ? Number(req.query.limit) : 20;
-    const status = req.query.status;
-    const rows = listSessions({ limit, status });
+    const limit = req.query.limit ? Number(req.query.limit) : MCP_SESSIONS_DEFAULT_LIMIT;
+    const status = typeof req.query.status === "string" ? req.query.status : void 0;
+    const branch = typeof req.query.branch === "string" ? req.query.branch : void 0;
+    const user = typeof req.query.user === "string" ? req.query.user : void 0;
+    const plan = typeof req.query.plan === "string" ? req.query.plan : void 0;
+    const sinceRaw = typeof req.query.since === "string" ? req.query.since : void 0;
+    const since = sinceRaw ? isoToEpochSeconds(sinceRaw) : void 0;
+    let id;
+    if (plan) {
+      const planRow = getPlan(plan);
+      if (!planRow || !planRow.session_id) return { body: { sessions: [] } };
+      id = planRow.session_id;
+    }
+    const rows = listSessions({ limit, status, branch, user, since, id });
     const sessions = rows.map((row) => ({
       id: row.id,
       agent: row.agent,
@@ -6601,7 +6767,7 @@ function createMcpProxyHandlers(deps) {
       ended_at: row.ended_at,
       status: row.status,
       title: row.title,
-      summary: (row.summary ?? "").slice(0, 300),
+      summary: (row.summary ?? "").slice(0, SESSION_SUMMARY_PREVIEW_CHARS),
       prompt_count: row.prompt_count,
       tool_count: row.tool_count,
       parent_session_id: row.parent_session_id
@@ -6622,6 +6788,7 @@ function createMcpProxyHandlers(deps) {
   return {
     handleRemember,
     handleSupersede,
+    handleConsolidate,
     handlePlans,
     handleSessions,
     handleTeam
@@ -6675,7 +6842,7 @@ function createAgentRunHandlers(deps) {
         };
       }
     }
-    const { runAgent } = await import("./executor-NXNSUEMQ.js");
+    const { runAgent } = await import("./executor-ACDHGTRH.js");
     const resultPromise = runAgent(vaultDir, {
       task,
       instruction,
@@ -6833,6 +7000,207 @@ function reconcileLogBuffer(logDir, sinceTimestamp) {
   return replayed;
 }
 
+// src/config/focus.ts
+var CONFIG_FOCUS_SECTION_PARAM = "configSection";
+var CONFIG_FOCUS_FIELD_PARAM = "configField";
+var CONFIG_SECTION_IDS = {
+  appearance: "config-section-appearance",
+  settingsAgent: "config-section-settings-agent",
+  settingsEmbedding: "config-section-settings-embedding",
+  settingsContextInjection: "config-section-settings-context-injection",
+  settingsNotifications: "config-section-settings-notifications",
+  settingsPlanCapture: "config-section-settings-plan-capture",
+  settingsProject: "config-section-settings-project",
+  agentOperations: "config-section-agent-operations",
+  operationsMaintenance: "config-section-operations-maintenance",
+  operationsBackup: "config-section-operations-backup"
+};
+var SECTION_RULES = [
+  {
+    prefix: "appearance",
+    page: "/settings",
+    sectionId: CONFIG_SECTION_IDS.appearance,
+    sectionLabel: "Appearance"
+  },
+  {
+    prefix: "agent.provider",
+    page: "/settings",
+    sectionId: CONFIG_SECTION_IDS.settingsAgent,
+    sectionLabel: "Myco Agent"
+  },
+  {
+    prefix: "embedding",
+    page: "/settings",
+    sectionId: CONFIG_SECTION_IDS.settingsEmbedding,
+    sectionLabel: "Embedding"
+  },
+  {
+    prefix: "context",
+    page: "/settings",
+    sectionId: CONFIG_SECTION_IDS.settingsContextInjection,
+    sectionLabel: "Context Injection"
+  },
+  {
+    prefix: "notifications",
+    page: "/settings",
+    sectionId: CONFIG_SECTION_IDS.settingsNotifications,
+    sectionLabel: "Notifications"
+  },
+  {
+    prefix: "capture",
+    page: "/settings",
+    sectionId: CONFIG_SECTION_IDS.settingsPlanCapture,
+    sectionLabel: "Plan Capture"
+  },
+  {
+    prefix: "daemon",
+    page: "/settings",
+    sectionId: CONFIG_SECTION_IDS.settingsProject,
+    sectionLabel: "Project"
+  },
+  {
+    prefix: "agent.scheduled_tasks_enabled",
+    page: "/agent",
+    sectionId: CONFIG_SECTION_IDS.agentOperations,
+    sectionLabel: "Agent Operations",
+    searchParams: { tab: "config" }
+  },
+  {
+    prefix: "agent.event_tasks_enabled",
+    page: "/agent",
+    sectionId: CONFIG_SECTION_IDS.agentOperations,
+    sectionLabel: "Agent Operations",
+    searchParams: { tab: "config" }
+  },
+  {
+    prefix: "agent.summary_batch_interval",
+    page: "/agent",
+    sectionId: CONFIG_SECTION_IDS.agentOperations,
+    sectionLabel: "Agent Operations",
+    searchParams: { tab: "config" }
+  },
+  {
+    prefix: "maintenance",
+    page: "/operations",
+    sectionId: CONFIG_SECTION_IDS.operationsMaintenance,
+    sectionLabel: "Scheduled Maintenance"
+  },
+  {
+    prefix: "backup",
+    page: "/operations",
+    sectionId: CONFIG_SECTION_IDS.operationsBackup,
+    sectionLabel: "Backup & Restore"
+  }
+];
+var EXACT_FIELD_LABELS = {
+  "appearance.theme": "Color Theme",
+  "appearance.mode": "Mode",
+  "appearance.font": "Font",
+  "appearance.density": "Density",
+  "agent.provider": "Provider",
+  "agent.provider.type": "Provider",
+  "agent.provider.model": "Model",
+  "agent.provider.base_url": "Base URL",
+  "agent.provider.context_length": "Context Length",
+  "embedding.provider": "Provider",
+  "embedding.model": "Model",
+  "embedding.base_url": "Base URL",
+  "context.digest_tier": "Digest Tier",
+  "context.prompt_search": "Prompt Search",
+  "context.prompt_max_spores": "Max Spores per Prompt",
+  "notifications.enabled": "Notifications",
+  "notifications.default_mode": "Default Display",
+  "notifications.system_notifications": "Browser Notifications",
+  "capture.ignore_plan_dirs_in_git": "Ignore Custom Plan Dirs In Git",
+  "capture.plan_dirs": "Custom Directories",
+  "daemon.port": "Daemon Port",
+  "daemon.log_level": "Log Level",
+  "daemon.log_retention_days": "Log Retention (days)",
+  "agent.scheduled_tasks_enabled": "Scheduled Tasks",
+  "agent.event_tasks_enabled": "Event-Driven Tasks",
+  "agent.summary_batch_interval": "Title & Summary Batch Interval",
+  "maintenance.auto_optimize": "Auto-optimize",
+  "maintenance.auto_optimize_interval_hours": "Auto-optimize Interval",
+  "backup.dir": "Backup Directory"
+};
+var DYNAMIC_FIELD_LABEL_RULES = [
+  {
+    prefix: "notifications.domains.",
+    format: (path23) => {
+      const match = /^notifications\.domains\.([^.]+)\.(enabled|mode)$/.exec(path23);
+      if (!match) return null;
+      const [, domain, leaf] = match;
+      const domainLabel = humanizeToken(domain);
+      return leaf === "mode" ? `${domainLabel} Display` : `${domainLabel} Notifications`;
+    }
+  }
+];
+var SAVE_MESSAGE_LABEL_LIMIT = 3;
+function resolveConfigFocusTarget(path23) {
+  const section = findSectionRule(path23);
+  if (!section) return null;
+  return {
+    ...section,
+    fieldPath: path23,
+    fieldLabel: resolveFieldLabel(path23)
+  };
+}
+function buildConfigFocusLink(target) {
+  const params = new URLSearchParams(target.searchParams);
+  params.set(CONFIG_FOCUS_SECTION_PARAM, target.sectionId);
+  params.set(CONFIG_FOCUS_FIELD_PARAM, target.fieldPath);
+  return `${target.page}?${params.toString()}`;
+}
+function buildScopedConfigSaveNotification(scope, touchedPaths) {
+  const uniquePaths = [...new Set(touchedPaths)];
+  const scopeLabel = scope === "local" ? "Personal" : "Project";
+  const focusTarget = uniquePaths.map(resolveConfigFocusTarget).find((target) => target !== null) ?? null;
+  const fieldLabels = uniquePaths.map(resolveFieldLabel);
+  const primaryLabel = fieldLabels[0] ?? "Setting";
+  const labelList = fieldLabels.slice(0, SAVE_MESSAGE_LABEL_LIMIT).join(", ");
+  const remainingCount = Math.max(0, fieldLabels.length - SAVE_MESSAGE_LABEL_LIMIT);
+  const messageLabel = remainingCount > 0 ? `${labelList}, +${remainingCount} more` : labelList;
+  return {
+    title: uniquePaths.length === 1 ? `${primaryLabel} saved` : `${uniquePaths.length} settings saved`,
+    message: focusTarget ? `${focusTarget.sectionLabel} \xB7 ${messageLabel} \xB7 ${scopeLabel}` : `${messageLabel} \xB7 ${scopeLabel}`,
+    link: focusTarget ? buildConfigFocusLink(focusTarget) : null,
+    metadata: {
+      scope,
+      touched_paths: uniquePaths,
+      field_labels: fieldLabels,
+      focus_target: focusTarget ? {
+        page: focusTarget.page,
+        section_id: focusTarget.sectionId,
+        field_path: focusTarget.fieldPath,
+        field_label: focusTarget.fieldLabel
+      } : null
+    }
+  };
+}
+function findSectionRule(path23) {
+  for (const rule of SECTION_RULES) {
+    if (path23 === rule.prefix || path23.startsWith(`${rule.prefix}.`)) {
+      const { page, sectionId, sectionLabel, searchParams } = rule;
+      return { page, sectionId, sectionLabel, searchParams };
+    }
+  }
+  return null;
+}
+function resolveFieldLabel(path23) {
+  const exact = EXACT_FIELD_LABELS[path23];
+  if (exact) return exact;
+  for (const rule of DYNAMIC_FIELD_LABEL_RULES) {
+    if (path23 === rule.prefix || path23.startsWith(rule.prefix)) {
+      const label = rule.format(path23);
+      if (label) return label;
+    }
+  }
+  return humanizeToken(path23.split(".").pop() ?? "setting");
+}
+function humanizeToken(value) {
+  return value.split(/[-_]/g).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+
 // src/daemon/power.ts
 var PowerManager = class {
   state = "active";
@@ -7029,7 +7397,7 @@ function registerPowerJobs(powerManager, deps) {
     name: "log-retention",
     runIn: ["idle", "sleep"],
     fn: async () => {
-      const retentionDays = config.daemon.log_retention_days;
+      const retentionDays = loadMergedConfig(vaultDir).daemon.log_retention_days;
       const cutoff = new Date(Date.now() - retentionDays * MS_PER_DAY).toISOString();
       const deleted = deleteOldLogs(cutoff);
       if (deleted > 0) {
@@ -7504,11 +7872,22 @@ function createStopProcessor(deps) {
   const sessionTitleCache = /* @__PURE__ */ new Map();
   const StopBody = external_exports.object({
     session_id: external_exports.string(),
+    agent: external_exports.string().optional(),
     user: external_exports.string().optional(),
     transcript_path: external_exports.string().nullish(),
     last_assistant_message: external_exports.string().nullish()
   });
   const triggerTitleSummary2 = (sessionId) => triggerTitleSummary(sessionId, { vaultDir, embeddingManager, config, logger });
+  function cleanupInvalidCapturedSession(sessionId) {
+    registry.unregister(sessionId);
+    sessionBuffers.delete(sessionId);
+    sessionTitleCache.delete(sessionId);
+    const result = deleteSessionCascade(sessionId);
+    if (!result.deleted) return false;
+    cleanupAfterSessionCascade(sessionId, result, embeddingManager, vaultDir).catch(() => {
+    });
+    return true;
+  }
   async function processStopEvent(sessionId, user, sessionMeta, hookTranscriptPath, lastAssistantMessage) {
     const transcriptResult = transcriptMiner.getAllTurnsWithSource(sessionId, hookTranscriptPath);
     let allTurns = transcriptResult.turns;
@@ -7681,7 +8060,30 @@ function createStopProcessor(deps) {
     });
   }
   const handleStopRoute = async (req) => {
-    const { session_id: sessionId, user, transcript_path: hookTranscriptPath, last_assistant_message: lastAssistantMessage } = StopBody.parse(req.body);
+    const {
+      session_id: sessionId,
+      agent,
+      user,
+      transcript_path: hookTranscriptPath,
+      last_assistant_message: lastAssistantMessage
+    } = StopBody.parse(req.body);
+    if (hookTranscriptPath) {
+      const transcriptMeta = readTranscriptMeta(hookTranscriptPath) ?? void 0;
+      const detectedAgent = agent ?? getSession(sessionId)?.agent ?? "claude-code";
+      const decision = evaluateSessionCaptureRules(loadManifests(), detectedAgent, {
+        transcriptPath: hookTranscriptPath,
+        transcriptMeta
+      });
+      if (decision.action === "drop") {
+        const deleted = cleanupInvalidCapturedSession(sessionId);
+        logger.info(LOG_KINDS.HOOKS_STOP, "Stop ignored \u2014 invalid captured session", {
+          session_id: sessionId,
+          reason: decision.reason ?? "rule",
+          deleted_existing_session: deleted
+        });
+        return { body: { ok: true, ignored: decision.reason ?? "rule" } };
+      }
+    }
     const existingSessionMeta = registry.getSession(sessionId);
     if (!hookTranscriptPath && !existingSessionMeta) {
       logger.info(LOG_KINDS.HOOKS_STOP, "Stop ignored \u2014 ephemeral sub-invocation", {
@@ -7969,6 +8371,62 @@ function createEventDispatcher(deps) {
   };
 }
 
+// src/daemon/config-reactions/registry.ts
+function createConfigReactionRegistry(logger) {
+  const entries = [];
+  return {
+    on(paths, fn) {
+      entries.push({ paths, fn });
+    },
+    async fire(touchedPaths, ctx) {
+      for (const entry of entries) {
+        if (!shouldFire(entry.paths, touchedPaths)) continue;
+        try {
+          await entry.fn(ctx);
+        } catch (err) {
+          logger.error("config-reactions", "reaction threw", { error: String(err) });
+        }
+      }
+    }
+  };
+}
+function shouldFire(registeredPaths, touched) {
+  if (registeredPaths.length === 0) return true;
+  for (const prefix of registeredPaths) {
+    for (const path23 of touched) {
+      if (path23 === prefix || path23.startsWith(`${prefix}.`)) return true;
+    }
+  }
+  return false;
+}
+
+// src/daemon/config-reactions/context.ts
+function loadReactionContext(vaultDir, logger) {
+  try {
+    return loadMergedConfig(vaultDir);
+  } catch (err) {
+    if (err instanceof external_exports.ZodError) {
+      logger.warn("config-reactions", "skipping reactions because merged config is invalid", {
+        issues: err.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message
+        }))
+      });
+      return null;
+    }
+    throw err;
+  }
+}
+
+// src/daemon/plan-watch-reaction.ts
+function createPlanWatchReaction(deps) {
+  return (ctx) => {
+    const customDirs = ctx.capture.plan_dirs ?? [];
+    deps.planWatchConfig.watchDirs = [.../* @__PURE__ */ new Set([...deps.symbiontPlanDirs, ...customDirs])];
+    deps.planWatchConfig.extensions = ctx.capture.artifact_extensions;
+  };
+}
+
 // src/daemon/main.ts
 import fs23 from "fs";
 import os8 from "os";
@@ -8003,7 +8461,7 @@ async function main() {
   const symbiontPlanDirs = manifests.flatMap((m) => m.capture?.planDirs ?? []);
   const symbiontPlanTags = [...new Set(manifests.flatMap((m) => m.capture?.planTags ?? []))];
   const projectRoot = process.cwd();
-  let planWatchConfig = {
+  const planWatchConfig = {
     watchDirs: [.../* @__PURE__ */ new Set([...symbiontPlanDirs, ...config.capture.plan_dirs ?? []])],
     projectRoot,
     extensions: config.capture.artifact_extensions
@@ -8113,7 +8571,7 @@ async function main() {
   const databaseManager = new DatabaseMaintenanceManager(vaultDbPath(vaultDir), vaultDir, logger);
   let definitionsDir;
   try {
-    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-AAZ6VUIA.js");
+    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-TSB5M7FD.js");
     definitionsDir = resolveDefinitionsDir2();
     await registerBuiltInAgentsAndTasks(definitionsDir, vaultDir);
     logger.info(LOG_KINDS.AGENT_TASK, "Built-in agents and tasks registered");
@@ -8236,39 +8694,59 @@ async function main() {
   let configHash = computeConfigHash(vaultDir);
   server.registerRoute("GET", "/api/config", async () => handleGetConfig(vaultDir));
   server.registerRoute("GET", "/api/symbionts", async () => handleListSymbionts(vaultDir));
-  server.registerRoute("PUT", "/api/config", async (req) => {
-    const result = await handlePutConfig(vaultDir, req.body);
-    if (!result.status || result.status < 400) {
-      reconcileConfiguredSymbionts(path22.dirname(vaultDir), vaultDir);
-      configHash = computeConfigHash(vaultDir);
-    }
-    return result;
-  });
+  server.registerRoute("GET", "/api/config/merged", async () => handleGetMergedConfig(vaultDir));
+  server.registerRoute("GET", "/api/config/local", async () => handleGetLocalConfig(vaultDir));
   const symbiontPlanDirsByAgent = {};
   for (const m of manifests) {
     const dirs = m.capture?.planDirs ?? [];
     if (dirs.length > 0) symbiontPlanDirsByAgent[m.displayName] = dirs;
   }
-  const planDirHandlers = createPlanDirHandlers({
-    vaultDir,
-    symbiontPlanDirsByAgent,
+  const reactions = createConfigReactionRegistry(logger);
+  reactions.on([], () => {
+    configHash = computeConfigHash(vaultDir);
+  });
+  reactions.on(["capture", "symbionts"], (ctx) => {
+    reconcileConfiguredSymbionts(path22.dirname(vaultDir), vaultDir, ctx);
+  });
+  reactions.on(["capture"], createPlanWatchReaction({
     symbiontPlanDirs,
-    planWatchConfig,
-    setPlanWatchConfig: (cfg) => {
-      planWatchConfig = cfg;
-    },
-    reconcileProjectFiles: () => {
-      reconcileConfiguredSymbionts(path22.dirname(vaultDir), vaultDir);
+    planWatchConfig
+  }));
+  reactions.on(["daemon.log_level"], (ctx) => {
+    logger.setLevel(ctx.daemon.log_level);
+    if (ctx.daemon.log_level === "debug") {
+      process.env.MYCO_AGENT_DEBUG = "1";
+    } else {
+      delete process.env.MYCO_AGENT_DEBUG;
     }
   });
-  server.registerRoute("GET", "/api/config/plan-dirs", planDirHandlers.handleGetPlanDirs);
-  server.registerRoute("POST", "/api/config/plan-dirs", async (req) => {
-    const result = await planDirHandlers.handleUpdatePlanDirs(req);
+  server.registerRoute("PUT", "/api/config/scoped", async (req) => {
+    const result = await handlePutScopedConfig(vaultDir, req.body);
     if (!result.status || result.status < 400) {
-      configHash = computeConfigHash(vaultDir);
+      const body = req.body;
+      const touchedPaths = computeTouchedPaths(body.patch, body.clear);
+      const reactionContext = loadReactionContext(vaultDir, logger);
+      if (reactionContext) {
+        await reactions.fire(touchedPaths, reactionContext);
+        const summary = buildScopedConfigSaveNotification(body.scope, touchedPaths);
+        notify(vaultDir, {
+          domain: "settings",
+          type: "settings.saved",
+          title: summary.title,
+          message: summary.message,
+          link: summary.link ?? void 0,
+          metadata: summary.metadata
+        }, reactionContext);
+      } else {
+        configHash = computeConfigHash(vaultDir);
+      }
     }
     return result;
   });
+  const planDirHandlers = createPlanDirHandlers({
+    symbiontPlanDirsByAgent
+  });
+  server.registerRoute("GET", "/api/config/plan-dirs", planDirHandlers.handleGetPlanDirs);
   const configHashRef = { get: () => configHash };
   server.registerRoute("GET", "/api/stats", createLiveStatsHandler({
     vaultDir,
@@ -8346,6 +8824,7 @@ async function main() {
   const mcpProxy = createMcpProxyHandlers({ machineId, embeddingManager });
   server.registerRoute("POST", "/api/mcp/remember", mcpProxy.handleRemember);
   server.registerRoute("POST", "/api/mcp/supersede", mcpProxy.handleSupersede);
+  server.registerRoute("POST", "/api/mcp/consolidate", mcpProxy.handleConsolidate);
   server.registerRoute("GET", "/api/mcp/plans", mcpProxy.handlePlans);
   server.registerRoute("GET", "/api/mcp/sessions", mcpProxy.handleSessions);
   server.registerRoute("GET", "/api/mcp/team", mcpProxy.handleTeam);
@@ -8454,4 +8933,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-RPJSS7PT.js.map
+//# sourceMappingURL=main-5S4MDCIO.js.map