leerness 1.36.164 → 1.36.165

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.36.165 — 2026-08-26
+
+- verify-code가 fresh basic 권한에서도 Python/Go/Rust 러너를 제한적으로 실행하고, 혼합 Node/Python 테스트와 npm placeholder를 올바르게 판별하며, 실패·차단된 최신 증거가 lazy/gate를 거짓 통과하지 않도록 수정 (T-0143)
+
 ## 1.36.164 — 2026-08-26
 
 - `release publish --npm-publish`가 `release sync-main`과 동일한 보안 배포 경로를 사용하도록 통합했습니다. `prepublishOnly`와 pack은 npm/provider/cloud 시크릿 및 npm auth/OTP를 제거한 환경과 별도의 0바이트 임시 userconfig에서 실행하고, 그 단계가 생성한 exact `.tgz`를 권한 제한 임시 `.npmrc`와 `--ignore-scripts`로 그대로 업로드합니다. 따라서 npm이 기본 사용자 `.npmrc` 경로를 lifecycle에 다시 주입하거나 postpack이 작업 디렉터리를 바꿔도 인증정보와 검증 산출물의 경계가 유지됩니다. 토큰·OTP는 argv에 싣지 않으며 임시 인증 파일은 zeroize·삭제를 재시도합니다. 정리 실패와 `sync-main`의 npm 실패도 전체 명령 실패로 전파하고, registry 오류는 알려진 credential을 비식별화합니다. 긴 오류의 `EPUBLISHCONFLICT`도 전체 출력에서 분류한 뒤 exact version 재조회가 성공할 때만 멱등 성공으로 인정합니다. 토큰이 없으면 스크립트를 끈 업로드 단계에서만 기존 npm userconfig 로그인을 유지하며 dry-run은 인증 파일과 lifecycle을 모두 생략해 프로젝트 무쓰기를 보장합니다. 이 경계들을 실제 npm CLI·로컬 Git remote 공격성 프로브로 검증합니다.

package/README.md

@@ -128,7 +128,7 @@ MIT
 <!-- leerness:project-readme:start -->
 ## Leerness Project Harness
 
-이 프로젝트는 Leerness v1.36.164 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
+이 프로젝트는 Leerness v1.36.165 하네스를 사용합니다. AI 에이전트는 작업 전 `leerness handoff`로 컨텍스트를 적재하고, 작업 후 `leerness check`/`leerness audit`/`leerness session close`를 수행해야 합니다.
 
 ### 정체성 — AI 에이전트 운영 레이어 (UR-0030)
 
@@ -182,7 +182,7 @@ leerness memory restore decision <date|title>
 
 ### MCP server (외부 AI 통합)
 
-Leerness v1.36.164는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
+Leerness v1.36.165는 stdio JSON-RPC MCP server를 내장합니다 — Claude Code · Cursor · Codex CLI 등 외부 AI에 **89개 도구**를 노출:
 
 ```jsonc
 // 카테고리별
@@ -203,7 +203,7 @@ Leerness v1.36.164는 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) 다음 라운드 예약.
 
-현재 누적: **v1.9.x → 1.36.164 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
+현재 누적: **v1.9.x → 1.36.165 릴리스 태그 이력** (수백 라운드) · _reports/는 비공개 보존.
 
 ### 성능 가이드
 
@@ -241,5 +241,5 @@ 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.164: 2026-08-26
+Last synced by Leerness v1.36.165: 2026-08-26
 <!-- leerness:project-readme:end -->

package/bin/leerness.js

@@ -47,7 +47,7 @@ const {
   migrateLegacyWorkspace,
 } = require('../lib/workspace-dir');
 
-const VERSION = '1.36.164';
+const VERSION = '1.36.165';
 
 // 1.9.290 (UR-0037, Codex gpt-5.5 #4 수렴): CLI 전용 부작용은 require 시 실행하지 않는다.
 //   이전: warning listener 제거 / NODE_OPTIONS 변경 / chcp IIFE 가 top-level 즉시 실행 → require('harness') 시 호스트 프로세스 오염.
@@ -5775,6 +5775,29 @@ function _selfTestCases() {
       const extOk = _isCommandPermitted({ mode: 'extended', shell: { exec: true, allowList: [] } }, 'python x.py', {}) === true;  // exec:true → 허용
       return blockedDefault && blockedPy && allowedAuth && coreStillOk && extOk;
     } },
+    { name: 'T-0143: verify-code 고정 비-JS 러너만 basic 호출단위 허용 + 임의 python 차단 유지 (행위)', run: () => {
+      const basic = { mode: 'basic', shell: { exec: false, allowList: [] } };
+      const scoped = { commandAllowList: VERIFY_CODE_RUNNER_ALLOW };
+      return _isCommandPermitted(basic, 'pytest -q', scoped) === true
+        && _isCommandPermitted(basic, 'go test ./...', scoped) === true
+        && _isCommandPermitted(basic, 'cargo test', scoped) === true
+        && _isCommandPermitted(basic, 'python arbitrary.py', scoped) === false
+        && _isCommandPermitted(basic, 'pytest -q', {}) === false;
+    } },
+    { name: 'T-0143: 최신 실패/권한차단 증거는 no_test_run, 성공·optional skip 조합만 인정 (행위)', run: () => {
+      const pass = '## 2026-08-26T04:00 verify-code\nCommand: pytest -q\n- test: exit=0\n';
+      const blocked = pass + '\n## 2026-08-26T04:01 verify-code\nCommand: pytest -q\n- test: exit=126\n';
+      const recovered = blocked + '\n## 2026-08-26T04:02 verify-code\nCommand: pytest -q\n- test: exit=0\n';
+      const mixed = '## 2026-08-26T04:00 verify-code\nCommand: npm test\n- test: exit=0\n- typecheck: exit=127\n';
+      const failed = '## 2026-08-26\n```\ncargo test\n1 failed\n```\n';
+      const legacyPass = '## 2026-08-26\n```\ncargo test --all\n42 passed; 0 failed\n```\n';
+      const passingTail = '## 2026-08-26T04:00 verify-code\n- test: exit=0 — `pytest -q`\nTail:\n- child: exit=1\n';
+      const manualFail = '## 2026-08-26\nCommand: pytest -q\nExit: 0\nFAIL: expected exit=0 but got 1\n';
+      return _hasSuccessfulTestRunEvidence(pass) && !_hasSuccessfulTestRunEvidence(blocked)
+        && _hasSuccessfulTestRunEvidence(recovered) && _hasSuccessfulTestRunEvidence(mixed) && !_hasSuccessfulTestRunEvidence(failed)
+        && _hasSuccessfulTestRunEvidence(legacyPass) && _hasSuccessfulTestRunEvidence(passingTail)
+        && !_hasSuccessfulTestRunEvidence(manualFail);
+    } },
     { name: '재실증 P1 (1.18.1): verify-claim 차단 실행은 skip(불일치 판정 아님) + 종합 라벨이 실제 cmd (소스 가드)', run: () => {
       const src = read(__filename);
       const authPass = src.includes('userAuthorized: true, timeout: 5 * 60 * 1000, kind: ' + "'verify_claim_test'");
@@ -15539,6 +15562,38 @@ function encodingCheck(root, opts = {}) {
   }
 }
 
+const _TEST_RUN_EVIDENCE_RE = /\b(npm test|pnpm test|yarn test|pytest|jest|vitest|tsc|eslint|playwright|cypress|go test|cargo test|cargo nextest|rspec|rake test|rake spec|phpunit|dotnet test|mvn test|mvn verify|gradle test|gradlew test|bun test|deno test|mocha|ctest|make test|make check|mix test|swift test|flutter test|dart test|tox|unittest|nose2)\b/i;
+
+function _hasSuccessfulTestRunEvidence(text) {
+  // 실제 verify-code는 ISO `YYYY-MM-DDTHH:mm`, 정책 예시는 공백형
+  // `YYYY-MM-DD HH:mm`을 쓴다. 둘 다 독립 블록으로 나눠 최신 결과만 본다.
+  const blocks = String(text || '').split(/\n(?=##\s+\d{4}-\d{2}-\d{2}(?:T|\s))/);
+  const relevant = blocks.filter(block => _TEST_RUN_EVIDENCE_RE.test(block));
+  if (!relevant.length) return false;
+  const latest = relevant[relevant.length - 1];
+  // verify-code Tail은 테스트의 정상적인 negative-path 로그도 담는다. 그 안의
+  // "expected child exit=1" 같은 문자열을 실행 결과로 오인하지 않고, 도구가 쓴
+  // summary 행만 신뢰한다. 수동 증거의 Exit: 행은 아래 별도 경로에서 처리한다.
+  const summary = latest.split(/^Tail:\s*$/im)[0];
+  const exits = Array.from(summary.matchAll(/^\s*-\s+.+?:\s*exit\s*=\s*(null|-?\d+)\b/gim), match => {
+    return match[1].toLowerCase() === 'null' ? null : Number(match[1]);
+  });
+  if (exits.length) {
+    // 127 is verify-code's explicit optional-runner skip. A block still needs at
+    // least one actual success, and permission denial (126) is never evidence.
+    return exits.some(code => code === 0) && exits.every(code => code === 0 || code === 127);
+  }
+  const explicitFailure = /(?:^|\n)\s*(?:✗|FAIL\b)/im.test(latest)
+    || /\b(?:test|lint|typecheck|build|bench)\s+failed\b/i.test(latest)
+    || /\b[1-9]\d*\s+failed\b/i.test(latest);
+  if (explicitFailure) return false;
+  const manualExits = Array.from(latest.matchAll(/^\s*Exit\s*:\s*(null|-?\d+)\b/gim), match => {
+    return match[1].toLowerCase() === 'null' ? null : Number(match[1]);
+  });
+  if (manualExits.length) return manualExits.some(code => code === 0) && manualExits.every(code => code === 0);
+  return true;
+}
+
 // 1.9.101: lazy detect 결과를 JSON으로 노출 (외부 AI/MCP 통합용). opts.json=true 시 verbose 출력 억제 후 JSON만.
 function lazyDetect(root, opts = {}) {
   root = absRoot(root);
@@ -15573,8 +15628,11 @@ function lazyDetect(root, opts = {}) {
       { kind: 'handoff_empty', severity: 'warn' });
   }
   const ev = exists(evidencePath(root)) ? read(evidencePath(root)) : '';
-  // 1.35.16 (lazy 헌트 FP): JS+pytest 중심 목록에 비-JS 러너 추가 — Go/Rust/Ruby/PHP/.NET/Java/Elixir/Swift/Dart/C 등이 실제 테스트를 돌려도 no_test_run 오탐(active 프로젝트에선 blocking → gate 거짓 실패)하던 것 차단. (negative finding 억제라 추가는 FP-safe.)
-  const hasTestRun = /\b(npm test|pnpm test|yarn test|pytest|jest|vitest|tsc|eslint|playwright|cypress|go test|cargo test|cargo nextest|rspec|rake test|rake spec|phpunit|dotnet test|mvn test|mvn verify|gradle test|gradlew test|bun test|deno test|mocha|ctest|make test|make check|mix test|swift test|flutter test|dart test|tox|unittest|nose2)\b/i.test(ev);
+  // 1.35.16 (lazy 헌트 FP): JS+pytest 중심 목록에 비-JS 러너 추가 — Go/Rust/Ruby/PHP/.NET/Java/Elixir/Swift/Dart/C 등이 실제 테스트를 돌려도 no_test_run 오탐(active 프로젝트에선 blocking → gate 거짓 실패)하던 것 차단.
+  // T-0143: 러너 이름만 찾으면 verify-code 가 exit=126/1 을 기록한 직후에도 lazy/gate 가 초록이 됐다.
+  // 가장 최근 관련 증거 블록에 구조화 exit 가 있으면 성공(0)과 optional skip(127)만 허용하고,
+  // 구조화되지 않은 기존 수동 증거는 명시적 실패 신호가 없을 때만 이전 호환 동작을 유지한다.
+  const hasTestRun = _hasSuccessfulTestRunEvidence(ev);
   if (!hasTestRun) { issues++; _warn('review-evidence.md has no recorded test/typecheck/lint run',
     { kind: 'no_test_run', severity: 'warn' }); }
   // 1.9.7 C: TODO 자동 추적 강화 — 위치+텍스트 캡처, known-todos 비교, --auto-track 등록
@@ -23227,7 +23285,9 @@ function verifyCodeCmd(root) {
     try { pkg = JSON.parse(read(pkgFile)); } catch (e) { return fail('package.json 파싱 실패: ' + e.message); }
     const scripts = pkg.scripts || {};
     const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-    if (scripts.test) tasks.push({ name: 'test', cmd: 'npm test', runtime: 'node' });
+    // npm init 기본 placeholder는 실제 검증이 아니며 Python 테스트를 가리면 안 된다.
+    const nodeTest = typeof scripts.test === 'string' && !/no test specified/i.test(scripts.test);
+    if (nodeTest) tasks.push({ name: 'test', cmd: 'npm test', runtime: 'node' });
     else if (scripts['test:smoke']) tasks.push({ name: 'test', cmd: 'npm run test:smoke', runtime: 'node' });
     // 1.9.148: 명시 script 없어도 인기 러너 의존성 발견 시 시도
     else if (deps.vitest) tasks.push({ name: 'test', cmd: 'npx --yes vitest run', runtime: 'node' });
@@ -23240,9 +23300,19 @@ function verifyCodeCmd(root) {
     if (has('--build') && scripts.build) tasks.push({ name: 'build', cmd: 'npm run build', runtime: 'node' });
     if (has('--bench') && scripts.bench) tasks.push({ name: 'bench', cmd: 'npm run bench', runtime: 'node', optional: true });
   }
-  // (2) Python: pyproject.toml / setup.py / tests/ 존재 시 pytest 시도
-  if (exists(path.join(root, 'pyproject.toml')) || exists(path.join(root, 'setup.py')) || exists(path.join(root, 'tests'))) {
-    if (!tasks.find(t => t.name === 'test')) tasks.push({ name: 'test', cmd: 'pytest -q', runtime: 'python', optional: true });
+  // (2) Python: Python 표식이 있으면 Node test와 독립적으로 pytest를 실행한다.
+  // `tests/` 이름만으로는 JS 프로젝트를 오인하므로 그 경로는 실제 .py 파일이 있을 때만 표식이다.
+  const testsDir = path.join(root, 'tests');
+  let hasPythonTests = false;
+  if (exists(testsDir)) {
+    try {
+      if (fs.statSync(testsDir).isDirectory()) {
+        for (const file of walk(testsDir)) { if (/\.py$/i.test(file)) { hasPythonTests = true; break; } }
+      }
+    } catch {}
+  }
+  if (exists(path.join(root, 'pyproject.toml')) || exists(path.join(root, 'setup.py')) || hasPythonTests) {
+    tasks.push({ name: 'test:python', cmd: 'pytest -q', runtime: 'python', optional: true });
   }
   // (3) Go: go.mod 존재 시 go test ./...
   if (exists(path.join(root, 'go.mod'))) {
@@ -23268,7 +23338,7 @@ function verifyCodeCmd(root) {
     const start = Date.now();
     // 1.9.150: runCommandSafe — cwd jail + env scrub + observability 자동 (shell:true 유지 — npm/pytest 호환)
     // 1.9.299 (UR-0039): scrubSecrets — 신뢰 못 할 워크스페이스 test/build 스크립트에 publish 토큰/시크릿 노출 차단.
-    const r = runCommandSafe(t.cmd, [], { cwd: root, root, timeout: 5 * 60 * 1000, allowShell: true, scrubSecrets: true, kind: 'verify_code_task', label: `verify-${t.name}` });
+    const r = runCommandSafe(t.cmd, [], { cwd: root, root, timeout: 5 * 60 * 1000, allowShell: true, scrubSecrets: true, commandAllowList: VERIFY_CODE_RUNNER_ALLOW, kind: 'verify_code_task', label: `verify-${t.name}` });
     const dur = Date.now() - start;
     if (r.status === 0) ok(`${t.name} passed (${dur}ms)`);
     else if (t.optional && r.status === 127) warn(`${t.name} 스킵 (${t.cmd} 없음)`);
@@ -26025,6 +26095,9 @@ function _isCwdSafe(root, cwd) {
 }
 // basic 모드에서도 항상 허용하는 핵심 도구 (release/install 흐름 유지)
 const RUN_CORE_ALLOW = ['git', 'npm', 'npx', 'node', 'pnpm', 'yarn'];
+// verify-code가 파일 표식에서 직접 고정 생성하는 비-JS 러너만 호출 단위로 허용한다.
+// 전역 core allow에 넣지 않아 다른 명령 표면의 basic 권한은 넓어지지 않는다.
+const VERIFY_CODE_RUNNER_ALLOW = ['pytest', 'go', 'cargo'];
 // 1.18.1 (재실증 신규 P1): 명령 실행 권한 결정 — 순수 함수(테스트 가능). cwd jail 은 별도(여기서 판단 안 함).
 //   userAuthorized: 사용자가 명시적으로 입력한 명령(예: verify-claim --test-cmd "<명령>" 또는 config testCommand)
 //   → basic 모드 allowList 우회(명시 권한). 이전엔 coreAllow(JS 도구)만 허용해 --test-cmd "python ..." 가
@@ -26036,12 +26109,13 @@ function _isCommandPermitted(perms, cmdStr, opts) {
   const exec = perms.shell && perms.shell.exec !== false;
   if (exec) return true;  // extended/full 모드 (또는 exec:true)
   const allow = (perms.shell && perms.shell.allowList) || [];
+  const scopedAllow = Array.isArray(opts.commandAllowList) ? opts.commandAllowList : [];
   const first = String(cmdStr || '').trim().split(/\s+/)[0];
-  return RUN_CORE_ALLOW.includes(first) || allow.includes('*') || allow.includes(first);
+  return RUN_CORE_ALLOW.includes(first) || scopedAllow.includes(first) || allow.includes('*') || allow.includes(first);
 }
 
 function runCommandSafe(cmd, args, opts) {
-  // opts: { cwd, root, timeout, env, stdio, kind, label, allowShell, encoding, input, allowOutsideCwd, userAuthorized }
+  // opts: { cwd, root, timeout, env, stdio, kind, label, allowShell, encoding, input, allowOutsideCwd, userAuthorized, commandAllowList }
   opts = opts || {};
   const root = opts.root || opts.cwd || process.cwd();
   const cwd = opts.cwd || root;
@@ -30786,7 +30860,7 @@ module.exports = {
   // 1.9.289: shell-safe 인용 (Codex #3) — 단위 테스트
   _shellQuoteArg,
   // 1.18.1: 명령 실행 권한 결정 (재실증 신규 P1: --test-cmd 비-JS 인터프리터 거짓차단) — 단위 테스트
-  _isCommandPermitted, RUN_CORE_ALLOW, _uiLang, _tx,
+  _isCommandPermitted, RUN_CORE_ALLOW, VERIFY_CODE_RUNNER_ALLOW, _hasSuccessfulTestRunEvidence, _uiLang, _tx,
   _loadEnvFile, _dotenvKeyAllowed, _scrubEnv,
   // 1.18.2: verify-claim 위장 스텁(빈 export 껍데기) 판정 — 단위 테스트
   _vcImplIsEmpty, _VC_EMPTY_SHELL_RE,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leerness",
-  "version": "1.36.164",
+  "version": "1.36.165",
   "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,8 +48,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/release-runtime-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js && npm run test:commands && npm run test:installed && node ./scripts/e2e.js",
-    "test:core": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/release-runtime-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js",
+    "test": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js && npm run test:commands && npm run test:installed && node ./scripts/e2e.js",
+    "test:core": "node ./scripts/lint.js && node ./scripts/workspace-dir-source-ratchet.js && node ./scripts/workspace-dir-migration-probe.js && node ./scripts/lock-probe.js && node ./scripts/platform-smoke.js && node ./scripts/verify-code-cross-runtime-probe.js && node ./scripts/release-runtime-probe.js && node ./bin/leerness.js --version && node ./bin/leerness.js selftest && node ./scripts/e2e-core.js && node ./scripts/handoff-readonly-probe.js",
     "test:commands": "node ./scripts/e2e-command-surface.js",
     "test:installed": "node ./scripts/installed-cleanroom-probe.js",
     "test:handoff": "node ./scripts/handoff-readonly-probe.js",

package/scripts/verify-code-cross-runtime-probe.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+'use strict';
+
+// T-0143: verify-code must execute its own fixed Python/Go/Rust runners under
+// fresh basic permissions, and a failed run must not become green gate evidence.
+
+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 tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'leerness-cross-runtime-'));
+const fakeBin = path.join(tempRoot, 'fake-bin');
+const baseEnv = {
+  ...process.env,
+  LEERNESS_OFFLINE: '1',
+  LEERNESS_NO_BANNER: '1',
+  LEERNESS_NO_PROMPT: '1',
+  LEERNESS_NO_DRIFT_CHECK: '1',
+};
+
+function run(args, cwd, env = baseEnv) {
+  return cp.spawnSync(process.execPath, [CLI, ...args], {
+    cwd,
+    env,
+    encoding: 'utf8',
+    timeout: 120000,
+  });
+}
+
+function output(result) {
+  return `${result.stdout || ''}\n${result.stderr || ''}`.trim();
+}
+
+function check(condition, message, result) {
+  if (condition) return;
+  const detail = result ? `\n${output(result).slice(0, 1600)}` : '';
+  throw new Error(`${message}${detail}`);
+}
+
+function write(file, text) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, text, 'utf8');
+}
+
+function writeRunner(name, stdout, exitCode) {
+  fs.mkdirSync(fakeBin, { recursive: true });
+  if (process.platform === 'win32') {
+    write(path.join(fakeBin, `${name}.cmd`), `@echo off\r\necho ${stdout}\r\nexit /b ${exitCode}\r\n`);
+    return;
+  }
+  const file = path.join(fakeBin, name);
+  write(file, `#!/bin/sh\nprintf '%s\\n' '${stdout.replace(/'/g, "'\\''")}'\nexit ${exitCode}\n`);
+  fs.chmodSync(file, 0o755);
+}
+
+function runnerEnv() {
+  return { ...baseEnv, PATH: `${fakeBin}${path.delimiter}${baseEnv.PATH || ''}` };
+}
+
+function initProject(name) {
+  const root = path.join(tempRoot, name);
+  fs.mkdirSync(root, { recursive: true });
+  const result = run(['init', root, '--yes', '--language', 'en', '--no-stale-check'], tempRoot);
+  check(result.status === 0, `init failed for ${name} (exit ${result.status})`, result);
+  return root;
+}
+
+function addDoneWork(root) {
+  let result = run(['task', 'add', 'cross-runtime verification', '--path', root], root);
+  check(result.status === 0, `task add failed (exit ${result.status})`, result);
+  const tracker = fs.readFileSync(path.join(root, '.leerness', 'progress-tracker.md'), 'utf8');
+  const ids = Array.from(tracker.matchAll(/\|\s*(T-\d{4,})\s*\|/g), match => match[1]);
+  const id = ids[ids.length - 1];
+  check(!!id, 'task id not found after task add');
+  result = run(['task', 'update', id, '--status', 'done', '--evidence', 'cross-runtime fixture implemented', '--path', root], root);
+  check(result.status === 0, `task update failed (exit ${result.status})`, result);
+  result = run(['session', 'close', '--path', root], root);
+  check(result.status === 0, `session close failed (exit ${result.status})`, result);
+}
+
+function parseJson(result, label) {
+  try { return JSON.parse(result.stdout || '{}'); }
+  catch { throw new Error(`${label} returned invalid JSON\n${output(result).slice(0, 1600)}`); }
+}
+
+try {
+  writeRunner('pytest', '- child: exit=1', 0);
+  writeRunner('go', 'ok example.test/module 0.01s', 0);
+  writeRunner('cargo', 'test result: ok. 2 passed; 0 failed', 0);
+
+  const passRoot = initProject('pass');
+  write(path.join(passRoot, 'pyproject.toml'), '[project]\nname = "probe"\nversion = "0.0.0"\n');
+  write(path.join(passRoot, 'go.mod'), 'module example.test/module\n\ngo 1.22\n');
+  write(path.join(passRoot, 'Cargo.toml'), '[package]\nname = "probe"\nversion = "0.0.0"\nedition = "2021"\n');
+  const passed = run(['verify-code', '--path', passRoot], passRoot, runnerEnv());
+  check(
+    passed.status === 0
+      && /test:python passed/.test(passed.stdout || '')
+      && /test:go passed/.test(passed.stdout || '')
+      && /test:rust passed/.test(passed.stdout || ''),
+    `cross-runtime verify blocked/failed under basic permissions (exit ${passed.status})`,
+    passed,
+  );
+  const passLazy = run(['lazy', 'detect', '--path', passRoot, '--json'], passRoot, runnerEnv());
+  const passLazyJson = parseJson(passLazy, 'passing lazy detect');
+  check(
+    Array.isArray(passLazyJson.findings) && !passLazyJson.findings.some(f => f.kind === 'no_test_run'),
+    'successful verify Tail text was mistaken for a failed exit',
+    passLazy,
+  );
+
+  writeRunner('pytest', '1 failed in 0.01s', 1);
+  const failRoot = initProject('fail');
+  write(path.join(failRoot, 'pyproject.toml'), '[project]\nname = "probe-fail"\nversion = "0.0.0"\n');
+  addDoneWork(failRoot);
+  const failedVerify = run(['verify-code', '--path', failRoot], failRoot, runnerEnv());
+  check(failedVerify.status === 1, `failing pytest was not propagated (exit ${failedVerify.status})`, failedVerify);
+
+  const lazy = run(['lazy', 'detect', '--path', failRoot, '--json'], failRoot, runnerEnv());
+  const lazyJson = parseJson(lazy, 'lazy detect');
+  check(
+    lazy.status === 1 && Array.isArray(lazyJson.findings) && lazyJson.findings.some(f => f.kind === 'no_test_run'),
+    `failed verify evidence accepted by lazy detect (exit ${lazy.status})`,
+    lazy,
+  );
+
+  const gate = run(['gate', '--path', failRoot, '--json'], failRoot, runnerEnv());
+  const gateJson = parseJson(gate, 'gate');
+  const lazyStep = Array.isArray(gateJson.checks) && gateJson.checks.find(item => item.name === 'lazy detect');
+  check(gate.status === 1 && gateJson.ok === false && lazyStep && lazyStep.ok === false, `failed verify evidence accepted by gate (exit ${gate.status})`, gate);
+
+  writeRunner('npm', 'node suite passed', 0);
+  const hybridRoot = initProject('hybrid');
+  write(path.join(hybridRoot, 'package.json'), JSON.stringify({ name: 'hybrid-probe', version: '0.0.0', scripts: { test: 'node -e "process.exit(0)"' } }, null, 2) + '\n');
+  write(path.join(hybridRoot, 'pyproject.toml'), '[project]\nname = "hybrid-probe"\nversion = "0.0.0"\n');
+  const hybrid = run(['verify-code', '--path', hybridRoot], hybridRoot, runnerEnv());
+  check(
+    hybrid.status === 1 && /test passed/.test(hybrid.stdout || '') && /test:python failed/.test(hybrid.stdout || ''),
+    `passing Node test hid failing Python tests (exit ${hybrid.status})`,
+    hybrid,
+  );
+
+  writeRunner('pytest', '4 passed in 0.01s', 0);
+  const recoveredVerify = run(['verify-code', '--path', failRoot], failRoot, runnerEnv());
+  check(recoveredVerify.status === 0, `fixed pytest did not recover verify-code (exit ${recoveredVerify.status})`, recoveredVerify);
+  const recoveredLazy = run(['lazy', 'detect', '--path', failRoot, '--json'], failRoot, runnerEnv());
+  const recoveredLazyJson = parseJson(recoveredLazy, 'recovered lazy detect');
+  check(
+    recoveredLazy.status === 0 && Array.isArray(recoveredLazyJson.findings) && !recoveredLazyJson.findings.some(f => f.kind === 'no_test_run'),
+    `latest successful verify did not recover lazy detect (exit ${recoveredLazy.status})`,
+    recoveredLazy,
+  );
+  const recoveredGate = run(['gate', '--path', failRoot, '--json'], failRoot, runnerEnv());
+  const recoveredGateJson = parseJson(recoveredGate, 'recovered gate');
+  check(recoveredGate.status === 0 && recoveredGateJson.ok === true, `latest successful verify did not recover gate (exit ${recoveredGate.status})`, recoveredGate);
+
+  const placeholderRoot = initProject('placeholder');
+  write(path.join(placeholderRoot, 'package.json'), JSON.stringify({ name: 'placeholder-probe', version: '0.0.0', scripts: { test: 'echo "Error: no test specified" && exit 1' } }, null, 2) + '\n');
+  write(path.join(placeholderRoot, 'pyproject.toml'), '[project]\nname = "placeholder-probe"\nversion = "0.0.0"\n');
+  const placeholder = run(['verify-code', '--path', placeholderRoot], placeholderRoot, runnerEnv());
+  check(
+    placeholder.status === 0 && /verify-code \(1개\)/.test(placeholder.stdout || '') && /test:python passed/.test(placeholder.stdout || '') && !/^## test: npm test/m.test(placeholder.stdout || ''),
+    `npm placeholder masked Python verification (exit ${placeholder.status})`,
+    placeholder,
+  );
+
+  const jsOnlyRoot = initProject('js-only-tests-dir');
+  write(path.join(jsOnlyRoot, 'package.json'), JSON.stringify({ name: 'js-only-probe', version: '0.0.0' }, null, 2) + '\n');
+  write(path.join(jsOnlyRoot, 'tests', 'math.test.js'), 'test("math", () => {});\n');
+  const jsOnly = run(['verify-code', '--path', jsOnlyRoot], jsOnlyRoot, runnerEnv());
+  check(jsOnly.status === 0 && !/pytest -q/.test(jsOnly.stdout || ''), `JavaScript-only tests directory was misdetected as Python (exit ${jsOnly.status})`, jsOnly);
+
+  process.stdout.write('PASS verify-code cross-runtime permissions and failed-evidence gate probe\n');
+} catch (error) {
+  process.stderr.write(`FAIL verify-code cross-runtime probe: ${error.message}\n`);
+  process.exitCode = 1;
+} finally {
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+}