etymd 0.15.0 → 0.17.0

package/dist/{fleet-4FYZ3GBK.js → chunk-LVR2DPR7.js}

@@ -1,19 +1,12 @@
 #!/usr/bin/env node
-import { dismiss, accept } from './chunk-HOR4M6EC.js';
-import { runAudit } from './chunk-2RNQ6OLV.js';
-import { parseFailOnTier, meetsFailOn } from './chunk-IWG77WV3.js';
+import { runAudit } from './chunk-WKP7M2B3.js';
 import { readLedger } from './chunk-3E2IPCRY.js';
-import { print, theme, section, renderFleetRows, renderFleetNotes, renderFindings, TIER_BADGE, glyph } from './chunk-HI7NWPRA.js';
-import { scanProject } from './chunk-Y6RZRED3.js';
-import './chunk-DBWDMIYO.js';
 import { DEFAULT_CONFIG, ETYMD_DIR } from './chunk-P6ATKV2R.js';
-import './chunk-YQZDYDAK.js';
-import { readText, pathExists, git, isDirectory } from './chunk-4VPBP6K6.js';
-import { promises } from 'fs';
+import { readText, isDirectory, git, pathExists } from './chunk-4VPBP6K6.js';
 import os from 'os';
 import path from 'path';
-import { select, isCancel, cancel, text, confirm } from '@clack/prompts';
 import { execFile } from 'child_process';
+import { promises } from 'fs';
 import { promisify } from 'util';
 
 var FLEET_TRUST_VALUES = ["public-repo", "public-bound", "private"];
@@ -25,14 +18,14 @@ function expandTilde(p) {
   if (p.startsWith("~/")) return path.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;
 }
@@ -73,7 +66,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;
@@ -86,8 +79,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,
@@ -125,12 +118,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) {
@@ -146,11 +139,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: path.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}`
     });
   }
 }
@@ -199,7 +192,7 @@ async function loadFleetManifest(manifestPath) {
     shape: "registry",
     manifestPath: abs,
     dir,
-    corpHosts: [],
+    guardedHosts: [],
     labels: {},
     localDirs: {},
     localPath: path.join(dir, "registry.local.json"),
@@ -232,8 +225,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 = path.resolve(dir, expandTilde(rootRaw));
     const orientationRec = asRecord(parsed.orientation);
@@ -271,10 +264,334 @@ async function loadFleetManifest(manifestPath) {
   }
   return manifest;
 }
+
+// src/engine/milestones.ts
+var MILESTONES_FILE = "MILESTONES.md";
+var BOARD_JSON_SCHEMA = "fleet-board-experimental-0.1";
+var MILESTONE_COLUMNS = [
+  "id",
+  "milestone",
+  "goal",
+  "status",
+  "next",
+  "effort",
+  "depends-on"
+];
+var INITIATIVE_COLUMNS = [
+  "rank",
+  "id",
+  "initiative",
+  "goal",
+  "status",
+  "next",
+  "effort",
+  "projects",
+  "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(cell2) {
+  if (NONE_MARKERS.has(cell2.trim().toLowerCase())) return [];
+  return cell2.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 };
+}
+function parseInitiatives(text) {
+  const problems = [];
+  const lines = text.split(/\r?\n/);
+  const table = firstTable(lines, 0);
+  if (!table) {
+    problems.push(`no initiatives table: expected \`| ${INITIATIVE_COLUMNS.join(" | ")} |\``);
+    return { rows: [], problems };
+  }
+  if (!checkColumns(table, INITIATIVE_COLUMNS, problems)) return { rows: [], problems };
+  const rows = [];
+  const ids = /* @__PURE__ */ new Set();
+  const ranks = /* @__PURE__ */ new Set();
+  for (const { line, cells } of table.rows) {
+    if (cells.length !== INITIATIVE_COLUMNS.length) {
+      problems.push(`line ${line}: ${cells.length} cells, expected ${INITIATIVE_COLUMNS.length}`);
+      continue;
+    }
+    const [rankRaw, id, initiative, goal, status, next, effort, projects, deps] = cells;
+    let ok = true;
+    const rank = Number(rankRaw);
+    if (!/^\d+$/.test(rankRaw) || rank < 1) {
+      problems.push(`line ${line}: rank \`${rankRaw}\` is not a positive integer`);
+      ok = false;
+    } else if (ranks.has(rank)) {
+      problems.push(`line ${line}: rank ${rank} is used twice \u2014 a rank is an order, not a score`);
+      ok = false;
+    }
+    if (!/^I\d+$/.test(id)) {
+      problems.push(`line ${line}: id \`${id}\` is not \`I<number>\``);
+      ok = false;
+    } else if (ids.has(id)) {
+      problems.push(`line ${line}: id \`${id}\` is used twice`);
+      ok = false;
+    }
+    if (!initiative) {
+      problems.push(`line ${line}: initiative title is empty`);
+      ok = false;
+    }
+    if (!next) {
+      problems.push(`line ${line}: next step is empty`);
+      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);
+    ranks.add(rank);
+    rows.push({
+      rank,
+      id,
+      milestone: initiative,
+      goal,
+      status,
+      next,
+      effort,
+      projects: parseList(projects),
+      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`);
+    }
+  }
+  rows.sort((a, b) => a.rank - b.rank);
+  return { rows, problems };
+}
+function cell(s) {
+  return s.replace(/\|/g, "\\|");
+}
+function list(xs) {
+  return xs.length ? xs.join(", ") : "\u2014";
+}
+function countBy(rows) {
+  const c = { planned: 0, active: 0, blocked: 0, done: 0 };
+  for (const r of rows) c[r.status] += 1;
+  return c;
+}
+function statusLine(rows) {
+  const c = countBy(rows);
+  return MILESTONE_STATUSES.map((s) => `${s} ${c[s]}`).join(" \xB7 ");
+}
+function renderBoard(input) {
+  const out = [];
+  out.push("# Fleet board");
+  out.push("");
+  out.push(
+    `Generated ${input.generatedOn} by \`etymd fleet board\` from \`${input.manifest}\`. Do not edit: change a project's milestones file or the initiatives table and re-render.`
+  );
+  out.push("");
+  out.push("## Initiatives, ranked");
+  out.push("");
+  if (input.initiatives === null) {
+    out.push("No initiatives file given (`--initiatives <file>`).");
+  } else {
+    if (input.initiativesProblems.length) {
+      out.push("Problems in the initiatives table:");
+      out.push("");
+      for (const p of input.initiativesProblems) out.push(`- ${p}`);
+      out.push("");
+    }
+    if (input.initiatives.length === 0) {
+      out.push("No initiatives ranked yet.");
+    } else {
+      out.push(`| ${INITIATIVE_COLUMNS.join(" | ")} |`);
+      out.push(`|${INITIATIVE_COLUMNS.map(() => "---").join("|")}|`);
+      for (const i of input.initiatives) {
+        out.push(
+          `| ${i.rank} | ${i.id} | ${cell(i.milestone)} | ${i.goal} | ${i.status} | ${cell(i.next)} | ${i.effort} | ${cell(list(i.projects))} | ${list(i.dependsOn)} |`
+        );
+      }
+    }
+  }
+  out.push("");
+  out.push("## Milestones by project");
+  out.push("");
+  const all = [];
+  for (const p of input.projects) {
+    const kind = p.kind ? ` (${p.kind})` : "";
+    switch (p.state) {
+      case "ok":
+      case "declared-empty":
+      case "invalid": {
+        const head = p.state === "declared-empty" ? "declared, empty" : p.state === "invalid" ? `INVALID \u2014 ${p.problems.length} problem${p.problems.length === 1 ? "" : "s"}` : statusLine(p.rows);
+        out.push(`### ${p.name}${kind} \u2014 ${head}`);
+        out.push("");
+        if (p.problems.length) {
+          for (const pr of p.problems) out.push(`- ${pr}`);
+          out.push("");
+        }
+        if (p.rows.length) {
+          out.push(`| ${MILESTONE_COLUMNS.join(" | ")} |`);
+          out.push(`|${MILESTONE_COLUMNS.map(() => "---").join("|")}|`);
+          for (const r of p.rows) {
+            out.push(
+              `| ${r.id} | ${cell(r.milestone)} | ${r.goal} | ${r.status} | ${cell(r.next)} | ${r.effort} | ${list(r.dependsOn)} |`
+            );
+          }
+          out.push("");
+          all.push(...p.rows);
+        }
+        break;
+      }
+      case "not-declared":
+        out.push(`### ${p.name}${kind} \u2014 not declared (no \`milestones\` contract key)`);
+        out.push("");
+        break;
+      case "none":
+        out.push(`### ${p.name}${kind} \u2014 none, by declaration`);
+        out.push("");
+        break;
+      case "missing":
+        out.push(
+          `### ${p.name}${kind} \u2014 MISSING: \`${p.file ?? MILESTONES_FILE}\` is declared and absent`
+        );
+        out.push("");
+        break;
+      case "unresolved":
+        out.push(`### ${p.name}${kind} \u2014 not read: ${p.problems[0] ?? "unresolved"}`);
+        out.push("");
+        break;
+    }
+  }
+  out.push("## Totals");
+  out.push("");
+  const c = countBy(all);
+  out.push("| status | count |");
+  out.push("|---|---|");
+  for (const s of MILESTONE_STATUSES) out.push(`| ${s} | ${c[s]} |`);
+  out.push("");
+  const byGoal = { "1": 0, "2": 0, "3": 0 };
+  for (const r of all) if (r.status !== "done") byGoal[r.goal] = (byGoal[r.goal] ?? 0) + 1;
+  out.push("| goal | open milestones |");
+  out.push("|---|---|");
+  for (const g of MILESTONE_GOALS) out.push(`| ${g} | ${byGoal[g] ?? 0} |`);
+  out.push("");
+  const states = input.projects.reduce((acc, p) => {
+    acc[p.state] = (acc[p.state] ?? 0) + 1;
+    return acc;
+  }, {});
+  out.push(
+    `Projects: ${input.projects.length} \u2014 ` + Object.entries(states).map(([k, v]) => `${k} ${v}`).join(" \xB7 ")
+  );
+  out.push("");
+  return out.join("\n");
+}
 var pExecFile = 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) {
@@ -307,12 +624,12 @@ function finding(id, tier, claim, evidence, why, action) {
     confidence: "high"
   };
 }
-function corpPersistenceRoot(manifest, name) {
-  const corpDir = path.join(manifest.dir, "corp");
-  const root = path.resolve(corpDir, name);
-  if (path.dirname(root) !== corpDir || root === corpDir) {
+function guardedPersistenceRoot(manifest, name) {
+  const guardedDir = path.join(manifest.dir, "guarded");
+  const root = path.resolve(guardedDir, name);
+  if (path.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;
@@ -345,7 +662,7 @@ async function realpathOr(p) {
     return path.resolve(p);
   }
 }
-function emailMatchesCorpHosts(email, hosts) {
+function emailMatchesGuardedHosts(email, hosts) {
   const domain = email.split("@")[1]?.toLowerCase();
   if (!domain) return false;
   return hosts.some((h) => {
@@ -396,7 +713,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(
         finding(
@@ -434,14 +751,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(
         finding(
           `${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}.`
         )
       );
@@ -505,28 +822,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(path.join(entry.resolvedRoot, artifact))) {
         findings.push(
           finding(
-            `${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.`
           )
         );
       }
@@ -534,9 +851,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;
   }
@@ -557,16 +874,16 @@ async function checkCoverage(manifest, findings, disclosures) {
     if (!await pathExists(path.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(
         finding(
-          `${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."
         )
       );
     }
@@ -614,7 +931,7 @@ async function checkHygieneNeedles(manifest, findings, disclosures) {
       [
         ...Object.values(manifest.labels),
         ...Object.values(manifest.localDirs).map((d) => path.basename(expandNeedleDir(d))),
-        ...manifest.corpHosts
+        ...manifest.guardedHosts
       ].filter((n) => n.length >= 3)
     )
   ];
@@ -641,7 +958,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)."
           )
         );
@@ -652,10 +969,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;
   }
@@ -664,21 +981,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(
         finding(
-          `${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."
         )
       );
@@ -686,18 +1005,18 @@ async function checkCorpEmails(manifest, findings, disclosures) {
   }
 }
 async function checkGateDrift(manifest, findings, disclosures) {
-  const { planWorkflow } = await import('./generate-KEX75XNG.js');
-  const { scanProject: scanProject2 } = await import('./scan-W4US23MU.js');
+  const { planWorkflow } = await import('./generate-FSJQFQPV.js');
+  const { scanProject } = await import('./scan-5SC47FSM.js');
   const { readConfig } = await import('./config-724Y3IOB.js');
   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;
     }
-    const facts = await scanProject2(root);
+    const facts = await scanProject(root);
     if (!facts.git.isRepo) continue;
     if (facts.hooks.source === "husky" || facts.hooks.source === "husky-legacy") {
       disclosures.push(
@@ -705,8 +1024,13 @@ async function checkGateDrift(manifest, findings, disclosures) {
       );
       continue;
     }
-    const { config } = await readConfig(root);
-    const planned = (await planWorkflow(root, facts, { agents: false, gates: true, gateConfig: config.gates })).filter((f) => f.executable);
+    const { config, explicit } = await readConfig(root);
+    const planned = (await planWorkflow(root, facts, {
+      agents: false,
+      gates: true,
+      gateConfig: config.gates,
+      gateFailOnPinned: explicit.gatesFailOn
+    })).filter((f) => f.executable);
     const missing = planned.filter((f) => !f.exists).map((f) => f.path);
     const differing = planned.filter((f) => f.exists && f.differs);
     const stale = differing.filter((f) => f.drift !== "edited").map((f) => f.path);
@@ -745,11 +1069,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 };
 }
@@ -815,13 +1139,13 @@ async function sweepEntry(manifest, entry, opts) {
       );
     }
   }
-  const corp = entry.profile === "corp";
-  const optedIn = !corp && await pathExists(path.join(root, ETYMD_DIR));
+  const guarded = entry.profile === "guarded";
+  const optedIn = !guarded && await pathExists(path.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
   });
@@ -829,11 +1153,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(path.join(root, milestonesFile));
+    if (text === null) {
+      project.findings.push(
+        finding(
+          `${FLEET_LENS}/milestones-missing:${entry.name}`,
+          "gap",
+          `\`${entry.name}\` declares milestones at \`${milestonesFile}\` and the file is absent`,
+          [
+            `${path.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(
+          finding(
+            `${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(path.join(root, value.replace(/#.*$/, "")));
     project.disclosures.push(
       `contract override \`${key}: ${value}\` \u2014 registered, existence-checked only (${exists ? "present" : "MISSING"})`
@@ -885,12 +1241,12 @@ async function fleetLedgerTarget(manifest, name) {
   if (!entry.resolvedRoot) {
     throw new Error(`\`${name}\` does not resolve on this machine: ${entry.unresolved}`);
   }
-  const corp = entry.profile === "corp";
+  const guarded = entry.profile === "guarded";
   return {
     entry,
     auditRoot: entry.resolvedRoot,
-    ledgerRoot: corp ? corpPersistenceRoot(manifest, name) : entry.resolvedRoot,
-    corp
+    ledgerRoot: guarded ? guardedPersistenceRoot(manifest, name) : entry.resolvedRoot,
+    guarded
   };
 }
 async function ensureFindingRecorded(manifest, name, id) {
@@ -899,398 +1255,11 @@ async function ensureFindingRecorded(manifest, name, id) {
   if (await has()) return { ledgerRoot: target.ledgerRoot, recorded: true };
   await runAudit(target.auditRoot, {
     persistLedger: true,
-    readOnlyRoot: target.corp,
-    ledgerRoot: target.corp ? target.ledgerRoot : void 0,
+    readOnlyRoot: target.guarded,
+    ledgerRoot: target.guarded ? target.ledgerRoot : void 0,
     stateBudgets: stateBudgetsFor(target.entry)
   });
   return { ledgerRoot: target.ledgerRoot, recorded: await has() };
 }
 
-// src/commands/fleet.ts
-var LAST_SWEEP_FILE = "last.fleet.json";
-async function loadManifest(cwd, manifestOpt) {
-  if (manifestOpt) {
-    return { manifest: await loadFleetManifest(path.resolve(cwd, manifestOpt)) };
-  }
-  const candidate = path.join(cwd, "registry.json");
-  if (await pathExists(candidate)) {
-    return {
-      manifest: await loadFleetManifest(candidate),
-      autoNote: `manifest auto-selected from the cwd: ${candidate} (no --manifest given)`
-    };
-  }
-  throw new Error(
-    "no --manifest given and no registry.json in the current directory \u2014 pass --manifest <file> (there is deliberately no env var and no global pointer)"
-  );
-}
-async function readLastSweep(lastPath) {
-  const raw = await readText(lastPath);
-  if (raw === null) return { record: null };
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return {
-      record: null,
-      note: `${LAST_SWEEP_FILE} exists but is not valid JSON \u2014 delta baseline reset (every finding reads as new this sweep).`
-    };
-  }
-  const rec = parsed;
-  if (typeof rec !== "object" || rec === null || rec.schema !== FLEET_JSON_SCHEMA || typeof rec.projects !== "object" || rec.projects === null || Array.isArray(rec.projects) || !Array.isArray(rec.wall)) {
-    return {
-      record: null,
-      note: `${LAST_SWEEP_FILE} carries a foreign schema \u2014 delta baseline reset (every finding reads as new this sweep).`
-    };
-  }
-  return { record: rec };
-}
-function failOnExit(failOn, findings) {
-  if (failOn === void 0) return;
-  if (meetsFailOn(findings, parseFailOnTier(failOn))) process.exitCode = 1;
-}
-async function sweep(opts) {
-  if (opts.profile && opts.profile !== "personal" && opts.profile !== "corp") {
-    throw new Error(`--profile must be personal or corp, got \`${opts.profile}\``);
-  }
-  if (opts.failOn !== void 0) parseFailOnTier(opts.failOn);
-  const { manifest, autoNote } = await loadManifest(opts.cwd, opts.manifest);
-  const result = await sweepFleet(manifest, {
-    only: opts.only,
-    profile: opts.profile,
-    kind: opts.truth ? "truth" : void 0,
-    persistLedgers: opts.persistLedgers
-  });
-  const lastPath = path.join(manifest.dir, LAST_SWEEP_FILE);
-  const { record: previous, note: baselineNote } = await readLastSweep(lastPath);
-  const previousIds = (name) => new Set((previous?.projects[name] ?? []).map((e) => e.id));
-  const previousWallIds = new Set((previous?.wall ?? []).map((e) => e.id));
-  const allFindings = [...result.projects.flatMap((p) => p.findings), ...result.wall];
-  failOnExit(opts.failOn, allFindings);
-  const fullSweep = !opts.only && !opts.profile && !opts.truth;
-  const delta = {};
-  for (const p of result.projects) {
-    const prev = previousIds(p.name);
-    const current = new Set(p.findings.map((f) => f.id));
-    delta[p.name] = {
-      new: [...current].filter((id) => !prev.has(id)),
-      resolved: [...prev].filter((id) => !current.has(id))
-    };
-  }
-  const wallNew = result.wall.filter((f) => !previousWallIds.has(f.id)).map((f) => f.id);
-  if (opts.json) {
-    print(
-      JSON.stringify(
-        {
-          ...result,
-          delta: previous ? delta : null,
-          ...baselineNote ? { deltaBaselineNote: baselineNote } : {}
-        },
-        null,
-        2
-      )
-    );
-  } else {
-    if (autoNote) print(`  ${theme.dim(`\u25E6 ${autoNote}`)}`);
-    if (baselineNote) print(`  ${theme.dim(`\u25E6 ${baselineNote}`)}`);
-    renderSweep(result, previous, delta, wallNew);
-  }
-  if (fullSweep) {
-    const record = {
-      schema: FLEET_JSON_SCHEMA,
-      sweptAt: result.sweptAt,
-      projects: Object.fromEntries(
-        result.projects.map((p) => [p.name, p.findings.map((f) => ({ id: f.id, tier: f.tier }))])
-      ),
-      wall: result.wall.map((f) => ({ id: f.id, tier: f.tier }))
-    };
-    const tmpPath = `${lastPath}.tmp`;
-    await promises.writeFile(tmpPath, JSON.stringify(record, null, 2) + "\n", "utf8");
-    await promises.rename(tmpPath, lastPath);
-  } else if (!opts.json) {
-    print();
-    print(`  ${theme.dim("partial sweep \u2014 the delta baseline was not updated")}`);
-  }
-}
-function renderSweep(result, previous, delta, wallNew) {
-  section(
-    `Fleet sweep ${theme.dim(`\xB7 ${path.basename(result.manifest)} \xB7 ${result.projects.length} project(s) \xB7 schema ${result.schema}`)}`
-  );
-  const rows = result.projects.map((p) => {
-    const d = delta[p.name] ?? { new: [], resolved: [] };
-    const deltaStr = !previous ? "first sweep" : d.new.length || d.resolved.length ? `\u0394 ${[d.new.length ? `+${d.new.length}` : "", d.resolved.length ? `\u2212${d.resolved.length}` : ""].filter(Boolean).join(" ")}` : "\u0394 \xB10";
-    return {
-      name: p.name,
-      age: p.stateAgeDays === null ? "\u2014" : `${p.stateAgeDays}/${p.staleAfterDays}d`,
-      counts: p.counts,
-      delta: deltaStr,
-      note: p.unresolved
-    };
-  });
-  renderFleetRows(rows);
-  renderFleetNotes(
-    result.problems,
-    result.projects.flatMap((p) => p.disclosures.map((d) => `${p.name}: ${d}`))
-  );
-  const detail = [
-    ...result.projects.flatMap(
-      (p) => p.findings.filter((f) => f.tier === "risk" || (delta[p.name]?.new ?? []).includes(f.id))
-    ),
-    ...result.wall.filter((f) => f.tier === "risk" || wallNew.includes(f.id))
-  ];
-  if (detail.length) {
-    section(`New or risk findings ${theme.dim(`(${detail.length})`)}`);
-    renderFindings(detail);
-  }
-  if (result.recurringClasses.length) {
-    section(`Recurring classes ${theme.dim("(open in \u22652 projects \u2014 class-fix candidates)")}`);
-    for (const rc of result.recurringClasses) {
-      print(
-        `  ${TIER_BADGE[rc.tier]} ${rc.classId} ${theme.dim(`\u2014 ${rc.projects.length}\xD7: ${rc.projects.join(", ")}`)}`
-      );
-    }
-  }
-  section("Fleet wall");
-  if (!result.wall.length) print(`  ${glyph.ok} ${theme.dim("clean")}`);
-  else
-    print(
-      `  ${theme.warn(`${result.wall.length} finding(s)`)} ${theme.dim("(detailed above if new or risk)")}`
-    );
-  renderFleetNotes([], result.wallDisclosures);
-  if (result.outOfScope.length) {
-    print(
-      `  ${theme.dim(`out of scope (not audited, named above): ${result.outOfScope.join(", ")}`)}`
-    );
-  }
-}
-async function check(opts) {
-  const { manifest, autoNote } = await loadManifest(opts.cwd, opts.manifest);
-  const { findings, disclosures } = await checkManifest(manifest);
-  if (findings.length) process.exitCode = 1;
-  if (opts.json) {
-    print(
-      JSON.stringify(
-        { schema: FLEET_JSON_SCHEMA, manifest: manifest.manifestPath, findings, disclosures },
-        null,
-        2
-      )
-    );
-    return;
-  }
-  if (autoNote) print(`  ${theme.dim(`\u25E6 ${autoNote}`)}`);
-  section(
-    `Fleet check ${theme.dim(`\xB7 ${path.basename(manifest.manifestPath)} \xB7 ${manifest.entries.length} entr${manifest.entries.length === 1 ? "y" : "ies"} \xB7 manifest truth only, no lenses`)}`
-  );
-  renderFindings(findings);
-  renderFleetNotes([], disclosures);
-}
-async function recordCorpMapping(manifest, name, absTarget) {
-  const home = os.homedir();
-  const value = absTarget === home || absTarget.startsWith(home + path.sep) ? `~${absTarget.slice(home.length)}` : absTarget;
-  const insideRepo = await git(manifest.dir, ["rev-parse", "--is-inside-work-tree"]) === "true";
-  if (insideRepo) {
-    const ignored = await git(manifest.dir, ["check-ignore", "-q", manifest.localPath]) !== null;
-    if (!ignored) {
-      throw new Error(
-        `${path.basename(manifest.localPath)} is not gitignored \u2014 refusing to write employer directory names into a file git would track. Add it to .gitignore, then re-run.`
-      );
-    }
-  }
-  const existing = await readText(manifest.localPath);
-  let doc = {};
-  if (existing) {
-    try {
-      doc = JSON.parse(existing);
-    } catch {
-      throw new Error(
-        `${path.basename(manifest.localPath)} is not valid JSON \u2014 fix it before registering, so the mapping is not written over hand-maintained entries that cannot be re-derived.`
-      );
-    }
-  }
-  const dirs = doc.dirs ?? {};
-  dirs[name] = value;
-  doc.dirs = dirs;
-  await promises.writeFile(manifest.localPath, JSON.stringify(doc, null, 2) + "\n", "utf8");
-  return value;
-}
-async function add(opts) {
-  const { manifest, autoNote } = await loadManifest(opts.cwd, opts.manifest);
-  if (autoNote) print(`  ${theme.dim(`\u25E6 ${autoNote}`)}`);
-  if (manifest.shape !== "registry") {
-    throw new Error("`fleet add` targets the registry shape \u2014 this manifest is a legacy corpus");
-  }
-  const raw = await readText(manifest.manifestPath);
-  if (raw === null) throw new Error(`cannot read ${manifest.manifestPath}`);
-  const absTarget = path.resolve(opts.cwd, opts.target);
-  if (!await pathExists(absTarget)) throw new Error(`no such directory: ${absTarget}`);
-  const name = opts.name ?? path.basename(absTarget);
-  if (manifest.entries.some((e) => e.name === name)) {
-    throw new Error(`\`${name}\` is already registered \u2014 resolution is keyed by name`);
-  }
-  const facts = await scanProject(absTarget);
-  const remote = facts.git.isRepo ? await git(absTarget, ["remote", "get-url", "origin"]) : null;
-  section(`Fleet add ${theme.dim(`\xB7 ${name} \xB7 ${absTarget}`)}`);
-  let profile = opts.profile;
-  if (!profile && !opts.yes) {
-    const picked = await select({
-      message: "Which side of the wall does this belong to?",
-      initialValue: "personal",
-      options: [
-        { value: "personal", label: "personal \u2014 your own work" },
-        { value: "corp", label: "corp \u2014 employer work (alias-only, machine-pinned)" }
-      ]
-    });
-    if (isCancel(picked)) {
-      cancel("No entry written.");
-      return;
-    }
-    profile = picked;
-  }
-  profile = profile ?? "personal";
-  if (profile !== "personal" && profile !== "corp") {
-    throw new Error(`--profile must be personal or corp, got \`${profile}\``);
-  }
-  const derivedKind = facts.commands.build || facts.commands.test ? "tool" : "repo";
-  let kind = opts.kind;
-  if (!kind && !opts.yes) {
-    const known = [...new Set(manifest.entries.map((e) => e.kind).filter(Boolean))];
-    const choices = [.../* @__PURE__ */ new Set([derivedKind, ...known])];
-    const picked = await select({
-      message: "Kind?",
-      initialValue: derivedKind,
-      options: [
-        ...choices.map((k) => ({
-          value: k,
-          label: k === derivedKind ? `${k} \u2014 matches this repo's shape` : k
-        })),
-        { value: "", label: "something else\u2026" }
-      ]
-    });
-    if (isCancel(picked)) {
-      cancel("No entry written.");
-      return;
-    }
-    kind = picked;
-    if (!kind) {
-      const typed = await text({
-        message: "Kind (free text):",
-        validate: (v) => v.trim() ? void 0 : "a kind is required"
-      });
-      if (isCancel(typed)) {
-        cancel("No entry written.");
-        return;
-      }
-      kind = typed.trim();
-    }
-  }
-  kind = kind ?? derivedKind;
-  let trust;
-  if (profile === "personal") {
-    trust = opts.trust;
-    if (!trust && !opts.yes) {
-      const picked = await select({
-        message: "How exposed is this repo's history? (gates content screening)",
-        options: [
-          { value: "private", label: "private \u2014 not destined to be published" },
-          { value: "public-bound", label: "public-bound \u2014 private now, plausibly public later" },
-          { value: "public-repo", label: "public-repo \u2014 already public" }
-        ]
-      });
-      if (isCancel(picked)) {
-        cancel("No entry written.");
-        return;
-      }
-      trust = picked;
-    }
-    if (!trust) {
-      throw new Error(
-        `\`${name}\` needs a trust level: pass --trust <${FLEET_TRUST_VALUES.join("|")}> (non-interactive runs cannot be prompted, and there is deliberately no default \u2014 trust gates content screening)`
-      );
-    }
-    if (!isFleetTrust(trust)) {
-      throw new Error(`--trust must be one of ${FLEET_TRUST_VALUES.join(", ")}, got \`${trust}\``);
-    }
-  } else if (opts.trust) {
-    throw new Error("corp entries take no `trust` \u2014 `profile: corp` already implies it");
-  }
-  const corpHost = remote ? manifest.corpHosts.find((h) => remote.includes(h)) : void 0;
-  if (corpHost && profile !== "corp") {
-    throw new Error(
-      `\`${name}\` has a remote on the corp host \`${corpHost}\`, but --profile is \`${profile}\`. A personal entry records its path and raw remote in the TRACKED manifest \u2014 register it with \`--profile corp\` (alias-only, machine-pinned), or move it out of the fleet root.`
-    );
-  }
-  const entry = profile === "corp" ? { name, kind, profile, private: true } : {
-    name,
-    kind,
-    profile,
-    path: path.relative(manifest.root ?? manifest.dir, absTarget),
-    trust,
-    contract: {},
-    links: {}
-    // The remote is deliberately NOT recorded. Nothing reads it — it was persisted only
-    // because it happened to be derivable — and it is the field that turns a mis-profiled
-    // entry into a disclosure: a raw URL carries the host AND the internal group path,
-    // while `path` carries a bare directory name. Removing a field no consumer reads
-    // retires that whole class without any host-matching guess, and keeps working on a
-    // machine that has no local manifest for the corp-host guard above to read.
-    // It stays derivable at any time from the checkout itself, which is where it came from.
-  };
-  print(`  ${glyph.bullet} ${theme.dim("entry")}`);
-  print(
-    JSON.stringify(entry, null, 2).split("\n").map((l) => `    ${theme.dim(l)}`).join("\n")
-  );
-  if (!opts.yes) {
-    const ok = await confirm({
-      message: `Write this entry to ${path.basename(manifest.manifestPath)}?`
-    });
-    if (isCancel(ok) || !ok) {
-      cancel("No entry written.");
-      return;
-    }
-  }
-  let mappedTo;
-  if (profile === "corp") {
-    mappedTo = await recordCorpMapping(manifest, name, absTarget);
-  }
-  const doc = JSON.parse(raw);
-  if (!Array.isArray(doc.projects)) throw new Error("manifest has no `projects` array to append to");
-  doc.projects.push(entry);
-  await promises.writeFile(manifest.manifestPath, JSON.stringify(doc, null, 2) + "\n", "utf8");
-  print(`  ${glyph.ok} ${theme.dim("registered")} ${theme.info(name)}`);
-  if (mappedTo) {
-    print(
-      `  ${glyph.ok} ${theme.dim("mapped")} ${theme.info(`${name} \u2192 ${mappedTo}`)} ${theme.dim(`in ${path.basename(manifest.localPath)} (gitignored)`)}`
-    );
-  }
-  print(`  ${theme.dim(`verify with \`etymd fleet check --manifest ${manifest.manifestPath}\``)}`);
-}
-async function resolveFleetFinding(opts, status) {
-  if (status === "dismissed" && !opts.reason?.trim()) {
-    throw new Error('dismiss needs a reason: etymd fleet dismiss <name> <id> --reason "\u2026"');
-  }
-  const { manifest, autoNote } = await loadManifest(opts.cwd, opts.manifest);
-  if (autoNote) print(`  ${theme.dim(`\u25E6 ${autoNote}`)}`);
-  const target = await fleetLedgerTarget(manifest, opts.name);
-  const hadLedger = await pathExists(path.join(target.ledgerRoot, ".etymd"));
-  const { ledgerRoot, recorded } = await ensureFindingRecorded(manifest, opts.name, opts.id);
-  if (!recorded) {
-    throw new Error(
-      `no finding \`${opts.id}\` recorded for \`${opts.name}\` even after a fresh audit \u2014 check the id against \`etymd fleet\` output (fleet-manifest wall findings are not ledger-quietable)`
-    );
-  }
-  if (!hadLedger) {
-    print(
-      `  ${theme.dim(`first ledger for \`${opts.name}\`: created ${path.join(ledgerRoot, ".etymd")} (a persisting audit ran to record the finding)`)}`
-    );
-  }
-  const args = { cwd: ledgerRoot, id: opts.id, reason: opts.reason };
-  await (status === "dismissed" ? dismiss(args) : accept(args));
-  print(`  ${theme.dim(`ledger: ${path.join(ledgerRoot, ".etymd", "ledger.json")}`)}`);
-}
-async function dismiss2(opts) {
-  await resolveFleetFinding(opts, "dismissed");
-}
-async function accept2(opts) {
-  await resolveFleetFinding(opts, "accepted");
-}
-
-export { accept2 as accept, add, check, dismiss2 as dismiss, sweep };
+export { BOARD_JSON_SCHEMA, FLEET_JSON_SCHEMA, FLEET_TRUST_VALUES, MILESTONES_FILE, checkManifest, ensureFindingRecorded, fleetLedgerTarget, isFleetTrust, loadFleetManifest, parseInitiatives, parseMilestones, renderBoard, sweepFleet };