etymd 0.13.0 → 0.15.0

package/dist/{init-XJEYU2HC.js → init-H57H2JBE.js}

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
 import { applyFiles } from './chunk-GWGKEPRX.js';
-import { planWorkflow } from './chunk-HRJJQCMT.js';
-import './chunk-DWL2IKZH.js';
-import { theme, renderFacts, print, renderPlan, section, glyph } from './chunk-5BVKFJWM.js';
-import { scanProject } from './chunk-YXOAPMQH.js';
-import { VERSION } from './chunk-D3R74TJ2.js';
-import { writeCachedFacts, deriveProfile, writeBaseline, CACHE_DIR } from './chunk-JHZ2BN4U.js';
-import { PACK_VERSION } from './chunk-LSZGCKIQ.js';
+import { planWorkflow } from './chunk-UFNETE6P.js';
+import { theme, renderFacts, print, renderPlan, section, glyph } from './chunk-HI7NWPRA.js';
+import { scanProject } from './chunk-Y6RZRED3.js';
+import { VERSION } from './chunk-DBWDMIYO.js';
+import { writeCachedFacts, deriveProfile, writeBaseline, CACHE_DIR } from './chunk-P6ATKV2R.js';
+import { PACK_VERSION } from './chunk-YQZDYDAK.js';
 import { git, readText } from './chunk-4VPBP6K6.js';
 import { promises } from 'fs';
 import path from 'path';
@@ -57,12 +56,14 @@ async function run(opts) {
   const hasContract = facts.artifacts.some((a) => a.id === "agents" && a.exists);
   let scaffoldAgents = false;
   if (!hasContract) {
-    scaffoldAgents = opts.yes ? true : guard(
-      await confirm({
-        message: "No AGENTS.md found \u2014 scaffold a minimal one from the reckoning?",
-        initialValue: true
-      })
-    );
+    if (opts.withAgents) scaffoldAgents = true;
+    else if (!opts.yes)
+      scaffoldAgents = guard(
+        await confirm({
+          message: "No AGENTS.md found \u2014 scaffold a minimal one from the reckoning?",
+          initialValue: true
+        })
+      );
   }
   let gates = false;
   if (facts.git.isRepo && facts.hooks.source === "none") {

package/dist/ledger-T54JDHGP.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+export { accept, dismiss, list } from './chunk-HOR4M6EC.js';
+import './chunk-3E2IPCRY.js';
+import './chunk-HI7NWPRA.js';
+import './chunk-P6ATKV2R.js';
+import './chunk-4VPBP6K6.js';

package/dist/premise-VMC3UUIB.js

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+import { parseFailOnTier, meetsFailOn, buildTruthEnv, emptyCounters, checkTextClaims, checkDocRefs, loadDecisionLedger, checkDecisionRefs, rankFindings, PATH_TOKEN_RE, KNOWN_EXTENSIONS } from './chunk-IWG77WV3.js';
+import { print, section, theme, renderFindings } from './chunk-HI7NWPRA.js';
+import { scanProject } from './chunk-Y6RZRED3.js';
+import './chunk-DBWDMIYO.js';
+import { ETYMD_DIR } from './chunk-P6ATKV2R.js';
+import './chunk-YQZDYDAK.js';
+import { readText, pathExists } from './chunk-4VPBP6K6.js';
+import path from 'path';
+import { promises } from 'fs';
+
+var PREMISE_LENS = "premise";
+var PREMISE_BRIEF_FILE = path.join(ETYMD_DIR, "premise-brief.md");
+var TASK_LABEL = "task";
+var MAX_PATH_FINDINGS = 15;
+var CODE_SPAN_RE = /(```[\s\S]*?```|`[^`\n]+`)/g;
+var RUN_RE = /\b(?:pnpm|yarn|npm|bun)\s+run\s+(?!-)([A-Za-z0-9:._-]+)|\bnpm\s+(?:test|start)\b/g;
+var BARE_PM_RE = /\b(?:pnpm|yarn|bun)\s+(?!run\b)(?!-)[A-Za-z0-9:._-]+/g;
+var STOP_WORDS = new Set(
+  "a an the this that these those it its them all any both each every some your our my their and or but to in on at of for with from by as is are was were be will would can could should may might must do does did not no so if then than when where which who what how also again now first once twice after before via into over only just too very".split(" ")
+);
+var WRAP_RE = /^([([{"']*)(.*?)([.,;:!?)\]}"']*)$/;
+var TRAIL_RE = /[.,;:!?)\]}"']*$/;
+var HOSTNAME_RE = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*\.([a-z]{2,})$/i;
+function promoteBareTokens(text, ctx) {
+  const skips = {
+    bareInvocations: 0,
+    proseScripts: 0,
+    hostnameLike: 0,
+    unrootedDirs: 0
+  };
+  const promoted = text.split(CODE_SPAN_RE).map((segment, i) => i % 2 === 1 ? segment : promoteProse(segment, ctx, skips)).join("");
+  return { text: promoted, skips };
+}
+function promoteProse(segment, ctx, skips) {
+  skips.bareInvocations += segment.match(BARE_PM_RE)?.length ?? 0;
+  const withCommands = segment.replace(RUN_RE, (m, script) => {
+    const trail = TRAIL_RE.exec(m)?.[0] ?? "";
+    const core = trail ? m.slice(0, -trail.length) : m;
+    if (script !== void 0) {
+      const name = script.replace(TRAIL_RE, "");
+      if (name.length < 2 || STOP_WORDS.has(name.toLowerCase())) {
+        skips.proseScripts += 1;
+        return m;
+      }
+    }
+    return `\`${core}\`${trail}`;
+  });
+  return withCommands.replace(/[^\s`]+/g, (token) => {
+    const m = WRAP_RE.exec(token);
+    if (!m) return token;
+    const [, lead = "", core = "", trail = ""] = m;
+    if (!core || core.includes("://") || !PATH_TOKEN_RE.test(core)) return token;
+    const first = core.slice(0, core.indexOf("/"));
+    const hostSuffix = HOSTNAME_RE.exec(first)?.[1]?.toLowerCase();
+    if (hostSuffix && !KNOWN_EXTENSIONS.has(hostSuffix)) {
+      skips.hostnameLike += 1;
+      return token;
+    }
+    if (core.endsWith("/")) {
+      if (!ctx.rootedDirs.has(first)) {
+        skips.unrootedDirs += 1;
+        return token;
+      }
+      return `${lead}\`${core}\`${trail}`;
+    }
+    const ext = core.toLowerCase().match(/\.([a-z0-9]{1,8})$/)?.[1];
+    if (!ext || !KNOWN_EXTENSIONS.has(ext)) return token;
+    return `${lead}\`${core}\`${trail}`;
+  });
+}
+async function listRootedDirs(env) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const base of env.bases) {
+    for (const sub of ["", "src", "scripts"]) {
+      const entries = await promises.readdir(path.join(base, sub), { withFileTypes: true }).catch(() => []);
+      for (const entry of entries) if (entry.isDirectory()) dirs.add(entry.name);
+    }
+  }
+  return dirs;
+}
+async function runPremise(opts) {
+  const root = opts.root;
+  const task = opts.task.trim();
+  const facts = await scanProject(root);
+  const env = await buildTruthEnv(root, facts);
+  const counters = emptyCounters();
+  const promoted = promoteBareTokens(task, { rootedDirs: await listRootedDirs(env) });
+  const text = { path: TASK_LABEL, text: promoted.text };
+  const findings = [];
+  const disclosures = [];
+  const entities = [];
+  const claims = await checkTextClaims(
+    env,
+    text,
+    {
+      lensId: PREMISE_LENS,
+      subject: "The task",
+      missingPathTier: "risk",
+      maxPathFindings: MAX_PATH_FINDINGS,
+      whyCommand: "The task is built on a command that does not exist \u2014 an agent will run it and fail, or quietly substitute something else and report success.",
+      actionCommand: "Fix the task before handing it over: name the real script, or restore it.",
+      whyPath: "The task is ABOUT this path. Acting on it means editing, testing, or reasoning about something that is not there \u2014 the wrong problem, solved precisely.",
+      actionPath: "Find where the behaviour actually lives and rewrite the task to name it."
+    },
+    counters
+  );
+  findings.push(...claims.findings);
+  disclosures.push(...claims.disclosures);
+  entities.push(...claims.examined);
+  const docs = await checkDocRefs(env, text, PREMISE_LENS, counters, "The task");
+  findings.push(...docs.findings);
+  entities.push(...docs.examined);
+  const ledger = await loadDecisionLedger(root, facts);
+  const decisions = checkDecisionRefs(
+    text,
+    ledger,
+    {
+      lensId: PREMISE_LENS,
+      subject: "The task",
+      why: "The task presupposes a ruling that was never recorded; an agent will act on a decision nobody made.",
+      action: "Point the task at the entry that exists \u2014 or record the missing decision first."
+    },
+    counters
+  );
+  findings.push(...decisions.findings);
+  entities.push(...decisions.examined);
+  if (!entities.length) {
+    disclosures.push(
+      "The task names no path with a directory, no package script, no well-known doc, and no decision id \u2014 nothing etymd can check by reading the repo. Everything it presupposes is in the brief."
+    );
+  }
+  disclosures.push(
+    "In prose, a path needs a directory and a recognized extension (a directory claim needs a trailing slash and a first segment that exists here), and a script needs the `run` form (`npm run X`, `pnpm run X` \u2026) or the `npm test` / `npm start` shorthands; anything backticked is read exactly as an instruction file would be. A bare file name (a lone `config.ts`) is prose."
+  );
+  const { skips } = promoted;
+  if (skips.bareInvocations) {
+    disclosures.push(
+      `${skips.bareInvocations} bare \`pnpm X\` / \`yarn X\` / \`bun X\` mention(s) in prose were not read as scripts \u2014 in a sentence that shape is a phrase as often as an invocation; write \`\u2026 run X\` or backtick it to have it checked.`
+    );
+  }
+  if (skips.proseScripts) {
+    disclosures.push(
+      `${skips.proseScripts} \`\u2026 run X\` mention(s) put a function word or a one-letter stand-in where a script name would be; read as prose, skipped.`
+    );
+  }
+  if (skips.hostnameLike) {
+    disclosures.push(
+      `${skips.hostnameLike} slash token(s) start with a host name (e.g. \`github.com/\u2026\`) \u2014 a URL, not a repo path; skipped.`
+    );
+  }
+  if (skips.unrootedDirs) {
+    disclosures.push(
+      `${skips.unrootedDirs} slash-joined phrase(s) ending in \`/\` start with no directory that exists here (e.g. \`input/output/\`) \u2014 read as prose; skipped, not flagged. Backtick one to have it checked.`
+    );
+  }
+  if (counters.unverifiableCommands) {
+    disclosures.push(
+      `node_modules is not installed \u2014 ${counters.unverifiableCommands} command(s) matching no package script could not be checked against installed binaries; skipped, not flagged.`
+    );
+  }
+  if (counters.binaryResolved) {
+    disclosures.push(
+      `${counters.binaryResolved} command(s) resolve to installed binaries (node_modules/.bin), not package scripts \u2014 treated as true.`
+    );
+  }
+  if (counters.gitignoredSkipped) {
+    disclosures.push(
+      `${counters.gitignoredSkipped} missing path(s) are gitignored (machine-local) \u2014 existence is not verifiable from the repo; skipped, not flagged.`
+    );
+  }
+  if (counters.prospectiveSkipped) {
+    disclosures.push(
+      `${counters.prospectiveSkipped} path(s) sit in create-this prose (the task says to create them) \u2014 forward-looking, not missing; skipped.`
+    );
+  }
+  if (counters.placeholderSkipped) {
+    disclosures.push(
+      `${counters.placeholderSkipped} path(s) are naming stand-ins (e.g. \`my-feature\`) rather than real references; skipped.`
+    );
+  }
+  if (counters.filteredSkipped) {
+    disclosures.push(
+      `${counters.filteredSkipped} workspace-filtered command(s) (\`--filter\`, \`-C\` \u2026) were not resolved; skipped.`
+    );
+  }
+  if (counters.tildeSkipped) {
+    disclosures.push(
+      `${counters.tildeSkipped} well-known doc mention(s) sit inside \`~/\` home paths (e.g. \`~/.claude/CLAUDE.md\`) \u2014 machine-global files, not this repo's; skipped, not flagged.`
+    );
+  }
+  if (counters.qualifiedRefsSkipped) {
+    disclosures.push(
+      `${counters.qualifiedRefsSkipped} decision reference(s) name another record \u2014 not this repo's; skipped.`
+    );
+  }
+  if (counters.unresolvableRefs) {
+    disclosures.push(
+      `${counters.unresolvableRefs} decision reference(s) could not be resolved \u2014 no decisions file with \`## D-NNN\` entries; skipped, not flagged.`
+    );
+  }
+  disclosures.push(
+    "What the task PRESUPPOSES \u2014 that the named things are the ones meant, that the mechanism it assumes actually runs, that the state it assumes holds \u2014 cannot be checked by reading files. The brief hands those to the agent."
+  );
+  disclosures.push("Task findings are not remembered between runs \u2014 no ledger is written.");
+  const ranked = rankFindings(findings);
+  const brief = renderBrief(task, ranked, entities);
+  let briefPath = null;
+  if (opts.writeBrief !== false && await pathExists(path.join(root, ETYMD_DIR))) {
+    await promises.writeFile(path.join(root, PREMISE_BRIEF_FILE), brief, "utf8");
+    briefPath = PREMISE_BRIEF_FILE;
+  }
+  return {
+    schema: "premise/1",
+    task,
+    source: opts.source ?? "argument",
+    name: facts.name,
+    findings: ranked,
+    disclosures,
+    entities,
+    brief,
+    briefPath
+  };
+}
+function mark(exists) {
+  return exists === null ? "?" : exists ? "\u2713" : "\u2717";
+}
+function kindLabel(kind) {
+  return kind === "script" ? "script " : kind === "decision" ? "decision " : "";
+}
+function renderBrief(task, findings, entities) {
+  const oneLine = task.replace(/\s+/g, " ").trim();
+  const title = oneLine.length > 100 ? `${oneLine.slice(0, 97)}\u2026` : oneLine;
+  const checked = entities.length ? entities.map(
+    (e) => `- ${mark(e.exists)} ${kindLabel(e.kind)}\`${e.value}\`${e.exists === null ? " \u2014 could not be checked" : e.exists ? " \u2014 exists" : " \u2014 missing (see the finding)"}`
+  ).join("\n") : "- (nothing the task names could be checked by reading the repo)";
+  const failed = findings.filter((f) => f.tier === "risk");
+  const failedLine = failed.length ? `
+**${failed.length} premise(s) already failed** \u2014 the task names things that do not exist. Resolve those before anything below.
+` : "";
+  return `# Premise brief \u2014 ${title}
+
+The task, verbatim:
+
+> ${task.replace(/\n/g, "\n> ")}
+
+etymd checked what the task names against the repo. What it could NOT check is listed under
+"only you can verify"; check those before acting, and if one fails, say so first \u2014 everything
+else is downstream of it.
+${failedLine}
+## What the task names, and whether it exists
+
+${checked}
+
+## Premises only you can verify
+
+1. **The named things are the ones MEANT.** A file that exists can still be the wrong file, and a
+   script that exists can still not be the one the task has in mind. Confirm each is where the
+   behaviour actually lives before touching it.
+2. **The mechanism the task assumes is working.** A task shaped like "make X faster / less flaky /
+   fresh after Y" assumes X and Y already do what it says. Run them once. If the assumed
+   mechanism does not run, the task is downstream of a defect it does not mention.
+3. **The state the task assumes holds.** Read it; do not trust the task's description of it.
+
+## If a premise fails
+
+Report it first, in one line: what the task presupposes, and what you found instead. Do not
+answer the original task as if the premise held \u2014 a wrong problem solved precisely is still the
+wrong problem.
+`;
+}
+
+// src/commands/premise.ts
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function run(opts) {
+  const failOn = opts.failOn === void 0 ? void 0 : parseFailOnTier(opts.failOn);
+  let task = opts.task;
+  let source = "argument";
+  if (opts.file === "-") {
+    task = await readStdin();
+    source = "stdin";
+  } else if (opts.file) {
+    const abs = path.resolve(opts.cwd, opts.file);
+    const text = await readText(abs);
+    if (text === null) throw new Error(`could not read the task file: ${opts.file}`);
+    task = text;
+    source = opts.file;
+  }
+  if (!task?.trim()) {
+    throw new Error(
+      'give the task as an argument (etymd premise "\u2026"), with --file <path>, or on stdin (--file -)'
+    );
+  }
+  const result = await runPremise({
+    root: opts.cwd,
+    task,
+    source,
+    writeBrief: opts.brief !== false
+  });
+  if (failOn && meetsFailOn(result.findings, failOn)) {
+    process.exitCode = 1;
+  }
+  if (opts.json) {
+    print(JSON.stringify(result, null, 2));
+    return;
+  }
+  section(`Premise ${theme.dim(`\xB7 ${result.name} \xB7 is this the right task?`)}`);
+  const shown = result.task.length > 160 ? `${result.task.slice(0, 157)}\u2026` : result.task;
+  print(`  ${theme.dim("task")}  ${shown.replace(/\n/g, " ")}`);
+  section(`Findings ${theme.dim("(a missing thing the task is about ranks as risk)")}`);
+  renderFindings(result.findings);
+  for (const d of result.disclosures) print(`       ${theme.dim(`\u25E6 ${d}`)}`);
+  if (opts.brief === false) return;
+  section("Brief");
+  if (result.briefPath) {
+    print(`  ${theme.dim("wrote")} ${theme.info(result.briefPath)}`);
+    print(
+      `  ${theme.dim("Hand it to the agent with the task:")} ${theme.dim('"Read')} ${theme.info(result.briefPath)}${theme.dim(' before you start."')}`
+    );
+  } else {
+    print(`  ${theme.dim("(no .etymd/ here, so nothing is written \u2014 the brief follows)")}`);
+    print();
+    for (const line of result.brief.split("\n")) print(`  ${line}`);
+  }
+}
+
+export { run };

package/dist/scan-W4US23MU.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+export { scanProject } from './chunk-Y6RZRED3.js';
+import './chunk-DBWDMIYO.js';
+import './chunk-YQZDYDAK.js';
+import './chunk-4VPBP6K6.js';

package/dist/{scan-B24RZAV2.js → scan-XBOHDXAH.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { print, renderFacts, theme } from './chunk-5BVKFJWM.js';
-import { scanProject } from './chunk-YXOAPMQH.js';
-import './chunk-D3R74TJ2.js';
-import { writeCachedFacts } from './chunk-JHZ2BN4U.js';
-import './chunk-LSZGCKIQ.js';
+import { print, renderFacts, theme } from './chunk-HI7NWPRA.js';
+import { scanProject } from './chunk-Y6RZRED3.js';
+import './chunk-DBWDMIYO.js';
+import { writeCachedFacts } from './chunk-P6ATKV2R.js';
+import './chunk-YQZDYDAK.js';
 import './chunk-4VPBP6K6.js';
 
 // src/commands/scan.ts

package/dist/{screen-CS6PSG7U.js → screen-E4FC7W5N.js}

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { print, glyph, theme, section } from './chunk-5BVKFJWM.js';
+import { print, glyph, theme, section } from './chunk-HI7NWPRA.js';
+import './chunk-P6ATKV2R.js';
 import { git, readText, pathExists } from './chunk-4VPBP6K6.js';
 import { promises } from 'fs';
 import path from 'path';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "etymd",
-  "version": "0.13.0",
-  "description": "Keep your agent instructions true — verify AGENTS.md, CLAUDE.md, rules & skills against the actual repo, with drift caught over time and a regression ledger.",
+  "version": "0.15.0",
+  "description": "Keep your agent instructions true — verify AGENTS.md, CLAUDE.md, rules, skills, and the task you hand an agent against the actual repo, with drift caught over time and a regression ledger.",
   "keywords": [
     "cli",
     "ai",

package/dist/audit-YRT4SWSQ.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-export { run } from './chunk-DSAQ5S5D.js';
-import './chunk-PXRLOEN5.js';
-import './chunk-F75Q43BC.js';
-import './chunk-3E2IPCRY.js';
-import './chunk-DWL2IKZH.js';
-import './chunk-5BVKFJWM.js';
-import './chunk-YXOAPMQH.js';
-import './chunk-D3R74TJ2.js';
-import './chunk-JHZ2BN4U.js';
-import './chunk-LSZGCKIQ.js';
-import './chunk-4VPBP6K6.js';

package/dist/chunk-F75Q43BC.js

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-import { DEFAULT_CONFIG } from './chunk-DWL2IKZH.js';
-import { readText, wordCount, approxTokens, pathExists } from './chunk-4VPBP6K6.js';
-import { promises } from 'fs';
-import path from 'path';
-
-var ALWAYS_LOADED = [
-  { path: "AGENTS.md", role: "operating contract" },
-  { path: "PROJECT_CONTEXT.md", role: "ground-truth state" },
-  { path: "CLAUDE.md", role: "Claude Code pointer" },
-  { path: "GEMINI.md", role: "Gemini pointer" },
-  { path: ".github/copilot-instructions.md", role: "Copilot instructions" },
-  { path: ".cursorrules", role: "Cursor rules (legacy)" }
-];
-var EXTRACTION_THRESHOLD = DEFAULT_CONFIG.context.perFileWords;
-function isAlwaysAppliedCursorRule(text) {
-  const fm = text.match(/^---\n([\s\S]*?)\n---/);
-  if (!fm) return true;
-  const frontmatter = fm[1] ?? "";
-  return /^\s*alwaysApply\s*:\s*true\s*$/m.test(frontmatter);
-}
-async function measureContext(root, perFileWords = EXTRACTION_THRESHOLD) {
-  const files = [];
-  for (const spec of ALWAYS_LOADED) {
-    const abs = path.join(root, spec.path);
-    const text = await readText(abs);
-    if (text === null) continue;
-    const words = wordCount(text);
-    files.push({ path: spec.path, role: spec.role, words, approxTokens: approxTokens(words) });
-  }
-  const rulesDir = path.join(root, ".cursor", "rules");
-  if (await pathExists(rulesDir)) {
-    try {
-      for (const entry of await promises.readdir(rulesDir)) {
-        if (!entry.endsWith(".mdc") && !entry.endsWith(".md")) continue;
-        const text = await readText(path.join(rulesDir, entry));
-        if (text === null || !isAlwaysAppliedCursorRule(text)) continue;
-        const words = wordCount(text);
-        files.push({
-          path: `.cursor/rules/${entry}`,
-          role: "Cursor rule (always applied)",
-          words,
-          approxTokens: approxTokens(words)
-        });
-      }
-    } catch {
-    }
-  }
-  const totalWords = files.reduce((s, f) => s + f.words, 0);
-  return {
-    files: files.sort((a, b) => b.words - a.words),
-    totalWords,
-    totalApproxTokens: approxTokens(totalWords),
-    perFileWords,
-    extractionCandidates: files.filter((f) => f.words >= perFileWords)
-  };
-}
-
-export { measureContext };

package/dist/chunk-JHZ2BN4U.js

@@ -1,67 +0,0 @@
-#!/usr/bin/env node
-import { readJson } from './chunk-4VPBP6K6.js';
-import { promises } from 'fs';
-import path from 'path';
-
-var ETYMD_DIR = ".etymd";
-var CACHE_DIR = path.join(ETYMD_DIR, "cache");
-var CACHE_FACTS_FILE = path.join(CACHE_DIR, "facts.json");
-var BASELINE_FILE = path.join(ETYMD_DIR, "baseline.json");
-function cacheFactsPath(root) {
-  return path.join(root, CACHE_FACTS_FILE);
-}
-function baselinePath(root) {
-  return path.join(root, BASELINE_FILE);
-}
-async function writeJsonFile(target, data) {
-  await promises.mkdir(path.dirname(target), { recursive: true });
-  await promises.writeFile(target, JSON.stringify(data, null, 2) + "\n", "utf8");
-  return target;
-}
-async function writeCachedFacts(root, facts) {
-  return writeJsonFile(cacheFactsPath(root), facts);
-}
-function withoutMachinePath(facts) {
-  return { ...facts, root: "." };
-}
-function baselineCarriesMachinePath(baseline) {
-  const root = baseline.facts?.root;
-  return typeof root === "string" && root !== "." && (root.startsWith("/") || /^[A-Za-z]:[\\/]/.test(root));
-}
-async function writeBaseline(root, baseline) {
-  return writeJsonFile(baselinePath(root), {
-    ...baseline,
-    facts: withoutMachinePath(baseline.facts)
-  });
-}
-async function readBaseline(root) {
-  return readJson(baselinePath(root));
-}
-function deriveProfile(facts) {
-  return (facts.git.recentAuthors ?? 1) > 2 ? "team" : "solo";
-}
-var DRIFT_ROLES = ["test", "lint", "typecheck", "format", "formatCheck", "build", "dev"];
-function summarizeBaselineDrift(old, fresh) {
-  const commands = [];
-  for (const role of DRIFT_ROLES) {
-    const from = old.commands[role];
-    const to = fresh.commands[role];
-    if (from !== to) commands.push({ role, from, to });
-  }
-  const presentIds = (f) => new Set(f.artifacts.filter((a) => a.exists).map((a) => a.id));
-  const oldArtifacts = presentIds(old);
-  const freshArtifacts = presentIds(fresh);
-  const labelOf = (id) => fresh.artifacts.find((a) => a.id === id)?.label ?? old.artifacts.find((a) => a.id === id)?.label ?? id;
-  const artifactsAdded = [...freshArtifacts].filter((id) => !oldArtifacts.has(id)).map(labelOf);
-  const artifactsRemoved = [...oldArtifacts].filter((id) => !freshArtifacts.has(id)).map(labelOf);
-  const oldDirs = new Set(old.tree.dirs.map((d) => d.name));
-  const freshDirs = new Set(fresh.tree.dirs.map((d) => d.name));
-  const dirsAdded = [...freshDirs].filter((d) => !oldDirs.has(d));
-  const dirsRemoved = [...oldDirs].filter((d) => !freshDirs.has(d));
-  return { commands, artifactsAdded, artifactsRemoved, dirsAdded, dirsRemoved };
-}
-function isDriftEmpty(d) {
-  return d.commands.length === 0 && d.artifactsAdded.length === 0 && d.artifactsRemoved.length === 0 && d.dirsAdded.length === 0 && d.dirsRemoved.length === 0;
-}
-
-export { BASELINE_FILE, CACHE_DIR, ETYMD_DIR, baselineCarriesMachinePath, deriveProfile, isDriftEmpty, readBaseline, summarizeBaselineDrift, writeBaseline, writeCachedFacts };

package/dist/doctor-7YKDXSKM.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-import { run } from './chunk-DSAQ5S5D.js';
-import './chunk-PXRLOEN5.js';
-import './chunk-F75Q43BC.js';
-import './chunk-3E2IPCRY.js';
-import './chunk-DWL2IKZH.js';
-import './chunk-5BVKFJWM.js';
-import './chunk-YXOAPMQH.js';
-import './chunk-D3R74TJ2.js';
-import './chunk-JHZ2BN4U.js';
-import './chunk-LSZGCKIQ.js';
-import './chunk-4VPBP6K6.js';
-
-// src/commands/doctor.ts
-async function run2(opts) {
-  await run({ cwd: opts.cwd, json: opts.json, truth: true });
-}
-
-export { run2 as run };

package/dist/generate-PMCP37DC.js

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-export { deriveFailOn, derivedCommands, planWorkflow, riskReachability } from './chunk-HRJJQCMT.js';
-import './chunk-DWL2IKZH.js';
-import './chunk-JHZ2BN4U.js';
-import './chunk-LSZGCKIQ.js';
-import './chunk-4VPBP6K6.js';

package/dist/ledger-4FOZ5HAB.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-export { accept, dismiss, list } from './chunk-2VLNI3L2.js';
-import './chunk-3E2IPCRY.js';
-import './chunk-5BVKFJWM.js';
-import './chunk-4VPBP6K6.js';

package/dist/scan-QDNN7ER3.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-export { scanProject } from './chunk-YXOAPMQH.js';
-import './chunk-D3R74TJ2.js';
-import './chunk-LSZGCKIQ.js';
-import './chunk-4VPBP6K6.js';