leerness 1.36.303 → 1.36.304

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 1.36.304 - 2026-10-16
+
+- Fixed (tests): probes and e2e cases left their temp folders behind (T-0357). On 2026-10-14 this PC's temp directory held 8,434 `leerness-*` folders under 332 name prefixes; 5,142 of them came from e2e.js case sandboxes and 1,243 from the memory probes' arena (T-0354 fixed that one). The test runner now removes them: the test process records the folders it makes, and `scripts/ci-shard.js` removes them after the test ended with exit status 0.
+  - `scripts/temp-cleanup.js` `trackTemp(module)` records only when the environment carries `LEERNESS_TEMP_RECORD`, a directory the runner makes for each leaf; without it nothing is wrapped and the script behaves as before. It wraps `fs.mkdtempSync` and appends one line per folder to its own file in that directory in the same synchronous step that made the folder. The callback and promise forms are not wrapped: they complete later, when another folder may have been put in place (review round 1); their folders are left, and no script in `scripts/` uses them. It removes nothing and installs no exit, emit or exception hook. Child processes that inherit the variable record into the same directory.
+  - What is recorded: only a call whose prefix is an absolute path without `.` or `..` segments; a `Buffer` prefix or result only if it is UTF-8 that decodes and encodes back to the same bytes; a result only if it is the prefix followed by the six characters mkdtemp adds; a folder only if it is strictly below the temp directory of the moment of the call and empty when the call returns (a wrapper installed before the tracker could otherwise put an existing folder in its place; review round 2). Others are left, as before.
+  - `runNpm` gives each leaf its own record directory and, after the leaf ended with status 0, no signal and no spawn error (the verdict it uses for pass/fail), removes the recorded folders newest first with `removeRecorded`: each must still be the folder recorded (same file identity and real path, not a link) and strictly below both the temp directory recorded with it and the runner's own; links inside are removed as links and never followed, and each folder must still resolve inside the tree before it is listed and before a link in it is removed (the checks T-0354 wrote for the memory arena, shared as `ownTree` and `removeOwnedTree`). A failed leaf keeps its folders. The runner checks its record root and each leaf's directory right after making them (an empty directory, not a link; a wrapper of `fs.mkdtempSync` or `fs.mkdirSync` installed before the runner could put an existing folder there, review round 3); a leaf whose directory fails gets no variable and records nothing. It removes only the leaf directories it checked, the root only when it is empty, and prints one line with the counts.
+  - Each of the 171 scripts in `scripts/` that name `mkdtemp` has the tracker as its first statement, before it loads anything from `lib/` or `bin/`; the tracker records only when given a module whose chain reaches the main module, in the main thread (a script loaded with `--require` into another process, anything it loads, and a call without a module record nothing).
+  - Runs that do not go through the runner (`node scripts/x.js`, a plain `npm test`, and CI's e2e and core jobs, which run on throw-away machines) record nothing and leave their folders as before; CONTRIBUTING.md names `node ./scripts/ci-shard.js npm test 1/1` for a local run that cleans up.
+  - Not covered: folders made by processes that do not inherit the variable or do not run the tracker (such as the CLI a probe starts); a test that writes into the record directory, replaces the mkdtemp functions again, or patches the module loader; a folder a process renames or replaces after recording it (left).
+  - Measured with each tree's own runner (the 30 probes of the 2026-10-14 prefix map, one leaf each, a dedicated temp directory per tree, side by side): 29 `leerness-*` folders left with 1.36.303 and 1 now (a memory recovery bundle that `memory-recovery-external-probe.js` makes while it points the temp directory elsewhere); every leaf passed. The full test run (`ci-shard.js npm test i/3`, three shards in parallel, each with its own new temp directory; Windows, Node v26.3.0; on the round-4 code, before the later changes, which touch only `temp-cleanup-probe.js` and `ci-shard-probe.js`): 68/68, 69/69 and 69/69 leaves passed, e2e 469/469 with 432 folders recorded; the runner removed 37, 116 and 150 folders. Five `leerness-*` folders were left: one that an e2e case replaces after it was recorded (`orph116`); two memory recovery bundles from processes that do not record (the one above, and one made by the CLI that `memory-migration-boundary-probe.js` starts); and two that the record-root test of `ci-shard-probe.js` left, the folder it swaps in and the root it moves aside (that test now removes them; run alone and as a leaf it leaves nothing). The first full run of this version left 10 memory recovery bundles: `lib/runtime-writes.js` intercepts fs writes, and the record went through `fs.appendFileSync`, which calls the intercepted `fs.openSync`. Records are now written, and folders read, with the fs functions of the moment the tracker starts.
+  - Why the runner: 1.36.302 and 1.36.303 decided inside the test process at exit. In eight review rounds a later piece of JavaScript (another exit listener, a microtask, an exception handler, an interrupted `process.exit()`) kept changing the verdict after the decision; the owner moved the change out of both releases. The exit status the runner reads cannot change afterwards. The first review round of this version found two problems (an asynchronous mkdtemp whose folder was swapped before its completion was recorded; a call without a module skipped the check against preloads) and the second one more (a wrapper preloaded before the tracker swapped an existing folder in); the third found that the runner's own record root was removed without that check, and that the lossy-`Buffer` test did not distinguish on POSIX; the owner chose one more round, and the fourth found that the encoded-result test did not distinguish its check (a test was added, which fails on that mutant; the owner chose a short confirmation of it, which found that the new test failed when the temp path holds a non-ASCII letter: it is skipped there; a second confirmation found that the skip also gives up a setup where a link of the mangled name leads back into the temp path, and the owner chose to document that and ship). Each code fix has a test that fails on the reviewed code.
+- Tests: `scripts/temp-cleanup-probe.js` has twenty-seven cases (four before) and `scripts/ci-shard-probe.js` three more (seventeen):
+  - without `LEERNESS_TEMP_RECORD` the tracker changes nothing (the mkdtemp functions stay the same objects, nothing is recorded or removed); with it, `fs.mkdtempSync` records its folder with path, identity, real path and temp directory in the process's own file, and the process removes nothing; `fs.mkdtemp`, `fs.promises.mkdtemp`, `require('fs/promises').mkdtemp` and `util.promisify(fs.mkdtemp)` stay unwrapped and record nothing, also when the folder is swapped for another before the completion (review round 1); a record is written when the call returns, so a run that then fails, throws or calls `process.exit(3)` keeps it; a record is written and the folder read with the fs functions of the start, also after the test replaced `fs.openSync`, `fs.writeSync`, `fs.appendFileSync`, `fs.lstatSync` and `fs.realpathSync.native`;
+  - a folder that is not empty when `fs.mkdtempSync` returns is not recorded: a wrapper preloaded before the tracker that swaps in a folder holding a file gets nothing recorded, and that folder survives the runner's removal (an empty folder swapped in is recorded, as named in the stop rule);
+  - not recorded: a `Buffer` prefix that is not UTF-8, also when a wrapper preloaded before the tracker planted the sibling its lossy decoding names (POSIX; Windows refuses such a prefix, so there it is a control); a result in another encoding that is not the prefix plus six characters (`hex`, and `latin1` with a non-ASCII letter, also when a wrapper preloaded before the tracker made the folder the mangled result names; review round 4; skipped when the temp path itself holds a non-ASCII letter, which `latin1` mangles too, also where a link of the mangled name would lead back into it); a relative prefix, a dotted prefix, and a folder outside the temp directory; recorded: a `Buffer` result that is UTF-8 and a `file:` URL prefix; each case has a control that must be recorded in the same process;
+  - with recording on, `process.reallyExit`, `process.exit`, `process.emit` and the `exit`, `beforeExit`, `uncaughtExceptionMonitor` and `newListener` listener counts are unchanged;
+  - nothing is recorded by `trackTemp()` without a module (in a main script, a `--require` preload, or `node -e`; review round 1), by a script loaded with `--require` (directly, through `NODE_OPTIONS`, a module such a script loads, 60 requires deep, or through `createRequire()`), or in a worker thread started from a script file; the same script, and the same 60-deep chain, run as the main script record, and so does a main script after `temp-cleanup.js` itself was preloaded; one tracker per process;
+  - `removeRecorded` removes the recorded folders newest first, nested ones too, and leaves a link's target alone; it leaves a folder replaced by a link (and the link) or by another folder, skips one already gone, leaves a folder outside the runner's temp directory or outside the temp directory of its own record, skips lines it cannot use, and removes nothing for an empty or missing directory;
+  - `scripts/ci-shard-probe.js`: `runNpm` removes the folders a passing leaf and its tracked child recorded and keeps those of a failing leaf and of a killed one; each leaf gets its own record directory, the runner leaves no record directory behind, prints the count line, and does not change the caller's environment; a wrapper that swaps an existing folder in for the record root or a leaf's record directory gets nothing removed and the leaf no variable (the test then removes those folders itself; the full run found them left); a folder a leaf moves into the record root is left with the root;
+  - every script in `scripts/` that names `mkdtemp` in any form has the tracker as its first statement; the check refuses a tracker in a block comment, a line comment (ended by any JavaScript line terminator: CR, LF, U+2028, U+2029), a string, or after other code.
+  - 35 deliberate breaks of `temp-cleanup.js` and `ci-shard.js` (each check removed or weakened in turn, including reverting each review fix) were run against this probe, `ci-shard-probe.js` and `memory-arena-cleanup-probe.js`, with the unchanged files as the control (27/27, 17/17 and 5/5): 27 made a case fail on Windows (one of them, the encoded-result check, only through the round-4 test). Of the eight that pass on Windows, two concern POSIX only (a lossily decoded `Buffer` prefix, which Windows refuses; a leaf ended by a signal, which on Windows ends with exit code 1; CI's Linux jobs run the same tests); one is the identity check when the runner removes a leaf's record directory, which matters only if the leaf replaces that directory (a test writing into the record directory, named in the stop rule); the other five do not change what is removed, because another check stops the same case (a link in place of a folder has another identity; a real path that moved fails the inside check of `removeOwnedTree`; the identity check repeated inside `removeOwnedTree` and the inside check before listing guard only against changes during the removal; an inherited variable of the same name is replaced for the leaf).
+
 ## 1.36.303 - 2026-10-15
 
 - Fixed (tests): `scripts/ci-shard.js` passed its own `LEERNESS_CI_SHARD_TIMES` to the leaves it runs, so `scripts/ci-shard-probe.js`, which runs the runner itself, overwrote the outer run's times file in the middle of a local full run (found in a full run for this release; the outer runner rewrote the file at its end, so the stored times were right). Leaves no longer see the variable, the way `e2eShard` already hides its own. CI does not set it. A new probe case fails on the 1.36.302 runner (13/14) and passes now (14/14) (T-0364).

package/CONTRIBUTING.md

@@ -37,6 +37,8 @@ When you add a guard, construct the **discriminating case**: an input where the
 
 Each top-level case in `scripts/e2e.js` starts with `if (e2eShard.take('<unique key>')) {` and counts itself with `total++;` inside the block. CI runs that file, `test:commands` and `test:fast` in parallel shards (`scripts/ci-shard.js`): every shard computes the same split from `scripts/ci-shard-weights.json`, so the shards of one job run each case and leaf exactly once. A top-level block without the guard, a repeated key, or a guard that is not reached exactly once fails the e2e run. `node ./scripts/ci-shard.js plan e2e 4` shows the split; a run with `LEERNESS_E2E_TIMES=<file>` (e2e) or `LEERNESS_CI_SHARD_TIMES=<file>` (npm leaves) writes measured seconds, and `node ./scripts/ci-shard.js weights e2e <file>` stores them.
 
+A script in `scripts/` that makes temp folders with `fs.mkdtempSync`, `fs.mkdtemp` or `fs.promises.mkdtemp` starts with `require('./temp-cleanup').trackTemp(module);` as its first statement, before it loads anything from `lib/` or `bin/`. Under the test runner (`node ./scripts/ci-shard.js npm <script> <i>/<k>`, as CI runs `test:commands` and `test:fast`, or `node ./scripts/ci-shard.js npm test 1/1` locally), the script records the folders it makes below the temp directory, and the runner removes them after the script ended with exit status 0 and keeps them after a failure; links inside are removed as links, never followed. Child processes that inherit the runner's variable record too. Run directly (`node scripts/x.js`, a plain `npm test`), nothing is recorded or removed. Only code that the main script loaded records; a script loaded with `--require` into another process does not. `scripts/temp-cleanup-probe.js` fails when a script that names `mkdtemp` lacks the line.
+
 ## Release
 
 `npm test` (gate) → bump `VERSION` in `bin/leerness.js` **and** `version` in `package.json` (selftest asserts they match) → CHANGELOG entry → commit → publish → push.

package/README.md

@@ -195,7 +195,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.303 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.304 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### 정체성 — AI 에이전트 운영 레이어 (UR-0030)
 
@@ -249,7 +249,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.36.303는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **102개 도구**를 노출:
+Leerness v1.36.304는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **102개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -270,7 +270,7 @@ Leerness v1.36.303는 stdio JSON-RPC MCP server를 내장합니다 — Claude Co
 `<<autonomous-loop-dynamic>>` 신호만 보내면 AI가:
 1) 다음 라운드 후보 선정 → 2) 코드 변경 → 3) 회귀 테스트 갱신 → 4) 전체 e2e 스위트 통과 → 5) npm publish + git tag → 6) main push → 7) session close → 8) 다음 라운드 예약.
 
-현재 사용 중인 하네스 버전: **1.36.303**. 공개 릴리스 여부는 공개 저장소의 태그와 배포 기록에서 별도로 확인합니다.
+현재 사용 중인 하네스 버전: **1.36.304**. 공개 릴리스 여부는 공개 저장소의 태그와 배포 기록에서 별도로 확인합니다.
 
 ### 성능 가이드
 
@@ -308,7 +308,7 @@ leerness release pack --close --auto-main-push
 - `.leerness/session-handoff.md`: 다음 세션 인수인계 (자동 작성)
 - `.leerness/lessons.md` / `decisions.md` / `rules.md`: 영구 메모리 (5 surface)
 
-Last synced by Leerness v1.36.303: 2026-09-30
+Last synced by Leerness v1.36.304: 2026-09-30
 <!-- leerness:project-readme:end -->
 GitHub 로그인 계정 확인용 서버 어댑터: [설정·연결·승인과의 구분](docs/github-login.md). 실제 앱 등록/브라우저 세션 연결과 대상별 승인은 후속입니다.
 

package/bin/leerness.js

@@ -115,7 +115,7 @@ const {
   migrateLegacyWorkspace,
 } = require('../lib/workspace-dir');
 
-const VERSION = '1.36.303';
+const VERSION = '1.36.304';
 
 // MCP lifecycle 주소 표식은 현재 CLI 호출 한 번에만 유효하다. CLI bootstrap에서 즉시 env에서
 // 떼어 두어 `--no-record`/hook처럼 presence 기록 함수에 도달하지 않는 경로도 후속 child에 유출하지 않는다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.303",
+  "version": "1.36.304",
   "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",

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