sprag-cli 3.53.0 → 3.55.0

package/src/harness.js

@@ -21,11 +21,13 @@ import {
   appendRatchetRule,
   RATCHET_IMPORT_RE,
   MODEL_RATCHET_IMPORT_RE,
+  renderPresetRatchet,
 } from './harness-templates.js';
 import { routeWarningForStatusline } from './route-scan.js';
 import { ruleHealthWarningForStatusline, modelRatchetPathFor, renderModelRatchet } from './model-rules.js';
 import { compactWindowWarningForStatusline } from './compact-window.js';
 import { userLanguage } from './config.js';
+import { codexUserDir } from './agent.js';
 
 const require = createRequire(import.meta.url);
 function readHarnessState() {
@@ -42,11 +44,13 @@ function readHarnessState() {
  * or package.json). Falls back to `start` itself so harness commands always
  * have *some* directory to write into, even outside a repo.
  */
-export function findProjectRoot(start = process.cwd()) {
+export function findProjectRoot(start = process.cwd(), { agent = 'claude' } = {}) {
   let dir = resolve(start);
   for (;;) {
     if (
-      existsSync(join(dir, 'CLAUDE.md')) ||
+      (agent === 'codex'
+        ? existsSync(join(dir, 'AGENTS.md')) || existsSync(join(dir, 'AGENTS.override.md'))
+        : existsSync(join(dir, 'CLAUDE.md'))) ||
       existsSync(join(dir, '.git')) ||
       existsSync(join(dir, 'package.json'))
     ) {
@@ -70,10 +74,15 @@ function globalRatchetMdPath() {
   return join(homedir(), '.claude', 'ratchet.md');
 }
 
-function resolveRatchetPath(scope, root) {
+function resolveRatchetPath(scope, root, agent = 'claude') {
+  if (agent === 'codex') return scope === 'global' ? join(codexUserDir(), 'ratchet.md') : join(root, '.codex', 'ratchet.md');
   return scope === 'global' ? globalRatchetMdPath() : ratchetMdPath(root);
 }
 
+function initialRatchet(agent) {
+  return agent === 'codex' ? '# Codex Ratchet Rules\n\n## Rules\n\n' : harnessRatchetMdInitial();
+}
+
 // Global harness lives in ~/.claude/CLAUDE.md — Claude Code loads this for every
 // project, so a global init makes the 5 harness sections apply everywhere
 // (mirrors the project/global split that ratchet.md already has).
@@ -257,6 +266,18 @@ export function harnessInit({ root = findProjectRoot(), force = false, scope = '
     result.skipped.push(mrPath + ' (already exists)');
   }
 
+  // ratchet-preset.md — tool-owned and imported by the global block only, so
+  // it is seeded here for the same reason as ratchet-model.md above.
+  if (scope === 'global') {
+    const prPath = join(homedir(), '.claude', 'ratchet-preset.md');
+    if (!existsSync(prPath)) {
+      try {
+        writeFileSync(prPath, renderPresetRatchet([], { lang: userLanguage() }));
+        result.wrote.push(prPath);
+      } catch { /* unwritable — the next session start renders it */ }
+    }
+  }
+
   return result;
 }
 
@@ -312,14 +333,14 @@ export function harnessUninit({ root = findProjectRoot(), purgeRatchet = false,
  * harness promote — append a one-line rule to .claude/ratchet.md.
  * Creates the file from the initial template if missing.
  */
-export function harnessPromote(ruleText, { root = findProjectRoot(), scope = 'project' } = {}) {
-  const rmPath = resolveRatchetPath(scope, root);
+export function harnessPromote(ruleText, { root = findProjectRoot(), scope = 'project', agent = 'claude' } = {}) {
+  const rmPath = resolveRatchetPath(scope, root, agent);
   let existing = '';
   if (existsSync(rmPath)) {
     existing = readFileSync(rmPath, 'utf8');
   } else {
     mkdirSync(dirname(rmPath), { recursive: true });
-    existing = harnessRatchetMdInitial();
+    existing = initialRatchet(agent);
   }
   const next = appendRatchetRule(existing, ruleText);
   writeFileSync(rmPath, next);
@@ -339,17 +360,29 @@ export function harnessPromote(ruleText, { root = findProjectRoot(), scope = 'pr
  * Deduped by rule text (ignoring the YYYY-MM-DD stamp) — idempotent.
  * Returns { path, scope, added, skippedRules, presets }.
  */
-export function harnessPull({ root = findProjectRoot(), scope = 'global' } = {}) {
+export async function harnessPull({ root = findProjectRoot(), scope = 'global', agent = 'claude' } = {}) {
+  // Global presets live in ratchet-preset.md now, rendered from recorded
+  // answers, so pulling them globally is accepting every one of them.
+  if (scope === 'global') {
+    const { acceptedGlobalPresets, presetRatchetPath } = await import('./preset-ratchet.js');
+    const { pendingSeeds, acceptSeed } = await import('./seed-rules.js');
+    const added = [];
+    for (const s of pendingSeeds({ root, agent }).filter((x) => x.kind === 'ratchet')) {
+      if (await acceptSeed(s.id, { scope: 'global', root, agent })) added.push(s.ruleText);
+    }
+    const all = acceptedGlobalPresets({ agent }).length;
+    return { path: presetRatchetPath({ agent }), scope, added, skippedRules: all - added.length, presets: presetRuleEntries().length };
+  }
   const presets = presetRules();
-  const rmPath = resolveRatchetPath(scope, root);
+  const rmPath = resolveRatchetPath(scope, root, agent);
   const result = { path: rmPath, scope, added: [], skippedRules: 0, presets: presets.length };
   const stripDate = (t) => t.replace(/^\d{4}-\d{2}-\d{2}:\s*/, '').trim();
 
   let content = existsSync(rmPath)
     ? readFileSync(rmPath, 'utf8')
-    : harnessRatchetMdInitial();
+    : initialRatchet(agent);
   const have = new Set(
-    harnessListRules({ root, scope }).rules.map((r) => stripDate(r.text)),
+    harnessListRules({ root, scope, agent }).rules.map((r) => stripDate(r.text)),
   );
   for (const rule of presets) {
     if (have.has(rule)) {
@@ -385,7 +418,8 @@ export function presetRuleEntries() {
     const data = JSON.parse(readFileSync(path, 'utf8'));
     return (Array.isArray(data.rules) ? data.rules : [])
       .filter((r) => r && typeof r.ko === 'string' && r.ko.trim())
-      .map((r) => ({ ko: r.ko.trim(), en: (r.en || r.ko).trim() }));
+      .map((r) => ({ ko: r.ko.trim(), en: (r.en || r.ko).trim(),
+        ...(Array.isArray(r.agents) ? { agents: r.agents.filter((a) => typeof a === 'string') } : {}) }));
   } catch {
     return [];
   }
@@ -400,8 +434,8 @@ export function presetRules(lang = userLanguage()) {
  * harness list — return numbered ratchet rules from .claude/ratchet.md.
  * Numbering is 1-based and matches `harness rm <N>`.
  */
-export function harnessListRules({ root = findProjectRoot(), scope = 'project' } = {}) {
-  const rmPath = resolveRatchetPath(scope, root);
+export function harnessListRules({ root = findProjectRoot(), scope = 'project', agent = 'claude' } = {}) {
+  const rmPath = resolveRatchetPath(scope, root, agent);
   if (!existsSync(rmPath)) return { path: rmPath, rules: [] };
   const lines = readFileSync(rmPath, 'utf8').split('\n');
   const rules = [];
@@ -482,8 +516,8 @@ export function contextWeightStatus({ root = findProjectRoot() } = {}) {
  * it. Selection is by tag and/or age; nothing is deleted, so a pruned rule can
  * be pasted back. Returns the pruned rules for the CLI to echo.
  */
-export function harnessPrune({ root = findProjectRoot(), scope = 'project', tag = null, olderThanMonths = null, dryRun = false } = {}) {
-  const { path: rmPath, rules } = harnessListRules({ root, scope });
+export function harnessPrune({ root = findProjectRoot(), scope = 'project', agent = 'claude', tag = null, olderThanMonths = null, dryRun = false } = {}) {
+  const { path: rmPath, rules } = harnessListRules({ root, scope, agent });
   if (!existsSync(rmPath)) return { ok: false, error: `ratchet.md not found at ${rmPath}` };
   if (!tag && !olderThanMonths) return { ok: false, error: 'Nothing selected — pass --tag <t> and/or --older-than <months>' };
   const cutoff = olderThanMonths ? Date.now() - olderThanMonths * 30 * 24 * 60 * 60 * 1000 : null;
@@ -519,8 +553,8 @@ export function harnessPrune({ root = findProjectRoot(), scope = 'project', tag
  * value is one-way accumulation; deleting should feel deliberate. The CLI
  * surfaces a "narrow the condition instead" reminder around this call.
  */
-export function harnessRmRule(n, { root = findProjectRoot(), scope = 'project' } = {}) {
-  const { path: rmPath, rules } = harnessListRules({ root, scope });
+export function harnessRmRule(n, { root = findProjectRoot(), scope = 'project', agent = 'claude' } = {}) {
+  const { path: rmPath, rules } = harnessListRules({ root, scope, agent });
   if (!existsSync(rmPath)) {
     return { ok: false, error: `ratchet.md not found at ${rmPath}` };
   }

package/src/preset-ratchet.js

@@ -0,0 +1,133 @@
+/**
+ * preset-ratchet — the bundled ratchet presets the user accepted globally,
+ * kept in a file of their own.
+ *
+ * Presets used to be appended to ratchet.md next to the user's own rules. Once
+ * there, an upgrade could not reword a preset, drop one that turned out wrong,
+ * or tell which lines were ours: every line looked like the user's. This file
+ * holds only presets and is regenerated whole from the recorded answers in
+ * seed-state, the same way ratchet-model.md is regenerated from the rule
+ * registry. So an upgrade updates it by itself, `seed skip` removes one, and
+ * ratchet.md stays the user's.
+ *
+ *   Claude Code  ~/.claude/ratchet-preset.md   (imported by the global harness block)
+ *   Codex        <CODEX_HOME>/ratchet-preset.md (injected by the SessionStart hook)
+ *
+ * Presets accepted into a project scope still go to that project's ratchet.md:
+ * a project rule is the user's placement decision, not a tool-wide default.
+ */
+
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { codexUserDir } from './agent.js';
+import { userLanguage } from './config.js';
+import {
+  HARNESS_BLOCK_BEGIN,
+  HARNESS_BLOCK_END,
+  PRESET_RATCHET_IMPORT_RE,
+  presetRatchetImportLine,
+  renderPresetRatchet,
+} from './harness-templates.js';
+import { loadSeedState, ratchetPresets, saveSeedState } from './seed-rules.js';
+
+export function presetRatchetPath({ agent = 'claude' } = {}) {
+  return agent === 'codex'
+    ? join(codexUserDir(), 'ratchet-preset.md')
+    : join(homedir(), '.claude', 'ratchet-preset.md');
+}
+
+function globalRatchetPath(agent) {
+  return agent === 'codex' ? join(codexUserDir(), 'ratchet.md') : join(homedir(), '.claude', 'ratchet.md');
+}
+
+function writeIfChanged(file, text) {
+  let before = null;
+  try { before = readFileSync(file, 'utf8'); } catch { /* first write */ }
+  if (before === text) return false;
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  writeFileSync(tmp, text);
+  renameSync(tmp, file);
+  return true;
+}
+
+/** The accepted-global presets, in the bundled order, with this version's wording. */
+export function acceptedGlobalPresets({ agent = 'claude', lang = userLanguage() } = {}) {
+  const { decided } = loadSeedState({ agent });
+  return ratchetPresets(lang, { agent })
+    .filter((p) => decided[p.id]?.action === 'accepted' && decided[p.id]?.scope === 'global')
+    .map((p) => ({ id: p.id, text: p.text }));
+}
+
+/**
+ * Rewrite the preset file from the recorded answers. A preset that a newer
+ * release removed simply stops being rendered; its answer stays in seed-state
+ * so it is not offered again if it comes back under the same text.
+ */
+export function syncPresetRatchet({ agent = 'claude', lang = userLanguage() } = {}) {
+  const file = presetRatchetPath({ agent });
+  const rules = acceptedGlobalPresets({ agent, lang });
+  const changed = writeIfChanged(file, renderPresetRatchet(rules, { lang, agent }));
+  return { file, rules: rules.length, changed };
+}
+
+/**
+ * Move presets that earlier versions appended to the global ratchet.md into
+ * the preset file. A line counts as a preset only when its text, without the
+ * date stamp, equals a bundled rule in either language, so nothing the user
+ * wrote themselves is touched. The original is backed up once before the
+ * first change.
+ */
+export function migrateLegacyPresetRules({ agent = 'claude' } = {}) {
+  const file = globalRatchetPath(agent);
+  if (!existsSync(file)) return { file, moved: 0 };
+  const byText = new Map();
+  for (const lang of ['ko', 'en']) {
+    for (const p of ratchetPresets(lang, { agent })) byText.set(p.text.trim(), p.id);
+  }
+  const stamp = /^\d{4}-\d{2}-\d{2}(\s*\([^)]*\))?:\s*/;
+  const original = readFileSync(file, 'utf8');
+  const moved = [];
+  const kept = original.split('\n').filter((line) => {
+    const m = line.match(/^\s*-\s+(.*)$/);
+    if (!m) return true;
+    const id = byText.get(m[1].replace(stamp, '').trim());
+    if (!id) return true;
+    moved.push(id);
+    return false;
+  });
+  if (!moved.length) return { file, moved: 0 };
+  writeFileSync(`${file}.bak-preset-migration`, original);
+  writeIfChanged(file, kept.join('\n'));
+  const state = loadSeedState({ agent });
+  const today = new Date().toISOString().slice(0, 10);
+  for (const id of moved) state.decided[id] = { action: 'accepted', at: today, scope: 'global', migrated: true };
+  saveSeedState(state, { agent });
+  return { file, moved: moved.length };
+}
+
+/**
+ * Add the preset import to a global harness block written before the file
+ * existed. Only the tool's own marked block is edited; a CLAUDE.md without the
+ * block is left alone, since the user chose not to install the harness there.
+ */
+export function ensurePresetImport() {
+  const file = join(homedir(), '.claude', 'CLAUDE.md');
+  let text;
+  try { text = readFileSync(file, 'utf8'); } catch { return { file, added: false }; }
+  const begin = text.indexOf(HARNESS_BLOCK_BEGIN);
+  const end = text.indexOf(HARNESS_BLOCK_END);
+  if (begin < 0 || end < begin) return { file, added: false };
+  if (PRESET_RATCHET_IMPORT_RE.test(text.slice(begin, end))) return { file, added: false };
+  writeFileSync(file, `${text.slice(0, end)}${presetRatchetImportLine()}\n${text.slice(end)}`);
+  return { file, added: true };
+}
+
+/** Everything a session start or an install does: migrate, render, and wire the import. */
+export function preparePresetRatchet({ agent = 'claude', lang = userLanguage() } = {}) {
+  const migrated = migrateLegacyPresetRules({ agent });
+  const synced = syncPresetRatchet({ agent, lang });
+  const imported = agent === 'codex' ? { added: false } : ensurePresetImport();
+  return { ...synced, moved: migrated.moved, importAdded: imported.added };
+}

package/src/seed-rules.js

@@ -46,23 +46,25 @@ import {
 
 const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
 
-export function seedStatePath() {
-  return join(userDataDir(), 'seed-state.json');
+// Codex answers are kept apart: saying no in one agent must not consume the
+// other agent's offer, and the two agents write to different ratchet files.
+export function seedStatePath({ agent = 'claude' } = {}) {
+  return join(userDataDir(), agent === 'codex' ? 'codex-seed-state.json' : 'seed-state.json');
 }
 
-export function loadSeedState() {
+export function loadSeedState(opts = {}) {
   try {
-    const data = JSON.parse(readFileSync(seedStatePath(), 'utf8'));
+    const data = JSON.parse(readFileSync(seedStatePath(opts), 'utf8'));
     return data && typeof data.decided === 'object' && data.decided ? data : { decided: {} };
   } catch {
     return { decided: {} };
   }
 }
 
-export function saveSeedState(state) {
+export function saveSeedState(state, opts = {}) {
   const dir = userDataDir();
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(seedStatePath(), JSON.stringify(state, null, 2) + '\n');
+  writeFileSync(seedStatePath(opts), JSON.stringify(state, null, 2) + '\n');
 }
 
 /** Bundled tier-delegation presets (empty array when the file is unreadable). */
@@ -80,15 +82,19 @@ export function modelPresets() {
  * ids would renumber the moment a rule is inserted above them, silently moving
  * a user's "no" onto a different rule.
  */
-export function ratchetPresets(lang = userLanguage()) {
-  return presetRuleEntries().map((r) => ({
-    // Hashed from the Korean text in both languages: the id has to survive a
-    // reworded translation, or a user who declined a rule would be asked again
-    // the next time its English copy changes.
-    id: `fix-${createHash('sha1').update(r.ko).digest('hex').slice(0, 6)}`,
-    text: lang === 'ko' ? r.ko : r.en,
-    ko: r.ko,
-  }));
+export function ratchetPresets(lang = userLanguage(), { agent = 'claude' } = {}) {
+  return presetRuleEntries()
+    // A preset without `agents` applies everywhere; one naming Claude model
+    // tiers would only mislead a Codex session.
+    .filter((r) => !r.agents || r.agents.includes(agent))
+    .map((r) => ({
+      // Hashed from the Korean text in both languages: the id has to survive a
+      // reworded translation, or a user who declined a rule would be asked again
+      // the next time its English copy changes.
+      id: `fix-${createHash('sha1').update(r.ko).digest('hex').slice(0, 6)}`,
+      text: lang === 'ko' ? r.ko : r.en,
+      ko: r.ko,
+    }));
 }
 
 const stripDate = (t) => t.replace(/^\d{4}-\d{2}-\d{2}(\s*\([^)]*\))?:\s*/, '').trim();
@@ -102,9 +108,11 @@ const stripDate = (t) => t.replace(/^\d{4}-\d{2}-\d{2}(\s*\([^)]*\))?:\s*/, '').
  * whose own route-scan already promoted that shape does not need ours, and
  * offering it anyway would read as the tool failing to notice its own state.
  */
-export function pendingSeeds({ lang = userLanguage(), root = findProjectRoot() } = {}) {
-  const { decided } = loadSeedState();
-  const registered = (() => {
+export function pendingSeeds({ lang = userLanguage(), root = findProjectRoot(), agent = 'claude' } = {}) {
+  const { decided } = loadSeedState({ agent });
+  // Codex model routing comes from its own measured route-scan candidates;
+  // Claude tier presets name models Codex does not run.
+  const registered = agent === 'codex' ? [] : (() => {
     try {
       return loadModelRules().rules;
     } catch {
@@ -116,12 +124,12 @@ export function pendingSeeds({ lang = userLanguage(), root = findProjectRoot() }
   const haveText = new Set();
   for (const scope of ['global', 'project']) {
     try {
-      for (const r of harnessListRules({ root, scope }).rules) haveText.add(stripDate(r.text));
+      for (const r of harnessListRules({ root, scope, agent }).rules) haveText.add(stripDate(r.text));
     } catch { /* a missing ratchet file just means nothing is registered yet */ }
   }
 
   const out = [];
-  for (const p of modelPresets()) {
+  for (const p of agent === 'codex' ? [] : modelPresets()) {
     if (decided[p.id]) continue;
     if (haveModel.has(`${p.tier}|${p.category}`)) continue;
     out.push({
@@ -134,7 +142,7 @@ export function pendingSeeds({ lang = userLanguage(), root = findProjectRoot() }
       preset: p,
     });
   }
-  for (const p of ratchetPresets(lang)) {
+  for (const p of ratchetPresets(lang, { agent })) {
     if (decided[p.id]) continue;
     // Either language counts as already registered: `harness pull` may have
     // written the other one.
@@ -149,10 +157,10 @@ export function findSeed(id, opts = {}) {
   return pendingSeeds(opts).find((s) => s.id === id) || null;
 }
 
-function recordDecision(id, action, extra = {}) {
-  const state = loadSeedState();
+function recordDecision(id, action, extra = {}, { agent = 'claude' } = {}) {
+  const state = loadSeedState({ agent });
   state.decided[id] = { action, at: new Date().toISOString().slice(0, 10), ...extra };
-  saveSeedState(state);
+  saveSeedState(state, { agent });
 }
 
 /**
@@ -162,13 +170,24 @@ function recordDecision(id, action, extra = {}) {
  *
  * Returns { id, kind, scope, path?, rule } or null when the id is not pending.
  */
-export async function acceptSeed(id, { scope = 'global', root = findProjectRoot(), lang = userLanguage() } = {}) {
-  const seed = findSeed(id, { lang, root });
+export async function acceptSeed(id, { scope, root = findProjectRoot(), lang = userLanguage(), agent = 'claude' } = {}) {
+  // No default: a rule in the wrong scope is noise everywhere or missing where it mattered.
+  if (scope !== 'global' && scope !== 'project') throw new Error('acceptSeed needs an explicit scope: global or project');
+  const seed = findSeed(id, { lang, root, agent });
   if (!seed) return null;
 
   if (seed.kind === 'ratchet') {
-    const res = harnessPromote(seed.ruleText, { root, scope });
-    recordDecision(id, 'accepted', { scope });
+    // A global preset goes to the tool-owned preset file, which is rendered
+    // from the recorded answer; a project one is the user's placement and is
+    // appended to that project's ratchet.md as before.
+    if (scope === 'global') {
+      recordDecision(id, 'accepted', { scope }, { agent });
+      const { syncPresetRatchet } = await import('./preset-ratchet.js');
+      const res = syncPresetRatchet({ agent, lang });
+      return { id, kind: 'ratchet', scope, path: res.file, rule: seed.ruleText };
+    }
+    const res = harnessPromote(seed.ruleText, { root, scope, agent });
+    recordDecision(id, 'accepted', { scope }, { agent });
     return { id, kind: 'ratchet', scope, path: res.path, rule: seed.ruleText };
   }
 
@@ -208,23 +227,39 @@ export async function acceptSeed(id, { scope = 'global', root = findProjectRoot(
     lastSeen: today,
   });
   const written = syncAllFiles();
-  recordDecision(id, 'accepted', { scope });
+  recordDecision(id, 'accepted', { scope }, { agent });
   return { id, kind: 'model', scope, paths: written, rule: composeRuleText(entry.rule, entry, lang) };
 }
 
-/** Record a "no" so the rule is never offered again (until `seed reset`). */
-export function skipSeed(id, opts = {}) {
+/**
+ * Record a "no" so the rule is never offered again (until `seed reset`).
+ *
+ * A preset already accepted globally can be skipped too: that is how one comes
+ * out of the preset file, which is rendered from these answers.
+ */
+export async function skipSeed(id, opts = {}) {
   const seed = findSeed(id, opts);
-  if (!seed) return null;
-  recordDecision(id, 'skipped');
-  return { id, kind: seed.kind, rule: seed.ruleText };
+  if (seed) {
+    recordDecision(id, 'skipped', {}, { agent: opts.agent });
+    return { id, kind: seed.kind, rule: seed.ruleText };
+  }
+  const { decided } = loadSeedState({ agent: opts.agent });
+  const preset = ratchetPresets(opts.lang, { agent: opts.agent }).find((p) => p.id === id);
+  if (!preset || decided[id]?.action !== 'accepted' || decided[id]?.scope !== 'global') return null;
+  recordDecision(id, 'skipped', { was: 'accepted' }, { agent: opts.agent });
+  const { syncPresetRatchet } = await import('./preset-ratchet.js');
+  syncPresetRatchet({ agent: opts.agent, lang: opts.lang });
+  return { id, kind: 'ratchet', rule: preset.text, removed: true };
 }
 
 /** Forget every recorded answer — the full set becomes pending again. */
-export function resetSeeds() {
-  const state = loadSeedState();
+export async function resetSeeds({ agent = 'claude' } = {}) {
+  const state = loadSeedState({ agent });
   const count = Object.keys(state.decided).length;
-  saveSeedState({ decided: {} });
+  saveSeedState({ decided: {} }, { agent });
+  // The preset file mirrors the answers, so forgetting them empties it.
+  const { syncPresetRatchet } = await import('./preset-ratchet.js');
+  syncPresetRatchet({ agent });
   return count;
 }
 
@@ -236,9 +271,23 @@ export function resetSeeds() {
  * asked for, and because a single "register all of these?" question invites a
  * yes to rules the user never read.
  */
-export function seedOfferBlock({ lang = userLanguage(), root = findProjectRoot() } = {}) {
-  const pending = pendingSeeds({ lang, root });
+export function seedOfferBlock({ lang = userLanguage(), root = findProjectRoot(), agent = 'claude' } = {}) {
+  const pending = pendingSeeds({ lang, root, agent });
   if (pending.length === 0) return null;
+  if (agent === 'codex') {
+    // Codex hook text stays English; the rule text itself follows the user's language.
+    const cmd = (s) => `${CLI_NAME} seed ${s} --agent codex`;
+    return [
+      `[Sprag seed] ${pending.length} recommended Codex ratchet rule(s) from the bundled presets are not registered yet.`,
+      'Ask in your first reply, after answering any request the user opened with. Offer these choices in this order:',
+      `  1. Register all, globally: ${cmd('accept all --global')}`,
+      `  2. Register all, this project only: ${cmd('accept all --project')}`,
+      '  3. Decide one at a time: ask about each rule below and run its command as soon as they answer',
+      `  4. Register none: ${cmd('skip all')} (never offered again)`,
+      'Always confirm the scope with the user before running an accept command.',
+      ...pending.map((s) => `  [${s.id}] ${s.ruleText}`),
+    ].join('\n');
+  }
   const models = pending.filter((s) => s.kind === 'model');
   const fixes = pending.filter((s) => s.kind === 'ratchet');
   const lines = [];

package/src/update-check.js

@@ -266,16 +266,51 @@ export function releaseHighlights(body, lang = 'en') {
   return out;
 }
 
+/**
+ * The releases endpoint for one version, or a throw.
+ *
+ * The version that arrives here came out of a registry response rather than out
+ * of this process, so it is checked rather than trusted: a value carrying a
+ * slash or a scheme would otherwise have a say in which URL this function
+ * requests. Two checks are needed, because either one alone leaves a gap. The
+ * shape test rejects anything that is not a version, and the prefix test runs
+ * against the parsed URL rather than against the string it was built from,
+ * because `new URL` has collapsed `../` segments by that point and the same
+ * test on the raw string would pass a value that walks back out of the path.
+ * The origin is a constant either way, so no input can move the request to
+ * another host; this states that guarantee in code instead of leaving it
+ * implied.
+ */
+function releaseTagUrl(version) {
+  const tag = String(version);
+  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(tag)) {
+    throw new Error(`refusing to request notes for ${JSON.stringify(tag)}: not a version`);
+  }
+  const url = new URL(`${RELEASES_API}/v${tag}`);
+  if (!url.href.startsWith(`${RELEASES_API}/`)) {
+    throw new Error(`refusing to request ${url.href}: outside ${RELEASES_API}`);
+  }
+  return url;
+}
+
 /**
  * Fetch the highlights for one version. Returns [] on any failure: the notice
  * is worth showing with a bare version number, so a missing release, a rate
- * limit, or an offline machine must not cost the user the notice itself.
+ * limit, or an offline machine must not cost the user the notice itself. A
+ * version that fails the endpoint check above lands in that same place: no
+ * highlights, and the notice still goes out.
  */
 export async function fetchHighlights(version, { timeoutMs = FETCH_TIMEOUT_MS, lang = 'en' } = {}) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const res = await fetch(`${RELEASES_API}/v${version}`, {
+    const endpoint = releaseTagUrl(version);
+    // The URL is this module's own constant plus a checked version. The
+    // scanner's node_ssrf heuristic reads any two-argument function as an HTTP
+    // handler and its first argument as request input, which is what it matched
+    // on here; this module serves nothing and has no request to read.
+    // nosemgrep: rules.lgpl.nodejs_scan.javascript-ssrf-rule-node_ssrf
+    const res = await fetch(endpoint, {
       signal: controller.signal,
       headers: { accept: 'application/vnd.github+json' },
     });