@su-record/vibe 2.13.0 → 2.14.0

package/hooks/scripts/__tests__/keyword-detector.test.js

@@ -27,28 +27,30 @@ function runDetector(text) {
 // ══════════════════════════════════════════════════
 describe('keyword-detector', () => {
   describe('ralph keyword', () => {
-    it('should detect ralph keyword', () => {
+    it('should detect ralph keyword and emit deprecation hint', () => {
       const result = runDetector('implement the login feature ralph');
-      expect(result.stdout).toContain('[RALPH MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
       expect(result.stdout).toContain('persistence');
     });
 
     it('should detect ralph case-insensitively', () => {
       const result = runDetector('RALPH fix all the bugs');
-      expect(result.stdout).toContain('[RALPH MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
     });
   });
 
   describe('ultrawork keyword', () => {
-    it('should detect ultrawork keyword', () => {
+    it('should detect ultrawork keyword and emit automationLevel banner', () => {
       const result = runDetector('ultrawork build the entire app');
-      expect(result.stdout).toContain('[ULTRAWORK MODE]');
+      expect(result.stdout).toContain('[ULTRAWORK]');
       expect(result.stdout).toContain('parallel');
     });
 
     it('should detect ulw alias', () => {
       const result = runDetector('ulw refactor the codebase');
-      expect(result.stdout).toContain('[ULTRAWORK MODE]');
+      expect(result.stdout).toContain('[ULTRAWORK]');
     });
 
     it('should detect Korean alias when word boundary matches', () => {
@@ -74,28 +76,32 @@ describe('keyword-detector', () => {
   // strict 키워드(일상어): 명령 끝 위치 또는 --flag 에서만 발동.
   // 일상 영어("please verify", "quick question")의 오탐을 막기 위함.
   describe('verify keyword (strict)', () => {
-    it('should detect verify at command tail', () => {
+    it('should detect verify at command tail and emit deprecation hint', () => {
       const result = runDetector('make the implementation correct, verify');
-      expect(result.stdout).toContain('[VERIFY MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
       expect(result.stdout).toContain('verification');
     });
 
     it('should detect --verify flag', () => {
       const result = runDetector('fix the bug --verify');
-      expect(result.stdout).toContain('[VERIFY MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
     });
   });
 
   describe('quick keyword (strict)', () => {
-    it('should detect quick at command tail', () => {
+    it('should detect quick at command tail and emit --max-iter 1 hint', () => {
       const result = runDetector('fix this typo quick');
-      expect(result.stdout).toContain('[QUICK MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('--max-iter 1');
       expect(result.stdout).toContain('fast');
     });
 
     it('should detect --quick flag', () => {
       const result = runDetector('build the payment API --quick');
-      expect(result.stdout).toContain('[QUICK MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('--max-iter 1');
     });
   });
 
@@ -140,17 +146,19 @@ describe('keyword-detector', () => {
   // Keyword combinations / synergies
   // ══════════════════════════════════════════════════
   describe('keyword combinations', () => {
-    it('should detect ralph+ultrawork synergy', () => {
+    it('should detect ralph+ultrawork synergy and emit deprecation hint', () => {
       const result = runDetector('ralph ultrawork build everything from scratch');
-      expect(result.stdout).toContain('[RALPH+ULTRAWORK]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
       expect(result.stdout).toContain('persistence');
       expect(result.stdout).toContain('parallel');
     });
 
-    it('should detect ralph+verify synergy', () => {
+    it('should detect ralph+verify synergy and emit deprecation hint', () => {
       // verify is strict → use --verify flag (ralph stays bare)
       const result = runDetector('ralph fix each step --verify');
-      expect(result.stdout).toContain('[RALPH+VERIFY]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
     });
 
     it('should output both keywords when no synergy key matches sorted order', () => {
@@ -158,7 +166,7 @@ describe('keyword-detector', () => {
       // sorts keywords alphabetically → tries 'explore+ultrawork' which has no match.
       // So individual outputs are emitted instead. explore is strict → --explore.
       const result = runDetector('ultrawork analyze the entire project --explore');
-      expect(result.stdout).toContain('[ULTRAWORK MODE]');
+      expect(result.stdout).toContain('[ULTRAWORK]');
       expect(result.stdout).toContain('[EXPLORE MODE]');
       expect(result.stdout).toContain('[FLAGS]');
     });
@@ -224,7 +232,7 @@ describe('keyword-detector', () => {
     });
 
     it('should merge flags from multiple keywords', () => {
-      // quick is strict → place at command tail
+      // quick is strict → place at command tail; ralph stays bare
       const result = runDetector('ralph finish this quick');
       expect(result.stdout).toContain('[FLAGS]');
       expect(result.stdout).toContain('persistence');

package/hooks/scripts/__tests__/loop-ledger.test.js

@@ -0,0 +1,321 @@
+/**
+ * loop-ledger 라이브러리 + CLI 테스트
+ *
+ * 커버리지:
+ * - appendLoopEvent round-trip
+ * - isStuck: 2회 연속 동일 hash → true
+ * - isStuck: 다른 hash → false
+ * - isStuck: 이력 없음 → false
+ * - fail-open: 손상된 jsonl 줄 무시
+ * - hashDiscoverOutput: 공백 정규화
+ * - CLI: start / end / check-stuck 서브커맨드
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+let tmpDir;
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vibe-loop-ledger-test-'));
+});
+afterEach(() => {
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+async function importLedger() {
+  const p = path.resolve(__dirname, '..', 'lib', 'loop-ledger.js');
+  return import(p);
+}
+
+const CLI = path.resolve(__dirname, '..', 'loop-ledger.js');
+
+function historyPath(dir) {
+  return path.join(dir, '.vibe', 'metrics', 'loop-history.jsonl');
+}
+
+// ─── appendLoopEvent round-trip ───────────────────────────────────────
+
+describe('loop-ledger: appendLoopEvent round-trip', () => {
+  it('start 이벤트를 append 하면 jsonl 파일에 기록된다', async () => {
+    const { appendLoopEvent } = await importLedger();
+    appendLoopEvent(tmpDir, { loop: 'nightly', event: 'start' });
+
+    const p = historyPath(tmpDir);
+    expect(fs.existsSync(p)).toBe(true);
+    const line = fs.readFileSync(p, 'utf-8').trim();
+    const obj = JSON.parse(line);
+    expect(obj.loop).toBe('nightly');
+    expect(obj.event).toBe('start');
+    expect(obj.ts).toBeDefined();
+  });
+
+  it('end 이벤트에 result, summary, discoverHash가 포함된다', async () => {
+    const { appendLoopEvent } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'end',
+      result: 'ok',
+      summary: '3 items processed',
+      discoverHash: 'abc123',
+    });
+
+    const p = historyPath(tmpDir);
+    const line = fs.readFileSync(p, 'utf-8').trim();
+    const obj = JSON.parse(line);
+    expect(obj.event).toBe('end');
+    expect(obj.result).toBe('ok');
+    expect(obj.summary).toBe('3 items processed');
+    expect(obj.discoverHash).toBe('abc123');
+  });
+
+  it('여러 이벤트가 순서대로 append 된다', async () => {
+    const { appendLoopEvent } = await importLedger();
+    appendLoopEvent(tmpDir, { loop: 'loop-a', event: 'start' });
+    appendLoopEvent(tmpDir, { loop: 'loop-a', event: 'end', result: 'ok' });
+    appendLoopEvent(tmpDir, { loop: 'loop-b', event: 'start' });
+
+    const p = historyPath(tmpDir);
+    const lines = fs.readFileSync(p, 'utf-8').trim().split('\n');
+    expect(lines).toHaveLength(3);
+    expect(JSON.parse(lines[0]).loop).toBe('loop-a');
+    expect(JSON.parse(lines[1]).event).toBe('end');
+    expect(JSON.parse(lines[2]).loop).toBe('loop-b');
+  });
+
+  it('appendLoopEvent는 true를 반환한다', async () => {
+    const { appendLoopEvent } = await importLedger();
+    const result = appendLoopEvent(tmpDir, { loop: 'x', event: 'start' });
+    expect(result).toBe(true);
+  });
+});
+
+// ─── isStuck ──────────────────────────────────────────────────────────
+
+describe('loop-ledger: isStuck', () => {
+  it('이력 없으면 false', async () => {
+    const { isStuck } = await importLedger();
+    expect(isStuck(tmpDir, 'nightly', 'hash-abc')).toBe(false);
+  });
+
+  it('직전 discover 이벤트와 동일 hash → true (2회 연속 성립)', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    // 이전 반복의 discover 이벤트 (같은 hash)
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'discover',
+      discoverHash: 'hash-same',
+    });
+    // 신규 반복이 같은 hash를 갖고 오면 stuck
+    expect(isStuck(tmpDir, 'nightly', 'hash-same')).toBe(true);
+  });
+
+  it('직전 discover 이벤트와 다른 hash → false', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'discover',
+      discoverHash: 'hash-old',
+    });
+    expect(isStuck(tmpDir, 'nightly', 'hash-new')).toBe(false);
+  });
+
+  it('end 이벤트의 hash는 비교 대상이 아님 (discover만 본다)', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'end',
+      result: 'ok',
+      discoverHash: 'hash-same',
+    });
+    expect(isStuck(tmpDir, 'nightly', 'hash-same')).toBe(false);
+  });
+
+  it('다른 루프 이름의 이벤트는 영향 안 줌', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'other-loop',
+      event: 'discover',
+      discoverHash: 'hash-same',
+    });
+    // 'nightly' 에 대한 이력 없음 → false
+    expect(isStuck(tmpDir, 'nightly', 'hash-same')).toBe(false);
+  });
+
+  it('start 이벤트만 있고 discover 없으면 false', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    appendLoopEvent(tmpDir, { loop: 'nightly', event: 'start' });
+    expect(isStuck(tmpDir, 'nightly', 'hash-abc')).toBe(false);
+  });
+
+  it('discoverHash 가 빈 문자열이면 false', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'discover',
+      discoverHash: '',
+    });
+    expect(isStuck(tmpDir, 'nightly', '')).toBe(false);
+  });
+});
+
+// ─── fail-open: 손상된 jsonl 줄 ──────────────────────────────────────
+
+describe('loop-ledger: fail-open on corrupt jsonl', () => {
+  it('손상된 줄이 있어도 isStuck이 충돌하지 않고 false 반환', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+
+    // 정상 줄 + 손상 줄 + 정상 줄 혼합
+    const p = historyPath(tmpDir);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(
+      p,
+      [
+        JSON.stringify({ ts: '2026-01-01T00:00:00.000Z', loop: 'nightly', event: 'discover', discoverHash: 'abc' }),
+        'CORRUPTED LINE {{{',
+        JSON.stringify({ ts: '2026-01-01T01:00:00.000Z', loop: 'nightly', event: 'discover', discoverHash: 'xyz' }),
+      ].join('\n') + '\n',
+      'utf-8'
+    );
+
+    // 손상 줄은 건너뛰고, 가장 최근 discover 이벤트(최신)의 hash는 'xyz'
+    expect(isStuck(tmpDir, 'nightly', 'xyz')).toBe(true);
+    expect(isStuck(tmpDir, 'nightly', 'abc')).toBe(false);
+  });
+
+  it('appendLoopEvent: 전체 파일이 corrupt 여도 추가 후 정상 동작', async () => {
+    const { appendLoopEvent } = await importLedger();
+    const p = historyPath(tmpDir);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, 'NOT JSON\n', 'utf-8');
+
+    const ok = appendLoopEvent(tmpDir, { loop: 'x', event: 'start' });
+    expect(ok).toBe(true);
+    const lines = fs.readFileSync(p, 'utf-8').split('\n').filter(Boolean);
+    // 손상 줄 + 새로 추가된 정상 줄
+    expect(lines.length).toBeGreaterThanOrEqual(2);
+    const last = JSON.parse(lines[lines.length - 1]);
+    expect(last.event).toBe('start');
+  });
+});
+
+// ─── hashDiscoverOutput ───────────────────────────────────────────────
+
+describe('loop-ledger: hashDiscoverOutput', () => {
+  it('동일 텍스트는 동일 해시를 반환한다', async () => {
+    const { hashDiscoverOutput } = await importLedger();
+    const h1 = hashDiscoverOutput('hello world');
+    const h2 = hashDiscoverOutput('hello world');
+    expect(h1).toBe(h2);
+  });
+
+  it('공백 정규화: 여분 공백/줄바꿈이 달라도 동일 해시', async () => {
+    const { hashDiscoverOutput } = await importLedger();
+    const h1 = hashDiscoverOutput('item a\nitem b');
+    const h2 = hashDiscoverOutput('item a  item b');
+    const h3 = hashDiscoverOutput('  item a item b  ');
+    expect(h1).toBe(h2);
+    expect(h2).toBe(h3);
+  });
+
+  it('다른 텍스트는 다른 해시', async () => {
+    const { hashDiscoverOutput } = await importLedger();
+    expect(hashDiscoverOutput('abc')).not.toBe(hashDiscoverOutput('xyz'));
+  });
+
+  it('sha256 hex 64자 반환', async () => {
+    const { hashDiscoverOutput } = await importLedger();
+    expect(hashDiscoverOutput('test')).toMatch(/^[0-9a-f]{64}$/);
+  });
+});
+
+// ─── CLI: start / end / check-stuck ─────────────────────────────────
+
+describe('loop-ledger CLI', () => {
+  it('start → exit 0, 확인 메시지 출력, jsonl 생성', () => {
+    const result = spawnSync('node', [CLI, 'start', 'nightly'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('start recorded');
+    expect(result.stdout).toContain('nightly');
+    expect(fs.existsSync(historyPath(tmpDir))).toBe(true);
+  });
+
+  it('end → exit 0, jsonl에 end 이벤트 기록', () => {
+    const result = spawnSync('node', [CLI, 'end', 'nightly', 'ok', 'summary text'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('end recorded');
+
+    const line = fs.readFileSync(historyPath(tmpDir), 'utf-8').trim();
+    const obj = JSON.parse(line);
+    expect(obj.event).toBe('end');
+    expect(obj.result).toBe('ok');
+    expect(obj.summary).toBe('summary text');
+  });
+
+  it('check-stuck: 직전 discover hash와 동일 → stdout "stuck"', async () => {
+    const { appendLoopEvent } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'discover',
+      discoverHash: 'deadbeef',
+    });
+
+    const result = spawnSync('node', [CLI, 'check-stuck', 'nightly', 'deadbeef'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout.trim()).toBe('stuck');
+  });
+
+  it('check-stuck: 새 hash → stdout "ok"', async () => {
+    const { appendLoopEvent } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'end',
+      result: 'ok',
+      discoverHash: 'old-hash',
+    });
+
+    const result = spawnSync('node', [CLI, 'check-stuck', 'nightly', 'new-hash'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout.trim()).toBe('ok');
+  });
+
+  it('check-stuck: 이력 없으면 "ok"', () => {
+    const result = spawnSync('node', [CLI, 'check-stuck', 'nightly', 'anyhash'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout.trim()).toBe('ok');
+  });
+
+  it('인수 없이 실행해도 exit 0 (fail-open)', () => {
+    const result = spawnSync('node', [CLI], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+  });
+});

package/hooks/scripts/keyword-detector.js

@@ -8,20 +8,20 @@ import { VIBE_PATH, PROJECT_DIR } from './utils.js';
 
 // 매직 키워드 정의
 const MAGIC_KEYWORDS = {
-  // 지속성 모드 (완료까지 계속)
+  // Deprecated: 기본 루프 동작과 동일 (no-op). exit=coverage-100으로 해석.
   ralph: {
-    name: 'Ralph Loop',
-    description: 'Continue until task is verified complete',
+    name: 'Ralph (deprecated alias)',
+    description: '[deprecated] Looping to convergence is the default; alias mapped',
     flags: ['persistence', 'verification'],
-    output: '[RALPH MODE] Self-referential completion loop activated. Will continue until ALL tasks verified complete. NO early stopping.',
+    output: '[vibe] \'ralph\' is deprecated — looping to convergence is the default; alias mapped.',
   },
 
-  // 울트라워크 모드 (병렬 + 자동 계속)
+  // 울트라워크 모드 (automationLevel: autonomous + 병렬 ACT)
   ultrawork: {
     name: 'Ultrawork',
-    description: 'Maximum parallel execution, no pause',
+    description: 'automationLevel: autonomous + parallel ACT (deprecated alias)',
     flags: ['parallel', 'auto_continue', 'no_confirmation'],
-    output: '[ULTRAWORK MODE] Use PARALLEL Task calls. Auto-continue through ALL phases. Auto-retry on errors up to 3 times. Do NOT ask for confirmation between phases.',
+    output: '[ULTRAWORK] automationLevel: autonomous + parallel ACT. Loop runs to convergence; stuck → auto-TODO (no confirmation).',
   },
   ulw: {
     alias: 'ultrawork',
@@ -47,12 +47,12 @@ const MAGIC_KEYWORDS = {
     output: '[RALPLAN MODE] Iterative planning with consensus. Will refine plan until approved, then execute with Ralph persistence.',
   },
 
-  // 검증 모드
+  // Deprecated: 기본 JUDGE는 항상 결정론 검증 (no-op)
   verify: {
-    name: 'Verify Mode',
-    description: 'Strict verification after each step',
+    name: 'Verify (deprecated alias)',
+    description: '[deprecated] Deterministic verification is the default; alias mapped',
     flags: ['verification', 'strict'],
-    output: '[VERIFY MODE] Strict verification enabled. Every change must be verified before proceeding.',
+    output: '[vibe] \'verify\' is deprecated — deterministic JUDGE is the default; alias mapped.',
     strict: true, // 일상어 ("please verify the fix" 오탐 방지)
   },
 
@@ -65,29 +65,29 @@ const MAGIC_KEYWORDS = {
     strict: true, // 일상어 ("let me explore the options" 오탐 방지)
   },
 
-  // 빠른 모드
+  // Deprecated: --max-iter 1 매핑
   quick: {
-    name: 'Quick Mode',
-    description: 'Fast execution, minimal verification',
+    name: 'Quick (deprecated alias)',
+    description: '[deprecated] Maps to --max-iter 1; use --max-iter 1 explicitly',
     flags: ['fast', 'minimal_verification'],
-    output: '[QUICK MODE] Fast execution mode. Minimal verification, single round reviews.',
+    output: '[vibe] \'quick\' maps to --max-iter 1 (single-pass, minimal JUDGE).',
     strict: true, // 일상어 ("quick question on auth" 오탐 방지)
   },
 };
 
-// 키워드 조합 시너지
+// 키워드 조합 시너지 (deprecated alias 조합도 매핑 유지)
 const KEYWORD_SYNERGIES = {
   'ralph+ultrawork': {
-    name: 'Ralph Ultrawork',
-    output: '[RALPH+ULTRAWORK] Maximum persistence AND parallel execution. Will NOT stop until ALL phases complete with verification.',
+    name: 'Ralph+Ultrawork (deprecated)',
+    output: '[vibe] \'ralph\'+\'ultrawork\' deprecated: automationLevel: autonomous + parallel ACT, exit=coverage-100.',
   },
   'ralph+verify': {
-    name: 'Ralph Verify',
-    output: '[RALPH+VERIFY] Persistent completion with strict verification at each step.',
+    name: 'Ralph+Verify (deprecated)',
+    output: '[vibe] \'ralph\'+\'verify\' deprecated: both are default behavior; alias mapped.',
   },
   'ultrawork+explore': {
-    name: 'Ultrawork Explore',
-    output: '[ULTRAWORK+EXPLORE] Parallel exploration agents for maximum coverage.',
+    name: 'Ultrawork+Explore',
+    output: '[ULTRAWORK+EXPLORE] automationLevel: autonomous + parallel exploration agents.',
   },
 };
 

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

@@ -19,6 +19,26 @@ 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'이 없음.
@@ -37,16 +57,25 @@ export function readStdinSync() {
     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: non-blocking stdin에 데이터 없음 → 루프 종료
-        if (err.code === 'EAGAIN') break;
+        // 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;