@marcomigozzi/trailhead 0.15.0 → 0.16.0

package/plugins/trailhead/hooks/lib/plan-review-rounds.test.js

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+// Tests for templates/trailhead-plan-review-rounds.js. Run: node plan-review-rounds.test.js
+// No framework: plain asserts, same style as auto-slot.test.js.
+//
+// Layers covered:
+//   1. ask: config lookup, roster resolution, host drop, unknown names, options menu.
+//   2. round: converged / continue / exhausted / no-progress / ceiling and their precedence.
+//   3. Usage errors (exit 2).
+//   4. End-to-end: the script itself through spawnSync.
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const scriptPath = path.resolve(__dirname, '..', '..', 'templates', 'trailhead-plan-review-rounds.js');
+const { main } = require(scriptPath);
+
+let passed = 0;
+const ok = (name, cond) => { assert.ok(cond, name); passed++; };
+
+function run(argv, deps = {}) {
+  let out = '';
+  let errOut = '';
+  const code = main(argv, { stdout: { write: (s) => { out += s; } }, stderr: { write: (s) => { errOut += s; } }, ...deps });
+  let json = null;
+  try { json = JSON.parse(out.trim()); } catch { /* not json */ }
+  return { code, out, json, errOut };
+}
+
+const tmp = () => fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'plan-review-rounds-')));
+const rm = (d) => fs.rmSync(d, { recursive: true, force: true });
+
+// A project root and a global config dir holding the given config objects (null = no file).
+function setup(project, global) {
+  const root = tmp();
+  const gdir = tmp();
+  if (project !== null && project !== undefined) {
+    fs.mkdirSync(path.join(root, '.trailhead'), { recursive: true });
+    fs.writeFileSync(path.join(root, '.trailhead', 'config.json'), typeof project === 'string' ? project : JSON.stringify(project));
+  }
+  if (global !== null && global !== undefined) {
+    fs.mkdirSync(path.join(gdir, 'trailhead'), { recursive: true });
+    fs.writeFileSync(path.join(gdir, 'trailhead', 'config.json'), typeof global === 'string' ? global : JSON.stringify(global));
+  }
+  return { root, gdir, done: () => { rm(root); rm(gdir); } };
+}
+
+// Deps with a fixed set of binaries "on PATH" and a canned kimi --help.
+const deps = (gdir, installed, kimiHelp = '--output-format json') => ({
+  env: { CLAUDE_CONFIG_DIR: gdir, PATH: '/nowhere' },
+  which: (name) => installed.includes(name),
+  kimiHelp: () => kimiHelp,
+});
+
+const ask = (s, installed, extra = [], kimiHelp) => run(['ask', '--repo', s.root, ...extra], deps(s.gdir, installed, kimiHelp));
+const values = (r) => r.json.options.map((o) => o.value);
+
+// --- ask: skip ---------------------------------------------------------------
+{
+  const s = setup({}, null);
+  const r = ask(s, ['codex', 'gemini']);
+  ok('ask: plan_review unset is skip off', r.code === 0 && r.json.status === 'skip' && r.json.reason === 'off' && r.json.configured === 2);
+  s.done();
+}
+{
+  const s = setup({ plan_review: 'off', 'plan_review.rounds': 4 }, null);
+  const r = ask(s, ['codex']);
+  ok('ask: plan_review off is skip off with the configured rounds', r.json.status === 'skip' && r.json.reason === 'off' && r.json.configured === 4);
+  s.done();
+}
+{
+  const s = setup({ plan_review: 'on' }, null);
+  const r = ask(s, []);
+  ok('ask: on with nothing installed is skip no-reviewer', r.code === 0 && r.json.status === 'skip' && r.json.reason === 'no-reviewer');
+  const own = ask(s, ['claude']);
+  ok('ask: only the host CLI installed is skip no-reviewer', own.json.status === 'skip' && own.json.reason === 'no-reviewer');
+  const codexHost = ask(s, ['codex'], ['--host', 'codex']);
+  ok('ask: --host codex drops codex', codexHost.json.status === 'skip' && codexHost.json.reason === 'no-reviewer');
+  const claudeOnCodex = ask(s, ['claude'], ['--host', 'codex']);
+  ok('ask: --host codex keeps claude as an independent reviewer', claudeOnCodex.json.status === 'ask' && JSON.stringify(claudeOnCodex.json.reviewers) === '["claude"]');
+  s.done();
+}
+
+// --- ask: roster resolution --------------------------------------------------
+{
+  const s = setup({ plan_review: 'on' }, null);
+  const r = ask(s, ['claude', 'codex', 'gemini', 'agy', 'cursor-agent', 'not-in-roster']);
+  ok('ask: on resolves the whole roster minus the host, in roster order', r.json.status === 'ask' && JSON.stringify(r.json.reviewers) === JSON.stringify(['gemini', 'codex', 'agy', 'cursor-agent']));
+  ok('ask: on ignores binaries outside the roster', !r.json.reviewers.includes('not-in-roster') && r.json.unknown.length === 0);
+  ok('ask: reports the configured count', r.json.configured === 2);
+  s.done();
+}
+{
+  const s = setup({ plan_review: 'codex, gemini' }, null);
+  const r = ask(s, ['codex', 'gemini', 'qwen']);
+  ok('ask: a comma list restricts the candidates', JSON.stringify(r.json.reviewers) === JSON.stringify(['codex', 'gemini']));
+  const only = ask(s, ['gemini']);
+  ok('ask: a listed CLI that is not installed is not counted', JSON.stringify(only.json.reviewers) === '["gemini"]' && only.json.unknown.length === 0);
+  s.done();
+}
+
+// --- ask: kimi probe ---------------------------------------------------------
+{
+  const s = setup({ plan_review: 'kimi' }, null);
+  ok('ask: kimi counts when --help mentions --output-format', ask(s, ['kimi'], [], 'usage: kimi --output-format').json.status === 'ask');
+  const legacy = ask(s, ['kimi'], [], 'usage: kimi [--print]');
+  ok('ask: legacy kimi (no --output-format) does not count', legacy.json.status === 'skip' && legacy.json.reason === 'no-reviewer');
+  const noHelp = ask(s, ['kimi'], [], null);
+  ok('ask: a failing kimi --help does not count', noHelp.json.status === 'skip');
+  let probes = 0;
+  const o = run(['ask', '--repo', s.root], { ...deps(s.gdir, []), kimiHelp: () => { probes++; return '--output-format'; } });
+  ok('ask: kimi is not probed when its binary is absent', probes === 0 && o.json.status === 'skip');
+  s.done();
+}
+
+// --- ask: unknown names ------------------------------------------------------
+{
+  const s = setup({ plan_review: 'codex,my-local,tpyo' }, null);
+  const r = ask(s, ['codex', 'my-local']);
+  ok('ask: a custom reviewer counts when its binary is on PATH', JSON.stringify(r.json.reviewers) === JSON.stringify(['codex', 'my-local']));
+  ok('ask: a custom reviewer on PATH is not unknown', !r.json.unknown.includes('my-local'));
+  ok('ask: an unknown name with no binary is listed, not counted, and warned', JSON.stringify(r.json.unknown) === '["tpyo"]' && !r.json.reviewers.includes('tpyo') && r.json.warnings.some((w) => w.includes('tpyo')));
+  const typoOnly = setup({ plan_review: 'tpyo' }, null);
+  const t = ask(typoOnly, ['codex']);
+  ok('ask: a list of only unknown absent names is skip no-reviewer, still reporting unknown', t.json.status === 'skip' && t.json.reason === 'no-reviewer' && JSON.stringify(t.json.unknown) === '["tpyo"]');
+  typoOnly.done();
+  s.done();
+}
+
+// --- ask: options menu -------------------------------------------------------
+{
+  const mk = (rounds) => {
+    const s = setup({ plan_review: 'codex', 'plan_review.rounds': rounds }, null);
+    const r = ask(s, ['codex']);
+    s.done();
+    return r;
+  };
+  const r2 = mk(2);
+  ok('options: n=2 is config(2) Recommended first, then 1, 3, until', JSON.stringify(values(r2)) === JSON.stringify(['config', '1', '3', 'until']) && r2.json.options[0].recommended === true && r2.json.options[0].label === 'As in config (2)');
+  ok('options: only the first entry is recommended', r2.json.options.slice(1).every((o) => !o.recommended));
+  ok('options: every entry has a human label', r2.json.options.every((o) => typeof o.label === 'string' && o.label.length > 0));
+  ok('options: n=1 is config, 2, 3, until', JSON.stringify(values(mk(1))) === JSON.stringify(['config', '2', '3', 'until']));
+  ok('options: n=3 is config, 1, 2, until', JSON.stringify(values(mk(3))) === JSON.stringify(['config', '1', '2', 'until']));
+  const r5 = mk(5);
+  ok('options: n=5 is config(5), 1, 2, until', JSON.stringify(values(r5)) === JSON.stringify(['config', '1', '2', 'until']) && r5.json.options[0].label === 'As in config (5)');
+  ok('options: never more than four entries', [1, 2, 3, 4, 7, 12].every((n) => mk(n).json.options.length <= 4));
+  ok('options: the numbered-list fallback lists all five', JSON.stringify(r2.json.fallback.map((o) => o.value)) === JSON.stringify(['config', '1', '2', '3', 'until']));
+}
+
+// --- ask: rounds fallback ----------------------------------------------------
+{
+  for (const bad of [0, -1, 1.5, 'two', null]) {
+    const s = setup({ plan_review: 'codex', 'plan_review.rounds': bad }, null);
+    const r = ask(s, ['codex']);
+    ok(`rounds: ${JSON.stringify(bad)} falls back to 2 with a warning`, r.code === 0 && r.json.configured === 2 && r.json.warnings.some((w) => w.includes('plan_review.rounds')));
+    s.done();
+  }
+  const s = setup({ plan_review: 'codex' }, null);
+  const r = ask(s, ['codex']);
+  ok('rounds: unset is 2 without a warning', r.json.configured === 2 && r.json.warnings.length === 0);
+  s.done();
+}
+
+// --- ask: config lookup ------------------------------------------------------
+{
+  const s = setup({ 'plan_review.rounds': 3 }, { plan_review: 'codex', 'plan_review.rounds': 5 });
+  const r = ask(s, ['codex']);
+  ok('config: keys resolve one by one, nearest wins (global plan_review, project rounds)', r.json.status === 'ask' && r.json.configured === 3 && JSON.stringify(r.json.reviewers) === '["codex"]');
+  s.done();
+}
+{
+  const s = setup({ plan_review: 'off' }, { plan_review: 'on' });
+  ok('config: the project value beats the global one', ask(s, ['codex']).json.reason === 'off');
+  s.done();
+}
+{
+  const s = setup(null, { plan_review: 'on' });
+  ok('config: a global-only config applies', ask(s, ['codex']).json.status === 'ask');
+  s.done();
+}
+{
+  const s = setup({ plan_review: 'on' }, null);
+  const home = tmp();
+  fs.mkdirSync(path.join(home, '.claude', 'trailhead'), { recursive: true });
+  fs.writeFileSync(path.join(home, '.claude', 'trailhead', 'config.json'), JSON.stringify({ 'plan_review.rounds': 4 }));
+  const r = run(['ask', '--repo', s.root], { env: { HOME: home, PATH: '/nowhere' }, which: (n) => n === 'codex', kimiHelp: () => null });
+  ok('config: without CLAUDE_CONFIG_DIR the global file is ~/.claude/trailhead/config.json', r.json.configured === 4);
+  rm(home);
+  s.done();
+}
+
+// --- ask: invalid config -----------------------------------------------------
+{
+  const bad = setup('{not json', null);
+  const r = ask(bad, ['codex']);
+  ok('error: an unparseable project config is status error, exit 1', r.code === 1 && r.json.status === 'error' && /JSON/.test(r.json.reason));
+  bad.done();
+  const arr = setup('[1]', null);
+  ok('error: a non-object config is status error', ask(arr, ['codex']).json.status === 'error');
+  arr.done();
+  const gl = setup({}, '{nope');
+  ok('error: an unparseable global config is status error', ask(gl, ['codex']).code === 1);
+  gl.done();
+  const typ = setup({ plan_review: 7 }, null);
+  ok('error: a non-string plan_review is status error', ask(typ, ['codex']).json.status === 'error');
+  typ.done();
+  const empty = setup({ plan_review: ' , ' }, null);
+  ok('error: a plan_review list with no name is status error', ask(empty, ['codex']).json.status === 'error');
+  empty.done();
+}
+{
+  const s = setup({ plan_review: 'on' }, null);
+  const failing = { readFileSync: () => { const e = new Error('EACCES: denied'); e.code = 'EACCES'; throw e; } };
+  const r = run(['ask', '--repo', s.root], { ...deps(s.gdir, ['codex']), fs: failing });
+  ok('error: an unreadable config (not ENOENT) is status error', r.code === 1 && r.json.status === 'error' && /cannot read/.test(r.json.reason));
+  s.done();
+}
+
+// --- ask: real PATH scan -----------------------------------------------------
+{
+  const bin = tmp();
+  fs.writeFileSync(path.join(bin, 'gemini'), '#!/bin/sh\n', { mode: 0o755 });
+  fs.writeFileSync(path.join(bin, 'qwen'), '#!/bin/sh\n', { mode: 0o644 });
+  fs.mkdirSync(path.join(bin, 'codex'));
+  const s = setup({ plan_review: 'on' }, null);
+  const r = run(['ask', '--repo', s.root], { env: { CLAUDE_CONFIG_DIR: s.gdir, PATH: bin }, kimiHelp: () => null });
+  ok('path: the default scan finds executable files only', r.json.status === 'ask' && JSON.stringify(r.json.reviewers) === '["gemini"]');
+  s.done();
+  rm(bin);
+}
+
+// --- round -------------------------------------------------------------------
+const c = (key, text) => ({ key, text: text || `full text of ${key}` });
+function round(history, choice, configured, extra = {}) {
+  const dir = tmp();
+  const file = path.join(dir, 'history.json');
+  fs.writeFileSync(file, typeof history === 'string' ? history : JSON.stringify(history));
+  const r = run(['round', '--choice', choice, '--configured', String(configured), '--history', file], extra);
+  rm(dir);
+  return r;
+}
+const decision = (r) => r.json.decision;
+
+ok('round: a latest round with no concern is converged', decision(round([[c('a')], []], '2', 2)) === 'converged' && round([[]], 'until', 2).json.rounds === 1);
+ok('round: converged carries no surviving', !('surviving' in round([[]], '1', 2).json));
+ok('round: a fixed choice with rounds left continues', decision(round([[c('a')]], '2', 2)) === 'continue' && !('surviving' in round([[c('a')]], '2', 2).json));
+{
+  const r = round([[c('a', 'A is wrong because X'), c('b')], [c('a', 'A is still wrong because X')]], '2', 2);
+  ok('round: a fixed choice with rounds spent is exhausted', decision(r) === 'exhausted');
+  ok('round: exhausted surviving carries the full {key,text} of the latest round', JSON.stringify(r.json.surviving) === JSON.stringify([c('a', 'A is still wrong because X')]));
+}
+ok('round: config resolves to --configured', decision(round([[c('a')]], 'config', 1)) === 'exhausted' && decision(round([[c('a')]], 'config', 3)) === 'continue');
+ok('round: exhausted is not reported for a fixed choice before its rounds', decision(round([[c('a')], [c('b')]], '3', 2)) === 'continue');
+ok('round: a fixed choice never reports no-progress', decision(round([[c('a')], [c('a')]], '3', 2)) === 'continue');
+ok('round: until continues while concerns change', decision(round([[c('a')], [c('a'), c('b')], [c('b')]], 'until', 2)) === 'continue');
+ok('round: until with round 1 never reports no-progress', decision(round([[c('a')]], 'until', 2)) === 'continue');
+{
+  const r = round([[c('a'), c('b')], [c('a'), c('b'), c('c', 'new one')]], 'until', 2);
+  ok('round: until with none of the previous concerns resolved is no-progress', decision(r) === 'no-progress' && r.json.surviving.length === 3 && r.json.surviving[2].text === 'new one');
+}
+ok('round: until with one previous concern resolved keeps going', decision(round([[c('a'), c('b')], [c('a')]], 'until', 2)) === 'continue');
+ok('round: keys are compared normalised', decision(round([[c('  Plan  Gap ')], [c('plan gap')]], 'until', 2)) === 'no-progress');
+ok('round: until at 5 rounds with progress is ceiling', decision(round([[c('a')], [c('b')], [c('c')], [c('d')], [c('e')]], 'until', 2)) === 'ceiling');
+ok('round: ceiling carries surviving', round([[c('a')], [c('b')], [c('c')], [c('d')], [c('e')]], 'until', 2).json.surviving[0].key === 'e');
+ok('round: until at 4 rounds still continues', decision(round([[c('a')], [c('b')], [c('c')], [c('d')]], 'until', 2)) === 'continue');
+ok('round: precedence: converged beats ceiling', decision(round([[c('a')], [c('b')], [c('c')], [c('d')], []], 'until', 2)) === 'converged');
+ok('round: precedence: no-progress beats ceiling at round 5', decision(round([[c('a')], [c('b')], [c('c')], [c('d')], [c('d')]], 'until', 2)) === 'no-progress');
+ok('round: precedence: converged beats exhausted', decision(round([[c('a')], []], '1', 1)) === 'converged');
+ok('round: output is one status ok JSON line with the round count', round([[c('a')]], '2', 2).json.status === 'ok' && round([[c('a')]], '2', 2).json.rounds === 1 && round([[c('a')]], '2', 2).out.trim().split('\n').length === 1);
+
+// --- usage errors ------------------------------------------------------------
+{
+  const u = (argv) => run(argv);
+  ok('usage: no command exits 2', u([]).code === 2);
+  ok('usage: unknown command exits 2', u(['go', '--repo', '/x']).code === 2);
+  ok('usage: ask without --repo exits 2', u(['ask']).code === 2);
+  ok('usage: ask with a bad --host exits 2', u(['ask', '--repo', '/x', '--host', 'vim']).code === 2);
+  ok('usage: unknown flag exits 2', u(['ask', '--repo', '/x', '--bogus', '1']).code === 2);
+  ok('usage: a flag without a value exits 2', u(['ask', '--repo']).code === 2);
+  ok('usage: round without --choice exits 2', u(['round', '--configured', '2', '--history', '/x']).code === 2);
+  ok('usage: round with a bad --choice exits 2', u(['round', '--choice', '4', '--configured', '2', '--history', '/x']).code === 2);
+  ok('usage: round without --configured exits 2', u(['round', '--choice', '1', '--history', '/x']).code === 2);
+  ok('usage: round with a non-positive --configured exits 2', u(['round', '--choice', '1', '--configured', '0', '--history', '/x']).code === 2);
+  ok('usage: round without --history exits 2', u(['round', '--choice', '1', '--configured', '2']).code === 2);
+  ok('usage: errors go to stderr, stdout stays empty', u(['ask']).errOut.startsWith('usage:') && u(['ask']).out === '');
+  ok('usage: history that is not JSON exits 2', round('{nope', '2', 2).code === 2);
+  ok('usage: history that is not an array exits 2', round({ a: 1 }, '2', 2).code === 2);
+  ok('usage: an empty history exits 2', round([], '2', 2).code === 2);
+  ok('usage: a round that is not an array exits 2', round([{}], '2', 2).code === 2);
+  ok('usage: a concern that is a bare string exits 2', round([['a']], '2', 2).code === 2);
+  ok('usage: a concern with an empty key exits 2', round([[{ key: ' ', text: 'x' }]], '2', 2).code === 2);
+  ok('usage: a concern with an empty text exits 2', round([[{ key: 'a', text: '' }]], '2', 2).code === 2);
+  ok('usage: a concern with a non-string text exits 2', round([[{ key: 'a', text: 3 }]], '2', 2).code === 2);
+  const missing = run(['round', '--choice', '1', '--configured', '2', '--history', '/nowhere/h.json']);
+  ok('usage: a missing history file is status error, exit 1', missing.code === 1 && missing.json.status === 'error');
+}
+
+// --- end-to-end --------------------------------------------------------------
+{
+  const s = setup({ plan_review: 'on' }, null);
+  const bin = tmp();
+  fs.writeFileSync(path.join(bin, 'gemini'), '#!/bin/sh\n', { mode: 0o755 });
+  const res = spawnSync(process.execPath, [scriptPath, 'ask', '--repo', s.root], { encoding: 'utf8', env: { ...process.env, CLAUDE_CONFIG_DIR: s.gdir, PATH: bin } });
+  const j = JSON.parse(res.stdout.trim());
+  ok('e2e: ask prints one JSON line and exits 0', res.status === 0 && j.status === 'ask' && JSON.stringify(j.reviewers) === '["gemini"]' && j.options.length === 4);
+  const dir = tmp();
+  const file = path.join(dir, 'h.json');
+  fs.writeFileSync(file, JSON.stringify([[c('a')]]));
+  const rr = spawnSync(process.execPath, [scriptPath, 'round', '--choice', '1', '--configured', '2', '--history', file], { encoding: 'utf8' });
+  const rj = JSON.parse(rr.stdout.trim());
+  ok('e2e: round prints the decision and exits 0', rr.status === 0 && rj.decision === 'exhausted' && rj.surviving[0].key === 'a');
+  ok('e2e: usage error exits 2', spawnSync(process.execPath, [scriptPath, '--bogus'], { encoding: 'utf8' }).status === 2);
+  const bad = setup('{nope', null);
+  ok('e2e: an invalid config exits 1', spawnSync(process.execPath, [scriptPath, 'ask', '--repo', bad.root], { encoding: 'utf8', env: { ...process.env, CLAUDE_CONFIG_DIR: bad.gdir } }).status === 1);
+  bad.done(); s.done(); rm(bin); rm(dir);
+}
+
+console.log(`plan-review-rounds.test.js: ${passed} checks passed`);

package/plugins/trailhead/hooks/lib/statusline-context.test.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+// Tests for templates/statusline-trailhead.sh (barra contesto, --context-only).
+// Run: node statusline-context.test.js
+// No framework: plain asserts, same style as work-state.test.js.
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const script = path.resolve(__dirname, '..', '..', 'templates', 'statusline-trailhead.sh');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'trailhead-statusline-ctx-'));
+const home = path.join(root, 'home');
+const cfg = path.join(root, 'cfg');
+const proj = path.join(root, 'proj');
+for (const d of [home, cfg, path.join(proj, '.claude')]) fs.mkdirSync(d, { recursive: true });
+
+const SETTINGS = {
+  user: path.join(cfg, 'settings.json'),
+  project: path.join(proj, '.claude', 'settings.json'),
+  local: path.join(proj, '.claude', 'settings.local.json'),
+};
+
+let passed = 0;
+const ok = (name, cond) => { assert.ok(cond, name); passed++; };
+const eq = (name, got, want) => { assert.strictEqual(got, want, `${name}: got ${JSON.stringify(got)}, want ${JSON.stringify(want)}`); passed++; };
+
+function setSettings(files) {
+  for (const f of Object.values(SETTINGS)) fs.rmSync(f, { force: true });
+  for (const [k, v] of Object.entries(files || {})) {
+    fs.writeFileSync(SETTINGS[k], typeof v === 'string' ? v : JSON.stringify(v));
+  }
+}
+
+// Esegue lo script e ritorna { pct, shown, out }
+function ctx(tok, { env = {}, settings = {}, modelId = 'claude-opus-5-5[1m]', size = 1000000 } = {}) {
+  setSettings(settings);
+  const base = { ...process.env };
+  for (const k of ['CLAUDE_CODE_AUTO_COMPACT_WINDOW', 'CLAUDE_AUTOCOMPACT_PCT_OVERRIDE',
+    'DISABLE_AUTO_COMPACT', 'DISABLE_COMPACT', 'CONTEXT_LIMIT', 'CONTEXT_USABLE_RATIO']) delete base[k];
+  const input = {
+    model: { id: modelId, display_name: 'Test' },
+    workspace: { project_dir: proj, current_dir: proj },
+    context_window: { context_window_size: size, current_usage: { input_tokens: tok } },
+  };
+  const r = spawnSync('bash', [script, '--context-only'], {
+    input: JSON.stringify(input),
+    env: { ...base, NO_COLOR: '1', TRAILHEAD_STATUSLINE_USAGE: '0', HOME: home, CLAUDE_CONFIG_DIR: cfg, ...env },
+    encoding: 'utf8',
+  });
+  const out = r.stdout.trim();
+  const m = out.match(/^\[.{10}\] (\d+)k\/(\d+)k \((\d+)%\)$/);
+  assert.ok(m, `unexpected output: ${JSON.stringify(out)} ${r.stderr}`);
+  return { pct: Number(m[3]), shown: `${m[1]}k/${m[2]}k`, out };
+}
+const pct = (tok, o) => ctx(tok, o).pct;
+
+// --- default 1M: soglia = 1M - 33k = 967k ---
+eq('default 966k', pct(966000), 100);
+eq('default 967k', pct(967000), 100);
+eq('default 900k', pct(900000), 93);
+ok('default 800k not 100', pct(800000) < 100);
+eq('display full window', ctx(900000).shown, '900k/1000k');
+
+// --- autoCompactWindow ---
+const win650 = { autoCompactWindow: 650000 };
+eq('top-level 617k', pct(617000, { settings: { user: win650 } }), 100);
+ok('top-level 600k', pct(600000, { settings: { user: win650 } }) < 100);
+const perModel = { modelSettings: { 'claude-opus-5-5': { autoCompactWindow: 650000 } } };
+eq('per-model 617k', pct(617000, { settings: { user: perModel } }), 100);
+ok('per-model 600k', pct(600000, { settings: { user: perModel } }) < 100);
+eq('per-model beats top-level', pct(617000, {
+  settings: { user: { autoCompactWindow: 900000, ...perModel } } }), 100);
+eq('per-model beats top-level (larger top)', pct(300000, {
+  settings: { user: { autoCompactWindow: 400000, modelSettings: { 'claude-opus-5-5': { autoCompactWindow: 1000000 } } } } }), 31);
+eq('local beats user', pct(617000, { settings: { user: { autoCompactWindow: 1000000 }, local: win650 } }), 100);
+eq('local beats project', pct(617000, { settings: { project: { autoCompactWindow: 1000000 }, local: win650 } }), 100);
+eq('project beats user', pct(617000, { settings: { user: { autoCompactWindow: 1000000 }, project: win650 } }), 100);
+eq('invalid json skipped', pct(617000, { settings: { user: win650, local: '{nope' } }), 100);
+eq('non-positive setting ignored', pct(900000, { settings: { user: { autoCompactWindow: -5 } } }), 93);
+eq('non-numeric setting ignored', pct(900000, { settings: { user: { autoCompactWindow: 'big' } } }), 93);
+eq('invalid higher file value falls to lower', pct(617000, {
+  settings: { user: win650, local: { autoCompactWindow: 'x' } } }), 100);
+
+// --- env CLAUDE_CODE_AUTO_COMPACT_WINDOW ---
+eq('env beats setting', pct(617000, { env: { CLAUDE_CODE_AUTO_COMPACT_WINDOW: '650000' },
+  settings: { user: { autoCompactWindow: 1000000 } } }), 100);
+for (const bad of ['abc', '0', '-100']) {
+  eq(`env ${bad} ignored`, pct(900000, { env: { CLAUDE_CODE_AUTO_COMPACT_WINDOW: bad } }), 93);
+}
+eq('env bad falls back to setting', pct(617000, { env: { CLAUDE_CODE_AUTO_COMPACT_WINDOW: 'abc' },
+  settings: { user: win650 } }), 100);
+eq('window above model capped', pct(966000, { env: { CLAUDE_CODE_AUTO_COMPACT_WINDOW: '5000000' } }), 100);
+eq('window above model capped 900k', pct(900000, { env: { CLAUDE_CODE_AUTO_COMPACT_WINDOW: '5000000' } }), 93);
+
+// --- CLAUDE_AUTOCOMPACT_PCT_OVERRIDE ---
+eq('pct 50 at threshold', pct(500000, { env: { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: '50' } }), 100);
+eq('pct 50 at 450k', pct(450000, { env: { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: '50' } }), 90);
+for (const v of ['100', '101', '0', '-3', 'abc']) {
+  eq(`pct ${v} no change`, pct(900000, { env: { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: v } }), 93);
+}
+eq('pct 1 -> threshold 10k', pct(10000, { env: { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: '1' } }), 100);
+eq('pct 1 at 5k', pct(5000, { env: { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: '1' } }), 50);
+
+// --- disabilitato ---
+eq('DISABLE_AUTO_COMPACT', pct(400000, { env: { DISABLE_AUTO_COMPACT: '1' } }), 40);
+eq('DISABLE_COMPACT true', pct(400000, { env: { DISABLE_COMPACT: 'TRUE' } }), 40);
+eq('disabled ignores settings and pct', pct(400000, { env: { DISABLE_AUTO_COMPACT: 'yes', CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: '10' },
+  settings: { user: win650 } }), 40);
+eq('falsy DISABLE ignored', pct(900000, { env: { DISABLE_AUTO_COMPACT: '0' } }), 93);
+eq('DISABLE_COMPACT on', pct(400000, { env: { DISABLE_COMPACT: 'on' } }), 40);
+eq('DISABLE false ignored', pct(900000, { env: { DISABLE_COMPACT: 'false' } }), 93);
+
+// --- per-modello in un file meno specifico batte top-level in uno piu' specifico ---
+eq('per-model user beats top-level local', pct(617000, {
+  settings: { user: perModel, local: { autoCompactWindow: 1000000 } } }), 100);
+
+// --- fallback tabella modello (niente context_window_size): 200k, soglia 167k ---
+eq('model table fallback', pct(100000, { size: 0 }), 60);
+eq('model table fallback display', ctx(100000, { size: 0 }).shown, '100k/200k');
+
+// --- tetto modello ---
+eq('CONTEXT_LIMIT caps display', ctx(100000, { env: { CONTEXT_LIMIT: '200000' } }).shown, '100k/200k');
+eq('CONTEXT_LIMIT pct (threshold 167k)', pct(100000, { env: { CONTEXT_LIMIT: '200000' } }), 60);
+
+// --- override manuale CONTEXT_USABLE_RATIO ---
+eq('ratio 0.8 old behaviour', pct(800000, { env: { CONTEXT_USABLE_RATIO: '0.8' } }), 100);
+eq('ratio 0.8 at 400k', pct(400000, { env: { CONTEXT_USABLE_RATIO: '0.8' } }), 50);
+eq('ratio bypasses window setting', pct(400000, { env: { CONTEXT_USABLE_RATIO: '0.8' }, settings: { user: win650 } }), 50);
+eq('ratio invalid ignored', pct(900000, { env: { CONTEXT_USABLE_RATIO: '2' } }), 93);
+
+// --- bordo soglia: finestra 34k -> soglia 1000 ---
+const edge = { env: { CLAUDE_CODE_AUTO_COMPACT_WINDOW: '34000' } };
+eq('edge threshold-1', pct(994, edge), 99);
+eq('edge threshold', pct(1000, edge), 100);
+// finestra minuscola: soglia mai sotto 1
+eq('tiny window guard', pct(5, { env: { CLAUDE_CODE_AUTO_COMPACT_WINDOW: '10' } }), 100);
+
+fs.rmSync(root, { recursive: true, force: true });
+console.log(`statusline-context.test.js: ${passed} assertions passed`);

package/plugins/trailhead/hooks/lib/uat-followup.test.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+// Tests for templates/trailhead-uat-followup.js (#281). Run: node uat-followup.test.js
+// No framework: plain asserts. A fake tracker sits behind an injected `gh` runner;
+// one end-to-end run uses a fake `gh` on PATH.
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const scriptPath = path.resolve(__dirname, '..', '..', 'templates', 'trailhead-uat-followup.js');
+const { main } = require(scriptPath);
+
+let passed = 0;
+const ok = (name, cond) => { assert.ok(cond, name); passed++; };
+
+// Fake tracker behind `gh api graphql`: answers GraphQL-shaped pages, 'pageSize' issues each,
+// following the `after` cursor (a page index as a string).
+function makeTracker(init = {}) {
+  const t = { issues: init.issues || [], fail: !!init.fail, raw: init.raw, pageSize: init.pageSize || 100, respond: init.respond, calls: [], argLists: [] };
+  t.gh = (args) => {
+    t.calls.push(args.join(' '));
+    t.argLists.push(args);
+    if (t.fail) return { status: 1, stdout: '', stderr: 'forced failure' };
+    if (t.raw !== undefined) return { status: 0, stdout: t.raw, stderr: '' };
+    const afterIdx = args.findIndex((x) => typeof x === 'string' && x.startsWith('after='));
+    const page = afterIdx < 0 ? 0 : Number(args[afterIdx].slice('after='.length));
+    if (t.respond) return { status: 0, stdout: JSON.stringify(t.respond(page)), stderr: '' };
+    const slice = t.issues.slice(page * t.pageSize, (page + 1) * t.pageSize);
+    const more = (page + 1) * t.pageSize < t.issues.length;
+    const pageInfo = { hasNextPage: more, endCursor: more ? String(page + 1) : null };
+    return { status: 0, stdout: JSON.stringify({ data: { repository: { issues: { nodes: slice, pageInfo } } } }), stderr: '' };
+  };
+  return t;
+}
+
+function run(t, argv) {
+  let out = '';
+  let errOut = '';
+  const code = main(argv, { gh: t.gh, stdout: { write: (s) => { out += s; } }, stderr: { write: (s) => { errOut += s; } } });
+  let json = null;
+  try { json = JSON.parse(out.trim()); } catch { /* not json */ }
+  return { code, out, errOut, json };
+}
+
+const URL_ = (n, repo = 'o/r') => `https://github.com/${repo}/issues/${n}`;
+const fu = (number, state, body, title = `UAT ${number}`) => ({ number, title, state, body });
+const base = ['find', '--parent', '281', '--repo', 'o/r'];
+
+// --- matching ----------------------------------------------------------------
+{
+  // A URL whose number runs into letters is not a pointer to that issue.
+  const t = makeTracker({ issues: [fu(310, 'OPEN', 'UAT of: [P](https://github.com/o/r/issues/281abc)')] });
+  const r = run(t, base);
+  ok('URL with trailing letters after the number does not match', r.code === 0 && r.json.open.length === 0 && r.json.reuse === null);
+}
+{
+  const t = makeTracker({ issues: [
+    fu(300, 'OPEN', `Intro\n\nUAT of: [Parent](${URL_(281)})\n\n- [ ] step`),
+    fu(301, 'OPEN', 'UAT of: #281\n- [ ] step'),
+    fu(302, 'OPEN', 'See the UAT of: [P](' + URL_(281) + ') mid-line'),
+    fu(303, 'OPEN', `UAT of: [P](${URL_(28)})`),
+    fu(304, 'OPEN', `UAT of: [P](${URL_(2810)})`),
+    fu(305, 'OPEN', 'UAT of: #28'),
+    fu(306, 'OPEN', 'UAT of: #2810'),
+    fu(307, 'OPEN', `UAT of: [P](${URL_(281, 'other/r')})`),
+    fu(308, 'OPEN', 'no pointer at all'),
+    fu(309, 'OPEN', `UAT of: [P](${URL_(281, 'O/R')})`),
+    fu(310, 'OPEN', `UAT of: [P](${URL_(281)})\r\n- [ ] step`),
+  ] });
+  const r = run(t, base);
+  const nums = r.json.open.map((x) => x.number);
+  ok('matches by URL, by #n, case-insensitive repo, CRLF', JSON.stringify(nums) === '[300,301,309,310]');
+  ok('ignores mid-line, prefix numbers, other repo, no pointer', !nums.some((n) => [302, 303, 304, 305, 306, 307, 308].includes(n)));
+  ok('prints one JSON line with title', r.code === 0 && r.json.status === 'ok' && r.json.parent === 281 && r.json.open[0].title === 'UAT 300' && r.out.trim().split('\n').length === 1);
+  ok('reuse is the lowest open', r.json.reuse === 300);
+  const a0 = t.calls[0];
+  ok('one graphql call with the label and both states, never issue list or search', t.calls.length === 1 && a0.includes('api graphql') && a0.includes('labels:["trailhead:uat"]') && a0.includes('states:[OPEN,CLOSED]') && !a0.includes('issue list') && !a0.includes('--search'));
+  ok('owner and name go as string fields, no cursor on the first page', a0.includes('-f owner=o') && a0.includes('-f name=r') && !a0.includes('after='));
+}
+
+// --- open vs closed ------------------------------------------------------------
+{
+  const t = makeTracker({ issues: [
+    fu(12, 'CLOSED', 'UAT of: #281'),
+    fu(11, 'CLOSED', 'UAT of: #281'),
+    fu(20, 'OPEN', 'UAT of: #281'),
+    fu(15, 'OPEN', 'UAT of: #281'),
+  ] });
+  const r = run(t, base);
+  ok('splits open and closed ascending', JSON.stringify(r.json.open.map((x) => x.number)) === '[15,20]' && JSON.stringify(r.json.closed.map((x) => x.number)) === '[11,12]');
+  ok('reuse picks the lowest open of several', r.json.reuse === 15);
+}
+{
+  const t = makeTracker({ issues: [fu(11, 'CLOSED', 'UAT of: #281')] });
+  const r = run(t, base);
+  ok('only closed: reported, reuse null', r.code === 0 && r.json.closed.length === 1 && r.json.open.length === 0 && r.json.reuse === null);
+}
+{
+  const r = run(makeTracker({ issues: [] }), base);
+  ok('none found: empty lists, reuse null', r.code === 0 && r.json.reuse === null && r.json.open.length === 0 && r.json.closed.length === 0);
+}
+
+// --- errors --------------------------------------------------------------------
+{
+  const r = run(makeTracker({ fail: true }), base);
+  ok('gh failure is a fail-closed error', r.code === 1 && r.json.status === 'error' && typeof r.json.reason === 'string');
+  const b = run(makeTracker({ raw: 'not json' }), base);
+  ok('bad JSON is an error', b.code === 1 && b.json.status === 'error');
+  const o = run(makeTracker({ raw: '{"a":1}' }), base);
+  ok('JSON without data.repository is an error', o.code === 1 && o.json.status === 'error');
+  const er = run(makeTracker({ raw: JSON.stringify({ errors: [{ message: 'boom' }], data: null }) }), base);
+  ok('errors array is an error', er.code === 1 && er.json.status === 'error' && /boom/.test(er.json.reason));
+  const nr = run(makeTracker({ raw: JSON.stringify({ data: { repository: null } }) }), base);
+  ok('null repository is an error', nr.code === 1 && nr.json.status === 'error');
+  const nn = run(makeTracker({ raw: JSON.stringify({ data: { repository: { issues: { pageInfo: { hasNextPage: false, endCursor: null } } } } }) }), base);
+  ok('missing nodes is an error', nn.code === 1 && nn.json.status === 'error');
+  const np = run(makeTracker({ raw: JSON.stringify({ data: { repository: { issues: { nodes: [] } } } }) }), base);
+  ok('missing pageInfo is an error', np.code === 1 && np.json.status === 'error');
+  const nc = run(makeTracker({ raw: JSON.stringify({ data: { repository: { issues: { nodes: [], pageInfo: { hasNextPage: true, endCursor: null } } } } }) }), base);
+  ok('hasNextPage without a cursor is an error', nc.code === 1 && nc.json.status === 'error');
+  const endless = makeTracker({ respond: (p) => ({ data: { repository: { issues: { nodes: [], pageInfo: { hasNextPage: true, endCursor: String(p + 1) } } } } }) });
+  const cap = run(endless, base);
+  ok('page cap exceeded is an error, never a partial answer', cap.code === 1 && cap.json.status === 'error' && /page/.test(cap.json.reason) && endless.calls.length === 100);
+}
+
+// --- pagination ----------------------------------------------------------------
+{
+  const t = makeTracker({ pageSize: 2, issues: [
+    fu(1, 'OPEN', 'x'), fu(2, 'CLOSED', 'x'), fu(3, 'OPEN', 'x'),
+    fu(4, 'OPEN', 'UAT of: #281'), fu(5, 'CLOSED', 'UAT of: #281'),
+  ] });
+  const r = run(t, base);
+  ok('follow-up on a later page is found', r.code === 0 && r.json.reuse === 4 && r.json.closed[0].number === 5);
+  ok('three pages, cursor passed on later ones only', t.calls.length === 3 && !t.calls[0].includes('after=') && t.calls[1].includes('-f after=1') && t.calls[2].includes('-f after=2'));
+  ok('no page uses issue list or search', t.calls.every((c) => c.includes('api graphql') && !c.includes('issue list') && !c.includes('--search')));
+}
+
+// --- usage ---------------------------------------------------------------------
+for (const argv of [
+  [], ['bogus'], ['find'], ['find', '--parent', '281'], ['find', '--repo', 'o/r'],
+  ['find', '--parent', '0', '--repo', 'o/r'], ['find', '--parent', 'abc', '--repo', 'o/r'], ['find', '--parent', '-3', '--repo', 'o/r'],
+  ['find', '--parent', '281', '--repo', 'nope'], ['find', '--parent'], ['find', '--parent', '281', '--repo'],
+  ['find', '--parent', '281', '--repo', 'o/r', '--bogus', 'x'],
+]) {
+  const t = makeTracker();
+  const r = run(t, argv);
+  ok(`usage error exit 2: ${argv.join(' ') || '(none)'}`, r.code === 2 && t.calls.length === 0 && r.errOut.length > 0 && r.out === '');
+}
+
+// --- end-to-end with a fake gh on PATH ------------------------------------------
+{
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'uat-followup-'));
+  const binDir = path.join(tmp, 'bin');
+  fs.mkdirSync(binDir);
+  const payload = JSON.stringify({ data: { repository: { issues: { nodes: [fu(7, 'OPEN', 'UAT of: #281', 'Follow-up')], pageInfo: { hasNextPage: false, endCursor: null } } } } });
+  fs.writeFileSync(path.join(binDir, 'gh'), `#!/bin/sh\ncat <<'EOF_JSON'\n${payload}\nEOF_JSON\n`, { mode: 0o755 });
+  const env = { ...process.env, PATH: binDir + path.delimiter + process.env.PATH };
+  const res = spawnSync('node', [scriptPath, ...base], { encoding: 'utf8', env });
+  ok('e2e: finds the follow-up through gh on PATH', res.status === 0 && JSON.parse(res.stdout.trim()).reuse === 7);
+  fs.writeFileSync(path.join(binDir, 'gh'), '#!/bin/sh\nexit 1\n', { mode: 0o755 });
+  const bad = spawnSync('node', [scriptPath, ...base], { encoding: 'utf8', env });
+  ok('e2e: failing gh exits 1 with a JSON error line', bad.status === 1 && JSON.parse(bad.stdout.trim()).status === 'error');
+  const use = spawnSync('node', [scriptPath, '--bogus'], { encoding: 'utf8' });
+  ok('e2e: usage error exits 2', use.status === 2);
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+console.log(`uat-followup.test.js: ${passed} checks passed`);