@goondocks/myco 0.19.6 → 0.20.1

package/dist/{main-RPJSS7PT.js → main-E7HU4QYR.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-22JALAXN.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-FGY7J6EZ.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-UEWMSIL3.js";
 import "./chunk-SAKJMNSR.js";
 import {
   SymbiontInstaller
-} from "./chunk-TMNFCUAD.js";
+} from "./chunk-LZP4IJB3.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-3WWJOTYG.js";
 import {
   getPluginVersion
-} from "./chunk-ST2D3SGM.js";
+} from "./chunk-AIYFHQRX.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 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" } };
   }
-  const updated = updateConfig(vaultDir, (current) => mergeConfigSections(current, result.data));
-  return { body: updated };
+  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;
   }
-  return { handleGetPlanDirs, handleUpdatePlanDirs };
+}
+function createPlanDirHandlers(deps) {
+  async function handleGetPlanDirs(_req) {
+    return { body: { symbiont: deps.symbiontPlanDirsByAgent } };
+  }
+  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 ?? loadMergedConfig(vaultDir);
   const manifests = getConfiguredManifests(projectRoot, config);
   const packageRoot = resolvePackageRoot();
   let updatedCount = 0;
@@ -2400,11 +2457,20 @@ function restoreBackup(db, backupPath) {
 }
 
 // src/daemon/api/backup.ts
+import os7 from "os";
 import path14 from "path";
+function resolveBackupDir(config, vaultDir) {
+  const rawDir = config.backup.dir;
+  if (!rawDir) return path14.resolve(vaultDir, "backups");
+  const expanded = rawDir.startsWith("~/") ? path14.join(os7.homedir(), rawDir.slice(2)) : rawDir;
+  return path14.resolve(expanded);
+}
 function createBackupHandlers(deps) {
+  const currentBackupDir = () => resolveBackupDir(deps.liveConfig.current, deps.vaultDir);
   async function handleCreateBackup(_req) {
-    const filePath = createBackup(deps.db, deps.backupDir, deps.machineId);
-    const backups = listBackups(deps.backupDir);
+    const backupDir = currentBackupDir();
+    const filePath = createBackup(deps.db, backupDir, deps.machineId);
+    const backups = listBackups(backupDir);
     const created = backups.find((b) => b.machine_id === deps.machineId);
     return {
       body: {
@@ -2415,7 +2481,7 @@ function createBackupHandlers(deps) {
     };
   }
   async function handleListBackups(_req) {
-    const backups = listBackups(deps.backupDir);
+    const backups = listBackups(currentBackupDir());
     return { body: { backups } };
   }
   async function handleRestorePreview(req) {
@@ -2423,12 +2489,13 @@ function createBackupHandlers(deps) {
     if (!machine_id) {
       return { status: 400, body: { error: "missing_machine_id" } };
     }
-    const backups = listBackups(deps.backupDir);
+    const backupDir = currentBackupDir();
+    const backups = listBackups(backupDir);
     const backup = backups.find((b) => b.machine_id === machine_id);
     if (!backup) {
       return { status: 404, body: { error: "backup_not_found" } };
     }
-    const backupPath = `${deps.backupDir}/${backup.file_name}`;
+    const backupPath = `${backupDir}/${backup.file_name}`;
     const tables = restorePreview(deps.db, backupPath);
     const total_new = tables.reduce((sum, t) => sum + t.new, 0);
     const total_existing = tables.reduce((sum, t) => sum + t.existing, 0);
@@ -2439,12 +2506,13 @@ function createBackupHandlers(deps) {
     if (!machine_id) {
       return { status: 400, body: { error: "missing_machine_id" } };
     }
-    const backups = listBackups(deps.backupDir);
+    const backupDir = currentBackupDir();
+    const backups = listBackups(backupDir);
     const backup = backups.find((b) => b.machine_id === machine_id);
     if (!backup) {
       return { status: 404, body: { error: "backup_not_found" } };
     }
-    const backupPath = `${deps.backupDir}/${backup.file_name}`;
+    const backupPath = `${backupDir}/${backup.file_name}`;
     const result = restoreBackup(deps.db, backupPath);
     return { body: { machine_id, ...result } };
   }
@@ -2458,7 +2526,7 @@ function createBackupHandlers(deps) {
 function createBackupConfigHandlers(deps) {
   const { vaultDir } = deps;
   async function handleGetBackupConfig() {
-    const cfg = loadConfig(vaultDir);
+    const cfg = loadMergedConfig(vaultDir);
     return { body: { dir: cfg.backup.dir ?? null, default_dir: path14.resolve(vaultDir, "backups") } };
   }
   async function handlePutBackupConfig(req) {
@@ -2690,17 +2758,15 @@ function createTeamHandlers(deps) {
       worker_url: url
     });
     writeSecret(vaultDir, TEAM_API_KEY_SECRET, api_key);
-    deps.setTeamClient(client);
-    const config = loadConfig(vaultDir);
+    const config = loadMergedConfig(vaultDir);
     return { body: { connected: true, team: config.team } };
   }
   async function handleDisconnect(_req) {
     updateTeamConfig(vaultDir, { enabled: false });
-    deps.setTeamClient(null);
     return { body: { connected: false } };
   }
   async function handleStatus(_req) {
-    const config = loadConfig(vaultDir);
+    const config = loadMergedConfig(vaultDir);
     const client = deps.getTeamClient();
     const secrets = readSecrets(vaultDir);
     const hasApiKey = Boolean(secrets[TEAM_API_KEY_SECRET]);
@@ -2772,7 +2838,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) {
@@ -2929,7 +2995,7 @@ function createSessionLifecycleHandlers(deps) {
     powerManager,
     machineId,
     logger,
-    config,
+    liveConfig,
     vaultDir
   } = deps;
   async function handleRegister(req) {
@@ -2961,7 +3027,7 @@ function createSessionLifecycleHandlers(deps) {
       message: branch ? `Branch: ${branch}` : void 0,
       link: `/sessions/${session_id}`,
       metadata: { sessionId: session_id, agent: agent ?? "claude-code", branch }
-    }, config);
+    }, liveConfig.current);
     return { body: { ok: true, sessions: registry.sessions } };
   }
   async function handleUnregister(req) {
@@ -2981,7 +3047,7 @@ function createSessionLifecycleHandlers(deps) {
       title: "Session ended",
       link: `/sessions/${session_id}`,
       metadata: { sessionId: session_id }
-    }, config);
+    }, liveConfig.current);
     return { body: { ok: true, sessions: registry.sessions } };
   }
   return { handleRegister, handleUnregister };
@@ -3164,7 +3230,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-I6KRGJOO.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) });
@@ -3177,37 +3243,56 @@ function createSkillRecordDeleteHandler(deps) {
 
 // src/daemon/team-sync-init.ts
 function initTeamSync(deps) {
-  const { config, machineId, logger, vaultDir, serverVersion } = deps;
+  const { liveConfig, machineId, logger, vaultDir, serverVersion } = deps;
   let teamClient = null;
-  if (config.team.enabled && config.team.worker_url) {
-    const secrets = readSecrets(vaultDir);
-    const teamApiKey = secrets[TEAM_API_KEY_SECRET];
-    if (teamApiKey) {
-      teamClient = new TeamSyncClient({
-        workerUrl: config.team.worker_url,
-        apiKey: teamApiKey,
-        machineId,
-        syncProtocolVersion: SYNC_PROTOCOL_VERSION
-      });
-      logger.info(LOG_KINDS.TEAM_SYNC_START, "Team sync client initialized", { worker_url: config.team.worker_url });
-      teamClient.connect({
+  let clientSignature = null;
+  async function reconcileClient() {
+    const config = liveConfig.current;
+    const workerUrl = config.team.worker_url?.trim() || null;
+    const apiKey = readSecrets(vaultDir)[TEAM_API_KEY_SECRET]?.trim() || null;
+    const nextSignature = config.team.enabled && workerUrl && apiKey ? `${workerUrl}
+${apiKey}` : null;
+    if (!nextSignature) {
+      if (teamClient) {
+        logger.info(LOG_KINDS.TEAM_SYNC_START, "Team sync client cleared", {
+          enabled: config.team.enabled,
+          has_worker_url: Boolean(workerUrl),
+          has_api_key: Boolean(apiKey)
+        });
+      }
+      teamClient = null;
+      clientSignature = null;
+      return;
+    }
+    if (teamClient && clientSignature === nextSignature) return;
+    const activeWorkerUrl = workerUrl;
+    const activeApiKey = apiKey;
+    teamClient = new TeamSyncClient({
+      workerUrl: activeWorkerUrl,
+      apiKey: activeApiKey,
+      machineId,
+      syncProtocolVersion: SYNC_PROTOCOL_VERSION
+    });
+    clientSignature = nextSignature;
+    logger.info(LOG_KINDS.TEAM_SYNC_START, "Team sync client initialized", { worker_url: activeWorkerUrl });
+    try {
+      await teamClient.connect({
         machine_id: machineId,
         version: serverVersion
-      }).then(() => {
-        logger.info(LOG_KINDS.TEAM_SYNC_START, "Node registered with team worker");
-      }).catch((err) => {
-        logger.warn(LOG_KINDS.TEAM_SYNC_ERROR, "Node registration failed (will retry on next flush)", { error: err.message });
       });
-      setTimeout(() => {
-        try {
-          const backfilled = backfillUnsynced(machineId);
-          if (backfilled > 0) {
-            logger.info(LOG_KINDS.TEAM_SYNC_START, `Backfilled ${backfilled} unsynced records into outbox`);
-          }
-        } catch (err) {
-          logger.error(LOG_KINDS.TEAM_SYNC_ERROR, "Backfill failed", { error: err.message });
-        }
-      }, 0);
+      logger.info(LOG_KINDS.TEAM_SYNC_START, "Node registered with team worker");
+    } catch (err) {
+      logger.warn(LOG_KINDS.TEAM_SYNC_ERROR, "Node registration failed (will retry on next flush)", {
+        error: err.message
+      });
+    }
+    try {
+      const backfilled = backfillUnsynced(machineId);
+      if (backfilled > 0) {
+        logger.info(LOG_KINDS.TEAM_SYNC_START, `Backfilled ${backfilled} unsynced records into outbox`);
+      }
+    } catch (err) {
+      logger.error(LOG_KINDS.TEAM_SYNC_ERROR, "Backfill failed", { error: err.message });
     }
   }
   return {
@@ -3215,8 +3300,8 @@ function initTeamSync(deps) {
     setTeamClient: (client) => {
       teamClient = client;
     },
+    reconcileClient,
     registerFlushJob: (powerManager) => {
-      if (!config.team.enabled) return;
       const logDeadLettered = (ids) => {
         if (ids.length > 0) {
           logger.error(LOG_KINDS.TEAM_SYNC_DEAD_LETTER, `Dead-lettered ${ids.length} records after max retries`, { ids });
@@ -3225,8 +3310,9 @@ function initTeamSync(deps) {
       powerManager.register({
         name: "team-sync-flush",
         runIn: ["active", "idle", "sleep"],
-        preventsDeepSleep: () => countPending() > 0,
+        preventsDeepSleep: () => liveConfig.current.team.enabled && countPending() > 0,
         fn: async () => {
+          if (!liveConfig.current.team.enabled) return;
           const client = teamClient;
           if (!client) return;
           const pending = listPending();
@@ -3714,6 +3800,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 = [];
@@ -3784,11 +3878,12 @@ async function cleanupAfterSessionCascade(sessionId, result, embeddingManager, v
 
 // src/daemon/trigger-title-summary.ts
 async function triggerTitleSummary(sessionId, deps) {
-  const { vaultDir, embeddingManager, config, logger } = deps;
+  const { vaultDir, embeddingManager, liveConfig, logger } = deps;
+  const config = liveConfig.current;
   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-J4IBXSBY.js");
     runAgent(vaultDir, {
       task: "title-summary",
       instruction: `Process session ${sessionId} only`,
@@ -3853,7 +3948,7 @@ async function handleGetSessionPlans(req) {
   return { body: plans };
 }
 function createSessionMutationHandlers(deps) {
-  const { embeddingManager, vaultDir, logger, config } = deps;
+  const { embeddingManager, vaultDir, logger, liveConfig } = deps;
   async function handleDeleteSession(req) {
     const sessionId = req.params.id;
     const result = deleteSessionCascade(sessionId);
@@ -3877,7 +3972,7 @@ function createSessionMutationHandlers(deps) {
         ended_at: session.ended_at ?? epochSeconds()
       });
     }
-    await triggerTitleSummary(sessionId, { vaultDir, embeddingManager, config, logger });
+    await triggerTitleSummary(sessionId, { vaultDir, embeddingManager, liveConfig, logger });
     logger.info(LOG_KINDS.API_SESSION_COMPLETE, "Session manually completed", {
       session_id: sessionId,
       was_active: wasActive
@@ -4313,7 +4408,8 @@ var PromptContextBody = external_exports.object({
 function createSessionContextHandler(deps) {
   return async function handleSessionContext(req) {
     const { session_id, branch } = SessionContextBody.parse(req.body);
-    const { logger, config } = deps;
+    const { logger, liveConfig } = deps;
+    const config = liveConfig.current;
     logger.debug(LOG_KINDS.CONTEXT_QUERY, "Session context query", { session_id });
     try {
       const parts = [];
@@ -4425,7 +4521,8 @@ function createResumeContextHandler(deps) {
 function createPromptContextHandler(deps) {
   return async function handlePromptContext(req) {
     const { prompt, session_id } = PromptContextBody.parse(req.body);
-    const { logger, config, embeddingManager } = deps;
+    const { logger, liveConfig, embeddingManager } = deps;
+    const config = liveConfig.current;
     if (!config.context.prompt_search) {
       logger.debug(LOG_KINDS.CONTEXT_PROMPT, "Prompt search disabled by config", { session_id });
       return { body: { text: "" } };
@@ -4546,7 +4643,7 @@ async function handleListSymbionts(vaultDir) {
   const manifests = loadManifests();
   let enabledNames = null;
   try {
-    enabledNames = getEnabledSymbiontNames(loadConfig(vaultDir));
+    enabledNames = getEnabledSymbiontNames(loadMergedConfig(vaultDir));
   } catch {
   }
   const symbionts = manifests.map((m) => ({
@@ -4563,7 +4660,7 @@ async function handleListSymbionts(vaultDir) {
 var EMBEDDING_STATUS_IDLE = "idle";
 var EMBEDDING_STATUS_PENDING = "pending";
 async function handleGetEmbeddingStatus(vaultDir) {
-  const config = loadConfig(vaultDir);
+  const config = loadMergedConfig(vaultDir);
   const { queue_depth, embedded_count } = getEmbeddingQueueDepth();
   return {
     body: {
@@ -5941,6 +6038,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
@@ -5978,7 +6082,7 @@ async function handleCreateNotification(vaultDir, body) {
     return { status: 400, body: { error: "validation_failed", issues: parsed.error.issues } };
   }
   const { domain, type, title, message, link, metadata } = parsed.data;
-  const config = loadConfig(vaultDir);
+  const config = loadMergedConfig(vaultDir);
   if (!config.notifications.enabled) {
     return { body: { ok: true, suppressed: true, reason: "notifications_disabled" } };
   }
@@ -6182,7 +6286,7 @@ async function handleDeleteTask(req, vaultDir) {
 }
 async function handleGetTaskConfig(req, vaultDir) {
   const taskId = req.params.id;
-  const config = loadConfig(vaultDir);
+  const config = loadMergedConfig(vaultDir);
   const taskConfig = config.agent.tasks?.[taskId] ?? null;
   return { status: HTTP_OK, body: { taskId, config: taskConfig } };
 }
@@ -6334,18 +6438,19 @@ function buildScheduledJobs(tasks, configOverrides, context, initialLastRuns) {
 }
 
 // src/daemon/task-scheduling.ts
+var SCHEDULED_JOB_PREFIX = "scheduled:";
 async function registerScheduledTasks(powerManager, deps) {
-  const { definitionsDir, vaultDir, embeddingManager, logger, config } = deps;
+  const { definitionsDir, vaultDir, embeddingManager, logger, liveConfig } = deps;
   const runningTasks = /* @__PURE__ */ new Set();
   if (!definitionsDir) {
     logger.warn(LOG_KINDS.AGENT_ERROR, "Skipping dynamic task scheduling \u2014 definitions directory unavailable");
     return;
   }
-  if (config.agent.scheduled_tasks_enabled === false) {
-    logger.info(LOG_KINDS.AGENT_RUN, "Scheduled agent tasks disabled globally (agent.scheduled_tasks_enabled: false)");
-    return;
+  let lastEnabled = liveConfig.current.agent.scheduled_tasks_enabled !== false;
+  if (!lastEnabled) {
+    logger.info(LOG_KINDS.AGENT_RUN, "Scheduled agent tasks disabled (agent.scheduled_tasks_enabled: false) \u2014 jobs registered but will no-op until enabled");
   }
-  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 +6476,17 @@ async function registerScheduledTasks(powerManager, deps) {
       else runningTasks.delete(name);
     },
     runTask: async (taskName) => {
-      const { runAgent } = await import("./executor-NXNSUEMQ.js");
+      const config = liveConfig.current;
+      const enabled = config.agent.scheduled_tasks_enabled !== false;
+      if (enabled !== lastEnabled) {
+        logger.info(
+          LOG_KINDS.AGENT_RUN,
+          enabled ? "Scheduled agent tasks re-enabled \u2014 resuming" : "Scheduled agent tasks disabled \u2014 skipping until re-enabled"
+        );
+        lastEnabled = enabled;
+      }
+      if (!enabled) return;
+      const { runAgent } = await import("./executor-J4IBXSBY.js");
       const taskConfig = config.agent.tasks?.[taskName];
       const projectRoot = resolve(vaultDir, "..");
       const built = buildTaskInstruction(taskName, taskConfig?.params, taskAgentMap.get(taskName), projectRoot, embeddingManager);
@@ -6463,14 +6578,12 @@ async function registerScheduledTasks(powerManager, deps) {
   };
   const scheduledJobs = buildScheduledJobs(
     allTasks,
-    config.agent.tasks ?? {},
+    liveConfig.current.agent.tasks ?? {},
     scheduledContext,
     initialLastRuns
   );
-  for (const job of scheduledJobs) {
-    powerManager.register(job);
-  }
-  logger.info(LOG_KINDS.DAEMON_START, `Registered ${scheduledJobs.length} scheduled task(s)`, {
+  powerManager.replaceGroup(SCHEDULED_JOB_PREFIX, scheduledJobs);
+  logger.info(LOG_KINDS.DAEMON_START, `Synced ${scheduledJobs.length} scheduled task(s)`, {
     tasks: scheduledJobs.map((j) => j.name)
   });
 }
@@ -6487,6 +6600,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 +6611,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 +6690,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 +6710,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 +6808,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 +6829,7 @@ function createMcpProxyHandlers(deps) {
   return {
     handleRemember,
     handleSupersede,
+    handleConsolidate,
     handlePlans,
     handleSessions,
     handleTeam
@@ -6640,7 +6848,7 @@ function createAgentRunHandlers(deps) {
   const { vaultDir, embeddingManager, logger } = deps;
   async function handleRun(req) {
     const { task, instruction: rawInstruction, agentId } = AgentRunBody.parse(req.body);
-    const mycoConfig = loadConfig(vaultDir);
+    const mycoConfig = loadMergedConfig(vaultDir);
     if (!hasConfiguredProvider(mycoConfig, task)) {
       return {
         status: 400,
@@ -6675,7 +6883,7 @@ function createAgentRunHandlers(deps) {
         };
       }
     }
-    const { runAgent } = await import("./executor-NXNSUEMQ.js");
+    const { runAgent } = await import("./executor-J4IBXSBY.js");
     const resultPromise = runAgent(vaultDir, {
       task,
       instruction,
@@ -6833,6 +7041,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";
@@ -6850,6 +7259,10 @@ var PowerManager = class {
   register(job) {
     this.jobs.push(job);
   }
+  replaceGroup(prefix, jobs) {
+    this.jobs = this.jobs.filter((job) => !job.name.startsWith(prefix));
+    this.jobs.push(...jobs);
+  }
   recordActivity() {
     this.lastActivity = Date.now();
     this.deepSleepHeld = false;
@@ -6999,7 +7412,7 @@ async function runSessionMaintenance(deps) {
 // src/daemon/power-jobs.ts
 var STAGING_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 function registerPowerJobs(powerManager, deps) {
-  const { embeddingManager, registry, logger, config, db, backupDir, machineId, vaultDir, databaseManager } = deps;
+  const { embeddingManager, registry, logger, liveConfig, db, machineId, vaultDir, databaseManager } = deps;
   let reconcileRunning = false;
   powerManager.register({
     name: "embedding-reconcile",
@@ -7022,14 +7435,14 @@ function registerPowerJobs(powerManager, deps) {
       registeredSessionIds: () => registry.sessions,
       embeddingManager,
       vaultDir,
-      staleThresholdMs: config.daemon.stale_session_threshold_ms
+      staleThresholdMs: liveConfig.current.daemon.stale_session_threshold_ms
     })
   });
   powerManager.register({
     name: "log-retention",
     runIn: ["idle", "sleep"],
     fn: async () => {
-      const retentionDays = config.daemon.log_retention_days;
+      const retentionDays = liveConfig.current.daemon.log_retention_days;
       const cutoff = new Date(Date.now() - retentionDays * MS_PER_DAY).toISOString();
       const deleted = deleteOldLogs(cutoff);
       if (deleted > 0) {
@@ -7042,6 +7455,7 @@ function registerPowerJobs(powerManager, deps) {
     runIn: ["idle", "sleep"],
     fn: async () => {
       try {
+        const backupDir = resolveBackupDir(liveConfig.current, vaultDir);
         logger.info(LOG_KINDS.BACKUP_START, "Auto-backup starting");
         const filePath = createBackup(db, backupDir, machineId);
         logger.info(LOG_KINDS.BACKUP_COMPLETE, "Auto-backup complete", { file_path: filePath });
@@ -7054,6 +7468,7 @@ function registerPowerJobs(powerManager, deps) {
     name: "database-optimize",
     runIn: ["idle", "sleep"],
     fn: async () => {
+      const config = liveConfig.current;
       if (!config.maintenance?.auto_optimize) return;
       const intervalMs = (config.maintenance.auto_optimize_interval_hours ?? 24) * MS_PER_HOUR;
       const lastRun = await databaseManager.getLastOptimizeAt();
@@ -7366,7 +7781,7 @@ function captureBatchImages(input) {
 
 // src/daemon/plan-capture.ts
 import { createHash as createHash4 } from "crypto";
-import os7 from "os";
+import os8 from "os";
 import path20 from "path";
 function extractTaggedPlans(text, tags) {
   const results = [];
@@ -7395,7 +7810,7 @@ var PLAN_ID_HASH_LENGTH = 16;
 function isInPlanDirectory(filePath, watchDirs, projectRoot) {
   const abs = path20.isAbsolute(filePath) ? filePath : path20.resolve(projectRoot, filePath);
   return watchDirs.some((dir) => {
-    const expanded = dir.startsWith("~/") ? path20.join(os7.homedir(), dir.slice(2)) : dir;
+    const expanded = dir.startsWith("~/") ? path20.join(os8.homedir(), dir.slice(2)) : dir;
     const absDir = path20.isAbsolute(expanded) ? expanded : path20.resolve(projectRoot, expanded);
     const prefix = absDir.endsWith(path20.sep) ? absDir : absDir + path20.sep;
     return abs === absDir || abs.startsWith(prefix);
@@ -7499,16 +7914,27 @@ function enrichTurnsWithToolMetadata(turns, events) {
   }
 }
 function createStopProcessor(deps) {
-  const { registry, sessionBuffers, transcriptMiner, embeddingManager, logger, config, vaultDir } = deps;
+  const { registry, sessionBuffers, transcriptMiner, embeddingManager, logger, liveConfig, vaultDir } = deps;
   let activeStopProcessing = null;
   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 });
+  const triggerTitleSummary2 = (sessionId) => triggerTitleSummary(sessionId, { vaultDir, embeddingManager, liveConfig, 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 +8107,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", {
@@ -7736,7 +8185,7 @@ function createEventDispatcher(deps) {
     powerManager,
     logger,
     machineId,
-    config,
+    liveConfig,
     vaultDir,
     reconcileSession,
     planWatchConfig,
@@ -7803,7 +8252,7 @@ function createEventDispatcher(deps) {
             });
           }
           const batchCount = promptNumber;
-          const summaryInterval = config.agent.summary_batch_interval;
+          const summaryInterval = liveConfig.current.agent.summary_batch_interval;
           if (summaryInterval > 0 && batchCount > 0 && batchCount % summaryInterval === 0) {
             triggerTitleSummary2(event.session_id);
           }
@@ -7969,9 +8418,64 @@ 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";
 import path22 from "path";
 function killStaleDaemon(vaultDir, logger) {
   const daemonJsonPath = path22.join(vaultDir, "daemon.json");
@@ -7998,12 +8502,13 @@ async function main() {
   }
   const vaultDir = path22.resolve(vaultArg);
   loadSecrets(vaultDir);
-  const config = loadConfig(vaultDir);
+  const config = loadMergedConfig(vaultDir);
+  const liveConfig = { current: config };
   const manifests = loadManifests();
   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 +8618,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");
@@ -8138,7 +8643,7 @@ async function main() {
           message: "Daemon restarted while run was in progress",
           link: `/agent?run=${row.id}`,
           metadata: { taskName: row.task, runId: row.id, reason: "daemon_restart" }
-        }, config);
+        }, liveConfig.current);
       }
       logger.info(LOG_KINDS.AGENT_RUN, "Cleaned stale running agent runs", {
         count: staleRows.length,
@@ -8196,7 +8701,7 @@ async function main() {
     transcriptMiner,
     embeddingManager,
     logger,
-    config,
+    liveConfig,
     vaultDir,
     planTags: symbiontPlanTags
   });
@@ -8209,7 +8714,7 @@ async function main() {
     powerManager,
     machineId,
     logger,
-    config,
+    liveConfig,
     vaultDir
   });
   server.registerRoute("POST", "/sessions/register", sessionLifecycle.handleRegister);
@@ -8220,7 +8725,7 @@ async function main() {
     powerManager,
     logger,
     machineId,
-    config,
+    liveConfig,
     vaultDir,
     reconcileSession: reconciler.reconcileSession,
     planWatchConfig,
@@ -8228,7 +8733,7 @@ async function main() {
   });
   server.registerRoute("POST", "/events", eventDispatcher);
   server.registerRoute("POST", "/events/stop", stopProcessor.handleStopRoute);
-  const contextDeps = { embeddingManager, config, logger };
+  const contextDeps = { embeddingManager, liveConfig, logger };
   server.registerRoute("POST", "/context", createSessionContextHandler(contextDeps));
   server.registerRoute("POST", "/context/resume", createResumeContextHandler(contextDeps));
   server.registerRoute("POST", "/context/prompt", createPromptContextHandler(contextDeps));
@@ -8236,39 +8741,76 @@ 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([], (ctx) => {
+    liveConfig.current = ctx;
+  });
+  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);
-    if (!result.status || result.status < 400) {
+  async function syncScheduledTasks() {
+    await registerScheduledTasks(powerManager, { definitionsDir, vaultDir, embeddingManager, logger, liveConfig });
+  }
+  reactions.on(["agent.tasks"], async () => {
+    await syncScheduledTasks();
+  });
+  async function applyConfigWriteReactions(touchedPaths) {
+    const reactionContext = loadReactionContext(vaultDir, logger);
+    if (!reactionContext) {
       configHash = computeConfigHash(vaultDir);
+      return null;
+    }
+    await reactions.fire(touchedPaths, reactionContext);
+    return reactionContext;
+  }
+  server.registerRoute("PUT", "/api/config/scoped", async (req) => {
+    const result = await handlePutScopedConfig(vaultDir, req.body);
+    if (!result.status || result.status < 400) {
+      const body = req.body;
+      const touchedPaths = computeTouchedPaths(body.patch, body.clear);
+      const reactionContext = await applyConfigWriteReactions(touchedPaths);
+      if (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,
@@ -8302,7 +8844,7 @@ async function main() {
   server.registerRoute("GET", "/api/progress/:token", async (req) => handleGetProgress(progressTracker, req.params.token));
   server.registerRoute("GET", "/api/sessions", handleListSessions);
   server.registerRoute("GET", "/api/sessions/:id", handleGetSession);
-  const sessionMutations = createSessionMutationHandlers({ embeddingManager, vaultDir, logger, config });
+  const sessionMutations = createSessionMutationHandlers({ embeddingManager, vaultDir, logger, liveConfig });
   server.registerRoute("GET", "/api/sessions/:id/impact", sessionMutations.handleGetSessionImpact);
   server.registerRoute("POST", "/api/sessions/:id/complete", sessionMutations.handleCompleteSession);
   server.registerRoute("DELETE", "/api/sessions/:id", sessionMutations.handleDeleteSession);
@@ -8335,31 +8877,70 @@ async function main() {
   server.registerRoute("GET", "/api/agent/tasks", async (req) => handleListTasks(req, vaultDir));
   server.registerRoute("GET", "/api/agent/tasks/:id", async (req) => handleGetTask(req, vaultDir));
   server.registerRoute("GET", "/api/agent/tasks/:id/yaml", async (req) => handleGetTaskYaml(req, vaultDir));
-  server.registerRoute("PUT", "/api/agent/tasks/:id", async (req) => handleUpdateTask(req, vaultDir));
-  server.registerRoute("POST", "/api/agent/tasks", async (req) => handleCreateTask(req, vaultDir));
-  server.registerRoute("POST", "/api/agent/tasks/:id/copy", async (req) => handleCopyTask(req, vaultDir));
-  server.registerRoute("DELETE", "/api/agent/tasks/:id", async (req) => handleDeleteTask(req, vaultDir));
+  server.registerRoute("PUT", "/api/agent/tasks/:id", async (req) => {
+    const result = await handleUpdateTask(req, vaultDir);
+    if (!result.status || result.status < 400) {
+      await syncScheduledTasks();
+    }
+    return result;
+  });
+  server.registerRoute("POST", "/api/agent/tasks", async (req) => {
+    const result = await handleCreateTask(req, vaultDir);
+    if (!result.status || result.status < 400) {
+      await syncScheduledTasks();
+    }
+    return result;
+  });
+  server.registerRoute("POST", "/api/agent/tasks/:id/copy", async (req) => {
+    const result = await handleCopyTask(req, vaultDir);
+    if (!result.status || result.status < 400) {
+      await syncScheduledTasks();
+    }
+    return result;
+  });
+  server.registerRoute("DELETE", "/api/agent/tasks/:id", async (req) => {
+    const result = await handleDeleteTask(req, vaultDir);
+    if (!result.status || result.status < 400) {
+      await syncScheduledTasks();
+    }
+    return result;
+  });
   server.registerRoute("GET", "/api/agent/tasks/:id/config", async (req) => handleGetTaskConfig(req, vaultDir));
-  server.registerRoute("PUT", "/api/agent/tasks/:id/config", async (req) => handleUpdateTaskConfig(req, vaultDir));
+  server.registerRoute("PUT", "/api/agent/tasks/:id/config", async (req) => {
+    const result = await handleUpdateTaskConfig(req, vaultDir);
+    if (!result.status || result.status < 400) {
+      await applyConfigWriteReactions([`agent.tasks.${req.params.id}`]);
+    }
+    return result;
+  });
   server.registerRoute("GET", "/api/providers", async () => handleGetProviders());
   server.registerRoute("POST", "/api/providers/test", async (req) => handleTestProvider(req));
   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);
-  const rawBackupDir = config.backup.dir;
-  const backupDir = rawBackupDir ? path22.resolve(rawBackupDir.startsWith("~/") ? path22.join(os8.homedir(), rawBackupDir.slice(2)) : rawBackupDir) : path22.resolve(vaultDir, "backups");
-  const backupHandlers = createBackupHandlers({ db, backupDir, machineId });
+  const backupHandlers = createBackupHandlers({ db, machineId, vaultDir, liveConfig });
   server.registerRoute("POST", "/api/backup", backupHandlers.handleCreateBackup);
   server.registerRoute("GET", "/api/backups", backupHandlers.handleListBackups);
   server.registerRoute("POST", "/api/restore/preview", backupHandlers.handleRestorePreview);
   server.registerRoute("POST", "/api/restore", backupHandlers.handleRestore);
   const backupConfigHandlers = createBackupConfigHandlers({ vaultDir });
   server.registerRoute("GET", "/api/backup/config", backupConfigHandlers.handleGetBackupConfig);
-  server.registerRoute("PUT", "/api/backup/config", backupConfigHandlers.handlePutBackupConfig);
-  const teamSync = initTeamSync({ config, machineId, logger, vaultDir, serverVersion: server.version });
+  server.registerRoute("PUT", "/api/backup/config", async (req) => {
+    const result = await backupConfigHandlers.handlePutBackupConfig(req);
+    if (!result.status || result.status < 400) {
+      await applyConfigWriteReactions(["backup.dir"]);
+    }
+    return result;
+  });
+  const teamSync = initTeamSync({ liveConfig, machineId, logger, vaultDir, serverVersion: server.version });
+  reactions.on(["team"], async () => {
+    await teamSync.reconcileClient();
+  });
+  await teamSync.reconcileClient();
   const teamHandlers = createTeamHandlers({
     vaultDir,
     machineId,
@@ -8367,8 +8948,20 @@ async function main() {
     getTeamClient: teamSync.getTeamClient,
     setTeamClient: teamSync.setTeamClient
   });
-  server.registerRoute("POST", "/api/team/connect", teamHandlers.handleConnect);
-  server.registerRoute("POST", "/api/team/disconnect", teamHandlers.handleDisconnect);
+  server.registerRoute("POST", "/api/team/connect", async (req) => {
+    const result = await teamHandlers.handleConnect(req);
+    if (!result.status || result.status < 400) {
+      await applyConfigWriteReactions(["team.enabled", "team.worker_url"]);
+    }
+    return result;
+  });
+  server.registerRoute("POST", "/api/team/disconnect", async (req) => {
+    const result = await teamHandlers.handleDisconnect(req);
+    if (!result.status || result.status < 400) {
+      await applyConfigWriteReactions(["team.enabled", "team.worker_url"]);
+    }
+    return result;
+  });
   server.registerRoute("GET", "/api/team/status", teamHandlers.handleStatus);
   server.registerRoute("POST", "/api/team/backfill", teamHandlers.handleBackfill);
   server.registerRoute("POST", "/api/team/retry-failed", teamHandlers.handleRetryFailed);
@@ -8420,9 +9013,9 @@ async function main() {
       logger.warn(LOG_KINDS.DAEMON_CONFIG, "Failed to persist auto-derived port", { error: err.message });
     }
   }
-  registerPowerJobs(powerManager, { embeddingManager, registry, logger, config, db, backupDir, machineId, vaultDir, databaseManager });
+  registerPowerJobs(powerManager, { embeddingManager, registry, logger, liveConfig, db, machineId, vaultDir, databaseManager });
   teamSync.registerFlushJob(powerManager);
-  await registerScheduledTasks(powerManager, { definitionsDir, vaultDir, embeddingManager, logger, config });
+  await registerScheduledTasks(powerManager, { definitionsDir, vaultDir, embeddingManager, logger, liveConfig });
   powerManager.start();
   const shutdown = async (signal) => {
     logger.info(LOG_KINDS.DAEMON_START, `${signal} received`);
@@ -8454,4 +9047,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-RPJSS7PT.js.map
+//# sourceMappingURL=main-E7HU4QYR.js.map