mixdog 1.0.6 → 1.0.8

package/src/runtime/agent/orchestrator/session/store-summary-reader.mjs

@@ -17,7 +17,11 @@ import { readTopLevelLifecycleRecord, isLifecycleUnreadable } from './lifecycle-
 import { isAgentOnlySession, isRootLeadSession, sessionVisibility } from './store-summary-visibility.mjs';
 import { applySummaryLogText, readSummaryLogText } from './store-summary-log.mjs';
 import { createStoredTranscriptCache, nextProjectionStamp } from './store-transcript-cache.mjs';
-import { OFFLOAD_MIN_CHARS, projectStoredTranscriptOffThread } from './store-transcript-worker.mjs';
+import {
+  OFFLOAD_MIN_CHARS,
+  projectStoredTranscriptOffThread,
+  storedTranscriptWorkerRunning,
+} from './store-transcript-worker.mjs';
 import { projectStoredTranscript } from './store-transcript-projection.mjs';
 import { dataDir, sessionHeartbeatMtimes } from './store-summary-locations.mjs';
 import { desktopSession, isStoredSessionId, positiveNumber } from './store-summary-fields.mjs';
@@ -49,6 +53,12 @@ export function forgetStoredSessionTranscript(sessionId) {
   storedTranscriptCache.forget(`${String(sessionId || '').trim()}|`);
 }
 
+/** Its last view left: keep the cold projections for a revisit, within the
+ *  cache's idle budget. */
+export function releaseStoredSessionTranscript(sessionId) {
+  storedTranscriptCache.release(`${String(sessionId || '').trim()}|`);
+}
+
 /** Test/diagnostic seam: size of the retained cold projections. */
 export function storedTranscriptCacheStats() {
   return storedTranscriptCache.stats();
@@ -184,7 +194,6 @@ function normalizedRow(row, heartbeatAt = 0) {
     agent: row.agent || null,
     sourceType: row.sourceType || null,
     sourceName: row.sourceName || null,
-    sourceDelivery: row.sourceDelivery || null,
     scopeKey: row.scopeKey || null,
     ownerSessionId: row.ownerSessionId || row.parentSessionId || null,
     visibility: sessionVisibility(row),
@@ -487,6 +496,8 @@ export async function readStoredSessionTranscript(id, options = {}) {
   // checkpoint skips recovery: an unreadable probe must not silently
   // downgrade an interrupted turn to a plain cold read.
   const startedAt = performance.now();
+  // Phase durations of the parse this call ran (absent on a cache hit).
+  const timing = {};
   const recordStat = probePath(recordPath);
   if (recordStat.state === PROBE_ABSENT) return readArchivedAgentResult(sessionId);
   if (recordStat.state !== PROBE_PRESENT) return null;
@@ -517,6 +528,7 @@ export async function readStoredSessionTranscript(id, options = {}) {
     ].join(':'),
     fileStat: recordStat,
     loadText: async () => {
+      const readStartedAt = performance.now();
       const before = observeStamp(recordPath);
       let body = null;
       if (offloadable) {
@@ -529,6 +541,7 @@ export async function readStoredSessionTranscript(id, options = {}) {
         }
       }
       body ||= readTextFile(recordPath);
+      timing.readMs = performance.now() - readStartedAt;
       readState = body.state;
       if (body.state !== PROBE_PRESENT) return null;
       readStamp = before && sameSessionStamp(before, observeStamp(recordPath)) ? before : null;
@@ -541,7 +554,11 @@ export async function readStoredSessionTranscript(id, options = {}) {
       // no parse to the load cache (a later resume reads the file itself).
       if (offloadable && text.length >= OFFLOAD_MIN_CHARS) {
         try {
+          timing.worker = storedTranscriptWorkerRunning() ? 'warm' : 'cold';
+          const workerStartedAt = performance.now();
           const answer = await projectStoredTranscriptOffThread({ sessionId, text, itemLimit });
+          timing.workerMs = performance.now() - workerStartedAt;
+          Object.assign(timing, answer.timing);
           if (answer.unreadable) return null;
           if (stamp) readCanonicalLifecycle.rememberStrictVerdict(recordPath, stamp, answer.lifecycle);
           // Stamps are process-unique per module realm; re-issue in this one.
@@ -551,7 +568,9 @@ export async function readStoredSessionTranscript(id, options = {}) {
           // Worker unavailable: fall through to the in-process pipeline.
         }
       }
+      const parseStartedAt = performance.now();
       const record = readTopLevelLifecycleRecord(text);
+      timing.parseMs = performance.now() - parseStartedAt;
       if (isLifecycleUnreadable(record) || record.id !== sessionId) return null;
       // The same strict verdict the lifecycle authority would reach for these
       // bytes (storedSessionExists runs next when the pane's runtime loads).
@@ -574,6 +593,7 @@ export async function readStoredSessionTranscript(id, options = {}) {
       // a turn checkpoint the projection recovers through loadSession, the very
       // load the hand-off serves, and projects the load cache's session
       // exactly as before; only that projection is detached.
+      const projectStartedAt = performance.now();
       const value = await projectStoredTranscript(
         sessionId,
         handedOver && checkpointAbsent ? JSON.parse(text) : record.doc,
@@ -583,6 +603,7 @@ export async function readStoredSessionTranscript(id, options = {}) {
           checkpointAbsent,
         }
       );
+      timing.projectMs = performance.now() - projectStartedAt;
       if (!handedOver || checkpointAbsent || !value || mode !== 'items') return value;
       try {
         return structuredClone(value);
@@ -601,6 +622,7 @@ export async function readStoredSessionTranscript(id, options = {}) {
       ms: performance.now() - startedAt,
       chars: recordStat.size,
       items: Array.isArray(value?.items) ? value.items.length : 0,
+      timing,
     });
   }
   return value;

package/src/runtime/agent/orchestrator/session/store-transcript-cache.mjs

@@ -35,6 +35,10 @@ const SETTLED_FILE_AGE_MS = 2_500;
 // newcomer is served uncached.
 const ACTIVE_ENTRY_MS = 5_000;
 const GHOST_LIMIT = 256;
+// Projections nobody is being served (a view that left, a hover/boot
+// prefetch never opened) stay for a quick revisit only within this budget;
+// the full budget above is for the views still refreshing.
+const STORED_TRANSCRIPT_IDLE_MAX_BYTES = 4 * 1024 * 1024;
 
 function sameFileStat(left, right) {
   return (
@@ -60,6 +64,7 @@ export function createStoredTranscriptCache({
   // LRU reparsed every unchanged record when nine visible sessions refreshed.
   maxEntries = Number.POSITIVE_INFINITY,
   maxBytes = STORED_TRANSCRIPT_CACHE_MAX_BYTES,
+  maxIdleBytes = STORED_TRANSCRIPT_IDLE_MAX_BYTES,
 } = {}) {
   // Retain a content digest, not a second full transcript beside its projection.
   // The bound is the size of what is actually retained: the projection.
@@ -126,6 +131,17 @@ export function createStoredTranscriptCache({
     entries.delete(key);
     entries.set(key, entry);
   };
+  // Oldest idle entries go first until the idle ones fit their own budget.
+  const trimIdle = (now) => {
+    let idleBytes = 0;
+    for (const entry of entries.values()) if (now - entry.usedAt > ACTIVE_ENTRY_MS) idleBytes += entry.bytes;
+    for (const [key, entry] of [...entries]) {
+      if (idleBytes <= maxIdleBytes) break;
+      if (now - entry.usedAt <= ACTIVE_ENTRY_MS) continue;
+      idleBytes -= entry.bytes;
+      drop(key);
+    }
+  };
 
   return {
     /** The cached projection for this exact content, or a fresh one from
@@ -133,6 +149,7 @@ export function createStoredTranscriptCache({
      *  the entry. Concurrent callers with the same content share one parse.
      *  Entries naming the same `group` replace each other. */
     async read({ key, group = null, fingerprint, fileStat = null, loadText, produce, now = Date.now() }) {
+      trimIdle(now);
       const cached = entries.get(key);
       if (
         cached &&
@@ -181,6 +198,14 @@ export function createStoredTranscriptCache({
         if (inFlight.get(key) === record) inFlight.delete(key);
       }
     },
+    /** The last view of these projections left: they turn idle now and stay
+     *  only within the idle budget, ready for a revisit. */
+    release(keyPrefix, now = Date.now()) {
+      for (const [key, entry] of entries) {
+        if (key.startsWith(keyPrefix)) entry.usedAt = Math.min(entry.usedAt, now - ACTIVE_ENTRY_MS - 1);
+      }
+      trimIdle(now);
+    },
     forget(keyPrefix) {
       for (const key of inFlight.keys()) {
         if (key.startsWith(keyPrefix)) inFlight.delete(key);

package/src/runtime/agent/orchestrator/session/store-transcript-worker.mjs

@@ -36,19 +36,32 @@ export function projectStoredTranscriptOffThread({ sessionId, text, itemLimit })
   return client({ sessionId, text, itemLimit });
 }
 
+/** Whether a projection worker is attached (a request now skips its start). */
+export function storedTranscriptWorkerRunning() {
+  return client?.running() === true;
+}
+
 async function project({ sessionId, text, itemLimit }) {
+  const importStartedAt = performance.now();
   const [{ readTopLevelLifecycleRecord, isLifecycleUnreadable }, { projectStoredTranscript }] = await Promise.all([
     import('./lifecycle-scan.mjs'),
     import('./store-transcript-projection.mjs'),
   ]);
+  const parseStartedAt = performance.now();
   const record = readTopLevelLifecycleRecord(text);
   if (isLifecycleUnreadable(record) || record.id !== sessionId) return { unreadable: true };
+  const projectStartedAt = performance.now();
   const value = await projectStoredTranscript(sessionId, record.doc, {
     itemLimit,
     includeMessages: false,
     checkpointAbsent: true,
   });
-  return { value, lifecycle: { id: record.id, closed: record.closed, generation: record.generation } };
+  const timing = {
+    importMs: parseStartedAt - importStartedAt,
+    parseMs: projectStartedAt - parseStartedAt,
+    projectMs: performance.now() - projectStartedAt,
+  };
+  return { value, lifecycle: { id: record.id, closed: record.closed, generation: record.generation }, timing };
 }
 
 if (!isMainThread && workerData?.kind === WORKER_KIND) serveWorkerRequests(project);

package/src/runtime/agent/orchestrator/tools/builtin/runtime-capabilities.mjs

@@ -1,51 +1,9 @@
-import { accessSync, constants as fsConstants, readdirSync, readFileSync, statSync } from 'node:fs';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { readdir as readdirAsync } from 'node:fs/promises';
 import { runGitOffThread } from '../../../../shared/git-runner.mjs';
-import {
-  delimiter as pathDelimiter,
-  dirname as pathDirname,
-  join as pathJoin,
-  resolve as pathResolveAbsolute,
-} 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`];
-}
-
-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;
-}
+import { findPathExecutable } from '../../../../shared/path-executable.mjs';
+import { dirname as pathDirname, join as pathJoin, resolve as pathResolveAbsolute } from 'node:path';
 
 // Startup shell-tool line. An earlier inventory was dropped because it was
 // measured in this process's PATH while commands run under the login-shell

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

@@ -53,7 +53,6 @@ async function loadConfig() {
     return applyDefaults({
       ...DEFAULT_CONFIG,
       ...raw,
-      channelId: '',
       access: {
         ...DEFAULT_ACCESS,
         ...(raw.access || {}),

package/src/runtime/channels/lib/owned-runtime/config-reload.mjs

@@ -26,7 +26,7 @@ export function createConfigReloader({
     // startAutomationRuntime() is already past its automationRunning guard, so
     // nobody would call scheduler.start() again and every saved/edited schedule
     // stayed silently disarmed until the daemon restarted.
-    scheduler.reloadConfig(getConfig().nonInteractive ?? [], getConfig().interactive ?? [], getConfig().channelId, {
+    scheduler.reloadConfig(getConfig().nonInteractive ?? [], getConfig().interactive ?? [], {
       restart: state.automationRunning || getBridgeRuntimeConnected(),
     });
   }

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;
+}