@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/scripts/persist.ts

@@ -0,0 +1,54 @@
+/** `repo persist <kind> [--workspace dir]`: save the stdin body as a plan, roadmap, handoff, implementation or tmp file. */
+import path from "node:path";
+import { processHookIo, readAllText, type HookIo } from "./hook-io.ts";
+import { persistHandoff } from "./persist-handoff.ts";
+import { persistImplementation } from "./persist-implementation.ts";
+import { persistPlan } from "./persist-plan.ts";
+import { persistRoadmap } from "./persist-roadmap.ts";
+import { persistTmp } from "./persist-tmp.ts";
+import { resolveRoots } from "./workspace-root.ts";
+
+type Saved = { ok: true; serial: number; path: string; filename: string } | { ok: false; error: string };
+type Saver = (opts: { workspaceRoot: string; content: string }) => Saved;
+
+const SAVERS: Readonly<Record<string, Saver>> = {
+  plan: persistPlan,
+  roadmap: persistRoadmap,
+  handoff: persistHandoff,
+  implementation: persistImplementation,
+  tmp: persistTmp,
+};
+
+const KINDS = "use plan, roadmap, handoff, implementation or tmp";
+
+const fail = (message: string): number => {
+  process.stderr.write(`${message}\n`);
+  return 1;
+};
+
+/** `--workspace dir`, else the repo root the working directory sits in. */
+function workspaceOf(argv: string[]): string {
+  const at = argv.indexOf("--workspace");
+  return (at >= 0 ? argv[at + 1] : undefined) ?? resolveRoots().root;
+}
+
+function saveBody(save: Saver, argv: string[], io: HookIo): number {
+  try {
+    const workspaceRoot = workspaceOf(argv);
+    const result = save({ workspaceRoot, content: readAllText(io) });
+    if (!result.ok) return fail(result.error);
+    const { serial, path: saved, filename } = result;
+    io.write(JSON.stringify({ serial, path: saved, absPath: path.resolve(workspaceRoot, saved), filename }) + "\n");
+    return 0;
+  } catch (err) {
+    return fail(err instanceof Error ? err.message : String(err));
+  }
+}
+
+export function main(argv: string[] = [], io: HookIo = processHookIo()): number {
+  const kind = argv[0];
+  if (kind === undefined) return fail(`repo persist: missing kind; ${KINDS}`);
+  const save = Object.hasOwn(SAVERS, kind) ? SAVERS[kind] : undefined;
+  if (!save) return fail(`repo persist: unknown kind "${kind}"; ${KINDS}`);
+  return saveBody(save, argv, io);
+}

package/cli/scripts/phase-files.ts

@@ -0,0 +1,121 @@
+/** `repo phase-files <plan> <phases>`: map a parallel group's unstaged changes to its phases. */
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { PLAN_DIR, parallelFiles, planBoxes, planPhases } from "./persist-plan.ts";
+import { canonicalPath, resolveRoots } from "./workspace-root.ts";
+
+const USAGE = "usage: repo phase-files <plan serial|path> <phases, e.g. 2,3>\n";
+
+/** Paths with unstaged or untracked changes, as git prints them; the new side of a rename. */
+function unstagedPaths(cwd: string): string[] {
+  const raw = execFileSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 1 << 28,
+  });
+  const fields = raw.split("\0")[Symbol.iterator]();
+  const paths: string[] = [];
+  for (let next = fields.next(); !next.done; next = fields.next()) {
+    const entry = next.value;
+    if (entry.length < 4) continue;
+    const x = entry[0];
+    const y = entry[1];
+    // A rename or copy carries its old path in the next field.
+    if (x === "R" || x === "C" || y === "R" || y === "C") fields.next();
+    if (y !== " " || entry.startsWith("??")) paths.push(entry.slice(3).replace(/\\/g, "/"));
+  }
+  return [...new Set(paths)].sort();
+}
+
+function findPlan(arg: string, cwd: string): { file: string; label: string } | { error: string } {
+  if (!/^\d+$/.test(arg)) {
+    const file = path.resolve(cwd, arg);
+    return fs.existsSync(file)
+      ? { file, label: path.basename(file).split("-", 1).join("") }
+      : { error: `no plan ${arg}\n` };
+  }
+  const dir = path.join(resolveRoots({}, { cwd, env: {} }).root, PLAN_DIR);
+  const serial = Number(arg);
+  const names = fs.existsSync(dir)
+    ? fs.readdirSync(dir).filter((b) => b.endsWith(".md") && Number(/^(\d+)-/.exec(b)?.[1]) === serial)
+    : [];
+  const name = names.sort().at(-1);
+  return name ? { file: path.join(dir, name), label: arg } : { error: `no plan ${arg} in ${dir}\n` };
+}
+
+export function main(argv: string[], cwd: string = canonicalPath(process.cwd())): number {
+  const [planArg, phaseArg, ...extra] = argv;
+  if (!planArg || !phaseArg || extra.length) return fail(USAGE);
+  const plan = findPlan(planArg, cwd);
+  if ("error" in plan) return fail(plan.error);
+
+  const phases = planPhases(planBoxes(fs.readFileSync(plan.file, "utf8")));
+  const ids = [
+    ...new Set(
+      phaseArg
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean),
+    ),
+  ];
+  if (!ids.length) return fail(USAGE);
+  const wanted = [];
+  const declaredBy = new Map<string, string[]>();
+  for (const id of ids) {
+    const phase = phases.find((p) => p.id === id);
+    if (!phase) return fail(`plan ${plan.label} has no phase ${id}\n`);
+    wanted.push(phase);
+  }
+  for (const p of wanted) {
+    const declared = parallelFiles(p);
+    if (!declared) return fail(`phase ${p.id} is not parallel; name phases of one parallel group\n`);
+    declaredBy.set(p.id, declared);
+  }
+
+  // Adjacent parallel phases are one group.
+  const groupOf = (id: string) => {
+    const at = phases.findIndex((p) => p.id === id);
+    let from = at;
+    let to = at;
+    while (from > 0 && parallelFiles(phases[from - 1]!)) from--;
+    while (to < phases.length - 1 && parallelFiles(phases[to + 1]!)) to++;
+    return from;
+  };
+  const first = wanted[0]!;
+  const other = wanted.find((p) => groupOf(p.id) !== groupOf(first.id));
+  if (other)
+    return fail(`phases ${first.id} and ${other.id} are in different parallel groups; name phases of one group\n`);
+
+  let changed: string[];
+  try {
+    changed = unstagedPaths(cwd);
+  } catch (e) {
+    const detail = String((e as { stderr?: unknown }).stderr || (e as Error).message).trim();
+    return fail(`git status failed in ${cwd}: ${detail}\n`);
+  }
+  if (!changed.length) {
+    process.stdout.write("no unstaged changes\n");
+    return 0;
+  }
+
+  const owned = new Set<string>();
+  for (const [id, declared] of declaredBy) {
+    const mine = changed.filter((f) => declared.includes(f));
+    mine.forEach((f) => owned.add(f));
+    process.stdout.write(`phase ${id}${mine.map((f) => `  ${f}`).join("")}\n`);
+  }
+  const unowned = changed.filter((f) => !owned.has(f));
+  for (const f of unowned) {
+    process.stderr.write(
+      `unowned  ${f}  (no phase in ${wanted.map((p) => p.id).join(",")} lists it); send it back as a finding\n`,
+    );
+  }
+  return unowned.length ? 1 : 0;
+}
+
+function fail(message: string): number {
+  process.stderr.write(message);
+  return 2;
+}

package/cli/scripts/prompt.ts

@@ -0,0 +1,38 @@
+/** TTY prompts. Copied into consumers. */
+import * as clack from "@clack/prompts";
+
+type SelectOptions<Value> = Parameters<typeof clack.select<Value>>[0];
+
+export { isInteractive } from "./interactive.ts";
+
+export function bailIfCancel<T>(value: T | symbol): T {
+  if (clack.isCancel(value)) {
+    clack.cancel("Aborted");
+    process.exit(0);
+  }
+  return value as T; // isCancel above exits on the symbol, so only T is left
+}
+
+export async function select<Value>(opts: SelectOptions<Value>): Promise<Value> {
+  return bailIfCancel(await clack.select(opts));
+}
+
+export async function confirm(opts: Parameters<typeof clack.confirm>[0]): Promise<boolean> {
+  return bailIfCancel(await clack.confirm(opts));
+}
+
+export async function text(opts: Parameters<typeof clack.text>[0]): Promise<string> {
+  return bailIfCancel(await clack.text(opts));
+}
+
+export async function password(opts: Parameters<typeof clack.password>[0]): Promise<string> {
+  return bailIfCancel(await clack.password(opts));
+}
+
+export function spinner(): {
+  start: (msg?: string) => void;
+  stop: (msg?: string, code?: number) => void;
+  message: (msg?: string) => void;
+} {
+  return clack.spinner();
+}

package/cli/scripts/purge-global-mcps.ts

@@ -0,0 +1,313 @@
+#!/usr/bin/env bun
+/** Purge stubborn global MCP sources under $HOME (dry-run default). Never project MCP. */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { isRecord } from "./hook-input.ts";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { readEnv } from "../env.ts";
+import type { Env } from "../env.ts";
+
+type JsonObject = Record<string, unknown>;
+export type ParsedArgv = { ok: true; apply: boolean } | { ok: false; error: string };
+
+/** What one dest needs: skip it, or write `obj` (TOML) / `json` as the new text. */
+interface PlanBase {
+  abs: string;
+  skip: boolean;
+  detail: string;
+  changed?: boolean;
+}
+interface GrokPlan extends PlanBase {
+  obj: JsonObject | null;
+}
+interface JsonPlan extends PlanBase {
+  json: JsonObject | null;
+}
+
+export interface ReportRow {
+  action: string;
+  path: string;
+  detail: string;
+  line: string;
+}
+
+export interface PurgeResult {
+  ok: boolean;
+  report: ReportRow[];
+  error?: string;
+}
+
+const errorText = (err: unknown): string => (err instanceof Error ? err.message : String(err));
+
+const PLUGIN_IDS = ["cloudflare", "stripe"];
+const DISABLE_MCP = ["cloudflare-docs", "MCP_DOCKER", "stripe"];
+const CURSOR_SERVER = "MCP_DOCKER";
+const STRIPE_PLUGIN = "stripe";
+
+function isPlainObject(v: unknown): v is JsonObject {
+  return v != null && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date);
+}
+
+/** HOME, else USERPROFILE (Windows / env sim), else os.homedir(). */
+export function resolveHome(env: Env = readEnv()): string {
+  return env.HOME || env.USERPROFILE || os.homedir();
+}
+
+export function parseArgv(argv: unknown): ParsedArgv {
+  const args: unknown[] = Array.isArray(argv) ? argv : [];
+  let apply = false;
+  for (const a of args) {
+    if (a === "--apply") {
+      apply = true;
+      continue;
+    }
+    return { ok: false, error: `unknown flag: ${a}` };
+  }
+  return { ok: true, apply };
+}
+
+export function grokConfigPath(home: string): string {
+  return path.join(path.resolve(home), ".grok", "config.toml");
+}
+
+export function cursorMcpPath(home: string): string {
+  return path.join(path.resolve(home), ".cursor", "mcp.json");
+}
+
+export function claudePluginsPath(home: string): string {
+  return path.join(path.resolve(home), ".claude", "plugins", "installed_plugins.json");
+}
+
+function isStripePluginKey(k: unknown): boolean {
+  return String(k).split("@")[0] === STRIPE_PLUGIN;
+}
+
+function strList(v: unknown, label: string): string[] {
+  if (v == null) return [];
+  if (!Array.isArray(v)) throw new Error(`unreadable dest: ${label}`);
+  return v.map((x) => String(x));
+}
+
+function dedupe(list: string[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const x of list) {
+    if (seen.has(x)) continue;
+    seen.add(x);
+    out.push(x);
+  }
+  return out;
+}
+
+function writeText(abs: string, body: string): void {
+  const text = body.endsWith("\n") ? body : body + "\n";
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, text);
+}
+
+function reportLine(row: { action: string; path: string; detail: string }): string {
+  return `${row.action} ${row.path} ${row.detail}`;
+}
+
+function planGrok(home: string): GrokPlan {
+  const abs = grokConfigPath(home);
+  let raw: string;
+  try {
+    raw = fs.readFileSync(abs, "utf8");
+  } catch (err) {
+    if (isRecord(err) && err.code === "ENOENT") {
+      return { abs, skip: true, detail: "noop (missing)", obj: null };
+    }
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  let obj: JsonObject;
+  try {
+    obj = parseToml(raw);
+  } catch {
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+
+  const next = { ...obj };
+  const details: string[] = [];
+  let changed = false;
+
+  const hadPlugins = isPlainObject(obj.plugins);
+  const plugins: JsonObject = isPlainObject(obj.plugins) ? { ...obj.plugins } : {};
+  if (obj.plugins != null && !hadPlugins) {
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  const enabled = strList(plugins.enabled, abs);
+  const disabled = strList(plugins.disabled, abs);
+  const nextEnabled = enabled.filter((n) => !PLUGIN_IDS.includes(n));
+  const nextDisabled = dedupe([...disabled, ...PLUGIN_IDS]);
+  const enabledChanged = nextEnabled.join("\0") !== enabled.join("\0");
+  const disabledChanged = nextDisabled.join("\0") !== disabled.join("\0");
+  if (enabledChanged) {
+    const removed = enabled.filter((n) => PLUGIN_IDS.includes(n));
+    details.push(`remove ${removed.join(", ")} from [plugins].enabled`);
+    changed = true;
+  }
+  if (disabledChanged) {
+    const added = PLUGIN_IDS.filter((id) => !disabled.includes(id));
+    details.push(`add ${added.join(", ")} to [plugins].disabled`);
+    changed = true;
+  }
+  if (enabledChanged || disabledChanged) {
+    if ("enabled" in plugins || enabledChanged) plugins.enabled = nextEnabled;
+    plugins.disabled = nextDisabled;
+    next.plugins = plugins;
+  }
+
+  const mcpKey = "disabled_mcp_servers";
+  if (next[mcpKey] == null || Array.isArray(next[mcpKey])) {
+    const cur = strList(next[mcpKey], abs);
+    const mcpNext = dedupe([...cur, ...DISABLE_MCP]);
+    if (mcpNext.join("\0") !== cur.join("\0")) {
+      const added = mcpNext.filter((x) => !cur.includes(x));
+      next[mcpKey] = mcpNext;
+      details.push(`add ${added.join(", ")} to ${mcpKey}`);
+      changed = true;
+    }
+  }
+
+  return {
+    abs,
+    skip: !changed,
+    detail: changed ? details.join("; ") : "noop (already clean)",
+    obj: next,
+    changed,
+  };
+}
+
+function planClaudePlugins(home: string): JsonPlan {
+  const abs = claudePluginsPath(home);
+  let raw: string;
+  try {
+    raw = fs.readFileSync(abs, "utf8");
+  } catch (err) {
+    if (isRecord(err) && err.code === "ENOENT") {
+      return { abs, skip: true, detail: "noop (missing)", json: null };
+    }
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  if (!isPlainObject(parsed)) throw new Error(`unreadable dest: ${abs}`);
+  const obj = parsed;
+  const plugins = obj.plugins;
+  if (plugins == null) {
+    return { abs, skip: true, detail: "noop (already clean)", json: null };
+  }
+  if (!isPlainObject(plugins)) throw new Error(`unreadable dest: ${abs}`);
+  const keys = Object.keys(plugins).filter(isStripePluginKey);
+  if (!keys.length) {
+    return { abs, skip: true, detail: "noop (already clean)", json: null };
+  }
+  const nextPlugins = { ...plugins };
+  for (const k of keys) delete nextPlugins[k];
+  return {
+    abs,
+    skip: false,
+    detail: `remove ${keys.join(", ")} from plugins`,
+    json: { ...obj, plugins: nextPlugins },
+    changed: true,
+  };
+}
+
+function planCursor(home: string): JsonPlan {
+  const abs = cursorMcpPath(home);
+  let raw: string;
+  try {
+    raw = fs.readFileSync(abs, "utf8");
+  } catch (err) {
+    if (isRecord(err) && err.code === "ENOENT") {
+      return { abs, skip: true, detail: "noop (missing)", json: null };
+    }
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`unreadable dest: ${abs}`);
+  }
+  if (!isPlainObject(parsed)) throw new Error(`unreadable dest: ${abs}`);
+  const obj = parsed;
+  const servers = obj.mcpServers;
+  if (servers == null) {
+    return { abs, skip: true, detail: "noop (already clean)", json: null };
+  }
+  if (!isPlainObject(servers)) throw new Error(`unreadable dest: ${abs}`);
+  if (!Object.prototype.hasOwnProperty.call(servers, CURSOR_SERVER)) {
+    return { abs, skip: true, detail: "noop (already clean)", json: null };
+  }
+  const nextServers = { ...servers };
+  delete nextServers[CURSOR_SERVER];
+  const json = { ...obj, mcpServers: nextServers };
+  return {
+    abs,
+    skip: false,
+    detail: `remove ${CURSOR_SERVER} from mcpServers`,
+    json,
+    changed: true,
+  };
+}
+
+export function purgeGlobalMcps({ home, apply = false }: { home?: string; apply?: boolean } = {}): PurgeResult {
+  const report: ReportRow[] = [];
+  const action = apply ? "apply" : "dry-run";
+  try {
+    if (!home) throw new Error("HOME required");
+    const grok = planGrok(home);
+    const cursor = planCursor(home);
+    const claude = planClaudePlugins(home);
+    if (apply) {
+      if (!grok.skip && grok.obj) {
+        writeText(grok.abs, stringifyToml(grok.obj));
+      }
+      if (!cursor.skip && cursor.json) {
+        writeText(cursor.abs, JSON.stringify(cursor.json, null, 2));
+      }
+      if (!claude.skip && claude.json) {
+        writeText(claude.abs, JSON.stringify(claude.json, null, 2));
+      }
+    }
+    for (const row of [
+      { action, path: grok.abs, detail: grok.detail },
+      { action, path: cursor.abs, detail: cursor.detail },
+      { action, path: claude.abs, detail: claude.detail },
+    ]) {
+      report.push({ ...row, line: reportLine(row) });
+    }
+    return { ok: true, report };
+  } catch (err) {
+    return { ok: false, report, error: errorText(err) };
+  }
+}
+
+export function main(argv: string[]): number {
+  try {
+    const parsed = parseArgv(argv);
+    if (!parsed.ok) {
+      process.stderr.write(parsed.error + "\n");
+      return 1;
+    }
+    const result = purgeGlobalMcps({ home: resolveHome(), apply: parsed.apply });
+    for (const row of result.report) {
+      process.stdout.write(row.line + "\n");
+    }
+    if (!result.ok) {
+      process.stderr.write(result.error + "\n");
+      return 1;
+    }
+    return 0;
+  } catch (err) {
+    process.stderr.write(errorText(err) + "\n");
+    return 1;
+  }
+}

package/cli/scripts/rejections-step.ts

@@ -0,0 +1,37 @@
+/**
+ * The rejections step of `repo turn`: every reject file of each package the change set touches, since a change to a
+ * source can widen a type its reject files test. Absent when those packages hold none.
+ */
+import { sourceFiles } from "../check-comments.ts";
+import { rejectionProblems } from "../check-rejections.ts";
+import { ownerOf } from "./change-set.ts";
+import { failed, owners, passed, type Step } from "./turn-steps.ts";
+
+const REJECT_FILE = /\.reject\.tsx?$/;
+
+/** The reject files of the touched packages, or why they could not be listed. */
+function rejectFiles(root: string, packages: readonly string[], touched: readonly string[]) {
+  const listed = sourceFiles(root);
+  if (!listed.ok) return listed;
+  const files = listed.files.filter((rel) => REJECT_FILE.test(rel) && touched.includes(ownerOf(rel, packages)));
+  return { ok: true as const, files };
+}
+
+/** `rejections ok`, or `rejections N failed` naming the failing files' count, each problem printed. */
+export const rejectionsStep: Step = (turn) => {
+  const listed = rejectFiles(turn.root, turn.packages, owners(turn));
+  if (!listed.ok)
+    return failed(
+      "rejections failed",
+      listed.errors.map((line) => `repo turn: ${line}\n`),
+    );
+  if (listed.files.length === 0) return null;
+  const problems = rejectionProblems(turn.root, listed.files);
+  if (problems.length === 0) return passed("rejections ok");
+  const failing = listed.files.filter((rel) => problems.some((line) => line.startsWith(`${rel}: `)));
+  const label = failing.length === 0 ? "rejections failed" : `rejections ${failing.length} failed`;
+  return failed(
+    label,
+    problems.map((line) => `repo turn: rejections: ${line}\n`),
+  );
+};

package/cli/scripts/rtk-grok.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env bun
+/** Grok PreToolUse: rewrite Bash/run_terminal_command through `rtk rewrite`.
+
+Fail-open: parse error, missing rtk, timeout, no rewrite → empty stdout, exit 0.
+Keep the full toolInput (Grok needs `description`); only replace `command`.
+*/
+import { spawnSync } from "../spawn.ts";
+import { readEnv } from "../env.ts";
+import { processHookIo, readHookInput, type HookIo } from "./hook-io.ts";
+
+const RTK_TIMEOUT_MS = 3000;
+
+const ULTRA_SUBS = new Set([
+  "grep",
+  "rg",
+  "curl",
+  "wget",
+  "vitest",
+  "jest",
+  "pytest",
+  "test",
+  "lint",
+  "tsc",
+  "npm",
+  "npx",
+  "read",
+  "find",
+  "diff",
+  "json",
+  "log",
+  "playwright",
+  "cargo",
+  "ruff",
+  "prettier",
+  "format",
+]);
+
+export function main(_argv: string[] = [], io: HookIo = processHookIo()): number {
+  try {
+    const data = readHookInput(io);
+    if (!data) return 0;
+    const toolInput = data.toolInput ?? data.tool_input;
+    if (!toolInput) return 0;
+    const cmdRaw = toolInput.command;
+    if (typeof cmdRaw !== "string") return 0;
+    const cmd = cmdRaw.trim();
+    if (!cmd) return 0;
+
+    const first = cmd.slice(0, cmd.search(/\s|$/));
+    const already = first === "rtk" || first.endsWith("/rtk");
+    let rewritten: string | null;
+    if (already) {
+      rewritten = injectUltra(cmd);
+      if (rewritten === cmd) return 0;
+    } else {
+      rewritten = rewrite(cmd);
+      if (!rewritten) return 0;
+    }
+
+    const updated = Object.assign({}, toolInput, { command: rewritten });
+    io.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecisionReason: "RTK auto-rewrite",
+          updatedInput: updated,
+        },
+      }),
+    );
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
+function injectUltra(rewritten: string): string {
+  if (rewritten.includes("--ultra-compact")) return rewritten;
+  const m = rewritten.match(/^(\S+)\s+(\S+)(?:\s+([\s\S]*))?$/);
+  if (!m || m[1] !== "rtk") return rewritten;
+  // Groups 1 and 2 are required, so they are strings once the match succeeded.
+  const sub = m[2]!;
+  if (!ULTRA_SUBS.has(sub)) return rewritten;
+  const rest = m[3] || "";
+  return "rtk " + sub + " --ultra-compact" + (rest ? " " + rest : "");
+}
+
+function rewrite(cmd: string): string | null {
+  // Bun.which caches the PATH it started with, so pass the current one.
+  const rtk = Bun.which("rtk", { PATH: readEnv().PATH ?? "" });
+  if (!rtk) return null;
+  try {
+    const proc = spawnSync(rtk, ["rewrite", "--ultra-compact", cmd], {
+      encoding: "utf8",
+      timeout: RTK_TIMEOUT_MS,
+    });
+    const out = (proc.stdout || "").trim();
+    if (!out || out === cmd) return null;
+    return injectUltra(out);
+  } catch {
+    return null;
+  }
+}