leerness 1.36.298 → 1.36.299

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 1.36.299 - 2026-10-12
+
+- Fixed: on Windows, `leerness skill publish` made a `.zip` instead of the `.tgz` when Git for Windows' GNU tar came first on PATH, as it does in Git Bash and in agent shells built on it (T-0352).
+  - Cause: the archive step gave `tar -czf` the absolute output path, and GNU tar reads the drive letter `C:` as a remote host ("Cannot connect to C:"). The step failed, and the Compress-Archive fallback made a `.zip`.
+  - The archive is now named relative to the `.leerness` folder, with forward slashes (`skills-publish-tarball/leerness-skills-<version>.tgz`). Windows' own tar (bsdtar) accepts that form too.
+- Fixed: on Windows, `leerness path-setup --apply` could take a different folder for the npm bin folder and not add it (T-0353).
+  - Cause: it compared Path entries with PowerShell's `-contains`. That comparison uses the culture and ignores characters such as a soft hyphen (U+00AD), so an entry that differed from the bin folder only by such a character counted as present. Measured in Windows PowerShell 5.1 and PowerShell 7.
+  - Entries are now compared by ordinal value, letter case aside.
+- Fixed: the recovery bundle that a memory write saves to the temp folder after a runtime-layout failure could be written inside the project (T-0349). The check that keeps it out compared the project and the temp folder as spelled.
+  - When the temp folder was named by an 8.3 short name (GitHub's Windows runners use `C:\Users\RUNNER~1\...`) or reached through a link, it could lie inside the project while its spelling did not.
+  - The check also took a folder inside the project whose name starts with two dots, such as `..temp`, for a folder outside it.
+  - The check now also compares their real paths, and only a first path part of exactly `..` counts as outside. A temp folder that does not resolve is refused, and so is a project path that fails to resolve for any reason other than being gone. A project path that no longer exists, because the project was renamed or removed during the operation, is compared as spelled only, as before, so its recovery is still saved.
+  - The bundle is now written below the temp folder's real path, the one that was checked, and the recovery folder it reports is named by that path. A temp link retargeted into the project after the check can no longer carry the bundle there.
+- Tests (T-0347, T-0349, T-0352, T-0353, T-0354, T-0355):
+  - `scripts/skill-archive-probe.js` (`npm run test:skill-archive`, in `test`, `test:core` and `test:fast`) asks the archive step for the `.tgz` with each tar the machine has first on PATH, and checks that tar made it, with the expected entries. Here that is Windows' bsdtar and Git for Windows' GNU tar. With the old absolute path it passes 2 of 6.
+  - `scripts/memory-recovery-external-probe.js` (21 tests) adds nine. The old check fails eight of them:
+    - A temp folder inside the project, named through a link outside the project or by its 8.3 short name, must be refused before any recovery work. So must a folder inside the project whose name starts with two dots, named directly or through a link.
+    - A temp folder that does not resolve must be refused, also when the project path is gone. So must a project path that fails to resolve with an error other than "not found" (simulated). With the old check, an unresolvable temp folder failed the recovery later, with ENOENT.
+    - A temp link retargeted into the project while the check runs (simulated) must not carry the bundle into the project.
+    - A project renamed away during the operation must still get its recovery outside it. The old check passes this one.
+  - `scripts/path-setup-powershell-probe.js` (19 checks):
+    - An entry that differs from the bin folder by a soft hyphen must not count as present. The old script fails it.
+    - Every registry run now requires the parser check first. With a command injected into the script, no registry run happened. With that requirement removed, the injected command ran.
+  - `scripts/memory-policy-root-spelling-probe.js`: the MCP checks and the resolve check use the first non-canonical spelling the machine has. Before, they always used the lowercase drive letter, which a UNC path does not have. They print SKIP when there is none.
+  - The shared support of the memory probes (`scripts/memory-migration-test-support.js`) now removes its temp arena when every test passed, and keeps it when one failed. Links inside the arena are removed as links first, so their targets are left alone. An arena, or a folder in it, that was replaced with a link is neither walked nor removed. This holds also when the replacement happens while `finish()` runs: each folder must still resolve inside the arena just before it is listed and before a link in it is removed. A process that kept replacing folders during `finish()` could still race those checks; `finish()` runs after the tests.
+    - Before, every run left one arena (1,206 were in this machine's temp folder on 2026-10-11).
+    - `scripts/memory-arena-cleanup-probe.js` (`npm run test:memory-arena-cleanup`, in `test`, `test:core` and `test:fast`) checks five cases with links to folders outside the arena, three of them with a replacement before or during `finish()`. On the old support all five fail: the removal case because nothing is removed, the failing-run and replace-before cases only on the note that `finish()` now prints, and the two replacement-during cases because the old `finish()` never looks at the arena, so the replacement never happens.
+  - The 24 `fs.cpSync` copies in 21 test files now use `lib/copy-tree.js` (T-0347). On Windows with Node 22.23.3, `fs.cpSync` ends the process with an access violation when a path has non-ASCII letters, as the temp folder does for a Windows user name in Korean.
+    - Measured with the temp folder set to `...\AppData\Local\Temp\임시한글` on Node 22.23.3: on the old code all 21 files crashed (Segmentation fault, exit 139 in Git Bash). With the change, 20 passed.
+    - The 21st, `scripts/store-values-probe.js`, failed one language check, which read the Hangul in the temp path as Korean text. Its language checks now mask the test folder's path first, and it passes.
+  - On Windows, `lib/copy-tree.js` now resolves a relative directory link against the copy's own folder, so the copied link names its sibling in the copy. Before, Node resolved the junction target against the process's working folder. On POSIX the relative link is copied as written and names the same sibling. `fs.cpSync` instead points such a link back into the source tree.
+    - `scripts/copy-tree-probe.js` checks this where links can be made. A Windows machine without the symlink privilege skips it.
+
 ## 1.36.298 - 2026-10-11
 
 - Fixed: on Windows, `leerness path-setup --apply` never registered the npm bin folder in the user PATH (T-0351). This was so from 1.9.254.

package/README.md

@@ -195,7 +195,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.298 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.299 하네스를 사용합니다. 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.298는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **102개 도구**를 노출:
+Leerness v1.36.299는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **102개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -270,7 +270,7 @@ Leerness v1.36.298는 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.298**. 공개 릴리스 여부는 공개 저장소의 태그와 배포 기록에서 별도로 확인합니다.
+현재 사용 중인 하네스 버전: **1.36.299**. 공개 릴리스 여부는 공개 저장소의 태그와 배포 기록에서 별도로 확인합니다.
 
 ### 성능 가이드
 
@@ -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.298: 2026-09-30
+Last synced by Leerness v1.36.299: 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.298';
+const VERSION = '1.36.299';
 
 // MCP lifecycle 주소 표식은 현재 CLI 호출 한 번에만 유효하다. CLI bootstrap에서 즉시 env에서
 // 떼어 두어 `--no-record`/hook처럼 presence 기록 함수에 도달하지 않는 경로도 후속 child에 유출하지 않는다.
@@ -3998,7 +3998,7 @@ function _pathDiagnose() {
 //   do to the user Path (review round 1): the read expands %VAR% entries with this process's values, and the write
 //   stores REG_SZ, so a REG_EXPAND_SZ Path (the Windows default, e.g. %USERPROFILE%\...\WindowsApps) would lose its
 //   references. The script reads the raw value and its registry type and writes both back. An entry counts as present
-//   only as written (letter case aside): expanding %VAR% here would use this shell's variables, which new terminals may
+//   only as written (ordinal, letter case aside): expanding %VAR% here would use this shell's variables, which new terminals may
 //   not have, and could report EXISTS for a directory they cannot reach (review round 3; the owner chose this). The
 //   cost is a harmless second entry when the Path already names the directory through a variable. Deleting a variable
 //   that does not exist through SetEnvironmentVariable(..., 'User') writes nothing but sends the WM_SETTINGCHANGE that
@@ -4020,7 +4020,10 @@ function _winPathPsScript() {
       + "$kind = [Microsoft.Win32.RegistryValueKind]::ExpandString; "
       + "if ($names -contains 'Path') { $kind = $k.GetValueKind('Path') }; "
       + "if ($kind -ne [Microsoft.Win32.RegistryValueKind]::String -and $kind -ne [Microsoft.Win32.RegistryValueKind]::ExpandString) { throw ('the user Path has registry type ' + $kind) }; "
-      + "if ($raw.Split(';') -contains $b) { [Console]::Out.WriteLine('EXISTS') } "
+      // T-0353: ordinal, case-insensitive. -contains compares with the culture, which ignores characters such as a
+      //   soft hyphen (U+00AD), so 'C:\np<U+00AD>m' counted as 'C:\npm' (measured in Windows PowerShell 5.1 and 7).
+      + "$found = $false; foreach ($p in $raw.Split(';')) { if ([string]::Equals($p, $b, [StringComparison]::OrdinalIgnoreCase)) { $found = $true } }; "
+      + "if ($found) { [Console]::Out.WriteLine('EXISTS') } "
       + "else { $nu = if ($raw -eq '') { $b } else { $raw.TrimEnd(';') + ';' + $b }; "
       + "$k.SetValue('Path', $nu, $kind); "
       + "[Environment]::SetEnvironmentVariable('LEERNESS_PATH_SETUP_NOTIFY', $null, 'User'); "
@@ -26493,7 +26496,12 @@ function _createArchive(cwd, sourceDir, outPath) {
   // 1) tar.gz (POSIX 환경에서 가장 안정)
   if (/\.(tgz|tar\.gz)$/i.test(outPath)) {
     tried.push('tar');
-    const r = _spawnPortableArgvSync('tar', ['-czf', outPath, sourceDir], {
+    // T-0352: the archive is named relative to cwd, with forward slashes. Git for Windows' GNU tar, first on PATH in
+    //   Git Bash, reads the drive letter of an absolute Windows path as a remote host ("Cannot connect to C:") and
+    //   failed, so the .zip fallback ran instead. bsdtar accepts either form. A path on another drive stays absolute.
+    const relativeOut = path.relative(cwd, outPath);
+    const tarOut = relativeOut && !path.isAbsolute(relativeOut) ? relativeOut.split(path.sep).join('/') : outPath;
+    const r = _spawnPortableArgvSync('tar', ['-czf', tarOut, sourceDir], {
       encoding: 'utf8', timeout: 30000, shell: false, cwd
     });
     if (r.status === 0 && exists(outPath)) return { ok: true, path: outPath, method: 'tar', tried };
@@ -34146,6 +34154,8 @@ module.exports = {
   _cliMutationClass, _mustRemainReadOnly, _runtimeProjectRoot,
   _npmGlobalBin, _dirInPath, _leernessResolvable, _pathDiagnose, _registerPath,
   _winPathPsScript, _unixPathBlock, pathSetupCmd,
+  // T-0352: the skill publish archive chain (tar, then the zip fallbacks), for scripts/skill-archive-probe.js.
+  _createArchive,
   _isSecretKey, compareVer, parseHarnessVersion,
   // 1.9.257: CJK 인코딩 분류 (UR-0014 계열) 순수 함수 — 단위 테스트
   _classifyCJK, _riskLabel,

package/lib/copy-tree.js

@@ -12,10 +12,14 @@ const path = require('path');
 function copyTreeSync(src, dst) {
   const stat = fs.lstatSync(src);
   if (stat.isSymbolicLink()) {
-    const target = fs.readlinkSync(src);
+    let target = fs.readlinkSync(src);
     let type;
     if (process.platform === 'win32') {
       try { type = fs.statSync(src).isDirectory() ? 'junction' : 'file'; } catch { type = 'file'; }
+      // T-0347: a junction's target must be absolute, and Node resolves a relative one against the process cwd.
+      //   A relative directory link is resolved against the copy's own folder, so it still names the place it named
+      //   relative to where it now is (fs.cpSync instead points it back into the source tree).
+      if (type === 'junction' && !path.isAbsolute(target)) target = path.resolve(path.dirname(dst), target);
     }
     fs.symlinkSync(target, dst, type);
     return;

package/lib/runtime-writes.js

@@ -159,13 +159,33 @@ function assertExternalRecoveryAllowed(root) {
   }
   const project = path.resolve(root);
   const base = path.resolve(os.tmpdir());
-  const relative = path.relative(project, base);
-  if (relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))) {
+  // T-0349: compared as spelled and as real paths. A temp folder reached through a link, or named by an 8.3 short
+  //   name (GitHub's Windows runners give C:\Users\RUNNER~1\...), can lie inside the project while its spelling does
+  //   not, and the recovery bundle was then written into the project it must stay out of. A temp folder that cannot
+  //   be resolved counts as unsafe. A project path that no longer exists (ENOENT or ENOTDIR: renamed or removed during
+  //   the operation, one way this latch is reached) has nothing at it to lie inside, so only its spelling is compared;
+  //   any other failure to resolve it counts as unsafe.
+  const unsafe = () => {
     const error = new Error(`External recovery temp must stay outside project root: ${base}`);
     error.code = 'E_RECOVERY_TEMP_UNSAFE';
     throw error;
-  }
-  return base;
+  };
+  // Outside means a first component of exactly '..' (a child folder may be named '..temp', review round 1).
+  const inside = (from, to) => {
+    const relative = path.relative(from, to);
+    return !(relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative));
+  };
+  const real = p => { try { return { path: fs.realpathSync.native(p) }; } catch (error) { return { error }; } };
+  const realBase = real(base), realProject = real(project);
+  if (!realBase.path) unsafe();
+  const missing = !realProject.path && ['ENOENT', 'ENOTDIR'].includes(realProject.error && realProject.error.code);
+  if (!realProject.path && !missing) unsafe();
+  if (inside(project, base)) unsafe();
+  if (realProject.path && inside(realProject.path, realBase.path)) unsafe();
+  // The bundle goes below the real path that was checked, not below the alias: a temp link retargeted into the project
+  // after this check would otherwise carry the bundle there (review round 2). A real folder replaced while the
+  // recovery runs is not covered, as for every path-based write here.
+  return realBase.path;
 }
 
 // Streaming recovery uses the same latch and external-only destination. The

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.298",
+  "version": "1.36.299",
   "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",
@@ -48,15 +48,15 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && npm run test:state-scopes && npm run test:runtime-compatibility && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/e2e-repo-guard.js && node ./scripts/e2e-lived-in-harness.js && npm run test:lock-heartbeat && npm run test:temp-cleanup && npm run test:path-setup && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && npm run test:harness-text && npm run test:test-plan && node ./scripts/i18n-next-cluster-probe.js && node ./scripts/handoff-i18n-probe.js && node ./scripts/provider-capacity-probe.js && npm run test:provider-response && npm run test:github-login && npm run test:provider-dispatch && npm run test:provider-receipt && npm run test:provider-observation && npm run test:ui-review-publication && npm run test:ui-review-target && npm run test:ui-review-authorization && npm run test:ui-review-authority-host && npm run test:ui-review-authority-floor && npm run test:ui-review-proof-use && npm run test:ui-review-recovery && node ./scripts/file-lease-probe.js && node ./scripts/role-agent-schema-probe.js && node ./scripts/role-store-loader-probe.js && node ./scripts/role-fallback-probe.js && npm run test:agent-bench-output && npm run test:agent-chat-stream && npm run test:encoding-diagnostics && npm run test:managed-text && npm run test:plan-text && npm run test:session-close-text && npm run test:brief-text && npm run test:generation-text && npm run test:install-text && npm run test:authoring-language && npm run test:context-reading && npm run test:rule-text && npm run test:mode-text && npm run test:handoff-text && npm run test:audit-text && npm run test:audit-readme-text && npm run test:audit-env-text && npm run test:feature-graph-text && npm run test:env-sync-text && npm run test:teams-text && npm run test:reminder-text && npm run test:handoff-history-text && npm run test:env-snapshot-text && npm run test:context-current && npm run test:review-feedback && npm run test:ledger-sync && npm run test:state-lock && npm run test:history-retention && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/handoff-readonly-probe.js && node ./scripts/mcp-presence-probe.js && npm run test:commands && npm run test:installed && node ./scripts/e2e.js && node ./scripts/review-checkpoint-probe.js && node ./scripts/review-checkpoint-transport-probe.js && node ./scripts/review-snapshot-probe.js && npm run test:memory-migration && npm run test:memory-items && npm run test:memory-budget && npm run test:memory-footprint && npm run test:memory-write-budget && npm run test:memory-write-preparation && npm run test:memory-write-admission && npm run test:memory-command-policy && npm run test:memory-publication-policy && npm run test:memory-recovery-transfer && npm run test:ui-boundary && node ./scripts/review-control-probe.js && npm run test:ui-review-run && npm run test:rule-verification",
-    "test:core": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && npm run test:state-scopes && npm run test:runtime-compatibility && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/e2e-repo-guard.js && node ./scripts/e2e-lived-in-harness.js && npm run test:lock-heartbeat && npm run test:temp-cleanup && npm run test:path-setup && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && npm run test:harness-text && npm run test:test-plan && node ./scripts/i18n-next-cluster-probe.js && node ./scripts/handoff-i18n-probe.js && node ./scripts/provider-capacity-probe.js && npm run test:provider-response && npm run test:github-login && npm run test:provider-dispatch && npm run test:provider-receipt && npm run test:provider-observation && npm run test:ui-review-publication-smoke && npm run test:ui-review-target-smoke && npm run test:ui-review-authorization-smoke && npm run test:ui-review-authority-host-smoke && npm run test:ui-review-authority-floor-smoke && npm run test:ui-review-proof-use-smoke && npm run test:ui-review-recovery && node ./scripts/file-lease-probe.js && node ./scripts/role-agent-schema-probe.js && node ./scripts/role-store-loader-probe.js && node ./scripts/role-fallback-probe.js && npm run test:agent-bench-output && npm run test:review-feedback && npm run test:ledger-sync && npm run test:state-lock && npm run test:history-retention && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/memory-guard-order-probe.js && node ./scripts/memory-input-preflight-probe.js && node ./scripts/memory-utf8-admission-probe.js && node ./scripts/memory-checked-input-probe.js && node ./scripts/memory-input-unit-probe.js && node ./scripts/memory-restore-canonical-probe.js && node ./scripts/memory-archive-retention-probe.js && node ./scripts/memory-archive-check-probe.js && node ./scripts/memory-projection-retention-probe.js && node ./scripts/memory-language-probe.js && node ./scripts/memory-legacy-retention-probe.js && node ./scripts/memory-recovery-receipt-probe.js && node ./scripts/memory-output-unit-probe.js && node ./scripts/memory-output-posix-probe.js && node ./scripts/memory-output-publication-probe.js && node ./scripts/memory-output-parent-race-probe.js && node ./scripts/handoff-readonly-probe.js && node ./scripts/mcp-presence-probe.js && node ./scripts/rule-applicability-probe.js && node ./scripts/review-checkpoint-probe.js && node ./scripts/review-checkpoint-transport-probe.js && node ./scripts/review-snapshot-probe.js && node ./scripts/review-snapshot-transport-probe.js && npm run test:memory-migration && npm run test:memory-items && npm run test:memory-budget && npm run test:memory-footprint && npm run test:memory-write-budget && npm run test:memory-write-preparation && npm run test:memory-write-admission && npm run test:memory-command-policy && npm run test:memory-publication-policy && npm run test:memory-recovery-transfer && npm run test:ui-boundary && npm run test:ui-review-run && npm run test:rule-verification",
+    "test": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && npm run test:state-scopes && npm run test:runtime-compatibility && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/e2e-repo-guard.js && node ./scripts/e2e-lived-in-harness.js && npm run test:lock-heartbeat && npm run test:temp-cleanup && npm run test:path-setup && npm run test:skill-archive && npm run test:memory-arena-cleanup && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && npm run test:harness-text && npm run test:test-plan && node ./scripts/i18n-next-cluster-probe.js && node ./scripts/handoff-i18n-probe.js && node ./scripts/provider-capacity-probe.js && npm run test:provider-response && npm run test:github-login && npm run test:provider-dispatch && npm run test:provider-receipt && npm run test:provider-observation && npm run test:ui-review-publication && npm run test:ui-review-target && npm run test:ui-review-authorization && npm run test:ui-review-authority-host && npm run test:ui-review-authority-floor && npm run test:ui-review-proof-use && npm run test:ui-review-recovery && node ./scripts/file-lease-probe.js && node ./scripts/role-agent-schema-probe.js && node ./scripts/role-store-loader-probe.js && node ./scripts/role-fallback-probe.js && npm run test:agent-bench-output && npm run test:agent-chat-stream && npm run test:encoding-diagnostics && npm run test:managed-text && npm run test:plan-text && npm run test:session-close-text && npm run test:brief-text && npm run test:generation-text && npm run test:install-text && npm run test:authoring-language && npm run test:context-reading && npm run test:rule-text && npm run test:mode-text && npm run test:handoff-text && npm run test:audit-text && npm run test:audit-readme-text && npm run test:audit-env-text && npm run test:feature-graph-text && npm run test:env-sync-text && npm run test:teams-text && npm run test:reminder-text && npm run test:handoff-history-text && npm run test:env-snapshot-text && npm run test:context-current && npm run test:review-feedback && npm run test:ledger-sync && npm run test:state-lock && npm run test:history-retention && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/handoff-readonly-probe.js && node ./scripts/mcp-presence-probe.js && npm run test:commands && npm run test:installed && node ./scripts/e2e.js && node ./scripts/review-checkpoint-probe.js && node ./scripts/review-checkpoint-transport-probe.js && node ./scripts/review-snapshot-probe.js && npm run test:memory-migration && npm run test:memory-items && npm run test:memory-budget && npm run test:memory-footprint && npm run test:memory-write-budget && npm run test:memory-write-preparation && npm run test:memory-write-admission && npm run test:memory-command-policy && npm run test:memory-publication-policy && npm run test:memory-recovery-transfer && npm run test:ui-boundary && node ./scripts/review-control-probe.js && npm run test:ui-review-run && npm run test:rule-verification",
+    "test:core": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && npm run test:state-scopes && npm run test:runtime-compatibility && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/e2e-repo-guard.js && node ./scripts/e2e-lived-in-harness.js && npm run test:lock-heartbeat && npm run test:temp-cleanup && npm run test:path-setup && npm run test:skill-archive && npm run test:memory-arena-cleanup && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && npm run test:harness-text && npm run test:test-plan && node ./scripts/i18n-next-cluster-probe.js && node ./scripts/handoff-i18n-probe.js && node ./scripts/provider-capacity-probe.js && npm run test:provider-response && npm run test:github-login && npm run test:provider-dispatch && npm run test:provider-receipt && npm run test:provider-observation && npm run test:ui-review-publication-smoke && npm run test:ui-review-target-smoke && npm run test:ui-review-authorization-smoke && npm run test:ui-review-authority-host-smoke && npm run test:ui-review-authority-floor-smoke && npm run test:ui-review-proof-use-smoke && npm run test:ui-review-recovery && node ./scripts/file-lease-probe.js && node ./scripts/role-agent-schema-probe.js && node ./scripts/role-store-loader-probe.js && node ./scripts/role-fallback-probe.js && npm run test:agent-bench-output && npm run test:review-feedback && npm run test:ledger-sync && npm run test:state-lock && npm run test:history-retention && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/memory-guard-order-probe.js && node ./scripts/memory-input-preflight-probe.js && node ./scripts/memory-utf8-admission-probe.js && node ./scripts/memory-checked-input-probe.js && node ./scripts/memory-input-unit-probe.js && node ./scripts/memory-restore-canonical-probe.js && node ./scripts/memory-archive-retention-probe.js && node ./scripts/memory-archive-check-probe.js && node ./scripts/memory-projection-retention-probe.js && node ./scripts/memory-language-probe.js && node ./scripts/memory-legacy-retention-probe.js && node ./scripts/memory-recovery-receipt-probe.js && node ./scripts/memory-output-unit-probe.js && node ./scripts/memory-output-posix-probe.js && node ./scripts/memory-output-publication-probe.js && node ./scripts/memory-output-parent-race-probe.js && node ./scripts/handoff-readonly-probe.js && node ./scripts/mcp-presence-probe.js && node ./scripts/rule-applicability-probe.js && node ./scripts/review-checkpoint-probe.js && node ./scripts/review-checkpoint-transport-probe.js && node ./scripts/review-snapshot-probe.js && node ./scripts/review-snapshot-transport-probe.js && npm run test:memory-migration && npm run test:memory-items && npm run test:memory-budget && npm run test:memory-footprint && npm run test:memory-write-budget && npm run test:memory-write-preparation && npm run test:memory-write-admission && npm run test:memory-command-policy && npm run test:memory-publication-policy && npm run test:memory-recovery-transfer && npm run test:ui-boundary && npm run test:ui-review-run && npm run test:rule-verification",
     "test:commands": "npm run test:hooks && npm run test:e2e-observation && node ./scripts/memory-guard-order-probe.js && node ./scripts/memory-input-preflight-probe.js && node ./scripts/memory-utf8-admission-probe.js && node ./scripts/memory-checked-input-probe.js && node ./scripts/memory-input-unit-probe.js && node ./scripts/memory-restore-canonical-probe.js && node ./scripts/memory-archive-retention-probe.js && node ./scripts/memory-archive-check-probe.js && node ./scripts/memory-projection-retention-probe.js && node ./scripts/memory-language-probe.js && node ./scripts/memory-legacy-retention-probe.js && node ./scripts/memory-recovery-receipt-probe.js && node ./scripts/memory-output-unit-probe.js && node ./scripts/memory-output-posix-probe.js && node ./scripts/memory-output-publication-probe.js && node ./scripts/memory-output-parent-race-probe.js && node ./scripts/command-flags-probe.js && node ./scripts/dead-flags-probe.js && node ./scripts/free-text-args-probe.js && node ./scripts/title-args-probe.js && node ./scripts/false-claim-probe.js && node ./scripts/claim-sweep-git-probe.js && node ./scripts/claim-runtime-cache-probe.js && node ./scripts/runtime-cost-probe.js && node ./scripts/secret-scan-scope-probe.js && node ./scripts/handoff-preservation-probe.js && node ./scripts/next-action-suggestion-probe.js && node ./scripts/api-skill-match-probe.js && node ./scripts/crud-check-probe.js && node ./scripts/claims-baseline-probe.js && node ./scripts/claims-baseline-concurrency-probe.js && node ./scripts/e2e-command-surface.js && node ./scripts/rule-applicability-probe.js && node ./scripts/review-request-labels-probe.js && node ./scripts/review-request-signals-probe.js && node ./scripts/store-values-probe.js && node ./scripts/review-snapshot-transport-probe.js && node ./scripts/bugfix-areas-probe.js && node ./scripts/done-status-probe.js && node ./scripts/fix-evidence-language-probe.js && node ./scripts/decision-fence-offset-probe.js && node ./scripts/task-sync-roundtrip-probe.js && node ./scripts/tracker-write-language-probe.js && node ./scripts/write-path-language-probe.js && node ./scripts/write-primitive-language-probe.js && node ./scripts/dry-run-refusal-probe.js",
     "test:e2e-observation": "node ./scripts/e2e-temp-scope-probe.js && node ./scripts/e2e-child-diagnostics-probe.js",
     "test:next-actions": "node ./scripts/next-action-suggestion-probe.js && node ./scripts/api-skill-match-probe.js",
     "test:installed": "npm run test:installed-lifecycle && node ./scripts/installed-cleanroom-probe.js",
     "test:installed-lifecycle": "node ./scripts/installed-handoff-lifecycle-probe.js",
     "test:handoff": "node ./scripts/handoff-readonly-probe.js",
-    "test:fast": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && npm run test:state-scopes && npm run test:runtime-compatibility && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/e2e-repo-guard.js && npm run test:lock-heartbeat && npm run test:temp-cleanup && npm run test:path-setup && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && npm run test:harness-text && npm run test:test-plan && node ./scripts/i18n-next-cluster-probe.js && node ./scripts/handoff-i18n-probe.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/memory-guard-order-probe.js && node ./scripts/memory-input-preflight-probe.js && node ./scripts/memory-utf8-admission-probe.js && node ./scripts/memory-checked-input-probe.js && node ./scripts/memory-input-unit-probe.js && node ./scripts/memory-restore-canonical-probe.js && node ./scripts/memory-archive-retention-probe.js && node ./scripts/memory-archive-check-probe.js && node ./scripts/memory-projection-retention-probe.js && node ./scripts/memory-language-probe.js && node ./scripts/memory-legacy-retention-probe.js && node ./scripts/memory-recovery-receipt-probe.js && node ./scripts/memory-output-unit-probe.js && node ./scripts/memory-output-posix-probe.js && node ./scripts/memory-output-publication-probe.js && node ./scripts/memory-output-parent-race-probe.js && node ./scripts/mcp-presence-probe.js && node ./scripts/provider-capacity-probe.js && npm run test:provider-response && npm run test:provider-dispatch && npm run test:provider-receipt && npm run test:provider-observation && npm run test:ui-review-recovery && node ./scripts/file-lease-probe.js && node ./scripts/role-agent-schema-probe.js && node ./scripts/role-store-loader-probe.js && node ./scripts/role-fallback-probe.js && npm run test:agent-bench-output && npm run test:ledger-sync && npm run test:state-lock && npm run test:history-retention && node ./scripts/false-claim-probe.js && node ./scripts/smoke.js && node ./scripts/rule-applicability-probe.js && node ./scripts/review-checkpoint-probe.js && node ./scripts/review-checkpoint-transport-probe.js && node ./scripts/review-snapshot-probe.js && node ./scripts/review-snapshot-transport-probe.js && npm run test:memory-migration && npm run test:memory-items && npm run test:memory-budget && npm run test:memory-footprint && npm run test:memory-write-budget && npm run test:memory-write-preparation && npm run test:memory-write-admission && npm run test:memory-command-policy && npm run test:memory-publication-policy && npm run test:memory-recovery-transfer && npm run test:ui-boundary && npm run test:rule-verification",
+    "test:fast": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && npm run test:state-scopes && npm run test:runtime-compatibility && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/workspace-dir-lock-order-probe.js && node ./scripts/lock-probe.js && node ./scripts/e2e-repo-guard.js && npm run test:lock-heartbeat && npm run test:temp-cleanup && npm run test:path-setup && npm run test:skill-archive && npm run test:memory-arena-cleanup && node ./scripts/platform-smoke.js && node ./scripts/parent-detect-selftest-probe.js && node ./scripts/release-runtime-probe.js && node ./scripts/which-shim-probe.js && node ./scripts/i18n-priority-surface-probe.js && npm run test:harness-text && npm run test:test-plan && node ./scripts/i18n-next-cluster-probe.js && node ./scripts/handoff-i18n-probe.js && node ./scripts/mutation-integrity-probe.js && node ./scripts/memory-guard-order-probe.js && node ./scripts/memory-input-preflight-probe.js && node ./scripts/memory-utf8-admission-probe.js && node ./scripts/memory-checked-input-probe.js && node ./scripts/memory-input-unit-probe.js && node ./scripts/memory-restore-canonical-probe.js && node ./scripts/memory-archive-retention-probe.js && node ./scripts/memory-archive-check-probe.js && node ./scripts/memory-projection-retention-probe.js && node ./scripts/memory-language-probe.js && node ./scripts/memory-legacy-retention-probe.js && node ./scripts/memory-recovery-receipt-probe.js && node ./scripts/memory-output-unit-probe.js && node ./scripts/memory-output-posix-probe.js && node ./scripts/memory-output-publication-probe.js && node ./scripts/memory-output-parent-race-probe.js && node ./scripts/mcp-presence-probe.js && node ./scripts/provider-capacity-probe.js && npm run test:provider-response && npm run test:provider-dispatch && npm run test:provider-receipt && npm run test:provider-observation && npm run test:ui-review-recovery && node ./scripts/file-lease-probe.js && node ./scripts/role-agent-schema-probe.js && node ./scripts/role-store-loader-probe.js && node ./scripts/role-fallback-probe.js && npm run test:agent-bench-output && npm run test:ledger-sync && npm run test:state-lock && npm run test:history-retention && node ./scripts/false-claim-probe.js && node ./scripts/smoke.js && node ./scripts/rule-applicability-probe.js && node ./scripts/review-checkpoint-probe.js && node ./scripts/review-checkpoint-transport-probe.js && node ./scripts/review-snapshot-probe.js && node ./scripts/review-snapshot-transport-probe.js && npm run test:memory-migration && npm run test:memory-items && npm run test:memory-budget && npm run test:memory-footprint && npm run test:memory-write-budget && npm run test:memory-write-preparation && npm run test:memory-write-admission && npm run test:memory-command-policy && npm run test:memory-publication-policy && npm run test:memory-recovery-transfer && npm run test:ui-boundary && npm run test:rule-verification",
     "test:false-claims": "node ./scripts/false-claim-probe.js",
     "test:claim-sweep": "node ./scripts/claim-sweep-git-probe.js",
     "test:claim-runtime": "node ./scripts/claim-runtime-cache-probe.js",
@@ -141,6 +141,8 @@
     "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: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",
     "test:ui-review-publication": "node ./scripts/ui-review-publication-probe.js",
     "test:ui-review-publication-smoke": "node ./scripts/ui-review-publication-probe.js --smoke",
     "test:ui-review-target": "node ./scripts/ui-review-target-probe.js",

package/scripts/bugfix-areas-probe.js

@@ -41,7 +41,7 @@ const seed = lang => {
   return (seeds[lang] = dir);
 };
 let copies = 0;
-const fresh = (lang = 'ko') => { const dir = path.join(arena, 'p' + (++copies)); fs.cpSync(seed(lang), dir, { recursive: true }); return dir; };
+const fresh = (lang = 'ko') => { const dir = path.join(arena, 'p' + (++copies)); require('../lib/copy-tree').copyTreeSync(seed(lang), dir); return dir; };
 const runIn = (cwd, args, runEnv = env) => cp.spawnSync(process.execPath, [CLI, ...args], { cwd, encoding: 'utf8', timeout: 300000, windowsHide: true, env: runEnv });
 const show = r => `exit ${r.status}\n${String(r.stdout || '').slice(0, 1200)}${String(r.stderr || '').slice(0, 600)}`;
 const json = (r, label) => { const out = String(r.stdout || ''); try { return JSON.parse(out.slice(out.indexOf('{'))); } catch { throw new Error(label + ': not JSON — ' + show(r)); } };

package/scripts/copy-tree-probe.js

@@ -50,6 +50,23 @@ try {
     assert.throws(() => copyTreeSync(from, to), error => error.code === 'EEXIST');
     assert.strictEqual(fs.readFileSync(path.join(to, 'bytes.bin'), 'utf8'), 'kept');
   });
+  // T-0347: a relative directory link must still name its sibling inside the copy. On Windows the copy is a junction,
+  // whose target must be absolute; Node resolved the relative one against the process cwd.
+  {
+    const from = path.join(arena, 'src-relative-link'), to = path.join(arena, 'dst-relative-link');
+    fs.mkdirSync(path.join(from, 'sibling'), { recursive: true });
+    fs.writeFileSync(path.join(from, 'sibling', 'mark.txt'), 'source');
+    let made = true;
+    try { fs.symlinkSync('sibling', path.join(from, 'link'), 'dir'); }
+    catch (error) { if (error.code !== 'EPERM') throw error; made = false; }
+    if (!made) console.log('SKIP a relative directory link (creating one needs the symlink privilege here)');
+    else test('a relative directory link names its sibling inside the copy', () => {
+      copyTreeSync(from, to);
+      fs.writeFileSync(path.join(to, 'sibling', 'mark.txt'), 'copy');
+      assert.strictEqual(fs.readFileSync(path.join(to, 'link', 'mark.txt'), 'utf8'), 'copy');
+      assert.strictEqual(fs.realpathSync.native(path.join(to, 'link')), fs.realpathSync.native(path.join(to, 'sibling')));
+    });
+  }
   test('a missing source is an error, not an empty copy', () => {
     assert.throws(() => copyTreeSync(path.join(arena, 'missing'), path.join(arena, 'dst-missing')), error => error.code === 'ENOENT');
     assert.ok(!fs.existsSync(path.join(arena, 'dst-missing')));

package/scripts/done-status-probe.js

@@ -34,7 +34,7 @@ const seed = () => {
   return (seedDir = dir);
 };
 let copies = 0;
-const fresh = () => { const dir = path.join(arena, 'p' + (++copies)); fs.cpSync(seed(), dir, { recursive: true }); return dir; };
+const fresh = () => { const dir = path.join(arena, 'p' + (++copies)); require('../lib/copy-tree').copyTreeSync(seed(), dir); return dir; };
 const runIn = (cwd, args) => cp.spawnSync(process.execPath, [CLI, ...args], { cwd, encoding: 'utf8', timeout: 300000, windowsHide: true, env });
 const show = r => `exit ${r.status}\n${String(r.stdout || '').slice(0, 1200)}${String(r.stderr || '').slice(0, 600)}`;
 const json = (r, label) => { const out = String(r.stdout || ''); try { return JSON.parse(out.slice(out.indexOf('{'))); } catch { throw new Error(label + ': not JSON — ' + show(r)); } };

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

@@ -225,7 +225,7 @@ if (require.main === module) {
     ]) {
       const copy = path.join(root, 'copy-' + (++n));
       covered.push(what);
-      fs.cpSync(dir, copy, { recursive: true });
+      require('../lib/copy-tree').copyTreeSync(dir, copy);
       t(`fixture: ${what} changed alone is the one reported missing (#${n})`, () => {
         change(copy);
         assert.deepStrictEqual(livedInMissing(copy).map(m => m.split(' (')[0]), [what]);
@@ -235,7 +235,7 @@ if (require.main === module) {
     // Control for the whole-id match: the id in Markdown emphasis still names the task.
     t('fixture: a handoff naming the task as __id__ still counts', () => {
       const copy = path.join(root, 'copy-emphasis');
-      fs.cpSync(dir, copy, { recursive: true });
+      require('../lib/copy-tree').copyTreeSync(dir, copy);
       edit(copy, 'session-handoff.md', built.ids.task1, '__' + built.ids.task1 + '__');
       assert.deepStrictEqual(livedInMissing(copy), []);
     });

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

@@ -31,7 +31,7 @@ const seed = lang => {
   return (seeds[lang] = dir);
 };
 let copies = 0;
-const fresh = lang => { const dir = path.join(arena, 'p' + (++copies)); fs.cpSync(seed(lang), dir, { recursive: true }); return dir; };
+const fresh = lang => { const dir = path.join(arena, 'p' + (++copies)); require('../lib/copy-tree').copyTreeSync(seed(lang), dir); return dir; };
 const runIn = (cwd, args, extraEnv = {}) => cp.spawnSync(process.execPath, [CLI, ...args], { cwd, encoding: 'utf8', timeout: 300000, windowsHide: true, env: { ...env, ...extraEnv } });
 const show = r => `exit ${r.status}\n${String(r.stdout || '').slice(0, 1500)}${String(r.stderr || '').slice(0, 600)}`;
 const addDone = (dir, title, evidence) => {

package/scripts/i18n-next-cluster-probe.js

@@ -140,7 +140,7 @@ function normalizedJson(label, result) {
 function cloneProjectState(target) {
   fs.mkdirSync(target, { recursive: true });
   fs.copyFileSync(path.join(project, 'package.json'), path.join(target, 'package.json'));
-  fs.cpSync(path.join(project, '.leerness'), path.join(target, '.leerness'), { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(path.join(project, '.leerness'), path.join(target, '.leerness'));
 }
 
 const surfaces = [

package/scripts/memory-archive-check-probe.js

@@ -37,7 +37,7 @@ const code = r => { try { return JSON.parse(r.stdout).code; } catch { return '(n
 // A project holding `rows` (canonical JSON and its generated Markdown), dropped by `target`: the drop is the product's.
 function dropped(surface, rows, target) {
   const project = path.join(temp, `case-${++sequence}`);
-  fs.cpSync(seed, project, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(seed, project);
   const hd = path.join(project, '.leerness');
   const f = { project, surface, json: path.join(hd, `${surface}.json`), md: path.join(hd, `${surface}.md`), archive: path.join(hd, `${surface}.archive.md`) };
   fs.writeFileSync(f.json, JSON.stringify(rows, null, 2) + '\n');

package/scripts/memory-archive-retention-probe.js

@@ -40,7 +40,7 @@ function run(project, args) {
 function success(r) { assert.strictEqual(r.status, 0, String(r.stdout || r.stderr).slice(-1000)); }
 function fixture(surface, entry) {
   const project = path.join(temp, `case-${++sequence}`);
-  fs.cpSync(seed, project, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(seed, project);
   const hd = path.join(project, '.leerness');
   const json = path.join(hd, `${surface}.json`);
   const md = path.join(hd, `${surface}.md`);
@@ -176,7 +176,7 @@ try {
   });
   check('a lesson saved with surrounding spaces through the CLI drops and restores exactly', () => {
     const project = path.join(temp, `case-${++sequence}`);
-    fs.cpSync(seed, project, { recursive: true });
+    require('../lib/copy-tree').copyTreeSync(seed, project);
     const json = path.join(project, '.leerness', 'lessons.json');
     success(run(project, ['lesson', 'save', ' existing ']));
     const saved = JSON.parse(fs.readFileSync(json, 'utf8'));

package/scripts/memory-arena-cleanup-probe.js

@@ -0,0 +1,106 @@
+'use strict';
+// T-0354: scripts/memory-migration-test-support.js removes its arena at finish() when every test passed, and keeps
+// it when one failed. A link inside the arena that points outside it is removed as a link: its target and the files
+// in it must survive. An arena, or a folder in it, that was replaced with a link is not walked, whether that happened
+// before finish() or while it ran. Each case runs the support in a child process, the way the memory probes use it.
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const support = path.join(__dirname, 'memory-migration-test-support.js');
+let passed = 0, failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log('PASS ' + name); }
+  catch (error) { failed++; console.error('FAIL ' + name + ': ' + (error && error.stack || error)); }
+}
+const linkType = process.platform === 'win32' ? 'junction' : 'dir';
+const unlinkLink = link => { try { fs.unlinkSync(link); } catch { fs.rmdirSync(link); } };
+const outside = fs.mkdtempSync(path.join(fs.realpathSync.native(os.tmpdir()), 'leerness-arena-cleanup-outside-'));
+const sentinel = path.join(outside, 'sentinel.txt');
+fs.writeFileSync(sentinel, 'kept');
+// A second outside folder with a link of its own, for the replacement cases.
+const elsewhere = fs.mkdtempSync(path.join(fs.realpathSync.native(os.tmpdir()), 'leerness-arena-cleanup-elsewhere-'));
+fs.writeFileSync(path.join(elsewhere, 'keep.txt'), 'kept');
+fs.symlinkSync(outside, path.join(elsewhere, 'keep-link'), linkType);
+// The child links to `outside` from inside its arena, runs one test that passes or fails, calls finish(), and prints
+// its arena path. `replace` renames a folder aside and puts a link to `elsewhere` in its place:
+//   'arena-before'      the arena, before finish();
+//   'arena-after-check' the arena, right after finish() checked its identity;
+//   'nested-during'     the arena's `nested` folder, right after finish() saw it as a folder.
+const child = (shouldFail, replace = '') => cp.spawnSync(process.execPath, ['-e', `
+  const S = require(${JSON.stringify(support)});
+  const fs = require('fs'), path = require('path');
+  const type = ${JSON.stringify(linkType)}, elsewhere = ${JSON.stringify(elsewhere)}, replace = ${JSON.stringify(replace)};
+  const swap = dir => { fs.renameSync(dir, dir + '-aside'); fs.symlinkSync(elsewhere, dir, type); };
+  fs.mkdirSync(path.join(S.arena, 'nested'));
+  fs.symlinkSync(${JSON.stringify(outside)}, path.join(S.arena, 'nested', 'link-out'), type);
+  if (replace === 'arena-before') swap(S.arena);
+  S.test('child test', () => { if (${shouldFail}) throw new Error('planned failure'); });
+  const lstat = fs.lstatSync;
+  let armed = replace === 'arena-after-check' || replace === 'nested-during';
+  fs.lstatSync = function (file, ...rest) {
+    const st = lstat.call(this, file, ...rest);
+    if (armed && replace === 'arena-after-check' && file === S.arena && rest[0] && rest[0].bigint) { armed = false; swap(file); }
+    if (armed && replace === 'nested-during' && file === path.join(S.arena, 'nested')) { armed = false; swap(file); }
+    return st;
+  };
+  S.finish('arena cleanup child');
+  fs.lstatSync = lstat;
+  console.log('ARENA ' + S.arena + (armed ? ' (the replacement never happened)' : ''));
+`], { encoding: 'utf8', windowsHide: true, timeout: 60000 });
+const arenaOf = r => {
+  const line = r.stdout.split(/\r?\n/).find(l => l.startsWith('ARENA '));
+  assert(line && !line.includes('never happened'), r.stdout + r.stderr);
+  return line.slice(6);
+};
+const outsideIntact = () => {
+  assert.strictEqual(fs.lstatSync(path.join(elsewhere, 'keep-link')).isSymbolicLink(), true, 'the link behind the replacement must be kept');
+  assert.strictEqual(fs.readFileSync(path.join(elsewhere, 'keep.txt'), 'utf8'), 'kept');
+  assert.strictEqual(fs.readFileSync(sentinel, 'utf8'), 'kept');
+};
+try {
+  test('a passing run removes its arena, and a link to a folder outside it leaves that folder alone', () => {
+    const r = child(false);
+    assert.strictEqual(r.status, 0, r.stdout + r.stderr);
+    assert.strictEqual(fs.existsSync(arenaOf(r)), false, 'the arena must be gone');
+    assert.strictEqual(fs.readFileSync(sentinel, 'utf8'), 'kept', 'the link target must be untouched');
+    assert.match(r.stdout, /arena cleanup child: 1\/1 passed; fixtures: .*\(removed\)/);
+  });
+  test('a failing run keeps its arena for inspection', () => {
+    const r = child(true);
+    assert.strictEqual(r.status, 1, r.stdout + r.stderr);
+    const arena = arenaOf(r), link = path.join(arena, 'nested', 'link-out');
+    assert.strictEqual(fs.existsSync(arena), true, 'the arena must be kept');
+    assert.strictEqual(fs.lstatSync(link).isSymbolicLink(), true, 'its contents must be kept');
+    assert.match(r.stdout, /arena cleanup child: 0\/1 passed; fixtures: .*\(kept\)/);
+    unlinkLink(link);
+    fs.rmSync(arena, { recursive: true, force: true });
+    assert.strictEqual(fs.readFileSync(sentinel, 'utf8'), 'kept');
+  });
+  for (const [replace, what] of [['arena-before', 'an arena replaced by a link before finish()'],
+    ['arena-after-check', 'an arena replaced by a link right after its identity check'],
+    ['nested-during', 'a folder in the arena replaced by a link while finish() walks the arena']]) {
+    test(`${what} is not walked, and nothing behind the link is removed`, () => {
+      // Each case starts with `elsewhere` whole, so one failure does not decide the next case.
+      try { fs.lstatSync(path.join(elsewhere, 'keep-link')); } catch { fs.symlinkSync(outside, path.join(elsewhere, 'keep-link'), linkType); }
+      fs.writeFileSync(path.join(elsewhere, 'keep.txt'), 'kept');
+      const r = child(false, replace);
+      assert.strictEqual(r.status, 0, r.stdout + r.stderr);
+      const arena = arenaOf(r);
+      outsideIntact();
+      assert.match(r.stdout, /arena cleanup child: 1\/1 passed; fixtures: .*\(not removed: E_ARENA_REPLACED\)/);
+      const swapped = replace === 'nested-during' ? path.join(arena, 'nested') : arena;
+      unlinkLink(swapped);
+      unlinkLink(path.join(replace === 'nested-during' ? path.join(arena, 'nested-aside') : path.join(arena + '-aside', 'nested'), 'link-out'));
+      fs.rmSync(replace === 'nested-during' ? arena : arena + '-aside', { recursive: true, force: true });
+    });
+  }
+} finally {
+  try { unlinkLink(path.join(elsewhere, 'keep-link')); } catch {}
+  fs.rmSync(elsewhere, { recursive: true, force: true });
+  fs.rmSync(outside, { recursive: true, force: true });
+}
+console.log(`memory arena cleanup probe: ${passed}/${passed + failed} passed (${process.platform})`);
+process.exitCode = failed ? 1 : 0;

package/scripts/memory-checked-input-probe.js

@@ -63,7 +63,7 @@ function run(project,args,config) {
 }
 let serial=0;
 function fixture(surface,legacy=false) {
-  const project=path.join(temp,'case-'+(++serial)); fs.cpSync(seed,project,{recursive:true});
+  const project=path.join(temp,'case-'+(++serial)); require('../lib/copy-tree').copyTreeSync(seed,project);
   const p=ext=>path.join(project,'.leerness',surface+'.'+ext);
   const item=value=>surface==='decisions'?{date:'2026-01-01',title:value,decision:value,reason:null,alternatives:null,impact:null,extension:{keep:'line1\nline2'}}:{date:'2026-01-01',text:value,tag:null,extension:{keep:'line1\nline2'}};
   const body=value=>surface==='decisions'?`### 2026-01-01 — ${value}\n- Decision: ${value}\n`:`### 2026-01-01\n- Lesson: ${value}\n`;

package/scripts/memory-guard-order-probe.js

@@ -36,7 +36,7 @@ const snapshot = root => Object.fromEntries([
 let sequence = 0;
 const fixture = () => {
   const root = path.join(temp, `case-${++sequence}`);
-  fs.cpSync(seed, root, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(seed, root);
   return root;
 };
 const check = (name, fn) => {

package/scripts/memory-input-preflight-probe.js

@@ -52,7 +52,7 @@ const syncProjection = (root, surface, entries) => fs.writeFileSync(projection(r
 let sequence = 0;
 function fixture() {
   const root = path.join(temp, `case-${String(++sequence).padStart(3, '0')}`);
-  fs.cpSync(seed, root, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(seed, root);
   return root;
 }
 function run(root, args) {

package/scripts/memory-legacy-retention-probe.js

@@ -44,7 +44,7 @@ function fileState(file) {
 }
 function fixture(surface) {
   const project = path.join(temp, `case-${++sequence}`);
-  fs.cpSync(seed, project, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(seed, project);
   const p = ext => path.join(project, '.leerness', `${surface}.${ext}`);
   const entry = value => surface === 'decisions'
     ? { date: '2026-09-12', title: value, decision: value, reason: 'reason', alternatives: null, impact: null }
@@ -131,7 +131,7 @@ try {
     });
     check(`${surface} fresh init remains usable and retains its template`, () => {
       const project = path.join(temp, `case-${++sequence}`);
-      fs.cpSync(seed, project, { recursive: true });
+      require('../lib/copy-tree').copyTreeSync(seed, project);
       const md = path.join(project, '.leerness', `${surface}.md`);
       const original = fs.existsSync(md) ? fs.readFileSync(md, 'utf8') : '';
       success(run(project, commands(surface).add));

package/scripts/memory-migration-test-support.js

@@ -54,8 +54,46 @@ function privateMetadata(result) {
 const legacy = surface => surface === 'decisions'
   ? `# Personal notes\n### 2026-09-12 — Example\n- Decision: ${PRIVATE}\n- Reason: test\n`
   : `# Personal notes\n### 2026-09-12\n- Lesson: ${PRIVATE}\n- Tag: fixture\n`;
+// T-0354: a run with no failures removes its arena; nothing did before, and every run of a memory probe left one in
+// the temp directory (1,206 were found). A failed run keeps it for inspection. Links inside the arena are removed
+// first, as links, so the removal never walks into a link's target, wherever that points. The arena itself must
+// still be the folder made above (same file identity, not a link): a test that renamed it away and put a link in its
+// place would otherwise have the walk run inside the link's target (review round 1).
+const arenaIdentity = fs.lstatSync(arena, { bigint: true });
+function sameArena() {
+  const st = fs.lstatSync(arena, { bigint: true });
+  return !st.isSymbolicLink() && st.isDirectory() && st.dev === arenaIdentity.dev && st.ino === arenaIdentity.ino;
+}
+// Review round 2: a folder can also be replaced by a link after its lstat, and the arena right after sameArena().
+// So each folder must still resolve inside the arena just before it is listed and before a link in it is removed.
+// finish() runs after the tests, so nothing else changes the arena then; a process that kept swapping folders
+// during finish() could still race these checks.
+const arenaReal = fs.realpathSync.native(arena);
+const replaced = () => Object.assign(new Error('the arena was replaced'), { code: 'E_ARENA_REPLACED' });
+function resolvesInArena(dir) {
+  const relative = path.relative(arenaReal, fs.realpathSync.native(dir));
+  return !(relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative));
+}
+function removeLinks(dir) {
+  if (!resolvesInArena(dir)) throw replaced();
+  for (const name of fs.readdirSync(dir)) {
+    const file = path.join(dir, name), st = fs.lstatSync(file);
+    if (st.isSymbolicLink()) {
+      if (!resolvesInArena(dir)) throw replaced();
+      try { fs.unlinkSync(file); } catch { fs.rmdirSync(file); }
+    } else if (st.isDirectory()) removeLinks(file);
+  }
+}
 function finish(label) {
-  console.log(`${label}: ${count - failed}/${count} passed; fixtures: ${arena}`);
-  if (failed) process.exitCode = 1;
+  let kept = '';
+  if (failed) { process.exitCode = 1; kept = ' (kept)'; }
+  else {
+    try {
+      if (!sameArena()) throw replaced();
+      removeLinks(arena); require('./temp-cleanup').removeTree(arena, { recursive: true, force: true }); kept = ' (removed)';
+    }
+    catch (error) { kept = ` (not removed: ${error.code || error.message})`; }
+  }
+  console.log(`${label}: ${count - failed}/${count} passed; fixtures: ${arena}${kept}`);
 }
 module.exports = { assert, fs, path, cp, arena, entry, PRIVATE, test, project, snapshot, command, privateMetadata, legacy, finish };

package/scripts/memory-output-publication-probe.js

@@ -107,7 +107,7 @@ function entry(surface, value) {
 function render(surface, entries) { return surface === 'decisions' ? _renderDecisionsMd(entries) : _renderLessonsMd(entries); }
 function fixture(surface, options = {}) {
   const project = path.join(temp, `case-${++sequence}`);
-  fs.cpSync(seed, project, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(seed, project);
   const hd = path.join(project, '.leerness');
   const json = path.join(hd, `${surface}.json`);
   const md = path.join(hd, `${surface}.md`);

package/scripts/memory-policy-root-spelling-probe.js

@@ -52,11 +52,18 @@ function restoreMcp(spelled, s) {
   assert(!r.error && !r.signal, r.error && r.error.message); assert.equal(r.status,0,r.stderr);
   return JSON.parse(r.stdout.trim().split(/\r?\n/)[0]);
 }
+// T-0355: a spelling this machine cannot give counts as absent: a test arena on a UNC path has no drive letter, and
+// a link may be refused there. The MCP and resolve-check tests take the first non-canonical spelling that exists.
+const trySpell = (spell, p) => { try { return spell(p); } catch { return null; } };
+function alternate(p) {
+  for (const [name, spell] of spellings.slice(1)) { const spelled = trySpell(spell, p); if (spelled && spelled !== p) return [name, spelled]; }
+  return null;
+}
 
 for (const s of ['decisions','lessons']) {
   let expected = null;
   for (const [name, spell] of spellings) {
-    const p = make(s), spelled = spell(p);
+    const p = make(s), spelled = trySpell(spell, p);
     if (spelled === null) { console.log(`SKIP ${s}: policy restore through ${name} (this volume or path gives no such spelling)`); continue; }
     test(`${s}: policy restore through ${name} matches the restore through the real path`, () => {
       if (name !== 'as created') assert.notStrictEqual(spelled, p, 'the spelling must differ from the real path');
@@ -68,10 +75,11 @@ for (const s of ['decisions','lessons']) {
       if (expected === null) expected = after; else assert.deepEqual(after, expected);
     });
   }
-  const [mcpName, mcpSpell] = spellings[1]; // a lowercase drive letter on Windows, a symlink elsewhere
+  const pm = make(s), alt = alternate(pm);
+  if (!alt) { console.log(`SKIP ${s}: MCP policy restore (this volume or path gives no non-canonical spelling)`); continue; }
+  const [mcpName, spelled] = alt; // a lowercase drive letter on Windows when there is one, a symlink elsewhere
   test(`${s}: MCP policy restore through ${mcpName}`, () => {
-    const p = make(s), spelled = mcpSpell(p);
-    assert(spelled && spelled !== p, 'the MCP case needs a non-canonical spelling');
+    const p = pm;
     const reply = restoreMcp(spelled, s);
     assert(reply.result, JSON.stringify(reply)); assert.equal(reply.result.isError, false, JSON.stringify(reply));
     assert.deepEqual(state(p, s).rows.map(entry => entry.title || entry.text), ['base','revive']);
@@ -80,9 +88,11 @@ for (const s of ['decisions','lessons']) {
 // The capture names files under the given spelling only after that spelling's workspace resolves to the resolved
 // one. Make it resolve elsewhere (as a swapped link would between the two resolutions) and the capture must refuse
 // before reading a file; without the check the files of the other folder would be measured as this project's.
-test('a spelled workspace that resolves to another folder is refused before any file is read', () => {
+const resolveCheckProject = make('decisions'), resolveCheckAlternate = alternate(resolveCheckProject);
+if (!resolveCheckAlternate) console.log('SKIP a spelled workspace that resolves to another folder (no non-canonical spelling here)');
+else test('a spelled workspace that resolves to another folder is refused before any file is read', () => {
   const { inspectMemoryFootprint } = require('../lib/memory-footprint');
-  const p = make('decisions'), other = make('decisions'), spelled = spellings[1][1](p);
+  const p = resolveCheckProject, other = make('decisions'), spelled = resolveCheckAlternate[1];
   const limits = JSON.stringify(options().observation);
   assert.equal(inspectMemoryFootprint(spelled,'decisions',limits).ok, true, 'control: the spelling itself is accepted');
   const workspace = path.join(spelled,'.leerness'), same = (a, b) => win ? a.toLowerCase() === b.toLowerCase() : a === b;

package/scripts/memory-projection-retention-probe.js

@@ -39,7 +39,7 @@ function run(project, args) {
 function success(r) { assert.strictEqual(r.status, 0, String(r.stdout || r.stderr).slice(-1000)); }
 function fixture(surface) {
   const project = path.join(temp, `case-${++sequence}`);
-  fs.cpSync(seed, project, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(seed, project);
   const hd = path.join(project, '.leerness');
   const p = ext => path.join(hd, `${surface}.${ext}`);
   const entry = surface === 'decisions'

package/scripts/memory-recovery-external-probe.js

@@ -5,7 +5,9 @@ const os=require('os'),runtime=require('../lib/runtime-writes'),{attachMemoryRec
 // Node 18 writeFileSync dispatches through the later intercepted writeSync.
 // Capture primitive fixture writers before installing interception, so descriptor
 // changes represent an external writer rather than the guarded operation itself.
-const rawOpen=fs.openSync.bind(fs),rawWriteSync=fs.writeSync.bind(fs),rawClose=fs.closeSync.bind(fs);
+const rawOpen=fs.openSync.bind(fs),rawWriteSync=fs.writeSync.bind(fs),rawClose=fs.closeSync.bind(fs),rawRename=fs.renameSync.bind(fs);
+const rawSymlink=fs.symlinkSync.bind(fs),rawUnlink=fs.unlinkSync.bind(fs),rawRmdir=fs.rmdirSync.bind(fs);
+const rawUnlinkLink=link=>{try{rawUnlink(link);}catch{rawRmdir(link);}};
 function rawWrite(file,text){const fd=rawOpen(file,'w');try{rawWriteSync(fd,Buffer.from(text));}finally{rawClose(fd);}}
 const descriptor={schema:'leerness.runtime-layout/v1',schemaVersion:1,scope:'project-local',generation:1,layout:'legacy',requiredWriterProtocol:1};
 // Begin in the supported implicit legacy layout. Creating an incompatible
@@ -36,6 +38,71 @@ test('a temp directory inside the project is rejected before producer work',()=>
     os.tmpdir=()=>p;try{assert.throws(()=>runtime.writeExternalRecoveryStream(p,()=>{called=true;},8),e=>e.code==='E_RECOVERY_TEMP_UNSAFE');}finally{os.tmpdir=original;}
   });assert.equal(called,false);
 });
+// T-0349: the same folder spelled so that its text is outside the project: through a link placed outside it, and
+// on Windows by its 8.3 short name. The guard compared spellings only and let both through.
+function shortName(p){const r=cp.spawnSync(process.env.ComSpec||'cmd.exe',['/d','/s','/c',`"for %I in ("${p}") do @echo %~sI"`],{encoding:'utf8',windowsHide:true,windowsVerbatimArguments:true});const out=String(r.stdout||'').trim();return r.status===0&&out&&!out.includes('"')&&out.toLowerCase()!==p.toLowerCase()?out:null;}
+const insideSpellings=[['a link outside the project',(p,inside)=>{const link=p+'-temp-link';fs.symlinkSync(inside,link,process.platform==='win32'?'junction':'dir');return link;}],
+  ...(process.platform==='win32'?[['its 8.3 short name',(p,inside)=>shortName(inside)]]:[])];
+for(const [name,spell] of insideSpellings){
+  const p=project(),inside=path.join(p,'temp-folder-with-a-long-name');fs.mkdirSync(inside);const spelled=spell(p,inside);
+  if(!spelled){console.log('SKIP a temp folder inside the project named by '+name+' (no such spelling here)');continue;}
+  test('a temp folder inside the project named by '+name+' is rejected before producer work',()=>{
+    assert(path.relative(p,spelled).startsWith('..'),'the spelling must look outside the project: '+spelled);
+    const original=os.tmpdir;let called=false;latch(p,()=>{
+      os.tmpdir=()=>spelled;try{assert.throws(()=>runtime.writeExternalRecoveryStream(p,()=>{called=true;},8),e=>e.code==='E_RECOVERY_TEMP_UNSAFE');}finally{os.tmpdir=original;}
+    });assert.equal(called,false);assert.deepEqual(fs.readdirSync(inside),[]);
+  });
+}
+// T-0349 review: a project folder renamed away while the operation runs has no real path. Its recovery must still be
+// written outside it, as before; only a temp folder that does not resolve is refused.
+test('a project renamed away during the operation still gets its recovery outside it',()=>{
+  const p=project(),moved=p+'-moved';let dir;latch(p,()=>{
+    rawRename(p,moved);try{dir=runtime.writeExternalRecoveryStream(p,sink=>sink.write('before.bin',put=>put(Buffer.from('before'))),8);}finally{rawRename(moved,p);}
+  });
+  external.push(dir);assert(path.relative(p,dir).startsWith('..'));assert.equal(fs.readFileSync(path.join(dir,'before.bin'),'utf8'),'before');
+});
+// Review round 1: a child folder whose name starts with two dots is inside the project, named directly and through a
+// link outside the project (only the real paths then show it).
+for(const [name,spell] of [['directly',(p,inside)=>inside],['through a link outside the project',(p,inside)=>{const link=p+'-dots-link';fs.symlinkSync(inside,link,process.platform==='win32'?'junction':'dir');return link;}]]){
+  test('a temp folder inside the project whose name starts with two dots, named '+name+', is rejected before producer work',()=>{
+    const p=project(),inside=path.join(p,'..temp');fs.mkdirSync(inside);const spelled=spell(p,inside),original=os.tmpdir;let called=false;latch(p,()=>{
+      os.tmpdir=()=>spelled;try{assert.throws(()=>runtime.writeExternalRecoveryStream(p,()=>{called=true;},8),e=>e.code==='E_RECOVERY_TEMP_UNSAFE');}finally{os.tmpdir=original;}
+    });assert.equal(called,false);assert.deepEqual(fs.readdirSync(inside),[]);
+  });
+}
+test('a project path that fails to resolve for a reason other than absence is refused',()=>{
+  const p=project(),original=fs.realpathSync.native;let called=false;latch(p,()=>{
+    fs.realpathSync.native=function(q,...rest){if(path.resolve(String(q))===path.resolve(p))throw Object.assign(new Error('EIO: simulated'),{code:'EIO'});return original.call(this,q,...rest);};
+    try{assert.throws(()=>runtime.writeExternalRecoveryStream(p,()=>{called=true;},8),e=>e.code==='E_RECOVERY_TEMP_UNSAFE');}finally{fs.realpathSync.native=original;}
+  });assert.equal(called,false);
+});
+// Review round 2: the temp link is retargeted into the project after it was checked (here, while the guard resolves
+// the project path). The bundle must still go below the folder that was checked.
+test('a temp link retargeted into the project after the check still gets the recovery outside the project',()=>{
+  const p=project(),inside=path.join(p,'temp-after-retarget');fs.mkdirSync(inside);
+  const safe=fs.mkdtempSync(path.join(path.dirname(p),'safe-temp-')),link=p+'-temp-retarget-link',type=process.platform==='win32'?'junction':'dir';
+  rawSymlink(safe,link,type);
+  const originalTmp=os.tmpdir,originalReal=fs.realpathSync.native;let dir,retargeted=false;
+  latch(p,()=>{
+    os.tmpdir=()=>link;
+    fs.realpathSync.native=function(q,...rest){if(!retargeted&&path.resolve(String(q))===path.resolve(p)){retargeted=true;rawUnlinkLink(link);rawSymlink(inside,link,type);}return originalReal.call(this,q,...rest);};
+    try{dir=runtime.writeExternalRecoveryStream(p,sink=>sink.write('before.bin',put=>put(Buffer.from('before'))),8);}finally{os.tmpdir=originalTmp;fs.realpathSync.native=originalReal;}
+  });
+  external.push(dir);assert(retargeted,'the link must have been retargeted during the check');
+  assert.deepEqual(fs.readdirSync(inside),[]);assert.equal(fs.readFileSync(path.join(dir,'before.bin'),'utf8'),'before');
+  assert(path.relative(fs.realpathSync.native(p),fs.realpathSync.native(dir)).split(path.sep)[0]==='..','the recovery must be outside the project: '+dir);
+});
+test('a missing temp folder is refused when the project path is gone too',()=>{
+  const p=project(),moved=p+'-moved-too',original=os.tmpdir;let called=false;latch(p,()=>{
+    rawRename(p,moved);os.tmpdir=()=>path.join(path.dirname(p),'missing-temp-folder');
+    try{assert.throws(()=>runtime.writeExternalRecoveryStream(p,()=>{called=true;},8),e=>e.code==='E_RECOVERY_TEMP_UNSAFE');}finally{os.tmpdir=original;rawRename(moved,p);}
+  });assert.equal(called,false);
+});
+test('a temp folder that does not resolve is refused before producer work',()=>{
+  const p=project(),original=os.tmpdir;let called=false;latch(p,()=>{
+    os.tmpdir=()=>path.join(path.dirname(p),'missing-temp-folder');try{assert.throws(()=>runtime.writeExternalRecoveryStream(p,()=>{called=true;},8),e=>e.code==='E_RECOVERY_TEMP_UNSAFE');}finally{os.tmpdir=original;}
+  });assert.equal(called,false);
+});
 test('invalid chunk admission occurs before creating an external namespace',()=>{
   const p=project();latch(p,()=>{for(const value of [0,-1,65537,1.5,'8'])assert.throws(()=>runtime.writeExternalRecoveryStream(p,()=>{},value),e=>e.code==='E_RECOVERY_BUNDLE_INVALID');});
 });

package/scripts/memory-recovery-receipt-probe.js

@@ -97,7 +97,7 @@ function entry(surface, value) {
 function render(surface, entries) { return surface === 'decisions' ? _renderDecisionsMd(entries) : _renderLessonsMd(entries); }
 function fixture(surface) {
   const project = path.join(temp, `case-${++sequence}`);
-  fs.cpSync(seed, project, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(seed, project);
   const hd = path.join(project, '.leerness');
   const json = path.join(hd, `${surface}.json`);
   const md = path.join(hd, `${surface}.md`);

package/scripts/memory-restore-canonical-probe.js

@@ -54,7 +54,7 @@ function check(name, fn) {
 }
 function fixture(surface) {
   const project = path.join(temp, `case-${++sequence}`);
-  fs.cpSync(seed, project, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(seed, project);
   const file = ext => path.join(project, '.leerness', `${surface}.${ext}`);
   const identity = surface === 'decisions' ? 'title' : 'text';
   const item = (value, extra = {}) => surface === 'decisions'

package/scripts/memory-utf8-admission-probe.js

@@ -54,7 +54,7 @@ function success(result) {
 }
 function fixture(surface, payload, bom = false) {
   const project = path.join(temp, `case-${++sequence}`);
-  fs.cpSync(seed, project, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(seed, project);
   const dir = path.join(project, '.leerness');
   const file = ext => path.join(dir, `${surface}.${ext}`);
   const item = identity => surface === 'decisions'

package/scripts/path-setup-powershell-probe.js

@@ -127,8 +127,14 @@ function hookRegistration(options = {}) {
   };
   return seen;
 }
+// T-0353: the parser check is a precondition for every run below. A script with a command in it (an appended
+// `reg.exe add HKCU\Environment ...`, say) would pass the text rewrite, and the final Path hash would only see the
+// damage afterwards; so when the script does not parse to zero commands, no registry run happens at all.
+let commandCheck = null;
+const scriptIsCommandFree = () => (commandCheck === null ? (commandCheck = commandsAndErrors(SCRIPT)) : commandCheck) === '0|0';
 // Runs _registerPath with the spawn hook. Returns its result, what the child printed, and the throwaway Path after.
 function register(bin, preset, options = {}) {
+  assert(scriptIsCommandFree(), 'the PATH script must parse to zero commands before any registry run: ' + commandCheck);
   presetTestPath(...preset);
   const seen = hookRegistration(options);
   let result;
@@ -193,6 +199,15 @@ try {
     assert.strictEqual(r.after, after);
     assert.deepStrictEqual({ ok: r.result.ok, method: r.result.method }, { ok: true, method: word === 'ADDED' ? 'powershell-user-path' : 'already' });
   });
+  // T-0353: the match is ordinal. PowerShell's -eq and -contains compare with the culture and ignore a soft hyphen,
+  // so an entry that only looks like the bin path counted as present.
+  test('an entry that differs from the bin path by an ignorable character is not taken as present', () => {
+    const softHyphen = String.fromCharCode(0xad);
+    const lookalike = BIN.slice(0, -1) + softHyphen + BIN.slice(-1);
+    const r = register(BIN, ['String', 'C:\\a;' + lookalike]);
+    assert.strictEqual(r.seen[0].stdout.toString(), 'ADDED\r\n', r.seen[0].stderr);
+    assert(r.after.startsWith('String=C:\\a;') && r.after.endsWith(';' + BIN), r.after);
+  });
   test('a bin path with PowerShell syntax is added as text', () => {
     const hostile = "C:\\safe $(Write-Output INJECTED) `tick 'q' t\\";
     const r = register(hostile, ['String', 'C:\\a']);

package/scripts/release-bump-probe.js

@@ -20,7 +20,7 @@ function versionFromSource(file) {
 }
 
 function copyFixture(root) {
-  for (const dir of ['bin', 'lib']) fs.cpSync(path.join(sourceRoot, dir), path.join(root, dir), { recursive: true });
+  for (const dir of ['bin', 'lib']) require('../lib/copy-tree').copyTreeSync(path.join(sourceRoot, dir), path.join(root, dir));
   for (const file of ['package.json', 'README.md']) fs.copyFileSync(path.join(sourceRoot, file), path.join(root, file));
   fs.mkdirSync(path.join(root, '.leerness'), { recursive: true });
   const version = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')).version;

package/scripts/review-request-labels-probe.js

@@ -38,7 +38,7 @@ const project = () => {
     fs.mkdirSync(path.join(template, '.leerness', 'skills'));
   }
   const dir = path.join(arena, 'p' + (++seq));
-  fs.cpSync(template, dir, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(template, dir);
   return dir;
 };
 const skill = (dir, id, displayNameKo, capabilities) => {

package/scripts/review-request-signals-probe.js

@@ -44,7 +44,7 @@ const project = () => {
     fs.mkdirSync(path.join(template, '.leerness', 'skills'));
   }
   const dir = path.join(arena, 'p' + (++seq));
-  fs.cpSync(template, dir, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(template, dir);
   return dir;
 };
 const store = (dir, name) => path.join(dir, '.leerness', name);

package/scripts/skill-archive-probe.js

@@ -0,0 +1,71 @@
+'use strict';
+// T-0352: the archive step of `leerness skill publish --bundle-only` (_createArchive in bin/leerness.js).
+// It ran `tar -czf <absolute path>`. Git for Windows' GNU tar, first on PATH in Git Bash and in agent shells built on
+// it, reads the drive letter of an absolute Windows path as a remote host and failed, so the .zip fallback ran
+// instead of the .tgz. The e2e check accepted either. This probe asks for the .tgz with each tar the machine has
+// first on PATH and checks that tar made it, with the expected entries.
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const zlib = require('zlib');
+const { _createArchive } = require('../bin/leerness.js');
+
+let passed = 0, failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log('PASS ' + name); }
+  catch (error) { failed++; console.error('FAIL ' + name + ': ' + (error && error.stack || error)); }
+}
+// Entry names of a .tgz, read with zlib and the ustar header layout (name at 0, prefix at 345).
+function tgzEntries(file) {
+  const tar = zlib.gunzipSync(fs.readFileSync(file)), names = [];
+  for (let at = 0; at + 512 <= tar.length;) {
+    const header = tar.subarray(at, at + 512);
+    if (header.every(byte => byte === 0)) break;
+    const text = (from, length) => header.subarray(from, from + length).toString('utf8').replace(/\0[\s\S]*$/, '');
+    const name = text(0, 100), prefix = text(345, 155), size = parseInt(text(124, 12).trim() || '0', 8);
+    const type = text(156, 1);
+    if (type !== 'x' && type !== 'g' && type !== 'L') names.push((prefix ? prefix + '/' : '') + name);
+    at += 512 + Math.ceil(size / 512) * 512;
+  }
+  return names.map(n => n.replace(/\/$/, '')).sort();
+}
+const arena = fs.mkdtempSync(path.join(fs.realpathSync.native(os.tmpdir()), 'leerness-skill-archive-'));
+function project(name) {
+  const root = path.join(arena, name), source = path.join(root, '.leerness', 'skills-publish');
+  fs.mkdirSync(path.join(source, 'skill-a'), { recursive: true });
+  fs.writeFileSync(path.join(source, 'manifest.json'), '{"skills":1}\n');
+  fs.writeFileSync(path.join(source, 'skill-a', 'SKILL.md'), '# Skill A\n');
+  return path.join(root, '.leerness');
+}
+const tars = [['the tar found on PATH', null]];
+if (process.platform === 'win32') {
+  const system32 = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32');
+  if (fs.existsSync(path.join(system32, 'tar.exe'))) tars.push(["System32's bsdtar first on PATH", system32]);
+  const gitUsrBin = path.join(process.env.ProgramFiles || 'C:\\Program Files', 'Git', 'usr', 'bin');
+  if (fs.existsSync(path.join(gitUsrBin, 'tar.exe'))) tars.push(["Git for Windows' GNU tar first on PATH", gitUsrBin]);
+  else console.log("SKIP Git for Windows' GNU tar first on PATH (not installed)");
+}
+const expected = ['skills-publish', 'skills-publish/manifest.json', 'skills-publish/skill-a', 'skills-publish/skill-a/SKILL.md'];
+const originalPath = process.env.PATH;
+try {
+  for (const [name, dir] of tars) {
+    for (const [where, out] of [['below the working folder', cwd => path.join(cwd, 'skills-publish-tarball', 'bundle.tgz')],
+      ['beside the working folder', cwd => path.join(path.dirname(cwd), 'out', 'bundle.tgz')]]) {
+      test(`.tgz with ${name}, archive ${where}`, () => {
+        const cwd = project(`p-${passed + failed}`), file = out(cwd);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        if (dir) process.env.PATH = dir + path.delimiter + originalPath;
+        let made;
+        try { made = _createArchive(cwd, 'skills-publish', file); } finally { process.env.PATH = originalPath; }
+        assert.deepStrictEqual({ ok: made.ok, method: made.method, path: made.path }, { ok: true, method: 'tar', path: file }, JSON.stringify(made));
+        assert.deepStrictEqual(tgzEntries(file), expected);
+      });
+    }
+  }
+} finally {
+  process.env.PATH = originalPath;
+  fs.rmSync(arena, { recursive: true, force: true });
+}
+console.log(`skill archive probe: ${passed}/${passed + failed} passed (${process.platform})`);
+process.exitCode = failed ? 1 : 0;

package/scripts/store-values-probe.js

@@ -31,6 +31,11 @@ const filter = process.argv.includes('--match') ? process.argv[process.argv.inde
 const test = (name, fn) => { if (filter && !name.includes(filter)) return; try { fn(); passed++; console.log('PASS ' + name); } catch (e) { failed++; console.error('FAIL ' + name + ': ' + (e && e.stack || e)); } };
 const run = (dir, args, extra = {}) => cp.spawnSync(process.execPath, [CLI, ...args], { cwd: dir, encoding: 'utf8', timeout: 300000, windowsHide: true, env: { ...env, ...extra } });
 const both = r => String(r.stdout || '') + String(r.stderr || '');
+// T-0347: the language checks read messages with the arena path masked. Below a temp folder with Hangul in its path
+//   (a Windows user name in Korean), a path in an English message is not Korean text, and in a Korean one it is not
+//   proof of Korean text.
+const arenaSpellings = [...new Set([arena, fs.realpathSync.native(arena)])];
+const prose = text => arenaSpellings.reduce((s, a) => s.split(a).join('<arena>'), String(text));
 const must = (r, label) => { assert.ifError(r.error); assert.strictEqual(r.status, 0, label + ' exit ' + r.status + '\n' + both(r)); return String(r.stdout || ''); };
 const json = (r, label) => { const out = must(r, label); try { return JSON.parse(out); } catch (e) { throw new Error(label + ': stdout is not one JSON object\n' + out.slice(0, 800)); } };
 // init takes most of the run time, so it runs once; each test works on its own copy, with no installed skills.
@@ -44,7 +49,7 @@ const project = () => {
     fs.mkdirSync(path.join(template, '.leerness', 'skills'));
   }
   const dir = path.join(arena, 'p' + (++seq));
-  fs.cpSync(template, dir, { recursive: true });
+  require('../lib/copy-tree').copyTreeSync(template, dir);
   return dir;
 };
 const store = (dir, ...parts) => path.join(dir, '.leerness', ...parts);
@@ -128,7 +133,7 @@ test('array fields that are not arrays do not crash skill commands, and skill le
     const r = run(dir, ['skill', 'learn', 'str-caps', '--capability', 'zebra import', '--language', lang, '--path', dir]);
     assert.strictEqual(r.status, 1, 'learn into a non-list must fail\n' + both(r));
     assert.ok(/capabilities/.test(both(r)) && !JS_ERROR.test(both(r)), both(r));
-    assert.ok(lang === 'en' ? !/[가-힣]/.test(both(r)) : /[가-힣]/.test(both(r)), lang + ' message: ' + both(r));
+    assert.ok(lang === 'en' ? !/[가-힣]/.test(prose(both(r))) : /[가-힣]/.test(prose(both(r))), lang + ' message: ' + both(r));
   }
   assert.strictEqual(fs.readFileSync(store(dir, 'skills', 'str-caps', 'skill.json'), 'utf8'), before);
   // skill use counts from zero when there is no count (it saved NaN as null); a count that is not a number and optimizations
@@ -295,9 +300,9 @@ test('malformed platform-constraints.json entries are reported as an invalid sto
   const dir = project();
   constraints(dir, shapes['aliases is a string']);
   const add = run(dir, ['constraints', 'add', 'acme', '--constraint', 'cost:x', '--language', 'en', '--path', dir]);
-  assert.ok(add.status === 1 && /damaged/.test(both(add)) && !/[가-힣]/.test(both(add)), both(add));
+  assert.ok(add.status === 1 && /damaged/.test(both(add)) && !/[가-힣]/.test(prose(both(add))), both(add));
   const note = json(run(dir, ['constraints', 'list', '--json', '--language', 'en', '--path', dir]), 'list --json en').note;
-  assert.ok(/damaged/.test(note) && !/[가-힣]/.test(note), note);
+  assert.ok(/damaged/.test(note) && !/[가-힣]/.test(prose(note)), note);
 });
 
 test('the graph page reads skill fields as text', () => {

package/scripts/task-sync-roundtrip-probe.js

@@ -37,7 +37,7 @@ const seed = () => {
   return (seedDir = dir);
 };
 let copies = 0;
-const fresh = () => { const dir = path.join(arena, 'p' + (++copies)); fs.cpSync(seed(), dir, { recursive: true }); return dir; };
+const fresh = () => { const dir = path.join(arena, 'p' + (++copies)); require('../lib/copy-tree').copyTreeSync(seed(), dir); return dir; };
 const runIn = (cwd, args) => cp.spawnSync(process.execPath, [CLI, ...args], { cwd, encoding: 'utf8', timeout: 300000, windowsHide: true, env });
 const show = r => `exit ${r.status}\n${String(r.stdout || '').slice(0, 1500)}${String(r.stderr || '').slice(0, 600)}`;
 const jsonOf = (r, label) => { const out = String(r.stdout || ''); try { return JSON.parse(out.slice(out.indexOf('{'))); } catch { throw new Error(label + ': no JSON — ' + show(r)); } };