@su-record/vibe 3.2.64 → 4.0.0

package/hooks/scripts/lib/dispatcher.js

@@ -1,204 +0,0 @@
-/**
- * Hook dispatcher library — 여러 hook script를 단일 이벤트에서 실행.
- *
- * 목적:
- * - stdin을 한 번만 읽어 각 자식에 동일 버퍼로 pipe (중복 파싱/읽기 방지)
- * - config.hooks[name].enabled 로 개별 토글
- * - 한 스크립트 실패가 다른 스크립트를 막지 않도록 cascade 격리
- * - PreToolUse 계열: 자식 중 하나라도 exit 2(deny)면 상위에 전파
- *
- * 실행 모델이 둘로 갈린다 — 스텝이 서로 독립인지가 기준:
- *
- *   dispatch()          = 순차 (spawn). 유일한 사용처인 Stop 은 스텝끼리
- *                         부작용을 공유한다(auto-commit 의 git 상태를
- *                         devlog-gen 이 읽는다). 병렬화하면 auto-commit 의
- *                         git cascade 와 겹쳐 프로세스가 폭주하고,
- *                         devlog 가 커밋 이전 상태를 관측한다.
- *                         회귀 방지: __tests__/stop-dispatcher-sequential.test.js
- *
- *   dispatchInProcess() = 병렬 (import). PreToolUse 가드는 모두 독립적
- *                         검증자라 순서가 의미 없고, 직렬 실행은 tool당
- *                         150~300ms 누적 오버헤드를 유발한다.
- *                         트레이드오프:
- *                           - early-deny 낭비: sentinel-guard가 block이어도
- *                             pre-tool/scope-guard가 이미 실행됨. 실측 μs 수준.
- *                           - stderr 인터리빙: 가드 2개가 동시 block 시 경고가
- *                             섞일 수 있음. 각 메시지가 완결된 라인이라 무해.
- */
-import { spawn } from 'child_process';
-import path from 'path';
-import fs from 'fs';
-import { fileURLToPath } from 'url';
-import { readStdinSync, buildCtx } from './hook-context.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SCRIPTS_DIR = path.resolve(__dirname, '..');
-
-function loadHookConfig() {
-  try {
-    const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-    // Vibe config 탐색 — `.vibe/` 를 SSOT 로 삼고, legacy `.claude/vibe/` fallback
-    const candidates = [
-      path.join(projectDir, '.vibe', 'config.json'),
-      path.join(projectDir, '.claude', 'vibe', 'config.json'),
-    ];
-    const configPath = candidates.find(p => fs.existsSync(p));
-    if (!configPath) return {};
-    return JSON.parse(fs.readFileSync(configPath, 'utf-8')).hooks || {};
-  } catch {
-    return {};
-  }
-}
-
-function isEnabled(hookConfig, name) {
-  const entry = hookConfig[name];
-  if (entry && typeof entry === 'object' && entry.enabled === false) return false;
-  return true;
-}
-
-/**
- * guard 크래시를 deny 로 승격할지 — `VIBE_HOOK_FAILCLOSED=0` 이면 끈다.
- *
- * fail-closed 는 "검증하지 못했으면 통과시키지 않는다" 는 안전한 기본값이지만,
- * guard 에 버그가 생기면 Edit·Bash 가 전면 차단되어 guard 소스를 고칠 수단까지
- * 막힌다. 그래서 탈출구는 선택이 아니라 **복구 유일 수단**이고, 차단 메시지가
- * 스스로 그 방법을 알려줘야 한다 (교착에 빠진 사용자는 문서를 찾아볼 수 없다).
- */
-function isFailClosed() {
-  return process.env.VIBE_HOOK_FAILCLOSED !== '0';
-}
-
-/**
- * step 크래시를 stderr 에 드러낸다. 침묵하면 게이트가 죽은 줄도 모른다.
- * @param {string} name
- * @param {unknown} err
- */
-function reportCrash(name, err) {
-  const message = (err && err.message) || String(err);
-  process.stderr.write(`[vibe] hook step "${name}" crashed: ${message}\n`);
-}
-
-/**
- * 크래시한 step 의 종료 코드를 정한다.
- * deny 권한(denyOnExit2)이 있는 guard 만 2(deny)로 승격한다 — 로깅용 step 하나가
- * 죽었다고 도구 호출을 막을 이유는 없다.
- * @param {{ name: string, denyOnExit2?: boolean }} step
- * @returns {number}
- */
-function crashExitCode(step) {
-  if (!step.denyOnExit2 || !isFailClosed()) return 1;
-  process.stderr.write(
-    `[vibe] blocked: guard "${step.name}" could not complete, so the operation was not verified.\n` +
-    `       To bypass temporarily, re-run with VIBE_HOOK_FAILCLOSED=0\n`
-  );
-  return 2;
-}
-
-async function readStdin() {
-  if (process.stdin.isTTY) return '';
-  let data = '';
-  for await (const chunk of process.stdin) data += chunk;
-  return data;
-}
-
-/**
- * 단일 스크립트 실행. stdin을 통해 입력 전달, stdout은 메인 stdout으로 통과.
- * @returns {Promise<number>} exit code
- */
-function runScript(scriptName, args, stdinData, timeoutMs) {
-  return new Promise((resolve) => {
-    const scriptPath = path.join(SCRIPTS_DIR, scriptName);
-    const env = buildChildEnv(stdinData);
-    const proc = spawn(process.execPath, [scriptPath, ...args], {
-      stdio: ['pipe', 'inherit', 'inherit'],
-      timeout: timeoutMs,
-      env,
-    });
-    if (stdinData) proc.stdin.end(stdinData);
-    else proc.stdin.end();
-    proc.on('close', (code) => resolve(code ?? 0));
-    proc.on('error', () => resolve(1));
-  });
-}
-
-function buildChildEnv(stdinData) {
-  const env = { ...process.env };
-  if (!stdinData) return env;
-
-  env.HOOK_INPUT = stdinData;
-  try {
-    const parsed = JSON.parse(stdinData);
-    if (parsed?.tool_input) {
-      env.TOOL_INPUT = typeof parsed.tool_input === 'string'
-        ? parsed.tool_input
-        : JSON.stringify(parsed.tool_input);
-    }
-  } catch {
-    // Leave legacy env untouched when stdin is not JSON.
-  }
-  return env;
-}
-
-/**
- * 디스패처 실행 — 활성화된 스텝을 선언 순서대로 **순차** spawn.
- *
- * 순차인 이유는 파일 상단 주석 참고 — 스텝이 git 상태 같은 부작용을 공유한다.
- * 앞 스텝이 실패해도 다음 스텝은 계속 실행한다(cascade 격리 유지).
- *
- * @param {Array<{name: string, script: string, args?: string[], denyOnExit2?: boolean, timeoutMs?: number}>} steps
- */
-export async function dispatch(steps) {
-  const stdinData = await readStdin();
-  const hookConfig = loadHookConfig();
-
-  const enabledSteps = steps.filter(s => isEnabled(hookConfig, s.name));
-  const results = [];
-  for (const step of enabledSteps) {
-    const code = await runScript(step.script, step.args || [], stdinData, step.timeoutMs || 30000);
-    results.push({ step, code });
-  }
-
-  // 하나라도 deny(exit 2) 반환 → 상위에 전파
-  if (results.some(({ step, code }) => step.denyOnExit2 && code === 2)) {
-    process.exit(2);
-  }
-}
-
-/**
- * in-process 디스패처 — 자식 spawn 없이 import된 run(ctx)들을 병렬 실행.
- *
- * spawn 대비:
- *   - 자식 node VM 기동(~20ms × N)과 stdin 재읽기/재파싱 제거
- *   - 크래시 격리는 step별 try/catch로 대체 (throw → exit 1 취급, fail-open)
- *   - step별 강제 timeout은 없음 — 무거운 작업(포매터/테스트러너)은 모두
- *     자체 timeout을 가진 비동기 자식 프로세스라 디스패처가 행 걸리지 않는다
- *
- * deny 시맨틱 보존: denyOnExit2 step이 2를 반환하면 process.exit(2)로 상위 전파.
- *
- * @param {Array<{name: string, run: (ctx: object) => Promise<number>, denyOnExit2?: boolean}>} steps
- * @param {{ argvToolName?: string }} [options]
- */
-export async function dispatchInProcess(steps, { argvToolName = '' } = {}) {
-  const { raw, parsed } = readStdinSync();
-  const ctx = buildCtx({ rawInput: raw, payload: parsed, argvToolName });
-  const hookConfig = loadHookConfig();
-
-  const enabledSteps = steps.filter(s => isEnabled(hookConfig, s.name));
-  const results = await Promise.all(
-    enabledSteps.map(async (step) => {
-      try {
-        return { step, code: await step.run(ctx) };
-      } catch (err) {
-        // 크래시 격리는 유지하되 침묵하지 않는다. deny 권한이 있는 guard 는
-        // 검증에 실패한 것이므로 통과시키지 않는다 (fail-closed).
-        reportCrash(step.name, err);
-        return { step, code: crashExitCode(step) };
-      }
-    })
-  );
-
-  // 하나라도 deny(exit 2) 반환 → 상위에 전파
-  if (results.some(({ step, code }) => step.denyOnExit2 && code === 2)) {
-    process.exit(2);
-  }
-}

package/hooks/scripts/lib/ephemeral-lane.js

@@ -1,106 +0,0 @@
-/**
- * 일회성 코드 레인 — 생성·실행 후 폐기되는 코드에 durable 코드의 무게를 지우지 않는다.
- *
- * ## 이 파일이 대부분 방어인 이유
- *
- * 이 레인은 원래 "열지 말자" 로 판단했던 것이다. 사유 둘 중 하나가 **게이트 회피 구멍**이었다:
- * "이건 일회성이라 린트 면제" 를 모델이 판정하면 축이 아니라 뒷문이고, 뒷문은 바쁠 때 쓰인다.
- *
- * 그래서 단 하나의 규칙으로 막는다: **판정을 모델이 아니라 경로가 한다.**
- * 경로가 판정하면 면제 대상이 `ls` 하나로 감사되고, 그 경로는 커밋될 수 없다.
- *
- * ## 방어 순서 (과장하지 않는다)
- *
- * 1. **`.gitignore`** — 1차 방어. `git add` 는 무시된 경로를 그냥 거부한다
- * 2. **`pre-tool-guard`** — 심층 방어. 실제로 뚫리는 경로는 `git add -f` 하나뿐이고 그것을 막는다.
- *    훅은 프로젝트 로컬이라 미설치가 흔하므로 이것을 1차라고 부르지 않는다
- *
- * ## fail-safe (fail-open 아님)
- *
- * 훅은 보통 fail-open 이다 — 판정 실패가 작업을 막지 않는다. 여기는 반대로 판정에 실패하면
- * **일회성이 아니라고 답한다.** 모르면 면제하지 않는 쪽이 안전하다: 잘못된 면제는 조용히
- * 품질 게이트를 끄지만, 잘못된 비면제는 검사가 한 번 더 도는 것뿐이다.
- */
-
-import path from 'path';
-
-/** 유일한 일회성 경로 — 설정으로 열지 않는다. 설정 가능한 면제 경로는 프로젝트마다 다른 뒷문이 된다 */
-export const EPHEMERAL_DIR = '.vibe/ephemeral';
-
-/**
- * 프로젝트 기준 상대 경로로 정규화한다 (구분자 통일 + `..` 해소 + 절대/상대 통일).
- *
- * `path.resolve` 로 양쪽을 절대 경로로 만든 뒤 `path.relative` 를 쓴다 — 문자열 접두사
- * 비교로는 부족하다. 훅의 `PROJECT_DIR` 은 `CLAUDE_PROJECT_DIR` 미설정 시 `'.'` 이라
- * (utils.js), 접두사만 보면 절대 경로로 들어온 파일이 프로젝트 밖으로 판정된다.
- */
-function toProjectRelative(filePath, projectDir) {
-  const normalized = String(filePath).replace(/\\/g, '/');
-  const base = path.resolve(String(projectDir || '.').replace(/\\/g, '/'));
-  return path.relative(base, path.resolve(base, normalized)).replace(/\\/g, '/');
-}
-
-/**
- * 이 경로가 일회성 레인 안인가.
- *
- * **정규화 후** 접두사를 본다 — `.vibe/ephemeral/../src/x.ts` 는 `.vibe/src/x.ts` 가 되어
- * 거짓이다. 상위 탈출로 면제를 훔칠 수 없어야 한다.
- *
- * @param {string} filePath
- * @param {string} [projectDir] 주면 그 아래 절대 경로도 인식한다
- * @returns {boolean}
- */
-export function isEphemeralPath(filePath, projectDir) {
-  try {
-    if (!filePath) return false;
-    const rel = toProjectRelative(filePath, projectDir);
-    if (!rel || rel.startsWith('../') || path.isAbsolute(rel)) return false; // 프로젝트 밖
-    return rel === EPHEMERAL_DIR || rel.startsWith(`${EPHEMERAL_DIR}/`);
-  } catch {
-    return false; // fail-safe — 모르면 면제하지 않는다
-  }
-}
-
-/** `git add|stage|commit` 구간의 인자만 훑는다 (`;`·`&&`·`|` 로 끊는다) */
-const GIT_STAGING_RE = /\bgit\s+(?:add|stage|commit)\b([^;&|]*)/gi;
-
-/** 한 git 구간의 인자에서 일회성 경로만 고른다 (중첩을 얕게 유지하려고 분리했다) */
-function ephemeralArgsIn(segment) {
-  const found = [];
-  for (const rawArg of String(segment).split(/\s+/)) {
-    const arg = rawArg.replace(/^["']|["']$/g, '').trim();
-    if (arg && !arg.startsWith('-') && isEphemeralPath(arg)) found.push(arg);
-  }
-  return found;
-}
-
-/**
- * git 스테이징 명령줄에서 일회성 경로를 뽑는다.
- *
- * `git add .` · `git add -A` 는 걸러내지 않는다 — gitignore 가 이미 거르고, 여기서 막으면
- * 정상 커밋이 전부 멈춘다. 멈추는 게이트는 꺼진다.
- *
- * @param {string} command
- * @returns {string[]} 명령에 명시된 일회성 경로들
- */
-export function ephemeralPathsInGitCommand(command) {
-  try {
-    const found = [];
-    for (const match of String(command || '').matchAll(GIT_STAGING_RE)) {
-      found.push(...ephemeralArgsIn(match[1]));
-    }
-    return found;
-  } catch {
-    return []; // fail-safe — 판정 실패가 커밋을 막지 않는다
-  }
-}
-
-/** 차단 메시지 — 이유 없는 차단은 우회된다. 무엇을·왜·대안을 함께 낸다 */
-export function formatEphemeralBlock(paths) {
-  return [
-    `[EPHEMERAL] 일회성 경로를 커밋하려 한다: ${paths.join(', ')}`,
-    `  ${EPHEMERAL_DIR}/ 는 생성·실행 후 폐기되는 코드의 자리다. 품질 게이트를 면제받는 대신`,
-    '  커밋되지 않는다 — 면제받은 코드가 배포되면 그 면제가 곧 구멍이 된다.',
-    '  남겨야 하는 코드라면 이 경로 밖으로 옮기고 평소 게이트를 통과시켜라.',
-  ].join('\n');
-}

package/hooks/scripts/lib/gates.js

@@ -1,138 +0,0 @@
-/**
- * 사람 판단 게이트 — 대기 중인 질문을 디스크에 남긴다.
- *
- * 배경: vibe 의 사람 개입 지점(SPEC 승인 · stuck 질문 · 비용 게이트)은 전부
- * 모델이 그 자리에서 만들어 출력하는 텍스트였다. 세션이 죽거나 컨텍스트가
- * 압축되면 **무엇을 묻고 있었는지가 사라진다** — 사람은 돌아왔는데 답할 대상이
- * 없다. run-ledger·loop-history·인박스가 전부 디스크에 사는데 정작 "지금 사람을
- * 기다리는 이유"만 컨텍스트에 살고 있었다.
- *
- * 게이트는 **모호한 상태가 아니라 구체적 질문**을 담는다. "승인 대기" 는 게이트가
- * 아니다 — 무엇을 묻는지, 어떤 선택지가 있는지, 답이 무엇을 바꾸는지가 있어야
- * 다음 턴(또는 다음 사람)이 이어받을 수 있다.
- *
- * 저장: `.vibe/gates/<id>.json` — 파일 하나가 게이트 하나. 동시에 여러 루프가
- * 게이트를 열어도 서로 덮어쓰지 않는다.
- *
- * fail-open — 기록 실패가 루프를 멈추지 않는다.
- */
-import fs from 'fs';
-import path from 'path';
-import { projectVibePath, projectVibePathPreferred } from '../utils.js';
-
-/** 읽기용 게이트 디렉토리 (레거시 인식) */
-export function gatesDir(projectDir) {
-  return projectVibePath(projectDir, 'gates');
-}
-
-/** 쓰기용 게이트 디렉토리 — 항상 신규 레이아웃 */
-function gatesWriteDir(projectDir) {
-  return projectVibePathPreferred(projectDir, 'gates');
-}
-
-/** 파일명에 쓸 수 있는 형태로 정규화 — 경로 이탈 방지 */
-function safeId(id) {
-  return String(id).replace(/[^a-zA-Z0-9._-]/g, '-').slice(0, 80);
-}
-
-/**
- * 게이트를 연다.
- *
- * @param {string} projectDir
- * @param {{
- *   id: string,
- *   question: string,
- *   options?: string[],
- *   kind?: 'spec-approval'|'stuck'|'cost'|'other',
- *   context?: Record<string, unknown>,
- *   at: string,
- * }} gate - `at` 은 호출자가 넘긴다 (이 모듈은 시각을 읽지 않는다 — 테스트 결정성)
- * @returns {string|null} 기록된 파일 경로, 실패 시 null
- */
-export function openGate(projectDir, gate) {
-  try {
-    if (!gate?.id || !gate?.question || !gate?.at) return null;
-    // 구체적 질문이 아니면 게이트가 아니다 — 빈 질문·모호한 상태 문구를 거른다
-    if (gate.question.trim().length < 5) return null;
-
-    const dir = gatesWriteDir(projectDir);
-    fs.mkdirSync(dir, { recursive: true });
-    const file = path.join(dir, `${safeId(gate.id)}.json`);
-
-    const record = {
-      id: gate.id,
-      kind: gate.kind ?? 'other',
-      question: gate.question,
-      options: Array.isArray(gate.options) ? gate.options : [],
-      context: gate.context ?? {},
-      status: 'open',
-      openedAt: gate.at,
-    };
-    fs.writeFileSync(file, JSON.stringify(record, null, 2) + '\n', 'utf-8');
-    return file;
-  } catch {
-    return null;
-  }
-}
-
-/** 게이트 파일 하나를 읽는다. 손상된 파일은 무시한다. */
-function readGate(file) {
-  try {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
-    return parsed && typeof parsed === 'object' ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * 열려 있는 게이트 목록 — 오래된 것부터.
- * @returns {Array<object>}
- */
-export function listOpenGates(projectDir) {
-  try {
-    const dir = gatesDir(projectDir);
-    return fs.readdirSync(dir)
-      .filter(f => f.endsWith('.json'))
-      .map(f => readGate(path.join(dir, f)))
-      .filter(g => g && g.status === 'open')
-      .sort((a, b) => String(a.openedAt).localeCompare(String(b.openedAt)));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * 게이트에 답한다 — 파일은 남기고 status 만 바꾼다.
- * 지우지 않는 이유: 무엇을 물었고 무엇으로 답했는지가 증거다.
- *
- * @returns {boolean} 성공 여부
- */
-export function answerGate(projectDir, id, answer, at) {
-  try {
-    if (!id || !answer || !at) return false;
-    const file = path.join(gatesDir(projectDir), `${safeId(id)}.json`);
-    const gate = readGate(file);
-    if (!gate || gate.status !== 'open') return false;
-
-    fs.writeFileSync(
-      file,
-      JSON.stringify({ ...gate, status: 'answered', answer, answeredAt: at }, null, 2) + '\n',
-      'utf-8',
-    );
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** 사람이 읽는 요약 — 스킬이 그대로 출력한다 */
-export function formatOpenGates(gates) {
-  if (gates.length === 0) return '열린 게이트 없음';
-  return gates.map(g => {
-    const opts = g.options.length > 0
-      ? '\n' + g.options.map((o, i) => `     [${i + 1}] ${o}`).join('\n')
-      : '';
-    return `⏸️ ${g.id} (${g.kind}, ${g.openedAt})\n   ${g.question}${opts}`;
-  }).join('\n\n');
-}

package/hooks/scripts/lib/glob.js

@@ -1,32 +0,0 @@
-/**
- * 경량 glob → RegExp 변환 — code-check.js·scope-guard.js 공용 (중복 제거).
- *  - `**` : 경로 구분자 포함 임의 문자열
- *  - `*`  : 구분자 제외 임의 문자열
- *  - `?`  : 구분자 제외 한 글자
- *  - 기타 정규식 메타문자는 이스케이프
- * @param {string} glob
- * @returns {RegExp}
- */
-export function globToRegExp(glob) {
-  const normalized = glob.replace(/\\/g, '/');
-  let out = '';
-  for (let i = 0; i < normalized.length; i++) {
-    const c = normalized[i];
-    if (c === '*') {
-      if (normalized[i + 1] === '*') {
-        out += '.*';
-        i++;
-        if (normalized[i + 1] === '/') i++; // `**/` → `.*`
-      } else {
-        out += '[^/]*';
-      }
-    } else if (c === '?') {
-      out += '[^/]';
-    } else if ('.+^$()|{}[]\\'.includes(c)) {
-      out += '\\' + c;
-    } else {
-      out += c;
-    }
-  }
-  return new RegExp('^' + out + '$');
-}

package/hooks/scripts/lib/hook-context.js

@@ -1,147 +0,0 @@
-/**
- * Hook 실행 컨텍스트 공용 헬퍼 — in-process 평탄화의 기반.
- *
- * 훅 스크립트는 두 모드로 실행된다:
- *   1. in-process: 디스패처가 stdin을 1회 읽고 buildCtx()로 만든 ctx를
- *      각 스크립트의 run(ctx)에 직접 전달 (자식 spawn 없음)
- *   2. standalone CLI: antigravity-hooks.json / 기존 테스트가 스크립트를
- *      직접 실행 — isDirectRun()으로 감지해 stdin/argv/env에서 ctx를 구성
- *
- * ctx 형태: { toolName, toolInput, payload, hookInput, filePath }
- *   - toolName: payload.tool_name 우선, argv 폴백 (현행 각 스크립트와 동일 우선순위)
- *   - toolInput: 문자열 정규화된 tool_input (payload → argv[3] → env.TOOL_INPUT)
- *   - payload: 파싱된 stdin JSON 또는 null
- *   - hookInput: stdin 원문 문자열 (code-check의 HOOK_INPUT 사용처 대체)
- *   - filePath: toolInput 에서 뽑은 대상 파일 경로 (file_path → notebook_path →
- *     path 우선순위 — 각 스크립트의 인라인 추출 로직과 동일 규약)
- */
-import fs from 'fs';
-import { pathToFileURL } from 'url';
-
-/** stdin을 EOF까지 읽을 때 허용하는 최대 바이트 수 (10MB). */
-const STDIN_MAX_BYTES = 10 * 1024 * 1024;
-
-/** EAGAIN 재시도 간격/데드라인 — non-blocking pipe에서 writer가 아직 flush 전일 수 있다. */
-const STDIN_EAGAIN_RETRY_MS = 5;
-const STDIN_EAGAIN_DEADLINE_MS = 500;
-
-/** 동기 sleep (Atomics.wait — 이벤트 루프 없이 대기). */
-const sleepBuf = new Int32Array(new SharedArrayBuffer(4));
-function sleepSync(ms) {
-  Atomics.wait(sleepBuf, 0, 0, ms);
-}
-
-/** 누적 청크가 완전한 JSON인지 검사 — EAGAIN 시 조기 종료 판단용. */
-function isCompleteJson(chunks) {
-  try {
-    JSON.parse(Buffer.concat(chunks).toString('utf-8'));
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * stdin에서 JSON 페이로드 동기 읽기 (Claude Code 하네스 호환).
- * fd 0 직접 사용 — Windows는 '/dev/stdin'이 없음.
- * 64KB 단일 버퍼 대신 EOF까지 청크 반복 읽기 (STDIN_MAX_BYTES 상한).
- *
- * @returns {{ raw: string|null, parsed: object|null, truncated: boolean }}
- *   truncated=true: 페이로드가 STDIN_MAX_BYTES를 초과해 잘림
- */
-export function readStdinSync() {
-  try {
-    if (process.stdin.isTTY) return { raw: null, parsed: null, truncated: false };
-
-    const chunks = [];
-    let totalBytes = 0;
-    let truncated = false;
-    const chunkSize = 65536;
-    const chunkBuf = Buffer.alloc(chunkSize);
-
-    let lastProgress = Date.now();
-    while (true) {
-      let bytesRead;
-      try {
-        bytesRead = fs.readSync(0, chunkBuf, 0, chunkSize, null);
-      } catch (err) {
-        // EAGAIN: 파이프가 *지금* 비었을 뿐 EOF가 아닐 수 있다 (writer가 flush 전).
-        // EOF로 취급하면 대용량 페이로드가 중간에 끊겨 가드가 fail-open된다 —
-        // 완전한 JSON이 모였거나 데드라인이 지나기 전까지 재시도한다.
-        if (err.code === 'EAGAIN') {
-          if (chunks.length > 0 && isCompleteJson(chunks)) break;
-          if (Date.now() - lastProgress > STDIN_EAGAIN_DEADLINE_MS) break;
-          sleepSync(STDIN_EAGAIN_RETRY_MS);
-          continue;
-        }
-        throw err;
-      }
-      if (bytesRead === 0) break;
-      lastProgress = Date.now();
-      totalBytes += bytesRead;
-      if (totalBytes > STDIN_MAX_BYTES) {
-        truncated = true;
-        break;
-      }
-      chunks.push(Buffer.from(chunkBuf.subarray(0, bytesRead)));
-    }
-
-    if (chunks.length === 0) return { raw: null, parsed: null, truncated: false };
-
-    const raw = Buffer.concat(chunks).toString('utf-8');
-    try {
-      return { raw, parsed: JSON.parse(raw), truncated };
-    } catch {
-      return { raw, parsed: null, truncated };
-    }
-  } catch { /* stdin 없음 → 폴백 */ }
-  return { raw: null, parsed: null, truncated: false };
-}
-
-/**
- * toolInput(문자열화된 JSON)에서 대상 파일 경로 추출.
- * 각 훅 스크립트의 인라인 추출과 동일 우선순위: file_path → notebook_path → path.
- * @param {string} toolInput
- * @returns {string}
- */
-function extractFilePath(toolInput) {
-  try {
-    const parsed = JSON.parse(toolInput || '{}');
-    return parsed.file_path || parsed.notebook_path || parsed.path || '';
-  } catch {
-    return '';
-  }
-}
-
-/**
- * 실행 컨텍스트 구성. 우선순위는 현행 스크립트들과 동일:
- *   toolName: payload.tool_name → argvToolName
- *   toolInput: payload.tool_input(문자열화) → argv[3] → env.TOOL_INPUT
- */
-export function buildCtx({ rawInput = null, payload = null, argvToolName = '', argvToolInput = '' } = {}) {
-  const toolName = payload?.tool_name || argvToolName || '';
-  const toolInput = payload?.tool_input !== undefined && payload?.tool_input !== null
-    ? (typeof payload.tool_input === 'string' ? payload.tool_input : JSON.stringify(payload.tool_input))
-    : (argvToolInput || process.env.TOOL_INPUT || '');
-  return { toolName, toolInput, payload, hookInput: rawInput, filePath: extractFilePath(toolInput) };
-}
-
-/** standalone CLI 모드용 ctx — stdin/argv/env에서 구성 */
-export function buildCliCtx() {
-  const { raw, parsed } = readStdinSync();
-  return buildCtx({
-    rawInput: raw ?? process.env.HOOK_INPUT ?? null,
-    payload: parsed,
-    argvToolName: process.argv[2] || '',
-    argvToolInput: process.argv[3] || '',
-  });
-}
-
-/** 모듈이 `node <file>`로 직접 실행됐는지 감지 (import 시 false) */
-export function isDirectRun(importMetaUrl) {
-  try {
-    return Boolean(process.argv[1]) && importMetaUrl === pathToFileURL(process.argv[1]).href;
-  } catch {
-    return false;
-  }
-}