@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,77 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,320 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

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