etymd 0.1.0 → 0.2.1

package/dist/{chunk-5D7WNJ6N.js → chunk-SS7VGLJ5.js}

@@ -1,13 +1,30 @@
 #!/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 { readLedger, reconcileLedger, writeLedger, visibleFindings } from './chunk-KBF3SW3N.js';
+import { DEFAULT_CONFIG, readConfig, CONFIG_FILE, measureContext } from './chunk-ANCCGYSH.js';
+import { scanProject, PACK_VERSION, expandFileGlobs } from './chunk-E2Q7WFPN.js';
+import { ETYMD_DIR, writeCachedFacts, readBaseline, deriveProfile, baselineCarriesMachinePath, BASELINE_FILE } from './chunk-FZSIOCOZ.js';
+import { pathExists, readJson, git, readText, isDirectory, matchesAnyGlob, isCiEnvironment, normalizeRelPath } from './chunk-LBRNZZZF.js';
 import path from 'node:path';
 import YAML from 'yaml';
 import { promises } from 'node:fs';
 
+// src/engine/finding.ts
+var TIER_ORDER = { risk: 0, gap: 1, polish: 2 };
+var EFFORT_ORDER = { S: 0, M: 1, L: 2 };
+function parseFailOnTier(value) {
+  if (value === "risk" || value === "gap" || value === "polish") return value;
+  throw new Error(`--fail-on must be risk|gap|polish, got \`${value}\``);
+}
+function meetsFailOn(findings, failOn) {
+  const threshold = TIER_ORDER[failOn];
+  return findings.some((f) => TIER_ORDER[f.tier] <= threshold);
+}
+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/lenses/context-economy.ts
 var LENS_ID = "context-economy";
 DEFAULT_CONFIG.context.totalWords;
@@ -214,8 +231,8 @@ function parseGithubWorkflow(text, file, scripts) {
     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);
+      const run = step?.run;
+      if (typeof run === "string") for (const t of matchTools(run, scripts)) tools.add(t);
     }
     if (!tools.size) continue;
     jobs.push({
@@ -729,7 +746,13 @@ function packageManagerUsage(text) {
   }
   return counts;
 }
-var KNOWN_DOC_REFS = ["AGENTS.md", "CLAUDE.md", "PROJECT_CONTEXT.md", "GEMINI.md"];
+var KNOWN_DOC_REFS = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  "PROJECT_CONTEXT.md",
+  "DECISIONS.md",
+  "GEMINI.md"
+];
 function extractDocRefs(text) {
   return KNOWN_DOC_REFS.filter((name) => text.includes(name));
 }
@@ -1027,25 +1050,228 @@ var instructionTruthLens = {
     };
   }
 };
-
-// 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]
-  );
+var LENS_ID4 = "state-freshness";
+var DECISIONS_FORMAT_MARKER = "<!-- decisions-format: 1 -->";
+var MS_PER_DAY = 864e5;
+function parseDecisionEntries(text) {
+  const headings = [...text.matchAll(/^## .*$/gm)];
+  const entries = [];
+  for (let i = 0; i < headings.length; i++) {
+    const h = headings[i];
+    const m = /^## (D-(\d+))\b/.exec(h[0]);
+    if (!m) continue;
+    const start = (h.index ?? 0) + h[0].length;
+    const end = i + 1 < headings.length ? headings[i + 1].index : void 0;
+    entries.push({ id: m[1], num: Number(m[2]), block: text.slice(start, end) });
+  }
+  return entries;
 }
+function checkIdSequence(file, entries) {
+  const findings = [];
+  const nextFree = Math.max(0, ...entries.map((e) => e.num)) + 1;
+  const seen = /* @__PURE__ */ new Map();
+  const duplicated = /* @__PURE__ */ new Set();
+  let prev;
+  for (const entry of entries) {
+    if (seen.has(entry.num)) {
+      if (!duplicated.has(entry.num)) {
+        duplicated.add(entry.num);
+        findings.push({
+          id: `${LENS_ID4}/duplicate-id:${file}:${entry.id}`,
+          lens: LENS_ID4,
+          tier: "gap",
+          claim: `${file} carries more than one ${entry.id} entry`,
+          evidence: [`${file}: ${entry.id} appears twice`],
+          why: "Two decisions under one id cannot be cited, superseded, or dismissed unambiguously \u2014 append races collide exactly here.",
+          action: `Rename the later entry to D-${String(nextFree).padStart(3, "0")} (the next free id).`,
+          effort: "S",
+          confidence: "high"
+        });
+      }
+    } else {
+      seen.set(entry.num, entry);
+      if (prev && entry.num < prev.num) {
+        findings.push({
+          id: `${LENS_ID4}/id-order:${file}:${entry.id}`,
+          lens: LENS_ID4,
+          tier: "gap",
+          claim: `${file} lists ${entry.id} after ${prev.id} \u2014 ids out of append order`,
+          evidence: [`${file}: ${prev.id} precedes ${entry.id}`],
+          why: "An append-only record reads in id order; out-of-order ids make the newest decision hard to find and the next id hard to pick.",
+          action: `Rename the out-of-order entry into sequence (next free id: D-${String(nextFree).padStart(3, "0")}).`,
+          effort: "S",
+          confidence: "high"
+        });
+      }
+      prev = entry;
+    }
+  }
+  return findings;
+}
+function checkFormatFields(file, entries, today) {
+  const findings = [];
+  for (const entry of entries) {
+    if (!/Scope[\s*]*:/.test(entry.block)) {
+      findings.push({
+        id: `${LENS_ID4}/scope-missing:${file}:${entry.id}`,
+        lens: LENS_ID4,
+        tier: "gap",
+        claim: `${file} ${entry.id} has no Scope: field`,
+        evidence: [`${file}: ${entry.id}`],
+        why: "A decision without a scope binds nobody \u2014 a reader cannot tell whether it covers the project they are working in.",
+        action: "Add a Scope: line naming what the decision binds.",
+        effort: "S",
+        confidence: "high"
+      });
+    }
+    const revisit = /Revisit[\s*]*:[\s*]*(\d{4}-\d{2}-\d{2})/.exec(entry.block);
+    if (revisit && revisit[1] < today) {
+      findings.push({
+        id: `${LENS_ID4}/revisit-due:${file}:${entry.id}`,
+        lens: LENS_ID4,
+        tier: "gap",
+        claim: `${file} ${entry.id} was due for revisit on ${revisit[1]}`,
+        evidence: [`${file}: ${entry.id} Revisit: ${revisit[1]}`],
+        why: "Review debt is due \u2014 a Revisit date is a promise to re-evaluate, and a past one silently hardens into policy.",
+        action: "Re-evaluate the decision: supersede it or move the Revisit date.",
+        effort: "S",
+        confidence: "high"
+      });
+    }
+  }
+  return findings;
+}
+var stateFreshnessLens = {
+  id: LENS_ID4,
+  version: "1",
+  title: "State freshness",
+  kind: "truth",
+  async run(ctx) {
+    const budgets = ctx.config?.config.state ?? DEFAULT_CONFIG.state;
+    const findings = [];
+    const disclosures = [...ctx.config?.problems ?? []];
+    const outOfScope = [];
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const stateArtifacts = ctx.facts.artifacts.filter((a) => a.kind === "state" && a.exists);
+    const decisionArtifacts = ctx.facts.artifacts.filter((a) => a.kind === "decisions" && a.exists);
+    if (stateArtifacts.length === 0 && decisionArtifacts.length === 0) {
+      disclosures.push("No state or decisions artifacts detected \u2014 nothing to check.");
+    }
+    const freshness = ctx.facts.freshness;
+    if (!freshness) {
+      disclosures.push("Scan carried no freshness facts \u2014 staleness unchecked.");
+    } else {
+      for (const u of freshness.unverifiable) {
+        disclosures.push(`Freshness of ${u.path} is unverifiable (${u.reason}) \u2014 not flagged.`);
+      }
+      for (const a of stateArtifacts) {
+        const fact = freshness.artifacts.find((f) => f.artifactId === a.id);
+        if (!fact || !freshness.repoLastCommit) continue;
+        if (fact.dirty) {
+          disclosures.push(
+            `${a.path} has uncommitted changes \u2014 modified since its last commit; treated fresh-now, not flagged.`
+          );
+          continue;
+        }
+        if (!fact.commitsSince) continue;
+        const gapDays = Math.floor(
+          (Date.parse(freshness.repoLastCommit) - Date.parse(fact.lastCommit)) / MS_PER_DAY
+        );
+        if (gapDays <= budgets.staleAfterDays) continue;
+        const escalated = gapDays > budgets.staleAfterDays * 3;
+        findings.push({
+          id: `${LENS_ID4}/stale-state:${a.path}`,
+          lens: LENS_ID4,
+          tier: escalated ? "risk" : "gap",
+          claim: `${a.path} trails the repo by ${gapDays} days of commit traffic \u2014 it says "now" but the repo moved on`,
+          evidence: [
+            `${a.path} last commit: ${fact.lastCommit}`,
+            `repo last commit: ${freshness.repoLastCommit}`
+          ],
+          why: escalated ? `Over three times the ${budgets.staleAfterDays}-day threshold while commits kept landing \u2014 every session starts from a picture of the project that is no longer true.` : `A state doc more than ${budgets.staleAfterDays} days behind continued commit traffic misleads every session that loads it.`,
+          action: "Refresh the state doc (or record why it is still current).",
+          effort: "S",
+          confidence: "high"
+        });
+      }
+    }
+    for (const a of stateArtifacts) {
+      const text = await readText(path.join(ctx.root, a.path));
+      if (text === null) {
+        disclosures.push(`${a.path} could not be read \u2014 unexamined, not clean.`);
+        outOfScope.push(a.path);
+        continue;
+      }
+      if (text.length > budgets.maxChars) {
+        findings.push({
+          id: `${LENS_ID4}/state-over-budget:${a.path}`,
+          lens: LENS_ID4,
+          tier: "gap",
+          claim: `${a.path} is ${text.length} chars \u2014 over the ${budgets.maxChars}-char state budget`,
+          evidence: [`${a.path}: ${text.length} chars`],
+          why: "Session-injection hooks truncate state around 10,000 chars \u2014 an over-budget state doc gets cut mid-sentence, and every session pays its full weight before the task begins.",
+          action: "Trim to budget; move overflow into decisions/docs and keep a pointer.",
+          effort: "M",
+          confidence: "high"
+        });
+      }
+    }
+    for (const a of decisionArtifacts) {
+      const text = await readText(path.join(ctx.root, a.path));
+      if (text === null) {
+        disclosures.push(
+          `${a.path} recognized as a decisions convention (directory) \u2014 age-exempt; per-entry format checks apply only to marker-carrying decisions files.`
+        );
+        continue;
+      }
+      const entries = parseDecisionEntries(text);
+      findings.push(...checkIdSequence(a.path, entries));
+      if (!text.includes(DECISIONS_FORMAT_MARKER)) {
+        disclosures.push(
+          `${a.path} carries no \`${DECISIONS_FORMAT_MARKER}\` marker \u2014 format checks skipped (forward-only, never retroactive); id-sequence checks still ran.`
+        );
+        outOfScope.push(a.path);
+        continue;
+      }
+      findings.push(...checkFormatFields(a.path, entries, today));
+    }
+    disclosures.push(
+      `Thresholds: staleAfterDays ${budgets.staleAfterDays} (3x escalates to risk), state budget ${budgets.maxChars} chars (${budgets.staleAfterDays === DEFAULT_CONFIG.state.staleAfterDays && budgets.maxChars === DEFAULT_CONFIG.state.maxChars ? `defaults \u2014 override under \`state\` in ${CONFIG_FILE}` : `set in ${CONFIG_FILE}`}). Decisions artifacts are exempt from age \u2014 old decisions are history, not defects.`
+    );
+    return {
+      lens: LENS_ID4,
+      version: "1",
+      title: "State freshness",
+      kind: "truth",
+      status: "ran",
+      disclosures,
+      findings,
+      ...outOfScope.length ? { outOfScope } : {}
+    };
+  }
+};
 
 // src/engine/run.ts
-var LENSES = [instructionTruthLens, gateIntegrityLens, contextEconomyLens];
+var LENSES = [
+  instructionTruthLens,
+  stateFreshnessLens,
+  gateIntegrityLens,
+  contextEconomyLens
+];
 async function runAudit(root, opts = {}) {
-  const facts = await scanProject(root);
-  if ((opts.persistLedger ?? true) || await pathExists(path.join(root, ETYMD_DIR))) {
+  const facts = await scanProject(root, { upstreamRemote: opts.upstreamRemote });
+  const ledgerRoot = opts.ledgerRoot ?? root;
+  if (!opts.readOnlyRoot && ((opts.persistLedger ?? true) || await pathExists(path.join(root, ETYMD_DIR)))) {
     await writeCachedFacts(root, facts);
   }
   const baseline = await readBaseline(root);
-  const config = await readConfig(root);
+  let config = await readConfig(root);
+  if (opts.stateBudgets) {
+    config = {
+      ...config,
+      config: { ...config.config, state: { ...config.config.state, ...opts.stateBudgets } }
+    };
+  }
   const profile = baseline?.profile ?? deriveProfile(facts);
   const selected = LENSES.filter(
     (lens) => (!opts.kind || lens.kind === opts.kind) && (!opts.lensIds || opts.lensIds.includes(lens.id))
@@ -1068,12 +1294,13 @@ async function runAudit(root, opts = {}) {
     }
   }
   const all = reports.flatMap((r) => r.findings);
-  const previous = await readLedger(root);
+  const previous = await readLedger(ledgerRoot);
   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);
+  const ledgerWritable = !opts.readOnlyRoot || ledgerRoot !== root;
+  if ((opts.persistLedger ?? true) && fullRun && ledgerWritable) {
+    await writeLedger(ledgerRoot, ledger);
   }
   return {
     facts,
@@ -1087,62 +1314,4 @@ async function runAudit(root, opts = {}) {
   };
 }
 
-// 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 };
+export { meetsFailOn, parseFailOnTier, runAudit };

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { VERSION } from './chunk-U33XLT5I.js';
+import { VERSION } from './chunk-C4Z6NXDO.js';
 import path from 'node:path';
 import { Command } from 'commander';
 import pc from 'picocolors';
@@ -23,12 +23,15 @@ var program = new Command();
 program.name("etymd").description(
   "Keep your agent instructions true \u2014 verify AGENTS.md & friends against the actual repo, on a budget, with drift caught over time."
 ).version(VERSION, "-v, --version").option("--cwd <dir>", "run against a different project directory", process.cwd());
-program.command("audit").description("Verify every instruction claim against the repo: ranked findings + ledger diff").option("--json", "print the machine-stable audit result as JSON").option("--truth", "truth lenses only (the doctor subset)").option("--lens <id>", "run a single lens (instruction-truth | gate-integrity | context-economy)").option("--no-ledger", "read-only: do not persist the reconciled ledger").option(
+program.command("audit").description("Verify every instruction claim against the repo: ranked findings + ledger diff").option("--json", "print the machine-stable audit result as JSON").option("--truth", "truth lenses only (the doctor subset)").option(
+  "--lens <id>",
+  "run a single lens (instruction-truth | state-freshness | gate-integrity | context-economy)"
+).option("--no-ledger", "read-only: do not persist the reconciled ledger").option(
   "--fail-on <tier>",
   "exit non-zero when findings at/above this tier exist (risk|gap|polish)"
 ).action(
   (opts, cmd) => action(async () => {
-    const { run } = await import('./audit-OHOSWOWA.js');
+    const { run } = await import('./audit-YH74YZFQ.js');
     await run({
       cwd: resolveCwd(cmd),
       json: opts.json,
@@ -41,7 +44,7 @@ program.command("audit").description("Verify every instruction claim against the
 );
 program.command("init").description("Onboard the truth guard: approve the baseline; scaffold AGENTS.md only if missing").option("-y, --yes", "accept defaults without prompting (never overwrites)").action(
   (opts, cmd) => action(async () => {
-    const { run } = await import('./init-V627UXKU.js');
+    const { run } = await import('./init-ISEFZWPV.js');
     await run({ cwd: resolveCwd(cmd), yes: opts.yes });
   })
 );
@@ -49,55 +52,112 @@ program.command("approve").description(
   "Re-approve the committed baseline after intentional structural changes (non-interactive)"
 ).action(
   (_opts, cmd) => action(async () => {
-    const { run } = await import('./approve-WM6OJHQG.js');
+    const { run } = await import('./approve-X3AW7KLD.js');
     await run({ cwd: resolveCwd(cmd) });
   })
 );
 program.command("scan").description("Deterministically reckon the project into a facts index").option("--json", "print the raw facts as JSON").option("--no-save", "do not write the .etymd cache").action(
   (opts, cmd) => action(async () => {
-    const { run } = await import('./scan-YL7JHLUA.js');
+    const { run } = await import('./scan-ADZ2RKYY.js');
     await run({ cwd: resolveCwd(cmd), json: opts.json, save: opts.save });
   })
 );
 program.command("doctor").description('Alias for `audit --truth` \u2014 "are the recorded instructions still true?"').option("--json", "print findings as JSON").action(
   (opts, cmd) => action(async () => {
-    const { run } = await import('./doctor-NNRJTNIY.js');
+    const { run } = await import('./doctor-EAA4IP4Y.js');
     await run({ cwd: resolveCwd(cmd), json: opts.json });
   })
 );
 program.command("context").description("Measure the always-loaded context footprint and flag extraction candidates").option("--json", "print the budget as JSON").action(
   (opts, cmd) => action(async () => {
-    const { run } = await import('./context-TT5H76LA.js');
+    const { run } = await import('./context-GYCLR3TG.js');
     await run({ cwd: resolveCwd(cmd), json: opts.json });
   })
 );
 program.command("brief").description("Emit a grounded briefing for the in-repo agent to complete the semantic layer").option("--human", "write a human onboarding brief instead of the agent briefing").action(
   (opts, cmd) => action(async () => {
-    const { run } = await import('./brief-2MPNTITQ.js');
+    const { run } = await import('./brief-RT6KE4CN.js');
     await run({ cwd: resolveCwd(cmd), human: opts.human });
   })
 );
 program.command("ledger").description("List every tracked finding grouped by status (open \xB7 accepted \xB7 dismissed \xB7 \u2026)").option("--json", "print the raw ledger as JSON").action(
   (opts, cmd) => action(async () => {
-    const { list } = await import('./ledger-YFTYCOIC.js');
+    const { list } = await import('./ledger-RHQJH5EA.js');
     await list({ cwd: resolveCwd(cmd), json: opts.json });
   })
 );
 program.command("dismiss").argument("<finding-id>", "the finding id (from `etymd audit`) to dismiss").description("Dismiss a finding as a false positive / not applicable (hidden from future audits)").requiredOption("--reason <text>", "why it is dismissed \u2014 recorded so the decision survives").action(
   (id, opts, cmd) => action(async () => {
-    const { dismiss } = await import('./ledger-YFTYCOIC.js');
+    const { dismiss } = await import('./ledger-RHQJH5EA.js');
     await dismiss({ cwd: resolveCwd(cmd), id, reason: opts.reason });
   })
 );
 program.command("accept").argument("<finding-id>", "the finding id (from `etymd audit`) to accept").description("Accept a real finding as a known trade-off (hidden from future audits)").option("--reason <text>", "optional note on why the trade-off is accepted").action(
   (id, opts, cmd) => action(async () => {
-    const { accept } = await import('./ledger-YFTYCOIC.js');
+    const { accept } = await import('./ledger-RHQJH5EA.js');
     await accept({ cwd: resolveCwd(cmd), id, reason: opts.reason });
   })
 );
+var fleet = program.command("fleet").description(
+  "Sweep every project in a fleet manifest: per-repo audits + manifest-truth wall checks (schemas EXPERIMENTAL through 0.2.x)"
+).option(
+  "--manifest <file>",
+  "the fleet manifest (registry.json / legacy sources.json) \u2014 required unless the cwd holds registry.json"
+).option("--only <names...>", "sweep only these registered names").option("--profile <profile>", "sweep only entries with this profile (personal|corp)").option("--truth", "truth lenses only per repo (the doctor subset)").option(
+  "--persist-ledgers",
+  "persist per-repo ledgers \u2014 personal-profile entries that already carry .etymd only; corp worktrees are never written"
+).option("--json", "print the machine schema (EXPERIMENTAL through 0.2.x, local-only)").option(
+  "--fail-on <tier>",
+  "exit non-zero when findings at/above this tier exist (risk|gap|polish)"
+).action(
+  (opts, cmd) => action(async () => {
+    const { sweep } = await import('./fleet-IS6YWDDV.js');
+    await sweep({
+      cwd: resolveCwd(cmd),
+      manifest: opts.manifest,
+      only: opts.only,
+      profile: opts.profile,
+      truth: opts.truth,
+      persistLedgers: opts.persistLedgers,
+      json: opts.json,
+      failOn: opts.failOn
+    });
+  })
+);
+fleet.command("check").description("Validate the manifest pair only \u2014 no lenses: dangling mappings, duplicates, leaks").option("--manifest <file>", "the fleet manifest \u2014 required unless the cwd holds registry.json").option("--json", "print the findings as JSON (EXPERIMENTAL through 0.2.x)").action(
+  (_opts, cmd) => action(async () => {
+    const { check } = await import('./fleet-IS6YWDDV.js');
+    const opts = cmd.optsWithGlobals();
+    await check({ cwd: resolveCwd(cmd), manifest: opts.manifest, json: opts.json });
+  })
+);
+fleet.command("dismiss").argument("<name>", "the registered project name").argument("<finding-id>", "the finding id (from `etymd fleet`) to dismiss").description(
+  "Dismiss a project's finding from any cwd \u2014 corp ledgers persist beside the manifest"
+).requiredOption("--reason <text>", "why it is dismissed \u2014 recorded so the decision survives").option("--manifest <file>", "the fleet manifest \u2014 required unless the cwd holds registry.json").action(
+  (name, id, _opts, cmd) => action(async () => {
+    const { dismiss } = await import('./fleet-IS6YWDDV.js');
+    const opts = cmd.optsWithGlobals();
+    await dismiss({
+      cwd: resolveCwd(cmd),
+      manifest: opts.manifest,
+      name,
+      id,
+      reason: opts.reason
+    });
+  })
+);
+fleet.command("accept").argument("<name>", "the registered project name").argument("<finding-id>", "the finding id (from `etymd fleet`) to accept").description(
+  "Accept a project's finding as a known trade-off \u2014 corp ledgers persist beside the manifest"
+).option("--reason <text>", "optional note on why the trade-off is accepted").option("--manifest <file>", "the fleet manifest \u2014 required unless the cwd holds registry.json").action(
+  (name, id, _opts, cmd) => action(async () => {
+    const { accept } = await import('./fleet-IS6YWDDV.js');
+    const opts = cmd.optsWithGlobals();
+    await accept({ cwd: resolveCwd(cmd), manifest: opts.manifest, name, id, reason: opts.reason });
+  })
+);
 program.command("gates").description("Install the local git-hook gates (process \u2192 pre-commit, correctness \u2192 pre-push)").option("--ci", "note about the CI review gate (ships later; local gates install now)").option("-y, --yes", "skip prompts; never overwrites a hand-edited hook").action(
   (opts, cmd) => action(async () => {
-    const { run } = await import('./gates-KPDEUC36.js');
+    const { run } = await import('./gates-3NPKF4IZ.js');
     await run({ cwd: resolveCwd(cmd), ci: opts.ci, yes: opts.yes });
   })
 );

package/dist/{context-TT5H76LA.js → context-GYCLR3TG.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { readConfig, measureContext } from './chunk-I566LDX7.js';
-import './chunk-SMM2TW35.js';
-import { print, renderContext } from './chunk-WVYKYPKS.js';
+import { readConfig, measureContext } from './chunk-ANCCGYSH.js';
+import './chunk-FZSIOCOZ.js';
+import { print, renderContext } from './chunk-LBRNZZZF.js';
 
 // src/commands/context.ts
 async function run(opts) {

package/dist/doctor-EAA4IP4Y.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { run } from './chunk-6W3J4PJ6.js';
+import './chunk-SS7VGLJ5.js';
+import './chunk-KBF3SW3N.js';
+import './chunk-ANCCGYSH.js';
+import './chunk-E2Q7WFPN.js';
+import './chunk-C4Z6NXDO.js';
+import './chunk-FZSIOCOZ.js';
+import './chunk-LBRNZZZF.js';
+
+// src/commands/doctor.ts
+async function run2(opts) {
+  await run({ cwd: opts.cwd, json: opts.json, truth: true });
+}
+
+export { run2 as run };