@wooojin/forgen 0.4.0 → 0.4.1

package/dist/hooks/stop-guard.js

@@ -22,7 +22,15 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import { readStdinJSON } from './shared/read-stdin.js';
-import { approve, blockStop, failOpenWithTracking } from './shared/hook-response.js';
+import { approve, approveWithWarning, blockStop, failOpenWithTracking } from './shared/hook-response.js';
+import { takeLastExtractionNotice } from '../core/extraction-notice.js';
+import { checkConclusionVerificationRatio } from '../checks/conclusion-verification-ratio.js';
+import { checkSelfScoreInflation } from '../checks/self-score-deflation.js';
+import { STATE_DIR } from '../core/paths.js';
+import { sanitizeId } from './shared/sanitize-id.js';
+import { detectRecallReferences } from '../core/recall-reference-detector.js';
+import { appendImplicitFeedback } from '../store/implicit-feedback-store.js';
+import { atomicWriteJSON } from './shared/atomic-write.js';
 import { recordHookTiming } from './shared/hook-timing.js';
 import { isHookEnabled } from './hook-config.js';
 import { loadActiveRules } from '../store/rule-store.js';
@@ -38,9 +46,9 @@ import { DEFAULT_STOP_TRIGGER_RE, DEFAULT_STOP_EXCLUDE_RE } from './shared/stop-
  * ADR-002 Meta 트리거(규칙 자동 강등)로 연결한다.
  */
 const STUCK_LOOP_THRESHOLD = 3;
-const BLOCK_COUNT_DIR = path.join(os.homedir(), '.forgen', 'state', 'enforcement', 'block-count');
-const DRIFT_LOG = path.join(os.homedir(), '.forgen', 'state', 'enforcement', 'drift.jsonl');
-const ACK_LOG = path.join(os.homedir(), '.forgen', 'state', 'enforcement', 'acknowledgments.jsonl');
+const BLOCK_COUNT_DIR = path.join(STATE_DIR, 'enforcement', 'block-count');
+const DRIFT_LOG = path.join(STATE_DIR, 'enforcement', 'drift.jsonl');
+const ACK_LOG = path.join(STATE_DIR, 'enforcement', 'acknowledgments.jsonl');
 /**
  * Spike scenarios.json 로더 — FORGEN_SPIKE_RULES 명시 시에만 로드.
  * H1 (2026-04-22): 이전에는 process.cwd()/tests/spike/... 를 기본 폴백했으나,
@@ -213,7 +221,7 @@ function evaluateVerifier(rule) {
  * 루트 밖 경로는 존재 여부와 무관하게 false 반환.
  */
 function artifactFresh(relOrAbs, maxAgeS) {
-    const homeBase = path.join(os.homedir(), '.forgen', 'state');
+    const homeBase = STATE_DIR;
     const projectBase = path.resolve(process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd(), '.forgen', 'state');
     const allowedRoots = [homeBase, projectBase];
     let p = relOrAbs;
@@ -397,22 +405,138 @@ export function getStuckLoopThreshold() {
         return env;
     return STUCK_LOOP_THRESHOLD;
 }
+/**
+ * H4 완결 (2026-04-24): recall_referenced emit 경로.
+ * Stop hook 에서 Claude 의 직전 응답 텍스트와 이 세션의 injection-cache 를 대조해,
+ * 주입된 솔루션 이름이 응답에 등장하면 `recall_referenced` 이벤트 기록. 동일
+ * 솔루션 중복 emit 방지용으로 injection-cache 의 해당 엔트리에 `_referenced: true`
+ * 플래그 세팅 후 atomic 재기록. fail-open — 어떤 단계든 throw 시 스킵.
+ */
+function emitRecallReferencesFailOpen(sessionId, lastMessage) {
+    try {
+        const cachePath = path.join(STATE_DIR, `injection-cache-${sanitizeId(sessionId)}.json`);
+        if (!fs.existsSync(cachePath))
+            return;
+        const raw = fs.readFileSync(cachePath, 'utf-8');
+        const cache = JSON.parse(raw);
+        const sols = Array.isArray(cache.solutions) ? cache.solutions : [];
+        if (sols.length === 0)
+            return;
+        const { newlyReferenced } = detectRecallReferences(lastMessage, sols);
+        if (newlyReferenced.length === 0)
+            return;
+        const now = new Date().toISOString();
+        for (const name of newlyReferenced) {
+            appendImplicitFeedback({
+                type: 'recall_referenced',
+                category: 'positive',
+                solution: name,
+                at: now,
+                sessionId,
+            });
+        }
+        // 중복 emit 방지 — cache 에 플래그 저장 후 재기록
+        const refSet = new Set(newlyReferenced);
+        const updated = {
+            ...cache,
+            solutions: sols.map((s) => (refSet.has(s.name) ? { ...s, _referenced: true } : s)),
+            updatedAt: now,
+        };
+        atomicWriteJSON(cachePath, updated, { mode: 0o600, dirMode: 0o700 });
+    }
+    catch {
+        /* fail-open */
+    }
+}
+/**
+ * TEST-2 support: post-tool-use 가 저장한 modified-files-{sessionId}.json 에서
+ * recentToolNames 윈도우를 로드. 파일이 없거나 깨져도 빈 배열로 fail-open.
+ */
+function loadRecentToolNames(sessionId) {
+    try {
+        const p = path.join(STATE_DIR, `modified-files-${sanitizeId(sessionId)}.json`);
+        if (!fs.existsSync(p))
+            return [];
+        const raw = fs.readFileSync(p, 'utf-8');
+        const data = JSON.parse(raw);
+        if (Array.isArray(data.recentToolNames)) {
+            return data.recentToolNames.filter((n) => typeof n === 'string');
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * H2: Stop hook approve 시 이전 세션의 auto-compound 추출 결과를 1회만 surface.
+ * takeLastExtractionNotice 가 null 이면 일반 approve, 아니면 systemMessage 포함.
+ */
+function approveWithOptionalExtractionNotice() {
+    const notice = takeLastExtractionNotice();
+    if (notice)
+        return approveWithWarning(notice);
+    return approve();
+}
 export async function main() {
     const started = Date.now();
     try {
         if (!isHookEnabled(HOOK_NAME)) {
-            console.log(approve());
+            console.log(approveWithOptionalExtractionNotice());
             return;
         }
         const input = await readStdinJSON();
         const lastMessage = readLastAssistantMessage(input);
         if (!lastMessage) {
-            console.log(approve());
+            console.log(approveWithOptionalExtractionNotice());
             return;
         }
+        // H4 완결: 응답 텍스트와 injection-cache 대조해 recall_referenced emit.
+        // block/approve 어느 경로이든 동일하게 기록 (참조는 응답 내용이 결정).
+        const sessionIdForRef = input?.session_id ?? 'unknown';
+        emitRecallReferencesFailOpen(sessionIdForRef, lastMessage);
+        // TEST-2/3: rule-free meta guards — FORGEN_USER_CONFIRMED=1 우회 공통.
+        if (process.env.FORGEN_USER_CONFIRMED !== '1') {
+            const sessionId = input?.session_id ?? 'unknown';
+            // TEST-2 (자가 점수 인플레이션): 숫자 점수 상승 선언 + 측정 도구 0회 → block.
+            // TEST-3 보다 강한 신호라 먼저 평가.
+            const recentTools = loadRecentToolNames(sessionId);
+            const score = checkSelfScoreInflation({ text: lastMessage, recentTools });
+            if (score.block) {
+                recordViolation({
+                    rule_id: 'builtin:self-score-inflation',
+                    session_id: sessionId,
+                    source: 'stop-guard',
+                    kind: 'block',
+                    message_preview: lastMessage.slice(0, 120),
+                });
+                const reasonText = `[forgen:stop-guard/self-score-inflation] ${score.reason}
+
+(Override this turn: set FORGEN_USER_CONFIRMED=1 (audited).)`;
+                console.log(blockStop(reasonText, 'rule:TEST-2 — self-score inflation'));
+                return;
+            }
+            // TEST-3: 결론/검증 비율 — Claude 가 실제 측정 도구는 돌렸지만 서술이
+            // 결론-편향이면 여전히 block.
+            const ratio = checkConclusionVerificationRatio({ text: lastMessage });
+            if (ratio.block) {
+                recordViolation({
+                    rule_id: 'builtin:conclusion-verification-ratio',
+                    session_id: sessionId,
+                    source: 'stop-guard',
+                    kind: 'block',
+                    message_preview: lastMessage.slice(0, 120),
+                });
+                const reasonText = `[forgen:stop-guard/conclusion-ratio] ${ratio.reason}
+
+(Override this turn: set FORGEN_USER_CONFIRMED=1 (audited).)`;
+                console.log(blockStop(reasonText, 'rule:TEST-3 — conclusion/verification ratio'));
+                return;
+            }
+        }
         const rules = loadStopRules();
         if (rules.length === 0) {
-            console.log(approve());
+            console.log(approveWithOptionalExtractionNotice());
             return;
         }
         const result = evaluateStop(lastMessage, rules);
@@ -421,7 +545,7 @@ export async function main() {
             // R9-PA2: 같은 session 에 pending block 이 있었다면 retract→pass 루프가
             // 실제 작동한 것 — acknowledgment 이벤트로 기록. block-count 는 cleanup.
             acknowledgeSessionBlocks(sessionId);
-            console.log(approve());
+            console.log(approveWithOptionalExtractionNotice());
             return;
         }
         const { hit, reason } = result;
@@ -433,7 +557,7 @@ export async function main() {
                 kind: 'correction',
                 message_preview: `[FORGEN_USER_CONFIRMED=1 bypass] ${lastMessage.slice(0, 100)}`,
             });
-            console.log(approve());
+            console.log(approveWithOptionalExtractionNotice());
             return;
         }
         // T2 signal: block 은 rule 위반 증거 — violations.jsonl 에 기록.
@@ -464,13 +588,13 @@ export async function main() {
                 message_preview: lastMessage.slice(0, 120),
             });
             resetBlockCount(sessionId, hit.id);
-            console.log(approve());
+            console.log(approveWithOptionalExtractionNotice());
             return;
         }
         console.log(blockStop(reasonWithHint, hit.system_tag));
     }
-    catch {
-        console.log(failOpenWithTracking(HOOK_NAME));
+    catch (e) {
+        console.log(failOpenWithTracking(HOOK_NAME, e));
     }
     finally {
         recordHookTiming(HOOK_NAME, Date.now() - started, 'Stop');

package/dist/hooks/subagent-tracker.js

@@ -86,5 +86,5 @@ async function main() {
 }
 main().catch((e) => {
     process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
-    console.log(failOpenWithTracking('subagent-tracker'));
+    console.log(failOpenWithTracking('subagent-tracker', e));
 });

package/dist/i18n/index.js

@@ -5,8 +5,7 @@
  * 사용자 대면 출력만 로케일에 따라 전환.
  */
 import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
+import { GLOBAL_CONFIG } from '../core/paths.js';
 // ── Pack Display Names ──
 const QUALITY_NAMES = {
     ko: { '보수형': '보수형', '균형형': '균형형', '속도형': '속도형' },
@@ -215,10 +214,9 @@ export function getLocale() { return _currentLocale; }
 /** GlobalConfig에서 locale을 읽어 설정. 없으면 'en' 기본값. */
 export function initLocaleFromConfig() {
     try {
-        const configPath = path.join(os.homedir(), '.forgen', 'config.json');
-        if (!fs.existsSync(configPath))
+        if (!fs.existsSync(GLOBAL_CONFIG))
             return;
-        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const config = JSON.parse(fs.readFileSync(GLOBAL_CONFIG, 'utf-8'));
         if (config.locale === 'ko' || config.locale === 'en') {
             _currentLocale = config.locale;
         }

package/dist/store/evidence-store.js

@@ -31,7 +31,18 @@ export function createEvidence(params) {
         raw_payload: params.raw_payload ?? {},
     };
 }
+/** TEST-4 / RC4: behavior_observation 의 summary 가 의미있는 내용을 담아야 분석 가능. */
+const MIN_BEHAVIOR_OBSERVATION_LEN = 20;
 export function saveEvidence(evidence) {
+    // TEST-4 / RC4: 빈/짧은 behavior_observation 은 저장 거부.
+    // 결함: ~/.forgen/me/behavior/*.json 다수에 summary="" 가 누적되어 학습 데이터가
+    // 분석 불가능한 형태로 쌓임. saveEvidence 가 마지막 게이트라 여기서 거른다.
+    // 다른 evidence type (explicit_correction, session_summary) 은 backward compat.
+    if (evidence.type === 'behavior_observation') {
+        const len = (evidence.summary ?? '').trim().length;
+        if (len < MIN_BEHAVIOR_OBSERVATION_LEN)
+            return;
+    }
     atomicWriteJSON(evidencePath(evidence.evidence_id), evidence, { pretty: true });
 }
 /**

package/dist/store/implicit-feedback-store.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Forgen v0.4.1 — Implicit Feedback Store (TEST-5)
+ *
+ * `~/.forgen/state/implicit-feedback.jsonl` 의 append/read.
+ *
+ * TEST-5 / RC5: 누적된 엔트리들이 `type` 문자열만 가지고 category 없이 섞여 있어
+ *   - drift_critical / drift_warning / revert_detected / repeated_edit / agent_* 가 한 스트림에 섞여
+ *   - 집계/쿼리 시 카테고리 enum 부재로 휴리스틱 문자열 매칭에 의존
+ *   - 스키마 검증이 없어 빈/잘못된 필드로 쓰여도 나중에 분석 불가
+ * 이 모듈은 category 필드를 **필수화**하고, 기존 레거시 라인은 read 시 `type→category`
+ * 백필로 보정한다. 새 write 는 category 없으면 drift/revert 계열은 **거부**한다.
+ */
+export declare const IMPLICIT_FEEDBACK_LOG: string;
+/**
+ * TEST-5/H4: 카테고리 enum.
+ *  - drift / revert: 네거티브 signal (schema 강제)
+ *  - edit / agent: 네거티브-ish signal (휴리스틱)
+ *  - positive: H4 양수 신호 — assist (recommendation_surfaced, recall_referenced)
+ */
+export type ImplicitFeedbackCategory = 'drift' | 'revert' | 'edit' | 'agent' | 'positive';
+export interface ImplicitFeedbackEntry {
+    type: string;
+    category: ImplicitFeedbackCategory;
+    sessionId?: string;
+    at: string;
+    [key: string]: unknown;
+}
+/** 호출지 입력 — category 선택적 (schema 가 허용하면 inference 로 채움). */
+export interface ImplicitFeedbackInput {
+    type: string;
+    category?: ImplicitFeedbackCategory;
+    sessionId?: string;
+    at: string;
+    [key: string]: unknown;
+}
+/** type → category 추론. 레거시 엔트리 마이그레이션과 호출지 기본값 계산에 공용. */
+export declare function inferCategoryFromType(type: string): ImplicitFeedbackCategory | null;
+/**
+ * TEST-5 메인 라이터. 내부에서 스키마 검증 후 append.
+ * drift/revert 스키마 위반 시 silent drop (hot path 에서 throw 금지).
+ * 반환값: 실제로 기록되었는지 (테스트 검증용).
+ */
+export declare function appendImplicitFeedback(entry: ImplicitFeedbackInput): boolean;
+/**
+ * TEST-5 리더. 세션 필터링 + 레거시 라인에 대한 lazy 마이그레이션 (category 백필).
+ * 디스크 상 파일은 건드리지 않고 읽기 시점에만 category 를 보정한다 — atomic-write
+ * 없이 append-only 로그를 rewrite 하면 race 위험이 있기 때문.
+ * 영구 백필은 `migrateImplicitFeedbackLog()` 를 명시적으로 호출한다.
+ */
+export declare function loadImplicitFeedback(sessionId: string): ImplicitFeedbackEntry[];
+/**
+ * 영구 마이그레이션 — 레거시 로그 파일을 읽어 category 백필 후 원자적으로 재기록.
+ * 마이그레이션 불가 라인 (type 도 category 도 없거나 inference 실패) 은 drop.
+ * 반환: { migrated: 백필된 라인 수, dropped: 버려진 라인 수 }
+ */
+export declare function migrateImplicitFeedbackLog(): {
+    migrated: number;
+    dropped: number;
+};

package/dist/store/implicit-feedback-store.js

@@ -0,0 +1,153 @@
+/**
+ * Forgen v0.4.1 — Implicit Feedback Store (TEST-5)
+ *
+ * `~/.forgen/state/implicit-feedback.jsonl` 의 append/read.
+ *
+ * TEST-5 / RC5: 누적된 엔트리들이 `type` 문자열만 가지고 category 없이 섞여 있어
+ *   - drift_critical / drift_warning / revert_detected / repeated_edit / agent_* 가 한 스트림에 섞여
+ *   - 집계/쿼리 시 카테고리 enum 부재로 휴리스틱 문자열 매칭에 의존
+ *   - 스키마 검증이 없어 빈/잘못된 필드로 쓰여도 나중에 분석 불가
+ * 이 모듈은 category 필드를 **필수화**하고, 기존 레거시 라인은 read 시 `type→category`
+ * 백필로 보정한다. 새 write 는 category 없으면 drift/revert 계열은 **거부**한다.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR } from '../core/paths.js';
+export const IMPLICIT_FEEDBACK_LOG = path.join(STATE_DIR, 'implicit-feedback.jsonl');
+/** type → category 추론. 레거시 엔트리 마이그레이션과 호출지 기본값 계산에 공용. */
+export function inferCategoryFromType(type) {
+    if (type === 'drift_critical' || type === 'drift_warning')
+        return 'drift';
+    if (type === 'revert_detected')
+        return 'revert';
+    if (type === 'repeated_edit')
+        return 'edit';
+    if (type.startsWith('agent_'))
+        return 'agent';
+    // H4: 양수 assist 신호 — 솔루션이 사용자에게 노출/참조되었음을 기록.
+    if (type === 'recommendation_surfaced' || type === 'recall_referenced')
+        return 'positive';
+    return null;
+}
+/**
+ * TEST-5 스키마 검증 — drift/revert 계열은 category 누락 시 쓰기 거부.
+ * agent/edit 은 fail-open (기존 호출지가 빠뜨려도 로깅 자체는 보존), 대신 inference
+ * 가 가능하면 자동 보정.
+ */
+function validateAndNormalize(entry) {
+    if (!entry.type || !entry.at)
+        return null;
+    const inferred = inferCategoryFromType(entry.type);
+    const category = entry.category ?? inferred;
+    // drift/revert/positive 는 schema 강제: 명시든 추론이든 올바른 카테고리여야 함.
+    if (entry.type === 'drift_critical' || entry.type === 'drift_warning') {
+        if (category !== 'drift')
+            return null;
+    }
+    if (entry.type === 'revert_detected') {
+        if (category !== 'revert')
+            return null;
+    }
+    if (entry.type === 'recommendation_surfaced' || entry.type === 'recall_referenced') {
+        if (category !== 'positive')
+            return null;
+    }
+    if (!category)
+        return null;
+    return { ...entry, category };
+}
+/**
+ * TEST-5 메인 라이터. 내부에서 스키마 검증 후 append.
+ * drift/revert 스키마 위반 시 silent drop (hot path 에서 throw 금지).
+ * 반환값: 실제로 기록되었는지 (테스트 검증용).
+ */
+export function appendImplicitFeedback(entry) {
+    const normalized = validateAndNormalize(entry);
+    if (!normalized)
+        return false;
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.appendFileSync(IMPLICIT_FEEDBACK_LOG, JSON.stringify(normalized) + '\n');
+        return true;
+    }
+    catch {
+        // fail-open: implicit feedback recording must not throw.
+        return false;
+    }
+}
+/**
+ * TEST-5 리더. 세션 필터링 + 레거시 라인에 대한 lazy 마이그레이션 (category 백필).
+ * 디스크 상 파일은 건드리지 않고 읽기 시점에만 category 를 보정한다 — atomic-write
+ * 없이 append-only 로그를 rewrite 하면 race 위험이 있기 때문.
+ * 영구 백필은 `migrateImplicitFeedbackLog()` 를 명시적으로 호출한다.
+ */
+export function loadImplicitFeedback(sessionId) {
+    try {
+        if (!fs.existsSync(IMPLICIT_FEEDBACK_LOG))
+            return [];
+        const lines = fs.readFileSync(IMPLICIT_FEEDBACK_LOG, 'utf-8').split('\n').filter(Boolean);
+        const entries = [];
+        for (const line of lines) {
+            try {
+                const raw = JSON.parse(line);
+                if (raw.sessionId !== sessionId)
+                    continue;
+                if (!raw.type || !raw.at)
+                    continue;
+                const category = raw.category ?? inferCategoryFromType(raw.type);
+                if (!category)
+                    continue;
+                entries.push({ ...raw, category });
+            }
+            catch {
+                /* skip malformed lines */
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 영구 마이그레이션 — 레거시 로그 파일을 읽어 category 백필 후 원자적으로 재기록.
+ * 마이그레이션 불가 라인 (type 도 category 도 없거나 inference 실패) 은 drop.
+ * 반환: { migrated: 백필된 라인 수, dropped: 버려진 라인 수 }
+ */
+export function migrateImplicitFeedbackLog() {
+    if (!fs.existsSync(IMPLICIT_FEEDBACK_LOG))
+        return { migrated: 0, dropped: 0 };
+    const lines = fs.readFileSync(IMPLICIT_FEEDBACK_LOG, 'utf-8').split('\n').filter(Boolean);
+    const out = [];
+    let migrated = 0;
+    let dropped = 0;
+    for (const line of lines) {
+        try {
+            const raw = JSON.parse(line);
+            if (!raw.type || !raw.at) {
+                dropped++;
+                continue;
+            }
+            if (raw.category) {
+                out.push(JSON.stringify(raw));
+                continue;
+            }
+            const inferred = inferCategoryFromType(raw.type);
+            if (!inferred) {
+                dropped++;
+                continue;
+            }
+            const repaired = { ...raw, category: inferred };
+            out.push(JSON.stringify(repaired));
+            migrated++;
+        }
+        catch {
+            dropped++;
+        }
+    }
+    // atomic replace via temp file
+    const tmp = `${IMPLICIT_FEEDBACK_LOG}.migrate.${process.pid}`;
+    fs.writeFileSync(tmp, out.length > 0 ? out.join('\n') + '\n' : '');
+    fs.renameSync(tmp, IMPLICIT_FEEDBACK_LOG);
+    return { migrated, dropped };
+}

package/dist/store/rule-store.js

@@ -33,6 +33,14 @@ export function createRule(params) {
 }
 export function saveRule(rule) {
     rule.updated_at = new Date().toISOString();
+    // v0.4.1 audit-trail 불변식: rule 저장 시 lifecycle state 가 null/undefined 이면
+    // active phase 기본값 주입. 이전에는 old rule 파일이 lifecycle 없이 존재해 쌤 이후
+    // audit trail (phase/violation_count/meta_promotions) 추적 불가 — 이번 세션에서
+    // suppressed rule 의 lifecycle=null 발견. initLifecycle 은 기존 값이 있으면 normalize,
+    // 없으면 phase='active' + counters=0 초기화.
+    if (!rule.lifecycle) {
+        rule.lifecycle = initLifecycle(rule);
+    }
     atomicWriteJSON(rulePath(rule.rule_id), rule, { pretty: true });
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooojin/forgen",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "preferGlobal": true,
   "main": "dist/lib.js",
   "types": "./dist/lib.d.ts",
@@ -30,7 +30,7 @@
     "postinstall": "node scripts/postinstall.js",
     "prepare": "npm run build",
     "prepublishOnly": "npm test",
-    "prepack": "node scripts/prepack-hooks.cjs"
+    "prepack": "npm run build && node scripts/prepack-hooks.cjs"
   },
   "author": "jang-ujin",
   "license": "MIT",

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://claude.ai/schemas/claude-plugin.json",
   "name": "forgen",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Claude Code harness — the more you use Claude, the better it gets",
   "author": {
     "name": "jang-ujin",