mixdog 1.0.5 → 1.0.7

package/src/runtime/channels/lib/scheduler.mjs

@@ -97,14 +97,12 @@ function releaseSchedulerRuntime(scheduler) {
 class Scheduler {
   nonInteractive;
   interactive;
-  channelId;
   promptsDir;
   tickTimer = null;
   lastFired = /* @__PURE__ */ new Map();
   // name -> "YYYY-MM-DDTHH:MM"
   running = /* @__PURE__ */ new Set();
   injectFn = null;
-  sendFn = null;
   injectReadyFn = null;
   pendingCheck = null;
   // Injected by the host: (schedule, { prompt }) => Promise<{ result }>.
@@ -118,13 +116,9 @@ class Scheduler {
   // name -> node-cron ScheduledTask for cron-expression entries
   oneShotTimers = /* @__PURE__ */ new Map();
   // name -> setTimeout handle for when_at one-shot entries
-  //
-  // `channelId` is the single resolved main-channel id used when a schedule's
-  // `channel` flag is set (post-to-channel); absent flag → inject into session.
-  constructor(nonInteractive, interactive, channelId) {
+  constructor(nonInteractive, interactive) {
     this.nonInteractive = nonInteractive.filter((s) => s.enabled !== false);
     this.interactive = interactive.filter((s) => s.enabled !== false);
-    this.channelId = channelId ?? '';
     this.promptsDir = join(DATA_DIR, 'prompts');
     for (const s of [...this.nonInteractive, ...this.interactive]) {
       if (s.lastFiredAt) this.lastFired.set(s.name, new Date(s.lastFiredAt).toISOString());
@@ -134,9 +128,6 @@ class Scheduler {
   setInjectHandler(fn) {
     this.injectFn = fn;
   }
-  setSendHandler(fn) {
-    this.sendFn = fn;
-  }
   /** Probe for a live Lead bridge seat. When set, the interactive
    *  inject only fires while it reports true; otherwise the visible-session
    *  fallback keeps the fire from being lost. Unset → inject when wired. */
@@ -561,10 +552,9 @@ ${prompt}`;
     releaseSchedulerRuntime(this);
     this.start();
   }
-  reloadConfig(nonInteractive, interactive, channelId, options = {}) {
+  reloadConfig(nonInteractive, interactive, options = {}) {
     this.nonInteractive = nonInteractive.filter((s) => s.enabled !== false);
     this.interactive = interactive.filter((s) => s.enabled !== false);
-    this.channelId = channelId ?? '';
     this.promptsDir = join(DATA_DIR, 'prompts');
     // Defer/skip state is persisted (deferred_until / skipped_until) and
     // re-read from the reloaded rows, so a reload no longer drops it.
@@ -629,14 +619,10 @@ ${prompt}`;
       this.notifyFailure(schedule, 'prompt not found — fire skipped');
       return false;
     }
-    // target 'channel' → relay the run result to the schedule's channel_id
-    // (falling back to the resolved main channel). target 'session' → no
-    // channel relay; the visible session run IS the surface.
-    const channelId = schedule.target === 'channel' ? this.resolveChannel(schedule.channelId) : '';
-    return await this.fireTimedPrompt(schedule, type, prompt, channelId, opts);
+    return await this.fireTimedPrompt(schedule, type, prompt, opts);
   }
   /** Fire a timed schedule with the given prompt content */
-  async fireTimedPrompt(schedule, type, prompt, channelId, { awaitDispatch = false } = {}) {
+  async fireTimedPrompt(schedule, type, prompt, { awaitDispatch = false } = {}) {
     logSchedule(`firing ${schedule.name} (${type})\n`);
     if (this.running.has(schedule.name)) {
       // Not silent anymore: overlap skips were invisible and read as the
@@ -644,7 +630,7 @@ ${prompt}`;
       logSchedule(`${schedule.name}: skipped — previous run still in progress\n`);
       return false;
     }
-    if (type === 'interactive' && this.injectIntoLead(schedule, type, prompt, channelId)) return true;
+    if (type === 'interactive' && this.injectIntoLead(schedule, type, prompt)) return true;
     this.running.add(schedule.name);
     const presetId = schedule.model;
     if (!presetId) {
@@ -657,7 +643,7 @@ ${prompt}`;
     // and swallow async failures. A one-shot (awaitDispatch) instead awaits
     // the dispatch so a rejected run propagates and the caller leaves the
     // entry pending for retry instead of retiring it.
-    const dispatch = this.dispatchScheduleRun(schedule, prompt, channelId, awaitDispatch);
+    const dispatch = this.dispatchScheduleRun(schedule, prompt, awaitDispatch);
     if (awaitDispatch) return await dispatch;
     return true;
   }
@@ -666,11 +652,11 @@ ${prompt}`;
    *  exactly like inbound channel messages — enqueue counts as the fire.
    *  False when no live Lead seat is attached or the inject fails, so the
    *  visible-session run remains the fallback and a fire is never lost. */
-  injectIntoLead(schedule, type, prompt, channelId) {
+  injectIntoLead(schedule, type, prompt) {
     if (!this.injectFn || !this.injectReady()) return false;
     try {
       const wrapped = this.wrapPrompt(schedule.name, prompt, type);
-      this.injectFn(channelId, `schedule:${schedule.name}`, ' ', { type: 'schedule', instruction: wrapped });
+      this.injectFn('', `schedule:${schedule.name}`, ' ', { type: 'schedule', instruction: wrapped });
       logSchedule(`${schedule.name}: injected into Lead session queue (interactive fire)\n`);
       return true;
     } catch (err) {
@@ -682,21 +668,16 @@ ${prompt}`;
   }
   /** Fires run as VISIBLE schedule sessions (desktop Recent / TUI resume)
    *  via runScheduleSession; the wrapped prompt keeps the schedule context
-   *  header, and the result is relayed to the channel. Resolves true on
-   *  success; a failure rejects for awaitDispatch callers and resolves false
-   *  (after a channel notice) for fire-and-forget cron fires. */
-  dispatchScheduleRun(schedule, prompt, channelId, awaitDispatch) {
+   *  header. Resolves true on success; a failure rejects for awaitDispatch
+   *  callers and resolves false (after a logged notice) for fire-and-forget
+   *  cron fires. */
+  dispatchScheduleRun(schedule, prompt, awaitDispatch) {
     const run = this.scheduleRunner
       ? this.scheduleRunner(schedule, { prompt })
       : Promise.reject(new Error('schedule runner not configured'));
     return run
       .then(({ result }) => {
         this.running.delete(schedule.name);
-        if (result && channelId && this.sendFn) {
-          this.sendFn(channelId, result).catch((err) =>
-            process.stderr.write(`mixdog scheduler: ${schedule.name} relay failed: ${err}\n`)
-          );
-        }
         logSchedule(`${schedule.name} done\n`);
         return true;
       })
@@ -704,7 +685,7 @@ ${prompt}`;
         this.running.delete(schedule.name);
         logSchedule(`${schedule.name} LLM error: ${err.message}\n`);
         // The cron fire-and-forget contract swallowed failures entirely;
-        // surface them on the channel so a failed scheduled run is never
+        // log them so a failed scheduled run is never
         // silent (one-shots propagate via the awaitDispatch throw instead).
         if (awaitDispatch) throw err;
         this.notifyFailure(schedule, `run failed: ${err.message}`);
@@ -712,18 +693,9 @@ ${prompt}`;
       });
   }
   // ── Helpers ─────────────────────────────────────────────────────────
-  /** Best-effort failure notice to the schedule's channel (or the main
-   *  channel) so scheduled fires never fail silently. Respects an explicit
-   *  channel opt-out ("false" → resolveChannel yields "" → no notice). */
+  /** Failure notice: logged so scheduled fires never fail silently. */
   notifyFailure(schedule, reason) {
-    try {
-      if (!this.sendFn) return;
-      const target = this.resolveChannel(schedule?.channelId);
-      if (!target) return;
-      Promise.resolve(this.sendFn(target, `schedule "${schedule?.name}": ${reason}`)).catch(() => {});
-    } catch {
-      /* best-effort */
-    }
+    logSchedule(`schedule "${schedule?.name}": ${reason}\n`);
   }
   /** Resolve prompt: inline text from the row, with a prompts-dir file
    *  fallback for legacy `<name>.md` references. */
@@ -736,18 +708,5 @@ ${prompt}`;
     const full = isAbsolute(nameOrPath) ? nameOrPath : join(this.promptsDir, nameOrPath);
     return tryRead(full);
   }
-  /** Resolve a schedule's channel flag to a channel id (pre-refactor
-   *  semantics): absent/empty/"false" → "" (inject into session); a
-   *  pure-digit / snowflake value is honored verbatim as an explicit id
-   *  override; any other value — including legacy labels like "main" —
-   *  resolves to the configured main channel. */
-  resolveChannel(flag) {
-    if (flag == null) return this.channelId ?? '';
-    const v = String(flag).trim();
-    if (v.toLowerCase() === 'false') return '';
-    if (/^-?\d+$/.test(v)) return v;
-    // empty or a legacy label ("main") → configured main channel
-    return this.channelId ?? '';
-  }
 }
 export { Scheduler };

package/src/runtime/channels/lib/worker-main.mjs

@@ -131,9 +131,7 @@ const statusState = new JsonStateFile(STATUS_FILE, {});
 statusState.ensure();
 const scheduler = new Scheduler(
   config.nonInteractive ?? [],
-  config.interactive ?? [],
-  // Single resolved main-channel id used for the schedule `channel` flag.
-  config.channelId
+  config.interactive ?? []
 );
 // Schedules fire as visible sessions; the session runner belongs to the
 // session-runtime layer, so this worker entry injects it (lazy, like webhooks).
@@ -220,16 +218,12 @@ scheduler.setInjectHandler((channelId, name, content, options) => {
 // actually holds the live bridge seat; otherwise the scheduler falls back to
 // the visible-session run so the fire is never lost.
 scheduler.setInjectReadyCheck(() => bridgeRuntimeConnected && currentOwnerState().owned);
-scheduler.setSendHandler(async () => {
-  // Channel delivery is retired: schedule results surface in the app session
-  // (parent notify / Automations row) only.
-});
 function wireWebhookHandlers() {
   if (!webhookServer) return;
   webhookServer.setEventPipeline(eventPipeline);
   // Webhook fires run as sessions (schedules parity); the Automations
   // session row is the only surface (channel relay retired).
-  webhookServer.setBridgeDispatch(async ({ prompt, model, cwd, workflow, attachments, delivery, context, signal }) => {
+  webhookServer.setBridgeDispatch(async ({ prompt, model, cwd, workflow, attachments, context, signal }) => {
     const { runWebhookSession } = await import('../../../session-runtime/webhook-session-run.mjs');
     const run = await runWebhookSession({
       name: context?.endpoint || 'webhook',
@@ -237,7 +231,6 @@ function wireWebhookHandlers() {
       cwd: cwd || null,
       workflow: workflow || null,
       attachments: attachments || null,
-      delivery: delivery || null,
       // Dispatch-timeout cancellation only works if the signal reaches the run.
       signal: signal || null,
       prompt,

package/src/runtime/shared/config.mjs

@@ -2,7 +2,7 @@
  * Unified config reader/writer.
  * Single file: mixdog-config.json with sections such as channels, agent, and memory.
  */
-import { readFileSync, statSync, mkdirSync, existsSync } from 'node:fs';
+import { readFileSync, statSync, mkdirSync, existsSync, watch as fsWatch } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { createRequire } from 'node:module';
 import { resolvePluginData } from './plugin-paths.mjs';
@@ -315,8 +315,72 @@ function readAllForRmW() {
   }
 }
 
+// Config-change notification. In-process writes notify directly after the file
+// is persisted; writes from other processes arrive through one lazily started
+// directory watch (the atomic rename replaces the file, which would orphan a
+// file-level watch on POSIX). Bursts coalesce into one listener pass.
+const CONFIG_CHANGE_DEBOUNCE_MS = 100;
+const _configChangeListeners = new Set();
+let _configChangeTimer = null;
+let _configWatcher = null;
+let _configWatchDir = '';
+
+function stopConfigWatcher() {
+  try {
+    _configWatcher?.close();
+  } catch {}
+  _configWatcher = null;
+  _configWatchDir = '';
+}
+
+function notifyConfigChanged() {
+  if (!_configChangeListeners.size) return;
+  if (_configChangeTimer) clearTimeout(_configChangeTimer);
+  _configChangeTimer = setTimeout(() => {
+    _configChangeTimer = null;
+    invalidateConfigReadCache();
+    for (const listener of [..._configChangeListeners]) {
+      try {
+        listener();
+      } catch {}
+    }
+  }, CONFIG_CHANGE_DEBOUNCE_MS);
+  _configChangeTimer.unref?.();
+}
+
+function ensureConfigWatcher() {
+  const dir = dirname(configPath());
+  if (_configWatcher && _configWatchDir === dir) return;
+  stopConfigWatcher();
+  try {
+    _configWatcher = fsWatch(dir, (_event, filename) => {
+      if (!filename || String(filename) === 'mixdog-config.json') notifyConfigChanged();
+    });
+    _configWatcher.unref?.();
+    _configWatcher.on?.('error', stopConfigWatcher);
+    _configWatchDir = dir;
+  } catch {
+    _configWatcher = null;
+  }
+}
+
+/** Subscribe to persisted config changes (this process or another). Returns unsubscribe. */
+export function subscribeConfigChange(listener) {
+  _configChangeListeners.add(listener);
+  ensureConfigWatcher();
+  return () => {
+    _configChangeListeners.delete(listener);
+    if (!_configChangeListeners.size) {
+      if (_configChangeTimer) clearTimeout(_configChangeTimer);
+      _configChangeTimer = null;
+      stopConfigWatcher();
+    }
+  };
+}
+
 function writeAll(data) {
   writeConfigFile(canonicalizeUnifiedConfig(data));
+  notifyConfigChanged();
 }
 
 // Serialize a read-modify-write under the same file lock. Concurrent
@@ -390,6 +454,7 @@ async function writeConfigFileAsync(data) {
 
 async function writeAllAsync(data) {
   await writeConfigFileAsync(canonicalizeUnifiedConfig(data));
+  notifyConfigChanged();
 }
 
 function withConfigLockAsync(fn) {

package/src/runtime/shared/llm/usage-ledger-quota.mjs

@@ -209,11 +209,22 @@ function quotaInstances(rows, label, now) {
       paced: false,
     };
   });
+  // After a reset, early or on time, the meter reads zero until the next
+  // request: that last run is the window open now, not a gap between windows.
+  const latest = instances.at(-1);
+  if (
+    latest?.idle &&
+    instances.some((instance) => !instance.idle) &&
+    (latest.resetAt == null || latest.resetAt > now)
+  ) {
+    latest.idle = false;
+  }
   const active = instances.filter((instance) => !instance.idle);
   let previousEnd = -Infinity;
-  active.forEach((instance, index) => {
+  active.forEach((instance) => {
     const first = instance.rows[0];
-    const next = active[index + 1];
+    // Any later reading, even an idle one after an early reset, closes it.
+    const next = instances[instances.indexOf(instance) + 1];
     // A window's clock started at its opening: never after its first reading,
     // never inside the window before it.
     const opened = quotaWindowOpened(label, instance.resetAt);

package/src/runtime/shared/path-executable.mjs

@@ -0,0 +1,58 @@
+// PATH lookups with no other runtime dependency, so a bundle that only needs
+// "is this executable installed?" (the desktop service's feature gates) does
+// not pull in the git worker or the rest of runtime-capabilities.
+import { accessSync, constants as fsConstants, statSync } from 'node:fs';
+import { delimiter as pathDelimiter, join as pathJoin } from 'node:path';
+
+function _pathDirectory(value) {
+  const text = String(value || '').trim();
+  return text.length >= 2 && text.startsWith('"') && text.endsWith('"') ? text.slice(1, -1) : text;
+}
+
+function _executableNames(name, platform) {
+  const text = String(name || '').trim();
+  if (!text) return [];
+  if (platform !== 'win32' || /\.(?:exe|cmd|bat|com)$/i.test(text)) return [text];
+  return [text, `${text}.exe`, `${text}.cmd`, `${text}.bat`, `${text}.com`];
+}
+
+export function findPathExecutable(
+  name,
+  { pathValue = process.env.PATH || '', platform = process.platform, maxDirectories = 64 } = {}
+) {
+  const names = _executableNames(name, platform);
+  if (!names.length) return null;
+  const seenDirectories = new Set();
+  for (const rawDirectory of String(pathValue).split(pathDelimiter)) {
+    const directory = _pathDirectory(rawDirectory);
+    if (!directory) continue;
+    const key = platform === 'win32' ? directory.toLowerCase() : directory;
+    if (seenDirectories.has(key)) continue;
+    seenDirectories.add(key);
+    if (seenDirectories.size > maxDirectories) break;
+    for (const executable of names) {
+      const file = pathJoin(directory, executable);
+      try {
+        if (!statSync(file).isFile()) continue;
+        accessSync(file, platform === 'win32' ? fsConstants.F_OK : fsConstants.X_OK);
+        return `${executable} (${directory.replace(/\\/g, '/')})`;
+      } catch {}
+    }
+  }
+  return null;
+}
+
+// Whether a `git` executable is on PATH. The tool surface asks on every
+// policy refresh, so the PATH walk is memoized briefly; the short window still
+// lets a session opened after a Git install pick the tool up.
+const GIT_PRESENCE_TTL_MS = 30_000;
+let _gitPresence = null;
+export function gitExecutablePresent({ pathValue = process.env.PATH || '', platform = process.platform } = {}) {
+  const now = Date.now();
+  if (_gitPresence && _gitPresence.pathValue === pathValue && now - _gitPresence.at < GIT_PRESENCE_TTL_MS) {
+    return _gitPresence.present;
+  }
+  const present = Boolean(findPathExecutable('git', { pathValue, platform }));
+  _gitPresence = { pathValue, at: now, present };
+  return present;
+}

package/src/session-runtime/boot/apis.mjs

@@ -20,6 +20,7 @@ import {
   normalizeSystemShellCommand,
   normalizeAutoClearConfig,
   autoClearIdleMsForProvider,
+  resolveAutoClearIdleMs,
   autoClearProviderDefaults,
   normalizeCompactionConfig,
   setModuleEnabledInConfig,
@@ -75,7 +76,10 @@ export function wireApis(boot) {
   });
   boot.lifecycleApi = lifecycleApiFor(boot);
   boot.resourceApi = resourceApiFor(boot);
-  boot.disposeGlobalExtensionSubscription = () => boot.resourceApi.disposeGlobalExtensionSubscription?.();
+  boot.disposeGlobalExtensionSubscription = () => {
+    boot.disposeConfigSync?.();
+    boot.resourceApi.disposeGlobalExtensionSubscription?.();
+  };
   boot.modelRouteApi = modelRouteApiFor(boot);
   boot.workflowAgentsApi = workflowAgentsApiFor(boot);
   boot.sessionTurnApi = sessionTurnApiFor(boot);
@@ -207,6 +211,7 @@ function settingsApiFor(boot) {
     hasOwn,
     normalizeAutoClearConfig,
     autoClearIdleMsForProvider,
+    resolveAutoClearIdleMs,
     autoClearProviderDefaults,
     normalizeCompactionConfig,
     normalizeSystemShellConfig,
@@ -229,7 +234,6 @@ function settingsApiFor(boot) {
     tidyToolEnabledFn: boot.tidyToolEnabledFn,
     localProviderEnabledFn: boot.localProviderEnabledFn,
     webSearchEnabled: boot.webSearchEnabled,
-    channelsEnabled: boot.channelsEnabled,
     autoUpdateEnabled: selfUpdate.autoUpdateEnabled,
     getUpdateCheckState: () => selfUpdate.getCheckState(),
     getUpdateProcessState: () => selfUpdate.getProcessState(),

package/src/session-runtime/boot/begin.mjs

@@ -86,7 +86,6 @@ export async function loadModules(boot) {
     localProviderEnabledFn,
     mediaToolEnabledFn,
     tidyToolEnabledFn,
-    channelsEnabled,
     featureDisallowedTools,
   } = createRuntimeFeatureGates({
     getConfig: () => rt.config,
@@ -114,7 +113,6 @@ export async function loadModules(boot) {
     localProviderEnabledFn,
     mediaToolEnabledFn,
     tidyToolEnabledFn,
-    channelsEnabled,
     featureDisallowedTools,
     getMemoryModule,
     getWebSearchModule,

package/src/session-runtime/boot/providers.mjs

@@ -71,9 +71,11 @@ function wireConfigLifecycle(boot) {
     LAZY_SECRET_PROVIDERS,
     clean,
     resolve,
+    onConfigReloaded: () => boot.invalidateContextStatusCache?.(),
     STANDALONE_DATA_DIR,
   });
   const {
+    disposeConfigSync,
     getOutputStyleStatusCached,
     invalidateOutputStyleStatusCache,
     seedOutputStyleStatusCache,
@@ -89,6 +91,7 @@ function wireConfigLifecycle(boot) {
     ensureConfigForRouteProvider,
   } = lifecycle;
   Object.assign(boot, {
+    disposeConfigSync,
     getOutputStyleStatusCached,
     invalidateOutputStyleStatusCache,
     seedOutputStyleStatusCache,

package/src/session-runtime/boot/tools.mjs

@@ -232,7 +232,6 @@ function wireInternalTools(boot) {
       officeToolsEnabled: boot.officeToolsEnabledFn,
       mediaToolEnabled: boot.mediaToolEnabledFn,
       tidyToolEnabled: boot.tidyToolEnabledFn,
-      channelsEnabled: boot.channelsEnabled,
       getWebSearchModule: boot.getWebSearchModule,
       getMemoryModule: boot.getMemoryModule,
       getCodeGraphModule: boot.getCodeGraphModule,

package/src/session-runtime/config-lifecycle.mjs

@@ -66,6 +66,7 @@ export function createConfigLifecycle({
   clean,
   resolve,
   performanceNow = () => performance.now(),
+  onConfigReloaded,
   STANDALONE_DATA_DIR,
 }) {
   const outputStyleCache = createOutputStyleStatusCache({
@@ -160,7 +161,17 @@ export function createConfigLifecycle({
     return ensureFullConfig();
   }
 
+  // Settings persisted by any other runtime (or process) reach this runtime's
+  // in-memory config. reloadFullConfig keeps our own pending edits, and the
+  // shared layer coalesces bursts into one pass per subscriber.
+  const unsubscribeConfigChange = sharedCfgMod?.subscribeConfigChange?.(() => {
+    reloadFullConfig();
+    outputStyleCache.invalidateOutputStyleStatusCache();
+    onConfigReloaded?.();
+  });
+
   return {
+    disposeConfigSync: () => unsubscribeConfigChange?.(),
     // output-style cache
     ...outputStyleCache,
     // adopt / save

package/src/session-runtime/internal-tool-executor.mjs

@@ -22,7 +22,6 @@ export function createInternalToolExecutor({
   officeToolsEnabled,
   mediaToolEnabled,
   tidyToolEnabled = () => true,
-  channelsEnabled,
   getWebSearchModule,
   getMemoryModule,
   getCodeGraphModule,
@@ -68,7 +67,6 @@ export function createInternalToolExecutor({
     if (callerCtx?.invocationSource === 'model-tool') guardModelCall(name);
     if (Object.hasOwn(handlers, name)) return handlers[name](args, { name, callerCtx, callerCwd });
     if (channels.isChannelTool(name)) {
-      if (!channelsEnabled()) throw new Error('channels are disabled in settings');
       return await channels.execute(name, args || {});
     }
     throw new Error(`unknown standalone internal tool: ${name}`);

package/src/session-runtime/runtime-feature-gates.mjs

@@ -5,7 +5,7 @@
 // Key names mirror the dependency names of settings-api.mjs / the session-build
 // deps, so the runtime can hand them straight through.
 import { builtinFeatureActive, featureDisallowedToolsFor, localGitToolsActive } from '../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
-import { moduleEnabled, recapEnabled } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
+import { recapEnabled } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { browserBridgeAvailableSync } from '../runtime/browser-bridge/client.mjs';
 import { computerBridgeAvailableSync } from '../runtime/computer-bridge/client.mjs';
 
@@ -17,12 +17,11 @@ export function createRuntimeFeatureGates({ getConfig, getToolProfile }) {
     recapEnabledFn: () => recapEnabled(getConfig(), true),
     memoryToolsEnabledFn: () => builtinFeatureActive(getConfig(), 'memory'),
     webSearchEnabled: () => builtinFeatureActive(getConfig(), 'webSearch'),
-    gitToolsEnabledFn: () => localGitToolsActive(getConfig(), getToolProfile()),
+    gitToolsEnabledFn: () => localGitToolsActive(getConfig()),
     officeToolsEnabledFn: () => builtinFeatureActive(getConfig(), 'office'),
     localProviderEnabledFn: () => builtinFeatureActive(getConfig(), 'localProvider'),
     mediaToolEnabledFn: () => builtinFeatureActive(getConfig(), 'media'),
     tidyToolEnabledFn: () => builtinFeatureActive(getConfig(), 'tidy'),
-    channelsEnabled: () => moduleEnabled(getConfig(), 'channels', true),
     // Browser/Computer activate on live desktop-bridge presence, so the probe
     // runs per call instead of being captured at boot.
     featureDisallowedTools: () =>

package/src/session-runtime/schedule-session-run.mjs

@@ -48,7 +48,6 @@ export async function runScheduleSession(schedule, { config = null, prompt: prom
     owner: 'user',
     sourceType: 'schedule',
     sourceName: schedule.name,
-    sourceDelivery: schedule.delivery || null,
     ...(cwd ? { cwd } : {}),
     desktopSession: cwd
       ? { classification: 'project', projectPath: cwd }