catherd-cli 1.5.0 → 2.0.0-beta.20261022113309

package/src/domain/slopalytics.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { CatherdError } from "./errors.ts";
+
+/** One model at one effort, as the Slopalytics proxy indexes it: its intelligence and the facts that come with it. */
+export interface SlopRecord {
+  family: string;
+  effort: string;
+  intelligence: number;
+  inputPrice: number | null;
+  outputPrice: number | null;
+  speed: number | null;
+  context: number | null;
+}
+
+const RecordSchema = z.object({
+  family: z.string(),
+  effort: z.string(),
+  intelligence: z.number(),
+  inputPrice: z.number().nullable(),
+  outputPrice: z.number().nullable(),
+  speed: z.number().nullable(),
+  context: z.number().nullable(),
+});
+
+/** `<data>/slopalytics.json`: the last good answer, when it was fetched and checked, and the last failure. */
+export const IndexFileSchema = z.looseObject({
+  schema: z.literal(1),
+  checkedAt: z.iso.datetime(),
+  fetchedAt: z.string().nullable(),
+  error: z.object({ at: z.string(), message: z.string() }).nullable(),
+  models: z.array(RecordSchema),
+});
+export type IndexFile = z.infer<typeof IndexFileSchema>;
+
+/** A finite number or a finite numeric string (the proxy sends some prices as strings), else null. */
+const num = (v: unknown): number | null => {
+  const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
+  return typeof n === "number" && Number.isFinite(n) ? n : null;
+};
+
+/** The proxy's answer as the records catherd ranks on: only a record with a positive intelligence is a pair. */
+export function parseProxy(body: unknown): { fetchedAt: string | null; models: SlopRecord[] } {
+  const b = body as { fetchedAt?: unknown; models?: unknown } | null;
+  if (typeof b !== "object" || b === null || !Array.isArray(b.models))
+    throw new CatherdError("E_INPUT_INVALID", "Slopalytics answered without a models list");
+  const models: SlopRecord[] = [];
+  for (const raw of b.models) {
+    const r = (raw ?? {}) as Record<string, unknown>;
+    const intelligence = num(r.intelligence);
+    if (typeof r.family !== "string" || !r.family) continue;
+    if (typeof r.effort !== "string" || !r.effort) continue;
+    if (intelligence === null || intelligence <= 0) continue;
+    const context = num(r.context);
+    models.push({
+      family: r.family,
+      effort: r.effort,
+      intelligence,
+      inputPrice: num(r.inputPrice),
+      outputPrice: num(r.outputPrice),
+      speed: num(r.speed),
+      context: context !== null && Number.isInteger(context) && context > 0 ? context : null,
+    });
+  }
+  return { fetchedAt: typeof b.fetchedAt === "string" ? b.fetchedAt : null, models };
+}
+
+/** A model's Slopalytics family key: its provider dropped, lower case, dots as dashes (`gpt-6.1-sol` → `gpt-6-1-sol`). */
+export const slopKey = (model: string): string =>
+  model
+    .slice(model.lastIndexOf("/") + 1)
+    .toLowerCase()
+    .replaceAll(".", "-");

package/src/entry/answer-command.ts

@@ -0,0 +1,39 @@
+import { defineCommand } from "citty";
+import { CatherdError } from "../domain/errors.ts";
+import { answerUnit } from "../services/run-client.ts";
+import { defaultDeps } from "./deps.ts";
+import { JSON_ARG, printJson, refuseInRole } from "./cli-kit.ts";
+
+/** What the phone message names: the run, the unit and the answer, as one command. */
+export const answerCommand = defineCommand({
+  meta: {
+    name: "answer",
+    description: "Answer a parked unit of a run: it runs again with your answer",
+  },
+  args: {
+    run: { type: "positional", required: true, description: "the run id" },
+    unit: {
+      type: "positional",
+      required: true,
+      description: "the parked unit: the run, a milestone or a lane",
+    },
+    answer: {
+      type: "positional",
+      required: false,
+      description: "your answer (several words need no quotes)",
+    },
+    ...JSON_ARG,
+  },
+  async run({ args }) {
+    refuseInRole(process.env, "catherd answer");
+    // citty names the first words; the rest of the line is the answer's too
+    const answer = (args._ as string[]).slice(2).join(" ").trim();
+    if (!answer)
+      throw new CatherdError("E_INPUT_INVALID", "no answer given", {
+        fix: 'catherd answer <run> <unit> "<your answer>"',
+      });
+    const r = await answerUnit(defaultDeps(), { run: args.run, unit: args.unit, answer });
+    if (args.json) return printJson(r);
+    console.log(`answered ${r.unit}${r.parked.length ? `; still waiting: ${r.parked.join(", ")}` : ""}`);
+  },
+});

package/src/entry/catalog-command.ts

@@ -1,4 +1,3 @@
-import { HOST_ARG, terminalHost } from "./host-arg.ts";
 import { defineCommand } from "citty";
 import { CatherdError, isCatherdError } from "../domain/errors.ts";
 import { ROLES, type Role } from "../domain/roles.ts";
@@ -6,68 +5,35 @@ import { gitToplevel } from "../infra/git.ts";
 import {
   type CatalogModel,
   catalogQuery,
+  type IndexStatus,
   type Refreshed,
   refreshDiscovery,
-  saveTreatLike,
+  refreshIndex,
 } from "../services/catalog-service.ts";
-import { readDerived } from "../infra/sources/cache.ts";
-import { type SyncReport, syncSources } from "../services/source-sync.ts";
-import { clearTreatLike, type LeftOnStandIn, resetTreatLikes, suggestFor } from "../services/treat-likes.ts";
-import { exitCodeOf, JSON_ARG, mark, printError, refuseInRole } from "./cli-kit.ts";
+import { indexCheck } from "../services/doctor-checks.ts";
+import { exitCodeOf, JSON_ARG, mark, printError } from "./cli-kit.ts";
 
-/**
- * Spec 1.2 §9: a sync, one line per source (fetched, fresh, skipped, or failed with the answer it kept),
- * then the rungs newly scored, the user's stand-ins no longer needed and the cross-check warnings.
- */
-export function syncLines(r: SyncReport, plain = false): string[] {
-  if (r.busy) return ["- sources: another sync is running; its results apply when it ends"];
-  const out: string[] = [];
-  for (const s of r.sources) {
-    if (s.state === "fetched") out.push(`${mark("ok", plain)} ${s.source}: fetched`);
-    else if (s.state === "fresh") out.push(`- ${s.source}: fresh (fetched ${s.fetchedAt})`);
-    else if (s.state === "skipped") out.push(`- ${s.source}: ${s.detail}`);
-    else
-      out.push(
-        `${mark("warn", plain)} ${s.source}: ${s.error}; ${s.fetchedAt ? `keeps the answer fetched ${s.fetchedAt}` : "no earlier answer"}`,
-      );
-  }
-  if (r.newlyScored.length) out.push(`newly scored: ${r.newlyScored.join(", ")}`);
-  for (const n of r.noLongerNeeded)
-    out.push(`stand-in no longer needed: ${n.rung} has values of its own for what ${n.like} lent it`);
-  for (const w of r.warnings) out.push(`${mark("warn", plain)} ${w}`);
-  return out;
+/** `sync`'s one line: the index's pair count and age, or why the last fetch failed and what was kept. */
+export function syncLine(s: IndexStatus, plain = false, now = Date.now()): string {
+  const c = indexCheck(now, s);
+  return `${mark(c.state === "ok" ? "ok" : "warn", plain)} ${c.label}: ${c.detail}`;
 }
 
 const sync = defineCommand({
   meta: {
     name: "sync",
     description:
-      "Fetch the public model facts and scores now (each source at most every 12 hours unless --force) and show what changed",
+      "Fetch the Slopalytics index now (it is refreshed at most hourly unless --force) and show how many pairs it holds",
   },
   args: {
-    force: { type: "boolean", description: "fetch every source, however fresh" },
-    unmatched: {
-      type: "boolean",
-      description: "also list each source's ids that match no model in the catalog",
-    },
+    force: { type: "boolean", description: "fetch even when the index was checked within the hour" },
     ...JSON_ARG,
   },
   async run({ args }) {
-    try {
-      const r = await syncSources({ force: args.force === true });
-      if (args.json) console.log(JSON.stringify(r, null, 2));
-      else for (const l of syncLines(r)) console.log(l);
-      if (args.unmatched && !args.json) {
-        const unmatched = readDerived()?.unmatched ?? {};
-        if (Object.keys(unmatched).length === 0) console.log("unmatched: none");
-        for (const [source, ids] of Object.entries(unmatched))
-          console.log(`unmatched in ${source}: ${ids.join(", ")}`);
-      }
-      const got = r.sources.some((s) => s.state === "fetched" || s.state === "fresh");
-      process.exitCode = r.failed.length && !got ? 1 : 0;
-    } catch (e) {
-      fail(e);
-    }
+    const s = await refreshIndex({ force: args.force === true });
+    if (args.json) console.log(JSON.stringify(s, null, 2));
+    else console.log(syncLine(s));
+    process.exitCode = s.pairs === 0 ? 1 : 0;
   },
 });
 
@@ -80,29 +46,19 @@ export function formatRefreshed(r: Refreshed, plain = false): string {
   ].join("\n");
 }
 
-/**
- * One model: its rungs scored and roles, then (spec 1.2 §4.1, §5.3, §8) its price and speed facts, and each
- * rung's values with their confidence and source, and the runs catherd has made on it.
- */
+/** One model: its indexed pairs and roles, then each pair's intelligence, price, speed and the runs catherd has made on it. */
 export function formatModel(m: CatalogModel): string {
-  const scored = m.rungs.filter((r) => r.enabled).length;
   const listed = m.listed === false ? "  not offered by this account" : "";
   const lines = [
-    `${m.backend}:${m.model}  ${scored}/${m.rungs.length} rungs scored  roles ${m.roles.join(",") || "none"}${listed}`,
-  ];
-  const facts = [
-    ...(m.price ? [`$${m.price.input}/$${m.price.output} per M tokens in/out`] : []),
-    ...Object.entries(m.speed).map(([k, v]) => `${k} ${Number(v.toPrecision(4))}`),
+    `${m.backend}:${m.model}  ${m.rungs.length} ${m.rungs.length === 1 ? "pair" : "pairs"}  roles ${m.roles.join(",") || "none"}${listed}`,
   ];
-  if (facts.length) lines.push(`  ${facts.join(" · ")}`);
   for (const r of m.rungs) {
-    // spec 1.2 §5.3: each value with its confidence and source, as `route` reports it; a guess names its rung
-    const values = Object.entries(r.scores).map(
-      ([dim, v]) =>
-        `${dim} ${Number(v.value.toPrecision(4))} (${v.from ? (v.lent === "treat-like" ? `like ${v.from}` : `inferred from ${v.from}`) : v.confidence}, ${v.source})`,
-    );
-    if (values.length === 0 && !r.evidence) continue;
-    lines.push(`  #${r.rung.slice(r.rung.lastIndexOf("#") + 1)}  ${values.join(" · ") || "unscored"}`);
+    const parts = [
+      `intelligence ${r.intelligence.toFixed(1)}`,
+      ...(r.price ? [`$${r.price.input}/$${r.price.output} per M`] : []),
+      ...(r.speed !== null ? [`${Number(r.speed.toPrecision(3))} tok/s`] : []),
+    ];
+    lines.push(`  #${r.rung.slice(r.rung.lastIndexOf("#") + 1)}  ${parts.join(" · ")}`);
     if (r.evidence) lines.push(`    runs: ${r.evidence}`);
   }
   return lines.join("\n");
@@ -129,12 +85,11 @@ const refresh = defineCommand({
 });
 
 const list = defineCommand({
-  meta: { name: "list", description: "The models catherd can place, with their scored rungs" },
+  meta: { name: "list", description: "The models catherd can place, with their indexed pairs" },
   args: {
     backend: { type: "string", description: "only this backend or billing key" },
     role: { type: "string", description: `only models for this role (${ROLES.join(", ")})` },
     text: { type: "string", description: "only ids containing this" },
-    scored: { type: "boolean", description: "only models with a scored rung" },
     ...JSON_ARG,
   },
   async run({ args }) {
@@ -149,7 +104,6 @@ const list = defineCommand({
         backend: args.backend,
         role: args.role as Role | undefined,
         text: args.text,
-        scoredOnly: args.scored === true,
         limit: 10_000,
         repo: await hereRepo(),
       });
@@ -161,111 +115,8 @@ const list = defineCommand({
   },
 });
 
-/** Spec 1.2 §6.4: the profile rungs a removal leaves on an inferred stand-in or unscored, one line each. */
-export function leftLines(left: LeftOnStandIn[], plain = false): string[] {
-  return left.map((l) => {
-    const what = l.unscored
-      ? ["unscored: routing skips it"]
-      : [
-          ...(l.dims.length ? [`on an inferred stand-in for ${l.dims.join(", ")}`] : []),
-          ...(l.missing?.length
-            ? [`with no ${l.missing.join(", ")} value: it clears no bar that needs one`]
-            : []),
-        ];
-    return `${mark("warn", plain)} ${l.profile}: ${l.rung} is left ${what.join(", and ")}`;
-  });
-}
-
-/** Spec 1.2 §6.4 `--suggest`: the three nearest stand-ins, each with its distance and the features it rests on. */
-export function suggestLines(r: ReturnType<typeof suggestFor>, rung: string): string[] {
-  const head = r.lacking.length
-    ? `${r.canonical} has no ${r.lacking.join(", ")} value of its own; the nearest stand-ins:`
-    : `${r.canonical} has every value the bars use; the nearest scored rungs:`;
-  if (r.suggestions.length === 0)
-    return [
-      `${r.canonical}: no scored rung shares 3 features with it; map it by hand: catherd catalog treat-like ${rung} <rung>`,
-    ];
-  return [
-    head,
-    ...r.suggestions.map(
-      (s, i) =>
-        `  ${i + 1}. ${s.like}  distance ${s.distance.toFixed(2)}  lends ${s.lends.join(", ")}  on ${s.features.join(", ")}`,
-    ),
-    `map one: catherd catalog treat-like ${rung} <rung>`,
-  ];
-}
-
-const treatLike = defineCommand({
-  meta: {
-    name: "treat-like",
-    description:
-      "Score an unscored rung as a scored one; --suggest ranks stand-ins, --clear and --reset remove your mappings",
-  },
-  args: {
-    ...HOST_ARG,
-    rung: {
-      type: "positional",
-      required: false,
-      description: "the unscored rung, backend:model#effort or model#effort",
-    },
-    like: { type: "positional", required: false, description: "the scored rung whose scores it borrows" },
-    suggest: { type: "string", description: "list the 3 nearest stand-ins for this rung" },
-    clear: { type: "string", description: "remove your treat-like for this rung" },
-    reset: { type: "boolean", description: "remove every treat-like of yours" },
-    ...JSON_ARG,
-  },
-  async run({ args }) {
-    try {
-      const modes = [
-        args.suggest !== undefined,
-        args.clear !== undefined,
-        args.reset === true,
-        args.rung !== undefined,
-      ];
-      if (modes.filter(Boolean).length !== 1 || (args.rung !== undefined && args.like === undefined))
-        throw new CatherdError(
-          "E_INPUT_INVALID",
-          "treat-like takes <rung> <like>, or one of --suggest, --clear, --reset",
-          {
-            fix: "catherd catalog treat-like <rung> <like> | --suggest <rung> | --clear <rung> | --reset",
-          },
-        );
-      if (args.suggest !== undefined) {
-        const r = suggestFor(args.suggest);
-        if (args.json) console.log(JSON.stringify(r, null, 2));
-        else for (const l of suggestLines(r, args.suggest)) console.log(l);
-        return;
-      }
-      refuseInRole(process.env, "catherd catalog treat-like");
-      if (args.clear !== undefined) {
-        const r = await clearTreatLike(args.clear, terminalHost(args.host).host);
-        if (args.json) return console.log(JSON.stringify(r, null, 2));
-        for (const l of leftLines(r.left)) console.log(l);
-        console.log(`${mark("ok")} ${r.rung} is no longer treated like ${r.like}`);
-        return;
-      }
-      if (args.reset) {
-        const r = await resetTreatLikes(terminalHost(args.host).host);
-        if (args.json) return console.log(JSON.stringify(r, null, 2));
-        for (const l of leftLines(r.left)) console.log(l);
-        console.log(
-          r.removed.length
-            ? `${mark("ok")} removed ${r.removed.length} treat-like${r.removed.length === 1 ? "" : "s"}: ${r.removed.map(([a, b]) => `${a} → ${b}`).join(", ")}`
-            : "no treat-like of yours to remove",
-        );
-        return;
-      }
-      const r = await saveTreatLike(args.rung as string, args.like as string);
-      if (args.json) return console.log(JSON.stringify(r, null, 2));
-      console.log(`${mark("ok")} ${r.rung} is treated like ${r.like}`);
-    } catch (e) {
-      fail(e);
-    }
-  },
-});
-
-/** Spec §8 and 1.2 §9: `catherd catalog refresh|list|sync|treat-like <rung> <like> | --suggest|--clear|--reset`. */
+/** Spec §8: `catherd catalog refresh|list|sync`. */
 export const catalogCommand = defineCommand({
   meta: { name: "catalog", description: "The model catalog" },
-  subCommands: { refresh, list, sync, "treat-like": treatLike },
+  subCommands: { refresh, list, sync },
 });

package/src/entry/check-bin.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+// The detached check worker's entry: it imports only what running one milestone check needs, never src/cli.ts.
+import { errorMessage } from "../domain/errors.ts";
+import { checkWorker } from "../services/milestone-check.ts";
+
+const flight = process.argv[2];
+if (!flight) {
+  console.error("usage: check-bin.ts <flight file>");
+  process.exit(2);
+}
+try {
+  await checkWorker(flight);
+} catch (e) {
+  console.error(`catherd check: ${errorMessage(e)}`);
+  process.exit(1);
+}
+process.exit(0);

package/src/entry/cli-kit.ts

@@ -46,7 +46,7 @@ export const printJson = (v: unknown): void => console.log(JSON.stringify(v, nul
 export const JSON_ARG = { json: { type: "boolean", description: "print JSON" } } as const;
 
 /**
- * The glyph for a state, as in `✓ ready`: the dashboard's own (spec §9.3), ASCII with `--plain` only;
+ * The glyph for a state, as in `✓ ready`: catherd's own (spec §9.3), ASCII with `--plain` only;
  * NO_COLOR drops colour, never glyphs. The caller adds the word.
  */
 export const mark = (state: State, plain = false): string => glyph(state, plain);

package/src/entry/daemon-bin.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+// The detached run daemon's entry: like the supervisor's it imports only what driving a run needs, never
+// src/cli.ts.
+import { errorMessage } from "../domain/errors.ts";
+import { runDaemon } from "../services/daemon.ts";
+import { defaultDeps } from "./deps.ts";
+
+const runId = process.argv[2];
+if (!runId) {
+  console.error("usage: daemon-bin.ts <run id>");
+  process.exit(2);
+}
+try {
+  // nobody's role and no Claude Code session: the daemon answers to the run's events
+  const result = await runDaemon({ ...defaultDeps(), session: null, role: null }, runId);
+  if (result === "lost-lock") console.error(`catherd daemon: another daemon holds run ${runId}`);
+} catch (e) {
+  console.error(`catherd daemon: ${errorMessage(e)}`);
+  process.exit(1);
+}
+// the lock is released and the run's events are written: a hook's call left hanging must not keep it alive
+process.exit(0);

package/src/entry/glyphs.ts

@@ -1,6 +1,6 @@
 /**
- * Spec §9.3's glyphs, each with its ASCII twin for `--plain`: the dashboard and every CLI command draw
- * state with these. Free of OpenTUI, so `mcp`, `lock` and `_supervise` can load it (spec §3.1).
+ * Spec §9.3's glyphs, each with its ASCII twin for `--plain`: every CLI command draws state with these, so
+ * `mcp`, `lock` and `_supervise` can load them (spec §3.1).
  */
 const GLYPHS = {
   ok: ["✓", "+"],
@@ -32,3 +32,16 @@ export const glyph = (g: Glyph, plain: boolean): string => GLYPHS[g][plain ? 1 :
 
 /** The words state always travels with (spec §9.3: green/amber/red only for state, always with a word). */
 export type State = "ok" | "warn" | "fail" | "skip" | "info";
+
+export type Mood = "good" | "working" | "waiting" | "failed";
+export const FACES: Record<Mood, string> = {
+  good: "=^.^=",
+  working: "=o.o=",
+  waiting: "=-.-=",
+  failed: "=x.x=",
+};
+
+/** The conductor, for the init welcome only (spec §9.3). ASCII already. */
+export function mascot(mood: Mood): [string, string, string] {
+  return [" /\\_/\\  .", `(${FACES[mood]})/`, ' (")(")'].map((l) => l.padEnd(9)) as [string, string, string];
+}

package/src/entry/init-command.ts

@@ -6,20 +6,17 @@ import { errorMessage, isCatherdError } from "../domain/errors.ts";
 import { configDir } from "../infra/paths.ts";
 import { VERSION } from "../infra/version.ts";
 import { doctor } from "../services/doctor.ts";
-import { testAaKey } from "../infra/sources/artificial-analysis.ts";
-import { aaKey, saveAaKey } from "../services/credentials.ts";
+import { type IndexStatus, refreshIndex } from "../services/catalog-service.ts";
 import { jevKey, saveJevKey, testJevKey } from "../services/jev-service.ts";
-import { type SyncReport, syncSources } from "../services/source-sync.ts";
 import { reinstallCommand } from "../services/doctor-checks.ts";
 import { ensureGlobal, type GlobalInstallDeps, realGlobalInstall } from "../services/global-install.ts";
 import { hasProfileFile, type InitResult, initSetup, moveLegacy } from "../services/setup.ts";
 import { activeName } from "../services/profile-store.ts";
-import { formatRefreshed, syncLines } from "./catalog-command.ts";
+import { formatRefreshed } from "./catalog-command.ts";
 import { mark as markOf, refuseInRole } from "./cli-kit.ts";
 import { formatReport } from "./doctor-command.ts";
 import { mcpHandshake } from "./mcp/handshake.ts";
-import type { State } from "./glyphs.ts";
-import { mascot } from "./tui/theme.ts";
+import { mascot, type State } from "./glyphs.ts";
 import { type Prompter, prompter } from "./prompt.ts";
 
 /** What `init` prints last (spec §9.1): the plugin install commands, to paste into a terminal. */
@@ -30,7 +27,7 @@ export const PLUGIN_STEPS = [
   "Then start a new Claude Code session, so it loads the plugin and the catherd agents.",
 ];
 
-/** Spec §9.3: the full mascot greets `init` (and the TUI's empty states), nowhere else. */
+/** Spec §9.3: the full mascot greets `init` nowhere else. */
 export function welcomeLines(version: string): string[] {
   const [ears, face, paws] = mascot("good");
   return [ears, `${face}  catherd ${version}`, `${paws}  herds your coding agents`, ""];
@@ -72,68 +69,22 @@ export async function jevStep(
 }
 
 /**
- * Spec 1.2 §9: the Artificial Analysis key step, after Jev's. ARTIFICIAL_ANALYSIS_API_KEY wins, else the saved
- * key, else a prompt (Enter skips). A typed key is tested with one request: a 200 saves it, a 401 does not,
- * and a key that cannot be checked (no network) is not saved either. It never stops `init`.
- */
-export async function aaStep(
-  ask: Prompter | null,
-  d: {
-    testAaKey?: (key: string) => Promise<{ result: "ok" | "refused" | "unchecked"; error?: string }>;
-    saveAaKey?: (key: string) => void;
-  } = {},
-  plain = false,
-): Promise<void> {
-  const mark = (state: State) => markOf(state, plain);
-  if (process.env.ARTIFICIAL_ANALYSIS_API_KEY?.trim()) {
-    ask?.skip?.();
-    return console.log(`${mark("ok")} Artificial Analysis: using ARTIFICIAL_ANALYSIS_API_KEY`);
-  }
-  if (aaKey()) {
-    ask?.skip?.();
-    return console.log(`${mark("ok")} Artificial Analysis: using the saved key`);
-  }
-  const key = ask ? await ask.secret("Artificial Analysis API key (optional; Enter skips): ") : "";
-  if (!key)
-    return console.log(
-      "- Artificial Analysis: no key; scores come from the keyless sources (add one later with catherd init)",
-    );
-  const t = await (d.testAaKey ?? testAaKey)(key).catch((e: unknown) => ({
-    result: "unchecked" as const,
-    error: errorMessage(e),
-  }));
-  if (t.result === "refused")
-    return console.log(`${mark("warn")} Artificial Analysis: the key was refused (401), so it was not saved`);
-  if (t.result === "unchecked")
-    return console.log(
-      `${mark("warn")} Artificial Analysis: the key could not be checked (${t.error ?? "no answer"}), so it was not saved; run catherd init again to retry`,
-    );
-  try {
-    (d.saveAaKey ?? saveAaKey)(key);
-    console.log(`${mark("ok")} Artificial Analysis: the key answers; saved with mode 600`);
-  } catch (e) {
-    console.log(
-      `${mark("warn")} Artificial Analysis: could not save the key: ${errorMessage(e).split("\n").join(" ")}`,
-    );
-    if (isCatherdError(e) && e.fix) console.log(`    fix: ${e.fix}`);
-  }
-}
-
-/**
- * Spec 1.2 §9: `init` syncs the public sources in the foreground, after the keys. It never stops `init`;
+ * `init` refreshes the Slopalytics index in the foreground, after the Jev key. It never stops `init`;
  * CATHERD_NO_SYNC=1 skips it.
  */
-export async function syncStep(o: { plain?: boolean; sync?: () => Promise<SyncReport> } = {}): Promise<void> {
+export async function syncStep(
+  o: { plain?: boolean; sync?: () => Promise<IndexStatus> } = {},
+): Promise<void> {
   const plain = o.plain === true;
   if (process.env.CATHERD_NO_SYNC === "1")
-    return console.log("- sources: not synced (CATHERD_NO_SYNC=1); catherd catalog sync fetches them");
-  console.log("syncing the public model sources…");
-  try {
-    for (const l of syncLines(await (o.sync ?? (() => syncSources()))(), plain)) console.log(l);
-  } catch (e) {
-    console.log(`${markOf("warn", plain)} sources: ${errorMessage(e).split("\n").join(" ")}`);
-    console.log("    fix: catherd catalog sync");
-  }
+    return console.log("- catalog: not fetched (CATHERD_NO_SYNC=1); catherd catalog sync fetches it");
+  console.log("fetching the Slopalytics index…");
+  const s = await (o.sync ?? (() => refreshIndex({ auto: true })))().catch(
+    (e: unknown) => ({ error: errorMessage(e), pairs: 0 }) as Pick<IndexStatus, "error" | "pairs">,
+  );
+  if (s.error === null) return console.log(`${markOf("ok", plain)} Slopalytics: ${s.pairs} pairs indexed`);
+  console.log(`${markOf("warn", plain)} Slopalytics: ${s.error.split("\n").join(" ")}`);
+  console.log("    fix: catherd catalog sync");
 }
 
 /**
@@ -190,12 +141,12 @@ export function profileLines(r: InitResult, plain = false): string[] {
   return out;
 }
 
-/** Spec §8 `catherd init [--no-input]`: first-run setup without the TUI (plan 6 adds the TUI wizard). */
+/** Spec §8 `catherd init [--no-input]`: first-run setup without the panel. */
 export const initCommand = defineCommand({
   meta: {
     name: "init",
     description:
-      "First run: the global catherd command, the Jev key, the Artificial Analysis key, a sync of the public model sources, the default profile, its agents, and a readiness report. Piped, it reads the answers from stdin one per line, a line per question even when this machine skips it (the Jev key, the Artificial Analysis key, the profile, whether to replace it), and waits for stdin to close; --no-input asks nothing",
+      "First run: the global catherd command, the Jev key, a fetch of the Slopalytics model index, the default profile, its agents, and a readiness report. Piped, it reads the answers from stdin one per line, a line per question even when this machine skips it (the Jev key, the profile, whether to replace it), and waits for stdin to close; --no-input asks nothing",
   },
   args: {
     ...HOST_ARG,
@@ -224,7 +175,6 @@ export const initCommand = defineCommand({
       console.log(`catherd ${VERSION}: setting up in ${configDir()}`);
       await globalStep(VERSION, { skip: (args as { global?: boolean }).global === false, plain });
       await jevStep(ask, {}, plain);
-      await aaStep(ask, {}, plain);
       await syncStep({ plain });
       const repo = await gitToplevel(process.cwd());
       // 0.x files go first, so a legacy profile about to be moved aside is never asked about