@regardio/dev 2.1.1 → 2.3.0

package/dist/bin/ship/hotfix.bin.mjs

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
-import { a as runQualityChecks, i as gitRead, o as runScript, r as git, t as branchExists } from "./utils-BQ-JZ2D5.mjs";
-import { execFileSync, execSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { a as git, c as runScript, i as getWorkspacePackages, n as chooseForEach, o as gitRead, s as runQualityChecks, t as branchExists } from "./utils-VktE94Vs.mjs";
 //#region src/bin/ship/hotfix.ts
 /**
 * ship-hotfix: Manage hotfix branches based on production code.
@@ -14,10 +11,10 @@ import { join } from "node:path";
 * GitLab workflow:
 *   production → hotfix/<name> → production → staging → main
 *
-* During a hotfix, add a changeset (`pnpm changeset`) describing the fix.
-* `ship-hotfix finish` consumes all pending changesets, commits the version
-* bumps, and propagates the hotfix through production → staging → main.
-* CI on `production` handles the `changeset publish` to npm.
+* During a hotfix, commit your fix with conventional commits. `ship-hotfix
+* finish` runs `pnpm release` to bump the version based on those commits,
+* updates CHANGELOG.md, then propagates the hotfix through
+* production → staging → main. CI on `production` handles publishing to npm.
 */
 function runShipHotfix(subcommand, subArgs, cwd = process.cwd()) {
 	if (subcommand === "start") {
@@ -41,7 +38,7 @@ function runShipHotfix(subcommand, subArgs, cwd = process.cwd()) {
 		git("pull", "--ff-only", "origin", "production");
 		git("checkout", "-b", hotfixBranch);
 		console.log(`\n✅ Hotfix branch "${hotfixBranch}" created from production.`);
-		console.log("Apply your fix, add a changeset (`pnpm changeset`), commit, then run:");
+		console.log("Apply your fix using conventional commits, then run:");
 		console.log("  ship-hotfix finish");
 		process.exit(0);
 	}
@@ -55,14 +52,6 @@ function runShipHotfix(subcommand, subArgs, cwd = process.cwd()) {
 			console.error("Working directory has uncommitted changes. Commit or stash them first.");
 			process.exit(1);
 		}
-		if (!existsSync(join(cwd, ".changeset"))) {
-			console.error("\nNo .changeset/ directory found. This tooling requires Changesets.\nCopy the template from @regardio/dev/templates/changeset and run:\n  pnpm changeset init");
-			process.exit(1);
-		}
-		if (execFileSync("sh", ["-c", `ls .changeset/*.md 2>/dev/null | grep -v README.md | wc -l | tr -d ' '`], { encoding: "utf-8" }).trim() === "0") {
-			console.error("\nNo pending changesets. Run `pnpm changeset` before finishing the hotfix.");
-			process.exit(1);
-		}
 		console.log("\nRunning quality checks...");
 		try {
 			runQualityChecks();
@@ -71,37 +60,19 @@ function runShipHotfix(subcommand, subArgs, cwd = process.cwd()) {
 			process.exit(1);
 		}
 		console.log("✅ Quality checks passed");
-		const packageJsonPath = join(cwd, "package.json");
-		if (!existsSync(packageJsonPath)) {
-			console.error("No package.json found in current directory.");
+		const packages = getWorkspacePackages(cwd);
+		if (packages.length === 0) {
+			console.error("No publishable workspace packages found.");
 			process.exit(1);
 		}
-		const { name: packageName } = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-		console.log("\nApplying changesets (bumping versions and updating CHANGELOGs)...");
-		runScript("changeset version");
-		try {
-			runScript("fix:pkg");
-		} catch {}
-		try {
-			git("add", "-A");
-			const changedFiles = gitRead("diff", "--cached", "--name-only").split("\n").filter(Boolean);
-			for (const file of changedFiles) {
-				if (file.endsWith(".json")) try {
-					execSync(`npx biome check --write ${file}`, {
-						cwd,
-						stdio: "inherit"
-					});
-				} catch {}
-				if (file.endsWith(".md")) try {
-					execSync(`npx markdownlint-cli2 --fix ${file}`, {
-						cwd,
-						stdio: "inherit"
-					});
-				} catch {}
-			}
-		} catch {}
-		git("add", "-A");
-		git("commit", "-m", "chore(hotfix): version packages");
+		console.log("\nSelect a version bump for each package (or skip):");
+		const bumps = chooseForEach(packages);
+		if (bumps.length === 0) {
+			console.log("\nNo packages selected for release. Aborted.");
+			process.exit(0);
+		}
+		console.log("\nBumping versions and updating CHANGELOGs...");
+		for (const { package: pkg, bump } of bumps) runScript(`--filter ${pkg.name} release:${bump}`);
 		console.log("\nFetching latest state from origin...");
 		git("fetch", "origin");
 		console.log("\nMerging hotfix into production...");
@@ -118,12 +89,13 @@ function runShipHotfix(subcommand, subArgs, cwd = process.cwd()) {
 		git("checkout", "main");
 		git("pull", "--ff-only", "origin", "main");
 		git("merge", "--no-ff", "staging", "-m", "chore(hotfix): merge staging into main");
-		git("push", "origin", "main");
+		git("push", "--follow-tags", "origin", "main");
 		git("branch", "-d", currentBranch);
 		try {
 			git("push", "origin", "--delete", currentBranch);
 		} catch {}
-		console.log(`\n✅ Hotfix ${packageName} shipped to production → staging → main`);
+		const shipped = bumps.map((b) => b.package.name).join(", ");
+		console.log(`\n✅ Hotfix ${shipped} shipped to production → staging → main`);
 		console.log("CI will publish changed packages to npm.");
 		console.log("You are on main and ready to keep working.");
 		process.exit(0);

package/dist/bin/ship/production.bin.mjs

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
-import { a as runQualityChecks, i as gitRead, n as confirm, o as runScript, r as git, t as branchExists } from "./utils-BQ-JZ2D5.mjs";
-import { execFileSync, execSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { a as git, c as runScript, i as getWorkspacePackages, n as chooseForEach, o as gitRead, r as confirm, s as runQualityChecks, t as branchExists } from "./utils-VktE94Vs.mjs";
 //#region src/bin/ship/production.ts
 /**
 * ship-production: Promote main to production following the GitLab workflow.
@@ -10,12 +7,12 @@ import { join } from "node:path";
 * Usage: ship-production
 *
 * GitLab workflow:
-*   main → (changeset version + commit) → production → staging → main
+*   main → (commit-and-tag-version) → production → staging → main
 *
-* Versioning is driven by Changesets. Authors add a changeset (`pnpm changeset`)
-* alongside their change on main. This script consumes all pending changesets
-* at ship time, commits the version bumps, then merges main → production.
-* CI on `production` handles the actual `changeset publish` to npm.
+* Versioning is driven by commit-and-tag-version. Running `pnpm release`
+* at ship time reads conventional commits since the last tag, bumps the
+* version, updates CHANGELOG.md, and commits the result on `main` before
+* merging to `production`. CI on `production` handles publishing to npm.
 */
 function runShipProduction(cwd = process.cwd()) {
 	const currentBranch = gitRead("branch", "--show-current");
@@ -45,22 +42,18 @@ function runShipProduction(cwd = process.cwd()) {
 	}
 	console.log("\nCommits to be shipped to production:");
 	console.log(ahead);
-	const packageJsonPath = join(cwd, "package.json");
-	if (!existsSync(packageJsonPath)) {
-		console.error("No package.json found in current directory.");
+	const packages = getWorkspacePackages(cwd);
+	if (packages.length === 0) {
+		console.error("No publishable workspace packages found.");
 		process.exit(1);
 	}
-	const { name: packageName } = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-	const hasChangesets = existsSync(join(cwd, ".changeset"));
-	if (hasChangesets) {
-		const pendingChangesets = execFileSync("sh", ["-c", `ls .changeset/*.md 2>/dev/null | grep -v README.md | wc -l | tr -d ' '`], { encoding: "utf-8" }).trim();
-		if (pendingChangesets === "0") {
-			console.error("\nNo pending changesets. Run `pnpm changeset` before shipping to production.");
-			process.exit(1);
-		}
-		console.log(`\n${pendingChangesets} pending changeset(s) will be consumed.`);
+	console.log("\nSelect a version bump for each package (or skip):");
+	const bumps = chooseForEach(packages);
+	if (bumps.length === 0) {
+		console.log("\nNo packages selected for release. Aborted.");
+		process.exit(0);
 	}
-	if (!confirm(`Ship ${packageName} to production?`)) {
+	if (!confirm(`\nShip to production?\n${bumps.map((b) => `  ${b.package.name}  →  ${b.bump}`).join("\n")}\n`)) {
 		console.log("Aborted.");
 		process.exit(0);
 	}
@@ -72,33 +65,8 @@ function runShipProduction(cwd = process.cwd()) {
 		process.exit(1);
 	}
 	console.log("✅ Quality checks passed");
-	if (hasChangesets) {
-		console.log("\nApplying changesets (bumping versions and updating CHANGELOGs)...");
-		runScript("changeset version");
-		try {
-			runScript("fix:pkg");
-		} catch {}
-		try {
-			git("add", "-A");
-			const changedFiles = gitRead("diff", "--cached", "--name-only").split("\n").filter(Boolean);
-			for (const file of changedFiles) {
-				if (file.endsWith(".json")) try {
-					execSync(`npx biome check --write ${file}`, {
-						cwd,
-						stdio: "inherit"
-					});
-				} catch {}
-				if (file.endsWith(".md")) try {
-					execSync(`npx markdownlint-cli2 --fix ${file}`, {
-						cwd,
-						stdio: "inherit"
-					});
-				} catch {}
-			}
-		} catch {}
-		git("add", "-A");
-		git("commit", "-m", "chore(release): version packages");
-	}
+	console.log("\nBumping versions and updating CHANGELOGs...");
+	for (const { package: pkg, bump } of bumps) runScript(`--filter ${pkg.name} release:${bump}`);
 	console.log("\nMerging main into production...");
 	git("checkout", "production");
 	git("pull", "--ff-only", "origin", "production");
@@ -110,8 +78,9 @@ function runShipProduction(cwd = process.cwd()) {
 	git("merge", "--ff-only", "production");
 	git("push", "origin", "staging");
 	git("checkout", "main");
-	git("push", "origin", "main");
-	console.log(`\n✅ Shipped ${packageName} to production. CI will publish changed packages to npm.`);
+	git("push", "--follow-tags", "origin", "main");
+	const shipped = bumps.map((b) => b.package.name).join(", ");
+	console.log(`\n✅ Shipped ${shipped} to production. CI will publish changed packages to npm.`);
 	console.log("You are on main and ready to keep working.");
 }
 //#endregion

package/dist/bin/ship/staging.bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as runQualityChecks, i as gitRead, r as git, t as branchExists } from "./utils-BQ-JZ2D5.mjs";
+import { a as git, o as gitRead, s as runQualityChecks, t as branchExists } from "./utils-VktE94Vs.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/bin/ship/staging.ts

package/dist/bin/ship/utils-VktE94Vs.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import { execFileSync, execSync } from "node:child_process";
+import { closeSync, openSync, readSync } from "node:fs";
+//#region src/bin/ship/utils.ts
+/**
+* Shared utilities for ship-staging, ship-production, and ship-hotfix.
+*
+* Git commands use execFileSync (not a shell string) so user-provided
+* strings such as commit messages are never interpolated by the shell.
+* pnpm script invocations use execSync via shell since script names are
+* developer-controlled and pnpm itself is resolved through PATH.
+*/
+const git = (...args) => {
+	console.log(`$ git ${args.join(" ")}`);
+	execFileSync("git", args, { stdio: "inherit" });
+};
+const gitRead = (...args) => execFileSync("git", args, { encoding: "utf-8" }).trim();
+const runScript = (script) => {
+	console.log(`$ pnpm ${script}`);
+	execSync(`pnpm ${script}`, { stdio: "inherit" });
+};
+const runQualityChecks = () => {
+	runScript("build");
+	runScript("typecheck");
+	runScript("test");
+};
+const getWorkspacePackages = (cwd = process.cwd()) => {
+	const raw = execFileSync("pnpm", [
+		"list",
+		"--recursive",
+		"--json",
+		"--depth",
+		"0"
+	], {
+		cwd,
+		encoding: "utf-8"
+	});
+	return JSON.parse(raw).filter((p) => p.private !== true && p.name !== void 0).map(({ name, path }) => ({
+		name,
+		path
+	}));
+};
+const chooseForEach = (packages, ttyPath = "/dev/tty") => {
+	const bumps = [];
+	const options = [
+		{
+			label: "skip",
+			value: "skip"
+		},
+		{
+			label: "patch — bug fixes",
+			value: "patch"
+		},
+		{
+			label: "minor — new features",
+			value: "minor"
+		},
+		{
+			label: "major — breaking changes",
+			value: "major"
+		}
+	];
+	for (const pkg of packages) {
+		const answer = choose(`\n${pkg.name}:`, [...options], ttyPath);
+		if (answer !== "skip") bumps.push({
+			bump: answer,
+			package: pkg
+		});
+	}
+	return bumps;
+};
+const branchExists = (name) => gitRead("branch", "--list", name) !== "" || gitRead("branch", "--list", "--remotes", `origin/${name}`) !== "";
+const confirm = (prompt, ttyPath = "/dev/tty") => {
+	process.stdout.write(`${prompt} (y/N) `);
+	const buf = Buffer.alloc(1024);
+	let fd;
+	let shouldClose = false;
+	try {
+		fd = openSync(ttyPath, "r");
+		shouldClose = true;
+	} catch {
+		fd = process.stdin.fd;
+	}
+	const bytesRead = readSync(fd, buf, 0, buf.length, null);
+	if (shouldClose) closeSync(fd);
+	const answer = buf.slice(0, bytesRead).toString().trim();
+	return answer === "y" || answer === "Y";
+};
+const choose = (prompt, options, ttyPath = "/dev/tty") => {
+	const keys = options.map((_, i) => String(i + 1));
+	const optionList = options.map((o, i) => `  ${i + 1}) ${o.label}`).join("\n");
+	process.stdout.write(`${prompt}\n${optionList}\nChoice [${keys.join("/")}]: `);
+	const buf = Buffer.alloc(1024);
+	let fd;
+	let shouldClose = false;
+	try {
+		fd = openSync(ttyPath, "r");
+		shouldClose = true;
+	} catch {
+		fd = process.stdin.fd;
+	}
+	const bytesRead = readSync(fd, buf, 0, buf.length, null);
+	if (shouldClose) closeSync(fd);
+	const answer = buf.slice(0, bytesRead).toString().trim();
+	const index = keys.indexOf(answer);
+	if (index === -1) {
+		console.error(`\nInvalid choice: "${answer}". Expected one of: ${keys.join(", ")}`);
+		process.exit(1);
+	}
+	const chosen = options[index];
+	if (!chosen) process.exit(1);
+	return chosen.value;
+};
+//#endregion
+export { git as a, runScript as c, getWorkspacePackages as i, chooseForEach as n, gitRead as o, confirm as r, runQualityChecks as s, branchExists as t };

package/docs/en/README.md

@@ -46,18 +46,21 @@ Configuration and usage for each tool in the stack:
 ### Commands
 
 ```bash
-pnpm build         # Build all packages
-pnpm dev           # Start development
-pnpm fix           # Run all fixes and linting
-pnpm lint          # Run linting only
-pnpm report        # Run tests with coverage
-pnpm changeset     # Declare a version bump alongside your change
-pnpm ship:staging  # Deploy main to staging for validation (optional)
-pnpm ship:production  # Consume changesets, merge main → production, trigger publish
+pnpm build              # Build all packages
+pnpm dev                # Start development
+pnpm fix                # Run all fixes and linting
+pnpm lint               # Run linting only
+pnpm report             # Run tests with coverage
+pnpm release            # Bump version from conventional commits, update CHANGELOG.md
+pnpm release:patch      # Force a patch bump
+pnpm release:minor      # Force a minor bump
+pnpm release:major      # Force a major bump
+pnpm ship:staging       # Deploy main to staging for validation (optional)
+pnpm ship:production    # Bump version, merge main → production, trigger publish
 pnpm ship:hotfix start <name>  # Start an urgent fix from production
-pnpm ship:hotfix finish  # Propagate the hotfix back through production → staging → main
-pnpm test          # Run tests
-pnpm typecheck     # TypeScript type checking
+pnpm ship:hotfix finish        # Propagate the hotfix back through production → staging → main
+pnpm test               # Run tests
+pnpm typecheck          # TypeScript type checking
 ```
 
 ### Config Files

package/docs/en/standards/commits.md

@@ -97,7 +97,7 @@ Commit messages are validated by [Commitlint](../tools/commitlint.md) through gi
 
 ## Changelog generation
 
-Changelogs are generated from [Changesets](../tools/releases.md) — one-line descriptions authors write with `pnpm changeset` alongside their change. `ship-production` consumes pending changesets at ship time and writes them into each package's `CHANGELOG.md`. The changeset description is what users read, so write it for that reader from the start.
+Changelogs are generated by [commit-and-tag-version](../tools/releases.md) from conventional commit subjects. `ship-production` runs `pnpm release` at ship time, which reads commits since the last tag and writes them into `CHANGELOG.md`. The commit subject is what users read, so write it for that reader from the start.
 
 ## Related
 

package/docs/en/tools/releases.md

@@ -1,7 +1,7 @@
 ---
 
 title: "Release Workflow"
-description: "Branch-based release workflow for Regardio packages — main → staging → production, driven by Changesets."
+description: "Branch-based release workflow for Regardio packages — main → staging → production, driven by commit-and-tag-version."
 publishedAt: 2026-04-17
 language: "en"
 status: "published"
@@ -11,7 +11,7 @@ area: "dev"
 
 # Release Workflow
 
-Branch-based release workflow for Regardio packages. `main` → `staging` → `production`. Changesets carry the version bumps; quality gates run locally before any branch promotion. Nothing broken reaches a shared branch.
+Branch-based release workflow for Regardio packages. `main` → `staging` → `production`. `commit-and-tag-version` reads conventional commits to determine the version bump; quality gates run locally before any branch promotion. Nothing broken reaches a shared branch.
 
 ## Overview
 
@@ -21,119 +21,111 @@ Branches mirror deployment environments:
 main → staging (optional) → production
 ```
 
-- **`main`** — active development, always deployable. Authors add a changeset (`pnpm changeset`) alongside each version-worthy change.
+- **`main`** — active development, always deployable. Version bumps happen at ship time, not per-commit.
 - **`staging`** — optional validation environment. No versioning happens here.
 - **`production`** — versioned, published code only.
 
-Changesets decide what bumps. When `ship-production` runs, it consumes every pending changeset, bumps affected packages, rewrites each package's `CHANGELOG.md`, and commits the result on `main` before merging to `production`. CI on `production` runs `changeset publish` to push the new versions to npm.
+When `ship-production` runs, it discovers all publishable workspace packages and asks you to assign a bump type — `skip`, `patch`, `minor`, or `major` — to each one individually. Packages you skip are left untouched. For each package with a bump, it calls `pnpm --filter <package> release:<type>`, which bumps that package's version, rewrites its `CHANGELOG.md` using commits since its last scoped tag, and commits on `main`. The branches merge once after all bumps are applied. CI on `production` publishes only the packages whose version changed.
 
 ## How It Works
 
 ### Design principles
 
 1. **Branches mirror environments.** `staging` reflects what is deployed to the staging server (when used); `production` always reflects what is published to npm. There is never ambiguity about what is running where.
-2. **Changesets drive versioning.** A bump is declared in a `.changeset/*.md` file alongside the code change, not chosen at ship time. Every published version corresponds to a set of consumed changesets.
-3. **Version numbers are a production guarantee.** Bumps are applied only at `ship-production` time. This means every version tag in git and every release on npm corresponds to code that has been validated and shipped.
-4. **Staging is optional.** You can ship directly from `main` to `production`. Use `ship-staging` when you want to test changes in a staging environment first. Either way, `staging` is automatically synced with `production` after each ship.
-5. **Tests are a local gate, not a CI gate.** Quality checks (`build`, `typecheck`, `test`) run on your machine before any commit is made. Broken code cannot enter the repository. CI only runs `build` and `publish`.
+2. **You choose the bump per package at ship time.** When running `ship-production` or `ship-hotfix finish`, every publishable package is listed and you assign it `skip`, `patch`, `minor`, or `major`. Packages you skip are untouched. The conventional commits in the log inform each choice; the decisions are always explicit.
+3. **Version numbers are a production guarantee.** Bumps are applied only at `ship-production` time. Every version tag in git and every release on npm corresponds to code that has been validated and shipped.
+4. **Staging is optional.** You can ship directly from `main` to `production`. Use `ship-staging` when you want to test changes in a staging environment first.
+5. **Tests are a local gate, not a CI gate.** Quality checks (`build`, `typecheck`, `test`) run on your machine before any commit is made. Broken code cannot enter the repository.
 6. **You always land back on `main`.** Every command returns you to `main` when it finishes.
 
 ### Full flow diagram
 
 ```text
-                    pnpm changeset           (on main, alongside your change)
-                    ┌──────────────────────────┐
-                    │ write .changeset/<x>.md  │
-main ───────────────┤ commit + push            ├──► main
-                    └──────────────────────────┘
-                                │
-                    ship-staging (OPTIONAL)
-                    ┌──────────────────────────┐
-main ───────────────┤ quality checks pass      ├──► staging (pushed)
-                    │ ff-merge main → staging  │
-                    └──────────────────────────┘
-                                │
-                           (validated in staging)
-                                │
-                                ▼
-                    ship-production
-                    ┌──────────────────────────┐
-                    │ quality checks on main   │
-                    │ pnpm changeset version   │
-main ───────────────┤ bumps + CHANGELOG.md     ├──► production
-                    │ chore(release): ...      │
-                    │ ff-merge main → prod     │
-                    │ ff-merge prod → staging  │
-                    │ sync back to main        │
-                    └──────────────────────────┘
-                                │
-                           (CI: pnpm changeset publish → npm + git tags)
-                                ▼
-                           production
-
-
-                    ship-hotfix start fix-name
-                    ┌──────────────────────────┐
-production ─────────┤ create hotfix/fix-name   ├──► hotfix/fix-name
-                    └──────────────────────────┘
-                                │
-                       (author fixes + pnpm changeset)
-                                │
-                    ship-hotfix finish
-                    ┌──────────────────────────┐
-                    │ quality checks           │
-                    │ pnpm changeset version   │
-hotfix/fix-name ────┤ bumps + CHANGELOG.md     ├──► production → staging → main
-                    │ merge to production      │
-                    │ propagate to staging     │
-                    │ propagate to main        │
-                    └──────────────────────────┘
+                ship-staging (OPTIONAL)
+                ┌──────────────────────────┐
+main ───────────┤ quality checks pass      ├──► staging (pushed)
+                │ ff-merge main → staging  │
+                └──────────────────────────┘
+                            │
+                   (validated in staging)
+                            │
+                            ▼
+                ship-production
+                ┌──────────────────────────┐
+                │ quality checks on main   │
+                │ pnpm release             │
+main ───────────┤ bumps version +          ├──► production
+                │ rewrites CHANGELOG.md    │
+                │ ff-merge main → prod     │
+                │ ff-merge prod → staging  │
+                │ push --follow-tags main  │
+                └──────────────────────────┘
+                            │
+                   (CI: pnpm -r publish → npm)
+                            ▼
+                       production
+
+
+                ship-hotfix start fix-name
+                ┌──────────────────────────┐
+production ─────┤ create hotfix/fix-name   ├──► hotfix/fix-name
+                └──────────────────────────┘
+                            │
+                   (author fixes with conventional commits)
+                            │
+                ship-hotfix finish
+                ┌──────────────────────────┐
+                │ quality checks           │
+                │ pnpm release             │
+hotfix/fix-name ┤ bumps version +          ├──► production → staging → main
+                │ rewrites CHANGELOG.md    │
+                │ merge to production      │
+                │ propagate to staging     │
+                │ propagate to main        │
+                └──────────────────────────┘
 ```
 
 ### What each branch represents at any point in time
 
 | Branch | Contains | Version bumped? |
 |--------|----------|-----------------|
-| `main` | All committed, tested work + pending `.changeset/*.md` files | Only after `ship-production` / `ship-hotfix finish` |
+| `main` | All committed, tested work | Only after `ship-production` / `ship-hotfix finish` |
 | `staging` | Synced from `production` after each ship, or from `main` via `ship-staging` | After a ship propagates |
 | `production` | Only shipped, versioned releases | Yes — always |
 
 ### CI role
 
-CI is intentionally minimal. It does not re-run tests. On push to `production` it:
+CI is intentionally minimal. On push to `production` it:
 
 1. Installs dependencies and builds
-2. Runs `pnpm changeset publish` — publishes every workspace package whose current version is not yet on npm, skipping `private: true` packages, and creates git tags per published package
-3. Pushes the tags
+2. Runs `pnpm -r publish --access public --no-git-checks` — publishes every workspace package whose current version is not yet on npm, skipping `private: true` packages
+3. Tags are already present (pushed by `ship-production` via `--follow-tags`)
 
 ## Commands
 
 | Command | Usage | Purpose |
 |---------|-------|---------|
-| `pnpm changeset` | interactive | Declare a version bump alongside your change |
+| `pnpm release` | auto | Bump version from conventional commits, update CHANGELOG.md, commit |
+| `pnpm release:patch` | explicit | Force a patch bump |
+| `pnpm release:minor` | explicit | Force a minor bump |
+| `pnpm release:major` | explicit | Force a major bump |
 | `ship-staging` | `ship-staging` | (Optional) Deploy changes to staging for testing |
-| `ship-production` | `ship-production` | Consume changesets, merge main → production, trigger publish |
+| `ship-production` | `ship-production` | Bump version, merge main → production, trigger publish |
 | `ship-hotfix start <name>` | `ship-hotfix start <name>` | Create a hotfix branch from production |
-| `ship-hotfix finish` | `ship-hotfix finish` | Consume changesets, propagate hotfix through production → staging → main |
-
-Bump types (`patch` / `minor` / `major`) are no longer passed on the command line — they come from the changeset files.
+| `ship-hotfix finish` | `ship-hotfix finish` | Bump version, propagate hotfix through production → staging → main |
 
 ## Typical Release Flow
 
-### 1. Author a change with a changeset
+### 1. Develop with conventional commits
 
-On `main`:
+On `main`, use conventional commits so the bump type is inferred automatically:
 
 ```bash
-# make your code change
-pnpm changeset          # choose packages, bump type, write a one-line description
-git add .
-git commit -m "feat: ..."
-git push
+feat: add user authentication       # → minor bump
+fix: resolve login redirect loop    # → patch bump
+feat!: redesign authentication API  # → major bump
 ```
 
-A file like `.changeset/lively-otters-hop.md` is committed with the change.
-
 ### 2. Ship to production
 
 ```bash
@@ -144,16 +136,17 @@ This will:
 
 1. Guard: must be on `main`, working tree clean
 2. Fetch and verify `staging` + `production` branches exist
-3. Show commits to be shipped, report pending changeset count, ask for confirmation
-4. Run full quality suite on `main` — aborts on failure
-5. Run `pnpm changeset version` — bumps versions, rewrites `CHANGELOG.md` per package, deletes consumed changeset files
-6. Format modified files
-7. Commit with `chore(release): version packages` on `main`
+3. Show commits to be shipped
+4. For each publishable package: choose `skip / patch / minor / major`
+5. Confirm the planned bumps — abort if declined or all skipped
+6. Run full quality suite on `main` — aborts on failure
+7. For each non-skipped package: run `pnpm --filter <pkg> release:<type>` — bumps version, rewrites `CHANGELOG.md`, commits
 8. Fast-forward merge `main` into `production` and push
 9. Sync `staging` with `production`
-10. Return to `main`
+10. Push `main` with `--follow-tags` to push all new version tags
+11. Return to `main`
 
-CI on `production` runs `pnpm changeset publish` to push the new versions to npm and create tags.
+CI on `production` runs `pnpm -r publish` to push changed packages to npm.
 
 ### Option: Test in staging first
 
@@ -169,32 +162,26 @@ For urgent fixes that must go directly to production:
 
 ```bash
 pnpm ship:hotfix start fix-auth-bug
-# apply your fix
-pnpm changeset          # describe the fix and the bump
+# apply your fix with conventional commits
 git add . && git commit -m "fix: ..."
 pnpm ship:hotfix finish
 ```
 
-`finish` consumes the pending changeset, bumps the version, then merges `hotfix → production → staging → main` and deletes the hotfix branch. CI publishes from `production`.
+`finish` asks you to assign a bump type (`skip`, `patch`, `minor`, or `major`) to each publishable package, runs `pnpm --filter <pkg> release:<type>` for each non-skipped one to bump versions and update `CHANGELOG.md`, then merges `hotfix → production → staging → main` and deletes the hotfix branch. CI publishes from `production`.
 
 ## Adoption
 
 Install `@regardio/dev` and:
 
-1. **Initialize Changesets** — copy the template:
-
-   ```bash
-   cp -r node_modules/@regardio/dev/templates/changeset .changeset
-   ```
-
-2. **Add the scripts to `package.json`**:
+1. **Add the scripts to `package.json`**:
 
    ```json
    {
      "scripts": {
-       "changeset": "changeset",
-       "changeset:publish": "changeset publish",
-       "changeset:version": "changeset version",
+       "release": "commit-and-tag-version",
+       "release:major": "commit-and-tag-version --release-as major",
+       "release:minor": "commit-and-tag-version --release-as minor",
+       "release:patch": "commit-and-tag-version --release-as patch",
        "ship:hotfix": "ship-hotfix",
        "ship:production": "ship-production",
        "ship:staging": "ship-staging"
@@ -202,6 +189,15 @@ Install `@regardio/dev` and:
    }
    ```
 
+2. **Add a `.versionrc.json` to each publishable package** with a scoped `tagPrefix` so tags and changelogs stay isolated per package:
+
+   ```bash
+   cp node_modules/@regardio/dev/templates/versionrc/.versionrc.json packages/my-pkg/.versionrc.json
+   # then set "tagPrefix": "@my-scope/my-pkg@v" inside that file
+   ```
+
+   For a single-package repo, put `.versionrc.json` at the root instead.
+
 3. **Create the branches**:
 
    ```bash
@@ -210,7 +206,7 @@ Install `@regardio/dev` and:
    git checkout main
    ```
 
-4. **Copy the release workflow** for your forge. A GitHub Actions template ships with `@regardio/dev`; Forgejo Actions accepts the same workflow syntax with minimal changes.
+4. **Copy the release workflow** for your forge:
 
    ```bash
    # GitHub
@@ -222,8 +218,6 @@ Install `@regardio/dev` and:
    cp node_modules/@regardio/dev/templates/github/release.yml .forgejo/workflows/release.yml
    ```
 
-   For other CI systems, treat the template as a reference: the workflow installs dependencies, builds, runs `pnpm changeset publish`, and pushes tags on every push to `production`.
-
 5. **First publish of any new package must be done locally**:
 
    ```bash
@@ -242,57 +236,7 @@ pnpm test       # Must succeed
 
 ## Private Packages
 
-Packages that should never be published to npm must set `"private": true` in `package.json`. `changeset publish` skips them automatically. The git flow (`ship-staging`, `ship-production`, `ship-hotfix`) works identically for private packages — changesets, version bumps, and branch promotion all continue as normal; only the npm publish step is skipped.
-
-## Workspace-Level Automation
-
-The meta-workspace (`workspace/`) provides scripts that operate across all repos at once. Run these from the `workspace/` directory.
-
-### Daily maintenance: safe-upgrade-and-ship
-
-After a dependency upgrade cycle, ship everything to staging in one command:
-
-```bash
-cd workspace
-pnpm safe-upgrade-and-ship
-```
-
-What it does:
-
-1. Runs `pnpm safe-upgrade` — upgrades all dependencies, runs build + lint + test + typecheck across the full workspace. Aborts if anything fails.
-2. For every repo (workspace itself, commons, ensemble, system, channels/*): checks `git status`.
-3. If only `package.json` and/or `pnpm-lock.yaml` changed: commits with `chore: upgrade dependencies`, pushes `main` to origin, fast-forward merges `main → staging`, pushes `staging`, returns to `main`.
-4. If unexpected files are uncommitted: skips that repo and reports it.
-
-No further interaction needed — husky pre-commit hooks run on the commit step, and the full quality suite already passed in step 1.
-
-### Selective staging ship
-
-If changes are already committed and ready:
-
-```bash
-cd workspace
-pnpm ship:staging
-```
-
-Delegates to each repo's `ship:staging` (which re-runs quality checks per repo). Workspace itself is handled directly to avoid recursion.
-
-### Production ship
-
-```bash
-cd workspace
-pnpm ship:production
-```
-
-Calls each sub-repo's `ship:production` in sequence, then promotes workspace itself (`main → production → staging`). For repos with Changesets (commons), this triggers the full version-bump flow. For app repos without Changesets (ensemble, system, channels), it promotes the branch without versioning.
-
-### When to use each command
-
-| Command | When |
-|---------|------|
-| `pnpm safe-upgrade-and-ship` | Daily/weekly dependency maintenance — upgrade all, verify all, ship all to staging |
-| `pnpm ship:staging` | Changes are already committed; just push everything to staging |
-| `pnpm ship:production` | Ready to go to production across all repos |
+Packages that should never be published to npm must set `"private": true` in `package.json`. `pnpm -r publish` skips them automatically. The git flow (`ship-staging`, `ship-production`, `ship-hotfix`) works identically — version bumps and branch promotion continue as normal; only the npm publish step is skipped.
 
 ## Related
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "@regardio/dev",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "private": false,
   "description": "Regardio development presets: biome, typescript, commitlint, markdownlint, vitest, playwright, sqlfluff, husky, and GitLab-flow ship tooling",
   "keywords": [
@@ -66,7 +66,8 @@
     "src/markdownlint",
     "src/typescript",
     "docs",
-    "templates"
+    "templates",
+    "pnpm-lock.yaml"
   ],
   "devDependencies": {
     "@total-typescript/ts-reset": "0.6.1",
@@ -77,13 +78,12 @@
   },
   "peerDependencies": {
     "@biomejs/biome": ">=2",
-    "@changesets/changelog-git": ">=0.2",
-    "@changesets/cli": ">=2",
     "@commitlint/cli": ">=20",
     "@commitlint/config-conventional": ">=20",
     "@playwright/test": ">=1",
     "@testing-library/jest-dom": ">=6",
     "@testing-library/react": ">=16",
+    "commit-and-tag-version": ">=12",
     "husky": ">=9",
     "jsdom": ">=29",
     "markdownlint-cli2": ">=0.22",
@@ -98,6 +98,10 @@
     "clean": "rimraf .turbo dist",
     "dev": "tsdown --watch",
     "fix": "run-s fix:pkg fix:md fix:biome",
+    "release": "commit-and-tag-version",
+    "release:major": "commit-and-tag-version --release-as major",
+    "release:minor": "commit-and-tag-version --release-as minor",
+    "release:patch": "commit-and-tag-version --release-as patch",
     "fix:biome": "biome check --write --unsafe .",
     "fix:md": "markdownlint-cli2 --config ../../.markdownlint-cli2.jsonc --fix",
     "fix:pkg": "sort-package-json",

package/templates/github/release.yml

@@ -2,14 +2,15 @@
 # Copy this file to .github/workflows/release.yml
 #
 # Required setup:
-# 1. Initialize Changesets in your repo:
-#      cp -r node_modules/@regardio/dev/templates/changeset .changeset
-# 2. Add these scripts to package.json:
-#      "changeset": "changeset",
-#      "changeset:publish": "changeset publish",
+# 1. Add these scripts to package.json:
+#      "release": "commit-and-tag-version",
+#      "release:major": "commit-and-tag-version --release-as major",
+#      "release:minor": "commit-and-tag-version --release-as minor",
+#      "release:patch": "commit-and-tag-version --release-as patch",
 #      "ship:staging": "ship-staging",
 #      "ship:production": "ship-production",
 #      "ship:hotfix": "ship-hotfix"
+# 2. Copy .versionrc.json from node_modules/@regardio/dev/templates/versionrc/.versionrc.json
 # 3. Create the branches:
 #      git checkout -b staging && git push -u origin staging
 #      git checkout -b production && git push -u origin production
@@ -17,10 +18,9 @@
 #    must be done locally (`npm publish --access public`).
 #
 # Usage:
-# - Author adds a changeset on main: `pnpm changeset`
-# - `pnpm ship:staging` deploys to staging for validation
-# - `pnpm ship:production` consumes changesets locally, bumps versions, merges
-#   to production. This workflow then publishes to npm.
+# - `pnpm ship:staging` deploys to staging for validation (optional)
+# - `pnpm ship:production` runs commit-and-tag-version locally, bumps the version,
+#   merges to production. This workflow then publishes to npm.
 
 name: Release
 
@@ -62,16 +62,7 @@ jobs:
         run: pnpm -r build
 
       - name: Publish changed public packages
-        # `changeset publish`:
-        #   - walks the workspace topologically
-        #   - replaces `workspace:*` with real versions
-        #   - skips packages where the current version already exists on npm
-        #   - skips packages marked `"private": true`
-        #   - creates git tags like `@scope/pkg@1.2.3` for each published package
-        run: pnpm changeset publish
+        run: pnpm -r publish --access public --no-git-checks
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
           NPM_CONFIG_PROVENANCE: "true"
-
-      - name: Push tags
-        run: git push --tags

package/templates/versionrc/.versionrc.json

@@ -0,0 +1,16 @@
+{
+  "commitAll": false,
+  "sign": false,
+  "tagPrefix": "v",
+  "types": [
+    { "section": "Features", "type": "feat" },
+    { "section": "Bug Fixes", "type": "fix" },
+    { "section": "Performance", "type": "perf" },
+    { "section": "Refactoring", "type": "refactor" },
+    { "hidden": false, "section": "Chores", "type": "chore" },
+    { "hidden": true, "type": "docs" },
+    { "hidden": true, "type": "style" },
+    { "hidden": true, "type": "test" },
+    { "hidden": true, "type": "ci" }
+  ]
+}

package/dist/bin/ship/utils-BQ-JZ2D5.mjs

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-import { execFileSync, execSync } from "node:child_process";
-import { closeSync, openSync, readSync } from "node:fs";
-//#region src/bin/ship/utils.ts
-/**
-* Shared utilities for ship-staging, ship-production, and ship-hotfix.
-*
-* Git commands use execFileSync (not a shell string) so user-provided
-* strings such as commit messages are never interpolated by the shell.
-* pnpm script invocations use execSync via shell since script names are
-* developer-controlled and pnpm itself is resolved through PATH.
-*/
-const git = (...args) => {
-	console.log(`$ git ${args.join(" ")}`);
-	execFileSync("git", args, { stdio: "inherit" });
-};
-const gitRead = (...args) => execFileSync("git", args, { encoding: "utf-8" }).trim();
-const runScript = (script) => {
-	console.log(`$ pnpm ${script}`);
-	execSync(`pnpm ${script}`, { stdio: "inherit" });
-};
-const runQualityChecks = () => {
-	runScript("build");
-	runScript("typecheck");
-	runScript("test");
-};
-const branchExists = (name) => gitRead("branch", "--list", name) !== "" || gitRead("branch", "--list", "--remotes", `origin/${name}`) !== "";
-const confirm = (prompt, ttyPath = "/dev/tty") => {
-	process.stdout.write(`${prompt} (y/N) `);
-	const buf = Buffer.alloc(1024);
-	let fd;
-	let shouldClose = false;
-	try {
-		fd = openSync(ttyPath, "r");
-		shouldClose = true;
-	} catch {
-		fd = process.stdin.fd;
-	}
-	const bytesRead = readSync(fd, buf, 0, buf.length, null);
-	if (shouldClose) closeSync(fd);
-	const answer = buf.slice(0, bytesRead).toString().trim();
-	return answer === "y" || answer === "Y";
-};
-//#endregion
-export { runQualityChecks as a, gitRead as i, confirm as n, runScript as o, git as r, branchExists as t };

package/templates/changeset/README.md

@@ -1,14 +0,0 @@
-# Changesets
-
-Pending version bumps live here as small Markdown files. Add one with `pnpm changeset` whenever you make a version-worthy change.
-
-## How it fits the GitLab flow
-
-- On `main`, authors run `pnpm changeset` alongside their change to describe the bump.
-- `ship-staging` deploys to staging without touching versions.
-- `ship-production` runs quality checks, consumes pending changesets (bumping versions and updating each package's `CHANGELOG.md`), commits the bumps on `main`, and merges to `production`.
-- CI on `production` runs `changeset publish` to push the new versions to npm.
-
-## Skipping a release
-
-If a commit is tooling-only and should not trigger a release, don't add a changeset.

package/templates/changeset/config.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@changesets/config@3.1.4/schema.json",
-  "access": "public",
-  "baseBranch": "main",
-  "changelog": "@changesets/changelog-git",
-  "commit": false,
-  "fixed": [],
-  "ignore": [],
-  "linked": [],
-  "updateInternalDependencies": "patch"
-}