@wooojin/forgen 0.4.7 → 0.4.9

package/dist/core/paths.d.ts

@@ -60,7 +60,15 @@ export declare const OUTCOMES_DIR: string;
 export declare const CANDIDATES_DIR: string;
 /** ~/.forgen/lab/archived/ — rollback destination for evolved solutions. */
 export declare const ARCHIVED_DIR: string;
-/** ~/.forgen/sessions/ — 세션 로그 */
+/**
+ * ~/.forgen/sessions/ — legacy session log directory (transcript-like).
+ *
+ * session-logger.ts 가 prepareHarness step 11 에서 한 줄짜리
+ * `{date}_{uuid}.json` 메타 파일을 기록. v1 의 SessionEffectiveState
+ * 와는 다른 책임이라 별 디렉토리 (V1_SESSIONS_DIR) 와 공존:
+ *   - SESSIONS_DIR (여기): 세션 발생 사실 + 시작/종료 시각 + cwd
+ *   - V1_SESSIONS_DIR     : profile + pack 합성 결과 (effective state)
+ */
 export declare const SESSIONS_DIR: string;
 /** ~/.forgen/config.json — 글로벌 설정 */
 export declare const GLOBAL_CONFIG: string;
@@ -72,7 +80,13 @@ export declare const LAB_DIR: string;
 export declare const FORGE_PROFILE: string;
 /** ~/.forgen/me/recommendations/ — Pack Recommendation */
 export declare const V1_RECOMMENDATIONS_DIR: string;
-/** ~/.forgen/state/sessions/ — Session Effective State */
+/**
+ * ~/.forgen/state/sessions/ — v1 Session Effective State.
+ *
+ * session-state-store.ts 가 매 세션마다 profile + active rules + pack
+ * 합성 결과를 `{sessionId}.json` 으로 기록. SESSIONS_DIR (legacy session
+ * log) 와는 다른 책임 (정합화는 v0.4.8 A3 참조).
+ */
 export declare const V1_SESSIONS_DIR: string;
 /** ~/.forgen/state/raw-logs/ — Raw Log */
 export declare const V1_RAW_LOGS_DIR: string;

package/dist/core/paths.js

@@ -65,7 +65,15 @@ export const OUTCOMES_DIR = path.join(STATE_DIR, 'outcomes');
 export const CANDIDATES_DIR = path.join(FORGEN_HOME, 'lab', 'candidates');
 /** ~/.forgen/lab/archived/ — rollback destination for evolved solutions. */
 export const ARCHIVED_DIR = path.join(FORGEN_HOME, 'lab', 'archived');
-/** ~/.forgen/sessions/ — 세션 로그 */
+/**
+ * ~/.forgen/sessions/ — legacy session log directory (transcript-like).
+ *
+ * session-logger.ts 가 prepareHarness step 11 에서 한 줄짜리
+ * `{date}_{uuid}.json` 메타 파일을 기록. v1 의 SessionEffectiveState
+ * 와는 다른 책임이라 별 디렉토리 (V1_SESSIONS_DIR) 와 공존:
+ *   - SESSIONS_DIR (여기): 세션 발생 사실 + 시작/종료 시각 + cwd
+ *   - V1_SESSIONS_DIR     : profile + pack 합성 결과 (effective state)
+ */
 export const SESSIONS_DIR = path.join(FORGEN_HOME, 'sessions');
 /** ~/.forgen/config.json — 글로벌 설정 */
 export const GLOBAL_CONFIG = path.join(FORGEN_HOME, 'config.json');
@@ -77,7 +85,13 @@ export const LAB_DIR = path.join(FORGEN_HOME, 'lab');
 export const FORGE_PROFILE = path.join(ME_DIR, 'forge-profile.json');
 /** ~/.forgen/me/recommendations/ — Pack Recommendation */
 export const V1_RECOMMENDATIONS_DIR = path.join(ME_DIR, 'recommendations');
-/** ~/.forgen/state/sessions/ — Session Effective State */
+/**
+ * ~/.forgen/state/sessions/ — v1 Session Effective State.
+ *
+ * session-state-store.ts 가 매 세션마다 profile + active rules + pack
+ * 합성 결과를 `{sessionId}.json` 으로 기록. SESSIONS_DIR (legacy session
+ * log) 와는 다른 책임 (정합화는 v0.4.8 A3 참조).
+ */
 export const V1_SESSIONS_DIR = path.join(STATE_DIR, 'sessions');
 /** ~/.forgen/state/raw-logs/ — Raw Log */
 export const V1_RAW_LOGS_DIR = path.join(STATE_DIR, 'raw-logs');

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

@@ -6,7 +6,18 @@
  * 외부 의존성 없음 — Node.js 22+ 내장 node:sqlite 사용.
  */
 /**
- * Transcript JSONL을 SQLite에 인덱싱.
+ * v0.4.8 (A1): Codex transcript JSONL 을 SQLite 에 인덱싱.
+ *
+ * Codex schema (Claude 와 다름):
+ *   {type: 'response_item', payload: {type: 'message', role: 'user'|'assistant',
+ *    content: [{type: 'input_text'|'output_text', text: '...'}]}}
+ *
+ * 결정 (v0.4.8 A1): Claude/Codex 통합 abstraction 대신 분기 함수 두 개로
+ * 처리. 미래에 host 가 추가될 때 통합 추상화로 리팩터.
+ */
+export declare function indexCodexSession(cwd: string, transcriptPath: string, sessionId: string): Promise<void>;
+/**
+ * Transcript JSONL을 SQLite에 인덱싱. (Claude schema)
  */
 export declare function indexSession(cwd: string, transcriptPath: string, sessionId: string): Promise<void>;
 /**

package/dist/core/session-store.js

@@ -10,6 +10,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { createLogger } from './logger.js';
 import { FORGEN_HOME } from './paths.js';
+import { ensureObservabilitySchema } from './observability-store.js';
 const require = createRequire(import.meta.url);
 // Suppress ExperimentalWarning for node:sqlite (Node.js 22+)
 {
@@ -31,6 +32,7 @@ function openDb() {
         // Node.js 22+ experimental node:sqlite
         const { DatabaseSync } = require('node:sqlite');
         const db = new DatabaseSync(DB_PATH);
+        db.exec(`PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA busy_timeout=1000;`);
         db.exec(`
       CREATE TABLE IF NOT EXISTS sessions (
         id TEXT PRIMARY KEY,
@@ -62,6 +64,8 @@ function openDb() {
             log.debug('FTS5 미지원 — LIKE 폴백 사용', e);
             fts5Available = false;
         }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ensureObservabilitySchema(db);
         return db;
     }
     catch (e) {
@@ -69,8 +73,80 @@ function openDb() {
         return null;
     }
 }
+/** Codex content array → flat string. content: [{type: 'input_text', text: ...}, ...] */
+function extractCodexText(content) {
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const item of content) {
+        if (item && typeof item === 'object' && 'text' in item && typeof item.text === 'string') {
+            parts.push(item.text);
+        }
+    }
+    return parts.join('\n').trim();
+}
+/**
+ * v0.4.8 (A1): Codex transcript JSONL 을 SQLite 에 인덱싱.
+ *
+ * Codex schema (Claude 와 다름):
+ *   {type: 'response_item', payload: {type: 'message', role: 'user'|'assistant',
+ *    content: [{type: 'input_text'|'output_text', text: '...'}]}}
+ *
+ * 결정 (v0.4.8 A1): Claude/Codex 통합 abstraction 대신 분기 함수 두 개로
+ * 처리. 미래에 host 가 추가될 때 통합 추상화로 리팩터.
+ */
+export async function indexCodexSession(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);
+                if (entry.type !== 'response_item' || !entry.payload)
+                    continue;
+                const role = entry.payload.role;
+                if (role !== 'user' && role !== 'assistant')
+                    continue;
+                const text = extractCodexText(entry.payload.content);
+                if (!text)
+                    continue;
+                const truncated = text.slice(0, 10000);
+                const ts = typeof entry.timestamp === 'string' ? entry.timestamp : '';
+                const result = insertMsg.run(sessionId, role, truncated, ts);
+                if (fts5Available) {
+                    try {
+                        db.prepare('INSERT INTO messages_fts(rowid, content) VALUES (?, ?)').run(result.lastInsertRowid, truncated);
+                    }
+                    catch { /* FTS sync failure */ }
+                }
+                messageCount++;
+            }
+            catch { /* skip malformed lines */ }
+        }
+        db.prepare('UPDATE sessions SET message_count = ? WHERE id = ?').run(messageCount, sessionId);
+        log.debug(`Codex 세션 인덱싱 완료: ${sessionId} (${messageCount} messages)`);
+    }
+    catch (e) {
+        log.debug('Codex 세션 인덱싱 실패', e);
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { /* ignore */ }
+    }
+}
 /**
- * Transcript JSONL을 SQLite에 인덱싱.
+ * Transcript JSONL을 SQLite에 인덱싱. (Claude schema)
  */
 export async function indexSession(cwd, transcriptPath, sessionId) {
     const db = openDb();

package/dist/core/spawn.d.ts

@@ -1,5 +1,22 @@
 import type { V1HarnessContext } from './harness.js';
 import type { RuntimeHost } from './types.js';
+/**
+ * Plan B-1: 세션 transcript 사후 스캔으로 rate-limit 감지.
+ *
+ * stdio='inherit' 라 Claude 출력을 직접 캡처할 수 없으므로,
+ * 세션 종료 후 transcript JSONL 의 마지막 N 라인을 읽어
+ * RATE_LIMIT_REGEX 매칭 여부를 확인한다.
+ *
+ * - transcript 없음 / 빈 파일 / parse 실패 → matched: false (fail-open)
+ * - 이미 pending-resume.json 존재 시 hook 이 먼저 잡은 것이므로 덮어쓰지 않음
+ *
+ * @param transcriptPath JSONL 파일 경로
+ * @param tailLines 검사할 마지막 라인 수 (기본 5)
+ */
+export declare function scanTranscriptForRateLimit(transcriptPath: string, tailLines?: number): Promise<{
+    matched: boolean;
+    resetAt: string | null;
+}>;
 /** Claude Code를 하네스 환경으로 실행. exit code를 반환. */
 export declare function spawnClaude(args: string[], context: V1HarnessContext, runtime?: RuntimeHost): Promise<number>;
 declare const MAX_RESUMES = 3;

package/dist/core/spawn.js

@@ -2,13 +2,16 @@ 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 * as crypto from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { buildEnv } from './config-injector.js';
 import { loadGlobalConfig } from './global-config.js';
 import { createLogger } from './logger.js';
-import { STATE_DIR } from './paths.js';
+import { STATE_DIR, ME_SOLUTIONS } from './paths.js';
 import { getHostRuntime } from '../host/host-runtime.js';
 import { sendNotification } from './notify.js';
+import { querySurfacedWithin, emitSolutionEvent } from './observability-store.js';
+import { parseSolutionV3 } from '../engine/solution-format.js';
 const log = createLogger('spawn');
 /** Phase 2: host-runtime 어댑터 위임. */
 function findRuntimeLauncher(runtime) {
@@ -139,6 +142,83 @@ async function countUserMessages(transcriptPath) {
     }
     return count;
 }
+/**
+ * Observability P2: commit-diff acted_on signal.
+ * 세션 시작 이후 생성된 commit 들의 diff 를 scan 하여 surfaced 솔루션과 키워드 매칭.
+ * 프라이버시: commit sha 는 SHA1 해시 12char prefix 만 저장, diff/path 내용 미저장.
+ */
+async function scanCommitDiffForActedOn(sessionId, cwd, sessionStartTime) {
+    try {
+        const surfaces = querySurfacedWithin(sessionId, 30); // 30분 window
+        if (surfaces.length === 0)
+            return;
+        const since = new Date(sessionStartTime).toISOString();
+        let logOutput;
+        try {
+            logOutput = execFileSync('git', ['log', '--since', since, '--pretty=format:%H'], {
+                cwd, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch {
+            return; // git not available or not a repo
+        }
+        const shas = logOutput.trim().split('\n').filter(Boolean);
+        if (shas.length === 0)
+            return;
+        const seen = new Set(); // (sha12+solutionId) dedup
+        for (const sha of shas) {
+            let diff;
+            try {
+                diff = execFileSync('git', ['show', '--unified=0', sha], {
+                    cwd, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            catch {
+                continue;
+            }
+            const diffLower = diff.toLowerCase();
+            const shaHash = crypto.createHash('sha1').update(sha).digest('hex').slice(0, 12);
+            for (const surf of surfaces) {
+                const dedupKey = `${shaHash}:${surf.solutionId}`;
+                if (seen.has(dedupKey))
+                    continue;
+                const filePath = path.join(ME_SOLUTIONS, `${surf.solutionId}.md`);
+                if (!fs.existsSync(filePath))
+                    continue;
+                let raw;
+                try {
+                    raw = fs.readFileSync(filePath, 'utf-8');
+                }
+                catch {
+                    continue;
+                }
+                const sol = parseSolutionV3(raw);
+                if (!sol)
+                    continue;
+                const tags = sol.frontmatter.tags ?? [];
+                const identifiers = sol.frontmatter.identifiers ?? [];
+                if (tags.length === 0 && identifiers.length === 0)
+                    continue;
+                const hit = tags.some(t => diffLower.includes(t.toLowerCase()))
+                    || identifiers.some(id => diffLower.includes(id.toLowerCase()));
+                if (!hit)
+                    continue;
+                seen.add(dedupKey);
+                emitSolutionEvent({
+                    sessionId,
+                    solutionId: surf.solutionId,
+                    eventType: 'acted_on',
+                    signalSource: 'commit-diff',
+                    signalScore: 0.30,
+                    meta: { commit_sha_hash: shaHash, surface_ts: surf.ts },
+                });
+            }
+        }
+    }
+    catch (e) {
+        log.debug('scanCommitDiffForActedOn 실패', e);
+    }
+}
 /**
  * 세션 종료 후 자동 compound 추출 + USER.md 업데이트.
  * auto-compound-runner.ts를 동기 실행하여 솔루션 추출 + 사용자 패턴 관찰.
@@ -160,16 +240,96 @@ async function runAutoCompound(cwd, transcriptPath, sessionId) {
 }
 /**
  * Transcript를 SQLite FTS5에 인덱싱 (추후 session-search MCP 도구용).
+ *
+ * v0.4.8 (A1): runtime 별 schema 차이로 분기. Claude 는 `entry.type === 'user'|
+ * 'assistant'`, Codex 는 `entry.type === 'response_item' && entry.payload.role`.
  */
-async function indexTranscriptToFTS(cwd, transcriptPath, sessionId) {
+async function indexTranscriptToFTS(cwd, transcriptPath, sessionId, runtime = 'claude') {
     try {
-        const { indexSession } = await import('./session-store.js');
-        await indexSession(cwd, transcriptPath, sessionId);
+        const store = await import('./session-store.js');
+        if (runtime === 'codex') {
+            await store.indexCodexSession(cwd, transcriptPath, sessionId);
+        }
+        else {
+            await store.indexSession(cwd, transcriptPath, sessionId);
+        }
     }
     catch (e) {
         log.debug('FTS5 인덱싱 실패 (session-store 미구현 시 정상)', e);
     }
 }
+/**
+ * Plan B-1: 세션 transcript 사후 스캔으로 rate-limit 감지.
+ *
+ * stdio='inherit' 라 Claude 출력을 직접 캡처할 수 없으므로,
+ * 세션 종료 후 transcript JSONL 의 마지막 N 라인을 읽어
+ * RATE_LIMIT_REGEX 매칭 여부를 확인한다.
+ *
+ * - transcript 없음 / 빈 파일 / parse 실패 → matched: false (fail-open)
+ * - 이미 pending-resume.json 존재 시 hook 이 먼저 잡은 것이므로 덮어쓰지 않음
+ *
+ * @param transcriptPath JSONL 파일 경로
+ * @param tailLines 검사할 마지막 라인 수 (기본 5)
+ */
+export async function scanTranscriptForRateLimit(transcriptPath, tailLines = 5) {
+    const notFound = { matched: false, resetAt: null };
+    if (!transcriptPath)
+        return notFound;
+    try {
+        if (!fs.existsSync(transcriptPath))
+            return notFound;
+        const { RATE_LIMIT_REGEX, parseRateLimitResetAt } = await import('../hooks/context-guard.js');
+        // tail: 파일 끝에서 tailLines 개 라인만 읽음 (대용량 transcript 효율)
+        const { createInterface } = await import('node:readline');
+        const stream = fs.createReadStream(transcriptPath, { encoding: 'utf-8' });
+        const rl = createInterface({ input: stream, crlfDelay: Infinity });
+        const lines = [];
+        for await (const line of rl) {
+            if (line)
+                lines.push(line);
+            if (lines.length > tailLines)
+                lines.shift();
+        }
+        rl.close();
+        stream.close();
+        if (lines.length === 0)
+            return notFound;
+        // 각 라인의 content/text/message 필드를 합쳐 regex 적용
+        const combined = lines
+            .map((line) => {
+            try {
+                const obj = JSON.parse(line);
+                const parts = [];
+                if (typeof obj.content === 'string')
+                    parts.push(obj.content);
+                if (typeof obj.text === 'string')
+                    parts.push(obj.text);
+                if (typeof obj.message === 'string')
+                    parts.push(obj.message);
+                // content 가 배열인 경우 (Claude JSONL block format)
+                if (Array.isArray(obj.content)) {
+                    for (const block of obj.content) {
+                        if (block && typeof block.text === 'string') {
+                            parts.push(block.text);
+                        }
+                    }
+                }
+                return parts.join(' ');
+            }
+            catch {
+                return '';
+            }
+        })
+            .join(' ');
+        if (!RATE_LIMIT_REGEX.test(combined))
+            return notFound;
+        const resetAt = parseRateLimitResetAt(combined);
+        return { matched: true, resetAt };
+    }
+    catch {
+        return notFound;
+    }
+}
 /** Claude Code를 하네스 환경으로 실행. exit code를 반환. */
 export async function spawnClaude(args, context, runtime = 'claude') {
     const launcher = findRuntimeLauncher(runtime);
@@ -225,11 +385,34 @@ export async function spawnClaude(args, context, runtime = 'claude') {
                     else {
                         sessionId = path.basename(transcript, '.jsonl');
                     }
-                    // 1. FTS5 인덱싱 (claude only — codex schema FTS 호환은 미검증, 별도 작업)
-                    if (runtime === 'claude') {
-                        await indexTranscriptToFTS(context.cwd, transcript, sessionId);
+                    // 1. FTS5 인덱싱 — v0.4.8 (A1) 부터 Claude/Codex 모두 지원.
+                    await indexTranscriptToFTS(context.cwd, transcript, sessionId, runtime);
+                    // 2. Plan B-1: transcript 사후 스캔으로 rate-limit 감지 (hook 미감지 보완)
+                    const resumePath = path.join(STATE_DIR, 'pending-resume.json');
+                    if (!fs.existsSync(resumePath)) {
+                        try {
+                            const scanResult = await scanTranscriptForRateLimit(transcript);
+                            if (scanResult.matched) {
+                                const marker = {
+                                    reason: 'rate-limit',
+                                    sessionId,
+                                    runtime,
+                                    resetAt: scanResult.resetAt,
+                                    savedAt: new Date().toISOString(),
+                                    cwd: context.cwd,
+                                    source: 'spawn-transcript-scan',
+                                };
+                                fs.writeFileSync(resumePath, JSON.stringify(marker, null, 2));
+                                log.debug(`transcript scan: rate-limit 감지 → pending-resume.json 작성`);
+                            }
+                        }
+                        catch (e) {
+                            log.debug('transcript rate-limit scan 실패 (fail-open)', e);
+                        }
                     }
-                    // 2. 자동 compound (10+ user 메시지인 경우만) — 양 runtime 호환
+                    // 3. Observability P2: commit-diff acted_on scan
+                    await scanCommitDiffForActedOn(sessionId, context.cwd, sessionStartTime);
+                    // 4. 자동 compound (10+ user 메시지인 경우만) — 양 runtime 호환
                     const userMsgCount = await countUserMessages(transcript);
                     if (userMsgCount >= 10) {
                         await runAutoCompound(context.cwd, transcript, sessionId);

package/dist/core/statusline-cli.js

@@ -17,6 +17,7 @@ import { execSync } from 'node:child_process';
 import { loadActiveRules } from '../store/rule-store.js';
 import { getUsageStats } from './usage-telemetry.js';
 import { STATE_DIR } from './paths.js';
+import { classifySolutions } from './lifecycle-classifier.js';
 // 0.4.6 perf #13 — statusline 출력을 5초 캐싱.
 // claude statusLine 은 짧은 간격으로 재호출되는데 매번 git/find/rule-store 를
 // 실행하면 ~100ms 누적. CACHE_TTL_MS 동안 동일 출력 재사용.
@@ -123,6 +124,30 @@ function buildLine1(payload, cwd) {
         parts.push(`${GREEN}${gitBranch}${RESET}`);
     return parts.join(`  ${DIM}|${RESET}  `);
 }
+/** Build lifecycle line: "🔥X 🟡X 🥶X 💀X 🌱X" — P3 신설. 0건이면 null */
+function buildLifecycleLine() {
+    try {
+        const classified = classifySolutions();
+        if (classified.length === 0)
+            return null;
+        const counts = { hot: 0, warm: 0, cold: 0, dead: 0, new: 0 };
+        for (const c of classified)
+            counts[c.lifecycle]++;
+        const total = counts.hot + counts.warm + counts.cold + counts.dead + counts.new;
+        if (total === 0)
+            return null;
+        return [
+            `${YELLOW}🔥${counts.hot}${RESET}`,
+            `${YELLOW}🟡${counts.warm}${RESET}`,
+            `${DIM}🥶${counts.cold}${RESET}`,
+            `${DIM}💀${counts.dead}${RESET}`,
+            `${DIM}🌱${counts.new}${RESET}`,
+        ].join(`  `);
+    }
+    catch {
+        return null;
+    }
+}
 /** Build usage line: "📊 87/5h · 412/wk (claude)" — 0.4.6 신설 */
 function buildUsageLine() {
     try {
@@ -193,6 +218,7 @@ export async function handleStatusline() {
     const line1 = buildLine1(payload, cwd);
     const line3 = buildLine3(claudeDir, cwd);
     const usageLine = buildUsageLine();
+    const lifecycleLine = buildLifecycleLine();
     // Line 2 (context/usage): stdin JSON spec 미확인으로 생략 — TODO
     // Line 4 (tool counts): 추적 인프라 없음 — TODO
     // Line 5 (active task): 추적 인프라 없음 — TODO
@@ -200,6 +226,13 @@ export async function handleStatusline() {
     console.log(line3);
     if (usageLine)
         console.log(usageLine);
-    const cacheBody = usageLine ? `${line1}\n${line3}\n${usageLine}\n` : `${line1}\n${line3}\n`;
+    if (lifecycleLine)
+        console.log(lifecycleLine);
+    const cacheLines = [line1, line3];
+    if (usageLine)
+        cacheLines.push(usageLine);
+    if (lifecycleLine)
+        cacheLines.push(lifecycleLine);
+    const cacheBody = cacheLines.join('\n') + '\n';
     writeCache(cacheBody);
 }

package/dist/core/v1-bootstrap.d.ts

@@ -18,6 +18,13 @@ export declare function ensureV1Directories(): void;
 export interface V1BootstrapResult {
     needsOnboarding: boolean;
     legacyBackupPath: string | null;
+    /**
+     * profile.json 이 존재했지만 parse/shape 오류로 사용 불가하여 v0.4.8
+     * 의 auto-repair 가 timestamp 백업으로 치워둔 경로. legacyBackupPath
+     * 와 의미가 다름 (legacy = model_version 구 버전 cutover, corrupt =
+     * 깨진 파일 격리).
+     */
+    corruptProfileBackupPath: string | null;
     session: SessionEffectiveState | null;
     renderedRules: string | null;
     profile: Profile | null;

package/dist/core/v1-bootstrap.js

@@ -15,10 +15,10 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as crypto from 'node:crypto';
-import { FORGEN_HOME, ME_DIR, ME_RULES, ME_BEHAVIOR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, STATE_DIR, V1_RAW_LOGS_DIR, ME_SOLUTIONS } from './paths.js';
+import { FORGEN_HOME, ME_DIR, ME_RULES, ME_BEHAVIOR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, STATE_DIR, V1_RAW_LOGS_DIR, ME_SOLUTIONS, SESSIONS_DIR } from './paths.js';
 import { checkLegacyProfile, runLegacyCutover } from './legacy-detector.js';
 import { detectRuntimeCapability } from './runtime-detector.js';
-import { loadProfile, profileExists } from '../store/profile-store.js';
+import { backupCorruptProfile, loadProfile, profileExists } from '../store/profile-store.js';
 import { loadActiveRules, cleanupStaleSessionRules, markRulesInjected } from '../store/rule-store.js';
 import { composeSession } from '../preset/preset-manager.js';
 import { renderRules, DEFAULT_CONTEXT } from '../renderer/rule-renderer.js';
@@ -27,7 +27,14 @@ import { loadEvidenceBySession } from '../store/evidence-store.js';
 import { computeSessionSignals, detectMismatch } from '../forge/mismatch-detector.js';
 import { createRecommendation, saveRecommendation } from '../store/recommendation-store.js';
 // ── Directory Initialization ──
-const V1_DIRS = [FORGEN_HOME, ME_DIR, ME_RULES, ME_BEHAVIOR, V1_RECOMMENDATIONS_DIR, STATE_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR, ME_SOLUTIONS];
+// v0.4.8 (A3): SESSIONS_DIR (~/.forgen/sessions/) 도 v1 bootstrap 보장 대상.
+// 이전엔 V1_DIRS 에 누락되어 있어, prepareHarness step 11 (startSessionLog)
+// 에 도달 못 하는 코드 경로 (예: forgen install 직접 실행) 에선 디렉토리가
+// 끝까지 생성되지 않았음. legacy session log 와 v1 effective state 는
+// 서로 다른 저장소 책임이라 두 dir 모두 명시 보장.
+//   - SESSIONS_DIR     = ~/.forgen/sessions/        ← legacy session log (transcript-like)
+//   - V1_SESSIONS_DIR  = ~/.forgen/state/sessions/  ← v1 effective state per session
+const V1_DIRS = [FORGEN_HOME, ME_DIR, ME_RULES, ME_BEHAVIOR, V1_RECOMMENDATIONS_DIR, STATE_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR, ME_SOLUTIONS, SESSIONS_DIR];
 export function ensureV1Directories() {
     for (const dir of V1_DIRS) {
         fs.mkdirSync(dir, { recursive: true });
@@ -48,6 +55,7 @@ export function bootstrapV1Session() {
         return {
             needsOnboarding: true,
             legacyBackupPath,
+            corruptProfileBackupPath: null,
             session: null,
             renderedRules: null,
             profile: null,
@@ -56,7 +64,20 @@ export function bootstrapV1Session() {
     }
     const profile = loadProfile();
     if (!profile) {
-        return { needsOnboarding: true, legacyBackupPath, session: null, renderedRules: null, profile: null, mismatch: null };
+        // v0.4.8 — corrupt/invalid profile auto-repair.
+        // profileExists()=true && loadProfile()=null 은 parse 실패 또는 v1
+        // shape 위반. 그대로 두면 다음 실행에서도 같은 분기로 빠지므로
+        // backup 후 새 onboarding 흐름을 강제.
+        const corruptProfileBackupPath = backupCorruptProfile();
+        return {
+            needsOnboarding: true,
+            legacyBackupPath,
+            corruptProfileBackupPath,
+            session: null,
+            renderedRules: null,
+            profile: null,
+            mismatch: null,
+        };
     }
     // 3. Runtime capability 감지
     const runtime = detectRuntimeCapability();
@@ -133,7 +154,7 @@ export function bootstrapV1Session() {
     try {
         // 세션 시작 로그
         const rawLogPath = path.join(V1_RAW_LOGS_DIR, `${sessionId}.jsonl`);
-        fs.appendFileSync(rawLogPath, JSON.stringify({
+        fs.appendFileSync(rawLogPath, `${JSON.stringify({
             event: 'session-started',
             session_id: sessionId,
             timestamp: new Date().toISOString(),
@@ -142,7 +163,7 @@ export function bootstrapV1Session() {
             judgment_pack: profile.base_packs.judgment_pack,
             communication_pack: profile.base_packs.communication_pack,
             effective_trust: session.effective_trust_policy,
-        }) + '\n');
+        })}\n`);
         // TTL sweep: 7일 이상 된 raw log 파일 삭제
         const TTL_MS = 7 * 24 * 60 * 60 * 1000;
         const now = Date.now();
@@ -163,6 +184,7 @@ export function bootstrapV1Session() {
     return {
         needsOnboarding: false,
         legacyBackupPath,
+        corruptProfileBackupPath: null,
         session,
         renderedRules,
         profile,