@marcomigozzi/trailhead 0.16.1 → 0.18.0

package/plugins/trailhead/templates/trailhead-checkout-in.js

@@ -4,35 +4,62 @@
 // install channel). The panel cannot move the session's directory, so it hands the
 // pinned checkout to `work` / `resume` as a trailing `--in=<token>` word and the
 // verb moves there first. This helper decodes the token, validates it and says
-// whether the session is already there. It fails closed: it never searches for
-// another checkout. #312.
+// whether the session is already there. It fails closed: never a blind search for
+// another checkout, only a lookup by the repo's origin remote when the path is gone
+// and the token names the repo (trailhead-checkout-find.js). #312, #329.
 //
 // The token is base64url(path) (alphabet [A-Za-z0-9_-], no padding), so a path
-// with spaces, quotes or a leading `-` travels as one shell-safe word.
+// with spaces, quotes or a leading `-` travels as one shell-safe word. It may carry
+// the repo identity as a second part: base64url(path) + '.' + base64url(host/owner/name)
+// (`.` is outside the alphabet, so an old helper rejects it and stays fail-closed).
 //
 // CLI:
-//   node trailhead-checkout-in.js --in <b64url> --cwd <dir>
+//   node trailhead-checkout-in.js --in <token> --cwd <dir> [--roots <a:b>]
+// `--roots` replaces the default search roots of the remote lookup (tests).
 //
 // Prints exactly one JSON line on stdout:
-//   {"status":"here"|"move"|"invalid","path":"...","reason":"...","cd":"..."}
+//   {"status":"here"|"move"|"choose"|"invalid","path":"...","reason":"...","cd":"..."}
 // `cd` is present on `move` only: a ready-to-run, single-quote-escaped command.
-// Exit 0 for the three statuses, 2 on a usage error (stderr).
+// `relocatedFrom` (the old path) is added to `here`/`move` when the checkout was
+// found by its remote. `choose` (path gone, several checkouts match) carries
+// `candidates` ([{path, kind}]) and `reason`.
+// Exit 0 for the four statuses, 2 on a usage error (stderr).
 
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { gitEnv } = require('./trailhead-git-env.js');
+
+const { findCheckouts, parseRepoShape } = require('./trailhead-checkout-find.js');
 
 const PREFIX = '--in=';
 
-function encodeIn(p) {
-  return PREFIX + Buffer.from(String(p), 'utf8').toString('base64url');
+const b64 = (s) => Buffer.from(String(s), 'utf8').toString('base64url');
+
+function encodeIn(p, repo) {
+  return PREFIX + b64(p) + (repo ? '.' + b64(repo) : '');
+}
+
+// One base64url part back to its string, or null when it is not canonical.
+function decodePart(part) {
+  if (!/^[A-Za-z0-9_-]+$/.test(part)) return null;
+  const s = Buffer.from(part, 'base64url').toString('utf8');
+  // Round-trip guard: a part that does not re-encode to itself is not ours.
+  return s !== '' && b64(s) === part ? s : null;
 }
 
+// {path, repo} (repo null for a one-part token), or null for a malformed token.
 function decodeIn(token) {
-  if (typeof token !== 'string' || !/^[A-Za-z0-9_-]+$/.test(token)) return null;
-  const p = Buffer.from(token, 'base64url').toString('utf8');
-  // Round-trip guard: a token that does not re-encode to itself is not ours.
-  return p !== '' && Buffer.from(p, 'utf8').toString('base64url') === token ? p : null;
+  if (typeof token !== 'string') return null;
+  const parts = token.split('.');
+  if (parts.length > 2) return null;
+  const p = decodePart(parts[0]);
+  if (p === null) return null;
+  if (parts.length === 1) return { path: p, repo: null };
+  const repo = decodePart(parts[1]);
+  // The repo part is `host/owner/name` by shape (the host may be dotless, e.g. `gitea`).
+  if (repo === null || parseRepoShape(repo) === null) return null;
+  return { path: p, repo };
 }
 
 function real(p) {
@@ -44,7 +71,7 @@ function real(p) {
 }
 
 function toplevelOf(dir) {
-  const r = spawnSync('git', ['-C', dir, 'rev-parse', '--show-toplevel'], { encoding: 'utf8' });
+  const r = spawnSync('git', ['-C', dir, 'rev-parse', '--show-toplevel'], { encoding: 'utf8', env: gitEnv() });
   if (r.status !== 0) return null;
   const top = r.stdout.replace(/\n$/, '');
   return top === '' ? null : real(top);
@@ -55,12 +82,8 @@ function cdCommand(p) {
   return `cd -- '${p.replace(/'/g, `'\\''`)}'`;
 }
 
-function check(token, cwd) {
-  const p = decodeIn(token);
-  if (p === null) return { status: 'invalid', path: '', reason: 'the token does not decode to a path' };
-  if (!path.isAbsolute(p)) return { status: 'invalid', path: p, reason: 'the path is not absolute' };
-  const canon = real(p);
-  if (canon === null) return { status: 'invalid', path: p, reason: 'the path does not exist' };
+// here/move for a path that must be a checkout root.
+function resolveRoot(p, canon, cwd) {
   // The path must be a checkout root itself, never a folder inside one.
   if (toplevelOf(p) !== canon) return { status: 'invalid', path: p, reason: 'the path is not the root of a git checkout' };
   const here = real(cwd) !== null ? toplevelOf(cwd) : null;
@@ -68,6 +91,38 @@ function check(token, cwd) {
   return { status: 'move', path: p, cd: cdCommand(p) };
 }
 
+// The path is gone: look the repo up by its remote (only when the token names it).
+function relocate(old, repo, cwd, opts) {
+  const found = findCheckouts(parseRepoShape(repo), opts.roots ? { roots: opts.roots } : { cwd });
+  if (found.status === 'found') {
+    const root = resolveRoot(found.path, found.path, cwd);
+    return { ...root, relocatedFrom: old };
+  }
+  if (found.status === 'ambiguous') {
+    const cut = found.truncated ? ' (the search was cut short)' : '';
+    return {
+      status: 'choose',
+      path: old,
+      candidates: found.candidates,
+      reason: `the path does not exist and ${found.candidates.length === 1 ? 'a checkout' : 'several checkouts'} of ${repo} may match${cut}`,
+    };
+  }
+  return { status: 'invalid', path: old, reason: `the path does not exist and no checkout of ${repo} was found` };
+}
+
+function check(token, cwd, opts = {}) {
+  const d = decodeIn(token);
+  if (d === null) return { status: 'invalid', path: '', reason: 'the token does not decode to a path' };
+  const p = d.path;
+  if (!path.isAbsolute(p)) return { status: 'invalid', path: p, reason: 'the path is not absolute' };
+  const canon = real(p);
+  if (canon === null) {
+    if (d.repo === null) return { status: 'invalid', path: p, reason: 'the path does not exist' };
+    return relocate(p, d.repo, cwd, opts);
+  }
+  return resolveRoot(p, canon, cwd);
+}
+
 function main(argv) {
   const get = (flag) => {
     const i = argv.indexOf(flag);
@@ -75,11 +130,13 @@ function main(argv) {
   };
   const token = get('--in');
   const cwd = get('--cwd');
+  const roots = get('--roots');
   if (token === null || cwd === null) {
-    process.stderr.write('usage: trailhead-checkout-in.js --in <b64url> --cwd <dir>\n');
+    process.stderr.write('usage: trailhead-checkout-in.js --in <token> --cwd <dir> [--roots <a:b>]\n');
     return 2;
   }
-  process.stdout.write(JSON.stringify(check(token, cwd)) + '\n');
+  const opts = roots === null ? {} : { roots: roots.split(':').filter((r) => r !== '') };
+  process.stdout.write(JSON.stringify(check(token, cwd, opts)) + '\n');
   return 0;
 }
 

package/plugins/trailhead/templates/trailhead-commit-msg-sync.js

@@ -23,6 +23,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { execFileSync } = require('child_process');
+const { gitEnv } = require('./trailhead-git-env.js');
 
 // Nome del file di logica installato accanto al wrapper commit-msg.
 const CJS_NAME = 'trailhead-commit-msg.cjs';
@@ -47,7 +48,7 @@ function normalize(text) {
 // deve stampare rumore sul terminale dell'invocante, solo far fallire questa
 // chiamata (il chiamante decide come reagire).
 function defaultRunGit(args, cwd) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+  return execFileSync('git', args, { cwd, encoding: 'utf8', env: gitEnv(), stdio: ['ignore', 'pipe', 'pipe'] }).trim();
 }
 
 // Risolve la hooksDir effettiva del repo (rispetta core.hooksPath e i

package/plugins/trailhead/templates/trailhead-dashboard.js

@@ -7,11 +7,18 @@
 // updatedAt check, post-write conflict check, secret scan). #253.
 //
 // CLI:
-//   node trailhead-dashboard.js [--repo <owner/name>] [--set-last-audit <ISO-8601 UTC>] [--dry-run]
+//   node trailhead-dashboard.js [--repo <owner/name>] [--set-last-audit <ISO-8601 UTC>] [--dry-run] [--update-only]
 // --set-last-audit replaces the `<!-- trailhead:last-audit ... -->` marker (the
 // audit's only writer path); without it the marker is copied verbatim from the
 // existing body. --dry-run gathers and reads through gh, computes and scans, but
 // writes, creates, pins and labels nothing; it prints the old and new byte sizes.
+// --update-only refreshes an existing dashboard and never opens one: with no open
+// dashboard issue it creates, pins and labels nothing (the label ensure is skipped
+// too) and prints `skipped: no dashboard issue (update-only)`, exit 0. A capture
+// uses it so it cannot open a second issue; the check lives here, in the helper,
+// so there is no check-then-call race. That is all it forbids: it never creates the
+// dashboard. With a dashboard present it is a normal refresh (the label ensure and
+// the re-pin run as usual, both idempotent).
 //
 // Singleton labels (dashboard, codebase, conventions): more than one open issue
 // aborts before any write, naming every duplicate by title and number.
@@ -23,6 +30,7 @@
 //
 // Prints exactly one line on stdout:
 //   dashboard #33: 4 maps, whiteboard 1, flags: map-14 exhausted, map-98 near cap 92/100 (body 21034 -> 2210 bytes)
+//   skipped: no dashboard issue (update-only)
 //   aborted: <reason>
 // Exit 0 on success, 1 on an abort or a conflict, 2 on a usage error (stderr).
 // A pin check or pin failure AFTER the body was written is not an abort: the line
@@ -266,10 +274,11 @@ function createDashboard(gh, repo, body, tmpdir) {
 // --- CLI ---------------------------------------------------------------------
 
 function parseArgs(argv) {
-  const o = { repo: null, setLastAudit: null, dryRun: false };
+  const o = { repo: null, setLastAudit: null, dryRun: false, updateOnly: false };
   for (let i = 0; i < argv.length; i++) {
     const flag = argv[i];
     if (flag === '--dry-run') { o.dryRun = true; continue; }
+    if (flag === '--update-only') { o.updateOnly = true; continue; }
     if (flag !== '--repo' && flag !== '--set-last-audit') return { error: `usage: unknown argument: ${flag}` };
     i++;
     if (i >= argv.length) return { error: `usage: ${flag} requires a value` };
@@ -304,6 +313,10 @@ function main(argv, { gh, stdout, stderr, guard, tmpdir, firstEditDelta2 } = {})
     const repo = o.repo || defaultRepo(run);
     if (!repo) return abort('cannot resolve the repository (pass --repo owner/name)');
     const singles = lookupSingletons(run, repo); // fail closed on duplicates, before any write
+    if (o.updateOnly && singles.dashboard === null) {
+      out.write('skipped: no dashboard issue (update-only)\n');
+      return 0;
+    }
     if (!o.dryRun) run(['label', 'create', LABEL, '--color', '5319E7', '--description', 'Pinned index of the trailhead surface', '-R', repo]); // idempotent, failure = already there
     const snap = gatherSnapshot(run, repo, singles);
     const marker = o.setLastAudit ? `<!-- trailhead:last-audit ${o.setLastAudit} -->` : null;

package/plugins/trailhead/templates/trailhead-git-env.js

@@ -0,0 +1,40 @@
+'use strict';
+// Repo-location environment for git spawns.
+//
+// Git gives these variables precedence over `-C` and the cwd, so an exported
+// GIT_DIR (a hook, `git rebase --exec`, a parent shell) silently redirects every
+// git call to another repository. Each git spawn in the plugin builds its env
+// through gitEnv() so it always acts on the checkout it was pointed at.
+//
+// The names are `git rev-parse --local-env-vars` minus GIT_CONFIG*: those carry
+// the parent's `-c` options and are meant to be inherited. A static list keeps
+// this free of a git spawn; refresh it from that command when git adds a name.
+// Names must be deleted: an empty string is not "unset" (`fatal: '' is not a git repository`).
+//
+// hooks/lib/trailhead-git-env.js is a byte-identical copy for the hooks (they
+// install without the templates); a test keeps the two in sync.
+
+const GIT_LOCATION_VARS = Object.freeze([
+  'GIT_ALTERNATE_OBJECT_DIRECTORIES',
+  'GIT_OBJECT_DIRECTORY',
+  'GIT_DIR',
+  'GIT_WORK_TREE',
+  'GIT_IMPLICIT_WORK_TREE',
+  'GIT_GRAFT_FILE',
+  'GIT_INDEX_FILE',
+  'GIT_NO_REPLACE_OBJECTS',
+  'GIT_REPLACE_REF_BASE',
+  'GIT_PREFIX',
+  'GIT_SHALLOW_FILE',
+  'GIT_COMMON_DIR',
+]);
+
+// A new env object: `base` without the repo-location names, then `extra` on top.
+// Never mutates `base` (process.env by default).
+function gitEnv(base = process.env, extra = {}) {
+  const out = {};
+  for (const [k, v] of Object.entries(base)) if (!GIT_LOCATION_VARS.includes(k)) out[k] = v;
+  return { ...out, ...extra };
+}
+
+module.exports = { GIT_LOCATION_VARS, gitEnv };

package/plugins/trailhead/templates/trailhead-inbox-needs-info.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+'use strict';
+// trailhead inbox needs-info classifier (self-contained, ships in templates/ so it
+// reaches every install channel). Read-only: never writes to the tracker. #354.
+//
+// An inbox issue parked with `trailhead:needs-info` waits on its reporter. This
+// helper sorts the parked issues so the inbox protocol can act on them:
+//   answered  the reporter commented strictly after the latest label event
+//   timedOut  no answer and at least N whole days since the label
+//   waiting   no answer yet, inside the window
+//   unknown   a read failed, no label event, or no usable reporter identity
+//
+// CLI:
+//   node trailhead-inbox-needs-info.js --repo <owner/name> --config-root <project root>
+// N comes from `inbox.needs_info_days` (project config over the global one, default 14).
+//
+// Prints exactly one JSON line on stdout:
+//   {status, days, answered, timedOut, waiting, unknown, warnings}
+// Exit 0 on ok, 1 on status error (the list read failed), 2 on a usage error (stderr).
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { gitEnv } = require('./trailhead-git-env.js');
+
+const LABEL = 'trailhead:needs-info';
+const KEY = 'inbox.needs_info_days';
+const DEFAULT_DAYS = 14;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+function defaultGh(args) {
+  const r = spawnSync('gh', args, { encoding: 'utf8', env: gitEnv(), maxBuffer: 64 * 1024 * 1024 });
+  return { status: r.status === null ? 1 : r.status, stdout: r.stdout || '', stderr: r.stderr || (r.error ? String(r.error.message) : '') };
+}
+
+const firstLine = (s) => String(s || '').split('\n').find((l) => l.trim()) || '';
+
+function parseArgs(argv) {
+  const o = { repo: null, configRoot: null };
+  for (let i = 0; i < argv.length; i++) {
+    const flag = argv[i];
+    if (flag !== '--repo' && flag !== '--config-root') return { error: `usage: unknown argument: ${flag}` };
+    i++;
+    if (i >= argv.length) return { error: `usage: ${flag} requires a value` };
+    const v = argv[i];
+    if (flag === '--repo') {
+      if (!/^[^/\s]+\/[^/\s]+$/.test(v)) return { error: `usage: --repo must be owner/name, got: ${v}` };
+      o.repo = v;
+    } else {
+      o.configRoot = v;
+    }
+  }
+  if (!o.repo) return { error: 'usage: missing --repo <owner/name>' };
+  if (!o.configRoot) return { error: 'usage: missing --config-root <project root>' };
+  return o;
+}
+
+// Lines of `gh api --paginate ... --jq '... | tojson'`: one JSON document per line.
+// Any non-zero exit discards the whole read: a later page can fail after earlier ones printed.
+function jsonLines(r) {
+  if (r.status !== 0) return null;
+  const out = [];
+  for (const line of r.stdout.split('\n')) {
+    if (!line.trim()) continue;
+    try { out.push(JSON.parse(line)); } catch { return null; }
+  }
+  return out;
+}
+
+const has = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+
+// Su Codex lo script vive in <codexHome>/skills/trailhead/<dir>: la config globale sta lì, non in ~/.claude.
+const CODEX_INSTALL = /[\\/]skills[\\/]trailhead[\\/](?:hooks|templates)$/;
+const codexHome = () => (CODEX_INSTALL.test(__dirname) ? path.resolve(__dirname, '..', '..', '..') : null);
+
+function globalConfigPath(env) {
+  const base = codexHome() || env.CLAUDE_CONFIG_DIR || path.join(env.HOME || os.homedir(), '.claude');
+  return path.join(base, 'trailhead', 'config.json');
+}
+
+// { found, value } for the key in one parsed file: the flat key wins over the nested one.
+function pick(cfg) {
+  if (has(cfg, KEY)) return { found: true, value: cfg[KEY] };
+  if (isObject(cfg.inbox) && has(cfg.inbox, 'needs_info_days')) return { found: true, value: cfg.inbox.needs_info_days };
+  return { found: false };
+}
+
+// Days from the nearest valid layer. A bad layer warns and falls to the next one: a timeout only
+// ever produces an offer the maintainer confirms.
+function resolveDays(root, env, fs_, warnings) {
+  for (const file of [path.join(root, '.trailhead', 'config.json'), globalConfigPath(env)]) {
+    let cfg;
+    try {
+      cfg = JSON.parse(fs_.readFileSync(file, 'utf8'));
+    } catch (e) {
+      if (e && e.code === 'ENOENT') continue;
+      warnings.push(e instanceof SyntaxError ? `${file} is not valid JSON; ignored` : `cannot read ${file}; ignored`);
+      continue;
+    }
+    if (!isObject(cfg)) { warnings.push(`${file} is not a JSON object; ignored`); continue; }
+    const hit = pick(cfg);
+    if (!hit.found) continue;
+    if (Number.isInteger(hit.value) && hit.value > 0) return hit.value;
+    warnings.push(`${KEY} in ${file} must be a positive integer; ignored`);
+  }
+  return DEFAULT_DAYS;
+}
+
+const usable = (login) => typeof login === 'string' && login !== '' && login.toLowerCase() !== 'ghost';
+
+function main(argv, { gh, now, stdout, stderr, env, fs: fs_ } = {}) {
+  const out = stdout || process.stdout;
+  const err = stderr || process.stderr;
+  const o = parseArgs(argv || []);
+  if (o.error) { err.write(o.error + '\n'); return 2; }
+  const run = gh || defaultGh;
+  const nowMs = (now ? now() : new Date()).getTime();
+  const warnings = [];
+  const days = resolveDays(o.configRoot, env || process.env, fs_ || fs, warnings);
+  const emit = (obj) => out.write(JSON.stringify(obj) + '\n');
+
+  const list = jsonLines(run(['api', '--paginate', `repos/${o.repo}/issues?labels=${LABEL}&state=open&per_page=100`, '--jq', '.[] | select(.pull_request == null) | {number, title, author: .user.login} | tojson']));
+  if (!list) {
+    emit({ status: 'error', days, answered: [], timedOut: [], waiting: [], unknown: [], warnings, reason: 'could not read the parked issues' });
+    return 1;
+  }
+
+  const res = { status: 'ok', days, answered: [], timedOut: [], waiting: [], unknown: [], warnings };
+  for (const i of list) {
+    const { number, title } = i;
+    const unknown = (reason) => res.unknown.push({ number, title, reason });
+    const events = jsonLines(run(['api', '--paginate', `repos/${o.repo}/issues/${number}/events`, '--jq', `.[] | select(.event == "labeled" and .label.name == "${LABEL}") | {at: .created_at} | tojson`]));
+    if (!events) { unknown('could not read the label events'); continue; }
+    const times = events.map((e) => Date.parse(e.at)).filter((t) => !Number.isNaN(t));
+    if (!times.length) { unknown('no label event found'); continue; }
+    if (!usable(i.author)) { unknown('the reporter has no usable identity'); continue; }
+    const labeledMs = Math.max(...times);
+    const labeledAt = new Date(labeledMs).toISOString().replace('.000Z', 'Z');
+    const comments = jsonLines(run(['api', '--paginate', `repos/${o.repo}/issues/${number}/comments?since=${labeledAt}&per_page=100`, '--jq', '.[] | {author: .user.login, at: .created_at} | tojson']));
+    if (!comments) { unknown('could not read the comments'); continue; }
+    // `since` filters on update time, so the creation time is checked again.
+    const reporter = i.author.toLowerCase();
+    const answers = comments
+      .filter((c) => usable(c.author) && c.author.toLowerCase() === reporter && Date.parse(c.at) > labeledMs)
+      .sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+    const ageDays = Math.max(0, Math.floor((nowMs - labeledMs) / DAY_MS));
+    if (answers.length) res.answered.push({ number, title, author: i.author, labeledAt, answeredAt: answers[0].at });
+    else if (ageDays >= days) res.timedOut.push({ number, title, author: i.author, labeledAt, ageDays });
+    else res.waiting.push({ number, title, labeledAt, ageDays });
+  }
+  emit(res);
+  return 0;
+}
+
+module.exports = { globalConfigPath, main, parseArgs, resolveDays, DEFAULT_DAYS };
+
+if (require.main === module) {
+  process.exit(main(process.argv.slice(2), {}));
+}

package/plugins/trailhead/templates/trailhead-isolation-answer.js

@@ -32,6 +32,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { execFileSync } = require('child_process');
+const { gitEnv } = require('./trailhead-git-env.js');
 
 const STATE_DIR = '.trailhead';
 const STATE_FILE = 'isolation-answer.json';
@@ -124,7 +125,7 @@ function parseArgs(argv) {
 function resolveProjectRoot(dir) {
   try {
     const common = execFileSync('git', ['-C', dir, 'rev-parse', '--path-format=absolute', '--git-common-dir'],
-      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], env: gitEnv() }).trim();
     if (common && path.basename(common) === '.git') return path.dirname(common);
     return dir;
   } catch {

package/plugins/trailhead/templates/trailhead-isolation-copy.js

@@ -33,6 +33,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execFileSync } = require('child_process');
+const { gitEnv } = require('./trailhead-git-env.js');
 
 const CONFIG_REL = path.join('.trailhead', 'config.json');
 const SUFFIXES = ['.example', '.sample'];
@@ -98,8 +99,12 @@ function readCopyList(file, fs_) {
   return { state: 'set', list: value, warnings };
 }
 
+// Su Codex lo script vive in <codexHome>/skills/trailhead/<dir>: la config globale sta lì, non in ~/.claude.
+const CODEX_INSTALL = /[\\/]skills[\\/]trailhead[\\/](?:hooks|templates)$/;
+const codexHome = () => (CODEX_INSTALL.test(__dirname) ? path.resolve(__dirname, '..', '..', '..') : null);
+
 function globalConfigPath(env) {
-  const base = env.CLAUDE_CONFIG_DIR || path.join(env.HOME || os.homedir(), '.claude');
+  const base = codexHome() || env.CLAUDE_CONFIG_DIR || path.join(env.HOME || os.homedir(), '.claude');
   return path.join(base, 'trailhead', 'config.json');
 }
 
@@ -131,7 +136,7 @@ const exists = (p, fs_) => {
 function suggest(from, fs_) {
   let tracked;
   try {
-    tracked = execFileSync('git', ['-C', from, 'ls-files', '-z'], { stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 64 * 1024 * 1024 })
+    tracked = execFileSync('git', ['-C', from, 'ls-files', '-z'], { stdio: ['ignore', 'pipe', 'ignore'], env: gitEnv(), maxBuffer: 64 * 1024 * 1024 })
       .toString().split('\0').filter(Boolean);
   } catch (err) {
     return [];
@@ -143,7 +148,7 @@ function suggest(from, fs_) {
     const sibling = file.slice(0, -suffix.length);
     if (out.includes(sibling) || checkRelPath(sibling) !== null || !exists(path.join(from, sibling), fs_)) continue;
     try {
-      execFileSync('git', ['-C', from, 'check-ignore', '-q', '--', sibling], { stdio: 'ignore' });
+      execFileSync('git', ['-C', from, 'check-ignore', '-q', '--', sibling], { stdio: 'ignore', env: gitEnv() });
       out.push(sibling);
     } catch (err) {
       // not ignored (exit 1) or git error: not a suggestion
@@ -231,7 +236,7 @@ function main(argv, { cwd, stdout, env, fs: fsMod } = {}) {
   }
 }
 
-module.exports = { checkRelPath, readCopyList, parseArgs, main };
+module.exports = { globalConfigPath, checkRelPath, readCopyList, parseArgs, main };
 
 if (require.main === module) {
   const code = main(process.argv.slice(2), { cwd: process.cwd(), stdout: process.stdout, env: process.env });