@wooojin/forgen 0.1.0

package/dist/engine/term-normalizer.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Term normalizer — indexed matchTerms registry replacing SYNONYM_MAP.
+ *
+ * Why this module exists (T2 of the Round 3 plan):
+ *   The previous `expandTagsWithSynonyms` in solution-matcher.ts did:
+ *     1. forward lookup:  SYNONYM_MAP[tag]  → O(1)
+ *     2. reverse lookup:  Object.entries(SYNONYM_MAP).filter(...) → O(N)
+ *   The reverse sweep was called *inside* `calculateRelevance` which itself
+ *   runs once per solution, so expanding a single query against N solutions
+ *   cost O(N × M) where M is the synonym-map size. That is the hot-path
+ *   cost the plan targets.
+ *
+ *   This module pre-computes both directions as Maps at module load time,
+ *   so every lookup is O(1). The forward map (`canonicalToTerms`) is used
+ *   to expand a canonical into its family; the reverse map
+ *   (`termToCanonicals`) is used to find which canonical(s) a term belongs
+ *   to (a term may belong to more than one canonical — `mock` is both a
+ *   testing-family term and a dependency-injection-family term).
+ *
+ * Migration rules (T2 Task 2, Step 3 of the plan):
+ *   - The old SYNONYM_MAP had 32 top-level keys. This migration consolidates
+ *     them into 19 canonicals by merging Korean↔English duplicates (e.g.
+ *     `에러` was a key AND a value inside `error` — both directions now live
+ *     under a single `error` canonical's `matchTerms`). See the registry
+ *     block below for per-family merge notes; the `error`/`debug` split is
+ *     documented inline because it was reverted from an earlier round after
+ *     measurable baseline regression.
+ *   - Exact duplicates within a single `matchTerms` array are deduplicated
+ *     by the Set construction in `buildTermNormalizer`.
+ *   - Korean-English cross-mappings (the big 5.1.2 hotfix) are kept intact:
+ *     `에러` ↔ `error`, `핸들링` ↔ `handling`, `배포` ↔ `deploy`, etc.
+ *
+ *   Input normalization: `normalizeTerms` NFC-normalizes each input term at
+ *   entry. macOS HFS+ paths come back as NFD, and `fm.tags` from YAML can
+ *   occasionally arrive that way too — matching the same NFC strategy as
+ *   PR3's `term-matcher.ts` prevents silent lookup misses on Korean tags.
+ *
+ * Design contract (consumer-facing):
+ *   - `normalizeTerms(input)` is the replacement for
+ *     `expandTagsWithSynonyms(input)`. It returns a de-duplicated array.
+ *   - `canonicalToTerms` and `termToCanonicals` are exposed for callers
+ *     that want richer introspection (the ranking-log writer in T3 will
+ *     record "query term → matched canonical → sibling terms" for offline
+ *     explainability).
+ *   - `defaultNormalizer` is a pre-built instance from `DEFAULT_MATCH_TERMS`,
+ *     suitable for direct use in hot paths (matchSolutions, solution-reader,
+ *     solution-index). Tests can build their own via `buildTermNormalizer`.
+ */
+/**
+ * A single canonical group in the match-terms registry.
+ *
+ * `canonical` is the preferred term used for display/debug. `matchTerms`
+ * lists all synonyms that should pull the same family. The canonical
+ * itself does not need to appear in `matchTerms` — `buildTermNormalizer`
+ * always includes it in the expanded set.
+ */
+export interface MatchTermEntry {
+    canonical: string;
+    matchTerms: string[];
+}
+/**
+ * Pre-built lookup shape. `buildTermNormalizer` returns this; consumers
+ * call `normalizeTerms` in their hot path.
+ */
+export interface TermNormalizer {
+    /** canonical → full Set of terms (canonical + matchTerms). */
+    canonicalToTerms: Map<string, Set<string>>;
+    /**
+     * Any term (canonical OR matchTerm) → ordered list of canonicals it
+     * belongs to. Ordered to keep debug traces stable; a term usually
+     * belongs to 1 canonical, occasionally 2-3.
+     */
+    termToCanonicals: Map<string, string[]>;
+    /**
+     * Expand an input term list to the union of all related terms.
+     * Output is deduplicated. Unknown terms pass through unchanged.
+     *
+     * For each input term:
+     *   1. Include the term itself
+     *   2. Look up `termToCanonicals[term]` → list of canonicals
+     *   3. For each canonical, include `canonicalToTerms[canonical]`
+     *      (the full family)
+     */
+    normalizeTerms(input: string[]): string[];
+}
+/**
+ * Build a term normalizer from a list of `MatchTermEntry` records.
+ *
+ * Safe for runtime use and for tests (tests can pass custom entries to
+ * exercise edge cases without mutating `DEFAULT_MATCH_TERMS`).
+ */
+export declare function buildTermNormalizer(entries: MatchTermEntry[]): TermNormalizer;
+/**
+ * Default match-terms registry, ported 1:1 from the previous
+ * `SYNONYM_MAP` in `solution-matcher.ts`. Each entry captures one
+ * semantic family.
+ *
+ * Editing guidance:
+ *   - Adding a new canonical is safe — it extends coverage without
+ *     shifting existing ranks.
+ *   - Adding a matchTerm under an existing canonical pulls the new term
+ *     into the existing family. Check the bootstrap eval (`npm test --
+ *     solution-matcher-eval`) to confirm baseline metrics don't regress.
+ *   - Removing a matchTerm can drop recall for the corresponding query
+ *     shape. Update `ROUND3_BASELINE` and the plan doc if intentional.
+ *   - Korean-English cross-mapping (`에러` ↔ `error`) must not regress —
+ *     covered by the bilingual spot-checks in
+ *     `tests/term-normalizer.test.ts`.
+ */
+export declare const DEFAULT_MATCH_TERMS: MatchTermEntry[];
+/**
+ * Pre-built normalizer for the default registry. Modules that need the
+ * default behaviour should import this directly rather than calling
+ * `buildTermNormalizer(DEFAULT_MATCH_TERMS)` on every query.
+ */
+export declare const defaultNormalizer: TermNormalizer;

package/dist/engine/term-normalizer.js

@@ -0,0 +1,171 @@
+/**
+ * Term normalizer — indexed matchTerms registry replacing SYNONYM_MAP.
+ *
+ * Why this module exists (T2 of the Round 3 plan):
+ *   The previous `expandTagsWithSynonyms` in solution-matcher.ts did:
+ *     1. forward lookup:  SYNONYM_MAP[tag]  → O(1)
+ *     2. reverse lookup:  Object.entries(SYNONYM_MAP).filter(...) → O(N)
+ *   The reverse sweep was called *inside* `calculateRelevance` which itself
+ *   runs once per solution, so expanding a single query against N solutions
+ *   cost O(N × M) where M is the synonym-map size. That is the hot-path
+ *   cost the plan targets.
+ *
+ *   This module pre-computes both directions as Maps at module load time,
+ *   so every lookup is O(1). The forward map (`canonicalToTerms`) is used
+ *   to expand a canonical into its family; the reverse map
+ *   (`termToCanonicals`) is used to find which canonical(s) a term belongs
+ *   to (a term may belong to more than one canonical — `mock` is both a
+ *   testing-family term and a dependency-injection-family term).
+ *
+ * Migration rules (T2 Task 2, Step 3 of the plan):
+ *   - The old SYNONYM_MAP had 32 top-level keys. This migration consolidates
+ *     them into 19 canonicals by merging Korean↔English duplicates (e.g.
+ *     `에러` was a key AND a value inside `error` — both directions now live
+ *     under a single `error` canonical's `matchTerms`). See the registry
+ *     block below for per-family merge notes; the `error`/`debug` split is
+ *     documented inline because it was reverted from an earlier round after
+ *     measurable baseline regression.
+ *   - Exact duplicates within a single `matchTerms` array are deduplicated
+ *     by the Set construction in `buildTermNormalizer`.
+ *   - Korean-English cross-mappings (the big 5.1.2 hotfix) are kept intact:
+ *     `에러` ↔ `error`, `핸들링` ↔ `handling`, `배포` ↔ `deploy`, etc.
+ *
+ *   Input normalization: `normalizeTerms` NFC-normalizes each input term at
+ *   entry. macOS HFS+ paths come back as NFD, and `fm.tags` from YAML can
+ *   occasionally arrive that way too — matching the same NFC strategy as
+ *   PR3's `term-matcher.ts` prevents silent lookup misses on Korean tags.
+ *
+ * Design contract (consumer-facing):
+ *   - `normalizeTerms(input)` is the replacement for
+ *     `expandTagsWithSynonyms(input)`. It returns a de-duplicated array.
+ *   - `canonicalToTerms` and `termToCanonicals` are exposed for callers
+ *     that want richer introspection (the ranking-log writer in T3 will
+ *     record "query term → matched canonical → sibling terms" for offline
+ *     explainability).
+ *   - `defaultNormalizer` is a pre-built instance from `DEFAULT_MATCH_TERMS`,
+ *     suitable for direct use in hot paths (matchSolutions, solution-reader,
+ *     solution-index). Tests can build their own via `buildTermNormalizer`.
+ */
+/**
+ * Build a term normalizer from a list of `MatchTermEntry` records.
+ *
+ * Safe for runtime use and for tests (tests can pass custom entries to
+ * exercise edge cases without mutating `DEFAULT_MATCH_TERMS`).
+ */
+export function buildTermNormalizer(entries) {
+    const canonicalToTerms = new Map();
+    const termToCanonicals = new Map();
+    for (const entry of entries) {
+        // Canonical is always in its own family
+        const family = new Set([entry.canonical, ...entry.matchTerms]);
+        canonicalToTerms.set(entry.canonical, family);
+        // Reverse map: every term in the family points back to this canonical
+        for (const term of family) {
+            const existing = termToCanonicals.get(term) ?? [];
+            if (!existing.includes(entry.canonical)) {
+                existing.push(entry.canonical);
+            }
+            termToCanonicals.set(term, existing);
+        }
+    }
+    function normalizeTerms(input) {
+        const out = new Set();
+        for (const rawTerm of input) {
+            // NFC normalize on ingest — macOS NFD tags must not silently miss the
+            // NFC-encoded registry. Mirrors PR3 `term-matcher.ts` strategy.
+            const term = rawTerm.normalize('NFC');
+            out.add(term); // always include the original (post-normalize)
+            const canonicals = termToCanonicals.get(term);
+            if (!canonicals)
+                continue;
+            for (const canonical of canonicals) {
+                const family = canonicalToTerms.get(canonical);
+                if (!family)
+                    continue;
+                for (const related of family)
+                    out.add(related);
+            }
+        }
+        return [...out];
+    }
+    return { canonicalToTerms, termToCanonicals, normalizeTerms };
+}
+/**
+ * Default match-terms registry, ported 1:1 from the previous
+ * `SYNONYM_MAP` in `solution-matcher.ts`. Each entry captures one
+ * semantic family.
+ *
+ * Editing guidance:
+ *   - Adding a new canonical is safe — it extends coverage without
+ *     shifting existing ranks.
+ *   - Adding a matchTerm under an existing canonical pulls the new term
+ *     into the existing family. Check the bootstrap eval (`npm test --
+ *     solution-matcher-eval`) to confirm baseline metrics don't regress.
+ *   - Removing a matchTerm can drop recall for the corresponding query
+ *     shape. Update `ROUND3_BASELINE` and the plan doc if intentional.
+ *   - Korean-English cross-mapping (`에러` ↔ `error`) must not regress —
+ *     covered by the bilingual spot-checks in
+ *     `tests/term-normalizer.test.ts`.
+ */
+export const DEFAULT_MATCH_TERMS = [
+    // ── Frameworks / UI ──
+    { canonical: 'react', matchTerms: ['jsx', 'component', 'hook', 'useState', 'useEffect', '컴포넌트'] },
+    // ── Persistence ──
+    { canonical: 'database', matchTerms: ['db', 'sql', 'schema', 'migration', 'query', '데이터베이스', '스키마'] },
+    { canonical: 'migration', matchTerms: ['migrate', 'upgrade', '마이그레이션', '업그레이드'] },
+    // ── Testing ──
+    { canonical: 'test', matchTerms: ['testing', 'spec', 'vitest', 'jest', 'mocha', '테스트', '단위테스트'] },
+    // ── Languages ──
+    { canonical: 'typescript', matchTerms: ['ts', 'type', 'interface', 'generic'] },
+    // ── API / Network ──
+    { canonical: 'api', matchTerms: ['rest', 'graphql', 'endpoint', 'route'] },
+    { canonical: 'auth', matchTerms: ['authentication', 'authorization', 'login', 'session', 'jwt', '인증'] },
+    // ── DevOps ──
+    { canonical: 'docker', matchTerms: ['container', 'dockerfile', 'compose'] },
+    { canonical: 'ci', matchTerms: ['pipeline', 'workflow', 'actions'] },
+    { canonical: 'deploy', matchTerms: ['deployment', 'release', 'publish', '배포'] },
+    // ── Error / Debug ──
+    //
+    // Two canonicals kept distinct — debug tooling ≠ the error condition
+    // itself. Merging them pulled `디버깅`/`debugger`/`breakpoint` into query
+    // expansions of `error`, which inflated `starter-debugging-systematic`'s
+    // relevance on any generic error-handling query and flipped the ranking
+    // of `"proper error handling pattern"` to the wrong solution (baseline
+    // mrrAt5 dropped from 1.0 → 0.988). Splitting them back restores the
+    // old SYNONYM_MAP semantic: `error` includes `debug` (the verb/general
+    // concept) but NOT the debugging toolchain terms.
+    //
+    // Query-side impact: `"에러 핸들링"` still expands densely via the
+    // `error` + `handling` families; `"디버깅"` queries now expand via the
+    // dedicated `debug` family and no longer cross-contaminate error matches.
+    { canonical: 'error', matchTerms: ['bug', 'fix', 'debug', 'crash', 'exception', '에러', '오류', '버그', '예외'] },
+    { canonical: 'debug', matchTerms: ['debugger', 'breakpoint', '디버깅', '디버그'] },
+    // Handling is kept distinct from `error`: not every "handling" query is
+    // about errors (event handling, request handling), but they often co-occur.
+    { canonical: 'handling', matchTerms: ['handler', 'catch', 'try', 'recovery', '핸들링', '처리', '대응'] },
+    // ── Performance / Cache ──
+    //
+    // Merged `performance` + `성능` + `최적화` into one family — all three
+    // pulled overlapping `optimize`/`profiling`/`bottleneck` terms.
+    { canonical: 'performance', matchTerms: ['optimize', 'profiling', 'bottleneck', 'latency', '성능', '최적화', '프로파일링', '병목'] },
+    { canonical: 'cache', matchTerms: ['caching', 'memoize', 'invalidate', '캐시', '캐싱'] },
+    // ── Security ──
+    //
+    // Merged `security` + `보안` + `인증` overlap is handled by the `auth`
+    // canonical above. Security keeps the vulnerability family.
+    { canonical: 'security', matchTerms: ['vulnerability', 'injection', 'xss', 'csrf', '보안', '취약점'] },
+    // ── Refactoring / Architecture ──
+    //
+    // Merged `refactor` + `리팩토링`.
+    { canonical: 'refactor', matchTerms: ['cleanup', 'restructure', 'simplify', 'decompose', '리팩토링', '정리', '개선', '분리'] },
+    // ── Validation ──
+    { canonical: 'validation', matchTerms: ['validate', 'check', 'sanitize', '검증', '유효성'] },
+    // ── Logging ──
+    { canonical: 'logging', matchTerms: ['log', 'trace', 'monitor', '로깅', '로그'] },
+];
+/**
+ * Pre-built normalizer for the default registry. Modules that need the
+ * default behaviour should import this directly rather than calling
+ * `buildTermNormalizer(DEFAULT_MATCH_TERMS)` on every query.
+ */
+export const defaultNormalizer = buildTermNormalizer(DEFAULT_MATCH_TERMS);

package/dist/fgx.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * fgx — forgen --dangerously-skip-permissions 의 단축 명령
+ * 모든 인자를 그대로 전달하되, --dangerously-skip-permissions 를 자동 주입
+ */
+export {};

package/dist/fgx.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/**
+ * fgx — forgen --dangerously-skip-permissions 의 단축 명령
+ * 모든 인자를 그대로 전달하되, --dangerously-skip-permissions 를 자동 주입
+ */
+const args = process.argv.slice(2);
+// 이미 포함되어 있으면 중복 추가하지 않음
+if (!args.includes('--dangerously-skip-permissions')) {
+    args.unshift('--dangerously-skip-permissions');
+}
+// cli.ts 의 main 로직을 재사용
+import { prepareHarness, isFirstRun } from './core/harness.js';
+import { spawnClaude } from './core/spawn.js';
+async function main() {
+    // Security warning — fgx bypasses all Claude Code permission checks
+    console.warn('\n  ⚠  fgx: ALL permission checks are disabled (--dangerously-skip-permissions)');
+    console.warn('  ⚠  Claude Code will execute tools without asking for confirmation.');
+    console.warn('  ⚠  Use only in trusted environments.\n');
+    // fgx는 서브커맨드 없이 바로 Claude Code 실행 전용
+    const firstRun = isFirstRun();
+    if (firstRun) {
+        console.log('\n  Forgen — Setting up for the first time.\n');
+        console.log('  Creating ~/.forgen/ directory and default philosophy.');
+        console.log('  Run `forgen onboarding` afterwards to complete personalization.\n');
+    }
+    const context = await prepareHarness(process.cwd());
+    if (firstRun) {
+        console.log('  [Done] Initial setup complete.\n');
+    }
+    const v1 = context.v1;
+    console.log(`[forgen] Profile: ${v1.session ? `${v1.session.quality_pack}/${v1.session.autonomy_pack}` : 'onboarding needed'}`);
+    if (v1.session) {
+        console.log(`[forgen] Trust: ${v1.session.effective_trust_policy}`);
+    }
+    console.log('[forgen] Mode: dangerously-skip-permissions');
+    console.log('[forgen] Starting Claude Code...\n');
+    await spawnClaude(args, context);
+}
+main().catch((err) => {
+    console.error('[forgen] Error:', err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/forge/cli.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Forgen Forge — v1 CLI Handler
+ *
+ * forgen forge                  v1 onboarding (첫 실행) 또는 profile 요약
+ * forgen forge --profile        현재 v1 profile 표시
+ * forgen forge --export         Profile JSON 출력
+ * forgen forge --reset soft     Soft reset
+ * forgen forge --reset learning Learning reset
+ * forgen forge --reset full     Full reset
+ */
+export declare function handleForge(args: string[]): Promise<void>;

package/dist/forge/cli.js

@@ -0,0 +1,100 @@
+/**
+ * Forgen Forge — v1 CLI Handler
+ *
+ * forgen forge                  v1 onboarding (첫 실행) 또는 profile 요약
+ * forgen forge --profile        현재 v1 profile 표시
+ * forgen forge --export         Profile JSON 출력
+ * forgen forge --reset soft     Soft reset
+ * forgen forge --reset learning Learning reset
+ * forgen forge --reset full     Full reset
+ */
+import { loadProfile, profileExists } from '../store/profile-store.js';
+import { renderProfile } from '../renderer/inspect-renderer.js';
+import { runOnboarding } from './onboarding-cli.js';
+export async function handleForge(args) {
+    if (args.includes('--profile')) {
+        handleShowProfile();
+        return;
+    }
+    if (args.includes('--export')) {
+        handleExport();
+        return;
+    }
+    if (args.includes('--reset')) {
+        const level = args[args.indexOf('--reset') + 1] ?? 'soft';
+        await handleReset(level);
+        return;
+    }
+    // Default: profile이 있으면 보여주고, 없으면 onboarding
+    if (profileExists()) {
+        handleShowProfile();
+    }
+    else {
+        await runOnboarding();
+    }
+}
+function handleShowProfile() {
+    const profile = loadProfile();
+    if (!profile) {
+        console.log('\n  No v1 profile found. Run `forgen forge` or `forgen onboarding`.\n');
+        return;
+    }
+    console.log('\n' + renderProfile(profile) + '\n');
+}
+function handleExport() {
+    const profile = loadProfile();
+    if (!profile) {
+        console.log('{}');
+        return;
+    }
+    console.log(JSON.stringify(profile, null, 2));
+}
+async function handleReset(level) {
+    const validLevels = ['soft', 'learning', 'full'];
+    if (!validLevels.includes(level)) {
+        console.log(`  Invalid reset level: ${level}`);
+        console.log(`  Valid levels: ${validLevels.join(', ')}`);
+        return;
+    }
+    // 동적 import로 store 모듈 로드
+    const fs = await import('node:fs');
+    const { V1_PROFILE, V1_RULES_DIR, V1_EVIDENCE_DIR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR, V1_SOLUTIONS_DIR } = await import('../core/paths.js');
+    const deleteDirs = (dirs) => {
+        for (const dir of dirs) {
+            try {
+                fs.rmSync(dir, { recursive: true, force: true });
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            catch { /* ignore */ }
+        }
+    };
+    const deleteFile = (p) => {
+        try {
+            fs.unlinkSync(p);
+        }
+        catch { /* ignore */ }
+    };
+    if (level === 'soft') {
+        deleteFile(V1_PROFILE);
+        deleteDirs([V1_RULES_DIR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR]);
+        console.log('\n  Soft reset 완료. Profile + Rule + Recommendation + Session 초기화.');
+    }
+    else if (level === 'learning') {
+        deleteFile(V1_PROFILE);
+        deleteDirs([V1_RULES_DIR, V1_EVIDENCE_DIR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR]);
+        console.log('\n  Learning reset 완료. 개인 학습 전체 초기화.');
+    }
+    else if (level === 'full') {
+        deleteFile(V1_PROFILE);
+        deleteDirs([V1_RULES_DIR, V1_EVIDENCE_DIR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR, V1_SOLUTIONS_DIR]);
+        console.log('\n  Full reset 완료. Compound 포함 전체 초기화.');
+    }
+    // Reset 후 자동 온보딩 (interactive 환경에서만)
+    if (process.stdin.isTTY) {
+        console.log('  새 프로필을 생성합니다.\n');
+        await runOnboarding();
+    }
+    else {
+        console.log('  forgen forge 또는 forgen onboarding 으로 새 프로필을 생성하세요.\n');
+    }
+}

package/dist/forge/evidence-processor.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Forgen v1 — Evidence Processor
+ *
+ * 교정/관찰 → Evidence 생성 + facet 조정 제안 인터페이스.
+ * Migration Plan §5.4: 이 모듈의 "해석" 계층은 AI(Claude 세션)가 채운다.
+ * 여기서는 구조화된 입출력 인터페이스와 알고리즘 적용 함수만 정의.
+ */
+import type { CorrectionRequest, CorrectionResult, SessionLearningSummary, QualityFacets, AutonomyFacets } from '../store/types.js';
+/**
+ * 사용자 교정을 Evidence로 기록하고, 필요 시 temporary rule 생성.
+ * axis_hint는 AI(Claude 세션)가 제공하는 것을 전제.
+ */
+export declare function processCorrection(req: CorrectionRequest): CorrectionResult;
+/**
+ * SessionLearningSummary의 profile_delta_suggestion을 현재 facet에 적용.
+ * delta 값은 AI가 제안한 것이고, 이 함수는 clamp만 수행.
+ */
+export declare function applyFacetDelta(currentQuality: QualityFacets, currentAutonomy: AutonomyFacets, delta: SessionLearningSummary['profile_delta_suggestion']): {
+    quality: QualityFacets;
+    autonomy: AutonomyFacets;
+};

package/dist/forge/evidence-processor.js

@@ -0,0 +1,87 @@
+/**
+ * Forgen v1 — Evidence Processor
+ *
+ * 교정/관찰 → Evidence 생성 + facet 조정 제안 인터페이스.
+ * Migration Plan §5.4: 이 모듈의 "해석" 계층은 AI(Claude 세션)가 채운다.
+ * 여기서는 구조화된 입출력 인터페이스와 알고리즘 적용 함수만 정의.
+ */
+import { createEvidence, saveEvidence } from '../store/evidence-store.js';
+import { createRule, saveRule } from '../store/rule-store.js';
+// ── Correction → Evidence + Temporary Rule ──
+/**
+ * 사용자 교정을 Evidence로 기록하고, 필요 시 temporary rule 생성.
+ * axis_hint는 AI(Claude 세션)가 제공하는 것을 전제.
+ */
+export function processCorrection(req) {
+    // Evidence 기록
+    const evidence = createEvidence({
+        type: 'explicit_correction',
+        session_id: req.session_id,
+        source_component: 'Hooks',
+        summary: req.message,
+        axis_refs: req.axis_hint ? [req.axis_hint] : [],
+        confidence: 0.85, // explicit correction은 기본 높은 confidence
+        raw_payload: {
+            kind: req.kind,
+            target: req.target,
+            axis_hint: req.axis_hint,
+            // avoid-this는 현재 설정과 반대 방향의 교정 → mismatch 감지용
+            direction: req.kind === 'avoid-this' ? 'opposite' : 'same',
+        },
+    });
+    saveEvidence(evidence);
+    // fix-now, avoid-this → temporary session rule
+    let temporaryRule = null;
+    if (req.kind === 'fix-now' || req.kind === 'avoid-this') {
+        temporaryRule = createRule({
+            category: req.axis_hint === 'quality_safety' ? 'quality'
+                : req.axis_hint === 'autonomy' ? 'autonomy'
+                    : 'workflow',
+            scope: 'session',
+            trigger: req.target,
+            policy: req.message,
+            strength: req.kind === 'avoid-this' ? 'strong' : 'default',
+            source: 'explicit_correction',
+            evidence_refs: [evidence.evidence_id],
+            render_key: `${req.axis_hint ?? 'workflow'}.${req.target.toLowerCase().replace(/\s+/g, '-').slice(0, 30)}`,
+        });
+        saveRule(temporaryRule);
+    }
+    return {
+        temporary_rule: temporaryRule,
+        evidence_event_id: evidence.evidence_id,
+        recompose_required: temporaryRule !== null,
+        promotion_candidate: req.kind === 'prefer-from-now' || req.kind === 'avoid-this',
+    };
+}
+// ── Facet Delta 적용 (알고리즘 계층) ──
+/**
+ * SessionLearningSummary의 profile_delta_suggestion을 현재 facet에 적용.
+ * delta 값은 AI가 제안한 것이고, 이 함수는 clamp만 수행.
+ */
+export function applyFacetDelta(currentQuality, currentAutonomy, delta) {
+    if (!delta)
+        return { quality: { ...currentQuality }, autonomy: { ...currentAutonomy } };
+    const clamp = (v) => Math.max(0.0, Math.min(1.0, v));
+    const quality = { ...currentQuality };
+    if (delta.quality_safety) {
+        if (delta.quality_safety.verification_depth !== undefined)
+            quality.verification_depth = clamp(quality.verification_depth + delta.quality_safety.verification_depth);
+        if (delta.quality_safety.stop_threshold !== undefined)
+            quality.stop_threshold = clamp(quality.stop_threshold + delta.quality_safety.stop_threshold);
+        if (delta.quality_safety.change_conservatism !== undefined)
+            quality.change_conservatism = clamp(quality.change_conservatism + delta.quality_safety.change_conservatism);
+    }
+    const autonomy = { ...currentAutonomy };
+    if (delta.autonomy) {
+        if (delta.autonomy.confirmation_independence !== undefined)
+            autonomy.confirmation_independence = clamp(autonomy.confirmation_independence + delta.autonomy.confirmation_independence);
+        if (delta.autonomy.assumption_tolerance !== undefined)
+            autonomy.assumption_tolerance = clamp(autonomy.assumption_tolerance + delta.autonomy.assumption_tolerance);
+        if (delta.autonomy.scope_expansion_tolerance !== undefined)
+            autonomy.scope_expansion_tolerance = clamp(autonomy.scope_expansion_tolerance + delta.autonomy.scope_expansion_tolerance);
+        if (delta.autonomy.approval_threshold !== undefined)
+            autonomy.approval_threshold = clamp(autonomy.approval_threshold + delta.autonomy.approval_threshold);
+    }
+    return { quality, autonomy };
+}

package/dist/forge/mismatch-detector.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Forgen v1 — Pack Mismatch Detector
+ *
+ * rolling 3세션 mismatch score 계산.
+ * Authoritative spec: docs/plans/2026-04-03-forgen-onboarding-adaptation-spec.md §8
+ *
+ * 신호별 점수:
+ * - 반대 방향 explicit_correction: +2
+ * - session_summary가 반대 pack 성향 명시: +1
+ * - 같은 축 strong rule 2개+ 신규 생성: +1
+ *
+ * 후보 조건:
+ * - 최근 3세션 rolling sum >= 4 (축별)
+ * - 또는 최근 3세션에 같은 방향 explicit_correction 2회+
+ */
+import type { Evidence, Rule, QualityPack, AutonomyPack } from '../store/types.js';
+export interface MismatchSignal {
+    session_id: string;
+    axis: 'quality_safety' | 'autonomy';
+    score: number;
+    reason: string;
+}
+export interface MismatchResult {
+    quality_mismatch: boolean;
+    autonomy_mismatch: boolean;
+    quality_score: number;
+    autonomy_score: number;
+    signals: MismatchSignal[];
+}
+/**
+ * 단일 세션의 mismatch 신호를 계산.
+ *
+ * @param sessionId 세션 ID
+ * @param corrections 해당 세션의 explicit_correction evidence
+ * @param summaries 해당 세션의 session_summary evidence
+ * @param newStrongRules 해당 세션에서 신규 생성된 strong rule
+ * @param currentQuality 현재 quality pack
+ * @param currentAutonomy 현재 autonomy pack
+ */
+export declare function computeSessionSignals(sessionId: string, corrections: Evidence[], summaries: Evidence[], newStrongRules: Rule[], _currentQuality: QualityPack, _currentAutonomy: AutonomyPack): MismatchSignal[];
+/**
+ * 최근 3세션 rolling sum으로 mismatch 판정.
+ */
+export declare function detectMismatch(recentSignals: MismatchSignal[]): MismatchResult;