leerness 1.36.303 → 1.36.305

package/lib/workspace-dir.js

@@ -4,6 +4,7 @@
 // migrated.  Keeping the policy in this domain module prevents another
 // read-one-directory/write-another split brain.
 const fs = require('fs');
+const { removeSync } = require('./safe-remove');
 const path = require('path');
 const crypto = require('crypto');
 
@@ -290,7 +291,7 @@ function _safeRemoveCanonicalDir(root, target) {
   if (resolvedTarget !== allowed || path.dirname(resolvedTarget) !== resolvedRoot || resolvedRoot === path.parse(resolvedRoot).root) {
     throw new WorkspaceDirectoryError('E_WORKSPACE_DIR_UNSAFE_REMOVE', `unsafe canonical rollback target: ${resolvedTarget}`);
   }
-  fs.rmSync(resolvedTarget, { recursive: true, force: true });
+  removeSync(resolvedTarget, { recursive: true, force: true });
 }
 
 function _rewriteLegacyReference(file) {
@@ -915,7 +916,7 @@ function _migrateLegacyWorkspace(root, opts = {}) {
         legacyRenamed = false;
       }
       for (const item of overwritten.reverse()) { _beat(); _copyFile(item.backup, item.dst); }
-      for (const file of created.reverse()) { _beat(); if (fs.existsSync(file)) fs.rmSync(file, { force: true }); }
+      for (const file of created.reverse()) { _beat(); if (fs.existsSync(file)) removeSync(file, { force: true }); }
       _beat();
       if (!canonicalExisted && fs.existsSync(state.canonical.abs)) _safeRemoveCanonicalDir(state.root, state.canonical.abs);
     } catch (rollbackError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.303",
+  "version": "1.36.305",
   "description": "The AI-coding operations layer that makes \"done\" require evidence — persistent memory, evidence-gated completion checks, and clean handoffs for any AI agent (Claude Code, Codex, Cursor). State lives as plain files in your repo. CLI + MCP, 0 runtime dependencies.",
   "keywords": [
     "leerness",
@@ -143,7 +143,7 @@
     "test:ledger-sync": "node ./scripts/execution-ledger-sync-probe.js",
     "test:state-lock": "node ./scripts/shared-state-lock-probe.js",
     "test:lock-heartbeat": "node ./scripts/lock-heartbeat-probe.js",
-    "test:temp-cleanup": "node ./scripts/temp-cleanup-probe.js && node ./scripts/copy-tree-probe.js",
+    "test:temp-cleanup": "node ./scripts/temp-cleanup-probe.js && node ./scripts/copy-tree-probe.js && node ./scripts/safe-remove-probe.js",
     "test:path-setup": "node ./scripts/path-setup-powershell-probe.js",
     "test:skill-archive": "node ./scripts/skill-archive-probe.js",
     "test:memory-arena-cleanup": "node ./scripts/memory-arena-cleanup-probe.js",

package/scripts/agents-bench-output-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert');
 const fs = require('fs');
 const path = require('path');

package/scripts/api-skill-match-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 // T-0319: saved API skills (.leerness/api-skills/*.md) are matched against the in-progress task by handoff,
 // handoff --json, health --json and session close --json. All four read row.title and row.notes, which progress
 // rows do not have, so nothing ever matched. They now share one task-text helper (request and next action), and

package/scripts/audit-env-text-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { createHash } = require('crypto');
 const { removeTree } = require('./temp-cleanup');

package/scripts/audit-readme-text-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { createHash } = require('crypto');
 const { removeTree } = require('./temp-cleanup');

package/scripts/audit-text-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { createHash } = require('crypto');
 const { removeTree } = require('./temp-cleanup');

package/scripts/authoring-language-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { createHash } = require('crypto');
 const { removeTree } = require('./temp-cleanup');

package/scripts/auto-update-hooks-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // Real CLI regressions for the configuration consumed by Codex/Claude hooks.
 const fs = require('fs'), os = require('os'), path = require('path'), cp = require('child_process');

package/scripts/brief-text-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { createHash } = require('crypto');
 const { removeTree } = require('./temp-cleanup');

package/scripts/bugfix-areas-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 // T-0330: past fixes at completion. `bugfix receipt --areas` declares the files or folders a fix is about;
 // verify-claim then lists the bugfix receipts whose declared areas hold a file the task's evidence names: finished
 // ones (their task is done, also in retained history) as past fixes with the root cause and the probe to re-run,

package/scripts/ci-shard-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 // T-0359: CI runs e2e.js cases and npm-script leaves in parallel shards (scripts/ci-shard.js). A shard that drops a
 //   unit fails nothing — the unit silently stops running — so this probe checks the parts that decide what runs:
 //   the assignment is a deterministic partition, every leaf of the real sharded scripts parses and lands in exactly
@@ -151,6 +152,104 @@ try {
     assert.strictEqual(env.LEERNESS_CI_SHARD_TIMES, times, 'the caller\'s environment object was changed');
   });
 
+  check('runNpm removes the temp folders a passing leaf and its tracked child recorded, and keeps a failing or killed leaf\'s (T-0357)', () => {
+    // The leaf only records (scripts/temp-cleanup.js trackTemp); the runner, which sees the exit status, removes.
+    const dir = path.join(arena, 'temp-record');
+    const leafTemp = path.join(dir, 'temp');
+    fs.mkdirSync(leafTemp, { recursive: true });
+    const TC = JSON.stringify(path.join(__dirname, 'temp-cleanup.js'));
+    const make = (name, end) => fs.writeFileSync(path.join(dir, `${name}.js`), [
+      `require(${TC}).trackTemp(module);`,
+      "const fs = require('fs'), os = require('os'), path = require('path'), cp = require('child_process');",
+      `const d = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-leaf-${name}-'));`,
+      `const c = cp.spawnSync(process.execPath, [${JSON.stringify(path.join(dir, 'child.js'))}], { encoding: 'utf8' }).stdout.trim();`,
+      `fs.writeFileSync(${JSON.stringify(path.join(dir, `${name}.out`))}, JSON.stringify({ d, c, rec: process.env.LEERNESS_TEMP_RECORD || null }));`,
+      end, ''].join('\n'));
+    fs.writeFileSync(path.join(dir, 'child.js'), [`require(${TC}).trackTemp(module);`,
+      "const fs = require('fs'), os = require('os'), path = require('path');",
+      "process.stdout.write(fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-leaf-child-')));", ''].join('\n'));
+    make('pass', 'process.exitCode = 0;');
+    make('fail', 'process.exitCode = 1;');
+    make('killed', "process.kill(process.pid, 'SIGKILL');");
+    const recordRoots = () => fs.readdirSync(os.tmpdir()).filter(n => n.startsWith('leerness-temp-record-')).sort();
+    const rootsBefore = recordRoots();
+    const lines = [];
+    const env = { ...process.env, GITHUB_ACTIONS: '', TEMP: leafTemp, TMP: leafTemp, TMPDIR: leafTemp, LEERNESS_TEMP_RECORD: path.join(dir, 'outer-record') };
+    const r = cs.runNpm('suite', { index: 1, count: 1 }, { root: dir, scripts: { suite: 'node ./pass.js && node ./fail.js && node ./killed.js' }, weights: { e2e: {}, npm: {} }, stdio: 'ignore', env, log: l => lines.push(l) });
+    assert.deepStrictEqual(r.failed, ['node ./fail.js', 'node ./killed.js']);
+    const res = n => JSON.parse(fs.readFileSync(path.join(dir, `${n}.out`), 'utf8'));
+    const pass = res('pass'), fail = res('fail');
+    assert.ok(pass.d && pass.c && fail.d && fail.c, JSON.stringify({ pass, fail }));
+    assert.strictEqual(fs.existsSync(pass.d), false, 'the passing leaf\'s folder was kept');
+    assert.strictEqual(fs.existsSync(pass.c), false, 'the passing leaf\'s tracked child\'s folder was kept');
+    assert.strictEqual(fs.existsSync(fail.d), true, 'the failing leaf\'s folder was removed');
+    assert.strictEqual(fs.existsSync(fail.c), true, 'the failing leaf\'s child\'s folder was removed');
+    const killedMade = fs.readdirSync(leafTemp).filter(n => n.startsWith('leerness-leaf-killed-'));
+    assert.strictEqual(killedMade.length, 1, 'the killed leaf\'s folder was removed');
+    assert.ok(pass.rec && fail.rec && pass.rec !== fail.rec && pass.rec !== env.LEERNESS_TEMP_RECORD, 'each leaf gets its own record directory from the runner');
+    assert.strictEqual(fs.existsSync(pass.rec) || fs.existsSync(fail.rec), false, 'a record directory was left');
+    assert.deepStrictEqual(recordRoots(), rootsBefore, 'the runner left its record root');
+    assert.ok(lines.some(l => /^ci-shard: temp folders: 2 removed after passing leaves/.test(l)), lines.join('\n'));
+    assert.strictEqual(env.LEERNESS_TEMP_RECORD, path.join(dir, 'outer-record'), 'the caller\'s environment object was changed');
+  });
+
+  // 1.36.304 review round 3: the record root was removed recursively without checking that it was still the folder the
+  //   runner made. A wrapper of fs.mkdtempSync (or fs.mkdirSync, for a leaf's directory) installed before the runner
+  //   can put an existing folder there; the runner now checks each directory right after making it (its own identity,
+  //   empty), records nothing into one that fails, removes only the leaf directories it checked, and the root only when
+  //   it is empty.
+  check('runNpm removes no folder that a wrapper swapped in for its record root or a leaf\'s record directory (T-0357)', () => {
+    const dir = path.join(arena, 'temp-record-swap');
+    const leafTemp = path.join(dir, 'temp');
+    fs.mkdirSync(leafTemp, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'pass.js'), [`require(${JSON.stringify(path.join(__dirname, 'temp-cleanup.js'))}).trackTemp(module);`,
+      "const fs = require('fs'), os = require('os'), path = require('path');",
+      "fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-leaf-swap-'));", ''].join('\n'));
+    for (const target of ['root', 'leaf']) {
+      const unrelated = path.join(dir, `unrelated-${target}`);
+      fs.mkdirSync(unrelated); fs.writeFileSync(path.join(unrelated, 'keep.txt'), 'keep');
+      const saved = { mkdtempSync: fs.mkdtempSync, mkdirSync: fs.mkdirSync };
+      let swappedAt = null;
+      const swapIn = made => { fs.renameSync(made, made + '-aside'); fs.renameSync(unrelated, made); swappedAt = made; };
+      if (target === 'root') fs.mkdtempSync = function (prefix, ...rest) { const d = saved.mkdtempSync.call(fs, prefix, ...rest); if (String(prefix).includes('leerness-temp-record-')) swapIn(d); return d; };
+      else fs.mkdirSync = function (p, ...rest) { const r = saved.mkdirSync.call(fs, p, ...rest); if (!swappedAt && /leerness-temp-record-/.test(path.dirname(String(p)))) swapIn(String(p)); return r; };
+      let r;
+      const lines = [];
+      try {
+        r = cs.runNpm('suite', { index: 1, count: 1 }, { root: dir, scripts: { suite: 'node ./pass.js' }, weights: { e2e: {}, npm: {} }, stdio: 'ignore',
+          env: { ...process.env, GITHUB_ACTIONS: '', TEMP: leafTemp, TMP: leafTemp, TMPDIR: leafTemp }, log: l => lines.push(l) });
+      } finally { fs.mkdtempSync = saved.mkdtempSync; fs.mkdirSync = saved.mkdirSync; }
+      assert.deepStrictEqual(r.failed, [], target);
+      assert.ok(swappedAt, `${target}: the wrapper did not run`);
+      assert.strictEqual(fs.readFileSync(path.join(swappedAt, 'keep.txt'), 'utf8'), 'keep', `${target}: the folder swapped in was removed`);
+      assert.ok(lines.some(l => /^ci-shard: temp folders: .*1 leaves not recorded/.test(l)), `${target}: the leaf was given a directory that failed the check\n${lines.join('\n')}`);
+      // What the runner rightly leaves is this test's own, in the temp directory: for the root, the folder swapped in and
+      //   the root moved aside; for a leaf's directory, the root that holds them (1.36.304 full run: they were left).
+      const own = target === 'root' ? [swappedAt, swappedAt + '-aside'] : [path.dirname(swappedAt)];
+      for (const p of own) {
+        assert.ok(path.resolve(path.dirname(p)) === path.resolve(os.tmpdir()) && path.basename(p).startsWith('leerness-temp-record-'), `${target}: not the runner's folder: ${p}`);
+        fs.rmSync(p, { recursive: true, force: true });
+      }
+    }
+  });
+
+  check('runNpm removes its record root only when it is empty: a folder a leaf moved into it is left (T-0357)', () => {
+    const dir = path.join(arena, 'temp-record-into-root');
+    const leafTemp = path.join(dir, 'temp');
+    fs.mkdirSync(leafTemp, { recursive: true });
+    const moved = path.join(dir, 'moved');
+    fs.mkdirSync(moved); fs.writeFileSync(path.join(moved, 'keep.txt'), 'keep');
+    fs.writeFileSync(path.join(dir, 'mover.js'), ["const fs = require('fs'), path = require('path');",
+      `const into = path.join(path.dirname(process.env.LEERNESS_TEMP_RECORD), 'moved'); fs.renameSync(${JSON.stringify(moved)}, into);`,
+      `fs.writeFileSync(${JSON.stringify(path.join(dir, 'into.txt'))}, into);`, ''].join('\n'));
+    const r = cs.runNpm('suite', { index: 1, count: 1 }, { root: dir, scripts: { suite: 'node ./mover.js' }, weights: { e2e: {}, npm: {} }, stdio: 'ignore',
+      env: { ...process.env, GITHUB_ACTIONS: '', TEMP: leafTemp, TMP: leafTemp, TMPDIR: leafTemp }, log: () => {} });
+    assert.deepStrictEqual(r.failed, []);
+    const into = fs.readFileSync(path.join(dir, 'into.txt'), 'utf8');
+    assert.strictEqual(fs.readFileSync(path.join(into, 'keep.txt'), 'utf8'), 'keep', 'the folder moved into the record root was removed with it');
+    fs.rmSync(path.dirname(into), { recursive: true, force: true });
+  });
+
   const CREATE = names => `const e2eShard = require('./ci-shard').e2eShard(__filename, [${names.map(n => `'${n}'`).join(', ')}]);`;
   const START = '// e2e-shard: cases start here';
 

package/scripts/ci-shard.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 // T-0359: split CI work across parallel jobs. Until 1.36.300 each Windows gate job ran e2e.js (167-226 min) and the
 //   command-surface leaves (43-52 min) one after the other, and the Windows fast job ran its leaves for 79 min, so a
 //   release waited about five hours for CI (run 38193803239). A shard runs part of that work. Shards 1..k of one job
@@ -17,11 +18,17 @@
 //   guessed: running it differently from npm would test something else. Leaves run with node directly, in the
 //   package root, in their order in the script. A shard runs all of its leaves and fails if any failed, so one CI
 //   run reports every failing leaf of the shard (a plain `&&` chain stops at the first).
+// T-0357: each leaf records the temp folders it makes (scripts/temp-cleanup.js trackTemp, into a directory this runner
+//   gives it through LEERNESS_TEMP_RECORD), and the runner removes them after the leaf ended with status 0, no signal
+//   and no spawn error: the verdict it uses for pass/fail, read from the exit status, which no code in the leaf can
+//   change afterwards. A failed leaf's folders are kept for inspection.
 // e2e.js uses e2eShard() below: each top-level case is `if (e2eShard.take('<key>')) {`, and finish() checks that the
 //   file has no unguarded top-level block and that every guard was reached exactly once.
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const cp = require('child_process');
+const temp = require('./temp-cleanup');
 
 const ROOT = path.resolve(__dirname, '..');
 const WEIGHTS_FILE = path.join(__dirname, 'ci-shard-weights.json');
@@ -139,23 +146,48 @@ function runNpm(name, spec, opts = {}) {
   const grouped = env.GITHUB_ACTIONS === 'true';
   // Leaves do not see this runner's times file: a leaf that runs runNpm itself (ci-shard-probe.js) would overwrite it.
   const leafEnv = { ...env };
-  for (const k of Object.keys(leafEnv)) if (k.toUpperCase() === 'LEERNESS_CI_SHARD_TIMES') delete leafEnv[k];
+  for (const k of Object.keys(leafEnv)) if (['LEERNESS_CI_SHARD_TIMES', temp.RECORD_ENV].includes(k.toUpperCase())) delete leafEnv[k];
   log(`ci-shard: ${name} shard ${spec.index}/${spec.count} runs ${mine.length} of ${leaves.length} leaves`);
+  // T-0357: one record directory per leaf, below a root this runner makes. Each is checked right after it is made (an
+  //   empty directory, not a link, its identity kept): a wrapper of fs.mkdtempSync or fs.mkdirSync installed before
+  //   the runner could put an existing folder there (1.36.304 review round 3). A leaf whose directory fails the check
+  //   gets no variable and records nothing; only checked directories are removed, and the root only when it is empty.
+  const freshDir = d => {
+    try {
+      const st = fs.lstatSync(d, { bigint: true });
+      return st.isSymbolicLink() || !st.isDirectory() || fs.readdirSync(d).length ? null : temp.ownTree(d);
+    } catch { return null; }
+  };
+  let recordRoot = null;
+  try { recordRoot = freshDir(fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-temp-record-'))); } catch { /* nothing recorded */ }
+  const tempCount = { removed: 0, left: 0, unrecorded: 0 };
   const results = [];
-  for (const leaf of mine) {
+  for (const [i, leaf] of mine.entries()) {
     if (grouped) log(`::group::${leaf.key}`);
+    let recordDir = null;
+    if (recordRoot) { const d = path.join(recordRoot.dir, String(i)); try { fs.mkdirSync(d); recordDir = freshDir(d); } catch { /* nothing recorded */ } }
+    if (!recordDir) tempCount.unrecorded++;
     const started = Date.now();
-    const r = cp.spawnSync(process.execPath, [path.resolve(root, leaf.file), ...leaf.args], { cwd: root, stdio: opts.stdio || 'inherit', env: leafEnv });
+    const r = cp.spawnSync(process.execPath, [path.resolve(root, leaf.file), ...leaf.args], { cwd: root, stdio: opts.stdio || 'inherit', env: recordDir ? { ...leafEnv, [temp.RECORD_ENV]: recordDir.dir } : leafEnv });
     const seconds = (Date.now() - started) / 1000;
     const ok = r.status === 0 && !r.signal && !r.error;
+    if (ok && recordDir) { const t = temp.removeRecorded(recordDir.dir); tempCount.removed += t.removed; tempCount.left += t.left; }
+    if (recordDir) try { temp.removeOwnedTree(recordDir, { timeoutMs: 2000 }); } catch { /* left behind */ }
     results.push({ key: leaf.key, ok, seconds, status: r.status, signal: r.signal || null, error: r.error ? String(r.error.code || r.error.message) : null });
     if (grouped) log('::endgroup::');
     log(`ci-shard: ${ok ? 'ok  ' : 'FAIL'} ${seconds.toFixed(1).padStart(7)} s  ${leaf.key}${ok ? '' : ` (exit ${r.status}${r.signal ? `, signal ${r.signal}` : ''}${r.error ? `, ${r.error.code || r.error.message}` : ''})`}`);
   }
+  if (recordRoot) {
+    try {
+      const st = fs.lstatSync(recordRoot.dir, { bigint: true });
+      if (!st.isSymbolicLink() && st.dev === recordRoot.dev && st.ino === recordRoot.ino) fs.rmdirSync(recordRoot.dir);
+    } catch { /* not empty or replaced: left behind */ }
+  }
   const failed = results.filter(r => !r.ok);
   const total = results.reduce((s, r) => s + r.seconds, 0);
   log(`ci-shard: ${name} shard ${spec.index}/${spec.count}: ${results.length - failed.length}/${results.length} leaves passed · ${total.toFixed(0)} s`);
   for (const f of failed) log(`ci-shard: failed: ${f.key}`);
+  log(`ci-shard: temp folders: ${tempCount.removed} removed after passing leaves${tempCount.left ? `, ${tempCount.left} left (replaced, outside the temp directory, or still held)` : ''}${tempCount.unrecorded ? `, ${tempCount.unrecorded} leaves not recorded (their record directory was not the one made)` : ''}; a failed leaf keeps its own`);
   if (env.LEERNESS_CI_SHARD_TIMES) {
     fs.writeFileSync(env.LEERNESS_CI_SHARD_TIMES, JSON.stringify(Object.fromEntries(results.map(r => [r.key, Math.round(r.seconds * 10) / 10])), null, 1) + '\n');
   }

package/scripts/claim-runtime-cache-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // T-0303: generated runtime cache must not create a strict Git mismatch for
 // an unrelated, already committed claim when an older project lacks .gitignore.

package/scripts/claim-sweep-git-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // T-0302: count real Git status requests at the CLI boundary, rather than
 // matching the implementation's source text.

package/scripts/claims-baseline-concurrency-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // T-0145 multi-session regression: two first-time creators may both observe
 // "absent", but the create-only check inside the file lock must let exactly

package/scripts/claims-baseline-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // T-0145 regression probe: a reviewed legacy debt boundary unblocks only exact
 // historical failures. Raw/per-task audits, changed rows, new failures, invalid

package/scripts/command-flags-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 const fs = require('fs');
 const crypto = require('crypto');

package/scripts/context-current-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { createHash } = require('crypto');
 const { removeTree } = require('./temp-cleanup');

package/scripts/context-reading-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { removeTree } = require('./temp-cleanup');
 if (!process.argv.includes('--worker')) {

package/scripts/copy-tree-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 // T-0343: lib/copy-tree.js copyTreeSync, the fs.cpSync replacement used for fixture and selftest copies.
 // It must copy nested directories and file bytes exactly, copy into an existing directory, never overwrite a file,
 // and work with non-ASCII paths on every supported Node (fs.cpSync crashes on them in Node 22.23.3 on Windows).

package/scripts/crud-check-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 // T-0323 (owner request 2026-09-30): data features get the CRUD operations they need, by default and in every
 // leerness project. The owner chose "guidance plus an automatic check at completion" (advisory, never blocking),
 // for new features and changes to existing ones, and "the four operations plus quality items" as the standard:

package/scripts/dead-flags-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // T-0094: advertised options must change observable behavior (or fail closed).
 // This probe intentionally uses isolated projects and real CLI processes so a

package/scripts/done-status-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 // T-0332: which tracker statuses read as done. verify-claim (one task, and --all, which gate --claims runs), the claims
 // baseline, lazy detection and past-fix advice share one exact predicate: done, completed, verified or 완료, in any
 // case, with the cell's spaces trimmed, also inside one pair of brackets (the older tracker form, like [진행]).

package/scripts/dry-run-refusal-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 // T-0339: commands whose edits need a state lock refuse --dry-run with the dry-run refusal. Under --dry-run the CLI
 // takes no state lock (it would leave lock metadata), so lib/managed-text.js refused every edit with "Managed text
 // requires its existing state lock" (E_TEXT_LOCK) before its first write could meet the dry-run guard (task add, drop

package/scripts/e2e-child-diagnostics-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // Observation integration only: original E2E predicates, real temp files, no heavyweight CLI.
 const assert = require('node:assert/strict');

package/scripts/e2e-command-surface.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // T-0099 / UR-0076: historically uncovered command families.
 // Local state commands execute end-to-end in a disposable fixture. Commands that

package/scripts/e2e-concurrency.js

@@ -1,6 +1,7 @@
 // scripts/e2e-concurrency.js — T-0115의 silent lost-update 회귀 방지.
 // LOCKPROBE_STALL_*은 scripts/lock-probe.js를 명시 preload한 이 테스트에서만 활성화된다.
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 const fs = require('fs');
 const os = require('os');

package/scripts/e2e-core.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // 1.35.13 (UR-0014): 3-tier 테스트의 중간 티어 — critical-path 행위(behavioral) 스위트.
 //   test:fast (smoke.js) — 명령이 크래시 없이 도는가만 clean 프로젝트에서 확인, <1분. 개발 루프.

package/scripts/e2e-lived-in-harness.js

@@ -10,6 +10,7 @@
 // dated decision, a lesson, an active rule, an open user request, a closed session (a handoff naming the
 // in-progress task, the current state, a pre-wake report), the manifest, the installed skills and the usage counter.
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const fs = require('fs');
 const path = require('path');
 const cp = require('child_process');

package/scripts/e2e-repo-guard.js

@@ -8,6 +8,7 @@
 // A snapshot records size, mtime (ns) and inode of every file and each directory, gitignored state included.
 // Content hashes are unnecessary: a write moves mtime, and a rename or hard link changes the inode.
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const fs = require('fs');
 const os = require('os');
 const path = require('path');

package/scripts/e2e-temp-scope-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // T-0182: execute the original E2E counter and failure assertion, with real
 // process-local TMP isolation. No product implementation or fs/os mock.

package/scripts/e2e.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 const fs = require('fs');
 const os = require('os');
@@ -15957,6 +15958,10 @@ setImmediate(() => {
     failed++;
     console.log(`✗ T-0359 e2e 샤드 가드 이상 ${JSON.stringify({ problems: _shard.problems.slice(0, 10), missing: _shard.missing.slice(0, 10), repeated: _shard.repeated.slice(0, 10), unknown: _shard.unknown.slice(0, 10) })}`);
   }
+  // T-0357: 케이스가 만든 임시 폴더는 이 프로세스가 기록만 하고, 이 실행을 시작한 러너(scripts/ci-shard.js)가 종료 코드 0 을
+  //   보고 지운다(링크는 링크로만). 러너 없이 실행하면 기록하지 않는다.
+  const _temp = require('./temp-cleanup').trackTemp(module);
+  if (_temp.active) console.log(`  임시 폴더 ${_temp.pending()}개 기록 — 러너가 종료 코드 0 을 보면 삭제, 실패면 남김`);
   console.log(`\nE2E result: ${total - failed}/${total} passed${_shard.spec ? ` · shard ${_shard.spec.index}/${_shard.spec.count} (${_shard.ran}/${_shard.total} cases)` : ''} · ${((Date.now() - _e2eStart) / 1000).toFixed(0)}s`);
   if (failed > 0) process.exitCode = 1;
 });

package/scripts/encoding-diagnostics-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { createHash } = require('crypto');
 const { LEGACY_WORKSPACE_DIR } = require('../lib/workspace-dir');

package/scripts/encoding-selftest-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // T-0181: test the confirmed UR-0113 diagnostic/exit-code defect separately
 // from the unconfirmed Windows CI failure. The default violates the platform's

package/scripts/env-snapshot-text-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { createHash } = require('crypto');
 const { removeTree } = require('./temp-cleanup');

package/scripts/env-sync-text-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { removeTree } = require('./temp-cleanup');
 if (!process.argv.includes('--worker')) {

package/scripts/execution-ledger-sync-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // Real filesystem writes and process termination; injected I/O faults are
 // explicitly synthetic. These checks do not simulate physical power loss.

package/scripts/false-claim-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // T-0095 regression probe: read/status commands must state what they actually
 // measured. A CLI version is not a project version, an invalid memory verb is

package/scripts/feature-graph-text-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { removeTree } = require('./temp-cleanup');
 if (!process.argv.includes('--worker')) {

package/scripts/file-lease-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // Exact-file leases are an opt-in coordination primitive. This probe deliberately
 // distinguishes them from the discarded ambient scope advisory: only explicit calls

package/scripts/fix-evidence-language-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 // T-0333: `task fix-evidence` speaks the project's language. It printed Korean everywhere: in an English project the
 // header, the guidance, the per-row lines, the suggested evidence and the results of `--set` and of an empty list were
 // Korean. English projects now get English; Korean output stays byte for byte (every expected line below is the text

package/scripts/free-text-args-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 // T-0321: free text given to a command is exactly the positional text the user typed.
 // Reported: `clarify "<request>" --path <dir>` appends <dir> to the request. That did not reproduce —
 // main() builds args with nonFlagArgs(), which already drops registered value flags and their values; the

package/scripts/generation-text-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { createHash } = require('crypto');
 const { removeTree } = require('./temp-cleanup');

package/scripts/git-resolution-cache-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 const assert = require('assert');
 const fs = require('fs');

package/scripts/github-login-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // Real loopback TLS; only the test intercepts DNS destination/trust roots.
 const assert = require('node:assert/strict');

package/scripts/handoff-history-text-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 const assert = require('assert'), fs = require('fs'), path = require('path'), os = require('os'), cp = require('child_process');
 const { createHash } = require('crypto');
 const { removeTree } = require('./temp-cleanup');

package/scripts/handoff-i18n-probe.js

@@ -1,4 +1,5 @@
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 // T-0317: English handoff output carries no Korean-only tool text. An English project on Korean Windows saw the
 // terminal-encoding notice, skill suggestions, the official-skill cache note, next-step suggestions and the compact
 // "다음:" line in Korean. Every line the tool writes on the handoff paths now goes through a language helper whose

package/scripts/handoff-preservation-probe.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+require('./temp-cleanup').trackTemp(module); // T-0357: records this run's temp folders; the runner that started it removes them after a clean exit
 
 // T-0307: session close keeps user-written handoff text by position, and every reader of the
 // handoff looks at the current generated region rather than the whole file.