leerness 1.36.299 → 1.36.300

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 1.36.300 - 2026-10-13
+
+- Fixed: `leerness lazy detect --auto-track` registered TODOs that a task already covered (T-0345).
+  - When a batch of new TODOs mixed files that no tracker row references with a file a task already referenced, every new TODO got a task, including those in the referenced file.
+  - Now only the TODOs whose file no row references are registered, decided under the tracker lock as before, and `known-todos.json` gains exactly those. A TODO in a referenced file is left as it is, as without `--auto-track`.
+- Tests (T-0345, T-0346):
+  - `scripts/lazy-auto-track-probe.js` (`npm run test:lazy-auto-track`, in `test:commands`) checks a mixed batch, a rerun, and two controls: nothing referenced, and everything referenced. On the old code the two mixed-batch cases fail: the referenced file's two TODOs got tasks too.
+  - The 30 races of `scripts/e2e-concurrency.js` now check that the two commands overlapped. Before, the first command's publication stalled for a fixed 1.2 s, and a second command that started later than that passed without racing.
+    - The second command now runs with `scripts/lock-probe.js` too. After each operation on the stalled file it reports: a finished read, open, stat or existence check, and the result of its first attempt at that file's lock or at a lock the first command held when it stalled (refused because held, or taken). It reads those held locks once, when it starts; if they cannot be read, the race does not count. It marks its report complete when it exits. A report that cannot be written sets its exit code to 97 at once, and an incomplete report does not count.
+    - The first command stays stalled until a report exists (at most 15 s), then 1.2 s more. `scripts/race-overlap.js` judges the reports. A race counts when such a lock attempt was refused because the first command held the lock. For a command that tried none of those locks, it counts when its read finished before the first command resumed. A first attempt that took such a lock means the first command had already released it, and the race does not count.
+    - `scripts/race-overlap-probe.js` (`npm run test:race-overlap`, in `test`, `test:core` and `test:fast`) runs the handshake with two small processes on ten fixed schedules. They include a second process that is slow to reach its lock attempt, one that reads during the stall but takes a lock after the release, held locks that cannot be read, and a report that can no longer be rewritten, also after the report was completed. Write failures are injected (`LOCKPROBE_REPORT_FAIL_AFTER`), so the test does not depend on file permissions. Ablations:
+      - every lock attempt reported as refused, whatever its result: 8 of 10;
+      - a first process that does not wait for the report: 6 of 10;
+      - the held locks read at the first lock attempt, and a failed read kept as "none": 8 of 10;
+      - a report judged without the completion mark: 9 of 10;
+      - a failed write that sets the exit code only in the closing exit listener: 9 of 10.
+    - Measured from the stall to the first report: 468-1,704 ms on this Windows PC and 123-217 ms on Linux (Docker node:20). In `creds-refresh` the second command reached the stalled file 1,704 ms after the stall began, 504 ms after the old fixed stall would have ended, so with the old harness that race would have passed without overlapping.
+    - On the current code all 30 races overlapped and passed, on Windows and on Linux. On Linux the second command's lock attempt was refused by the first command's lock in all 30; on Windows in 29, and `bugfix-start-vs-task-add` counted by its read. On Linux with the 1.36.296 code (before T-0343) all 30 overlapped too, and 20 failed: the 19 races T-0343 added and `plan-init-vs-remove`, whose `plan init` T-0343 also fixed. The other 10 pass there, as before.
+
 ## 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).

package/README.md

@@ -195,7 +195,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.299 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.300 하네스를 사용합니다. 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.299는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **102개 도구**를 노출:
+Leerness v1.36.300는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **102개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -270,7 +270,7 @@ Leerness v1.36.299는 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.299**. 공개 릴리스 여부는 공개 저장소의 태그와 배포 기록에서 별도로 확인합니다.
+현재 사용 중인 하네스 버전: **1.36.300**. 공개 릴리스 여부는 공개 저장소의 태그와 배포 기록에서 별도로 확인합니다.
 
 ### 성능 가이드
 
@@ -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.299: 2026-09-30
+Last synced by Leerness v1.36.300: 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.299';
+const VERSION = '1.36.300';
 
 // MCP lifecycle 주소 표식은 현재 CLI 호출 한 번에만 유효하다. CLI bootstrap에서 즉시 env에서
 // 떼어 두어 `--no-record`/hook처럼 presence 기록 함수에 도달하지 않는 경로도 후속 child에 유출하지 않는다.
@@ -17528,23 +17528,27 @@ function lazyDetect(root, opts = {}) {
           const header = progressHeader(root, input.text);
           const rows2 = readProgressRows(root, input.text);
           const lockedText = rows2.map(r => `${r.request || ''} ${r.evidence || ''}`).join('\n');
-          if (!newTodos.some(t => !lockedText.includes(t.file))) return false;
+          // T-0345: only the TODOs whose file no row references. A batch with one untracked file registered every
+          //   new TODO, so TODOs in files a task already covered were registered again.
+          const toRegister = newTodos.filter(t => !lockedText.includes(t.file));
+          if (!toRegister.length) return [];
           let maxT = _historyRetention.reservedTaskMax(root); const idRe = /\bT-(\d{4,})\b/g;
           const scanSrc = (exists(planPath(root)) ? read(planPath(root)) : '') + '\n' + rows2.map(r => r.id).join('\n');
           let mm; while ((mm = idRe.exec(scanSrc))) maxT = Math.max(maxT, Number(mm[1]));
-          _historyRetention.assertTaskIdCapacity(maxT, newTodos.length);
-          for (const t of newTodos) {
+          _historyRetention.assertTaskIdCapacity(maxT, toRegister.length);
+          for (const t of toRegister) {
             maxT++;
             rows2.push({ id: `T-${String(maxT).padStart(4, '0')}`, status: 'requested', request: `TODO ${t.file}:${t.line}`, evidence: 'auto-tracked', nextAction: t.text.slice(0, 80), updated: today() });
           }
           writeProgressRows(root, header, rows2, { input });
-          return true;
+          return toRegister;
         });
-        if (registered) {
-          // known-todos에 추가 — 다음 detect에서 재카운트 안 하도록
-          const merged = [...knownList, ...newTodos.map(t => ({ ...t, ackAt: now() }))];
+        if (registered.length) {
+          // known-todos에 추가 — 다음 detect에서 재카운트 안 하도록. T-0345: only what was registered; a TODO in a
+          //   file a task already references stays as it is, as without --auto-track.
+          const merged = [...knownList, ...registered.map(t => ({ ...t, ackAt: now() }))];
           writeUtf8(knownPath, JSON.stringify(merged, null, 2) + '\n');
-          if (!jsonMode) ok(`${newTodos.length}개 TODO를 progress-tracker에 자동 등록 + known-todos.json 갱신`);
+          if (!jsonMode) ok(`${registered.length}개 TODO를 progress-tracker에 자동 등록 + known-todos.json 갱신`);
         }
       } else if (newTodos.length && !jsonMode) {
         log(`    💡 자동 등록: leerness lazy detect --auto-track`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.299",
+  "version": "1.36.300",
   "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 && 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": "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/race-overlap-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/race-overlap-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 && node ./scripts/lazy-auto-track-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 && 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: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/race-overlap-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",
@@ -74,6 +74,8 @@
     "test:tracker-write-language": "node ./scripts/tracker-write-language-probe.js",
     "test:write-path-language": "node ./scripts/write-path-language-probe.js",
     "test:write-primitive-language": "node ./scripts/write-primitive-language-probe.js",
+    "test:race-overlap": "node ./scripts/race-overlap-probe.js",
+    "test:lazy-auto-track": "node ./scripts/lazy-auto-track-probe.js",
     "test:dry-run-refusal": "node ./scripts/dry-run-refusal-probe.js",
     "test:api-skill-match": "node ./scripts/api-skill-match-probe.js",
     "test:crud-check": "node ./scripts/crud-check-probe.js",

package/scripts/e2e-concurrency.js

@@ -9,6 +9,7 @@ const cp = require('child_process');
 
 const CLI = path.resolve(process.argv[2] || path.join(__dirname, '..', 'bin', 'leerness.js'));
 const PRELOAD = path.join(__dirname, 'lock-probe.js');
+const { overlapOf } = require('./race-overlap');
 const ENV = {
   ...process.env,
   LEERNESS_OFFLINE: '1',
@@ -37,16 +38,22 @@ function init(d) {
 // is observed rather than inferred. T-0314: inferring it from `<target>.tmp-*` names stopped working when
 // 1.36.190 published memory outputs through `.<target>.publish-*` + link; 8 of 11 races then never raced.
 const readyFileOf = d => path.join(d, '.stall-ready.json');
+// T-0346: the second command writes this file after it read the target, or tried its lock or a lock the first
+// command held when it stalled; the first command's stall ends only after it exists (see scripts/lock-probe.js).
+// A fixed 1.2 s stall could end before the second command had started (a Node start alone can take that long on
+// Windows), and the race then passed without overlapping the publication.
+const reachFileOf = d => path.join(d, '.stall-reached.json');
 
-function spawn(d, args, stallTarget) {
-  const nodeArgs = stallTarget
-    ? ['--require', PRELOAD, CLI, ...args, '--path', d]
-    : [CLI, ...args, '--path', d];
-  const env = stallTarget
-    ? { ...ENV, LOCKPROBE_STALL_TARGET: stallTarget, LOCKPROBE_STALL_MS: String(STALL_MS), LOCKPROBE_READY_FILE: readyFileOf(d) }
-    : ENV;
+// role 'first' stalls the publication of `target` until the second command reaches it; role 'second' reports
+// reaching it. Both run with the lock-probe preload.
+function spawn(d, args, role, target) {
+  const nodeArgs = ['--require', PRELOAD, CLI, ...args, '--path', d];
+  const env = role === 'first'
+    ? { ...ENV, LOCKPROBE_STALL_TARGET: target, LOCKPROBE_STALL_MS: String(STALL_MS), LOCKPROBE_READY_FILE: readyFileOf(d), LOCKPROBE_WAIT_FILE: reachFileOf(d) }
+    : { ...ENV, LOCKPROBE_REACH_TARGET: target, LOCKPROBE_REACH_FILE: reachFileOf(d), LOCKPROBE_REACH_LOCKS_FILE: readyFileOf(d) };
   return cp.spawn(process.execPath, nodeArgs, { cwd: d, env, stdio: 'ignore' });
 }
+const readJson = file => { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } };
 
 function waitForStall(d, target) {
   // T-0343: an absolute target (a file outside .leerness) is acknowledged by its full path, a relative one by its
@@ -66,15 +73,22 @@ async function race(name, config) {
     if (config.seed) config.seed(d);
     // T-0343: a target outside .leerness is given as a function of the project directory (its absolute path).
     const stallTarget = typeof config.stallTarget === 'function' ? config.stallTarget(d) : config.stallTarget;
-    const first = spawn(d, config.first, stallTarget);
+    const first = spawn(d, config.first, 'first', stallTarget);
     const stalled = waitForStall(d, stallTarget);
     if (config.beforeSecond) config.beforeSecond(d);
-    const second = spawn(d, typeof config.second === 'function' ? config.second(d) : config.second);
+    const second = spawn(d, typeof config.second === 'function' ? config.second(d) : config.second, 'second', stallTarget);
     const exits = await Promise.all([wait(first), wait(second)]);
+    // T-0346: the race counts only when the second command overlapped the first one's stalled section (see
+    // scripts/race-overlap.js): a contended lock attempt, or, for a command that tried none of those locks, a read
+    // of the stalled file that finished before the first command resumed.
+    const ready = readJson(readyFileOf(d)) || {}, reach = readJson(reachFileOf(d));
+    const { overlapped, why } = overlapOf({ stalled, ready, reach });
     const inspected = config.inspect(d);
     // T-0343: `secondExit` names the second command's expected exit when it is not 0 (lazy detect reports issues with 1).
     const secondExit = config.secondExit === undefined ? 0 : config.secondExit;
-    return { name, stalled, exits, ...inspected, ok: stalled && exits[0] === 0 && exits[1] === secondExit && inspected.preserved === true };
+    return { name, stalled, overlapped, why, read: reach && reach.read && reach.read.how, lock: reach && reach.lock && reach.lock.result,
+      waitedMs: ready.waitedMs, exits, ...inspected,
+      ok: overlapped && exits[0] === 0 && exits[1] === secondExit && inspected.preserved === true };
   } catch (e) {
     return { name, error: String(e && e.message || e), ok: false };
   } finally {

package/scripts/lazy-auto-track-probe.js

@@ -0,0 +1,87 @@
+'use strict';
+// T-0345: `lazy detect --auto-track` registers a task for each new TODO whose file no tracker row references, and
+// only those. A batch that mixed such files with a file a task already referenced registered every new TODO, so the
+// TODOs in the referenced file got tasks of their own as well. known-todos.json gains exactly the registered TODOs.
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const CLI = path.resolve(__dirname, '..', 'bin', 'leerness.js');
+const ENV = { ...process.env, LEERNESS_OFFLINE: '1', LEERNESS_NO_PROMPT: '1', LEERNESS_NO_LOCK_WARN: '1', LEERNESS_NO_AUTOCHCP: '1' };
+const arena = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-lazy-auto-track-'));
+let passed = 0, failed = 0, seq = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log('PASS ' + name); }
+  catch (error) { failed++; console.error('FAIL ' + name + ': ' + (error && error.stack || error)); }
+}
+const run = (d, args) => {
+  const r = cp.spawnSync(process.execPath, [CLI, ...args], { cwd: d, env: ENV, encoding: 'utf8', timeout: 120000, windowsHide: true });
+  assert.strictEqual(r.error, undefined, r.error && r.error.message);
+  return r;
+};
+// A project with the given source files and, for each entry of `referenced`, a task whose text names that file.
+function project(files, referenced = []) {
+  const d = path.join(arena, 'p' + (++seq));
+  fs.mkdirSync(d);
+  assert.strictEqual(run(d, ['init', d, '--yes', '--minimal']).status, 0, 'init');
+  for (const [name, text] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(d, name)), { recursive: true });
+    fs.writeFileSync(path.join(d, name), text);
+  }
+  for (const name of referenced) assert.strictEqual(run(d, ['task', 'add', `Clean up ${name}`, '--path', d]).status, 0, 'task add');
+  return d;
+}
+const tasks = d => {
+  const r = run(d, ['task', 'list', '--path', d, '--json']);
+  assert.strictEqual(r.status, 0, r.stdout + r.stderr);
+  const parsed = JSON.parse(r.stdout);
+  return (parsed.tasks || parsed).map(t => t.request);
+};
+const autoTracked = d => tasks(d).filter(request => /^TODO /.test(request)).sort();
+const known = d => {
+  const file = path.join(d, '.leerness', 'known-todos.json');
+  return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')).map(t => `${t.file}:${t.line}`).sort() : null;
+};
+const autoTrack = d => {
+  const r = run(d, ['lazy', 'detect', d, '--auto-track']);
+  assert.ok(r.status === 0 || r.status === 1, 'lazy detect exit ' + r.status + '\n' + r.stdout + r.stderr);
+  return r;
+};
+const SOURCES = {
+  'src/covered.js': '// TODO: first covered note\nfunction a() {}\n// FIXME: second covered note\n',
+  'src/fresh.js': 'function b() {}\n// TODO: fresh note\n',
+};
+try {
+  test('a mixed batch registers only the TODO in the file no task references', () => {
+    const d = project(SOURCES, ['src/covered.js']);
+    autoTrack(d);
+    assert.deepStrictEqual(autoTracked(d), ['TODO src/fresh.js:2']);
+    assert.deepStrictEqual(known(d), ['src/fresh.js:2']);
+    assert.strictEqual(tasks(d).filter(request => request === 'Clean up src/covered.js').length, 1, 'the referencing task is kept as it was');
+  });
+  test('running it again registers nothing more', () => {
+    const d = project(SOURCES, ['src/covered.js']);
+    autoTrack(d);
+    autoTrack(d);
+    assert.deepStrictEqual(autoTracked(d), ['TODO src/fresh.js:2']);
+    assert.deepStrictEqual(known(d), ['src/fresh.js:2']);
+  });
+  test('control: with no file referenced, every new TODO is registered', () => {
+    const d = project(SOURCES);
+    autoTrack(d);
+    assert.deepStrictEqual(autoTracked(d), ['TODO src/covered.js:1', 'TODO src/covered.js:3', 'TODO src/fresh.js:2']);
+    assert.deepStrictEqual(known(d), ['src/covered.js:1', 'src/covered.js:3', 'src/fresh.js:2']);
+  });
+  test('control: with every file referenced, nothing is registered and known-todos.json is not written', () => {
+    const d = project(SOURCES, ['src/covered.js', 'src/fresh.js']);
+    autoTrack(d);
+    assert.deepStrictEqual(autoTracked(d), []);
+    assert.strictEqual(known(d), null);
+  });
+} finally {
+  fs.rmSync(arena, { recursive: true, force: true });
+}
+console.log(`lazy auto-track probe: ${passed}/${passed + failed} passed (${process.platform})`);
+process.exitCode = failed ? 1 : 0;

package/scripts/lock-probe.js

@@ -35,6 +35,25 @@ const STALL_ABSOLUTE = process.env.LOCKPROBE_STALL_TARGET && path.isAbsolute(pro
 const STALL_PREFIX = String(process.env.LOCKPROBE_STALL_PREFIX || '').replace(/\\/g, '/').replace(/^\.?\/+/, '');
 const STALL_MS = Math.max(0, Math.min(10000, Number(process.env.LOCKPROBE_STALL_MS) || 0));
 const READY_FILE = process.env.LOCKPROBE_READY_FILE ? path.resolve(process.env.LOCKPROBE_READY_FILE) : null;
+// T-0346: a race's second command reports what it did at the stalled target (LOCKPROBE_REACH_TARGET) in
+//   LOCKPROBE_REACH_FILE, each report written after the operation ran: a read, open, stat or existence check of the
+//   target, and the result of its first attempt at the target's lock or at a lock the first command held when it
+//   stalled (EEXIST: contended; success: acquired, so not contended). The first command, given that file as
+//   LOCKPROBE_WAIT_FILE, keeps its publication stalled until a report exists (at most LOCKPROBE_WAIT_MAX_MS) and
+//   then for LOCKPROBE_STALL_MS more. A fixed stall alone could end before the second command had started, and a
+//   report written before the operation (review round 1) could be followed by the operation after the stall ended;
+//   either way the race passed without overlapping anything. scripts/race-overlap.js judges the reports.
+const targetMatcher = raw => {
+  const value = String(raw || '');
+  if (!value) return () => false;
+  if (path.isAbsolute(value)) { const full = norm(value).replace(/\\/g, '/'); return p => norm(p).replace(/\\/g, '/') === full; }
+  const rel = value.replace(/\\/g, '/').replace(/^\.?\/+/, '');
+  return p => relOf(norm(p)) === rel;
+};
+const REACH_FILE = process.env.LOCKPROBE_REACH_FILE ? path.resolve(process.env.LOCKPROBE_REACH_FILE) : null;
+const isReachTarget = REACH_FILE ? targetMatcher(process.env.LOCKPROBE_REACH_TARGET) : () => false;
+const WAIT_FILE = process.env.LOCKPROBE_WAIT_FILE ? path.resolve(process.env.LOCKPROBE_WAIT_FILE) : null;
+const WAIT_MAX_MS = Math.max(0, Math.min(60000, Number(process.env.LOCKPROBE_WAIT_MAX_MS) || 15000));
 let stalled = false;
 const shouldStall = p => {
   if (stalled || STALL_MS <= 0) return false;
@@ -48,11 +67,89 @@ const stall = ms => {
   try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); }
   catch { const until = Date.now() + ms; while (Date.now() < until) {} }
 };
+const _existsRaw = fs.existsSync.bind(fs);
+const _readRaw = fs.readFileSync.bind(fs);
+// A lock the first command held when it stalled (`heldOn` of its ready file, LOCKPROBE_REACH_LOCKS_FILE) counts too:
+// a second command that waits for such a lock is held up by the stalled section, even when it waits there before
+// touching the target, or never touches it (a plan add waiting for the plan lock while a restore publishes the
+// plan archive).
+const REACH_LOCKS_FILE = process.env.LOCKPROBE_REACH_LOCKS_FILE ? path.resolve(process.env.LOCKPROBE_REACH_LOCKS_FILE) : null;
+// Read once, when this preload starts. The race starts the second command only after it read the first command's
+// whole ready file, and the first command rewrites that file only after a report exists, so no rewrite is under
+// way now. Review round 2: the set was read lazily, and a read during a rewrite was cached as "holds no lock", which
+// hid a later lock taken after the release. A file that does not parse within 2 s marks every report
+// `heldUnknown`, and such a race does not count.
+let firstHeld = new Set(), firstHeldKnown = !REACH_LOCKS_FILE;
+if (REACH_LOCKS_FILE && REACH_FILE) {
+  const until = Date.now() + 2000;
+  for (;;) {
+    try { const heldOn = JSON.parse(_readRaw(REACH_LOCKS_FILE, 'utf8')).heldOn; if (Array.isArray(heldOn)) { firstHeld = new Set(heldOn); firstHeldKnown = true; break; } } catch {}
+    if (Date.now() >= until) break;
+    stall(10);
+  }
+}
+const heldByFirst = p => firstHeld.has(relOf(norm(p)));
+// The report holds the first completed access of the target (`read`: how and when) and the result of the first
+// attempt at one of those locks (`lock`: contended or acquired, and when). It is rewritten when either is first set.
+const report = firstHeldKnown ? {} : { heldUnknown: true };
+// Review round 3: a rewrite that failed (EACCES, say) left the earlier report standing, and its read then counted
+// although a later lock was taken after the release. So the report is trusted only with `complete: true`, written
+// when this process exits; a failed write marks it `failed` where it can, and the process exits with 97.
+let reportFailed = false;
+// LOCKPROBE_REPORT_FAIL_AFTER=n (tests of this module only): writes after the n-th fail as a read-only file would,
+// and the report cannot be removed either, the same for every user (a chmod does not stop root).
+const FAIL_AFTER = process.env.LOCKPROBE_REPORT_FAIL_AFTER === undefined ? Infinity : Number(process.env.LOCKPROBE_REPORT_FAIL_AFTER);
+let writes = 0;
+const writeReport = () => {
+  try {
+    if (++writes > FAIL_AFTER) throw Object.assign(new Error('injected report write failure'), { code: 'EACCES' });
+    fs.writeFileSync.call(fs, REACH_FILE, JSON.stringify(report), 'utf8');
+    return true;
+  } catch (error) {
+    reportFailed = true;
+    // Review round 4: fail at once, not only in the closing exit listener: a listener that runs after it could take
+    // a lock whose report then fails to land. The stale report is also removed where possible.
+    process.exitCode = 97;
+    if (writes <= FAIL_AFTER) { try { fs.unlinkSync.call(fs, REACH_FILE); } catch {} }
+    try { process.stderr.write(`lock-probe: the race report could not be written (${error && error.code || error})\n`); } catch {}
+    return false;
+  }
+};
+if (REACH_FILE) {
+  process.on('exit', () => {
+    if (!report.read && !report.lock && !reportFailed) return;
+    if (reportFailed) report.failed = true; else report.complete = true;
+    if (!writeReport() || report.failed) process.exitCode = 97;
+  });
+}
+const isWatchedLock = p => { const lock = String(p); return /\.lock$/i.test(lock) && (isReachTarget(lock.slice(0, -'.lock'.length)) || heldByFirst(lock)); };
+// After a read-type call on the target ran (also when it threw, as for a file missing during a POSIX publication).
+const reachedRead = (p, how) => {
+  if (!REACH_FILE || report.read) return;
+  try { if (isReachTarget(String(p))) { report.read = { target: relOf(norm(p)), how, at: Date.now() }; writeReport(); } } catch {}
+};
+// After a lock attempt ran: `error` is what it threw, or null when it took the lock.
+const reachedLock = (p, error) => {
+  if (!REACH_FILE || report.lock) return;
+  try {
+    if (!isWatchedLock(p)) return;
+    if (error && error.code !== 'EEXIST') return;
+    report.lock = { target: relOf(norm(p)), result: error ? 'contended' : 'acquired', at: Date.now() };
+    writeReport();
+  } catch {}
+};
+for (const [name, how] of [['readFileSync', 'read'], ['existsSync', 'exists'], ['statSync', 'stat'], ['lstatSync', 'stat'], ['accessSync', 'stat']]) {
+  const original = fs[name].bind(fs);
+  fs[name] = function (p, ...a) { try { return original(p, ...a); } finally { reachedRead(p, how); } };
+}
 
 const _mkdir = fs.mkdirSync.bind(fs);
 fs.mkdirSync = function (p, ...a) {
-  const r = _mkdir(p, ...a);
-  try { if (/\.lock$/.test(String(p))) held.add(norm(p)); } catch {}
+  const isLock = /\.lock$/.test(String(p));
+  let r;
+  try { r = _mkdir(p, ...a); } catch (error) { if (isLock) reachedLock(p, error); throw error; }
+  if (isLock) reachedLock(p, null);
+  try { if (isLock) held.add(norm(p)); } catch {}
   return r;
 };
 const _rmdir = fs.rmdirSync.bind(fs);
@@ -64,8 +161,12 @@ fs.rmdirSync = function (p, ...a) {
 // 구버전 고정 파일 락도 계측 호환성을 유지한다.
 const _open = fs.openSync.bind(fs);
 fs.openSync = function (p, flags, ...a) {
-  const r = _open(p, flags, ...a);
-  try { if (String(flags) === 'wx' && /\.lock$/.test(String(p))) held.add(norm(p)); } catch {}
+  const isLock = String(flags) === 'wx' && /\.lock$/.test(String(p));
+  let r;
+  try { r = _open(p, flags, ...a); }
+  catch (error) { if (isLock) reachedLock(p, error); else reachedRead(p, 'open'); throw error; }
+  if (isLock) reachedLock(p, null); else reachedRead(p, 'open');
+  try { if (isLock) held.add(norm(p)); } catch {}
   return r;
 };
 const _unlink = fs.unlinkSync.bind(fs);
@@ -91,14 +192,20 @@ const stallBefore = (to) => {
     if (shouldStall(to)) {
       stalled = true;
       const target = norm(to);
-      if (READY_FILE) {
-        _w(READY_FILE, JSON.stringify({
-          target: relOf(target),
-          locked: held.has(target + '.lock'),
-          heldOn: [...held].map(relOf).sort()
-        }), 'utf8');
+      const ready = { target: relOf(target), locked: held.has(target + '.lock'), heldOn: [...held].map(relOf).sort() };
+      if (READY_FILE) _w(READY_FILE, JSON.stringify(ready), 'utf8');
+      if (WAIT_FILE) {
+        // T-0346: hold the publication until the second command has reached the target, then STALL_MS more. The
+        //   outcome is added to the ready file, which the race reads after both commands exit.
+        const started = Date.now();
+        while (!_existsRaw(WAIT_FILE) && Date.now() - started < WAIT_MAX_MS) stall(10);
+        ready.reached = _existsRaw(WAIT_FILE);
+        ready.waitedMs = Date.now() - started;
+        if (READY_FILE) _w(READY_FILE, JSON.stringify(ready), 'utf8');
       }
       stall(STALL_MS);
+      // When the publication goes on; a read reported after this moment did not see the stalled state.
+      if (WAIT_FILE) { ready.resumedAt = Date.now(); if (READY_FILE) _w(READY_FILE, JSON.stringify(ready), 'utf8'); }
     }
   } catch {}
 };

package/scripts/race-overlap-probe.js

@@ -0,0 +1,148 @@
+'use strict';
+// T-0346: the e2e-concurrency handshake (scripts/lock-probe.js reports, scripts/race-overlap.js judgement) with two
+// small processes instead of leerness commands, so each schedule is fixed. The first process takes
+// .leerness/x.json.lock (and y.json.lock when asked), prepares x.json and renames it into place; the preload stalls
+// that rename. The second process does what each case says. A race may count only when the second process really
+// met the stalled section.
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { overlapOf } = require('./race-overlap');
+
+const PRELOAD = path.join(__dirname, 'lock-probe.js');
+const STALL_MS = 1200;
+const arena = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-race-overlap-'));
+let passed = 0, failed = 0, seq = 0;
+function test(name, fn) {
+  return fn().then(() => { passed++; console.log('PASS ' + name); },
+    error => { failed++; console.error('FAIL ' + name + ': ' + (error && error.stack || error)); });
+}
+const wait = child => new Promise(resolve => child.on('close', code => resolve(code)));
+const nap = ms => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+const readJson = file => { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } };
+// Shared by both processes: `sleep(ms)` and `takeLock(name)` (retry on EEXIST, as leerness locks do). The first
+// process holds x.json.lock and, when asked, y.json.lock, a lock the race knows only from the first one's `heldOn`.
+const PRELUDE = `
+  const fs = require('fs'), path = require('path');
+  const hd = path.join(process.argv[1], '.leerness'), target = path.join(hd, 'x.json'), lock = target + '.lock';
+  const other = path.join(hd, 'y.json.lock');
+  const sleep = ms => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  const takeLock = (name = lock) => { for (;;) { try { fs.mkdirSync(name); return; } catch (e) { if (e.code !== 'EEXIST') throw e; sleep(20); } } };
+`;
+const FIRST = PRELUDE + `
+  const both = process.argv[2] === 'both';
+  takeLock(); if (both) takeLock(other);
+  const tmp = target + '.tmp-1-1';
+  fs.writeFileSync(tmp, JSON.stringify({ by: 'first' }));
+  fs.renameSync(tmp, target);
+  if (both) fs.rmdirSync(other);
+  fs.rmdirSync(lock);
+`;
+// `heldFile`: what the second process reads as the first one's held locks: 'ready' (the ready file itself),
+// 'corrupt-after-read' (a copy that the race overwrites with half a JSON object once the second process has
+// reported its read, as a rewrite caught midway would look), or 'corrupt' (half a JSON object from the start).
+// `failAfter`: report writes after that many fail in the second process (LOCKPROBE_REPORT_FAIL_AFTER), as for a
+// report file that turned read-only, whoever runs the test.
+async function race(second, { waitMaxMs = 15000, firstLocks = 'one', heldFile = 'ready', failAfter } = {}) {
+  const d = path.join(arena, 'case-' + (++seq));
+  fs.mkdirSync(path.join(d, '.leerness'), { recursive: true });
+  fs.writeFileSync(path.join(d, '.leerness', 'x.json'), JSON.stringify({ by: 'seed' }));
+  const ready = path.join(d, 'ready.json'), reach = path.join(d, 'reach.json'), heldCopy = path.join(d, 'held.json');
+  const first = cp.spawn(process.execPath, ['--require', PRELOAD, '-e', FIRST, d, firstLocks], { stdio: 'ignore', env: { ...process.env,
+    LOCKPROBE_STALL_TARGET: 'x.json', LOCKPROBE_STALL_MS: String(STALL_MS), LOCKPROBE_READY_FILE: ready,
+    LOCKPROBE_WAIT_FILE: reach, LOCKPROBE_WAIT_MAX_MS: String(waitMaxMs) } });
+  let stalled = false;
+  for (let i = 0; i < 800 && !stalled; i++) { stalled = (readJson(ready) || {}).target === 'x.json'; if (!stalled) nap(10); }
+  const half = '{"target":"x.json","heldOn":["x.js';
+  if (heldFile !== 'ready') fs.writeFileSync(heldCopy, heldFile === 'corrupt' ? half : fs.readFileSync(ready));
+  const started = Date.now();
+  const child = cp.spawn(process.execPath, ['--require', PRELOAD, '-e', PRELUDE + second, d], { stdio: 'ignore', env: { ...process.env,
+    LOCKPROBE_REACH_TARGET: 'x.json', LOCKPROBE_REACH_FILE: reach, LOCKPROBE_REACH_LOCKS_FILE: heldFile === 'ready' ? ready : heldCopy,
+    ...(failAfter === undefined ? {} : { LOCKPROBE_REPORT_FAIL_AFTER: String(failAfter) }) } });
+  if (heldFile === 'corrupt-after-read') {
+    for (let i = 0; i < 1500 && !(readJson(reach) || {}).read; i++) nap(10);
+    fs.writeFileSync(heldCopy, half);
+  }
+  const exits = await Promise.all([wait(first), wait(child)]);
+  const r = { stalled, ready: readJson(ready), reach: readJson(reach), exits, secondStartedAt: started };
+  return { ...r, ...overlapOf(r) };
+}
+(async () => {
+  try {
+    await test('a lock attempt that waits on the stalled section counts', async () => {
+      const r = await race('takeLock(); fs.rmdirSync(lock);');
+      assert.deepStrictEqual(r.exits, [0, 0]);
+      assert.strictEqual(r.reach.lock.result, 'contended', JSON.stringify(r.reach));
+      assert.strictEqual(r.overlapped, true, r.why);
+    });
+    await test('a delay before the first access does not let the stall end first', async () => {
+      // The schedule of review round 1: the second process is slow to reach its lock attempt. The report is written
+      // after the attempt ran, so the first process is still stalled when it happens.
+      const r = await race('sleep(1500); takeLock(); fs.rmdirSync(lock);');
+      assert.strictEqual(r.reach.lock.result, 'contended', JSON.stringify(r.reach));
+      assert.ok(r.ready.waitedMs >= 1400, 'the first process waited for the report: ' + r.ready.waitedMs);
+      assert.ok(r.reach.lock.at <= r.ready.resumedAt, 'the attempt came before the first process resumed');
+      assert.strictEqual(r.overlapped, true, r.why);
+    });
+    await test('a read during the stall followed by a lock taken after the release does not count', async () => {
+      const r = await race(`fs.existsSync(target); sleep(${STALL_MS + 1300}); takeLock(); fs.rmdirSync(lock);`);
+      assert.strictEqual(r.reach.read.how, 'exists');
+      assert.strictEqual(r.reach.lock.result, 'acquired', JSON.stringify(r.reach));
+      assert.strictEqual(r.overlapped, false, r.why);
+    });
+    await test('a command that only reads counts when its read finished while stalled', async () => {
+      const r = await race('fs.readFileSync(target);');
+      assert.ok(['read', 'open'].includes(r.reach.read.how), JSON.stringify(r.reach)); // readFileSync opens through openSync
+      assert.strictEqual(r.reach.lock, undefined);
+      assert.ok(r.reach.read.at <= r.ready.resumedAt);
+      assert.strictEqual(r.overlapped, true, r.why);
+    });
+    await test("a lock attempt that waits on another lock the first process holds counts", async () => {
+      const r = await race('takeLock(other); fs.rmdirSync(other);', { firstLocks: 'both' });
+      assert.strictEqual(r.reach.lock.target, 'y.json.lock', JSON.stringify(r.reach));
+      assert.strictEqual(r.reach.lock.result, 'contended');
+      assert.strictEqual(r.overlapped, true, r.why);
+    });
+    await test('review round 2: a held-locks file broken after the read does not hide a lock taken after the release', async () => {
+      // The second process read the held locks when it started; a rewrite caught midway later must not change them.
+      const r = await race(`fs.existsSync(target); sleep(${STALL_MS + 1300}); takeLock(other); fs.rmdirSync(other);`,
+        { firstLocks: 'both', heldFile: 'corrupt-after-read' });
+      assert.strictEqual(r.reach.lock && r.reach.lock.result, 'acquired', JSON.stringify(r.reach));
+      assert.strictEqual(r.overlapped, false, r.why);
+    });
+    await test('review round 3: a report that can no longer be rewritten does not let an earlier read count', async () => {
+      // The read report lands; the later "acquired" cannot be written (the first write succeeds, later ones fail).
+      const r = await race(`fs.existsSync(target); sleep(${STALL_MS + 1300}); takeLock(other); fs.rmdirSync(other);`,
+        { firstLocks: 'both', failAfter: 1 });
+      assert.ok(r.reach && r.reach.read && !r.reach.lock && r.reach.complete === undefined, JSON.stringify(r.reach));
+      assert.strictEqual(r.exits[1], 97, 'the second process fails when its report cannot be written');
+      assert.strictEqual(r.overlapped, false, r.why);
+    });
+    await test('review round 4: a lock taken in a later exit listener whose report fails makes the second process fail', async () => {
+      // The preload's closing listener marks the read report complete (write 2); a listener registered after it then
+      // takes a held lock after the release, and that report (write 3) fails. The completed read report stays, so
+      // only the exit code can tell the race.
+      const r = await race(`fs.existsSync(target); process.on('exit', () => { sleep(${STALL_MS + 1300}); takeLock(other); fs.rmdirSync(other); });`,
+        { firstLocks: 'both', failAfter: 2 });
+      assert.ok(r.reach && r.reach.read && r.reach.complete === true && !r.reach.lock, JSON.stringify(r.reach));
+      assert.strictEqual(r.exits[1], 97, 'the failed write after completion still fails the process');
+    });
+    await test('held locks that cannot be read make the race not count', async () => {
+      const r = await race('takeLock(); fs.rmdirSync(lock);', { heldFile: 'corrupt' });
+      assert.strictEqual(r.reach.heldUnknown, true, JSON.stringify(r.reach));
+      assert.strictEqual(r.overlapped, false, r.why);
+    });
+    await test('a command that never reaches the stalled section does not count', async () => {
+      const r = await race("fs.readFileSync(path.join(process.argv[1], 'ready.json'));", { waitMaxMs: 1500 });
+      assert.strictEqual(r.ready.reached, false);
+      assert.strictEqual(r.reach, null);
+      assert.strictEqual(r.overlapped, false, r.why);
+    });
+  } finally {
+    fs.rmSync(arena, { recursive: true, force: true });
+  }
+  console.log(`race overlap probe: ${passed}/${passed + failed} passed (${process.platform})`);
+  process.exitCode = failed ? 1 : 0;
+})();

package/scripts/race-overlap.js

@@ -0,0 +1,28 @@
+'use strict';
+// T-0346: did a race's second command overlap the first command's stalled publication? Judged from the first
+// command's ready file (scripts/lock-probe.js: `reached`, `resumedAt`) and the second command's report (`read`,
+// `lock`), which lock-probe.js writes only after the operation ran.
+//   - A lock attempt that failed with EEXIST (the stalled file's lock, or a lock the first command held when it
+//     stalled) shows that the second command waited on the stalled section.
+//   - A first such attempt that took the lock shows that the first command had already released it: the second
+//     command's locked section ran after the publication, so it did not overlap.
+//   - A command that never tried one of those locks overlapped when its read of the stalled file finished before the
+//     first command resumed. The first command waits for that report, so this holds unless its wait timed out.
+function overlapOf({ stalled, ready, reach }) {
+  if (!stalled || !ready || ready.reached !== true || !reach || (!reach.read && !reach.lock)) {
+    return { overlapped: false, why: 'no report while the first command was stalled' };
+  }
+  // Without the first command's held locks, a lock taken after the release could go unreported.
+  if (reach.heldUnknown) return { overlapped: false, why: "the first command's held locks could not be read" };
+  // Only a report that the second command closed at its exit is whole: a later rewrite may have failed.
+  if (reach.complete !== true || reach.failed) return { overlapped: false, why: 'the report was not completed' };
+  if (reach.lock) {
+    return reach.lock.result === 'contended'
+      ? { overlapped: true, why: 'a lock attempt was contended' }
+      : { overlapped: false, why: 'a lock the first command held was taken without contention' };
+  }
+  if (typeof ready.resumedAt === 'number' && reach.read.at <= ready.resumedAt) return { overlapped: true, why: 'the read finished while stalled' };
+  return { overlapped: false, why: 'the read finished after the first command resumed' };
+}
+
+module.exports = { overlapOf };