@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/clients/slow-fs.js

@@ -0,0 +1,77 @@
+import { BoundedLruCache } from "./bounded-cache.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { toPositiveFinite } from "./env-utils.js";
+import { normalizeFilePath } from "./path-utils.js";
+export const DEFAULT_SLOW_FS_THRESHOLD_US = 500;
+const PROBE_SAMPLE_CAP = 15;
+function resolveThresholdMicros() {
+  const envValue = toPositiveFinite(process.env.DM_LENS_SLOW_FS_THRESHOLD_US);
+  return envValue > 0 ? envValue : DEFAULT_SLOW_FS_THRESHOLD_US;
+}
+function median(values) {
+  if (values.length === 0)
+    return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+export function probeSlowFs(rootDir) {
+  try {
+    const resolvedRoot = path.resolve(rootDir);
+    const entries = fs.readdirSync(resolvedRoot).slice(0, PROBE_SAMPLE_CAP);
+    if (entries.length === 0) {
+      return { slow: false, medianStatMicros: 0, samples: 0 };
+    }
+    const samplesMicros = [];
+    for (const entry of entries) {
+      const fullPath = path.join(resolvedRoot, entry);
+      const startedAt = process.hrtime.bigint();
+      try {
+        fs.statSync(fullPath);
+      } catch {
+        continue;
+      }
+      const elapsedNs = process.hrtime.bigint() - startedAt;
+      samplesMicros.push(Number(elapsedNs) / 1000);
+    }
+    if (samplesMicros.length === 0) {
+      return { slow: false, medianStatMicros: 0, samples: 0 };
+    }
+    const medianStatMicros = median(samplesMicros);
+    const threshold = resolveThresholdMicros();
+    return {
+      slow: medianStatMicros > threshold,
+      medianStatMicros,
+      samples: samplesMicros.length
+    };
+  } catch {
+    return { slow: false, medianStatMicros: 0, samples: 0 };
+  }
+}
+const slowFsVerdictCache = new BoundedLruCache(32);
+export function getSlowFsVerdict(cwd) {
+  if (process.env.DM_LENS_ALLOW_SLOW_FS_SCAN === "1") {
+    return { slow: false, medianStatMicros: 0, samples: 0 };
+  }
+  if (process.env.DM_LENS_FORCE_SLOW_FS === "1") {
+    return { slow: true, medianStatMicros: 0, samples: 0 };
+  }
+  const key = normalizeFilePath(path.resolve(cwd));
+  const cached = slowFsVerdictCache.get(key);
+  if (cached)
+    return cached;
+  const result = probeSlowFs(cwd);
+  slowFsVerdictCache.set(key, result);
+  return result;
+}
+export function isSlowFs(cwd) {
+  return getSlowFsVerdict(cwd).slow;
+}
+export function _resetSlowFsForTests() {
+  slowFsVerdictCache.clear();
+}
+export const SLOW_FS_REDUCED_MAX_FILES = 500;
+export function slowFsDegradationNotice() {
+  return "slow filesystem detected (set DM_LENS_ALLOW_SLOW_FS_SCAN=1 to override)";
+}

package/extensions/dm-lens/dist/clients/smells-rollup.js

@@ -0,0 +1,118 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getGlobalDmLensLogDir } from "./probe-home-state.js";
+export const SMELLS_TAIL_BYTES_PER_FILE = 64 * 1024;
+const SMELLS_ROLLING_WINDOW_MS = 24 * 60 * 60000;
+const SMELLS_TURN_CHECK_INTERVAL = 20;
+export const SMELLS_THRESHOLDS = {
+  staleCtxEmitFailed: 5,
+  opengrepRespawn: 5
+};
+const SMELL_LABELS = {
+  staleCtxEmitFailed: "stale-ctx emit_failed (bus-events.log)",
+  opengrepRespawn: "opengrep respawn (latency.log)"
+};
+const SMELL_KEYS = ["staleCtxEmitFailed", "opengrepRespawn"];
+export function tailReadText(filePath, maxBytes) {
+  let fd;
+  try {
+    fd = fs.openSync(filePath, "r");
+  } catch {
+    return "";
+  }
+  try {
+    const size = fs.fstatSync(fd).size;
+    const readBytes = Math.min(size, maxBytes);
+    if (readBytes <= 0)
+      return "";
+    const start = size - readBytes;
+    const buf = Buffer.alloc(readBytes);
+    fs.readSync(fd, buf, 0, readBytes, start);
+    const text = buf.toString("utf8");
+    if (start <= 0)
+      return text;
+    const firstNewline = text.indexOf(`
+`);
+    return firstNewline >= 0 ? text.slice(firstNewline + 1) : "";
+  } catch {
+    return "";
+  } finally {
+    try {
+      fs.closeSync(fd);
+    } catch {}
+  }
+}
+function countMatchingLines(text, predicate, sessionStartMs) {
+  let count = 0;
+  for (const line of text.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry && typeof entry === "object" && (sessionStartMs === undefined || isAtOrAfterSessionStart(entry, sessionStartMs)) && predicate(entry)) {
+      count++;
+    }
+  }
+  return count;
+}
+function isAtOrAfterSessionStart(entry, sessionStartMs) {
+  const timestamp = typeof entry.ts === "string" ? Date.parse(entry.ts) : NaN;
+  return Number.isFinite(timestamp) && timestamp >= sessionStartMs;
+}
+function isStaleCtxEmitFailed(entry) {
+  return entry.outcome === "emit_failed" && typeof entry.error === "string" && entry.error.includes("stale after session replacement");
+}
+function isOpengrepRespawn(entry) {
+  if (entry.phase !== "lsp_server_respawn")
+    return false;
+  const metadata = entry.metadata;
+  return metadata?.serverId === "opengrep";
+}
+export function countRecentSmells(root = getGlobalDmLensLogDir(), sessionStartMs) {
+  const sinceMs = sessionStartMs ?? Date.now() - SMELLS_ROLLING_WINDOW_MS;
+  const busTail = tailReadText(path.join(root, "bus-events.log"), SMELLS_TAIL_BYTES_PER_FILE);
+  const latencyTail = tailReadText(path.join(root, "latency.log"), SMELLS_TAIL_BYTES_PER_FILE);
+  return {
+    staleCtxEmitFailed: countMatchingLines(busTail, isStaleCtxEmitFailed, sinceMs),
+    opengrepRespawn: countMatchingLines(latencyTail, isOpengrepRespawn, sinceMs)
+  };
+}
+export function formatSmellsSessionStartLine(counts) {
+  const bits = [];
+  for (const key of SMELL_KEYS) {
+    if (counts[key] >= SMELLS_THRESHOLDS[key]) {
+      bits.push(`${SMELL_LABELS[key]} x${counts[key]}`);
+    }
+  }
+  if (bits.length === 0)
+    return null;
+  const tailKb = Math.round(SMELLS_TAIL_BYTES_PER_FILE / 1024);
+  return `session_start smells (last ${tailKb}KB tail): ${bits.join(", ")} — run \`npm run logs:smells\` for detail`;
+}
+export function formatSmellsHealthLine(counts) {
+  return `Smells (last 24h tail-scan): stale-ctx emit_failed=${counts.staleCtxEmitFailed}` + ` · opengrep respawn=${counts.opengrepRespawn}`;
+}
+export function shouldCheckSmellsThisTurn(turnIndex) {
+  return turnIndex > 0 && turnIndex % SMELLS_TURN_CHECK_INTERVAL === 0;
+}
+const notifiedThisSession = new Set;
+export function checkSmellsAndNoteOnce(counts) {
+  const notes = [];
+  for (const key of SMELL_KEYS) {
+    if (notifiedThisSession.has(key))
+      continue;
+    if (counts[key] >= SMELLS_THRESHOLDS[key]) {
+      notifiedThisSession.add(key);
+      notes.push(`dm-lens smell: ${SMELL_LABELS[key]} x${counts[key]} (recent tail-scan) — run \`npm run logs:smells\` for detail`);
+    }
+  }
+  return notes;
+}
+export function resetSmellsSessionState() {
+  notifiedThisSession.clear();
+}

package/extensions/dm-lens/dist/clients/source-filter.js

@@ -0,0 +1,320 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectIgnoreMatcher } from "./file-utils.js";
+import { classifyGeneratedOrArtifactDetailed, isDeclarationFile } from "./generated-artifacts.js";
+import { isCodeKindFile, KIND_EXTENSIONS } from "./file-kinds.js";
+import { logLatency } from "./latency-logger.js";
+import { normalizeEphemeralMapKey } from "./path-utils.js";
+import { isSlowFs, SLOW_FS_REDUCED_MAX_FILES } from "./slow-fs.js";
+import { shouldRecurseIntoDir, walkTreeRecursiveSync, walkTreeStackAsync } from "./source-walker.js";
+export function createArtifactProbeCache() {
+  return new Map;
+}
+function probeExists(filePath, cache) {
+  if (!cache)
+    return fs.existsSync(filePath);
+  const key = normalizeEphemeralMapKey(filePath);
+  const cached = cache.get(key);
+  if (cached !== undefined)
+    return cached;
+  const result = fs.existsSync(filePath);
+  cache.set(key, result);
+  return result;
+}
+export const SOURCE_PRECEDENCE = {
+  ".ts": [".js", ".jsx", ".mjs", ".cjs"],
+  ".tsx": [".jsx", ".js", ".mjs", ".cjs"],
+  ".mts": [".mjs", ".js", ".jsx", ".cjs"],
+  ".cts": [".cjs", ".js", ".jsx", ".mjs"],
+  ".vue": [".js", ".mjs"],
+  ".svelte": [".js", ".mjs"],
+  ".coffee": [".js"]
+};
+export function sourceTwinCandidates(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const stem = filePath.slice(0, filePath.length - ext.length);
+  const sourceExts = ext === ".mjs" ? [".mts", ".ts", ".tsx", ".cts"] : ext === ".cjs" ? [".cts", ".ts", ".tsx", ".mts"] : ext === ".jsx" ? [".tsx", ".ts", ".mts", ".cts"] : ext === ".js" ? [".ts", ".tsx", ".mts", ".cts"] : [];
+  return sourceExts.map((sourceExt) => `${stem}${sourceExt}`);
+}
+export function canonicalSourceTwin(filePath, availableFiles, excludedFiles) {
+  for (const candidate of sourceTwinCandidates(filePath)) {
+    if (availableFiles.has(candidate) && !excludedFiles?.has(candidate)) {
+      return candidate;
+    }
+  }
+  return filePath;
+}
+export const ALL_SCANNABLE_EXTENSIONS = [
+  ...new Set([
+    ...Object.values(KIND_EXTENSIONS).flat(),
+    ...Object.keys(SOURCE_PRECEDENCE)
+  ])
+];
+export const DEFAULT_MAX_SOURCE_FILES = 20000;
+export const DEFAULT_MAX_SCAN_ENTRIES = 200000;
+function createKeptFilesAccumulator(maxFiles, prioritizeCodeKinds) {
+  if (!prioritizeCodeKinds) {
+    const files = [];
+    return {
+      push: (file) => void files.push(file),
+      isFull: () => files.length >= maxFiles,
+      list: () => files
+    };
+  }
+  const codeFiles = [];
+  const otherFiles = [];
+  return {
+    push(file) {
+      if (isCodeKindFile(file))
+        codeFiles.push(file);
+      else if (otherFiles.length < maxFiles)
+        otherFiles.push(file);
+    },
+    isFull: () => codeFiles.length >= maxFiles,
+    list: () => [...codeFiles, ...otherFiles].slice(0, maxFiles)
+  };
+}
+function createSourceWalkSkipCounters() {
+  return {
+    generatedOrArtifactSkips: 0,
+    buildArtifactSkips: 0,
+    generatedDirSkips: 0,
+    generatedNameOverrides: 0,
+    generatedNameOnlySkips: 0
+  };
+}
+function logSourceWalkSkipsIfAny(rootDir, counters) {
+  if (counters.generatedOrArtifactSkips === 0 && counters.buildArtifactSkips === 0 && counters.generatedDirSkips === 0 && counters.generatedNameOverrides === 0) {
+    return;
+  }
+  logLatency({
+    type: "phase",
+    phase: "source_walk_skip_summary",
+    filePath: rootDir,
+    durationMs: 0,
+    metadata: {
+      generatedOrArtifactSkips: counters.generatedOrArtifactSkips,
+      buildArtifactSkips: counters.buildArtifactSkips,
+      generatedDirSkips: counters.generatedDirSkips,
+      generatedNameOverrides: counters.generatedNameOverrides,
+      generatedNameOnlySkips: counters.generatedNameOnlySkips
+    }
+  });
+}
+function classifySkipGeneratedOrArtifact(filePath, options) {
+  const includeDeclarations = options?.includeDeclarationFiles === true;
+  if (options?.includeGenerated === true) {
+    return !includeDeclarations && isDeclarationFile(filePath) ? { verdict: "generated", evidence: "strong" } : { verdict: "clean" };
+  }
+  return classifyGeneratedOrArtifactDetailed(filePath, {
+    readContentHeader: options?.inspectGeneratedHeaders !== false,
+    includeDeclarations: !includeDeclarations
+  });
+}
+function shouldSkipGeneratedOrArtifact(filePath, options) {
+  return classifySkipGeneratedOrArtifact(filePath, options).verdict === "generated";
+}
+function getBasename(filePath) {
+  const ext = path.extname(filePath);
+  return path.basename(filePath, ext);
+}
+function getDir(filePath) {
+  return path.dirname(filePath);
+}
+export function findSourceSibling(filePath, probeCache) {
+  for (const candidate of sourceTwinCandidates(filePath)) {
+    if (probeExists(candidate, probeCache))
+      return candidate;
+  }
+  const ext = path.extname(filePath).toLowerCase();
+  const dir = getDir(filePath);
+  const base = getBasename(filePath);
+  for (const [sourceExt, shadowedExts] of Object.entries(SOURCE_PRECEDENCE)) {
+    if (!sourceExtsForCompiledExt(sourceExt).length && shadowedExts.includes(ext)) {
+      const siblingPath = path.join(dir, base + sourceExt);
+      if (probeExists(siblingPath, probeCache))
+        return siblingPath;
+    }
+  }
+  return null;
+}
+function sourceExtsForCompiledExt(sourceExt) {
+  return sourceExt === ".ts" || sourceExt === ".tsx" || sourceExt === ".mts" || sourceExt === ".cts" ? [sourceExt] : [];
+}
+export function isBuildArtifact(filePath, probeCache) {
+  return findSourceSibling(filePath, probeCache) !== null;
+}
+export function filterSourceFiles(filePaths, options) {
+  const keep = [];
+  const skipReasons = new Map;
+  const probeCache = createArtifactProbeCache();
+  for (const filePath of filePaths) {
+    const sourceSibling = findSourceSibling(filePath, probeCache);
+    if (sourceSibling) {
+      skipReasons.set(filePath, sourceSibling);
+    } else if (shouldSkipGeneratedOrArtifact(filePath, options)) {
+      skipReasons.set(filePath, "generated-or-artifact");
+    } else {
+      keep.push(filePath);
+    }
+  }
+  return keep;
+}
+function resolveFiniteCap(raw, fallback) {
+  return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : fallback;
+}
+function resolveCollectionConfig(rootDir, options, config) {
+  const requestedMax = resolveFiniteCap(options?.maxFiles, DEFAULT_MAX_SOURCE_FILES);
+  const maxFiles = config?.clampForSlowFsSyncWalk === true && isSlowFs(rootDir) ? Math.min(requestedMax, SLOW_FS_REDUCED_MAX_FILES) : requestedMax;
+  return {
+    ignoreMatcher: getProjectIgnoreMatcher(rootDir),
+    extraExcludePatterns: options?.excludeDirs ?? [],
+    extensions: new Set(options?.extensions || ALL_SCANNABLE_EXTENSIONS),
+    maxFiles,
+    maxScanEntries: resolveFiniteCap(options?.maxScanEntries, DEFAULT_MAX_SCAN_ENTRIES),
+    options
+  };
+}
+function classifyEntry(entry, fullPath, cfg, probeCache, skipCounters) {
+  const { ignoreMatcher, extraExcludePatterns, extensions, options } = cfg;
+  if (entry.isDirectory()) {
+    const canRecurse = shouldRecurseIntoDir(entry, fullPath, {
+      ignoreMatcher,
+      extraExcludeDirs: extraExcludePatterns,
+      skipGeneratedArtifactDirs: options?.includeGenerated !== true,
+      followSymlinks: options?.followSymlinks === true
+    }, skipCounters ? () => {
+      skipCounters.generatedDirSkips += 1;
+    } : undefined);
+    if (!canRecurse)
+      return {};
+    return { recurseInto: fullPath };
+  }
+  if (entry.isFile()) {
+    const ext = path.extname(entry.name).toLowerCase();
+    if (!extensions.has(ext))
+      return {};
+    if (ignoreMatcher.isIgnored(fullPath, false))
+      return {};
+    if (isBuildArtifact(fullPath, probeCache)) {
+      if (skipCounters)
+        skipCounters.buildArtifactSkips += 1;
+      return {};
+    }
+    const classification = classifySkipGeneratedOrArtifact(fullPath, options);
+    if (classification.verdict === "generated") {
+      if (skipCounters) {
+        skipCounters.generatedOrArtifactSkips += 1;
+        if (classification.evidence === "name-only") {
+          skipCounters.generatedNameOnlySkips += 1;
+        }
+      }
+      return {};
+    }
+    if (classification.verdict === "override" && skipCounters) {
+      skipCounters.generatedNameOverrides += 1;
+    }
+    return { keepFile: fullPath };
+  }
+  return {};
+}
+function createEntryBudget(limit) {
+  return { visited: 0, limit, exceeded: false };
+}
+function chargeEntryBudget(budget) {
+  if (budget.exceeded)
+    return false;
+  budget.visited += 1;
+  if (budget.visited > budget.limit)
+    budget.exceeded = true;
+  return !budget.exceeded;
+}
+export function collectSourceFilesWithBudget(dir, options) {
+  const rootDir = path.resolve(dir);
+  const cfg = resolveCollectionConfig(rootDir, options, {
+    clampForSlowFsSyncWalk: true
+  });
+  const kept = createKeptFilesAccumulator(cfg.maxFiles, options?.prioritizeCodeKinds === true);
+  const probeCache = createArtifactProbeCache();
+  const budget = createEntryBudget(cfg.maxScanEntries);
+  const skipCounters = createSourceWalkSkipCounters();
+  walkTreeRecursiveSync(rootDir, (entry, fullPath) => {
+    if (kept.isFull())
+      return "stop";
+    if (!chargeEntryBudget(budget))
+      return "stop";
+    const { recurseInto, keepFile } = classifyEntry(entry, fullPath, cfg, probeCache, skipCounters);
+    if (recurseInto)
+      return "recurse";
+    if (keepFile)
+      kept.push(keepFile);
+    return "skip";
+  });
+  logSourceWalkSkipsIfAny(rootDir, skipCounters);
+  return {
+    files: kept.list(),
+    entryBudgetExceeded: budget.exceeded,
+    generatedOrArtifactSkips: skipCounters.generatedOrArtifactSkips,
+    buildArtifactSkips: skipCounters.buildArtifactSkips,
+    generatedDirSkips: skipCounters.generatedDirSkips,
+    generatedNameOverrides: skipCounters.generatedNameOverrides,
+    generatedNameOnlySkips: skipCounters.generatedNameOnlySkips
+  };
+}
+export function collectSourceFiles(dir, options) {
+  return collectSourceFilesWithBudget(dir, options).files;
+}
+export async function collectSourceFilesAsync(dir, options) {
+  return (await collectSourceFilesWithBudgetAsync(dir, options)).files;
+}
+export async function collectSourceFilesWithBudgetAsync(dir, options) {
+  const rootDir = path.resolve(dir);
+  const cfg = resolveCollectionConfig(rootDir, options);
+  const kept = createKeptFilesAccumulator(cfg.maxFiles, options?.prioritizeCodeKinds === true);
+  const probeCache = createArtifactProbeCache();
+  const budget = createEntryBudget(cfg.maxScanEntries);
+  const skipCounters = createSourceWalkSkipCounters();
+  await walkTreeStackAsync(rootDir, (entry, fullPath) => {
+    options?.onEntryVisited?.();
+    if (!chargeEntryBudget(budget))
+      return "stop";
+    const { recurseInto, keepFile } = classifyEntry(entry, fullPath, cfg, probeCache, skipCounters);
+    if (recurseInto)
+      return "recurse";
+    if (keepFile) {
+      kept.push(keepFile);
+      if (kept.isFull())
+        return "stop";
+    }
+    return "skip";
+  }, {
+    budgetMs: Math.max(1, options?.budgetMs ?? 8),
+    beforeWalk: () => cfg.ignoreMatcher.ensureTrackedIndex()
+  });
+  logSourceWalkSkipsIfAny(rootDir, skipCounters);
+  return {
+    files: kept.list(),
+    entryBudgetExceeded: budget.exceeded,
+    generatedOrArtifactSkips: skipCounters.generatedOrArtifactSkips,
+    buildArtifactSkips: skipCounters.buildArtifactSkips,
+    generatedDirSkips: skipCounters.generatedDirSkips,
+    generatedNameOverrides: skipCounters.generatedNameOverrides,
+    generatedNameOnlySkips: skipCounters.generatedNameOnlySkips
+  };
+}
+export function getFilterStats(allFiles, filteredFiles) {
+  const skipped = allFiles.length - filteredFiles.length;
+  const byType = {};
+  for (const file of allFiles) {
+    if (!filteredFiles.includes(file)) {
+      const ext = path.extname(file).toLowerCase();
+      byType[ext] = (byType[ext] || 0) + 1;
+    }
+  }
+  return {
+    total: allFiles.length,
+    kept: filteredFiles.length,
+    skipped,
+    byType
+  };
+}

package/extensions/dm-lens/dist/clients/source-walker.js

@@ -0,0 +1,96 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isExcludedDirName } from "./file-utils.js";
+import { isGeneratedArtifactDirectoryName } from "./generated-artifacts.js";
+import { createDeadline, yieldIfOverBudget } from "./cooperative-budget.js";
+export function readDirEntriesSafe(dirPath) {
+  try {
+    return fs.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+export async function readDirEntriesSafeAsync(dirPath) {
+  try {
+    return await fs.promises.readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+export function shouldRecurseIntoDir(entry, fullPath, policy, onGeneratedDirSkip) {
+  if (isExcludedDirName(entry.name, policy.extraExcludeDirs ?? [])) {
+    return false;
+  }
+  if (policy.ignoreMatcher.isIgnored(fullPath, true))
+    return false;
+  if (policy.skipGeneratedArtifactDirs === true && isGeneratedArtifactDirectoryName(entry.name)) {
+    onGeneratedDirSkip?.();
+    return false;
+  }
+  if (policy.followSymlinks !== true && entry.isSymbolicLink())
+    return false;
+  return true;
+}
+function* walkTreeStackSteps(rootDir, visit, shouldStop) {
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    if (shouldStop?.())
+      return false;
+    const dir = stack.pop();
+    if (dir === undefined)
+      continue;
+    const entries = (yield dir) ?? [];
+    const subDirs = [];
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const disposition = visit(entry, fullPath);
+      if (disposition === "stop")
+        return true;
+      if (disposition === "recurse")
+        subDirs.push(fullPath);
+      yield undefined;
+    }
+    for (let i = subDirs.length - 1;i >= 0; i--)
+      stack.push(subDirs[i]);
+  }
+  return false;
+}
+export function walkTreeStackSync(rootDir, visit, opts = {}) {
+  const steps = walkTreeStackSteps(rootDir, visit, opts.shouldStop);
+  let step = steps.next();
+  while (!step.done) {
+    step = steps.next(step.value === undefined ? undefined : readDirEntriesSafe(step.value));
+  }
+  return step.value;
+}
+export async function walkTreeStackAsync(rootDir, visit, opts) {
+  await opts.beforeWalk?.();
+  const steps = walkTreeStackSteps(rootDir, visit, opts.shouldStop);
+  const deadline = createDeadline(opts.budgetMs ?? 8);
+  let step = steps.next();
+  while (!step.done) {
+    if (step.value !== undefined) {
+      step = steps.next(await readDirEntriesSafeAsync(step.value));
+      deadline.reset();
+      continue;
+    }
+    if (deadline.expired())
+      await yieldIfOverBudget(deadline);
+    step = steps.next();
+  }
+  return step.value;
+}
+export function walkTreeRecursiveSync(rootDir, visit) {
+  function scan(currentDir) {
+    for (const entry of readDirEntriesSafe(currentDir)) {
+      const fullPath = path.join(currentDir, entry.name);
+      const disposition = visit(entry, fullPath);
+      if (disposition === "stop")
+        return true;
+      if (disposition === "recurse" && scan(fullPath))
+        return true;
+    }
+    return false;
+  }
+  return scan(rootDir);
+}

package/extensions/dm-lens/dist/clients/spawn-output-cap.js

@@ -0,0 +1,35 @@
+export const DEFAULT_MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
+export function createBoundedOutputSink(maxBytes = DEFAULT_MAX_OUTPUT_BYTES) {
+  let text = "";
+  let retained = 0;
+  let truncated = false;
+  let observed = 0;
+  return {
+    append(chunk) {
+      const part = typeof chunk === "string" ? chunk : chunk.toString();
+      const bytes = Buffer.byteLength(part);
+      observed += bytes;
+      if (retained + bytes <= maxBytes) {
+        retained += bytes;
+        text += part;
+        return;
+      }
+      truncated = true;
+    },
+    get text() {
+      return text;
+    },
+    get truncated() {
+      return truncated;
+    },
+    get observedBytes() {
+      return observed;
+    }
+  };
+}
+export function truncatedByOutputCap(result) {
+  return result.outputTruncated === true && result.failure !== "timeout" && result.failure !== "aborted";
+}
+export function killedForOutputCap(result) {
+  return result.killedForOutputCap === true && result.failure !== "timeout" && result.failure !== "aborted";
+}

package/extensions/dm-lens/dist/clients/spawn-timeout-cooldown.js

@@ -0,0 +1,51 @@
+import path from "node:path";
+import { logLatency } from "./latency-logger.js";
+import { normalizeLoggedPath } from "./path-utils.js";
+const COOLDOWN_STATE_KEY = Symbol.for("dm-lens:spawn-timeout-cooldown");
+const _global = globalThis;
+if (!_global[COOLDOWN_STATE_KEY]) {
+  _global[COOLDOWN_STATE_KEY] = { timedOutByCommand: new Map };
+}
+const timedOutByCommand = _global[COOLDOWN_STATE_KEY].timedOutByCommand;
+function wrapperKindOf(command) {
+  const ext = path.extname(command);
+  return ext ? ext.slice(1) : "bare";
+}
+function cooldownKey(command) {
+  return path.basename(command).replace(/\.[^.]+$/, "").toLowerCase();
+}
+export function noteSpawnTimeout(input) {
+  const key = cooldownKey(input.command);
+  timedOutByCommand.set(key, {
+    tool: input.tool,
+    command: input.command,
+    phase: input.phase,
+    atMs: Date.now()
+  });
+  logLatency({
+    type: "phase",
+    toolName: input.tool,
+    phase: "spawn_timeout_cooldown",
+    filePath: normalizeLoggedPath(input.command),
+    durationMs: input.durationMs ?? 0,
+    status: "cooldown_armed",
+    metadata: {
+      command: input.command,
+      wrapperKind: wrapperKindOf(input.command),
+      timeoutPhase: input.phase,
+      ...input.durationMs !== undefined && {
+        timeoutBudgetMs: input.durationMs
+      },
+      ...input.teardown && {
+        teardownMs: input.teardown.ms,
+        teardownOutcome: input.teardown.outcome
+      }
+    }
+  });
+}
+export function isInSpawnTimeoutCooldown(command) {
+  return timedOutByCommand.has(cooldownKey(command));
+}
+export function resetSpawnTimeoutCooldowns() {
+  timedOutByCommand.clear();
+}

package/extensions/dm-lens/dist/clients/stale-marker.js

@@ -0,0 +1 @@
+export const STALE_LINE_MARKER = "[stale — re-run to confirm]";