@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/instance-registry.js

@@ -1,452 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { writeFileAtomic, writeFileAtomicAsync } from "./atomic-write.js";
-import { incrementDegradationCount, recordDegradationOnce } from "./degradation-ledger.js";
-import { getGlobalDmLensDir } from "./file-utils.js";
-import { withInstanceRegistryLock, withInstanceRegistryLockSync } from "./instance-registry-lock.js";
-import { realIsPidAlive, STALE_HEARTBEAT_MS } from "./instance-reaper.js";
-import { normalizeFilePath } from "./path-utils.js";
-import { getProcessSingleton } from "./process-singletons.js";
-import { getSubagentIdentity, isSubagentSession } from "./subagent-mode.js";
-function registryPath() {
-  return path.join(getGlobalDmLensDir(), "instances.json");
-}
-let _enabledCache;
-export function isInstanceRegistryEnabled() {
-  if (_enabledCache !== undefined)
-    return _enabledCache;
-  _enabledCache = process.env.DM_LENS_INSTANCE_REGISTRY !== "0";
-  return _enabledCache;
-}
-export function _resetInstanceRegistryEnabledForTests() {
-  _enabledCache = undefined;
-}
-function recordCorruptRegistryRead(reasonCode) {
-  recordDegradationOnce({
-    kind: "instance-registry-corrupt",
-    subject: "instances.json",
-    reason: `read failed (${reasonCode}); treating as empty`
-  });
-}
-function readRegistrySync() {
-  try {
-    const raw = fs.readFileSync(registryPath(), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed && Array.isArray(parsed.instances)) {
-      return parsed;
-    }
-    recordCorruptRegistryRead("invalid shape");
-    return { instances: [] };
-  } catch (err) {
-    const code = err?.code;
-    if (code !== "ENOENT")
-      recordCorruptRegistryRead(code ?? "invalid");
-    return { instances: [] };
-  }
-}
-async function readRegistryAsync() {
-  try {
-    const raw = await fs.promises.readFile(registryPath(), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed && Array.isArray(parsed.instances)) {
-      return parsed;
-    }
-    recordCorruptRegistryRead("invalid shape");
-    return { instances: [] };
-  } catch (err) {
-    const code = err?.code;
-    if (code !== "ENOENT")
-      recordCorruptRegistryRead(code ?? "invalid");
-    return { instances: [] };
-  }
-}
-export async function readInstanceRegistry() {
-  const file = await readRegistryAsync();
-  return file.instances;
-}
-async function writeRegistryAsync(file) {
-  const dir = getGlobalDmLensDir();
-  const target = registryPath();
-  try {
-    await fs.promises.mkdir(dir, { recursive: true });
-  } catch {
-    return;
-  }
-  await writeFileAtomicAsync(target, JSON.stringify(file));
-}
-const REGISTRY_WRITE_RETRIES = 3;
-async function writeRegistryWithRetry(mutate, isCommitted) {
-  await withInstanceRegistryLock(registryPath(), async () => {
-    for (let attempt = 0;attempt < REGISTRY_WRITE_RETRIES; attempt++) {
-      await writeRegistryAsync(mutate(await readRegistryAsync()));
-      if (isCommitted(await readRegistryAsync()))
-        return;
-    }
-  });
-}
-function writeRegistrySync(file) {
-  const dir = getGlobalDmLensDir();
-  const target = registryPath();
-  try {
-    fs.mkdirSync(dir, { recursive: true });
-  } catch {
-    return;
-  }
-  writeFileAtomic(target, JSON.stringify(file));
-}
-export function getInstanceRoots(entry) {
-  const listed = Array.isArray(entry.projectRoots) ? entry.projectRoots.filter((root) => typeof root === "string" && root.length > 0) : [];
-  if (listed.length > 0)
-    return listed;
-  return typeof entry.projectRoot === "string" && entry.projectRoot.length > 0 ? [entry.projectRoot] : [];
-}
-const INSTANCE_ROOT_CAP = 32;
-export function mergeInstanceRoots(priorRoots, normalizedRoot) {
-  const roots = priorRoots.includes(normalizedRoot) ? [...priorRoots] : [...priorRoots, normalizedRoot];
-  while (roots.length > INSTANCE_ROOT_CAP)
-    roots.splice(1, 1);
-  return roots;
-}
-export function registerInstance(projectRoot) {
-  return queueRegistryMutation(() => registerInstanceNow(projectRoot));
-}
-async function registerInstanceNow(projectRoot) {
-  if (!isInstanceRegistryEnabled())
-    return;
-  rememberRegistrationRoot(projectRoot);
-  const pid = process.pid;
-  const normalizedRoot = normalizeFilePath(projectRoot);
-  const now = new Date().toISOString();
-  const identity = isSubagentSession() ? getSubagentIdentity() : undefined;
-  const subagent = identity ? {
-    marker: identity.marker,
-    agentType: identity.agentName,
-    parentPid: identity.parentPid,
-    runId: identity.runId
-  } : undefined;
-  await writeRegistryWithRetry((file) => {
-    const others = file.instances.filter((entry) => entry.pid !== pid);
-    const existing = file.instances.find((entry) => entry.pid === pid);
-    const existingRoots = existing ? getInstanceRoots(existing) : [];
-    const roots = existing?.rootSource === "lsp-fallback" ? existingRoots.slice(1).reduce((acc, root) => mergeInstanceRoots(acc, root), [normalizedRoot]) : mergeInstanceRoots(existingRoots, normalizedRoot);
-    others.push({
-      pid,
-      startedAt: existing?.startedAt ?? now,
-      projectRoot: roots[0] ?? normalizedRoot,
-      projectRoots: roots,
-      lspChildren: existing?.lspChildren ?? [],
-      lspChildCount: existing?.lspChildren?.length ?? 0,
-      rssBytes: process.memoryUsage().rss,
-      heartbeatAt: now,
-      ...subagent ? { subagent } : {}
-    });
-    return { instances: others };
-  }, (file) => file.instances.some((entry) => entry.pid === pid));
-}
-export function registerInstanceRoot(projectRoot) {
-  return queueRegistryMutation(() => registerInstanceRootNow(projectRoot));
-}
-async function registerInstanceRootNow(projectRoot) {
-  if (!isInstanceRegistryEnabled())
-    return;
-  const pid = process.pid;
-  const normalizedRoot = normalizeFilePath(projectRoot);
-  await withInstanceRegistryLock(registryPath(), async () => {
-    const file = await readRegistryAsync();
-    const idx = file.instances.findIndex((entry) => entry.pid === pid);
-    if (idx === -1)
-      return;
-    const current = file.instances[idx];
-    const priorRoots = getInstanceRoots(current);
-    const roots = mergeInstanceRoots(priorRoots, normalizedRoot);
-    if (roots.length === priorRoots.length && roots.every((root, index) => root === priorRoots[index]))
-      return;
-    file.instances[idx] = {
-      ...current,
-      projectRoot: roots[0] ?? current.projectRoot,
-      projectRoots: roots
-    };
-    await writeRegistryAsync(file);
-  });
-}
-export async function updateHeartbeat(patch = {}) {
-  if (!isInstanceRegistryEnabled())
-    return;
-  const pid = process.pid;
-  let missing = false;
-  await withInstanceRegistryLock(registryPath(), async () => {
-    const file = await readRegistryAsync();
-    const idx = file.instances.findIndex((entry) => entry.pid === pid);
-    if (idx === -1) {
-      missing = true;
-      return;
-    }
-    const now = new Date().toISOString();
-    const current = file.instances[idx];
-    const lspChildren = patch.childUsage ? current.lspChildren.map((child) => {
-      const usage = patch.childUsage?.[child.pid];
-      if (!usage)
-        return child;
-      return {
-        ...child,
-        rssBytes: usage.rssBytes ?? child.rssBytes,
-        cpuPercent: usage.cpuPercent ?? child.cpuPercent
-      };
-    }) : current.lspChildren;
-    file.instances[idx] = {
-      ...current,
-      rssBytes: patch.rssBytes ?? process.memoryUsage().rss,
-      cpuPercent: patch.cpuPercent ?? current.cpuPercent,
-      lspChildren,
-      lspChildCount: lspChildren.length,
-      heartbeatAt: now
-    };
-    await writeRegistryAsync(file);
-  });
-  const intent = registrationIntent();
-  if (missing && intent.root !== undefined && intent.target === registryPath()) {
-    incrementDegradationCount({
-      kind: "instance-registry-registration-missing",
-      subject: String(pid),
-      reason: "entry missing at heartbeat; re-registering from the session root"
-    });
-    registerInstance(intent.root);
-  }
-}
-const REGISTRY_TAIL_FAMILY = "instance-registry.mutation-tail";
-const REGISTRY_TAIL_VERSION = 1;
-function registryTailState() {
-  return getProcessSingleton(REGISTRY_TAIL_FAMILY, REGISTRY_TAIL_VERSION, () => ({
-    tail: Promise.resolve()
-  }));
-}
-const REGISTRATION_INTENT_FAMILY = "instance-registry.registration-intent";
-const REGISTRATION_INTENT_VERSION = 1;
-function registrationIntent() {
-  return getProcessSingleton(REGISTRATION_INTENT_FAMILY, REGISTRATION_INTENT_VERSION, () => ({ root: undefined, target: undefined }));
-}
-function rememberRegistrationRoot(root) {
-  const intent = registrationIntent();
-  intent.root = root;
-  intent.target = root === undefined ? undefined : registryPath();
-}
-function queueRegistryMutation(op) {
-  const state = registryTailState();
-  const run = state.tail.then(op);
-  state.tail = run.catch(() => {});
-  return run;
-}
-export function _settleRegistryMutationsForTests() {
-  return queueRegistryMutation(async () => {});
-}
-export function recordLspChild(entry) {
-  return queueRegistryMutation(() => recordLspChildNow(entry));
-}
-async function recordLspChildNow(entry) {
-  if (!isInstanceRegistryEnabled())
-    return;
-  const pid = process.pid;
-  const now = new Date().toISOString();
-  const childEntry = {
-    pid: entry.pid,
-    serverId: entry.serverId,
-    command: entry.command,
-    marker: entry.marker,
-    spawnedAt: now
-  };
-  const hostIdentity = getSubagentIdentity();
-  await writeRegistryWithRetry((file) => {
-    const idx = file.instances.findIndex((inst) => inst.pid === pid);
-    if (idx === -1) {
-      recordDegradationOnce({
-        kind: "instance-registry-registration-missing",
-        subject: String(pid),
-        reason: "synthesizing host entry while recording an LSP child"
-      });
-      const identity = entry.sessionIdentity;
-      if (!identity?.projectRoot) {
-        recordDegradationOnce({
-          kind: "instance-registry-identity-fallback",
-          subject: String(pid),
-          reason: "session cwd unavailable; using process cwd"
-        });
-      }
-      const projectRoot = normalizeFilePath(identity?.projectRoot ?? process.cwd());
-      file.instances.push({
-        pid,
-        startedAt: identity?.startedAt ?? now,
-        projectRoot,
-        rootSource: identity?.rootSource ?? "lsp-fallback",
-        projectRoots: [projectRoot],
-        lspChildren: [childEntry],
-        lspChildCount: 1,
-        rssBytes: process.memoryUsage().rss,
-        heartbeatAt: now,
-        ...hostIdentity ? {
-          subagent: {
-            marker: hostIdentity.marker,
-            agentType: hostIdentity.agentName,
-            parentPid: hostIdentity.parentPid,
-            runId: hostIdentity.runId
-          }
-        } : {}
-      });
-    } else {
-      const current = file.instances[idx];
-      const filtered = current.lspChildren.filter((child) => child.pid !== entry.pid);
-      filtered.push(childEntry);
-      file.instances[idx] = {
-        ...current,
-        lspChildren: filtered,
-        lspChildCount: filtered.length
-      };
-    }
-    return file;
-  }, (file) => file.instances.some((instance) => instance.pid === pid && instance.lspChildren.some((child) => child.pid === entry.pid)));
-}
-export function removeLspChild(pid, expectedMarker) {
-  return queueRegistryMutation(() => removeLspChildNow(pid, expectedMarker));
-}
-async function removeLspChildNow(pid, expectedMarker) {
-  if (!isInstanceRegistryEnabled())
-    return;
-  const selfPid = process.pid;
-  await withInstanceRegistryLock(registryPath(), async () => {
-    const file = await readRegistryAsync();
-    const idx = file.instances.findIndex((inst) => inst.pid === selfPid);
-    if (idx === -1)
-      return;
-    const current = file.instances[idx];
-    const filtered = current.lspChildren.filter((child) => {
-      if (child.pid !== pid)
-        return true;
-      if (expectedMarker && child.marker && child.marker !== expectedMarker) {
-        return true;
-      }
-      return false;
-    });
-    if (filtered.length === current.lspChildren.length)
-      return;
-    file.instances[idx] = {
-      ...current,
-      lspChildren: filtered,
-      lspChildCount: filtered.length
-    };
-    await writeRegistryAsync(file);
-  });
-}
-export function deregisterInstance() {
-  rememberRegistrationRoot(undefined);
-  if (!isInstanceRegistryEnabled())
-    return;
-  const pid = process.pid;
-  withInstanceRegistryLockSync(registryPath(), () => {
-    const file = readRegistrySync();
-    const remaining = file.instances.filter((entry) => entry.pid !== pid);
-    if (remaining.length === file.instances.length)
-      return;
-    writeRegistrySync({ instances: remaining });
-  });
-}
-export function deregisterInstanceRoot(projectRoot) {
-  return queueRegistryMutation(async () => deregisterInstanceRootNow(projectRoot));
-}
-function deregisterInstanceRootNow(projectRoot) {
-  if (!isInstanceRegistryEnabled())
-    return;
-  const pid = process.pid;
-  const normalizedRoot = normalizeFilePath(projectRoot);
-  withInstanceRegistryLockSync(registryPath(), () => {
-    const file = readRegistrySync();
-    const idx = file.instances.findIndex((entry) => entry.pid === pid);
-    if (idx === -1) {
-      const intent = registrationIntent();
-      if (intent.root !== undefined && normalizeFilePath(intent.root) === normalizedRoot)
-        rememberRegistrationRoot(undefined);
-      return;
-    }
-    const current = file.instances[idx];
-    const remainingRoots = getInstanceRoots(current).filter((root) => root !== normalizedRoot);
-    if (remainingRoots.length === getInstanceRoots(current).length)
-      return;
-    if (remainingRoots.length === 0) {
-      rememberRegistrationRoot(undefined);
-      writeRegistrySync({
-        instances: file.instances.filter((entry) => entry.pid !== pid)
-      });
-      return;
-    }
-    file.instances[idx] = {
-      ...current,
-      projectRoot: remainingRoots[0],
-      projectRoots: remainingRoots
-    };
-    rememberRegistrationRoot(remainingRoots[0]);
-    writeRegistrySync(file);
-  });
-}
-function rootsOverlap(a, b) {
-  if (a === b)
-    return true;
-  const [shorter, longer] = a.length < b.length ? [a, b] : [b, a];
-  return longer.startsWith(shorter.endsWith("/") ? shorter : `${shorter}/`);
-}
-export function selectLivePeerInstances(entries, root, now = Date.now(), isPidAlive = realIsPidAlive, match = "exact") {
-  const normalizedRoot = normalizeFilePath(root);
-  return entries.filter((entry) => entry.pid !== process.pid && getInstanceRoots(entry).some((entryRoot) => match === "exact" ? entryRoot === normalizedRoot : rootsOverlap(entryRoot, normalizedRoot)) && isPidAlive(entry.pid) && Number.isFinite(Date.parse(entry.heartbeatAt)) && now - Date.parse(entry.heartbeatAt) <= STALE_HEARTBEAT_MS).sort((a, b) => Date.parse(a.startedAt) - Date.parse(b.startedAt));
-}
-export function computeResourceFootprint(instances, isPidAlive) {
-  const liveInstances = isPidAlive ? instances.filter((instance) => isPidAlive(instance.pid)) : instances;
-  const perInstance = liveInstances.map((instance) => {
-    const lspChildRssBytes = instance.lspChildren.reduce((sum, child) => sum + (child.rssBytes ?? 0), 0);
-    const lspChildCpuPercent = instance.lspChildren.reduce((sum, child) => sum + (child.cpuPercent ?? 0), 0);
-    const roots = getInstanceRoots(instance);
-    return {
-      pid: instance.pid,
-      projectRoot: roots[0] ?? instance.projectRoot,
-      projectRoots: roots,
-      rssBytes: instance.rssBytes ?? 0,
-      cpuPercent: instance.cpuPercent ?? 0,
-      lspChildCount: instance.lspChildren.length,
-      lspChildRssBytes,
-      lspChildCpuPercent
-    };
-  });
-  let totalRssBytes = 0;
-  let totalCpuPercent = 0;
-  let totalLspChildCount = 0;
-  for (const inst of perInstance) {
-    totalRssBytes += inst.rssBytes + inst.lspChildRssBytes;
-    totalCpuPercent += inst.cpuPercent + inst.lspChildCpuPercent;
-    totalLspChildCount += inst.lspChildCount;
-  }
-  return {
-    instanceCount: perInstance.length,
-    totalRssBytes,
-    totalCpuPercent,
-    totalLspChildCount,
-    perInstance
-  };
-}
-export async function getResourceFootprint(isPidAlive = realIsPidAlive) {
-  const instances = await readInstanceRegistry();
-  const deadPids = new Set(instances.filter((instance) => !isPidAlive(instance.pid)).map((instance) => instance.pid));
-  if (deadPids.size > 0) {
-    prunePids(deadPids).catch(() => {});
-  }
-  return computeResourceFootprint(instances, isPidAlive);
-}
-export async function pruneDeadInstances(deadPids) {
-  const result = await withInstanceRegistryLock(registryPath(), async () => {
-    const file = await readRegistryAsync();
-    const remaining = file.instances.filter((entry) => !deadPids.has(entry.pid));
-    if (remaining.length === file.instances.length)
-      return "no-match";
-    await writeRegistryAsync({ instances: remaining });
-    return "pruned";
-  });
-  return result ?? "could-not-acquire";
-}
-async function prunePids(deadPids) {
-  await pruneDeadInstances(deadPids);
-}

package/extensions/dm-lens/dist/clients/jscpd-client.js

@@ -1,252 +0,0 @@
-import { formatToolFailure } from "./dispatch/runners/utils/tool-failure.js";
-import { createSubsystemLogger } from "./extension-log.js";
-import { incrementDegradationCount } from "./degradation-ledger.js";
-import * as fs from "node:fs";
-import { mkdtempSync } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { getExcludedDirGlobs, getProjectIgnoreGlobs, getProjectIgnoreMatcher } from "./file-utils.js";
-import { findNodeToolBinary } from "./package-manager.js";
-import { isAtOrAboveHomeDir, isFullyQualified } from "./path-utils.js";
-import { getJscpdMaxEntriesDerived } from "./project-scale.js";
-import { createAvailabilityChecker, findManagedNodeToolBinary, resolveAvailableOrInstall } from "./dispatch/runners/utils/runner-helpers.js";
-import { safeSpawnAsync } from "./safe-spawn.js";
-import { shouldRecurseIntoDir, walkTreeStackSync } from "./source-walker.js";
-const EMPTY_RESULT = {
-  success: false,
-  clones: [],
-  duplicatedLines: 0,
-  totalLines: 0,
-  percentage: 0
-};
-const SCAN_TIMEOUT_MS = 30000;
-const JSCPD_CONFIG_FILENAMES = [".jscpd.json", "jscpd.json"];
-function hasProjectJscpdConfig(cwd) {
-  for (const name of JSCPD_CONFIG_FILENAMES) {
-    if (fs.existsSync(path.join(cwd, name)))
-      return true;
-  }
-  try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
-    if (pkg && typeof pkg === "object" && pkg.jscpd !== undefined)
-      return true;
-  } catch {}
-  return false;
-}
-const jscpdAvailability = createAvailabilityChecker("jscpd", "", ["--version"], {
-  probeTimeout: 1500,
-  fastPath: () => findManagedNodeToolBinary("jscpd")
-});
-
-export class JscpdClient {
-  jscpdManagedPath = null;
-  inFlight = new Map;
-  log;
-  constructor(verbose = false) {
-    this.log = verbose ? createSubsystemLogger("jscpd") : () => {};
-  }
-  async shutdown() {
-    await Promise.allSettled(this.inFlight.values());
-  }
-  hasSourceFilesRecursive(rootDir) {
-    const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
-    const state = { visited: 0 };
-    const MAX_ENTRIES = getJscpdMaxEntriesDerived(rootDir);
-    return walkTreeStackSync(rootDir, (entry, fullPath) => {
-      state.visited += 1;
-      if (entry.isSymbolicLink())
-        return "skip";
-      if (entry.isDirectory()) {
-        return shouldRecurseIntoDir(entry, fullPath, {
-          ignoreMatcher,
-          followSymlinks: true
-        }) ? "recurse" : "skip";
-      }
-      if (!entry.isFile())
-        return "skip";
-      if (/\.(ts|tsx|js|jsx|mjs|cjs|py|pyi|java|go|rs|rb|php|swift|kt|kts|dart|lua|scala|c|h|cpp|cc|cxx|hpp|hxx|cs|m|mm)$/.test(entry.name)) {
-        if (entry.name.endsWith(".d.ts"))
-          return "skip";
-        if (ignoreMatcher.isIgnored(fullPath, false))
-          return "skip";
-        return "stop";
-      }
-      return "skip";
-    }, { shouldStop: () => state.visited >= MAX_ENTRIES });
-  }
-  async ensureAvailable() {
-    const resolved = await resolveAvailableOrInstall(jscpdAvailability, "jscpd", process.cwd());
-    if (!resolved)
-      return false;
-    if (isFullyQualified(resolved))
-      this.jscpdManagedPath = resolved;
-    return true;
-  }
-  getAvailabilityVerdict() {
-    const verdict = jscpdAvailability.getVerdict(process.cwd());
-    return {
-      outcome: verdict.outcome,
-      cause: verdict.cause,
-      retryAtMs: verdict.retryAtMs
-    };
-  }
-  async scan(cwd, minLines = 5, minTokens = 50, isTsProject = false, options = {}) {
-    const targetDir = path.resolve(cwd);
-    if (isAtOrAboveHomeDir(targetDir, options.homeDir)) {
-      this.log(`Refusing scan of unsafe root at/above home: ${targetDir}`);
-      return { ...EMPTY_RESULT };
-    }
-    if (!fs.existsSync(targetDir)) {
-      return { ...EMPTY_RESULT };
-    }
-    if (!this.hasSourceFilesRecursive(targetDir)) {
-      return { ...EMPTY_RESULT, success: true };
-    }
-    if (!await this.ensureAvailable()) {
-      return { ...EMPTY_RESULT };
-    }
-    const key = `${targetDir}:${minLines}:${minTokens}:${isTsProject}`;
-    const existing = this.inFlight.get(key);
-    if (existing) {
-      this.log(`Scan already in flight for ${targetDir}; sharing result`);
-      return existing;
-    }
-    const promise = this.runScan(targetDir, minLines, minTokens, isTsProject).finally(() => {
-      if (this.inFlight.get(key) === promise)
-        this.inFlight.delete(key);
-    });
-    this.inFlight.set(key, promise);
-    return promise;
-  }
-  async runScan(cwd, minLines, minTokens, isTsProject) {
-    const outDir = mkdtempSync(`${os.tmpdir()}${path.sep}dm-lens-jscpd-`);
-    const baseIgnores = [
-      ...getExcludedDirGlobs(),
-      ...getProjectIgnoreGlobs(cwd),
-      "**/*.md",
-      "**/*.txt",
-      "**/*.json",
-      "**/*.yaml",
-      "**/*.yml",
-      "**/*.toml",
-      "**/*.lock",
-      "**/*.test.*",
-      "**/*.spec.*",
-      "**/*.poc.test.*",
-      "**/__tests__/**",
-      "**/tests/**"
-    ];
-    if (isTsProject) {
-      baseIgnores.push("**/*.js", "**/*.jsx");
-    }
-    const ignorePattern = baseIgnores.join(",");
-    try {
-      const bin = await findNodeToolBinary("jscpd", cwd);
-      const { cmd, prefix } = bin ? { cmd: bin, prefix: [] } : this.jscpdManagedPath ? { cmd: this.jscpdManagedPath, prefix: [] } : { cmd: "npx", prefix: ["jscpd"] };
-      const hasConfig = hasProjectJscpdConfig(cwd);
-      const result = await safeSpawnAsync(cmd, [
-        ...prefix,
-        ".",
-        ...hasConfig ? [] : [
-          "--min-lines",
-          String(minLines),
-          "--min-tokens",
-          String(minTokens)
-        ],
-        "--reporters",
-        "json",
-        "--output",
-        outDir,
-        ...hasConfig ? [] : ["--ignore", ignorePattern]
-      ], {
-        timeout: SCAN_TIMEOUT_MS,
-        cwd
-      });
-      if (result.error) {
-        this.log(`Scan error: ${result.error.message}`);
-        return { ...EMPTY_RESULT };
-      }
-      const reportPath = path.join(outDir, "jscpd-report.json");
-      if (!fs.existsSync(reportPath)) {
-        if (result.status !== 0) {
-          const reason = formatToolFailure({
-            tool: "jscpd",
-            status: result.status,
-            signal: result.signal,
-            stderr: result.stderr,
-            reportMissing: true,
-            fields: { command: cmd }
-          });
-          this.log(reason);
-          incrementDegradationCount({
-            kind: "runner-empty-result",
-            subject: "jscpd",
-            reason
-          });
-          return { ...EMPTY_RESULT };
-        }
-        return { ...EMPTY_RESULT, success: true };
-      }
-      return this.parseReport(reportPath);
-    } catch (err) {
-      this.log(`Scan error: ${err.message}`);
-      return { ...EMPTY_RESULT };
-    } finally {
-      try {
-        fs.rmSync(outDir, { recursive: true, force: true });
-      } catch (err) {}
-    }
-  }
-  formatResult(result, maxClones = 8) {
-    if (!result.success || result.clones.length === 0)
-      return "";
-    const pct = result.percentage.toFixed(1);
-    let output = `[jscpd] ${result.clones.length} duplicate block(s) — ${pct}% of codebase (${result.duplicatedLines}/${result.totalLines} lines):
-`;
-    for (const clone of result.clones.slice(0, maxClones)) {
-      const a = `${path.basename(clone.fileA)}:${clone.startA}`;
-      const b = `${path.basename(clone.fileB)}:${clone.startB}`;
-      output += `  ${clone.lines} lines — ${a} ↔ ${b}
-`;
-    }
-    if (result.clones.length > maxClones) {
-      output += `  ... and ${result.clones.length - maxClones} more
-`;
-    }
-    return output;
-  }
-  parseReport(reportPath) {
-    try {
-      const data = JSON.parse(fs.readFileSync(reportPath, "utf-8"));
-      const total = data.statistics?.total ?? {};
-      const duplicatedLines = total.duplicatedLines ?? 0;
-      const totalLines = total.lines ?? 0;
-      const percentage = total.percentage ?? (totalLines > 0 ? duplicatedLines / totalLines * 100 : 0);
-      const rawClones = data.duplicates ?? [];
-      const clones = rawClones.map((c) => ({
-        fileA: c.firstFile?.name ?? "",
-        startA: c.firstFile?.start ?? 0,
-        fileB: c.secondFile?.name ?? "",
-        startB: c.secondFile?.start ?? 0,
-        lines: c.lines ?? 0,
-        tokens: c.tokens ?? 0
-      }));
-      return {
-        success: true,
-        analyzed: true,
-        clones,
-        duplicatedLines,
-        totalLines,
-        percentage
-      };
-    } catch (err) {
-      return {
-        success: false,
-        clones: [],
-        duplicatedLines: 0,
-        totalLines: 0,
-        percentage: 0
-      };
-    }
-  }
-}