@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/cargo-manifest.js

@@ -0,0 +1,151 @@
+import { readFile } from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { logExtension } from "./extension-log.js";
+import { findNearestMarkerRoot, isAtOrAboveHomeDir } from "./path-utils.js";
+export async function readTextFileOrUndefined(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return;
+  }
+}
+function stripTomlLineComment(line) {
+  let quote = null;
+  for (let i = 0;i < line.length; i++) {
+    const ch = line[i];
+    if (quote) {
+      if (ch === quote)
+        quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "#")
+      return line.slice(0, i);
+  }
+  return line;
+}
+function normalizeToml(content) {
+  return content.replace(/^\uFEFF/, "").replace(/\r\n/g, `
+`).split(`
+`).map(stripTomlLineComment).join(`
+`);
+}
+export function extractTomlTableSection(content, tableName) {
+  const normalized = normalizeToml(content);
+  const heading = new RegExp(`^[ \\t]*\\[${tableName}\\][ \\t]*(?:#.*)?$`, "m");
+  const match = heading.exec(normalized);
+  if (!match)
+    return;
+  const rest = normalized.slice(match.index + match[0].length);
+  const nextHeading = rest.match(/^[ \t]*\[{1,2}[^\]]+\]{1,2}[ \t]*(?:#.*)?$/m);
+  return nextHeading?.index !== undefined ? rest.slice(0, nextHeading.index) : rest;
+}
+export function parseTomlStringArray(content, key) {
+  if (content === undefined)
+    return [];
+  const normalized = normalizeToml(content);
+  const match = normalized.match(new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*\\[([\\s\\S]*?)\\]`, "m"));
+  if (!match)
+    return [];
+  return [...match[1].matchAll(/"([^"]*)"|'([^']*)'/g)].map((m) => (m[1] ?? m[2] ?? "").trim());
+}
+function parseTomlScalarString(content, key) {
+  if (content === undefined)
+    return;
+  const match = content.match(new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*(?:"([^"]*)"|'([^']*)')`, "m"));
+  if (!match)
+    return;
+  return match[1] ?? match[2];
+}
+export function hasCargoWorkspaceTable(content) {
+  return hasTomlTable(content, "workspace");
+}
+export function hasTomlTable(content, tableName) {
+  return extractTomlTableSection(content, tableName) !== undefined;
+}
+export function readCargoPackageName(content) {
+  const packageSection = extractTomlTableSection(content, "package");
+  return parseTomlScalarString(packageSection, "name");
+}
+export function readCargoWorkspaceMembers(content) {
+  return parseTomlStringArray(extractTomlTableSection(content, "workspace"), "members");
+}
+export function readCargoWorkspaceExclude(content) {
+  return parseTomlStringArray(extractTomlTableSection(content, "workspace"), "exclude");
+}
+export function readCargoDependencyNames(content) {
+  const section = extractTomlTableSection(content, "dependencies");
+  if (section === undefined)
+    return [];
+  const names = [];
+  for (const rawLine of section.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    const match = line.match(/^([A-Za-z0-9_-]+)\s*=/);
+    if (match)
+      names.push(match[1]);
+  }
+  return names;
+}
+function isTomlKeyWorkspaceInherited(content, key) {
+  if (content === undefined)
+    return false;
+  const dotted = new RegExp(`^[ \\t]*${key}\\.workspace[ \\t]*=[ \\t]*true`, "m");
+  const inline = new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*\\{[^}\\n]*\\bworkspace[ \\t]*=[ \\t]*true`, "m");
+  return dotted.test(content) || inline.test(content);
+}
+const SUPPORTED_RUSTFMT_EDITIONS = new Set(["2015", "2018", "2021", "2024"]);
+function validatedEdition(value, filePath) {
+  if (value === undefined)
+    return;
+  if (SUPPORTED_RUSTFMT_EDITIONS.has(value))
+    return value;
+  logExtension({
+    subsystem: "format",
+    message: "resolveCargoPackageEdition: manifest edition is not a rustfmt-supported value; falling back to the static rustfmt command",
+    level: "debug",
+    metadata: { rejectedEdition: value, filePath }
+  });
+  return;
+}
+function readWorkspacePackageEdition(content) {
+  const workspaceSection = extractTomlTableSection(content, "workspace.package");
+  return parseTomlScalarString(workspaceSection, "edition");
+}
+export async function resolveCargoPackageEdition(filePath, homeDir = os.homedir()) {
+  const startDir = path.dirname(path.resolve(filePath));
+  const packageDir = findNearestMarkerRoot(startDir, ["Cargo.toml"], {
+    homeDir
+  });
+  if (!packageDir)
+    return;
+  const packageContent = await readTextFileOrUndefined(path.join(packageDir, "Cargo.toml"));
+  if (packageContent === undefined)
+    return;
+  const packageSection = extractTomlTableSection(packageContent, "package");
+  const direct = parseTomlScalarString(packageSection, "edition");
+  if (direct !== undefined)
+    return validatedEdition(direct, filePath);
+  if (!isTomlKeyWorkspaceInherited(packageSection, "edition"))
+    return;
+  if (hasCargoWorkspaceTable(packageContent)) {
+    return validatedEdition(readWorkspacePackageEdition(packageContent), filePath);
+  }
+  let current = path.dirname(packageDir);
+  for (let depth = 0;depth < 64; depth++) {
+    if (isAtOrAboveHomeDir(current, homeDir))
+      return;
+    const ancestorContent = await readTextFileOrUndefined(path.join(current, "Cargo.toml"));
+    if (ancestorContent !== undefined && hasCargoWorkspaceTable(ancestorContent)) {
+      return validatedEdition(readWorkspacePackageEdition(ancestorContent), filePath);
+    }
+    const parent = path.dirname(current);
+    if (parent === current)
+      return;
+    current = parent;
+  }
+  return;
+}

package/extensions/dm-lens/dist/clients/cascade-budget.js

@@ -0,0 +1,52 @@
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { toPositiveFinite } from "./env-utils.js";
+import { isQuietWindowEnabled, quietWindowWaitMs } from "./quiet-window-config.js";
+import { RUNTIME_CONFIG } from "./runtime-config.js";
+export function cascadeSettleWaitMs() {
+  const raw = Number(process.env.DM_LENS_CASCADE_SETTLE_WAIT_MS);
+  return Number.isFinite(raw) && raw >= 0 ? raw : 5000;
+}
+const MIN_NEIGHBOUR_BUDGET = RUNTIME_CONFIG.pipeline.cascadeMaxFiles;
+const DEFAULT_NEIGHBOUR_BUDGET = 40;
+export const CASCADE_NEIGHBOUR_BUDGET = Math.max(MIN_NEIGHBOUR_BUDGET, Number.parseInt(process.env.DM_LENS_CASCADE_NEIGHBOUR_BUDGET ?? "40", 10) || DEFAULT_NEIGHBOUR_BUDGET);
+const NEIGHBOUR_BUDGET_OVERRIDDEN = process.env.DM_LENS_CASCADE_NEIGHBOUR_BUDGET !== undefined && CASCADE_NEIGHBOUR_BUDGET !== DEFAULT_NEIGHBOUR_BUDGET;
+const DEFAULT_NEIGHBOUR_COST_MS = 100;
+function neighbourCostMs() {
+  return toPositiveFinite(process.env.DM_LENS_CASCADE_NEIGHBOUR_COST_MS) || DEFAULT_NEIGHBOUR_COST_MS;
+}
+function neighbourFloor() {
+  return toPositiveFinite(process.env.DM_LENS_CASCADE_NEIGHBOUR_FLOOR) || MIN_NEIGHBOUR_BUDGET;
+}
+export function deriveCascadeNeighbourBudget(options) {
+  const ceiling = options.ceiling ?? CASCADE_NEIGHBOUR_BUDGET;
+  const floor = Math.min(ceiling, options.floor ?? neighbourFloor());
+  const onTimeMs = options.settleWaitMs ?? cascadeSettleWaitMs();
+  const perNeighbourMs = options.perNeighbourMs ?? neighbourCostMs();
+  const elapsedMs = toPositiveFinite(options.elapsedMs);
+  const remainingMs = onTimeMs - elapsedMs;
+  const deliveryWindowMs = onTimeMs + (options.quietDrainMs ?? (isQuietWindowEnabled() ? quietWindowWaitMs() : 0));
+  const full = { budget: ceiling, ceiling, remainingMs, deliveryWindowMs };
+  if (onTimeMs <= 0 || onTimeMs < ceiling * perNeighbourMs) {
+    if (options.ceiling === undefined && NEIGHBOUR_BUDGET_OVERRIDDEN) {
+      recordDegradationOnce({
+        kind: "cascade-budget-override-disarmed",
+        subject: "cascade-neighbour-budget",
+        reason: `DM_LENS_CASCADE_NEIGHBOUR_BUDGET=${CASCADE_NEIGHBOUR_BUDGET} needs ` + `${ceiling * perNeighbourMs}ms to walk the full cap, which exceeds ` + `the ${onTimeMs}ms settle window — the rescue band is disarmed and ` + `every cascade keeps the flat (overridden) cap`
+      });
+    }
+    return { ...full, zone: "no-rescue-window" };
+  }
+  if (remainingMs >= ceiling * perNeighbourMs) {
+    return { ...full, zone: "fits" };
+  }
+  if (remainingMs < floor * perNeighbourMs) {
+    return { ...full, zone: "past-rescue" };
+  }
+  return {
+    budget: Math.min(ceiling, Math.max(floor, Math.floor(remainingMs / perNeighbourMs))),
+    ceiling,
+    remainingMs,
+    deliveryWindowMs,
+    zone: "narrowed"
+  };
+}

package/extensions/dm-lens/dist/clients/cascade-format.js

@@ -0,0 +1,160 @@
+import * as fs from "node:fs";
+import { retagAuxiliaryDiagnostics } from "./dispatch/auxiliary-lsp.js";
+import { applyFindingPolicy, loadProjectRulePolicyMap, renderedRuleIdentities } from "./dispatch/finding-policy.js";
+import { detectFileRole } from "./file-role.js";
+import { logLatency } from "./latency-logger.js";
+import { formatCacheAgeLabel } from "./finding-delivery-gate.js";
+import { convertLspDiagnostics } from "./dispatch/utils/lsp-diagnostics.js";
+import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
+export function formatCascadeNeighborDiagnostics(cwd, neighbors, options = {}) {
+  const withErrors = neighbors.filter((n) => n.diagnostics.length > 0);
+  const inconclusive = neighbors.filter((n) => n.inconclusive === true && n.diagnostics.length === 0);
+  const uncovered = neighbors.filter((n) => n.diagnostics.length === 0 && n.inconclusive !== true && (n.unconfirmedServerIds?.length ?? 0) > 0);
+  if (withErrors.length === 0 && inconclusive.length === 0 && uncovered.length === 0) {
+    return "";
+  }
+  const noun = options.noun ?? "neighbor";
+  let out = withErrors.length > 0 ? `\uD83D\uDCD0 Cascade errors in ${withErrors.length} ${noun} file(s) — fix before finishing turn:` : "";
+  for (const neighbor of withErrors) {
+    const display = toRunnerDisplayPath(cwd, neighbor.filePath);
+    const reason = options.includeReason ? ` reason="${neighbor.reason}"` : "";
+    out += `
+<diagnostics file="${display}"${reason}>`;
+    for (const d of neighbor.diagnostics) {
+      const line = d.line ?? 1;
+      const col = d.column ?? 1;
+      const rule = d.rule ? ` rule=${d.rule}` : "";
+      out += `
+  line ${line}, col ${col}${rule}: ${d.message.split(`
+`)[0].slice(0, 100)}`;
+    }
+    out += `
+</diagnostics>`;
+  }
+  if (inconclusive.length > 0) {
+    if (out)
+      out += `
+`;
+    out += `⚠️ Cascade diagnostics inconclusive for ${inconclusive.length} ${noun} file(s) — no clean result was confirmed:`;
+    for (const neighbor of inconclusive) {
+      out += `
+  ${toRunnerDisplayPath(cwd, neighbor.filePath)}`;
+    }
+  }
+  if (uncovered.length > 0) {
+    if (out)
+      out += `
+`;
+    out += `⚠️ Cascade scanners did not cover ${uncovered.length} ${noun} file(s) — no findings does NOT mean clean here:`;
+    for (const neighbor of uncovered) {
+      const servers = (neighbor.unconfirmedServerIds ?? []).join(", ");
+      out += `
+  ${toRunnerDisplayPath(cwd, neighbor.filePath)} (not scanned by ${servers})`;
+    }
+  }
+  return out;
+}
+export function buildResolvedFoundCascadeRun(cwd, neighbor) {
+  const { filePath } = neighbor;
+  const errors = neighbor.diagnostics.filter((d) => d.severity === 1);
+  if (errors.length === 0)
+    return;
+  const policyStart = Date.now();
+  const { diagnostics, suppressed, auxSuppressed, total } = applyCascadeDisplayPolicy(errors, {
+    cwd,
+    policyRoot: cwd,
+    filePath
+  });
+  recordCascadeFindingPolicy({
+    filePath,
+    durationMs: Date.now() - policyStart,
+    suppressed,
+    total,
+    auxSuppressed
+  });
+  const neighbors = [
+    { filePath, reason: "references", diagnostics, lspTouched: true }
+  ];
+  const rendered = formatCascadeNeighborDiagnostics(cwd, neighbors, {
+    noun: "cold neighbor"
+  });
+  if (!rendered)
+    return;
+  const formatted = suppressed > 0 ? `${rendered}
+suppressed by disposition: ${suppressed} finding(s) (marked false-positive or won't-fix).` : rendered;
+  return {
+    filePath,
+    result: {
+      filePath,
+      impact: {
+        filePath,
+        changedSymbols: [],
+        directImporters: [],
+        directCallers: [],
+        neighborFiles: [filePath],
+        riskFlags: []
+      },
+      neighbors,
+      formatted
+    },
+    neighborCount: 1,
+    diagnosticCount: diagnostics.length,
+    ...neighbor.publishedAt !== undefined ? { observedAt: neighbor.publishedAt } : {}
+  };
+}
+export function applyCascadeDisplayPolicy(errors, options) {
+  if (errors.length === 0) {
+    return { diagnostics: [], suppressed: 0, auxSuppressed: 0, total: 0 };
+  }
+  const { cwd, policyRoot, filePath } = options;
+  const content = options.content ?? readNeighborContent(filePath);
+  const converted = convertLspDiagnostics(errors, filePath);
+  const retained = retagAuxiliaryDiagnostics(converted, errors, content ?? "", {
+    cwd,
+    fileRole: detectFileRole(filePath, content)
+  });
+  const { kept } = applyFindingPolicy(retained, {
+    cwd: policyRoot,
+    filePath,
+    content: content ?? "",
+    policyMap: loadProjectRulePolicyMap(policyRoot),
+    identities: renderedRuleIdentities
+  });
+  return {
+    diagnostics: options.displayCap === undefined ? kept : kept.slice(0, options.displayCap),
+    suppressed: retained.length - kept.length,
+    auxSuppressed: converted.length - retained.length,
+    total: converted.length
+  };
+}
+export function recordCascadeFindingPolicy(entry) {
+  const inputTruncated = entry.inputTruncated ?? 0;
+  if (entry.suppressed === 0 && entry.auxSuppressed === 0 && inputTruncated === 0)
+    return;
+  logLatency({
+    type: "phase",
+    toolName: "cascade",
+    filePath: entry.filePath,
+    phase: "cascade_finding_policy",
+    durationMs: entry.durationMs,
+    metadata: {
+      suppressed: entry.suppressed,
+      total: entry.total,
+      auxSuppressed: entry.auxSuppressed,
+      ...inputTruncated > 0 && { inputTruncated }
+    }
+  });
+}
+function readNeighborContent(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return;
+  }
+}
+export function cascadeCarrySuffix(carriedTurns, observedAt) {
+  if (carriedTurns === undefined || carriedTurns < 1)
+    return;
+  const noun = carriedTurns === 1 ? "turn" : "turns";
+  return `(carried ${carriedTurns} ${noun} · ${formatCacheAgeLabel(observedAt)})`;
+}

package/extensions/dm-lens/dist/clients/cascade-logger.js

@@ -0,0 +1,22 @@
+import * as path from "node:path";
+import { isTestMode } from "./env-utils.js";
+import { getGlobalDmLensLogDir } from "./probe-home-state.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
+import { getMaxLogSizeMB } from "./log-cleanup.js";
+import { normalizeLoggedPath } from "./path-utils.js";
+const CASCADE_LOG_DIR = getGlobalDmLensLogDir();
+const CASCADE_LOG_FILE = path.join(CASCADE_LOG_DIR, "cascade.log");
+const writer = createNdjsonLogger({
+  filePath: CASCADE_LOG_FILE,
+  maxBytes: getMaxLogSizeMB() * 1024 * 1024
+});
+export function logCascade(entry) {
+  if (isTestMode()) {
+    return;
+  }
+  writer.log({
+    ts: new Date().toISOString(),
+    ...entry,
+    filePath: normalizeLoggedPath(entry.filePath)
+  });
+}

package/extensions/dm-lens/dist/clients/cascade-types.js

@@ -0,0 +1 @@
+export const CASCADE_DIAGNOSTICS_TTL_MS = 240000;

package/extensions/dm-lens/dist/clients/child-unref.js

@@ -0,0 +1,59 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { createBoundedOutputSink } from "./spawn-output-cap.js";
+export function unrefChildAndPipes(child) {
+  try {
+    child.unref();
+    for (const stream of [child.stdout, child.stderr, child.stdin]) {
+      stream?.unref?.();
+    }
+  } catch {}
+}
+export function spawnCollectStdoutResult(command, args, options, collectOptions = {}) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let timer;
+    const settle = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      resolve(result);
+    };
+    try {
+      const child = nodeSpawn(command, args, options);
+      unrefChildAndPipes(child);
+      const out = createBoundedOutputSink();
+      child.stdout?.on("data", (chunk) => out.append(chunk));
+      child.once("error", (error) => settle({ stdout: "", status: "spawn-error", error }));
+      child.once("close", (code, signal) => settle(code === 0 && signal === null ? { stdout: out.text, status: "ok" } : {
+        stdout: "",
+        status: "exit-error",
+        exitCode: code,
+        exitSignal: signal
+      }));
+      const timeoutMs = collectOptions.timeoutMs;
+      if (typeof timeoutMs === "number" && timeoutMs > 0) {
+        timer = setTimeout(() => {
+          terminateTimedOutChild(child, collectOptions.onTimeout).then((timeoutKill) => settle({ stdout: out.text, status: "timeout", timeoutKill }));
+        }, timeoutMs);
+        timer.unref();
+      }
+    } catch (error) {
+      settle({ stdout: "", status: "spawn-error", error });
+    }
+  });
+}
+async function terminateTimedOutChild(child, onTimeout) {
+  if (onTimeout) {
+    try {
+      return await onTimeout(child);
+    } catch {
+      return "unverified";
+    }
+  }
+  try {
+    child.kill();
+  } catch {}
+  return "unverified";
+}

package/extensions/dm-lens/dist/clients/code-quality-warnings.js

@@ -0,0 +1,192 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
+import { displayProjectDataPath, getProjectDataDir } from "./file-utils.js";
+import { normalizeMessage, stableFindingId } from "./finding-identity.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { resolveLensToolName } from "./tool-config.js";
+const TIER_BUDGET_ORDER = [
+  "warning",
+  "info",
+  "hint"
+];
+function createCodeQualityWarningId(args) {
+  return stableFindingId("cq:", {
+    cwd: args.cwd,
+    filePath: args.filePath,
+    parts: [
+      args.tool,
+      args.rule,
+      args.code,
+      normalizeMessage(args.message),
+      args.line
+    ]
+  });
+}
+function categorize(diagnostic) {
+  const haystack = `${diagnostic.tool} ${diagnostic.rule ?? ""} ${diagnostic.code ?? ""} ${diagnostic.message}`.toLowerCase();
+  if (haystack.includes("type") || haystack.includes("any"))
+    return "type-safety";
+  if (haystack.includes("complex") || haystack.includes("fan-out") || haystack.includes("fanout"))
+    return "maintainability";
+  if (haystack.includes("duplicate") || haystack.includes("similar"))
+    return "duplication";
+  if (haystack.includes("style") || haystack.includes("format"))
+    return "style";
+  return "other";
+}
+function lineInModifiedRanges(line, ranges) {
+  if (line === undefined)
+    return true;
+  if (ranges.length === 0)
+    return true;
+  return ranges.some((range) => line >= range.start - 2 && line <= range.end + 2);
+}
+export function recordFromCodeQualityDiagnostic(diagnostic, cwd) {
+  if (diagnostic.semantic !== "warning" && diagnostic.semantic !== "none")
+    return;
+  if (diagnostic.severity === "error")
+    return;
+  if (diagnostic.fixable || diagnostic.fixSuggestion || diagnostic.autoFixAvailable)
+    return;
+  const filePath = path.resolve(cwd, diagnostic.filePath);
+  return {
+    id: createCodeQualityWarningId({
+      cwd,
+      filePath,
+      tool: diagnostic.tool,
+      rule: diagnostic.rule,
+      code: diagnostic.code,
+      message: diagnostic.message,
+      line: diagnostic.line
+    }),
+    filePath,
+    displayPath: toRunnerDisplayPath(cwd, filePath),
+    line: diagnostic.line,
+    column: diagnostic.column,
+    severity: diagnostic.severity === "hint" ? "hint" : diagnostic.severity === "info" ? "info" : "warning",
+    tool: diagnostic.tool,
+    rule: diagnostic.rule,
+    code: diagnostic.code,
+    message: diagnostic.message,
+    category: categorize(diagnostic),
+    origin: "dispatch"
+  };
+}
+export function buildCodeQualityWarningsReport(args) {
+  const cwd = path.resolve(args.cwd);
+  const maxWarnings = Math.max(1, args.maxWarnings ?? 50);
+  const byId = new Map;
+  for (const warning of args.warnings) {
+    const ranges = args.modifiedRangesByFile.get(normalizeMapKey(warning.filePath)) ?? [];
+    if (!lineInModifiedRanges(warning.line, ranges))
+      continue;
+    byId.set(warning.id, warning);
+  }
+  const byDisplayOrder = (a, b) => a.displayPath.localeCompare(b.displayPath) || (a.line ?? 0) - (b.line ?? 0) || a.message.localeCompare(b.message);
+  const candidates = [...byId.values()].sort(byDisplayOrder);
+  const merged = [];
+  for (const tier of TIER_BUDGET_ORDER) {
+    for (const warning of candidates) {
+      if (merged.length >= maxWarnings)
+        break;
+      if (warning.severity === tier)
+        merged.push(warning);
+    }
+  }
+  merged.sort(byDisplayOrder);
+  const byFile = new Map;
+  for (const warning of merged) {
+    const arr = byFile.get(warning.filePath) ?? [];
+    arr.push(warning);
+    byFile.set(warning.filePath, arr);
+  }
+  const files = [...byFile.entries()].map(([filePath, warnings]) => ({
+    filePath,
+    displayPath: toRunnerDisplayPath(cwd, filePath),
+    fileSeq: args.fileSeqByPath?.get(normalizeMapKey(filePath)),
+    warnings
+  }));
+  const ruleCounts = new Map;
+  for (const warning of merged) {
+    const rule = warning.rule ?? warning.tool;
+    ruleCounts.set(rule, (ruleCounts.get(rule) ?? 0) + 1);
+  }
+  const topRules = [...ruleCounts.entries()].map(([rule, count]) => ({ rule, count })).sort((a, b) => b.count - a.count || a.rule.localeCompare(b.rule)).slice(0, 8);
+  return {
+    generatedAt: new Date().toISOString(),
+    scope: "turn_delta",
+    sessionId: args.sessionId,
+    turnIndex: args.turnIndex,
+    projectSeqStart: args.projectSeqStart,
+    projectSeqEnd: args.projectSeqEnd,
+    deltaOnly: true,
+    files,
+    summary: {
+      warnings: merged.length,
+      files: files.length,
+      byTier: {
+        warning: merged.filter((w) => w.severity === "warning").length,
+        info: merged.filter((w) => w.severity === "info").length,
+        hint: merged.filter((w) => w.severity === "hint").length
+      },
+      topRules
+    }
+  };
+}
+export function writeCodeQualityWarningsReport(cacheManager, cwd, report) {
+  cacheManager.writeCache("code-quality-warnings", report, cwd);
+}
+export function getCodeQualityWarningsHistoryPath(cwd) {
+  return path.join(getProjectDataDir(cwd), "code-quality-warnings.jsonl");
+}
+export function appendCodeQualityWarningsHistory(cwd, report) {
+  const warnings = report.files.flatMap((file) => file.warnings.map((warning) => ({
+    timestamp: report.generatedAt,
+    sessionId: report.sessionId,
+    turnIndex: report.turnIndex,
+    projectSeq: report.projectSeqEnd,
+    filePath: warning.filePath,
+    displayPath: warning.displayPath,
+    fileSeq: file.fileSeq,
+    line: warning.line,
+    column: warning.column,
+    severity: warning.severity,
+    tool: warning.tool,
+    rule: warning.rule,
+    code: warning.code,
+    message: warning.message,
+    category: warning.category,
+    warningId: warning.id
+  })));
+  if (warnings.length === 0)
+    return;
+  const historyPath = getCodeQualityWarningsHistoryPath(cwd);
+  try {
+    fs.mkdirSync(path.dirname(historyPath), { recursive: true });
+    fs.appendFileSync(historyPath, `${warnings.map((entry) => JSON.stringify(entry)).join(`
+`)}
+`, "utf8");
+  } catch {}
+}
+export function formatCodeQualityWarningsAdvisory(report, cwd, host = "pi") {
+  if (report.summary.warnings === 0)
+    return;
+  const topRules = report.summary.topRules.slice(0, 3).map((entry) => `${entry.rule}×${entry.count}`).join(", ");
+  const byTier = report.summary.byTier ?? { warning: 0, info: 0, hint: 0 };
+  const tiers = byTier.hint || byTier.info ? [
+    byTier.warning ? `${byTier.warning} warning` : undefined,
+    byTier.info ? `${byTier.info} info` : undefined,
+    byTier.hint ? `${byTier.hint} hint` : undefined
+  ].filter(Boolean).join(", ") : "";
+  const diagnosticsTool = resolveLensToolName("lens_diagnostics", host);
+  return [
+    `Code-quality warnings introduced/touched this turn: ${report.summary.warnings} across ${report.summary.files} file(s).`,
+    tiers ? `By tier: ${tiers}. Hint and info are style opinions, not defects.` : undefined,
+    topRules ? `Top rules: ${topRules}` : undefined,
+    diagnosticsTool ? `Use ${diagnosticsTool} with mode=delta to inspect these warnings.` : undefined,
+    "No action required unless you are already refactoring these areas.",
+    `Raw report (only if you need the JSON): ${displayProjectDataPath(cwd, "cache", "code-quality-warnings.json")}`
+  ].filter(Boolean).join(`
+`);
+}