@indigoai-us/hq-cli 5.77.14 → 5.79.0

package/src/utils/pack-contributions.ts

@@ -1,450 +0,0 @@
-/**
- * Content-pack contribution helpers -- the SINGLE SOURCE OF TRUTH (US-003) for
- * the `contributes.* -> host` mapping that `hq install` wires via
- * `core/scripts/scan-packages.sh`.
- *
- * `pack-install.ts` only INSTALLS content packs (into `core/packages/<name>/`,
- * tracked by filesystem presence -- there is no registry file). The list /
- * update / uninstall lifecycle in `commands/packs.ts` needs to reason about the
- * SAME mapping so it can report link health and cleanly un-wire a pack without
- * leaving dangling symlinks.
- *
- * Historically that mapping was RESTATED in five places (the scan-packages.sh
- * bash `case`, pack-install.ts:validateManifest's `subpaths` record,
- * `linkFor`'s switch, `contributionLinks`, and the `PackContributeKey` union),
- * drift-guarded only by a substring check. US-003 collapses it to ONE
- * declarative table -- `CONTRIBUTION_TABLE` below -- with a row per key
- * `{ payload, host, wire }`:
- *
- *   - `PackContributeKey` is DERIVED from the table keys (see types.ts).
- *   - `linkFor` / `contributionLinks` / the `subpaths` validator READ the table.
- *   - `core/scripts/scan-packages.sh` reads a generated data block emitted from
- *     this same table (regenerate via `scripts/generate-scan-packages-table.mjs`).
- *
- * A parity test (`pack-contributions.test.ts`) asserts FULL key-set +
- * payload-suffix + wire-mode equivalence across every surface, so the copies
- * cannot drift.
- *
- * `wire` discriminates HOW a contribution reaches the host:
- *   - `symlink`: a single `ln -s` into a well-known host directory (every
- *     contribution type that shipped before MCP).
- *   - `merge`: the contribution is MERGED into a shared host config rather than
- *     symlinked (the `mcp` row -- registered into the Claude + Codex agent
- *     configs). The merge WIRING is delivered in US-004/US-005; US-003 only
- *     DECLARES the row as data so the table is the single source and the parity
- *     test guards the real invariant. `symlink`-only readers (linkFor,
- *     contributionLinks, the symlink validator, scan-packages) must SKIP
- *     `merge` rows -- they never produce a symlink.
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-import type { PackManifest, PackContributeKey } from '../types.js';
-import { CONTRIBUTION_TABLE, payloadFor, type WireMode } from './contribution-table.js';
-import {
-  unregisterMcpServers,
-  type UnregisterServerResult,
-  type SafeWriteEnv,
-  type AcquireLockOptions,
-} from '../commands/mcp-registration.js';
-
-// NOTE on dependency direction: this module imports from ../commands/mcp-registration.js
-// to un-register `wire:merge` (mcp) servers on uninstall. mcp-registration.ts imports
-// ONLY fs/os/path/smol-toml (it does NOT import from pack-contributions.ts), so there
-// is NO import cycle. If that ever changes, invert via a callback injected by packs.ts.
-
-export { CONTRIBUTION_TABLE };
-export type { WireMode };
-
-/**
- * Where a contributes key is ROUTED (US-005). Reads the single-source table's
- * `wire` field — `'symlink'` keys go through `linkFor`/`contributionLinks` (a
- * host `ln -s`); `'merge'` keys (e.g. `mcp`) go through the `registerMcpServers`
- * seam in `commands/mcp-registration.ts` and are NEVER symlinked.
- *
- * This is the explicit, code-enforced discriminator behind the invariant that
- * merge keys never reach the symlink path: callers fan out on the return value
- * rather than relying on `linkFor` happening to return `null`.
- */
-export function routeContribution(key: PackContributeKey): WireMode {
-  return CONTRIBUTION_TABLE[key].wire;
-}
-
-/**
- * The subset of a pack's declared `contributes` keys that are `wire: 'merge'`
- * (e.g. `mcp`) — the keys that MUST be routed to `registerMcpServers` (US-006)
- * and MUST NOT be symlinked. Unknown keys and non-array/empty values are
- * ignored, mirroring `contributionLinks`. Returned in `contributes` iteration
- * order, de-duplicated.
- */
-export function mergeKeys(
-  contributes: Partial<Record<PackContributeKey, string[]>>,
-): PackContributeKey[] {
-  const out: PackContributeKey[] = [];
-  for (const [key, items] of Object.entries(contributes) as [
-    PackContributeKey,
-    unknown,
-  ][]) {
-    if (!(key in CONTRIBUTION_TABLE)) continue; // unknown key -> ignore
-    if (!Array.isArray(items) || items.length === 0) continue;
-    if (routeContribution(key) === 'merge' && !out.includes(key)) out.push(key);
-  }
-  return out;
-}
-
-/** A single symlink a pack contributes: dst (host path) -> src (inside pack). */
-export interface WiredLink {
-  key: PackContributeKey;
-  item: string;
-  src: string; // absolute path inside core/packages/<pack>/
-  dst: string; // absolute host path the symlink lives at
-}
-
-export type LinkStatus =
-  | 'live' // dst is a symlink -> this pack's src, and src exists
-  | 'broken' // dst is a symlink -> this pack's src, but src is gone
-  | 'missing' // dst does not exist (declared but never wired / already removed)
-  | 'foreign'; // dst exists but points elsewhere or is a real file (collision)
-
-/**
- * Map one SYMLINK contributes entry to its source/host paths, READING the
- * single-source `CONTRIBUTION_TABLE` (US-003). The src is the expanded pack
- * payload; the dst is `<host-dir>/<payload-basename>` so per-key suffixes
- * (`.md`, `.sh`, none) carry through.
- *
- * Returns `null` for a `wire: 'merge'` key (e.g. `mcp`): a merge contribution
- * is not a symlink and has no `WiredLink`. Callers that only handle symlinks
- * (contributionLinks/unwirePack) skip those keys.
- */
-function linkFor(
-  hqRoot: string,
-  packDir: string,
-  key: PackContributeKey,
-  item: string,
-): WiredLink | null {
-  const row = CONTRIBUTION_TABLE[key];
-  if (row.wire !== 'symlink') return null;
-  const payloadRel = payloadFor(key, item); // e.g. commands/foo.md
-  // dst keeps the payload's basename (so the suffix carries through) under the
-  // host directory declared in the table.
-  const dstRel = path.join(row.host, path.basename(payloadRel));
-  return {
-    key,
-    item,
-    src: path.join(packDir, payloadRel),
-    dst: path.join(hqRoot, dstRel),
-  };
-}
-
-/**
- * Every SYMLINK a pack's `contributes` block declares. Empty subfields and
- * non-array values are ignored, mirroring scan-packages.sh. `wire: 'merge'`
- * keys (e.g. `mcp`) produce no symlink and are skipped here -- their host
- * effect (a config merge) is handled separately (US-004/US-005).
- */
-export function contributionLinks(
-  hqRoot: string,
-  packDir: string,
-  contributes: Partial<Record<PackContributeKey, string[]>>,
-): WiredLink[] {
-  const links: WiredLink[] = [];
-  for (const [key, items] of Object.entries(contributes) as [
-    PackContributeKey,
-    unknown,
-  ][]) {
-    if (!(key in CONTRIBUTION_TABLE)) continue; // unknown key -> ignore
-    if (!Array.isArray(items)) continue;
-    // INVARIANT (US-005): merge keys are NEVER symlinked. They route to
-    // registerMcpServers (commands/mcp-registration.ts) instead. Skip them
-    // explicitly here -- not just via linkFor returning null -- so the symlink
-    // path provably excludes them.
-    if (routeContribution(key) === 'merge') continue;
-    for (const item of items) {
-      if (typeof item !== 'string' || item.length === 0) continue;
-      const link = linkFor(hqRoot, packDir, key, item);
-      if (link) links.push(link); // null for merge keys -- skip
-    }
-  }
-  return links;
-}
-
-/** Classify a host path against the link that should own it. */
-export function linkStatus(link: WiredLink): LinkStatus {
-  let st: fs.Stats | undefined;
-  try {
-    st = fs.lstatSync(link.dst);
-  } catch {
-    return 'missing';
-  }
-  if (!st.isSymbolicLink()) {
-    return 'foreign'; // a real file/dir occupies the slot -- not ours
-  }
-  let target: string;
-  try {
-    target = fs.readlinkSync(link.dst);
-  } catch {
-    return 'foreign';
-  }
-  // scan-packages.sh writes the symlink target as the absolute `src` path, so a
-  // direct compare is correct. Resolve both to be robust to trailing slashes.
-  const resolvedTarget = path.resolve(path.dirname(link.dst), target);
-  if (path.resolve(link.src) !== resolvedTarget) {
-    return 'foreign'; // points at another pack / somewhere else
-  }
-  return fs.existsSync(link.src) ? 'live' : 'broken';
-}
-
-// ---------------------------------------------------------------------------
-// Installed-pack discovery
-// ---------------------------------------------------------------------------
-
-/** A content pack's manifest plus the install-time stamped source. */
-export interface InstalledPackManifest extends PackManifest {
-  source?: string; // stamped by pack-install.ts:stampInstallSource
-}
-
-export interface InstalledPack {
-  name: string; // directory name (== manifest.name when well-formed)
-  dir: string; // absolute path to core/packages/<name>/
-  manifest: InstalledPackManifest | null; // null when package.yaml is unreadable
-  error?: string; // parse/validation error message when manifest is null
-}
-
-/** Absolute path to `<hqRoot>/core/packages`. */
-export function packagesDir(hqRoot: string): string {
-  return path.join(hqRoot, 'core', 'packages');
-}
-
-/** Read and shallowly validate a pack's package.yaml. */
-export function readPackManifest(packDir: string): {
-  manifest: InstalledPackManifest | null;
-  error?: string;
-} {
-  const manifestPath = path.join(packDir, 'package.yaml');
-  if (!fs.existsSync(manifestPath)) {
-    return { manifest: null, error: 'package.yaml missing' };
-  }
-  try {
-    const parsed = yaml.load(fs.readFileSync(manifestPath, 'utf-8'));
-    if (!parsed || typeof parsed !== 'object') {
-      return { manifest: null, error: 'package.yaml is not a mapping' };
-    }
-    return { manifest: parsed as InstalledPackManifest };
-  } catch (e) {
-    return { manifest: null, error: `package.yaml invalid: ${(e as Error).message}` };
-  }
-}
-
-/**
- * Walk `core/packages/<name>/package.yaml`. Skips the `.archive` dir, the bundled
- * `README.md`, and any non-directory entry. Filesystem presence is the source
- * of truth for installed content packs.
- */
-export function listInstalledPacks(hqRoot: string): InstalledPack[] {
-  const dir = packagesDir(hqRoot);
-  if (!fs.existsSync(dir)) return [];
-  const out: InstalledPack[] = [];
-  for (const name of fs.readdirSync(dir).sort()) {
-    if (name.startsWith('.')) continue; // .archive, .DS_Store, etc.
-    const packDir = path.join(dir, name);
-    let st: fs.Stats;
-    try {
-      st = fs.statSync(packDir);
-    } catch {
-      continue;
-    }
-    if (!st.isDirectory()) continue; // README.md and friends
-    const { manifest, error } = readPackManifest(packDir);
-    if (!manifest && !fs.existsSync(path.join(packDir, 'package.yaml'))) {
-      continue; // a plain dir that isn't a pack -- ignore silently
-    }
-    out.push({ name, dir: packDir, manifest, error });
-  }
-  return out;
-}
-
-/**
- * Installed packs that declare `name` in their `requires.packs` (M0). Pure over
- * the supplied list — the uninstall dependents guard calls this with
- * `listInstalledPacks(hqRoot)`. Excludes the pack named `name` itself, so a
- * self-reference never counts as its own dependent.
- */
-export function findDependentPacks(
-  installed: InstalledPack[],
-  name: string,
-): InstalledPack[] {
-  return installed.filter(
-    (p) =>
-      p.name !== name &&
-      (p.manifest?.requires?.packs ?? []).some((d) => d.name === name),
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Un-wiring (the uninstall guarantee)
-// ---------------------------------------------------------------------------
-
-export interface UnwireResult {
-  unlinked: Array<{ key: PackContributeKey; item: string; dst: string }>;
-  skipped: Array<{
-    key: PackContributeKey;
-    item: string;
-    dst: string;
-    reason: 'foreign' | 'missing';
-  }>;
-}
-
-/**
- * Remove only the host symlinks that resolve into THIS pack's directory
- * (status `live` or `broken`). Foreign links and real files are left in place
- * -- same collision philosophy as scan-packages.sh. This is what prevents an
- * uninstall from leaving dangling symlinks behind.
- */
-export function unwirePack(
-  hqRoot: string,
-  packDir: string,
-  contributes: Partial<Record<PackContributeKey, string[]>>,
-): UnwireResult {
-  const result: UnwireResult = { unlinked: [], skipped: [] };
-  for (const link of contributionLinks(hqRoot, packDir, contributes)) {
-    const status = linkStatus(link);
-    if (status === 'live' || status === 'broken') {
-      try {
-        fs.unlinkSync(link.dst);
-        result.unlinked.push({ key: link.key, item: link.item, dst: link.dst });
-      } catch {
-        result.skipped.push({
-          key: link.key,
-          item: link.item,
-          dst: link.dst,
-          reason: 'foreign',
-        });
-      }
-    } else {
-      result.skipped.push({
-        key: link.key,
-        item: link.item,
-        dst: link.dst,
-        reason: status === 'missing' ? 'missing' : 'foreign',
-      });
-    }
-  }
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// MCP un-wiring (US-009) — the `wire: 'merge'` parallel to symlink un-wiring.
-//
-// `unwirePack` above only removes SYMLINKS: it iterates `contributionLinks`, which
-// SKIPS every `wire: 'merge'` key (e.g. `mcp`). So a pack's MCP servers — registered
-// into ~/.claude.json + ~/.codex/config.toml, NOT symlinked — are INVISIBLE to the
-// symlink unwire and would leak after uninstall. `unwirePackMcp` is the parallel
-// path: for each name in `contributes.mcp` it calls `unregisterMcpServers` (US-009),
-// which removes ONLY entries whose `_hqPack` provenance matches THIS pack and
-// skip-and-warns on any foreign/unstamped same-named entry.
-//
-// Kept as a SEPARATE, composable call from `unwirePack` (not folded into it) so the
-// existing `unwirePack` signature + tests stay intact and each path is testable in
-// isolation. The uninstall command composes both (symlink unwire + MCP unwire).
-// ---------------------------------------------------------------------------
-
-/** The result of {@link unwirePackMcp}: the per-server un-registration outcomes (empty when no `mcp` keys). */
-export interface UnwireMcpResult {
-  /** One {@link UnregisterServerResult} per declared `contributes.mcp` server, in declaration order. */
-  servers: UnregisterServerResult[];
-}
-
-/** Tuning passthrough for {@link unwirePackMcp} (tests inject a tmpdir `env.home` + tiny lock timeouts). */
-export interface UnwirePackMcpOptions {
-  /** Injectable env — tests MUST pass a tmpdir `home` so the real ~/.claude.json / ~/.codex are untouched. */
-  env?: Partial<SafeWriteEnv>;
-  /** Lock tuning (tests use tiny timeouts). */
-  lock?: AcquireLockOptions;
-  /** Backup timestamp override (deterministic tests). */
-  stamp?: string;
-}
-
-/**
- * Un-register the `wire: 'merge'` (MCP) servers a pack declares — the parallel to
- * {@link unwirePack}'s symlink removal. For each name in `mergeKeys(contributes)` →
- * `contributes.<mergeKey>` (today only `mcp`), this delegates to
- * {@link unregisterMcpServers}, which removes ONLY entries stamped with THIS pack's
- * `_hqPack` provenance and SKIPS-AND-WARNS on a foreign/unstamped same-named entry.
- *
- * No-ops cleanly when the pack declares no merge keys (returns `{ servers: [] }`),
- * when the runtime config is absent (Codex-less host → first-class skip; missing
- * ~/.claude.json → `absent`), and on a re-run (already-removed → `absent`). It does
- * NOT throw on a foreign entry — uninstall of one pack must not abort on a server
- * another pack (or the user) owns.
- *
- * @param packName    the pack being uninstalled — the provenance to match
- * @param contributes the pack's `contributes` block (its `mcp` list drives removal)
- */
-export function unwirePackMcp(
-  packName: string,
-  contributes: Partial<Record<PackContributeKey, string[]>>,
-  options?: UnwirePackMcpOptions,
-): UnwireMcpResult {
-  const servers: UnregisterServerResult[] = [];
-  for (const key of mergeKeys(contributes)) {
-    const names = (contributes[key] ?? []).filter(
-      (n): n is string => typeof n === 'string' && n.length > 0,
-    );
-    if (names.length === 0) continue;
-    servers.push(
-      ...unregisterMcpServers(packName, names, {
-        env: options?.env,
-        lock: options?.lock,
-        stamp: options?.stamp,
-      }),
-    );
-  }
-  return { servers };
-}
-
-// ---------------------------------------------------------------------------
-// Host introspection: hqVersion + recommended_packages catalog
-// ---------------------------------------------------------------------------
-
-/** Locate core.yaml -- v14+ nests it under `core/`, older layouts at the root. */
-function coreYamlPath(hqRoot: string): string | null {
-  const nested = path.join(hqRoot, 'core', 'core.yaml');
-  if (fs.existsSync(nested)) return nested;
-  const flat = path.join(hqRoot, 'core.yaml');
-  if (fs.existsSync(flat)) return flat;
-  return null;
-}
-
-export function readHqVersion(hqRoot: string): string | null {
-  const p = coreYamlPath(hqRoot);
-  if (!p) return null;
-  try {
-    const c = yaml.load(fs.readFileSync(p, 'utf-8')) as { hqVersion?: string };
-    return c?.hqVersion ?? null;
-  } catch {
-    return null;
-  }
-}
-
-export interface CatalogEntry {
-  source: string;
-  description?: string;
-  conditional?: string;
-  auto_install?: boolean;
-}
-
-/** Read `recommended_packages` from core.yaml (the curated content-pack catalog). */
-export function readRecommendedPackages(hqRoot: string): CatalogEntry[] {
-  const p = coreYamlPath(hqRoot);
-  if (!p) return [];
-  try {
-    const c = yaml.load(fs.readFileSync(p, 'utf-8')) as {
-      recommended_packages?: CatalogEntry[];
-    };
-    const list = c?.recommended_packages;
-    return Array.isArray(list) ? list : [];
-  } catch {
-    return [];
-  }
-}

package/src/utils/people.ts

@@ -1,215 +0,0 @@
-/**
- * Company people (membership) directory reader + search.
- *
- * The local source of truth for "who belongs to a company" is the per-company
- * people store on disk:
- *
- *     companies/<company-slug>/people/<person-slug>/meta.yaml
- *
- * Each `meta.yaml` carries at least `name` and `type` ("internal" | "external")
- * plus optional `email`, `role`, `organization`, `tags`, etc. (see
- * `companies/_template/people/_example/meta.yaml` for the canonical schema).
- *
- * Everything here is scoped to ONE company directory. Callers resolve a single
- * company slug up front; nothing in this module ever enumerates or reads across
- * company boundaries — HQ tenancy rules forbid cross-company member lookups.
- */
-
-import * as fs from "fs";
-import * as path from "path";
-import { parseUserYaml } from "./user-yaml-error.js";
-
-/** A single person/member record parsed from a `people/<slug>/meta.yaml`. */
-export interface PersonRecord {
-  /** Folder slug under `companies/<company>/people/<slug>/`. */
-  slug: string;
-  /** Display name (required field in `meta.yaml`). */
-  name: string;
-  /** Contact email, when recorded. */
-  email?: string;
-  /** "internal" (team member) | "external" (client, vendor, …). */
-  type?: string;
-  /** Role/title inside (or relative to) the company. */
-  role?: string;
-  /** External-only: the person's own organization. */
-  organization?: string;
-  /** Freeform tags for filtering. */
-  tags?: string[];
-  /** Absolute path to the `meta.yaml` this record was parsed from. */
-  source: string;
-}
-
-/**
- * Company slugs map directly onto a filesystem path segment, so we validate
- * them before joining to keep a malicious or fat-fingered `--company` value
- * from escaping the `companies/` tree. Mirrors the slug rules used by
- * cloud-provision.
- */
-const COMPANY_SLUG_REGEX = /^[A-Za-z0-9._-]+$/;
-const FORBIDDEN_COMPANY_SLUGS = new Set(["personal", ".", ".."]);
-
-export function assertSafeCompanySlug(slug: string): void {
-  if (!slug || !COMPANY_SLUG_REGEX.test(slug)) {
-    throw new Error(
-      `Invalid company slug "${slug}" — must match ${COMPANY_SLUG_REGEX.source}`,
-    );
-  }
-  if (FORBIDDEN_COMPANY_SLUGS.has(slug)) {
-    throw new Error(`Company slug "${slug}" is reserved and cannot be used here`);
-  }
-}
-
-/** Absolute path to a company's `people/` directory. */
-export function companyPeopleDir(hqRoot: string, companySlug: string): string {
-  assertSafeCompanySlug(companySlug);
-  return path.join(hqRoot, "companies", companySlug, "people");
-}
-
-/**
- * Parse a single `meta.yaml` body into a `PersonRecord`. Returns `null` when the
- * file is empty, unparseable, or has no usable `name` — a person record without
- * a name can't be listed, searched, or resolved, so it's skipped rather than
- * surfaced as a half-row. Exported for unit testing.
- */
-export function parsePersonMeta(
-  raw: string,
-  slug: string,
-  source: string,
-): PersonRecord | null {
-  const doc = parseUserYaml<unknown>(raw, source);
-  if (!doc || typeof doc !== "object") return null;
-  const d = doc as Record<string, unknown>;
-
-  const name = typeof d.name === "string" ? d.name.trim() : "";
-  if (!name) return null;
-
-  const str = (v: unknown): string | undefined =>
-    typeof v === "string" && v.trim() ? v.trim() : undefined;
-
-  const tags = Array.isArray(d.tags)
-    ? d.tags.filter((t): t is string => typeof t === "string")
-    : undefined;
-
-  return {
-    slug,
-    name,
-    email: str(d.email),
-    type: str(d.type),
-    role: str(d.role),
-    organization: str(d.organization),
-    ...(tags && tags.length > 0 ? { tags } : {}),
-    source,
-  };
-}
-
-/**
- * List every person recorded for ONE company. Reads
- * `companies/<companySlug>/people/<personSlug>/meta.yaml` for each person
- * folder.
- *
- * - Folders whose name starts with `_` are skipped (e.g. the `_example`
- *   template that ships in `companies/_template/people/`).
- * - Folders without a `meta.yaml`, or whose `meta.yaml` has no `name`, are
- *   skipped silently — they aren't members yet.
- * - Returns `[]` when the company has no `people/` directory at all.
- *
- * Results are sorted by name (case-insensitive) for stable output.
- */
-export function listCompanyPeople(
-  hqRoot: string,
-  companySlug: string,
-): PersonRecord[] {
-  const dir = companyPeopleDir(hqRoot, companySlug);
-  if (!fs.existsSync(dir)) return [];
-
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  const people: PersonRecord[] = [];
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    if (entry.name.startsWith("_")) continue; // _example and other scaffolding
-
-    const metaPath = path.join(dir, entry.name, "meta.yaml");
-    if (!fs.existsSync(metaPath)) continue;
-
-    const raw = fs.readFileSync(metaPath, "utf-8");
-    const record = parsePersonMeta(raw, entry.name, metaPath);
-    if (record) people.push(record);
-  }
-
-  people.sort((a, b) =>
-    a.name.localeCompare(b.name, undefined, { sensitivity: "base" }),
-  );
-  return people;
-}
-
-/**
- * Case-insensitive keyword search over a person's NAME and EMAIL (plus the
- * folder slug, which is a normalized alias of the name). Pure — operates on an
- * already-loaded list so it's trivially testable and reusable.
- *
- * An empty/whitespace keyword matches nothing (callers should treat that as a
- * usage error rather than "return everyone").
- */
-export function searchPeople(
-  people: PersonRecord[],
-  keyword: string,
-): PersonRecord[] {
-  const needle = keyword.trim().toLowerCase();
-  if (!needle) return [];
-  return people.filter((p) => {
-    const haystacks = [p.name, p.email, p.slug].filter(
-      (v): v is string => typeof v === "string",
-    );
-    return haystacks.some((h) => h.toLowerCase().includes(needle));
-  });
-}
-
-/** Outcome of resolving a name to an email address. */
-export type ResolveResult =
-  | { status: "found"; email: string; person: PersonRecord }
-  | { status: "no_email"; person: PersonRecord }
-  | { status: "ambiguous"; matches: PersonRecord[] }
-  | { status: "not_found" };
-
-/**
- * Resolve a person NAME to their email, built on top of {@link searchPeople}.
- *
- * Match precedence (narrowest first) so a precise query isn't drowned out by
- * looser substring hits:
- *   1. exact name match (case-insensitive, trimmed)
- *   2. exact folder-slug match
- *   3. substring search over name/email/slug
- *
- * The first tier that yields any match decides the result:
- *   - exactly one match with an email  → `found`
- *   - exactly one match, no email      → `no_email`
- *   - more than one match              → `ambiguous` (caller disambiguates)
- *   - no match in any tier             → `not_found`
- */
-export function resolveNameToEmail(
-  people: PersonRecord[],
-  name: string,
-): ResolveResult {
-  const query = name.trim();
-  if (!query) return { status: "not_found" };
-  const lowered = query.toLowerCase();
-
-  const exactName = people.filter((p) => p.name.toLowerCase() === lowered);
-  const exactSlug = people.filter((p) => p.slug.toLowerCase() === lowered);
-  const substring = searchPeople(people, query);
-
-  const matches =
-    exactName.length > 0
-      ? exactName
-      : exactSlug.length > 0
-        ? exactSlug
-        : substring;
-
-  if (matches.length === 0) return { status: "not_found" };
-  if (matches.length > 1) return { status: "ambiguous", matches };
-
-  const person = matches[0];
-  if (!person.email) return { status: "no_email", person };
-  return { status: "found", email: person.email, person };
-}