@inixiative/config 0.5.200 → 0.5.201

package/README.md

@@ -110,10 +110,10 @@ Lanes stand alone. A lane with a package missing a checkout, or claimed by ambig
 Blessing is two-phase, so a dependent that needs work never deadlocks a release:
 
 1. **Candidate.** A published version is recorded under `candidates`, and the config release that ends the train carries it, so `check` in any repo's CI accepts it from then on.
-2. **Adopt.** A repo (lane checkout or consumer) whose check fails against the candidates it was moved onto doesn't stop the train. Its checkout is put back as it was, and the train opens `train/adopt-<pkg>-<version>` in a worktree (the repo's own `worktree:create <base> <branch>` when it declares one, so a template-based repo gets its slot's databases, released with its `worktree:destroy`; otherwise a temporary linked worktree; either way with the repo's ignored `.env*` files copied in where missing): the same bump and re-lock, then the repo's `train:adopt` script if its package.json declares one (Foundry's re-records cassettes with `bun run test:live`), all committed, and re-locked onto the new config release so the PR's CI judges it against the candidates. A lane checkout that adopts publishes nothing this run. A consumer that passes against candidates gets the same branch name: its default branch is still on the previous versions until the branch merges. If the adoption's commit is refused (its hooks typecheck), the branch is deleted and the summary says to adopt by hand.
-3. **Promote.** At the end of each run a candidate is blessed (moved into its lane's section) unless something holds it: its lane stopped; a repo has an adoption branch for it that is not yet on its default branch (opened this run, unmerged, or committed but never pushed); or a repo that declares it was not walked to an outcome this run (another lane's checkout, a skipped or failed one, a consumer without a checkout). A later train finds a waiting adoption branch and opens nothing new; once it merges, the repo is on the candidate and the train promotes it. A candidate every dependent already accepts is blessed in the run that published it. An adoption PR closed without merging holds its candidates until its branch is deleted.
+2. **Adopt.** A repo (lane checkout or consumer) whose check fails against the candidates it was moved onto doesn't stop the train. Its checkout is put back as it was, and the train opens `train/adopt-<pkg>-<version>` in a worktree (the repo's own `worktree:create <base> <branch>` when it declares one, so a template-based repo gets its slot's databases, released with its `worktree:destroy`; otherwise a temporary linked worktree; either way with the repo's ignored `.env*` files copied in where missing): the same bump and re-lock, then the repo's `train:adopt` script if its package.json declares one (Foundry's re-records cassettes with `bun run test:live`), all committed, and re-locked onto the new config release so its CI judges it against the candidates. `--push` pushes the branch; the train opens no PR. A lane checkout that adopts publishes nothing this run. A consumer that passes against candidates commits on its default branch, like any other passing repo. If the adoption's commit is refused (its hooks typecheck), the branch is deleted and the summary says to adopt by hand.
+3. **Promote.** At the end of each run a candidate is blessed (moved into its lane's section) unless something holds it: its lane stopped; a repo has an adoption branch for it that is not yet on its default branch (opened this run, unmerged, or committed but never pushed); or a repo that declares it was not walked to an outcome this run (another lane's checkout, a skipped or failed one, a consumer without a checkout). A later train finds a waiting adoption branch and opens nothing new; once it merges, the repo is on the candidate and the train promotes it. A candidate every dependent already accepts is blessed in the run that published it. An adoption branch abandoned without merging holds its candidates until it is deleted; the next train that moves that repo deletes it.
 
-The summary lists what was blessed, every candidate with what holds it, every hold with its reason, and each pending adoption branch with its PR when `gh` can find one.
+The summary lists what was blessed, every candidate with what holds it, every hold with its reason, and each pending adoption branch.
 
 **Holds.** A hold keeps a package's breaking line out of the blessed set while its dependents can't take it yet (signet 0.12 waiting on Kingdom's grants cutover), without stopping the package's own releases or anyone else's:
 
@@ -139,11 +139,11 @@ Every version at or above `below` is held; versions below it ride the train as u
 
 A root package publishes with `npm publish`; a workspace member is packed with `bun pm pack`, which rewrites `workspace:` ranges to the versions being released, and the tarball is published with `npm publish`, so OTP prompts pass through either way. A package already on npm at its local version but neither blessed nor a candidate (published by hand, or by a train whose lane later failed) becomes a candidate on the next run, unless a hold covers that version. Likewise, an `@inixiative/config` version committed ahead of npm (a release whose publish failed) is published by the next run, even when it blesses nothing new.
 
-Consumers run once, after every selected lane, upstreams first, against the full blessed set: a consumer of both lanes ends coherent with both whichever lane ran. They get the same bump → re-lock → `check`, never a publish, and their changes go through review: the train commits them on a `train/ecosystem-sync-<date>` branch, in a worktree, and puts the checkout back on its default branch, clean.
+Consumers run once, after every selected lane, upstreams first, against the full blessed set: a consumer of both lanes ends coherent with both whichever lane ran. They get the same bump → re-lock → `check`, never a publish, and a passing re-lock is committed on their default branch, as a lane repo's is. Only a consumer that fails against candidates gets a branch (an adoption, above).
 
 A train never leaves a checkout dirty or off its default branch. It only works in a checkout it found clean, so a checkout that then fails is reset to HEAD (tracked and untracked files; ignored ones such as node_modules and `.env` stay) and re-installed from its lockfile. Every branch it makes is committed in a temporary worktree, removed when the train exits.
 
-When anything was recorded or blessed it then ships this package last, so the BOM names the new state: bumps its own patch version if npm already has the current one, blesses that version in the BOM, brings the `test/fixtures` consumers onto the blessed set, runs `check`, commits, publishes. Then every checkout the train re-locked (lane packages on their default branch, consumer and adoption branches in their worktrees) is re-locked onto that new `@inixiative/config` and committed, so none is left pinning the previous release. It never pushes unless asked: pass `--push` to push every repo it committed to and open a PR for each consumer and adoption branch; otherwise it prints the commands. `--dry-run` walks the same plan and prints each step it would take (range rewrites, re-locks and checks, commits, review branches, publishes, BOM blessings, pushes) without running any of them; it only fetches and reads git state and `npm view`.
+When anything was recorded or blessed it then ships this package last, so the BOM names the new state: bumps its own patch version if npm already has the current one, blesses that version in the BOM, brings the `test/fixtures` consumers onto the blessed set, runs `check`, commits, publishes. Then every checkout the train re-locked (lane packages and consumers on their default branch, adoption branches in their worktrees) is re-locked onto that new `@inixiative/config` and committed, so none is left pinning the previous release. It never pushes unless asked: pass `--push` to push every repo it committed to and each adoption branch, then delete every other `train/*` branch, local and on origin, in each repo it moved (that repo is now on the whole target, so they are superseded). It opens no PRs. Without `--push` it prints the commands. Its worktrees, and the temporary dirs that hold them, are removed however the run ends. `--dry-run` walks the same plan and prints each step it would take (range rewrites, re-locks and checks, commits, adoption branches, publishes, BOM blessings, pushes) without running any of them; it only fetches and reads git state and `npm view`.
 
 Each command accepts only its own flags. An unknown or misplaced flag (`--dryrun`, `--push` on `sync`) is a usage error and exits 2 before anything runs.
 
@@ -173,4 +173,4 @@ Two lanes, each publishing in dependency order, with config last:
 - **primitives:** for example json-rules → permissions → transitions → rules-builder, plus prisma-map, atlas and gloss. Consumers: template, kingdom.
 - **agentic:** signet, kcp (the Kingdom CLI proxy, on signet), archive and agent-session, then foundry-core → foundry → foundry-acp (foundry depends on archive), built on the primitives' blessed set. foundry-core, foundry and foundry-acp publish from the foundry monorepo's `packages/core`, `packages/foundry` and `packages/acp`. Consumers: oracle (a private leaf), kingdom.
 
-A release is `train` (or `train --lane=agentic` to leave the primitives alone): bump the package's version on its default branch, then run the train. `train` automates the whole walk, this package and the consumer PRs included. Downstream repos pick up toolchain changes via `sync`.
+A release is `train` (or `train --lane=agentic` to leave the primitives alone): bump the package's version on its default branch, then run the train. `train` automates the whole walk, this package and the consumer bumps included. Downstream repos pick up toolchain changes via `sync`.

package/dist/cli.js

@@ -1547,7 +1547,7 @@ if (command === "train") {
   const failed = [];
   const failedLanes = /* @__PURE__ */ new Set();
   const committed = /* @__PURE__ */ new Set();
-  const reviewBranches = [];
+  const adoptionBranches = [];
   const waiting = [];
   const walked = /* @__PURE__ */ new Set();
   const worktrees = [];
@@ -1557,7 +1557,10 @@ if (command === "train") {
         cwd: repo,
         stdio: "inherit"
       });
-    } else git(repo, "worktree", "remove", "--force", path);
+    } else {
+      git(repo, "worktree", "remove", "--force", path);
+      rmSync3(dirname3(path), { recursive: true, force: true });
+    }
   };
   process.on("exit", () => {
     for (const entry of worktrees.splice(0)) removeWorktree(entry);
@@ -1669,7 +1672,7 @@ if (command === "train") {
     if (!remote && !local) return false;
     const state = remote ? "unmerged" : "unpushed";
     console.log(
-      `\u23F3 adopting ${moving.join(", ")} on ${branch} \u2014 ${state === "unmerged" ? "waiting for it to merge" : "never pushed: push it and open its PR"}`
+      `\u23F3 adopting ${moving.join(", ")} on ${branch} \u2014 ${state === "unmerged" ? "waiting for it to merge" : "never pushed: push it"}`
     );
     waiting.push({ name: checkout.name, dir: checkout.dir, moving, state, branch });
     walked.add(checkout.dir);
@@ -1713,46 +1716,8 @@ if (command === "train") {
     git(checkout.dir, "branch", "-D", branch);
   };
   const defaultBranch = (cwd) => offDefaultBranch(cwd)?.main ?? currentBranch(cwd);
-  const reviewBranch = (checkout, packagePaths, moving) => {
-    const branch = moving.length > 0 ? adoptionBranch(moving) : freeBranch(checkout.dir, `train/ecosystem-sync-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
-    const base = defaultBranch(checkout.dir);
-    const opened = effect(
-      `create review branch ${branch} in ${checkout.name} (in a worktree; the checkout stays on ${base})`,
-      true,
-      () => {
-        const branchCheckout = worktree(checkout, branch);
-        for (const path of [...packagePaths, "bun.lock"]) {
-          if (existsSync3(join3(checkout.dir, path))) {
-            writeFileSync3(join3(branchCheckout.dir, path), readFileSync3(join3(checkout.dir, path)));
-          }
-        }
-        restore(checkout);
-        try {
-          relockAndCheck(branchCheckout, false);
-          const message = moving.length > 0 ? `chore: adopt ${moving.map((name) => `${name}@${manifest.candidates?.[name]}`).join(", ")}` : void 0;
-          if (!commitOwned(branchCheckout, packagePaths, true, message)) {
-            console.log(`\u2713 nothing to commit for ${checkout.name} after its re-lock`);
-            dropBranch(checkout, branch);
-            return false;
-          }
-        } catch (error) {
-          dropBranch(checkout, branch);
-          throw error;
-        }
-        followers.push({ checkout: branchCheckout, onBranch: true });
-        console.log(`committed on ${branch} for review; ${checkout.name} stays on ${base}`);
-        return true;
-      }
-    );
-    if (!opened) return;
-    reviewBranches.push({ dir: checkout.dir, branch, base });
-    if (moving.length > 0) {
-      waiting.push({ name: checkout.name, dir: checkout.dir, moving, state: "opened", branch });
-    }
-  };
   const adopt = (checkout, moving) => {
     const branch = adoptionBranch(moving);
-    const base = defaultBranch(checkout.dir);
     const label = moving.map((name) => `${name}@${manifest.candidates?.[name]}`).join(", ");
     const script = checkout.pkg.scripts?.["train:adopt"];
     try {
@@ -1769,7 +1734,7 @@ if (command === "train") {
               stdio: "inherit"
             }).status !== 0) {
               console.log(
-                `\u26A0 train:adopt failed in ${checkout.name} \u2014 the PR needs work before it merges`
+                `\u26A0 train:adopt failed in ${checkout.name} \u2014 the branch needs work before it merges`
               );
             }
             git(branchCheckout.dir, "add", "-A");
@@ -1789,7 +1754,7 @@ if (command === "train") {
           followers.push({ checkout: branchCheckout, onBranch: true });
         }
       );
-      reviewBranches.push({ dir: checkout.dir, branch, base });
+      adoptionBranches.push({ dir: checkout.dir, branch });
       waiting.push({ name: checkout.name, dir: checkout.dir, moving, state: "opened", branch });
     } catch (error) {
       if (!(error instanceof Abort)) throw error;
@@ -1971,7 +1936,10 @@ if (command === "train") {
     }
     try {
       relockAndCheck(checkout);
-      reviewBranch(checkout, inspection.packagePaths, moving);
+      const message = moving.length > 0 ? `chore: adopt ${moving.map((name) => `${name}@${manifest.candidates?.[name]}`).join(", ")}` : void 0;
+      if (commitOwned(checkout, inspection.packagePaths, true, message))
+        committed.add(checkout.dir);
+      followers.push({ checkout, onBranch: false });
       walked.add(checkout.dir);
     } catch (error) {
       if (!(error instanceof Abort)) throw error;
@@ -2028,7 +1996,7 @@ if (command === "train") {
   }
   const why = {
     opened: "opened this run",
-    unmerged: "waiting for its PR to merge",
+    unmerged: "waiting for its branch to merge",
     unpushed: "committed but never pushed",
     failed: "the train could not commit it \u2014 adopt by hand",
     unverified: "not verified this run"
@@ -2045,11 +2013,10 @@ blessed: ${promoted.length === 0 ? "nothing" : promoted.join(", ")}`);
   }
   for (const line of holdLines(manifest)) console.log(line);
   if (waiting.length > 0) {
-    console.log("pending (merge each adoption PR, then run the train again to bless):");
+    console.log("pending (merge each adoption branch, then run the train again to bless):");
     for (const entry of waiting) {
-      const url = entry.state === "unmerged" && !dryRun && entry.branch ? prUrl(entry.dir, entry.branch) : null;
       console.log(
-        `  ${entry.name}: ${entry.branch ? `${entry.branch} \u2014 ` : ""}${why[entry.state]}${url ? ` ${url}` : ""}`
+        `  ${entry.name}: ${entry.branch ? `${entry.branch} \u2014 ` : ""}${why[entry.state]}`
       );
     }
   }
@@ -2136,13 +2103,20 @@ blessed: ${promoted.length === 0 ? "nothing" : promoted.join(", ")}`);
       }
     }
   }
+  const moved = [.../* @__PURE__ */ new Set([...committed, ...adoptionBranches.map((entry) => entry.dir)])];
+  const keep = new Set(adoptionBranches.map((entry) => `${entry.dir}\0${entry.branch}`));
+  const superseded = (repoDir) => {
+    const refs = (prefix) => git(repoDir, "for-each-ref", "--format=%(refname:short)", prefix).stdout.split("\n").map((ref) => ref.trim().replace(/^origin\//, "")).filter((branch) => branch.startsWith("train/") && !keep.has(`${repoDir}\0${branch}`));
+    return { local: refs("refs/heads/train/"), remote: refs("refs/remotes/origin/train/") };
+  };
   if (dryRun) {
     console.log(
       `
-dry run complete \u2014 a real train would commit in ${committed.size} repo(s) and open ${reviewBranches.length} review branch(es)${commandLine.push ? ", then push them" : ""}:`
+dry run complete \u2014 a real train would commit in ${committed.size} repo(s) and open ${adoptionBranches.length} adoption branch(es)${commandLine.push ? ", then push them and delete the train branches they supersede" : ""}:`
     );
     for (const repoDir of committed) console.log(`  ${repoDir}`);
-    for (const { dir: repoDir, branch } of reviewBranches) console.log(`  ${repoDir} (${branch})`);
+    for (const { dir: repoDir, branch } of adoptionBranches)
+      console.log(`  ${repoDir} (${branch})`);
   } else if (commandLine.push) {
     for (const repoDir of committed) {
       if (spawnSync3("git", ["push"], { cwd: repoDir, stdio: "inherit" }).status !== 0) {
@@ -2150,45 +2124,47 @@ dry run complete \u2014 a real train would commit in ${committed.size} repo(s) a
         process.exit(1);
       }
     }
-    for (const { dir: repoDir, branch, base } of reviewBranches) {
+    for (const { dir: repoDir, branch } of adoptionBranches) {
       const push = spawnSync3("git", ["push", "-u", "origin", branch], {
         cwd: repoDir,
         stdio: "inherit"
       });
-      const pr = push.status === 0 && spawnSync3("gh", ["pr", "create", "--fill", "--base", base, "--head", branch], {
-        cwd: repoDir,
-        stdio: "inherit"
-      }).status === 0;
-      if (!pr) console.error(`\u2717 could not push ${branch} and open its PR in ${repoDir}`);
+      if (push.status !== 0) console.error(`\u2717 could not push ${branch} in ${repoDir}`);
+    }
+    for (const repoDir of moved) {
+      git(repoDir, "fetch", "--quiet", "--prune", "origin");
+      const { local, remote } = superseded(repoDir);
+      const gone = /* @__PURE__ */ new Set();
+      for (const branch of remote) {
+        if (git(repoDir, "push", "--quiet", "origin", "--delete", branch).status === 0) {
+          gone.add(branch);
+        } else console.error(`\u2717 could not delete origin/${branch} in ${repoDir}`);
+      }
+      for (const branch of local) {
+        if (git(repoDir, "branch", "-D", branch).status === 0) gone.add(branch);
+        else console.error(`\u2717 could not delete ${branch} in ${repoDir}`);
+      }
+      if (gone.size > 0) console.log(`\u{1F9F9} ${repoDir}: deleted ${[...gone].join(", ")}`);
     }
-    console.log(`pushed: ${committed.size + reviewBranches.length} repos`);
-  } else if (committed.size > 0 || reviewBranches.length > 0) {
+    console.log(`pushed: ${committed.size + adoptionBranches.length} repos`);
+  } else if (committed.size > 0 || adoptionBranches.length > 0) {
     console.log("train does not push without --push \u2014 review its commits, then push:");
     for (const repoDir of committed) console.log(`  git -C ${repoDir} push`);
-    for (const { dir: repoDir, branch, base } of reviewBranches) {
-      console.log(
-        `  git -C ${repoDir} push -u origin ${branch} && (cd ${repoDir} && gh pr create --fill --base ${base})`
-      );
+    for (const { dir: repoDir, branch } of adoptionBranches) {
+      console.log(`  git -C ${repoDir} push -u origin ${branch}`);
+    }
+    for (const repoDir of moved) {
+      const { local, remote } = superseded(repoDir);
+      for (const branch of remote)
+        console.log(`  git -C ${repoDir} push origin --delete ${branch}`);
+      if (local.length > 0) console.log(`  git -C ${repoDir} branch -D ${local.join(" ")}`);
     }
   }
   process.exit(failed.length > 0 ? 1 : 0);
 }
-function prUrl(cwd, branch) {
-  const view = spawnSync3("gh", ["pr", "view", branch, "--json", "url", "--jq", ".url"], {
-    cwd,
-    encoding: "utf8"
-  });
-  return view.status === 0 ? view.stdout.trim() || null : null;
-}
 function currentBranch(cwd) {
   return git(cwd, "rev-parse", "--abbrev-ref", "HEAD").stdout.trim();
 }
-function freeBranch(cwd, name) {
-  const taken = (candidate2) => git(cwd, "rev-parse", "--verify", "--quiet", `refs/heads/${candidate2}`).status === 0;
-  let candidate = name;
-  for (let n = 2; taken(candidate); n++) candidate = `${name}-${n}`;
-  return candidate;
-}
 function servedByRegistry(name, version) {
   const deadline = Date.now() + 15 * 6e4;
   while (true) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inixiative/config",
-  "version": "0.5.200",
+  "version": "0.5.201",
   "description": "Shared toolchain and theme for the inixiative packages: tsconfig/biome/tsup presets, theme CSS, a version manifest (BOM), and a sync/check/train CLI",
   "type": "module",
   "license": "MIT",

package/versions.json

@@ -13,7 +13,7 @@
     "@types/bun"
   ],
   "ecosystem": {
-    "@inixiative/config": "0.5.200",
+    "@inixiative/config": "0.5.201",
     "@inixiative/json-rules": "3.16.0",
     "@inixiative/permissions": "0.21.1",
     "@inixiative/transitions": "0.7.2",
@@ -52,6 +52,6 @@
   },
   "candidates": {
     "@inixiative/atlas": "0.5.0",
-    "@inixiative/json-rules": "3.20.0"
+    "@inixiative/json-rules": "3.21.0"
   }
 }