'use strict';
// Claude Code 헤드리스(-p) 실행 래퍼.
// 사이트 디렉터리를 작업 폴더로 하여 Claude Opus 5.5 로 페이지를 생성/수정하고,
// stream-json 이벤트를 파싱해 진행 로그와 최종 토큰 사용량을 돌려준다.
const { spawn } = require('child_process');
const readline = require('readline');
const path = require('path');

const ROOT = path.resolve(__dirname, '..');
const settings = require('./settings');
const os = require('os');
const fs = require('fs');
const { execFileSync } = require('child_process');
// claude 실행 파일 자동 탐색: CLAUDE_BIN → PATH → 잘 알려진 설치 위치 순. 실행 실패(ENOENT) 시 다시 탐색한다.
const HOME = os.homedir();
const KNOWN_DIRS = [path.join(HOME, '.local', 'bin'), path.join(HOME, '.npm-global', 'bin'), '/usr/local/bin', '/usr/bin', '/opt/homebrew/bin', path.join(HOME, '.claude', 'local'), path.join(HOME, 'node_modules', '.bin')];
function isExec(p) { try { fs.accessSync(p, fs.constants.X_OK); return fs.statSync(p).isFile(); } catch (_) { return false; } }
let resolvedBin = null; let resolvedAt = 0;
function resolveClaudeBin(force) {
  if (resolvedBin && !force && Date.now() - resolvedAt < 60000 && isExec(resolvedBin)) return resolvedBin;
  const candidates = [];
  if (process.env.CLAUDE_BIN) candidates.push(process.env.CLAUDE_BIN);
  for (const d of (process.env.PATH || '').split(path.delimiter)) if (d) candidates.push(path.join(d, 'claude'));
  for (const d of KNOWN_DIRS) candidates.push(path.join(d, 'claude'));
  const found = candidates.find(isExec);
  resolvedBin = found || null; resolvedAt = Date.now();
  return resolvedBin;
}
function claudeInfo() {
  const bin = resolveClaudeBin(true); if (!bin) return { bin: null, version: null, searched: [...new Set([process.env.CLAUDE_BIN, ...KNOWN_DIRS].filter(Boolean))] };
  let version = null; try { version = execFileSync(bin, ['--version'], { timeout: 15000, env: cleanEnv(os.tmpdir()) }).toString().trim().split('\n')[0]; } catch (e) { version = '버전 확인 실패: ' + (e.message || '').split('\n')[0]; }
  return { bin, realpath: (() => { try { return fs.realpathSync(bin); } catch (_) { return bin; } })(), version, searched: [...new Set([process.env.CLAUDE_BIN, ...KNOWN_DIRS].filter(Boolean))] };
}
const MODEL = process.env.CLAUDE_MODEL || 'claude-opus-5-5'; // 기본값. 실제 실행 모델은 settings.getModel()
const MAX_TURNS = parseInt(process.env.CLAUDE_MAX_TURNS || '80', 10);
// v1.6.31 (요구 3): 훅 설정은 서버마다 다른 설치 경로(/home/master/webmaker, /srv/webmaker/current …)에 맞춰 기동 때 만든다.
//   1.5.x 의 hooks/settings.json 은 개발 PC 의 절대 경로가 박혀 있어 다른 서버에서는 훅이 실행되지 못했다(명령 없음 → Claude 는 차단 없이 진행) → 가드가 사실상 꺼져 있었다.
const HOOK_SETTINGS = (() => { const dir = path.join(process.env.DATA_ROOT || path.join(ROOT, 'data'), 'run'); try { fs.mkdirSync(dir, { recursive: true }); } catch (_) {} const f = path.join(dir, 'claude-hooks.json'); try { fs.writeFileSync(f, JSON.stringify({ hooks: { PreToolUse: [{ matcher: 'Read|Write|Edit|MultiEdit|NotebookEdit|Glob|Grep|Bash|WebFetch|WebSearch', hooks: [{ type: 'command', command: path.join(ROOT, 'hooks', 'guard.sh') }] }] } }, null, 1)); } catch (e) { console.error('[claude] 훅 설정 파일 작성 실패: ' + e.message); } return f; })();
/** 작업 하나의 최대 실행 시간(분) — 설정 ai.maxJobMinutes(기본 45). 넘으면 중단해 다른 사용자·서버에 영향을 주지 않는다 (요구 3·12) */
const MAX_JOB_MIN = () => { try { const v = parseInt(require('./config').get('ai.maxJobMinutes') || '45', 10); return Number.isFinite(v) && v > 0 ? v : 45; } catch (_) { return 45; } };
const IDLE_MIN = 15;   // 출력이 이만큼 없으면 멈춘 것으로 보고 중단
// 파일 조작 도구만 사용 가능하게 제한(--tools). Bash/Web/Task 등은 모델에 아예 노출되지 않는다.
// 쓰기 범위는 hooks/guard.sh(PreToolUse) 가 사이트 폴더로 제한한다.
const ALLOWED_TOOLS = 'Write,Edit,MultiEdit,Read,Glob,Grep';

// ============================================================================
// v1.4.5 이번 실행 비용 계산 (세션 누적값 문제)
//
// Claude CLI 결과의 total_cost_usd 와 modelUsage 는 "그 세션의 누적값" 이다. --resume 으로 같은 세션을 이어 가면
// 앞선 실행 비용이 계속 더해져 나온다(2026-10-10 실측: 새 세션 0.046121 → 이어서 0.0496223 → 0.0522053 USD).
// 1.4.4 까지는 이 값을 그대로 "이번 작업 비용" 으로 청구해 같은 비용이 작업마다 다시 청구되었다.
// 반면 결과의 usage(입력·출력·캐시 토큰)는 이번 실행분만이다.
//
// 그래서 세션마다 마지막 누적값을 장부(data/claude-sessions.json)에 남기고, 이번 비용 = 지금 누적 − 지난 누적 으로 구한다.
// 장부를 믿을 수 없을 때는 이번 실행 usage 를 가격표로 계산한다(가격표 계산은 CLI 비용과 일치함을 실측으로 확인):
//  - 1.4.5 이전에 시작된 세션을 처음 이어 갈 때(장부에 없음)
//  - 지난 실행이 중단(취소·캐시 소진)되어 결과 누적값을 받지 못했을 때 — 그 실행의 완성된 메시지는 세션에 남아
//    다음 누적값에 들어가므로, 차이로 계산하면 이미 추정 청구한 중단 실행분이 한 번 더 청구된다
//  - 누적값이 줄어든 경우(CLI 가 세션 비용을 새로 시작)
// ============================================================================
const SESSION_LEDGER = path.join(process.env.DATA_ROOT || path.join(ROOT, 'data'), 'claude-sessions.json');
const LEDGER_DAYS = 120;   // 이 기간 동안 쓰지 않은 세션 기록은 지운다 (파일이 끝없이 커지지 않게)
function loadLedger() { try { return JSON.parse(fs.readFileSync(SESSION_LEDGER, 'utf8')) || {}; } catch (_) { return {}; } }
function saveLedger(d) {
  const cut = Date.now() - LEDGER_DAYS * 86400000; for (const k of Object.keys(d)) if (!(Date.parse(d[k].at) > cut)) delete d[k];
  try { fs.mkdirSync(path.dirname(SESSION_LEDGER), { recursive: true }); const tmp = SESSION_LEDGER + '.tmp'; fs.writeFileSync(tmp, JSON.stringify(d), { mode: 0o600 }); fs.renameSync(tmp, SESSION_LEDGER); } catch (_) {}
}
/** 세션 장부에 "지난 실행이 중단되어 누적값을 모름" 표시 — 다음 실행은 가격표 계산 (위 설명) */
function markSessionDirty(sessionId) { if (!sessionId) return; const d = loadLedger(); d[sessionId] = { ...(d[sessionId] || {}), clean: false, at: new Date().toISOString() }; saveLedger(d); }
/** modelUsage 두 개의 차이 (모델별 토큰·비용). 줄어든 값은 0 으로 */
function diffModelUsage(cur, prev) {
  const out = {};
  for (const [m, v] of Object.entries(cur || {})) {
    const p = (prev || {})[m] || {}; const o = {};
    for (const k of Object.keys(v)) o[k] = typeof v[k] === 'number' && /Tokens$|^costUSD$|Requests$/.test(k) ? Math.max(0, v[k] - (p[k] || 0)) : v[k];
    if ((o.costUSD || 0) > 0 || (o.inputTokens || 0) + (o.outputTokens || 0) > 0) out[m] = o;
  }
  return out;
}
/** 이번 실행 usage 만으로 만든 modelUsage (가격표 계산 때) */
function runModelUsage(model, u, costUsd) {
  return { [model]: { inputTokens: u.input, outputTokens: u.output, cacheReadInputTokens: u.cacheRead, cacheCreationInputTokens: u.cacheCreate, thinkingTokens: u.thinking, costUSD: costUsd, priced: true } };
}
/**
 * 이번 실행의 비용·모델별 사용량을 정한다.
 * @param {object} r    CLI result 이벤트
 * @param {object} usage 정규화한 이번 실행 usage
 * @param {object} o    runClaudeOnce 옵션 (resume, sessionId, noPersist)
 * @returns {{costUsd, modelUsage, costSource: 'single'|'delta'|'priced', cumulativeUsd, pricedUsd}}
 */
function runCost(r, usage, model, o) {
  const cum = Number(r.total_cost_usd) || 0; const cumMU = r.modelUsage || {};
  const pricedUsd = settings.estimateUsd(usage, model);   // 이번 실행 토큰 × 가격표 (확인·대체용)
  if (o.noPersist) return { costUsd: cum, modelUsage: cumMU, costSource: 'single', cumulativeUsd: cum, pricedUsd };   // 세션을 남기지 않는 한 번짜리 실행: 누적 = 이번
  const sid = o.sessionId || r.session_id; const d = loadLedger(); const prev = o.resume ? d[sid] : null;
  let out;
  if (!o.resume) out = { costUsd: cum, modelUsage: cumMU, costSource: 'single' };   // 새 세션의 첫 실행
  else if (prev && prev.clean !== false && Number.isFinite(prev.costUsd) && cum + 1e-9 >= prev.costUsd) out = { costUsd: Math.max(0, cum - prev.costUsd), modelUsage: diffModelUsage(cumMU, prev.modelUsage), costSource: 'delta' };
  else out = { costUsd: pricedUsd, modelUsage: runModelUsage(model, usage, pricedUsd), costSource: 'priced' };
  if (sid) { d[sid] = { costUsd: cum, modelUsage: cumMU, clean: true, at: new Date().toISOString() }; saveLedger(d); }
  return { ...out, cumulativeUsd: cum, pricedUsd };
}

/**
 * 자식(claude) 환경 변수 — v1.6.31 (요구 3): 서비스 프로세스의 환경을 통째로 넘기지 않고 허용 목록만 넘긴다.
 *   1.5.x 까지는 DATA_ROOT·SITES_ROOT·PORT 등 서비스 환경과 상위 세션 변수가 그대로 전달됐다(검토 S1). AI 가 셸로 env 를 보면 서버 구조가 드러났다.
 *   HOME 은 claude 의 로그인 상태(~/.claude)를 위해 남긴다(서버 로그인 방식). 인증은 authEnv(API 키·OAuth 토큰)로만 넣는다.
 */
const ENV_ALLOW = ['PATH', 'HOME', 'USER', 'LOGNAME', 'LANG', 'LC_ALL', 'LC_CTYPE', 'TERM', 'TMPDIR', 'TZ', 'NODE_EXTRA_CA_CERTS', 'SSL_CERT_FILE', 'HTTPS_PROXY', 'HTTP_PROXY', 'NO_PROXY', 'https_proxy', 'http_proxy', 'no_proxy', 'ANTHROPIC_BASE_URL', 'CLAUDE_CODE_USE_BEDROCK', 'CLAUDE_CODE_USE_VERTEX', 'XDG_CONFIG_HOME', 'XDG_DATA_HOME'];
function cleanEnv(siteDir, authEnv) {
  const env = {};
  for (const k of ENV_ALLOW) if (process.env[k] !== undefined) env[k] = process.env[k];
  env.SITE_DIR = siteDir;           // hooks/guard.js 가 참조
  env.CI = '1';
  // v1.6.31 (검토 S8): TLS 검증 완화는 기본 꺼짐. 사설 프록시 환경에서만 설정 ai.allowInsecureTls 로 켠다(자식 프로세스 전체의 TLS 검증이 꺼지므로 경고 대상)
  if (process.env.CLAUDE_ALLOW_INSECURE_TLS === '1') env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
  env.HOOK_SCRIPT = path.join(ROOT, 'hooks', 'guard.sh');
  if (!env.HOME) env.HOME = require('os').homedir();
  Object.assign(env, authEnv || settings.authEnv()); // 실행별 지정(사용자 키) 또는 관리자 설정
  const bin = resolvedBin; if (bin) { const dir = path.dirname(bin); const parts = (env.PATH || '').split(path.delimiter); if (!parts.includes(dir)) env.PATH = [dir, ...parts].filter(Boolean).join(path.delimiter); }
  return env;
}

function friendlyProgress(c) {
  const input = c.input || {}; const fp = input.file_path ? path.basename(input.file_path) : '';
  switch (c.name) {
    case 'Write': return `파일 작성 중: ${fp}`;
    case 'Edit': case 'MultiEdit': return `파일 수정 중: ${fp}`;
    case 'Read': return `내용 확인 중: ${fp}`;
    case 'Glob': case 'Grep': return '파일 구조 확인 중';
    case 'WebFetch': return '참고 웹 페이지 확인 중';
    default: return '작업 진행 중';
  }
}
function summarizeToolUse(c) {
  const input = c.input || {};
  const fp = input.file_path ? path.basename(input.file_path) : '';
  switch (c.name) {
    case 'Write': return `파일 작성: ${fp} (${(input.content || '').length.toLocaleString()}자)`;
    case 'Edit': case 'MultiEdit': return `파일 수정: ${fp}`;
    case 'Read': return `파일 읽기: ${fp}`;
    case 'Glob': return `파일 검색: ${input.pattern || ''}`;
    case 'Grep': return `내용 검색: ${input.pattern || ''}`;
    case 'WebFetch': return `웹 페이지 확인: ${input.url || ''}`;
    default: return `도구 호출: ${c.name}`;
  }
}

/**
 * @param {object} o
 * @param {string} o.siteDir       작업 폴더 (사이트 루트)
 * @param {string} o.prompt        사용자 프롬프트
 * @param {string} o.systemPrompt  append-system-prompt
 * @param {string} o.sessionId     신규 세션 ID (uuid)
 * @param {boolean} o.resume       true 이면 --resume sessionId
  * @param {(ev:object)=>void} o.onEvent  진행 이벤트 콜백
 * @param {string} [o.tools]    사용 가능 도구 목록 (기본: 파일 도구)
 * @param {boolean} [o.noPersist] 세션을 남기지 않음(기획 단계 단발 호출)
 * @param {(h:{cancel:Function})=>void} [o.onStart] 실행 핸들(취소 함수) 전달
 */
// 저장된 세션(~/.claude/projects/<cwd 인코딩>/<id>.jsonl)이 이 서버에 있는지 확인.
// 다른 서버에서 DB 를 옮겨온 경우 세션 파일이 없어 --resume 이 "No conversation found" 로 즉시 실패하므로,
// 그런 경우 새 세션(--session-id)으로 시작한다.
function sessionExists(sessionId) {
  if (!sessionId || !/^[0-9a-f-]{36}$/i.test(sessionId)) return false;
  const root = path.join(HOME, '.claude', 'projects');
  try {
    for (const d of fs.readdirSync(root)) { if (fs.existsSync(path.join(root, d, `${sessionId}.jsonl`))) return true; }
  } catch (_) {}
  return false;
}
const MISSING_SESSION_RE = /No conversation found with session ID/i;

function runClaude(o) {
  if (o.resume && o.sessionId && !sessionExists(o.sessionId)) {
    // v1.4.0: 오류가 아니라 정상 동작(세션 파일이 없는 서버·정리된 세션)이라 info 로 남긴다 — debug 는 관리자 오류 목록에 섞여 오류처럼 보였다
    if (o.onEvent) o.onEvent({ type: 'log', level: 'info', text: `이전 세션(${o.sessionId})이 이 서버에 없어 새 세션으로 시작합니다` });
    o = { ...o, resume: false, sessionId: require('crypto').randomUUID() };
  }
  return runClaudeOnce(o).catch((err) => {
    // 세션 파일 목록에 있었지만 손상 등으로 이어가기에 실패한 경우에도 한 번 새 세션으로 재시도
    if (o.resume && !err.cancelled && MISSING_SESSION_RE.test(err.message || '')) {
      if (o.onEvent) o.onEvent({ type: 'log', level: 'debug', text: '이전 세션을 이어갈 수 없어 새 세션으로 다시 시작합니다' });
      return runClaudeOnce({ ...o, resume: false, sessionId: require('crypto').randomUUID() });
    }
    throw err;
  });
}

function runClaudeOnce(o) {
  return new Promise((resolve, reject) => {
    const model = o.model || settings.getModel();
    const args = [
      '-p', o.prompt,
      '--model', model,
      '--output-format', 'stream-json',
      '--verbose',
      // v1.1.6: 응답이 쓰이는 도중의 사용량(message_start 의 입력·캐시 토큰, 본문 조각)을 받아 캐시 소진을 빨리 감지한다
      '--include-partial-messages',
      '--tools', o.tools || ALLOWED_TOOLS,
      '--allowedTools', o.tools || ALLOWED_TOOLS,
      '--settings', HOOK_SETTINGS,
      '--max-turns', String(MAX_TURNS),
      '--append-system-prompt', o.systemPrompt,
    ];
    if (o.resume) args.push('--resume', o.sessionId);
    else if (o.sessionId) args.push('--session-id', o.sessionId);
    if (o.noPersist) args.push('--no-session-persistence');

    const bin = resolveClaudeBin(false) || resolveClaudeBin(true);
    if (!bin) return reject(new Error(`claude 실행 파일을 찾지 못했습니다. 서버에 Claude Code 를 설치하거나 CLAUDE_BIN 을 지정하세요 (탐색 위치: ${KNOWN_DIRS.join(', ')})`));
    const child = spawn(bin, args, {
      cwd: o.siteDir,
      env: cleanEnv(o.siteDir, o.authEnv),
      stdio: ['ignore', 'pipe', 'pipe'],
      detached: true, // 자체 프로세스 그룹 → 취소 시 훅/하위 프로세스까지 한꺼번에 종료
    });

    let result = null;
    let stderr = '';
    let cancelled = false; let lastLive = null;
    const killGroup = (sig) => { try { process.kill(-child.pid, sig); } catch (_) { try { child.kill(sig); } catch (_) {} } };
    // v1.6.31 (요구 3·12·25): 실행 시간 상한과 유휴 상한 — 넘으면 중단하고 이유를 결과에 남긴다. 자식 PID 를 기록해 서비스가 죽어도 다음 기동 때 정리한다(lib/jobpids.js)
    let watchdogReason = null; let lastOut = Date.now();
    const maxTimer = setTimeout(() => { watchdogReason = `최대 실행 시간 ${MAX_JOB_MIN()}분을 넘겨 중단했습니다`; cancel(); }, MAX_JOB_MIN() * 60000);
    const idleTimer = setInterval(() => { if (Date.now() - lastOut > IDLE_MIN * 60000) { watchdogReason = `${IDLE_MIN}분 동안 응답이 없어 중단했습니다`; cancel(); } }, 30000);
    try { require('./jobpids').add(child.pid, { kind: 'claude', siteDir: o.siteDir }); } catch (_) {}
    const clearWatch = () => { clearTimeout(maxTimer); clearInterval(idleTimer); try { require('./jobpids').remove(child.pid); } catch (_) {} };
    const cancel = () => {
      if (cancelled) return; cancelled = true;
      killGroup('SIGTERM');
      setTimeout(() => { if (child.exitCode === null && child.signalCode === null) killGroup('SIGKILL'); }, 2000);
      // 종료 신호가 무시되어도 결과를 기다리지 않도록 스트림을 닫는다
      setTimeout(() => { if (child.exitCode === null && child.signalCode === null) { try { child.stdout.destroy(); child.stderr.destroy(); } catch (_) {} } }, 4000);
    };
    if (o.onStart) o.onStart({ cancel });
    /**
     * 실시간 사용량
     *  seen    : 메시지 ID → usage. 완성된 assistant 메시지의 usage 가 오면 그 값으로 확정, 그 전에는 message_start 의 usage(입력·캐시) 로 미리 채운다.
     *  partial : 쓰는 중인 메시지의 출력 토큰 추정(본문 조각 글자 수 ÷ 3). 메시지가 완성되면 0 으로.
     *  emitLive 는 조각마다 부르면 이벤트가 너무 많으므로 0.8초 간격으로 묶는다(확정 시에는 즉시).
     */
    const seen = new Map(); let thinkingEst = 0; let partial = 0; let curMsg = null; let liveTimer = null; let lastEmit = 0;
    const emitLive = (force) => {
      const now = Date.now(); if (!force && now - lastEmit < 800) { if (!liveTimer) liveTimer = setTimeout(() => { liveTimer = null; emitLive(true); }, 800); return; }
      lastEmit = now; if (liveTimer) { clearTimeout(liveTimer); liveTimer = null; }
      const u = { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 };
      for (const x of seen.values()) { u.input += x.input_tokens || 0; u.output += x.output_tokens || 0; u.cacheCreate += x.cache_creation_input_tokens || 0; u.cacheRead += x.cache_read_input_tokens || 0; }
      u.output += thinkingEst + partial; u.total = u.input + u.output + u.cacheCreate + u.cacheRead; u.thinking = thinkingEst; lastLive = u;
      emit({ type: 'usage', live: true, usage: u, calls: seen.size });
    };
    const emit = (ev) => { try { o.onEvent && o.onEvent(ev); } catch (_) { /* ignore */ } };

    child.on('error', (err) => { if (err.code === 'ENOENT') resolveClaudeBin(true); reject(new Error(`claude 실행 실패 (${bin}): ${err.message}`)); });

    child.stderr.on('data', (d) => {
      stderr += d.toString();
      if (stderr.length > 20000) stderr = stderr.slice(-20000);
    });

    child.stdout.on('data', () => { lastOut = Date.now(); });   // v1.6.31 유휴 감시
    const rl = readline.createInterface({ input: child.stdout });
    rl.on('line', (line) => {
      line = line.trim();
      if (!line) return;
      let ev;
      try { ev = JSON.parse(line); } catch (_) { return; }
      switch (ev.type) {
        case 'stream_event': {
          // 부분 메시지 (--include-partial-messages): 시작 시 입력·캐시 토큰, 진행 중 본문 조각, 끝에 출력 토큰
          const e = ev.event || {};
          if (e.type === 'message_start' && e.message) { curMsg = e.message.id || `m${seen.size}`; seen.set(curMsg, { ...(e.message.usage || {}), output_tokens: 0 }); partial = 0; emitLive(); }
          else if (e.type === 'content_block_delta' && e.delta) { const t = e.delta.text || e.delta.partial_json || e.delta.thinking || ''; if (t) { partial += t.length / 3; emitLive(); } }
          else if (e.type === 'message_delta' && e.usage && curMsg && seen.has(curMsg)) { seen.get(curMsg).output_tokens = e.usage.output_tokens || 0; partial = 0; emitLive(true); }
          break;
        }
        case 'system':
          if (ev.subtype === 'init') { emit({ type: 'log', level: 'info', text: `세션 시작 (모델: ${ev.model || model})` }); emit({ type: 'progress', text: 'AI 연결됨 · 작업을 구상하고 있습니다' }); }
          else if (ev.subtype === 'thinking_tokens' && typeof ev.estimated_tokens === 'number') { thinkingEst = Math.max(thinkingEst, ev.estimated_tokens); emitLive(); emit({ type: 'progress', text: '내용을 구상하고 있습니다…' }); }
          break;
        case 'assistant': {
          if (ev.message && ev.message.usage) { seen.set(ev.message.id || String(seen.size), ev.message.usage); thinkingEst = 0; partial = 0; emitLive(true); }
          const content = (ev.message && ev.message.content) || [];
          for (const c of content) {
            if (c.type === 'text' && c.text && c.text.trim()) { const t = c.text.replace(/<brief>[\s\S]*?<\/brief>/g, '[Brief 갱신됨]').trim(); if (t) { emit({ type: 'log', level: 'assistant', text: t }); emit({ type: 'progress', text: '결과를 정리하고 있습니다' }); } }
            else if (c.type === 'tool_use') { emit({ type: 'log', level: 'tool', text: summarizeToolUse(c) }); emit({ type: 'progress', text: friendlyProgress(c) }); }
          }
          break;
        }
        case 'user': {
          const content = (ev.message && ev.message.content);
          if (Array.isArray(content)) {
            for (const c of content) {
              if (c.type === 'tool_result' && c.is_error) {
                const t = typeof c.content === 'string' ? c.content : JSON.stringify(c.content);
                emit({ type: 'log', level: 'debug', text: `도구 오류: ${String(t).slice(0, 300)}` });
              }
            }
          }
          break;
        }
        case 'result':
          result = ev;
          break;
        default:
          break;
      }
    });

    child.on('close', (code) => {
      clearWatch();   // v1.6.31 감시 타이머·PID 기록 정리
      if (liveTimer) { clearTimeout(liveTimer); liveTimer = null; }   // 종료 뒤에 늦은 사용량 이벤트가 나가지 않게
      if (result) result.__model = model;
      if ((cancelled || !result) && !o.noPersist) markSessionDirty(o.sessionId);   // v1.4.5 누적값을 받지 못한 실행 — 다음 실행은 가격표로 계산
      if (cancelled) return reject(Object.assign(new Error(watchdogReason || '사용자가 작업을 중단했습니다'), { cancelled: true, watchdog: !!watchdogReason, usage: lastLive || { input: 0, output: 0, cacheCreate: 0, cacheRead: 0, thinking: 0, total: 0 } }));
      if (!result) {
        return reject(new Error(`claude 종료 코드 ${code}, 결과 없음. ${stderr.trim().slice(-800)}`));
      }
      const nr = normalizeResult(result, o); if (!nr.ok && !nr.errorText && stderr.trim()) nr.errorText = stderr.trim().slice(-800);
      resolve(nr);
    });
  });
}

function normalizeResult(r, o = {}) {
  const u = r.usage || {}; const cc = u.cache_creation || {};
  const usage = {
    input: u.input_tokens || 0,
    output: u.output_tokens || 0,
    cacheCreate: u.cache_creation_input_tokens || 0,
    cacheRead: u.cache_read_input_tokens || 0,
    thinking: (u.output_tokens_details && u.output_tokens_details.thinking_tokens) || 0,
    // v1.4.5 캐시 쓰기 종류별 토큰 (1시간 캐시는 입력 단가의 2배, 5분 캐시는 1.25배 — Claude Code 는 1시간 캐시를 쓴다)
    cacheCreate1h: cc.ephemeral_1h_input_tokens || 0,
    cacheCreate5m: cc.ephemeral_5m_input_tokens || 0,
  };
  usage.total = usage.input + usage.output + usage.cacheCreate + usage.cacheRead;
  const model = r.__model || Object.keys(r.modelUsage || {})[0] || MODEL;
  const cost = runCost(r, usage, model, o);   // v1.4.5 이번 실행 비용 (세션 누적값이 아님)
  return {
    model,
    ok: !r.is_error && r.subtype === 'success',
    subtype: r.subtype,
    isError: !!r.is_error,
    resultText: typeof r.result === 'string' ? r.result : '',
    errorText: (!r.is_error && r.subtype === 'success') ? '' : [typeof r.result === 'string' ? r.result : '', ...(Array.isArray(r.errors) ? r.errors : [])].filter(Boolean).join(' / ').slice(0, 800),
    sessionId: r.session_id,
    usage,
    costUsd: cost.costUsd,             // 이번 실행 비용 (청구 기준)
    costSource: cost.costSource,       // single(새 세션·한 번짜리) | delta(누적 차이) | priced(이번 토큰 × 가격표)
    costCumulativeUsd: cost.cumulativeUsd,   // CLI 가 알려 준 세션 누적 비용 (참고용)
    costPricedUsd: cost.pricedUsd,     // 이번 토큰 × 가격표 (확인용)
    numTurns: r.num_turns || 0,
    durationMs: r.duration_ms || 0,
    modelUsage: cost.modelUsage,       // 이번 실행분 모델별 사용량 (v1.4.5 전에는 세션 누적이었음)
    permissionDenials: r.permission_denials || [],
    raw: r,
  };
}

module.exports = { runClaude, sessionExists, MODEL, currentModel: () => settings.getModel(), claudeInfo, resolveClaudeBin };