@goondocks/myco 0.20.0 → 0.20.1

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

@@ -15,7 +15,7 @@ import {
   getEmbeddingQueueDepth,
   getUnembedded,
   markEmbedded
-} from "./chunk-P3DN5EWW.js";
+} from "./chunk-22JALAXN.js";
 import {
   getTeamPackageVersion,
   loadSecrets,
@@ -72,7 +72,7 @@ import {
   setResponseSummary,
   updateCandidate,
   updateNotificationStatus
-} from "./chunk-L6XFAJIF.js";
+} from "./chunk-FGY7J6EZ.js";
 import {
   fullTextSearch,
   hydrateSearchResults
@@ -110,11 +110,11 @@ import {
   listBufferSessionIds
 } from "./chunk-V7XG6V6C.js";
 import "./chunk-POEPHBQK.js";
-import "./chunk-YSNIAJ5D.js";
+import "./chunk-UEWMSIL3.js";
 import "./chunk-SAKJMNSR.js";
 import {
   SymbiontInstaller
-} from "./chunk-4LCIKVDM.js";
+} from "./chunk-LZP4IJB3.js";
 import {
   checkLocalProvider
 } from "./chunk-BPRIYNLE.js";
@@ -189,10 +189,10 @@ import {
 } from "./chunk-ZXZPJJN3.js";
 import {
   resolveCliEntryPath
-} from "./chunk-UOQQENDW.js";
+} from "./chunk-3WWJOTYG.js";
 import {
   getPluginVersion
-} from "./chunk-ACQ2AIEM.js";
+} from "./chunk-AIYFHQRX.js";
 import {
   loadManifests,
   resolvePackageRoot
@@ -2287,7 +2287,7 @@ function getConfiguredManifests(projectRoot, config) {
   return allManifests.filter((manifest) => fs12.existsSync(path12.join(projectRoot, manifest.configDir)));
 }
 function reconcileConfiguredSymbionts(projectRoot, vaultDir = path12.join(projectRoot, ".myco"), preloadedConfig) {
-  const config = preloadedConfig ?? loadConfig(vaultDir);
+  const config = preloadedConfig ?? loadMergedConfig(vaultDir);
   const manifests = getConfiguredManifests(projectRoot, config);
   const packageRoot = resolvePackageRoot();
   let updatedCount = 0;
@@ -2457,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: {
@@ -2472,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) {
@@ -2480,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);
@@ -2496,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 } };
   }
@@ -2515,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) {
@@ -2747,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]);
@@ -2986,7 +2995,7 @@ function createSessionLifecycleHandlers(deps) {
     powerManager,
     machineId,
     logger,
-    config,
+    liveConfig,
     vaultDir
   } = deps;
   async function handleRegister(req) {
@@ -3018,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) {
@@ -3038,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 };
@@ -3221,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-ZNK4JSQA.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) });
@@ -3234,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 {
@@ -3272,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 });
@@ -3282,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();
@@ -3849,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-ACDHGTRH.js");
+    const { runAgent } = await import("./executor-J4IBXSBY.js");
     runAgent(vaultDir, {
       task: "title-summary",
       instruction: `Process session ${sessionId} only`,
@@ -3918,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);
@@ -3942,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
@@ -4378,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 = [];
@@ -4490,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: "" } };
@@ -4611,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) => ({
@@ -4628,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: {
@@ -6050,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" } };
   }
@@ -6254,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 } };
 }
@@ -6406,16 +6438,17 @@ 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-MGJSJBAS.js");
   const allTasks = Array.from(loadAllTasks2(definitionsDir, vaultDir).values());
@@ -6443,7 +6476,17 @@ async function registerScheduledTasks(powerManager, deps) {
       else runningTasks.delete(name);
     },
     runTask: async (taskName) => {
-      const { runAgent } = await import("./executor-ACDHGTRH.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);
@@ -6535,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)
   });
 }
@@ -6807,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,
@@ -6842,7 +6883,7 @@ function createAgentRunHandlers(deps) {
         };
       }
     }
-    const { runAgent } = await import("./executor-ACDHGTRH.js");
+    const { runAgent } = await import("./executor-J4IBXSBY.js");
     const resultPromise = runAgent(vaultDir, {
       task,
       instruction,
@@ -7218,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;
@@ -7367,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",
@@ -7390,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 = loadMergedConfig(vaultDir).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) {
@@ -7410,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 });
@@ -7422,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();
@@ -7734,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 = [];
@@ -7763,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);
@@ -7867,7 +7914,7 @@ 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({
@@ -7877,7 +7924,7 @@ function createStopProcessor(deps) {
     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);
@@ -8138,7 +8185,7 @@ function createEventDispatcher(deps) {
     powerManager,
     logger,
     machineId,
-    config,
+    liveConfig,
     vaultDir,
     reconcileSession,
     planWatchConfig,
@@ -8205,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);
           }
@@ -8429,7 +8476,6 @@ function createPlanWatchReaction(deps) {
 
 // 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");
@@ -8456,7 +8502,8 @@ 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 ?? []))];
@@ -8596,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,
@@ -8654,7 +8701,7 @@ async function main() {
     transcriptMiner,
     embeddingManager,
     logger,
-    config,
+    liveConfig,
     vaultDir,
     planTags: symbiontPlanTags
   });
@@ -8667,7 +8714,7 @@ async function main() {
     powerManager,
     machineId,
     logger,
-    config,
+    liveConfig,
     vaultDir
   });
   server.registerRoute("POST", "/sessions/register", sessionLifecycle.handleRegister);
@@ -8678,7 +8725,7 @@ async function main() {
     powerManager,
     logger,
     machineId,
-    config,
+    liveConfig,
     vaultDir,
     reconcileSession: reconciler.reconcileSession,
     planWatchConfig,
@@ -8686,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));
@@ -8705,6 +8752,9 @@ async function main() {
   reactions.on([], () => {
     configHash = computeConfigHash(vaultDir);
   });
+  reactions.on([], (ctx) => {
+    liveConfig.current = ctx;
+  });
   reactions.on(["capture", "symbionts"], (ctx) => {
     reconcileConfiguredSymbionts(path22.dirname(vaultDir), vaultDir, ctx);
   });
@@ -8720,14 +8770,28 @@ async function main() {
       delete process.env.MYCO_AGENT_DEBUG;
     }
   });
+  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 = loadReactionContext(vaultDir, logger);
+      const reactionContext = await applyConfigWriteReactions(touchedPaths);
       if (reactionContext) {
-        await reactions.fire(touchedPaths, reactionContext);
         const summary = buildScopedConfigSaveNotification(body.scope, touchedPaths);
         notify(vaultDir, {
           domain: "settings",
@@ -8780,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);
@@ -8813,12 +8877,42 @@ 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 });
@@ -8828,17 +8922,25 @@ async function main() {
   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,
@@ -8846,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);
@@ -8899,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`);
@@ -8933,4 +9047,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-5S4MDCIO.js.map
+//# sourceMappingURL=main-E7HU4QYR.js.map