@ramon-sg/issue-flow 0.1.0 → 0.2.1

package/README.md

@@ -2,11 +2,11 @@
 
 Flujo de trabajo de issue a PR para cualquier repo, en local y en las sesiones de Claude en la nube: nombra la rama de cada issue, crea su worktree con puertos y Docker propios, abre el PR en draft y limpia cuando se mergea. Trae las skills que usan ese flujo.
 
-> **Instalar en un repo:** `npx @ramon-sg/issue-flow init` (ver [Instalar en un repo](#instalar-en-un-repo-issue-flow-init)). El paquete es `@ramon-sg/issue-flow` y el comando, `issue-flow`; sin el scope, `issue-flow` en npm es otro paquete.
+> **Instalar en un repo:** `npx agent-kit`, que instala este flujo con sus skills, las skills generales, `claude-cloud` y `claude-repo-guard`, y los actualiza ([agent-kit](https://github.com/ramon-sg/agent-kit)). El paquete es `@ramon-sg/issue-flow` y el comando, `issue-flow`; sin el scope, `issue-flow` en npm es otro paquete.
 
 ## Qué va a tener
 
-- **`issue-flow init`:** escribe `.agents/flow.json` con las recetas que sugieren los archivos del repo, las dependencias y los hooks, y después instala `claude-cloud`, `claude-repo-guard` y las skills. `doctor` revisa que todo esté a esta versión y `upgrade` lo mueve a la siguiente.
+- **`issue-flow init|doctor|upgrade`:** escribe, revisa y mueve a su versión lo que el flujo deja en el repo: `.agents/flow.json` con sus recetas, las dependencias y los hooks. Los corre `agent-kit`.
 - **`issue-flow issue branch <n>`:** propone la rama de una issue (con Claude por defecto, o desde el título). Con `--missing`, agrega el slug de rama a todas las issues abiertas que no lo tienen.
 - **`issue-flow issue start <n>`:** crea la rama y el worktree, hace el commit inicial, abre el PR en draft, asigna la issue y abre Claude. Con `--cloud`, lo hace en una sesión en la nube.
 - **`issue-flow worktree setup|teardown|ports|cleanup|prune`:** prepara y limpia cada worktree con los pasos del repo, le da un bloque de puertos y borra los worktrees con el PR cerrado.
@@ -178,13 +178,15 @@ Es el hook `SessionStart` de Claude Code. Lo que imprime le llega a Claude como
 4. Borra el Docker de los worktrees que ya no existen: Claude Code no llama al hook `WorktreeRemove` de los worktrees que no hizo un hook `WorktreeCreate`.
 5. Si hay `.envrc` y `direnv`, agrega su entorno a `CLAUDE_ENV_FILE`, para que los comandos de la sesión lo tengan.
 
-## Instalar en un repo: `issue-flow init`
+## Lo que el flujo deja en el repo: `issue-flow init`
+
+`npx agent-kit` corre estos tres comandos en la versión que corresponde. Correrlos a mano sirve para probar el flujo en un repo sin lo demás.
 
 ```sh
-npx @ramon-sg/issue-flow init           # pregunta cada paso
+npx @ramon-sg/issue-flow init           # pregunta cada receta y pide el OK
 npx @ramon-sg/issue-flow init --yes     # sin preguntas, con las recetas que sugiere el repo
-npx @ramon-sg/issue-flow doctor         # revisa que el repo esté como lo deja init
-npx @ramon-sg/issue-flow upgrade        # pasa todo a la última versión (o --to 0.2.0)
+npx @ramon-sg/issue-flow doctor         # revisa que el repo esté como lo deja init (--json para agent-kit)
+npx @ramon-sg/issue-flow@<versión> upgrade  # mueve el repo a esa versión (--dry-run)
 ```
 
 `init` muestra lo que va a escribir y pide el OK; correrlo otra vez solo completa lo que falta.
@@ -192,15 +194,10 @@ npx @ramon-sg/issue-flow upgrade        # pasa todo a la última versión (o --t
 1. **`.agents/flow.json`:** si no existe, lo crea con el `$schema` de esta versión y, si el repo tiene `paseo.json`, con su plantilla de rama y sus tipos. Suma las recetas que elijas.
 2. **`package.json`:** `@ramon-sg/issue-flow`, `@ramon-sg/github-rest` y `@ramon-sg/skills-manager` como dependencias de desarrollo con versión exacta, y los scripts `issue:start`, `worktree:prune` y `pr:worktree`. Lo que el repo ya tiene con otro valor se queda, con un aviso.
 3. **`.claude/settings.json`:** los hooks `SessionStart`, `WorktreeCreate` y `WorktreeRemove`, fijados a esta versión y con 600 segundos. El de `SessionStart` corre `claude-cloud session` en la nube, así que un hook propio de `claude-cloud` se quita para que no corra dos veces.
-4. **`claude-cloud init`**, después de preguntar (`--no-cloud` lo salta).
-5. **`claude-repo-guard`**, después de preguntar (`--no-guard`). Antes escribe en sus opciones que abrir el PR en draft, asignar la issue y agregar el "Slug de rama" son parte del flujo; la `baseBranch` como `integrationBranch`, si el repo tiene una; y en macOS `weakerNetworkIsolation`, que `gh` necesita dentro del sandbox.
-6. **Las skills**, con el menú de `skills-manager` y los dos catálogos: el de este repo en la tag de esta versión y el de `agent-skills` (`--no-skills`). Sin terminal o con `--yes`, elige las del flujo y `code-audit`.
-
-Si una de las herramientas falla, `init` sigue con las demás, dice cómo reintentar y sale con 1.
 
-**`doctor`** no cambia nada. Revisa la config, las dependencias, que los hooks y las skills del flujo estén en esta versión, y `claude-repo-guard` (su propio `doctor` y, en macOS, `weakerNetworkIsolation`). Cada problema dice qué lo arregla.
+**`doctor`** no cambia nada. Revisa la config, las dependencias y que los hooks estén en esta versión. Cada problema dice qué lo arregla.
 
-**`upgrade`** mueve juntas la CLI y las skills del flujo, porque las skills llaman a la CLI: las dependencias a las que fija esa versión (las lee de npm), los hooks, el `$schema` y el catálogo del flujo en `.agents/skills.json`, y corre `skills-manager update` solo con las skills del flujo. Las de `agent-skills` se actualizan aparte. `--dry-run` solo dice qué cambiaría.
+**`upgrade`** mueve el repo a la versión que corre: las dependencias a las que fija, los hooks y el `$schema`. No consulta npm, así que se corre con la versión: `npx @ramon-sg/issue-flow@<versión> upgrade`. Nunca baja de versión: si el repo ya tiene una más nueva (por ejemplo, una copia local vieja en `node_modules`), se detiene y dice qué correr. Las skills del flujo llaman a la CLI, así que tienen que ir a la misma tag: `agent-kit` las mueve después. `--dry-run` solo dice qué cambiaría.
 
 ### Recetas
 
@@ -213,7 +210,7 @@ Piezas de `flow.json` para lo que muchos repos comparten. `init` ofrece las que
 | `direnv` | `.envrc` | `direnv allow` en cada worktree, para que carguen su entorno y sus secretos (Infisical, por ejemplo) |
 
 Los pasos de preparación de las recetas son `trusted`: corren el código del worktree (el lockfile, el compose, el `.envrc`), así que en un worktree con código que no está en la rama base, como el de `pr worktree`, se saltan y el comando dice qué correr cuando lo revisaste.
-| `staging-main` | Nada: se pide | `baseBranch: "staging"`; `init` deja a `claude-repo-guard` mergear a `staging` |
+| `staging-main` | Nada: se pide | `baseBranch: "staging"`; `agent-kit` deja a `claude-repo-guard` mergear a `staging` |
 
 ## Skills del flujo
 
@@ -227,11 +224,7 @@ Viven en `skills/` y `skills-catalog.json` las lista. Se instalan con [`skills-m
 | `pr-review-comments` | PRs | Verifica cada comentario y check contra el código, propone un plan, aplica lo aprobado y responde los hilos | `github-issues` |
 | `pr-worktree` | PRs | Revisa un PR en su worktree con `issue-flow pr worktree`, sin tocar el checkout principal | `close-pr` |
 
-```sh
-npx @ramon-sg/skills-manager@1 add --catalog ramon-sg/issue-flow
-```
-
-En un repo sin `.agents/skills.json`, `init` en vez de `add`. `close-pr` y `pr-worktree` usan `code-audit`, del catálogo [`agent-skills`](https://github.com/ramon-sg/agent-skills): instala los dos.
+`agent-kit` las instala con el catálogo en la tag de la versión del flujo y las mueve con él. `close-pr` y `pr-worktree` usan `code-audit`, del catálogo [`agent-skills`](https://github.com/ramon-sg/agent-skills): `agent-kit` ofrece los dos.
 
 **Lo propio de cada repo va en `project.md`**, que cada skill (salvo `pr-worktree`) crea desde su plantilla al instalarse: los labels y el assignee, qué flujo sigue cada issue, qué corre sin preguntar al cerrar, qué bots revisan y qué cuenta como review aprobado. Ese archivo es del repo: `check` no lo marca y las actualizaciones lo conservan.
 
@@ -285,7 +278,7 @@ Usa [`github-rest`](https://github.com/ramon-sg/github-rest) para hablar con Git
 
 ## Publicar una versión
 
-Una versión es una release `vX.Y.Z` en GitHub, con el mismo número que `package.json`. Al publicarla, GitHub Actions corre los tests y publica en npm con procedencia (`.github/workflows/publish.yml`). La tag es también la versión de las skills del flujo: `init` instala el catálogo en la tag de su propia versión, así que la CLI y sus skills van siempre juntas.
+Una versión es una release `vX.Y.Z` en GitHub, con el mismo número que `package.json`. Al publicarla, GitHub Actions corre los tests y publica en npm con procedencia (`.github/workflows/publish.yml`). La tag es también la versión de las skills del flujo: `agent-kit` instala el catálogo en la tag de la versión del flujo, así que la CLI y sus skills van siempre juntas.
 
 1. Un PR que sube `version` en `package.json`.
 2. Después del merge, una release `v<versión>` sobre ese commit de `main`.
@@ -296,7 +289,7 @@ El workflow se detiene si la tag no coincide con `package.json`.
 
 1. Desde `main`, con sesión en npm (`npm login`): `npm publish --provenance=false`. La procedencia solo se genera dentro de un CI.
 2. En npmjs.com, configurar la publicación desde GitHub (trusted publishing) para `publish.yml`.
-3. Pushear la tag `v0.1.0` sin crear una release: la necesitan `init` y el `$schema`, y una release volvería a publicar la misma versión y fallaría.
+3. Pushear la tag `v0.1.0` sin crear una release: la necesitan las skills y el `$schema`, y una release volvería a publicar la misma versión y fallaría.
 
 Desde 0.2.0, cada versión es una release y la publica el workflow.
 

package/dist/cli-setup.js

@@ -18,9 +18,9 @@ export async function runSetupCommand(command, flags, rest, run) {
     if (rest.length > 0)
         throw new UsageError(`${command} takes no arguments.`);
     if (command === "doctor")
-        return doctor(run.cwd, run.out);
+        return doctor(run.cwd, flags.json ?? false, run.out);
     if (command === "upgrade")
-        return upgrade({ cwd: run.cwd, to: flags.to ?? null, dryRun: flags["dry-run"] ?? false }, run.out);
+        return upgrade({ cwd: run.cwd, dryRun: flags["dry-run"] ?? false }, run.out);
     const recipes = flags.recipe === undefined ? null : flags.recipe.split(",").map((name) => name.trim()).filter((name) => name !== "");
-    return init({ cwd: run.cwd, yes: flags.yes ?? false, recipes, skills: !(flags["no-skills"] ?? false), guard: !(flags["no-guard"] ?? false), cloud: !(flags["no-cloud"] ?? false) }, run.out);
+    return init({ cwd: run.cwd, yes: flags.yes ?? false, recipes }, run.out);
 }

package/dist/cli.d.ts

@@ -84,18 +84,6 @@ declare const OPTIONS: {
     readonly recipe: {
         readonly type: "string";
     };
-    readonly "no-cloud": {
-        readonly type: "boolean";
-    };
-    readonly "no-guard": {
-        readonly type: "boolean";
-    };
-    readonly "no-skills": {
-        readonly type: "boolean";
-    };
-    readonly to: {
-        readonly type: "string";
-    };
 };
 /** The parsed flags. */
 export type Flags = ReturnType<typeof parseArgs<{

package/dist/cli.js

@@ -41,10 +41,6 @@ const OPTIONS = {
     next: { type: "boolean" },
     "no-setup": { type: "boolean" },
     recipe: { type: "string" },
-    "no-cloud": { type: "boolean" },
-    "no-guard": { type: "boolean" },
-    "no-skills": { type: "boolean" },
-    to: { type: "string" },
 };
 /** Flags each command takes, besides `--repo`, `--help` and `--namer`. */
 const COMMAND_FLAGS = {
@@ -76,9 +72,9 @@ const COMMAND_FLAGS = {
     "adapter archive": [],
     "hook worktree-create": [],
     "hook worktree-remove": [],
-    init: ["yes", "recipe", "no-cloud", "no-guard", "no-skills"],
-    doctor: [],
-    upgrade: ["to", "dry-run"],
+    init: ["yes", "recipe"],
+    doctor: ["json"],
+    upgrade: ["dry-run"],
 };
 /** An issue number: digits only. */
 const NUMBER = /^\d+$/;

package/dist/commands/doctor.d.ts

@@ -2,9 +2,10 @@ import type { Output } from "../output.js";
 /**
  * Checks the repo; see the file's header.
  * @param cwd - Where it runs.
+ * @param json - Whether to print the checks as JSON.
  * @param out - Where to write.
  * @returns 0 if everything passes, 1 if not.
- * @throws SetupError outside a checkout.
- * @example doctor(process.cwd(), out)
+ * @throws SetupError outside a checkout; a broken file is a failed check.
+ * @example doctor(process.cwd(), false, out)
  */
-export declare function doctor(cwd: string, out: Output): number;
+export declare function doctor(cwd: string, json: boolean, out: Output): number;

package/dist/commands/doctor.js

@@ -1,18 +1,17 @@
 /**
- * @file `issue-flow doctor`: whether the repo is set up as `init` leaves it, at this
- * version. It checks the config, the dev dependencies, the hooks, the tag of the flow's
- * skills, and `claude-repo-guard` (its own doctor and, on macOS, `weakerNetworkIsolation`,
- * which `gh` needs inside the sandbox). It changes nothing; each problem says what fixes it.
+ * @file `issue-flow doctor [--json]`: whether the repo's flow files are as `init` leaves
+ * them, at this version: the config, the dev dependencies and the hooks. It changes nothing;
+ * each problem says what fixes it. `--json` prints the checks for `agent-kit`,
+ * which adds those of the skills and the other tools.
  */
-import { ConfigError, isObject } from "../config-base.js";
+import { ConfigError } from "../config-base.js";
 import { loadConfig } from "../config.js";
 import { locateRepo } from "../git.js";
-import { WEAKER_NETWORK } from "../guard-config.js";
 import { dependencyVersion } from "../package-edits.js";
 import { hookVersions } from "../settings-hooks.js";
-import { captureNpx, flowSkills, GUARD_CONFIG, GUARD_SPEC, ownVersions, PACKAGE, readJson, SETTINGS_FILE, SetupError, SKILLS_LOCK, } from "../setup-files.js";
-/** What fixes most problems. */
-const RUN_INIT = "run issue-flow init";
+import { ownVersions, PACKAGE, readJson, SETTINGS_FILE, SetupError } from "../setup-files.js";
+/** What fixes every problem: it runs init or upgrade at the right version. */
+const RUN_AGENT_KIT = "run npx agent-kit";
 /**
  * Checks the config.
  * @param root - The repo.
@@ -41,8 +40,8 @@ function packageChecks(root, version) {
     const flow = dependencyVersion(pkg, PACKAGE);
     const rest = dependencyVersion(pkg, "@ramon-sg/github-rest");
     return [
-        { name: PACKAGE, ok: flow === version, detail: flow === null ? `not in package.json: ${RUN_INIT}` : flow === version ? version : `package.json has ${flow}, this is ${version}: run issue-flow upgrade` },
-        { name: "@ramon-sg/github-rest", ok: rest !== null, detail: rest ?? `not in package.json, and the skills call it: ${RUN_INIT}` },
+        { name: PACKAGE, ok: flow === version, detail: flow === null ? `not in package.json: ${RUN_AGENT_KIT}` : flow === version ? version : `package.json has ${flow}, this is ${version}: ${RUN_AGENT_KIT}` },
+        { name: "@ramon-sg/github-rest", ok: rest !== null, detail: rest ?? `not in package.json, and the skills call it: ${RUN_AGENT_KIT}` },
     ];
 }
 /**
@@ -55,70 +54,37 @@ function hookChecks(root, version) {
     return Object.entries(hookVersions(readJson(root, SETTINGS_FILE))).map(([event, found]) => ({
         name: `${event} hook`,
         ok: found === version,
-        detail: found === null ? `not in ${SETTINGS_FILE}: ${RUN_INIT}` : found === version ? version : `at ${found}, this is ${version}: run issue-flow upgrade`,
+        detail: found === null ? `not in ${SETTINGS_FILE}: ${RUN_AGENT_KIT}` : found === version ? version : `at ${found}, this is ${version}: ${RUN_AGENT_KIT}`,
     }));
 }
-/**
- * Checks that the flow's skills are at this version's tag: they call this CLI, so they go
- * together.
- * @param root - The repo.
- * @param version - This package's version.
- * @returns The check.
- */
-function skillsCheck(root, version) {
-    const skills = flowSkills(readJson(root, SKILLS_LOCK));
-    const tag = `v${version}`;
-    const off = skills.filter((skill) => skill.tag !== tag);
-    if (skills.length === 0)
-        return { name: "flow skills", ok: false, detail: `none in ${SKILLS_LOCK}: ${RUN_INIT}` };
-    if (off.length === 0)
-        return { name: "flow skills", ok: true, detail: `${skills.length} at ${tag}` };
-    return { name: "flow skills", ok: false, detail: `${off.map((skill) => `${skill.name} at ${skill.tag ?? "no tag"}`).join(", ")}, this is ${tag}: run issue-flow upgrade` };
-}
-/**
- * Checks `claude-repo-guard`, if the repo has it: its own doctor and, on macOS, the option
- * `gh` needs.
- * @param root - The repo.
- * @returns The checks.
- */
-function guardChecks(root) {
-    const options = readJson(root, GUARD_CONFIG);
-    if (options === null)
-        return [{ name: "claude-repo-guard", ok: true, detail: "not installed (Claude opens with your own permissions)" }];
-    const checks = [];
-    if (process.platform === "darwin" && options[WEAKER_NETWORK] !== true)
-        checks.push({ name: WEAKER_NETWORK, ok: false, detail: `not true in ${GUARD_CONFIG}, so gh fails inside the macOS sandbox: ${RUN_INIT}` });
-    const result = captureNpx(root, [GUARD_SPEC, "doctor", "--json"]);
-    let found;
-    try {
-        found = JSON.parse(result?.out ?? "");
-    }
-    catch {
-        found = null;
-    }
-    if (!Array.isArray(found))
-        return [...checks, { name: "claude-repo-guard", ok: false, detail: `could not run its doctor; run 'npx ${GUARD_SPEC} doctor'` }];
-    const failed = found.filter((check) => !isObject(check) || check.ok !== true).map((check) => (isObject(check) ? check : { name: "?", detail: String(check) }));
-    if (failed.length === 0)
-        return [...checks, { name: "claude-repo-guard", ok: true, detail: "its doctor passes" }];
-    return [...checks, ...failed.map((check) => ({ name: `claude-repo-guard: ${String(check.name)}`, ok: false, detail: String(check.detail) }))];
-}
 /**
  * Checks the repo; see the file's header.
  * @param cwd - Where it runs.
+ * @param json - Whether to print the checks as JSON.
  * @param out - Where to write.
  * @returns 0 if everything passes, 1 if not.
- * @throws SetupError outside a checkout.
- * @example doctor(process.cwd(), out)
+ * @throws SetupError outside a checkout; a broken file is a failed check.
+ * @example doctor(process.cwd(), false, out)
  */
-export function doctor(cwd, out) {
+export function doctor(cwd, json, out) {
     const located = locateRepo(cwd);
     if (located === null)
         throw new SetupError("run doctor inside a checkout of the repo.");
     const root = located.mainRoot;
     const { issueFlow } = ownVersions();
-    const checks = [configCheck(root), ...packageChecks(root, issueFlow), ...hookChecks(root, issueFlow), skillsCheck(root, issueFlow), ...guardChecks(root)];
-    for (const check of checks)
-        out.stdout(`${check.ok ? "✓" : "✗"} ${check.name}: ${check.detail}\n`);
+    let checks;
+    try {
+        checks = [configCheck(root), ...packageChecks(root, issueFlow), ...hookChecks(root, issueFlow)];
+    }
+    catch (error) {
+        if (!(error instanceof SetupError))
+            throw error;
+        checks = [{ name: "files", ok: false, detail: error.message }];
+    }
+    if (json)
+        out.stdout(`${JSON.stringify(checks)}\n`);
+    else
+        for (const check of checks)
+            out.stdout(`${check.ok ? "✓" : "✗"} ${check.name}: ${check.detail}\n`);
     return checks.every((check) => check.ok) ? 0 : 1;
 }

package/dist/commands/init.d.ts

@@ -4,9 +4,6 @@ export interface InitOptions {
     cwd: string;
     yes: boolean;
     recipes: string[] | null;
-    skills: boolean;
-    guard: boolean;
-    cloud: boolean;
 }
 /**
  * The URL of the config's schema at a version.
@@ -19,9 +16,9 @@ export declare function schemaUrl(version: string): string;
  * Sets the repo up for the flow; see the file's header.
  * @param options - The options.
  * @param out - Where to write and ask.
- * @returns 0, or 1 if a file was not written or another tool failed.
+ * @returns 0, or 1 if the files were not written.
  * @throws SetupError outside the main checkout or with a broken file; ConfigError if the
  * config would be invalid; UsageError for an unknown recipe.
- * @example await init({ cwd, yes: true, recipes: null, skills: true, guard: true, cloud: true }, out)
+ * @example await init({ cwd, yes: true, recipes: null }, out)
  */
 export declare function init(options: InitOptions, out: Output): Promise<number>;

package/dist/commands/init.js

@@ -2,27 +2,19 @@
  * @file `issue-flow init`: sets a repo up for the flow, and can run again to fill in what
  * is missing. It writes `.agents/flow.json` (from `paseo.json` if the repo has one, plus the
  * recipes it picks), the flow's dev dependencies and scripts in `package.json`, and the
- * `SessionStart`, `WorktreeCreate` and `WorktreeRemove` hooks. Then, each after asking, it
- * runs `claude-cloud init`, installs `claude-repo-guard` with what the flow needs in its
- * options, and opens the skills menu of `skills-manager` with the two catalogs (`init` if
- * the repo has no manifest, `add` if it has one, because `init` stops then). A tool that
- * fails is reported and the rest goes on.
+ * `SessionStart`, `WorktreeCreate` and `WorktreeRemove` hooks. Only the flow's own files:
+ * the skills, `claude-cloud` and `claude-repo-guard` are installed by `agent-kit`,
+ * which runs this command.
  */
 import { confirm } from "../ask.js";
 import { CONFIG_PATH, isObject } from "../config-base.js";
 import { parseConfig } from "../config.js";
 import { checkoutRoot, locateRepo } from "../git.js";
-import { guardOptions } from "../guard-config.js";
 import { UsageError, warn } from "../output.js";
 import { withFlowPackages } from "../package-edits.js";
 import { applyRecipe, detectedRecipes, loadRecipes, projectPrefix } from "../recipes.js";
 import { registerHooks } from "../settings-hooks.js";
-import { CLOUD_SPEC, FLOW_CATALOG, GENERAL_CATALOG, GUARD_CONFIG, GUARD_SPEC, ownVersions, packageManager, readJson, runNpx, SETTINGS_FILE, SetupError, SKILLS_MANIFEST, writeJson, } from "../setup-files.js";
-/** The skills picked without a terminal: 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:${GENERAL_CATALOG}/code-audit`,
-];
+import { FLOW_REPO, ownVersions, packageManager, readJson, SETTINGS_FILE, SetupError, writeJson } from "../setup-files.js";
 /**
  * The URL of the config's schema at a version.
  * @param version - This package's version.
@@ -30,7 +22,7 @@ const DEFAULT_SKILLS = [
  * @example schemaUrl("0.1.0") // "https://raw.githubusercontent.com/ramon-sg/issue-flow/v0.1.0/schema.json"
  */
 export function schemaUrl(version) {
-    return `https://raw.githubusercontent.com/${FLOW_CATALOG}/v${version}/schema.json`;
+    return `https://raw.githubusercontent.com/${FLOW_REPO}/v${version}/schema.json`;
 }
 /**
  * A new config: the schema, and the branch rules of `paseo.json` if the repo has one.
@@ -107,78 +99,14 @@ function plan(root, versions, recipes) {
     });
     return [file(CONFIG_PATH, raw, configChanges), file("package.json", pkg.pkg, pkg.changes), file(SETTINGS_FILE, hooks.settings, hooks.changes)];
 }
-/**
- * Runs one of the other tools after asking, and says if it failed.
- * @param step - What it is and how it runs.
- * @param options - The options.
- * @param out - Where to ask and write.
- * @returns False if it ran and failed.
- */
-async function external(step, options, out) {
-    if (!options.yes && !(await confirm(out, step.question)))
-        return true;
-    if (step.run())
-        return true;
-    warn(out, step.failed);
-    return false;
-}
-/**
- * Installs `claude-repo-guard`, after writing in its options what the flow needs.
- * @param root - The repo.
- * @param out - Where to write.
- * @returns Whether it installed.
- */
-function installGuard(root, out) {
-    const flow = readJson(root, CONFIG_PATH);
-    const baseBranch = typeof flow?.baseBranch === "string" ? flow.baseBranch : null;
-    const { options, changes } = guardOptions(readJson(root, GUARD_CONFIG), baseBranch, process.platform);
-    if (changes.length > 0)
-        writeJson(root, GUARD_CONFIG, options);
-    for (const change of changes)
-        out.stdout(`  ${change}\n`);
-    return runNpx(root, [GUARD_SPEC, "install", "--yes"]);
-}
-/**
- * The ids of the default skills the manifest does not take yet: `skills-manager` leaves the
- * ones it has out of the candidates, and fails if `--select` names one.
- * @param manifest - The skills manifest, or null.
- * @returns The ids to pick.
- */
-function missingDefaults(manifest) {
-    const sources = Array.isArray(manifest?.sources) ? manifest.sources.filter(isObject) : [];
-    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)}`) : [])));
-    return DEFAULT_SKILLS.filter((id) => !taken.has(id));
-}
-/**
- * Opens the skills menu with the flow's catalog, at this version, and the general one; without
- * a terminal or with `--yes`, it picks the flow's skills and `code-audit` that are not there yet.
- * @param root - The repo.
- * @param versions - This package's versions.
- * @param pick - Whether to pick without the menu.
- * @param out - Where to say there is nothing to add.
- * @returns Whether `skills-manager` worked, or true if there was nothing to pick.
- */
-function installSkills(root, versions, pick, out) {
-    const manifest = readJson(root, SKILLS_MANIFEST);
-    const command = manifest === null ? "init" : "add";
-    const args = [`@ramon-sg/skills-manager@${versions.skillsManager}`, command, "--catalog", `${FLOW_CATALOG}#v${versions.issueFlow}`, "--catalog", GENERAL_CATALOG];
-    if (!pick)
-        return runNpx(root, args);
-    const missing = missingDefaults(manifest);
-    if (missing.length === 0) {
-        out.stdout(`The flow's skills and code-audit are already in ${SKILLS_MANIFEST}.\n`);
-        return true;
-    }
-    return runNpx(root, [...args, "--select", missing.join(",")]);
-}
 /**
  * Sets the repo up for the flow; see the file's header.
  * @param options - The options.
  * @param out - Where to write and ask.
- * @returns 0, or 1 if a file was not written or another tool failed.
+ * @returns 0, or 1 if the files were not written.
  * @throws SetupError outside the main checkout or with a broken file; ConfigError if the
  * config would be invalid; UsageError for an unknown recipe.
- * @example await init({ cwd, yes: true, recipes: null, skills: true, guard: true, cloud: true }, out)
+ * @example await init({ cwd, yes: true, recipes: null }, out)
  */
 export async function init(options, out) {
     const located = locateRepo(options.cwd);
@@ -202,12 +130,7 @@ export async function init(options, out) {
     }
     for (const file of files.filter((item) => item.changes.length > 0))
         writeJson(root, file.path, file.value);
-    const results = [
-        !options.cloud || await external({ question: "Set up Claude cloud sessions with claude-cloud init?", run: () => runNpx(root, [CLOUD_SPEC, "init"]), failed: `claude-cloud init failed; run 'npx ${CLOUD_SPEC} init' to retry.` }, options, out),
-        !options.guard || await external({ question: "Install claude-repo-guard (auto mode, with the sandbox)?", run: () => installGuard(root, out), failed: `claude-repo-guard did not install; run 'npx ${GUARD_SPEC} install' to retry.` }, options, out),
-        !options.skills || await external({ question: "Pick the skills now?", run: () => installSkills(root, versions, options.yes || !out.interactive, out), failed: "skills-manager failed; run issue-flow init again to retry." }, options, out),
-    ];
     const manager = packageManager(root, readJson(root, "package.json"));
     out.stdout(`Next: run '${manager} install', and commit .agents/, .claude/ and package.json.\n`);
-    return results.every(Boolean) ? 0 : 1;
+    return 0;
 }

package/dist/commands/upgrade.d.ts

@@ -2,15 +2,15 @@ import type { Output } from "../output.js";
 /** Options of `issue-flow upgrade`. */
 export interface UpgradeOptions {
     cwd: string;
-    to: string | null;
     dryRun: boolean;
 }
 /**
- * Moves the repo to another version of the flow; see the file's header.
+ * Moves the repo's flow files to this version; see the file's header.
  * @param options - The options.
  * @param out - Where to write.
- * @returns 0, or 1 if `skills-manager` failed.
- * @throws SetupError outside the main checkout, if npm cannot tell the version or a file is broken.
- * @example upgrade({ cwd, to: null, dryRun: false }, out)
+ * @returns 0.
+ * @throws SetupError outside the main checkout, if a file is broken, or if the repo is
+ * already at a newer version (a stale local copy must not move it back).
+ * @example upgrade({ cwd, dryRun: false }, out)
  */
 export declare function upgrade(options: UpgradeOptions, out: Output): number;

package/dist/commands/upgrade.js

@@ -1,72 +1,53 @@
 /**
- * @file `issue-flow upgrade [--to <version>] [--dry-run]`: moves the repo to another version
- * of the flow, the latest on npm by default. The CLI and the flow's skills go together,
- * because the skills call the CLI: it moves the dev dependencies to the ones that version
- * pins, the hooks and the config's schema to it, and the flow's catalog in the skills
- * manifest to its tag, and then runs `skills-manager update` on the flow's skills only (the
- * general ones keep their own versions). The versions come from npm, not from the CLI
- * that runs, which may be the old one.
+ * @file `issue-flow upgrade [--dry-run]`: moves the repo's flow files to the version that
+ * runs: the dev dependencies to the ones it pins, and the hooks and the config's schema to
+ * it. `agent-kit` runs it as `npx @ramon-sg/issue-flow@<version> upgrade` and then
+ * moves the flow's skills to the same tag, because the skills call this CLI.
  */
-import { spawnSync } from "node:child_process";
-import { CONFIG_PATH, isObject } from "../config-base.js";
+import { CONFIG_PATH } from "../config-base.js";
 import { checkoutRoot, locateRepo } from "../git.js";
-import { withFlowPackages } from "../package-edits.js";
-import { registerHooks } from "../settings-hooks.js";
-import { FLOW_CATALOG, flowSkills, PACKAGE, packageManager, readJson, runNpx, SETTINGS_FILE, SetupError, SKILLS_LOCK, SKILLS_MANIFEST, writeJson, } from "../setup-files.js";
+import { dependencyVersion, withFlowPackages } from "../package-edits.js";
+import { hookVersions, registerHooks } from "../settings-hooks.js";
+import { FLOW_REPO, ownVersions, PACKAGE, packageManager, readJson, SETTINGS_FILE, SetupError, writeJson } from "../setup-files.js";
 import { schemaUrl } from "./init.js";
-/** A release version. */
-const VERSION = /^\d+\.\d+\.\d+$/;
 /** The start of the schema URL `init` writes, at any version. */
-const SCHEMA_PREFIX = `https://raw.githubusercontent.com/${FLOW_CATALOG}/`;
+const SCHEMA_PREFIX = `https://raw.githubusercontent.com/${FLOW_REPO}/`;
+/** A release version, after an optional range sign. */
+const RELEASE = /^[\^~=]?(\d+)\.(\d+)\.(\d+)$/;
 /**
- * The versions a release of this package pins, from npm.
- * @param to - The version, or null for the latest.
- * @returns The versions.
- * @throws SetupError if npm cannot tell, or the release lacks them.
+ * Whether a version is newer than another; false if either is not a release.
+ * @param version - The version, maybe with a range sign.
+ * @param than - The other.
+ * @returns True if it is newer.
  */
-function releaseVersions(to) {
-    const spec = `${PACKAGE}@${to ?? "latest"}`;
-    const result = spawnSync("npm", ["view", spec, "version", "dependencies", "devDependencies", "--json"], { encoding: "utf8" });
-    let info;
-    try {
-        info = JSON.parse(result.stdout);
+function isNewer(version, than) {
+    const [left, right] = [RELEASE.exec(version), RELEASE.exec(than)];
+    if (left === null || right === null)
+        return false;
+    for (let index = 1; index <= 3; index += 1) {
+        const diff = Number(left[index]) - Number(right[index]);
+        if (diff !== 0)
+            return diff > 0;
     }
-    catch {
-        info = null;
-    }
-    if (result.status !== 0 || !isObject(info))
-        throw new SetupError(`npm could not find ${spec}${result.stderr ? `: ${result.stderr.trim()}` : "."}`);
-    const deps = isObject(info.dependencies) ? info.dependencies : {};
-    const devDeps = isObject(info.devDependencies) ? info.devDependencies : {};
-    const githubRest = deps["@ramon-sg/github-rest"];
-    const skillsManager = devDeps["@ramon-sg/skills-manager"];
-    if (typeof info.version !== "string" || !VERSION.test(info.version) || typeof githubRest !== "string" || typeof skillsManager !== "string")
-        throw new SetupError(`${spec} on npm lacks its version or those of github-rest and skills-manager.`);
-    return { issueFlow: info.version, githubRest, skillsManager };
+    return false;
 }
 /**
- * The skills manifest with the flow's catalog at a tag.
- * @param manifest - The manifest, or null.
- * @param tag - The tag.
- * @returns The new manifest and whether it changed, or null if the flow's catalog is not in it.
+ * The newest version of the flow the repo already has, in package.json or a hook.
+ * @param root - The repo.
+ * @returns The version, or null if it has none.
  */
-function movedManifest(manifest, tag) {
-    const sources = Array.isArray(manifest?.sources) ? manifest.sources : [];
-    const index = sources.findIndex((source) => isObject(source) && source.catalog === FLOW_CATALOG);
-    const source = sources[index];
-    if (manifest === null || !isObject(source))
-        return null;
-    if (source.ref === tag)
-        return { manifest, changed: false };
-    return { manifest: { ...manifest, sources: sources.map((item, at) => (at === index ? { ...source, ref: tag } : item)) }, changed: true };
+function repoVersion(root) {
+    const found = [dependencyVersion(readJson(root, "package.json"), PACKAGE), ...Object.values(hookVersions(readJson(root, SETTINGS_FILE)))];
+    return found.filter((version) => version !== null).reduce((newest, version) => (newest === null || isNewer(version, newest) ? version : newest), null);
 }
 /**
- * Moves the repo to another version of the flow; see the file's header.
+ * Moves the repo's flow files to this version; see the file's header.
  * @param options - The options.
  * @param out - Where to write.
- * @returns 0, or 1 if `skills-manager` failed.
- * @throws SetupError outside the main checkout, if npm cannot tell the version or a file is broken.
- * @example upgrade({ cwd, to: null, dryRun: false }, out)
+ * @returns 0.
+ * @throws SetupError outside the main checkout, if a file is broken, or if the repo is
+ * already at a newer version (a stale local copy must not move it back).
+ * @example upgrade({ cwd, dryRun: false }, out)
  */
 export function upgrade(options, out) {
     const located = locateRepo(options.cwd);
@@ -75,10 +56,10 @@ export function upgrade(options, out) {
     const root = located.mainRoot;
     if (checkoutRoot(options.cwd) !== root)
         throw new SetupError(`run upgrade in the main checkout, ${root}, not in a worktree.`);
-    if (options.to !== null && !VERSION.test(options.to))
-        throw new SetupError(`--to expects a version like 0.2.0: ${options.to}`);
-    const versions = releaseVersions(options.to);
-    const tag = `v${versions.issueFlow}`;
+    const versions = ownVersions();
+    const current = repoVersion(root);
+    if (current !== null && isNewer(current, versions.issueFlow))
+        throw new SetupError(`the repo is at issue-flow ${current}, newer than this ${versions.issueFlow}; run 'npx ${PACKAGE}@${current.replace(/^[\^~=]/, "")} upgrade' or 'npx agent-kit'.`);
     const writes = [];
     const lines = [];
     const pkg = withFlowPackages(readJson(root, "package.json"), versions, true);
@@ -92,24 +73,13 @@ export function upgrade(options, out) {
     const config = readJson(root, CONFIG_PATH);
     if (config !== null && typeof config.$schema === "string" && config.$schema.startsWith(SCHEMA_PREFIX) && config.$schema !== schemaUrl(versions.issueFlow)) {
         writes.push({ path: CONFIG_PATH, value: { ...config, $schema: schemaUrl(versions.issueFlow) } });
-        lines.push(`${CONFIG_PATH}: $schema at ${tag}`);
-    }
-    const manifest = movedManifest(readJson(root, SKILLS_MANIFEST), tag);
-    if (manifest?.changed === true) {
-        writes.push({ path: SKILLS_MANIFEST, value: manifest.manifest });
-        lines.push(`${SKILLS_MANIFEST}: ${FLOW_CATALOG} at ${tag}`);
+        lines.push(`${CONFIG_PATH}: $schema at v${versions.issueFlow}`);
     }
-    const skills = flowSkills(readJson(root, SKILLS_LOCK)).map((skill) => skill.name);
     out.stdout(lines.length === 0 ? `Already at issue-flow ${versions.issueFlow}.\n` : `To issue-flow ${versions.issueFlow}:\n${lines.map((line) => `  ${line}\n`).join("")}`);
-    if (manifest === null)
-        out.stdout(`  the flow's skills are not in ${SKILLS_MANIFEST}: issue-flow init installs them\n`);
-    if (options.dryRun)
+    if (options.dryRun || writes.length === 0)
         return 0;
     for (const write of writes)
         writeJson(root, write.path, write.value);
-    const updated = manifest === null || skills.length === 0 || runNpx(root, [`@ramon-sg/skills-manager@${versions.skillsManager}`, "update", ...skills]);
-    if (!updated)
-        out.stderr(`issue-flow: skills-manager update failed; run 'npx @ramon-sg/skills-manager@${versions.skillsManager} update ${skills.join(" ")}' to retry.\n`);
     out.stdout(`Next: run '${packageManager(root, readJson(root, "package.json"))} install', review the diff and commit it.\n`);
-    return updated ? 0 : 1;
+    return 0;
 }

package/dist/setup-files.d.ts

@@ -1,21 +1,9 @@
 /** This package's name on npm. */
 export declare const PACKAGE = "@ramon-sg/issue-flow";
-/** The GitHub repo of this package, which is also the catalog of the flow skills. */
-export declare const FLOW_CATALOG = "ramon-sg/issue-flow";
-/** The catalog of the general skills. */
-export declare const GENERAL_CATALOG = "ramon-sg/agent-skills";
-/** Where `skills-manager` keeps the repo's skills manifest. */
-export declare const SKILLS_MANIFEST = ".agents/skills.json";
-/** Where `skills-manager` keeps the repo's skills lock. */
-export declare const SKILLS_LOCK = ".agents/skills.lock.json";
+/** The GitHub repo of this package, whose tags hold the config's schema of each version. */
+export declare const FLOW_REPO = "ramon-sg/issue-flow";
 /** Claude Code's settings of the repo. */
 export declare const SETTINGS_FILE = ".claude/settings.json";
-/** The options of `claude-repo-guard` in the repo. */
-export declare const GUARD_CONFIG = ".claude/repo-guard.config.json";
-/** How `claude-repo-guard` runs: it is not on npm. */
-export declare const GUARD_SPEC = "github:ramon-sg/claude-repo-guard";
-/** How `claude-cloud` runs. */
-export declare const CLOUD_SPEC = "@ramon-sg/claude-cloud@1";
 /** Error of `init`, `doctor` or `upgrade`: exits 1 with the message. */
 export declare class SetupError extends Error {
 }
@@ -58,32 +46,3 @@ export declare function writeJson(root: string, path: string, value: unknown): v
  * @example packageManager(root, { packageManager: "pnpm@9.0.0" }) // "pnpm"
  */
 export declare function packageManager(root: string, pkg: Record<string, unknown> | null): string;
-/**
- * Runs `npx <args>` in the repo, its output on this terminal.
- * @param root - The repo.
- * @param args - The package and its arguments.
- * @returns Whether it exited 0.
- * @example runNpx(root, ["@ramon-sg/claude-cloud@1", "init"])
- */
-export declare function runNpx(root: string, args: string[]): boolean;
-/**
- * Runs `npx <args>` in the repo and returns what it printed.
- * @param root - The repo.
- * @param args - The package and its arguments.
- * @returns Its stdout and exit code, or null if npx could not start.
- * @example captureNpx(root, ["github:ramon-sg/claude-repo-guard", "doctor", "--json"])
- */
-export declare function captureNpx(root: string, args: string[]): {
-    out: string;
-    status: number | null;
-} | null;
-/**
- * The flow's skills in the repo's skills lock, with the tag each one is at.
- * @param lock - The lock, or null.
- * @returns Name and tag of each skill of the flow's catalog.
- * @example flowSkills(lock) // [{ name: "close-pr", tag: "v0.1.0" }]
- */
-export declare function flowSkills(lock: Record<string, unknown> | null): {
-    name: string;
-    tag: string | null;
-}[];

package/dist/setup-files.js

@@ -1,32 +1,19 @@
 /**
  * @file What `init`, `doctor` and `upgrade` share: this package's own versions, the JSON
- * files of the repo they read and write, its package manager, and running another tool
- * with `npx`. Every package goes by its scoped name: the unscoped `issue-flow`,
- * `github-rest` and `skills-manager` on npm belong to other people.
+ * files of the repo they read and write, and its package manager. Every package goes by its
+ * scoped name: the unscoped `issue-flow`, `github-rest` and `skills-manager` on npm belong
+ * to other people.
  */
-import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { isObject } from "./config-base.js";
 /** This package's name on npm. */
 export const PACKAGE = "@ramon-sg/issue-flow";
-/** The GitHub repo of this package, which is also the catalog of the flow skills. */
-export const FLOW_CATALOG = "ramon-sg/issue-flow";
-/** The catalog of the general skills. */
-export const GENERAL_CATALOG = "ramon-sg/agent-skills";
-/** Where `skills-manager` keeps the repo's skills manifest. */
-export const SKILLS_MANIFEST = ".agents/skills.json";
-/** Where `skills-manager` keeps the repo's skills lock. */
-export const SKILLS_LOCK = ".agents/skills.lock.json";
+/** The GitHub repo of this package, whose tags hold the config's schema of each version. */
+export const FLOW_REPO = "ramon-sg/issue-flow";
 /** Claude Code's settings of the repo. */
 export const SETTINGS_FILE = ".claude/settings.json";
-/** The options of `claude-repo-guard` in the repo. */
-export const GUARD_CONFIG = ".claude/repo-guard.config.json";
-/** How `claude-repo-guard` runs: it is not on npm. */
-export const GUARD_SPEC = "github:ramon-sg/claude-repo-guard";
-/** How `claude-cloud` runs. */
-export const CLOUD_SPEC = "@ramon-sg/claude-cloud@1";
 /** Error of `init`, `doctor` or `upgrade`: exits 1 with the message. */
 export class SetupError extends Error {
 }
@@ -102,37 +89,3 @@ export function packageManager(root, pkg) {
         return field;
     return LOCKFILES.find(([file]) => existsSync(join(root, file)))?.[1] ?? "npm";
 }
-/**
- * Runs `npx <args>` in the repo, its output on this terminal.
- * @param root - The repo.
- * @param args - The package and its arguments.
- * @returns Whether it exited 0.
- * @example runNpx(root, ["@ramon-sg/claude-cloud@1", "init"])
- */
-export function runNpx(root, args) {
-    const result = spawnSync("npx", ["--yes", ...args], { cwd: root, stdio: "inherit" });
-    return result.status === 0;
-}
-/**
- * Runs `npx <args>` in the repo and returns what it printed.
- * @param root - The repo.
- * @param args - The package and its arguments.
- * @returns Its stdout and exit code, or null if npx could not start.
- * @example captureNpx(root, ["github:ramon-sg/claude-repo-guard", "doctor", "--json"])
- */
-export function captureNpx(root, args) {
-    const result = spawnSync("npx", ["--yes", ...args], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "inherit"] });
-    return result.error === undefined ? { out: result.stdout, status: result.status } : null;
-}
-/**
- * The flow's skills in the repo's skills lock, with the tag each one is at.
- * @param lock - The lock, or null.
- * @returns Name and tag of each skill of the flow's catalog.
- * @example flowSkills(lock) // [{ name: "close-pr", tag: "v0.1.0" }]
- */
-export function flowSkills(lock) {
-    const skills = isObject(lock?.skills) ? lock.skills : {};
-    return Object.entries(skills)
-        .filter(([, entry]) => isObject(entry) && entry.source === `catalog:${FLOW_CATALOG}`)
-        .map(([name, entry]) => ({ name, tag: isObject(entry) && typeof entry.tag === "string" ? entry.tag : null }));
-}

package/dist/usage.d.ts

@@ -2,4 +2,4 @@
  * @file The usage text of the CLI, printed with `--help` and after a usage error.
  */
 /** Usage text. */
-export declare const USAGE = "Usage:\n  issue-flow issue branch <n>... [--namer claude|title] [--json] [-R owner/repo]\n  issue-flow issue branch --missing [--limit <n>] [--namer claude|title] [--dry-run | --yes] [--json] [-R owner/repo]\n  issue-flow issue start <n> [--branch] [--dry-run | --yes] [--resume <branch> | --new] [--no-launch]\n                             [--ask-permissions | --free] [--namer claude|title] [-R owner/repo]\n  issue-flow issue start <n> --plan [--ask-permissions | --free] [--namer claude|title] [-R owner/repo]\n  issue-flow issue start <n> --cloud | --here | --teleport | --adopt [...]\n  issue-flow worktree setup [--only <step>]\n  issue-flow worktree teardown [--path <dir>]\n  issue-flow worktree ports [--next]\n  issue-flow worktree cleanup [--path <dir>]\n  issue-flow worktree prune [--only <dir>] [--yes] [-R owner/repo]\n  issue-flow pr worktree <n> [--no-setup] [-R owner/repo] [-- [<command>...]]\n  issue-flow adapter setup [--only <step>] | issue [<url>] | archive [-R owner/repo]\n  issue-flow session\n  issue-flow hook worktree-create | worktree-remove\n  issue-flow init [--yes] [--recipe <name>,...] [--no-cloud] [--no-guard] [--no-skills]\n  issue-flow doctor\n  issue-flow upgrade [--to <version>] [--dry-run]\n\nThe slug comes from the issue's \"Slug de rama\" block, then from Claude, then from the title,\nand the branch from the repo's template (an older \"Rama sugerida\" block is used if it fits).\n--missing adds the slug block to every open issue without a block, after confirming.\n\nissue start makes the branch in a worktree (or, with --branch, in this checkout), the\nstart commit, the push, the draft PR and the assignment, after confirming, and opens\nClaude: in auto mode if the repo has claude-repo-guard, with your settings with\n--ask-permissions, and with no sandbox nor questions with --free. --plan prints the branch\nand the prompt as JSON and changes nothing.\n\n--cloud confirms here and opens a Claude cloud session that starts the issue there.\n--here, inside a cloud session, starts it in this checkout and opens nothing. --teleport\nbrings the cloud session noted in the PR to the worktree. --adopt starts it in the\nworktree another tool (Orca, Paseo) just made, without asking nor opening Claude.\n\nworktree runs the steps of \"worktrees\" in .agents/flow.json: setup prepares this worktree,\nteardown cleans it before it goes (steps, ports, Docker), ports prints or moves its block\nof ports, cleanup deletes the Docker of deleted worktrees, and prune deletes the worktrees\nwhose PR was merged or closed. session is the SessionStart hook of Claude Code.\n\npr worktree makes (or reuses) a worktree on a PR's own branch, to review and fix it; with\n--, it runs the command there (Claude if none). adapter is what Orca and Paseo run: setup\nwhen they make a worktree (its steps and, if it came from an issue, issue start --adopt),\nissue to start one by hand, and archive before they delete it. hook implements Claude\nCode's WorktreeCreate and WorktreeRemove for claude --worktree.\n\ninit sets the repo up: .agents/flow.json (with the recipes its files suggest), the dev\ndependencies and scripts, and the hooks; then, after asking, claude-cloud init,\nclaude-repo-guard and the skills menu. doctor checks it is set up at this version, and\nupgrade moves the CLI, the hooks and the flow's skills to the latest version (or --to).";
+export declare const USAGE = "Usage:\n  issue-flow issue branch <n>... [--namer claude|title] [--json] [-R owner/repo]\n  issue-flow issue branch --missing [--limit <n>] [--namer claude|title] [--dry-run | --yes] [--json] [-R owner/repo]\n  issue-flow issue start <n> [--branch] [--dry-run | --yes] [--resume <branch> | --new] [--no-launch]\n                             [--ask-permissions | --free] [--namer claude|title] [-R owner/repo]\n  issue-flow issue start <n> --plan [--ask-permissions | --free] [--namer claude|title] [-R owner/repo]\n  issue-flow issue start <n> --cloud | --here | --teleport | --adopt [...]\n  issue-flow worktree setup [--only <step>]\n  issue-flow worktree teardown [--path <dir>]\n  issue-flow worktree ports [--next]\n  issue-flow worktree cleanup [--path <dir>]\n  issue-flow worktree prune [--only <dir>] [--yes] [-R owner/repo]\n  issue-flow pr worktree <n> [--no-setup] [-R owner/repo] [-- [<command>...]]\n  issue-flow adapter setup [--only <step>] | issue [<url>] | archive [-R owner/repo]\n  issue-flow session\n  issue-flow hook worktree-create | worktree-remove\n  issue-flow init [--yes] [--recipe <name>,...]\n  issue-flow doctor [--json]\n  issue-flow upgrade [--dry-run]\n\nThe slug comes from the issue's \"Slug de rama\" block, then from Claude, then from the title,\nand the branch from the repo's template (an older \"Rama sugerida\" block is used if it fits).\n--missing adds the slug block to every open issue without a block, after confirming.\n\nissue start makes the branch in a worktree (or, with --branch, in this checkout), the\nstart commit, the push, the draft PR and the assignment, after confirming, and opens\nClaude: in auto mode if the repo has claude-repo-guard, with your settings with\n--ask-permissions, and with no sandbox nor questions with --free. --plan prints the branch\nand the prompt as JSON and changes nothing.\n\n--cloud confirms here and opens a Claude cloud session that starts the issue there.\n--here, inside a cloud session, starts it in this checkout and opens nothing. --teleport\nbrings the cloud session noted in the PR to the worktree. --adopt starts it in the\nworktree another tool (Orca, Paseo) just made, without asking nor opening Claude.\n\nworktree runs the steps of \"worktrees\" in .agents/flow.json: setup prepares this worktree,\nteardown cleans it before it goes (steps, ports, Docker), ports prints or moves its block\nof ports, cleanup deletes the Docker of deleted worktrees, and prune deletes the worktrees\nwhose PR was merged or closed. session is the SessionStart hook of Claude Code.\n\npr worktree makes (or reuses) a worktree on a PR's own branch, to review and fix it; with\n--, it runs the command there (Claude if none). adapter is what Orca and Paseo run: setup\nwhen they make a worktree (its steps and, if it came from an issue, issue start --adopt),\nissue to start one by hand, and archive before they delete it. hook implements Claude\nCode's WorktreeCreate and WorktreeRemove for claude --worktree.\n\ninit sets the flow up in the repo: .agents/flow.json (with the recipes its files suggest),\nthe dev dependencies and scripts, and the hooks. doctor checks them at this version, and\nupgrade moves them to this version. npx agent-kit runs the three, along with the\nskills, claude-cloud and claude-repo-guard.";

package/dist/usage.js

@@ -18,9 +18,9 @@ export const USAGE = `Usage:
   issue-flow adapter setup [--only <step>] | issue [<url>] | archive [-R owner/repo]
   issue-flow session
   issue-flow hook worktree-create | worktree-remove
-  issue-flow init [--yes] [--recipe <name>,...] [--no-cloud] [--no-guard] [--no-skills]
-  issue-flow doctor
-  issue-flow upgrade [--to <version>] [--dry-run]
+  issue-flow init [--yes] [--recipe <name>,...]
+  issue-flow doctor [--json]
+  issue-flow upgrade [--dry-run]
 
 The slug comes from the issue's "Slug de rama" block, then from Claude, then from the title,
 and the branch from the repo's template (an older "Rama sugerida" block is used if it fits).
@@ -48,7 +48,7 @@ when they make a worktree (its steps and, if it came from an issue, issue start
 issue to start one by hand, and archive before they delete it. hook implements Claude
 Code's WorktreeCreate and WorktreeRemove for claude --worktree.
 
-init sets the repo up: .agents/flow.json (with the recipes its files suggest), the dev
-dependencies and scripts, and the hooks; then, after asking, claude-cloud init,
-claude-repo-guard and the skills menu. doctor checks it is set up at this version, and
-upgrade moves the CLI, the hooks and the flow's skills to the latest version (or --to).`;
+init sets the flow up in the repo: .agents/flow.json (with the recipes its files suggest),
+the dev dependencies and scripts, and the hooks. doctor checks them at this version, and
+upgrade moves them to this version. npx agent-kit runs the three, along with the
+skills, claude-cloud and claude-repo-guard.`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ramon-sg/issue-flow",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Issue-to-PR workflow for any repo: names each issue's branch, creates its worktree, opens the draft PR and launches Claude Code, locally and in Claude's cloud.",
   "license": "MIT",
   "type": "module",
@@ -18,5 +18,5 @@
     "prepublishOnly": "npm test"
   },
   "dependencies": { "@ramon-sg/github-rest": "0.2.1" },
-  "devDependencies": { "@ramon-sg/skills-manager": "1.1.0", "@types/node": "^24.0.0", "typescript": "^5.9.3" }
+  "devDependencies": { "@ramon-sg/skills-manager": "1.2.0", "@types/node": "^24.0.0", "typescript": "^5.9.3" }
 }

package/recipes/staging-main.json

@@ -1,5 +1,5 @@
 {
-  "description": "Work starts from staging and PRs go there; main only gets releases. Also lets claude-repo-guard's auto mode merge into staging.",
+  "description": "Work starts from staging and PRs go there; main only gets releases.",
   "detect": [],
   "config": { "baseBranch": "staging" }
 }

package/dist/guard-config.d.ts

@@ -1,16 +0,0 @@
-/** What the auto mode is told about the flow. */
-export declare const GUARD_ENVIRONMENT = "issue-flow is this repo's issue workflow: making the branch and worktree of an issue, its empty start commit, pushing it, opening its draft PR, assigning the issue and adding its \"Slug de rama\" block are normal steps of the work, not risky actions.";
-/** The option that lets `gh` verify TLS inside the macOS sandbox. */
-export declare const WEAKER_NETWORK = "weakerNetworkIsolation";
-/**
- * The guard's options with what the flow needs added; what the repo set stays.
- * @param current - The options, or null if there is no file.
- * @param baseBranch - The flow's `baseBranch`, or null.
- * @param platform - The operating system (`process.platform`).
- * @returns The new options and what changed.
- * @example guardOptions(null, "staging", "darwin").options.integrationBranch // "staging"
- */
-export declare function guardOptions(current: Record<string, unknown> | null, baseBranch: string | null, platform: string): {
-    options: Record<string, unknown>;
-    changes: string[];
-};

package/dist/guard-config.js

@@ -1,38 +0,0 @@
-/**
- * @file What `issue-flow` writes in `claude-repo-guard`'s options before installing it. The
- * auto mode's classifier gets told that the flow's own writes (the start commit, the push,
- * the draft PR, the assignment, the "Slug de rama" block) are the normal workflow. A repo
- * with its own base branch (`staging`) gets it as `integrationBranch`, so merging into it is
- * part of the flow too. On macOS `gh` needs `weakerNetworkIsolation` inside the sandbox.
- */
-import { GUARD_CONFIG } from "./setup-files.js";
-/** What the auto mode is told about the flow. */
-export const GUARD_ENVIRONMENT = "issue-flow is this repo's issue workflow: making the branch and worktree of an issue, its empty start commit, pushing it, opening its draft PR, assigning the issue and adding its \"Slug de rama\" block are normal steps of the work, not risky actions.";
-/** The option that lets `gh` verify TLS inside the macOS sandbox. */
-export const WEAKER_NETWORK = "weakerNetworkIsolation";
-/**
- * The guard's options with what the flow needs added; what the repo set stays.
- * @param current - The options, or null if there is no file.
- * @param baseBranch - The flow's `baseBranch`, or null.
- * @param platform - The operating system (`process.platform`).
- * @returns The new options and what changed.
- * @example guardOptions(null, "staging", "darwin").options.integrationBranch // "staging"
- */
-export function guardOptions(current, baseBranch, platform) {
-    const options = { ...(current ?? {}) };
-    const changes = [];
-    const environment = Array.isArray(options.environment) ? options.environment.map(String) : [];
-    if (!environment.includes(GUARD_ENVIRONMENT)) {
-        options.environment = [...environment, GUARD_ENVIRONMENT];
-        changes.push(`${GUARD_CONFIG}: tells the auto mode about the issue flow`);
-    }
-    if (baseBranch !== null && (options.integrationBranch === undefined || options.integrationBranch === "")) {
-        options.integrationBranch = baseBranch;
-        changes.push(`${GUARD_CONFIG}: integrationBranch ${baseBranch}`);
-    }
-    if (platform === "darwin" && options[WEAKER_NETWORK] === undefined) {
-        options[WEAKER_NETWORK] = true;
-        changes.push(`${GUARD_CONFIG}: ${WEAKER_NETWORK} true, so gh works inside the macOS sandbox`);
-    }
-    return { options, changes };
-}