mixdog 0.9.97 → 0.9.99

package/src/runtime/channels/lib/interaction-handlers.mjs

@@ -1,12 +1,6 @@
-import * as fs from "fs";
-import * as path from "path";
-// Discord permission-prompt + interaction/modal routing extracted from
-// channels/index.mjs (behavior-preserving). Installs provider.onInteraction /
-// onModalRequest handlers and the terminal tool-exec signal watcher; returns the
-// pending-permission map + marker refresher for the worker IPC handler.
+// Discord interaction/modal routing extracted from channels/index.mjs.
 export function createInteractionHandlers({
   getProvider,
-  getConfig,
   getBridgeRuntimeConnected,
   instanceId,
   getBridgeOwnershipSnapshot,
@@ -14,33 +8,12 @@ export function createInteractionHandlers({
   pendingSetup,
   buildModalRequestSpec,
   loadProfileConfig,
-  getDiscordToken,
   sendNotifyToParent,
   scheduler,
   controlClaudeSession,
   writeTextFile,
   TURN_END_FILE,
-  getPermissionResultPath,
-  TERMINAL_LEAD_PID,
-  localTimestamp,
-  isMixdogDebug,
-  appendSessionStartCriticalLog,
-  DATA_DIR,
-  _bootLog,
-  RUNTIME_ROOT,
 }) {
-function editDiscordMessage(channelId, messageId, label) {
-  // Behavior-preserving: route through the getProvider() abstraction (which uses
-  // discord.js under the hood) instead of issuing a raw REST PATCH. Errors
-  // are swallowed to stderr to match the prior fire-and-forget shape — the
-  // call site never awaited the HTTPS request either.
-  if (!getDiscordToken()) return;
-  const text = `\u{1F510} **Permission Request** \u2014 ${label}`;
-  void getProvider().editMessage(channelId, messageId, text, { components: [] }).catch((err) => {
-    process.stderr.write(`mixdog: editDiscordMessage failed: ${err}
-`);
-  });
-}
 getProvider().onModalRequest = async (rawInteraction) => {
   if (!getBridgeRuntimeConnected() || !getBridgeOwnershipSnapshot().owned) {
     refreshBridgeOwnershipSafe();
@@ -67,170 +40,8 @@ getProvider().onModalRequest = async (rawInteraction) => {
   modal.addComponents(...rows);
   await rawInteraction.showModal(modal);
 };
-const pendingPermRequests = new Map();
-const TOOL_EXEC_CONSUMER_MARKER = path.join(RUNTIME_ROOT, '.tool-exec-consumer');
-function refreshToolExecConsumerMarker() {
-  try {
-    if (pendingPermRequests.size > 0) {
-      fs.writeFileSync(TOOL_EXEC_CONSUMER_MARKER, String(Date.now()));
-    } else {
-      try { fs.unlinkSync(TOOL_EXEC_CONSUMER_MARKER); } catch {}
-    }
-  } catch {}
-}
-// Watch for terminal-approved tool executions. The PostToolUse hook writes a
-// signal file per tool call; when we see one, find the oldest pending perm
-// request with a matching tool name and mark its Discord message as
-// "Allowed (terminal)" so users don't see stale active buttons.
-try {
-  try { if (!fs.existsSync(RUNTIME_ROOT)) fs.mkdirSync(RUNTIME_ROOT, { recursive: true }); } catch {}
-  const SIGNAL_RE = /^tool-exec-\d+-[0-9a-f]+\.signal$/;
-  fs.watch(RUNTIME_ROOT, { persistent: false }, (eventType, filename) => {
-    if (!filename || !SIGNAL_RE.test(filename)) return;
-    setTimeout(() => {
-      try {
-        const signalPath = path.join(RUNTIME_ROOT, filename);
-        let raw;
-        try { raw = fs.readFileSync(signalPath, 'utf8'); } catch { return; }
-        let payload;
-        try { payload = JSON.parse(raw); } catch { return; }
-        const toolName = payload?.toolName;
-        if (!toolName) return;
-        const sigFilePath = payload?.filePath || '';
-        let oldestKey = null;
-        let oldestEntry = null;
-        for (const [k, v] of pendingPermRequests) {
-          if (v.toolName !== toolName) continue;
-          // Bind on filePath too. If both sides are empty (non-file tools
-          // like Bash), toolName alone is the match. Otherwise both must
-          // equal — prevents two concurrent Edit/Write requests from
-          // cross-approving each other.
-          const vFilePath = v.filePath || '';
-          if (vFilePath || sigFilePath) {
-            if (vFilePath !== sigFilePath) continue;
-          }
-          if (!oldestEntry || v.createdAt < oldestEntry.createdAt) {
-            oldestKey = k;
-            oldestEntry = v;
-          }
-        }
-        // No matching pending request — leave the signal on disk so a
-        // agent role hook (or other consumer) gets a chance to claim it.
-        if (!oldestKey || !oldestEntry) return;
-        if (oldestEntry.channelId && oldestEntry.messageId) {
-          try {
-            editDiscordMessage(oldestEntry.channelId, oldestEntry.messageId, 'Allowed (terminal)');
-          } catch (err) {
-            try { process.stderr.write(`mixdog channels: tool-exec signal edit failed: ${err && err.message || err}\n`); } catch {}
-          }
-        }
-        pendingPermRequests.delete(oldestKey);
-        refreshToolExecConsumerMarker();
-        // Only unlink once we've confirmed the match and handled it.
-        try { fs.unlinkSync(signalPath); } catch {}
-      } catch (err) {
-        try { process.stderr.write(`mixdog channels: tool-exec signal handler error: ${err && err.message || err}\n`); } catch {}
-      }
-    }, 50);
-  });
-  // Stale-signal sweeper: any signal file older than 60s is removed so
-  // unclaimed files don't accumulate on disk. Runs every 30s.
-  setInterval(() => {
-    try {
-      const now = Date.now();
-      const entries = fs.readdirSync(RUNTIME_ROOT);
-      for (const name of entries) {
-        if (!SIGNAL_RE.test(name)) continue;
-        const p = path.join(RUNTIME_ROOT, name);
-        try {
-          const st = fs.statSync(p);
-          if (now - st.mtimeMs > 60_000) {
-            try { fs.unlinkSync(p); } catch {}
-          }
-        } catch {}
-      }
-    } catch {}
-  }, 30_000)?.unref?.();
-} catch (err) {
-  try { process.stderr.write(`mixdog channels: tool-exec signal watcher setup failed: ${err && err.message || err}\n`); } catch {}
-}
 
 getProvider().onInteraction = (interaction) => {
-  // Channel-route permission reply. Custom_id format: perm-ch-{request_id}-{allow|session|deny}.
-  // request_id is the 5-letter short ID CC generates via shortRequestId().
-  // Emit notifications/claude/channel/permission back to the MCP host; the race
-  // logic in interactiveHandler.ts resolves the pending request and dismisses
-  // every other racer (local dialog, bridge, hook, classifier).
-  if (interaction.customId?.startsWith("perm-ch-")) {
-    const match = interaction.customId.match(/^perm-ch-([a-km-z]{5})-(allow|session|deny)$/);
-    if (!match) return;
-    const [, requestId, action] = match;
-    const access = getConfig().access;
-    if (access?.allowFrom?.length > 0 && !access.allowFrom.includes(interaction.userId)) {
-      process.stderr.write(`mixdog: perm-ch button rejected — user ${interaction.userId} not in allowFrom\n`);
-      return;
-    }
-    const pending = pendingPermRequests.get(requestId);
-    pendingPermRequests.delete(requestId);
-    refreshToolExecConsumerMarker();
-    const params = { request_id: requestId };
-    if (action === 'deny') {
-      params.behavior = 'deny';
-    } else if (action === 'session') {
-      params.behavior = 'allow';
-      const toolName = pending?.toolName;
-      if (toolName) {
-        params.updatedPermissions = [{ type: 'addRules', rules: [{ toolName }], behavior: 'allow', destination: 'session' }];
-      }
-    } else {
-      params.behavior = 'allow';
-    }
-    sendNotifyToParent('notifications/claude/channel/permission', params);
-    const labels = { allow: 'Approved', session: 'Session Approved', deny: 'Denied' };
-    if (interaction.message?.id && interaction.channelId) {
-      editDiscordMessage(interaction.channelId, interaction.message.id, labels[action] || action);
-    }
-    return;
-  }
-  if (interaction.customId?.startsWith("perm-")) {
-    const match = interaction.customId.match(/^perm-([0-9a-f]{32})-(allow|session|deny)$/);
-    if (!match) return;
-    const [, uuid, action] = match;
-    const access = getConfig().access;
-    if (!access) {
-      const _permDropLine = `[${localTimestamp()}] perm interaction dropped: no access getConfig()\n`;
-      if (isMixdogDebug()) {
-        fs.appendFileSync(_bootLog, _permDropLine);
-      } else {
-        appendSessionStartCriticalLog(DATA_DIR, `[channels] ${_permDropLine}`);
-      }
-      return;
-    }
-    if (access.allowFrom?.length > 0 && !access.allowFrom.includes(interaction.userId)) {
-      process.stderr.write(`mixdog: perm button rejected \u2014 user ${interaction.userId} not in allowFrom
-`);
-      return;
-    }
-    const resultPaths = [getPermissionResultPath(instanceId, uuid)];
-    const leadInstanceId = String(TERMINAL_LEAD_PID);
-    if (leadInstanceId && leadInstanceId !== instanceId) {
-      resultPaths.push(getPermissionResultPath(leadInstanceId, uuid));
-    }
-    for (const resultPath of resultPaths) {
-      try {
-        fs.writeFileSync(resultPath, action, { flag: "wx" });
-      } catch (e) {
-        if (e.code !== "EEXIST") {
-          process.stderr.write(`mixdog: writePermissionResult failed: ${e.message}\n`);
-        }
-      }
-    }
-    const labels = { allow: "Approved", session: "Session Approved", deny: "Denied" };
-    if (interaction.message?.id && interaction.channelId) {
-      editDiscordMessage(interaction.channelId, interaction.message.id, labels[action] || action);
-    }
-    return;
-  }
   if (!getBridgeRuntimeConnected() || !getBridgeOwnershipSnapshot().owned) {
     refreshBridgeOwnershipSafe();
     return;
@@ -256,5 +67,4 @@ getProvider().onInteraction = (interaction) => {
     }
   });
 };
-  return { pendingPermRequests, refreshToolExecConsumerMarker };
 }

package/src/runtime/channels/lib/runtime-paths.mjs

@@ -117,9 +117,6 @@ function getControlPath(instanceId) {
 function getControlResponsePath(instanceId) {
   return join(RUNTIME_ROOT, `control-${sanitize(instanceId)}.response.json`);
 }
-function getPermissionResultPath(instanceId, uuid) {
-  return join(RUNTIME_ROOT, `perm-${sanitize(instanceId)}-${sanitize(uuid)}.result`);
-}
 function getStopFlagPath(instanceId) {
   return join(RUNTIME_ROOT, `stop-${sanitize(instanceId)}.flag`);
 }
@@ -424,6 +421,7 @@ function cleanupInstanceRuntimeFiles(instanceId) {
   for (const target of targets) {
     removeFileIfExists(target);
   }
+  // Remove artifacts left by pre-standalone Discord approval builds.
   forEachFile(RUNTIME_ROOT, (fullPath, file) => {
     if (file.startsWith(`perm-${sanitize(instanceId)}-`)) {
       removeFileIfExists(fullPath);
@@ -455,7 +453,6 @@ export {
   getChannelOwnerPath,
   getControlPath,
   getControlResponsePath,
-  getPermissionResultPath,
   getTerminalLeadPid,
   getStatusPath,
   getTurnEndPath,

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

@@ -14,8 +14,6 @@ export function runWorkerIpc({
   statusState,
   getProvider,
   getConfig,
-  pendingPermRequests,
-  refreshToolExecConsumerMarker,
   handleMemoryCallResponse,
   handleToolCallWithBridgeRetry,
   bootProfile,
@@ -84,70 +82,6 @@ export function runWorkerIpc({
       } catch { /* best-effort */ }
       return;
     }
-    // Host permission request → Discord Allow/Deny prompt.
-    // Parent (server.mjs) receives notifications/claude/channel/permission_request
-    // from the MCP host and forwards the params here. We post a buttoned message;
-    // button clicks are handled in getProvider().onInteraction and sent back to CC as
-    // notifications/claude/channel/permission via sendNotifyToParent.
-    if (msg && msg.type === 'permission_request_inbound') {
-      try {
-        const { request_id, tool_name, description, input_preview } = msg.params || {};
-        // tool_input arrives via the passthrough() schema in server.mjs when
-        // The host includes it in the permission_request notification.
-        // Used to bind the pendingPermRequest to a specific file so two
-        // concurrent Edit/Write requests cannot cross-approve via the
-        // terminal signal.
-        const toolInputParam = (msg.params && (msg.params.tool_input || msg.params.toolInput)) || {};
-        const filePathParam = toolInputParam.file_path || '';
-        if (!request_id || !tool_name) return;
-        if (pendingPermRequests.size > 100) {
-          const cutoff = Date.now() - 30 * 60 * 1000;
-          for (const [k, v] of pendingPermRequests) {
-            if (v.createdAt < cutoff) pendingPermRequests.delete(k);
-          }
-          refreshToolExecConsumerMarker();
-        }
-        const target = (statusState?.read?.().channelId)
-          || getConfig()?.channelId
-          || null;
-        if (!target || !getProvider()?.sendMessage) {
-          process.stderr.write(`mixdog channels: permission_request dropped, no target channel (request_id=${request_id})\n`);
-          return;
-        }
-        const lines = [`🔐 **Permission Request**`, `Tool: \`${tool_name}\``];
-        if (description) lines.push(description);
-        if (input_preview) lines.push('```\n' + String(input_preview).slice(0, 800) + '\n```');
-        const content = lines.join('\n');
-        const components = [{
-          type: 1,
-          components: [
-            { type: 2, style: 3, label: 'Allow', custom_id: `perm-ch-${request_id}-allow` },
-            { type: 2, style: 1, label: 'Session Allow', custom_id: `perm-ch-${request_id}-session` },
-            { type: 2, style: 4, label: 'Deny', custom_id: `perm-ch-${request_id}-deny` },
-          ],
-        }];
-        let sentIds = null;
-        try {
-          const sendResult = await getProvider().sendMessage(target, content, { components });
-          sentIds = sendResult?.sentIds;
-        } catch (err) {
-          process.stderr.write(`mixdog channels: permission_request Discord send failed: ${err && err.message || err}\n`);
-          return;
-        }
-        const messageId = Array.isArray(sentIds) && sentIds.length > 0 ? sentIds[0] : null;
-        pendingPermRequests.set(request_id, {
-          toolName: tool_name,
-          filePath: filePathParam,
-          createdAt: Date.now(),
-          channelId: target,
-          messageId,
-        });
-        refreshToolExecConsumerMarker();
-      } catch (err) {
-        try { process.stderr.write(`mixdog channels: permission_request handler error: ${err && err.message || err}\n`); } catch {}
-      }
-      return;
-    }
     if (handleMemoryCallResponse(msg)) return;
     if (msg.type === 'cancel' && msg.callId) {
       const entry = _inFlightChannelCalls.get(msg.callId)

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

@@ -35,7 +35,6 @@ import {
   makeInstanceId,
   getTurnEndPath,
   getStatusPath,
-  getPermissionResultPath,
   getChannelOwnerPath,
   getActiveOwnerPid,
   getTerminalLeadPid,
@@ -51,7 +50,6 @@ import {
   clearServerPid,
   RUNTIME_ROOT
 } from "./runtime-paths.mjs";
-import { getDiscordToken } from "./config.mjs";
 import { invalidateConfigReadCache } from "../../shared/config.mjs";
 import { bootProfile, localTimestamp } from "./boot-profile.mjs";
 import {
@@ -125,7 +123,6 @@ const _bootLogEarly = path.join(
 const {
   isMixdogDebugEnabled: isMixdogDebug,
   pruneStalePluginDataLogSiblings,
-  appendSessionStartCriticalLog,
   DEFAULT_STALE_LOG_SIBLING_MAX,
 } = _require("../../../lib/mixdog-debug.cjs");
 // One-shot log rotation at worker boot (10 MB threshold, .1 suffix overwrite).
@@ -134,7 +131,6 @@ if (isMixdogDebug()) {
   fs.appendFileSync(_bootLogEarly, `[${localTimestamp()}] bootstrap start pid=${process.pid}
 `);
 }
-const _bootLog = path.join(DATA_DIR, "boot.log");
 let config = await loadConfig();
 let provider = createProvider(config);
 const INSTANCE_ID = makeInstanceId();
@@ -499,12 +495,8 @@ function wireEventQueueHandlers(eventQueue) {
   eventQueue.setOwnerGetter(() => bridgeRuntimeConnected && currentOwnerState().owned);
   forwarder.setOwnerGetter(() => bridgeRuntimeConnected && currentOwnerState().owned);
 }
-const {
-  pendingPermRequests,
-  refreshToolExecConsumerMarker,
-} = createInteractionHandlers({
+createInteractionHandlers({
   getProvider: () => provider,
-  getConfig: () => config,
   getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
   instanceId: INSTANCE_ID,
   getBridgeOwnershipSnapshot,
@@ -512,20 +504,11 @@ const {
   pendingSetup,
   buildModalRequestSpec,
   loadProfileConfig,
-  getDiscordToken,
   sendNotifyToParent,
   scheduler,
   controlClaudeSession,
   writeTextFile,
   TURN_END_FILE,
-  getPermissionResultPath,
-  TERMINAL_LEAD_PID,
-  localTimestamp,
-  isMixdogDebug,
-  appendSessionStartCriticalLog,
-  DATA_DIR,
-  _bootLog,
-  RUNTIME_ROOT,
 });
 const { isVoiceAttachment, transcribeVoice } = createVoiceTranscription({
   getConfig: () => config,
@@ -741,8 +724,6 @@ if (_isWorkerMode && process.send && process.env.MIXDOG_DAEMON_HOST !== '1') {
     statusState,
     getProvider: () => provider,
     getConfig: () => config,
-    pendingPermRequests,
-    refreshToolExecConsumerMarker,
     handleMemoryCallResponse,
     handleToolCallWithBridgeRetry,
     bootProfile,

package/src/runtime/memory/lib/http-wire.mjs

@@ -2,11 +2,41 @@
 // utilities with no module state — no db, _traceDb, or timer dependencies.
 // index.mjs imports these; behavior and signatures are unchanged.
 
-export function readBody(req) {
+export const MAX_HTTP_BODY_BYTES = 1024 * 1024
+
+export function readBody(req, { maxBytes = MAX_HTTP_BODY_BYTES } = {}) {
   return new Promise((resolve, reject) => {
-    const chunks = []
-    req.on('data', c => chunks.push(c))
+    const limit = Math.max(1, Number(maxBytes) || MAX_HTTP_BODY_BYTES)
+    const contentLength = Number(req.headers?.['content-length'] || 0)
+    let chunks = []
+    let total = 0
+    let settled = false
+    const rejectTooLarge = () => {
+      if (settled) return
+      settled = true
+      chunks = []
+      const error = new Error(`request body exceeds the ${limit} byte limit`)
+      error.statusCode = 413
+      reject(error)
+    }
+    if (Number.isFinite(contentLength) && contentLength > limit) {
+      req.resume?.()
+      rejectTooLarge()
+      return
+    }
+    req.on('data', c => {
+      if (settled) return
+      const chunk = Buffer.isBuffer(c) ? c : Buffer.from(c)
+      total += chunk.length
+      if (total > limit) {
+        rejectTooLarge()
+        return
+      }
+      chunks.push(chunk)
+    })
     req.on('end', () => {
+      if (settled) return
+      settled = true
       const raw = Buffer.concat(chunks).toString('utf8').trim()
       if (!raw) { resolve({}); return }
       try { resolve(JSON.parse(raw)) }
@@ -16,7 +46,12 @@ export function readBody(req) {
         reject(e)
       }
     })
-    req.on('error', reject)
+    req.on('error', error => {
+      if (settled) return
+      settled = true
+      chunks = []
+      reject(error)
+    })
   })
 }
 

package/src/runtime/shared/json-metrics.mjs

@@ -0,0 +1,94 @@
+import { createHash } from 'node:crypto';
+
+function escapedStringBytes(value) {
+  const text = String(value);
+  let bytes = Buffer.byteLength(text, 'utf8') + 2;
+  for (let index = 0; index < text.length; index += 1) {
+    const code = text.charCodeAt(index);
+    if (code === 0x22 || code === 0x5c || code === 0x08 || code === 0x0c
+      || code === 0x0a || code === 0x0d || code === 0x09) bytes += 1;
+    else if (code < 0x20) bytes += 5;
+  }
+  return bytes;
+}
+
+export function estimateJsonBytes(value, seen = new Set()) {
+  if (value === null) return 4;
+  if (typeof value === 'string') return escapedStringBytes(value);
+  if (typeof value === 'number') return Number.isFinite(value) ? String(value).length : 4;
+  if (typeof value === 'boolean') return value ? 4 : 5;
+  if (typeof value === 'bigint') return String(value).length;
+  if (value === undefined || typeof value === 'function' || typeof value === 'symbol') return 0;
+  if (seen.has(value)) return 0;
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      let bytes = 2;
+      for (let index = 0; index < value.length; index += 1) {
+        if (index > 0) bytes += 1;
+        bytes += estimateJsonBytes(value[index], seen);
+      }
+      return bytes;
+    }
+    let bytes = 2;
+    let first = true;
+    for (const [key, entry] of Object.entries(value)) {
+      if (entry === undefined || typeof entry === 'function' || typeof entry === 'symbol') continue;
+      if (!first) bytes += 1;
+      first = false;
+      bytes += escapedStringBytes(key) + 1 + estimateJsonBytes(entry, seen);
+    }
+    return bytes;
+  } finally {
+    seen.delete(value);
+  }
+}
+
+export function hashStructuredValue(value, {
+  algorithm = 'sha1',
+  maxStringChars = Infinity,
+} = {}) {
+  const hash = createHash(algorithm);
+  let remaining = Number.isFinite(maxStringChars) ? Math.max(0, maxStringChars) : Infinity;
+  const seen = new Set();
+  const walk = (entry) => {
+    if (remaining <= 0) return;
+    if (entry === null) { hash.update('n;'); return; }
+    const type = typeof entry;
+    if (type === 'string') {
+      const slice = remaining === Infinity ? entry : entry.slice(0, remaining);
+      hash.update('s:').update(slice).update(';');
+      if (remaining !== Infinity) remaining -= slice.length;
+      return;
+    }
+    if (type === 'number' || type === 'boolean' || type === 'bigint') {
+      hash.update(`${type[0]}:${String(entry)};`);
+      return;
+    }
+    if (type === 'undefined' || type === 'function' || type === 'symbol') {
+      hash.update('u;');
+      return;
+    }
+    if (seen.has(entry)) { hash.update('c;'); return; }
+    seen.add(entry);
+    try {
+      if (Array.isArray(entry)) {
+        hash.update('[');
+        for (const item of entry) walk(item);
+        hash.update(']');
+        return;
+      }
+      hash.update('{');
+      for (const [key, item] of Object.entries(entry)) {
+        hash.update('k:').update(key).update(';');
+        walk(item);
+        if (remaining <= 0) break;
+      }
+      hash.update('}');
+    } finally {
+      seen.delete(entry);
+    }
+  };
+  walk(value);
+  return hash.digest('hex');
+}

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

@@ -4,6 +4,7 @@ import {
   createTurnWorktreeSnapshot,
   refreshTurnWorktreeSnapshot,
   revertTurnWorktreeFile,
+  revertTurnWorktreeSnapshot,
 } from './turn-worktree-snapshot.mjs';
 
 // Turn-scoped review registry.
@@ -501,6 +502,18 @@ export async function revertTurnReviewFile(_worktree, sessionId, file) {
   return await getTurnReviewDiff(_worktree, ownerSessionId);
 }
 
+/** Restore every file in the reviewed turn to its turn-start state. */
+export async function revertTurnReview(_worktree, sessionId) {
+  const ownerSessionId = clean(sessionId);
+  const tracker = _diffTrackersBySession.get(ownerSessionId);
+  if (tracker?.worktreeContended) {
+    throw new Error('turn review revert is unavailable while sessions share a worktree');
+  }
+  if (!tracker?.worktreeSnapshot) throw new Error('turn worktree snapshot is unavailable');
+  await revertTurnWorktreeSnapshot(tracker.worktreeSnapshot);
+  return await getTurnReviewDiff(_worktree, ownerSessionId);
+}
+
 export function _resetTurnSnapshotForTest() {
   _turnsBySession.clear();
   _diffTrackersBySession.clear();

package/src/runtime/shared/turn-worktree-snapshot.mjs

@@ -547,6 +547,25 @@ export async function revertTurnWorktreeFile(snapshot, value) {
   });
 }
 
+export async function revertTurnWorktreeSnapshot(snapshot) {
+  if (!snapshot?.state || !snapshot.baselineTree) throw new Error('turn worktree snapshot is unavailable');
+  return await withStateLock(snapshot.state, async () => {
+    // Resolve and validate every path before the first mutation. Renames and
+    // copies contribute both sides so the worktree returns to the exact
+    // turn-start tree rather than leaving a destination behind.
+    const targets = [...new Set(snapshot.files
+      .flatMap((file) => [file.path, file.oldPath])
+      .filter(Boolean))]
+      .map((target) => safeRelativePath(snapshot.root, target));
+    for (const target of targets) {
+      await restorePathFromTree(snapshot, target);
+    }
+    const currentTree = await captureTreeUnlocked(snapshot.state);
+    Object.assign(snapshot, await diffTreesUnlocked(snapshot.state, snapshot.baselineTree, currentTree));
+    return snapshot;
+  });
+}
+
 export function _resetTurnWorktreeSnapshotsForTest() {
   states.clear();
 }

package/src/session-runtime/provider-models.mjs

@@ -233,6 +233,13 @@ export function createProviderModels({
     const providersStartedAt = performance.now();
     await ensureProvidersReady(config().providers || {});
     profile('providers-ready', { ms: (performance.now() - providersStartedAt).toFixed(1) });
+    // ensureProvidersReady starts the daemon-wide force refresh without
+    // blocking boot. A foreground full picker load must join that refresh;
+    // otherwise it can snapshot yesterday's provider cache moments before the
+    // refresh invalidates it, leaving the UI on the stale first-open rows.
+    if (!forceRefresh && typeof reg().refreshProviderCatalogsOnStartup === 'function') {
+      await reg().refreshProviderCatalogsOnStartup();
+    }
     if (forceRefresh && typeof reg().refreshCatalogs === 'function') {
       await reg().refreshCatalogs();
     }
@@ -305,7 +312,10 @@ export function createProviderModels({
       return providerModelsFromCacheRows(caches.providerModelsCache.models);
     }
     if (!force && quick) {
-      warmProviderModelCache();
+      // A user-facing quick read seeds the authoritative secrets-aware load.
+      // Desktop asks quick first and full second; a no-secrets warm here made
+      // the full request join a partial catalog and only recover on re-entry.
+      warmProviderModelCache({ loadSecrets: true });
       return quickHelpers.quickProviderModelRows();
     }
     if (force) {