@catalyst-cloud/catalyst-skills 0.1.1 → 0.2.1

package/dist/http.js

@@ -0,0 +1,175 @@
+import { normalizeBaseUrl } from "./config.js";
+import { CliError, MeError } from "./errors.js";
+export const REQUEST_TIMEOUT_MS = 15_000;
+export class ApiClient {
+    cfg;
+    fetchImpl;
+    constructor(cfg, fetchImpl) {
+        this.cfg = cfg;
+        this.fetchImpl = fetchImpl;
+    }
+    /** `path` is absolute under the origin (e.g. `/api/v1/issues`). */
+    url(path, query) {
+        const u = new URL(`${normalizeBaseUrl(this.cfg.baseUrl)}${path}`);
+        for (const [k, v] of Object.entries(query ?? {}))
+            if (v !== undefined)
+                u.searchParams.set(k, String(v));
+        return u.toString();
+    }
+    async getJson(path, opts = {}) {
+        const headers = {
+            authorization: `Bearer ${this.cfg.key}`,
+            accept: "application/json",
+        };
+        if (opts.etag)
+            headers["if-none-match"] = opts.etag;
+        const url = this.url(path, opts.query);
+        const res = await this.send(url, { method: "GET", headers });
+        if (opts.accept?.includes(res.status)) {
+            return { status: res.status, body: undefined, headers: res.headers };
+        }
+        await this.refuseIfNotOk(res, `GET ${path}`);
+        return { status: res.status, body: await this.parseBody(res, `GET ${path}`), headers: res.headers };
+    }
+    /**
+     * A GET whose success body is NDJSON — one JSON object per line, the shape `streamNdjson` sends.
+     *
+     * ⛔ `/changes` and `/snapshot` ANSWER NDJSON ON 200 AND JSON ON A REFUSAL, so a caller that only
+     * has `getJson` reads every real success as "returned a non-JSON body" while its refusals parse
+     * perfectly. That asymmetry is why `query changes` looked like it worked: nothing reached a 200.
+     * `accept` behaves as it does on `getJson` — those statuses come back with `rows: []` for the
+     * caller to branch on, and their (JSON) body is deliberately not parsed here.
+     */
+    async getNdjson(path, opts = {}) {
+        const url = this.url(path, opts.query);
+        const res = await this.send(url, {
+            method: "GET",
+            headers: { authorization: `Bearer ${this.cfg.key}`, accept: "application/x-ndjson, application/json" },
+        });
+        if (opts.accept?.includes(res.status))
+            return { status: res.status, body: [], headers: res.headers };
+        await this.refuseIfNotOk(res, `GET ${path}`);
+        const text = await res.text();
+        const rows = [];
+        for (const line of text.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed === "")
+                continue;
+            try {
+                rows.push(JSON.parse(trimmed));
+            }
+            catch {
+                throw new MeError(`GET ${path} returned a line that is not JSON: ${trimmed.slice(0, 120)}`, "shape");
+            }
+        }
+        return { status: res.status, body: rows, headers: res.headers };
+    }
+    async postJson(path, body) {
+        const url = this.url(path);
+        const res = await this.send(url, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.cfg.key}`,
+                accept: "application/json",
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        await this.refuseIfNotOk(res, `POST ${path}`);
+        return { status: res.status, body: await this.parseBody(res, `POST ${path}`), headers: res.headers };
+    }
+    async send(url, init) {
+        try {
+            return await this.fetchImpl(url, { ...init, signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+        }
+        catch (err) {
+            throw new MeError(`could not reach ${url}: ${err instanceof Error ? err.message : String(err)}`, "network");
+        }
+    }
+    async parseBody(res, what) {
+        try {
+            return (await res.json());
+        }
+        catch {
+            throw new MeError(`${what} returned a non-JSON body`, "shape");
+        }
+    }
+    async refuseIfNotOk(res, what) {
+        if (res.ok)
+            return;
+        let reason = "";
+        let raw = "";
+        try {
+            raw = await res.text();
+            const body = JSON.parse(raw);
+            reason = body.reason ?? body.error ?? body.message ?? "";
+        }
+        catch {
+            reason = raw.slice(0, 200);
+        }
+        if (res.status === 401) {
+            throw new CliError(`${what} failed (401): credential not accepted — ask your tenant admin for a valid account key`, "unauthorized", 2, 401);
+        }
+        if (res.status === 403) {
+            throw new CliError(`${what} failed (403): this key may not reach that route${reason ? ` (${reason})` : ""} — a machine-gated route needs an account key (ctc_acct_…), not a workstation key`, "forbidden", 2, 403);
+        }
+        if (res.status === 429) {
+            const retryAfter = res.headers.get("retry-after");
+            const budget = /budget/i.test(raw) || /budget/i.test(reason);
+            throw new CliError(`${what} refused (429)${budget ? ": the per-host daily write budget is spent" : ": rate limited"}${reason ? ` — ${reason}` : ""}${retryAfter ? ` — retry after ${retryAfter}s` : ""}`, budget ? "budget" : "rate-limited", 2, 429);
+        }
+        throw new CliError(`${what} failed (${res.status})${reason ? `: ${reason}` : ""}`, "http", 2, res.status);
+    }
+}
+export function apiClient(cfg, ctx) {
+    return new ApiClient(cfg, ctx.fetch);
+}
+/** GET /api/v1/me — how a key learns its own tenant. Unchanged contract from 0.1. */
+export async function fetchMe(baseUrl, key, fetchImpl, timeoutMs = REQUEST_TIMEOUT_MS) {
+    const url = `${normalizeBaseUrl(baseUrl)}/api/v1/me`;
+    let res;
+    try {
+        res = await fetchImpl(url, {
+            headers: { authorization: `Bearer ${key}`, accept: "application/json" },
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+    }
+    catch (err) {
+        throw new MeError(`could not reach ${url}: ${err instanceof Error ? err.message : String(err)}`, "network");
+    }
+    if (!res.ok) {
+        let reason;
+        try {
+            const body = (await res.json());
+            reason = body.reason ?? body.error ?? "";
+        }
+        catch {
+            reason = "";
+        }
+        const detail = res.status === 401
+            ? "credential not accepted — ask your tenant admin for a valid account key"
+            : reason || `HTTP ${res.status}`;
+        throw new MeError(`GET /me failed (${res.status}): ${detail}`, "http", res.status);
+    }
+    let body;
+    try {
+        body = (await res.json());
+    }
+    catch {
+        throw new MeError("GET /me returned a non-JSON body", "shape");
+    }
+    if (typeof body.account !== "string" ||
+        typeof body.slug !== "string" ||
+        typeof body.name !== "string" ||
+        (body.permissions !== null && !Array.isArray(body.permissions)) ||
+        (body.principal !== "service" && body.principal !== "session")) {
+        throw new MeError("GET /me returned an unexpected shape", "shape");
+    }
+    return {
+        account: body.account,
+        slug: body.slug,
+        name: body.name,
+        permissions: body.permissions,
+        principal: body.principal,
+    };
+}

package/dist/prompt.js

@@ -0,0 +1,35 @@
+// prompt.ts — the one interactive read in the CLI: asking for the account key on a terminal without
+// echoing it. The streams are parameters so the tests can drive it without a real TTY.
+import { createInterface } from "node:readline";
+/** True when there is a terminal to prompt on. Both ends matter: the question needs somewhere to go. */
+export function stdinIsTty() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+/**
+ * Read one line without echoing it. Everything readline would write after the question itself goes
+ * to a muted stream, so the key never reaches the screen or a scrollback buffer; the caller still
+ * gets it back, trimmed.
+ */
+export async function promptSecret(question, io) {
+    const input = io?.input ?? process.stdin;
+    const target = io?.output ?? process.stdout;
+    let muted = false;
+    const output = Object.create(target);
+    output.write = (chunk) => {
+        if (!muted)
+            target.write(chunk);
+        return true;
+    };
+    const rl = createInterface({ input, output, terminal: true });
+    try {
+        const answer = await new Promise((resolve) => {
+            rl.question(question, (value) => resolve(value));
+            muted = true;
+        });
+        target.write("\n");
+        return answer.trim();
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/query.js

@@ -0,0 +1,225 @@
+// query.ts — `query issues|issue|pulls|pull|projects|cycles|search|changes`: the replica when it is
+// fresh, else the API, with the source named on stderr every time. Output shape is the read-model
+// view either way. `pull`, `cycles`, `search` and `changes` are API-only (the SDK wraps no view for
+// them and the read-model package is not a declared dependency of this bundle).
+import { flagInt, flagString, positionals } from "./args.js";
+import { requireConfig, replicaDbPath } from "./config.js";
+import { CliError, UsageError } from "./errors.js";
+import { apiClient } from "./http.js";
+import { engineFor, replicaStatus } from "./replica.js";
+import { loadSdk } from "./sdk.js";
+const REPLICA_CAPABLE = new Set(["issues", "issue", "pulls", "projects"]);
+export async function cmdQuery(args, ctx, deps = {}) {
+    const [sub, ...rest] = positionals(args);
+    if (!sub)
+        throw new UsageError("query needs a subcommand: issues | issue <id> | pulls | pull <id> | projects | cycles | search <terms> | changes --since <n>");
+    const cfg = requireConfig(ctx);
+    const filters = {
+        team: flagString(args, "team"),
+        project: flagString(args, "project"),
+        state: flagString(args, "state"),
+        limit: flagInt(args, "limit", 50),
+    };
+    const forced = flagString(args, "source");
+    if (forced && forced !== "replica" && forced !== "api")
+        throw new UsageError("--source must be replica or api");
+    const status = replicaStatus(ctx, cfg);
+    let source;
+    let why;
+    if (!REPLICA_CAPABLE.has(sub)) {
+        source = "api";
+        why = `${sub} is api-only`;
+    }
+    else if (forced) {
+        source = forced;
+        why = `--source ${forced}`;
+    }
+    else if (status.verdict === "fresh") {
+        source = "replica";
+        why = `cursor ${status.cursor}`;
+    }
+    else {
+        source = "api";
+        why = `replica ${status.verdict}`;
+    }
+    ctx.stderr(source === "replica" ? `source: replica (${why})` : `source: api (${why})`);
+    let result;
+    if (source === "replica") {
+        if (status.verdict === "absent" || status.verdict === "not-configured") {
+            throw new UsageError(`--source replica but the replica is ${status.verdict}`);
+        }
+        result = await fromReplica(ctx, cfg, sub, rest, filters, deps);
+    }
+    else {
+        result = await fromApi(ctx, cfg, sub, rest, filters, args);
+    }
+    if (result === null) {
+        ctx.stderr(`${sub} ${rest[0] ?? ""}: not found`);
+        return 1;
+    }
+    printResult(ctx, args, sub, result);
+    return 0;
+}
+async function fromReplica(ctx, cfg, sub, rest, f, deps) {
+    const sdk = await loadSdk();
+    const dbPath = replicaDbPath(cfg, ctx.home);
+    const engine = await engineFor(sdk, dbPath, ctx, { ...deps.engineDeps, readonly: true });
+    const replica = await sdk.CatalystReplica.openReadOnly({ dbPath, engine, log: () => { } });
+    try {
+        switch (sub) {
+            case "issues": {
+                const rows = replica.issues({ limit: Math.max(f.limit, 200) });
+                return applyFilters(rows, f).slice(0, f.limit);
+            }
+            case "issue":
+                return replica.issue(needArg(rest, "issue <identifier>"));
+            case "pulls":
+                return replica.pulls({ limit: f.limit });
+            case "projects":
+                return applyFilters(replica.projects({ limit: Math.max(f.limit, 200) }), { limit: f.limit, state: f.state }).slice(0, f.limit);
+            default:
+                throw new UsageError(`${sub} is not readable from the replica`);
+        }
+    }
+    finally {
+        await replica.close();
+    }
+}
+async function fromApi(ctx, cfg, sub, rest, f, args) {
+    const api = apiClient(cfg, ctx);
+    const common = { team: f.team, project: f.project, state: f.state, limit: f.limit };
+    switch (sub) {
+        case "issues": {
+            const res = await api.getJson("/api/v1/issues", { query: common });
+            return applyFilters(rowsOf(res.body), f).slice(0, f.limit);
+        }
+        case "issue": {
+            const id = needArg(rest, "issue <identifier>");
+            const res = await api.getJson(`/api/v1/issues/${encodeURIComponent(id)}`, { accept: [404] });
+            return res.status === 404 ? null : res.body;
+        }
+        case "pulls": {
+            const res = await api.getJson("/api/v1/pulls", { query: { limit: f.limit, ticket: flagString(args, "ticket") } });
+            return rowsOf(res.body).slice(0, f.limit);
+        }
+        case "pull": {
+            const id = needArg(rest, "pull <node id>");
+            const res = await api.getJson(`/api/v1/pulls/${encodeURIComponent(id)}`, { accept: [404] });
+            return res.status === 404 ? null : res.body;
+        }
+        case "projects": {
+            const res = await api.getJson("/api/v1/projects", { query: { limit: f.limit } });
+            return rowsOf(res.body).slice(0, f.limit);
+        }
+        case "cycles": {
+            const res = await api.getJson("/api/v1/cycles", { query: { team: f.team, limit: f.limit } });
+            return rowsOf(res.body);
+        }
+        case "search": {
+            const q = rest.join(" ").trim();
+            if (!q)
+                throw new UsageError("search needs terms: query search <terms>");
+            const res = await api.getJson("/api/v1/search", { query: { q, limit: f.limit } });
+            return rowsOf(res.body);
+        }
+        case "changes": {
+            const since = flagString(args, "since");
+            if (since === undefined)
+                throw new UsageError("changes needs --since <cursor>, or --since head to start from now");
+            return await readChanges(api, since, f.limit);
+        }
+        default:
+            throw new UsageError(`unknown query subcommand: ${sub}`);
+    }
+}
+/** CTC-137 stamps the live head seq on EVERY `/changes` response — the 200 stream and both 409s. */
+const HEAD_SEQ_HEADER = "x-catalyst-head-seq";
+/**
+ * `query changes --since <cursor|head>`.
+ *
+ * ⛔ THE CHANGEFEED EVICTS, so a refusal must name a cursor that works. `buildChanges` answers a
+ * `since` below the oldest retained seq with 409 `cursor_underflow`, and one past the head with 409
+ * `cursor_ahead_of_head` — both `{resync: true}`. `--since 0`, the form the docs show, is therefore
+ * a 409 on any tenant whose log has rotated, and 0.2.0 surfaced it as a bare "GET /api/v1/changes
+ * failed (409)" that left the customer with no way to learn a usable cursor. The head is stamped on
+ * the refusal itself, so there is always something actionable to say.
+ */
+async function readChanges(api, since, limit) {
+    const resolved = since === "head" ? String(await headCursor(api)) : since;
+    // ⛔ NDJSON ON 200, JSON ON A REFUSAL — see `getNdjson`. Reading this with `getJson` turned every
+    // real success into "returned a non-JSON body" while every refusal parsed, which is why the verb
+    // looked fine: `--since 0` 409s on a rotated feed, so no 200 was ever reached to fail on.
+    const res = await api.getNdjson("/api/v1/changes", {
+        query: { since: resolved, limit },
+        accept: [409],
+    });
+    const head = res.headers.get(HEAD_SEQ_HEADER);
+    if (res.status !== 409) {
+        return { since: Number(resolved), head: head === null ? null : Number(head), changes: res.body };
+    }
+    const where = head === null ? "" : ` The feed's live cursor is ${head}.`;
+    throw new CliError(`cursor ${resolved} is not usable: it is either past the feed's head or no longer in the change log, which keeps only recent changes.${where} Re-run with \`--since head\` to start from now, or with a cursor the feed still holds.`, "changefeed-resync", 1, 409);
+}
+/** The live head, read off any `/changes` response's own header — a 409 carries it too, which is
+ *  what makes this work on a tenant whose log has rotated past every cursor the caller could guess. */
+async function headCursor(api) {
+    const probe = await api.getNdjson("/api/v1/changes", { query: { since: "0", limit: 1 }, accept: [409] });
+    const raw = probe.headers.get(HEAD_SEQ_HEADER);
+    const head = raw === null ? Number.NaN : Number(raw);
+    if (!Number.isFinite(head)) {
+        throw new CliError(`--since head needs the feed's live cursor, and this cloud did not send one (no ${HEAD_SEQ_HEADER} header). Pass an explicit --since <cursor>.`, "changefeed-head-unknown", 1);
+    }
+    return head;
+}
+function needArg(rest, usage) {
+    const v = rest[0];
+    if (!v)
+        throw new UsageError(`query ${usage}`);
+    return v;
+}
+/** The API answers a list route with either a bare array or `{rows|items|issues|...: []}`. */
+export function rowsOf(body) {
+    if (Array.isArray(body))
+        return body;
+    if (body && typeof body === "object") {
+        for (const key of ["rows", "items", "issues", "pulls", "projects", "cycles", "results", "changes", "data"]) {
+            const v = body[key];
+            if (Array.isArray(v))
+                return v;
+        }
+    }
+    return [];
+}
+export function applyFilters(rows, f) {
+    return rows.filter((r) => {
+        if (f.team && !(String(r.identifier ?? "").toUpperCase().startsWith(`${f.team.toUpperCase()}-`) || r.team_id === f.team || r.team_key === f.team))
+            return false;
+        if (f.project && r.project_id !== f.project)
+            return false;
+        if (f.state && String(r.state ?? "").toLowerCase() !== f.state.toLowerCase())
+            return false;
+        return true;
+    });
+}
+function printResult(ctx, args, sub, result) {
+    if (args.json || !Array.isArray(result)) {
+        ctx.stdout(JSON.stringify(result, null, args.json ? 0 : 2));
+        return;
+    }
+    for (const row of result)
+        ctx.stdout(summaryLine(sub, row));
+}
+export function summaryLine(sub, r) {
+    switch (sub) {
+        case "issues":
+            return `${r.identifier ?? r.id}  ${r.state ?? "?"}  ${r.title ?? ""}${r.assignee_name || r.assignee ? `  (${r.assignee_name ?? r.assignee})` : ""}`;
+        case "pulls":
+            return `#${r.number ?? "?"}  ${r.state ?? "?"}${r.merged ? " merged" : ""}  ${r.title ?? ""}  [${r.node_id ?? ""}]`;
+        case "projects":
+            return `${r.id}  ${r.state ?? "?"}  ${r.name ?? ""}`;
+        case "cycles":
+            return `cycle ${r.number ?? r.id}  ${r.name ?? ""}  ${r.starts_at ?? ""} → ${r.ends_at ?? ""}`;
+        default:
+            return JSON.stringify(r);
+    }
+}

package/dist/ready.js

@@ -0,0 +1,123 @@
+// ready.ts — `ready`: the machine checks plus the tenant's own readiness vector from the contract,
+// one verdict, and per failure the fix and who can apply it. The replica is optional, so its absence
+// is a note, never a failure; the SDK loading IS a check, because the replica and watch need it.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { defaultSkillsDirFor, loadConfig, readManifest } from "./config.js";
+import { contractVersionInRange, readContractCache } from "./contract.js";
+import { CliError } from "./errors.js";
+import { replicaStatus, statusLine } from "./replica.js";
+import { loadSdk } from "./sdk.js";
+function whoCanAnswer(doc) {
+    const roles = doc.humans.map((h) => `${h.role} ${h.linearUserId}`);
+    return roles.length ? roles.join(", ") : "a tenant owner or admin (none resolved on the contract)";
+}
+export async function readyReport(ctx, deps) {
+    const checks = [];
+    const nodeMajor = deps.nodeMajor ?? Number(process.versions.node.split(".")[0]);
+    checks.push(nodeMajor >= 22
+        ? { id: "node", ok: true, line: `node: ${nodeMajor} (22 or newer required)` }
+        : { id: "node", ok: false, line: `node: ${nodeMajor} is too old`, fix: "install Node 22 or newer (the SDK's built-in SQLite engine needs it)", who: "you" });
+    let cfg = null;
+    try {
+        cfg = loadConfig(ctx.home);
+        checks.push(cfg
+            ? { id: "config", ok: true, line: `config: joined ${cfg.name} (${cfg.slug}) as ${cfg.principal}` }
+            : { id: "config", ok: false, line: "config: not connected", fix: "CATALYST_CLOUD_TOKEN=<account key> npx @catalyst-cloud/catalyst-skills login", who: "you (the key comes from your tenant admin)" });
+    }
+    catch (err) {
+        checks.push({ id: "config", ok: false, line: `config: ${err instanceof CliError ? err.message : String(err)}`, fix: "re-run login to rewrite it", who: "you" });
+    }
+    const cache = readContractCache(ctx.home);
+    const range = readManifest().tenantContractRange;
+    if (!cache) {
+        checks.push({ id: "contract", ok: false, line: "contract: not cached", fix: "catalyst-skills contract --refresh (needs an account key, not a workstation key)", who: "you" });
+    }
+    else if (contractVersionInRange(cache.contractVersion, range) !== true) {
+        checks.push({ id: "contract", ok: false, line: `contract: version ${cache.contractVersion} is outside this bundle's range ${range}`, fix: "npm update -g @catalyst-cloud/catalyst-skills", who: "you" });
+    }
+    else {
+        checks.push({ id: "contract", ok: true, line: `contract: ${cache.contractVersion} cached ${cache.fetchedAt} (range ${range})` });
+    }
+    if (cfg) {
+        checks.push(cfg.cliPath && existsSync(cfg.cliPath)
+            ? { id: "cliPath", ok: true, line: `cliPath: ${cfg.cliPath}` }
+            : { id: "cliPath", ok: false, line: `cliPath: ${cfg.cliPath ? `${cfg.cliPath} does not exist` : "not recorded"}`, fix: "re-run login so the skill scripts can find this CLI", who: "you" });
+    }
+    // The skills are installed by the customer's own agent (a plugin, or `npx skills add`), so an
+    // empty copy directory is the normal case and must not read as NOT READY. A PARTIAL copy is the
+    // one broken state this check can see: half a set this package put there and never finished.
+    const skillsDir = cfg?.skillsDir ?? defaultSkillsDirFor(ctx.home);
+    const present = deps.skillNames.filter((n) => existsSync(join(skillsDir, n, "SKILL.md")));
+    const missing = deps.skillNames.filter((n) => !present.includes(n));
+    if (present.length === 0) {
+        checks.push({ id: "skills", ok: true, note: true, line: `skills: none copied to ${skillsDir} — you are reading one, so your agent installed them its own way` });
+    }
+    else if (missing.length === 0) {
+        checks.push({ id: "skills", ok: true, line: `skills: all ${deps.skillNames.length} present in ${skillsDir}` });
+    }
+    else {
+        checks.push({ id: "skills", ok: false, line: `skills: ${present.length} of ${deps.skillNames.length} in ${skillsDir}, missing ${missing.join(", ")}`, fix: "catalyst-skills install", who: "you" });
+    }
+    try {
+        await (deps.loadSdk ?? loadSdk)();
+        checks.push({ id: "sdk", ok: true, line: "sdk: loads (replica and watch are available)" });
+    }
+    catch (err) {
+        checks.push({ id: "sdk", ok: false, line: `sdk: ${err instanceof Error ? err.message : String(err)}`, fix: "run under Node 22.15 or newer (or bun); every read still works through the API meanwhile", who: "you" });
+    }
+    const replica = replicaStatus(ctx, cfg);
+    checks.push({ id: "replica", ok: replica.verdict === "fresh", note: true, line: statusLine(replica) });
+    if (cache) {
+        const doc = cache.doc;
+        const who = whoCanAnswer(doc);
+        for (const team of doc.teams) {
+            const label = team.key ?? team.id;
+            if (team.readiness.status === "unchecked") {
+                checks.push({ id: `team:${label}`, ok: true, note: true, line: `team ${label}: readiness not checked yet` });
+                continue;
+            }
+            const bad = team.readiness.checks.filter((c) => c.state !== "pass");
+            if (bad.length === 0 && team.readiness.status === "ready") {
+                checks.push({ id: `team:${label}`, ok: true, line: `team ${label}: ready` });
+                continue;
+            }
+            for (const c of bad) {
+                const meta = doc.readinessChecks.find((r) => r.id === c.id);
+                const needsAnswer = meta?.needsAnswer ?? true;
+                checks.push({
+                    id: `team:${label}:${c.id}`,
+                    ok: !needsAnswer && c.state !== "fail",
+                    note: !needsAnswer,
+                    line: `team ${label}: ${c.id} is ${c.state}${c.reason ? ` (${c.reason}${c.count !== undefined ? ` ×${c.count}` : ""})` : ""}${meta ? `, ${meta.severity}` : ""}`,
+                    fix: `open settings for team ${label} and resolve ${c.id}`,
+                    who: needsAnswer ? who : "nobody yet; it is informational",
+                });
+            }
+            if (bad.length === 0 && team.readiness.status !== "ready") {
+                checks.push({ id: `team:${label}`, ok: team.readiness.status !== "blocked", note: team.readiness.status === "degraded", line: `team ${label}: ${team.readiness.status}`, fix: `open settings for team ${label}`, who });
+            }
+        }
+    }
+    const ready = checks.every((c) => c.ok || c.note);
+    return { ready, checks };
+}
+export async function cmdReady(args, ctx, deps) {
+    const report = await readyReport(ctx, deps);
+    if (args.json) {
+        ctx.stdout(JSON.stringify(report));
+    }
+    else {
+        for (const c of report.checks) {
+            ctx.stdout(`${c.note ? "note" : c.ok ? "ok " : "FAIL"}  ${c.line}`);
+            if (!c.ok && !c.note) {
+                if (c.fix)
+                    ctx.stdout(`      fix: ${c.fix}`);
+                if (c.who)
+                    ctx.stdout(`      who: ${c.who}`);
+            }
+        }
+        ctx.stdout(report.ready ? "READY" : "NOT READY");
+    }
+    return report.ready ? 0 : 1;
+}