@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/clients/advisory-provenance.js

@@ -0,0 +1,387 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logLatency } from "./latency-logger.js";
+import { normalizeMapKey, toProjectRelativePath } from "./path-utils.js";
+import { resolveRunnerPath } from "./dispatch/runner-context.js";
+import { freshnessFromMtime } from "./freshness.js";
+export const MAX_ADVISORY_AFFECTED_FILES = 256;
+export function advisoryPathKey(filePath, cwd) {
+  return normalizeMapKey(path.resolve(cwd, filePath));
+}
+export function advisoryFileHash(filePath) {
+  try {
+    return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+  } catch (error) {
+    const code = error.code ?? "unknown";
+    return code === "ENOENT" ? "missing" : `unreadable:${code}`;
+  }
+}
+function snapshotOne(filePath, cwd, role) {
+  const resolved = path.resolve(cwd, filePath);
+  try {
+    const stat = fs.statSync(resolved);
+    return {
+      path: resolved,
+      role,
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+      sha256: advisoryFileHash(resolved)
+    };
+  } catch (error) {
+    const code = error.code ?? "unknown";
+    return {
+      path: resolved,
+      role,
+      mtimeMs: -1,
+      size: -1,
+      sha256: code === "ENOENT" ? "missing" : `unreadable:${code}`
+    };
+  }
+}
+export function snapshotAdvisoryProvenance(args) {
+  const seen = new Set;
+  const files = [];
+  for (const file of args.files) {
+    const key = advisoryPathKey(file.path, args.cwd);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    files.push(snapshotOne(file.path, args.cwd, file.role));
+  }
+  return {
+    revision: {
+      sessionId: args.runtime.telemetrySessionId,
+      projectSeq: args.runtime.projectSeq,
+      turnIndex: args.runtime.turnIndex,
+      generation: args.generation,
+      capturedAt: args.capturedAt ?? Date.now()
+    },
+    files,
+    ...args.truncated ? { truncated: true } : {}
+  };
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isCapturedHash(value) {
+  return typeof value === "string" && (/^[a-f0-9]{64}$/.test(value) || value === "missing" || value.startsWith("unreadable:"));
+}
+function isWellFormed(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const record = value;
+  const revision = record.revision;
+  return !!revision && typeof revision.sessionId === "string" && isFiniteNumber(revision.projectSeq) && isFiniteNumber(revision.turnIndex) && isFiniteNumber(revision.generation) && isFiniteNumber(revision.capturedAt) && Array.isArray(record.files) && record.files.length > 0 && record.files.every((file) => !!file && typeof file.path === "string" && (file.role === "source" || file.role === "test" || file.role === "affected") && isFiniteNumber(file.mtimeMs) && isFiniteNumber(file.size) && isCapturedHash(file.sha256));
+}
+export function validateAdvisoryProvenance(record, cwd, runtime) {
+  if (!isWellFormed(record.provenance)) {
+    return {
+      status: "unknown",
+      reasons: ["malformed-or-legacy-provenance"],
+      allFilesDeleted: false,
+      changedPathCount: 0
+    };
+  }
+  const provenance = record.provenance;
+  const reasons = [];
+  let unknown = provenance.truncated === true;
+  if (unknown)
+    reasons.push("truncated-provenance");
+  if (runtime) {
+    if (provenance.revision.sessionId !== runtime.telemetrySessionId)
+      reasons.push("session-mismatch");
+  }
+  let deletedFiles = 0;
+  const changedPaths = new Set;
+  for (const captured of provenance.files) {
+    const resolved = path.resolve(cwd, captured.path);
+    const reasonsBefore = reasons.length;
+    let stat;
+    try {
+      stat = fs.statSync(resolved);
+    } catch (error) {
+      const code = error.code ?? "unknown";
+      if (code === "ENOENT") {
+        if (captured.sha256 !== "missing") {
+          deletedFiles += 1;
+          reasons.push(`missing:${advisoryPathKey(resolved, cwd)}`);
+          changedPaths.add(advisoryPathKey(resolved, cwd));
+        }
+      } else {
+        unknown = true;
+        reasons.push(`unreadable:${advisoryPathKey(resolved, cwd)}:${code}`);
+        changedPaths.add(advisoryPathKey(resolved, cwd));
+      }
+      continue;
+    }
+    if (captured.sha256.startsWith("unreadable:")) {
+      unknown = true;
+      reasons.push(`capture-unreadable:${advisoryPathKey(resolved, cwd)}`);
+      changedPaths.add(advisoryPathKey(resolved, cwd));
+      continue;
+    }
+    if (captured.sha256 === "missing") {
+      reasons.push(`created:${advisoryPathKey(resolved, cwd)}`);
+      changedPaths.add(advisoryPathKey(resolved, cwd));
+      continue;
+    }
+    if (stat.mtimeMs !== captured.mtimeMs || stat.size !== captured.size) {
+      reasons.push(`metadata-changed:${advisoryPathKey(resolved, cwd)}`);
+    }
+    const currentHash = advisoryFileHash(resolved);
+    if (currentHash.startsWith("unreadable:")) {
+      unknown = true;
+      reasons.push(`${currentHash}:${advisoryPathKey(resolved, cwd)}`);
+    } else if (currentHash !== captured.sha256) {
+      reasons.push(`content-changed:${advisoryPathKey(resolved, cwd)}`);
+    }
+    if (reasons.length > reasonsBefore)
+      changedPaths.add(advisoryPathKey(resolved, cwd));
+  }
+  const allFilesDeleted = deletedFiles === provenance.files.length;
+  if (unknown)
+    return {
+      status: "unknown",
+      reasons,
+      allFilesDeleted,
+      changedPathCount: changedPaths.size
+    };
+  return reasons.length > 0 ? {
+    status: "superseded",
+    reasons,
+    allFilesDeleted,
+    changedPathCount: changedPaths.size
+  } : { status: "current", reasons: [], allFilesDeleted, changedPathCount: 0 };
+}
+const MAX_FINDING_PATH_STATS = MAX_ADVISORY_AFFECTED_FILES;
+const MAX_LOGGED_DEAD_PATHS = 3;
+export function findingPathFreshness(resolvedPath, scannedAtMs) {
+  return freshnessFromFacts(statFindingPath(resolvedPath), scannedAtMs);
+}
+function statFindingPath(resolvedPath) {
+  try {
+    return { state: "present", mtimeMs: fs.statSync(resolvedPath).mtimeMs };
+  } catch (error) {
+    const code = error.code ?? "unknown";
+    return code === "ENOENT" || code === "ENOTDIR" ? { state: "missing" } : { state: "unknown" };
+  }
+}
+function freshnessFromFacts(facts, scannedAtMs) {
+  if (facts.state === "missing")
+    return "missing";
+  if (facts.state === "unknown")
+    return "unknown";
+  if (scannedAtMs === undefined)
+    return "live";
+  return freshnessFromMtime({
+    mtimeMs: facts.mtimeMs,
+    referenceMs: scannedAtMs
+  }).verdict === "stale" ? "stale" : "live";
+}
+export function findingPathExistence(resolvedPath) {
+  return findingPathFreshness(resolvedPath);
+}
+export function parseScannedAtMs(scannedAt) {
+  if (scannedAt === undefined || scannedAt === null || scannedAt === "") {
+    return;
+  }
+  const ms = typeof scannedAt === "number" ? scannedAt : Date.parse(scannedAt);
+  return Number.isFinite(ms) ? ms : undefined;
+}
+export function partitionFindingsByCitedPath(args) {
+  return partitionOneSource({ ...args, store: args.store ?? "" }, createPathFactsMemo(args));
+}
+function createPathFactsMemo(args) {
+  return {
+    facts: new Map,
+    probe: args.probePath ?? statFindingPath,
+    limit: args.maxUniquePaths ?? MAX_FINDING_PATH_STATS,
+    starved: new Map
+  };
+}
+function partitionOneSource(args, memo) {
+  const scannedAtMs = parseScannedAtMs(args.scannedAt);
+  const onMissing = args.onMissing ?? "drop";
+  const rawVerdicts = new Map;
+  const live = [];
+  const stale = [];
+  const dropped = [];
+  const deadPaths = [];
+  const stalePaths = [];
+  const seenPaths = new Set;
+  let probed = 0;
+  for (const finding of args.findings) {
+    const cited = args.citedPath(finding);
+    if (!cited) {
+      live.push(finding);
+      continue;
+    }
+    let verdict = rawVerdicts.get(cited);
+    if (verdict === undefined) {
+      const resolved = resolveRunnerPath(args.cwd, cited);
+      let facts = memo.facts.get(resolved);
+      if (facts === undefined) {
+        if (probed >= memo.limit) {
+          memo.starved.set(args.store, (memo.starved.get(args.store) ?? 0) + 1);
+          facts = { state: "unknown" };
+        } else {
+          probed += 1;
+          facts = memo.probe(resolved);
+          memo.facts.set(resolved, facts);
+        }
+      }
+      verdict = freshnessFromFacts(facts, scannedAtMs);
+      if (verdict === "missing" && onMissing === "demote")
+        verdict = "stale";
+      if (!seenPaths.has(resolved)) {
+        seenPaths.add(resolved);
+        if (verdict === "missing")
+          deadPaths.push(resolved);
+        else if (verdict === "stale")
+          stalePaths.push(resolved);
+      }
+      rawVerdicts.set(cited, verdict);
+    }
+    if (verdict === "missing")
+      dropped.push(finding);
+    else if (verdict === "stale")
+      stale.push(finding);
+    else
+      live.push(finding);
+  }
+  return {
+    live,
+    stale,
+    dropped,
+    deadPaths,
+    stalePaths,
+    statCount: memo.facts.size,
+    truncated: (memo.starved.get(args.store) ?? 0) > 0
+  };
+}
+export function dropFindingsForMissingPaths(args) {
+  const partition = partitionFindingsByCitedPath(args);
+  emitDeadPathDropRecord(args.cwd, partition, {
+    [args.store]: partition.dropped.length
+  });
+  return partition.live;
+}
+export function gateFindingsByPathFreshness(args) {
+  const memo = createPathFactsMemo(args);
+  const names = Object.keys(args.sources).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const gates = {};
+  const dropped = {};
+  const demoted = {};
+  const merged = {
+    live: [],
+    stale: [],
+    dropped: [],
+    deadPaths: [],
+    stalePaths: [],
+    statCount: 0,
+    truncated: false
+  };
+  const scannedAtByStore = {};
+  for (const name of names) {
+    const source = args.sources[name];
+    const partition = partitionOneSource({ ...source, store: name, cwd: args.cwd }, memo);
+    gates[name] = { live: partition.live, stale: partition.stale };
+    if (partition.dropped.length > 0)
+      dropped[name] = partition.dropped.length;
+    if (partition.stale.length > 0)
+      demoted[name] = partition.stale.length;
+    if (source.scannedAt !== undefined) {
+      scannedAtByStore[name] = String(source.scannedAt);
+    }
+    merged.live.push(...partition.live);
+    merged.stale.push(...partition.stale);
+    merged.dropped.push(...partition.dropped);
+    for (const deadPath of partition.deadPaths) {
+      if (!merged.deadPaths.includes(deadPath))
+        merged.deadPaths.push(deadPath);
+    }
+    for (const stalePath of partition.stalePaths) {
+      if (!merged.stalePaths.includes(stalePath)) {
+        merged.stalePaths.push(stalePath);
+      }
+    }
+  }
+  merged.statCount = memo.facts.size;
+  merged.truncated = memo.starved.size > 0;
+  if (args.quiet !== true) {
+    emitDeadPathDropRecord(args.cwd, merged, dropped);
+    emitStaleLineDemoteRecord(args.cwd, scannedAtByStore, merged, demoted);
+    emitStatBudgetRecord(args.cwd, memo);
+  }
+  return gates;
+}
+function emitDeadPathDropRecord(cwd, partition, byStore) {
+  if (partition.dropped.length === 0)
+    return;
+  const stores = Object.keys(byStore);
+  logLatency({
+    type: "phase",
+    phase: "finding_dead_path_drop",
+    filePath: cwd,
+    durationMs: 0,
+    metadata: {
+      store: stores.join("+"),
+      byStore,
+      droppedDeadPaths: partition.dropped.length,
+      deadPathCount: partition.deadPaths.length,
+      deliveredCount: partition.live.length,
+      statCount: partition.statCount,
+      samplePaths: partition.deadPaths.slice(0, MAX_LOGGED_DEAD_PATHS).map((deadPath) => toProjectRelativePath(deadPath, cwd)),
+      ...partition.truncated ? { truncated: true } : {}
+    }
+  });
+}
+function emitStaleLineDemoteRecord(cwd, scannedAtByStore, partition, byStore) {
+  if (partition.stale.length === 0)
+    return;
+  const stores = Object.keys(byStore);
+  const single = stores.length === 1 ? scannedAtByStore[stores[0]] : undefined;
+  logLatency({
+    type: "phase",
+    phase: "finding_stale_line_demote",
+    filePath: cwd,
+    durationMs: 0,
+    metadata: {
+      store: stores.join("+"),
+      byStore,
+      demotedStalePaths: partition.stale.length,
+      stalePathCount: partition.stalePaths.length,
+      deliveredCount: partition.live.length,
+      statCount: partition.statCount,
+      samplePaths: partition.stalePaths.slice(0, MAX_LOGGED_DEAD_PATHS).map((stalePath) => toProjectRelativePath(stalePath, cwd)),
+      ...single === undefined ? {} : { scannedAt: single },
+      ...stores.length > 1 ? {
+        scannedAtByStore: Object.fromEntries(stores.map((name) => [name, scannedAtByStore[name] ?? ""]))
+      } : {},
+      ...partition.truncated ? { truncated: true } : {}
+    }
+  });
+}
+function emitStatBudgetRecord(cwd, memo) {
+  if (memo.starved.size === 0)
+    return;
+  const stores = [...memo.starved.keys()].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  logLatency({
+    type: "phase",
+    phase: "finding_path_stat_budget_exhausted",
+    filePath: cwd,
+    durationMs: 0,
+    metadata: {
+      store: stores.join("+"),
+      byStore: Object.fromEntries(stores.map((name) => [name, memo.starved.get(name) ?? 0])),
+      maxUniquePaths: memo.limit,
+      statCount: memo.facts.size
+    }
+  });
+}
+export function provenanceStamp(provenance) {
+  if (!isWellFormed(provenance))
+    return "session unknown / turn unknown / generation unknown";
+  return `session ${provenance.revision.sessionId} / turn ${provenance.revision.turnIndex} / generation ${provenance.revision.generation}`;
+}

package/extensions/dm-lens/dist/clients/agent-behavior-client.js

@@ -0,0 +1,94 @@
+import { isMutatingToolName } from "./mutating-tool.js";
+import { normalizeMapKey } from "./path-utils.js";
+const READ_OPS = new Set(["read", "bash", "grep", "glob", "find", "rg"]);
+const BLIND_WRITE_WINDOW = 5;
+const THRASH_THRESHOLD = 3;
+const THRASH_TIMEOUT_MS = 30000;
+
+export class AgentBehaviorClient {
+  toolHistory = [];
+  consecutiveCount = 0;
+  lastToolName = null;
+  lastToolFilePath = null;
+  lastToolTimestamp = 0;
+  fileEditCount = new Map;
+  static FILE_EDIT_IDLE_MS = 30 * 60000;
+  recordToolCall(toolName, filePath) {
+    const warnings = [];
+    const now = Date.now();
+    const normalizedPath = filePath ? normalizeMapKey(filePath) : null;
+    if (toolName === this.lastToolName && normalizedPath === this.lastToolFilePath && now - this.lastToolTimestamp < THRASH_TIMEOUT_MS) {
+      this.consecutiveCount++;
+    } else {
+      this.consecutiveCount = 1;
+    }
+    this.lastToolName = toolName;
+    this.lastToolFilePath = normalizedPath;
+    this.lastToolTimestamp = now;
+    if (this.consecutiveCount === THRASH_THRESHOLD) {
+      const fileLabel = filePath ? ` on \`${filePath}\`` : "";
+      warnings.push({
+        type: "thrashing",
+        message: `\uD83D\uDD34 THRASHING — ${THRASH_THRESHOLD} consecutive \`${toolName}\`${fileLabel} calls with no progress. Consider fixing the root cause instead of re-running.`,
+        severity: "error",
+        details: {
+          toolName,
+          filePath,
+          callCount: this.consecutiveCount
+        }
+      });
+    }
+    if (isMutatingToolName(toolName)) {
+      const recentWindow = this.toolHistory.slice(-BLIND_WRITE_WINDOW);
+      const hasRecentRead = recentWindow.some((r) => READ_OPS.has(r.toolName) || isMutatingToolName(r.toolName) && r.filePath !== undefined && normalizedPath !== null && normalizeMapKey(r.filePath) === normalizedPath);
+      if (!hasRecentRead && recentWindow.length > 0) {
+        const writesWithoutRead = recentWindow.filter((r) => isMutatingToolName(r.toolName)).length;
+        if (writesWithoutRead >= 2) {
+          warnings.push({
+            type: "blind-write",
+            message: `⚠ BLIND WRITE — editing \`${filePath ?? "file"}\` without reading in the last ${BLIND_WRITE_WINDOW} tool calls. Read the file first to avoid assumptions.`,
+            severity: "warning",
+            details: {
+              filePath,
+              windowSize: recentWindow.length
+            }
+          });
+        }
+      }
+      if (filePath) {
+        const key = normalizeMapKey(filePath);
+        this.fileEditCount.set(key, {
+          count: (this.fileEditCount.get(key)?.count ?? 0) + 1,
+          lastUsedAt: now
+        });
+        for (const [pathKey, entry] of this.fileEditCount) {
+          if (now - entry.lastUsedAt > AgentBehaviorClient.FILE_EDIT_IDLE_MS) {
+            this.fileEditCount.delete(pathKey);
+          }
+        }
+      }
+    }
+    this.toolHistory.push({ toolName, filePath, timestamp: now });
+    if (this.toolHistory.length > 50) {
+      this.toolHistory = this.toolHistory.slice(-50);
+    }
+    return warnings;
+  }
+  formatWarnings(warnings) {
+    if (warnings.length === 0)
+      return "";
+    return warnings.map((w) => w.message).join(`
+`);
+  }
+  getEditCount(filePath) {
+    return this.fileEditCount.get(normalizeMapKey(filePath))?.count ?? 0;
+  }
+  reset() {
+    this.toolHistory = [];
+    this.consecutiveCount = 0;
+    this.lastToolName = null;
+    this.lastToolTimestamp = 0;
+    this.fileEditCount.clear();
+  }
+}
+export const agentBehaviorClient = new AgentBehaviorClient;