mixdog 1.1.2 → 1.2.1

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

@@ -7,11 +7,14 @@
  * Kept apart from the cache/fingerprint policy in store-summary-reader.mjs
  * because this runs exactly once per distinct content and is the only part
  * that lazily enters the heavier reconnect-recovery boundary (dynamic imports
- * preserved verbatim so the cold summary path stays leaf-only).
+ * keep the cold summary path leaf-only).
  */
 import { sessionContextMeasurement, contextMeasurementStats } from '../../../shared/context-measurement.mjs';
 import { nextProjectionStamp } from './store-transcript-cache.mjs';
+import { join } from 'node:path';
 import { cleanValue, desktopSession, positiveNumber } from './store-summary-fields.mjs';
+import { compactionArchiveRange, readCompactionArchivePage } from './compaction-archive.mjs';
+import { dataDir } from './store-summary-locations.mjs';
 
 /** The parse/recovery/projection body of a stored transcript read. Runs once
  *  per distinct content; its result is shared read-only through the cache. */
@@ -90,17 +93,31 @@ export async function projectStoredTranscript(sessionId, doc, options) {
   // tail is identical either way.
   const itemLimit = Number.isFinite(options.itemLimit) ? options.itemLimit : Number.POSITIVE_INFINITY;
   const restored = restoreTranscriptItems(messages, { sessionId, itemLimit: itemLimit + 1 });
-  const transcriptHasOlder = restored.length > itemLimit;
+  let transcriptHasOlder = restored.length > itemLimit;
+  let items = transcriptHasOlder ? restored.slice(-itemLimit) : restored;
+  // A paged window continues past the first stored message into the
+  // display-only compaction archive (newest segment first). A legacy whole
+  // read never receives it.
+  const archiveRange = Number.isFinite(itemLimit) && !transcriptHasOlder ? compactionArchiveRange(session) : null;
+  if (archiveRange) {
+    const archived = await readCompactionArchivePage(join(dataDir(), 'sessions'), sessionId, {
+      ...archiveRange,
+      limit: itemLimit - restored.length,
+    });
+    if (archived.items.length) items = [...archived.items, ...restored];
+    transcriptHasOlder = archived.hasOlder;
+  }
   return {
     sessionId,
     projectionStamp: nextProjectionStamp(),
     ...(options.includeMessages ? { messages } : {}),
-    items: transcriptHasOlder ? restored.slice(-itemLimit) : restored,
+    items,
     transcriptHasOlder,
     provider: session.provider || '',
     model: session.model || '',
     effort: session.effort || '',
     fast: session.fast === true,
+    ...(session.autoEffort === false ? { autoEffort: false } : {}),
     modelParameters: session.modelParameters || {},
     cwd: session.cwd || '',
     desktopSession: desktopSession(session.desktopSession, session.cwd),

package/src/runtime/agent/orchestrator/session/synthetic-user-envelope.mjs

@@ -16,6 +16,7 @@
 import { isActualUserInstructionMessage, isInjectedSkillBodyMessage, isSummaryMessage } from './compact/messages.mjs';
 import { ACTIVE_TURN_CONTINUATION_ANCHOR, ACTIVE_TURN_CONTINUATION_SOURCE } from './compact/continuation.mjs';
 import { parseTaskNotification } from '../../../shared/task-notification-envelope.mjs';
+import { isImportedMessage } from './imported-message.mjs';
 
 export const SYNTHETIC_USER_ENVELOPE_TAG = 'mixdog-runtime';
 
@@ -62,7 +63,8 @@ function isAlreadyEnveloped(text) {
 
 // null => a real user instruction (or nothing to wrap); otherwise the kind.
 export function classifySyntheticUserMessage(message) {
-  if (message?.role !== 'user') return null;
+  // Imported prose stays the user's own (unwrapped) voice.
+  if (message?.role !== 'user' || isImportedMessage(message)) return null;
   const text = messageText(message);
   if (!text.trim()) return null;
   if (isAlreadyEnveloped(text)) return null;

package/src/runtime/agent/orchestrator/session/tool-batch/pre-dispatch.mjs

@@ -92,7 +92,7 @@ function crossTurnStub(batch, call, ctSig) {
 // (which spans ONE assistant turn): when the model re-issues an IDENTICAL
 // normalized call that has already failed repeatFailLimit times in a row
 // across iterations, stop re-executing — the result will not change, and
-// each retry burns a full LLM round-trip until the hard iteration cap. The
+// each retry burns a full LLM round-trip with no iteration cap to end it. The
 // call stays unresolved; the guard only skips re-execution.
 function repeatFailureSkip(batch, call, sigs) {
   const { sessionRef, repeatFailLimit } = batch;

package/src/runtime/agent/orchestrator/session/transcript-restore/restore.mjs

@@ -6,6 +6,7 @@
  */
 import { contextMeasurementStats } from '../../../../shared/context-measurement.mjs';
 import { toolResultText } from './tool-result-text.mjs';
+import { restoredUserImageRefs, restoredUserText } from './user-text.mjs';
 import {
   completionCardFromExecution,
   parseModelVisibleCompletionWrapper,
@@ -37,6 +38,7 @@ import {
 } from '../../../../shared/tool-execution-contract.mjs';
 import { toolResultTerminalStatus } from '../../../../shared/tool-status.mjs';
 import { transcriptRouteMetadataFields } from '../../../../shared/transcript-metadata.mjs';
+import { isImportedMessage } from '../imported-message.mjs';
 
 function restoredTranscriptMetadata(message) {
   const value = message?.meta?.transcript;
@@ -48,12 +50,23 @@ function restoredTranscriptMetadata(message) {
   if (completionValue && completionStatus && Number.isFinite(completionElapsedMs)) {
     completion = { status: completionStatus, elapsedMs: Math.max(0, completionElapsedMs) };
     if (typeof completionValue.verb === 'string' && completionValue.verb) completion.verb = completionValue.verb;
+    if (typeof completionValue.checkpointId === 'string' && completionValue.checkpointId) {
+      completion.checkpointId = completionValue.checkpointId;
+    }
   }
   return {
+    // The stable message id lets a live view map a compaction's dropped
+    // messages back to these rows.
+    ...(typeof value.messageId === 'string' && value.messageId ? { messageId: value.messageId } : {}),
     ...(Number.isFinite(Number(value.at)) ? { at: Number(value.at) } : {}),
     ...transcriptRouteMetadataFields(value),
     ...(typeof value.sender === 'string' && value.sender ? { sender: value.sender } : {}),
     ...(typeof value.device === 'string' && value.device ? { device: value.device } : {}),
+    ...(typeof value.checkpointId === 'string' && value.checkpointId ? { checkpointId: value.checkpointId } : {}),
+    // Skills this user turn explicitly loaded (header selection or `$name`).
+    ...(Array.isArray(value.appliedSkills) && value.appliedSkills.length
+      ? { appliedSkills: value.appliedSkills.filter((name) => typeof name === 'string' && name) }
+      : {}),
     ...(completion ? { completion } : {}),
   };
 }
@@ -70,15 +83,16 @@ function restoredAssistantTranscriptItems(message, nextId) {
       ...completion,
       ...(completion.status === 'done' ? { finalAssistantId: items[0].id } : {}),
       ...(metadata.at ? { at: metadata.at } : {}),
+      ...(metadata.messageId ? { messageId: metadata.messageId } : {}),
     });
   }
   return items;
 }
 
 // Restored tool cards: stored assistant messages keep their (compacted)
-// tool_calls and the follow-up role:'tool' results, but resume used to drop
-// both — a reopened session lost every tool marker (user bug). Rebuild one
-// transcript tool item per call and attach its result by tool_call_id.
+// tool_calls and the follow-up role:'tool' results. Rebuild one transcript
+// tool item per call and attach its result by tool_call_id, so a reopened
+// session keeps its tool markers.
 function restoredMessageToolCalls(message) {
   if (Array.isArray(message?.tool_calls)) return message.tool_calls;
   if (Array.isArray(message?.toolCalls)) return message.toolCalls;
@@ -112,7 +126,12 @@ function restoredToolCallItems(message, nextId, pendingByCallId) {
       ...(Number.isFinite(at) ? { at, startedAt: at, completedAt: at } : {}),
     };
     const callId = typeof call?.id === 'string' ? call.id : '';
-    if (callId) pendingByCallId.set(callId, item);
+    // The call id ties the card to its call and result messages (a live view
+    // greys it when a compaction drops them).
+    if (callId) {
+      item.callId = callId;
+      pendingByCallId.set(callId, item);
+    }
     items.push(item);
   }
   return items;
@@ -203,6 +222,9 @@ function buildRestoredAggregateItem(members) {
       ...(loadingTargets.length > 0 ? { loadingTargets } : {}),
     },
     aggregate: true,
+    ...(members.some(({ item }) => item.callId)
+      ? { callIds: members.map(({ item }) => item.callId).filter(Boolean) }
+      : {}),
     categories: Object.fromEntries(header.categories),
     doneCategories: aggregateDoneCategories(calls),
     completedCount: calls.length,
@@ -219,8 +241,8 @@ function buildRestoredAggregateItem(members) {
 
 // Restored transcripts must mirror the live turn's category merging: the live
 // session runtime (turn.mjs) collapses consecutive same-bucket tool calls into one
-// aggregate card, but resume rebuilt one card per call, so a reopened session
-// un-merged every run (user bug). Walk the restored items and merge adjacent
+// aggregate card, so a reopened session must not show them un-merged. Walk the
+// restored items and merge adjacent
 // tool cards whose aggregateBucketForCategory matches; any non-tool item
 // (user/assistant/turndone) is a block boundary, same as the live seal rule.
 // Runs of 1 keep the plain per-call card (its argument summary stays visible).
@@ -279,9 +301,11 @@ function restoredMessageItemUpperBound(message) {
 function restoredNotificationToolItem(parsed, text, message, nextId, errorLabel) {
   const label = parsed.label || 'notification';
   const at = Number(message?.meta?.transcript?.at);
+  const messageId = message?.meta?.transcript?.messageId;
   return {
     kind: 'tool',
     id: nextId(),
+    ...(typeof messageId === 'string' && messageId ? { messageId } : {}),
     name: parsed.name || 'agent',
     args: parsed.args || {
       type: label,
@@ -303,7 +327,12 @@ function restoredUserTranscriptItems(message, nextId) {
   // skill bodies (meta:'skill'), hook/system reminders, and tag-wrapped context
   // blocks must not restore as user bubbles in any client.
   if (message?.meta === 'skill' || message?.meta === 'hook') return [];
-  const text = (typeof message?.content === 'string' ? message.content : toolResultText(message?.content)).trim();
+  // Imported prose renders verbatim: never a control row, card or display rewrite.
+  if (isImportedMessage(message)) {
+    const text = (typeof message.content === 'string' ? message.content : toolResultText(message.content)).trim();
+    return text ? [{ kind: 'user', id: nextId(), text, ...restoredTranscriptMetadata(message) }] : [];
+  }
+  const text = restoredUserText(message?.content).trim();
   // Persisted async-completion wrappers ("Async shell task ... finished. Result:
   // > ...") are the only durable record of a background completion — the live
   // Response card is an event-time push that does not survive a transcript
@@ -329,11 +358,21 @@ function restoredUserTranscriptItems(message, nextId) {
   // step, but render it like a live cancel tail (◈ Cancelled) instead of a
   // raw user bubble with bracketed internals.
   if (isTranscriptCancelledStatusText(text)) {
-    return [{ kind: 'turndone', id: nextId(), status: 'cancelled', elapsedMs: 0 }];
+    const { messageId } = restoredTranscriptMetadata(message);
+    return [{ kind: 'turndone', id: nextId(), status: 'cancelled', elapsedMs: 0, ...(messageId ? { messageId } : {}) }];
   }
   const synthetic = parseSyntheticAgentMessage(text);
   if (!synthetic) {
-    return [{ kind: 'user', id: nextId(), text, ...restoredTranscriptMetadata(message) }];
+    const imageRefs = restoredUserImageRefs(message?.content);
+    return [
+      {
+        kind: 'user',
+        id: nextId(),
+        text,
+        ...restoredTranscriptMetadata(message),
+        ...(imageRefs.length ? { imageRefs } : {}),
+      },
+    ];
   }
   return [restoredNotificationToolItem(synthetic, text, message, nextId, /^(failed|error|killed|cancelled)$/i)];
 }

package/src/runtime/agent/orchestrator/session/transcript-restore/user-text.mjs

@@ -0,0 +1,161 @@
+/**
+ * The text a restored user bubble shows for a stored prompt, matching what the
+ * live bubble showed for it:
+ * - An image part is drawn by the `[Image: …]` metadata line the composer put
+ *   before it; the part itself adds no raw `[image: image/png]` marker (a bare
+ *   one gets a metadata line of its own, which renders as an image chip).
+ * - A desktop `<visualize_feedback>` block (the agent-facing pin/choice
+ *   record) is shown as the lines the live bubble showed: `📌 N · label —
+ *   note` per pin, one `☑ group: label, …` line for the picks and one
+ *   `🎚 id: value (was old), …` line for tweaks (drawn with an icon). Intake
+ *   moves a long block into the attachment store; it is read back from there.
+ */
+import { isAttachmentReference, readAttachmentTextWithin } from '../../../../attachments/store.mjs';
+import { toolResultText } from './tool-result-text.mjs';
+
+const IMAGE_METADATA_LINE = /\[Image(?::| source:) [^\]\r\n]+\]\s*$/;
+const FEEDBACK_OPEN = '<visualize_feedback>';
+const FEEDBACK_BLOCK = /<visualize_feedback>\n([\s\S]*?)\n?<\/visualize_feedback>/g;
+// Feedback blocks are bounded (20 pins, trimmed HTML); a larger blob is a long
+// prompt or paste, which restores as before without being read. The cap holds
+// on the blob itself: the reference's claimed sizeBytes is not trusted.
+const FEEDBACK_MAX_BYTES = 128 * 1024;
+const QUOTED = '("(?:[^"\\\\]|\\\\.)*")';
+const CHOICE_LINE = new RegExp(`· group: (?:${QUOTED}|\\(none\\)) → choice: ${QUOTED}(?: \\(${QUOTED}\\))?$`);
+
+function unquote(value) {
+  if (!value) return '';
+  try {
+    return String(JSON.parse(value));
+  } catch {
+    return '';
+  }
+}
+
+/** The live bubble's lines for one feedback block body. */
+function feedbackDisplay(body) {
+  const pins = [];
+  const choices = [];
+  let pin = null;
+  let note = false;
+  let inChoices = false;
+  const tweakSets = [];
+  let tweaks = null;
+  for (const line of body.split('\n')) {
+    if (line.startsWith('tweaks (')) {
+      pin = null;
+      inChoices = false;
+      tweaks = null;
+      tweakSets.push([]);
+      tweaks = tweakSets.at(-1);
+      continue;
+    }
+    if (tweaks) {
+      const change = /^ {4}(.+?) \([^)]*\): (.*) \(was (.*)\)$/.exec(line);
+      if (change) tweaks.push(`${change[1]}: ${change[2]} (was ${change[3]})`);
+      else if (line.startsWith('  - tab: ')) {
+        tweaks = [];
+        tweakSets.push(tweaks);
+      } else tweaks = null;
+      if (tweaks) continue;
+    }
+    const head = /^pin (\d+) · (.*)$/.exec(line);
+    if (head) {
+      pin = { n: head[1], label: head[2], note: '' };
+      pins.push(pin);
+      note = false;
+      inChoices = false;
+      continue;
+    }
+    if (line === 'choices:') {
+      pin = null;
+      inChoices = true;
+      continue;
+    }
+    if (pin && line.startsWith('  note: ')) {
+      pin.note = line.slice(8);
+      note = true;
+      continue;
+    }
+    if (pin && note && line.startsWith('    ')) {
+      pin.note += `\n${line.slice(4)}`;
+      continue;
+    }
+    note = false;
+    const choice = inChoices ? CHOICE_LINE.exec(line) : null;
+    if (choice) {
+      choices.push({ group: unquote(choice[1]), choice: unquote(choice[2]), label: unquote(choice[3]) });
+    }
+  }
+  const lines = pins.map((entry) => `📌 ${entry.n} · ${entry.label} — ${entry.note.replace(/\s+/g, ' ')}`);
+  if (choices.length) {
+    lines.push(
+      `☑ ${choices.map((entry) => (entry.group ? `${entry.group}: ` : '') + (entry.label || entry.choice)).join(', ')}`
+    );
+  }
+  const changed = tweakSets.filter((set) => set.length).map((set) => set.join(', '));
+  if (changed.length) lines.push(`🎚 ${changed.join('; ')}`);
+  return lines.join('\n');
+}
+
+export function withVisualizeFeedbackDisplay(text) {
+  const value = String(text ?? '');
+  if (!value.includes(FEEDBACK_OPEN)) return value;
+  return value.replace(FEEDBACK_BLOCK, (_block, body) => feedbackDisplay(body));
+}
+
+/** A stored text reference's body when it is a feedback block, else ''. */
+function referencedFeedbackText(part) {
+  if (part?.type !== 'text' || part.textKind) return '';
+  try {
+    const text = readAttachmentTextWithin(part, FEEDBACK_MAX_BYTES);
+    return text?.startsWith(FEEDBACK_OPEN) ? text : '';
+  } catch {
+    // A blob gone from the store restores as it always did: without its text.
+    return '';
+  }
+}
+
+/** The display lines of a stored prompt's parts, and for each image part the
+ *  line that draws it: the composer's metadata line right before it, else a
+ *  bare line of its own (a bare line never stands for the next image). */
+function restoredUserParts(content) {
+  const texts = [];
+  const images = [];
+  let pendingMetadata = '';
+  for (const part of content) {
+    if (part?.type === 'image' || part?.type === 'input_image') {
+      let line = pendingMetadata;
+      if (!line) {
+        line = `[Image: ${part.mimeType || part.mediaType || 'image'}]`;
+        texts.push(line);
+      }
+      pendingMetadata = '';
+      images.push({ part, line });
+      continue;
+    }
+    const text = isAttachmentReference(part) ? referencedFeedbackText(part) : toolResultText([part]);
+    if (text) texts.push(text);
+    pendingMetadata = IMAGE_METADATA_LINE.test(text) ? text.trimEnd().split(/\r?\n/).pop().trim() : '';
+  }
+  return { texts, images };
+}
+
+export function restoredUserText(content) {
+  if (!Array.isArray(content)) {
+    return withVisualizeFeedbackDisplay(typeof content === 'string' ? content : toolResultText(content));
+  }
+  return withVisualizeFeedbackDisplay(restoredUserParts(content).texts.join('\n'));
+}
+
+/** The stored original of each image the restored bubble draws, by the
+ *  `[Image: …]` line that draws it. Every image keeps its slot (one without a
+ *  stored original has no `ref`) so later images do not shift onto it; empty
+ *  when no image has a stored original. */
+export function restoredUserImageRefs(content) {
+  if (!Array.isArray(content)) return [];
+  const slots = restoredUserParts(content).images.map(({ part, line }) =>
+    isAttachmentReference(part) ? { line, ref: part.attachmentRef } : { line }
+  );
+  return slots.some((slot) => slot.ref) ? slots : [];
+}

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/invocation-plan.mjs

@@ -3,13 +3,25 @@ import { buildPowerShellFilterTeePlan } from '../shell-analysis.mjs';
 import { normalizeErrorMessage } from '../path-diagnostics.mjs';
 import { planDirectExeSpawn } from '../shell-direct-exe.mjs';
 import { POWERSHELL_UTF8_PREFIX } from '../../../../../shared/shell-display.mjs';
+import { renderPowerShellSkillFunction, skillScriptRuntime } from '../../../../../shared/skill-script-runtime.mjs';
 import { buildShellSpawnEnv } from './spawn-env.mjs';
 import { formatShellToolFailure } from './result-format.mjs';
 
+// Every PowerShell model command defines `mixdog-skill-node` first, so the
+// skill launcher runs without the .cmd's cmd.exe argument re-parsing.
+// Injected whenever absent, independent of the UTF-8 prefix deduplication.
+function prefixPowerShellSkillFunction(command) {
+  const fn = renderPowerShellSkillFunction(skillScriptRuntime());
+  const text = String(command || '');
+  return text.trimStart().startsWith(`${fn}\n`) ? text : `${fn}\n${text}`;
+}
+
 function prefixPowerShellUtf8(command) {
   const prefix = POWERSHELL_UTF8_PREFIX;
   const text = String(command || '');
-  return text.trimStart().startsWith(prefix) ? text : `${prefix}\n${text}`;
+  const trimmed = text.trimStart();
+  const body = trimmed.startsWith(prefix) ? trimmed.slice(prefix.length).replace(/^[ \t]*\r?\n/, '') : text;
+  return `${prefix}\n${prefixPowerShellSkillFunction(body)}`;
 }
 
 // How the command reaches the child: a direct exe spawn, PowerShell with the
@@ -54,6 +66,10 @@ export async function planShellInvocation({ command, resolvedSpec, cwd }) {
     plan.wrappedCommand = prefixPowerShellUtf8(plan.teePlan ? plan.teePlan.command : command);
     return plan;
   }
+  if (shellType === 'powershell') {
+    plan.wrappedCommand = prefixPowerShellSkillFunction(command);
+    return plan;
+  }
   if (process.platform !== 'win32' && (shell.includes('bash') || shell.includes('zsh'))) {
     try {
       plan.wrappedCommand = await wrapCommandWithSnapshot(shell, command);

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/spawn-env.mjs

@@ -1,4 +1,5 @@
 import { resourceAdmission } from '../../../../../shared/resource-admission.mjs';
+import { withSkillLauncherPath } from '../../../../../shared/skill-script-runtime.mjs';
 import {
   applyShellEgressPolicy,
   scrubLoaderVars,
@@ -24,5 +25,8 @@ export function buildShellSpawnEnv(cwd, baseEnv = process.env) {
   scrubLoaderVars(spawnEnv);
   scrubRuntimeRootVars(spawnEnv);
   applyShellEgressPolicy(spawnEnv);
+  // `mixdog-skill-node` (a skill's ${MIXDOG_SKILL_NODE}) resolves in every
+  // model shell; only this env gets the entry, never the daemon's own.
+  withSkillLauncherPath(spawnEnv);
   return spawnEnv;
 }

package/src/runtime/agent/orchestrator/tools/builtin/cache-layers.mjs

@@ -5,10 +5,15 @@ import { isAbsolute, sep } from 'node:path';
 import { canonicalCachePath, deleteReadRangeIndexForPath } from './read-range-index.mjs';
 import { resolveAgainstCwd } from './path-utils.mjs';
 import { fileVersion, sameFileVersion } from './file-version.mjs';
+import { canCacheReadFile } from './read-cache-policy.mjs';
 
 const RESULT_CACHE = new Map(); // key → { ts, value, paths, scopes, readSnapshotMeta, contentPrefixHash, bytes }
 const RESULT_CACHE_INFLIGHT = new Map(); // key → { promise, controller, subscribers, settled }
 const RESULT_CACHE_COMPUTE = new AsyncLocalStorage();
+const READ_CACHE_PUBLICATION = new AsyncLocalStorage();
+// Only active reads retain a slot. Invalidating an inactive path creates
+// no history, and the final reader releases its path in a finally block.
+const ACTIVE_READ_CACHE_PATHS = new Map();
 const RESULT_CACHE_TTL_MS = 30_000;
 const RESULT_CACHE_MAX_ENTRIES = 200;
 // A byte budget from the bytes env var, else the megabytes one, else the
@@ -72,6 +77,37 @@ function cachePathsOverlap(a, b) {
   return a.startsWith(b.endsWith(sep) ? b : `${b}${sep}`) || b.startsWith(a.endsWith(sep) ? a : `${a}${sep}`);
 }
 
+export async function runReadCachePublication(fullPaths, read) {
+  const paths = normalizeCacheMetaPaths(Array.isArray(fullPaths) ? fullPaths : [fullPaths]);
+  const leases = paths.map((path) => {
+    let slot = ACTIVE_READ_CACHE_PATHS.get(path);
+    if (!slot) {
+      slot = { generation: 0, references: 0 };
+      ACTIVE_READ_CACHE_PATHS.set(path, slot);
+    }
+    slot.references++;
+    return { path, slot, generation: slot.generation, released: false };
+  });
+  try {
+    return await READ_CACHE_PUBLICATION.run(leases, read);
+  } finally {
+    for (const lease of leases) {
+      lease.released = true;
+      if (--lease.slot.references === 0) ACTIVE_READ_CACHE_PATHS.delete(lease.path);
+    }
+  }
+}
+
+export function canPublishReadCache(targets = null) {
+  const leases = READ_CACHE_PUBLICATION.getStore();
+  if (!leases) return true;
+  const paths = normalizeCacheMetaPaths(Array.isArray(targets) ? targets : [targets]);
+  return leases.every((lease) => {
+    if (paths.length && !paths.some((path) => cachePathsOverlap(path, lease.path))) return true;
+    return !lease.released && lease.generation === lease.slot.generation;
+  });
+}
+
 function cacheEntryOverlapsPaths(entry, affectedPaths) {
   const entryPaths = Array.isArray(entry?.paths) ? entry.paths : [];
   const entryScopes = Array.isArray(entry?.scopes) ? entry.scopes : [];
@@ -107,6 +143,11 @@ export function cacheSet(key, value, meta = {}) {
   // A detached/aborted computation must never repopulate a newer cache.
   const computation = RESULT_CACHE_COMPUTE.getStore();
   if (computation?.invalidated || computation?.controller?.signal?.aborted) return;
+  const publicationPaths = [
+    ...(Array.isArray(meta.paths) ? meta.paths : []),
+    ...(Array.isArray(meta.scopes) ? meta.scopes : []),
+  ];
+  if (!canPublishReadCache(publicationPaths)) return;
   // Replace-in-place: clear old entry's byte accounting before write.
   if (RESULT_CACHE.has(key)) resultCacheDelete(key);
   const bytes = estimateResultBytes(value);
@@ -239,7 +280,7 @@ export async function runRawContentInFlight(fullPath, loader = fsPromises.readFi
   // Buffered reads provide their observed version: a later read must not
   // join older bytes merely because a watcher has not fired yet. Preserve
   // the unversioned helper contract for callers that supply no stat.
-  if (stat !== undefined && !version) return await loader(fullPath);
+  if (stat !== undefined && (!version || !canCacheReadFile(version))) return await loader(fullPath);
   const key = version ? JSON.stringify([path, version]) : path;
   return await runPathInFlight(RAW_CONTENT_INFLIGHT, key, path, () => loader(fullPath));
 }
@@ -260,6 +301,10 @@ function rawContentCacheDelete(key) {
 export function rawContentCacheGet(fullPath, stat, now = Date.now()) {
   if (!fullPath || !stat) return null;
   const key = canonicalCachePath(fullPath);
+  if (!canCacheReadFile(stat)) {
+    rawContentCacheDelete(key);
+    return null;
+  }
   const entry = RAW_CONTENT_CACHE.get(key);
   if (!entry) return null;
   if (now - entry.ts > RAW_CONTENT_CACHE_TTL_MS) {
@@ -276,9 +321,10 @@ export function rawContentCacheGet(fullPath, stat, now = Date.now()) {
 }
 
 export function rawContentCacheSet(fullPath, stat, rawBuf, now = Date.now()) {
+  if (!canPublishReadCache(fullPath)) return;
   if (!fullPath || !Buffer.isBuffer(rawBuf)) return;
   const version = fileVersion(stat);
-  if (!version || rawBuf.length !== version.size || rawBuf.length > RAW_CONTENT_CACHE_MAX_BYTES) return;
+  if (!version || !canCacheReadFile(version) || rawBuf.length !== version.size || rawBuf.length > RAW_CONTENT_CACHE_MAX_BYTES) return;
   const key = canonicalCachePath(fullPath);
   rawContentCacheDelete(key);
   RAW_CONTENT_CACHE.set(key, {
@@ -450,6 +496,7 @@ function runExtraInvalidationListeners(affectedPaths = null) {
 }
 
 function cacheInvalidateAll() {
+  for (const slot of ACTIVE_READ_CACHE_PATHS.values()) slot.generation++;
   for (const entry of RESULT_CACHE_INFLIGHT.values()) {
     entry.invalidated = true;
   }
@@ -470,6 +517,9 @@ function cacheInvalidatePaths(paths) {
     cacheInvalidateAll();
     return;
   }
+  for (const [path, slot] of ACTIVE_READ_CACHE_PATHS) {
+    if (affectedPaths.some((affected) => cachePathsOverlap(path, affected))) slot.generation++;
+  }
   for (const inFlight of [RAW_CONTENT_INFLIGHT, READ_ONLY_STAT_INFLIGHT]) {
     for (const [key, entry] of inFlight) {
       if (affectedPaths.some((affected) => cachePathsOverlap(entry.path, affected))) inFlight.delete(key);