@marcomigozzi/trailhead 0.17.0 → 0.18.0

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 });

package/plugins/trailhead/templates/trailhead-issue-body.js

@@ -8,7 +8,8 @@
 //
 // CLI:
 //   node trailhead-issue-body.js <append|replace|remove> --issue <n> [--repo <owner/name>]
-//        --section "<name>" (--line "<text>" | --file <path> | --match "<text>") [--dry-run]
+//        --section "<name>" (--line "<text>" | --file <path> | --match "<text>")
+//        [--stamp <sha>] [--dry-run]
 //   append   adds --line as the last line of the section (a `_none yet_`-style
 //            placeholder that is the section's only content is dropped)
 //   replace  swaps the section content for the text of --file
@@ -17,6 +18,12 @@
 // <name> matches a `## ` heading with its leading emoji/punctuation stripped
 // (`Decisions so far` matches `## ✅ Decisions so far`); `:preamble` is the text
 // before the first `## ` (the conventions header).
+// --stamp <sha> (7 to 40 lowercase hex) sets the section's `_as of <sha>_` line, the
+// commit a codebase facet was written or last patched against: the first content
+// line of the section, then a blank line. Applied only when given (map and
+// conventions patches omit it) and written in the same single guarded write as the
+// patch. Without it an existing stamp is kept; a no-op `remove` writes nothing and
+// does not stamp. Not valid on `:preamble`. #360.
 // --dry-run reads and computes (secret scan included) but writes nothing and
 // prints the old and new byte sizes.
 //
@@ -40,6 +47,7 @@ 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 PREAMBLE = ':preamble';
 const DEGENERATE_MAX = 20; // a body with fewer non-space characters is degenerate
@@ -197,9 +205,83 @@ function readSection(body, name) {
   return sec ? lines.slice(sec.from, sec.to).filter((l) => !isBlank(l)) : null;
 }
 
-// op: { kind: 'append'|'replace'|'remove', section, line|text|match }.
+// --- facet stamp -------------------------------------------------------------
+
+const STAMP_RE = /^_as of ([0-9a-f]{7,40})_$/;
+const STAMP_VALUE_RE = /^[0-9a-f]{7,40}$/;
+const stampLine = (sha) => `_as of ${sha}_`;
+
+// The first non-blank line of lines[from..to) when it is a stamp: { at, sha }, else null.
+function stampIn(lines, from, to) {
+  for (let i = from; i < to; i++) {
+    if (isBlank(lines[i])) continue;
+    const m = STAMP_RE.exec(lines[i].trim());
+    return m ? { at: i, sha: m[1] } : null;
+  }
+  return null;
+}
+
+// `## ` sections of a body as { name, sha, text }: sha is the stamp or null, text
+// the section content. Fence-aware (headingIndexes), so a fenced `## ` is no facet.
+function facetsOf(body) {
+  const { lines } = splitBody(String(body));
+  const heads = headingIndexes(lines);
+  return heads.map((h, k) => {
+    const to = k + 1 < heads.length ? heads[k + 1] : lines.length;
+    const stamp = stampIn(lines, h + 1, to);
+    return { name: headingName(lines[h]), sha: stamp ? stamp.sha : null, text: lines.slice(h + 1, to).join('\n') };
+  });
+}
+
+// Runs the op with the stamp set aside, then writes the supplied stamp (else the
+// old one, else the file's own for a replace) back as the section's first content.
+function applyStamped(body, op) {
+  if (op.stamp !== undefined && !STAMP_VALUE_RE.test(op.stamp)) return { error: 'stamp must be 7 to 40 lowercase hex characters' };
+  if (op.section === PREAMBLE) return op.stamp === undefined ? applyCore(body, op) : { error: 'a stamp does not apply to the preamble' };
+  const parts = splitBody(String(body));
+  const sec = findSection(parts.lines, op.section);
+  if (!sec) return { error: `section not found: ${op.section}` };
+  const old = stampIn(parts.lines, sec.from, sec.to);
+  let text = op.text;
+  let own = null;
+  if (op.kind === 'replace') {
+    const tl = bodyLines(text);
+    const t = stampIn(tl, 0, tl.length);
+    if (t) {
+      own = t.sha;
+      tl.splice(t.at, t.at + 1 < tl.length && isBlank(tl[t.at + 1]) ? 2 : 1);
+      text = tl.join('\n');
+    }
+  }
+  const sha = op.stamp !== undefined ? op.stamp : old ? old.sha : own;
+  if (!old && sha === null) return applyCore(body, { ...op, text });
+  // Strip the old stamp line and the one blank line after it.
+  let stripped = parts;
+  if (old) {
+    const drop = old.at + 1 < sec.to && isBlank(parts.lines[old.at + 1]) ? 2 : 1;
+    stripped = { ...parts, lines: [...parts.lines.slice(0, old.at), ...parts.lines.slice(old.at + drop)] };
+  }
+  const r = applyCore(joinBody(stripped), { ...op, text });
+  if (r.error) return r;
+  if (!r.changed) return { ...r, body: String(body) };
+  const out = splitBody(r.body);
+  const ns = findSection(out.lines, op.section);
+  let at = ns.from;
+  while (at < ns.to && isBlank(out.lines[at])) at++;
+  if (at === ns.to) at = ns.from;
+  const add = [stampLine(sha)];
+  if (at >= out.lines.length || !isBlank(out.lines[at])) add.push('');
+  const lines = [...out.lines.slice(0, at), ...add, ...out.lines.slice(at)];
+  return { ...r, body: joinBody({ ...out, lines }) };
+}
+
+// op: { kind: 'append'|'replace'|'remove', section, line|text|match, stamp? }.
 // Returns { body, changed, summary } or { error }.
 function applyOp(body, op) {
+  return applyStamped(body, op);
+}
+
+function applyCore(body, op) {
   const parts = splitBody(String(body));
   const { lines } = parts;
   const sec = findSection(lines, op.section);
@@ -291,7 +373,7 @@ function secretProblem(text, guard) {
 // --- gh boundary -------------------------------------------------------------
 
 function defaultGh(args) {
-  const r = spawnSync('gh', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  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) : '') };
 }
 
@@ -445,7 +527,7 @@ function parseArgs(argv) {
   for (let i = 1; i < argv.length; i++) {
     const flag = argv[i];
     if (flag === '--dry-run') { o.dryRun = true; continue; }
-    if (!['--issue', '--repo', '--section', '--line', '--file', '--match'].includes(flag)) return { error: `usage: unknown argument: ${flag}` };
+    if (!['--issue', '--repo', '--section', '--line', '--file', '--match', '--stamp'].includes(flag)) return { error: `usage: unknown argument: ${flag}` };
     i++;
     if (i >= argv.length) return { error: `usage: ${flag} requires a value` };
     const v = argv[i];
@@ -459,6 +541,10 @@ function parseArgs(argv) {
   }
   if (o.issue === undefined) return { error: 'usage: --issue is required' };
   if (!o.section) return { error: 'usage: --section is required' };
+  if (o.stamp !== undefined) {
+    if (!STAMP_VALUE_RE.test(o.stamp)) return { error: `usage: --stamp must be 7 to 40 lowercase hex characters, got: ${o.stamp}` };
+    if (o.section === PREAMBLE) return { error: 'usage: --stamp does not apply to :preamble' };
+  }
   const given = ['line', 'file', 'match'].filter((k) => o[k] !== undefined);
   const want = { append: 'line', replace: 'file', remove: 'match' }[kind];
   if (given.length !== 1 || given[0] !== want) return { error: `usage: ${kind} needs exactly --${want}` };
@@ -475,7 +561,7 @@ function main(argv, { gh, stdout, stderr, guard, tmpdir, firstEditDelta2 } = {})
   if (o.kind === 'replace') {
     try { text = fs.readFileSync(o.file, 'utf8'); } catch (e) { err.write(`usage: cannot read --file ${o.file}: ${e.message}\n`); return 2; }
   }
-  const op = { kind: o.kind, section: o.section, line: o.line, text, match: o.match };
+  const op = { kind: o.kind, section: o.section, line: o.line, text, match: o.match, stamp: o.stamp };
   const prefix = `issue #${o.issue}`;
   let summary = '';
   let unchanged = false;
@@ -515,7 +601,7 @@ function noopFirst(o, compute, wasUnchanged, opts) {
   return !(r && r.error) && wasUnchanged();
 }
 
-module.exports = { applyOp, readSection, defaultGh, PLACEHOLDER_RE, guardedWrite, loadGuard, main, parseArgs, readIssue, editCount, secretProblem, PREAMBLE, HISTORY_FULL_NOTE };
+module.exports = { applyOp, facetsOf, readSection, defaultGh, PLACEHOLDER_RE, guardedWrite, loadGuard, main, parseArgs, readIssue, editCount, secretProblem, PREAMBLE, HISTORY_FULL_NOTE };
 
 if (require.main === module) {
   process.exit(main(process.argv.slice(2), {}));

package/plugins/trailhead/templates/trailhead-merge-ticket.js

@@ -40,6 +40,7 @@ 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 { guardedWrite, loadGuard, secretProblem } = require('./trailhead-issue-body.js');
 
 const MAX_PAGES = 100; // 100 pages x 100 issues
@@ -52,7 +53,7 @@ const NEEDS_YOU_DESC = 'Needs you: an autonomous run parked it for the human';
 const TITLE_PREFIX = 'Merge the branches left unmerged: ';
 
 function defaultGh(args) {
-  const r = spawnSync('gh', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  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) : '') };
 }
 

package/plugins/trailhead/templates/trailhead-needs-you.js

@@ -7,6 +7,7 @@
 // CLI:
 //   node trailhead-needs-you.js park  --issue <n> --reason <text> --repo <owner/name>
 //   node trailhead-needs-you.js clear --issue <n> --repo <owner/name>
+//   node trailhead-needs-you.js sweep --repo <owner/name>
 //
 // park, in this order (so any partial failure leaves the ticket visible: a label is
 // never set on a ticket still claimed by the run):
@@ -21,15 +22,19 @@
 //   5. unassign `@me` when the ticket is assigned;
 //   6. add the label last.
 // clear: when the ticket carries the label, remove it; otherwise a no-op.
+// sweep: remove the label from every CLOSED issue that still carries it, however it was
+//   closed (a Resolve, a hand close, the web UI): a closed ticket never waits on the human.
 //
 // Prints exactly one JSON line on stdout:
 //   park:  {"status":"ok","issue":n,"commented":bool,"unassigned":bool,"labelled":bool}
 //   clear: {"status":"ok","issue":n,"cleared":bool}
+//   sweep: {"status":"ok","cleared":[n,...]}  (an error also carries the cleared list)
 //   error: {"status":"error","reason":"..."}
 // Exit 0 on ok, 1 on an error (any failed or unparseable gh step), 2 on a usage error
 // (stderr).
 
 const { spawnSync } = require('child_process');
+const { gitEnv } = require('./trailhead-git-env.js');
 const fs = require('fs');
 const path = require('path');
 
@@ -37,9 +42,10 @@ const LABEL = 'trailhead:needs-you';
 const LABEL_COLOR = 'D93F0B';
 const LABEL_DESC = 'Needs you: an autonomous run parked it for the human';
 const MARKER = 'NEEDS YOU';
+const SWEEP_LIMIT = 1000;
 
 function defaultGh(args) {
-  const r = spawnSync('gh', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  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) : '') };
 }
 
@@ -82,8 +88,8 @@ function secretProblem(text, guard) {
 
 function parseArgs(argv) {
   const cmd = argv[0];
-  if (cmd !== 'park' && cmd !== 'clear') return { error: `usage: expected park or clear, got: ${cmd === undefined ? '(nothing)' : cmd}` };
-  const allowed = cmd === 'park' ? ['--issue', '--reason', '--repo'] : ['--issue', '--repo'];
+  if (!['park', 'clear', 'sweep'].includes(cmd)) return { error: `usage: expected park, clear or sweep, got: ${cmd === undefined ? '(nothing)' : cmd}` };
+  const allowed = { park: ['--issue', '--reason', '--repo'], clear: ['--issue', '--repo'], sweep: ['--repo'] }[cmd];
   const o = { cmd, issue: null, reason: null, repo: null };
   for (let i = 1; i < argv.length; i++) {
     const flag = argv[i];
@@ -102,7 +108,7 @@ function parseArgs(argv) {
     }
   }
   if (!o.repo) return { error: `usage: ${cmd} requires --repo` };
-  if (!o.issue) return { error: `usage: ${cmd} requires --issue` };
+  if (cmd !== 'sweep' && !o.issue) return { error: `usage: ${cmd} requires --issue` };
   if (cmd === 'park' && (o.reason === null || !o.reason.trim())) return { error: 'usage: park requires a non-empty --reason' };
   return o;
 }
@@ -124,6 +130,32 @@ function readIssue(run, o) {
   };
 }
 
+// Numeri delle issue chiuse che portano ancora la label, ordinati; oppure { error }.
+function listClosedLabelled(run, repo) {
+  const r = run(['issue', 'list', '--state', 'closed', '--label', LABEL, '--json', 'number', '--limit', String(SWEEP_LIMIT), '-R', repo]);
+  if (r.status !== 0) return { error: `gh issue list failed: ${firstLine(r.stderr) || 'exit ' + r.status}` };
+  let j;
+  try { j = JSON.parse(r.stdout); } catch { return { error: 'gh issue list returned unparseable JSON' }; }
+  if (!Array.isArray(j)) return { error: 'gh issue list returned unexpected JSON' };
+  return { numbers: j.map((i) => i && i.number).filter((n) => Number.isInteger(n)).sort((a, b) => a - b) };
+}
+
+// Toglie la label da ogni issue chiusa; continua dopo un errore e lo riporta alla fine.
+function sweep(run, repo, emit) {
+  const list = listClosedLabelled(run, repo);
+  if (list.error) { emit({ status: 'error', reason: list.error, cleared: [] }); return 1; }
+  const results = list.numbers.map((n) => ({ n, r: run(['issue', 'edit', String(n), '--remove-label', LABEL, '-R', repo]) }));
+  const cleared = results.filter((x) => x.r.status === 0).map((x) => x.n);
+  const failed = results.filter((x) => x.r.status !== 0);
+  if (failed.length) {
+    const reason = failed.map((x) => `#${x.n}: ${firstLine(x.r.stderr) || 'exit ' + x.r.status}`).join('; ');
+    emit({ status: 'error', reason: `gh issue edit (remove label) failed for ${reason}`, cleared });
+    return 1;
+  }
+  emit({ status: 'ok', cleared });
+  return 0;
+}
+
 // True when the latest NEEDS YOU comment already carries this reason.
 function alreadyCommented(comments, reason) {
   const mine = comments.filter((b) => String(b).replace(/\r/g, '').split('\n')[0] === MARKER);
@@ -143,6 +175,8 @@ function main(argv, { gh, guard, stdout, stderr } = {}) {
   const R = ['-R', o.repo];
   const n = String(o.issue);
 
+  if (o.cmd === 'sweep') return sweep(run, o.repo, emit);
+
   if (o.cmd === 'clear') {
     const cur = readIssue(run, o);
     if (cur.error) return fail(cur.error);