@wooojin/forgen 0.1.0

package/dist/preset/preset-manager.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Forgen v1 — Preset Manager
+ *
+ * pack + overlay + trust policy 합성 엔진.
+ * Authoritative spec: docs/plans/2026-04-03-forgen-preset-system-design.md §7
+ *
+ * 합성 순서:
+ * 1. 글로벌 안전 불변식
+ * 2. base pack
+ * 3. 개인 장기 overlay
+ * 4. 현재 세션 임시 overlay
+ * 5. runtime capability detection
+ * 6. effective trust policy 계산
+ *
+ * 충돌 해소: 세션 임시 > 개인 장기 > base pack (글로벌 안전은 hard constraint)
+ */
+import type { Profile, Rule, SessionEffectiveState, RuntimeCapabilityState, TrustPolicy } from '../store/types.js';
+declare const GLOBAL_SAFETY_RULES: Rule[];
+export interface TrustComputeResult {
+    effective: TrustPolicy;
+    warning: string | null;
+}
+export declare function computeEffectiveTrust(desired: TrustPolicy, runtime: RuntimeCapabilityState): TrustComputeResult;
+export declare function composeSession(params: {
+    session_id: string;
+    profile: Profile;
+    personalRules: Rule[];
+    sessionOverlays: Rule[];
+    runtime: RuntimeCapabilityState;
+}): SessionEffectiveState;
+export { GLOBAL_SAFETY_RULES };

package/dist/preset/preset-manager.js

@@ -0,0 +1,111 @@
+/**
+ * Forgen v1 — Preset Manager
+ *
+ * pack + overlay + trust policy 합성 엔진.
+ * Authoritative spec: docs/plans/2026-04-03-forgen-preset-system-design.md §7
+ *
+ * 합성 순서:
+ * 1. 글로벌 안전 불변식
+ * 2. base pack
+ * 3. 개인 장기 overlay
+ * 4. 현재 세션 임시 overlay
+ * 5. runtime capability detection
+ * 6. effective trust policy 계산
+ *
+ * 충돌 해소: 세션 임시 > 개인 장기 > base pack (글로벌 안전은 hard constraint)
+ */
+// ── Global Safety Invariants ──
+const GLOBAL_SAFETY_RULES = [
+    {
+        rule_id: 'global-no-credentials',
+        category: 'safety',
+        scope: 'me',
+        trigger: 'always',
+        policy: '.env, credentials, API 키를 절대 커밋하거나 노출하지 마라.',
+        strength: 'hard',
+        source: 'pack_overlay',
+        status: 'active',
+        evidence_refs: [],
+        render_key: 'safety.no_credentials',
+        created_at: '2026-01-01T00:00:00Z',
+        updated_at: '2026-01-01T00:00:00Z',
+    },
+    {
+        rule_id: 'global-no-destructive-unconfirmed',
+        category: 'safety',
+        scope: 'me',
+        trigger: 'destructive command detected',
+        policy: '파괴적 명령(rm -rf, DROP, force-push)은 사용자 확인 없이 실행하지 마라.',
+        strength: 'hard',
+        source: 'pack_overlay',
+        status: 'active',
+        evidence_refs: [],
+        render_key: 'safety.no_destructive_unconfirmed',
+        created_at: '2026-01-01T00:00:00Z',
+        updated_at: '2026-01-01T00:00:00Z',
+    },
+];
+// ── Trust Policy Computation ──
+const TRUST_ORDER = ['가드레일 우선', '승인 완화', '완전 신뢰 실행'];
+function trustRank(policy) {
+    return TRUST_ORDER.indexOf(policy);
+}
+export function computeEffectiveTrust(desired, runtime) {
+    // runtime capability → trust level 매핑
+    let runtimeTrust;
+    if (runtime.dangerous_skip_permissions) {
+        runtimeTrust = '완전 신뢰 실행';
+    }
+    else if (runtime.permission_mode === 'bypassed') {
+        runtimeTrust = '완전 신뢰 실행';
+    }
+    else if (runtime.permission_mode === 'relaxed') {
+        runtimeTrust = '승인 완화';
+    }
+    else {
+        runtimeTrust = '가드레일 우선';
+    }
+    // effective = min(desired, runtime) — runtime이 최상위 사실
+    const desiredRank = trustRank(desired);
+    const runtimeRank = trustRank(runtimeTrust);
+    if (runtimeRank < desiredRank) {
+        // runtime < desired → 세션 시작 시 안내
+        return {
+            effective: runtimeTrust,
+            warning: `Trust 하향: desired=${desired}, runtime=${runtimeTrust} (${runtime.permission_mode})`,
+        };
+    }
+    if (runtimeRank > desiredRank) {
+        // runtime > desired → 조용히 진행, effective만 상향
+        return { effective: runtimeTrust, warning: null };
+    }
+    return { effective: desired, warning: null };
+}
+// ── Session Effective State 합성 ──
+export function composeSession(params) {
+    const { session_id, profile, personalRules, sessionOverlays, runtime } = params;
+    // trust 계산
+    const trustResult = computeEffectiveTrust(profile.trust_preferences.desired_policy, runtime);
+    // rule 합성: global safety + personal + session overlay
+    const allRules = [...GLOBAL_SAFETY_RULES, ...personalRules, ...sessionOverlays];
+    const activeRuleIds = allRules.filter(r => r.status === 'active').map(r => r.rule_id);
+    const warnings = [];
+    if (trustResult.warning)
+        warnings.push(trustResult.warning);
+    return {
+        session_id,
+        profile_version: profile.model_version,
+        quality_pack: profile.base_packs.quality_pack,
+        autonomy_pack: profile.base_packs.autonomy_pack,
+        judgment_pack: profile.base_packs.judgment_pack,
+        communication_pack: profile.base_packs.communication_pack,
+        effective_trust_policy: trustResult.effective,
+        active_rule_ids: activeRuleIds,
+        temporary_overlays: sessionOverlays,
+        runtime_capability_state: runtime,
+        warnings,
+        started_at: new Date().toISOString(),
+        ended_at: null,
+    };
+}
+export { GLOBAL_SAFETY_RULES };

package/dist/renderer/inspect-renderer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Forgen v1 — Inspect Renderer
+ *
+ * forgen inspect profile/rules/evidence/session 출력 생성.
+ * Authoritative spec: docs/plans/2026-04-03-forgen-rule-renderer-spec.md §6
+ */
+import type { Profile, Rule, Evidence, SessionEffectiveState } from '../store/types.js';
+export declare function renderProfile(profile: Profile): string;
+export declare function renderRules(rules: Rule[]): string;
+export declare function renderEvidence(evidence: Evidence[]): string;
+export declare function renderSession(state: SessionEffectiveState): string;

package/dist/renderer/inspect-renderer.js

@@ -0,0 +1,123 @@
+/**
+ * Forgen v1 — Inspect Renderer
+ *
+ * forgen inspect profile/rules/evidence/session 출력 생성.
+ * Authoritative spec: docs/plans/2026-04-03-forgen-rule-renderer-spec.md §6
+ */
+import { initLocaleFromConfig, getLocale, qualityName, autonomyName, judgmentName, communicationName, trustName } from '../i18n/index.js';
+export function renderProfile(profile) {
+    initLocaleFromConfig();
+    const l = getLocale();
+    const lines = [
+        `Profile v${profile.model_version} | updated: ${profile.metadata.updated_at}`,
+        '',
+        `Quality pack: ${qualityName(profile.base_packs.quality_pack, l)}`,
+        `Autonomy pack: ${autonomyName(profile.base_packs.autonomy_pack, l)}`,
+        `Judgment pack: ${judgmentName(profile.base_packs.judgment_pack, l)}`,
+        `Communication pack: ${communicationName(profile.base_packs.communication_pack, l)}`,
+        `Trust policy: ${trustName(profile.trust_preferences.desired_policy, l)} (source: ${profile.trust_preferences.source})`,
+        '',
+        '── 4축 상위 score ──',
+        `  품질/안전: ${profile.axes.quality_safety.score.toFixed(2)} (confidence: ${profile.axes.quality_safety.confidence.toFixed(2)})`,
+        `  자율성:   ${profile.axes.autonomy.score.toFixed(2)} (confidence: ${profile.axes.autonomy.confidence.toFixed(2)})`,
+        `  판단철학: ${profile.axes.judgment_philosophy.score.toFixed(2)} (confidence: ${profile.axes.judgment_philosophy.confidence.toFixed(2)})`,
+        `  커뮤니케이션: ${profile.axes.communication_style.score.toFixed(2)} (confidence: ${profile.axes.communication_style.confidence.toFixed(2)})`,
+        '',
+        '── Quality facets ──',
+        `  verification_depth: ${profile.axes.quality_safety.facets.verification_depth.toFixed(2)}`,
+        `  stop_threshold: ${profile.axes.quality_safety.facets.stop_threshold.toFixed(2)}`,
+        `  change_conservatism: ${profile.axes.quality_safety.facets.change_conservatism.toFixed(2)}`,
+        '',
+        '── Autonomy facets ──',
+        `  confirmation_independence: ${profile.axes.autonomy.facets.confirmation_independence.toFixed(2)}`,
+        `  assumption_tolerance: ${profile.axes.autonomy.facets.assumption_tolerance.toFixed(2)}`,
+        `  scope_expansion_tolerance: ${profile.axes.autonomy.facets.scope_expansion_tolerance.toFixed(2)}`,
+        `  approval_threshold: ${profile.axes.autonomy.facets.approval_threshold.toFixed(2)}`,
+        '',
+        '── Judgment facets ──',
+        `  minimal_change_bias: ${profile.axes.judgment_philosophy.facets.minimal_change_bias.toFixed(2)}`,
+        `  abstraction_bias: ${profile.axes.judgment_philosophy.facets.abstraction_bias.toFixed(2)}`,
+        `  evidence_first_bias: ${profile.axes.judgment_philosophy.facets.evidence_first_bias.toFixed(2)}`,
+        '',
+        '── Communication facets ──',
+        `  verbosity: ${profile.axes.communication_style.facets.verbosity.toFixed(2)}`,
+        `  structure: ${profile.axes.communication_style.facets.structure.toFixed(2)}`,
+        `  teaching_bias: ${profile.axes.communication_style.facets.teaching_bias.toFixed(2)}`,
+    ];
+    return lines.join('\n');
+}
+export function renderRules(rules) {
+    const active = rules.filter(r => r.status === 'active');
+    const suppressed = rules.filter(r => r.status === 'suppressed');
+    const lines = [];
+    if (active.length > 0) {
+        lines.push(`── Active rules (${active.length}) ──`);
+        for (const r of active) {
+            lines.push(`  [${r.category}/${r.strength}] ${r.render_key} — ${r.policy}`);
+            lines.push(`    source: ${r.source} | evidence: ${r.evidence_refs.length}`);
+        }
+    }
+    if (suppressed.length > 0) {
+        lines.push('');
+        lines.push(`── Suppressed rules (${suppressed.length}) ──`);
+        for (const r of suppressed) {
+            lines.push(`  [${r.category}/${r.strength}] ${r.render_key} — ${r.policy}`);
+        }
+    }
+    if (lines.length === 0)
+        lines.push('No rules.');
+    return lines.join('\n');
+}
+export function renderEvidence(evidence) {
+    const corrections = evidence.filter(e => e.type === 'explicit_correction');
+    const observations = evidence.filter(e => e.type === 'behavior_observation');
+    const summaries = evidence.filter(e => e.type === 'session_summary');
+    const lines = [];
+    if (corrections.length > 0) {
+        lines.push(`── Explicit corrections (${corrections.length}) ──`);
+        for (const e of corrections.slice(0, 10)) {
+            lines.push(`  ${e.timestamp.slice(0, 10)} [${e.confidence.toFixed(2)}] ${e.summary}`);
+            if (e.candidate_rule_refs.length > 0)
+                lines.push(`    → rules: ${e.candidate_rule_refs.join(', ')}`);
+        }
+    }
+    if (observations.length > 0) {
+        lines.push('');
+        lines.push(`── Behavior observations (${observations.length}) ──`);
+        for (const e of observations.slice(0, 10)) {
+            lines.push(`  ${e.timestamp.slice(0, 10)} [${e.confidence.toFixed(2)}] ${e.summary}`);
+        }
+    }
+    if (summaries.length > 0) {
+        lines.push('');
+        lines.push(`── Session summaries (${summaries.length}) ──`);
+        for (const e of summaries.slice(0, 5)) {
+            lines.push(`  ${e.timestamp.slice(0, 10)} [${e.confidence.toFixed(2)}] ${e.summary}`);
+        }
+    }
+    if (lines.length === 0)
+        lines.push('No evidence.');
+    return lines.join('\n');
+}
+export function renderSession(state) {
+    initLocaleFromConfig();
+    const l = getLocale();
+    const lines = [
+        `Session: ${state.session_id}`,
+        `Quality: ${qualityName(state.quality_pack, l)} | Autonomy: ${autonomyName(state.autonomy_pack, l)} | Judgment: ${judgmentName(state.judgment_pack, l)} | Communication: ${communicationName(state.communication_pack, l)}`,
+        `Runtime: ${state.runtime_capability_state.permission_mode} (detected from: ${state.runtime_capability_state.detected_from})`,
+        `Effective trust: ${trustName(state.effective_trust_policy, l)}`,
+    ];
+    if (state.warnings.length > 0) {
+        lines.push(`Warnings: ${state.warnings.join('; ')}`);
+    }
+    if (state.temporary_overlays.length > 0) {
+        lines.push(`Temporary overlays: ${state.temporary_overlays.length}`);
+        for (const o of state.temporary_overlays) {
+            lines.push(`  - ${o.render_key}: ${o.policy}`);
+        }
+    }
+    lines.push(`Active rules: ${state.active_rule_ids.length}`);
+    lines.push(`Started: ${state.started_at}${state.ended_at ? ` | Ended: ${state.ended_at}` : ' (active)'}`);
+    return lines.join('\n');
+}

package/dist/renderer/rule-renderer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Forgen v1 — Rule Renderer
+ *
+ * Rule[] + SessionEffectiveState → Claude Code용 자연어 규칙 세트 변환.
+ * Authoritative spec: docs/plans/2026-04-03-forgen-rule-renderer-spec.md
+ *
+ * 파이프라인: filter → dedupe(render_key) → group(category) → order → template → budget
+ */
+import type { Rule, SessionEffectiveState, Profile } from '../store/types.js';
+export type RenderSurface = 'session_start' | 'recompose' | 'inspect';
+export interface RenderContext {
+    surface: RenderSurface;
+    max_rules: number;
+    max_chars: number;
+    include_pack_summary: boolean;
+}
+export declare const DEFAULT_CONTEXT: RenderContext;
+export declare function renderRules(rules: Rule[], state: SessionEffectiveState, _profile: Profile, ctx?: RenderContext): string;

package/dist/renderer/rule-renderer.js

@@ -0,0 +1,159 @@
+/**
+ * Forgen v1 — Rule Renderer
+ *
+ * Rule[] + SessionEffectiveState → Claude Code용 자연어 규칙 세트 변환.
+ * Authoritative spec: docs/plans/2026-04-03-forgen-rule-renderer-spec.md
+ *
+ * 파이프라인: filter → dedupe(render_key) → group(category) → order → template → budget
+ */
+import { initLocaleFromConfig, getLocale, qualityName, autonomyName, judgmentName, communicationName, RULE_RENDERER } from '../i18n/index.js';
+export const DEFAULT_CONTEXT = {
+    surface: 'session_start',
+    max_rules: 30,
+    max_chars: 4000,
+    include_pack_summary: true,
+};
+// ── Output Sections ──
+const SECTION_ORDER = ['Must Not', 'Working Defaults', 'When To Ask', 'How To Validate', 'How To Report'];
+const CATEGORY_TO_SECTION = {
+    safety: 'Must Not',
+    quality: 'How To Validate',
+    autonomy: 'When To Ask',
+    judgment: 'Working Defaults',
+    communication: 'How To Report',
+    workflow: 'Working Defaults',
+};
+// ── Dedupe: render_key 충돌 해소 ──
+const SCOPE_RANK = { session: 0, me: 1 };
+const STRENGTH_RANK = { hard: 0, strong: 1, default: 2, soft: 3 };
+const SOURCE_RANK = { explicit_correction: 0, onboarding: 1, behavior_inference: 2, pack_overlay: 3 };
+function dedupeByRenderKey(rules) {
+    const groups = new Map();
+    for (const r of rules) {
+        const existing = groups.get(r.render_key) ?? [];
+        existing.push(r);
+        groups.set(r.render_key, existing);
+    }
+    const result = [];
+    for (const group of groups.values()) {
+        if (group.length === 1) {
+            result.push(group[0]);
+            continue;
+        }
+        group.sort((a, b) => {
+            const scopeDiff = SCOPE_RANK[a.scope] - SCOPE_RANK[b.scope];
+            if (scopeDiff !== 0)
+                return scopeDiff;
+            const strengthDiff = STRENGTH_RANK[a.strength] - STRENGTH_RANK[b.strength];
+            if (strengthDiff !== 0)
+                return strengthDiff;
+            const sourceDiff = SOURCE_RANK[a.source] - SOURCE_RANK[b.source];
+            if (sourceDiff !== 0)
+                return sourceDiff;
+            const timeDiff = b.updated_at.localeCompare(a.updated_at);
+            if (timeDiff !== 0)
+                return timeDiff;
+            return a.rule_id.localeCompare(b.rule_id);
+        });
+        result.push(group[0]);
+    }
+    return result;
+}
+// ── Template ──
+function ruleToText(rule) {
+    // policy 필드가 이미 사람이 읽을 수 있는 문장이면 그대로 사용
+    // render_key로 템플릿을 찾을 수도 있지만 v1은 policy 직접 사용
+    return rule.policy;
+}
+function trustPolicySummary(policy) {
+    const s = RULE_RENDERER[getLocale()];
+    switch (policy) {
+        case '가드레일 우선': return s.trustGuardrails;
+        case '승인 완화': return s.trustRelaxed;
+        case '완전 신뢰 실행': return s.trustFullTrust;
+    }
+}
+function judgmentPackRules(pack) {
+    const s = RULE_RENDERER[getLocale()];
+    switch (pack) {
+        case '최소변경형': return s.judgmentMinimalChange;
+        case '구조적접근형': return s.judgmentStructural;
+        case '균형형': return s.judgmentBalanced;
+    }
+}
+function communicationPackRules(pack) {
+    const s = RULE_RENDERER[getLocale()];
+    switch (pack) {
+        case '간결형': return s.commConcise;
+        case '상세형': return s.commDetailed;
+        case '균형형': return s.commBalanced;
+    }
+}
+// ── Main Render ──
+export function renderRules(rules, state, _profile, ctx = DEFAULT_CONTEXT) {
+    // 1. active만 수집
+    const active = rules.filter(r => r.status === 'active');
+    // 2. dedupe by render_key
+    const deduped = dedupeByRenderKey(active);
+    // 3. hard constraints 먼저
+    const hardRules = deduped.filter(r => r.strength === 'hard');
+    const otherRules = deduped.filter(r => r.strength !== 'hard');
+    // 4. category별 그룹
+    const sections = new Map();
+    for (const name of SECTION_ORDER)
+        sections.set(name, []);
+    for (const rule of hardRules) {
+        sections.get('Must Not').push(ruleToText(rule));
+    }
+    for (const rule of otherRules) {
+        const section = CATEGORY_TO_SECTION[rule.category] ?? 'Working Defaults';
+        sections.get(section).push(ruleToText(rule));
+    }
+    // 5. trust policy + pack 기본 규칙 주입
+    if (ctx.include_pack_summary) {
+        sections.get('Working Defaults').unshift(`Trust: ${trustPolicySummary(state.effective_trust_policy)}`);
+        // judgment pack 기본 규칙
+        for (const rule of judgmentPackRules(state.judgment_pack)) {
+            sections.get('Working Defaults').push(rule);
+        }
+        // communication pack 기본 규칙
+        for (const rule of communicationPackRules(state.communication_pack)) {
+            sections.get('How To Report').push(rule);
+        }
+    }
+    // 6. 섹션 조립
+    const parts = [];
+    if (ctx.include_pack_summary) {
+        const l = getLocale();
+        parts.push(`[${qualityName(state.quality_pack, l)} quality / ${autonomyName(state.autonomy_pack, l)} autonomy / ${judgmentName(state.judgment_pack, l)} judgment / ${communicationName(state.communication_pack, l)} communication]`);
+    }
+    let totalChars = parts.reduce((sum, p) => sum + p.length, 0);
+    let totalRules = 0;
+    for (const name of SECTION_ORDER) {
+        const items = sections.get(name);
+        if (items.length === 0)
+            continue;
+        const header = `## ${name}`;
+        const body = items.map(item => `- ${item}`).join('\n');
+        const section = `${header}\n${body}`;
+        if (totalChars + section.length > ctx.max_chars)
+            break;
+        if (totalRules + items.length > ctx.max_rules)
+            break;
+        parts.push(section);
+        totalChars += section.length;
+        totalRules += items.length;
+    }
+    // 7. Evidence Collection 지시 (항상 포함, 로케일)
+    initLocaleFromConfig();
+    const ecStrings = RULE_RENDERER[getLocale()];
+    parts.push([
+        `## ${ecStrings.evidenceCollectionHeader}`,
+        ...ecStrings.evidenceCollectionRules.map(r => `- ${r}`),
+    ].join('\n'));
+    // 8. warnings
+    if (state.warnings.length > 0) {
+        parts.push(`## Warnings\n${state.warnings.map(w => `- ${w}`).join('\n')}`);
+    }
+    return parts.join('\n\n');
+}

package/dist/store/evidence-store.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Forgen v1 — Evidence Store
+ *
+ * explicit_correction, behavior_observation, session_summary CRUD.
+ * Authoritative schema: docs/plans/2026-04-03-forgen-data-model-storage-spec.md §4
+ */
+import type { Evidence, EvidenceType } from './types.js';
+export declare function createEvidence(params: {
+    type: EvidenceType;
+    session_id: string;
+    source_component: string;
+    summary: string;
+    axis_refs?: string[];
+    candidate_rule_refs?: string[];
+    confidence: number;
+    raw_payload?: Record<string, unknown>;
+}): Evidence;
+export declare function saveEvidence(evidence: Evidence): void;
+export declare function loadEvidence(evidenceId: string): Evidence | null;
+export declare function loadAllEvidence(): Evidence[];
+export declare function loadEvidenceBySession(sessionId: string): Evidence[];
+export declare function loadEvidenceByType(type: EvidenceType): Evidence[];
+export declare function loadRecentEvidence(limit?: number): Evidence[];

package/dist/store/evidence-store.js

@@ -0,0 +1,58 @@
+/**
+ * Forgen v1 — Evidence Store
+ *
+ * explicit_correction, behavior_observation, session_summary CRUD.
+ * Authoritative schema: docs/plans/2026-04-03-forgen-data-model-storage-spec.md §4
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { V1_EVIDENCE_DIR } from '../core/paths.js';
+import { atomicWriteJSON, safeReadJSON } from '../hooks/shared/atomic-write.js';
+function evidencePath(evidenceId) {
+    return path.join(V1_EVIDENCE_DIR, `${evidenceId}.json`);
+}
+export function createEvidence(params) {
+    return {
+        evidence_id: crypto.randomUUID(),
+        type: params.type,
+        session_id: params.session_id,
+        timestamp: new Date().toISOString(),
+        source_component: params.source_component,
+        summary: params.summary,
+        axis_refs: params.axis_refs ?? [],
+        candidate_rule_refs: params.candidate_rule_refs ?? [],
+        confidence: params.confidence,
+        raw_payload: params.raw_payload ?? {},
+    };
+}
+export function saveEvidence(evidence) {
+    atomicWriteJSON(evidencePath(evidence.evidence_id), evidence, { pretty: true });
+}
+export function loadEvidence(evidenceId) {
+    return safeReadJSON(evidencePath(evidenceId), null);
+}
+export function loadAllEvidence() {
+    if (!fs.existsSync(V1_EVIDENCE_DIR))
+        return [];
+    const items = [];
+    for (const file of fs.readdirSync(V1_EVIDENCE_DIR)) {
+        if (!file.endsWith('.json'))
+            continue;
+        const ev = safeReadJSON(path.join(V1_EVIDENCE_DIR, file), null);
+        if (ev)
+            items.push(ev);
+    }
+    return items;
+}
+export function loadEvidenceBySession(sessionId) {
+    return loadAllEvidence().filter(e => e.session_id === sessionId);
+}
+export function loadEvidenceByType(type) {
+    return loadAllEvidence().filter(e => e.type === type);
+}
+export function loadRecentEvidence(limit = 20) {
+    return loadAllEvidence()
+        .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+        .slice(0, limit);
+}

package/dist/store/profile-store.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Forgen v1 — Profile Store
+ *
+ * Profile CRUD. 4축 + facet + trust preferences.
+ * Authoritative schema: docs/plans/2026-04-03-forgen-data-model-storage-spec.md §2
+ */
+import type { Profile, QualityPack, AutonomyPack, JudgmentPack, CommunicationPack, TrustPolicy } from './types.js';
+export declare function createProfile(userId: string, qualityPack: QualityPack, autonomyPack: AutonomyPack, trustPolicy: TrustPolicy, trustSource: Profile['trust_preferences']['source'], judgmentPack?: JudgmentPack, communicationPack?: CommunicationPack): Profile;
+export declare function loadProfile(): Profile | null;
+export declare function saveProfile(profile: Profile): void;
+export declare function profileExists(): boolean;
+export declare function isV1Profile(data: unknown): data is Profile;

package/dist/store/profile-store.js

@@ -0,0 +1,53 @@
+/**
+ * Forgen v1 — Profile Store
+ *
+ * Profile CRUD. 4축 + facet + trust preferences.
+ * Authoritative schema: docs/plans/2026-04-03-forgen-data-model-storage-spec.md §2
+ */
+import * as fs from 'node:fs';
+import { V1_PROFILE } from '../core/paths.js';
+import { atomicWriteJSON, safeReadJSON } from '../hooks/shared/atomic-write.js';
+import { qualityCentroid, autonomyCentroid, judgmentCentroid, communicationCentroid, } from '../preset/facet-catalog.js';
+const MODEL_VERSION = '2.0';
+export function createProfile(userId, qualityPack, autonomyPack, trustPolicy, trustSource, judgmentPack = '균형형', communicationPack = '균형형') {
+    const now = new Date().toISOString();
+    return {
+        user_id: userId,
+        model_version: MODEL_VERSION,
+        axes: {
+            quality_safety: { score: 0.5, facets: qualityCentroid(qualityPack), confidence: 0.45 },
+            autonomy: { score: 0.5, facets: autonomyCentroid(autonomyPack), confidence: 0.45 },
+            judgment_philosophy: { score: 0.5, facets: judgmentCentroid(judgmentPack), confidence: 0.45 },
+            communication_style: { score: 0.5, facets: communicationCentroid(communicationPack), confidence: 0.45 },
+        },
+        base_packs: {
+            quality_pack: qualityPack,
+            autonomy_pack: autonomyPack,
+            judgment_pack: judgmentPack,
+            communication_pack: communicationPack,
+        },
+        trust_preferences: { desired_policy: trustPolicy, source: trustSource },
+        metadata: {
+            created_at: now,
+            updated_at: now,
+            last_onboarding_at: now,
+            last_reclassification_at: null,
+        },
+    };
+}
+export function loadProfile() {
+    return safeReadJSON(V1_PROFILE, null);
+}
+export function saveProfile(profile) {
+    profile.metadata.updated_at = new Date().toISOString();
+    atomicWriteJSON(V1_PROFILE, profile, { pretty: true });
+}
+export function profileExists() {
+    return fs.existsSync(V1_PROFILE);
+}
+export function isV1Profile(data) {
+    if (!data || typeof data !== 'object')
+        return false;
+    const p = data;
+    return typeof p.model_version === 'string' && p.model_version.startsWith('2.');
+}

package/dist/store/recommendation-store.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Forgen v1 — Pack Recommendation Store
+ *
+ * Authoritative schema: docs/plans/2026-04-03-forgen-data-model-storage-spec.md §6
+ */
+import type { PackRecommendation, QualityPack, AutonomyPack, JudgmentPack, CommunicationPack, TrustPolicy, RecommendationSource, RecommendationStatus } from './types.js';
+export declare function createRecommendation(params: {
+    source: RecommendationSource;
+    quality_pack: QualityPack;
+    autonomy_pack: AutonomyPack;
+    judgment_pack?: JudgmentPack;
+    communication_pack?: CommunicationPack;
+    suggested_trust_policy: TrustPolicy;
+    confidence: number;
+    reason_summary: string;
+}): PackRecommendation;
+export declare function saveRecommendation(rec: PackRecommendation): void;
+export declare function loadRecommendation(id: string): PackRecommendation | null;
+export declare function loadAllRecommendations(): PackRecommendation[];
+export declare function updateRecommendationStatus(id: string, status: RecommendationStatus): boolean;
+export declare function loadAcceptedRecommendation(): PackRecommendation | null;
+export declare function loadLatestRecommendation(): PackRecommendation | null;