mixdog 1.2.2 → 1.2.3

package/src/runtime/office/pdf/pdf-edit-document.mjs

@@ -5,6 +5,7 @@
  */
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, resolve } from 'node:path';
+import { noteOfficeWrite } from '../core/office-write-ledger.mjs';
 import {
   PDFDocument,
   PDFArray,
@@ -130,6 +131,7 @@ export async function writeSibling(path, target, bytes) {
   if (output.toLowerCase() === resolve(path).toLowerCase())
     throw new Error('output must differ from the document being edited');
   await mkdir(dirname(output), { recursive: true });
+  noteOfficeWrite(output);
   await writeFile(output, bytes);
   return output;
 }

package/src/runtime/office/pdf/pdf-render.mjs

@@ -5,6 +5,7 @@ import { createCanvas, loadImage } from '@napi-rs/canvas';
 import { pdfjsStandardFontDataUrl, resolvedPdfJs } from '../../attachments/pdfjs-runtime.mjs';
 import { installPdfGlobals } from './pdf-document.mjs';
 import { workerExecArgv } from '../../shared/worker-exec-argv.mjs';
+import { noteOfficeWrite } from '../core/office-write-ledger.mjs';
 
 const PAGE_NUMBER_PATTERN = /^\s*(?:(?:page\s*)?\d+\s*(?:of|\/)\s*\d+|페이지\s*\d+|\d+\s*페이지)\s*$/i;
 
@@ -144,8 +145,8 @@ async function runPdfRenderWorker(data, signal = null) {
 }
 
 // Many pages are reviewed as contact sheets: one labelled grid image per group
-// of pages, written next to the PDF.
-async function writeContactSheet(group, width, imagePath, renderPage) {
+// of pages, for a file next to the PDF.
+async function contactSheet(group, width, imagePath, renderPage) {
   const columns = group.length <= 2 ? 1 : Math.max(2, Math.ceil(Math.sqrt(group.length * 0.75)));
   const rows = Math.ceil(group.length / columns);
   const gap = 12;
@@ -182,7 +183,6 @@ async function writeContactSheet(group, width, imagePath, renderPage) {
     context.strokeRect(x, y + labelHeight, image.width, image.height);
   }
   const data = sheet.toBuffer('image/png');
-  await writeFile(imagePath, data);
   return {
     page: group[0],
     pages: group,
@@ -204,7 +204,18 @@ async function writeContactSheet(group, width, imagePath, renderPage) {
   };
 }
 
-async function renderPdfPagesDirect(path, { pages = null, maxWidth = 1400, maximumScale = 2, signal = null } = {}) {
+// The page images land beside the PDF, each reported as an Office write first.
+async function writePageImages(images) {
+  for (const image of images) {
+    noteOfficeWrite(image.path);
+    await writeFile(image.path, Buffer.from(image.data, 'base64'));
+  }
+}
+
+async function renderPdfPagesDirect(
+  path,
+  { pages = null, maxWidth = 1400, maximumScale = 2, signal = null, writeImages = true } = {}
+) {
   if (signal?.aborted) throw new Error('PDF rendering was cancelled');
   installPdfGlobals();
   const { getDocument, VerbosityLevel } = await resolvedPdfJs();
@@ -248,7 +259,6 @@ async function renderPdfPagesDirect(path, { pages = null, maxWidth = 1400, maxim
       for (const pageNumber of selected) {
         const { canvas, data } = await renderPage(pageNumber, maxWidth);
         const imagePath = join(dirname(path), `${stem}-page-${pageNumber}.png`);
-        await writeFile(imagePath, data);
         output.push({
           page: pageNumber,
           path: imagePath,
@@ -264,9 +274,10 @@ async function renderPdfPagesDirect(path, { pages = null, maxWidth = 1400, maxim
       for (let offset = 0; offset < selected.length; offset += pagesPerSheet) {
         const group = selected.slice(offset, offset + pagesPerSheet);
         const imagePath = join(dirname(path), `${stem}-pages-${group[0]}-${group.at(-1)}.png`);
-        output.push(await writeContactSheet(group, width, imagePath, renderPage));
+        output.push(await contactSheet(group, width, imagePath, renderPage));
       }
     }
+    if (writeImages) await writePageImages(output);
     const reviewedPages = output.flatMap((image) => image.pages || [image.page]);
     const reviewedPageSet = new Set(reviewedPages);
     return {
@@ -293,7 +304,9 @@ export async function renderPdfPages(path, options = {}) {
   const signal = options.signal || null;
   if (signal?.aborted) throw new Error('PDF rendering was cancelled');
   if (!isMainThread) return await renderPdfPagesDirect(path, options);
-  return await runPdfRenderWorker(
+  // The worker rasterizes; this thread writes the images, where the call's
+  // write ledger can see each one before it lands.
+  const rendered = await runPdfRenderWorker(
     {
       kind: PDF_RENDER_WORKER_KIND,
       path,
@@ -301,10 +314,13 @@ export async function renderPdfPages(path, options = {}) {
         pages: options.pages ?? null,
         maxWidth: options.maxWidth ?? 1400,
         maximumScale: options.maximumScale ?? 2,
+        writeImages: false,
       },
     },
     signal
   );
+  await writePageImages(rendered.images);
+  return rendered;
 }
 
 if (!isMainThread && [PDF_RENDER_WORKER_KIND, PDF_RENDER_PAGE_WORKER_KIND].includes(workerData?.kind)) {

package/src/runtime/office/pdf/pdf-security.mjs

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { writeFile, rm, rename } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+import { noteOfficeWrite } from '../core/office-write-ledger.mjs';
 
 // qpdf on PATH, or wherever MIXDOG_QPDF_PATH points (the Windows installer
 // does not add itself to PATH).
@@ -89,6 +90,7 @@ export async function securePdf({ input, output, mode, password = '', ownerPassw
       ? ['--encrypt', password, ownerPassword || password, '256', '--', input, target]
       : [`--password=${password}`, '--decrypt', input, target];
   await writeFile(responsePath, `${args.join('\n')}\n`, { encoding: 'utf8', mode: 0o600 });
+  noteOfficeWrite(output);
   try {
     await run(QPDF, [`@${responsePath}`]);
     if (samePath) await rename(target, output);

package/src/runtime/office/portable/portable-opc.mjs

@@ -1,6 +1,7 @@
 import { posix } from 'node:path';
 import { createHash } from 'node:crypto';
 import { readFile, writeFile } from 'node:fs/promises';
+import { noteOfficeWrite } from '../core/office-write-ledger.mjs';
 import { koreanParticleReplacements } from '../shared/korean-particles.mjs';
 import { presetLabels } from '../shared/labels.mjs';
 import {
@@ -137,7 +138,9 @@ export async function packageBuffer(zip) {
 }
 
 export async function savePackage(zip, path) {
-  await writeFile(path, await packageBuffer(zip));
+  const bytes = await packageBuffer(zip);
+  noteOfficeWrite(path);
+  await writeFile(path, bytes);
 }
 
 export function relationshipMap(xml) {

package/src/runtime/office/quality/visual-diff.mjs

@@ -1,6 +1,7 @@
 import { writeFile } from 'node:fs/promises';
 import { dirname, extname, basename, join } from 'node:path';
 import { createCanvas, loadImage } from '@napi-rs/canvas';
+import { noteOfficeWrite } from '../core/office-write-ledger.mjs';
 
 function imageByPage(images) {
   return new Map((images || []).map((image) => [Number(image.page), image]));
@@ -61,6 +62,7 @@ export async function compareRenderedPages(beforeImages, afterImages, outputPdf)
     diffContext.putImageData(diff, 0, 0);
     const data = diffCanvas.toBuffer('image/png');
     const path = join(dirname(outputPdf), `${stem}-visual-diff-page-${page}.png`);
+    noteOfficeWrite(path);
     await writeFile(path, data);
     const total = width * height;
     metrics.push({

package/src/runtime/shared/bounded-file-read.mjs

@@ -156,6 +156,19 @@ export function readBoundedFile(
   }
 }
 
+/**
+ * A file's state for the turn review of a tool write: null when absent, its
+ * bytes (binary included) up to PATCH_EDIT_MAX_BYTES and within `budget`,
+ * otherwise an omitted marker — counted as changed, never diffed or restored.
+ * Throws ENOTREGULAR for anything but a regular file.
+ */
+export function reviewFileContent(path, { budget = null } = {}) {
+  const read = readBoundedFile(path, { maxBytes: PATCH_EDIT_MAX_BYTES, budget, detectBinary: false });
+  if (read.state === 'absent') return null;
+  if (read.state === 'omitted') return { omitted: true, size: read.size, reason: read.reason };
+  return read.content;
+}
+
 /** Human phrase for an omitted read: "binary (N bytes)", "larger than 8 MiB (N bytes)". */
 export function describeOmittedFile({ reason, size, limit } = {}) {
   const bytes = `${Number(size) || 0} bytes`;

package/src/runtime/shared/bounded-line-diff.mjs

@@ -0,0 +1,182 @@
+// In-process line diffs for the turn-change paths, bounded the way codex
+// bounds its own: every file gets a short timeout, every operation (one tool
+// call, one review or seal pass) a total budget. A file over the size limits,
+// past its timeout or past the spent budget gets one replacement hunk between
+// its common line prefix and suffix instead — still an exact patch that
+// applies, only not a minimal one. Results are cached by content, so the same
+// pair is not diffed again across calls and reviews.
+import { createHash } from 'node:crypto';
+import { performance } from 'node:perf_hooks';
+import { formatPatch, structuredPatch } from 'diff';
+
+/** Longest a single file's Myers diff may run (codex's per-file value). */
+export const LINE_DIFF_FILE_TIMEOUT_MS = 100;
+/** Total Myers diff time one operation may spend across its files. */
+// Kept well under the lag target: an operation also renders, hashes and
+// bounds its patches outside the diff itself.
+export const LINE_DIFF_OPERATION_BUDGET_MS = 150;
+// A side over either limit is never Myers-diffed.
+const LINE_DIFF_MAX_CHARS = 1024 * 1024;
+const LINE_DIFF_MAX_LINES = 20_000;
+const CONTEXT_LINES = 3;
+const CACHE_MAX_ENTRIES = 512;
+// Cached hunks reference their texts: bound the cache by their length.
+const CACHE_MAX_CHARS = 32 * 1024 * 1024;
+
+/** One operation's diff budget; pass it to every lineDiffHunks call of it. */
+export function createLineDiffBudget(totalMs = LINE_DIFF_OPERATION_BUDGET_MS) {
+  return { remainingMs: totalMs };
+}
+
+const _cache = new Map();
+let _cachedChars = 0;
+const _hashByBytes = new WeakMap();
+
+const sha1 = (value) => createHash('sha1').update(value).digest('hex');
+
+/** Content hash of one side: a byte array is hashed once per object. A text
+ *  hashes to the same id as its UTF-8 bytes; one that has no exact UTF-8 form
+ *  (a lone surrogate) gets no id. */
+function sideHash(source, text) {
+  if (source && typeof source === 'object') {
+    let hash = _hashByBytes.get(source);
+    if (!hash) {
+      hash = sha1(source);
+      _hashByBytes.set(source, hash);
+    }
+    return hash;
+  }
+  return text.isWellFormed() ? sha1(text) : null;
+}
+
+function cacheKey(sources, oldText, newText) {
+  const before = sideHash(sources[0], oldText);
+  const after = before && sideHash(sources[1], newText);
+  return after ? `${before}:${after}` : null;
+}
+
+function cacheGet(key) {
+  const entry = _cache.get(key);
+  if (!entry) return null;
+  _cache.delete(key);
+  _cache.set(key, entry);
+  return entry.result;
+}
+
+function cacheSet(key, result, chars) {
+  if (chars > CACHE_MAX_CHARS) return;
+  _cachedChars -= _cache.get(key)?.chars || 0;
+  _cache.delete(key);
+  _cache.set(key, { result, chars });
+  _cachedChars += chars;
+  while (_cache.size > CACHE_MAX_ENTRIES || _cachedChars > CACHE_MAX_CHARS) {
+    const [oldest, entry] = _cache.entries().next().value;
+    _cache.delete(oldest);
+    _cachedChars -= entry.chars;
+  }
+}
+
+function overLimits(text) {
+  if (text.length > LINE_DIFF_MAX_CHARS) return true;
+  let lines = 0;
+  for (let index = text.indexOf('\n'); index >= 0; index = text.indexOf('\n', index + 1)) {
+    lines += 1;
+    if (lines > LINE_DIFF_MAX_LINES) return true;
+  }
+  return false;
+}
+
+/** Lines with their `\n` (the last one may lack it), as jsdiff tokenizes. */
+function lineTokens(text) {
+  if (!text) return [];
+  const lines = text.split('\n');
+  const tokens = lines.map((line, index) => (index < lines.length - 1 ? `${line}\n` : line));
+  if (tokens.at(-1) === '') tokens.pop();
+  return tokens;
+}
+
+/** The one hunk replacing everything between the texts' common line prefix
+ *  and suffix, with up to three context lines each side, in jsdiff's hunk
+ *  shape (`` included). */
+function replacementHunks(oldText, newText) {
+  const before = lineTokens(oldText);
+  const after = lineTokens(newText);
+  const shortest = Math.min(before.length, after.length);
+  let start = 0;
+  while (start < shortest && before[start] === after[start]) start += 1;
+  let end = 0;
+  while (end < shortest - start && before[before.length - 1 - end] === after[after.length - 1 - end]) end += 1;
+  const lead = Math.min(CONTEXT_LINES, start);
+  const trail = Math.min(CONTEXT_LINES, end);
+  const lines = [];
+  const push = (mark, tokens) => {
+    for (const token of tokens) {
+      if (token.endsWith('\n')) lines.push(mark + token.slice(0, -1));
+      else lines.push(mark + token, '\');
+    }
+  };
+  push(' ', before.slice(start - lead, start));
+  push('-', before.slice(start, before.length - end));
+  push('+', after.slice(start, after.length - end));
+  push(' ', before.slice(before.length - end, before.length - end + trail));
+  const first = start - lead;
+  return [
+    {
+      oldStart: first + 1,
+      oldLines: before.length - end + trail - first,
+      newStart: first + 1,
+      newLines: after.length - end + trail - first,
+      lines,
+    },
+  ];
+}
+
+/**
+ * Hunks (context 3, jsdiff's structuredPatch shape) turning `oldText` into
+ * `newText`: jsdiff's own when its diff finishes within the file timeout and
+ * what is left of `budget` (`exact`), else the replacement hunk. `sources`
+ * are the raw sides the texts came from (bytes or the texts), used only as
+ * the cache key. The returned value is shared: never mutate it.
+ */
+export function lineDiffHunks(oldText, newText, budget, sources = [oldText, newText]) {
+  if (oldText === newText) return { hunks: [], exact: true };
+  const key = cacheKey(sources, oldText, newText);
+  const cached = key ? cacheGet(key) || budget.fallbacks?.get(key) : null;
+  if (cached) return cached;
+  let result = null;
+  // A fallback forced by the operation's spent budget is not this pair's own
+  // outcome: it is not cached, so a later operation can still diff it.
+  let repeatable = true;
+  if (!overLimits(oldText) && !overLimits(newText)) {
+    if (budget.remainingMs > 0) {
+      const timeout = Math.min(LINE_DIFF_FILE_TIMEOUT_MS, budget.remainingMs);
+      const startedAt = performance.now();
+      const patch = structuredPatch('', '', oldText, newText, '', '', { context: CONTEXT_LINES, timeout });
+      budget.remainingMs -= performance.now() - startedAt;
+      if (patch) result = { hunks: patch.hunks, exact: true };
+      else repeatable = timeout >= LINE_DIFF_FILE_TIMEOUT_MS;
+    } else {
+      repeatable = false;
+    }
+  }
+  result ||= { hunks: replacementHunks(oldText, newText), exact: false };
+  if (key && repeatable) cacheSet(key, result, oldText.length + newText.length);
+  // Within its own operation it is final: the budget never grows back.
+  else if (key) (budget.fallbacks ||= new Map()).set(key, result);
+  return result;
+}
+
+/** The `--- `/`+++ ` headers and hunks of `hunks`, as jsdiff formats them,
+ *  ending in exactly one newline. */
+export function unifiedHunksBody(oldHeader, newHeader, hunks) {
+  const generated = formatPatch({ oldFileName: oldHeader, newFileName: newHeader, oldHeader: '', newHeader: '', hunks });
+  let end = generated.length;
+  // Linear trim: a /\n*$/ regex rescans from every position of a large patch.
+  while (end > 0 && generated.charCodeAt(end - 1) === 10) end -= 1;
+  return `${generated.slice(generated.search(/^--- /m), end)}\n`;
+}
+
+export function _resetLineDiffCacheForTest() {
+  _cache.clear();
+  _cachedChars = 0;
+}

package/src/runtime/shared/buffered-appender.mjs

@@ -175,6 +175,24 @@ export function appendBuffered(path, text) {
   }
 }
 
+/**
+ * Drop every not-yet-written chunk for `path` (its file is being deleted, so a
+ * later flush must not recreate it). A write already handed to the OS cannot
+ * be recalled; callers unlink after this and it lands before or is removed.
+ */
+export function discardBuffered(path) {
+  const q = queues.get(path);
+  if (!q) return;
+  if (q.timer) {
+    clearTimeout(q.timer);
+    q.timer = null;
+  }
+  q.chunks = [];
+  q.bytes = 0;
+  q.failCount = 0;
+  deleteIfIdle(path, q);
+}
+
 /** Observable overflow counters for buffered append queues. */
 export function getBufferedAppenderStats(path) {
   const q = queues.get(path);

package/src/runtime/shared/config.mjs

@@ -18,8 +18,10 @@ import {
   backupUserData,
   backupUserDataAsync,
   markUserDataInitialized,
+  ensureUserDataInitialized,
   loadLatestMixdogConfigFromBackup,
-  hasUserDataInitMarker,
+  isUserDataRecoveryExpected,
+  findLegacyUserDataEvidence,
 } from './user-data-guard.mjs';
 import { AGENT_PROVIDER_ENV, AGENT_PROVIDER_ENV_ALIASES, getAgentApiKey } from './provider-api-key.mjs';
 
@@ -236,7 +238,7 @@ function readConfigFile() {
   }
 }
 
-function writeConfigFile(data) {
+function writeConfigFile(data, postBackupReason = 'post-config-write') {
   // R4 data-at-rest: mixdog-config.json holds provider apiKeys; clamp to
   // owner-only on POSIX via 0o600/0o700 mode bits, AND fail-closed on
   // Windows where those bits are advisory — `secret: true` makes the
@@ -261,29 +263,76 @@ function writeConfigFile(data) {
     markUserDataInitialized(resolvePluginData());
   } catch {}
   try {
-    backupUserData(resolvePluginData(), 'post-config-write');
+    backupUserData(resolvePluginData(), postBackupReason);
   } catch {}
 }
 
+// Config paths whose restore could not be persisted: the in-memory restore is
+// still served, but the failure is logged (and the write retried) only once
+// per process instead of on every read.
+const _restorePersistFailed = new Set();
+
+/**
+ * Write a config restored on a plain read back to disk through the normal save
+ * path (atomic write + backups), so later reads hit the file instead of
+ * restoring again. Try-once lock: a contended lock means a writer (possibly
+ * this process's own outer RMW) is about to persist, so the next read retries.
+ */
+function persistRestoredConfig(restored) {
+  const path = configPath();
+  if (_restorePersistFailed.has(path)) return;
+  try {
+    const wrote = withFileLockSync(
+      `${path}.lock`,
+      () => {
+        if (existsSync(path)) return false;
+        writeAll(restored, 'post-restore');
+        return true;
+      },
+      { timeoutMs: 0 }
+    );
+    if (wrote) {
+      process.stderr.write(
+        '[config] read: restored mixdog-config.json from latest user-data backup (missing after init) and saved it\n'
+      );
+    }
+  } catch (err) {
+    if (err?.code === 'ELOCKCONTENDED') return;
+    _restorePersistFailed.add(path);
+    process.stderr.write(
+      `[config] read: restored mixdog-config.json from latest user-data backup (missing after init); saving it failed, serving it from memory: ${err?.message || err}\n`
+    );
+  }
+}
+
 function readAll() {
   const parsed = readConfigFile();
-  if (parsed != null) return canonicalizeUnifiedConfig(parsed);
+  if (parsed != null) {
+    // A data dir from before the in-dir init marker gets one (plus a first
+    // scoped snapshot) once per process, so its config stays recoverable.
+    try {
+      ensureUserDataInitialized(resolvePluginData());
+    } catch {}
+    return canonicalizeUnifiedConfig(parsed);
+  }
   // Symmetric with readAllForRmW(): a missing/unreadable config on a data
   // dir that was previously initialized means the file was LOST (deleted,
-  // failed write), not a fresh install. Self-heal from the newest
+  // failed write), not a fresh install. A recreated data dir has no marker
+  // and starts fresh. Self-heal from this data dir's newest
   // structurally-complete backup instead of silently collapsing to {} —
   // which callers (readSection/getCapabilities) merge with in-memory
-  // defaults, dropping the user's presets/agent routes/sections. In-memory only:
-  // readAll() runs OUTSIDE the config lock (unlike the RMW path), so we do
-  // not write here to avoid an unlocked-write race; the next updateSection
-  // re-persists the file under the lock.
-  if (hasUserDataInitMarker(resolvePluginData())) {
+  // defaults, dropping the user's presets/agent routes/sections. The restore
+  // is persisted under the config lock (only if the file is still missing) so
+  // later reads hit the file instead of restoring and logging again.
+  // An upgraded data dir (legacy marker / matching legacy backup, no in-dir
+  // marker yet) is a recovery case too; without a verifiable backup reads stay
+  // empty and RMW writes refuse (see readAllForRmW).
+  if (isUserDataRecoveryExpected(resolvePluginData())) {
     const restored = loadLatestMixdogConfigFromBackup(resolvePluginData());
     if (restored && isPlainObject(restored)) {
-      process.stderr.write(
-        '[config] read: restored mixdog-config.json from latest user-data backup (missing after init)\n'
-      );
-      return canonicalizeUnifiedConfig(restored);
+      const config = canonicalizeUnifiedConfig(restored);
+      persistRestoredConfig(config);
+      return config;
     }
   }
   return {};
@@ -300,11 +349,22 @@ function quarantineMalformedConfig(parseErr) {
 }
 
 function restoreAllForRmWOrThrow(reason) {
-  const restored = loadLatestMixdogConfigFromBackup(resolvePluginData());
+  const restored = loadLatestMixdogConfigFromBackup(resolvePluginData(), { fresh: true });
   if (restored && isPlainObject(restored)) {
     process.stderr.write(`[config] RMW read: restored mixdog-config.json from latest user-data backup (${reason})\n`);
     return restored;
   }
+  const legacy = findLegacyUserDataEvidence(resolvePluginData(), { fresh: true });
+  if (legacy) {
+    const err = new Error(
+      `[config] mixdog-config.json is missing but this data dir (${resolvePluginData()}) was initialized by an older ` +
+        `Mixdog build and no backup verified to belong to it was found; refusing to write a fresh config over a ` +
+        `recoverable state. Restore mixdog-config.json from a backup under ${legacy.roots.join(' or ')}, or delete ` +
+        `the legacy marker(s) to start fresh: ${legacy.markers.join(', ') || '(none; matching legacy backups are incomplete)'}`
+    );
+    err.code = 'EUSERDATARECOVERY';
+    throw err;
+  }
   throw new Error(
     `[config] mixdog-config.json is unreadable and no valid backup was found (${reason}); refusing section write that would wipe other sections`
   );
@@ -321,7 +381,7 @@ function readAllForRmW() {
     raw = readFileSync(configPath(), 'utf8');
   } catch (err) {
     if (err.code === 'ENOENT') {
-      if (hasUserDataInitMarker(resolvePluginData())) {
+      if (isUserDataRecoveryExpected(resolvePluginData(), { fresh: true })) {
         return restoreAllForRmWOrThrow('config file missing after user-data was initialized');
       }
       return {};
@@ -402,8 +462,8 @@ export function subscribeConfigChange(listener) {
   };
 }
 
-function writeAll(data) {
-  writeConfigFile(canonicalizeUnifiedConfig(data));
+function writeAll(data, postBackupReason) {
+  writeConfigFile(canonicalizeUnifiedConfig(data), postBackupReason);
   notifyConfigChanged();
 }
 

package/src/runtime/shared/err-text.mjs

@@ -215,6 +215,12 @@ export function presentErrorText(error, options = {}) {
   const name = error && typeof error === 'object' ? String(error.name || '') : '';
   const code = error && typeof error === 'object' ? String(error.code || '') : '';
   const status = errorHttpStatus(error);
+  // The fixed request overhead error is actionable as written (sizes,
+  // contributors, remedy): keep its lines instead of a generic "Context too
+  // large." that would suggest compacting.
+  if (code === 'TOOL_SURFACE_EXCEEDS_CONTEXT' || /\(TOOL_SURFACE_EXCEEDS_CONTEXT\)/.test(text)) {
+    return stripErrorPrefix(text);
+  }
   const jsonError = extractJsonError(text);
   if (jsonError) text = jsonError;
   const embeddedError = extractEmbeddedError(text);

package/src/runtime/shared/file-permissions.d.mts

@@ -1,3 +1,8 @@
 export function enforceOwnerOnlyAclWin32(targetPath: string, options?: { fresh?: boolean }): void;
 
-export function enforceOwnerOnlyAclWin32Async(targetPath: string, options?: { fresh?: boolean }): Promise<void>;
+export function enforceOwnerOnlyAclWin32Async(
+  targetPath: string,
+  options?: { fresh?: boolean }
+): Promise<void>;
+
+export function enforceOwnerOnlyDirectoryWin32Async(targetPath: string): Promise<void>;

package/src/runtime/shared/file-permissions.mjs

@@ -73,6 +73,16 @@ function icaclsPath() {
   return path;
 }
 
+const quoteForPowerShell = (value) => `'${String(value).replaceAll("'", "''")}'`;
+
+function powerShellCommand(icacls, script) {
+  return {
+    executable: join(dirname(icacls), 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+    label: 'Windows ACL update',
+    args: ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')],
+  };
+}
+
 function ownerOnlyAclCommand(targetPath, sid, fresh, icacls) {
   if (fresh) {
     return {
@@ -84,7 +94,7 @@ function ownerOnlyAclCommand(targetPath, sid, fresh, icacls) {
   // Never /reset a published secret: that temporarily restores broad parent
   // grants, and a later failure leaves them in place. Build the protected DACL
   // in memory and publish it in one native ACL update instead.
-  const quote = (value) => `'${String(value).replaceAll("'", "''")}'`;
+  const quote = quoteForPowerShell;
   const script = [
     "$ErrorActionPreference = 'Stop';",
     `$path = ${quote(targetPath)};`,
@@ -100,11 +110,37 @@ function ownerOnlyAclCommand(targetPath, sid, fresh, icacls) {
     'if ($directory) { [System.IO.Directory]::SetAccessControl($path, $acl) }',
     'else { [System.IO.File]::SetAccessControl($path, $acl) };',
   ].join(' ');
-  return {
-    executable: join(dirname(icacls), 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
-    label: 'Windows ACL update',
-    args: ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')],
-  };
+  return powerShellCommand(icacls, script);
+}
+
+// Replaces a directory's whole DACL (explicit grants to anyone else included)
+// with one protected, inheritable owner-only grant, in one native update, so
+// files created inside need no ACL call of their own. Files already inside
+// that carry an explicit grant or any other principal's grant are reset to
+// inherit only that owner grant.
+function ownerOnlyDirectoryCommand(targetPath, sid, icacls) {
+  const script = [
+    "$ErrorActionPreference = 'Stop';",
+    `$path = ${quoteForPowerShell(targetPath)};`,
+    `$sid = [System.Security.Principal.SecurityIdentifier]::new(${quoteForPowerShell(sid)});`,
+    '$acl = [System.Security.AccessControl.DirectorySecurity]::new();',
+    '$acl.SetAccessRuleProtection($true, $false);',
+    '$acl.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new(',
+    '$sid, [System.Security.AccessControl.FileSystemRights]::FullControl,',
+    "[System.Security.AccessControl.InheritanceFlags]'ContainerInherit, ObjectInherit',",
+    '[System.Security.AccessControl.PropagationFlags]::None,',
+    '[System.Security.AccessControl.AccessControlType]::Allow));',
+    '[System.IO.Directory]::SetAccessControl($path, $acl);',
+    'foreach ($file in [System.IO.Directory]::GetFiles($path)) {',
+    '$current = [System.IO.File]::GetAccessControl($file);',
+    '$rules = @($current.GetAccessRules($true, $true, [System.Security.Principal.SecurityIdentifier]));',
+    '$foreign = @($rules | Where-Object { -not $_.IsInherited -or $_.IdentityReference -ne $sid });',
+    'if ($current.AreAccessRulesProtected -or $foreign.Count -gt 0) {',
+    '$reset = [System.Security.AccessControl.FileSecurity]::new();',
+    '$reset.SetAccessRuleProtection($false, $false);',
+    '[System.IO.File]::SetAccessControl($file, $reset) } };',
+  ].join(' ');
+  return powerShellCommand(icacls, script);
 }
 
 function aclFailure(targetPath, cause, label = 'icacls') {
@@ -143,3 +179,15 @@ export async function enforceOwnerOnlyAclWin32Async(targetPath, { fresh = false
     throw aclFailure(targetPath, error, command.label);
   }
 }
+
+export async function enforceOwnerOnlyDirectoryWin32Async(targetPath) {
+  if (process.platform !== 'win32') return;
+  const icacls = icaclsPath();
+  if (cachedUserSid === null) cachedUserSid = await resolveCurrentUserPrincipalAsync();
+  const command = ownerOnlyDirectoryCommand(targetPath, cachedUserSid, icacls);
+  try {
+    await execFileAsync(command.executable, command.args, { windowsHide: true, timeout: 15_000 });
+  } catch (error) {
+    throw aclFailure(targetPath, error, command.label);
+  }
+}

package/src/runtime/shared/llm/anthropic-effort.mjs

@@ -291,6 +291,12 @@ export function applyAnthropicEffortToBody(
 ) {
   if (!body || typeof body !== 'object') return;
 
+  // A gateway that declares its own effort contract (DeepSeek ignores
+  // budget_tokens) projects effort itself; returning true skips the Claude rules.
+  if (typeof opts.messagesEffortProjection === 'function') {
+    if (opts.messagesEffortProjection(body, { model, effort: opts.effort }) === true) return;
+  }
+
   const thinkingBudgetTokens = Number(opts.thinkingBudgetTokens);
   if (Number.isFinite(thinkingBudgetTokens) && thinkingBudgetTokens > 0) {
     assertAnthropicManualBudgetSupported(model);