@opum-ai/lore 0.1.0 → 0.1.1

package/src/commands/agent.ts

@@ -1,301 +0,0 @@
-/** Thin CLI layer for singular task-scoped agent context profiles. */
-
-import { readFileSync } from "node:fs";
-import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
-import type { BacklogAdapter } from "../adapters/backlog";
-import { type AgentContextExport, compileAgentContext, renderAgentContextMarkdown } from "../core/agent-context";
-import {
-  type AgentProfile,
-  findAgentProfile,
-  loadAgentProfiles,
-  validateAgentProfileReferences,
-} from "../core/agent-profile";
-import { compareCodeUnits } from "../core/order";
-import { loadReferenceRetrievalGraph, type RetrievalGraphLoader } from "../core/retrieval";
-import { EXIT_OK, LoreError, WarningCollector, type Writer } from "../errors";
-import { emit, type OutputContext, type Renderable } from "../output";
-import { assertFlagAtMostOnce, parseCommandArgs, singleOptionValue, usage } from "./args";
-import { readSource } from "./discover";
-import { assertNoSymlinkInPath, classifyExistingFile, ensureDir, writeFileAtomic } from "./fswrite";
-
-export interface AgentCommandOptions {
-  readonly root: string;
-  readonly output: OutputContext;
-  readonly args: readonly string[];
-  readonly stdout?: Writer;
-  readonly stderr?: Writer;
-  readonly adapter?: BacklogAdapter;
-  readonly retrieval?: RetrievalGraphLoader;
-  readonly readTaskFile?: (path: string) => string;
-}
-
-export interface AgentProfilesResult {
-  readonly profiles: readonly AgentProfileSummary[];
-}
-
-export interface AgentProfileSummary {
-  readonly name: string;
-  readonly kind: AgentProfile["kind"];
-  readonly description: string;
-  readonly maxTokens: number;
-  readonly sourceCount: number;
-  readonly delegateCount: number;
-}
-
-export interface AgentProfileResult extends AgentProfileSummary {
-  readonly pinned: readonly string[];
-  readonly sources: readonly string[];
-  readonly delegates: readonly string[];
-  readonly path: string;
-}
-
-type AgentAction =
-  | { readonly kind: "list" }
-  | { readonly kind: "show"; readonly name: string }
-  | {
-      readonly kind: "context";
-      readonly name: string;
-      readonly task?: string;
-      readonly taskFile?: string;
-      readonly maxTokens?: number;
-      readonly out?: string;
-      readonly force: boolean;
-    };
-
-export async function runAgent(options: AgentCommandOptions): Promise<number> {
-  const action = parseAgentArgs(options.args);
-  const snapshot = loadAgentProfiles(options.root);
-  const advisories = new WarningCollector();
-  const retrieval = await (options.retrieval ?? loadReferenceRetrievalGraph)({
-    root: options.root,
-    warnings: advisories,
-    adapter: options.adapter,
-  });
-  try {
-    validateAgentProfileReferences(snapshot, retrieval.graph);
-    advisories.flush({ color: options.output.color, stderr: options.stderr });
-    if (action.kind === "list") {
-      const data: AgentProfilesResult = {
-        profiles: [...snapshot.profiles.values()].sort((a, b) => compareCodeUnits(a.name, b.name)).map(summary),
-      };
-      emit(profilesRenderable(data), options.output, options.stdout);
-      return EXIT_OK;
-    }
-    const profile = findAgentProfile(snapshot, action.name);
-    if (action.kind === "show") {
-      const data: AgentProfileResult = {
-        ...summary(profile),
-        pinned: profile.pinned.map((reference) => reference.normalized),
-        sources: profile.sources.map((reference) => reference.normalized),
-        delegates: [...profile.delegates],
-        path: profile.path,
-      };
-      emit(profileRenderable(data), options.output, options.stdout);
-      return EXIT_OK;
-    }
-
-    const task = resolveTask(action, options);
-    let data = compileAgentContext(snapshot, retrieval.graph, profile.name, task, action.maxTokens);
-    const markdown = renderAgentContextMarkdown(data);
-    if (action.out !== undefined) {
-      const target = confineOutFile(action.out, options.root);
-      assertNoSymlinkInPath(options.root, target.relPath);
-      const state = classifyExistingFile(target.absPath, markdown);
-      if (state === "differs" && !action.force) {
-        throw new LoreError(
-          "conflict",
-          `cannot overwrite differing context file ${target.relPath}`,
-          "pass --force to replace it, choose another --out path, or remove the existing file",
-          { path: target.relPath },
-        );
-      }
-      const writeAction = state === "missing" ? "created" : state === "unchanged" ? "unchanged" : "updated";
-      if (state !== "unchanged") {
-        ensureDir(options.root, dirname(target.relPath));
-        writeFileAtomic(target.absPath, markdown, target.relPath);
-      }
-      data = { ...data, write: { path: target.relPath, action: writeAction } };
-    }
-    emit(contextRenderable(data), options.output, options.stdout);
-    return EXIT_OK;
-  } finally {
-    await retrieval.dispose?.();
-  }
-}
-
-function parseAgentArgs(args: readonly string[]): AgentAction {
-  const parsed = parseCommandArgs(args, "agent");
-  for (const flag of ["task", "task-file", "max-tokens", "out", "force"]) {
-    assertFlagAtMostOnce(parsed, flag);
-  }
-  const action = parsed.positionals[0];
-  if (action === undefined) {
-    throw usage(
-      "`lore agent` needs an action",
-      "run `lore agent list`, `lore agent show <name>`, or `lore agent context <name> --task <text>`",
-    );
-  }
-  if (action === "list") {
-    assertArityAndNoFlags(parsed, 1, "`lore agent list` takes no arguments or command flags", "run `lore agent list`");
-    return { kind: "list" };
-  }
-  if (action === "show") {
-    assertArityAndNoFlags(
-      parsed,
-      2,
-      "`lore agent show` needs exactly one profile name",
-      "run `lore agent show <name>`",
-    );
-    return { kind: "show", name: parsed.positionals[1] as string };
-  }
-  if (action !== "context") {
-    throw usage(`unknown agent action "${action}"`, "use list, show, or context", { action });
-  }
-  if (parsed.positionals.length !== 2) {
-    throw usage("`lore agent context` needs exactly one profile name", "run `lore agent context <name> --task <text>`");
-  }
-  const task = nonEmptyOption(parsed, "task");
-  const taskFile = nonEmptyOption(parsed, "task-file");
-  if ((task === undefined) === (taskFile === undefined)) {
-    throw usage(
-      "agent context needs exactly one of --task or --task-file",
-      "pass task text directly or read it from one path (use --task-file - for stdin)",
-    );
-  }
-  const rawMaxTokens = nonEmptyOption(parsed, "max-tokens");
-  const maxTokens = rawMaxTokens === undefined ? undefined : parsePositiveInteger("--max-tokens", rawMaxTokens);
-  const out = nonEmptyOption(parsed, "out");
-  const force = parsed.flags.has("force");
-  if (force && out === undefined) {
-    throw usage("--force requires --out", "pass an output path or remove --force");
-  }
-  return {
-    kind: "context",
-    name: parsed.positionals[1] as string,
-    ...(task === undefined ? {} : { task }),
-    ...(taskFile === undefined ? {} : { taskFile }),
-    ...(maxTokens === undefined ? {} : { maxTokens }),
-    ...(out === undefined ? {} : { out }),
-    force,
-  };
-}
-
-function assertArityAndNoFlags(
-  parsed: ReturnType<typeof parseCommandArgs>,
-  arity: number,
-  message: string,
-  hint: string,
-): void {
-  if (parsed.positionals.length !== arity || parsed.flags.size > 0) throw usage(message, hint);
-}
-
-function nonEmptyOption(parsed: ReturnType<typeof parseCommandArgs>, name: string): string | undefined {
-  const value = singleOptionValue(parsed, name);
-  if (value === undefined) return undefined;
-  if (value.trim() === "") throw usage(`--${name} needs a value`, `pass --${name}=<value>`);
-  return value;
-}
-
-function parsePositiveInteger(flag: string, value: string): number {
-  if (!/^\d+$/.test(value)) throw usage(`invalid ${flag} "${value}"`, `pass a positive integer, e.g. ${flag} 8000`);
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isSafeInteger(parsed)) throw usage(`${flag} "${value}" is too large`, "pass a smaller integer");
-  if (parsed < 1) throw usage(`invalid ${flag} "${value}"`, `pass a positive integer, e.g. ${flag} 8000`);
-  return parsed;
-}
-
-function resolveTask(action: Extract<AgentAction, { kind: "context" }>, options: AgentCommandOptions): string {
-  if (action.task !== undefined) return action.task;
-  const path = action.taskFile as string;
-  if (options.readTaskFile !== undefined) return options.readTaskFile(path);
-  if (path === "-") {
-    try {
-      return readFileSync(0, "utf8");
-    } catch (cause) {
-      throw new LoreError("denied", "cannot read task text from stdin", "pipe readable UTF-8 task text to stdin", {
-        path: "-",
-        cause: cause instanceof Error ? cause.message : String(cause),
-      });
-    }
-  }
-  const target = confineRepoFile(path, options.root, "--task-file");
-  assertNoSymlinkInPath(options.root, target.relPath);
-  return readSource(target.absPath, target.relPath);
-}
-
-function confineOutFile(out: string, root: string): { absPath: string; relPath: string } {
-  return confineRepoFile(out, root, "--out");
-}
-
-function confineRepoFile(
-  path: string,
-  root: string,
-  flag: "--out" | "--task-file",
-): { absPath: string; relPath: string } {
-  const absPath = resolve(root, path);
-  const rel = relative(root, absPath);
-  if (isAbsolute(path) || rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
-    throw usage(`${flag} path "${path}" must name a file inside the repo`, `give ${flag} a repo-relative file path`);
-  }
-  return { absPath, relPath: rel.split(sep).join("/") };
-}
-
-function summary(profile: AgentProfile): AgentProfileSummary {
-  return {
-    name: profile.name,
-    kind: profile.kind,
-    description: profile.description,
-    maxTokens: profile.maxTokens,
-    sourceCount: profile.pinned.length + profile.sources.length,
-    delegateCount: profile.delegates.length,
-  };
-}
-
-function profilesRenderable(data: AgentProfilesResult): Renderable<AgentProfilesResult> {
-  return {
-    kind: "agent.profiles",
-    data,
-    pretty: renderProfiles,
-    plain: renderProfiles,
-  };
-}
-
-function profileRenderable(data: AgentProfileResult): Renderable<AgentProfileResult> {
-  return {
-    kind: "agent.profile",
-    data,
-    pretty: renderProfile,
-    plain: renderProfile,
-  };
-}
-
-function contextRenderable(data: AgentContextExport): Renderable<AgentContextExport> {
-  return {
-    kind: "agent.context.export",
-    data,
-    pretty: renderAgentContextMarkdown,
-    plain: renderAgentContextMarkdown,
-  };
-}
-
-function renderProfiles(data: AgentProfilesResult): string {
-  if (data.profiles.length === 0) return "agent profiles: none";
-  return [
-    `agent profiles: ${data.profiles.length}`,
-    ...data.profiles.map(
-      (profile) =>
-        `- ${profile.name} [${profile.kind}] — ${profile.description} (budget ${profile.maxTokens}; sources ${profile.sourceCount}; delegates ${profile.delegateCount})`,
-    ),
-  ].join("\n");
-}
-
-function renderProfile(data: AgentProfileResult): string {
-  return [
-    `${data.name} [${data.kind}] — ${data.description}`,
-    `budget: ${data.maxTokens}`,
-    `path: ${data.path}`,
-    `pinned: ${data.pinned.length === 0 ? "none" : data.pinned.join(", ")}`,
-    `sources: ${data.sources.length === 0 ? "none" : data.sources.join(", ")}`,
-    `delegates: ${data.delegates.length === 0 ? "none" : data.delegates.join(", ")}`,
-  ].join("\n");
-}

package/src/commands/agents.ts

@@ -1,302 +0,0 @@
-/**
- * commands/agents.ts — `lore agents`: generate/refresh the Claude Code agent bridge.
- *
- * The thin, side-effecting layer over the pure {@link planBridge} (core/agent-bridge.ts): it resolves
- * the two bridge paths, reads their current bytes, asks core what each file's next state should be,
- * and applies the writes — unless `--check`, which reports drift and writes nothing. All the bytes
- * and all the decisions live in core; only the filesystem IO and the exit-code selection live here
- * (lore-design §2.1), exactly as `lore init` splits `runInit` from `buildScaffold`.
- *
- * Contract (docs/reference/cli-surface.md §agents): no positional args; `--force` overwrites a
- * differing (possibly hand-edited) SKILL.md; `--check` reports drift without writing — a CI gate for
- * a stale bridge, returning exit `6` (`drift`) when anything is out of date, `0` otherwise. Output is
- * `kind: agents.result`. A malformed `lore:agents` marker pair in CLAUDE.md surfaces as the
- * `validation` error {@link upsertManagedBlock} throws (exit 6), never a silent guess.
- */
-
-import { dirname, join } from "node:path";
-import { type BridgeAction, CLAUDE_MD_REL_PATH, planBridge, SKILL_REL_PATH } from "../core/agent-bridge";
-import { ANSI, EXIT_CODES, EXIT_OK, paint, readFileIfPresent, type Writer } from "../errors";
-import { emit, type OutputContext, type Renderable } from "../output";
-import { parseCommandArgs, usage } from "./args";
-import { assertNoSymlinkInAnyPath, ensureDir, writeFileAtomic } from "./fswrite";
-
-/** Options for {@link runAgents}; `root` and the stdout stream are injectable for tests. */
-export interface AgentsOptions {
-  /** The repo root the bridge is written into. */
-  root: string;
-  /** The resolved output mode/color (from `output.ts`). */
-  output: OutputContext;
-  /** The command's normalized tokens from Commander. */
-  args: readonly string[];
-  /** stdout sink; defaults to `process.stdout`. */
-  stdout?: Writer;
-}
-
-/** The `agents.result` payload: the run's mode plus the decided next state of each bridge file. */
-export interface AgentsResult {
-  /** The repo root the bridge was generated in. */
-  root: string;
-  /** Whether this was a `--check` run (report only, no writes). */
-  check: boolean;
-  /** Whether `--force` was given. */
-  force: boolean;
-  /** Each bridge file and what happened (or would happen, under `--check`) to it. */
-  files: ReadonlyArray<{ path: string; action: BridgeAction }>;
-}
-
-/** The parsed, validated arguments {@link applyAgentsBridge} needs — `root` plus `--force`/`--check`. */
-export interface ApplyAgentsOptions {
-  /** The repo root the bridge is written into (or checked against). */
-  root: string;
-  /** `--force`: overwrite a differing (possibly hand-edited) SKILL.md. */
-  force: boolean;
-  /** `--check`: report drift without writing. */
-  check: boolean;
-}
-
-/**
- * Plan both bridge files from their on-disk bytes and apply the writes (unless `check`) — the pure
- * side-effecting core of `lore agents`, extracted (LORE-260) so `lore init`'s wizard/flags can fold
- * the agent bridge into one onboarding run without going through `runAgents`' own arg-parsing/emit
- * (which would print a second, separate envelope onto the SAME stdout `lore init` owns — the
- * `--json` contract requires stdout be exclusively `init`'s own envelope, cli-contract §4). Returns
- * the {@link AgentsResult}; the caller decides what to do with it (emit it directly for `lore agents`
- * itself, or fold it into a larger structured result for `lore init`).
- */
-export function applyAgentsBridge(options: ApplyAgentsOptions): AgentsResult {
-  const { root, force, check } = options;
-
-  const skillOnDisk = normalizeOnDisk(readFileIfPresent(join(root, SKILL_REL_PATH), SKILL_REL_PATH));
-  const claudeRaw = readFileIfPresent(join(root, CLAUDE_MD_REL_PATH), CLAUDE_MD_REL_PATH);
-  const claudeOnDisk = normalizeOnDisk(claudeRaw);
-  // Detected from the RAW (pre-normalization) bytes, so a refresh of just the managed block can
-  // re-apply the file's own BOM/EOL convention instead of silently rewriting it to LF/no-BOM
-  // (LORE-128) — see reapplyDiskStyle below.
-  const claudeStyle = detectDiskStyle(claudeRaw);
-
-  // Pass both flags through: a differing SKILL.md is `protected` unless `--force` was given, AND
-  // `--check` is not in effect. `--check` never writes, so `--force` cannot actually take effect
-  // during one — `planBridge` must not report `updated` (a claimed write) for a run that performs
-  // none, or the printed trailer falls through to the inert plain-`lore agents` remedy, which
-  // leaves the file `protected` again and CI stays red (LORE-129).
-  const plan = planBridge({ skillOnDisk, claudeOnDisk, force, check });
-
-  if (!check) {
-    const targets = plan.files.filter((file) => file.contents !== null).map((file) => file.path);
-    // Swept as a whole before either file is written (LORE-93 AC#5) — `lore agents` writes two
-    // files per run, and a bad target reached second in the loop must not leave the first already
-    // written; ensureDir's own per-call guard alone is reactive to loop order.
-    assertNoSymlinkInAnyPath(root, targets);
-    for (const file of plan.files) {
-      if (file.contents === null) {
-        continue; // unchanged, or protected without --force — leave the file untouched
-      }
-      const absPath = join(root, file.path);
-      ensureDir(root, dirname(file.path));
-      // CLAUDE.md is a managed-block refresh over a user's hand-authored file: re-apply its
-      // original BOM/EOL convention before writing (LORE-128). SKILL.md is wholesale-regenerated
-      // (planSkill), so no such preservation applies there.
-      const contents = file.path === CLAUDE_MD_REL_PATH ? reapplyDiskStyle(file.contents, claudeStyle) : file.contents;
-      // Atomic (temp-write + rename): `lore agents` writes two files per run, one of them the user's
-      // hand-authored root CLAUDE.md — a crash mid-write must never leave it truncated (fswrite.ts).
-      writeFileAtomic(absPath, contents, file.path);
-    }
-  }
-
-  return {
-    root,
-    check,
-    force,
-    files: plan.files.map((file) => ({ path: file.path, action: file.action })),
-  };
-}
-
-/**
- * Run `lore agents`: the thin CLI layer over {@link applyAgentsBridge} — parse the arguments, apply
- * the bridge, render the result, and return the exit code. `--check` writes nothing and returns `6`
- * (`drift`) when any file is out of date, `0` otherwise; a normal run returns `0` (a differing
- * SKILL.md left `protected` for lack of `--force` is reported, not an error — `--check` is the gate).
- */
-export function runAgents(options: AgentsOptions): number {
-  const { force, check } = parseAgentsArgs(options.args);
-  const result = applyAgentsBridge({ root: options.root, force, check });
-  const drift = result.files.some((file) => file.action !== "unchanged");
-  emit(agentsRenderable(result), options.output, options.stdout);
-  return check && drift ? EXIT_CODES.drift : EXIT_OK;
-}
-
-/** Parse `agents`' tokens: no positionals; boolean `--force`/`--check`. A positional or unknown flag is a `usage` error (exit 2). */
-function parseAgentsArgs(args: readonly string[]): { force: boolean; check: boolean } {
-  const { positionals, flags } = parseCommandArgs(args, "agents");
-  if (positionals.length > 0) {
-    throw usage(
-      `\`lore agents\` takes no arguments, got "${positionals[0]}"`,
-      "run `lore agents [--check] [--force]`",
-      {
-        unexpected: [...positionals],
-      },
-    );
-  }
-  return { force: flags.has("force"), check: flags.has("check") };
-}
-
-/**
- * Coerce a raw read (absent → `undefined`) into the `string | null` the planner expects, normalizing
- * line endings and a leading BOM to LF — the line-ending half of concept.ts's `normalizeInput`, so a
- * CRLF/lone-CR/BOM-prefixed file compares equal to the LF-only generated content instead of reading
- * as spurious drift. It deliberately does NOT strip leading whitespace the way `normalizeInput` does:
- * that would clobber the head of a user's hand-authored CLAUDE.md.
- */
-function normalizeOnDisk(raw: string | undefined): string | null {
-  return raw === undefined ? null : raw.replace(/^\uFEFF+/, "").replace(/\r\n?/g, "\n");
-}
-
-/** A file's on-disk BOM presence and dominant line-ending convention, detected from its RAW bytes. */
-interface DiskStyle {
-  /** Whether the raw file began with a UTF-8 BOM (`\uFEFF`). */
-  readonly bom: boolean;
-  /** The dominant EOL sequence: `\r\n` (CRLF) or `\r` (lone CR) if either appears, else `\n` (LF). */
-  readonly eol: "\n" | "\r\n" | "\r";
-}
-
-/** The default style: no BOM, LF endings — a no-op for {@link reapplyDiskStyle}, and what a freshly-created file gets. */
-const LF_NO_BOM_STYLE: DiskStyle = { bom: false, eol: "\n" };
-
-/**
- * Detect `raw`'s BOM + dominant EOL convention from its UN-normalized bytes (before
- * {@link normalizeOnDisk} strips/collapses them), so a managed-block refresh can re-apply the
- * file's own convention on write-back instead of silently rewriting it (LORE-128). An absent file
- * reports {@link LF_NO_BOM_STYLE} — nothing to preserve, so a fresh file is written LF/no-BOM as
- * before. CRLF is checked before lone CR since every `\r\n` also contains a `\r`.
- */
-function detectDiskStyle(raw: string | undefined): DiskStyle {
-  if (raw === undefined) {
-    return LF_NO_BOM_STYLE;
-  }
-  const bom = raw.startsWith("\uFEFF");
-  const eol = raw.includes("\r\n") ? "\r\n" : raw.includes("\r") ? "\r" : "\n";
-  return { bom, eol };
-}
-
-/**
- * Re-apply a detected {@link DiskStyle} to freshly-planned (LF, no-BOM) `contents` before writing
- * it back, so refreshing just the `lore:agents` managed block does not silently rewrite a CRLF
- * and/or BOM-prefixed CLAUDE.md to LF-only / BOM-stripped beyond the block itself (LORE-128).
- * `contents` itself is always pure LF (built from {@link normalizeOnDisk}'d input plus template
- * strings that only ever use `\n`), so a blanket `\n` -> `style.eol` replace is safe and exact. A
- * no-op for {@link LF_NO_BOM_STYLE}.
- */
-function reapplyDiskStyle(contents: string, style: DiskStyle): string {
-  const withEol = style.eol === "\n" ? contents : contents.replace(/\n/g, style.eol);
-  return style.bom ? `\uFEFF${withEol}` : withEol;
-}
-
-/** Build the `agents.result` {@link Renderable}. */
-function agentsRenderable(data: AgentsResult): Renderable<AgentsResult> {
-  return { kind: "agents.result", data, pretty: renderPretty, plain: renderPlain };
-}
-
-/** The per-action verb shown for a file: the drift status (`--check`) or the applied action (write path). */
-function actionLabel(action: BridgeAction, check: boolean): string {
-  if (check) {
-    if (action === "protected") {
-      return "out of date (protected; needs --force)";
-    }
-    return action === "unchanged" ? "up to date" : "out of date";
-  }
-  return action;
-}
-
-/** Stable, token-shaped equivalent of {@link actionLabel} for `--plain`. */
-function plainActionLabel(action: BridgeAction, check: boolean): string {
-  if (check && action === "protected") {
-    return "out-of-date-protected";
-  }
-  return actionLabel(action, check).replace(/ /g, "-");
-}
-
-/**
- * The colour each {@link BridgeAction} paints in `pretty` mode: `unchanged` is dim (nothing
- * happened), `protected` is a warning (a hand-edited file was deliberately left untouched — see
- * {@link renderTrailer}), and `created`/`updated` are a success green. A total `Record`, not a
- * chain of `===` checks with a trailing fallback: TypeScript requires every {@link BridgeAction}
- * literal as a key, so a sixth/future variant added to that union without a matching entry here is
- * a compile error (`bun run typecheck` fails), not a silent runtime fall-through to some default
- * colour. That total mapping is also why there is no fallback to reconsider — an action outside the
- * union cannot reach {@link bridgeActionColor} at all, well-typed callers included.
- */
-const BRIDGE_ACTION_COLOR: Record<BridgeAction, string> = {
-  unchanged: ANSI.dim,
-  protected: ANSI.yellow,
-  created: ANSI.green,
-  updated: ANSI.green,
-};
-
-/**
- * The colour a bridge file's {@link BridgeAction} paints in `pretty` mode — see
- * {@link BRIDGE_ACTION_COLOR}. Exported (LORE-267) so `lore init`'s own renderer (init.ts) paints
- * the exact same {@link BridgeAction} in the exact same colour, instead of keeping a second,
- * hand-maintained copy of this mapping that can silently drift from this one — which is exactly how
- * `protected` came to render green here (the old two-way `unchanged`-or-green split) while `init`
- * already painted it yellow.
- */
-export function bridgeActionColor(action: BridgeAction): string {
-  return BRIDGE_ACTION_COLOR[action];
-}
-
-/** Human view: a heading, one line per file, and an actionable trailer for stale/protected state. */
-function renderPretty(data: AgentsResult, opts: { color: boolean }): string {
-  const head = data.check ? `Checking the lore agent bridge at ${data.root}` : `lore agent bridge at ${data.root}`;
-  const lines = [head];
-  for (const file of data.files) {
-    const label = actionLabel(file.action, data.check);
-    const color = bridgeActionColor(file.action);
-    lines.push(`  ${paint(label, color, opts.color)} ${file.path}`);
-  }
-  const trailer = renderTrailer(data);
-  if (trailer !== undefined) {
-    lines.push(paint(trailer, ANSI.yellow, opts.color));
-  }
-  return lines.join("\n");
-}
-
-/** ANSI-free, diff-stable view: one `<action> <path>` line each, plus any trailer as a plain line. */
-function renderPlain(data: AgentsResult): string {
-  const lines = data.files.map((file) => `${plainActionLabel(file.action, data.check)} ${file.path}`);
-  const trailer = renderTrailer(data);
-  if (trailer !== undefined) {
-    lines.push(trailer);
-  }
-  return lines.join("\n");
-}
-
-/**
- * The trailing advisory line, or `undefined` when none applies. The remedy depends on *why* the
- * bridge is stale: a differing (hand-edited) SKILL.md is `protected` and can only be regenerated with
- * `--force` (a plain `lore agents` would leave it untouched), so the hint must say `--force` whenever a
- * protected file is present — under `--check` (where the inert plain remedy would otherwise keep CI
- * red) and on a normal run alike.
- *
- * Exported (LORE-260 review round 2, MINOR-4) so `lore init`'s own renderers can reuse this EXACT
- * trailer for the agent-bridge step it folds in, instead of dropping it: LORE-129 established this
- * line as load-bearing (a `protected` file with no visible remedy reads as silent success), and
- * `init`'s own rendering must not regress it just because it's a second, thinner caller.
- */
-export function renderTrailer(data: AgentsResult): string | undefined {
-  const hasProtected = data.files.some((file) => file.action === "protected");
-  if (data.check) {
-    const stale = data.files.some((file) => file.action !== "unchanged");
-    if (!stale) {
-      return undefined;
-    }
-    return hasProtected
-      ? "bridge is out of date — a hand-edited file needs `lore agents --force` to regenerate (exit 6)"
-      : "bridge is out of date — run `lore agents` to regenerate (exit 6)";
-  }
-  if (!hasProtected) {
-    return undefined;
-  }
-  const count = data.files.filter((file) => file.action === "protected").length;
-  return `${count} file(s) look hand-edited and were left untouched — run \`lore agents --force\` to overwrite`;
-}