leerness 1.36.166 → 1.36.168

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

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+'use strict';
+
+// T-0145 multi-session regression: two first-time creators may both observe
+// "absent", but the create-only check inside the file lock must let exactly
+// one policy win and must never overwrite that winner.
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const cp = require('child_process');
+
+const CLI = path.resolve(__dirname, '..', 'bin', 'leerness.js');
+const env = {
+  ...process.env,
+  LEERNESS_OFFLINE: '1',
+  LEERNESS_NO_PROMPT: '1',
+  LEERNESS_NO_AUTOCHCP: '1',
+  LEERNESS_NO_AUTO_ROADMAP: '1',
+  LEERNESS_NO_STALE_CHECK: '1',
+  LEERNESS_INTERNAL: '1',
+};
+
+function run(root, args, timeout = 90000) {
+  return cp.spawnSync(process.execPath, [CLI, ...args, '--path', root], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout,
+    env,
+  });
+}
+
+function spawnRun(root, args) {
+  return new Promise(resolve => {
+    const child = cp.spawn(process.execPath, [CLI, ...args, '--path', root], {
+      cwd: root,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.on('error', error => resolve({ status: null, stdout, stderr, error }));
+    child.on('close', status => resolve({ status, stdout, stderr }));
+  });
+}
+
+function json(result) {
+  try { return JSON.parse(result.stdout || ''); } catch { return null; }
+}
+
+function digest(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+const failures = [];
+function check(label, condition, result) {
+  if (condition) { console.log(`✓ ${label}`); return; }
+  failures.push(label);
+  const detail = result ? `\n  ${JSON.stringify(result).slice(0, 1000)}` : '';
+  console.log(`✗ ${label}${detail}`);
+}
+
+async function main() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-claims-baseline-race-'));
+  try {
+    let result = cp.spawnSync(process.execPath, [CLI, 'init', root, '--yes', '--no-enforce', '--no-stale-check'], {
+      cwd: root, encoding: 'utf8', timeout: 90000, env,
+    });
+    check('concurrency fixture init succeeds', result.status === 0, result);
+
+    result = run(root, ['task', 'add', 'legacy one']);
+    const legacyOne = (result.stdout.match(/T-\d{4,}/) || [])[0];
+    result = run(root, ['task', 'update', legacyOne, '--status', 'done', '--evidence', 'ghost-one.js implemented and tested', '--next', 'legacy']);
+    check('first legacy failure fixture is ready', result.status === 0 && !!legacyOne, result);
+
+    result = run(root, ['task', 'add', 'first boundary']);
+    const boundaryOne = (result.stdout.match(/T-\d{4,}/) || [])[0];
+    result = run(root, ['task', 'add', 'legacy two']);
+    const legacyTwo = (result.stdout.match(/T-\d{4,}/) || [])[0];
+    result = run(root, ['task', 'update', legacyTwo, '--status', 'done', '--evidence', 'ghost-two.js implemented and tested', '--next', 'legacy']);
+    check('second legacy failure fixture is ready', result.status === 0 && !!legacyTwo, result);
+
+    result = run(root, ['task', 'add', 'second boundary']);
+    const boundaryTwo = (result.stdout.match(/T-\d{4,}/) || [])[0];
+    check('two distinct policy boundaries are ready', result.status === 0 && !!boundaryOne && !!boundaryTwo, result);
+
+    const contenders = await Promise.all([
+      spawnRun(root, ['verify-claim', 'baseline', 'create', '--before', boundaryOne, '--yes', '--json']),
+      spawnRun(root, ['verify-claim', 'baseline', 'create', '--before', boundaryTwo, '--yes', '--json']),
+    ]);
+    const winners = contenders.filter(item => item.status === 0 && json(item)?.ok === true);
+    const losers = contenders.filter(item => item.status === 1 && json(item)?.code === 'baseline_exists');
+    check('two concurrent creators produce exactly one winner and one baseline_exists loser',
+      winners.length === 1 && losers.length === 1,
+      contenders);
+
+    const baselineFile = path.join(root, '.leerness', 'claims-baseline.json');
+    const stored = fs.existsSync(baselineFile) ? JSON.parse(fs.readFileSync(baselineFile, 'utf8')) : null;
+    const winner = json(winners[0] || {});
+    check('stored policy is exactly the reported winner, never a mixed or overwritten document',
+      stored && winner && stored.beforeTaskId === winner.beforeTaskId
+        && stored.integrity === winner.integrity && stored.entries.length === winner.baselined,
+      { stored, winner });
+
+    const winnerHash = fs.existsSync(baselineFile) ? digest(baselineFile) : null;
+    result = run(root, ['verify-claim', 'baseline', 'create', '--before', boundaryTwo, '--yes', '--json']);
+    check('later retries remain create-only and preserve the winning bytes',
+      result.status === 1 && json(result)?.code === 'baseline_exists'
+        && winnerHash && digest(baselineFile) === winnerHash,
+      result);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+
+  if (failures.length) {
+    console.log(`CLAIMS_BASELINE_CONCURRENCY_PROBE_FAILED: ${failures.join('; ')}`);
+    process.exitCode = 1;
+  } else {
+    console.log('claims baseline concurrency probe passed');
+  }
+}
+
+main().catch(error => {
+  console.error(error && error.stack || error);
+  process.exitCode = 1;
+});

package/scripts/claims-baseline-probe.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+'use strict';
+
+// T-0145 regression probe: a reviewed legacy debt boundary unblocks only exact
+// historical failures. Raw/per-task audits, changed rows, new failures, invalid
+// input, and corrupt stores must all remain fail-closed.
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const cp = require('child_process');
+const claimsBaseline = require('../lib/claims-baseline');
+
+const CLI = path.resolve(__dirname, '..', 'bin', 'leerness.js');
+const env = {
+  ...process.env,
+  LEERNESS_OFFLINE: '1',
+  LEERNESS_NO_PROMPT: '1',
+  LEERNESS_NO_AUTOCHCP: '1',
+  LEERNESS_NO_AUTO_ROADMAP: '1',
+  LEERNESS_NO_STALE_CHECK: '1',
+  LEERNESS_INTERNAL: '1',
+};
+
+function run(root, args, timeout = 60000) {
+  return cp.spawnSync(process.execPath, [CLI, ...args, '--path', root], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout,
+    env,
+  });
+}
+
+function json(result) {
+  try { return JSON.parse(result.stdout || ''); } catch { return null; }
+}
+
+function digest(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function canonical(value) {
+  if (Array.isArray(value)) return '[' + value.map(canonical).join(',') + ']';
+  if (value && typeof value === 'object') {
+    return '{' + Object.keys(value).sort().map(key => JSON.stringify(key) + ':' + canonical(value[key])).join(',') + '}';
+  }
+  return JSON.stringify(value);
+}
+
+function withIntegrity(doc) {
+  const unsigned = { ...doc };
+  delete unsigned.integrity;
+  return {
+    ...unsigned,
+    integrity: 'sha256:' + crypto.createHash('sha256').update(canonical(unsigned)).digest('hex'),
+  };
+}
+
+const failures = [];
+function check(label, condition, result) {
+  if (condition) { console.log(`✓ ${label}`); return; }
+  failures.push(label);
+  const detail = result ? `\n  exit=${result.status}\n  stdout=${String(result.stdout || '').slice(0, 800)}\n  stderr=${String(result.stderr || '').slice(0, 400)}` : '';
+  console.log(`✗ ${label}${detail}`);
+}
+
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-claims-baseline-'));
+try {
+  let result = cp.spawnSync(process.execPath, [CLI, 'init', root, '--yes', '--no-enforce', '--no-stale-check'], {
+    cwd: root, encoding: 'utf8', timeout: 90000, env,
+  });
+  check('fixture init succeeds', result.status === 0, result);
+
+  fs.writeFileSync(path.join(root, 'calc.js'), 'function add(a,b){return a+b}\nmodule.exports={add}\n', 'utf8');
+  fs.mkdirSync(path.join(root, 'tests'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'tests', 'calc.test.js'), 'const {add}=require("../calc.js");\ntest("a",()=>{if(add(1,2)!==3)throw 0});\n', 'utf8');
+
+  result = run(root, ['task', 'add', 'legacy calc claim']);
+  const legacyId = (result.stdout.match(/T-\d{4,}/) || [])[0];
+  result = run(root, ['task', 'update', legacyId, '--status', 'done', '--evidence', 'calc.js + tests/calc.test.js 테스트 50개 통과', '--next', 'legacy next']);
+  check('legacy false claim fixture is created', result.status === 0 && !!legacyId, result);
+  result = run(root, ['task', 'add', 'new work boundary']);
+  const boundaryId = (result.stdout.match(/T-\d{4,}/) || [])[0];
+  check('explicit non-done boundary fixture is created', result.status === 0 && !!boundaryId, result);
+
+  // Keep the five heuristic gate checks clean so --claims is the only failing dimension.
+  fs.writeFileSync(path.join(root, '.leerness', 'session-handoff.md'), '# Handoff\nLast generated: 2026-08-26T00:00:00Z\n\n## Completed\n- calc.js add() 구현 + 테스트\n\n## Next Exact Step\n- migration\n', 'utf8');
+  fs.writeFileSync(path.join(root, '.leerness', 'review-evidence.md'), '# Evidence\n## Test run\n- npm test: 1/1 passing\n', 'utf8');
+
+  const tracker = path.join(root, '.leerness', 'progress-tracker.md');
+  const trackerText = fs.readFileSync(tracker, 'utf8');
+  const trackerHash = digest(tracker);
+  const baselineFile = path.join(root, '.leerness', 'claims-baseline.json');
+
+  const beforeGate = run(root, ['gate', '.', '--claims', '--json'], 120000);
+  const beforeGateJson = json(beforeGate);
+  const beforeClaimCheck = beforeGateJson?.checks?.find(row => row.name === 'verify-claims');
+  check('gate --claims reproduces the legacy-only failure before migration',
+    beforeGate.status === 1 && beforeClaimCheck?.ok === false && beforeClaimCheck?.rawFailed === 1,
+    beforeGate);
+
+  result = run(root, ['verify-claim', 'baseline', 'create', '--before', boundaryId, '--json']);
+  check('baseline creation requires explicit --yes and writes nothing on refusal',
+    result.status === 1 && json(result)?.code === 'confirmation_required' && !fs.existsSync(baselineFile),
+    result);
+
+  result = run(root, ['verify-claim', 'baseline', 'create', '--before', 'T-9999', '--yes', '--json']);
+  check('unknown boundary fails before writing a baseline',
+    result.status === 1 && json(result)?.code === 'boundary_not_found' && !fs.existsSync(baselineFile),
+    result);
+
+  result = run(root, ['verify-claim', 'baseline', 'create', '--before', boundaryId, '--yes', '--json']);
+  const created = json(result);
+  check('baseline creation isolates only the failed row before the explicit boundary',
+    result.status === 0 && created?.ok === true && created?.baselined === 1
+      && created?.beforeTaskId === boundaryId && created?.historicalEvidenceModified === false
+      && fs.existsSync(baselineFile),
+    result);
+  check('baseline creation does not rewrite tracker rows or historical evidence',
+    digest(tracker) === trackerHash && fs.readFileSync(tracker, 'utf8') === trackerText);
+  const stored = JSON.parse(fs.readFileSync(baselineFile, 'utf8'));
+  check('baseline stores fingerprints/reasons, not replacement evidence',
+    stored.entries?.length === 1 && stored.entries[0].id === legacyId
+      && /^[a-f0-9]{64}$/.test(stored.entries[0].fingerprint)
+      && !JSON.stringify(stored).includes('테스트 50개'));
+
+  const casRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-claims-baseline-cas-'));
+  try {
+    let winnerHash = null;
+    let raceCode = null;
+    try {
+      claimsBaseline.saveBaseline(casRoot, stored, (target, write) => {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, 'concurrent-winner\n', 'utf8');
+        winnerHash = digest(target);
+        return write();
+      });
+    } catch (error) { raceCode = error && error.code; }
+    const target = claimsBaseline.baselinePath(casRoot);
+    check('create-only CAS rechecks destination absence inside the acquired lock',
+      raceCode === 'E_CLAIMS_BASELINE_EXISTS' && digest(target) === winnerHash);
+  } finally {
+    fs.rmSync(casRoot, { recursive: true, force: true });
+  }
+
+  result = run(root, ['verify-claim', '--all', '--json']);
+  const applied = json(result);
+  check('default aggregate verification applies exact legacy debt and exposes raw counts',
+    result.status === 0 && applied?.ok === true && applied?.rawFailed === 1
+      && applied?.baselined === 1 && applied?.failed === 0
+      && applied?.results?.find(row => row.id === legacyId)?.baselineAccepted === true,
+    result);
+
+  result = run(root, ['verify-claim', '--all', '--raw', '--json']);
+  const raw = json(result);
+  check('--raw preserves the original failing verdict',
+    result.status === 1 && raw?.ok === false && raw?.failed === 1
+      && raw?.baselined === 0 && raw?.baseline?.state === 'ignored',
+    result);
+
+  result = run(root, ['verify-claim', legacyId, '--json']);
+  check('per-task verification always remains raw',
+    result.status === 1 && json(result)?.ok === false && !json(result)?.baselineAccepted,
+    result);
+
+  const afterGate = run(root, ['gate', '.', '--claims', '--json'], 120000);
+  const afterGateJson = json(afterGate);
+  const afterClaimCheck = afterGateJson?.checks?.find(row => row.name === 'verify-claims');
+  check('gate --claims is unblocked only through visible legacy-debt accounting',
+    afterGate.status === 0 && afterGateJson?.ok === true && afterClaimCheck?.ok === true
+      && afterClaimCheck?.rawFailed === 1 && afterClaimCheck?.baselined === 1 && afterClaimCheck?.failed === 0,
+    afterGate);
+
+  result = run(root, ['verify-claim', 'baseline', 'show', '--json']);
+  check('baseline show returns the integrity-bound policy document',
+    result.status === 0 && json(result)?.state === 'valid'
+      && json(result)?.baseline?.beforeTaskId === boundaryId,
+    result);
+
+  const changedTracker = trackerText.replace('| legacy next |', '| changed metadata |');
+  fs.writeFileSync(tracker, changedTracker, 'utf8');
+  result = run(root, ['verify-claim', '--all', '--json']);
+  const changed = json(result);
+  check('any historical tracker-row change invalidates that exemption',
+    result.status === 1 && changed?.baselined === 0 && changed?.failed === 1
+      && changed?.baseline?.mismatched?.includes(legacyId),
+    result);
+  const baselineHashBeforeRetry = digest(baselineFile);
+  result = run(root, ['verify-claim', 'baseline', 'create', '--before', boundaryId, '--yes', '--json']);
+  check('baseline create cannot relaunder a changed historical row by overwriting policy',
+    result.status === 1 && json(result)?.code === 'baseline_exists'
+      && digest(baselineFile) === baselineHashBeforeRetry,
+    result);
+  result = run(root, ['verify-claim', '--all', '--json']);
+  check('a refused baseline recreation leaves the changed row blocked',
+    result.status === 1 && json(result)?.baseline?.mismatched?.includes(legacyId),
+    result);
+  result = run(root, ['gate', '.', '--claims', '--json'], 120000);
+  const changedGateCheck = json(result)?.checks?.find(row => row.name === 'verify-claims');
+  check('gate JSON preserves baseline mismatch diagnostics',
+    result.status === 1 && changedGateCheck?.baseline?.mismatched?.includes(legacyId),
+    result);
+  fs.writeFileSync(tracker, trackerText, 'utf8');
+
+  result = run(root, ['task', 'add', 'new false claim']);
+  const newId = (result.stdout.match(/T-\d{4,}/) || [])[0];
+  result = run(root, ['task', 'update', newId, '--status', 'done', '--evidence', 'ghost.js implemented and tested', '--next', 'none']);
+  check('post-boundary false claim fixture is created', result.status === 0 && !!newId, result);
+  result = run(root, ['verify-claim', '--all', '--json']);
+  const withNew = json(result);
+  check('new failures still block while the unchanged legacy row stays isolated',
+    result.status === 1 && withNew?.rawFailed === 2 && withNew?.baselined === 1
+      && withNew?.failed === 1 && withNew?.baseline?.newFailures?.includes(newId),
+    result);
+  result = run(root, ['gate', '.', '--claims', '--json'], 120000);
+  const newFailureGateCheck = json(result)?.checks?.find(row => row.name === 'verify-claims');
+  check('gate JSON preserves new-failure identifiers',
+    result.status === 1 && newFailureGateCheck?.baseline?.newFailures?.includes(newId),
+    result);
+
+  const corrupt = { ...stored, integrity: 'sha256:' + '0'.repeat(64) };
+  fs.writeFileSync(baselineFile, JSON.stringify(corrupt, null, 2) + '\n', 'utf8');
+  result = run(root, ['verify-claim', '--all', '--json']);
+  check('corrupt baseline fails closed with a distinct machine-readable error',
+    result.status === 1 && json(result)?.ok === false
+      && json(result)?.errors?.includes('baseline-invalid')
+      && json(result)?.baseline?.problems?.includes('integrity-mismatch'),
+    result);
+  result = run(root, ['gate', '.', '--claims', '--json'], 120000);
+  const corruptGateCheck = json(result)?.checks?.find(row => row.name === 'verify-claims');
+  check('gate JSON preserves corrupt-baseline problems',
+    result.status === 1 && corruptGateCheck?.errors?.includes('baseline-invalid')
+      && corruptGateCheck?.baseline?.problems?.includes('integrity-mismatch'),
+    result);
+  result = run(root, ['verify-claim', '--all', '--raw', '--json']);
+  check('raw audit remains available even when the baseline store is corrupt',
+    result.status === 1 && json(result)?.baseline?.state === 'ignored'
+      && json(result)?.errors?.length === 0 && json(result)?.rawFailed === 2,
+    result);
+  result = run(root, ['verify-claim', 'baseline', 'show', '--json']);
+  check('baseline show reports corruption instead of silently treating it as absent',
+    result.status === 1 && json(result)?.code === 'baseline_invalid',
+    result);
+
+  const nonCanonical = withIntegrity({
+    ...stored,
+    entries: stored.entries.map(entry => ({ ...entry, reasons: [...entry.reasons, entry.reasons[0]] })),
+  });
+  fs.writeFileSync(baselineFile, JSON.stringify(nonCanonical, null, 2) + '\n', 'utf8');
+  result = run(root, ['verify-claim', '--all', '--json']);
+  check('non-canonical reasons fail closed even with a recomputed document integrity hash',
+    result.status === 1 && json(result)?.baseline?.problems?.includes('invalid-entry-reasons'),
+    result);
+} finally {
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+if (failures.length) {
+  console.log(`CLAIMS_BASELINE_PROBE_FAILED: ${failures.join('; ')}`);
+  process.exitCode = 1;
+} else {
+  console.log('claims baseline probe passed');
+}

package/scripts/command-flags-probe.js

@@ -270,6 +270,26 @@ try {
   check('verify-claim retains its supported --test-cmd contract',
     claimOwnsTestCommand.status === 1 && json(claimOwnsTestCommand)?.code !== 'unknown_flag',
     claimOwnsTestCommand);
+
+  const claimRaw = run(['verify-claim', '--all', '--raw', '--path', emptyProject, '--json']);
+  check('verify-claim --all retains its supported raw-audit contract',
+    claimRaw.status === 0 && json(claimRaw)?.baseline?.state === 'ignored',
+    claimRaw);
+
+  const claimForeignBoundary = run(['verify-claim', 'T-NOT-FOUND', '--before', 'T-0002', '--path', emptyProject, '--json']);
+  check('per-task verify-claim rejects the baseline-only --before flag',
+    claimForeignBoundary.status === 1 && json(claimForeignBoundary)?.code === 'unknown_flag',
+    claimForeignBoundary);
+
+  const baselineForeignRun = run(['verify-claim', 'baseline', 'show', '--run-tests', '--path', emptyProject, '--json']);
+  check('claims baseline show rejects verification-only mutation flags',
+    baselineForeignRun.status === 1 && json(baselineForeignRun)?.code === 'unknown_flag',
+    baselineForeignRun);
+
+  const gateForeignRaw = run(['gate', emptyProject, '--raw', '--json']);
+  check('gate rejects --raw because raw audit belongs to verify-claim --all',
+    gateForeignRaw.status === 1 && json(gateForeignRaw)?.code === 'unknown_flag',
+    gateForeignRaw);
 } finally {
   fs.rmSync(emptyProject, { recursive: true, force: true });
 }

package/scripts/release-runtime-probe.js

@@ -1124,8 +1124,11 @@ try {
       || /spawnSync\(['"]where(?:\.exe)?['"]/.test(npmSource)) {
     failures.push('공용 npm resolver가 bare where 또는 동적 cmd wrapper로 후퇴함');
   }
-  if (!diagnosticsSource.includes("windowsPathCandidates('leerness'") || /spawnSync\(tool,/.test(diagnosticsSource)) {
-    failures.push('which 진단이 Windows bare where를 다시 실행함');
+  if (!diagnosticsSource.includes("windowsPathCandidates('leerness'")
+      || !diagnosticsSource.includes('out.pathInstallations = _groupPathInstallations')
+      || !diagnosticsSource.includes('if (out.pathInstallations.length > 1)')
+      || /spawnSync\(tool,/.test(diagnosticsSource)) {
+    failures.push('which 진단이 안전한 Windows PATH 수집 또는 설치 단위 그룹화를 잃음');
   }
   if (cliSource.includes("cp.execSync('npm root -g'") || cliSource.includes("cp.spawnSync('chcp.com'")
       || cliSource.includes("cp.spawnSync('powershell'") || cliSource.includes("cp.spawnSync('powershell.exe'")) {

package/scripts/which-shim-probe.js

@@ -0,0 +1,208 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const diagnostics = require('../lib/diagnostics');
+
+const failures = [];
+let checks = 0;
+const groupPathInstallations = diagnostics._groupPathInstallations;
+
+function check(condition, failure) {
+  checks++;
+  if (!condition) failures.push(failure);
+}
+
+if (typeof groupPathInstallations !== 'function') {
+  failures.push('diagnostics._groupPathInstallations is not implemented');
+} else {
+  const npmShimPair = [
+    'C:\\Users\\tester\\AppData\\Roaming\\npm\\leerness',
+    'C:\\Users\\tester\\AppData\\Roaming\\npm\\leerness.cmd',
+  ];
+  const samePackage = candidate => candidate.replace(/\//g, '\\').toLowerCase().includes('\\npm\\leerness')
+    ? 'c:\\users\\tester\\appdata\\roaming\\npm\\node_modules\\leerness\\package.json'
+    : null;
+
+  const oneInstall = groupPathInstallations(npmShimPair, {
+    platform: 'win32',
+    command: 'leerness',
+    packageIdentity: samePackage,
+  });
+  check(oneInstall.length === 1 && oneInstall[0].candidates.length === 2,
+    `same npm shim pair should be one install, got ${JSON.stringify(oneInstall)}`);
+
+  const npmShimTrio = groupPathInstallations([...npmShimPair,
+    'C:\\Users\\tester\\AppData\\Roaming\\npm\\leerness.ps1'], {
+    platform: 'win32', command: 'leerness', packageIdentity: samePackage,
+  });
+  check(npmShimTrio.length === 1 && npmShimTrio[0].candidates.length === 3,
+    `PowerShell shim should join the same npm install, got ${JSON.stringify(npmShimTrio)}`);
+
+  const mixedCaseAndSeparators = groupPathInstallations([npmShimPair[0],
+    'c:/Users/tester/AppData/Roaming/npm/leerness.cmd'], {
+    platform: 'win32', command: 'leerness', packageIdentity: samePackage,
+  });
+  check(mixedCaseAndSeparators.length === 1,
+    `Windows case and separator variants should share one install, got ${JSON.stringify(mixedCaseAndSeparators)}`);
+
+  const nonStandardBat = groupPathInstallations([npmShimPair[0],
+    'C:\\Users\\tester\\AppData\\Roaming\\npm\\leerness.bat'], {
+    platform: 'win32', command: 'leerness', packageIdentity: samePackage,
+  });
+  check(nonStandardBat.length === 2,
+    `non-standard .bat must not be merged without content proof, got ${JSON.stringify(nonStandardBat)}`);
+
+  const trueConflict = groupPathInstallations([
+    ...npmShimPair,
+    'D:\\tools\\leerness.cmd',
+  ], {
+    platform: 'win32',
+    command: 'leerness',
+    packageIdentity: candidate => candidate.toLowerCase().startsWith('d:\\tools\\')
+      ? 'd:\\tools\\node_modules\\leerness\\package.json'
+      : samePackage(candidate),
+  });
+  check(trueConflict.length === 2,
+    `different PATH directories should remain a conflict, got ${JSON.stringify(trueConflict)}`);
+
+  const unprovenPair = groupPathInstallations(npmShimPair, {
+    platform: 'win32',
+    command: 'leerness',
+    packageIdentity: () => null,
+  });
+  check(unprovenPair.length === 2,
+    `same-stem files without a shared package must stay separate, got ${JSON.stringify(unprovenPair)}`);
+
+  const posixCandidates = groupPathInstallations([
+    '/usr/local/bin/leerness',
+    '/opt/leerness/bin/leerness',
+  ], {
+    platform: 'linux',
+    command: 'leerness',
+    packageIdentity: () => 'same-version-is-not-same-install',
+  });
+  check(posixCandidates.length === 2,
+    `POSIX candidates in separate PATH directories must not be grouped, got ${JSON.stringify(posixCandidates)}`);
+
+  const report = diagnostics.whichCmd({
+    VERSION: 'test', uiLang: 'en', has: () => false, harnessPath: 'fixture',
+    platform: 'win32', pathCandidates: npmShimPair, packageIdentity: samePackage,
+    skipNpm: true, quiet: true,
+  });
+  check(report.pathCandidates.length === 2 && report.pathInstallations.length === 1
+      && !report.diagnostics.some(line => /precedence conflict/.test(line)),
+  `product-level which report should preserve 2 raw shims without a conflict, got ${JSON.stringify(report)}`);
+
+  const conflictReport = diagnostics.whichCmd({
+    VERSION: 'test', uiLang: 'en', has: () => false, harnessPath: 'fixture',
+    platform: 'win32', pathCandidates: [...npmShimPair, 'D:\\tools\\leerness.cmd'],
+    packageIdentity: candidate => candidate.toLowerCase().startsWith('d:\\tools\\')
+      ? 'd:\\tools\\node_modules\\leerness\\package.json' : samePackage(candidate),
+    skipNpm: true, quiet: true,
+  });
+  check(conflictReport.pathInstallations.length === 2
+      && conflictReport.diagnostics.some(line => /2 leerness installations/.test(line)),
+  `product-level which report should retain true PATH conflicts, got ${JSON.stringify(conflictReport)}`);
+
+  if (process.platform === 'win32') {
+    const fixture = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-which-shim-'));
+    try {
+      const packageDir = path.join(fixture, 'node_modules', 'leerness');
+      const entryDir = path.join(packageDir, 'bin');
+      fs.mkdirSync(entryDir, { recursive: true });
+      fs.writeFileSync(path.join(packageDir, 'package.json'), JSON.stringify({
+        name: 'leerness', version: '9.9.9', bin: { leerness: 'bin/leerness.js' },
+      }));
+      fs.writeFileSync(path.join(entryDir, 'leerness.js'), '#!/usr/bin/env node\n');
+      const shShim = path.join(fixture, 'leerness');
+      const cmdShim = path.join(fixture, 'leerness.cmd');
+      const ps1Shim = path.join(fixture, 'leerness.ps1');
+      const validSh = '#!/bin/sh\nexec node "$basedir/node_modules/leerness/bin/leerness.js" "$@"\n';
+      const validCmd = '@ECHO off\nendLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\\node_modules\\leerness\\bin\\leerness.js" %*\n';
+      const validPs1 = '#!/usr/bin/env pwsh\n& "node$exe" "$basedir/node_modules/leerness/bin/leerness.js" $args\n';
+      fs.writeFileSync(shShim, validSh);
+      fs.writeFileSync(cmdShim, validCmd);
+      fs.writeFileSync(ps1Shim, validPs1);
+      const detected = groupPathInstallations([
+        shShim, cmdShim, ps1Shim,
+      ], { platform: 'win32', command: 'leerness' });
+      check(detected.length === 1 && detected[0].kind === 'npm-package'
+          && detected[0].candidates.length === 3,
+        `default package-manifest detection should group a real fixture, got ${JSON.stringify(detected)}`);
+
+      fs.writeFileSync(shShim,
+        '#!/bin/sh\nexec echo "$basedir/node_modules/leerness/bin/leerness.js" "$@"\n');
+      const dummySh = groupPathInstallations([shShim, cmdShim], {
+        platform: 'win32', command: 'leerness',
+      });
+      check(dummySh.length === 2,
+        `a dummy extensionless target argument must not prove execution, got ${JSON.stringify(dummySh)}`);
+      fs.writeFileSync(shShim, validSh);
+
+      fs.writeFileSync(cmdShim,
+        '@rem "%dp0%\\node_modules\\leerness\\bin\\leerness.js" %*\n"evil.exe" %*\n');
+      const commentedCmd = groupPathInstallations([shShim, cmdShim], {
+        platform: 'win32', command: 'leerness',
+      });
+      check(commentedCmd.length === 2,
+        `a commented cmd target plus divergent invocation must not be grouped, got ${JSON.stringify(commentedCmd)}`);
+      fs.writeFileSync(cmdShim, validCmd);
+
+      fs.writeFileSync(ps1Shim,
+        '# "$basedir/node_modules/leerness/bin/leerness.js" $args\n& evil $args\n');
+      const commentedPs1 = groupPathInstallations([shShim, ps1Shim], {
+        platform: 'win32', command: 'leerness',
+      });
+      check(commentedPs1.length === 2,
+        `a commented PowerShell target plus divergent invocation must not be grouped, got ${JSON.stringify(commentedPs1)}`);
+      fs.writeFileSync(ps1Shim, validPs1);
+
+      const otherEntry = path.join(fixture, 'node_modules', 'other', 'bin');
+      fs.mkdirSync(otherEntry, { recursive: true });
+      fs.writeFileSync(path.join(otherEntry, 'other.js'), '#!/usr/bin/env node\n');
+      fs.writeFileSync(cmdShim,
+        '@ECHO off\n"%_prog%" "%dp0%\\node_modules\\other\\bin\\other.js" %*\n');
+      const tampered = groupPathInstallations([
+        shShim, cmdShim,
+      ], { platform: 'win32', command: 'leerness' });
+      check(tampered.length === 2,
+        `adjacent package metadata must not hide a divergent shim, got ${JSON.stringify(tampered)}`);
+
+      const localModules = path.join(fixture, 'local with space', 'node_modules');
+      const localBin = path.join(localModules, '.bin');
+      const localPackage = path.join(localModules, 'leerness');
+      fs.mkdirSync(path.join(localPackage, 'bin'), { recursive: true });
+      fs.mkdirSync(localBin, { recursive: true });
+      fs.writeFileSync(path.join(localPackage, 'package.json'), JSON.stringify({
+        name: 'leerness', version: '9.9.9', bin: { leerness: 'bin/leerness.js' },
+      }));
+      fs.writeFileSync(path.join(localPackage, 'bin', 'leerness.js'), '#!/usr/bin/env node\n');
+      const localSh = path.join(localBin, 'leerness');
+      const localCmd = path.join(localBin, 'leerness.cmd');
+      const localPs1 = path.join(localBin, 'leerness.ps1');
+      fs.writeFileSync(localSh,
+        '#!/bin/sh\nexec node "$basedir/../leerness/bin/leerness.js" "$@"\n');
+      fs.writeFileSync(localCmd,
+        '@ECHO off\nendLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\\..\\leerness\\bin\\leerness.js" %*\n');
+      fs.writeFileSync(localPs1,
+        '#!/usr/bin/env pwsh\n& "node$exe" "$basedir/../leerness/bin/leerness.js" $args\n');
+      const localInstall = groupPathInstallations([localSh, localCmd, localPs1], {
+        platform: 'win32', command: 'leerness',
+      });
+      check(localInstall.length === 1 && localInstall[0].candidates.length === 3,
+        `local node_modules/.bin shims should be one install, got ${JSON.stringify(localInstall)}`);
+    } finally {
+      fs.rmSync(fixture, { recursive: true, force: true });
+    }
+  }
+}
+
+if (failures.length) {
+  console.error(`which shim grouping failures (${failures.length}):`);
+  failures.forEach(failure => console.error(`- ${failure}`));
+  process.exit(1);
+}
+
+console.log(`which shim grouping probe: ${checks}/${checks} passed`);