mixdog 0.9.52 → 0.9.53

package/src/runtime/shared/memory-snapshot.mjs

@@ -0,0 +1,236 @@
+import { execFile } from 'node:child_process';
+import {
+  closeSync,
+  existsSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+  writeSync,
+} from 'node:fs';
+import { freemem, totalmem } from 'node:os';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { withFileLockSync } from './atomic-file.mjs';
+import { resolvePluginData } from './plugin-paths.mjs';
+
+const execFileAsync = promisify(execFile);
+export const MEMORY_PRESSURE_SNAPSHOT_MAX_BYTES = 64 * 1024;
+const SNAPSHOT_NAME = 'memory-pressure.jsonl';
+const SNAPSHOT_INTERVAL_MS = 10 * 60 * 1000;
+const SNAPSHOT_RATE_LIMIT_MS = 60 * 1000;
+const SNAPSHOT_LOCK_TIMEOUT_MS = 2000;
+const SNAPSHOT_LOCK_STALE_MS = 10000;
+
+let periodicTimer = null;
+let lastPressureSnapshotAt = 0;
+
+function enabled() {
+  return process.env.MIXDOG_MEMORY_SNAPSHOT !== '0';
+}
+
+function snapshotPaths() {
+  const directory = join(resolvePluginData(), 'diagnostics');
+  const snapshot = join(directory, SNAPSHOT_NAME);
+  return {
+    directory,
+    snapshot,
+    previousSnapshot: `${snapshot}.1`,
+    lock: join(directory, 'memory-pressure.lock'),
+  };
+}
+
+function memoryUsage() {
+  try {
+    return process.memoryUsage();
+  } catch {
+    return {};
+  }
+}
+
+function systemMemory() {
+  try {
+    return { freeMemoryBytes: freemem(), totalMemoryBytes: totalmem() };
+  } catch {
+    return {};
+  }
+}
+
+function rotateSnapshot(paths) {
+  const size = Number(statSync(paths.snapshot).size) || 0;
+  try { unlinkSync(paths.previousSnapshot); } catch {}
+  if (size <= MEMORY_PRESSURE_SNAPSHOT_MAX_BYTES) {
+    renameSync(paths.snapshot, paths.previousSnapshot);
+    return;
+  }
+  writeFileSync(paths.previousSnapshot, '', { mode: 0o600 });
+  unlinkSync(paths.snapshot);
+}
+
+function appendSnapshot(entry) {
+  const line = `${JSON.stringify(entry)}\n`;
+  if (Buffer.byteLength(line) > MEMORY_PRESSURE_SNAPSHOT_MAX_BYTES) return false;
+  const paths = snapshotPaths();
+  try {
+    mkdirSync(paths.directory, { recursive: true, mode: 0o700 });
+    return withFileLockSync(paths.lock, () => {
+      if (existsSync(paths.previousSnapshot)
+        && statSync(paths.previousSnapshot).size > MEMORY_PRESSURE_SNAPSHOT_MAX_BYTES) {
+        writeFileSync(paths.previousSnapshot, '', { mode: 0o600 });
+      }
+      if (existsSync(paths.snapshot)
+        && statSync(paths.snapshot).size + Buffer.byteLength(line) > MEMORY_PRESSURE_SNAPSHOT_MAX_BYTES) {
+        rotateSnapshot(paths);
+      }
+      const fd = openSync(paths.snapshot, 'a', 0o600);
+      try {
+        writeSync(fd, line, null, 'utf8');
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
+      }
+      return statSync(paths.snapshot).size <= MEMORY_PRESSURE_SNAPSHOT_MAX_BYTES;
+    }, {
+      timeoutMs: SNAPSHOT_LOCK_TIMEOUT_MS,
+      staleMs: SNAPSHOT_LOCK_STALE_MS,
+    });
+  } catch {
+    return false;
+  }
+}
+
+function workingSetMb(bytes) {
+  return Math.round((Number(bytes) / (1024 * 1024)) * 10) / 10;
+}
+
+function nullableProcessText(value) {
+  if (typeof value !== 'string') return null;
+  if (!value.trim()) return null;
+  return value.length > 200 ? value.slice(0, 200) : value;
+}
+
+function nullablePid(value) {
+  if ((typeof value !== 'number' && typeof value !== 'string')
+    || (typeof value === 'string' && !value.trim())) return null;
+  const pid = Number(value);
+  return Number.isInteger(pid) ? pid : null;
+}
+
+function parseWindowsProcesses(stdout) {
+  const rows = JSON.parse(String(stdout).trim() || '[]');
+  return (Array.isArray(rows) ? rows : [rows])
+    .map((row) => ({
+      name: String(row?.Name || ''),
+      pid: Number(row?.ProcessId),
+      workingSetMb: workingSetMb(row?.WorkingSetSize),
+      commandLine: nullableProcessText(row?.CommandLine),
+      parentPid: nullablePid(row?.ParentProcessId),
+    }))
+    .filter((row) => row.name && Number.isInteger(row.pid) && Number.isFinite(row.workingSetMb))
+    .slice(0, 8);
+}
+
+function parsePosixProcesses(stdout) {
+  return String(stdout).split(/\r?\n/)
+    .map((line) => {
+      const match = line.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*?)\s+(\d+)\s*$/);
+      if (!match) return null;
+      return {
+        pid: Number(match[1]),
+        parentPid: nullablePid(match[2]),
+        name: match[3],
+        commandLine: nullableProcessText(match[4]),
+        workingSetMb: workingSetMb(Number(match[5]) * 1024),
+      };
+    })
+    .filter((row) => row && Number.isInteger(row.pid) && Number.isFinite(row.workingSetMb))
+    .sort((left, right) => right.workingSetMb - left.workingSetMb)
+    .slice(0, 8);
+}
+
+async function topProcesses() {
+  try {
+    if (process.platform === 'win32') {
+      const { stdout } = await execFileAsync('powershell.exe', [
+        '-NoProfile', '-NonInteractive', '-Command',
+        'Get-CimInstance Win32_Process | Sort-Object WorkingSetSize -Descending | Select-Object -First 8 ProcessId,Name,WorkingSetSize,CommandLine,ParentProcessId | ConvertTo-Json -Compress',
+      ], {
+        encoding: 'utf8',
+        timeout: 3000,
+        windowsHide: true,
+      });
+      return parseWindowsProcesses(stdout);
+    }
+    const { stdout } = await execFileAsync('ps', ['-eo', 'pid=,ppid=,comm=,args=,rss='], {
+      encoding: 'utf8',
+      timeout: 3000,
+      windowsHide: true,
+    });
+    return parsePosixProcesses(stdout);
+  } catch {
+    return null;
+  }
+}
+
+function baseSnapshot(reason) {
+  return {
+    timestamp: new Date().toISOString(),
+    pid: process.pid,
+    reason,
+    memoryUsage: memoryUsage(),
+    systemMemory: systemMemory(),
+  };
+}
+
+/**
+ * Collect a full attribution snapshot. Process enumeration failures are
+ * intentionally omitted from the record, rather than surfacing to callers.
+ */
+export async function captureMemoryPressureSnapshot(reason = 'memory-pressure') {
+  if (!enabled()) return false;
+  const entry = baseSnapshot(reason);
+  const processes = await topProcesses();
+  if (processes) entry.topProcesses = processes;
+  return appendSnapshot(entry);
+}
+
+function capturePeriodicMemorySnapshot() {
+  if (!enabled()) return false;
+  return appendSnapshot(baseSnapshot('periodic'));
+}
+
+/**
+ * Schedules one full snapshot without work on the admission path. This
+ * process-wide limiter deliberately reserves the interval before scheduling.
+ */
+export function requestMemoryPressureSnapshot(reason) {
+  try {
+    if (!enabled()) return false;
+    const now = Date.now();
+    if (now - lastPressureSnapshotAt < SNAPSHOT_RATE_LIMIT_MS) return false;
+    lastPressureSnapshotAt = now;
+    const immediate = setImmediate(() => {
+      void captureMemoryPressureSnapshot(reason).catch(() => {});
+    });
+    immediate.unref?.();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function armMemoryPressureSampling() {
+  if (!enabled() || periodicTimer) return false;
+  periodicTimer = setInterval(() => { capturePeriodicMemorySnapshot(); }, SNAPSHOT_INTERVAL_MS);
+  periodicTimer.unref?.();
+  return true;
+}
+
+export function memoryPressureSnapshotPath() {
+  return snapshotPaths().snapshot;
+}
+
+armMemoryPressureSampling();

package/src/runtime/shared/process-lifecycle.mjs

@@ -28,6 +28,7 @@ const REPORT_NAME = 'mixdog-node-report.json';
 const LEDGER_LOCK_NAME = 'process-lifecycle.lock';
 const LEDGER_LOCK_TIMEOUT_MS = 2000;
 const LEDGER_LOCK_STALE_MS = 10000;
+const IDENTITY_UPGRADE_DELAYS_MS = [1000, 9000, 20000];
 const STATE_KEY = Symbol.for('mixdog.processLifecycle.v1');
 const VALID_REASONS = new Set([
   'process-start',
@@ -119,9 +120,36 @@ function appendEntry(active, entry) {
 }
 
 function currentProcessIdentity() {
+  if (process.platform !== 'linux') {
+    const value = Math.floor((Date.now() - (process.uptime() * 1000)) / 1000);
+    return Number.isSafeInteger(value) && value > 0
+      ? { kind: 'start-seconds', value, method: 'uptime' }
+      : null;
+  }
   return processIdentityForPid(process.pid);
 }
 
+function windowsProcessIdentities(pids) {
+  const identities = new Map();
+  if (pids.length === 0) return identities;
+  try {
+    const out = execFileSync('powershell.exe', [
+      '-NoProfile', '-NonInteractive', '-Command',
+      `$ErrorActionPreference='SilentlyContinue'; Get-Process -Id @(${pids.join(',')}) | ForEach-Object { try { "$($_.Id):$(([DateTimeOffset]$_.StartTime).ToUnixTimeSeconds())" } catch {} }`,
+    ], { encoding: 'utf8', timeout: 2000, windowsHide: true });
+    for (const line of String(out).split(/\r?\n/)) {
+      const match = /^(\d+):(\d+)$/.exec(line.trim());
+      if (!match) continue;
+      const pid = Number(match[1]);
+      const value = Number(match[2]);
+      if (Number.isSafeInteger(pid) && Number.isSafeInteger(value) && value > 0) {
+        identities.set(pid, { kind: 'start-seconds', value, method: 'powershell' });
+      }
+    }
+  } catch {}
+  return identities;
+}
+
 function processIdentityForPid(pid) {
   if (process.platform === 'linux') {
     try {
@@ -136,13 +164,7 @@ function processIdentityForPid(pid) {
   }
   try {
     if (process.platform === 'win32') {
-      const out = execFileSync('powershell.exe', [
-        '-NoProfile', '-NonInteractive', '-Command',
-        `([DateTimeOffset](Get-Process -Id ${pid} -ErrorAction Stop).StartTime).ToUnixTimeSeconds()`,
-      ], { encoding: 'utf8', timeout: 2000, windowsHide: true });
-      const text = String(out).trim();
-      const value = /^\d+$/.test(text) ? Number(text) : NaN;
-      return Number.isSafeInteger(value) ? { kind: 'start-seconds', value } : null;
+      return windowsProcessIdentities([pid]).get(pid) || null;
     }
     const out = execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
       encoding: 'utf8',
@@ -150,12 +172,30 @@ function processIdentityForPid(pid) {
       windowsHide: true,
     });
     const value = Math.floor(Date.parse(String(out).trim()) / 1000);
-    return Number.isInteger(value) ? { kind: 'start-seconds', value } : null;
+    return Number.isInteger(value) ? { kind: 'start-seconds', value, method: 'ps' } : null;
   } catch {
     return null;
   }
 }
 
+function processIdentitiesForPids(pids) {
+  const unique = [...new Set(pids)];
+  if (process.platform !== 'win32') {
+    return new Map(unique.map((pid) => [pid, processIdentityForPid(pid)]));
+  }
+
+  const identities = new Map();
+  const otherPids = [];
+  for (const pid of unique) {
+    if (pid === process.pid) identities.set(pid, currentProcessIdentity());
+    else otherPids.push(pid);
+  }
+  for (const [pid, identity] of windowsProcessIdentities(otherPids)) {
+    identities.set(pid, identity);
+  }
+  return identities;
+}
+
 function sameProcessIdentity(expected, observed) {
   if (!expected || !observed || expected.kind !== observed.kind) return null;
   if (expected.kind === 'linux-start-ticks') {
@@ -166,7 +206,10 @@ function sameProcessIdentity(expected, observed) {
   if (expected.kind === 'start-seconds') {
     if (!Number.isSafeInteger(expected.value) || expected.value < 1
       || !Number.isSafeInteger(observed.value) || observed.value < 1) return null;
-    return expected.value === observed.value;
+    const crossMethod = expected.method === 'uptime' || observed.method === 'uptime';
+    return crossMethod
+      ? Math.abs(expected.value - observed.value) <= 2
+      : expected.value === observed.value;
   }
   return null;
 }
@@ -237,6 +280,28 @@ function writeMarker(active) {
   }
 }
 
+function scheduleProcessIdentityUpgrade(active) {
+  if (active.processIdentity?.method !== 'uptime') return;
+  const scheduleAttempt = (attempt) => {
+    if (attempt >= IDENTITY_UPGRADE_DELAYS_MS.length) return;
+    const timer = setTimeout(() => {
+      try {
+        if (sharedState().active !== active || !markerOwned(active)) return;
+        const processIdentity = processIdentityForPid(process.pid);
+        if (processIdentity && processIdentity.method !== 'uptime') {
+          const previousIdentity = active.processIdentity;
+          active.processIdentity = processIdentity;
+          if (writeMarker(active)) return;
+          active.processIdentity = previousIdentity;
+        }
+      } catch {}
+      scheduleAttempt(attempt + 1);
+    }, IDENTITY_UPGRADE_DELAYS_MS[attempt]);
+    timer.unref?.();
+  };
+  scheduleAttempt(0);
+}
+
 function reapVanishedMarkers(active) {
   const candidates = [];
   try {
@@ -247,20 +312,27 @@ function reapVanishedMarkers(active) {
     }
   } catch {}
   if (existsSync(active.legacyMarker)) candidates.push(active.legacyMarker);
+  const occupied = [];
   for (const markerPath of candidates) {
     try {
       const previous = JSON.parse(readFileSync(markerPath, 'utf8'));
-      const liveness = pidLiveness(previous?.pid);
-      let vanished = liveness === 'dead';
-      if (liveness === 'occupied') {
-        const identityMatch = sameProcessIdentity(
-          previous.processIdentity,
-          processIdentityForPid(previous.pid),
-        );
-        vanished = identityMatch === false;
+      if (previous?.pid === process.pid && previous?.token !== active.token) {
+        if (recordPriorVanished(active, previous)) unlinkSync(markerPath);
+        continue;
       }
-      if (!vanished) continue;
-      if (recordPriorVanished(active, previous)) unlinkSync(markerPath);
+      const liveness = pidLiveness(previous?.pid);
+      if (liveness === 'occupied') occupied.push({ markerPath, previous });
+      else if (liveness === 'dead' && recordPriorVanished(active, previous)) unlinkSync(markerPath);
+    } catch {}
+  }
+  const identities = processIdentitiesForPids(occupied.map(({ previous }) => previous.pid));
+  for (const { markerPath, previous } of occupied) {
+    try {
+      const identityMatch = sameProcessIdentity(
+        previous.processIdentity,
+        identities.get(previous.pid) || null,
+      );
+      if (identityMatch === false && recordPriorVanished(active, previous)) unlinkSync(markerPath);
     } catch {}
   }
 }
@@ -307,6 +379,7 @@ export function beginProcessLifecycle({
   reapVanishedMarkers(active);
   writeMarker(active);
   recordCurrent('process-start');
+  scheduleProcessIdentityUpgrade(active);
   if (configureReports && safeCommandLine) {
     try { unlinkSync(`${active.report}.1`); } catch {}
     try { renameSync(active.report, `${active.report}.1`); } catch {}

package/src/runtime/shared/process-shutdown.mjs

@@ -57,6 +57,7 @@ export function installProcessSignalCleanup({
   beforeCleanup,
   cleanup,
   afterCleanup,
+  restoreTerminal,
   log = writeStderr,
 } = {}) {
   let installed = true;
@@ -71,6 +72,7 @@ export function installProcessSignalCleanup({
   };
 
   const hardExit = (code) => {
+    try { restoreTerminal?.('forced-cleanup', { code }); } catch {}
     finishProcessLifecycle('forced-cleanup', code);
     try { process.exit(code); } catch {}
   };
@@ -148,9 +150,13 @@ export function installProcessSignalCleanup({
 
   if (fatal) {
     add('uncaughtException', (error) => {
+      // Run terminal restoration synchronously, before the async cleanup path
+      // or its hard-exit fallback can be interrupted by another fatal error.
+      try { restoreTerminal?.('uncaughtException', { code: 1, error }); } catch {}
       void run('uncaughtException', { code: 1, shouldExit: exit, error });
     });
     add('unhandledRejection', (error) => {
+      try { restoreTerminal?.('unhandledRejection', { code: 1, error }); } catch {}
       void run('unhandledRejection', { code: 1, shouldExit: exit, error });
     });
   }

package/src/runtime/shared/resource-admission.mjs

@@ -1,5 +1,6 @@
 import { freemem, totalmem } from 'node:os';
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { requestMemoryPressureSnapshot } from './memory-snapshot.mjs';
 
 const MB = 1024 * 1024;
 
@@ -100,16 +101,20 @@ export class ResourceAdmissionController {
     const rssMb = Number(sample.rssBytes) / MB;
     const freeMb = Number(sample.freeMemoryBytes) / MB;
     if (this.limits.maxRssMb > 0 && Number.isFinite(rssMb) && rssMb >= this.limits.maxRssMb) {
-      return new ResourcePressureError(
+      const error = new ResourcePressureError(
         `Mixdog RSS ${Math.ceil(rssMb)} MB reached ${this.limits.maxRssMb} MB limit; retry after memory recovers`,
         { kind, rssMb, limitMb: this.limits.maxRssMb, metric: 'rss' },
       );
+      requestMemoryPressureSnapshot(error.message);
+      return error;
     }
     if (this.limits.minFreeMemoryMb > 0 && Number.isFinite(freeMb) && freeMb < this.limits.minFreeMemoryMb) {
-      return new ResourcePressureError(
+      const error = new ResourcePressureError(
         `host free memory ${Math.floor(freeMb)} MB is below ${this.limits.minFreeMemoryMb} MB minimum; retry after memory recovers`,
         { kind, freeMb, limitMb: this.limits.minFreeMemoryMb, metric: 'free-memory' },
       );
+      requestMemoryPressureSnapshot(error.message);
+      return error;
     }
     return null;
   }

package/src/session-runtime/channel-config-api.mjs

@@ -2,12 +2,12 @@ import {
   channelSetup,
   deleteSchedule,
   deleteWebhook,
-  setChannel,
+  setChannelAsync,
   saveSchedule,
   saveWebhook,
   setScheduleEnabled,
   setWebhookEnabled,
-  setWebhookConfig,
+  setWebhookConfigAsync,
 } from '../standalone/channel-admin.mjs';
 
 // Channel/webhook/schedule config surface. Extracted verbatim from the runtime
@@ -20,19 +20,19 @@ export function createChannelConfigApi({ flushBackendSave, channels, reloadChann
       // Flush a pending debounced backend switch first so setup readers
       // (Settings → Channel Setting, remote toggles) never observe the
       // previous backend during the 150ms debounce window.
-      try { flushBackendSave(); } catch {}
+      try { await flushBackendSave(); } catch {}
       return channelSetup();
     },
     getChannelWorkerStatus() {
       return channels.status();
     },
-    setChannel(entry) {
-      const result = setChannel(entry);
+    async setChannel(entry) {
+      const result = await setChannelAsync(entry);
       reloadChannelsSoon();
       return result;
     },
-    setWebhookConfig(patch) {
-      const result = setWebhookConfig(patch);
+    async setWebhookConfig(patch) {
+      const result = await setWebhookConfigAsync(patch);
       reloadChannelsSoon();
       return result;
     },

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

@@ -30,7 +30,6 @@ export function createConfigLifecycle({
   // shared modules / helpers
   cfgMod,
   sharedCfgMod,
-  setBackend,
   setBackendAsync,
   setConfiguredShell,
   normalizeSystemShellConfig,
@@ -218,21 +217,6 @@ export function createConfigLifecycle({
     return p;
   }
 
-  function flushBackendSave() {
-    if (backendSaveTimer) {
-      clearTimeout(backendSaveTimer);
-      backendSaveTimer = null;
-    }
-    if (pendingBackendName === null) return;
-    const name = pendingBackendName;
-    pendingBackendName = null;
-    try {
-      setBackend(name);
-    } catch (err) {
-      process.stderr.write(`[channels] debounced setBackend failed: ${err?.message || err}\n`);
-    }
-  }
-
   function scheduleBackendSave(name) {
     pendingBackendName = name;
     if (backendSaveTimer) clearTimeout(backendSaveTimer);
@@ -335,6 +319,21 @@ export function createConfigLifecycle({
     return p;
   }
 
+  // Teardown barrier for every in-process writer that can hold the shared
+  // mixdog-config lock. Start/drain all debounce channels through their async
+  // variants, then resolve only when every promise tail (including skills,
+  // which config flushes after its whole-section write) has settled.
+  async function flushAllConfigSavesAsync() {
+    await Promise.all([
+      flushConfigSaveAsync(),
+      flushBackendSaveAsync(),
+      flushOutputStyleSaveAsync(),
+    ]);
+    // The shared config layer also tracks writes started directly by channel,
+    // webhook, voice, Discord access, and future async RMW callers.
+    await sharedCfgMod.pendingConfigWrites();
+  }
+
   function flushOutputStyleSave() {
     if (outputStyleSaveTimer) {
       clearTimeout(outputStyleSaveTimer);
@@ -418,12 +417,16 @@ export function createConfigLifecycle({
     adoptConfig,
     saveConfigAndAdopt,
     flushConfigSave,
-    flushBackendSave,
+    // Every lifecycle flush uses the async lock path. A synchronous waiter on
+    // the same lock would block the event loop needed by an in-flight async
+    // writer, so callers must await this before a dependent read/start.
+    flushBackendSave: flushBackendSaveAsync,
     scheduleBackendSave,
     flushSkillsSave,
     scheduleSkillsSave,
     flushOutputStyleSave,
     scheduleOutputStyleSave,
+    flushAllConfigSavesAsync,
     // reload / ensure
     reloadFullConfig,
     ensureFullConfig,

package/src/session-runtime/cwd-plugins.mjs

@@ -96,7 +96,7 @@ export function createCwdPlugins({
     return next;
   }
 
-  function applyResolvedCwd(nextCwd, { markRefresh = true } = {}) {
+  function applyResolvedCwd(nextCwd, { markRefresh = true, waitForMcpReset = false } = {}) {
     const resolved = resolve(nextCwd);
     const stat = statSync(resolved);
     if (!stat.isDirectory()) throw new Error(`cwd: not a directory: ${resolved}`);
@@ -125,16 +125,16 @@ export function createCwdPlugins({
       const delay = getCodeGraphPrewarmDelayMs();
       scheduleCodeGraphPrewarm(changed ? 0 : delay, changed ? 'cwd-change' : 'cwd');
     }
-    // Project-local `.mcp.json` follows the cwd: when the effective project MCP
-    // set changes, reconnect in the background (never await — this stays sync,
-    // and the session is preserved). Guarded so a no-op cwd change does not
-    // churn connections.
+    // Project-local `.mcp.json` follows the cwd. Ordinary in-session cwd changes
+    // reconnect in the background, while desktop context replacement requests
+    // an awaitable reset so the next session/turn cannot observe the old registry.
+    let mcpReset = null;
     if (changed) {
       try {
         const nextKey = resolved + '\u0000' + JSON.stringify(readProjectMcpServers(resolved));
         if (nextKey !== getLastProjectMcpKey()) {
           setLastProjectMcpKey(nextKey);
-          void connectConfiguredMcp({ reset: true })
+          mcpReset = Promise.resolve(connectConfiguredMcp({ reset: true }))
             .then(() => invalidatePreSessionToolSurface())
             .catch(() => {});
         }
@@ -145,7 +145,9 @@ export function createCwdPlugins({
     if (changed) {
       try { void hooks.dispatch('CwdChanged', hookCommonPayload({ cwd: currentCwd })); } catch {}
     }
-    return currentCwd;
+    return waitForMcpReset
+      ? Promise.resolve(mcpReset).then(() => currentCwd)
+      : currentCwd;
   }
 
   async function refreshSessionForCwdIfNeeded(reason = 'cwd-change') {

package/src/session-runtime/env.mjs

@@ -1,5 +1,4 @@
-// Environment-variable coercion helpers shared by the session runtime.
-// Extracted verbatim from mixdog-session-runtime.mjs during the facade split.
+// Environment-variable coercion helpers shared by session-runtime modules.
 export function envFlag(name) {
   return /^(1|true|yes|on)$/i.test(String(process.env[name] || ''));
 }

package/src/session-runtime/hitch-profile.mjs

@@ -0,0 +1,45 @@
+import { monitorEventLoopDelay } from 'node:perf_hooks';
+import { envFlag } from './env.mjs';
+
+const HITCH_PROFILE_ENABLED = envFlag('MIXDOG_HITCH_PROFILE');
+
+function positiveNumberEnv(name, fallback) {
+  const value = Number(process.env[name]);
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+// The histogram and sampling timer are never constructed unless explicitly
+// enabled, leaving the normal runtime with no event-loop profiling work.
+export function installHitchProfiler() {
+  if (!HITCH_PROFILE_ENABLED) return null;
+
+  const thresholdMs = positiveNumberEnv('MIXDOG_HITCH_THRESHOLD_MS', 100);
+  const resolutionMs = Math.max(1, Math.min(100, positiveNumberEnv('MIXDOG_HITCH_RESOLUTION_MS', 20)));
+  const sampleMs = Math.max(resolutionMs * 2, positiveNumberEnv('MIXDOG_HITCH_SAMPLE_MS', 100));
+  const histogram = monitorEventLoopDelay({ resolution: resolutionMs });
+  histogram.enable();
+  let lastSampleAt = performance.now();
+
+  const timer = setInterval(() => {
+    const now = performance.now();
+    // Histogram max is the primary signal. Timer drift covers a stall ending
+    // in the same timers phase before the histogram's internal sampler runs.
+    const delayMs = Math.max(histogram.max / 1e6, now - lastSampleAt - sampleMs);
+    lastSampleAt = now;
+    histogram.reset();
+    if (delayMs < thresholdMs) return;
+    try {
+      process.stderr.write(
+        `[mixdog-hitch] timestamp=${new Date().toISOString()} delayMs=${delayMs.toFixed(1)} thresholdMs=${thresholdMs}\n`,
+      );
+    } catch {}
+  }, sampleMs);
+  timer.unref?.();
+
+  return () => {
+    clearInterval(timer);
+    histogram.disable();
+  };
+}
+
+installHitchProfiler();