@wooojin/forgen 0.1.0

package/dist/core/session-logger.js

@@ -0,0 +1,111 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { SESSIONS_DIR } from './paths.js';
+import { createLogger } from './logger.js';
+const logger = createLogger('session-logger');
+/** 현재 세션 로그 파일 경로 (종료 시 업데이트에 사용) */
+let currentSessionPath = null;
+/** 세션 시작 시각 (duration 계산에 사용) */
+let sessionStartMs = null;
+/** exit/signal 리스너 등록 여부 (중복 등록 방지) */
+let isBound = false;
+/** UUID v4 생성 (node:crypto 활용) */
+function generateUUID() {
+    return crypto.randomUUID();
+}
+/** YYYY-MM-DD 형식의 날짜 문자열 반환 */
+function todayStr() {
+    return new Date().toISOString().slice(0, 10);
+}
+/**
+ * 세션 로그를 ~/.forgen/sessions/{date}_{sessionId}.json 에 기록
+ * harness.ts의 prepareHarness() 완료 후 호출
+ */
+export function startSessionLog(context) {
+    try {
+        // sessions 디렉토리가 없으면 생성
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+        const sessionId = generateUUID();
+        const startTime = new Date().toISOString();
+        sessionStartMs = Date.now();
+        // 모드 판별: 환경변수 또는 argv 기반
+        const mode = process.env.FORGEN_MODE ?? process.env.COMPOUND_MODE ?? 'default';
+        const log = {
+            sessionId,
+            startTime,
+            cwd: context.cwd,
+            philosophy: context.philosophy.name,
+            scope: context.scope.summary,
+            mode,
+        };
+        const filename = `${todayStr()}_${sessionId}.json`;
+        currentSessionPath = path.join(SESSIONS_DIR, filename);
+        fs.writeFileSync(currentSessionPath, JSON.stringify(log, null, 2));
+        // 오래된 세션 로그 정리 (90일+)
+        cleanOldSessions();
+        // 프로세스 종료 시 자동으로 endTime/duration 업데이트 (한 번만 등록)
+        if (!isBound) {
+            isBound = true;
+            process.on('exit', finalizeSessionLog);
+            process.on('SIGINT', () => {
+                finalizeSessionLog();
+                process.exit(0);
+            });
+            process.on('SIGTERM', () => {
+                finalizeSessionLog();
+                process.exit(0);
+            });
+        }
+    }
+    catch (e) {
+        logger.debug('세션 로그 시작 실패', e);
+    }
+}
+const RETENTION_DAYS = 90;
+/** 90일 이상 된 세션 로그 파일 삭제 */
+function cleanOldSessions() {
+    try {
+        if (!fs.existsSync(SESSIONS_DIR))
+            return;
+        const cutoff = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1000;
+        const files = fs.readdirSync(SESSIONS_DIR).filter(f => f.endsWith('.json'));
+        let deleted = 0;
+        for (const file of files) {
+            // 파일명에서 날짜 추출: YYYY-MM-DD_UUID.json
+            const dateStr = file.slice(0, 10);
+            const fileDate = new Date(dateStr).getTime();
+            if (!Number.isNaN(fileDate) && fileDate < cutoff) {
+                fs.unlinkSync(path.join(SESSIONS_DIR, file));
+                deleted++;
+            }
+        }
+        if (deleted > 0) {
+            logger.debug(`${deleted}개 오래된 세션 로그 정리 (${RETENTION_DAYS}일+)`);
+        }
+    }
+    catch (e) {
+        logger.debug('세션 로그 정리 실패', e);
+    }
+}
+/** 프로세스 종료 시 세션 로그에 endTime과 duration 추가 */
+function finalizeSessionLog() {
+    if (!currentSessionPath || !sessionStartMs)
+        return;
+    if (!fs.existsSync(currentSessionPath))
+        return;
+    try {
+        const raw = fs.readFileSync(currentSessionPath, 'utf-8');
+        const log = JSON.parse(raw);
+        const now = Date.now();
+        log.endTime = new Date(now).toISOString();
+        log.durationMs = now - sessionStartMs;
+        fs.writeFileSync(currentSessionPath, JSON.stringify(log, null, 2));
+    }
+    catch (e) {
+        logger.debug('세션 로그 종료 실패', e);
+    }
+    // 중복 호출 방지
+    currentSessionPath = null;
+    sessionStartMs = null;
+}

package/dist/core/session-store.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Forgen — Session Store (Node.js built-in SQLite)
+ *
+ * 세션 대화를 SQLite에 저장하여 과거 세션을 전문 검색할 수 있게 함.
+ * MCP session-search 도구가 이 데이터를 조회.
+ * 외부 의존성 없음 — Node.js 22+ 내장 node:sqlite 사용.
+ */
+/**
+ * Transcript JSONL을 SQLite에 인덱싱.
+ */
+export declare function indexSession(cwd: string, transcriptPath: string, sessionId: string): Promise<void>;
+/**
+ * 과거 세션 검색.
+ * FTS5 MATCH 우선 사용 (전문 검색, 순위 정렬).
+ * FTS5 미지원 시 LIKE 기반 폴백.
+ */
+export declare function searchSessions(query: string, limit?: number): Array<{
+    sessionId: string;
+    role: string;
+    content: string;
+    timestamp: string;
+    cwd: string;
+    tokens: string[];
+}>;
+/**
+ * 매칭 토큰 위치를 기준으로 컨텍스트 윈도우를 추출.
+ */
+export declare function extractContextWindow(content: string, tokens: string[], windowSize?: number): string;

package/dist/core/session-store.js

@@ -0,0 +1,218 @@
+/**
+ * Forgen — Session Store (Node.js built-in SQLite)
+ *
+ * 세션 대화를 SQLite에 저장하여 과거 세션을 전문 검색할 수 있게 함.
+ * MCP session-search 도구가 이 데이터를 조회.
+ * 외부 의존성 없음 — Node.js 22+ 내장 node:sqlite 사용.
+ */
+import { createRequire } from 'node:module';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createLogger } from './logger.js';
+import { FORGEN_HOME } from './paths.js';
+const require = createRequire(import.meta.url);
+// Suppress ExperimentalWarning for node:sqlite (Node.js 22+)
+{
+    const origWarningListeners = process.listeners('warning');
+    process.removeAllListeners('warning');
+    process.on('warning', (warning) => {
+        if (warning.name === 'ExperimentalWarning')
+            return;
+        for (const listener of origWarningListeners) {
+            listener(warning);
+        }
+    });
+}
+const log = createLogger('session-store');
+const DB_PATH = path.join(FORGEN_HOME, 'sessions.db');
+let fts5Available = false;
+function openDb() {
+    try {
+        // Node.js 22+ experimental node:sqlite
+        const { DatabaseSync } = require('node:sqlite');
+        const db = new DatabaseSync(DB_PATH);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        cwd TEXT NOT NULL,
+        started_at TEXT NOT NULL,
+        message_count INTEGER DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        timestamp TEXT NOT NULL
+      );
+    `);
+        // FTS5 가상 테이블 생성 (미지원 시 LIKE 폴백)
+        try {
+            db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+          content,
+          content=messages,
+          content_rowid=id,
+          tokenize='unicode61 remove_diacritics 2'
+        );
+      `);
+            fts5Available = true;
+        }
+        catch (e) {
+            log.debug('FTS5 미지원 — LIKE 폴백 사용', e);
+            fts5Available = false;
+        }
+        return db;
+    }
+    catch (e) {
+        log.debug('SQLite 초기화 실패 (Node.js 22+ 필요)', e);
+        return null;
+    }
+}
+/**
+ * Transcript JSONL을 SQLite에 인덱싱.
+ */
+export async function indexSession(cwd, transcriptPath, sessionId) {
+    const db = openDb();
+    if (!db)
+        return;
+    try {
+        const existing = db.prepare('SELECT id FROM sessions WHERE id = ?').get(sessionId);
+        if (existing)
+            return;
+        const content = fs.readFileSync(transcriptPath, 'utf-8');
+        const lines = content.split('\n').filter(Boolean);
+        db.prepare('INSERT INTO sessions (id, cwd, started_at, message_count) VALUES (?, ?, ?, 0)').run(sessionId, cwd, new Date().toISOString());
+        let messageCount = 0;
+        const insertMsg = db.prepare('INSERT INTO messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)');
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                let role = '';
+                let text = '';
+                if ((entry.type === 'user' || entry.type === 'queue-operation') && typeof entry.content === 'string') {
+                    role = 'user';
+                    text = entry.content;
+                }
+                else if (entry.type === 'assistant') {
+                    role = 'assistant';
+                    text = typeof entry.content === 'string'
+                        ? entry.content
+                        : Array.isArray(entry.content)
+                            ? entry.content.filter((c) => c.type === 'text').map((c) => c.text).join('\n')
+                            : '';
+                }
+                if (role && text) {
+                    const truncated = text.slice(0, 10000);
+                    const result = insertMsg.run(sessionId, role, truncated, entry.timestamp ?? '');
+                    // FTS5 인덱스 동기화
+                    if (fts5Available) {
+                        try {
+                            db.prepare('INSERT INTO messages_fts(rowid, content) VALUES (?, ?)').run(result.lastInsertRowid, truncated);
+                        }
+                        catch { /* FTS sync failure — search may miss this message */ }
+                    }
+                    messageCount++;
+                }
+            }
+            catch { /* skip malformed lines */ }
+        }
+        db.prepare('UPDATE sessions SET message_count = ? WHERE id = ?').run(messageCount, sessionId);
+        log.debug(`세션 인덱싱 완료: ${sessionId} (${messageCount} messages)`);
+    }
+    catch (e) {
+        log.debug('세션 인덱싱 실패', e);
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * 과거 세션 검색.
+ * FTS5 MATCH 우선 사용 (전문 검색, 순위 정렬).
+ * FTS5 미지원 시 LIKE 기반 폴백.
+ */
+export function searchSessions(query, limit = 10) {
+    const db = openDb();
+    if (!db)
+        return [];
+    const tokens = query
+        .split(/\s+/)
+        .map(t => t.toLowerCase())
+        .filter(t => t.length >= 2);
+    if (tokens.length === 0)
+        return [];
+    try {
+        let results;
+        if (fts5Available) {
+            // FTS5 MATCH — 전문 검색 + BM25 순위 정렬
+            const ftsQuery = tokens.map(t => `"${t.replace(/"/g, '""')}"`).join(' AND ');
+            results = db.prepare(`
+        SELECT m.session_id, m.role, m.content, m.timestamp, s.cwd
+        FROM messages_fts fts
+        JOIN messages m ON fts.rowid = m.id
+        JOIN sessions s ON m.session_id = s.id
+        WHERE messages_fts MATCH ?
+        ORDER BY fts.rank
+        LIMIT ?
+      `).all(ftsQuery, limit);
+        }
+        else {
+            // LIKE 폴백
+            const conditions = tokens.map(() => "LOWER(m.content) LIKE ? ESCAPE '\\'").join(' AND ');
+            const escapedTokens = tokens.map(t => t.replace(/%/g, '\\%').replace(/_/g, '\\_'));
+            const params = escapedTokens.map(t => `%${t}%`);
+            params.push(limit);
+            results = db.prepare(`
+        SELECT m.session_id, m.role, m.content, m.timestamp, s.cwd
+        FROM messages m
+        JOIN sessions s ON m.session_id = s.id
+        WHERE ${conditions}
+        ORDER BY m.id DESC
+        LIMIT ?
+      `).all(...params);
+        }
+        return results.map((r) => ({
+            sessionId: r.session_id,
+            role: r.role,
+            content: r.content,
+            timestamp: r.timestamp,
+            cwd: r.cwd,
+            tokens,
+        }));
+    }
+    catch (e) {
+        log.debug('세션 검색 실패', e);
+        return [];
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * 매칭 토큰 위치를 기준으로 컨텍스트 윈도우를 추출.
+ */
+export function extractContextWindow(content, tokens, windowSize = 120) {
+    const lower = content.toLowerCase();
+    const positions = [];
+    for (const token of tokens) {
+        const idx = lower.indexOf(token);
+        if (idx !== -1)
+            positions.push(idx);
+    }
+    if (positions.length === 0)
+        return content.slice(0, 200);
+    positions.sort((a, b) => a - b);
+    const center = positions[0];
+    const start = Math.max(0, center - windowSize);
+    const end = Math.min(content.length, center + windowSize);
+    const prefix = start > 0 ? '...' : '';
+    const suffix = end < content.length ? '...' : '';
+    return `${prefix}${content.slice(start, end)}${suffix}`;
+}

package/dist/core/settings-lock.d.ts

@@ -0,0 +1,18 @@
+import { CLAUDE_DIR, SETTINGS_PATH } from './paths.js';
+export { CLAUDE_DIR, SETTINGS_PATH };
+export declare const SETTINGS_BACKUP_PATH: string;
+/** lockfile 획득 (최대 3초 대기, 100ms 간격 재시도) */
+export declare function acquireLock(): void;
+/** lockfile 해제 */
+export declare function releaseLock(): void;
+/** 임시파일에 쓴 후 rename으로 원자적 교체 */
+export declare function atomicWriteFileSync(targetPath: string, data: string): void;
+/**
+ * settings.json 안전 읽기.
+ * 파일이 없으면 빈 객체 반환. 파싱 실패 시 Error throw (빈 설정 덮어쓰기 방지).
+ */
+export declare function readSettings(): Record<string, unknown>;
+/** settings.json 안전 쓰기. backup 생성 + lock + atomic write */
+export declare function writeSettings(settings: Record<string, unknown>): void;
+/** settings.json.forgen-backup 파일에서 원본 복원 */
+export declare function rollbackSettings(): boolean;

package/dist/core/settings-lock.js

@@ -0,0 +1,125 @@
+/**
+ * settings-lock — settings.json 동시접근 보호 유틸리티
+ *
+ * acquireLock/releaseLock + atomicWriteFileSync 패턴을
+ * settings.json을 조작하는 모든 모듈에서 재사용합니다.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createLogger } from './logger.js';
+import { CLAUDE_DIR, SETTINGS_PATH } from './paths.js';
+const log = createLogger('settings-lock');
+export { CLAUDE_DIR, SETTINGS_PATH };
+export const SETTINGS_BACKUP_PATH = path.join(CLAUDE_DIR, 'settings.json.forgen-backup');
+const SETTINGS_LOCK_PATH = path.join(CLAUDE_DIR, 'settings.json.lock');
+/** lockfile 내용에서 pid 추출 */
+function readLockPid() {
+    try {
+        const content = fs.readFileSync(SETTINGS_LOCK_PATH, 'utf-8').trim();
+        const pid = parseInt(content, 10);
+        return Number.isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+/** 프로세스가 살아있는지 확인 (signal 0 전송) */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** lockfile 획득 (최대 3초 대기, 100ms 간격 재시도) */
+export function acquireLock() {
+    const maxWaitMs = 3000;
+    const intervalMs = 100;
+    const start = Date.now();
+    while (Date.now() - start < maxWaitMs) {
+        try {
+            fs.writeFileSync(SETTINGS_LOCK_PATH, String(process.pid), { flag: 'wx' });
+            return; // 성공
+        }
+        catch {
+            // lock 파일이 이미 존재 — 대기 후 재시도
+            const elapsed = Date.now() - start;
+            if (elapsed + intervalMs >= maxWaitMs)
+                break;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, intervalMs);
+        }
+    }
+    // 타임아웃: lock을 잡고 있는 프로세스가 살아있는지 확인
+    const lockPid = readLockPid();
+    if (lockPid !== null && isProcessAlive(lockPid)) {
+        log.debug(`lockfile 타임아웃 — pid ${lockPid} 프로세스가 아직 활성 상태, 대기 중 강제 획득 보류`);
+        // 프로세스가 살아있으면 그래도 강제 획득 (데드락 방지)
+    }
+    else {
+        log.debug(`lockfile 타임아웃 — stale lock 감지 (pid: ${lockPid ?? 'unknown'}, 프로세스 종료됨)`);
+    }
+    fs.writeFileSync(SETTINGS_LOCK_PATH, String(process.pid));
+}
+/** lockfile 해제 */
+export function releaseLock() {
+    try {
+        fs.rmSync(SETTINGS_LOCK_PATH, { force: true });
+    }
+    catch { /* 이미 없으면 무시 */ }
+}
+/** 임시파일에 쓴 후 rename으로 원자적 교체 */
+export function atomicWriteFileSync(targetPath, data) {
+    const tmpPath = `${targetPath}.tmp.${process.pid}`;
+    fs.writeFileSync(tmpPath, data);
+    fs.renameSync(tmpPath, targetPath);
+}
+/**
+ * settings.json 안전 읽기.
+ * 파일이 없으면 빈 객체 반환. 파싱 실패 시 Error throw (빈 설정 덮어쓰기 방지).
+ */
+export function readSettings() {
+    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+    if (!fs.existsSync(SETTINGS_PATH))
+        return {};
+    const raw = fs.readFileSync(SETTINGS_PATH, 'utf-8');
+    return JSON.parse(raw); // 파싱 실패 시 throw → 호출자가 처리
+}
+/** settings.json 안전 쓰기. backup 생성 + lock + atomic write */
+export function writeSettings(settings) {
+    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+    acquireLock();
+    try {
+        if (fs.existsSync(SETTINGS_PATH)) {
+            fs.copyFileSync(SETTINGS_PATH, SETTINGS_BACKUP_PATH);
+        }
+        atomicWriteFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    }
+    finally {
+        releaseLock();
+    }
+}
+/** settings.json.forgen-backup 파일에서 원본 복원 */
+export function rollbackSettings() {
+    if (!fs.existsSync(SETTINGS_BACKUP_PATH))
+        return false;
+    acquireLock();
+    try {
+        // 현재 설정을 rollback 전 백업 (.pre-rollback) — 데이터 손실 방지
+        if (fs.existsSync(SETTINGS_PATH)) {
+            const preRollbackPath = `${SETTINGS_PATH}.pre-rollback`;
+            fs.copyFileSync(SETTINGS_PATH, preRollbackPath);
+        }
+        const backup = fs.readFileSync(SETTINGS_BACKUP_PATH, 'utf-8');
+        atomicWriteFileSync(SETTINGS_PATH, backup);
+        fs.rmSync(SETTINGS_BACKUP_PATH);
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        releaseLock();
+    }
+}

package/dist/core/spawn.d.ts

@@ -0,0 +1,3 @@
+import type { V1HarnessContext } from './harness.js';
+/** Claude Code를 하네스 환경으로 실행 */
+export declare function spawnClaude(args: string[], context: V1HarnessContext): Promise<void>;

package/dist/core/spawn.js

@@ -0,0 +1,135 @@
+import { spawn, execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { buildEnv } from './config-injector.js';
+import { loadGlobalConfig } from './global-config.js';
+import { createLogger } from './logger.js';
+const log = createLogger('spawn');
+/** claude CLI 경로 탐색 */
+function findClaude() {
+    return 'claude';
+}
+/**
+ * 가장 최근 transcript 파일을 찾는다.
+ * Claude Code는 세션 대화를 ~/.claude/projects/{sanitized-cwd}/{uuid}.jsonl에 저장.
+ */
+function findLatestTranscript(cwd) {
+    // Claude Code는 cwd의 /를 -로 치환하고 선행 -를 유지
+    const sanitized = cwd.replace(/\//g, '-');
+    const projectDir = path.join(os.homedir(), '.claude', 'projects', sanitized);
+    if (!fs.existsSync(projectDir))
+        return null;
+    const jsonlFiles = fs.readdirSync(projectDir)
+        .filter(f => f.endsWith('.jsonl'))
+        .map(f => ({ name: f, mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime);
+    return jsonlFiles.length > 0 ? path.join(projectDir, jsonlFiles[0].name) : null;
+}
+/**
+ * 세션 종료 후 자동 compound 추출 + USER.md 업데이트.
+ * auto-compound-runner.ts를 동기 실행하여 솔루션 추출 + 사용자 패턴 관찰.
+ */
+async function runAutoCompound(cwd, transcriptPath, sessionId) {
+    console.log('\n[forgen] 세션 분석 중... (자동 compound)');
+    const runnerPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'auto-compound-runner.js');
+    try {
+        execFileSync('node', [runnerPath, cwd, transcriptPath, sessionId], {
+            cwd,
+            timeout: 120_000,
+            stdio: ['pipe', 'inherit', 'inherit'],
+        });
+        console.log('[forgen] 자동 compound 완료\n');
+    }
+    catch (e) {
+        log.debug('auto-compound 실패', e);
+    }
+}
+/**
+ * Transcript를 SQLite FTS5에 인덱싱 (추후 session-search MCP 도구용).
+ */
+async function indexTranscriptToFTS(cwd, transcriptPath, sessionId) {
+    try {
+        const { indexSession } = await import('./session-store.js');
+        await indexSession(cwd, transcriptPath, sessionId);
+    }
+    catch (e) {
+        log.debug('FTS5 인덱싱 실패 (session-store 미구현 시 정상)', e);
+    }
+}
+/** Claude Code를 하네스 환경으로 실행 */
+export async function spawnClaude(args, context) {
+    const claudePath = findClaude();
+    const env = buildEnv(context.cwd);
+    const cleanArgs = [...args];
+    // config.json에서 dangerouslySkipPermissions 기본값 적용
+    const globalConfig = loadGlobalConfig();
+    if (globalConfig.dangerouslySkipPermissions && !cleanArgs.includes('--dangerously-skip-permissions')) {
+        cleanArgs.unshift('--dangerously-skip-permissions');
+    }
+    // 세션 시작 전 timestamp 기록 (종료 후 transcript 찾기 위해)
+    const sessionStartTime = Date.now();
+    return new Promise((resolve, reject) => {
+        const child = spawn(claudePath, cleanArgs, {
+            stdio: 'inherit',
+            env: { ...process.env, ...env },
+            cwd: context.cwd,
+        });
+        child.on('error', (err) => {
+            if (err.code === 'ENOENT') {
+                reject(new Error('Claude Code is not installed. npm install -g @anthropic-ai/claude-code'));
+            }
+            else {
+                reject(err);
+            }
+        });
+        child.on('exit', async (code) => {
+            // 세션 종료 후 하네스 작업
+            try {
+                const transcript = findLatestTranscript(context.cwd);
+                if (!transcript) {
+                    log.debug('transcript 파일을 찾을 수 없음');
+                }
+                else {
+                    const stat = fs.statSync(transcript);
+                    // 이 세션에서 생성/수정된 transcript만
+                    if (stat.mtimeMs <= sessionStartTime) {
+                        log.debug(`transcript mtime(${stat.mtimeMs}) <= sessionStart(${sessionStartTime}), 건너뜀`);
+                    }
+                    else {
+                        const sessionId = path.basename(transcript, '.jsonl');
+                        // 1. FTS5 인덱싱
+                        await indexTranscriptToFTS(context.cwd, transcript, sessionId);
+                        // 2. 자동 compound (10+ user 메시지인 경우만)
+                        const content = fs.readFileSync(transcript, 'utf-8');
+                        const userMsgCount = content.split('\n')
+                            .filter(l => { try {
+                            const t = JSON.parse(l).type;
+                            return t === 'user' || t === 'queue-operation';
+                        }
+                        catch {
+                            return false;
+                        } })
+                            .length;
+                        if (userMsgCount >= 10) {
+                            await runAutoCompound(context.cwd, transcript, sessionId);
+                        }
+                        else {
+                            console.log(`[forgen] 세션이 짧아 auto-compound 생략 (${userMsgCount} messages)`);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                console.error('[forgen] 세션 종료 후 처리 실패:', e instanceof Error ? e.message : e);
+            }
+            if (code === 0 || code === null) {
+                resolve();
+            }
+            else {
+                process.exit(code);
+            }
+        });
+    });
+}