@wooojin/forgen 0.4.13 → 0.5.5

package/dist/core/statusline-cli.d.ts

@@ -10,4 +10,11 @@
  * Line 4: (TODO: tool counts — 추적 인프라 없음)
  * Line 5: (TODO: active task — 추적 인프라 없음)
  */
+/**
+ * W1-2 (feature-audit 2026-07-21): forgen 가치 카운터 라인 — invisible 가치 가시화.
+ * native 플랜/토큰 usage(→ /usage, W2에서 물러남)가 아니라 forgen *자체 활동량*을
+ * 노출한다: recall 주입·surfaced·교정 캡처·ROI 강등·차단. 전부 computeStats()가 이미
+ * 실측 중인 카운터라 조작 위험 0. computeStats 실패 시 라인 생략(fail-open).
+ */
+export declare function buildValueLine(): string | null;
 export declare function handleStatusline(): Promise<void>;

package/dist/core/statusline-cli.js

@@ -15,9 +15,10 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 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';
+import { computeStats } from './stats-cli.js';
+import { loadRoiDemotions } from '../engine/roi-demotion.js';
 // 0.4.6 perf #13 — statusline 출력을 5초 캐싱.
 // claude statusLine 은 짧은 간격으로 재호출되는데 매번 git/find/rule-store 를
 // 실행하면 ~100ms 누적. CACHE_TTL_MS 동안 동일 출력 재사용.
@@ -148,18 +149,48 @@ function buildLifecycleLine() {
         return null;
     }
 }
-/** Build usage line: "📊 87/5h · 412/wk (claude)" — 0.4.6 신설 */
+/**
+ * ADR-010 W2-2: 사용량 세그먼트("📊 N/5h · N/wk") 제거 — native /usage 가
+ * plan limit 를 정확히 분해한다. 이관 사실을 딱 1회만 공지 (state flag).
+ */
 function buildUsageLine() {
     try {
-        const stats = getUsageStats();
-        if (stats.week.total === 0)
-            return null;
-        const dominant = stats.week.codex > stats.week.claude ? 'codex' : 'claude';
-        return [
-            `${YELLOW}📊 ${stats.hour5.total}/5h${RESET}`,
-            `${YELLOW}${stats.week.total}/wk${RESET}`,
-            `${DIM}(${dominant})${RESET}`,
-        ].join(`  ${DIM}·${RESET}  `);
+        const noticeFlag = path.join(STATE_DIR, 'usage-notice-shown');
+        if (!fs.existsSync(noticeFlag)) {
+            fs.mkdirSync(STATE_DIR, { recursive: true });
+            fs.writeFileSync(noticeFlag, new Date().toISOString());
+            return `${DIM}ℹ 사용량 표시는 native /usage 로 이동했습니다 (이 안내는 1회만 표시)${RESET}`;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * W1-2 (feature-audit 2026-07-21): forgen 가치 카운터 라인 — invisible 가치 가시화.
+ * native 플랜/토큰 usage(→ /usage, W2에서 물러남)가 아니라 forgen *자체 활동량*을
+ * 노출한다: recall 주입·surfaced·교정 캡처·ROI 강등·차단. 전부 computeStats()가 이미
+ * 실측 중인 카운터라 조작 위험 0. computeStats 실패 시 라인 생략(fail-open).
+ */
+export function buildValueLine() {
+    try {
+        let roiDemoted = 0;
+        try {
+            roiDemoted = Object.keys(loadRoiDemotions()).length;
+        }
+        catch { /* roi store 없음 → 0 */ }
+        const s = computeStats();
+        const a = s.assistToday;
+        const parts = [
+            `${YELLOW}✦${RESET}`,
+            `${DIM}recall${RESET} ${a.recallHits}`,
+            `${DIM}surfaced${RESET} ${a.surfaced}`,
+            `${DIM}교정${RESET} +${s.corrections7d}${DIM}(7d)${RESET}`,
+            `${DIM}ROI↓${RESET} ${roiDemoted}`,
+            `${DIM}차단${RESET} ${s.blocks7d}${DIM}(7d)${RESET}`,
+        ];
+        return parts.join(`  ${DIM}·${RESET}  `);
     }
     catch {
         return null;
@@ -204,7 +235,19 @@ function writeCache(content) {
     catch { /* fail-open */ }
 }
 export async function handleStatusline() {
-    // 캐시 hit 시 stdin payload 무시하고 바로 출력 (5초 윈도우 내 동일 출력 가정).
+    // W4-3 (ADR-010): hook stdin 엔 모델 필드가 없으므로 statusline 이 세션별
+    // 모델을 캐시 → Stop/SubagentStop 가드가 per-model 프로필 조회에 사용.
+    // 리뷰 SEV-2: 이 기록은 반드시 5초 표시-캐시 early-return **앞**에 있어야
+    // 한다 — /model 로 세션 중 모델을 바꾸면 cache-hit 렌더가 payload 를 아예
+    // 안 읽어 stale 모델(잘못된 가드 모드)이 유지되는 창이 생긴다.
+    // 필드 부재(구버전 CC 등) 시 기록 안 함 = 가드는 'unknown' → block 유지.
+    const payload = readStdinJson();
+    if (payload.session_id && payload.model?.id) {
+        const { cacheSessionModel } = await import('../checks/_shared/model-profile.js');
+        const { sanitizeId } = await import('../hooks/shared/sanitize-id.js');
+        cacheSessionModel(sanitizeId(payload.session_id), payload.model.id);
+    }
+    // 캐시 hit 시 표시만 캐시에서 (5초 윈도우 내 동일 출력 가정).
     // 라인 단위 cache → console.log 라인별 (테스트 호환).
     const cached = readCacheIfFresh();
     if (cached !== null) {
@@ -212,27 +255,28 @@ export async function handleStatusline() {
             console.log(line);
         return;
     }
-    const payload = readStdinJson();
     const cwd = payload.workspace?.current_dir ?? process.cwd();
     const claudeDir = path.join(os.homedir(), '.claude');
     const line1 = buildLine1(payload, cwd);
     const line3 = buildLine3(claudeDir, cwd);
     const usageLine = buildUsageLine();
+    const valueLine = buildValueLine(); // W1-2: forgen 가치 카운터
     const lifecycleLine = buildLifecycleLine();
-    // Line 2 (context/usage): stdin JSON spec 미확인으로 생략 — TODO
-    // Line 4 (tool counts): 추적 인프라 없음 — TODO
-    // Line 5 (active task): 추적 인프라 없음 — TODO
     console.log(line1);
     console.log(line3);
     if (usageLine)
         console.log(usageLine);
+    if (valueLine)
+        console.log(valueLine);
     if (lifecycleLine)
         console.log(lifecycleLine);
+    // W2-2: 1회 공지(usageLine)는 캐시에 넣지 않는다 — 캐시 재생 시
+    // "1회만" 약속이 5초 창 동안 반복 위반되는 실측 버그 방지.
     const cacheLines = [line1, line3];
-    if (usageLine)
-        cacheLines.push(usageLine);
+    if (valueLine)
+        cacheLines.push(valueLine);
     if (lifecycleLine)
         cacheLines.push(lifecycleLine);
-    const cacheBody = cacheLines.join('\n') + '\n';
+    const cacheBody = `${cacheLines.join('\n')}\n`;
     writeCache(cacheBody);
 }

package/dist/core/transcript-summary.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Transcript → 요약 텍스트 (순수, IO 없음 — 테스트 가능).
+ *
+ * auto-compound-runner 의 extractSummary 에서 분리(2026-08-04). 분리 이유: 실 Claude
+ * transcript 스키마 버그(text 가 `entry.message.content` 에 있는데 top-level `entry.content`
+ * 만 읽어 전 user/assistant 턴 누락 → auto-compound 가 실데이터에서 dead)를 회귀 테스트로
+ * 고정하기 위함. 러너 본문은 process.argv 실행부와 묶여 있어 직접 unit-test 불가였다.
+ *
+ * 스키마:
+ *   Claude: {type:'user'|'assistant', message:{role, content: string | [{type:'text',text}]}}
+ *           (일부 queue-operation 등은 top-level `content` 에 저장 → fallback)
+ *   Codex:  {type:'response_item', payload:{role, content:[{type:'input_text', text}]}}
+ */
+export declare function extractText(c: unknown): string;
+/** Codex content array → flat string. content: [{type:'input_text', text}] */
+export declare function extractCodexText(content: unknown): string;
+/** JSONL 원문 → `[User]/[Assistant]` 요약. maxChars 초과 시 조기 종료. */
+export declare function summarizeTranscript(rawText: string, maxChars?: number): string;

package/dist/core/transcript-summary.js

@@ -0,0 +1,81 @@
+/**
+ * Transcript → 요약 텍스트 (순수, IO 없음 — 테스트 가능).
+ *
+ * auto-compound-runner 의 extractSummary 에서 분리(2026-08-04). 분리 이유: 실 Claude
+ * transcript 스키마 버그(text 가 `entry.message.content` 에 있는데 top-level `entry.content`
+ * 만 읽어 전 user/assistant 턴 누락 → auto-compound 가 실데이터에서 dead)를 회귀 테스트로
+ * 고정하기 위함. 러너 본문은 process.argv 실행부와 묶여 있어 직접 unit-test 불가였다.
+ *
+ * 스키마:
+ *   Claude: {type:'user'|'assistant', message:{role, content: string | [{type:'text',text}]}}
+ *           (일부 queue-operation 등은 top-level `content` 에 저장 → fallback)
+ *   Codex:  {type:'response_item', payload:{role, content:[{type:'input_text', text}]}}
+ */
+export function extractText(c) {
+    if (typeof c === 'string')
+        return c;
+    if (Array.isArray(c)) {
+        return c
+            .filter((x) => typeof x === 'object' && x !== null && x.type === 'text')
+            .map((x) => (typeof x.text === 'string' ? x.text : ''))
+            .join('\n');
+    }
+    return '';
+}
+/** Codex content array → flat string. content: [{type:'input_text', text}] */
+export 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');
+}
+/** JSONL 원문 → `[User]/[Assistant]` 요약. maxChars 초과 시 조기 종료. */
+export function summarizeTranscript(rawText, maxChars = 8000) {
+    const lines = rawText.split('\n').filter(Boolean);
+    const messages = [];
+    let totalChars = 0;
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            // Claude schema — text 는 message.content 우선(실버그 수정), top-level 은 fallback.
+            if (entry.type === 'user' || entry.type === 'queue-operation') {
+                const text = extractText(entry.message?.content ?? entry.content);
+                if (text) {
+                    messages.push(`[User] ${text.slice(0, 500)}`);
+                    totalChars += text.length;
+                }
+            }
+            else if (entry.type === 'assistant') {
+                const text = extractText(entry.message?.content ?? entry.content);
+                if (text) {
+                    messages.push(`[Assistant] ${text.slice(0, 500)}`);
+                    totalChars += text.length;
+                }
+            }
+            // Codex schema
+            else if (entry.type === 'response_item' && entry.payload?.role === 'user') {
+                const text = extractCodexText(entry.payload.content);
+                if (text) {
+                    messages.push(`[User] ${text.slice(0, 500)}`);
+                    totalChars += text.length;
+                }
+            }
+            else if (entry.type === 'response_item' && entry.payload?.role === 'assistant') {
+                const text = extractCodexText(entry.payload.content);
+                if (text) {
+                    messages.push(`[Assistant] ${text.slice(0, 500)}`);
+                    totalChars += text.length;
+                }
+            }
+        }
+        catch { /* skip malformed line */ }
+        if (totalChars > maxChars)
+            break;
+    }
+    return messages.join('\n\n');
+}

package/dist/core/trust-layer-intent.d.ts

@@ -19,9 +19,29 @@ export interface CapabilityDeclaration {
     /** source-of-truth (spec 또는 외부 docs/source 인용). */
     readonly source?: string;
 }
-export type HostId = 'claude' | 'codex';
+/**
+ * 지원 host 의 정준 런타임 목록(단일 소스). `HostId` 는 여기서 파생되므로 새 host 추가 시
+ * 이 배열만 넓히면 타입·런타임이 함께 확장된다. 자유형 `host === 'claude'` 이진 비교 대신
+ * `(HOST_IDS as readonly string[]).includes(host)` 로 "유효 host 인지" 를 판정하라
+ * (W3-3 리뷰 SEV-3 #5: Record<HostId> 는 Record 리터럴만 강제, 자유비교는 미포착).
+ */
+export declare const HOST_IDS: readonly ["claude", "codex", "opencode"];
+export type HostId = (typeof HOST_IDS)[number];
+/**
+ * 능력 선언의 검증 수준 (W3-3 리뷰 SEV-3 #1).
+ *   - 'runtime': forgen 이 이 host 에서 실제로 강제/실행함(레퍼런스 host — claude).
+ *   - 'source' : host 의 hook schema 소스로 검증했고 forgen 배선 완료(codex).
+ *   - 'docs'   : host 문서 기반 선언이나 **forgen 배선 미완**(opencode P1 — plugin 슬림 전).
+ *
+ * status='supported' 의 의미가 host 마다 다른 문제를 구조화한다: 'runtime'/'source' 의
+ * supported 는 "forgen 이 강제함", 'docs' 의 supported 는 "플랫폼이 가능하나 forgen 미배선".
+ * 프로그램 소비자는 verificationLevel 로 둘을 게이트해야 한다(intentEnforced 참조).
+ */
+export type CapabilityVerificationLevel = 'runtime' | 'source' | 'docs';
 export interface HostCapabilities {
     readonly hostId: HostId;
+    /** 이 host 선언 전체의 검증 수준. 'docs' 면 아래 status 는 "플랫폼-가능"이지 "forgen-배선"이 아니다. */
+    readonly verificationLevel: CapabilityVerificationLevel;
     /**
      * 모든 TrustLayerIntent 에 대한 선언. `Record<TrustLayerIntent, _>` 타입이
      * 컴파일 타임에 누락을 차단한다.

package/dist/core/trust-layer-intent.js

@@ -16,6 +16,13 @@ export const TRUST_LAYER_INTENTS = [
     'forge-loop-state-inject',
     'self-evidence-record',
 ];
+/**
+ * 지원 host 의 정준 런타임 목록(단일 소스). `HostId` 는 여기서 파생되므로 새 host 추가 시
+ * 이 배열만 넓히면 타입·런타임이 함께 확장된다. 자유형 `host === 'claude'` 이진 비교 대신
+ * `(HOST_IDS as readonly string[]).includes(host)` 로 "유효 host 인지" 를 판정하라
+ * (W3-3 리뷰 SEV-3 #5: Record<HostId> 는 Record 리터럴만 강제, 자유비교는 미포착).
+ */
+export const HOST_IDS = ['claude', 'codex', 'opencode'];
 /**
  * 런타임 assertion — host adapter 가 새 의도 추가를 누락한 경우 fail.
  * 컴파일 타임 가드를 우회하는 동적 생성 코드를 위한 안전망.

package/dist/core/types.d.ts

@@ -1,3 +1,4 @@
+import type { HostId } from './trust-layer-intent.js';
 export interface Principle {
     belief: string;
     /**
@@ -106,8 +107,8 @@ export interface HarnessContext {
     /** 모델 라우팅 프리셋 (default, cost-saving, max-quality) */
     routingPreset?: string;
 }
-/** 런타임 Host */
-export type RuntimeHost = 'claude' | 'codex';
+/** 런타임 Host — 정식 정의는 `trust-layer-intent.ts` 의 HostId (Multi-Harness Adapter Plan P0). */
+export type RuntimeHost = HostId;
 /** 런칭 컨텍스트 — CLI에서 runtime/args 결정을 모델화 */
 export interface LaunchContext {
     runtime: RuntimeHost;

package/dist/core/uninstall.js

@@ -236,6 +236,10 @@ function cleanCompoundRules(cwd) {
         // v4.1+ consolidated
         'project-context.md',
         'routing.md',
+        // v0.5.0+ project-scoped (ADR-010 W1-3)
+        'v1-rules.md',
+        'forge-behavioral.md',
+        'user-profile.md',
         // legacy (v4.0 and earlier)
         'security.md',
         'golden-principles.md',
@@ -257,6 +261,14 @@ function cleanCompoundRules(cwd) {
         fs.unlinkSync(legacyPath);
         removedCount++;
     }
+    // 레거시 글로벌 사이드채널 (ADR-010 W1-3 이전 버전이 ~/.claude/rules/ 에 씀).
+    // 새 세션이 열리기 전에 uninstall 하는 경우 harness 마이그레이션이 못 지우므로
+    // 여기서도 회수한다 — 방치 시 언인스톨 후에도 전 세션에 주입된다.
+    const legacyGlobalBehavioral = path.join(os.homedir(), '.claude', 'rules', 'forge-behavioral.md');
+    if (fs.existsSync(legacyGlobalBehavioral)) {
+        fs.unlinkSync(legacyGlobalBehavioral);
+        removedCount++;
+    }
     if (removedCount > 0) {
         console.log(`  ✓ Removed ${removedCount} rule file(s)`);
     }

package/dist/core/usage-telemetry.d.ts

@@ -13,6 +13,7 @@
  * 0.4.6 신설. limit prediction 은 의도적으로 제외 — Anthropic 의 실제 limit 가
  * 계정/플랜별 가변이라 hard-code 부정확. raw count 만 노출하고 사용자가 판단.
  */
+import type { HostId } from './trust-layer-intent.js';
 export interface UsageStats {
     hour5: {
         claude: number;
@@ -25,7 +26,12 @@ export interface UsageStats {
         total: number;
     };
 }
-export declare function recordToolCall(runtime?: 'claude' | 'codex'): void;
+/**
+ * @deprecated ADR-010 W2-2 (2026-07-16): native `/usage` 가 plan limit 를
+ * skill/subagent/plugin/MCP 별로 정확히 분해하므로 forgen 의 raw count 는
+ * 중복 표면. 기록 중단(no-op shim — API 만 유지), v0.6.0 에서 모듈 삭제 예정.
+ */
+export declare function recordToolCall(_runtime?: HostId): void;
 /**
  * sliding window count. fail-open: 파일 미존재/parse 실패는 0 반환.
  *

package/dist/core/usage-telemetry.js

@@ -22,15 +22,13 @@ const TELEMETRY_PATH = path.join(STATE_DIR, 'usage-telemetry.jsonl');
 const HOUR5_MS = 5 * 60 * 60 * 1000;
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const PRUNE_THRESHOLD = 10_000; // 10K lines 누적 시 prune
-export function recordToolCall(runtime = 'claude') {
-    try {
-        fs.mkdirSync(STATE_DIR, { recursive: true });
-        const entry = { ts: Date.now(), rt: runtime };
-        fs.appendFileSync(TELEMETRY_PATH, `${JSON.stringify(entry)}\n`);
-    }
-    catch (e) {
-        log.debug('telemetry append 실패', e);
-    }
+/**
+ * @deprecated ADR-010 W2-2 (2026-07-16): native `/usage` 가 plan limit 를
+ * skill/subagent/plugin/MCP 별로 정확히 분해하므로 forgen 의 raw count 는
+ * 중복 표면. 기록 중단(no-op shim — API 만 유지), v0.6.0 에서 모듈 삭제 예정.
+ */
+export function recordToolCall(_runtime = 'claude') {
+    // no-op — 사용량 추적은 native /usage 로 이관됨.
 }
 /**
  * sliding window count. fail-open: 파일 미존재/parse 실패는 0 반환.

package/dist/core/v1-bootstrap.js

@@ -129,7 +129,7 @@ export function bootstrapV1Session() {
                 mismatchResult = detectMismatch(allSignals);
                 // mismatch 감지 시 재추천 생성
                 if (mismatchResult.quality_mismatch || mismatchResult.autonomy_mismatch) {
-                    session.warnings.push(`Pack mismatch 감지: quality=${mismatchResult.quality_score}, autonomy=${mismatchResult.autonomy_score}. forgen forge --reset soft 로 재설정하거나 forgen onboarding 으로 재추천을 받으세요.`);
+                    session.warnings.push(`Pack mismatch 감지: quality=${mismatchResult.quality_score}, autonomy=${mismatchResult.autonomy_score}. forgen forge --reset soft 로 재설정하거나 forgen forge --onboarding 으로 재추천을 받으세요.`);
                     const rec = createRecommendation({
                         source: 'mismatch_recommendation',
                         quality_pack: mismatchResult.quality_mismatch

package/dist/core/watch-cli.js

@@ -136,7 +136,7 @@ export async function handleWatch() {
             format: formatMatchEval,
         },
     ];
-    console.log(`\n  ${C.cyan}forgen watch${C.reset} — real-time event stream`);
+    console.log(`\n  ${C.cyan}forgen status --live${C.reset} — real-time event stream`);
     console.log(`  ${C.dim}Watching: hook-timing, violations, match-eval-log${C.reset}`);
     console.log(`  ${C.dim}Press Ctrl+C to stop${C.reset}\n`);
     // Show recent events (last 10 per source)

package/dist/engine/compound-extractor.js

@@ -21,6 +21,7 @@ import { getNewCommits, getCommitMessages, getGitDiff, getDiffStats } from './ex
 import { gate0, evaluateExtractedSolution } from './extraction-gates.js';
 import { extractFromDiff } from './extraction-diff.js';
 import { extractFromSessionContext } from './extraction-session.js';
+import { stripPrivate, isFullyPrivate } from './private-filter.js';
 import { loadLastExtraction, saveLastExtraction, saveExtractedSolution, updateReExtractedCounter, emitCompoundExtractActedOn, } from './extraction-persistence.js';
 const log = createLogger('compound-extractor');
 const MAX_EXTRACTIONS_PER_DAY = 5;
@@ -172,6 +173,15 @@ export function processExtractionResults(rawJson, sessionId) {
         return { saved, skipped };
     }
     for (const sol of solutions.slice(0, 3)) {
+        // W2-5 (private 태그): <private> 범위를 솔루션 content/context 에서 제거 후 저장.
+        // 통째로 private 이면 저장 skip (학습 코퍼스에 남기지 않음).
+        if (isFullyPrivate(sol.content) || isFullyPrivate(sol.context ?? '')) {
+            skipped.push(`${sol.name}: <private> (제외)`);
+            continue;
+        }
+        sol.content = stripPrivate(sol.content).cleaned;
+        if (sol.context)
+            sol.context = stripPrivate(sol.context).cleaned;
         const evaluation = evaluateExtractedSolution(sol);
         if (evaluation.action === 'skip' || evaluation.action === 'duplicate') {
             skipped.push(evaluation.message ?? `${sol.name}: skipped`);

package/dist/engine/compound-loop.js

@@ -190,11 +190,17 @@ export async function handleCompound(args) {
     forgen compound --lifecycle      Run promotion/demotion/circuit-breaker check
     forgen compound --verify <name>  Manually promote solution to verified
 
-  Export/Import:
+  Export/Import (whole store, tar.gz):
     forgen compound export [--output path]
                                      Export knowledge to tar.gz archive
     forgen compound import <path>    Import knowledge from archive (skip existing)
 
+  Export/Import (per-pattern, JSON — with confidence + provenance):
+    forgen compound export <name...> [--out file]
+                                     Export named solutions/rules as a portable bundle
+    forgen compound import <bundle.json> [--dry-run]
+                                     Import a bundle (probation trust, never overwrites)
+
   Auto-extraction:
     forgen compound --pause-auto     Pause auto-extraction
     forgen compound --resume-auto    Resume auto-extraction
@@ -204,16 +210,50 @@ export async function handleCompound(args) {
 `);
         return;
     }
+    // --- manual add (defense-in-depth, 2026-08-20) ---
+    // manual add(--solution/--rule/--convention/--pattern)를 아래 서브커맨드 dispatch 보다
+    // 먼저 처리한다. dispatch 는 args.includes('remove'|'clean-stale'|...) 로 전체 인자를
+    // 스캔하므로, add 의 위치인자(title/content)에 그런 토큰이 섞이면 삭제·정리 분기를
+    // 탈취할 수 있다(argument confusion — auto-compound 러너가 untrusted 모델 출력을 넘기던
+    // 경로에서 실증). type flag 는 add 전용이라 우선 처리해도 legit 동작 불변이며, 이렇게
+    // 하면 title/content 가 dispatch 스캔에 아예 닿지 않는다. (러너측 대시-선두 가드에 더한 2중 방어)
+    if (['--solution', '--rule', '--convention', '--pattern'].some(f => args.includes(f))) {
+        await handleManualAdd(args, cwd, scope);
+        return;
+    }
     // --- export command ---
+    // 통짜 tar.gz export(플래그만, positional 없음) vs 이름 지정 패턴 export를
+    // positional 인자 유무로 구분한다. `compound export foo` = 패턴 export,
+    // `compound export --output x` = 기존 whole-store export.
     if (args[0] === 'export') {
-        const { handleExport } = await import('./compound-export.js');
-        await handleExport(args.slice(1));
+        const rest = args.slice(1);
+        const hasPatternNames = rest.length > 0 && !rest[0].startsWith('--');
+        if (hasPatternNames) {
+            const { handleShareExport } = await import('./compound-share.js');
+            await handleShareExport(rest);
+        }
+        else {
+            const { handleExport } = await import('./compound-export.js');
+            await handleExport(rest);
+        }
         return;
     }
     // --- import command ---
+    // 대상 파일이 JSON 패턴 번들인지 tar.gz 아카이브인지 확장자/매직바이트로
+    // sniff해서 라우팅한다 (looksLikeShareBundle). 기존 tar.gz import 동작은
+    // 그대로 유지.
     if (args[0] === 'import') {
-        const { handleImport } = await import('./compound-export.js');
-        await handleImport(args.slice(1));
+        const rest = args.slice(1);
+        const filePath = rest.find(a => !a.startsWith('--'));
+        const { looksLikeShareBundle } = await import('./compound-share.js');
+        if (filePath && looksLikeShareBundle(path.resolve(filePath))) {
+            const { handleShareImport } = await import('./compound-share.js');
+            await handleShareImport(rest);
+        }
+        else {
+            const { handleImport } = await import('./compound-export.js');
+            await handleImport(rest);
+        }
         return;
     }
     // --pause-auto / --resume-auto
@@ -399,17 +439,25 @@ export async function handleCompound(args) {
         '--lifecycle', '--verify', '--save', '--interactive',
         'list', 'inspect', 'remove', 'rollback', 'retag', 'lifecycle',
         '--list', '--inspect', '--remove', '--rollback', '--retag', '--since', 'interactive',
-        'export', 'import', '--output',
+        'export', 'import', '--output', '--out', '--dry-run',
     ];
     const hasTypeFlag = knownFlags.some(f => args.includes(f));
     if (!hasTypeFlag) {
         console.log('  Unknown compound arguments. Run `forgen compound --help` for usage.\n');
         return;
     }
+    await handleManualAdd(args, cwd, scope);
+}
+/**
+ * 수동 인사이트 추가 (--solution/--rule/--convention/--pattern).
+ * handleCompound 에서 두 경로로 호출된다:
+ *  (1) hoisted early-dispatch — type flag 가 있으면 서브커맨드 스캔 전에 즉시(arg-confusion 방어).
+ *  (2) fallthrough — type flag 없이 다른 known flag(예: --to)만 있는 legacy 경로(동작 보존).
+ */
+async function handleManualAdd(args, cwd, scope) {
     console.log('\n  Compound Loop — Accumulating insights\n');
     console.log(`  Scope: ${scope.summary}`);
     console.log();
-    // 수동 인사이트 추가
     const type = args.includes('--solution') ? 'solution'
         : args.includes('--rule') ? 'rule'
             : args.includes('--convention') ? 'convention'

package/dist/engine/compound-share.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Forgen — Compound Pattern Share (패턴별 export/import)
+ *
+ * `compound-export.ts`의 `export`/`import`는 `~/.forgen/me/` 전체를 tar.gz로
+ * 통짜 백업/이관한다. 이 모듈은 그와 달리 **이름 지정된 패턴 단위**로 신뢰도
+ * (confidence/status/evidence)와 provenance를 함께 담은 JSON 번들을 만들고,
+ * 받는 쪽에서 안전하게 병합한다 (ECC `/instinct-import/export` 대응, OSS gap #1).
+ *
+ * 핵심 설계:
+ *   - 번들은 스키마 버전 고정 JSON. 최상위/패턴 필드 모두 화이트리스트 검증 —
+ *     예상 못한 필드가 있으면 통째로 reject (실행 가능한 콘텐츠가 섞여 들어올
+ *     여지 자체를 차단).
+ *   - 패턴마다 contentHash(sha256)를 동봉 — import 시 재계산해 일치하지 않으면
+ *     reject (변조/손상 탐지).
+ *   - 이름 충돌 시: 로컬 콘텐츠 해시가 같으면 "동일 패턴 재발견"으로 간주해
+ *     `reExtracted` 카운터만 증가(기존 신뢰도는 건드리지 않음 — 이미 solution-writer.ts
+ *     의 dual-path 금지 불변식과 일치). 다르면 절대 덮어쓰지 않고 suffix된
+ *     이름으로 새로 생성.
+ *   - 신규 생성되는 패턴은 항상 probation: status='experiment', confidence는
+ *     신규 솔루션 표준 베이스라인(statusConfidence('experiment')=0.3, 참고:
+ *     extraction-persistence.ts saveExtractedSolution)을 상한으로 export 시점
+ *     confidence의 절반만 반영. evidence는 전부 0으로 리셋 — exporter의 로컬
+ *     사용 이력을 이 머신이 검증 없이 물려받지 않는다. 이후 승급은 기존
+ *     compound-lifecycle.ts의 단일 경로(runLifecycleCheck)로만 진행된다.
+ */
+import { type SolutionFrontmatter } from './solution-format.js';
+export declare const SHARE_BUNDLE_SCHEMA_VERSION: 1;
+export interface ShareBundlePatternV1 {
+    name: string;
+    category: 'solution' | 'rule';
+    frontmatter: SolutionFrontmatter;
+    context: string;
+    content: string;
+    /** sha256(type + sorted tags/identifiers + context + content) — confidence/evidence/timestamp 제외한 콘텐츠 지문. */
+    contentHash: string;
+}
+export interface ShareBundleV1 {
+    schemaVersion: 1;
+    exportedAt: string;
+    /** sha256(hostname:username) 앞 16자 — 원본 식별용, PII 비가역. */
+    originHash: string;
+    patterns: ShareBundlePatternV1[];
+}
+export interface BuildBundleResult {
+    bundle: ShareBundleV1;
+    notFound: string[];
+    rejectedSecrets: string[];
+}
+/**
+ * 이름 목록으로 패턴 번들 생성.
+ *
+ * 시크릿 감지된 패턴은 조용히 스킵하지 않고 `rejectedSecrets`로 보고하되,
+ * 번들 자체는 나머지 clean한 패턴으로 계속 진행한다 (부분 실패 허용).
+ */
+export declare function buildShareBundle(names: string[]): BuildBundleResult;
+export interface ShareBundleValidation {
+    ok: boolean;
+    bundle: ShareBundleV1 | null;
+    errors: string[];
+}
+/**
+ * 번들 검증: 크기 캡 → 최상위 필드 화이트리스트 → 패턴별 필드 화이트리스트 →
+ * frontmatter 정합성 → contentHash 재계산 일치. 하나라도 실패하면 번들 전체를
+ * reject한다 (부분 신뢰 없음 — 손상/변조된 번들은 통째로 버린다).
+ */
+export declare function validateShareBundle(raw: unknown, rawSize: number): ShareBundleValidation;
+export interface ShareImportAction {
+    sourceName: string;
+    category: 'solution' | 'rule';
+    action: 'merge-reextract' | 'create' | 'create-suffixed';
+    targetName: string;
+    detail: string;
+}
+export interface ShareImportSummary {
+    dryRun: boolean;
+    actions: ShareImportAction[];
+}
+/** dry-run과 실제 실행이 공유하는 계획 수립 — 파일시스템에 아무것도 쓰지 않는다. */
+export declare function planShareImport(bundle: ShareBundleV1): ShareImportAction[];
+export declare function executeShareImport(bundle: ShareBundleV1, opts?: {
+    dryRun?: boolean;
+}): ShareImportSummary;
+export declare function looksLikeShareBundle(filePath: string): boolean;
+export declare function handleShareExport(args: string[]): Promise<void>;
+export declare function handleShareImport(args: string[]): Promise<void>;