@duckmind/dm-linux-x64 0.65.4 → 0.65.6

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

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

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

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

@@ -0,0 +1,31 @@
+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;
+}