etymd 0.15.0 → 0.17.0

package/dist/{init-H57H2JBE.js → init-6RULX5JZ.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { applyFiles } from './chunk-GWGKEPRX.js';
-import { planWorkflow } from './chunk-UFNETE6P.js';
+import { planWorkflow } from './chunk-PIJZUDDQ.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 { scanProject } from './chunk-446EZNAQ.js';
+import { VERSION } from './chunk-BUMOGHQA.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';

package/dist/{premise-VMC3UUIB.js → premise-GFWHSR3K.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { parseFailOnTier, meetsFailOn, buildTruthEnv, emptyCounters, checkTextClaims, checkDocRefs, loadDecisionLedger, checkDecisionRefs, rankFindings, PATH_TOKEN_RE, KNOWN_EXTENSIONS } from './chunk-IWG77WV3.js';
+import { parseFailOnTier, meetsFailOn, buildTruthEnv, emptyCounters, checkTextClaims, checkDocRefs, loadDecisionLedger, checkDecisionRefs, rankFindings, PATH_TOKEN_RE, KNOWN_EXTENSIONS, NAMESPACE_IDENT, NAMESPACE_STOP } from './chunk-FNA4R5KT.js';
 import { print, section, theme, renderFindings } from './chunk-HI7NWPRA.js';
-import { scanProject } from './chunk-Y6RZRED3.js';
-import './chunk-DBWDMIYO.js';
+import { scanProject } from './chunk-446EZNAQ.js';
+import './chunk-BUMOGHQA.js';
 import { ETYMD_DIR } from './chunk-P6ATKV2R.js';
 import './chunk-YQZDYDAK.js';
 import { readText, pathExists } from './chunk-4VPBP6K6.js';
@@ -27,7 +27,8 @@ function promoteBareTokens(text, ctx) {
     bareInvocations: 0,
     proseScripts: 0,
     hostnameLike: 0,
-    unrootedDirs: 0
+    unrootedDirs: 0,
+    namespaced: 0
   };
   const promoted = text.split(CODE_SPAN_RE).map((segment, i) => i % 2 === 1 ? segment : promoteProse(segment, ctx, skips)).join("");
   return { text: promoted, skips };
@@ -46,28 +47,44 @@ function promoteProse(segment, ctx, skips) {
     }
     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;
+  const parts = withCommands.split(/(\s+)/);
+  for (let i = 0; i < parts.length; i += 2) {
+    parts[i] = promoteToken(parts[i], i >= 2 ? parts[i - 2] : "", ctx, skips);
+  }
+  return parts.join("");
+}
+function namespaceOf(core, prev) {
+  const ns = new RegExp(`^(${NAMESPACE_IDENT}):`).exec(core)?.[1] ?? new RegExp(`^(${NAMESPACE_IDENT}):$`).exec(prev)?.[1];
+  return ns && !NAMESPACE_STOP.has(ns.toLowerCase()) ? ns : null;
+}
+function promoteToken(token, prev, ctx, skips) {
+  const m = WRAP_RE.exec(token);
+  if (!m) return token;
+  const [, lead = "", core = "", trail = ""] = m;
+  if (!core || core.includes("://")) return token;
+  const namespace = namespaceOf(core, prev);
+  const body = namespace && core.startsWith(`${namespace}:`) ? core.slice(namespace.length + 1) : core;
+  if (!PATH_TOKEN_RE.test(body)) return token;
+  const first = body.slice(0, body.indexOf("/"));
+  const hostSuffix = HOSTNAME_RE.exec(first)?.[1]?.toLowerCase();
+  if (hostSuffix && !KNOWN_EXTENSIONS.has(hostSuffix)) {
+    skips.hostnameLike += 1;
+    return token;
+  }
+  if (body.endsWith("/")) {
+    if (!ctx.rootedDirs.has(first)) {
+      skips.unrootedDirs += 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];
+  } else {
+    const ext = body.toLowerCase().match(/\.([a-z0-9]{1,8})$/)?.[1];
     if (!ext || !KNOWN_EXTENSIONS.has(ext)) return token;
-    return `${lead}\`${core}\`${trail}`;
-  });
+  }
+  if (namespace) {
+    skips.namespaced += 1;
+    return token;
+  }
+  return `${lead}\`${body}\`${trail}`;
 }
 async function listRootedDirs(env) {
   const dirs = /* @__PURE__ */ new Set();
@@ -85,7 +102,8 @@ async function runPremise(opts) {
   const facts = await scanProject(root);
   const env = await buildTruthEnv(root, facts);
   const counters = emptyCounters();
-  const promoted = promoteBareTokens(task, { rootedDirs: await listRootedDirs(env) });
+  const rootedDirs = await listRootedDirs(env);
+  const promoted = promoteBareTokens(task, { rootedDirs });
   const text = { path: TASK_LABEL, text: promoted.text };
   const findings = [];
   const disclosures = [];
@@ -98,6 +116,8 @@ async function runPremise(opts) {
       subject: "The task",
       missingPathTier: "risk",
       maxPathFindings: MAX_PATH_FINDINGS,
+      rootedFirstSegments: rootedDirs,
+      treatNamespacedPrefixes: true,
       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.",
@@ -154,6 +174,21 @@ async function runPremise(opts) {
       `${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 (skips.namespaced) {
+    disclosures.push(
+      `${skips.namespaced} path mention(s) in prose carry a namespace prefix (\`pc:src/x.ts\`, \`lk: src/x.ts\`) \u2014 another repo's tree, never this one; skipped, not flagged.`
+    );
+  }
+  if (counters.namespacedSkipped) {
+    disclosures.push(
+      `${counters.namespacedSkipped} backticked path mention(s) sit directly after a namespace prefix (\`pc: \`src/x.ts\`\`) \u2014 another repo's tree, not this one; skipped, not flagged.`
+    );
+  }
+  if (counters.outsideRepoSkipped) {
+    disclosures.push(
+      `${counters.outsideRepoSkipped} path(s) the task names start at no directory of this repo \u2014 typical of a path quoted from another repository or a scratchpad clone; outside this repo, not missing here. Skipped, not flagged.`
+    );
+  }
   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.`

package/dist/propose-IYNOIWAO.js

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+import { sweepFleet, loadFleetManifest, FLEET_JSON_SCHEMA } from './chunk-LVR2DPR7.js';
+import './chunk-WKP7M2B3.js';
+import './chunk-FNA4R5KT.js';
+import './chunk-3E2IPCRY.js';
+import { print, section, theme, renderFleetNotes } from './chunk-HI7NWPRA.js';
+import './chunk-446EZNAQ.js';
+import './chunk-BUMOGHQA.js';
+import './chunk-P6ATKV2R.js';
+import './chunk-YQZDYDAK.js';
+import { readText } from './chunk-4VPBP6K6.js';
+import path from 'path';
+
+// src/engine/propose.ts
+var PROPOSAL_SCHEMA = "proposal/1";
+var RUBRIC_CRITERIA = ["severity", "economy", "confidence", "breadth"];
+function parseRubric(text, file) {
+  const lines = [];
+  const seen = /* @__PURE__ */ new Map();
+  const rows = text.split(/\r?\n/);
+  for (const [i, raw] of rows.entries()) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const at = i + 1;
+    const refuse = (why) => new Error(
+      `${file}:${at} \`${raw.trim()}\` \u2014 ${why} (criteria: ${RUBRIC_CRITERIA.join(", ")})`
+    );
+    const sep = line.indexOf(":");
+    if (sep < 0) throw refuse("expected `criterion: <weight>`");
+    const criterion = line.slice(0, sep).trim();
+    const weightRaw = line.slice(sep + 1).trim();
+    if (!RUBRIC_CRITERIA.includes(criterion)) {
+      throw refuse(`unknown criterion \`${criterion}\``);
+    }
+    if (!/^\d+$/.test(weightRaw) || Number(weightRaw) < 1) {
+      throw refuse(`weight \`${weightRaw}\` is not a positive integer`);
+    }
+    const known = criterion;
+    if (seen.has(known)) {
+      throw new Error(
+        `${file}:${at} \`${raw.trim()}\` \u2014 criterion \`${criterion}\` is already weighted on line ${seen.get(known)}; one line per criterion`
+      );
+    }
+    seen.set(known, at);
+    lines.push({ criterion: known, weight: Number(weightRaw) });
+  }
+  if (!lines.length) {
+    throw new Error(`${file} carries no criterion lines \u2014 a rubric with no criteria scores nothing`);
+  }
+  return { lines };
+}
+var TIER_VALUE = { risk: 3, gap: 2, polish: 1 };
+var EFFORT_VALUE = { S: 3, M: 2, L: 1 };
+var CONFIDENCE_VALUE = { high: 3, medium: 2, low: 1 };
+function findingSubject(project, f) {
+  return {
+    id: `${project.name}:${f.id}`,
+    kind: "finding",
+    classId: f.id.split(":")[0] ?? f.id,
+    tier: f.tier,
+    effort: f.effort,
+    confidence: f.confidence,
+    projects: [project.name],
+    action: f.action ?? "",
+    evidence: f.evidence
+  };
+}
+function classSubject(classId, members) {
+  const pick = (order, at, dir) => {
+    const values = members.map((m) => order[at(m.finding)]);
+    const value = dir === 1 ? Math.max(...values) : Math.min(...values);
+    return Object.entries(order).find(([, v]) => v === value)[0];
+  };
+  const actions = [...new Set(members.map((m) => m.finding.action).filter(Boolean))].sort();
+  return {
+    id: `class:${classId}`,
+    kind: "class",
+    classId,
+    tier: pick(TIER_VALUE, (f) => f.tier, 1),
+    effort: pick(EFFORT_VALUE, (f) => f.effort, -1),
+    confidence: pick(CONFIDENCE_VALUE, (f) => f.confidence, -1),
+    projects: [...new Set(members.map((m) => m.project.name))].sort(),
+    action: actions.join("; "),
+    evidence: members.flatMap((m) => m.finding.evidence)
+  };
+}
+var CRITERION_VALUE = {
+  severity: (s) => TIER_VALUE[s.tier],
+  economy: (s) => EFFORT_VALUE[s.effort],
+  confidence: (s) => CONFIDENCE_VALUE[s.confidence],
+  breadth: (s) => Math.min(3, s.projects.length)
+};
+var FILENAME_RE = /^[^\s:]+\.[A-Za-z0-9]+$/;
+function extractFiles(evidence) {
+  const files = /* @__PURE__ */ new Set();
+  for (const line of evidence) {
+    const token = line.split(/[\s:]/)[0];
+    if (token && (token.includes("/") || FILENAME_RE.test(token))) files.add(token);
+  }
+  return [...files].sort();
+}
+function extractGates(files) {
+  return files.filter((f) => f.startsWith(".githooks/") || f.startsWith(".github/workflows/"));
+}
+function reversibility(files) {
+  if (!files.length) return "undetermined";
+  const generated = (f) => f.startsWith(".etymd/") || f.startsWith(".githooks/");
+  return files.every(generated) ? "regenerable" : "git-reversible";
+}
+function toProposal(s, rubric) {
+  const matched = [];
+  let score = 0;
+  for (const line of rubric.lines) {
+    const value = CRITERION_VALUE[line.criterion](s);
+    score += line.weight * value;
+    if (value >= 2) matched.push({ criterion: line.criterion, weight: line.weight, value });
+  }
+  const files = extractFiles(s.evidence);
+  return {
+    id: s.id,
+    schema: PROPOSAL_SCHEMA,
+    class: s.classId,
+    kind: s.kind,
+    projects: s.projects,
+    action: s.action,
+    effort: s.effort,
+    confidence: s.confidence,
+    score,
+    matched,
+    implications: {
+      projects: s.projects,
+      files,
+      gates: extractGates(files),
+      reversibility: reversibility(files)
+    }
+  };
+}
+function buildProposals(sweep, rubricName, rubric) {
+  const disclosures = [];
+  const personal = sweep.projects.filter((p) => p.profile === "personal");
+  const guarded = sweep.projects.filter((p) => p.profile !== "personal");
+  if (guarded.length) {
+    disclosures.push(
+      `guarded entries excluded from proposals: ${guarded.map((p) => p.name).sort().join(", ")}`
+    );
+  }
+  const notAudited = personal.filter((p) => !p.resolvedRoot || p.unresolved);
+  if (notAudited.length) {
+    disclosures.push(
+      `not audited, so not proposed: ${notAudited.map((p) => p.name).sort().join(", ")}`
+    );
+  }
+  const subjects = [];
+  for (const project of personal) {
+    for (const f of project.findings) {
+      if (f.kind === "improvement") subjects.push(findingSubject(project, f));
+    }
+  }
+  const byClass = /* @__PURE__ */ new Map();
+  for (const project of personal) {
+    for (const f of project.findings) {
+      const classId = f.id.split(":")[0] ?? f.id;
+      const entry = byClass.get(classId) ?? [];
+      entry.push({ project, finding: f });
+      byClass.set(classId, entry);
+    }
+  }
+  for (const [classId, members] of byClass) {
+    if (new Set(members.map((m) => m.project.name)).size >= 2) {
+      subjects.push(classSubject(classId, members));
+    }
+  }
+  const proposals = subjects.map((s) => toProposal(s, rubric)).sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+  return {
+    schema: PROPOSAL_SCHEMA,
+    manifest: sweep.manifest,
+    rubric: rubricName,
+    criteria: rubric.lines,
+    proposals,
+    disclosures: [
+      ...disclosures,
+      "implications.files are path-shaped tokens extracted from finding evidence \u2014 evidence lines carrying no path are not represented there"
+    ]
+  };
+}
+
+// src/commands/propose.ts
+async function readStoredSweep(abs) {
+  const raw = await readText(abs);
+  if (raw === null) throw new Error(`cannot read the stored sweep: ${abs}`);
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `${abs} is not valid JSON (${err instanceof Error ? err.message : String(err)})`
+    );
+  }
+  const rec = parsed;
+  if (typeof rec !== "object" || rec === null || rec.schema !== FLEET_JSON_SCHEMA || !Array.isArray(rec.projects)) {
+    throw new Error(
+      `${abs} is not a stored fleet sweep (schema ${FLEET_JSON_SCHEMA}) \u2014 write one with \`etymd fleet --json\``
+    );
+  }
+  return { manifest: rec.manifest ?? abs, projects: rec.projects };
+}
+async function run(opts) {
+  if (!opts.manifest && !opts.from) {
+    throw new Error(
+      "propose needs a sweep: pass --manifest <registry.json> (runs one now, read-only) or --from <fleet.json> (reads a stored `etymd fleet --json` output)"
+    );
+  }
+  if (opts.manifest && opts.from) {
+    throw new Error(
+      "--manifest and --from are alternatives \u2014 a fresh sweep or a stored one, not both"
+    );
+  }
+  const rubricPath = path.resolve(opts.cwd, opts.rubric);
+  const rubricText = await readText(rubricPath);
+  if (rubricText === null) throw new Error(`cannot read the rubric: ${rubricPath}`);
+  const rubric = parseRubric(rubricText, opts.rubric);
+  const swept = opts.from ? await readStoredSweep(path.resolve(opts.cwd, opts.from)) : await sweepFleet(await loadFleetManifest(path.resolve(opts.cwd, opts.manifest)));
+  const result = buildProposals(swept, opts.rubric, rubric);
+  if (opts.json) {
+    print(JSON.stringify(result, null, 2));
+    return;
+  }
+  render(result);
+}
+function render(result) {
+  section(
+    `Proposals ${theme.dim(`\xB7 ${path.basename(result.manifest)} \xB7 rubric ${result.rubric} (${result.criteria.map((l) => `${l.criterion}:${l.weight}`).join(", ")}) \xB7 ${result.proposals.length} proposal(s) \xB7 schema ${result.schema} (EXPERIMENTAL)`)}`
+  );
+  if (!result.proposals.length) {
+    print(`  ${theme.dim("nothing to propose \u2014 no improvement findings or recurring classes")}`);
+  }
+  for (const p of result.proposals) {
+    const who = p.kind === "class" ? `${p.class} ${theme.dim(`\u2014 class, ${p.projects.length}\xD7: ${p.projects.join(", ")}`)}` : `${p.id} ${theme.dim(`\u2014 ${p.projects.join(", ")}`)}`;
+    print(`  ${theme.info(String(p.score).padStart(3))}  ${who}`);
+    print(
+      `        ${theme.dim(`${p.effort} \xB7 ${p.confidence} \xB7 fired: ${p.matched.map((m) => `${m.criterion}(${m.value}/3)`).join(", ") || "\u2014"}`)}`
+    );
+    if (p.action) print(`        ${theme.dim(p.action)}`);
+    const im = p.implications;
+    print(
+      `        ${theme.dim(`implications: ${im.projects.length} project(s) \xB7 files: ${im.files.join(", ") || "\u2014"} \xB7 gates: ${im.gates.join(", ") || "\u2014"} \xB7 ${im.reversibility}`)}`
+    );
+  }
+  renderFleetNotes([], result.disclosures);
+}
+
+export { run };

package/dist/scan-5SC47FSM.js

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

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { print, renderFacts, theme } from './chunk-HI7NWPRA.js';
-import { scanProject } from './chunk-Y6RZRED3.js';
-import './chunk-DBWDMIYO.js';
+import { scanProject } from './chunk-446EZNAQ.js';
+import './chunk-BUMOGHQA.js';
 import { writeCachedFacts } from './chunk-P6ATKV2R.js';
 import './chunk-YQZDYDAK.js';
 import './chunk-4VPBP6K6.js';

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

@@ -6,17 +6,28 @@ import { promises } from 'fs';
 import path from 'path';
 
 var CLASS_DIRECTIVE = /^#[ \t]*class:[ \t]*(secret|vocabulary)\b/i;
-var MACHINE_PATH_RE = /\/(?:Users|home)\/[A-Za-z0-9._-]+\//;
+var MACHINE_PATH_RE = /(?:^|[\s"'=(\[:])\/(?:Users|home)\/[A-Za-z0-9._-]+\//;
 var ALLOW_MARKER = "allow-published-string";
 var ALLOW_FILE = ".etymd-screen-allow";
 var LEGACY_ALLOW_FILE = ".artifact-check-allow";
-var LABELED_LINE = /^(pattern|reason|date|author)[ \t]+(.*)$/;
+var LABELED_LINE = /^(pattern|generated|reason|date|author)[ \t]+(.*)$/;
+function compileLooseRegex(source) {
+  try {
+    return new RegExp(source, "i");
+  } catch {
+    return new RegExp(source.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+  }
+}
 function compileAllow(raw) {
-  const entries = [];
+  const lines = [];
+  const generated = [];
   let current = null;
+  let currentGen = null;
   const close = () => {
-    if (current) entries.push(current);
+    if (current) lines.push(current);
+    if (currentGen) generated.push(currentGen);
     current = null;
+    currentGen = null;
   };
   for (const rawLine of raw.split("\n")) {
     const l = rawLine.trim();
@@ -26,29 +37,26 @@ function compileAllow(raw) {
       const [, label = "", value = ""] = labeled;
       if (label === "pattern") {
         close();
-        current = makeAllowEntry(value);
+        current = { pattern: compileLooseRegex(value), isSelfName: false };
+      } else if (label === "generated") {
+        close();
+        currentGen = { path: compileLooseRegex(value) };
       } else if (current) {
         if (label === "reason") current.reason = value.trim();
         else if (label === "date") current.date = value.trim();
         else current.author = value.trim();
+      } else if (currentGen) {
+        if (label === "reason") currentGen.reason = value.trim();
+        else if (label === "date") currentGen.date = value.trim();
+        else currentGen.author = value.trim();
       }
     } else {
       close();
-      current = makeAllowEntry(l);
+      current = { pattern: compileLooseRegex(l), isSelfName: false };
     }
   }
   close();
-  return entries;
-}
-function makeAllowEntry(patternStr) {
-  try {
-    return { pattern: new RegExp(patternStr, "i"), isSelfName: false };
-  } catch {
-    return {
-      pattern: new RegExp(patternStr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i"),
-      isSelfName: false
-    };
-  }
+  return { lines, generated };
 }
 function compileOnePattern(l) {
   try {
@@ -117,11 +125,11 @@ async function selfIdentities(cwd) {
   names.delete("");
   return [...names];
 }
-function screenText(text, file, patterns, allow = [], upstreamOwned = false) {
+function screenText(text, file, patterns, allow = [], upstreamOwned = false, generatedData = false) {
   const classed = patterns.map(
     (p) => p instanceof RegExp ? { re: p, cls: "secret" } : p
   );
-  const active = upstreamOwned ? classed.filter((p) => p.cls === "secret") : classed;
+  const active = upstreamOwned || generatedData ? classed.filter((p) => p.cls === "secret") : classed;
   const hits = [];
   const lines = text.split("\n");
   for (const [i, line] of lines.entries()) {
@@ -213,9 +221,9 @@ async function run(opts) {
   }
   const usingLegacy = !await pathExists(path.join(opts.cwd, ALLOW_FILE)) && await pathExists(path.join(opts.cwd, LEGACY_ALLOW_FILE));
   const allowRaw = usingLegacy ? await readText(path.join(opts.cwd, LEGACY_ALLOW_FILE)) : await readText(path.join(opts.cwd, ALLOW_FILE));
-  const allowEntries = allowRaw ? compileAllow(allowRaw) : [];
+  const allowFile = allowRaw ? compileAllow(allowRaw) : { lines: [], generated: [] };
   const selves = await selfIdentities(opts.cwd);
-  const validatedEntries = allowEntries.filter((entry) => {
+  const validatedEntries = allowFile.lines.filter((entry) => {
     if (entry.isSelfName) return true;
     if (isSelfName(entry.pattern, selves)) {
       entry.isSelfName = true;
@@ -233,6 +241,17 @@ async function run(opts) {
     return true;
   });
   const allow = validatedEntries;
+  const generatedPaths = allowFile.generated.filter((entry) => {
+    if (entry.reason && entry.date && entry.author) return true;
+    print(
+      `  ${glyph.partial} ${theme.warn(`Missing provenance for generated-path exemption`)} ${theme.dim(String(entry.path))}`
+    );
+    print(
+      `    ${theme.dim("Format: a `generated` line, then `reason`, `date`, `author` lines \u2014 all four required")}`
+    );
+    return false;
+  });
+  const isGenerated = (rel) => generatedPaths.some((e) => e.path.test(rel));
   const active = selves.length ? patterns.filter((p) => !isSelfName(p.re, selves)) : patterns;
   const hasVocab = active.some((p) => p.cls === "vocabulary");
   const upstreamRemote = hasVocab && (opts.scope === "staged" || opts.scope === "tree") ? opts.upstream ?? await git(opts.cwd, ["config", "--get", "etymd.upstream"]) ?? void 0 : void 0;
@@ -263,6 +282,7 @@ async function run(opts) {
   const hits = [];
   let scanned = 0;
   let skippedBinary = 0;
+  const generatedExempted = [];
   if (opts.scope === "message") {
     const file = opts.target;
     if (!file) throw new Error("--message needs the message file path (the commit-msg hook's $1)");
@@ -284,7 +304,10 @@ async function run(opts) {
         continue;
       }
       scanned++;
-      hits.push(...screenText(raw, path.relative(dir, f), active, allow));
+      const rel = path.relative(dir, f);
+      const gen = isGenerated(rel);
+      if (gen) generatedExempted.push(rel);
+      hits.push(...screenText(raw, rel, active, allow, false, gen));
     }
   } else {
     const listing = opts.scope === "tree" ? await git(opts.cwd, ["ls-files"]) : await git(opts.cwd, ["diff", "--cached", "--name-only", "--diff-filter=ACM"]);
@@ -300,7 +323,9 @@ async function run(opts) {
         continue;
       }
       scanned++;
-      hits.push(...screenText(raw, rel, active, allow, isUpstreamOwned(rel)));
+      const gen = isGenerated(rel);
+      if (gen) generatedExempted.push(rel);
+      hits.push(...screenText(raw, rel, active, allow, isUpstreamOwned(rel), gen));
     }
   }
   if (upstreamNote) {
@@ -308,9 +333,16 @@ async function run(opts) {
   }
   section(
     `Content screen ${theme.dim(
-      `\xB7 ${opts.scope} \xB7 ${scanned} file(s)${skippedBinary ? ` \xB7 ${skippedBinary} binary skipped` : ""}`
+      `\xB7 ${opts.scope} \xB7 ${scanned} file(s)${skippedBinary ? ` \xB7 ${skippedBinary} binary skipped` : ""}${generatedExempted.length ? ` \xB7 ${generatedExempted.length} generated exempt` : ""}`
     )}`
   );
+  if (generatedExempted.length) {
+    print(
+      `  ${glyph.partial} ${theme.dim(
+        `generated data, vocabulary-class dropped (secret-class and machine paths still screened): ${generatedExempted.join(", ")}`
+      )}`
+    );
+  }
   if (!hits.length) {
     print(`  ${glyph.ok} ${theme.dim("clean")}`);
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "etymd",
-  "version": "0.15.0",
+  "version": "0.17.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",
@@ -19,11 +19,11 @@
   "author": "Alkis Yuv",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/triartleet/etymd.git"
+    "url": "git+https://github.com/fleetorders/etymd.git"
   },
-  "homepage": "https://github.com/triartleet/etymd#readme",
+  "homepage": "https://github.com/fleetorders/etymd#readme",
   "bugs": {
-    "url": "https://github.com/triartleet/etymd/issues"
+    "url": "https://github.com/fleetorders/etymd/issues"
   },
   "type": "module",
   "bin": {

package/dist/scan-W4US23MU.js

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