@marcomigozzi/trailhead 0.16.1 → 0.18.0

package/plugins/trailhead/hooks/mod/repo-pin.ts

@@ -5,6 +5,8 @@ import { atom, read, update } from 'claude-code'
 import type { EngineInterface } from 'claude-code'
 
 import type { RepoPin } from '../../types'
+import { gitArgv } from './git-env'
+import { parseWorktreeBranches } from './worktree-porcelain'
 import { sameValue } from './work-state-view'
 
 type RepoRead = { root: string; remote: string | null }
@@ -46,13 +48,16 @@ export const nextPin = (current: RepoPin | null, repo: RepoRead | null, toplevel
 }
 
 // The pinned checkout as the trailing word of a verb's args: `--in=` plus base64url of the root (alphabet
-// [A-Za-z0-9_-], no padding), so a path with spaces, quotes or a leading `-` stays one shell-safe word. The verb
-// decodes it with templates/trailhead-checkout-in.js and moves there first (#312).
+// [A-Za-z0-9_-], no padding), so a path with spaces, quotes or a leading `-` stays one shell-safe word, then `.` and
+// base64url of `host/owner/name` (`.` is outside the alphabet, so it separates unambiguously). The verb decodes it
+// with templates/trailhead-checkout-in.js and moves there first; when the root is gone, the repo part lets the
+// helper find the checkout by its remote (#312, #329).
 // No Buffer in the mod's runtime: UTF-8 bytes through btoa, then the url-safe alphabet.
-export const checkoutArg = (pin: RepoPin): string => {
-  const binary = Array.from(new TextEncoder().encode(pin.root), byte => String.fromCharCode(byte)).join('')
-  return `--in=${btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')}`
+const base64url = (text: string): string => {
+  const binary = Array.from(new TextEncoder().encode(text), byte => String.fromCharCode(byte)).join('')
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
 }
+export const checkoutArg = (pin: RepoPin): string => `--in=${base64url(pin.root)}.${base64url(pinKey(pin))}`
 
 // A repo-relative path under the pinned root, absolute whatever the session cwd is.
 export const pinPath = (pin: RepoPin, relative: string): string => `${pin.root.replace(/\/+$/, '')}/${relative}`
@@ -68,7 +73,7 @@ let remembered: RepoPin | null = null
 // the caller falls back.
 export async function toplevelOf($: EngineInterface): Promise<string | null> {
   try {
-    const out = await $.process.run(['git', 'rev-parse', '--show-toplevel'], { cwd: await $.session.cwd(), timeoutMs: 5_000 })
+    const out = await $.process.run(gitArgv('rev-parse', '--show-toplevel'), { cwd: await $.session.cwd(), timeoutMs: 5_000 })
     const top = out.stdout.trim()
     return out.exitCode === 0 && top.startsWith('/') ? top : null
   } catch {
@@ -92,9 +97,9 @@ async function gitRepo($: EngineInterface): Promise<{ repo: RepoRead; toplevel:
   try {
     const cwd = await $.session.cwd()
     const run = (argv: string[]) => $.process.run(argv, { cwd, timeoutMs: 5_000 })
-    const top = await run(['git', 'rev-parse', '--show-toplevel'])
+    const top = await run(gitArgv('rev-parse', '--show-toplevel'))
     if (repoFromGit(top, null) === null) return null
-    const repo = repoFromGit(top, await run(['git', 'remote', 'get-url', 'origin']))
+    const repo = repoFromGit(top, await run(gitArgv('remote', 'get-url', 'origin')))
     return repo === null ? null : { repo, toplevel: repo.root }
   } catch {
     return null
@@ -136,10 +141,107 @@ async function isServed($: EngineInterface, host: string, cwd: string): Promise<
   }
 }
 
+// The pinned checkout deleted under the session (a finished worktree, a removed clone): the pin moves to a live
+// checkout of the same repo (#347). Preferred in order: the main working tree, another worktree, the sibling
+// clone itself. Candidates are the repo's root as the host knows it and the folders beside the dead root; every
+// probe is `git -C <path>` from `/`, never a spawn in the dead directory. null when nothing is left.
+const MAX_SIBLINGS = 100
+const parentOf = (path: string): string => path.replace(/\/+$/, '').replace(/\/[^/]*$/, '') || '/'
+
+async function checkoutOf($: EngineInterface, path: string, key: string): Promise<string | null> {
+  try {
+    const run = (args: string[]) => $.process.run(gitArgv('-C', path, ...args), { cwd: '/', timeoutMs: 5_000 })
+    const top = await run(['rev-parse', '--show-toplevel'])
+    if (top.exitCode !== 0 || !top.stdout.trim().startsWith('/')) return null
+    const origin = await run(['remote', 'get-url', 'origin'])
+    const id = remoteId(origin.exitCode === 0 ? origin.stdout : null)
+    return id !== null && `${id.host}/${id.slug}` === key ? top.stdout.trim() : null
+  } catch {
+    return null
+  }
+}
+
+async function exists($: EngineInterface, path: string): Promise<boolean> {
+  try {
+    return await $.fs.exists(path)
+  } catch {
+    return true // unreadable: do not move the pin on a guess
+  }
+}
+
+async function siblingsOf($: EngineInterface, dir: string): Promise<string[]> {
+  try {
+    const entries = await $.fs.list(dir)
+    return entries.filter(e => e.kind === 'dir' && !e.name.startsWith('.')).slice(0, MAX_SIBLINGS).map(e => `${dir.replace(/\/+$/, '')}/${e.name}`)
+  } catch {
+    return []
+  }
+}
+
+async function liveCheckout($: EngineInterface, pin: RepoPin): Promise<string | null> {
+  const key = pinKey(pin)
+  const seeds: string[] = []
+  try {
+    const host = await $.session.repo()
+    if (host !== null && host.root !== pin.root) seeds.push(host.root)
+  } catch {
+    // The host read failed: the neighbours still answer.
+  }
+  seeds.push(...(await siblingsOf($, parentOf(pin.root))))
+  for (const seed of seeds) {
+    if (seed === pin.root || !(await exists($, seed))) continue
+    const top = await checkoutOf($, seed, key)
+    if (top === null) continue
+    // The seed's own worktree list names the main tree first, then the others.
+    const listed = await $.process.run(gitArgv('-C', top, 'worktree', 'list', '--porcelain'), { cwd: '/', timeoutMs: 5_000 }).catch(() => null)
+    const paths = listed !== null && listed.exitCode === 0 ? parseWorktreeBranches(listed.stdout).map(w => w.path) : []
+    for (const path of [...paths, top]) {
+      if (path === pin.root || !(await exists($, path))) continue
+      const checkout = path === top ? top : await checkoutOf($, path, key)
+      if (checkout !== null) return checkout
+    }
+  }
+  return null
+}
+
+// The pin as it stands, or the live checkout of its repo when its root is gone. Both outcomes are cached per
+// repo and dead root, since the host's memoized repo keeps naming the dead root and every refresh asks again: a hit
+// is revalidated by one exists check, a miss is not searched again within RELOCATE_RETRY_MS (a search spawns git
+// per sibling). Reset at a session start.
+const RELOCATE_RETRY_MS = 60_000
+const missed = new Map<string, number>()
+const relocated = new Map<string, string>()
+const relocationKey = (pin: RepoPin): string => `${pinKey(pin)}|${pin.root}`
+
+export async function livePin($: EngineInterface, pin: RepoPin): Promise<RepoPin> {
+  if (await exists($, pin.root)) return pin
+  const key = relocationKey(pin)
+  const known = relocated.get(key)
+  if (known !== undefined) {
+    if (await exists($, known)) return { ...pin, root: known }
+    relocated.delete(key)
+  }
+  const now = await $.clock.now().catch(() => null)
+  const last = missed.get(key)
+  if (now !== null && last !== undefined && now - last < RELOCATE_RETRY_MS) return pin
+  const root = await liveCheckout($, pin).catch(() => null)
+  if (root === null) {
+    if (now !== null) missed.set(key, now)
+    return pin
+  }
+  missed.delete(key)
+  relocated.set(key, root)
+  return { ...pin, root }
+}
+
 // Checks the working copy now and pins what it finds; a failed read keeps the last pin. The host's
 // `session.repo()` can stay null for a repo created mid-session, so git in the cwd answers then (#299). A session
 // start begins from nothing: the pin of an earlier session is not this one's.
 export async function refreshPin($: EngineInterface, init: { isStart?: boolean; onMove?: (pin: RepoPin | null) => Promise<void> } = {}): Promise<RepoPin | null> {
+  if (init.isStart === true) {
+    missed.clear()
+    relocated.clear()
+  }
   const stored = await read($, repoPin)
   const current = init.isStart === true ? null : (stored ?? remembered)
   let repo: RepoRead | null = null
@@ -156,7 +258,9 @@ export async function refreshPin($: EngineInterface, init: { isStart?: boolean;
   } catch {
     // Unreadable repo: keep the last pin.
   }
-  const pin = nextPin(current, repo, toplevel)
+  const next = nextPin(current, repo, toplevel)
+  // The pin, kept or freshly read (the host's memoized repo can keep naming a deleted root), may be gone.
+  const pin = next === null ? null : await livePin($, next)
   remembered = pin
   if (!sameValue(stored, pin)) {
     // Right before the atom changes, whoever moves it, so what was read for the old pin goes no later than the change.

package/plugins/trailhead/hooks/mod/work-state-locate.ts

@@ -3,6 +3,7 @@
 // may sit in the main checkout. Pure parts first, then the engine part that looks the state up.
 import type { EngineInterface } from 'claude-code'
 
+import { gitArgv } from './git-env'
 import { isMissing, parseWorkState } from './work-state-view'
 import { MAX_FAILURES, parseWorktreeBranches } from './worktree-porcelain'
 
@@ -91,7 +92,7 @@ async function nowOf($: EngineInterface): Promise<number | null> {
 // null: the listing itself failed (not the same as an empty one). Path and branch of each checkout.
 export async function listWorktreeBranches($: EngineInterface, root: string): Promise<{ path: string; branch: string | null }[] | null> {
   try {
-    const out = await $.process.run(['git', 'worktree', 'list', '--porcelain'], { cwd: root, timeoutMs: LOOKUP_TIMEOUT_MS })
+    const out = await $.process.run(gitArgv('worktree', 'list', '--porcelain'), { cwd: root, timeoutMs: LOOKUP_TIMEOUT_MS })
     return out.exitCode === 0 ? parseWorktreeBranches(out.stdout) : null
   } catch {
     return null

package/plugins/trailhead/hooks/trailhead-bash-guards.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 // trailhead-bash-guards.js: PreToolUse(Bash) hook.
-// One process for the six Bash guards (commit, secret, install, search, body, labels)
-// instead of six: each Bash call pays a single node start-up. The guards keep
+// One process for the seven Bash guards (commit, secret, install, search, body, labels, test)
+// instead of seven: each Bash call pays a single node start-up. The guards keep
 // their own modules and verdicts; this runner only calls each one's pure
-// evaluate(cmd) in a fixed order (commit, secret, install, search, body, labels).
+// evaluate(cmd) in a fixed order (commit, secret, install, search, body, labels, test).
 //   - First block wins: its payload goes to stdout and the hook exits 2; later
 //     guards do not run. An earlier advisory keeps its stderr line.
 //   - No block: advisories (secret-guard's "could not scan") surface on stderr
@@ -11,9 +11,9 @@
 //   - Failure posture is unchanged per guard: a throwing guard counts as allow
 //     and the others still run; a guard module that fails to load is skipped
 //     with a one-line stderr warning.
-//   - --guards=<name,...> picks the guards (default: all six). The Codex install
-//     ships no search-guard and registers --guards=commit,secret,install,body,labels.
-//     A missing, empty, malformed or unknown-name list falls back to all six, so
+//   - --guards=<name,...> picks the guards (default: all seven). The Codex install
+//     ships no search-guard and registers --guards=commit,secret,install,body,labels,test.
+//     A missing, empty, malformed or unknown-name list falls back to all seven, so
 //     a config typo never disables a guard.
 //   - TRAILHEAD_MOD_GUARDS=<name,...>@<epoch-ms>: the mod (which has ported those
 //     guards) stamps the guards it already ran; a stamp no older than
@@ -22,7 +22,7 @@
 // Crash-safe: unparseable input or any internal error -> exit 0.
 // Self-contained, no dependencies. Pure functions are exported for tests.
 
-const GUARD_ORDER = ['commit', 'secret', 'install', 'search', 'body', 'labels'];
+const GUARD_ORDER = ['commit', 'secret', 'install', 'search', 'body', 'labels', 'test'];
 const MOD_GUARDS_FRESH_MS = 5000;
 const MOD_GUARDS_RE = /^([a-z][a-z0-9-]*(?:,[a-z][a-z0-9-]*)*)@(\d+)$/;
 
@@ -37,7 +37,7 @@ function parseModGuards(value, now = Date.now()) {
 }
 
 // Guards selected by --guards=<name,...>, in canonical order. Anything but a
-// well-formed list of known names means all six.
+// well-formed list of known names means all seven.
 function parseGuardsArg(argv) {
   const arg = argv.find((a) => a.startsWith('--guards='));
   if (!arg) return GUARD_ORDER;

package/plugins/trailhead/hooks/trailhead-bash-guards.test.js

@@ -19,7 +19,7 @@ const eq = (name, actual, expected) => { assert.deepStrictEqual(actual, expected
 // Run the merged hook end-to-end: tool_input JSON on stdin, capture {code, out, err}.
 function runHook(command, { env = {}, args = [], hook = HOOK, cwd } = {}) {
   const input = JSON.stringify({ tool_input: { command }, ...(cwd ? { cwd } : {}) });
-  const r = spawnSync('node', [hook, ...args], { input, env: { ...process.env, ...env } });
+  const r = spawnSync('node', [hook, ...args], { input, env: { ...process.env, CLAUDE_CONFIG_DIR: NO_GLOBAL, ...env } });
   return { code: r.status, out: r.stdout.toString(), err: r.stderr.toString() };
 }
 const codeOf = (r) => (r.out ? JSON.parse(r.out).code : undefined);
@@ -31,9 +31,20 @@ const BAD_INSTALL = 'npm install left-pad';
 const BAD_SEARCH = 'cd x && grep y z';
 const BAD_BODY = 'gh issue edit 5 --body ""';
 const BAD_LABELS = 'gh issue create --title x --body y --label trailhead:bug';
+const BAD_TEST = 'npm test 2>&1 | tail -20';
+
+// A scratch trailhead repo whose config sets testing.full, and an empty global config dir so
+// the developer's own config never leaks into the probes.
+const SCRATCH = fs.mkdtempSync(path.join(os.tmpdir(), 'tb-test-guard-'));
+const TEST_REPO = path.join(SCRATCH, 'repo');
+fs.mkdirSync(path.join(TEST_REPO, '.git'), { recursive: true });
+fs.mkdirSync(path.join(TEST_REPO, '.trailhead'));
+fs.writeFileSync(path.join(TEST_REPO, '.trailhead', 'config.json'), JSON.stringify({ testing: { full: 'npm test' } }));
+const NO_GLOBAL = path.join(SCRATCH, 'no-global');
+fs.mkdirSync(NO_GLOBAL);
 
 // --- unit: constants ---
-eq('guard order is fixed', GUARD_ORDER, ['commit', 'secret', 'install', 'search', 'body', 'labels']);
+eq('guard order is fixed', GUARD_ORDER, ['commit', 'secret', 'install', 'search', 'body', 'labels', 'test']);
 ok('freshness window is 5s', MOD_GUARDS_FRESH_MS === 5000);
 
 // --- unit: parseModGuards ---
@@ -49,10 +60,10 @@ for (const bad of ['commit', '@123', 'commit@abc', ',@1', '', undefined, 'commit
 eq('unknown names are ignored', [...parseModGuards(`commit,bogus@${NOW}`, NOW)], ['commit']);
 
 // --- unit: parseGuardsArg ---
-eq('no --guards -> all six', parseGuardsArg([]), GUARD_ORDER);
+eq('no --guards -> all seven', parseGuardsArg([]), GUARD_ORDER);
 eq('valid subset keeps canonical order', parseGuardsArg(['--guards=body,commit']), ['commit', 'body']);
-eq('empty --guards -> all six', parseGuardsArg(['--guards=']), GUARD_ORDER);
-eq('malformed --guards -> all six', parseGuardsArg(['--guards=commit,,body']), GUARD_ORDER);
+eq('empty --guards -> all seven', parseGuardsArg(['--guards=']), GUARD_ORDER);
+eq('malformed --guards -> all seven', parseGuardsArg(['--guards=commit,,body']), GUARD_ORDER);
 eq('any unknown name invalidates the whole list', parseGuardsArg(['--guards=commit,secert']), GUARD_ORDER);
 
 // --- unit: runGuards with fake evaluators ---
@@ -66,7 +77,7 @@ const blocker = (code) => () => ({ kind: 'block', payload: { decision: 'block',
     evaluators: {
       commit: spy('commit', () => { throw new Error('boom'); }),
       secret: spy('secret', allow), install: spy('install', blocker('I')),
-      search: spy('search', blocker('S')), body: spy('body', allow), labels: spy('labels', allow),
+      search: spy('search', blocker('S')), body: spy('body', allow), labels: spy('labels', allow), test: spy('test', allow),
     },
   });
   eq('a throwing guard counts as allow and the next one still blocks', r.code, 2);
@@ -76,7 +87,7 @@ const blocker = (code) => () => ({ kind: 'block', payload: { decision: 'block',
 {
   const r = runGuards('x', {
     now: NOW, env: { TRAILHEAD_MOD_GUARDS: `commit@${NOW}` },
-    evaluators: { commit: blocker('C'), secret: allow, install: allow, search: allow, body: allow, labels: allow },
+    evaluators: { commit: blocker('C'), secret: allow, install: allow, search: allow, body: allow, labels: allow, test: allow },
   });
   eq('a fresh stamp skips the listed guard', r.code, 0);
 }
@@ -84,7 +95,7 @@ const blocker = (code) => () => ({ kind: 'block', payload: { decision: 'block',
   const adv = (t) => () => ({ kind: 'advise', stderr: `${t}\n`, payload: { hookSpecificOutput: { additionalContext: t } } });
   const r = runGuards('x', {
     now: NOW, env: {},
-    evaluators: { commit: adv('a'), secret: adv('b'), install: allow, search: allow, body: allow, labels: allow },
+    evaluators: { commit: adv('a'), secret: adv('b'), install: allow, search: allow, body: allow, labels: allow, test: allow },
   });
   eq('advisories exit 0', r.code, 0);
   eq('advisory stderr lines are all written', r.stderr, 'a\nb\n');
@@ -98,11 +109,13 @@ const { evaluate: evInstall } = require('./trailhead-install-guard.js');
 const { evaluate: evSearch } = require('./trailhead-search-guard.js');
 const { evaluate: evBody } = require('./trailhead-body-guard.js');
 const { evaluate: evLabels } = require('./trailhead-labels-guard.js');
+const { evaluate: evTest } = require('./trailhead-test-guard.js');
 for (const [name, cmd, ev] of [
   ['commit', BAD_COMMIT, evCommit], ['secret', BAD_SECRET, evSecret], ['install', BAD_INSTALL, evInstall],
   ['search', BAD_SEARCH, evSearch], ['body', BAD_BODY, evBody], ['labels', BAD_LABELS, evLabels],
+  ['test', BAD_TEST, (c) => evTest(c, { cwd: TEST_REPO, env: { CLAUDE_CONFIG_DIR: NO_GLOBAL } })],
 ]) {
-  const r = runHook(cmd);
+  const r = runHook(cmd, name === 'test' ? { cwd: TEST_REPO } : {});
   const want = ev(cmd);
   ok(`${name}: evaluator blocks the probe`, want.kind === 'block');
   eq(`${name}: exit 2`, r.code, 2);
@@ -171,19 +184,19 @@ for (const [name, cmd, ev] of [
     const hook = path.join(tmp, 'trailhead-bash-guards.js');
     fs.rmSync(path.join(tmp, 'trailhead-search-guard.js'));
 
-    const codex = runHook(BAD_SEARCH, { hook, args: ['--guards=commit,secret,install,body,labels'] });
+    const codex = runHook(BAD_SEARCH, { hook, args: ['--guards=commit,secret,install,body,labels,test'] });
     eq('--guards without search never loads search-guard', codex.code, 0);
     eq('--guards without search: no warning', codex.err, '');
-    const still = runHook(BAD_INSTALL, { hook, args: ['--guards=commit,secret,install,body,labels'] });
+    const still = runHook(BAD_INSTALL, { hook, args: ['--guards=commit,secret,install,body,labels,test'] });
     eq('--guards subset still blocks with its guards', still.code, 2);
     const only = runHook(BAD_INSTALL, { hook, args: ['--guards=commit'] });
     eq('unselected guards do not run', only.code, 0);
 
     for (const bad of ['--guards=', '--guards=commit,secert', '--guards=commit,,body']) {
       const r = runHook(BAD_INSTALL, { hook, args: [bad] });
-      eq(`${bad}: falls back to all six (install blocks)`, r.code, 2);
+      eq(`${bad}: falls back to all seven (install blocks)`, r.code, 2);
       const clean = runHook('git status', { hook, args: [bad] });
-      ok(`${bad}: all six are selected (the missing search module is reported)`, /search/.test(clean.err));
+      ok(`${bad}: all seven are selected (the missing search module is reported)`, /search/.test(clean.err));
     }
 
     const missing = runHook(`${BAD_BODY} && ${BAD_SEARCH}`, { hook });
@@ -217,13 +230,14 @@ for (const [name, cmd, ev] of [
 // Run from a scratch dir outside any trailhead repo: those suites open unlabelled issues, which
 // the labels guard (rightly) blocks inside a trailhead repo.
 const SUITE_CWD = fs.mkdtempSync(path.join(os.tmpdir(), 'tb-suites-'));
-for (const name of ['commit', 'secret', 'install', 'search', 'body', 'labels']) {
+for (const name of ['commit', 'secret', 'install', 'search', 'body', 'labels', 'test']) {
   const file = path.join(__dirname, `trailhead-${name}-guard.test.js`);
   const r = spawnSync('node', [file], { cwd: SUITE_CWD, env: { ...process.env, TRAILHEAD_GUARD_HOOK: HOOK } });
   if (r.status !== 0) process.stderr.write(r.stdout.toString() + r.stderr.toString());
   eq(`${name}-guard suite passes through the merged hook`, r.status, 0);
 }
 fs.rmSync(SUITE_CWD, { recursive: true, force: true });
+fs.rmSync(SCRATCH, { recursive: true, force: true });
 
 // --- registration: one Bash entry, one command (the merged hook) ---
 {

package/plugins/trailhead/hooks/trailhead-check-update.js

@@ -11,6 +11,8 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execFileSync } = require('child_process');
+// Un GIT_DIR ereditato batterebbe -C: le chiamate git non lo seguono (#349).
+const { gitEnv } = require('./lib/trailhead-git-env.js');
 
 const REPO = 'ToRvaLDz/trailhead';
 const NPM_PKG = '@marcomigozzi/trailhead';
@@ -33,7 +35,7 @@ function readJSON(p) {
 }
 function run(cmd, args) {
   try {
-    return execFileSync(cmd, args, { encoding: 'utf8', timeout: 8000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    return execFileSync(cmd, args, { encoding: 'utf8', env: gitEnv(), timeout: 8000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
   } catch { return ''; }
 }
 const SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
@@ -186,6 +188,21 @@ function labelGuardNotice(cwd) {
   }
 }
 
+// Preflight dell'auth di gh (#328): un GH_TOKEN/GITHUB_TOKEN non valido che
+// oscura il login gh funzionante fa fallire ogni chiamata gh; lo segnaliamo
+// una volta, all'avvio (la lib salta resume e compact). Come reviewNotice: il
+// require e' nel try, ogni errore -> null.
+function authNotice(input) {
+  try {
+    return require('./lib/gh-auth-preflight.js').check({
+      env: process.env,
+      source: input && typeof input.source === 'string' ? input.source : undefined,
+    }) || null;
+  } catch {
+    return null;
+  }
+}
+
 // Legge il JSON di SessionStart da stdin in modo asincrono, con timeout, come
 // gli altri hook: una lettura sincrona di fd 0 si bloccherebbe per sempre su
 // un TTY o su una pipe mai chiusa. Su TTY o input assente si prosegue con {}.
@@ -212,11 +229,12 @@ function readInput(done) {
 function main(input) {
   const cwd = (input && typeof input.cwd === 'string' && input.cwd) || process.cwd();
 
+  const auth = authNotice(input);
   const review = reviewNotice(cwd);
   const guard = labelGuardNotice(cwd);
   const update = updateNotice();
 
-  const parts = [review, guard, update].filter(Boolean);
+  const parts = [auth, review, guard, update].filter(Boolean);
   if (!parts.length) return;
 
   process.stdout.write(JSON.stringify({

package/plugins/trailhead/hooks/trailhead-check-update.test.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+// Test dell'hook SessionStart trailhead-check-update.js (notice auth di gh).
+// Run: node trailhead-check-update.test.js
+// Un gh finto in una bin dir tmp (prima nel PATH) applica la precedenza reale.
+const assert = require('assert');
+const { execFileSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+let passed = 0;
+const ok = (name, cond) => { assert.ok(cond, name); passed++; };
+
+const hookPath = path.join(__dirname, 'trailhead-check-update.js');
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'trailhead-check-update-test-'));
+const bin = path.join(tmp, 'bin');
+fs.mkdirSync(bin);
+const fakeGh = `#!${process.execPath}
+const a = process.argv.slice(2);
+if (a[0] !== 'api' || a[1] !== 'user') process.exit(1); // altre chiamate (update check): innocue
+const t = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+const v = t ? t : (process.env.FAKE_GH_STORED || 'bad');
+if (v === 'good') { console.log('octo'); process.exit(0); }
+console.log('{"message":"Bad credentials","status":"401"}');
+console.error('gh: Bad credentials (HTTP 401)');
+process.exit(1);
+`;
+fs.writeFileSync(path.join(bin, 'gh'), fakeGh, { mode: 0o755 });
+
+const repo = path.join(tmp, 'repo');
+execFileSync('git', ['init', '-q', repo]);
+
+function run(source, extraEnv) {
+  const env = { ...process.env, ...extraEnv };
+  delete env.GH_TOKEN; delete env.GITHUB_TOKEN;
+  Object.assign(env, extraEnv, {
+    PATH: `${bin}${path.delimiter}${process.env.PATH}`,
+    XDG_CACHE_HOME: path.join(tmp, 'cache'),
+    CLAUDE_CONFIG_DIR: path.join(tmp, 'cfg'),
+  });
+  const input = { cwd: repo };
+  if (source) input.source = source;
+  const out = execFileSync('node', [hookPath], { input: JSON.stringify(input), encoding: 'utf8', env });
+  return out ? JSON.parse(out).hookSpecificOutput.additionalContext : '';
+}
+const AUTH = 'GitHub rejects the';
+
+for (const source of ['startup', 'clear', undefined]) {
+  const ctx = run(source, { GITHUB_TOKEN: 'bad', FAKE_GH_STORED: 'good' });
+  ok(`source ${source}: auth notice surfaced`, ctx.includes(`${AUTH} GITHUB_TOKEN`) && ctx.includes('GITHUB_TOKEN= gh'));
+  ok(`source ${source}: token value not leaked`, !ctx.includes('bad'));
+}
+for (const source of ['resume', 'compact']) {
+  ok(`source ${source}: no auth notice`, !run(source, { GITHUB_TOKEN: 'bad', FAKE_GH_STORED: 'good' }).includes(AUTH));
+}
+ok('no token var: no auth notice', !run('startup', { FAKE_GH_STORED: 'good' }).includes(AUTH));
+ok('valid token: no auth notice', !run('startup', { GITHUB_TOKEN: 'good' }).includes(AUTH));
+
+fs.rmSync(tmp, { recursive: true, force: true });
+console.log(`trailhead-check-update: ${passed} passed`);

package/plugins/trailhead/hooks/trailhead-labels-guard.js

@@ -10,7 +10,7 @@
 //     prototype | build | bug | task, and exactly one of `trailhead:map-<n>` |
 //     `trailhead:whiteboard` (never both, never two maps). Non-ticket trailhead issues
 //     (`trailhead:map`, `trailhead:dashboard`, `trailhead:codebase`,
-//     `trailhead:conventions`, and `trailhead:fog` / `trailhead:unverified`) are exempt.
+//     `trailhead:conventions`, and `trailhead:fog` / `trailhead:needs-info` / `trailhead:unverified`) are exempt.
 //     State labels (blocked, seed, paused, ...) are allowed extras and never count
 //     toward the shape. This rule applies in any repo.
 //   - A create with NO `trailhead:*` label is blocked too, but only inside a trailhead
@@ -36,7 +36,7 @@ const { words, parseRedirects } = require('./lib/body-sources.js');
 
 const PLAIN_SENTINEL = /(?:^|\s)TRAILHEAD_PLAIN_ISSUE=1(?:\s|$)/;
 const TYPES = ['decision', 'research', 'prototype', 'build', 'bug', 'task'];
-const EXEMPT = ['trailhead:map', 'trailhead:dashboard', 'trailhead:codebase', 'trailhead:conventions', 'trailhead:fog', 'trailhead:unverified'];
+const EXEMPT = ['trailhead:map', 'trailhead:dashboard', 'trailhead:codebase', 'trailhead:conventions', 'trailhead:fog', 'trailhead:needs-info', 'trailhead:unverified'];
 const MAP_RE = /^trailhead:map-\d+$/;
 const WHITEBOARD = 'trailhead:whiteboard';
 const TYPE_LIST = TYPES.map((t) => `trailhead:${t}`).join(' | ');

package/plugins/trailhead/hooks/trailhead-labels-guard.test.js

@@ -104,7 +104,7 @@ ok('a seed without type is blocked', blocked(create(['trailhead:ticket', 'trailh
 }
 
 // --- non-ticket trailhead issues are exempt ---
-for (const l of ['trailhead:map', 'trailhead:dashboard', 'trailhead:codebase', 'trailhead:conventions', 'trailhead:fog', 'trailhead:unverified']) {
+for (const l of ['trailhead:map', 'trailhead:dashboard', 'trailhead:codebase', 'trailhead:conventions', 'trailhead:fog', 'trailhead:needs-info', 'trailhead:unverified']) {
   ok(`${l} create passes`, !blocked(create([l]), TH));
 }
 ok('map issue with extra labels passes', !blocked(create(['trailhead:map', 'trailhead:paused']), TH));