@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/clients/test-runner-delivery.js

@@ -1,15 +1,24 @@
 import { emitBounded } from "./bounded-telemetry.js";
+import {
+  boundDeferredTargets,
+  mergeDeferredTargets,
+  TEST_RUNNER_MAX_PERSISTED_TARGETS
+} from "./deferred-test-targets.js";
 import { recordDegradationOnce } from "./degradation-ledger.js";
 import { logLatency } from "./latency-logger.js";
 import { consumeTestFindings, peekTestFindings } from "./runtime-context.js";
 const MAX_PENDING_DELIVERIES = 32;
 const pending = new Map;
-function logDeliveredVerdicts(cacheManager, cwd, runtime, delivery) {
-  const verdicts = cacheManager.readCache("test-runner-findings", cwd)?.data?.verdicts;
+function staleVerdictNotice(stale) {
+  return stale.map((entry) => `verdict for an older version of ${entry.sourceFile} (${entry.gap} edit${entry.gap === 1 ? "" : "s"} ago); ${entry.runner ? "re-running" : "re-run manually"}`).join(`
+`);
+}
+function settleDeliveredVerdicts(cacheManager, cwd, runtime, delivery) {
+  const data = cacheManager.readCache("test-runner-findings", cwd)?.data;
   let knownCount = 0;
-  let staleCount = 0;
   let unknownCount = 0;
-  for (const verdict of verdicts ?? []) {
+  const stale = [];
+  for (const verdict of data?.verdicts ?? []) {
     const evidence = verdict.fileSeq ?? {
       state: "unknown",
       reason: "legacy-cache-record"
@@ -25,11 +34,37 @@ function logDeliveredVerdicts(cacheManager, cwd, runtime, delivery) {
     }
     knownCount += 1;
     const currentFileSeq = runtime.getFileSeq(verdict.sourceFile);
-    if (currentFileSeq > evidence.value)
-      staleCount += 1;
+    if (currentFileSeq <= evidence.value)
+      continue;
+    stale.push({
+      file: verdict.file,
+      sourceFile: verdict.sourceFile,
+      runner: verdict.runner,
+      gap: currentFileSeq - evidence.value
+    });
   }
   if (knownCount === 0 && unknownCount === 0)
     return;
+  const rerunEntries = [];
+  for (const entry of stale) {
+    if (!entry.runner)
+      continue;
+    rerunEntries.push({
+      testFile: entry.file,
+      sourceFile: entry.sourceFile,
+      runner: entry.runner,
+      attempts: 0,
+      sessionId: delivery.sessionId
+    });
+  }
+  if (data && stale.length > 0) {
+    cacheManager.writeCache("test-runner-findings", {
+      ...data,
+      content: `${staleVerdictNotice(stale)}
+${data.content}`,
+      deferredTargets: boundDeferredTargets(mergeDeferredTargets(data.deferredTargets ?? [], rerunEntries), TEST_RUNNER_MAX_PERSISTED_TARGETS, (entry) => entry.sessionId === delivery.sessionId)
+    }, cwd);
+  }
   logLatency({
     type: "phase",
     phase: "test_runner_verdict_delivery",
@@ -39,8 +74,10 @@ function logDeliveredVerdicts(cacheManager, cwd, runtime, delivery) {
       sessionId: delivery.sessionId,
       generation: delivery.generation,
       verdictCount: knownCount,
-      staleCount,
-      unknownCount
+      staleCount: stale.length,
+      unknownCount,
+      staleGaps: stale.map((entry) => entry.gap).slice(0, 32),
+      rerunQueued: rerunEntries.length
     }
   });
 }
@@ -238,7 +275,7 @@ export function consumeStagedTestRunnerFindings(args) {
     record(deliveryKey, "superseded", delivery, { currentGeneration });
     return;
   }
-  logDeliveredVerdicts(args.cacheManager, args.cwd, args.runtime, delivery);
+  settleDeliveredVerdicts(args.cacheManager, args.cwd, args.runtime, delivery);
   const findings = consumeTestFindings(args.cacheManager, args.cwd, args.runtime);
   if (!findings) {
     pending.delete(deliveryKey);

package/extensions/dm-lens/clients/test-target-roots.js

@@ -0,0 +1,20 @@
+import { dirname } from "node:path";
+import {
+  resolveGitCheckout,
+  resolveLinkedWorktreeOwner
+} from "./review-graph/git-identity.js";
+export function createTurnEndTestRoots(sessionCwd) {
+  const session = resolveGitCheckout(sessionCwd);
+  const ownerByDir = new Map;
+  return (absoluteFile) => {
+    if (session === null)
+      return sessionCwd;
+    const dir = dirname(absoluteFile);
+    let owner = ownerByDir.get(dir);
+    if (owner === undefined) {
+      owner = resolveLinkedWorktreeOwner(session, absoluteFile);
+      ownerByDir.set(dir, owner);
+    }
+    return owner === null ? sessionCwd : owner.spelledRoot;
+  };
+}

package/extensions/dm-lens/clients/tool-agreement.js

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { BoundedFifoMap } from "./bounded-cache.js";
-import { findNearestMarkerRoot } from "./path-utils.js";
+import { load as loadYaml } from "./deps/js-yaml.js";
+import { findNearestMarkerRoot, toPosix } from "./path-utils.js";
 import { getDegradationLedgerGeneration } from "./degradation-ledger.js";
 import {
   hasBlackConfig,
@@ -39,6 +40,12 @@ const NODE_PACKAGES = {
   prettier: "prettier",
   stylelint: "stylelint"
 };
+const NODE_LOCKFILE_PRECEDENCE = [
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock"
+];
+export const NODE_LOCKFILE_MAX_BYTES = 16 * 1024 * 1024;
 export const TOOL_AGREEMENT_POLICIES = {
   biome: { bucket: "node-lockfile", withoutEvidence: "decline" },
   eslint: { bucket: "node-lockfile", withoutEvidence: "decline" },
@@ -289,6 +296,244 @@ function exactOrSimpleRangeMatches(range, version) {
   }
   return { matches: false, unsupported: true };
 }
+function pnpmEvidence(doc, packageName, importerKey) {
+  if (doc && typeof doc === "object" && !Array.isArray(doc)) {
+    const docRecord = doc;
+    const importers = docRecord.importers;
+    if (importers && typeof importers === "object" && !Array.isArray(importers)) {
+      const importer = importers[importerKey];
+      if (importer && typeof importer === "object") {
+        for (const field of ["dependencies", "devDependencies"]) {
+          const deps = importer[field];
+          if (deps && typeof deps === "object") {
+            const entry = deps[packageName];
+            if (entry && typeof entry === "object") {
+              return {
+                kind: "resolved",
+                version: entry.version
+              };
+            }
+          }
+        }
+      }
+      return { kind: "resolved", version: undefined };
+    }
+    let sawTopLevelMaps = false;
+    let v6version;
+    let v6found = false;
+    for (const field of ["dependencies", "devDependencies"]) {
+      const deps = docRecord[field];
+      if (deps && typeof deps === "object" && !Array.isArray(deps)) {
+        sawTopLevelMaps = true;
+        const entry = deps[packageName];
+        if (entry && typeof entry === "object") {
+          v6version = entry.version;
+          v6found = true;
+          break;
+        }
+      }
+    }
+    if (v6found || sawTopLevelMaps) {
+      return { kind: "resolved", version: v6found ? v6version : undefined };
+    }
+  }
+  return { kind: "unsupported-shape" };
+}
+function decideNodeVersionAgreement(tool, packageName, range, version, supplier) {
+  const comparison = typeof version === "string" ? exactOrSimpleRangeMatches(range, version) : { matches: false, unsupported: false };
+  if (typeof version !== "string" || !comparison.matches) {
+    const reasonCode = typeof version === "string" && comparison.unsupported ? "evidence-unsupported" : typeof version === "string" && version.includes("+") ? "evidence-unsupported" : "evidence-unparseable";
+    const reason = typeof version === "string" && comparison.unsupported ? `the project declares ${packageName}@${range} in package.json, but the lockfile shape ${packageName}@${version} in ${supplier} or its range is unsupported; tool agreement cannot be established` : typeof version === "string" && parseCoreVersion(version) ? `the project declares ${packageName}@${range} in package.json, but the lockfile resolves ${packageName}@${version} in ${supplier}; agreement disagrees` : `the project declares ${packageName}@${range} in package.json, but ${supplier} does not establish its resolved version; tool agreement cannot be established`;
+    return {
+      decision: "decline",
+      subject: `node:${tool}`,
+      reason,
+      reasonCode
+    };
+  }
+  return { decision: "established", lockfile: supplier };
+}
+function readLockfileBounded(filePath) {
+  let fd;
+  try {
+    fd = fs.openSync(filePath, "r");
+    const buffer = Buffer.allocUnsafe(Math.min(fs.fstatSync(fd).size, NODE_LOCKFILE_MAX_BYTES) + 1);
+    let total = 0;
+    while (total < buffer.length) {
+      const read = fs.readSync(fd, buffer, total, buffer.length - total, null);
+      if (read === 0)
+        break;
+      total += read;
+    }
+    return total > NODE_LOCKFILE_MAX_BYTES ? { kind: "too-large" } : { kind: "text", text: buffer.toString("utf8", 0, total) };
+  } catch {
+    return { kind: "unreadable" };
+  } finally {
+    if (fd !== undefined) {
+      try {
+        fs.closeSync(fd);
+      } catch {}
+    }
+  }
+}
+function lockfileReadDecline(tool, lockfile, read) {
+  return read.kind === "too-large" ? {
+    decision: "decline",
+    subject: `node:${tool}`,
+    reason: `the project ${lockfile} exceeds the ${NODE_LOCKFILE_MAX_BYTES}-byte lockfile read bound; tool agreement cannot be established`,
+    reasonCode: "evidence-too-large"
+  } : {
+    decision: "decline",
+    subject: `node:${tool}`,
+    reason: `the project ${lockfile} is unreadable; tool agreement cannot be established`,
+    reasonCode: "evidence-unreadable"
+  };
+}
+function stripPnpmPeerSuffix(version) {
+  const core = /^\d+\.\d+\.\d+/.exec(version)?.[0];
+  if (!core || core.length === version.length)
+    return version;
+  let depth = 0;
+  for (let i = core.length;i < version.length; i += 1) {
+    const char = version[i];
+    if (char === "(") {
+      depth += 1;
+    } else if (char === ")") {
+      if (depth === 0 || version[i - 1] === "(")
+        return version;
+      depth -= 1;
+    } else if (depth === 0) {
+      return version;
+    }
+  }
+  return depth === 0 ? core : version;
+}
+function pnpmAgreement(tool, packageName, range, root, lockDir) {
+  const filePath = path.join(lockDir, "pnpm-lock.yaml");
+  const read = readLockfileBounded(filePath);
+  if (read.kind !== "text") {
+    return lockfileReadDecline(tool, "pnpm-lock.yaml", read);
+  }
+  let doc;
+  try {
+    doc = loadYaml(read.text);
+  } catch {
+    return {
+      decision: "decline",
+      subject: `node:${tool}`,
+      reason: "the project pnpm-lock.yaml is unparseable; tool agreement cannot be established",
+      reasonCode: "evidence-unparseable"
+    };
+  }
+  const importerKey = lockDir === path.resolve(root) ? "." : toPosix(path.relative(lockDir, root));
+  const evidence = pnpmEvidence(doc, packageName, importerKey);
+  if (evidence.kind === "unsupported-shape") {
+    return {
+      decision: "decline",
+      subject: `node:${tool}`,
+      reason: "the project pnpm-lock.yaml has an unsupported lockfile shape; tool agreement cannot be established",
+      reasonCode: "evidence-unsupported"
+    };
+  }
+  return decideNodeVersionAgreement(tool, packageName, range, typeof evidence.version === "string" ? stripPnpmPeerSuffix(evidence.version) : evidence.version, "pnpm-lock.yaml");
+}
+function yarnV1Blocks(text, packageName) {
+  const found = [];
+  for (const block of text.split(/\n[ \t]*\n/)) {
+    const lines = block.split(`
+`);
+    const header = (lines[0] ?? "").trim();
+    if (!header.endsWith(":"))
+      continue;
+    const prefix = `${packageName}@`;
+    const descriptors = [];
+    for (const rawPart of header.slice(0, -1).split(",")) {
+      const part = rawPart.trim().replace(/^"|"$/g, "").trim();
+      if (part.startsWith(prefix) && !part.slice(prefix.length).includes(":")) {
+        descriptors.push(part);
+      }
+    }
+    if (descriptors.length === 0)
+      continue;
+    let version;
+    for (const line of lines.slice(1)) {
+      const match = /^\s*version\s+"([^"]*)"/.exec(line);
+      if (match) {
+        version = match[1];
+        break;
+      }
+    }
+    found.push({ descriptors, version });
+  }
+  return found;
+}
+function yarnBerryEntries(doc, packageName) {
+  if (!doc || typeof doc !== "object" || Array.isArray(doc))
+    return;
+  const docRecord = doc;
+  if (!docRecord.__metadata || typeof docRecord.__metadata !== "object")
+    return;
+  const found = [];
+  const marker = "@npm:";
+  for (const [key, entry] of Object.entries(docRecord)) {
+    const unquoted = key.replace(/^"|"$/g, "");
+    const at = unquoted.lastIndexOf(marker);
+    if (at < 0)
+      continue;
+    if (unquoted.slice(0, at) !== packageName)
+      continue;
+    const version = entry && typeof entry === "object" ? entry.version : undefined;
+    found.push({ descriptors: [unquoted.slice(at + marker.length)], version });
+  }
+  return found;
+}
+function selectNodeCandidate(candidates, range) {
+  for (const candidate of candidates) {
+    if (candidate.descriptors.some((descriptor) => descriptor === range)) {
+      return typeof candidate.version === "string" ? candidate.version : undefined;
+    }
+  }
+  const first = candidates.length > 0 ? candidates[0]?.version : undefined;
+  return typeof first === "string" ? first : undefined;
+}
+function yarnAgreement(tool, packageName, range, filePath) {
+  const read = readLockfileBounded(filePath);
+  if (read.kind !== "text")
+    return lockfileReadDecline(tool, "yarn.lock", read);
+  const raw = read.text.replace(/\r\n?/g, `
+`);
+  let doc;
+  let yamlOk = true;
+  try {
+    doc = loadYaml(raw);
+  } catch {
+    yamlOk = false;
+  }
+  if (yamlOk) {
+    const berry = yarnBerryEntries(doc, packageName);
+    if (berry) {
+      return decideNodeVersionAgreement(tool, packageName, range, selectNodeCandidate(berry, range), "yarn.lock");
+    }
+  }
+  const v1 = yarnV1Blocks(raw, packageName);
+  if (v1.length > 0) {
+    return decideNodeVersionAgreement(tool, packageName, range, selectNodeCandidate(v1, range), "yarn.lock");
+  }
+  if (!yamlOk) {
+    return {
+      decision: "decline",
+      subject: `node:${tool}`,
+      reason: "the project yarn.lock is unparseable; tool agreement cannot be established",
+      reasonCode: "evidence-unparseable"
+    };
+  }
+  return {
+    decision: "decline",
+    subject: `node:${tool}`,
+    reason: "the project yarn.lock has an unsupported lockfile shape; tool agreement cannot be established",
+    reasonCode: "evidence-unsupported"
+  };
+}
 function nodeAgreement(tool, root) {
   const packageName = NODE_PACKAGES[tool];
   if (!packageName)
@@ -305,30 +550,48 @@ function nodeAgreement(tool, root) {
   const range = pkg.kind === "value" ? declaredRange(pkg.value, packageName) : undefined;
   if (!range)
     return;
-  const lock = readJson(path.join(root, "package-lock.json"));
-  if (lock.kind === "unreadable" || lock.kind === "unparseable") {
+  const lockDir = findNearestMarkerRoot(root, [...NODE_LOCKFILE_PRECEDENCE], {
+    boundaries: [".git", ".hg", ".svn"]
+  });
+  if (!lockDir) {
     return {
       decision: "decline",
       subject: `node:${tool}`,
-      reason: `the project package-lock.json is ${lock.kind}; tool agreement cannot be established`,
-      reasonCode: `evidence-${lock.kind}`
+      reason: `the project declares ${packageName}@${range} in package.json, but no lockfile (package-lock.json, pnpm-lock.yaml, yarn.lock) establishes its resolved version; tool agreement cannot be established`,
+      reasonCode: "evidence-absent"
     };
   }
-  const packages = lock.kind === "value" ? lock.value.packages : undefined;
-  const entry = packages && typeof packages === "object" ? packages[`node_modules/${packageName}`] : undefined;
-  const version = entry && typeof entry === "object" ? entry.version : undefined;
-  const comparison = typeof version === "string" ? exactOrSimpleRangeMatches(range, version) : { matches: false, unsupported: false };
-  if (typeof version !== "string" || !comparison.matches) {
-    const reasonCode = typeof version === "string" && comparison.unsupported ? "evidence-unsupported" : typeof version === "string" && version.includes("+") ? "evidence-unsupported" : "evidence-unparseable";
-    const reason = typeof version === "string" && comparison.unsupported ? `the project declares ${packageName}@${range}, but the lockfile shape ${packageName}@${version} or its range is unsupported; tool agreement cannot be established` : typeof version === "string" && parseCoreVersion(version) ? `the project declares ${packageName}@${range} in package.json, but the lockfile resolves ${packageName}@${version} in package-lock.json; agreement disagrees` : `the project declares ${packageName}@${range} in package.json, but package-lock.json does not establish its resolved version; tool agreement cannot be established`;
-    return {
-      decision: "decline",
-      subject: `node:${tool}`,
-      reason,
-      reasonCode
-    };
+  const supplier = fs.existsSync(path.join(lockDir, "package-lock.json")) ? "package-lock.json" : fs.existsSync(path.join(lockDir, "pnpm-lock.yaml")) ? "pnpm-lock.yaml" : "yarn.lock";
+  if (supplier === "package-lock.json") {
+    const lock = readJson(path.join(lockDir, "package-lock.json"));
+    if (lock.kind === "unreadable" || lock.kind === "unparseable") {
+      return {
+        decision: "decline",
+        subject: `node:${tool}`,
+        reason: `the project package-lock.json is ${lock.kind}; tool agreement cannot be established`,
+        reasonCode: `evidence-${lock.kind}`
+      };
+    }
+    const packages = lock.kind === "value" ? lock.value.packages : undefined;
+    const entry = packages && typeof packages === "object" ? packages[`node_modules/${packageName}`] : undefined;
+    const version = entry && typeof entry === "object" ? entry.version : undefined;
+    const comparison = typeof version === "string" ? exactOrSimpleRangeMatches(range, version) : { matches: false, unsupported: false };
+    if (typeof version !== "string" || !comparison.matches) {
+      const reasonCode = typeof version === "string" && comparison.unsupported ? "evidence-unsupported" : typeof version === "string" && version.includes("+") ? "evidence-unsupported" : "evidence-unparseable";
+      const reason = typeof version === "string" && comparison.unsupported ? `the project declares ${packageName}@${range}, but the lockfile shape ${packageName}@${version} or its range is unsupported; tool agreement cannot be established` : typeof version === "string" && parseCoreVersion(version) ? `the project declares ${packageName}@${range} in package.json, but the lockfile resolves ${packageName}@${version} in package-lock.json; agreement disagrees` : `the project declares ${packageName}@${range} in package.json, but package-lock.json does not establish its resolved version; tool agreement cannot be established`;
+      return {
+        decision: "decline",
+        subject: `node:${tool}`,
+        reason,
+        reasonCode
+      };
+    }
+    return { decision: "established", lockfile: supplier };
+  }
+  if (supplier === "pnpm-lock.yaml") {
+    return pnpmAgreement(tool, packageName, range, root, lockDir);
   }
-  return { decision: "established" };
+  return yarnAgreement(tool, packageName, range, path.join(lockDir, "yarn.lock"));
 }
 export function establishToolAgreement(tool, cwd) {
   const key = `${getDegradationLedgerGeneration()}\x00${path.resolve(cwd)}\x00${tool}`;

package/extensions/dm-lens/clients/tool-config.js

@@ -139,6 +139,7 @@ export const TOOL_REGISTRY = [
   }
 ];
 export const LENS_TOOL_NAMES = TOOL_REGISTRY.map((tool) => tool.name);
+export const DM_LENS_TOOL_NAMES = TOOL_REGISTRY.flatMap((tool) => tool.piName === undefined ? [] : [tool.piName]);
 export const PI_ONLY_TOOL_REASONS = {
   ast_grep_outline: "pi situational tool with no MCP mirror; MCP parity deferred like read_enclosing was.",
   lens_diagnostic_mark: "dm-lens-internal disposition tool; MCP has no equivalent surface (needs its own engine seam and tool route).",

package/extensions/dm-lens/clients/tool-event.js

@@ -16,3 +16,9 @@ export function resolveToolCallCorrelationId(event) {
   }
   return;
 }
+export function resolveReadEvidenceCorrelationId(event) {
+  const parent = resolveToolCallCorrelationId({
+    toolCallId: event?.parentToolCallId
+  });
+  return parent ?? resolveToolCallCorrelationId(event);
+}

package/extensions/dm-lens/clients/tool-probe.js

@@ -1,4 +1,12 @@
+import * as fs from "node:fs";
+import { join } from "node:path";
+import { getGlobalDmLensDir } from "./file-utils.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
+export function getIsolatedNpxSpawnOptions() {
+  const cwd = join(getGlobalDmLensDir(), "tools");
+  fs.mkdirSync(cwd, { recursive: true });
+  return { cwd, stripNpmConfig: true };
+}
 export async function probeToolAsync(command, args, options) {
   const { cwd: _strippedCwd, ...rest } = options ?? {};
   return safeSpawnAsync(command, [...args], { ...rest });

package/extensions/dm-lens/clients/tool-set-policy.js

@@ -1,38 +1,48 @@
 import { logLatency } from "./latency-logger.js";
-import { BoundedFifoMap } from "./bounded-cache.js";
 import { recordDegradationOnce } from "./degradation-ledger.js";
-export const REMEMBERED_LAZY_TOOLS_MAX_SESSIONS = 128;
-const rememberedLazyToolsBySessionFile = new BoundedFifoMap(REMEMBERED_LAZY_TOOLS_MAX_SESSIONS);
-export function rememberLazyTools(sessionFile, names) {
-  if (!sessionFile) {
+import {
+  defineSessionStore,
+  scopeCell
+} from "./session-scope.js";
+const LAZY_TOOL_MEMORY = "lazy-tool-memory";
+function memory(scope) {
+  return scopeCell(scope, LAZY_TOOL_MEMORY, () => new Set);
+}
+export const lazyToolMemoryStore = defineSessionStore({
+  name: LAZY_TOOL_MEMORY,
+  policy: {
+    startup: "adopt",
+    new: "reset",
+    resume: "adopt",
+    fork: "adopt",
+    reload: "adopt"
+  },
+  snapshot: (scope) => [...memory(scope)],
+  restore: (scope, payload) => {
+    if (!Array.isArray(payload))
+      return { itemsIn: 0, itemsKept: 0 };
+    const before = memory(scope).size;
+    for (const name of payload)
+      if (typeof name === "string")
+        memory(scope).add(name);
+    return { itemsIn: payload.length, itemsKept: memory(scope).size - before };
+  },
+  reason: "the lazy tools a conversation activated, restored on every rebuild so the advertised tool list keeps its prompt-cache prefix"
+});
+export function rememberLazyTools(scope, names) {
+  if (!scope) {
     recordDegradationOnce({
-      kind: "tool-set-session-file-unavailable",
+      kind: "tool-set-scope-unavailable",
       subject: "activation",
-      reason: "session-file identity unavailable; activation memory is inert"
+      reason: "a lazy-tool activation arrived before its session scope began; activation memory is inert"
     });
     return;
   }
-  const remembered = rememberedLazyToolsBySessionFile.get(sessionFile) ?? new Set;
   for (const name of names)
-    remembered.add(name);
-  rememberedLazyToolsBySessionFile.set(sessionFile, remembered);
-}
-export function getRememberedLazyTools(sessionFile) {
-  return sessionFile ? rememberedLazyToolsBySessionFile.get(sessionFile) ?? new Set : new Set;
-}
-export function clearRememberedLazyTools(sessionFile) {
-  if (sessionFile)
-    rememberedLazyToolsBySessionFile.delete(sessionFile);
-}
-export function inheritRememberedLazyTools(parentSessionFile, childSessionFile) {
-  if (!parentSessionFile || !childSessionFile || parentSessionFile === childSessionFile)
-    return;
-  const remembered = rememberedLazyToolsBySessionFile.get(parentSessionFile);
-  if (remembered)
-    rememberedLazyToolsBySessionFile.set(childSessionFile, new Set(remembered));
+    memory(scope).add(name);
 }
-export function resetRememberedLazyToolsForTests() {
-  rememberedLazyToolsBySessionFile.clear();
+export function getRememberedLazyTools(scope) {
+  return scope ? memory(scope) : new Set;
 }
 export function supportsDeferredTools(model) {
   return model?.compat?.supportsToolReferences === true;