@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/package-manager.js

@@ -1,303 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { classifyProbeFailure, createAvailabilityLatch, isTransientDecision, logAvailabilityDecision, startHostStallSampler } from "./dispatch/runners/utils/availability-policy.js";
-import { safeSpawnAsync } from "./safe-spawn.js";
-import { probeToolAsync } from "./tool-probe.js";
-import { createAvailabilityProbeFlight } from "./availability-probe-flight.js";
-import { createGenerationSource } from "./generation-guard.js";
-import { isAtOrAboveHomeDir, walkUpDirs } from "./path-utils.js";
-const PREFERENCE = [
-  "npm",
-  "pnpm",
-  "yarn",
-  "bun"
-];
-const packageManagerProbeFlights = createAvailabilityProbeFlight();
-function onWindows() {
-  return process.platform === "win32";
-}
-function isNodePackageManager(value) {
-  return value === "npm" || value === "pnpm" || value === "yarn" || value === "bun";
-}
-export function detectNodePackageManager(targetPath) {
-  if (fs.existsSync(path.join(targetPath, "bun.lockb")) || fs.existsSync(path.join(targetPath, "bun.lock"))) {
-    return "bun";
-  }
-  if (fs.existsSync(path.join(targetPath, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (fs.existsSync(path.join(targetPath, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (fs.existsSync(path.join(targetPath, "package-lock.json"))) {
-    return "npm";
-  }
-  return readPackageManagerField(targetPath);
-}
-function readPackageManagerField(targetPath) {
-  try {
-    const pkgPath = path.join(targetPath, "package.json");
-    if (!fs.existsSync(pkgPath))
-      return;
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    if (typeof pkg.packageManager !== "string")
-      return;
-    const name = pkg.packageManager.split("@")[0].trim().toLowerCase();
-    return isNodePackageManager(name) ? name : undefined;
-  } catch {
-    return;
-  }
-}
-const PROBE_TIMEOUT_MS = 5000;
-const availabilityLatches = new Map;
-function getLatch(pm) {
-  let latch = availabilityLatches.get(pm);
-  if (!latch) {
-    latch = createAvailabilityLatch();
-    availabilityLatches.set(pm, latch);
-  }
-  return latch;
-}
-async function probeAvailability(pm) {
-  const latch = getLatch(pm);
-  const startedAt = Date.now();
-  const finder = onWindows() ? "where" : "which";
-  const sampler = startHostStallSampler();
-  let result;
-  let hostStallMs;
-  try {
-    result = await probeToolAsync(finder, [pm], { timeout: PROBE_TIMEOUT_MS });
-  } finally {
-    hostStallMs = sampler.stop();
-  }
-  const elapsedMs = Date.now() - startedAt;
-  if (result.status === 0 && !result.error) {
-    latch.noteAvailable();
-    logAvailabilityDecision({
-      tool: pm,
-      verdict: "available",
-      outcome: "success",
-      cause: "ok",
-      elapsedMs,
-      latched: true,
-      hostStallMs,
-      budgetMs: PROBE_TIMEOUT_MS,
-      classifiedBy: "probe"
-    });
-    return true;
-  }
-  const { outcome, cause, evidence } = classifyProbeFailure(result, {
-    hostStallMs,
-    unclassifiedFailureOutcome: "missing"
-  });
-  const retryAfterMs = latch.noteUnavailable(outcome, cause);
-  logAvailabilityDecision({
-    tool: pm,
-    verdict: "unavailable",
-    outcome,
-    cause,
-    elapsedMs,
-    latched: outcome !== "transient",
-    hostStallMs,
-    ...retryAfterMs > 0 && { retryAfterMs },
-    budgetMs: PROBE_TIMEOUT_MS,
-    classifiedBy: "probe",
-    evidence
-  });
-  return false;
-}
-function isAvailable(pm, onTransient) {
-  const latch = getLatch(pm);
-  const reportIfTransient = (result) => {
-    if (!result && isTransientDecision({ outcome: latch.getOutcome() })) {
-      onTransient?.();
-    }
-    return result;
-  };
-  const memo = latch.read();
-  if (memo !== null)
-    return Promise.resolve(reportIfTransient(memo));
-  const shared = packageManagerProbeFlights.run(`package-manager:${pm}`, () => probeAvailability(pm));
-  return shared.promise.then(reportIfTransient);
-}
-export function _resetPackageManagerCache() {
-  packageManagerCacheGeneration.bump();
-  availabilityLatches.clear();
-  packageManagerProbeFlights.clear();
-  globalBinDirCache.clear();
-  globalBinDirProbeFlights.clear();
-}
-export async function resolveNodePackageManager(cwd = process.cwd()) {
-  const declared = detectNodePackageManager(cwd);
-  if (declared && await isAvailable(declared)) {
-    return declared;
-  }
-  for (const pm of PREFERENCE) {
-    if (await isAvailable(pm))
-      return pm;
-  }
-  return "npm";
-}
-export function pmBinary(pm) {
-  if (!onWindows())
-    return pm;
-  return pm === "bun" ? "bun.exe" : `${pm}.cmd`;
-}
-export function runScriptArgs(script) {
-  return ["run", script];
-}
-export function formatRunScript(pm, script) {
-  return `${pm} run ${script}`;
-}
-export function installArgs(pm, pkg, options = {}) {
-  const args = [pm === "npm" ? "install" : "add"];
-  if (options.ignoreScripts)
-    args.push("--ignore-scripts");
-  if (options.legacyPeerDeps && pm === "npm")
-    args.push("--legacy-peer-deps");
-  args.push(pkg);
-  return args;
-}
-export function updateArgs(pm, pkg, options = {}) {
-  const args = [pm === "yarn" ? "upgrade" : "update"];
-  if (options.ignoreScripts)
-    args.push("--ignore-scripts");
-  args.push(pkg);
-  return args;
-}
-export function globalInstallArgs(pm, pkg) {
-  switch (pm) {
-    case "yarn":
-      return ["global", "add", pkg];
-    case "npm":
-      return ["install", "-g", pkg];
-    default:
-      return ["add", "-g", pkg];
-  }
-}
-export function execArgs(pm, pkg, args = []) {
-  switch (pm) {
-    case "bun":
-      return { command: pmBinary("bun"), args: ["x", pkg, ...args] };
-    case "pnpm":
-      return { command: pmBinary("pnpm"), args: ["dlx", pkg, ...args] };
-    case "yarn":
-      return { command: pmBinary("yarn"), args: ["dlx", pkg, ...args] };
-    default:
-      return {
-        command: onWindows() ? "npx.cmd" : "npx",
-        args: ["--no", pkg, ...args]
-      };
-  }
-}
-const globalBinDirCache = new Map;
-const packageManagerCacheGeneration = createGenerationSource("package-manager-global-bin");
-const globalBinDirProbeFlights = createAvailabilityProbeFlight();
-async function globalBinDirsFor(pm) {
-  const cached = globalBinDirCache.get(pm);
-  if (cached)
-    return cached;
-  const generation = packageManagerCacheGeneration.capture();
-  const shared = globalBinDirProbeFlights.run(pm, () => probeGlobalBinDirs(pm, generation));
-  return shared.promise;
-}
-async function probeGlobalBinDirs(pm, generation) {
-  if (pm === "bun") {
-    const base = process.env.BUN_INSTALL || path.join(os.homedir(), ".bun");
-    const dirs = [path.join(base, "bin")];
-    generation.guardedWrite(pm, () => {
-      globalBinDirCache.set(pm, dirs);
-    });
-    return dirs;
-  }
-  const query = pm === "npm" ? ["config", "get", "prefix"] : pm === "pnpm" ? ["bin", "-g"] : ["global", "bin"];
-  const res = await safeSpawnAsync(pmBinary(pm), query, { timeout: 5000 });
-  if (res.status !== 0 || res.error)
-    return [];
-  const out = res.stdout.trim();
-  if (!out)
-    return [];
-  const dirs = pm === "npm" ? [onWindows() ? out : path.join(out, "bin")] : [out];
-  generation.guardedWrite(pm, () => {
-    globalBinDirCache.set(pm, dirs);
-  });
-  return dirs;
-}
-export async function allAvailableGlobalBinDirs(onTransient) {
-  const dirs = [];
-  const seen = new Set;
-  for (const pm of PREFERENCE) {
-    if (!await isAvailable(pm, onTransient))
-      continue;
-    for (const dir of await globalBinDirsFor(pm)) {
-      const normalized = path.resolve(dir);
-      if (seen.has(normalized))
-        continue;
-      seen.add(normalized);
-      dirs.push(normalized);
-    }
-  }
-  return dirs;
-}
-export async function findGlobalBinary(command, windowsExt = ".cmd") {
-  const candidates = onWindows() ? [`${command}${windowsExt}`, `${command}.exe`, command] : [command];
-  try {
-    for (const binDir of await allAvailableGlobalBinDirs()) {
-      for (const name of candidates) {
-        const full = path.join(binDir, name);
-        if (fs.existsSync(full))
-          return full;
-      }
-    }
-  } catch {}
-  return;
-}
-export const NODE_MODULES_BIN_DIRS = [
-  path.join("node_modules", ".bin")
-];
-export const VENDOR_BIN_DIRS = [path.join("vendor", "bin")];
-export const VENV_BIN_DIRS = [
-  path.join(".venv", "bin"),
-  path.join("venv", "bin"),
-  path.join(".venv", "Scripts"),
-  path.join("venv", "Scripts")
-];
-function expandCandidateNames(tools, windowsExt, isWindows) {
-  return isWindows && windowsExt !== "" ? tools.flatMap((tool) => [`${tool}${windowsExt}`, tool]) : [...tools];
-}
-function* matchesInDir(dir, names, binDirs) {
-  for (const name of names) {
-    for (const binDir of binDirs) {
-      const full = path.join(dir, binDir, name);
-      if (fs.existsSync(full))
-        yield full;
-    }
-  }
-}
-function* localBinMatches(tools, startDir, options) {
-  const { windowsExt = ".cmd", homeDir = os.homedir(), binDirs = NODE_MODULES_BIN_DIRS, isWindows = onWindows(), ceiling = true } = options;
-  const names = expandCandidateNames(tools, windowsExt, isWindows);
-  for (const dir of walkUpDirs(startDir)) {
-    if (ceiling && isAtOrAboveHomeDir(dir, homeDir))
-      return;
-    yield* matchesInDir(dir, names, binDirs);
-  }
-}
-export function findLocalBinUpwards(tool, startDir, options = {}) {
-  return localBinMatches([tool], startDir, options).next().value;
-}
-export function findLocalBinsUpwards(tools, startDir, options = {}) {
-  return [...localBinMatches(tools, startDir, options)];
-}
-export function findLocalBinsAt(tools, dir, options = {}) {
-  const { windowsExt = ".cmd", binDirs = NODE_MODULES_BIN_DIRS, isWindows = onWindows() } = options;
-  const names = expandCandidateNames(tools, windowsExt, isWindows);
-  return [...matchesInDir(path.resolve(dir), names, binDirs)];
-}
-export function findLocalBinAt(tool, dir, options = {}) {
-  return findLocalBinsAt([tool], dir, options)[0];
-}
-export async function findNodeToolBinary(tool, cwd, windowsExt = ".cmd") {
-  return findLocalBinUpwards(tool, cwd, { windowsExt }) ?? await findGlobalBinary(tool, windowsExt);
-}

package/extensions/dm-lens/dist/clients/package-root.js

@@ -1,25 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-const packageRootCache = new Map;
-export function getPackageRoot(importMetaUrl) {
-  const cached = packageRootCache.get(importMetaUrl);
-  if (cached)
-    return cached;
-  let current = path.dirname(fileURLToPath(importMetaUrl));
-  while (true) {
-    if (fs.existsSync(path.join(current, "package.json"))) {
-      packageRootCache.set(importMetaUrl, current);
-      return current;
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      packageRootCache.set(importMetaUrl, current);
-      return current;
-    }
-    current = parent;
-  }
-}
-export function resolvePackagePath(importMetaUrl, ...segments) {
-  return path.join(getPackageRoot(importMetaUrl), ...segments);
-}

package/extensions/dm-lens/dist/clients/partial-edit-apply.js

@@ -1,337 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import { writeFileAtomic } from "./atomic-write.js";
-import { createFileTime } from "./file-time.js";
-import { detectLineEnding, normalizeToLF, restoreLineEndings } from "./host-edit-normalize.js";
-import { PathKeyedMap } from "./path-keyed-map.js";
-import { normalizeMapKey } from "./path-utils.js";
-import { boundedEditIndexes, createReadGuardEditBatchSummary, formatBoundedEditIndexes, logReadGuardEvent } from "./read-guard-logger.js";
-const MAX_APPLIED_RECORDS_PER_FILE = 8;
-export const MAX_APPLIED_RECORD_FILES = 64;
-export function stripOldTextTrailingWhitespace(value) {
-  const lines = value.replace(/\r\n/g, `
-`).split(`
-`).map((l) => l.trimEnd());
-  while (lines.length > 1 && lines[lines.length - 1] === "")
-    lines.pop();
-  return lines.join(`
-`);
-}
-function editPairDigest(oldText, newText) {
-  return createHash("sha256").update(JSON.stringify([oldText, newText ?? ""]), "utf8").digest("hex");
-}
-function countLfOccurrences(content, needle) {
-  if (!needle)
-    return 0;
-  let count = 0;
-  let pos = 0;
-  while (pos < content.length) {
-    const idx = content.indexOf(needle, pos);
-    if (idx === -1)
-      break;
-    count += 1;
-    pos = idx + needle.length;
-  }
-  return count;
-}
-export function isExactAppliedRetry(args) {
-  const { contentLf, oldKey, newKey, contentHash, expectedContentHash, expectedAfterWriteHash } = args;
-  const haveExpectedHash = expectedContentHash !== undefined || expectedAfterWriteHash !== undefined;
-  if (haveExpectedHash) {
-    const matchesKnownState = contentHash !== undefined && (contentHash === expectedContentHash || contentHash === expectedAfterWriteHash);
-    if (!matchesKnownState)
-      return false;
-  }
-  if (!oldKey)
-    return false;
-  if (newKey === "")
-    return countLfOccurrences(contentLf, oldKey) === 0;
-  if (!newKey.includes(oldKey)) {
-    return countLfOccurrences(contentLf, oldKey) === 0 && countLfOccurrences(contentLf, newKey) >= 1;
-  }
-  const newOccurrences = [];
-  let pos = 0;
-  while (pos < contentLf.length) {
-    const idx = contentLf.indexOf(newKey, pos);
-    if (idx === -1)
-      break;
-    newOccurrences.push([idx, idx + newKey.length]);
-    pos = idx + newKey.length;
-  }
-  if (newOccurrences.length === 0)
-    return false;
-  pos = 0;
-  while (pos < contentLf.length) {
-    const idx = contentLf.indexOf(oldKey, pos);
-    if (idx === -1)
-      break;
-    const end = idx + oldKey.length;
-    if (!newOccurrences.some(([s, e]) => s <= idx && e >= end))
-      return false;
-    pos = end;
-  }
-  return true;
-}
-
-export class PartialApplyRecordStore {
-  files = new PathKeyedMap(normalizeMapKey, MAX_APPLIED_RECORD_FILES);
-  find(filePath, oldText, newText) {
-    if (!oldText)
-      return;
-    const pairDigest = editPairDigest(oldText, newText);
-    const records = this.files.get(filePath) ?? [];
-    return records.find((r) => r.pairDigest === pairDigest);
-  }
-  record(filePath, oldText, newText, contentHash) {
-    if (!oldText)
-      return;
-    const pairDigest = editPairDigest(oldText, newText);
-    const records = this.files.get(filePath) ?? [];
-    const existing = records.findIndex((r) => r.pairDigest === pairDigest);
-    if (existing >= 0)
-      records.splice(existing, 1);
-    const entry = {
-      pairDigest,
-      contentHash: contentHash ?? hashFile(filePath),
-      appliedAtMs: Date.now()
-    };
-    if (records.length >= MAX_APPLIED_RECORDS_PER_FILE)
-      records.shift();
-    records.push(entry);
-    this.files.set(filePath, records);
-  }
-  noteAfterWriteHash(filePath, oldText, newText, afterWriteContentHash) {
-    if (!oldText)
-      return;
-    const pairDigest = editPairDigest(oldText, newText);
-    const record = this.files.get(filePath)?.find((r) => r.pairDigest === pairDigest);
-    if (record)
-      record.afterWriteContentHash = afterWriteContentHash;
-  }
-  clear() {
-    this.files.clear();
-  }
-  get fileCount() {
-    return this.files.size;
-  }
-}
-const fileLock = createFileTime("partial-edit-apply");
-function hashBytes(content) {
-  return createHash("sha256").update(content).digest("hex");
-}
-function hashFile(filePath) {
-  try {
-    return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
-  } catch {
-    return;
-  }
-}
-
-class PartialApplyRejectionError extends Error {
-  reason;
-  detail;
-  constructor(reason, detail) {
-    super(detail);
-    this.reason = reason;
-    this.detail = detail;
-    this.name = "PartialApplyRejectionError";
-  }
-}
-export async function applyPartiallyApplicableEdits(args) {
-  const startedAt = Date.now();
-  const summaryRef = args.summary;
-  const correlationId = args.correlationId;
-  const logBatchEvent = (entry) => logReadGuardEvent({ ...entry, correlationId });
-  const reject = (reason, detail) => {
-    logBatchEvent({
-      event: "edit_partial_apply_rejected",
-      filePath: args.filePath,
-      metadata: {
-        tool: "edit",
-        rejectionReason: reason,
-        detail,
-        editCount: args.edits.length
-      }
-    });
-    return {
-      appliedCount: 0,
-      appliedTotal: 0,
-      appliedIndices: "",
-      postEditStatus: "not_run",
-      rejected: { reason, detail }
-    };
-  };
-  if (args.edits.length === 0) {
-    return reject("invalid_batch", "no preflight-approved edits were carried into the apply step");
-  }
-  const snapshot = args.edits[0].snapshot;
-  for (const edit of args.edits) {
-    if (edit.snapshot.hash !== snapshot.hash) {
-      return reject("invalid_batch", "carried edits reference different snapshot identities; the batch must be rebuilt from one preflight");
-    }
-  }
-  const commit = () => {
-    const rawBytes = fs.readFileSync(args.filePath);
-    if (hashBytes(rawBytes) !== snapshot.hash) {
-      throw new PartialApplyRejectionError("stale_snapshot", "the file changed since the preflight resolved these edits; rebuild the edit from the current content");
-    }
-    const raw = rawBytes.toString("utf8");
-    const ending = detectLineEnding(raw);
-    const lf = normalizeToLF(raw);
-    const ordered = [...args.edits].sort((a, b) => a.spanStart - b.spanStart);
-    for (let i = 0;i < ordered.length; i += 1) {
-      const edit = ordered[i];
-      if (lf.slice(edit.spanStart, edit.spanEnd) !== edit.appliedSpanText) {
-        throw new PartialApplyRejectionError("span_changed", `edits[${edit.originalIndex}] span no longer holds the text the preflight approved; the batch must be rebuilt from a fresh preflight`);
-      }
-      if (i > 0) {
-        const prev = ordered[i - 1];
-        if (edit.spanStart < prev.spanEnd) {
-          throw new PartialApplyRejectionError("span_overlap", `edits[${prev.originalIndex}] and edits[${edit.originalIndex}] resolved to overlapping spans; extend one oldText to disambiguate the location`);
-        }
-      }
-    }
-    let committed = lf;
-    for (let i = ordered.length - 1;i >= 0; i -= 1) {
-      const edit = ordered[i];
-      const newText = normalizeToLF(edit.newText ?? "");
-      committed = committed.slice(0, edit.spanStart) + newText + committed.slice(edit.spanEnd);
-    }
-    const output = restoreLineEndings(committed, ending);
-    const targetPath = fs.lstatSync(args.filePath).isSymbolicLink() ? fs.realpathSync(args.filePath) : args.filePath;
-    const mode = fs.statSync(args.filePath).mode & 4095;
-    writeFileAtomic(targetPath, output, {
-      bestEffort: false,
-      mode
-    });
-    return hashBytes(Buffer.from(output, "utf8"));
-  };
-  let commitStatus = "committed";
-  let committedContentHash;
-  try {
-    await fileLock.withLock(args.filePath, async () => {
-      committedContentHash = commit();
-      for (const edit of args.edits) {
-        args.recordStore?.record(args.filePath, edit.oldText, edit.newText, committedContentHash);
-      }
-    });
-  } catch (error) {
-    if (error instanceof PartialApplyRejectionError) {
-      commitStatus = "not_attempted";
-      const baseSummary = summaryRef ?? createReadGuardEditBatchSummary({
-        requestedIndexes: boundedEditIndexes(args.edits.map((edit) => edit.originalIndex)),
-        requestedTotal: args.edits.length
-      });
-      const summary = createReadGuardEditBatchSummary({
-        ...baseSummary,
-        participantIds: correlationId ? [...baseSummary.participantIds, correlationId] : baseSummary.participantIds,
-        participantTotal: correlationId ? baseSummary.participantTotal + 1 : baseSummary.participantTotal,
-        commitStatus,
-        postEditStatus: "not_run",
-        terminalStatus: "blocked",
-        durationMs: Date.now() - startedAt
-      });
-      logBatchEvent({
-        event: "edit_batch_summary",
-        filePath: args.filePath,
-        metadata: { tool: "edit", editBatchSummary: summary }
-      });
-      return reject(error.reason, error.detail);
-    }
-    commitStatus = "failed";
-    if (summaryRef || correlationId) {
-      const summary = createReadGuardEditBatchSummary({
-        ...summaryRef ?? {
-          requestedIndexes: boundedEditIndexes(args.edits.map((edit) => edit.originalIndex)),
-          requestedTotal: args.edits.length
-        },
-        appliedIndexes: [],
-        appliedTotal: 0,
-        participantIds: correlationId ? [correlationId] : undefined,
-        participantTotal: correlationId ? 1 : undefined,
-        commitStatus,
-        terminalStatus: "failed",
-        durationMs: Date.now() - startedAt
-      });
-      logBatchEvent({
-        event: "edit_batch_summary",
-        filePath: args.filePath,
-        metadata: { tool: "edit", editBatchSummary: summary }
-      });
-    }
-    throw error;
-  }
-  let postEditOutput;
-  let postEditStatus = "not_run";
-  if (args.afterWrite) {
-    try {
-      postEditOutput = await args.afterWrite();
-      postEditStatus = "succeeded";
-      if (args.recordStore) {
-        const afterWriteHash = hashFile(args.filePath);
-        if (afterWriteHash !== undefined && afterWriteHash !== committedContentHash) {
-          for (const edit of args.edits) {
-            args.recordStore.noteAfterWriteHash(args.filePath, edit.oldText, edit.newText, afterWriteHash);
-          }
-        }
-      }
-    } catch (error) {
-      postEditStatus = "failed";
-      if (!summaryRef && !correlationId)
-        throw error;
-    }
-  }
-  const appliedIndexes = boundedEditIndexes(args.edits.map((edit) => edit.originalIndex));
-  if (!summaryRef && !correlationId) {
-    return {
-      appliedCount: args.edits.length,
-      appliedTotal: args.edits.length,
-      appliedIndices: formatBoundedEditIndexes(appliedIndexes),
-      postEditOutput,
-      postEditStatus
-    };
-  }
-  const baseSummary = summaryRef ?? createReadGuardEditBatchSummary({
-    requestedIndexes: appliedIndexes,
-    requestedTotal: args.edits.length,
-    resolvedIndexes: appliedIndexes,
-    resolvedTotal: args.edits.length
-  });
-  const summary = createReadGuardEditBatchSummary({
-    ...baseSummary,
-    appliedIndexes,
-    appliedTotal: args.edits.length,
-    participantIds: correlationId ? [...baseSummary.participantIds, correlationId] : baseSummary.participantIds,
-    participantTotal: correlationId ? baseSummary.participantTotal + 1 : baseSummary.participantTotal,
-    commitStatus,
-    postEditStatus,
-    terminalStatus: postEditStatus === "failed" ? "failed" : "success",
-    durationMs: Date.now() - startedAt
-  });
-  if (postEditStatus === "failed") {
-    logBatchEvent({
-      event: "edit_post_edit_pipeline_failed",
-      filePath: args.filePath,
-      metadata: {
-        tool: "edit",
-        commitStatus,
-        appliedCount: args.edits.length,
-        appliedIndexes,
-        appliedTotal: args.edits.length
-      }
-    });
-  }
-  logBatchEvent({
-    event: "edit_batch_summary",
-    filePath: args.filePath,
-    metadata: { tool: "edit", editBatchSummary: summary }
-  });
-  return {
-    appliedCount: args.edits.length,
-    appliedTotal: args.edits.length,
-    appliedIndices: formatBoundedEditIndexes(appliedIndexes),
-    postEditOutput,
-    postEditStatus,
-    summary
-  };
-}

package/extensions/dm-lens/dist/clients/path-attribution-telemetry.js

@@ -1,31 +0,0 @@
-import { logLatency } from "./latency-logger.js";
-import { getProcessSingleton } from "./process-singletons.js";
-const VERIFIED_GUESS_FAMILY = "path-attribution-verified-guess-count";
-const VERIFIED_GUESS_VERSION = 1;
-function verifiedGuessCount() {
-  return getProcessSingleton(VERIFIED_GUESS_FAMILY, VERIFIED_GUESS_VERSION, () => ({
-    count: 0
-  }));
-}
-export function recordVerifiedPathAttributionGuess() {
-  verifiedGuessCount().count += 1;
-}
-export function getVerifiedPathAttributionGuessCount() {
-  return verifiedGuessCount().count;
-}
-export function emitVerifiedPathAttributionRollup(filePath) {
-  const cell = verifiedGuessCount();
-  if (cell.count === 0)
-    return;
-  logLatency({
-    type: "phase",
-    phase: "path_attribution_verified_rollup",
-    filePath,
-    durationMs: 0,
-    metadata: { count: cell.count }
-  });
-  cell.count = 0;
-}
-export function resetVerifiedPathAttributionGuessCount() {
-  verifiedGuessCount().count = 0;
-}