etymd 0.1.0

package/dist/chunk-5D7WNJ6N.js

@@ -0,0 +1,1148 @@
+#!/usr/bin/env node
+import { readLedger, reconcileLedger, writeLedger, visibleFindings } from './chunk-N64ZTBCW.js';
+import { DEFAULT_CONFIG, readConfig, CONFIG_FILE, measureContext } from './chunk-I566LDX7.js';
+import { scanProject, PACK_VERSION, expandFileGlobs } from './chunk-TCWKIMCU.js';
+import { ETYMD_DIR, writeCachedFacts, readBaseline, deriveProfile, baselineCarriesMachinePath, BASELINE_FILE } from './chunk-SMM2TW35.js';
+import { print, section, theme, renderLensCoverage, renderFindings, renderLedgerDiff, pathExists, readJson, git, isDirectory, matchesAnyGlob, readText, isCiEnvironment, normalizeRelPath } from './chunk-WVYKYPKS.js';
+import path from 'node:path';
+import YAML from 'yaml';
+import { promises } from 'node:fs';
+
+// src/lenses/context-economy.ts
+var LENS_ID = "context-economy";
+DEFAULT_CONFIG.context.totalWords;
+var contextEconomyLens = {
+  id: LENS_ID,
+  version: "1",
+  title: "Context economy",
+  kind: "improvement",
+  async run(ctx) {
+    const budgets = ctx.config?.config.context ?? DEFAULT_CONFIG.context;
+    const budget = await measureContext(ctx.root, budgets.perFileWords);
+    const findings = [];
+    for (const f of budget.extractionCandidates) {
+      findings.push({
+        id: `${LENS_ID}/heavy-file:${f.path}`,
+        lens: LENS_ID,
+        tier: "gap",
+        claim: `${f.path} loads ${f.words} words (~${f.approxTokens} tokens) into every session`,
+        evidence: [`${f.path}: ${f.words} words`],
+        why: "Reference material that loads every session taxes attention and cost on tasks that never need it.",
+        action: "Extract the reference bulk into an on-demand skill/doc and keep a pointer.",
+        effort: "M",
+        confidence: "high"
+      });
+    }
+    if (budget.totalWords >= budgets.totalWords) {
+      findings.push({
+        id: `${LENS_ID}/total-over-budget`,
+        lens: LENS_ID,
+        tier: "gap",
+        claim: `The always-loaded footprint is ${budget.totalWords} words (~${budget.totalApproxTokens} tokens) \u2014 over the ${budgets.totalWords}-word budget`,
+        evidence: budget.files.slice(0, 5).map((f) => `${f.path}: ${f.words}w`),
+        why: "Every session pays this before the task begins; instruction-following degrades as the resident context grows.",
+        action: "Run `etymd context` for the per-file breakdown and extract the heaviest block.",
+        effort: "M",
+        confidence: "high"
+      });
+    }
+    return {
+      lens: LENS_ID,
+      version: "1",
+      title: "Context economy",
+      kind: "improvement",
+      status: "ran",
+      disclosures: [
+        ...ctx.config?.problems ?? [],
+        `Budgets: ${budgets.perFileWords} words/file, ${budgets.totalWords} words total (${budgets.perFileWords === DEFAULT_CONFIG.context.perFileWords && budgets.totalWords === DEFAULT_CONFIG.context.totalWords ? `defaults \u2014 override under \`context\` in ${CONFIG_FILE}` : `set in ${CONFIG_FILE}`}). Scoped Cursor rules excluded.`
+      ],
+      findings
+    };
+  }
+};
+var TOOL_MATCHERS = [
+  ["sonar", /sonar-scanner|sonarqube|\bsonar\b/i],
+  ["codecov", /codecov/i],
+  ["commitlint", /commitlint/],
+  ["chromatic", /chromatic/],
+  ["size", /size-limit|bundlesize/],
+  ["e2e", /\bcypress\b|\bplaywright\b/],
+  ["coverage", /--coverage|\bnyc\b|\bc8\b/],
+  ["format-check", /prettier[^&|;]*(\s-l\b|\s--check)|format:check/],
+  ["format-write", /prettier[^&|;]*--write|--fix\b/],
+  ["typecheck", /\btsc\b(?![^&|;]*--watch)/],
+  ["lint", /\beslint\b/],
+  ["test", /\bjest\b|\bvitest\b|react-scripts test|\bnx\b[^&|;]*\btest\b/]
+];
+function expandScriptRefs(command, scripts, depth = 2) {
+  if (depth <= 0) return command;
+  let expanded = command;
+  for (const m of command.matchAll(
+    /(?:yarn|pnpm|npm run|bun run|npx run-s|npx run-p)\s+([A-Za-z0-9:._-]+)/g
+  )) {
+    const name = m[1];
+    const body = scripts[name];
+    if (body) expanded += `
+${expandScriptRefs(body, scripts, depth - 1)}`;
+  }
+  if (/npm-run-all|run-s|run-p/.test(command)) {
+    for (const token of command.split(/\s+/)) {
+      const clean = token.replace(/["']/g, "");
+      const body = scripts[clean];
+      if (body) expanded += `
+${expandScriptRefs(body, scripts, depth - 1)}`;
+    }
+  }
+  return expanded;
+}
+function matchTools(command, scripts) {
+  const expanded = expandScriptRefs(command, scripts);
+  const tools = /* @__PURE__ */ new Set();
+  for (const [tool, re] of TOOL_MATCHERS) {
+    if (re.test(expanded)) tools.add(tool);
+  }
+  return [...tools];
+}
+var GITLAB_TAGS = [
+  { tag: "!reference", collection: "seq", resolve: () => [] }
+];
+var GITLAB_RESERVED = /* @__PURE__ */ new Set([
+  "stages",
+  "variables",
+  "include",
+  "default",
+  "workflow",
+  "image",
+  "services",
+  "before_script",
+  "after_script",
+  "cache",
+  "types"
+]);
+function looksLikeJob(job) {
+  return job.script !== void 0 || job.before_script !== void 0 || job.extends !== void 0 || job.stage !== void 0 || job.image !== void 0 || job.trigger !== void 0 || job.rules !== void 0 || job.needs !== void 0 || job.allow_failure !== void 0;
+}
+function inferToolsFromShape(name, job) {
+  const tools = /* @__PURE__ */ new Set();
+  if (/sonar/i.test(name)) tools.add("sonar");
+  if (/chromatic/i.test(name)) tools.add("chromatic");
+  if (job.variables && typeof job.variables === "object") {
+    for (const key of Object.keys(job.variables)) {
+      if (key.startsWith("SONAR_")) tools.add("sonar");
+    }
+  }
+  return [...tools];
+}
+function asLines(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
+  return [];
+}
+function parseGitlabCi(text, file, scripts) {
+  const parseErrors = [];
+  let doc;
+  try {
+    doc = YAML.parse(text, { customTags: GITLAB_TAGS, logLevel: "silent" });
+  } catch (err) {
+    parseErrors.push(
+      `${file}: ${err instanceof Error ? err.message.split("\n")[0] : "unparseable YAML"}`
+    );
+    return { jobs: [], inheritedIncludes: [], parseErrors };
+  }
+  if (!doc || typeof doc !== "object") return { jobs: [], inheritedIncludes: [], parseErrors };
+  const inheritedIncludes = [];
+  const include = doc.include;
+  const includeEntries = Array.isArray(include) ? include : include ? [include] : [];
+  for (const entry of includeEntries) {
+    if (typeof entry === "string") inheritedIncludes.push(entry);
+    else if (entry && typeof entry === "object") {
+      const e = entry;
+      if (typeof e.local === "string") inheritedIncludes.push(`local: ${e.local}`);
+      else if (typeof e.project === "string") inheritedIncludes.push(`project: ${e.project}`);
+      else if (typeof e.template === "string") inheritedIncludes.push(`template: ${e.template}`);
+      else if (typeof e.remote === "string") inheritedIncludes.push(`remote: ${e.remote}`);
+    }
+  }
+  const jobs = [];
+  const resolveScript = (job, seen = /* @__PURE__ */ new Set()) => {
+    const lines = [...asLines(job.before_script), ...asLines(job.script)];
+    const bases = asLines(job.extends).length ? asLines(job.extends) : typeof job.extends === "string" ? [job.extends] : [];
+    for (const base of bases) {
+      if (seen.has(base)) continue;
+      seen.add(base);
+      const tpl = doc[base];
+      if (tpl && typeof tpl === "object") lines.push(...resolveScript(tpl, seen));
+    }
+    return lines;
+  };
+  for (const [key, value] of Object.entries(doc)) {
+    if (GITLAB_RESERVED.has(key) || key.startsWith(".")) continue;
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const job = value;
+    if (!looksLikeJob(job)) continue;
+    const lines = resolveScript(job);
+    const tools = new Set(inferToolsFromShape(key, job));
+    for (const line of lines) for (const t of matchTools(line, scripts)) tools.add(t);
+    if (!lines.length && !tools.size) continue;
+    jobs.push({
+      job: key,
+      file,
+      tools: [...tools],
+      advisory: job.allow_failure === true || typeof job.allow_failure === "object" && job.allow_failure !== null,
+      branchScoped: Boolean(job.rules ?? job.only ?? job.except),
+      scriptVisible: lines.length > 0
+    });
+  }
+  return { jobs, inheritedIncludes, parseErrors };
+}
+function parseGithubWorkflow(text, file, scripts) {
+  const parseErrors = [];
+  let doc;
+  try {
+    doc = YAML.parse(text, { logLevel: "silent" });
+  } catch (err) {
+    parseErrors.push(
+      `${file}: ${err instanceof Error ? err.message.split("\n")[0] : "unparseable YAML"}`
+    );
+    return { jobs: [], parseErrors };
+  }
+  const jobs = [];
+  const jobsObj = doc?.jobs ?? {};
+  for (const [key, value] of Object.entries(jobsObj)) {
+    if (!value || typeof value !== "object") continue;
+    const job = value;
+    const steps = Array.isArray(job.steps) ? job.steps : [];
+    const tools = /* @__PURE__ */ new Set();
+    for (const step of steps) {
+      const run2 = step?.run;
+      if (typeof run2 === "string") for (const t of matchTools(run2, scripts)) tools.add(t);
+    }
+    if (!tools.size) continue;
+    jobs.push({
+      job: key,
+      file,
+      tools: [...tools],
+      advisory: job["continue-on-error"] === true,
+      branchScoped: false,
+      scriptVisible: true
+    });
+  }
+  return { jobs, parseErrors };
+}
+async function localHookTools(root, facts, scripts) {
+  const hooks = facts.hooks;
+  const empty = [];
+  const readHook = async (name) => {
+    if (!hooks.dir) return empty;
+    const text = await readText(path.join(root, hooks.dir, name));
+    return text ? matchTools(text, scripts) : empty;
+  };
+  let preCommit = [];
+  let prePush = [];
+  let commitMsg = [];
+  if (hooks.dir) {
+    [preCommit, prePush, commitMsg] = await Promise.all([
+      readHook("pre-commit"),
+      readHook("pre-push"),
+      readHook("commit-msg")
+    ]);
+  } else if (hooks.source === "husky-legacy") {
+    const pkg = await readJson(
+      path.join(root, "package.json")
+    );
+    const legacy = pkg?.husky?.hooks ?? {};
+    const configText = await readText(path.join(root, "husky.config.js"));
+    const forHook = (name) => {
+      const cmd = legacy[name] ?? (configText?.includes(name) ? configText : void 0);
+      return cmd ? matchTools(cmd, scripts) : [];
+    };
+    preCommit = forHook("pre-commit");
+    prePush = forHook("pre-push");
+    commitMsg = forHook("commit-msg");
+  }
+  let lintStaged = [];
+  if (hooks.lintStaged) {
+    const pkg = await readJson(path.join(root, "package.json"));
+    const config = pkg?.["lint-staged"];
+    const commands = [];
+    const collect = (v) => {
+      if (typeof v === "string") commands.push(v);
+      else if (Array.isArray(v)) v.forEach(collect);
+      else if (v && typeof v === "object") Object.values(v).forEach(collect);
+    };
+    collect(config);
+    const tools = /* @__PURE__ */ new Set();
+    for (const cmd of commands) for (const t of matchTools(cmd, scripts)) tools.add(t);
+    lintStaged = [...tools];
+    if ((hooks.preCommit || hooks.source === "husky" || hooks.source === "husky-legacy") && lintStaged.length) {
+      preCommit = [.../* @__PURE__ */ new Set([...preCommit, ...lintStaged])];
+    }
+  }
+  const wired = hooks.source === "custom" || hooks.source === "husky" || hooks.source === "husky-legacy" ? true : hooks.source === "githooks" ? facts.git.hooksPath === hooks.dir : false;
+  return { source: hooks.source, wired, preCommit, prePush, commitMsg, lintStaged };
+}
+async function detectThresholds(root, scripts, ciJobs) {
+  const sonarConfigured = await pathExists(path.join(root, "sonar-project.properties")) || ciJobs.some((j) => j.tools.includes("sonar"));
+  let coverageThresholdLocal = false;
+  for (const f of [
+    "jest.config.js",
+    "jest.config.ts",
+    "jest.config.cjs",
+    "jest.config.mjs",
+    "jest.config.json",
+    "vitest.config.ts",
+    "vitest.config.js",
+    "vitest.config.mts"
+  ]) {
+    const text = await readText(path.join(root, f));
+    if (text && /coverageThreshold|thresholds\s*:/.test(text)) {
+      coverageThresholdLocal = true;
+      break;
+    }
+  }
+  if (!coverageThresholdLocal) {
+    const pkg = await readJson(
+      path.join(root, "package.json")
+    );
+    coverageThresholdLocal = Boolean(pkg?.jest?.coverageThreshold);
+  }
+  const coverageCollected = Object.values(scripts).some((v) => /--coverage|\bnyc\b|\bc8\b/.test(v)) || ciJobs.some((j) => j.tools.includes("coverage") || j.tools.includes("sonar"));
+  return { sonarConfigured, coverageThresholdLocal, coverageCollected };
+}
+async function buildGateInventory(root, facts) {
+  const scripts = facts.commands.raw;
+  const jobs = [];
+  const inheritedIncludes = [];
+  const parseErrors = [];
+  if (facts.ci.system === "gitlab") {
+    const text = await readText(path.join(root, ".gitlab-ci.yml"));
+    if (text) {
+      const parsed = parseGitlabCi(text, ".gitlab-ci.yml", scripts);
+      jobs.push(...parsed.jobs);
+      parseErrors.push(...parsed.parseErrors);
+      for (const inc of parsed.inheritedIncludes) {
+        if (inc.startsWith("local: ")) {
+          const rel = inc.slice("local: ".length).replace(/^\//, "");
+          const subText = await readText(path.join(root, rel));
+          if (subText) {
+            const sub = parseGitlabCi(subText, rel, scripts);
+            jobs.push(...sub.jobs);
+            parseErrors.push(...sub.parseErrors);
+            inheritedIncludes.push(...sub.inheritedIncludes);
+          } else {
+            inheritedIncludes.push(inc);
+          }
+        } else {
+          inheritedIncludes.push(inc);
+        }
+      }
+    }
+  } else if (facts.ci.system === "github") {
+    for (const file of facts.ci.files) {
+      const text = await readText(path.join(root, file));
+      if (!text) continue;
+      const parsed = parseGithubWorkflow(text, file, scripts);
+      jobs.push(...parsed.jobs);
+      parseErrors.push(...parsed.parseErrors);
+    }
+  }
+  const [local, thresholds] = await Promise.all([
+    localHookTools(root, facts, scripts),
+    detectThresholds(root, scripts, jobs)
+  ]);
+  const pkg = await readJson(path.join(root, "package.json"));
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  const commitlintDep = Boolean(deps["@commitlint/cli"] ?? deps["commitlint"]);
+  return {
+    local,
+    ci: { system: facts.ci.system, jobs, inheritedIncludes, parseErrors },
+    thresholds,
+    commitlintDep
+  };
+}
+
+// src/lenses/gate-integrity/lens.ts
+var LENS_ID2 = "gate-integrity";
+var CORRECTNESS_TOOLS = ["typecheck", "lint", "format-check", "test"];
+var TOOL_LABEL = {
+  typecheck: "type checking",
+  lint: "linting",
+  "format-check": "format checking",
+  "format-write": "format writing",
+  test: "unit tests",
+  coverage: "coverage",
+  e2e: "e2e tests",
+  sonar: "SonarQube analysis",
+  codecov: "Codecov upload",
+  commitlint: "commit-message linting",
+  size: "bundle-size check",
+  chromatic: "visual review"
+};
+function finding(partial) {
+  return { lens: LENS_ID2, ...partial };
+}
+function deriveGateFindings(inv, disclosures = []) {
+  const findings = [];
+  const localTools = /* @__PURE__ */ new Set([
+    ...inv.local.preCommit,
+    ...inv.local.prePush,
+    ...inv.local.commitMsg
+  ]);
+  const enforcedCiJobs = inv.ci.jobs.filter((j) => !j.advisory);
+  const enforcedCiTools = new Set(enforcedCiJobs.flatMap((j) => j.tools));
+  const anyCiTools = new Set(inv.ci.jobs.flatMap((j) => j.tools));
+  if (inv.local.source === "githooks" && !inv.local.wired) {
+    if (isCiEnvironment()) {
+      disclosures.push(
+        "Running in CI: git hook wiring (core.hooksPath) is a developer-machine fact and cannot be judged from an ephemeral checkout \u2014 not flagged here. Run `etymd audit` locally to check it."
+      );
+    } else {
+      findings.push(
+        finding({
+          id: `${LENS_ID2}/hooks-not-wired`,
+          tier: "risk",
+          claim: "Tracked .githooks/ exist but git core.hooksPath is unset \u2014 the hooks never run",
+          evidence: [".githooks/"],
+          why: "Every check in those hooks is silently skipped on this clone.",
+          action: "Run `git config core.hooksPath .githooks` (etymd gates does this).",
+          effort: "S",
+          confidence: "high"
+        })
+      );
+    }
+  }
+  for (const tool of CORRECTNESS_TOOLS) {
+    if (!enforcedCiTools.has(tool) || localTools.has(tool)) continue;
+    const jobs = enforcedCiJobs.filter((j) => j.tools.includes(tool));
+    const branchNote = jobs.every((j) => j.branchScoped) ? " (rule-scoped \u2014 blocking-ness may vary per branch)" : "";
+    findings.push(
+      finding({
+        id: `${LENS_ID2}/ci-only-${tool}`,
+        tier: "gap",
+        claim: `${TOOL_LABEL[tool]} is enforced only in CI \u2014 no local hook runs it`,
+        evidence: jobs.map((j) => `${j.file} job \`${j.job}\`${branchNote}`),
+        why: "A failure is invisible until the pipeline runs \u2014 the slowest possible feedback loop.",
+        action: "Wire it into a pre-push hook \u2014 `etymd gates` generates one from your own scripts.",
+        effort: "S",
+        confidence: "high"
+      })
+    );
+  }
+  if (inv.ci.system !== "none" && inv.ci.jobs.length) {
+    for (const tool of CORRECTNESS_TOOLS) {
+      if (!localTools.has(tool) || anyCiTools.has(tool)) continue;
+      if (inv.ci.inheritedIncludes.length) continue;
+      findings.push(
+        finding({
+          id: `${LENS_ID2}/local-only-${tool}`,
+          tier: "gap",
+          claim: `${TOOL_LABEL[tool]} runs only in local hooks \u2014 CI never re-checks it`,
+          evidence: [`local hooks (${inv.local.source})`],
+          why: "Hooks are skippable (`--no-verify`, fresh clones without hook setup) \u2014 CI is the backstop.",
+          action: "Add the same check to the CI pipeline.",
+          effort: "M",
+          confidence: "medium"
+        })
+      );
+    }
+  }
+  if (inv.thresholds.coverageCollected && !inv.thresholds.coverageThresholdLocal) {
+    const sonarJobs = inv.ci.jobs.filter((j) => j.tools.includes("sonar"));
+    const advisoryNote = sonarJobs.length && sonarJobs.every((j) => j.advisory) ? " (the job is allow_failure \u2014 advisory on this pipeline)" : "";
+    findings.push(
+      finding({
+        id: `${LENS_ID2}/coverage-no-local-threshold`,
+        tier: inv.thresholds.sonarConfigured ? "gap" : "polish",
+        claim: inv.thresholds.sonarConfigured ? `A coverage gate exists only server-side (SonarQube)${advisoryNote} \u2014 its threshold is not visible in this repo and nothing local mirrors it` : "Coverage is collected but no threshold gates it anywhere",
+        evidence: [
+          ...sonarJobs.map((j) => `${j.file} job \`${j.job}\``),
+          "no coverageThreshold in jest/vitest config"
+        ],
+        why: "A coverage regression is invisible until the server-side gate fails the pipeline \u2014 after push, sometimes after review.",
+        action: "Add a local coverageThreshold mirroring the server gate (or document the server value beside the config) so a regression warns before push.",
+        effort: "M",
+        confidence: inv.thresholds.sonarConfigured ? "high" : "medium"
+      })
+    );
+  }
+  if (inv.commitlintDep && !inv.local.commitMsg.includes("commitlint") && !localToolInHook(inv, "commitlint")) {
+    findings.push(
+      finding({
+        id: `${LENS_ID2}/commitlint-unwired`,
+        tier: "polish",
+        claim: "commitlint is a dependency but no commit-msg hook runs it",
+        evidence: ["package.json (@commitlint/cli)", "no commit-msg hook"],
+        why: "The commit convention the tooling promises is not actually enforced.",
+        action: "Wire commitlint into a commit-msg hook, or remove the dependency.",
+        effort: "S",
+        confidence: "high"
+      })
+    );
+  }
+  return findings;
+}
+function localToolInHook(inv, tool) {
+  return inv.local.preCommit.includes(tool) || inv.local.prePush.includes(tool) || inv.local.commitMsg.includes(tool);
+}
+var gateIntegrityLens = {
+  id: LENS_ID2,
+  version: "1",
+  title: "Gate integrity (CI \u2194 local)",
+  kind: "improvement",
+  async run(ctx) {
+    const inv = await buildGateInventory(ctx.root, ctx.facts);
+    const disclosures = [];
+    if (inv.ci.inheritedIncludes.length) {
+      disclosures.push(
+        `${inv.ci.inheritedIncludes.length} CI include(s) reference pipeline definitions outside this repo \u2014 the CI inventory is incomplete: ${inv.ci.inheritedIncludes.slice(0, 3).join("; ")}${inv.ci.inheritedIncludes.length > 3 ? " \u2026" : ""}`
+      );
+    }
+    const advisory = inv.ci.jobs.filter((j) => j.advisory);
+    if (advisory.length) {
+      disclosures.push(
+        `${advisory.length} CI job(s) are allow_failure/continue-on-error \u2014 advisory, not counted as enforced gates: ${advisory.map((j) => j.job).join(", ")}`
+      );
+    }
+    const inheritedScripts = inv.ci.jobs.filter((j) => !j.scriptVisible);
+    if (inheritedScripts.length) {
+      disclosures.push(
+        `${inheritedScripts.length} CI job(s) define their script in an inherited template \u2014 tools inferred from name/variables only: ${inheritedScripts.map((j) => j.job).join(", ")}`
+      );
+    }
+    if (inv.ci.parseErrors.length)
+      disclosures.push(...inv.ci.parseErrors.map((e) => `CI parse: ${e}`));
+    if (inv.ci.system === "none")
+      disclosures.push("No CI configuration found \u2014 CI\u2194local comparisons skipped.");
+    const findings = deriveGateFindings(inv, disclosures);
+    return {
+      lens: LENS_ID2,
+      version: "1",
+      title: "Gate integrity (CI \u2194 local)",
+      kind: "improvement",
+      status: "ran",
+      disclosures,
+      findings
+    };
+  }
+};
+async function listInstructionFiles(root, facts, scope) {
+  const files = [];
+  const add = async (rel) => {
+    const text = await readText(path.join(root, rel));
+    if (text !== null) files.push({ path: normalizeRelPath(rel), text });
+  };
+  const singleFileArtifacts = [
+    "agents",
+    "claude",
+    "gemini",
+    "copilot",
+    "cursorrules",
+    "cline",
+    "windsurf"
+  ];
+  for (const id of singleFileArtifacts) {
+    const artifact = facts.artifacts.find((a) => a.id === id);
+    if (artifact?.exists) await add(artifact.path);
+  }
+  const rulesDir = path.join(root, ".cursor", "rules");
+  if (await isDirectory(rulesDir)) {
+    try {
+      for (const entry of await promises.readdir(rulesDir)) {
+        if (entry.endsWith(".md") || entry.endsWith(".mdc"))
+          await add(path.join(".cursor/rules", entry));
+      }
+    } catch {
+    }
+  }
+  const skillsDir = path.join(root, ".claude", "skills");
+  if (await isDirectory(skillsDir)) {
+    try {
+      for (const entry of await promises.readdir(skillsDir)) {
+        const skill = path.join(".claude/skills", entry, "SKILL.md");
+        await add(skill);
+      }
+    } catch {
+    }
+  }
+  const detected = new Set(files.map((f) => f.path));
+  const included = [];
+  for (const rel of await expandFileGlobs(root, scope?.include ?? [])) {
+    if (detected.has(rel)) continue;
+    const before = files.length;
+    await add(rel);
+    if (files.length > before) included.push(rel);
+  }
+  const exclude = scope?.exclude ?? [];
+  if (!exclude.length) return { files, excluded: [], included };
+  const kept = [];
+  const excluded = [];
+  for (const file of files) {
+    if (matchesAnyGlob(file.path, exclude)) excluded.push(file.path);
+    else kept.push(file);
+  }
+  return { files: kept, excluded, included };
+}
+function extractCodeTokens(text) {
+  const tokens = [];
+  for (const m of text.matchAll(/`([^`\n]+)`/g)) tokens.push(m[1].trim());
+  for (const block of text.matchAll(/```[a-z]*\n([\s\S]*?)```/g)) {
+    for (const line of block[1].split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) tokens.push(trimmed);
+    }
+  }
+  return tokens;
+}
+var PM_BUILTINS = /* @__PURE__ */ new Set([
+  "install",
+  "i",
+  "add",
+  "remove",
+  "rm",
+  "up",
+  "update",
+  "upgrade",
+  "dlx",
+  "exec",
+  "create",
+  "init",
+  "link",
+  "unlink",
+  "publish",
+  "pack",
+  "audit",
+  "outdated",
+  "why",
+  "list",
+  "ls",
+  "view",
+  "info",
+  "config",
+  "store",
+  "import",
+  "rebuild",
+  "prune",
+  "setup",
+  "env",
+  "bin",
+  "root",
+  "licenses",
+  "patch",
+  "approve-builds",
+  "workspaces",
+  "workspace",
+  "cache",
+  "version",
+  "help"
+]);
+function extractCommandClaims(text) {
+  const scripts = /* @__PURE__ */ new Map();
+  let filteredSkipped = 0;
+  for (const token of extractCodeTokens(text)) {
+    for (const m of token.matchAll(
+      /(?:^|&&\s*|\|\|\s*|;\s*|\|\s*|\$\s+|\(\s*)(pnpm|yarn|npm|bun)\s+(?:(run)\s+)?(-{0,2}[A-Za-z0-9:._@/[\]-]+)/g
+    )) {
+      const pm = m[1];
+      const ranExplicit = Boolean(m[2]);
+      const arg = m[3];
+      if (arg.startsWith("-")) {
+        filteredSkipped += 1;
+        continue;
+      }
+      if (pm === "npm" && !ranExplicit && arg !== "test" && arg !== "start") continue;
+      if ((pm === "bun" || pm === "yarn" || pm === "pnpm") && !ranExplicit && PM_BUILTINS.has(arg))
+        continue;
+      if (ranExplicit && PM_BUILTINS.has(arg)) continue;
+      scripts.set(arg, token);
+    }
+  }
+  return { scripts, filteredSkipped };
+}
+var PATH_TOKEN_RE = /^[A-Za-z0-9_.-]+(\/[A-Za-z0-9_.$-]+)+\/?$/;
+var KNOWN_EXTENSIONS = /* @__PURE__ */ new Set([
+  ..."ts tsx cts mts js jsx cjs mjs json jsonc json5 md mdx mdc yml yaml toml ini cfg conf env sh bash zsh fish ps1 bat cmd css scss sass less html htm xml svg sql prisma graphql gql proto py rb rs go java kt kts swift c h cc cpp hpp cs php vue svelte astro txt log lock csv tsv png jpg jpeg gif webp ico avif woff woff2 ttf otf wasm map pem key crt tf tfvars example sample local snap ejs hbs pug".split(" ")
+]);
+var CREATION_CONTEXT_RE = /\b(?:creat(?:e|es|ed|ing)|generat(?:e|es|ed|ing)|scaffold(?:s|ed|ing)?|quarantin(?:e|es|ed|ing)|(?:writ(?:e|es|ten|ing)|output(?:s|ted)?|emit(?:s|ted|ting)?|sav(?:e|es|ed|ing)|mov(?:e|es|ed|ing)|copy|copi(?:es|ed))\s+(?:it\s+|them\s+)?(?:to|into)|new\s+(?:file|directory|folder)|will\s+(?:be\s+)?(?:created|generated|written)|add(?:s|ed|ing)?\s+(?:a|the)\s+new)\b/i;
+var PLACEHOLDER_SEGMENTS = /* @__PURE__ */ new Set(["placeholder", "foo", "bar", "baz", "qux"]);
+var PLACEHOLDER_PREFIX_RE = /^(?:my|your)-/i;
+function isPlaceholderClaim(token) {
+  return token.split("/").some((seg) => PLACEHOLDER_PREFIX_RE.test(seg) || PLACEHOLDER_SEGMENTS.has(seg.toLowerCase()));
+}
+function claimContext(text, index) {
+  const start = text.lastIndexOf("\n", index) + 1;
+  const endRaw = text.indexOf("\n", index);
+  const end = endRaw === -1 ? text.length : endRaw;
+  const line = text.slice(start, end);
+  if (!/^\s*(?:[-*+]|\d+[.)]|\|)/.test(line)) return line;
+  let cursor = start;
+  while (cursor > 0) {
+    const prevEnd = cursor - 1;
+    const prevStart = text.lastIndexOf("\n", prevEnd - 1) + 1;
+    const prev = text.slice(prevStart, prevEnd);
+    cursor = prevStart;
+    if (!prev.trim()) continue;
+    if (/^\s*(?:[-*+]|\d+[.)]|\|)/.test(prev)) continue;
+    return `${prev}
+${line}`;
+  }
+  return line;
+}
+function extractPathClaims(text) {
+  const prospectiveOnly = /* @__PURE__ */ new Map();
+  const placeholder = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(/`([^`\n]+)`/g)) {
+    const token = m[1].trim();
+    if (token.includes(" ") || token.length > 120) continue;
+    if (token.startsWith("/") || token.startsWith("~") || token.startsWith("@") || token.startsWith("$"))
+      continue;
+    if (token.includes("://") || token.startsWith("www.")) continue;
+    if (/[*?{}<>|]/.test(token)) continue;
+    if (token.includes("@")) continue;
+    if (!PATH_TOKEN_RE.test(token)) continue;
+    if (token.split("/").some((seg) => seg.startsWith("$"))) continue;
+    const isDirClaim = token.endsWith("/");
+    const ext = token.toLowerCase().match(/\.([a-z0-9]{1,8})$/)?.[1];
+    if (!isDirClaim && !(ext && KNOWN_EXTENSIONS.has(ext))) continue;
+    const claim = token.replace(/\/$/, "");
+    if (isPlaceholderClaim(claim)) {
+      placeholder.add(claim);
+      continue;
+    }
+    const prospective2 = CREATION_CONTEXT_RE.test(claimContext(text, m.index ?? 0));
+    prospectiveOnly.set(claim, (prospectiveOnly.get(claim) ?? true) && prospective2);
+  }
+  const paths = [];
+  const prospective = [];
+  for (const [claim, only] of prospectiveOnly) {
+    if (only) prospective.push(claim);
+    else paths.push(claim);
+  }
+  return { paths, prospective, placeholder: [...placeholder] };
+}
+function packageManagerUsage(text) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const token of extractCodeTokens(text)) {
+    for (const m of token.matchAll(/\b(pnpm|yarn|npm|bun)\s+(?:run\s+)?[A-Za-z-]/g)) {
+      const pm = m[1];
+      counts.set(pm, (counts.get(pm) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+var KNOWN_DOC_REFS = ["AGENTS.md", "CLAUDE.md", "PROJECT_CONTEXT.md", "GEMINI.md"];
+function extractDocRefs(text) {
+  return KNOWN_DOC_REFS.filter((name) => text.includes(name));
+}
+
+// src/lenses/instruction-truth/lens.ts
+var LENS_ID3 = "instruction-truth";
+var MAX_PATH_FINDINGS_PER_FILE = 15;
+function finding2(partial) {
+  return { lens: LENS_ID3, ...partial };
+}
+function compareCommands(baseline, fresh) {
+  const out = [];
+  for (const role of ["test", "lint", "typecheck", "format", "formatCheck", "build"]) {
+    const before = baseline.commands[role];
+    if (before && !(before in fresh.commands.raw)) {
+      out.push(
+        finding2({
+          id: `${LENS_ID3}/command-gone-${role}`,
+          tier: "risk",
+          claim: `Documented ${role} command \`${before}\` no longer exists in package.json`,
+          evidence: ["package.json"],
+          why: "Every doc, hook, and agent instruction naming it now fails or silently skips a check.",
+          action: "Re-point the contract/hooks at the renamed script, then refresh the baseline.",
+          effort: "S",
+          confidence: "high"
+        })
+      );
+    }
+  }
+  return out;
+}
+function compareArtifacts(baseline, fresh) {
+  const out = [];
+  const freshById = new Map(fresh.artifacts.map((a) => [a.id, a]));
+  for (const a of baseline.artifacts) {
+    const now = freshById.get(a.id);
+    if (a.exists && now && !now.exists) {
+      out.push(
+        finding2({
+          id: `${LENS_ID3}/artifact-gone-${a.id}`,
+          tier: "gap",
+          claim: `${a.label} was present at baseline but is now missing`,
+          evidence: [a.path],
+          why: "Agents and docs still assume it exists; instructions referring to it now mislead.",
+          action: "Restore it or update the contract and refresh the baseline.",
+          effort: "S",
+          confidence: "high"
+        })
+      );
+    }
+  }
+  return out;
+}
+function compareLayout(baseline, fresh) {
+  const now = new Set(fresh.tree.dirs.map((d) => d.name));
+  return baseline.tree.dirs.filter((d) => !now.has(d.name)).map(
+    (d) => finding2({
+      id: `${LENS_ID3}/dir-gone-${d.name}`,
+      tier: "gap",
+      claim: `Top-level \`${d.name}/\` from the baseline no longer exists \u2014 the repo map may be stale`,
+      evidence: [`${d.name}/`],
+      why: "A stale map sends agents (and people) to paths that are gone.",
+      action: "Update the repo map and refresh the baseline.",
+      effort: "S",
+      confidence: "medium"
+    })
+  );
+}
+var instructionTruthLens = {
+  id: LENS_ID3,
+  version: "1",
+  title: "Instruction truth",
+  kind: "truth",
+  async run(ctx) {
+    const findings = [];
+    const disclosures = [];
+    const { facts, root } = ctx;
+    const config = ctx.config?.config ?? DEFAULT_CONFIG;
+    disclosures.push(...ctx.config?.problems ?? []);
+    const {
+      files,
+      excluded,
+      included: includedExtra
+    } = await listInstructionFiles(root, facts, config.instructions);
+    if (!files.length) {
+      findings.push(
+        finding2({
+          id: `${LENS_ID3}/no-contract`,
+          tier: "gap",
+          claim: "No agent instruction files exist (AGENTS.md or equivalents)",
+          evidence: ["AGENTS.md (missing)"],
+          why: "Every agent in this repo works from generic priors instead of the project's rules.",
+          action: "Run `etymd init` to scaffold one.",
+          effort: "M",
+          confidence: "high"
+        })
+      );
+    }
+    const knownScripts = new Set(Object.keys(facts.commands.raw));
+    for (const pkg of facts.packages) {
+      const pkgJson = await readJson(
+        path.join(root, pkg.dir, "package.json")
+      );
+      for (const key of Object.keys(pkgJson?.scripts ?? {})) knownScripts.add(key);
+    }
+    const pathResolves = async (claim) => {
+      const bases = [root, ...facts.packages.map((p) => path.join(root, p.dir))];
+      for (const base of bases) {
+        if (await pathExists(path.join(base, claim))) return true;
+        if (await pathExists(path.join(base, "src", claim))) return true;
+        if (await pathExists(path.join(base, "scripts", claim))) return true;
+      }
+      return false;
+    };
+    const binResolves = async (name) => {
+      const bases = [root, ...facts.packages.map((p) => path.join(root, p.dir))];
+      for (const base of bases) {
+        if (await pathExists(path.join(base, "node_modules", ".bin", name))) return true;
+      }
+      return false;
+    };
+    const nodeModulesInstalled = await pathExists(path.join(root, "node_modules"));
+    let totalFilteredSkipped = 0;
+    let binaryResolved = 0;
+    let unverifiableCommands = 0;
+    let gitignoredSkipped = 0;
+    let prospectiveSkipped = 0;
+    let placeholderSkipped = 0;
+    for (const file of files) {
+      const { scripts: claimed, filteredSkipped } = extractCommandClaims(file.text);
+      totalFilteredSkipped += filteredSkipped;
+      for (const [script, raw] of claimed) {
+        if (knownScripts.has(script)) continue;
+        if (await binResolves(script)) {
+          binaryResolved += 1;
+          continue;
+        }
+        if (!nodeModulesInstalled) {
+          unverifiableCommands += 1;
+          continue;
+        }
+        findings.push(
+          finding2({
+            id: `${LENS_ID3}/stale-command:${file.path}:${script}`,
+            tier: "risk",
+            claim: `${file.path} tells agents to run \`${script}\` \u2014 no such script exists`,
+            evidence: [`${file.path}: \`${raw}\``, "package.json scripts (root + workspaces)"],
+            why: "An agent following this instruction runs a command that fails \u2014 or silently skips the check it was meant to run.",
+            action: "Update the instruction to the current script name (or restore the script).",
+            effort: "S",
+            confidence: "high"
+          })
+        );
+      }
+      const { paths, prospective, placeholder } = extractPathClaims(file.text);
+      prospectiveSkipped += prospective.length;
+      placeholderSkipped += placeholder.length;
+      const missing = [];
+      for (const claim of paths) {
+        if (!await pathResolves(claim)) missing.push(claim);
+      }
+      const ignoredOut = missing.length ? await git(root, ["check-ignore", ...missing]) : null;
+      const gitignored = new Set((ignoredOut ?? "").split("\n").filter(Boolean));
+      let pathFindings = 0;
+      for (const claim of missing) {
+        if (gitignored.has(claim)) {
+          gitignoredSkipped += 1;
+          continue;
+        }
+        if (pathFindings >= MAX_PATH_FINDINGS_PER_FILE) {
+          disclosures.push(
+            `${file.path}: more than ${MAX_PATH_FINDINGS_PER_FILE} missing-path claims \u2014 truncated.`
+          );
+          break;
+        }
+        pathFindings += 1;
+        findings.push(
+          finding2({
+            id: `${LENS_ID3}/stale-path:${file.path}:${claim}`,
+            tier: "gap",
+            claim: `${file.path} references \`${claim}\` \u2014 it does not exist in the repo`,
+            evidence: [file.path, `missing: ${claim}`],
+            why: "Agents navigate by these references; a dead path wastes a lookup and erodes trust in the rest of the file.",
+            action: "Fix or remove the reference.",
+            effort: "S",
+            confidence: "medium"
+          })
+        );
+      }
+      if (facts.packageManager !== "unknown") {
+        const usage = packageManagerUsage(file.text);
+        const own = usage.get(facts.packageManager) ?? 0;
+        for (const [pm, count] of usage) {
+          if (pm === facts.packageManager || count < 2 || count <= own) continue;
+          findings.push(
+            finding2({
+              id: `${LENS_ID3}/pm-conflict:${file.path}`,
+              tier: "gap",
+              claim: `${file.path} instructs \`${pm}\` (${count}\xD7) but the repo uses ${facts.packageManager}`,
+              evidence: [file.path, `lockfile \u2192 ${facts.packageManager}`],
+              why: "Mixed package-manager instructions produce divergent lockfiles and broken installs.",
+              action: `Rewrite the commands for ${facts.packageManager}.`,
+              effort: "S",
+              confidence: "medium"
+            })
+          );
+          break;
+        }
+      }
+      for (const ref of extractDocRefs(file.text)) {
+        if (await pathExists(path.join(root, ref))) continue;
+        findings.push(
+          finding2({
+            id: `${LENS_ID3}/dangling-ref:${file.path}:${ref}`,
+            tier: "gap",
+            claim: `${file.path} references ${ref} \u2014 no such file exists`,
+            evidence: [file.path, `missing: ${ref}`],
+            why: "The pointer chain agents follow breaks at a file they can never read.",
+            action: `Create ${ref} or remove the reference.`,
+            effort: "S",
+            confidence: "high"
+          })
+        );
+      }
+    }
+    if (ctx.baseline) {
+      findings.push(
+        ...compareCommands(ctx.baseline.facts, facts),
+        ...compareArtifacts(ctx.baseline.facts, facts),
+        ...compareLayout(ctx.baseline.facts, facts)
+      );
+      if (baselineCarriesMachinePath(ctx.baseline)) {
+        disclosures.push(
+          `${BASELINE_FILE} records an absolute machine path as its scan root (written by an older etymd). It is committed, so that path is published with your repo \u2014 run \`etymd approve\` to rewrite it.`
+        );
+      }
+      if (ctx.baseline.packVersion !== PACK_VERSION) {
+        disclosures.push(
+          `Baseline was approved under pack v${ctx.baseline.packVersion}; current pack is v${PACK_VERSION}.`
+        );
+      }
+    } else {
+      disclosures.push(
+        "No committed baseline (.etymd/baseline.json) \u2014 drift over time is not measurable; run `etymd init` to approve one."
+      );
+    }
+    if (binaryResolved) {
+      disclosures.push(
+        `${binaryResolved} command claim(s) are installed binaries (node_modules/.bin), not package scripts \u2014 treated as true.`
+      );
+    }
+    if (unverifiableCommands) {
+      disclosures.push(
+        `node_modules is not installed \u2014 ${unverifiableCommands} command claim(s) matching no package script could not be checked against installed binaries; skipped, not flagged.`
+      );
+    }
+    if (gitignoredSkipped) {
+      disclosures.push(
+        `${gitignoredSkipped} missing path claim(s) are gitignored (machine-local, e.g. .env) \u2014 existence is not verifiable from the repo; skipped, not flagged.`
+      );
+    }
+    if (prospectiveSkipped) {
+      disclosures.push(
+        `${prospectiveSkipped} path claim(s) sit in create-this prose (the file instructs generating them) \u2014 forward-looking, not stale; skipped, not flagged.`
+      );
+    }
+    if (placeholderSkipped) {
+      disclosures.push(
+        `${placeholderSkipped} path claim(s) are naming stand-ins (e.g. \`my-custom-skill\`) rather than real references; skipped, not flagged.`
+      );
+    }
+    if (excluded.length) {
+      const shown = excluded.slice(0, 5).join(", ");
+      disclosures.push(
+        `${excluded.length} instruction file(s) excluded by ${CONFIG_FILE} and NOT audited: ${shown}${excluded.length > 5 ? `, +${excluded.length - 5} more` : ""}.`
+      );
+    }
+    if (includedExtra.length) {
+      disclosures.push(
+        `${includedExtra.length} extra instruction file(s) audited via ${CONFIG_FILE} \`instructions.include\`: ${includedExtra.slice(0, 5).join(", ")}${includedExtra.length > 5 ? `, +${includedExtra.length - 5} more` : ""}.`
+      );
+    }
+    disclosures.push(
+      `Checked ${files.length} instruction file(s); commands resolved against root + ${facts.packages.length} workspace manifest(s) plus installed binaries; paths matched against root and package roots. Heuristics: workspace-filtered commands skipped (${totalFilteredSkipped}); tokens without a recognized extension treated as prose (a dir claim needs a trailing slash); gitignored claims unverifiable; create-this and stand-in path claims skipped; absolute/globbed/placeholder tokens skipped; framework-pattern staleness not checked.`
+    );
+    return {
+      lens: LENS_ID3,
+      version: "1",
+      title: "Instruction truth",
+      kind: "truth",
+      status: "ran",
+      disclosures,
+      findings,
+      outOfScope: excluded
+    };
+  }
+};
+
+// src/engine/finding.ts
+var TIER_ORDER = { risk: 0, gap: 1, polish: 2 };
+var EFFORT_ORDER = { S: 0, M: 1, L: 2 };
+function rankFindings(findings) {
+  return [...findings].sort(
+    (a, b) => TIER_ORDER[a.tier] - TIER_ORDER[b.tier] || EFFORT_ORDER[a.effort] - EFFORT_ORDER[b.effort]
+  );
+}
+
+// src/engine/run.ts
+var LENSES = [instructionTruthLens, gateIntegrityLens, contextEconomyLens];
+async function runAudit(root, opts = {}) {
+  const facts = await scanProject(root);
+  if ((opts.persistLedger ?? true) || await pathExists(path.join(root, ETYMD_DIR))) {
+    await writeCachedFacts(root, facts);
+  }
+  const baseline = await readBaseline(root);
+  const config = await readConfig(root);
+  const profile = baseline?.profile ?? deriveProfile(facts);
+  const selected = LENSES.filter(
+    (lens) => (!opts.kind || lens.kind === opts.kind) && (!opts.lensIds || opts.lensIds.includes(lens.id))
+  );
+  const reports = [];
+  for (const lens of selected) {
+    try {
+      reports.push(await lens.run({ root, facts, profile, baseline, config }));
+    } catch (err) {
+      reports.push({
+        lens: lens.id,
+        version: lens.version,
+        title: lens.title,
+        kind: lens.kind,
+        status: "skipped",
+        reason: err instanceof Error ? err.message : String(err),
+        disclosures: [],
+        findings: []
+      });
+    }
+  }
+  const all = reports.flatMap((r) => r.findings);
+  const previous = await readLedger(root);
+  const outOfScope = reports.flatMap((r) => r.outOfScope ?? []);
+  const { ledger, diff } = reconcileLedger(previous, all, void 0, outOfScope);
+  const fullRun = selected.length === LENSES.length;
+  if ((opts.persistLedger ?? true) && fullRun) {
+    await writeLedger(root, ledger);
+  }
+  return {
+    facts,
+    profile,
+    baseline,
+    config,
+    reports,
+    findings: rankFindings(visibleFindings(all, previous)),
+    ledger,
+    diff
+  };
+}
+
+// src/commands/audit.ts
+var TIER_RANK = { risk: 0, gap: 1, polish: 2 };
+async function run(opts) {
+  const result = await runAudit(opts.cwd, {
+    kind: opts.truth ? "truth" : void 0,
+    lensIds: opts.lens ? [opts.lens] : void 0,
+    persistLedger: !opts.noLedger
+  });
+  if (opts.failOn) {
+    const threshold = TIER_RANK[opts.failOn];
+    if (result.findings.some((f) => TIER_RANK[f.tier] <= threshold)) {
+      process.exitCode = 1;
+    }
+  }
+  if (opts.json) {
+    print(
+      JSON.stringify(
+        {
+          profile: result.profile,
+          baseline: result.baseline ? { packVersion: result.baseline.packVersion, approvedAt: result.baseline.approvedAt } : null,
+          reports: result.reports.map(({ findings: _findings, ...r }) => r),
+          findings: result.findings,
+          diff: {
+            new: result.diff.new.map((f) => f.id),
+            stillOpen: result.diff.stillOpen.map((f) => f.id),
+            regressed: result.diff.regressed.map((f) => f.id),
+            resolved: result.diff.resolved.map((e) => e.id),
+            dismissed: result.diff.dismissed.map((f) => f.id),
+            accepted: result.diff.accepted.map((f) => f.id)
+          }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  section(
+    `${opts.truth ? "Doctor \u2014 is this still true?" : "Audit"} ${theme.dim(`\xB7 ${result.facts.name} \xB7 ${result.profile} profile`)}`
+  );
+  if (!result.baseline && !opts.truth) {
+    print(
+      `  ${theme.dim("no committed baseline \u2014 run `etymd init` to approve one; drift checks are limited")}`
+    );
+  }
+  renderLensCoverage(result.reports);
+  section(`Findings ${theme.dim("(ranked: risk \u2192 gap \u2192 polish, cheapest first)")}`);
+  renderFindings(result.findings);
+  renderLedgerDiff(result.diff);
+  const top = result.findings[0];
+  if (top) {
+    print();
+    print(
+      `  ${theme.dim("next:")} ${theme.heading(top.claim)}${top.action ? theme.dim(` \u2014 ${top.action}`) : ""}`
+    );
+  }
+}
+
+export { run };