agent-kitchen 0.2.0 → 0.3.0

package/dist/pieces/issue-flow.js

@@ -3,8 +3,8 @@
  * The repo's version is the one in package.json. Installing runs its `init` at the latest
  * version; updating runs its `upgrade` at the new one and then moves its skills to the same
  * tag, because the skills call the CLI. If only the skills are off, it moves them alone.
+ * `init` runs with `--yes`: the person answered agent-kitchen's questions before the steps.
  */
-import { warn } from "../output.js";
 import { FLOW_CATALOG, FLOW_PACKAGE } from "../piece.js";
 import { dependencyVersion, readJson } from "../repo.js";
 import { catalogSkills, manifestCatalogs, pinCatalog, updateSkills } from "../skills-files.js";
@@ -12,7 +12,7 @@ import { captureNpx, compareVersions, isRelease, npmLatest, runNpx } from "../to
 /** The piece's name, as `--skip` takes it. */
 export const NAME = "issue-flow";
 /** How the catalog's ref is named when it is off. */
-const SKILLS_CATALOG_LABEL = "the catalog";
+const SKILLS_CATALOG_LABEL = "el catálogo";
 /** The first version whose `doctor` prints `--json`. */
 const JSON_DOCTOR = "0.2.0";
 /**
@@ -43,9 +43,9 @@ export function flowVersion(root) {
  */
 function skillsOff(root, version) {
     const tag = `v${version}`;
-    const off = catalogSkills(root, FLOW_CATALOG).filter((skill) => skill.tag !== tag).map((skill) => `${skill.name} at ${skill.tag ?? "no tag"}`);
+    const off = catalogSkills(root, FLOW_CATALOG).filter((skill) => skill.tag !== tag).map((skill) => `${skill.name} en ${skill.tag ?? "sin tag"}`);
     const source = manifestCatalogs(root).find((item) => item.catalog === FLOW_CATALOG);
-    return source !== undefined && source.ref !== tag ? [...off, `${SKILLS_CATALOG_LABEL} at ${source.ref ?? "the latest"}`] : off;
+    return source !== undefined && source.ref !== tag ? [...off, `${SKILLS_CATALOG_LABEL} en ${source.ref ?? "la última"}`] : off;
 }
 /**
  * Moves the flow's skills to a version's tag: the catalog's ref in the manifest, and then
@@ -54,13 +54,16 @@ function skillsOff(root, version) {
  * @param version - The flow's version.
  * @returns Whether it worked, or true if the repo has none of the flow's skills.
  */
-function moveSkills(context, version) {
+async function moveSkills(context, version) {
     if (!pinCatalog(context.root, FLOW_CATALOG, `v${version}`))
         return true;
-    const failed = updateSkills(context.root, catalogSkills(context.root, FLOW_CATALOG).map((skill) => skill.name));
-    if (failed === null)
+    const names = catalogSkills(context.root, FLOW_CATALOG).map((skill) => skill.name);
+    const failed = await updateSkills(context.root, names);
+    if (failed === null) {
+        context.note(`skills del flujo en v${version}: ${names.join(", ")}`);
         return true;
-    warn(context.out, `skills-manager did not update the flow's skills; run '${failed}' and then agent-kitchen again.`);
+    }
+    context.fail(`skills-manager no actualizó las skills del flujo; corre '${failed.command}' y luego agent-kitchen otra vez.`, failed.run.output);
     return false;
 }
 /**
@@ -70,10 +73,11 @@ function moveSkills(context, version) {
  * @param args - The command and its flags.
  * @returns Whether it exited 0.
  */
-function runFlow(context, version, args) {
-    if (runNpx(context.root, [`${FLOW_PACKAGE}@${version}`, ...args]))
+async function runFlow(context, version, args) {
+    const run = await runNpx(context.root, [`${FLOW_PACKAGE}@${version}`, ...args]);
+    if (run.ok)
         return true;
-    warn(context.out, `issue-flow ${args[0] ?? ""} failed; run 'npx ${FLOW_PACKAGE}@${version} ${args.join(" ")}'.`);
+    context.fail(`issue-flow ${args[0] ?? ""} falló; corre 'npx ${FLOW_PACKAGE}@${version} ${args.join(" ")}'.`, run.output);
     return false;
 }
 /**
@@ -85,47 +89,47 @@ function runFlow(context, version, args) {
  */
 function stepFor(installed, latest, root) {
     if (installed === null && latest !== null)
-        return { piece: NAME, checked: true, label: `issue-flow ${latest}: .agents/flow.json with its recipes, the hooks and scripts`, run: (context) => runFlow(context, latest, ["init", ...(context.yes ? ["--yes"] : [])]) };
+        return { piece: NAME, checked: true, downloads: [`${FLOW_PACKAGE}@${latest}`], label: `Instalar issue-flow ${latest}: config del flujo, hooks y scripts`, run: (context) => runFlow(context, latest, ["init", "--yes"]) };
     if (installed !== null && latest !== null && compareVersions(latest, installed) > 0)
-        return { piece: NAME, checked: true, label: `issue-flow ${installed} → ${latest}: the CLI, its hooks and its skills`, run: (context) => runFlow(context, latest, ["upgrade"]) && moveSkills(context, latest) };
+        return { piece: NAME, checked: true, downloads: [`${FLOW_PACKAGE}@${latest}`], label: `Actualizar issue-flow ${installed} → ${latest}, con sus hooks y sus skills`, run: async (context) => (await runFlow(context, latest, ["upgrade"])) && (await moveSkills(context, latest)) };
     if (installed !== null && skillsOff(root, installed).length > 0)
-        return { piece: NAME, checked: true, label: `issue-flow's skills → v${installed}, the CLI's version`, run: (context) => moveSkills(context, installed) };
+        return { piece: NAME, checked: true, downloads: [], label: `Poner las skills del flujo en v${installed}, la versión de issue-flow`, run: (context) => moveSkills(context, installed) };
     return null;
 }
 /**
  * What the repo has of the issue flow, and the step it needs.
  * @param root - The repo.
  * @returns The piece's status.
- * @example issueFlowStatus(root).state // "0.1.0, 0.2.0 available"
+ * @example (await issueFlowStatus(root)).state // "0.1.0, hay 0.2.0"
  */
-export function issueFlowStatus(root) {
-    const summary = "the issue flow: branch, worktree and draft PR per issue, and its skills";
+export async function issueFlowStatus(root) {
+    const summary = "rama, worktree y PR en draft por issue";
     const spec = flowSpec(root);
     if (spec !== null && !isRelease(spec))
-        return { name: NAME, summary, installed: true, state: `package.json has ${spec}, not an exact release; agent-kitchen leaves it`, steps: [] };
+        return { name: NAME, summary, installed: true, state: `package.json tiene ${spec}, no una versión exacta; no se toca`, steps: [] };
     const installed = flowVersion(root);
-    const latest = npmLatest(FLOW_PACKAGE);
+    const latest = await npmLatest(FLOW_PACKAGE);
     const step = stepFor(installed, latest, root);
-    const known = latest === null ? " (npm cannot tell the latest)" : "";
-    const state = installed === null ? `not installed${known}` : latest !== null && compareVersions(latest, installed) > 0 ? `${installed}, ${latest} available` : `${installed}${known}`;
+    const known = latest === null ? " (npm no responde)" : "";
+    const state = installed === null ? `no instalado${known}` : latest !== null && compareVersions(latest, installed) > 0 ? `${installed}, hay ${latest}` : `${installed}, al día${known}`;
     return { name: NAME, summary, installed: installed !== null, state, steps: step === null ? [] : [step] };
 }
 /**
  * The flow's own doctor at the repo's version, and whether its skills are at that tag.
  * @param root - The repo.
  * @returns The checks.
- * @example issueFlowChecks(root)[0].name // "issue-flow: .agents/flow.json"
+ * @example (await issueFlowChecks(root))[0].name // "issue-flow: .agents/flow.json"
  */
-export function issueFlowChecks(root) {
+export async function issueFlowChecks(root) {
     const spec = flowSpec(root);
     if (spec === null)
-        return [{ name: NAME, status: "info", detail: "not installed" }];
+        return [{ name: NAME, status: "info", detail: "no instalado" }];
     const installed = flowVersion(root);
     if (installed === null)
-        return [{ name: NAME, status: "info", detail: `package.json has ${spec}, not an exact release` }];
+        return [{ name: NAME, status: "info", detail: `package.json tiene ${spec}, no una versión exacta` }];
     if (compareVersions(installed, JSON_DOCTOR) < 0)
-        return [{ name: NAME, status: "info", detail: `${installed} predates its doctor --json: run npx agent-kitchen to update it` }];
-    const result = captureNpx(root, [`${FLOW_PACKAGE}@${installed}`, "doctor", "--json"]);
+        return [{ name: NAME, status: "info", detail: `${installed} no tiene doctor --json: corre npx agent-kitchen para actualizarlo` }];
+    const result = await captureNpx(root, [`${FLOW_PACKAGE}@${installed}`, "doctor", "--json"]);
     let found;
     try {
         found = JSON.parse(result?.out ?? "");
@@ -135,13 +139,13 @@ export function issueFlowChecks(root) {
     }
     const own = Array.isArray(found)
         ? found.map((check) => ({ name: `${NAME}: ${String(check.name)}`, status: check.ok === true ? "ok" : "fail", detail: String(check.detail) }))
-        : [{ name: NAME, status: "fail", detail: `could not run its doctor; run 'npx ${FLOW_PACKAGE}@${installed} doctor'` }];
+        : [{ name: NAME, status: "fail", detail: `no se pudo correr su doctor; corre 'npx ${FLOW_PACKAGE}@${installed} doctor'` }];
     const off = skillsOff(root, installed);
     const count = catalogSkills(root, FLOW_CATALOG).length;
     const skills = count === 0 && off.length === 0
-        ? { name: `${NAME}: skills`, status: "info", detail: "none installed" }
+        ? { name: `${NAME}: skills`, status: "info", detail: "ninguna instalada" }
         : off.length === 0
-            ? { name: `${NAME}: skills`, status: "ok", detail: `${count} at v${installed}` }
-            : { name: `${NAME}: skills`, status: "fail", detail: `${off.join(", ")}, the CLI is ${installed}: run npx agent-kitchen` };
+            ? { name: `${NAME}: skills`, status: "ok", detail: `${count} en v${installed}` }
+            : { name: `${NAME}: skills`, status: "fail", detail: `${off.join(", ")}; issue-flow está en ${installed}: corre npx agent-kitchen` };
     return [...own, skills];
 }

package/dist/pieces/skills.d.ts

@@ -1,17 +1,57 @@
-import { type Check, type PieceStatus } from "../piece.js";
+/**
+ * @file The skills, through `skills-manager`: the flow's catalog (pinned to the flow's
+ * version, because its skills call the CLI) and the general catalogs (each skill at its
+ * own tag). agent-kitchen reads what the catalogs offer (`--candidates`), lets the person
+ * pick before any step runs, and then installs the pick with `--select`, so
+ * `skills-manager` asks nothing. The first time every skill comes ticked. Later it offers
+ * to move the general skills to their catalog's latest tag, and, unticked, the skills a
+ * catalog has that the repo does not take yet. The flow's skills move with the flow
+ * (pieces/issue-flow.ts), never here.
+ *
+ * A skill the repo already has as its own (a folder the lock does not know) is replaced
+ * only if the person allows it (`--replace`); `skills-manager` keeps its `project.md`.
+ */
+import { type Candidate, type Check, type PieceStatus, type SkillPick } from "../piece.js";
 /** The piece's name, as `--skip` takes it. */
 export declare const NAME = "skills";
+/**
+ * Every skill some candidates bring: their own and what they require, all the way down,
+ * as `skills-manager` follows it.
+ * @param candidates - Every candidate offered.
+ * @param ids - The candidates picked.
+ * @returns The skills' names.
+ * @example skillsOf(candidates, ["catalog:ramon-sg/issue-flow/close-pr"]) // ["close-pr", "pr-review-comments", "github-issues"]
+ */
+export declare function skillsOf(candidates: Candidate[], ids: string[]): string[];
+/**
+ * The repo's own skills a pick would replace: each picked skill and what it requires.
+ * @param root - The repo.
+ * @param pick - The pick.
+ * @returns Their names.
+ * @example ownInPick(root, step.skills) // ["planning"]
+ */
+export declare function ownInPick(root: string, pick: SkillPick): string[];
+/**
+ * Drops from a pick the skills that would replace one of the repo's own (or that require
+ * one), for when the person does not allow replacing them.
+ * @param pick - The pick.
+ * @param own - The repo's own skills that stay.
+ * @returns The pick without them.
+ * @example keepOwn(pick, ["planning"]).picked
+ */
+export declare function keepOwn(pick: SkillPick, own: string[]): SkillPick;
 /**
  * What the repo has of the skills, and the steps it can take.
  * @param root - The repo.
+ * @param withFlow - Whether this run may install the flow (it is not left out with `--skip`).
  * @returns The piece's status.
- * @example skillsStatus(root).state // "6 installed"
+ * @example (await skillsStatus(root, true)).state // "6 instaladas"
  */
-export declare function skillsStatus(root: string): PieceStatus;
+export declare function skillsStatus(root: string, withFlow: boolean): Promise<PieceStatus>;
 /**
  * Whether `skills-manager check` passes: disk, lock and manifest agree.
  * @param root - The repo.
  * @returns The checks.
- * @example skillsChecks(root)[0].status // "ok"
+ * @example (await skillsChecks(root))[0].status // "ok"
  */
-export declare function skillsChecks(root: string): Check[];
+export declare function skillsChecks(root: string): Promise<Check[]>;

package/dist/pieces/skills.js

@@ -1,20 +1,24 @@
 /**
  * @file The skills, through `skills-manager`: the flow's catalog (pinned to the flow's
  * version, because its skills call the CLI) and the general catalogs (each skill at its
- * own tag). The first time it opens the `skills-manager` menu with every catalog. Later it
- * offers to move the general skills to their catalog's latest tag, and, unticked, to pick
- * the skills a catalog has that the repo does not take yet. The flow's skills move with the
- * flow (pieces/issue-flow.ts), never here.
+ * own tag). agent-kitchen reads what the catalogs offer (`--candidates`), lets the person
+ * pick before any step runs, and then installs the pick with `--select`, so
+ * `skills-manager` asks nothing. The first time every skill comes ticked. Later it offers
+ * to move the general skills to their catalog's latest tag, and, unticked, the skills a
+ * catalog has that the repo does not take yet. The flow's skills move with the flow
+ * (pieces/issue-flow.ts), never here.
+ *
+ * A skill the repo already has as its own (a folder the lock does not know) is replaced
+ * only if the person allows it (`--replace`); `skills-manager` keeps its `project.md`.
  */
-import { warn } from "../output.js";
-import { FLOW_CATALOG, GENERAL_CATALOGS, SKILLS_MANIFEST } from "../piece.js";
-import { readJson } from "../repo.js";
-import { catalogSkills, lockedSkills, manifestCatalogs, pinCatalog, skillsManagerSpec, updateSkills } from "../skills-files.js";
-import { captureNpx, compareVersions, latestTag, runNpx } from "../tools.js";
+import { FLOW_CATALOG, FLOW_PACKAGE, GENERAL_CATALOGS, SKILLS_MANIFEST } from "../piece.js";
+import { isObject, readJson } from "../repo.js";
+import { catalogSkills, lockedSkills, manifestCatalogs, ownSkills, pinCatalog, skillsManagerSpec, updateSkills } from "../skills-files.js";
+import { captureNpx, compareVersions, latestTag, npmLatest, runNpx } from "../tools.js";
 import { flowVersion } from "./issue-flow.js";
 /** The piece's name, as `--skip` takes it. */
 export const NAME = "skills";
-/** The skills picked without a terminal: the flow's, and the audit `close-pr` uses. */
+/** The skills picked when the catalogs cannot be read: the flow's, and the audit `close-pr` uses. */
 const DEFAULT_SKILLS = [
     ...["github-issues", "start-issue", "close-pr", "pr-review-comments", "pr-worktree"].map((name) => `catalog:${FLOW_CATALOG}/${name}`),
     "catalog:ramon-sg/agent-skills/code-audit",
@@ -22,47 +26,131 @@ const DEFAULT_SKILLS = [
 /** A release tag. */
 const RELEASE_TAG = /^v\d+\.\d+\.\d+$/;
 /**
- * The `--catalog` flags: the flow's at the repo's flow version, if the repo has the flow,
- * and the general ones.
- * @param root - The repo.
+ * The `--catalog` flags: the flow's at a version, if there is one, and the general ones.
+ * @param flow - The flow's version, or null.
  * @returns The flags.
  */
-function catalogArgs(root) {
-    const flow = flowVersion(root);
+function catalogArgs(flow) {
     const catalogs = [...(flow === null ? [] : [`${FLOW_CATALOG}#v${flow}`]), ...GENERAL_CATALOGS];
     return catalogs.flatMap((catalog) => ["--catalog", catalog]);
 }
 /**
- * The default skills the manifest does not take yet, of the catalogs offered.
+ * Reads one candidate of `--candidates`.
+ * @param value - An item of its output.
+ * @returns The candidate, or null if it is not one.
+ */
+function toCandidate(value) {
+    if (!isObject(value) || typeof value.id !== "string" || typeof value.name !== "string")
+        return null;
+    const names = (field) => (Array.isArray(field) ? field.map(String) : []);
+    return {
+        id: value.id,
+        name: value.name,
+        catalog: typeof value.catalog === "string" ? value.catalog : "",
+        description: typeof value.description === "string" ? value.description : "",
+        skills: names(value.skills),
+        requires: names(value.requires),
+    };
+}
+/**
+ * Every skill some candidates bring: their own and what they require, all the way down,
+ * as `skills-manager` follows it.
+ * @param candidates - Every candidate offered.
+ * @param ids - The candidates picked.
+ * @returns The skills' names.
+ * @example skillsOf(candidates, ["catalog:ramon-sg/issue-flow/close-pr"]) // ["close-pr", "pr-review-comments", "github-issues"]
+ */
+export function skillsOf(candidates, ids) {
+    const byName = new Map(candidates.map((candidate) => [candidate.name, candidate]));
+    const found = new Set();
+    const pending = candidates.filter((candidate) => ids.includes(candidate.id)).flatMap((candidate) => [...candidate.skills, ...candidate.requires]);
+    while (pending.length > 0) {
+        const name = pending.pop();
+        if (name === undefined || found.has(name))
+            continue;
+        found.add(name);
+        pending.push(...(byName.get(name)?.requires ?? []));
+    }
+    return [...found];
+}
+/**
+ * The catalog of a candidate's id (`catalog:<owner>/<repo>/<name>`).
+ * @param id - The id.
+ * @returns The catalog, as owner/repo.
+ */
+function catalogOf(id) {
+    return id.replace(/^catalog:/, "").split("/").slice(0, 2).join("/");
+}
+/**
+ * What the catalogs offer that the manifest does not take yet, as `skills-manager` lists it.
+ * @param root - The repo.
+ * @param flow - The flow's version whose catalog to read, or null.
+ * @returns The candidates, or null if `skills-manager` could not tell.
+ */
+async function readCandidates(root, flow) {
+    const command = readJson(root, SKILLS_MANIFEST) === null ? "init" : "add";
+    const result = await captureNpx(root, [skillsManagerSpec(root), command, "--candidates", ...catalogArgs(flow)], true);
+    let found;
+    try {
+        found = JSON.parse(result?.out ?? "");
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(found))
+        return null;
+    return found.flatMap((item) => toCandidate(item) ?? []);
+}
+/**
+ * The repo's own skills a pick would replace: each picked skill and what it requires.
  * @param root - The repo.
- * @returns Their ids.
+ * @param pick - The pick.
+ * @returns Their names.
+ * @example ownInPick(root, step.skills) // ["planning"]
+ */
+export function ownInPick(root, pick) {
+    return ownSkills(root, skillsOf(pick.candidates, pick.picked));
+}
+/**
+ * Drops from a pick the skills that would replace one of the repo's own (or that require
+ * one), for when the person does not allow replacing them.
+ * @param pick - The pick.
+ * @param own - The repo's own skills that stay.
+ * @returns The pick without them.
+ * @example keepOwn(pick, ["planning"]).picked
  */
-function missingDefaults(root) {
-    const manifest = readJson(root, SKILLS_MANIFEST);
-    const sources = Array.isArray(manifest?.sources) ? manifest.sources : [];
-    const taken = new Set(sources.flatMap((source) => (typeof source.catalog === "string" && Array.isArray(source.skills) ? source.skills.map((name) => `catalog:${String(source.catalog)}/${String(name)}`) : [])));
-    const flow = flowVersion(root) !== null;
-    return DEFAULT_SKILLS.filter((id) => !taken.has(id) && (flow || !id.startsWith(`catalog:${FLOW_CATALOG}/`)));
+export function keepOwn(pick, own) {
+    const picked = pick.picked.filter((id) => !skillsOf(pick.candidates, [id]).some((name) => own.includes(name)));
+    return { ...pick, picked, replace: [] };
 }
 /**
- * Opens the `skills-manager` menu with the catalogs; without a terminal or with `--yes`,
- * picks the default skills the repo does not have yet.
+ * Installs the picked skills with `--select`, replacing the own ones the person allowed.
  * @param context - Where it runs.
- * @returns Whether `skills-manager` worked, or true if there was nothing to pick.
+ * @param pick - What to install.
+ * @returns Whether `skills-manager` worked, or true if nothing was picked.
  */
-function pick(context) {
-    const spec = skillsManagerSpec(context.root);
-    const args = [spec, readJson(context.root, SKILLS_MANIFEST) === null ? "init" : "add", ...catalogArgs(context.root)];
-    const choose = context.yes || !context.out.interactive;
-    const missing = choose ? missingDefaults(context.root) : [];
-    if (choose && missing.length === 0) {
-        context.out.stdout(`  the default skills are already in ${SKILLS_MANIFEST}\n`);
+async function install(context, pick) {
+    const flow = flowVersion(context.root);
+    const picked = flow === null ? pick.picked.filter((id) => catalogOf(id) !== FLOW_CATALOG) : pick.picked;
+    if (picked.length < pick.picked.length)
+        context.note("sin las skills del flujo, porque issue-flow no está instalado");
+    if (picked.length === 0) {
+        context.note("ninguna skill que instalar");
         return true;
     }
-    if (runNpx(context.root, choose ? [...args, "--select", missing.join(",")] : args))
-        return true;
-    warn(context.out, `skills-manager did not install the skills; run 'npx ${args.join(" ")}'.`);
-    return false;
+    const spec = skillsManagerSpec(context.root);
+    const command = readJson(context.root, SKILLS_MANIFEST) === null ? "init" : "add";
+    const args = [spec, command, ...catalogArgs(flow), "--select", picked.join(","), ...(pick.replace.length === 0 ? [] : ["--replace", pick.replace.join(",")])];
+    const run = await runNpx(context.root, args);
+    if (!run.ok) {
+        context.fail(`skills-manager no instaló las skills; corre 'npx ${args.join(" ")}'.`, run.output);
+        return false;
+    }
+    const names = pick.candidates.filter((candidate) => picked.includes(candidate.id)).map((candidate) => candidate.name);
+    context.note(names.length === 0 ? `${picked.length} skills` : names.join(", "));
+    if (pick.replace.length > 0)
+        context.note(`reemplazadas (con su project.md): ${pick.replace.join(", ")}`);
+    return true;
 }
 /**
  * The step that moves a general catalog's skills to its latest tag, if they are behind. A
@@ -72,10 +160,10 @@ function pick(context) {
  * @param ref - The ref the manifest pins it to, or null.
  * @returns The step, or null.
  */
-function updateStep(root, catalog, ref) {
+async function updateStep(root, catalog, ref) {
     if (ref !== null && !RELEASE_TAG.test(ref))
         return null;
-    const latest = latestTag(catalog);
+    const latest = await latestTag(catalog);
     if (latest === null)
         return null;
     const behind = catalogSkills(root, catalog).filter((skill) => skill.tag !== null && RELEASE_TAG.test(skill.tag) && compareVersions(latest, skill.tag.replace(/^v/, "")) > 0);
@@ -85,71 +173,79 @@ function updateStep(root, catalog, ref) {
     return {
         piece: NAME,
         checked: true,
-        label: `${catalog}: ${behind.map((skill) => skill.name).join(", ")} ${from} → v${latest}`,
-        run: (context) => {
+        downloads: [skillsManagerSpec(root)],
+        label: `Actualizar skills de ${catalog} ${from} → v${latest}: ${behind.map((skill) => skill.name).join(", ")}`,
+        run: async (context) => {
             if (ref !== null)
                 pinCatalog(context.root, catalog, `v${latest}`);
-            const failed = updateSkills(context.root, behind.map((skill) => skill.name));
+            const failed = await updateSkills(context.root, behind.map((skill) => skill.name));
             if (failed === null)
                 return true;
-            warn(context.out, `skills-manager did not update ${catalog}; run '${failed}' and then agent-kitchen again.`);
+            context.fail(`skills-manager no actualizó ${catalog}; corre '${failed.command}' y luego agent-kitchen otra vez.`, failed.run.output);
             return false;
         },
     };
 }
 /**
- * The skills the catalogs have and the repo does not take, as `skills-manager` lists them,
- * without those already in the lock (it lists the ones that came through `requires`).
+ * The flow's version whose catalog to offer: the repo's, or the latest when the repo does
+ * not have the flow yet (it is installed before the skills), unless the flow is left out.
  * @param root - The repo.
- * @returns Their names, or null if `skills-manager` could not tell.
+ * @param withFlow - Whether this run may install the flow.
+ * @returns The version, or null if there is none.
  */
-function newSkills(root) {
-    const result = captureNpx(root, [skillsManagerSpec(root), "add", "--candidates", ...catalogArgs(root)]);
-    let found;
-    try {
-        found = JSON.parse(result?.out ?? "");
-    }
-    catch {
-        return null;
-    }
-    if (!Array.isArray(found))
-        return null;
-    const locked = lockedSkills(root);
-    return found.map((candidate) => String(candidate.name)).filter((name) => locked[name] === undefined);
+async function offeredFlow(root, withFlow) {
+    return flowVersion(root) ?? (withFlow ? await npmLatest(FLOW_PACKAGE) : null);
 }
 /**
  * What the repo has of the skills, and the steps it can take.
  * @param root - The repo.
+ * @param withFlow - Whether this run may install the flow (it is not left out with `--skip`).
  * @returns The piece's status.
- * @example skillsStatus(root).state // "6 installed"
+ * @example (await skillsStatus(root, true)).state // "6 instaladas"
  */
-export function skillsStatus(root) {
-    const summary = "skills: the flow's, planning, code and test audits";
+export async function skillsStatus(root, withFlow) {
+    const summary = "skills del flujo, planes y auditorías";
+    const flow = await offeredFlow(root, withFlow);
+    const candidatesRead = readCandidates(root, flow);
     if (readJson(root, SKILLS_MANIFEST) === null) {
-        const label = `skills: pick them from ${[FLOW_CATALOG, ...GENERAL_CATALOGS].join(" and ")} (without a terminal, the flow's and code-audit)`;
-        return { name: NAME, summary, installed: false, state: "not installed", steps: [{ piece: NAME, checked: true, label, run: pick }] };
+        const candidates = await candidatesRead;
+        const fallback = DEFAULT_SKILLS.filter((id) => flow !== null || catalogOf(id) !== FLOW_CATALOG).map((id) => {
+            const name = id.split("/").at(-1) ?? id;
+            return { id, name, catalog: catalogOf(id), description: "", skills: [name], requires: [] };
+        });
+        const offered = candidates ?? fallback;
+        const catalogs = [...new Set(offered.map((candidate) => candidate.catalog))];
+        const label = `Instalar ${offered.length} skills de ${catalogs.join(" y ")}`;
+        const skills = { candidates: offered, picked: offered.map((candidate) => candidate.id), replace: [] };
+        const state = candidates === null ? "no instaladas (no se pudieron leer los catálogos)" : "no instaladas";
+        return { name: NAME, summary, installed: false, state, steps: [{ piece: NAME, checked: true, downloads: [], label, skills, run: (context) => install(context, skills) }] };
     }
     const general = manifestCatalogs(root).filter((source) => source.catalog !== FLOW_CATALOG);
-    const steps = general.flatMap((source) => updateStep(root, source.catalog, source.ref) ?? []);
-    const fresh = newSkills(root);
-    if (fresh !== null && fresh.length > 0)
-        steps.push({ piece: NAME, checked: false, label: `skills: ${fresh.length} more to pick (${fresh.join(", ")})`, run: pick });
+    const steps = (await Promise.all(general.map((source) => updateStep(root, source.catalog, source.ref)))).flatMap((step) => step ?? []);
+    const locked = lockedSkills(root);
+    const candidates = await candidatesRead;
+    const fresh = (candidates ?? []).filter((candidate) => locked[candidate.name] === undefined);
+    if (fresh.length > 0) {
+        const skills = { candidates: fresh, picked: [], replace: [] };
+        steps.push({ piece: NAME, checked: false, downloads: [skillsManagerSpec(root)], label: `Agregar skills nuevas (${fresh.length}): ${fresh.map((candidate) => candidate.name).join(", ")}`, skills, run: (context) => install(context, skills) });
+    }
     const count = manifestCatalogs(root).reduce((total, source) => total + catalogSkills(root, source.catalog).length, 0);
     const behind = steps.filter((step) => step.checked).length;
-    return { name: NAME, summary, installed: true, state: `${count} installed${behind > 0 ? ", some behind" : ""}`, steps };
+    const unread = candidates === null ? " (no se pudieron leer los catálogos)" : "";
+    return { name: NAME, summary, installed: true, state: `${count} instaladas${behind > 0 ? ", algunas atrasadas" : ", al día"}${unread}`, steps };
 }
 /**
  * Whether `skills-manager check` passes: disk, lock and manifest agree.
  * @param root - The repo.
  * @returns The checks.
- * @example skillsChecks(root)[0].status // "ok"
+ * @example (await skillsChecks(root))[0].status // "ok"
  */
-export function skillsChecks(root) {
+export async function skillsChecks(root) {
     if (readJson(root, SKILLS_MANIFEST) === null)
-        return [{ name: NAME, status: "info", detail: "not installed" }];
+        return [{ name: NAME, status: "info", detail: "no instaladas" }];
     const spec = skillsManagerSpec(root);
-    const result = captureNpx(root, [spec, "check"]);
+    const result = await captureNpx(root, [spec, "check"]);
     if (result?.status === 0)
-        return [{ name: NAME, status: "ok", detail: "skills-manager check passes" }];
-    return [{ name: NAME, status: "fail", detail: `disk, lock and manifest disagree: run 'npx ${spec} check'` }];
+        return [{ name: NAME, status: "ok", detail: "skills-manager check pasa" }];
+    return [{ name: NAME, status: "fail", detail: `el disco, el lock y el manifiesto no coinciden: corre 'npx ${spec} check'` }];
 }

package/dist/repo.js

@@ -38,10 +38,10 @@ export function mainCheckout(cwd, command) {
     const common = git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
     const top = git(cwd, ["rev-parse", "--show-toplevel"]);
     if (common === null || top === null)
-        throw new KitError(`run ${command} inside a checkout of the repo.`);
+        throw new KitError(`corre ${command} dentro del repo.`);
     const main = realpathSync(dirname(common));
     if (realpathSync(top) !== main)
-        throw new KitError(`run ${command} in the main checkout, ${main}, not in a worktree.`);
+        throw new KitError(`corre ${command} en la copia principal, ${main}, no en un worktree.`);
     return main;
 }
 /**
@@ -61,10 +61,10 @@ export function readJson(root, path) {
         value = JSON.parse(readFileSync(file, "utf8"));
     }
     catch (error) {
-        throw new KitError(`${path} is not valid JSON (${error instanceof Error ? error.message : String(error)}); fix it and run again.`);
+        throw new KitError(`${path} no es JSON válido (${error instanceof Error ? error.message : String(error)}); arréglalo y corre otra vez.`);
     }
     if (!isObject(value))
-        throw new KitError(`${path} is not a JSON object; fix it and run again.`);
+        throw new KitError(`${path} no es un objeto JSON; arréglalo y corre otra vez.`);
     return value;
 }
 /**

package/dist/skills-files.d.ts

@@ -1,3 +1,4 @@
+import { type ToolRun } from "./tools.js";
 /** A skill in the lock: its name and the tag it is at. */
 export interface LockedSkill {
     name: string;
@@ -21,10 +22,22 @@ export declare function lockedSkills(root: string): Record<string, unknown>;
  * Runs `skills-manager update <name>` for each skill, stopping at the first that fails.
  * @param root - The repo.
  * @param names - The skills.
- * @returns The command that failed, to retry it, or null if every one worked.
- * @example updateSkills(root, ["close-pr", "pr-review-comments"]) // null
+ * @returns Null if every one worked, or the command that failed, to retry it, and what it printed.
+ * @example await updateSkills(root, ["close-pr", "pr-review-comments"]) // null
  */
-export declare function updateSkills(root: string, names: string[]): string | null;
+export declare function updateSkills(root: string, names: string[]): Promise<{
+    command: string;
+    run: ToolRun;
+} | null>;
+/**
+ * The repo's own skills among some names: a folder in the skills folder that the lock does
+ * not know, which `skills-manager` replaces only when allowed.
+ * @param root - The repo.
+ * @param names - The skills about to be installed.
+ * @returns The names that are the repo's own.
+ * @example ownSkills(root, ["planning", "code-audit"]) // ["planning"]
+ */
+export declare function ownSkills(root: string, names: string[]): string[];
 /**
  * The skills of a catalog in the repo's lock.
  * @param root - The repo.