catherd-cli 1.5.0 → 2.0.0-beta.20261022113309

package/src/services/source-sync.ts

@@ -1,312 +0,0 @@
-import { buildCatalog, type Catalog, DIMS } from "../domain/catalog.ts";
-import { CatherdError, errorMessage } from "../domain/errors.ts";
-import {
-  type Derived,
-  SOURCE_IDS,
-  type SourceId,
-  type SourcesFile,
-  SourcesFileSchema,
-} from "../domain/sources.ts";
-import { assetPath } from "../infra/assets.ts";
-import { log } from "../infra/log.ts";
-import { type AaAnswer, fetchArtificialAnalysis } from "../infra/sources/artificial-analysis.ts";
-import { fetchArena } from "../infra/sources/arena.ts";
-import {
-  readCached,
-  readDerived,
-  readSyncState,
-  tryLockSync,
-  writeCached,
-  writeDerived,
-  writeSyncState,
-} from "../infra/sources/cache.ts";
-import { fetchEpoch } from "../infra/sources/epoch.ts";
-import { rateLimitRemaining, SourceError, type SourceTransport } from "../infra/sources/http.ts";
-import { fetchLiteLlm } from "../infra/sources/litellm.ts";
-import { fetchModelsDev } from "../infra/sources/models-dev.ts";
-import { fetchOpenRouterEndpoints } from "../infra/sources/openrouter-endpoints.ts";
-import { fetchOpenRouterModels } from "../infra/sources/openrouter-models.ts";
-import { fetchVectara } from "../infra/sources/vectara.ts";
-import { readVersioned } from "../infra/store.ts";
-import { readOverride, shippedModels, shippedScores } from "./catalog-service.ts";
-import { aaKey } from "./credentials.ts";
-import { derive, openRouterIds, type RawAnswers } from "./source-derive.ts";
-
-/** Spec 1.2 §3.2: one TTL for every source. */
-export const TTL_MS = 12 * 3_600_000;
-/** A source whose last attempt failed waits this long before a background sync tries it again. */
-const BACKOFF_MS = 3_600_000;
-/** How long a foreground sync waits for one already running. */
-const LOCK_WAIT_MS = 120_000;
-
-let sourcesFile: SourcesFile | null = null;
-/** `catalog/sources.json`: the sources, their licenses and attribution lines, the aliases. */
-export const shippedSources = (): SourcesFile =>
-  (sourcesFile ??= readVersioned(assetPath("catalog/sources.json"), SourcesFileSchema, 1));
-
-export interface SyncOptions {
-  /** ignore the TTL (and a failing source's backoff) */
-  force?: boolean;
-  /** the MCP server's boot sync: skips when another sync runs, and gives a failing source an hour's rest */
-  background?: boolean;
-  /** false: answer `busy` at once when another sync holds the lock (the catalog_sync tool), never wait */
-  wait?: boolean;
-  /** how every source is fetched; tests replace it */
-  transport?: SourceTransport;
-  /** the Artificial Analysis key; default: the env's, else the saved one */
-  aaKey?: string | null;
-  now?: () => number;
-}
-
-export interface SourceOutcome {
-  source: SourceId;
-  /** fetched now; fresh (within the TTL); failed (the last good answer kept); skipped (no key, or backing off) */
-  state: "fetched" | "fresh" | "failed" | "skipped";
-  /** when the answer in the cache was fetched; null when there is none */
-  fetchedAt: string | null;
-  error?: string;
-  detail?: string;
-}
-
-export interface SyncReport {
-  /** another sync held the lock (a background sync never waits): nothing was done */
-  busy: boolean;
-  sources: SourceOutcome[];
-  /** canonical rungs with no value of their own before this sync and at least one after */
-  newlyScored: string[];
-  /** the user's treat-likes whose rung now has its own value on every dimension the stand-in lent */
-  noLongerNeeded: { rung: string; like: string }[];
-  failed: { source: SourceId; error: string }[];
-  /** the cross-checks that failed (spec 1.2 §3.5) */
-  warnings: string[];
-  /** each source's ids no family matched (spec 1.2 §3.4) */
-  unmatched: Record<string, string[]>;
-}
-
-const iso = (ms: number) => new Date(ms).toISOString();
-
-/** The catalog as routing would read it with `derived` as the synced layer. */
-const catalogWith = (derived: Derived | null, now: number): Catalog =>
-  buildCatalog({
-    models: shippedModels(),
-    scores: shippedScores(),
-    synced: derived?.scores,
-    facts: derived?.facts,
-    override: readOverride(),
-    now,
-  });
-
-const scored = (c: Catalog): Set<string> =>
-  new Set(Object.entries(c.scores).flatMap(([rung, dims]) => (Object.keys(dims).length ? [rung] : [])));
-
-async function takeLock(background: boolean): Promise<(() => void) | null> {
-  const deadline = Date.now() + LOCK_WAIT_MS;
-  for (;;) {
-    const release = tryLockSync();
-    if (release || background) return release;
-    if (Date.now() > deadline)
-      throw new CatherdError("E_IO_LOCK", "another catalog sync is still running", {
-        fix: "wait for it to finish, then run catherd catalog sync again",
-      });
-    await Bun.sleep(200);
-  }
-}
-
-/** Every cached answer, as `derive` reads them (and `scripts/catalog-refresh.ts` rebuilds the shipped file). */
-export function cachedAnswers(): RawAnswers {
-  const raw: RawAnswers = {};
-  for (const id of SOURCE_IDS) {
-    const c = readCached(id);
-    if (c) raw[id] = { fetchedAt: c.fetchedAt, data: c.data };
-  }
-  return raw;
-}
-
-/**
- * Spec 1.2 §3.2, §3.3: fetches every source whose cached answer is older than the TTL (every source with
- * `force`), all in parallel, and writes each answer atomically with its fetch time. A source that fails keeps
- * its last good answer; the sync records the error and goes on. Then it derives the synced values from every
- * cached answer. One sync runs at a time: a background sync skips when another holds the lock, a foreground
- * one waits for it.
- */
-export async function syncSources(o: SyncOptions = {}): Promise<SyncReport> {
-  const now = o.now ?? Date.now;
-  const release = await takeLock(o.background === true || o.wait === false);
-  if (!release)
-    return {
-      busy: true,
-      sources: [],
-      newlyScored: [],
-      noLongerNeeded: [],
-      failed: [],
-      warnings: [],
-      unmatched: {},
-    };
-  try {
-    const before = catalogWith(readDerived(), now());
-    const state = readSyncState();
-    const key = o.aaKey === undefined ? aaKey() : o.aaKey;
-    const t = o.transport ?? {};
-    const outcomes = new Map<SourceId, SourceOutcome>();
-    const fetchedAt = (id: SourceId) => state.sources[id]?.fetchedAt ?? null;
-    const fresh = (id: SourceId) => {
-      const at = fetchedAt(id);
-      // a cache file that no longer reads (corrupt, or an older schema) is fetched again
-      return !o.force && at !== null && now() - Date.parse(at) < TTL_MS && readCached(id) !== null;
-    };
-    const resting = (id: SourceId) => {
-      const s = state.sources[id];
-      return o.background && !o.force && s?.error && now() - Date.parse(s.lastAttemptAt) < BACKOFF_MS;
-    };
-
-    const run = async (id: SourceId, fetcher: () => Promise<unknown>): Promise<void> => {
-      if (fresh(id)) return void outcomes.set(id, { source: id, state: "fresh", fetchedAt: fetchedAt(id) });
-      if (resting(id))
-        return void outcomes.set(id, {
-          source: id,
-          state: "skipped",
-          fetchedAt: fetchedAt(id),
-          detail: "failed within the hour; the next sync tries again",
-        });
-      const at = now();
-      const prev = state.sources[id];
-      try {
-        const data = await fetcher();
-        writeCached(id, data, at);
-        const limit = id === "artificial-analysis" ? (data as AaAnswer).rateLimitRemaining : null;
-        state.sources[id] = {
-          fetchedAt: iso(at),
-          lastAttemptAt: iso(at),
-          error: null,
-          rateLimitRemaining: limit,
-          rateLimitAt: limit === null ? null : iso(at),
-        };
-        outcomes.set(id, { source: id, state: "fetched", fetchedAt: iso(at) });
-      } catch (e) {
-        const error = errorMessage(e);
-        const limit = e instanceof SourceError ? rateLimitRemaining(e.headers) : null;
-        // (1.2 minor) a failure with no header keeps the last count with the time that count was read
-        state.sources[id] = {
-          fetchedAt: prev?.fetchedAt ?? null,
-          lastAttemptAt: iso(at),
-          error,
-          rateLimitRemaining: limit ?? prev?.rateLimitRemaining ?? null,
-          rateLimitAt: limit === null ? (prev?.rateLimitAt ?? null) : iso(at),
-        };
-        outcomes.set(id, { source: id, state: "failed", fetchedAt: prev?.fetchedAt ?? null, error });
-        log(o.background ? "debug" : "warn", "sources", { source: id, error });
-      }
-    };
-
-    const orModels = run("openrouter-models", () => fetchOpenRouterModels(t));
-    const jobs: Promise<void>[] = [
-      orModels,
-      run("models-dev", () => fetchModelsDev(t)),
-      run("litellm", () => fetchLiteLlm(t)),
-      run("arena", () => fetchArena(t)),
-      run("vectara", () => fetchVectara(t)),
-      run("epoch", () => fetchEpoch(t)),
-      // plan 13 R-H: one request per catalog family OpenRouter lists, so it waits for OpenRouter's model list
-      orModels.then(() =>
-        run("openrouter-endpoints", async () => {
-          const list = readCached("openrouter-models");
-          if (!list) throw new Error("no OpenRouter model list to take the ids from");
-          const ids = openRouterIds(list.data, { models: shippedModels(), sources: shippedSources() });
-          return fetchOpenRouterEndpoints(ids, t);
-        }),
-      ),
-    ];
-    if (key) jobs.push(run("artificial-analysis", () => fetchArtificialAnalysis(key, t)));
-    else
-      outcomes.set("artificial-analysis", {
-        source: "artificial-analysis",
-        state: "skipped",
-        fetchedAt: fetchedAt("artificial-analysis"),
-        detail: "no key: catherd init, or export ARTIFICIAL_ANALYSIS_API_KEY",
-      });
-    await Promise.all(jobs);
-    writeSyncState(state);
-
-    const changed = [...outcomes.values()].some((x) => x.state === "fetched");
-    const raw = cachedAnswers();
-    if ((changed || readDerived() === null) && Object.keys(raw).length > 0)
-      writeDerived(
-        derive(raw, {
-          models: shippedModels(),
-          scores: shippedScores(),
-          sources: shippedSources(),
-          now: now(),
-        }),
-      );
-    const derived = readDerived();
-    const after = catalogWith(derived, now());
-    const had = scored(before);
-    const noLongerNeeded = Object.entries(after.treatLike).flatMap(([rung, t]) => {
-      if (t.source !== "user") return [];
-      const lends = DIMS.filter((d) => after.scores[t.like]?.[d]);
-      const covered = (c: Catalog) => lends.length > 0 && lends.every((d) => c.scores[rung]?.[d]);
-      return covered(after) && !covered(before) ? [{ rung, like: t.like }] : [];
-    });
-    const sources = SOURCE_IDS.map((id) => outcomes.get(id)).filter(
-      (x): x is SourceOutcome => x !== undefined,
-    );
-    return {
-      busy: false,
-      sources,
-      newlyScored: [...scored(after)].filter((r) => !had.has(r)).sort(),
-      noLongerNeeded,
-      failed: sources.flatMap((s) =>
-        s.state === "failed" ? [{ source: s.source, error: s.error ?? "" }] : [],
-      ),
-      warnings: derived?.warnings ?? [],
-      unmatched: derived?.unmatched ?? {},
-    };
-  } finally {
-    release();
-  }
-}
-
-/**
- * Spec 1.2 §3.2: the MCP server's boot sync, started without awaiting it. It never throws (a failure is
- * logged at debug) and never waits for another sync. `CATHERD_NO_SYNC=1` turns it off (tests, air-gapped
- * machines), as it does `init`'s sync; `catherd catalog sync` still runs.
- */
-export function backgroundSync(o: SyncOptions = {}): Promise<SyncReport | null> {
-  if (process.env.CATHERD_NO_SYNC === "1") return Promise.resolve(null);
-  return syncSources({ ...o, background: true }).catch((e: unknown) => {
-    log("debug", "sources", { error: errorMessage(e) });
-    return null;
-  });
-}
-
-export interface SourceStatus {
-  source: SourceId;
-  name: string;
-  /** when its cached answer was fetched; null when never */
-  fetchedAt: string | null;
-  error: string | null;
-}
-
-/** Spec 1.2 §9 doctor: each source's last fetch and error, the AA key, and AA's requests left. */
-export function sourcesStatus(): {
-  sources: SourceStatus[];
-  aaKey: boolean;
-  rateLimitRemaining: number | null;
-  rateLimitAt: string | null;
-} {
-  const state = readSyncState();
-  const aa = state.sources["artificial-analysis"];
-  return {
-    sources: shippedSources().sources.map((s) => ({
-      source: s.id,
-      name: s.name,
-      fetchedAt: state.sources[s.id]?.fetchedAt ?? null,
-      error: state.sources[s.id]?.error ?? null,
-    })),
-    aaKey: aaKey() !== null,
-    rateLimitRemaining: aa?.rateLimitRemaining ?? null,
-    // a state written before 1.5 has no rateLimitAt: its last attempt is the best guess
-    rateLimitAt:
-      aa?.rateLimitRemaining === null || aa === undefined ? null : (aa.rateLimitAt ?? aa.lastAttemptAt),
-  };
-}

package/src/services/standins.ts

@@ -1,238 +0,0 @@
-import {
-  type Catalog,
-  DIMS,
-  type Dim,
-  type Family,
-  type InferredStandIn,
-  rungInfo,
-  scoresOf,
-} from "../domain/catalog.ts";
-import { catalogRungs } from "../domain/failover.ts";
-import { EFFORT_ORDER } from "../domain/sources.ts";
-
-/**
- * Spec 1.2 §6.3: the features a rung is compared on. Numbers are z-scored across the catalog; `vendor` and
- * `family` are words, the same or not. Keyless: price, context, release date, vendor and family, the effort
- * (plan 14 Ruling 6), and the rung's own values on each dimension (the Arena and Epoch values, with the
- * shipped ones). With an Artificial Analysis key, its index, `hle`, `scicode`, `lcr`, cost per task and
- * tokens/s join them (`Catalog.features`).
- */
-export type Features = Record<string, number | string>;
-
-/** Spec 1.2 §6.3: a pair sharing fewer features than this is not suggested. */
-export const MIN_SHARED_FEATURES = 3;
-
-/**
- * Spec 1.5 plan 24: a rung stands in only when it has values of its own on at least this many dimensions. A
- * sparse row (GPT-6.1 Sol's one honesty figure) ranks near everything, for it has few features to differ on,
- * and would lend that one value to unrelated rungs.
- */
-export const MIN_STANDIN_DIMS = 3;
-
-export interface Suggestion {
-  /** the canonical rung that would stand in */
-  like: string;
-  distance: number;
-  /** the features the distance rests on: those both rungs have */
-  features: string[];
-  /** the dimensions it would lend: those the rung lacks and it has */
-  lends: Dim[];
-}
-
-const DAY_MS = 86_400_000;
-const family = (c: Catalog, canonical: string): Family | null =>
-  c.families.find((f) => f.id === canonical.slice(0, canonical.lastIndexOf("#"))) ?? null;
-
-/** The rung's own value per dimension: a value it borrows, or catherd's guess (`inferred`), never counts. */
-function ownValues(c: Catalog, canonical: string): Partial<Record<Dim, number>> {
-  const out: Partial<Record<Dim, number>> = {};
-  for (const d of DIMS) {
-    const s = c.scores[canonical]?.[d];
-    if (s && s.confidence !== "inferred") out[d] = s.value;
-  }
-  return out;
-}
-
-/** Spec 1.2 §6.3: a canonical rung's features, from its family, its effort, its own values and AA's. */
-export function featuresOf(c: Catalog, canonical: string): Features {
-  const out: Features = {};
-  const f = family(c, canonical);
-  if (f) {
-    out.price = Math.log10(f.price.input + f.price.output + 1e-6);
-    const contexts = Object.values(f.on).flatMap((m) => (m ? [m.context] : []));
-    if (contexts.length) out.context = Math.log10(Math.max(...contexts));
-    if (f.releaseDate) out.release = Date.parse(f.releaseDate) / DAY_MS;
-    const vendor = (f as { vendor?: unknown }).vendor;
-    if (typeof vendor === "string") out.vendor = vendor;
-    out.family = f.id;
-  }
-  const effort = (EFFORT_ORDER as readonly string[]).indexOf(canonical.slice(canonical.lastIndexOf("#") + 1));
-  if (effort >= 0) out.effort = effort;
-  for (const [d, v] of Object.entries(ownValues(c, canonical))) out[d] = v;
-  for (const [k, v] of Object.entries(c.features[canonical] ?? {})) out[`aa.${k}`] = v;
-  return out;
-}
-
-/** Every canonical rung the catalog can name, and every one it holds a value for. */
-export function canonicalRungs(c: Catalog): string[] {
-  const out = new Set(Object.keys(c.scores));
-  for (const r of catalogRungs(c)) {
-    try {
-      out.add(rungInfo(c, r).canonical);
-    } catch {
-      // catalogRungs only names parseable rungs
-    }
-  }
-  return [...out].sort();
-}
-
-interface Scale {
-  mean: number;
-  sd: number;
-}
-
-/** Each numeric feature's mean and spread over `all`; a feature with no spread tells rungs apart by nothing. */
-function scales(all: Features[]): Map<string, Scale> {
-  const values = new Map<string, number[]>();
-  for (const f of all)
-    for (const [k, v] of Object.entries(f))
-      if (typeof v === "number") values.set(k, [...(values.get(k) ?? []), v]);
-  const out = new Map<string, Scale>();
-  for (const [k, xs] of values) {
-    const mean = xs.reduce((s, x) => s + x, 0) / xs.length;
-    const sd = Math.sqrt(xs.reduce((s, x) => s + (x - mean) ** 2, 0) / xs.length);
-    if (sd > 0) out.set(k, { mean, sd });
-  }
-  return out;
-}
-
-/**
- * Spec 1.2 §6.3: the z-scored Euclidean distance over the features both have, as a root mean square so pairs
- * sharing different numbers of features compare (plan 14 Ruling 6); a word counts 0 when equal, else 1. Null
- * when they share fewer than MIN_SHARED_FEATURES.
- */
-function distance(a: Features, b: Features, z: Map<string, Scale>): { d: number; shared: string[] } | null {
-  const shared: string[] = [];
-  let sum = 0;
-  for (const [k, va] of Object.entries(a)) {
-    const vb = b[k];
-    if (vb === undefined) continue;
-    if (typeof va === "string" || typeof vb === "string") {
-      shared.push(k);
-      sum += va === vb ? 0 : 1;
-      continue;
-    }
-    const s = z.get(k);
-    if (!s) continue;
-    shared.push(k);
-    sum += ((va - vb) / s.sd) ** 2;
-  }
-  if (shared.length < MIN_SHARED_FEATURES) return null;
-  return { d: Math.sqrt(sum / shared.length), shared };
-}
-
-/** The dimensions the bars use that `canonical` has no value for, of its own or through a treat-like. */
-export function missingDims(c: Catalog, canonical: string, dims: readonly Dim[] = barDimsIn(c)): Dim[] {
-  const own = c.scores[canonical] ?? {};
-  const like = c.treatLike[canonical]?.like;
-  const lent = like ? (c.scores[like] ?? {}) : {};
-  return dims.filter((d) => !own[d] && !lent[d]);
-}
-
-/**
- * Every dimension some bar of the catalog (the defaults, with the user's override) has a threshold on: the
- * dimensions a stand-in fills. No shipped bar uses `steer`, so it is never inferred by default; a user's steer
- * bar makes it one (plan 14 Ruling 7, as the code has always read it; spec 1.5 plan 24 aligns the words).
- */
-export function barDimsIn(c: Catalog): Dim[] {
-  const used = new Set<string>();
-  for (const kind of Object.values(c.bars))
-    for (const bar of Object.values(kind))
-      for (const [d, min] of Object.entries(bar)) if (min !== undefined) used.add(d);
-  return DIMS.filter((d) => used.has(d));
-}
-
-class Ranker {
-  private readonly all = new Map<string, Features>();
-  private readonly z: Map<string, Scale>;
-  constructor(private readonly c: Catalog) {
-    for (const r of canonicalRungs(c)) this.all.set(r, featuresOf(c, r));
-    this.z = scales([...this.all.values()]);
-  }
-  /**
-   * The rungs with an own value on any of `dims` (and on at least MIN_STANDIN_DIMS dimensions in all), nearest
-   * first; each with what it would lend.
-   */
-  rank(canonical: string, dims: readonly Dim[]): Suggestion[] {
-    const mine = this.all.get(canonical) ?? featuresOf(this.c, canonical);
-    const out: Suggestion[] = [];
-    for (const [other, f] of this.all) {
-      if (other === canonical) continue;
-      const own = ownValues(this.c, other);
-      if (Object.keys(own).length < MIN_STANDIN_DIMS) continue;
-      const lends = dims.filter((d) => own[d] !== undefined);
-      if (lends.length === 0) continue;
-      const got = distance(mine, f, this.z);
-      if (got) out.push({ like: other, distance: Number(got.d.toFixed(4)), features: got.shared, lends });
-    }
-    return out.sort((a, b) => a.distance - b.distance || a.like.localeCompare(b.like));
-  }
-}
-
-/**
- * Spec 1.2 §6.4 `treat-like --suggest`: the `limit` nearest rungs that would lend `canonical` a value it lacks
- * on a dimension the bars use (any scored rung when it lacks none), with their distance and features.
- */
-export function suggestStandIns(c: Catalog, canonical: string, limit = 3): Suggestion[] {
-  const lacking = missingDims(c, canonical);
-  return new Ranker(c).rank(canonical, lacking.length ? lacking : DIMS).slice(0, limit);
-}
-
-/**
- * Spec 1.5 plan 24: the same effort of the family's predecessor (`Family.predecessor`), when it has a value on
- * `d` of its own; null otherwise.
- */
-function predecessorOf(c: Catalog, canonical: string, d: Dim): { like: string; value: number } | null {
-  const pred = family(c, canonical)?.predecessor;
-  if (!pred) return null;
-  const like = `${pred}${canonical.slice(canonical.lastIndexOf("#"))}`;
-  const s = c.scores[like]?.[d];
-  return s ? { like, value: s.value } : null;
-}
-
-/**
- * Spec 1.2 §6.1: for every rung the catalog can name, per dimension the bars use that it has no value for
- * (of its own or through a treat-like), its nearest stand-in with a value there. A rung no rung is near
- * enough to (fewer than MIN_SHARED_FEATURES shared) gets none on that dimension. Spec 1.5 plan 24: a new
- * release of a family line takes at least its predecessor's value at the same effort, so a guess never puts it
- * below the model it replaces (the identity run's GPT-6.1 Sol at 37.2, under GPT-6 Luna).
- */
-export function inferStandIns(c: Catalog): Catalog["inferred"] {
-  const dims = barDimsIn(c);
-  const ranker = new Ranker(c);
-  const out: Catalog["inferred"] = {};
-  for (const canonical of canonicalRungs(c)) {
-    const lacking = missingDims(c, canonical, dims);
-    for (const d of lacking) {
-      const best = ranker.rank(canonical, [d])[0];
-      const pred = predecessorOf(c, canonical, d);
-      const nearest = best ? c.scores[best.like]?.[d]?.value : undefined;
-      let entry: InferredStandIn | null = best
-        ? { like: best.like, distance: best.distance, features: best.features }
-        : null;
-      if (pred && (nearest === undefined || pred.value >= nearest))
-        entry = { like: pred.like, distance: 0, features: ["predecessor"] };
-      if (entry) (out[canonical] ??= {})[d] = entry;
-    }
-  }
-  return out;
-}
-
-/** The catalog with its inferred stand-ins filled in: what routing, validation and the surfaces read. */
-export function withStandIns(c: Catalog): Catalog {
-  return { ...c, inferred: inferStandIns(c) };
-}
-
-/** Whether `canonical` leans on an inferred stand-in for any value (`scoresOf`'s `inferred`). */
-export const leansOnStandIn = (c: Catalog, canonical: string): boolean =>
-  (scoresOf(c, canonical)?.inferred.length ?? 0) > 0;

package/src/services/treat-likes.ts

@@ -1,113 +0,0 @@
-import type { OrchestrationHost } from "../domain/host.ts";
-import { type Dim, scoresOf, rungInfo } from "../domain/catalog.ts";
-import { CatherdError } from "../domain/errors.ts";
-import { tryParseRung } from "../domain/ids.ts";
-import { ROLES } from "../domain/roles.ts";
-import { canonicalRung, loadCatalog, readOverride, removeTreatLikes } from "./catalog-service.ts";
-import { getProfile, listProfiles } from "./profile-store.ts";
-import { barDimsIn, type Suggestion, suggestStandIns } from "./standins.ts";
-
-/** A profile's rung that would lean on an inferred stand-in, or be left with no value at all (spec 1.2 §6.4). */
-export interface LeftOnStandIn {
-  profile: string;
-  rung: string;
-  /** the dimensions an inferred stand-in would fill; empty when the rung is left unscored */
-  dims: Dim[];
-  /** no value of its own and no stand-in near enough: routing skips it */
-  unscored: boolean;
-  /**
-   * (1.2 minor) the bar dimensions it keeps no value on at all, though it keeps others: present only when some
-   * are; no bar that needs one is cleared
-   */
-  missing?: Dim[];
-}
-
-/**
- * Spec 1.2 §6.4: the rungs of every profile (enabled roles' rungs and failover stand-ins) that would lean on an
- * inferred stand-in, or be left with no value at all, once the user's treat-likes for `removed` (canonical
- * rungs, or all of them) are gone. Never removed silently.
- */
-export function leftOnStandIns(
-  removed: string[] | "all",
-  host: OrchestrationHost = "unknown",
-): LeftOnStandIn[] {
-  const cur = readOverride();
-  const treatLike = Object.fromEntries(
-    Object.entries(cur.treatLike).filter(([r]) => removed !== "all" && !removed.includes(r)),
-  );
-  const gone = removed === "all" ? Object.keys(cur.treatLike) : removed;
-  const c = loadCatalog({ timings: false, override: { ...cur, treatLike } });
-  const out: LeftOnStandIn[] = [];
-  // an unknown host resolves no omitted architect/verifier rungs: name what either host would run
-  const hosts: OrchestrationHost[] = host === "unknown" ? ["claude-code", "codex"] : [host];
-  for (const profile of listProfiles()) {
-    const rungs = new Set(
-      hosts.flatMap((h) => {
-        const p = getProfile(profile, h);
-        return [
-          ...ROLES.filter((r) => p.roles[r].enabled).flatMap((r) => p.roles[r].rungs),
-          ...Object.values(p.failover),
-        ];
-      }),
-    );
-    for (const rung of rungs) {
-      if (!tryParseRung(rung)) continue;
-      const canonical = rungInfo(c, rung).canonical;
-      if (!gone.includes(canonical)) continue;
-      const s = scoresOf(c, canonical);
-      if (!s) {
-        out.push({ profile, rung, dims: [], unscored: true });
-        continue;
-      }
-      const missing = barDimsIn(c).filter((d) => s.values[d] === undefined);
-      if (s.inferred.length || missing.length)
-        out.push({
-          profile,
-          rung,
-          dims: s.inferred,
-          unscored: false,
-          ...(missing.length ? { missing } : {}),
-        });
-    }
-  }
-  return out;
-}
-
-/** Spec 1.2 §6.4 `--suggest`: the rung, in canonical form, and its three nearest stand-ins. */
-export function suggestFor(rung: string): { canonical: string; lacking: Dim[]; suggestions: Suggestion[] } {
-  const c = loadCatalog({ timings: false });
-  const canonical = canonicalRung(rung);
-  const s = scoresOf(c, canonical);
-  return {
-    canonical,
-    lacking: s ? s.inferred : [],
-    suggestions: suggestStandIns(c, canonical),
-  };
-}
-
-/**
- * Spec 1.2 §6.4 `--clear`: removes the user's treat-like for `rung`, naming first the profile rungs it
- * leaves on an inferred stand-in. A shipped treat-like is not the user's to remove.
- */
-export async function clearTreatLike(
-  rung: string,
-  host: OrchestrationHost = "unknown",
-): Promise<{ rung: string; like: string; left: LeftOnStandIn[] }> {
-  const canonical = canonicalRung(rung);
-  const like = readOverride().treatLike[canonical];
-  if (!like)
-    throw new CatherdError("E_INPUT_INVALID", `${canonical} has no treat-like of yours to clear`, {
-      fix: "catherd catalog list shows each rung's treat-like; a shipped one is not yours to clear",
-    });
-  const left = leftOnStandIns([canonical], host);
-  await removeTreatLikes([canonical]);
-  return { rung: canonical, like, left };
-}
-
-/** Spec 1.2 §6.4 `--reset`: removes every treat-like of the user's, naming first the rungs left on a stand-in. */
-export async function resetTreatLikes(
-  host: OrchestrationHost = "unknown",
-): Promise<{ removed: [string, string][]; left: LeftOnStandIn[] }> {
-  const left = leftOnStandIns("all", host);
-  return { removed: await removeTreatLikes("all"), left };
-}