@christang/keel 5.1.2 → 5.2.1

package/bin/keel.js

@@ -47,7 +47,7 @@ const {
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
 const PACKAGE_JSON = require(path.join(PACKAGE_ROOT, "package.json"));
 const INSTALL_SCRIPT = path.join(PACKAGE_ROOT, "scripts", "install_to_repo.py");
-const DEFAULT_UPDATE_SOURCE = "github:TanglmChris/keel";
+const DEFAULT_UPDATE_SOURCE = "@christang/keel";
 const VALID_TARGETS = new Set(["claude", "codex", "opencode", "both"]);
 const KEEL_SKILLS = [
   "keel-align-expectations",
@@ -56,11 +56,6 @@ const KEEL_SKILLS = [
   "keel-review-checklist",
   "keel-tdd-or-test-first",
 ];
-const ALIGNMENT_REFERENCES = [
-  "references/web.md",
-  "references/hardware.md",
-  "references/hardware-dsl.md",
-];
 const OPENSPEC_COMMAND_IDS = ["propose", "explore", "apply", "sync", "archive"];
 const OPENSPEC_SKILLS = [
   "openspec-propose",
@@ -86,6 +81,8 @@ Usage:
   keel project tasks [repo] --target claude [--change name] [--json]
   keel gate task-start|task-complete|change-close [repo] [--change name] [--task id] [--action sync|archive] [--base git-ref] [--no-guard] [--record] [--json]
   keel guard start|status|clear [repo] [--change name] [--task id] [--force] [--json]
+  keel lenses list|add [name] [repo] [--force]
+  keel openspec [args...]
   keel --init [repo] [--target claude|codex|opencode] [--dry-run] [--force-template-update]
   keel --install [repo] [--target claude|codex|opencode] [--dry-run] [--force-template-update]
   keel --clear [repo] [--target claude|codex|opencode] [--dry-run]
@@ -105,9 +102,7 @@ Defaults:
 Project layout:
   continuity is recomputed from OpenSpec on every invocation.
   keel/HANDOFF.md is an optional keel-handoff/v1 pointer override.
-  Claude skills are installed under .claude/skills/keel-*.
-  Codex skills are installed under .agents/skills/keel-*.
-  OpenCode skills are installed under .opencode/skills/keel-*.
+  keel-* behavioral skills are delivered by the installed Keel plugin, not by the CLI.
   repeat keel --install to refresh project protocol files.
 
 Examples:
@@ -121,6 +116,9 @@ Examples:
   keel guard start --change my-change --task 1.1 --json
   keel guard status --json
   keel guard clear --json
+  keel lenses list
+  keel lenses add web
+  keel lenses add web --force
   keel --init
   keel --install
   keel --install --target codex
@@ -169,6 +167,9 @@ function parseArgs(argv) {
     noGuard: false,
     record: false,
     guardSubcommand: null,
+    lensesSubcommand: null,
+    lensName: null,
+    openspecArgs: [],
     force: false,
     projectionEvent: null,
     authorizations: [],
@@ -207,6 +208,15 @@ function parseArgs(argv) {
       parsed.action = "guard";
       continue;
     }
+    if (arg === "lenses" && parsed.action === null && parsed.repo === null) {
+      parsed.action = "lenses";
+      continue;
+    }
+    if (arg === "openspec" && parsed.action === null && parsed.repo === null) {
+      parsed.action = "openspec";
+      parsed.openspecArgs = argv.slice(index + 1);
+      break;
+    }
     if (arg === "--force") {
       parsed.force = true;
       continue;
@@ -368,8 +378,8 @@ function parseArgs(argv) {
     if (arg === "--profile" || arg.startsWith("--profile=")) {
       fail(
         "--profile is no longer supported: web, hardware, and hardware-dsl "
-          + "guidance is bundled with the keel-align-expectations skill as "
-          + "on-demand references"
+          + "guidance is now user-authored lenses in keel/lenses/*.md "
+          + "(scaffold with `keel lenses add`)"
       );
     }
     if (arg === "--repo") {
@@ -423,6 +433,18 @@ function parseArgs(argv) {
       parsed.projectSubcommand = arg;
       continue;
     }
+    if (parsed.action === "lenses" && parsed.lensesSubcommand === null) {
+      parsed.lensesSubcommand = arg;
+      continue;
+    }
+    if (
+      parsed.action === "lenses"
+      && parsed.lensesSubcommand === "add"
+      && parsed.lensName === null
+    ) {
+      parsed.lensName = arg;
+      continue;
+    }
     if (parsed.repo !== null) {
       fail("repo path was provided more than once");
     }
@@ -486,8 +508,25 @@ function parseArgs(argv) {
   if (parsed.action !== "guard" && parsed.guardSubcommand !== null) {
     fail("guard subcommands apply only to keel guard");
   }
-  if (parsed.force && parsed.action !== "guard") {
-    fail("--force applies only to keel guard start");
+  if (
+    parsed.force
+    && parsed.action !== "guard"
+    && !(parsed.action === "lenses" && parsed.lensesSubcommand === "add")
+  ) {
+    fail("--force applies only to keel guard start or keel lenses add");
+  }
+  if (parsed.action === "lenses") {
+    if (!["list", "add"].includes(parsed.lensesSubcommand || "")) {
+      fail("lenses requires list or add");
+    }
+    if (parsed.lensesSubcommand === "add" && !parsed.lensName) {
+      fail("keel lenses add requires a lens name");
+    }
+    if (parsed.lensesSubcommand === "list" && parsed.lensName) {
+      fail("keel lenses list does not take a lens name");
+    }
+  } else if (parsed.lensesSubcommand !== null || parsed.lensName !== null) {
+    fail("lens subcommands apply only to keel lenses");
   }
   if (parsed.noGuard && parsed.action !== "gate") {
     fail("--no-guard applies only to keel gate task-start");
@@ -983,6 +1022,7 @@ function keelOpenSpecOverlay(action) {
           "- The current agent reviews all subagent output, command evidence, and diffs before marking any task complete.",
           "- When implementation exposes a material expectation, acceptance boundary, or user-owned decision absent from durable authority, stop before implementing that choice, rerun `keel-align-expectations`, and reauthor the affected proposal/design/spec/task authority first.",
           "- A discovered repository fact that does not change accepted behavior or scope may be recorded and execution continues inside the existing task boundary without a product interview.",
+          "- Invoke OpenSpec through `keel openspec` (for example `keel openspec validate`); a bare `openspec` command may not be on PATH.",
         ]
       : [
           "- The current agent owns final sync/archive decisions and must verify task evidence, follow-up ownership, and completion gates before proceeding.",
@@ -990,6 +1030,9 @@ function keelOpenSpecOverlay(action) {
           "- Target-native subagents may help with bounded assessment or evidence production only; they cannot archive, sync, change acceptance, or bypass completion gates.",
           "- The current agent reviews any subagent report before running `openspec-sync-specs`, `/opsx:sync`, or `/opsx:archive`.",
           "- Do not treat generic OpenSpec archive delegation language as authority to transfer Keel ownership.",
+          "- Invoke OpenSpec through `keel openspec` (for example `keel openspec validate`); a bare `openspec` command may not be on PATH.",
+          "- When `/opsx:sync` has already promoted the change's spec delta, run the archive with `--skip-specs` so the promoted delta is not re-applied; archive is not idempotent over an already-synced delta.",
+          "- After archiving, run `keel guard clear` to drop the change's guard manifest; the read-only gate never clears it for you.",
         ];
 
   const lines = [
@@ -1174,6 +1217,12 @@ function printTargetSurface(repo, target) {
     formatCount(openspecSkillCounts, openspecSkillRoot)
   );
 
+  printDoctorLine(
+    "Keel behavioral skills",
+    "plugin",
+    "keel-* skills are delivered by the installed Keel plugin (see native plugin status above); install the plugin if it is missing"
+  );
+
   const commands = commandSurfaceForTarget(target, repo);
   const commandCounts = countExisting(commands.paths);
   const commandDetail =
@@ -1226,11 +1275,27 @@ function runDoctor(options) {
   );
 
   const openspec = findOpenSpecCommand();
-  printDoctorLine(
-    "openspec",
-    openspec ? "ok" : "missing",
-    openspec || "reinstall keel so npm installs its OpenSpec dependency"
-  );
+  if (!openspec) {
+    printDoctorLine(
+      "openspec",
+      "missing",
+      "reinstall keel so npm installs its OpenSpec dependency"
+    );
+  } else {
+    const bareOpenSpecOnPath =
+      !path.isAbsolute(openspec)
+      || runCommand("openspec", ["--version"], {
+        stdio: "ignore",
+        silentNotFound: true,
+      }) === 0;
+    printDoctorLine(
+      "openspec",
+      bareOpenSpecOnPath ? "ok" : "warning",
+      bareOpenSpecOnPath
+        ? openspec
+        : `${openspec} is keel-resolvable but bare \`openspec\` is not on PATH — use \`keel openspec\``
+    );
+  }
 
   process.stdout.write("\nProject status:\n");
   const checkStatus = runPython(
@@ -1257,15 +1322,142 @@ function runDoctor(options) {
   }
 
   printTargetSurface(repo, options.target);
+  printLensSurface(repo, options.target);
 
   return checkStatus;
 }
 
+const SHIPPED_LENS_DIR = path.join(PACKAGE_ROOT, "assets", "lenses");
+const EXPECTED_LENS_TEMPLATES = ["web", "hardware", "hardware-dsl"];
+
+function targetSkillsDir(repo, target) {
+  if (target === "codex") return path.join(repo, ".agents", "skills");
+  if (target === "opencode") return path.join(repo, ".opencode", "skills");
+  return path.join(repo, ".claude", "skills");
+}
+
+function legacyProfileSkills(repo, target) {
+  try {
+    return fs
+      .readdirSync(targetSkillsDir(repo, target), { withFileTypes: true })
+      .filter(
+        (entry) => entry.isDirectory() && /^keel-profile-/.test(entry.name)
+      )
+      .map((entry) => entry.name)
+      .sort();
+  } catch (error) {
+    return [];
+  }
+}
+
+function printLensSurface(repo, target) {
+  process.stdout.write("\nDomain lens surface:\n");
+  const shipped = lensNames(SHIPPED_LENS_DIR);
+  const missing = EXPECTED_LENS_TEMPLATES.filter(
+    (name) => !shipped.includes(name)
+  );
+  printDoctorLine(
+    "lens templates",
+    missing.length === 0 ? "ok" : "incomplete",
+    missing.length === 0
+      ? `shipped: ${EXPECTED_LENS_TEMPLATES.join(", ")}; scaffold with keel lenses add`
+      : `missing template(s): ${missing.join(", ")}`
+  );
+  const installed = lensNames(path.join(repo, "keel", "lenses"));
+  printDoctorLine(
+    "installed lenses",
+    installed.length > 0 ? "ok" : "none",
+    installed.length > 0
+      ? `keel/lenses/: ${installed.join(", ")}`
+      : "no user lenses yet; keel lenses add scaffolds one"
+  );
+  const legacy = legacyProfileSkills(repo, target);
+  if (legacy.length > 0) {
+    printDoctorLine(
+      "legacy profiles",
+      "migrate",
+      `found ${legacy.join(", ")}; v3 keel-profile-* skills are replaced by `
+        + "pluggable lenses (keel lenses add). Left untouched; not active state."
+    );
+  }
+}
+
+function lensNames(dir) {
+  try {
+    return fs
+      .readdirSync(dir)
+      .filter((name) => name.endsWith(".md"))
+      .map((name) => name.slice(0, -3))
+      .sort();
+  } catch (error) {
+    return [];
+  }
+}
+
+function runLensesList(repo) {
+  const shipped = lensNames(SHIPPED_LENS_DIR);
+  const installed = lensNames(path.join(repo, "keel", "lenses"));
+  process.stdout.write("Shipped lens templates (assets/lenses/):\n");
+  if (shipped.length === 0) {
+    process.stdout.write("  (none)\n");
+  } else {
+    for (const name of shipped) {
+      const mark = installed.includes(name) ? " (installed)" : "";
+      process.stdout.write(`  ${name}${mark}\n`);
+    }
+  }
+  process.stdout.write("\nInstalled lenses (keel/lenses/):\n");
+  if (installed.length === 0) {
+    process.stdout.write("  (none) — run keel lenses add <name>\n");
+  } else {
+    for (const name of installed) {
+      const mark = shipped.includes(name) ? "" : " (custom)";
+      process.stdout.write(`  ${name}${mark}\n`);
+    }
+  }
+  return 0;
+}
+
+function runLensesAdd(repo, name, force) {
+  const source = path.join(SHIPPED_LENS_DIR, `${name}.md`);
+  if (!fs.existsSync(source)) {
+    const available = lensNames(SHIPPED_LENS_DIR).join(", ") || "(none)";
+    fail(`unknown lens template: ${name}; shipped templates: ${available}`);
+  }
+  const destDir = path.join(repo, "keel", "lenses");
+  const dest = path.join(destDir, `${name}.md`);
+  if (fs.existsSync(dest) && !force) {
+    process.stderr.write(
+      `keel: keel/lenses/${name}.md already exists; pass --force to overwrite\n`
+    );
+    return 3;
+  }
+  fs.mkdirSync(destDir, { recursive: true });
+  fs.copyFileSync(source, dest);
+  process.stdout.write(
+    `keel: wrote keel/lenses/${name}.md from the ${name} template; `
+      + "edit it to fit this repository\n"
+  );
+  return 0;
+}
+
 function runAction(options) {
   if (options.updateSource !== null && options.action !== "update") {
     fail("--source only applies to --update");
   }
 
+  if (options.action === "openspec") {
+    const openspec = findOpenSpecCommand();
+    if (!openspec) {
+      process.stderr.write(
+        "keel: openspec is not resolvable; reinstall keel so npm installs "
+          + "its OpenSpec dependency\n"
+      );
+      return 1;
+    }
+    return runCommand(openspec, options.openspecArgs, { stdio: "inherit" });
+  }
+
   if (options.action === "context") {
     if (options.dryRun || options.forceTemplateUpdate || options.updateSource) {
       fail("context does not accept install or update options");
@@ -1351,6 +1543,17 @@ function runAction(options) {
       : 3;
   }
 
+  if (options.action === "lenses") {
+    if (options.dryRun || options.forceTemplateUpdate || options.updateSource) {
+      fail("lenses does not accept install or update options");
+    }
+    const repo = path.resolve(options.repo || process.cwd());
+    if (options.lensesSubcommand === "list") {
+      return runLensesList(repo);
+    }
+    return runLensesAdd(repo, options.lensName, options.force);
+  }
+
   if (options.action === "capabilities") {
     if (options.dryRun || options.forceTemplateUpdate || options.updateSource) {
       fail("capabilities does not accept install or update options");

package/package.json

@@ -2,7 +2,7 @@
   "name": "@christang/keel",
   "displayName": "Keel",
   "description": "Keel OpenSpec execution discipline CLI for Claude Code, Codex, and OpenCode.",
-  "version": "5.1.2",
+  "version": "5.2.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/plugins/keel/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.1.2",
+  "version": "5.2.1",
   "description": "Keel OpenSpec execution discipline: stateless continuity, task capsules, deterministic gates, and expectation alignment for Codex and Claude Code.",
   "author": {
     "name": "TanglmChris",

package/plugins/keel/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.1.2",
+  "version": "5.2.1",
   "description": "Keel OpenSpec execution discipline: stateless continuity, task capsules, deterministic gates, and expectation alignment for Codex and Claude Code.",
   "author": {
     "name": "TanglmChris",

package/plugins/keel/skills/keel-align-expectations/SKILL.md

@@ -40,13 +40,9 @@ Accepted alignment routes to existing OpenSpec owners; create no separate alignm
 - specs own observable requirements and positive/negative/edge/failure scenarios.
 - tasks.md owns Covers, verification strategy and checks, scope, and stop boundaries that reference the accepted authority instead of duplicating chat prose.
 
-## Domain references
+## Domain lenses
 
-When the change touches a specific domain, read only the applicable reference before asking domain questions; do not load the others:
-
-- references/web.md for UI, API, routing, auth/session, persistence, or backend integration work.
-- references/hardware.md for Verilog/SystemVerilog interface, protocol, reset, or verification work.
-- references/hardware-dsl.md for hardware modeling DSL, generated RTL, or golden/equivalence work.
+When the change signals a specific domain, look in `keel/lenses/` for a lens whose `Applies when:` header matches, and read only that lens before asking domain questions; do not load unrelated lenses. When no lens matches, or the repo defines none, proceed on the domain-agnostic path. Lenses are user-authored; scaffold the bundled starting points with `keel lenses add` (web, hardware, hardware-dsl).
 
 ## Boundaries
 

package/plugins/keel/skills/keel-debug-failure/SKILL.md

@@ -12,9 +12,9 @@ Use this skill when a command or validation path fails. Keep the investigation t
 
 Read the selected OpenSpec task's Commands, Acceptance, Coupling, Candidate Boundary, Autonomy boundary, Stop Rules, Evidence, Stop if, Read, Touch, and Mode fields. When `Coupling: required`, also read design.md's Coupled Iteration Contract. Read the failed command output and any repository files needed to reproduce or explain the failure.
 
-## Domain reference
+## Domain lenses
 
-When the change's artifacts or the failing surface signal a supported domain (web, hardware, hardware-dsl), consult the matching reference's `Execution and review checks` section under `keel-align-expectations/references/` before locking a root-cause hypothesis — only the matching reference, never all of them. When no domain signal exists, load nothing.
+When the change's artifacts or the failing surface signal a domain, consult the matching lens's `Execution and review checks` section from `keel/lenses/` — the lens whose `Applies when:` header matches — before locking a root-cause hypothesis, and load only that one. When no lens matches, load nothing.
 
 ## Fuse
 

package/plugins/keel/skills/keel-review-checklist/SKILL.md

@@ -35,9 +35,9 @@ Record the current agent's judgment inside the selected task Evidence:
 
 The Review remains in tasks.md. A user-facing Report summarizes delivery but is not hidden gate state. Do not let Core or this checklist write evidence automatically.
 
-## Domain reference
+## Domain lenses
 
-When the change's artifacts or Touch extensions signal a supported domain (web, hardware, hardware-dsl), consult the matching reference's `Execution and review checks` section under `keel-align-expectations/references/` before concluding the review — only the matching reference, never all of them. When no domain signal exists, load nothing.
+When the change's artifacts or Touch extensions signal a domain, consult the matching lens's `Execution and review checks` section from `keel/lenses/` — the lens whose `Applies when:` header matches — before concluding the review, and load only that one. When no lens matches, load nothing.
 
 ## Expectation and follow-up ownership
 

package/plugins/keel/skills/keel-tdd-or-test-first/SKILL.md

@@ -24,9 +24,9 @@ Read the selected task's compiled capsule: resolved Acceptance, Verify strategy
 
 Red-green strategies (`vertical-tdd`, `regression-first`) must record concrete per-label `.red` and `.green` Evidence entries for the same check; `keel gate task-complete` rejects absent or pending entries.
 
-## Domain reference
+## Domain lenses
 
-When the change's proposal/design/specs or the task's Touch extensions signal a supported domain (web, hardware, hardware-dsl), consult the matching reference's `Execution and review checks` section under `keel-align-expectations/references/` before finalizing the strategy and the first check — only the matching reference, never all of them. When no domain signal exists, load nothing.
+When the change's proposal/design/specs or the task's Touch extensions signal a domain, consult the matching lens's `Execution and review checks` section from `keel/lenses/` — the lens whose `Applies when:` header matches — before finalizing the strategy and the first check, and load only that one. When no lens matches, load nothing.
 
 ## Coupled-task preflight
 

package/scripts/bump_version.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+"use strict";
+
+// One-shot version bump across every place Keel pins its version.
+//
+// The Keel validation suite requires the same version in package.json,
+// package-lock.json, both native plugin manifests, the validator constants,
+// the protocol docs, and the changelog. This script updates all of them
+// together so a release never ships half-aligned.
+//
+// Usage:
+//   node scripts/bump_version.js <patch|minor|major|explicit-version>
+//
+// After running: fill in the CHANGELOG entry, then `npm test`, commit,
+// tag `vX.Y.Z`, push, and publish a GitHub Release.
+
+const fs = require("fs");
+const path = require("path");
+
+const ROOT = path.resolve(__dirname, "..");
+const PKG_PATH = path.join(ROOT, "package.json");
+const LOCK_PATH = path.join(ROOT, "package-lock.json");
+const CHANGELOG_PATH = path.join(ROOT, "keel", "CHANGELOG.md");
+const CHANGELOG_HEADER = "# Keel Changelog\n\n";
+const SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)$/;
+
+function fail(message) {
+  process.stderr.write(`bump-version: ${message}\n`);
+  process.exit(1);
+}
+
+function resolveNewVersion(current, target) {
+  if (target === "patch" || target === "minor" || target === "major") {
+    const [, major, minor, patch] = current.match(SEMVER_RE).map(Number);
+    if (target === "major") return `${major + 1}.0.0`;
+    if (target === "minor") return `${major}.${minor + 1}.0`;
+    return `${major}.${minor}.${patch + 1}`;
+  }
+  if (!SEMVER_RE.test(target)) {
+    fail(`not a patch|minor|major keyword or an X.Y.Z version: ${target}`);
+  }
+  return target;
+}
+
+function writeJson(filePath, data) {
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`);
+}
+
+function bumpPackageFiles(newVersion) {
+  const pkg = JSON.parse(fs.readFileSync(PKG_PATH, "utf8"));
+  pkg.version = newVersion;
+  writeJson(PKG_PATH, pkg);
+  process.stdout.write("  updated package.json\n");
+
+  const lock = JSON.parse(fs.readFileSync(LOCK_PATH, "utf8"));
+  lock.version = newVersion;
+  if (lock.packages && lock.packages[""]) {
+    lock.packages[""].version = newVersion;
+  }
+  writeJson(LOCK_PATH, lock);
+  process.stdout.write("  updated package-lock.json\n");
+}
+
+function replaceInFile(relPath, replacements) {
+  const filePath = path.join(ROOT, relPath);
+  let content = fs.readFileSync(filePath, "utf8");
+  for (const [from, to] of replacements) {
+    if (!content.includes(from)) {
+      fail(`expected to find ${JSON.stringify(from)} in ${relPath}`);
+    }
+    content = content.split(from).join(to);
+  }
+  fs.writeFileSync(filePath, content);
+  process.stdout.write(`  updated ${relPath}\n`);
+}
+
+function prependChangelogEntry(newVersion) {
+  let content = fs.readFileSync(CHANGELOG_PATH, "utf8");
+  if (content.includes(`## ${newVersion} `) || content.includes(`## ${newVersion}\n`)) {
+    process.stdout.write(`  keel/CHANGELOG.md already has a ${newVersion} entry\n`);
+    return;
+  }
+  if (!content.startsWith(CHANGELOG_HEADER)) {
+    fail("keel/CHANGELOG.md does not start with the expected header");
+  }
+  const entry =
+    `## ${newVersion} - TODO: summarize this release\n\n` +
+    "- TODO: describe the change.\n" +
+    "- Version alignment: the npm package, both native plugin manifests, " +
+    `protocol docs, and this changelog share Keel ${newVersion}; the OpenSpec ` +
+    "dependency pin stays `^1.4.1`.\n\n";
+  content = CHANGELOG_HEADER + entry + content.slice(CHANGELOG_HEADER.length);
+  fs.writeFileSync(CHANGELOG_PATH, content);
+  process.stdout.write("  updated keel/CHANGELOG.md (fill in the TODO lines)\n");
+}
+
+function main() {
+  const target = process.argv[2];
+  if (!target) {
+    fail("usage: node scripts/bump_version.js <patch|minor|major|explicit-version>");
+  }
+
+  const oldVersion = JSON.parse(fs.readFileSync(PKG_PATH, "utf8")).version;
+  if (!SEMVER_RE.test(oldVersion)) {
+    fail(`current package.json version is not X.Y.Z: ${oldVersion}`);
+  }
+  const newVersion = resolveNewVersion(oldVersion, target);
+  process.stdout.write(`Bumping ${oldVersion} -> ${newVersion}\n`);
+
+  bumpPackageFiles(newVersion);
+  replaceInFile("plugins/keel/.claude-plugin/plugin.json", [
+    [`"version": "${oldVersion}"`, `"version": "${newVersion}"`],
+  ]);
+  replaceInFile("plugins/keel/.codex-plugin/plugin.json", [
+    [`"version": "${oldVersion}"`, `"version": "${newVersion}"`],
+  ]);
+  replaceInFile("scripts/validate_plugin.py", [
+    [`PACKAGE_VERSION = "${oldVersion}"`, `PACKAGE_VERSION = "${newVersion}"`],
+    [`PROTOCOL_VERSION = "${oldVersion}"`, `PROTOCOL_VERSION = "${newVersion}"`],
+  ]);
+  replaceInFile("AGENTS.md", [
+    [`v${oldVersion}`, `v${newVersion}`],
+    [`version=${oldVersion}`, `version=${newVersion}`],
+  ]);
+  replaceInFile("assets/bootstrap/AGENTS.md", [
+    [`version=${oldVersion}`, `version=${newVersion}`],
+  ]);
+  prependChangelogEntry(newVersion);
+
+  process.stdout.write(
+    `\nDone. Next:\n` +
+      `  1. Edit keel/CHANGELOG.md ${newVersion} entry.\n` +
+      `  2. npm test\n` +
+      `  3. git commit -am "${newVersion}"\n` +
+      `  4. git tag v${newVersion} && git push --follow-tags && git push origin v${newVersion}\n` +
+      `  5. gh release create v${newVersion} --title v${newVersion} --notes "..."\n`
+  );
+}
+
+main();