etymd 0.14.0 → 0.16.0

package/dist/index.js

@@ -30,8 +30,8 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "etymd",
-      version: "0.14.0",
-      description: "Keep your agent instructions true \u2014 verify AGENTS.md, CLAUDE.md, rules & skills against the actual repo, with drift caught over time and a regression ledger.",
+      version: "0.16.0",
+      description: "Keep your agent instructions true \u2014 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",
@@ -49,11 +49,11 @@ var init_package = __esm({
       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: {
@@ -1171,7 +1171,7 @@ function generatePreCommitHook(selfBuild = false) {
 
 ${localHookCall("pre-commit")}
 
-# Content screen \u2014 staged file bytes. Refuses to commit environment, employer or identity
+# Content screen \u2014 staged file bytes. Refuses to commit environment, guarded-side or identity
 # detail into a repo whose history is (or could become) public. The checker and its patterns
 # are machine-local by design, so this is a NO-OP wherever no checker is installed: safe to
 # commit anywhere, active only where you opted in.
@@ -2324,6 +2324,8 @@ var gateIntegrityLens = {
 init_version();
 init_config();
 init_facts();
+
+// src/lenses/instruction-truth/checks.ts
 init_util();
 
 // src/lenses/state-freshness.ts
@@ -2760,6 +2762,13 @@ 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()));
 }
+var NAMESPACE_IDENT = "[A-Za-z][A-Za-z0-9-]{0,15}";
+var NAMESPACE_STOP = new Set(
+  "note notes see warning caution caveat caveats example examples ex eg ie nb ps re per file files path paths hint tip tips todo fixme step steps rule rules ref refs fact facts output outputs input inputs result results summary status overview next prev then thus hence plus goal goals spec specs context".split(" ")
+);
+function isNamespace(ident) {
+  return Boolean(ident) && !NAMESPACE_STOP.has(ident.toLowerCase());
+}
 function claimContext(text, index) {
   const start = text.lastIndexOf("\n", index) + 1;
   const endRaw = text.indexOf("\n", index);
@@ -2779,8 +2788,9 @@ ${line}`;
   }
   return line;
 }
-function extractPathClaims(text) {
+function extractPathClaims(text, opts = {}) {
   const prospectiveOnly = /* @__PURE__ */ new Map();
+  const namespacedOnly = /* @__PURE__ */ new Map();
   const placeholder = /* @__PURE__ */ new Set();
   for (const m of text.matchAll(/`([^`\n]+)`/g)) {
     const token = m[1].trim();
@@ -2802,14 +2812,21 @@ function extractPathClaims(text) {
     }
     const prospective2 = CREATION_CONTEXT_RE.test(claimContext(text, m.index ?? 0));
     prospectiveOnly.set(claim, (prospectiveOnly.get(claim) ?? true) && prospective2);
+    if (opts.namespaces) {
+      const nsLead = new RegExp(`(${NAMESPACE_IDENT}):[ \\t]*$`).exec(text.slice(0, m.index ?? 0));
+      const prefixed = isNamespace(nsLead?.[1]);
+      namespacedOnly.set(claim, (namespacedOnly.get(claim) ?? true) && prefixed);
+    }
   }
   const paths = [];
   const prospective = [];
+  const namespaced = [];
   for (const [claim, only] of prospectiveOnly) {
     if (only) prospective.push(claim);
+    else if (namespacedOnly.get(claim)) namespaced.push(claim);
     else paths.push(claim);
   }
-  return { paths, prospective, placeholder: [...placeholder] };
+  return { paths, prospective, namespaced, placeholder: [...placeholder] };
 }
 var LOCAL_REF_LEADINS = new Set(
   "decision decisions entry entries ruling rulings record records ledger id ids item items see per in of on at by to as is was are were the a an and or but not with under over from via vs than after before since between through against latest newest earliest only also still now supersedes superseded superseding amends amended extends extended cites cited citing adds added adding wrote written writes locked locks closed closes opened opens resolves resolved reopened recorded number numbers".split(" ")
@@ -2871,6 +2888,214 @@ function extractDocRefs(text) {
   return { refs, tildeSkipped };
 }
 
+// src/lenses/instruction-truth/checks.ts
+async function buildTruthEnv(root, facts) {
+  const knownScripts = new Set(Object.keys(facts.commands.raw));
+  for (const pkg of facts.packages) {
+    const pkgJson = await readJson(
+      path2.join(root, pkg.dir, "package.json")
+    );
+    for (const key of Object.keys(pkgJson?.scripts ?? {})) knownScripts.add(key);
+  }
+  const bases = [root, ...facts.packages.map((p) => path2.join(root, p.dir))];
+  const pathResolves = async (claim) => {
+    for (const base of bases) {
+      if (await pathExists(path2.join(base, claim))) return true;
+      if (await pathExists(path2.join(base, "src", claim))) return true;
+      if (await pathExists(path2.join(base, "scripts", claim))) return true;
+    }
+    return false;
+  };
+  const binResolves = async (name) => {
+    for (const base of bases) {
+      if (await pathExists(path2.join(base, "node_modules", ".bin", name))) return true;
+    }
+    return false;
+  };
+  const nodeModulesInstalled = await pathExists(path2.join(root, "node_modules"));
+  const manifestExists = await pathExists(path2.join(root, "package.json")) || facts.packages.length > 0;
+  return {
+    root,
+    facts,
+    knownScripts,
+    nodeModulesInstalled,
+    manifestExists,
+    bases,
+    pathResolves,
+    binResolves
+  };
+}
+function emptyCounters() {
+  return {
+    filteredSkipped: 0,
+    tildeSkipped: 0,
+    binaryResolved: 0,
+    unverifiableCommands: 0,
+    gitignoredSkipped: 0,
+    prospectiveSkipped: 0,
+    placeholderSkipped: 0,
+    qualifiedRefsSkipped: 0,
+    unresolvableRefs: 0,
+    namespacedSkipped: 0,
+    outsideRepoSkipped: 0
+  };
+}
+async function checkTextClaims(env, file, opts, counters) {
+  const findings = [];
+  const disclosures = [];
+  const examined = [];
+  const subject = opts.subject ?? file.path;
+  const { scripts: claimed, filteredSkipped } = extractCommandClaims(file.text);
+  counters.filteredSkipped += filteredSkipped;
+  for (const [script, raw] of claimed) {
+    if (env.knownScripts.has(script)) {
+      examined.push({ kind: "script", value: script, exists: true });
+      continue;
+    }
+    if (await env.binResolves(script)) {
+      counters.binaryResolved += 1;
+      examined.push({ kind: "script", value: script, exists: true });
+      continue;
+    }
+    if (!env.nodeModulesInstalled && env.manifestExists) {
+      counters.unverifiableCommands += 1;
+      examined.push({ kind: "script", value: script, exists: null });
+      continue;
+    }
+    examined.push({ kind: "script", value: script, exists: false });
+    findings.push({
+      lens: opts.lensId,
+      id: `${opts.lensId}/stale-command:${file.path}:${script}`,
+      tier: "risk",
+      claim: `${subject} tells agents to run \`${script}\` \u2014 no such script exists`,
+      evidence: [`${file.path}: \`${raw}\``, "package.json scripts (root + workspaces)"],
+      why: opts.whyCommand ?? "An agent following this instruction runs a command that fails \u2014 or silently skips the check it was meant to run.",
+      action: opts.actionCommand ?? "Update the instruction to the current script name (or restore the script).",
+      effort: "S",
+      confidence: "high"
+    });
+  }
+  const { paths, prospective, placeholder, namespaced } = extractPathClaims(file.text, {
+    namespaces: opts.treatNamespacedPrefixes
+  });
+  counters.prospectiveSkipped += prospective.length;
+  counters.placeholderSkipped += placeholder.length;
+  counters.namespacedSkipped += namespaced.length;
+  const missing = [];
+  for (const claim of paths) {
+    if (await env.pathResolves(claim)) examined.push({ kind: "path", value: claim, exists: true });
+    else missing.push(claim);
+  }
+  const ignoredOut = missing.length ? await git(env.root, ["check-ignore", ...missing]) : null;
+  const gitignored = new Set((ignoredOut ?? "").split("\n").filter(Boolean));
+  let pathFindings = 0;
+  for (const claim of missing) {
+    if (opts.rootedFirstSegments && !opts.rootedFirstSegments.has(claim.split("/")[0] ?? claim)) {
+      counters.outsideRepoSkipped += 1;
+      examined.push({ kind: "path", value: claim, exists: null });
+      continue;
+    }
+    if (gitignored.has(claim)) {
+      counters.gitignoredSkipped += 1;
+      examined.push({ kind: "path", value: claim, exists: null });
+      continue;
+    }
+    examined.push({ kind: "path", value: claim, exists: false });
+    if (pathFindings >= opts.maxPathFindings) {
+      if (pathFindings === opts.maxPathFindings) {
+        disclosures.push(
+          `${file.path}: more than ${opts.maxPathFindings} missing-path claims \u2014 truncated.`
+        );
+        pathFindings += 1;
+      }
+      continue;
+    }
+    pathFindings += 1;
+    findings.push({
+      lens: opts.lensId,
+      id: `${opts.lensId}/stale-path:${file.path}:${claim}`,
+      tier: opts.missingPathTier,
+      claim: `${subject} references \`${claim}\` \u2014 it does not exist in the repo`,
+      evidence: [file.path, `missing: ${claim}`],
+      why: opts.whyPath ?? "Agents navigate by these references; a dead path wastes a lookup and erodes trust in the rest of the file.",
+      action: opts.actionPath ?? "Fix or remove the reference.",
+      effort: "S",
+      confidence: "medium"
+    });
+  }
+  return { findings, disclosures, examined };
+}
+async function checkDocRefs(env, file, lensId, counters, subject = file.path) {
+  const findings = [];
+  const examined = [];
+  const { refs, tildeSkipped } = extractDocRefs(file.text);
+  counters.tildeSkipped += tildeSkipped;
+  for (const ref of refs) {
+    const exists = await pathExists(path2.join(env.root, ref));
+    examined.push({ kind: "doc", value: ref, exists });
+    if (exists) continue;
+    findings.push({
+      lens: lensId,
+      id: `${lensId}/dangling-ref:${file.path}:${ref}`,
+      tier: "gap",
+      claim: `${subject} 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"
+    });
+  }
+  return { findings, examined };
+}
+async function loadDecisionLedger(root, facts) {
+  let ids = null;
+  const sources = [];
+  for (const artifact of facts.artifacts) {
+    if (artifact.kind !== "decisions" || !artifact.exists) continue;
+    const text = await readText(path2.join(root, artifact.path));
+    if (text === null) continue;
+    const entries = parseDecisionEntries(text);
+    if (!entries.length) continue;
+    ids ??= /* @__PURE__ */ new Set();
+    for (const entry of entries) ids.add(entry.num);
+    sources.push(artifact.path);
+  }
+  return { ids, sources };
+}
+function checkDecisionRefs(file, ledger, opts, counters) {
+  const findings = [];
+  const examined = [];
+  const subject = opts.subject ?? file.path;
+  const { refs, qualifiedSkipped } = extractDecisionRefs(file.text);
+  counters.qualifiedRefsSkipped += qualifiedSkipped;
+  if (!refs.size) return { findings, examined };
+  if (!ledger.ids) {
+    counters.unresolvableRefs += refs.size;
+    for (const asWritten of refs.values()) {
+      examined.push({ kind: "decision", value: asWritten, exists: null });
+    }
+    return { findings, examined };
+  }
+  for (const [num, asWritten] of refs) {
+    const exists = ledger.ids.has(num);
+    examined.push({ kind: "decision", value: asWritten, exists });
+    if (exists) continue;
+    findings.push({
+      lens: opts.lensId,
+      id: `${opts.lensId}/dead-decision-ref:${file.path}:${asWritten}`,
+      tier: "gap",
+      claim: `${subject} cites ${asWritten} \u2014 no such entry exists in ${ledger.sources.join(", ")}`,
+      evidence: [file.path, `${ledger.sources.join(", ")}: no ${asWritten} entry`],
+      why: opts.why ?? "A state doc is read as ground truth on return; a citation the decision record cannot back sends readers to a ruling that was never written.",
+      action: opts.action ?? "Fix the reference \u2014 or record the missing decision.",
+      effort: "S",
+      confidence: "medium"
+    });
+  }
+  return { findings, examined };
+}
+
 // src/lenses/instruction-truth/lens.ts
 var LENS_ID4 = "instruction-truth";
 var MAX_PATH_FINDINGS_PER_FILE = 15;
@@ -2965,99 +3190,17 @@ var instructionTruthLens = {
         })
       );
     }
-    const knownScripts = new Set(Object.keys(facts.commands.raw));
-    for (const pkg of facts.packages) {
-      const pkgJson = await readJson(
-        path2.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) => path2.join(root, p.dir))];
-      for (const base of bases) {
-        if (await pathExists(path2.join(base, claim))) return true;
-        if (await pathExists(path2.join(base, "src", claim))) return true;
-        if (await pathExists(path2.join(base, "scripts", claim))) return true;
-      }
-      return false;
+    const env = await buildTruthEnv(root, facts);
+    const counters = emptyCounters();
+    const claimOpts = {
+      lensId: LENS_ID4,
+      missingPathTier: "gap",
+      maxPathFindings: MAX_PATH_FINDINGS_PER_FILE
     };
-    const binResolves = async (name) => {
-      const bases = [root, ...facts.packages.map((p) => path2.join(root, p.dir))];
-      for (const base of bases) {
-        if (await pathExists(path2.join(base, "node_modules", ".bin", name))) return true;
-      }
-      return false;
-    };
-    const nodeModulesInstalled = await pathExists(path2.join(root, "node_modules"));
-    const manifestExists = await pathExists(path2.join(root, "package.json")) || facts.packages.length > 0;
-    let totalFilteredSkipped = 0;
-    let totalTildeSkipped = 0;
-    let binaryResolved = 0;
-    let unverifiableCommands = 0;
-    let gitignoredSkipped = 0;
-    let prospectiveSkipped = 0;
-    let placeholderSkipped = 0;
     const auditClaims = async (file) => {
-      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 && manifestExists) {
-          unverifiableCommands += 1;
-          continue;
-        }
-        findings.push(
-          finding2({
-            id: `${LENS_ID4}/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_ID4}/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"
-          })
-        );
-      }
+      const result = await checkTextClaims(env, file, claimOpts, counters);
+      findings.push(...result.findings);
+      disclosures.push(...result.disclosures);
     };
     for (const file of files) {
       await auditClaims(file);
@@ -3081,66 +3224,15 @@ var instructionTruthLens = {
           break;
         }
       }
-      const { refs: docRefs, tildeSkipped } = extractDocRefs(file.text);
-      totalTildeSkipped += tildeSkipped;
-      for (const ref of docRefs) {
-        if (await pathExists(path2.join(root, ref))) continue;
-        findings.push(
-          finding2({
-            id: `${LENS_ID4}/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"
-          })
-        );
-      }
+      findings.push(...(await checkDocRefs(env, file, LENS_ID4, counters)).findings);
     }
     const auditedPaths = new Set(files.map((f) => f.path));
     const stateDocs = await listStateDocuments(root, facts);
-    let qualifiedRefsSkipped = 0;
-    let unresolvableRefs = 0;
-    let ledgerIds = null;
-    const ledgerSources = [];
-    if (stateDocs.length) {
-      for (const artifact of facts.artifacts) {
-        if (artifact.kind !== "decisions" || !artifact.exists) continue;
-        const text = await readText(path2.join(root, artifact.path));
-        if (text === null) continue;
-        const entries = parseDecisionEntries(text);
-        if (!entries.length) continue;
-        ledgerIds ??= /* @__PURE__ */ new Set();
-        for (const entry of entries) ledgerIds.add(entry.num);
-        ledgerSources.push(artifact.path);
-      }
-    }
+    const ledger = stateDocs.length ? await loadDecisionLedger(root, facts) : { ids: null, sources: [] };
+    const ledgerSources = ledger.sources;
     for (const doc of stateDocs) {
       if (!auditedPaths.has(doc.path)) await auditClaims(doc);
-      const { refs, qualifiedSkipped } = extractDecisionRefs(doc.text);
-      qualifiedRefsSkipped += qualifiedSkipped;
-      if (!refs.size) continue;
-      if (!ledgerIds) {
-        unresolvableRefs += refs.size;
-        continue;
-      }
-      for (const [num, asWritten] of refs) {
-        if (ledgerIds.has(num)) continue;
-        findings.push(
-          finding2({
-            id: `${LENS_ID4}/dead-decision-ref:${doc.path}:${asWritten}`,
-            tier: "gap",
-            claim: `${doc.path} cites ${asWritten} \u2014 no such entry exists in ${ledgerSources.join(", ")}`,
-            evidence: [doc.path, `${ledgerSources.join(", ")}: no ${asWritten} entry`],
-            why: "A state doc is read as ground truth on return; a citation the decision record cannot back sends readers to a ruling that was never written.",
-            action: "Fix the reference \u2014 or record the missing decision.",
-            effort: "S",
-            confidence: "medium"
-          })
-        );
-      }
+      findings.push(...checkDecisionRefs(doc, ledger, { lensId: LENS_ID4 }, counters).findings);
     }
     if (ctx.baseline) {
       findings.push(
@@ -3163,34 +3255,34 @@ var instructionTruthLens = {
         "No committed baseline (.etymd/baseline.json) \u2014 drift over time is not measurable; run `etymd init` to approve one."
       );
     }
-    if (binaryResolved) {
+    if (counters.binaryResolved) {
       disclosures.push(
-        `${binaryResolved} command claim(s) are installed binaries (node_modules/.bin), not package scripts \u2014 treated as true.`
+        `${counters.binaryResolved} command claim(s) are installed binaries (node_modules/.bin), not package scripts \u2014 treated as true.`
       );
     }
-    if (unverifiableCommands) {
+    if (counters.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.`
+        `node_modules is not installed \u2014 ${counters.unverifiableCommands} command claim(s) matching no package script could not be checked against installed binaries; skipped, not flagged.`
       );
     }
-    if (gitignoredSkipped) {
+    if (counters.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.`
+        `${counters.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) {
+    if (counters.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.`
+        `${counters.prospectiveSkipped} path claim(s) sit in create-this prose (the file instructs generating them) \u2014 forward-looking, not stale; skipped, not flagged.`
       );
     }
-    if (placeholderSkipped) {
+    if (counters.placeholderSkipped) {
       disclosures.push(
-        `${placeholderSkipped} path claim(s) are naming stand-ins (e.g. \`my-custom-skill\`) rather than real references; skipped, not flagged.`
+        `${counters.placeholderSkipped} path claim(s) are naming stand-ins (e.g. \`my-custom-skill\`) rather than real references; skipped, not flagged.`
       );
     }
-    if (totalTildeSkipped) {
+    if (counters.tildeSkipped) {
       disclosures.push(
-        `${totalTildeSkipped} 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.`
+        `${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 (stateDocs.length) {
@@ -3198,14 +3290,14 @@ var instructionTruthLens = {
         `Checked ${stateDocs.length} state document(s) for command, path, and decision-reference claims (same skip classes as instruction files); decision ids resolved against ${ledgerSources.length ? ledgerSources.join(", ") : "nothing \u2014 no decisions file with D-NNN entries"}.`
       );
     }
-    if (qualifiedRefsSkipped) {
+    if (counters.qualifiedRefsSkipped) {
       disclosures.push(
-        `${qualifiedRefsSkipped} decision reference(s) name another record (e.g. a fleet-level ledger) \u2014 not claims about this repo's decisions; skipped, not flagged.`
+        `${counters.qualifiedRefsSkipped} decision reference(s) name another record (e.g. a fleet-level ledger) \u2014 not claims about this repo's decisions; skipped, not flagged.`
       );
     }
-    if (unresolvableRefs) {
+    if (counters.unresolvableRefs) {
       disclosures.push(
-        `${unresolvableRefs} decision reference(s) could not be resolved \u2014 no decisions file with \`## D-NNN\` entries; skipped, not flagged.`
+        `${counters.unresolvableRefs} decision reference(s) could not be resolved \u2014 no decisions file with \`## D-NNN\` entries; skipped, not flagged.`
       );
     }
     if (excluded.length) {
@@ -3220,7 +3312,7 @@ var instructionTruthLens = {
       );
     }
     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; doc mentions inside \`~/\` home paths skipped; framework-pattern staleness not checked.`
+      `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 (${counters.filteredSkipped}); 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; doc mentions inside \`~/\` home paths skipped; framework-pattern staleness not checked.`
     );
     return {
       lens: LENS_ID4,
@@ -3402,14 +3494,14 @@ function expandTilde(p) {
   if (p.startsWith("~/")) return path2.join(os.homedir(), p.slice(2));
   return p;
 }
-var REBUILD_RECIPE = 'rebuild it beside the manifest: {"machineProfile":"corp","dirs":{"<name>":"~/path/to/worktree"}}';
+var REBUILD_RECIPE = 'rebuild it beside the manifest: {"machineProfile":"guarded","dirs":{"<name>":"~/path/to/worktree"}}';
 var SAFE_NAME = /^[^\s/\\:.][^\s/\\:]*$/;
 function rejectUnsafeName(name, where, manifest, manifestFile) {
   if (SAFE_NAME.test(name)) return false;
   manifest.problems.push({
     kind: "bad-shape",
     file: manifestFile,
-    detail: `${where} name ${JSON.stringify(name)} is not a single path-safe segment \u2014 entry skipped (names build finding ids and corp/<name>/ persistence paths)`
+    detail: `${where} name ${JSON.stringify(name)} is not a single path-safe segment \u2014 entry skipped (names build finding ids and guarded/<name>/ persistence paths)`
   });
   return true;
 }
@@ -3450,7 +3542,7 @@ async function readLocal(localPath, problems) {
   }
 }
 function loadRegistryEntries(projects, manifest, manifestFile) {
-  const corpNames = [];
+  const guardedNames = [];
   for (const [i, rawEntry] of projects.entries()) {
     const rec = asRecord(rawEntry);
     const name = rec ? asString(rec.name) : void 0;
@@ -3463,8 +3555,8 @@ function loadRegistryEntries(projects, manifest, manifestFile) {
       continue;
     }
     if (rejectUnsafeName(name, `projects[${i}]`, manifest, manifestFile)) continue;
-    const profile = rec.profile === "corp" ? "corp" : "personal";
-    if (rec.profile !== void 0 && rec.profile !== "corp" && rec.profile !== "personal") {
+    const profile = rec.profile === "guarded" ? "guarded" : "personal";
+    if (rec.profile !== void 0 && rec.profile !== "guarded" && rec.profile !== "personal") {
       manifest.problems.push({
         kind: "bad-shape",
         file: manifestFile,
@@ -3502,12 +3594,12 @@ function loadRegistryEntries(projects, manifest, manifestFile) {
       contract,
       links: asStringMap(rec.links)
     };
-    if (entry.profile === "corp" || entry.private) {
-      corpNames.push(name);
+    if (entry.profile === "guarded" || entry.private) {
+      guardedNames.push(name);
       if (!manifest.localPresent) {
         entry.unresolved = `registry.local.json is absent \u2014 ${REBUILD_RECIPE}`;
       } else if (manifest.machineProfile === "personal") {
-        entry.unresolved = 'corp entries do not resolve under machineProfile "personal" \u2014 absent on this machine by design';
+        entry.unresolved = 'guarded entries do not resolve under machineProfile "personal" \u2014 absent on this machine by design';
       } else {
         const dir = manifest.localDirs[name];
         if (!dir) {
@@ -3523,11 +3615,11 @@ function loadRegistryEntries(projects, manifest, manifestFile) {
     }
     manifest.entries.push(entry);
   }
-  if (corpNames.length && !manifest.localPresent) {
+  if (guardedNames.length && !manifest.localPresent) {
     manifest.problems.push({
       kind: "local-missing",
       file: path2.basename(manifest.localPath),
-      detail: `${corpNames.length} corp/private entr${corpNames.length === 1 ? "y" : "ies"} (${corpNames.join(", ")}) cannot resolve without it \u2014 ${REBUILD_RECIPE}`
+      detail: `${guardedNames.length} guarded/private entr${guardedNames.length === 1 ? "y" : "ies"} (${guardedNames.join(", ")}) cannot resolve without it \u2014 ${REBUILD_RECIPE}`
     });
   }
 }
@@ -3576,7 +3668,7 @@ async function loadFleetManifest(manifestPath) {
     shape: "registry",
     manifestPath: abs,
     dir,
-    corpHosts: [],
+    guardedHosts: [],
     labels: {},
     localDirs: {},
     localPath: path2.join(dir, "registry.local.json"),
@@ -3609,8 +3701,8 @@ async function loadFleetManifest(manifestPath) {
     manifest.localPresent = local.present;
     manifest.localDirs = asStringMap(local.data.dirs);
     manifest.labels = asStringMap(local.data.labels);
-    manifest.corpHosts = Array.isArray(local.data.corpHosts) ? local.data.corpHosts.filter((h) => typeof h === "string") : [];
-    manifest.machineProfile = local.data.machineProfile === "corp" || local.data.machineProfile === "personal" ? local.data.machineProfile : void 0;
+    manifest.guardedHosts = Array.isArray(local.data.guardedHosts) ? local.data.guardedHosts.filter((h) => typeof h === "string") : [];
+    manifest.machineProfile = local.data.machineProfile === "guarded" || local.data.machineProfile === "personal" ? local.data.machineProfile : void 0;
     const rootRaw = asString(local.data.root) ?? asString(parsed.root);
     if (rootRaw) manifest.root = path2.resolve(dir, expandTilde(rootRaw));
     const orientationRec = asRecord(parsed.orientation);
@@ -3653,10 +3745,136 @@ async function loadFleetManifest(manifestPath) {
 init_config();
 init_facts();
 init_util();
+
+// src/engine/milestones.ts
+var MILESTONE_COLUMNS = [
+  "id",
+  "milestone",
+  "goal",
+  "status",
+  "next",
+  "effort",
+  "depends-on"
+];
+var MILESTONE_GOALS = ["1", "2", "3"];
+var MILESTONE_STATUSES = ["planned", "active", "blocked", "done"];
+var MILESTONE_EFFORTS = ["S", "M", "L"];
+var NONE_MARKERS = /* @__PURE__ */ new Set(["", "\u2014", "-", "\u2013", "none"]);
+function splitRow(line) {
+  const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+  return trimmed.split("|").map((c) => c.trim());
+}
+function isSeparatorRow(line) {
+  const cells = splitRow(line);
+  return cells.length > 0 && cells.every((c) => /^:?-{1,}:?$/.test(c));
+}
+function firstTable(lines, startLine) {
+  for (let i = startLine; i < lines.length - 1; i++) {
+    const line = lines[i] ?? "";
+    const next = lines[i + 1] ?? "";
+    if (!line.trim().startsWith("|") || !isSeparatorRow(next)) continue;
+    const header = splitRow(line).map((h) => h.toLowerCase());
+    const rows = [];
+    for (let j = i + 2; j < lines.length; j++) {
+      const body = lines[j] ?? "";
+      if (!body.trim().startsWith("|")) break;
+      rows.push({ line: j + 1, cells: splitRow(body) });
+    }
+    return { header, rows, headerLine: i + 1 };
+  }
+  return null;
+}
+function parseList(cell) {
+  if (NONE_MARKERS.has(cell.trim().toLowerCase())) return [];
+  return cell.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function checkColumns(table, expected, problems) {
+  const got = table.header.join(" | ");
+  const want = expected.join(" | ");
+  if (got !== want) {
+    problems.push(
+      `line ${table.headerLine}: table columns are \`${got}\`; the standard is \`${want}\``
+    );
+    return false;
+  }
+  return true;
+}
+function checkVocabulary(line, field, value, allowed, problems) {
+  if (allowed.includes(value)) return true;
+  problems.push(
+    `line ${line}: ${field} is \`${value}\`; allowed: ${allowed.map((a) => `\`${a}\``).join(", ")}`
+  );
+  return false;
+}
+function parseMilestones(text) {
+  const problems = [];
+  const lines = text.split(/\r?\n/);
+  const headingIdx = lines.findIndex((l) => /^#\s/.test(l));
+  if (headingIdx === -1 || lines[headingIdx]?.trim() !== "# Milestones") {
+    problems.push(
+      headingIdx === -1 ? "no heading: the file must start with `# Milestones`" : `line ${headingIdx + 1}: first heading is \`${lines[headingIdx]?.trim()}\`; it must be \`# Milestones\``
+    );
+  }
+  const table = firstTable(lines, headingIdx === -1 ? 0 : headingIdx + 1);
+  if (!table) {
+    problems.push(
+      `no milestones table: expected \`| ${MILESTONE_COLUMNS.join(" | ")} |\` after the heading`
+    );
+    return { rows: [], problems };
+  }
+  if (!checkColumns(table, MILESTONE_COLUMNS, problems)) return { rows: [], problems };
+  const rows = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const { line, cells } of table.rows) {
+    if (cells.length !== MILESTONE_COLUMNS.length) {
+      problems.push(`line ${line}: ${cells.length} cells, expected ${MILESTONE_COLUMNS.length}`);
+      continue;
+    }
+    const [id, milestone, goal, status, next, effort, deps] = cells;
+    let ok = true;
+    if (!/^M\d+$/.test(id)) {
+      problems.push(`line ${line}: id \`${id}\` is not \`M<number>\``);
+      ok = false;
+    } else if (ids.has(id)) {
+      problems.push(`line ${line}: id \`${id}\` is used twice`);
+      ok = false;
+    }
+    if (!milestone) {
+      problems.push(`line ${line}: milestone title is empty`);
+      ok = false;
+    }
+    if (!next) {
+      problems.push(`line ${line}: next step is empty \u2014 a milestone without a next step is a wish`);
+      ok = false;
+    }
+    ok = checkVocabulary(line, "goal", goal, MILESTONE_GOALS, problems) && ok;
+    ok = checkVocabulary(line, "status", status, MILESTONE_STATUSES, problems) && ok;
+    ok = checkVocabulary(line, "effort", effort, MILESTONE_EFFORTS, problems) && ok;
+    if (!ok) continue;
+    ids.add(id);
+    rows.push({
+      id,
+      milestone,
+      goal,
+      status,
+      next,
+      effort,
+      dependsOn: parseList(deps)
+    });
+  }
+  for (const r of rows) {
+    for (const d of r.dependsOn) {
+      if (!ids.has(d)) problems.push(`${r.id} depends on \`${d}\`, which is not in the table`);
+    }
+  }
+  return { rows, problems };
+}
+
+// src/engine/fleet.ts
 var pExecFile3 = promisify(execFile);
 var FLEET_LENS = "fleet-manifest";
 var FLEET_JSON_SCHEMA = "fleet-experimental-0.2";
-var CORP_WALL_ARTIFACTS = ["PROJECT_CONTEXT.md", "DECISIONS.md"];
+var GUARDED_WALL_ARTIFACTS = ["PROJECT_CONTEXT.md", "DECISIONS.md"];
 function recurringClasses(projects) {
   const byClass = /* @__PURE__ */ new Map();
   for (const p of projects) {
@@ -3689,12 +3907,12 @@ function finding3(id, tier, claim, evidence, why, action) {
     confidence: "high"
   };
 }
-function corpPersistenceRoot(manifest, name) {
-  const corpDir = path2.join(manifest.dir, "corp");
-  const root = path2.resolve(corpDir, name);
-  if (path2.dirname(root) !== corpDir || root === corpDir) {
+function guardedPersistenceRoot(manifest, name) {
+  const guardedDir = path2.join(manifest.dir, "guarded");
+  const root = path2.resolve(guardedDir, name);
+  if (path2.dirname(root) !== guardedDir || root === guardedDir) {
     throw new Error(
-      `entry name ${JSON.stringify(name)} escapes the corp persistence zone \u2014 refusing to resolve a ledger root for it`
+      `entry name ${JSON.stringify(name)} escapes the guarded persistence zone \u2014 refusing to resolve a ledger root for it`
     );
   }
   return root;
@@ -3727,7 +3945,7 @@ async function realpathOr(p) {
     return path2.resolve(p);
   }
 }
-function emailMatchesCorpHosts(email, hosts) {
+function emailMatchesGuardedHosts(email, hosts) {
   const domain = email.split("@")[1]?.toLowerCase();
   if (!domain) return false;
   return hosts.some((h) => {
@@ -3778,7 +3996,7 @@ async function checkManifest(manifest) {
       );
     }
     seen.add(entry.name);
-    if (entry.profile !== "corp" && !entry.private && !entry.trust) {
+    if (entry.profile !== "guarded" && !entry.private && !entry.trust) {
       const bad = entry.trustRaw;
       findings.push(
         finding3(
@@ -3816,14 +4034,14 @@ async function checkManifest(manifest) {
         )
       );
     }
-    if (entry.unresolved && manifest.localPresent && manifest.machineProfile !== "personal" && (entry.profile === "corp" || entry.private)) {
+    if (entry.unresolved && manifest.localPresent && manifest.machineProfile !== "personal" && (entry.profile === "guarded" || entry.private)) {
       findings.push(
         finding3(
           `${FLEET_LENS}/dangling-dir:${entry.name}`,
           "gap",
           `\`${entry.name}\` has no usable directory mapping`,
           [`${localFile}: ${entry.unresolved}`],
-          "An unmapped corp entry silently drops out of every sweep on the machine that most needs it.",
+          "An unmapped guarded entry silently drops out of every sweep on the machine that most needs it.",
           `Add a \`dirs\` mapping for \`${entry.name}\` in ${localFile}.`
         )
       );
@@ -3887,28 +4105,28 @@ async function checkManifest(manifest) {
     );
   }
   if (manifest.machineProfile === "personal") {
-    const corpCount = manifest.entries.filter((e) => e.profile === "corp" || e.private).length;
-    if (corpCount) {
+    const guardedCount = manifest.entries.filter((e) => e.profile === "guarded" || e.private).length;
+    if (guardedCount) {
       disclosures.push(
-        `machineProfile "personal": ${corpCount} corp entr${corpCount === 1 ? "y" : "ies"} deliberately absent on this machine \u2014 disclosed, not dangling.`
+        `machineProfile "personal": ${guardedCount} guarded entr${guardedCount === 1 ? "y" : "ies"} deliberately absent on this machine \u2014 disclosed, not dangling.`
       );
     }
   }
   return { findings, disclosures };
 }
-async function checkCorpWallArtifacts(entries, findings) {
+async function checkGuardedWallArtifacts(entries, findings) {
   for (const entry of entries) {
-    if (entry.profile !== "corp" || !entry.resolvedRoot) continue;
-    for (const artifact of CORP_WALL_ARTIFACTS) {
+    if (entry.profile !== "guarded" || !entry.resolvedRoot) continue;
+    for (const artifact of GUARDED_WALL_ARTIFACTS) {
       if (await pathExists(path2.join(entry.resolvedRoot, artifact))) {
         findings.push(
           finding3(
-            `${FLEET_LENS}/corp-artifact-in-repo:${entry.name}:${artifact}`,
+            `${FLEET_LENS}/guarded-artifact-in-repo:${entry.name}:${artifact}`,
             "risk",
-            `corp entry \`${entry.name}\` carries ${artifact} inside its worktree`,
+            `guarded entry \`${entry.name}\` carries ${artifact} inside its worktree`,
             [`${entry.resolvedRoot}/${artifact}`],
-            "Agent artifacts for corp repos live outside the repo by policy \u2014 an in-repo copy is one push away from colleagues' eyes and will diverge from the manifest-side truth.",
-            `Move it to the fleet's corp/${entry.name}/ zone and leave a pointer if the harness needs one.`
+            "Agent artifacts for guarded repos live outside the repo by policy \u2014 an in-repo copy is one push away from colleagues' eyes and will diverge from the manifest-side truth.",
+            `Move it to the fleet's guarded/${entry.name}/ zone and leave a pointer if the harness needs one.`
           )
         );
       }
@@ -3916,9 +4134,9 @@ async function checkCorpWallArtifacts(entries, findings) {
   }
 }
 async function checkCoverage(manifest, findings, disclosures) {
-  if (!manifest.corpHosts.length) {
+  if (!manifest.guardedHosts.length) {
     disclosures.push(
-      "Coverage check skipped \u2014 no corpHosts in the local manifest, so a corp remote cannot be recognized."
+      "Coverage check skipped \u2014 no guardedHosts in the local manifest, so a guarded remote cannot be recognized."
     );
     return;
   }
@@ -3939,16 +4157,16 @@ async function checkCoverage(manifest, findings, disclosures) {
     if (!await pathExists(path2.join(dir, ".git"))) continue;
     const remotes = await git(dir, ["config", "--get-regexp", "^remote\\..*\\.url"]);
     if (!remotes) continue;
-    const corpRemote = manifest.corpHosts.find((h) => remotes.includes(h));
-    if (corpRemote) {
+    const guardedRemote = manifest.guardedHosts.find((h) => remotes.includes(h));
+    if (guardedRemote) {
       findings.push(
         finding3(
-          `${FLEET_LENS}/unregistered-corp-remote:${d.name}`,
+          `${FLEET_LENS}/unregistered-guarded-remote:${d.name}`,
           "risk",
-          `\`${d.name}\` under the fleet root has a corp remote but is not registered`,
-          [`${dir}: remote matches ${corpRemote}`],
-          "The wall is only as good as its census \u2014 an unregistered employer checkout is corp material no sweep, wall check, or transfer plan knows exists.",
-          "Register it as a corp entry (opaque alias + local dirs mapping) or move it out of the fleet root."
+          `\`${d.name}\` under the fleet root has a guarded remote but is not registered`,
+          [`${dir}: remote matches ${guardedRemote}`],
+          "The wall is only as good as its census \u2014 an unregistered guarded checkout is guarded material no sweep, wall check, or transfer plan knows exists.",
+          "Register it as a guarded entry (opaque alias + local dirs mapping) or move it out of the fleet root."
         )
       );
     }
@@ -3996,7 +4214,7 @@ async function checkHygieneNeedles(manifest, findings, disclosures) {
       [
         ...Object.values(manifest.labels),
         ...Object.values(manifest.localDirs).map((d) => path2.basename(expandNeedleDir(d))),
-        ...manifest.corpHosts
+        ...manifest.guardedHosts
       ].filter((n) => n.length >= 3)
     )
   ];
@@ -4023,7 +4241,7 @@ async function checkHygieneNeedles(manifest, findings, disclosures) {
             "risk",
             `${file} in public-repo \`${entry.name}\` carries a needle from the fleet's private local manifest`,
             [`${file}: contains "${needle}"`],
-            "A public repo that names a private label, corp directory, or corp host joins the public and employer identities for anyone who greps.",
+            "A public repo that names a private label, guarded directory, or guarded host joins the public and guarded identities for anyone who greps.",
             "Scrub the needle from the tracked file (rewrite history if it already shipped)."
           )
         );
@@ -4034,10 +4252,10 @@ async function checkHygieneNeedles(manifest, findings, disclosures) {
 function expandNeedleDir(dir) {
   return dir.replace(/\/+$/, "");
 }
-async function checkCorpEmails(manifest, findings, disclosures) {
-  if (!manifest.corpHosts.length) {
+async function checkGuardedEmails(manifest, findings, disclosures) {
+  if (!manifest.guardedHosts.length) {
     disclosures.push(
-      "Corp-email check skipped \u2014 no corpHosts in the local manifest, so a corp domain cannot be recognized."
+      "Guarded-email check skipped \u2014 no guardedHosts in the local manifest, so a guarded domain cannot be recognized."
     );
     return;
   }
@@ -4046,21 +4264,23 @@ async function checkCorpEmails(manifest, findings, disclosures) {
     const emails = await git(entry.resolvedRoot, ["log", "-30", "--format=%ae"]);
     if (emails === null) {
       disclosures.push(
-        `Corp-email check could not run in \`${entry.name}\` (no readable commit history) \u2014 undetermined, not clean.`
+        `Guarded-email check could not run in \`${entry.name}\` (no readable commit history) \u2014 undetermined, not clean.`
       );
       continue;
     }
     const lines = emails.split("\n").filter(Boolean);
-    const matched = [...new Set(lines.filter((e) => emailMatchesCorpHosts(e, manifest.corpHosts)))];
+    const matched = [
+      ...new Set(lines.filter((e) => emailMatchesGuardedHosts(e, manifest.guardedHosts)))
+    ];
     if (matched.length) {
       const count = lines.filter((e) => matched.includes(e)).length;
       findings.push(
         finding3(
-          `${FLEET_LENS}/corp-email:${entry.name}`,
+          `${FLEET_LENS}/guarded-email:${entry.name}`,
           "risk",
-          `recent commits on personal entry \`${entry.name}\` are authored with a corp-host email`,
+          `recent commits on personal entry \`${entry.name}\` are authored with a guarded-host email`,
           [`${count} of the last ${lines.length} commits: ${matched.join(", ")}`],
-          "A corp email in a personal repo's history ties the two identities together permanently \u2014 and silently, since the machine's global git identity is usually the corp one.",
+          "A guarded email in a personal repo's history ties the two identities together permanently \u2014 and silently, since the machine's global git identity is usually the guarded one.",
           "Set the repo-local identity to the personal one and amend the unpushed commits."
         )
       );
@@ -4074,7 +4294,7 @@ async function checkGateDrift(manifest, findings, disclosures) {
   for (const entry of manifest.entries) {
     const root = entry.resolvedRoot;
     if (!root || !await isDirectory(root)) continue;
-    if (entry.profile === "corp" || entry.private) continue;
+    if (entry.profile === "guarded" || entry.private) continue;
     if (entry.gates === "none") {
       disclosures.push(`${entry.name}: gates declared \`none\` \u2014 deliberately absent, not missing`);
       continue;
@@ -4127,11 +4347,11 @@ async function checkGateDrift(manifest, findings, disclosures) {
 async function collectWallFindings(manifest) {
   const findings = [];
   const disclosures = [];
-  await checkCorpWallArtifacts(manifest.entries, findings);
+  await checkGuardedWallArtifacts(manifest.entries, findings);
   await checkCoverage(manifest, findings, disclosures);
   await checkManifestRepoMachinePaths(manifest, findings, disclosures);
   await checkHygieneNeedles(manifest, findings, disclosures);
-  await checkCorpEmails(manifest, findings, disclosures);
+  await checkGuardedEmails(manifest, findings, disclosures);
   await checkGateDrift(manifest, findings, disclosures);
   return { findings, disclosures };
 }
@@ -4197,13 +4417,13 @@ async function sweepEntry(manifest, entry, opts) {
       );
     }
   }
-  const corp = entry.profile === "corp";
-  const optedIn = !corp && await pathExists(path2.join(root, ETYMD_DIR));
+  const guarded = entry.profile === "guarded";
+  const optedIn = !guarded && await pathExists(path2.join(root, ETYMD_DIR));
   const result = await runAudit(root, {
     kind: opts.kind,
-    persistLedger: !corp && opts.persistLedgers === true && optedIn,
-    readOnlyRoot: corp,
-    ledgerRoot: corp ? corpPersistenceRoot(manifest, entry.name) : void 0,
+    persistLedger: !guarded && opts.persistLedgers === true && optedIn,
+    readOnlyRoot: guarded,
+    ledgerRoot: guarded ? guardedPersistenceRoot(manifest, entry.name) : void 0,
     stateBudgets: stateBudgetsFor(entry),
     upstreamRemote
   });
@@ -4211,11 +4431,43 @@ async function sweepEntry(manifest, entry, opts) {
   if (entry.contract.placement === "none") {
     project.findings = project.findings.filter((f) => !f.id.endsWith("/no-contract"));
   }
+  const milestonesFile = entry.contract.milestones;
+  if (milestonesFile && milestonesFile !== "none") {
+    const text = await readText(path2.join(root, milestonesFile));
+    if (text === null) {
+      project.findings.push(
+        finding3(
+          `${FLEET_LENS}/milestones-missing:${entry.name}`,
+          "gap",
+          `\`${entry.name}\` declares milestones at \`${milestonesFile}\` and the file is absent`,
+          [
+            `${path2.basename(manifest.manifestPath)}: ${entry.name}.contract.milestones = ${milestonesFile}`
+          ],
+          "The fleet board rolls every project's plan up from this file; a declared file that is absent is a row the board cannot fill.",
+          'Create it (heading `# Milestones`, then the standard table), or declare `milestones: "none"` if this project deliberately carries no plan.'
+        )
+      );
+    } else {
+      const doc = parseMilestones(text);
+      doc.problems.forEach((problem, i) => {
+        project.findings.push(
+          finding3(
+            `${FLEET_LENS}/milestones-shape:${entry.name}:${i + 1}`,
+            "gap",
+            `\`${entry.name}\` ${milestonesFile}: ${problem}`,
+            [`${milestonesFile}`],
+            "A milestones file the board cannot parse is a plan the fleet cannot see.",
+            `Fix the table to the standard shape: \`| ${MILESTONE_COLUMNS.join(" | ")} |\`.`
+          )
+        );
+      });
+    }
+  }
   for (const f of project.findings) project.counts[f.tier] += 1;
   project.stateAgeDays = stateAgeDays(result.facts);
   project.staleAfterDays = result.config.config.state.staleAfterDays;
   for (const [key, value] of Object.entries(entry.contract)) {
-    if (key === "placement" || !value) continue;
+    if (key === "placement" || key === "milestones" || !value) continue;
     const exists = await pathExists(path2.join(root, value.replace(/#.*$/, "")));
     project.disclosures.push(
       `contract override \`${key}: ${value}\` \u2014 registered, existence-checked only (${exists ? "present" : "MISSING"})`
@@ -4258,8 +4510,481 @@ async function sweepFleet(manifest, opts = {}) {
   };
 }
 
+// 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/engine/premise.ts
+init_facts();
+init_scan();
+init_util();
+var PREMISE_LENS = "premise";
+var PREMISE_BRIEF_FILE = path2.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,
+    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 };
+}
+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}`;
+  });
+  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;
+    }
+  } else {
+    const ext = body.toLowerCase().match(/\.([a-z0-9]{1,8})$/)?.[1];
+    if (!ext || !KNOWN_EXTENSIONS.has(ext)) return token;
+  }
+  if (namespace) {
+    skips.namespaced += 1;
+    return token;
+  }
+  return `${lead}\`${body}\`${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(path2.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 rootedDirs = await listRootedDirs(env);
+  const promoted = promoteBareTokens(task, { rootedDirs });
+  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,
+      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.",
+      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 (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.`
+    );
+  }
+  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(path2.join(root, ETYMD_DIR))) {
+    await promises.writeFile(path2.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/index.ts
 init_version();
 init_version2();
 
-export { CONFIG_FILE, DECISIONS_FORMAT_MARKER, DEFAULT_CONFIG, EXTRACTION_THRESHOLD, FLEET_JSON_SCHEMA, FLEET_LENS, LENSES, NAME, PACK_VERSION, TOTAL_BUDGET_WORDS, VERSION, applyFiles, baselineCarriesMachinePath, baselinePath, buildGateInventory, cacheFactsPath, checkManifest, collectWallFindings, configPath, contextEconomyLens, corpPersistenceRoot, deriveProfile, expandTilde, extractCommandClaims, extractPathClaims, gateIntegrityLens, instructionTruthLens, isAlwaysAppliedCursorRule, listInstructionFiles, loadFleetManifest, measureContext, planWorkflow, rankFindings, readBaseline, readCachedFacts, readConfig, readLedger, reconcileLedger, runAudit, scanProject, stateFreshnessLens, sweepFleet, withoutMachinePath, writeBaseline, writeCachedFacts, writeLedger };
+export { CONFIG_FILE, DECISIONS_FORMAT_MARKER, DEFAULT_CONFIG, EXTRACTION_THRESHOLD, FLEET_JSON_SCHEMA, FLEET_LENS, LENSES, NAME, PACK_VERSION, PREMISE_BRIEF_FILE, PREMISE_LENS, PROPOSAL_SCHEMA, RUBRIC_CRITERIA, TOTAL_BUDGET_WORDS, VERSION, applyFiles, baselineCarriesMachinePath, baselinePath, buildGateInventory, buildProposals, buildTruthEnv, cacheFactsPath, checkDecisionRefs, checkDocRefs, checkManifest, checkTextClaims, collectWallFindings, configPath, contextEconomyLens, deriveProfile, emptyCounters, expandTilde, extractCommandClaims, extractPathClaims, gateIntegrityLens, guardedPersistenceRoot, instructionTruthLens, isAlwaysAppliedCursorRule, listInstructionFiles, loadDecisionLedger, loadFleetManifest, measureContext, parseRubric, planWorkflow, promoteBareTokens, rankFindings, readBaseline, readCachedFacts, readConfig, readLedger, reconcileLedger, renderBrief, runAudit, runPremise, scanProject, stateFreshnessLens, sweepFleet, withoutMachinePath, writeBaseline, writeCachedFacts, writeLedger };