@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/clients/post-autofix-notice.js

@@ -0,0 +1,19 @@
+export function renderPostAutofixNotice(notice, decision) {
+  const topFiles = notice.changedFiles.slice(0, 8).map((f) => "  - " + f).join(`
+`);
+  const overflow = notice.changedFiles.length > 8 ? `
+  - ... and ` + (notice.changedFiles.length - 8) + " more" : "";
+  const fileList = notice.changedFiles.length ? `
+Modified files:
+` + topFiles + overflow : "";
+  switch (decision) {
+    case "attached":
+      return `⚠️ **The attached full content for ${notice.targetPath} is authoritative after autofix. You MUST re-read any other modified side-effect files before editing them.**${fileList}`;
+    case "size-capped":
+      return `⚠️ **File was modified by auto-format/fix. You MUST re-read ${notice.targetPath} before making any further edits — the authoritative content is too large to attach.**${fileList}`;
+    case "aggregate-budget-degraded":
+      return `⚠️ **File was modified by auto-format/fix. You MUST re-read ${notice.targetPath} before making any further edits — the aggregate authoritative content for this command is too large to attach.**${fileList}`;
+    default:
+      return `⚠️ **File was modified by auto-format/fix. You MUST re-read modified file(s) before making any further edits — the content on disk has changed (whitespace, indentation, quotes, or code). Editing from memory will produce mismatches.**${fileList}`;
+  }
+}

package/extensions/dm-lens/dist/clients/print-mode.js

@@ -0,0 +1,3 @@
+export function isPrintMode(argv = process.argv) {
+  return argv.includes("--print") || argv.includes("-p");
+}

package/extensions/dm-lens/dist/clients/probe-home-state.js

@@ -0,0 +1,67 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { isUnderDir, normalizeFilePath } from "./path-utils.js";
+const RESOLUTION_SLOT = Symbol.for("dm-lens.probe-home-state.resolution");
+export function getProbeHomeResolution() {
+  return globalThis[RESOLUTION_SLOT];
+}
+export function getProbeHomeRedirectEvent() {
+  return getProbeHomeResolution()?.event;
+}
+export function getGlobalDmLensLogDir() {
+  const override = process.env.DM_LENS_HOME?.trim();
+  if (override)
+    return path.resolve(override);
+  return resolveProbeHomeDir() ?? path.join(os.homedir(), ".dm-lens");
+}
+export function isTestProcessTargetingRealHome(file) {
+  if (!process.env.VITEST)
+    return false;
+  return isUnderRealDir(path.dirname(path.resolve(file)), path.join(os.homedir(), ".dm-lens"));
+}
+function resolveProbeHomeDir() {
+  const slot = globalThis;
+  const cached = slot[RESOLUTION_SLOT];
+  if (cached)
+    return cached.probeHome;
+  const cwd = process.cwd();
+  const probeHome = computeProbeHomeDir(cwd);
+  slot[RESOLUTION_SLOT] = {
+    probeHome,
+    event: probeHome ? { probeHome } : undefined
+  };
+  return probeHome;
+}
+export function _resetProbeHomeRedirectStateForTests() {
+  globalThis[RESOLUTION_SLOT] = undefined;
+}
+function computeProbeHomeDir(cwd) {
+  if (process.env.PILENS_PROBE === "1") {
+    return path.join(cwd, ".dm-lens-probe-home");
+  }
+  const worktreeRoot = findAgentWorktreeRoot(cwd);
+  if (worktreeRoot)
+    return path.join(worktreeRoot, ".dm-lens-probe-home");
+  if (isUnderRealDir(cwd, os.tmpdir())) {
+    return path.join(cwd, ".dm-lens-probe-home");
+  }
+  return;
+}
+function findAgentWorktreeRoot(cwd) {
+  const normalized = normalizeFilePath(path.resolve(cwd));
+  const match = /(?:^|\/)\.claude\/worktrees\/[^/]+(?:\/|$)/.exec(normalized);
+  if (!match)
+    return;
+  return normalized.slice(0, match.index + match[0].length).replace(/\/$/, "");
+}
+function isUnderRealDir(child, parent) {
+  return isUnderDir(toRealPath(child), toRealPath(parent));
+}
+function toRealPath(target) {
+  try {
+    return fs.realpathSync.native(target);
+  } catch {
+    return target;
+  }
+}

package/extensions/dm-lens/dist/clients/process-bridge.js

@@ -0,0 +1,48 @@
+import { getProcessSingleton } from "./process-singletons.js";
+export function registerProcessBridge(key, build) {
+  if (key in globalThis)
+    return;
+  const bridge = Object.freeze(build());
+  Object.defineProperty(globalThis, key, {
+    value: bridge,
+    writable: false,
+    configurable: false,
+    enumerable: false
+  });
+}
+export function getProcessBridge(key, version) {
+  const bridge = globalThis[key];
+  if (!bridge || typeof bridge !== "object")
+    return;
+  const candidate = bridge;
+  if (candidate.version !== version)
+    return;
+  return candidate;
+}
+function isScopedBridgeActivation(activation) {
+  if (typeof activation !== "object" || activation === null)
+    return false;
+  const candidate = activation;
+  return (candidate.role === "primary" || candidate.role === "secondary") && typeof candidate.scopeId === "number" && typeof candidate.isLive === "function";
+}
+function isPreSessionActivation(activation) {
+  return typeof activation === "object" && activation !== null && activation.role === "pre-session";
+}
+export function rebindableProcessBridgeDeps(family, version, activation, deps) {
+  const cell = getProcessSingleton(family, version, () => ({
+    activation,
+    deps
+  }));
+  const current = isScopedBridgeActivation(cell.activation) ? cell.activation : undefined;
+  const accepts = !isScopedBridgeActivation(activation) ? isPreSessionActivation(activation) ? current === undefined : cell.activation !== activation : activation.role === "primary" && activation.isLive() && (current === undefined || current.role === "primary" && activation.scopeId > current.scopeId);
+  if (accepts) {
+    cell.activation = activation;
+    cell.deps = deps;
+  }
+  return () => {
+    const owner = cell.activation;
+    if (isScopedBridgeActivation(owner) && !owner.isLive())
+      return;
+    return cell.deps;
+  };
+}

package/extensions/dm-lens/dist/clients/process-singletons.js

@@ -0,0 +1,69 @@
+const SINGLETON_HOST_KEY = Symbol.for("dm-lens.process-singletons.v1");
+const SINGLETON_SCHEMA = "dm-lens.process-singletons";
+export const PROCESS_SINGLETON_RESET_KIND = "process-singleton-reset";
+const singletonHost = globalThis;
+function container() {
+  const existing = singletonHost[SINGLETON_HOST_KEY];
+  if (existing instanceof Map)
+    return existing;
+  const fresh = new Map;
+  singletonHost[SINGLETON_HOST_KEY] = fresh;
+  return fresh;
+}
+function isAdoptable(cell, version) {
+  if (!cell || typeof cell !== "object")
+    return false;
+  const candidate = cell;
+  return candidate.schema === SINGLETON_SCHEMA && candidate.version === version && candidate.value !== undefined;
+}
+export const PROCESS_SINGLETON_RESET_LOG_FAMILY = "process-singleton-reset-log";
+const RESET_LOG_FAMILY = PROCESS_SINGLETON_RESET_LOG_FAMILY;
+const RESET_LOG_VERSION = 1;
+const RESET_LOG_CAP = 16;
+function resetLog() {
+  return getProcessSingleton(RESET_LOG_FAMILY, RESET_LOG_VERSION, () => ({
+    entries: []
+  }));
+}
+function recordIncompatibleCell(family, wantedVersion, found) {
+  if (family === RESET_LOG_FAMILY)
+    return;
+  const log = resetLog();
+  if (log.entries.some((entry) => entry.family === family))
+    return;
+  if (log.entries.length >= RESET_LOG_CAP)
+    return;
+  log.entries.push({
+    family,
+    reason: `incompatible process singleton discarded (found schema=${String(found.schema)} ` + `version=${String(found.version)}, this build wants schema=${SINGLETON_SCHEMA} ` + `version=${wantedVersion})`
+  });
+}
+export function getProcessSingletonResets() {
+  return resetLog().entries.map((entry) => ({ ...entry }));
+}
+export function getProcessSingleton(family, version, create, onIncompatible) {
+  const cells = container();
+  const existing = cells.get(family);
+  if (isAdoptable(existing, version))
+    return existing.value;
+  if (existing !== undefined) {
+    recordIncompatibleCell(family, version, existing);
+    onIncompatible?.(existing.value);
+  }
+  const value = create();
+  cells.set(family, { schema: SINGLETON_SCHEMA, version, value });
+  return value;
+}
+export function _resetProcessSingletonsForTests() {
+  singletonHost[SINGLETON_HOST_KEY] = new Map;
+}
+export function _seedProcessSingletonCellForTests(family, cell) {
+  container().set(family, cell);
+}
+const EVALUATION_ORDINAL_FAMILY = "module-evaluation-ordinal";
+const EVALUATION_ORDINAL_VERSION = 1;
+export function nextModuleEvaluationOrdinal() {
+  const state = getProcessSingleton(EVALUATION_ORDINAL_FAMILY, EVALUATION_ORDINAL_VERSION, () => ({ evaluations: 0 }));
+  state.evaluations += 1;
+  return state.evaluations;
+}

package/extensions/dm-lens/dist/clients/process-snapshot.js

@@ -0,0 +1,130 @@
+import { spawnCollectStdoutResult } from "./child-unref.js";
+import { buildEnvironmentQuery, buildProcessQuery, parseEnvironmentVariable, parseProcessTable, readLinuxPidNamespace, readLinuxProcessEnvironmentVariable, readLinuxProcessStart } from "../scripts/lib/process-scan.mjs";
+export { windowsExe } from "../scripts/lib/process-scan.mjs";
+export async function queryProcessTable(request, options) {
+  let query;
+  try {
+    query = buildProcessQuery(request.fields, {
+      filter: request.filter,
+      excludeSelfPid: request.excludeSelfPid
+    });
+  } catch {
+    return { rows: [], status: "spawn-error", serverSideFiltered: false };
+  }
+  const result = await spawnCollectStdoutResult(query.command, query.args, {
+    shell: false,
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "ignore"],
+    env: query.env
+  }, { timeoutMs: options.timeoutMs, onTimeout: options.onTimeout });
+  return {
+    rows: parseProcessTable(result.stdout, query.tabSeparated, query.fields),
+    status: result.status,
+    exitCode: result.exitCode,
+    timeoutKill: result.timeoutKill,
+    serverSideFiltered: query.serverSideFiltered
+  };
+}
+function validPids(pids) {
+  return [...new Set(pids.filter((p) => Number.isInteger(p) && p > 0))];
+}
+export async function queryProcessIdentities(pids, options) {
+  const valid = validPids(pids);
+  const identities = new Map;
+  if (valid.length === 0)
+    return { identities, status: "ok" };
+  const linux = process.platform === "linux";
+  const result = await queryProcessTable({
+    fields: linux ? ["pid", "command"] : ["pid", "startedAt", "command"],
+    filter: { column: "ProcessId", op: "eq", values: valid }
+  }, options);
+  for (const row of result.rows) {
+    const start = linux ? readLinuxProcessStart(row.pid) : row.startedAt;
+    identities.set(row.pid, {
+      command: row.command,
+      start: start ? start : undefined
+    });
+  }
+  return { identities, status: result.status };
+}
+export const OWNER_TAG_ENV = "DM_LENS_OWNER";
+export function formatOwnerTag(tag) {
+  return `${tag.pid}:${tag.start}`;
+}
+export function parseOwnerTag(value) {
+  const match = /^(\d+):(\d+@[0-9a-f-]{36}|\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)$/.exec(value ?? "");
+  if (!match)
+    return;
+  const [, pidText = "", start = ""] = match;
+  const pid = Number(pidText);
+  return pid > 0 ? { pid, start } : undefined;
+}
+export async function ownerTagForChildren(options) {
+  if (process.platform === "win32")
+    return;
+  const start = await ownProcessStart(options);
+  return start === undefined ? undefined : formatOwnerTag({ pid: process.pid, start });
+}
+export async function readOwnerTags(pids, options) {
+  const tags = new Map;
+  const valid = validPids(pids);
+  if (valid.length === 0 || process.platform === "win32")
+    return { tags, status: "ok" };
+  if (process.platform === "linux") {
+    const own = ownPidNamespace();
+    for (const pid of valid) {
+      const namespace = readLinuxPidNamespace(pid);
+      if (namespace === undefined || namespace !== own)
+        continue;
+      const tag = parseOwnerTag(readLinuxProcessEnvironmentVariable(pid, OWNER_TAG_ENV));
+      if (tag)
+        tags.set(pid, tag);
+    }
+    return { tags, status: "ok" };
+  }
+  const query = buildEnvironmentQuery(valid);
+  const result = await spawnCollectStdoutResult(query.command, query.args, { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }, options);
+  for (const [pid, value] of parseEnvironmentVariable(result.stdout, OWNER_TAG_ENV)) {
+    const tag = parseOwnerTag(value);
+    if (tag)
+      tags.set(pid, tag);
+  }
+  return {
+    tags,
+    status: result.status === "exit-error" ? "ok" : result.status
+  };
+}
+export function isInPidNamespace(entry, namespace) {
+  return entry.pidNamespace === undefined || entry.pidNamespace === namespace;
+}
+export function ownPidNamespace() {
+  return process.platform === "linux" ? readLinuxPidNamespace(process.pid) : undefined;
+}
+let ownStart = null;
+export function ownProcessStart(options) {
+  if (process.platform === "linux")
+    return Promise.resolve(readLinuxProcessStart(process.pid));
+  if (ownStart)
+    return ownStart.promise;
+  const cell = {
+    promise: readProcessStart(process.pid, options).then((start) => {
+      if (start === undefined)
+        ownStart = null;
+      else
+        cell.value = start;
+      return start;
+    })
+  };
+  ownStart = cell;
+  return cell.promise;
+}
+export async function readProcessStart(pid, options) {
+  if (process.platform === "linux")
+    return readLinuxProcessStart(pid);
+  return (await queryProcessIdentities([pid], options)).identities.get(pid)?.start;
+}
+export function ownProcessStartIfKnown() {
+  if (process.platform === "linux")
+    return readLinuxProcessStart(process.pid);
+  return ownStart?.value;
+}

package/extensions/dm-lens/dist/clients/project-changes.js

@@ -0,0 +1,174 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { incrementDegradationCount } from "./degradation-ledger.js";
+import { getProjectDataDir } from "./file-utils.js";
+import { withGenerationLockSync } from "./generation-lock.js";
+import { normalizeMapKey } from "./path-utils.js";
+export function getProjectChangeLogPath(cwd) {
+  return path.join(getProjectDataDir(cwd), "change-log.jsonl");
+}
+function parseChangeLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed.seq !== "number" || typeof parsed.fileSeq !== "number" || typeof parsed.filePath !== "string" || typeof parsed.source !== "string") {
+      return;
+    }
+    return {
+      seq: parsed.seq,
+      timestamp: parsed.timestamp ?? new Date(0).toISOString(),
+      sessionId: parsed.sessionId ?? "unknown",
+      turnIndex: parsed.turnIndex ?? 0,
+      source: parsed.source,
+      filePath: parsed.filePath,
+      fileSeq: parsed.fileSeq,
+      changedRange: parsed.changedRange,
+      ...parsed.unlocked === true ? { unlocked: true } : {}
+    };
+  } catch {
+    return;
+  }
+}
+const changeLogCursors = new BoundedFifoMap(16);
+function parseChangeLog(logPath, content) {
+  const entries = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map(parseChangeLine).filter((entry) => Boolean(entry));
+  const bytes = Buffer.byteLength(content.slice(0, content.lastIndexOf(`
+`) + 1));
+  let maxSeq = 0;
+  for (const entry of entries)
+    maxSeq = Math.max(maxSeq, entry.seq);
+  changeLogCursors.set(logPath, { bytes, maxSeq });
+  return entries;
+}
+export function readProjectChanges(cwd) {
+  const logPath = getProjectChangeLogPath(cwd);
+  try {
+    return parseChangeLog(logPath, fs.readFileSync(logPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+async function readProjectChangesAsync(cwd) {
+  const logPath = getProjectChangeLogPath(cwd);
+  try {
+    return parseChangeLog(logPath, await fs.promises.readFile(logPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+export function readChangesSince(cwd, seq, maxEntries = 200) {
+  const limit = Math.max(1, maxEntries);
+  return readProjectChanges(cwd).filter((entry) => entry.seq > seq).sort((a, b) => a.seq - b.seq).slice(-limit);
+}
+let _sequenceFoldCountForTests = 0;
+export function getSequenceFoldCountForTests() {
+  return _sequenceFoldCountForTests;
+}
+export function resetSequenceFoldCountForTests() {
+  _sequenceFoldCountForTests = 0;
+}
+function foldEntry(entry, fileSeqByPath) {
+  _sequenceFoldCountForTests++;
+  const key = normalizeMapKey(path.resolve(entry.filePath));
+  fileSeqByPath.set(key, Math.max(fileSeqByPath.get(key) ?? 0, entry.fileSeq));
+}
+function fullReplay(entries) {
+  let projectSeq = 0;
+  const fileSeqByPath = new Map;
+  for (const entry of entries) {
+    projectSeq = Math.max(projectSeq, entry.seq);
+    foldEntry(entry, fileSeqByPath);
+  }
+  return { projectSeq, fileSeqByPath };
+}
+function partialReplay(entries, base) {
+  let logMaxSeq = 0;
+  for (const entry of entries) {
+    if (entry.seq > logMaxSeq)
+      logMaxSeq = entry.seq;
+  }
+  if (base.sinceSeq > logMaxSeq)
+    return null;
+  const fileSeqByPath = new Map(base.fileSeqByPath);
+  let projectSeq = Math.max(0, base.projectSeq);
+  for (const entry of entries) {
+    if (entry.seq <= base.sinceSeq)
+      continue;
+    projectSeq = Math.max(projectSeq, entry.seq);
+    foldEntry(entry, fileSeqByPath);
+  }
+  return { projectSeq, fileSeqByPath };
+}
+export function readLatestProjectSequence(cwd, base) {
+  return replay(readProjectChanges(cwd), base);
+}
+function replay(entries, base) {
+  let unlockedThrough = 0;
+  entries.forEach((entry, index) => {
+    if (entry.unlocked)
+      unlockedThrough = index + 1;
+  });
+  const index = base && unlockedThrough <= (base.logEntries ?? 0) && partialReplay(entries, base) || fullReplay(entries);
+  return { ...index, logEntries: entries.length, unlockedThrough };
+}
+export async function readLatestProjectSequenceAsync(cwd, base) {
+  return replay(await readProjectChangesAsync(cwd), base);
+}
+export function appendProjectChange(cwd, entry) {
+  const logPath = getProjectChangeLogPath(cwd);
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  fs.appendFileSync(logPath, `${JSON.stringify(entry)}
+`, "utf-8");
+}
+function readChangeLogMaxSeq(logPath) {
+  let fd;
+  try {
+    fd = fs.openSync(logPath, "r");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return 0;
+    throw err;
+  }
+  try {
+    const cursor = changeLogCursors.get(logPath) ?? { bytes: 0, maxSeq: 0 };
+    const size = fs.fstatSync(fd).size;
+    if (size > cursor.bytes) {
+      const tail = Buffer.alloc(size - cursor.bytes);
+      const read = fs.readSync(fd, tail, 0, tail.length, cursor.bytes);
+      const complete = tail.subarray(0, read).lastIndexOf(10) + 1;
+      for (const line of tail.subarray(0, complete).toString("utf-8").split(`
+`)) {
+        const entry = line.trim() ? parseChangeLine(line) : undefined;
+        if (entry && entry.seq > cursor.maxSeq)
+          cursor.maxSeq = entry.seq;
+      }
+      cursor.bytes += complete;
+    }
+    changeLogCursors.set(logPath, cursor);
+    return cursor.maxSeq;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+const CHANGE_LOG_LOCK = { staleMs: 5000, waitMs: 500 };
+export function appendProjectChangeAllocated(cwd, build) {
+  const logPath = getProjectChangeLogPath(cwd);
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  readChangeLogMaxSeq(logPath);
+  const append = (locked) => {
+    const entry = build(readChangeLogMaxSeq(logPath));
+    const line = locked ? entry : { ...entry, unlocked: true };
+    fs.appendFileSync(logPath, `${JSON.stringify(line)}
+`, "utf-8");
+  };
+  const result = withGenerationLockSync(`${logPath}.locks`, CHANGE_LOG_LOCK, () => append(true));
+  if (result.held)
+    return;
+  const code = result.cause?.code;
+  incrementDegradationCount({
+    kind: "change-log-lock-unavailable",
+    subject: logPath,
+    reason: `appended unlocked: ${code ? `lock failed (${code})` : "lock wait ran out"}`
+  });
+  append(false);
+}

package/extensions/dm-lens/dist/clients/project-conventions.js

@@ -0,0 +1,152 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+function readPackageJson(cwd) {
+  const pkgPath = path.join(cwd, "package.json");
+  try {
+    const raw = fs.readFileSync(pkgPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return;
+  }
+}
+function hasDep(pkg, name) {
+  if (!pkg)
+    return false;
+  return Boolean(pkg.dependencies?.[name] ?? pkg.devDependencies?.[name] ?? pkg.peerDependencies?.[name]);
+}
+function fileExists(cwd, ...segments) {
+  try {
+    return fs.existsSync(path.join(cwd, ...segments));
+  } catch {
+    return false;
+  }
+}
+function dirExists(cwd, ...segments) {
+  try {
+    const target = path.join(cwd, ...segments);
+    const stat = fs.statSync(target);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function detectReact(_cwd, pkg) {
+  const signals = [];
+  if (hasDep(pkg, "react"))
+    signals.push("package.json:dependencies.react");
+  if (hasDep(pkg, "react-dom"))
+    signals.push("package.json:dependencies.react-dom");
+  if (hasDep(pkg, "@types/react"))
+    signals.push("package.json:devDependencies.@types/react");
+  if (signals.length === 0)
+    return;
+  const confidence = hasDep(pkg, "react-dom") ? "high" : "medium";
+  return { id: "react", confidence, signals };
+}
+function detectNext(cwd, pkg) {
+  const signals = [];
+  if (hasDep(pkg, "next"))
+    signals.push("package.json:dependencies.next");
+  for (const candidate of [
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts"
+  ]) {
+    if (fileExists(cwd, candidate))
+      signals.push(candidate);
+  }
+  if (dirExists(cwd, "src", "pages"))
+    signals.push("src/pages/");
+  else if (dirExists(cwd, "pages"))
+    signals.push("pages/");
+  if (dirExists(cwd, "src", "app"))
+    signals.push("src/app/");
+  else if (dirExists(cwd, "app"))
+    signals.push("app/");
+  if (signals.length === 0)
+    return;
+  const confidence = hasDep(pkg, "next") && signals.some((s) => s.startsWith("next.config.")) ? "high" : hasDep(pkg, "next") ? "medium" : "low";
+  return { id: "next", confidence, signals };
+}
+function detectVite(cwd, pkg) {
+  const signals = [];
+  if (hasDep(pkg, "vite"))
+    signals.push("package.json:devDependencies.vite");
+  for (const candidate of [
+    "vite.config.ts",
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.mts"
+  ]) {
+    if (fileExists(cwd, candidate))
+      signals.push(candidate);
+  }
+  if (signals.length === 0)
+    return;
+  const confidence = hasDep(pkg, "vite") && signals.some((s) => s.startsWith("vite.config.")) ? "high" : "medium";
+  return { id: "vite", confidence, signals };
+}
+function detectVitest(cwd, pkg) {
+  const signals = [];
+  if (hasDep(pkg, "vitest"))
+    signals.push("package.json:devDependencies.vitest");
+  for (const candidate of [
+    "vitest.config.ts",
+    "vitest.config.js",
+    "vitest.config.mjs",
+    "vitest.config.mts"
+  ]) {
+    if (fileExists(cwd, candidate))
+      signals.push(candidate);
+  }
+  if (signals.length === 0)
+    return;
+  const confidence = hasDep(pkg, "vitest") ? "high" : "medium";
+  return { id: "vitest", confidence, signals };
+}
+const AGENT_DOC_CANDIDATES = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  ".cursorrules"
+];
+function summarizeAgentDocs(cwd) {
+  const docs = [];
+  for (const candidate of AGENT_DOC_CANDIDATES) {
+    const abs = path.join(cwd, candidate);
+    try {
+      const raw = fs.readFileSync(abs, "utf-8");
+      const lineCount = raw.split(/\r?\n/).length;
+      docs.push({ filePath: candidate, lineCount });
+    } catch {}
+  }
+  return docs;
+}
+export function detectProjectConventions(cwd) {
+  let cwdExists = false;
+  try {
+    cwdExists = fs.statSync(cwd).isDirectory();
+  } catch {
+    cwdExists = false;
+  }
+  if (!cwdExists) {
+    return { frameworks: [], testRunners: [], buildTools: [], agentDocs: [] };
+  }
+  const pkg = readPackageJson(cwd);
+  const detectors = [detectReact, detectNext, detectVite, detectVitest];
+  const frameworks = [];
+  for (const detector of detectors) {
+    const detection = detector(cwd, pkg);
+    if (detection)
+      frameworks.push(detection);
+  }
+  const testRunners = [];
+  if (frameworks.some((f) => f.id === "vitest"))
+    testRunners.push("vitest");
+  const buildTools = [];
+  if (frameworks.some((f) => f.id === "vite"))
+    buildTools.push("vite");
+  if (frameworks.some((f) => f.id === "next"))
+    buildTools.push("next");
+  const agentDocs = summarizeAgentDocs(cwd);
+  return { frameworks, testRunners, buildTools, agentDocs };
+}