@su-record/vibe 3.2.64 → 4.0.1

package/hooks/scripts/lib/inbox.js

@@ -1,68 +0,0 @@
-/**
- * 루프 인박스 — 사람 리뷰 큐(`.vibe/loops/inbox.md`) 기록.
- *
- * loop-history.jsonl 은 결정론적으로 기록되는데 인박스만 모델이 마크다운을 직접
- * prepend 하고 있었다 (감사 2026-07-28 L5). 블록 형식과 최신순 정렬을 코드가 보장한다.
- *
- * fail-open — 기록 실패가 루프를 멈추지 않는다.
- */
-import fs from 'fs';
-import path from 'path';
-import { projectVibePath } from '../utils.js';
-
-const HEADER = '# Loop Inbox\n\n> 루프가 남긴 사람 리뷰 큐. 최신 항목이 위에 온다.\n';
-
-/**
- * 인박스 경로 — 이 모듈이 소유한다.
- *
- * 쓰기는 항상 `.vibe/` 로 한다(신규 레이아웃). 읽기는 레거시(`.claude/vibe/`)도
- * 봐야 하므로 `projectVibePath` 를 쓴다 — 두 쪽이 다른 파일을 보면 기록은 되는데
- * ANCHOR 는 못 읽는 상태가 된다.
- */
-export function inboxPath(projectDir) {
-  return projectVibePath(projectDir, 'loops', 'inbox.md');
-}
-
-/**
- * 인박스 블록을 최상단에 prepend 한다.
- *
- * @param {string} projectDir
- * @param {{ loop: string, result: 'ok'|'fail'|'stuck', at: string, lines?: string[] }} entry
- *        at 은 호출자가 넘긴다 — 이 모듈은 시각을 직접 읽지 않는다 (테스트 결정성)
- * @returns {boolean} 성공 여부
- */
-export function prependInboxBlock(projectDir, entry) {
-  try {
-    if (!entry?.loop || !entry?.result || !entry?.at) return false;
-
-    const body = (entry.lines ?? []).map(l => `- ${l}`).join('\n');
-    const block = `## ${entry.loop} — ${entry.at} — ${entry.result}\n${body}\n`;
-
-    const target = inboxPath(projectDir);
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-
-    const existing = fs.existsSync(target) ? fs.readFileSync(target, 'utf-8') : '';
-    const blocksStart = existing.indexOf('## ');
-    const head = blocksStart === -1 ? HEADER : existing.slice(0, blocksStart);
-    const rest = blocksStart === -1 ? '' : existing.slice(blocksStart);
-
-    fs.writeFileSync(target, `${head}\n${block}\n${rest}`.replace(/\n{3,}/g, '\n\n'), 'utf-8');
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * 아직 처리되지 않은 블록 수 — `## ` 로 시작하는 줄의 개수.
- * @param {string} projectDir
- * @returns {number}
- */
-export function countInboxBlocks(projectDir) {
-  try {
-    const raw = fs.readFileSync(inboxPath(projectDir), 'utf-8');
-    return raw.split('\n').filter(l => l.startsWith('## ')).length;
-  } catch {
-    return 0;
-  }
-}

package/hooks/scripts/lib/iteration-cost.js

@@ -1,178 +0,0 @@
-/**
- * 회전 비용 계측 — "그 전진이 얼마짜리였나" 를 코드가 센다.
- *
- * 원장은 `iterations`(폭주 방어)와 `verified`(전진량) 두 축만 세고 있었다. 둘로는
- * "10회를 썼고 2회 전진했다" 까지만 알 수 있고, 그 2회가 싼 전진이었는지 비싼
- * 전진이었는지는 모른다. vibe 가 효율에 대해 아무 주장도 할 수 없는 이유가 그것이다
- * (constitution §3.5 — 측정하지 않은 수치는 쓰지 않는다).
- *
- * **수치의 출처는 코드여야 한다.** 모델이 "도구를 12번 썼다" 고 보고하는 형태면 그건
- * vibe 가 완료 판정에서 배제하는 바로 그 자기보고이고, 그 위에 쌓인 데이터로는
- * 아무것도 주장할 수 없다. 그래서 인자로 받지 않고 이미 코드가 세고 있는 것을 읽는다 —
- * `step-counter.js`(PostToolUse)가 액션 툴콜을 `current-run.jsonl` 에 스로틀 없이 append 한다.
- *
- * 두 가지를 0 과 구분해서 남긴다. 이게 이 모듈의 존재 이유의 절반이다:
- *  - `measured: false` — 훅 미설치·첫 실행이라 **재지 못했다**. 0 이 아니다
- *  - `truncated: true` — 로그가 회전해 창의 앞부분이 사라졌다. 그 값은 **하한**이다
- * 재지 못한 것을 0 으로 채우면 훅 미설치 환경에서 "회전당 도구 0회" 라는 거짓 데이터가
- * 쌓이고, 훅은 프로젝트 로컬이라 미설치가 흔하다.
- */
-
-import fs from 'fs';
-import path from 'path';
-
-/** 서브에이전트 스폰 툴 — 하네스가 이름을 바꾼다. 옛 이름을 지우지 않는다 (step-counter 와 같은 규칙) */
-const SUBAGENT_TOOLS = new Set(['Agent', 'Task']);
-
-function toolLogPath(projectDir) {
-  return path.join(projectDir, '.vibe', 'metrics', 'current-run.jsonl');
-}
-
-function historyPath(projectDir) {
-  return path.join(projectDir, '.vibe', 'metrics', 'loop-history.jsonl');
-}
-
-/** 회전 마커 — `step-counter.js` 가 jsonl 앞부분을 잘라낼 때 남긴다 */
-function rotationMarkerPath(projectDir) {
-  return path.join(projectDir, '.vibe', 'metrics', 'current-run-rotation.json');
-}
-
-/**
- * 창의 앞부분이 회전으로 사라졌는가.
- *
- * **추측하지 않고 마커를 읽는다.** "로그의 첫 줄이 창 시작보다 뒤" 라는 추측은 회전이
- * 없어도 항상 참이다 — 창 시작 직후에 툴콜이 없었을 뿐일 수 있다. 그 추측으로 두면
- * 멀쩡한 회전이 전부 `truncated` 로 찍혀 합계에서 조용히 빠진다. 재지 못한 것을 0 으로
- * 적지 않으려다 잰 것까지 버리는 셈이다.
- *
- * @param {string} projectDir
- * @param {string} startTs 창 시작 ISO-8601
- * @returns {boolean}
- */
-function windowTruncated(projectDir, startTs) {
-  try {
-    const marker = JSON.parse(fs.readFileSync(rotationMarkerPath(projectDir), 'utf-8'));
-    return Boolean(marker && marker.keptFrom && marker.keptFrom > startTs);
-  } catch {
-    return false; // 마커 없음 = 회전 없음
-  }
-}
-
-function readJsonLines(filePath) {
-  const raw = fs.readFileSync(filePath, 'utf-8');
-  const out = [];
-  for (const line of raw.split('\n')) {
-    if (!line) continue;
-    try { out.push(JSON.parse(line)); } catch { /* 손상된 줄 무시 */ }
-  }
-  return out;
-}
-
-/**
- * 회전 창의 시작 시각 — 직전 `iteration`, 없으면 직전 `start`.
- *
- * 별도 신호를 만들지 않는 이유: 원장이 이미 두 시각을 갖고 있다. 새 신호를 만들면
- * 그것이 기록되지 않는 경로가 생기고, 그 경로에서 계측이 조용히 죽는다.
- *
- * @param {string} projectDir
- * @param {string} loop
- * @returns {string|null} ISO-8601, 판단 불가면 null
- */
-export function windowStart(projectDir, loop) {
-  try {
-    const events = readJsonLines(historyPath(projectDir)).filter((e) => e && e.loop === loop);
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-      if (events[i].event === 'iteration' || events[i].event === 'start') {
-        return events[i].ts || null;
-      }
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * 창은 `(startTs, endTs]` **반열림**이다.
- *
- * 경계에 정확히 걸친 호출을 앞 회전 몫으로 두어야 이중 계수가 나지 않는다 — 직전
- * 회전의 창은 그 시각을 끝으로 포함해 이미 세었다. 같은 밀리초 충돌은 실제로 일어난다.
- */
-function countInWindow(entries, startTs, endTs) {
-  let toolCalls = 0;
-  let subagents = 0;
-  for (const entry of entries) {
-    const ts = entry && entry.ts;
-    if (!ts || !entry.tool || ts <= startTs || ts > endTs) continue;
-    toolCalls += 1;
-    if (SUBAGENT_TOOLS.has(entry.tool)) subagents += 1;
-  }
-  return { toolCalls, subagents };
-}
-
-/** 재지 못한 회전 — 0 이 아니라 null 로 남긴다 */
-function unmeasured(elapsedMs, reason) {
-  return { measured: false, reason, elapsedMs, toolCalls: null, subagents: null, truncated: false };
-}
-
-/**
- * 이번 회전의 비용을 잰다.
- *
- * `elapsedMs` 는 툴 로그와 무관하게 원장 `ts` 만으로 나오므로 로그가 없어도 계산한다.
- *
- * @param {string} projectDir
- * @param {string} loop
- * @param {string} [endTs] 회전 종료 시각 ISO-8601 (기본: 지금)
- * @returns {{ measured: boolean, reason?: string, elapsedMs: number|null,
- *            toolCalls: number|null, subagents: number|null, truncated: boolean }}
- */
-export function measureIterationCost(projectDir, loop, endTs) {
-  const end = endTs || new Date().toISOString();
-  let elapsedMs = null;
-  try {
-    const start = windowStart(projectDir, loop);
-    if (start) elapsedMs = Math.max(0, Date.parse(end) - Date.parse(start));
-
-    if (!start) return unmeasured(elapsedMs, 'no-window-start');
-    const logPath = toolLogPath(projectDir);
-    if (!fs.existsSync(logPath)) return unmeasured(elapsedMs, 'no-tool-log');
-
-    const entries = readJsonLines(logPath);
-    if (entries.length === 0) return unmeasured(elapsedMs, 'empty-tool-log');
-
-    // 로그가 회전해 창의 앞부분이 사라졌으면 이 회전의 수치는 하한이다
-    const truncated = windowTruncated(projectDir, start);
-    const { toolCalls, subagents } = countInWindow(entries, start, end);
-    return { measured: true, elapsedMs, toolCalls, subagents, truncated };
-  } catch {
-    return unmeasured(elapsedMs, 'measure-failed');
-  }
-}
-
-/**
- * 회전별 비용을 합산한다.
- *
- * 미측정·절단 회전은 **합계에서 뺀다.** 대신 `measuredIterations` 로 분모를 함께 낸다 —
- * 분모를 모르면 합계는 거짓말이 된다 ("5회전에 도구 20회" 인지 "그중 2회전만 잰 20회" 인지).
- *
- * @param {Array<{cost?: object}>} iterationEvents
- * @returns {{ measuredIterations: number, unmeasuredIterations: number,
- *            elapsedMs: number, toolCalls: number, subagents: number }}
- */
-export function sumIterationCosts(iterationEvents) {
-  const total = {
-    measuredIterations: 0, unmeasuredIterations: 0, elapsedMs: 0, toolCalls: 0, subagents: 0,
-  };
-  for (const event of iterationEvents) {
-    const cost = event && event.cost;
-    if (!cost || cost.measured !== true || cost.truncated === true) {
-      total.unmeasuredIterations += 1;
-      continue;
-    }
-    total.measuredIterations += 1;
-    total.elapsedMs += Number(cost.elapsedMs) || 0;
-    total.toolCalls += Number(cost.toolCalls) || 0;
-    total.subagents += Number(cost.subagents) || 0;
-  }
-  return total;
-}

package/hooks/scripts/lib/loop-ledger.js

@@ -1,250 +0,0 @@
-/**
- * Loop Ledger 라이브러리 — 루프 실행 이력 추적 및 stuck 감지.
- *
- * 파일 위치: <projectDir>/.vibe/metrics/loop-history.jsonl
- * 형식: JSON Lines — 각 줄이 독립적인 루프 이벤트 JSON 객체
- *
- * 모든 함수는 fail-open (try/catch, 오류 시 무시하거나 안전한 기본값 반환).
- * isStuck: 같은 루프의 가장 최근 discover 이벤트의 discoverHash가
- *   신규 hash와 같으면 stuck으로 판정한다 (2회 연속 동일 발견).
- *   discover 이벤트는 CLI check-stuck이 판정 직후 스스로 기록한다 —
- *   기록 없는 판정은 다음 실행의 비교 기준을 잃는다.
- */
-
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-import { measureIterationCost, sumIterationCosts } from './iteration-cost.js';
-
-/** 루프 이력 파일 경로 */
-function historyPath(projectDir) {
-  return path.join(projectDir, '.vibe', 'metrics', 'loop-history.jsonl');
-}
-
-/**
- * discover 산출물 텍스트를 sha256 hex 해시로 변환한다.
- * 공백/줄바꿈을 정규화해 동등한 출력이 동일 해시를 갖도록 한다.
- *
- * @param {string} text
- * @returns {string} sha256 hex
- */
-export function hashDiscoverOutput(text) {
-  const normalized = text.replace(/\s+/g, ' ').trim();
-  return crypto.createHash('sha256').update(normalized, 'utf-8').digest('hex');
-}
-
-/**
- * 루프 이벤트를 jsonl 파일에 append한다.
- *
- * @param {string} projectDir
- * @param {{ loop: string, event: 'start'|'discover'|'end'|'iteration'|'trial-approved', result?: 'ok'|'fail'|'stuck', summary?: string, discoverHash?: string, verified?: boolean, cost?: object }} opts
- * @returns {boolean} 성공 여부
- */
-export function appendLoopEvent(projectDir, opts) {
-  try {
-    const p = historyPath(projectDir);
-    fs.mkdirSync(path.dirname(p), { recursive: true });
-    const entry = {
-      ts: new Date().toISOString(),
-      loop: opts.loop,
-      event: opts.event,
-      ...(opts.result !== undefined ? { result: opts.result } : {}),
-      ...(opts.summary !== undefined ? { summary: opts.summary } : {}),
-      ...(opts.discoverHash !== undefined ? { discoverHash: opts.discoverHash } : {}),
-      ...(opts.verified !== undefined ? { verified: opts.verified } : {}),
-      ...(opts.cost !== undefined ? { cost: opts.cost } : {}),
-    };
-    fs.appendFileSync(p, JSON.stringify(entry) + '\n', 'utf-8');
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * 지정 루프의 특정 이벤트 목록을 최신순으로 읽는다.
- * 손상된 줄은 건너뛴다 (fail-open).
- *
- * @param {string} projectDir
- * @param {string} loop
- * @param {string} eventType
- * @returns {{ ts: string, discoverHash?: string }[]}
- */
-function readEventsOfType(projectDir, loop, eventType) {
-  try {
-    const p = historyPath(projectDir);
-    if (!fs.existsSync(p)) return [];
-    const lines = fs.readFileSync(p, 'utf-8').split('\n').filter(Boolean);
-    const events = [];
-    for (const line of lines) {
-      try {
-        const obj = JSON.parse(line);
-        if (obj.loop === loop && obj.event === eventType) {
-          events.push(obj);
-        }
-      } catch {
-        // 손상된 줄 무시
-      }
-    }
-    // 최신순 정렬 (ts 기준)
-    return events.sort((a, b) => (a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * 신규 discoverHash가 stuck 조건을 충족하는지 판정한다.
- *
- * stuck 조건: 신규 hash가 non-empty이고, 해당 루프의 가장 최근
- * discover 이벤트에 동일한 discoverHash가 있을 때.
- * (직전 실행의 발견 + 이번 발견 = 2회 연속 동일이 되는 시점)
- *
- * 주의: 판정만 하고 기록하지 않으면 다음 실행이 비교할 기준이 없다 —
- * 호출자는 판정 직후 event:'discover'로 해시를 기록해야 한다 (CLI check-stuck이 수행).
- *
- * @param {string} projectDir
- * @param {string} loop
- * @param {string} discoverHash
- * @returns {boolean}
- */
-export function isStuck(projectDir, loop, discoverHash) {
-  try {
-    if (!discoverHash) return false;
-    const discoverEvents = readEventsOfType(projectDir, loop, 'discover');
-    if (discoverEvents.length === 0) return false;
-    const lastHash = discoverEvents[0].discoverHash;
-    return Boolean(lastHash && lastHash === discoverHash);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * 회전 1회를 기록한다.
- *
- * 비용은 **기록 시점에 재서 원장에 박는다.** 나중에 파생하지 않는 이유: 툴 로그
- * (`current-run.jsonl`)는 2MB/5000줄에서 회전하므로 과거 창은 이미 사라졌을 수 있고,
- * 그러면 조용히 낮은 값이 나온다. 계측은 재지 못한 것을 0 으로 채우지 않는 것이 절반이다.
- *
- * 계측은 append 보다 **먼저** 한다 — 창의 끝이 이번 회전이므로, 이 이벤트가 이력에
- * 들어간 뒤에 재면 창이 자기 자신에서 시작한다.
- *
- * @param {string} projectDir
- * @param {string} loop
- * @param {boolean} verified - 이 회전이 검증을 통과했는가 (JUDGE 결정론 게이트 기준)
- * @returns {boolean}
- */
-export function recordIteration(projectDir, loop, verified) {
-  let cost;
-  try {
-    cost = measureIterationCost(projectDir, loop);
-  } catch {
-    cost = undefined; // fail-open — 계측 실패가 회전 기록을 막지 않는다
-  }
-  return appendLoopEvent(projectDir, {
-    loop, event: 'iteration', verified: Boolean(verified), ...(cost ? { cost } : {}),
-  });
-}
-
-/**
- * 현재 루프 실행의 예산 상태.
- *
- * 두 축을 **따로** 센다:
- *  - `iterations` — 모든 회전. `max_iterations` 와 비교하는 폭주 방어 축이다.
- *  - `verified`   — 검증을 통과한 회전만. 실제로 전진한 양이다.
- *
- * 둘을 하나로 뭉치면 "10회를 썼다" 는 알아도 "그중 8회가 헛돌았다" 는 모른다 —
- * 헛도는 루프와 원래 큰 작업을 구분할 수 없다. loop-contract 는 폭주 방어가
- * 모델의 양심이 아니라 코드여야 한다고 선언하는데, 정작 max_iterations 에는
- * 런타임 계수가 없어 모델이 스스로 세고 있었다 (감사 2026-08-10).
- *
- * 직전 `start` 이후만 센다 — 새 실행은 예산도 새로 시작한다.
- *
- * @param {string} projectDir
- * @param {string} loop
- * 세 번째 축(`cost`)은 **계측이지 판정이 아니다** — 예산 소진이나 stuck 을 좌우하지
- * 않는다. 재지 못하거나 창이 잘린 회전은 합계에서 빠지고 `cost.measuredIterations` 가
- * 분모를 알려준다. 분모를 모르면 합계는 거짓말이 된다.
- *
- * ⚠️ 이 수치로 "N% 절감" 같은 문구를 쓰지 않는다 — 비교 데이터가 쌓이기 전의
- * 배수·퍼센트는 constitution §3.5 가 금지하는 바로 그것이다. 쌓기만 한다.
- *
- * @param {number} [maxIterations=10]
- * @returns {{ iterations: number, verified: number, remaining: number, exhausted: boolean,
- *             cost: { measuredIterations: number, unmeasuredIterations: number,
- *                     elapsedMs: number, toolCalls: number, subagents: number } }}
- */
-export function readBudget(projectDir, loop, maxIterations = 10) {
-  const emptyCost = {
-    measuredIterations: 0, unmeasuredIterations: 0, elapsedMs: 0, toolCalls: 0, subagents: 0,
-  };
-  const empty = {
-    iterations: 0, verified: 0, remaining: maxIterations, exhausted: false, cost: emptyCost,
-  };
-  try {
-    const raw = fs.readFileSync(historyPath(projectDir), 'utf-8');
-    const events = raw.split('\n')
-      .map(line => { try { return JSON.parse(line); } catch { return null; } })
-      .filter(e => e && e.loop === loop);
-
-    const lastStart = events.map(e => e.event).lastIndexOf('start');
-    const scoped = lastStart === -1 ? events : events.slice(lastStart);
-
-    const iters = scoped.filter(e => e.event === 'iteration');
-    const iterations = iters.length;
-    const verified = iters.filter(e => e.verified === true).length;
-    const remaining = Math.max(0, maxIterations - iterations);
-    return {
-      iterations, verified, remaining, exhausted: remaining === 0, cost: sumIterationCosts(iters),
-    };
-  } catch {
-    return empty;
-  }
-}
-
-/**
- * 시운전 게이트 — 처음 거는 루프는 **두 바퀴만** 돌고 멈춘다.
- *
- * WHY: 자율 루프의 첫 실행은 정의가 맞는지 아무도 모르는 상태다. discover 가
- * 엉뚱한 것을 긁거나 verify 기준이 틀려 있으면 루프는 그걸 **성실하게 반복**한다.
- * 사람이 안 보는 동안 도는 것이 목적이므로, 틀린 채로 도는 것도 안 보인다.
- * 그래서 처음에는 몇 바퀴만 돌려 기록을 눈으로 확인한 뒤 풀어준다.
- *
- * `max_iterations` 와는 다른 축이다 — 그건 **한 실행의 폭주**를 막고, 이건
- * **정의가 검증되지 않은 루프**를 막는다. 폭주 예산은 매 `start` 마다 초기화되지만
- * 시운전은 승인 전까지 계속 걸린다.
- *
- * 승인은 이력에 남긴다(`event: 'trial-approved'`) — 설정 파일이 아니라 원장에
- * 두는 이유는 루프별로 다르고, 언제 누가 풀었는지가 감사 대상이기 때문이다.
- *
- * @param {string} projectDir
- * @param {string} loop
- * @param {number} [trialIterations=2] 시운전 회전 수
- * @returns {{ inTrial: boolean, cap: number|null, iterations: number, exhausted: boolean }}
- */
-export function readTrialGate(projectDir, loop, trialIterations = 2) {
-  const cap = Math.max(1, Number(trialIterations) || 2);
-  try {
-    const raw = fs.readFileSync(historyPath(projectDir), 'utf-8');
-    const events = raw.split('\n')
-      .map(line => { try { return JSON.parse(line); } catch { return null; } })
-      .filter(e => e && e.loop === loop);
-
-    if (events.some(e => e.event === 'trial-approved')) {
-      return { inTrial: false, cap: null, iterations: 0, exhausted: false };
-    }
-
-    // 시운전 회전은 실행을 가로질러 누적한다 — 매 start 마다 초기화되면
-    // 루프를 다시 걸기만 해도 시운전이 무한정 연장된다.
-    const iterations = events.filter(e => e.event === 'iteration').length;
-    return { inTrial: true, cap, iterations, exhausted: iterations >= cap };
-  } catch {
-    return { inTrial: true, cap, iterations: 0, exhausted: false };
-  }
-}
-
-/** 시운전을 풀어 이 루프를 정상 예산으로 돌린다 — 사람이 기록을 확인한 뒤 호출한다 */
-export function approveTrial(projectDir, loop) {
-  return appendLoopEvent(projectDir, { loop, event: 'trial-approved' });
-}

package/hooks/scripts/lib/pr-gate-runner.js

@@ -1,62 +0,0 @@
-/**
- * PR 테스트 게이트 공유 헬퍼 — pr-test-gate.js와 pre-tool-guard.js가 공용.
- *
- * 테스트 커맨드 감지 → 실행 → 결과 반환.
- * exit code를 직접 호출하지 않고 결과 객체를 반환한다 (호출자가 판단).
- */
-import { execSync } from 'child_process';
-import { existsSync, readFileSync } from 'fs';
-import path from 'path';
-
-/**
- * 프로젝트에서 실행할 테스트 커맨드를 감지한다.
- *
- * @param {string} projectDir
- * @returns {string|null}
- */
-export function detectTestCommand(projectDir) {
-  const pkgPath = path.join(projectDir, 'package.json');
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-      if (pkg.scripts?.test && pkg.scripts.test !== 'echo "Error: no test specified" && exit 1') {
-        return 'npm test';
-      }
-    } catch { /* ignore */ }
-  }
-  // Python
-  if (existsSync(path.join(projectDir, 'pytest.ini')) || existsSync(path.join(projectDir, 'pyproject.toml'))) {
-    return 'python -m pytest --tb=short -q';
-  }
-  // Go
-  if (existsSync(path.join(projectDir, 'go.mod'))) {
-    return 'go test ./...';
-  }
-  return null;
-}
-
-/**
- * 테스트 게이트를 실행한다.
- *
- * @param {string} projectDir
- * @returns {{ passed: boolean, testCmd: string|null, output: string }}
- *   testCmd=null 이면 테스트 없음 → passed=true (통과)
- */
-export function runPrTestGate(projectDir) {
-  const testCmd = detectTestCommand(projectDir);
-  if (!testCmd) {
-    return { passed: true, testCmd: null, output: '' };
-  }
-
-  try {
-    execSync(testCmd, {
-      cwd: projectDir,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout: 120000,
-    });
-    return { passed: true, testCmd, output: '' };
-  } catch (err) {
-    const output = err.stdout ? err.stdout.toString().split('\n').slice(-5).join('\n') : '';
-    return { passed: false, testCmd, output };
-  }
-}