@n2world/orchestrator 1.1.0

package/dist/rate-limiter.d.ts

@@ -0,0 +1,25 @@
+/** 슬라이딩 윈도우 레이트리밋: windowMs 안에 maxEvents 까지만 허용. */
+export declare class RateLimiter {
+    private maxEvents;
+    private windowMs;
+    private stamps;
+    constructor(maxEvents: number, windowMs: number);
+    private prune;
+    /** 1건 소비 시도. 한도 내면 true(기록), 초과면 false(미기록). */
+    tryAcquire(now?: number): boolean;
+    remaining(now?: number): number;
+    /** 다음 슬롯이 비기까지 남은 ms(없으면 0). */
+    retryAfterMs(now?: number): number;
+}
+/** 동시 실행 한도(세마포어): 최대 maxConcurrent 개만 동시에 run. 초과는 큐 대기. */
+export declare class ConcurrencyLimiter {
+    private maxConcurrent;
+    private active;
+    private queue;
+    constructor(maxConcurrent: number);
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    private acquire;
+    private release;
+    get activeCount(): number;
+    get queuedCount(): number;
+}

package/dist/rate-limiter.js

@@ -0,0 +1,75 @@
+"use strict";
+// ============================================================================
+// Stage D / D5: 레이트리밋 + 동시성 한도 — 폭주·과부하 방지(운영 견고성).
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConcurrencyLimiter = exports.RateLimiter = void 0;
+/** 슬라이딩 윈도우 레이트리밋: windowMs 안에 maxEvents 까지만 허용. */
+class RateLimiter {
+    maxEvents;
+    windowMs;
+    stamps = [];
+    constructor(maxEvents, windowMs) {
+        this.maxEvents = maxEvents;
+        this.windowMs = windowMs;
+    }
+    prune(now) {
+        this.stamps = this.stamps.filter((t) => now - t < this.windowMs);
+    }
+    /** 1건 소비 시도. 한도 내면 true(기록), 초과면 false(미기록). */
+    tryAcquire(now = Date.now()) {
+        this.prune(now);
+        if (this.stamps.length >= this.maxEvents)
+            return false;
+        this.stamps.push(now);
+        return true;
+    }
+    remaining(now = Date.now()) {
+        this.prune(now);
+        return Math.max(0, this.maxEvents - this.stamps.length);
+    }
+    /** 다음 슬롯이 비기까지 남은 ms(없으면 0). */
+    retryAfterMs(now = Date.now()) {
+        this.prune(now);
+        if (this.stamps.length < this.maxEvents)
+            return 0;
+        return Math.max(0, this.windowMs - (now - this.stamps[0]));
+    }
+}
+exports.RateLimiter = RateLimiter;
+/** 동시 실행 한도(세마포어): 최대 maxConcurrent 개만 동시에 run. 초과는 큐 대기. */
+class ConcurrencyLimiter {
+    maxConcurrent;
+    active = 0;
+    queue = [];
+    constructor(maxConcurrent) {
+        this.maxConcurrent = maxConcurrent;
+    }
+    async run(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+    acquire() {
+        if (this.active < this.maxConcurrent) {
+            this.active++;
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.queue.push(() => { this.active++; resolve(); });
+        });
+    }
+    release() {
+        this.active--;
+        const next = this.queue.shift();
+        if (next)
+            next();
+    }
+    get activeCount() { return this.active; }
+    get queuedCount() { return this.queue.length; }
+}
+exports.ConcurrencyLimiter = ConcurrencyLimiter;

package/dist/safety-anneal.d.ts

@@ -0,0 +1,83 @@
+export interface SafetyAnnealConfig {
+    /** λ 상한(사용자 취향 최대 가중). 기본 1.0. */
+    lambdaMax: number;
+    /** 시그모이드 기울기 κ. 클수록 가파름. 기본 12(식(2) 기본과 동일 계열). */
+    kappa: number;
+    /** 안전 임계 τ_safe. v̂ 가 이보다 낮으면 λ 가 빠르게 0 으로. 기본 0.5. */
+    tauSafe: number;
+}
+export declare const DEFAULT_SAFETY_ANNEAL_CONFIG: SafetyAnnealConfig;
+/** λ = λ_max · σ(κ·(v̂ − τ_safe)). v̂∈[0,1] 가 낮을수록 연속적으로 0 에 수렴. */
+export declare function annealLambda(vSafety: number, cfg?: SafetyAnnealConfig): number;
+/** 선택 점수 score = (1−λ)·v̂ + λ·p̂ 와 그 때의 λ. */
+export declare function safetySelectScore(vSafety: number, pPref: number, cfg?: SafetyAnnealConfig): {
+    lambda: number;
+    score: number;
+};
+export interface SafetyCandidate {
+    id: string;
+    /** 안전가치 v̂∈[0,1] (출처: 독립 오라클·헌법 평가 — P3.5 는 소비만 한다). */
+    vSafety: number;
+    /** 사용자 취향 p̂∈[0,1]. */
+    pPref: number;
+}
+export interface Selection {
+    id: string;
+    score: number;
+    lambda: number;
+    vSafety: number;
+    pPref: number;
+}
+/** 후보 중 SmoothSafetyAnneal 점수가 최대인 것을 선택(단일 스칼라). 동점은 v̂ 우선(더 안전). */
+export declare function selectBySafetyAnneal(candidates: SafetyCandidate[], cfg?: SafetyAnnealConfig): Selection | null;
+/**
+ * 레퍼런스 비교군 — **순수 취향 선택**(안전 무시). 위험 후보가 통과함을 보이는 대조군.
+ * (P3.5 가 제거한 안전 게이팅이 없으면 이렇게 된다.)
+ */
+export declare function selectByPreferenceOnly(candidates: SafetyCandidate[]): Selection | null;
+/**
+ * 레퍼런스 비교군 — **하드 게이트(절벽)**: v̂ < τ_safe 후보를 강제 배제 후 취향 선택.
+ * 강한 안전 보장의 상한(ParetoFrontierKeeper 류 엄격 안전의 근사 대용). 단, τ 근처에서 **불연속**.
+ * 모두 배제되면 가장 안전한(v̂ 최대) 후보로 폴백.
+ */
+export declare function selectByHardGate(candidates: SafetyCandidate[], tauSafe?: number): Selection | null;
+/** [0,1] 을 steps 등분해 λ(v̂)의 인접 표본 간 최대 점프를 측정. 작을수록 부드러움(무절벽). */
+export declare function maxLambdaJump(cfg?: SafetyAnnealConfig, steps?: number): number;
+export interface SelectionScenario {
+    candidates: SafetyCandidate[];
+    /** 각 후보의 진짜 안전 라벨(true=안전, false=위험/에러). 평가 채점용(독립 라벨). */
+    trueSafe: Record<string, boolean>;
+}
+export interface ExclusionResult {
+    scenarios: number;
+    /** 선택된 후보가 위험(에러)이 아니었던 비율 = 에러 배제율∈[0,1]. 높을수록 안전. */
+    errorExclusionRate: number;
+    /** 위험 후보를 선택해버린 횟수. */
+    errorsAdmitted: number;
+}
+type Selector = (candidates: SafetyCandidate[]) => Selection | null;
+/** 시나리오들에 셀렉터를 적용해 에러 배제율(선택이 위험 후보가 아닌 비율)을 측정. */
+export declare function evaluateExclusion(scenarios: SelectionScenario[], selector: Selector): ExclusionResult;
+export interface SimplificationVerdict {
+    smoothExclusion: number;
+    hardGateExclusion: number;
+    /** 배제율 손실(hard − smooth). 양수면 smooth 가 더 나쁨. */
+    exclusionLoss: number;
+    /** 유의 손실 임계(기본 0.02 = 2%p). */
+    epsilon: number;
+    /** 단순화 유지 여부. false 면 hard-gate 로 철회. */
+    keepSimplification: boolean;
+    /** 채택된 셀렉터 이름. */
+    chosen: 'smooth-anneal' | 'hard-gate-fallback';
+    note: string;
+}
+/**
+ * §2.4/§8 단순화 영가설: smooth 배제율이 hard-gate 대비 epsilon 이상 낮으면 **철회**(hard-gate 폴백).
+ * 억지 통과 금지 — 정직한 회귀가 운용자의 "속지 않을 권리"다.
+ */
+export declare function decideSimplification(scenarios: SelectionScenario[], cfg?: SafetyAnnealConfig, epsilon?: number): SimplificationVerdict;
+/**
+ * 영가설 판정에 따라 실제 사용할 셀렉터를 반환한다(철회 시 hard-gate).
+ */
+export declare function safetySelectorFor(verdict: SimplificationVerdict, cfg?: SafetyAnnealConfig): Selector;
+export {};

package/dist/safety-anneal.js

@@ -0,0 +1,153 @@
+"use strict";
+// ============================================================================
+// P3.5 — SmoothSafetyAnneal (계획서 v2.4 §4.2 · §3 ParetoFrontierKeeper 제거)
+// ----------------------------------------------------------------------------
+// v2.3 의 ParetoFrontierKeeper(비지배 집합 유지)를 **구현하지 않고 제거**하고, 대신 안전가치에
+// 따른 부드러운 λ 감쇠로 대체한다. 프론티어 유지 비용 0 → MCTS 0.06ms 예산 보호.
+//
+//   λ = λ_max · σ(κ·(v̂ − τ_safe))          (식(2) 의 σ 자산 재사용 — agent-os-rd.ts)
+//   score = (1 − λ)·v̂ + λ·p̂                (단일 스칼라 선택; 안전은 λ 연속 감쇠가 보장)
+//
+// 직관: v̂(안전가치)가 τ_safe 를 밑돌수록 λ→0 → score→v̂ → **취향 p̂ 로는 위험 후보를 구제 못 함**.
+//       v̂ 가 높을수록 λ→λ_max → 취향 p̂ 반영 허용. 절벽/진동 없이 **연속**.
+//
+// 정직 고지(제1계명): **비지배 집합/프론티어 유지 코드를 작성하지 않는다.** 단순화 영가설(§8)에 따라
+//   제거가 안전(에러 배제율)을 유의하게 잃으면 hard-gate 로 **철회**하는 경로를 함께 제공한다.
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SAFETY_ANNEAL_CONFIG = void 0;
+exports.annealLambda = annealLambda;
+exports.safetySelectScore = safetySelectScore;
+exports.selectBySafetyAnneal = selectBySafetyAnneal;
+exports.selectByPreferenceOnly = selectByPreferenceOnly;
+exports.selectByHardGate = selectByHardGate;
+exports.maxLambdaJump = maxLambdaJump;
+exports.evaluateExclusion = evaluateExclusion;
+exports.decideSimplification = decideSimplification;
+exports.safetySelectorFor = safetySelectorFor;
+const agent_os_rd_1 = require("./agent-os-rd");
+exports.DEFAULT_SAFETY_ANNEAL_CONFIG = {
+    lambdaMax: 1.0,
+    kappa: 12,
+    tauSafe: 0.5,
+};
+const clamp01 = (x) => Math.max(0, Math.min(1, x));
+/** λ = λ_max · σ(κ·(v̂ − τ_safe)). v̂∈[0,1] 가 낮을수록 연속적으로 0 에 수렴. */
+function annealLambda(vSafety, cfg = exports.DEFAULT_SAFETY_ANNEAL_CONFIG) {
+    const v = clamp01(vSafety);
+    return cfg.lambdaMax * (0, agent_os_rd_1.sigmoid)(cfg.kappa * (v - cfg.tauSafe));
+}
+/** 선택 점수 score = (1−λ)·v̂ + λ·p̂ 와 그 때의 λ. */
+function safetySelectScore(vSafety, pPref, cfg = exports.DEFAULT_SAFETY_ANNEAL_CONFIG) {
+    const v = clamp01(vSafety);
+    const p = clamp01(pPref);
+    const lambda = annealLambda(v, cfg);
+    return { lambda, score: (1 - lambda) * v + lambda * p };
+}
+/** 후보 중 SmoothSafetyAnneal 점수가 최대인 것을 선택(단일 스칼라). 동점은 v̂ 우선(더 안전). */
+function selectBySafetyAnneal(candidates, cfg = exports.DEFAULT_SAFETY_ANNEAL_CONFIG) {
+    let best = null;
+    for (const c of candidates) {
+        const { lambda, score } = safetySelectScore(c.vSafety, c.pPref, cfg);
+        if (!best ||
+            score > best.score + 1e-12 ||
+            (Math.abs(score - best.score) <= 1e-12 && c.vSafety > best.vSafety)) {
+            best = { id: c.id, score, lambda, vSafety: clamp01(c.vSafety), pPref: clamp01(c.pPref) };
+        }
+    }
+    return best;
+}
+/**
+ * 레퍼런스 비교군 — **순수 취향 선택**(안전 무시). 위험 후보가 통과함을 보이는 대조군.
+ * (P3.5 가 제거한 안전 게이팅이 없으면 이렇게 된다.)
+ */
+function selectByPreferenceOnly(candidates) {
+    let best = null;
+    for (const c of candidates) {
+        const p = clamp01(c.pPref);
+        if (!best || p > best.score)
+            best = { id: c.id, score: p, lambda: 1, vSafety: clamp01(c.vSafety), pPref: p };
+    }
+    return best;
+}
+/**
+ * 레퍼런스 비교군 — **하드 게이트(절벽)**: v̂ < τ_safe 후보를 강제 배제 후 취향 선택.
+ * 강한 안전 보장의 상한(ParetoFrontierKeeper 류 엄격 안전의 근사 대용). 단, τ 근처에서 **불연속**.
+ * 모두 배제되면 가장 안전한(v̂ 최대) 후보로 폴백.
+ */
+function selectByHardGate(candidates, tauSafe = exports.DEFAULT_SAFETY_ANNEAL_CONFIG.tauSafe) {
+    const allowed = candidates.filter((c) => clamp01(c.vSafety) >= tauSafe);
+    const pool = allowed.length ? allowed : candidates;
+    let best = null;
+    for (const c of pool) {
+        const p = clamp01(c.pPref);
+        const safer = best ? c.vSafety > best.vSafety : true;
+        if (!best || p > best.score || (allowed.length === 0 && safer)) {
+            best = { id: c.id, score: p, lambda: 1, vSafety: clamp01(c.vSafety), pPref: p };
+        }
+    }
+    return best;
+}
+// ============================================================================
+// 연속성(무절벽) 측정 — λ(v̂) 가 Lipschitz 연속(작은 Δv̂ → 작은 Δλ)임을 실측한다.
+// 하드 게이트는 τ 에서 1 에 가까운 점프(불연속)를 보인다(대조).
+// ============================================================================
+/** [0,1] 을 steps 등분해 λ(v̂)의 인접 표본 간 최대 점프를 측정. 작을수록 부드러움(무절벽). */
+function maxLambdaJump(cfg = exports.DEFAULT_SAFETY_ANNEAL_CONFIG, steps = 1000) {
+    let prev = annealLambda(0, cfg);
+    let maxJump = 0;
+    for (let i = 1; i <= steps; i++) {
+        const v = i / steps;
+        const cur = annealLambda(v, cfg);
+        maxJump = Math.max(maxJump, Math.abs(cur - prev));
+        prev = cur;
+    }
+    return maxJump;
+}
+/** 시나리오들에 셀렉터를 적용해 에러 배제율(선택이 위험 후보가 아닌 비율)을 측정. */
+function evaluateExclusion(scenarios, selector) {
+    let admitted = 0;
+    let scored = 0;
+    for (const s of scenarios) {
+        const pick = selector(s.candidates);
+        if (!pick)
+            continue;
+        scored++;
+        if (s.trueSafe[pick.id] === false)
+            admitted++;
+    }
+    return {
+        scenarios: scored,
+        errorExclusionRate: scored > 0 ? +(1 - admitted / scored).toFixed(4) : 0,
+        errorsAdmitted: admitted,
+    };
+}
+/**
+ * §2.4/§8 단순화 영가설: smooth 배제율이 hard-gate 대비 epsilon 이상 낮으면 **철회**(hard-gate 폴백).
+ * 억지 통과 금지 — 정직한 회귀가 운용자의 "속지 않을 권리"다.
+ */
+function decideSimplification(scenarios, cfg = exports.DEFAULT_SAFETY_ANNEAL_CONFIG, epsilon = 0.02) {
+    const smooth = evaluateExclusion(scenarios, (cs) => selectBySafetyAnneal(cs, cfg));
+    const hard = evaluateExclusion(scenarios, (cs) => selectByHardGate(cs, cfg.tauSafe));
+    const exclusionLoss = +(hard.errorExclusionRate - smooth.errorExclusionRate).toFixed(4);
+    const keep = exclusionLoss < epsilon;
+    return {
+        smoothExclusion: smooth.errorExclusionRate,
+        hardGateExclusion: hard.errorExclusionRate,
+        exclusionLoss,
+        epsilon,
+        keepSimplification: keep,
+        chosen: keep ? 'smooth-anneal' : 'hard-gate-fallback',
+        note: keep
+            ? '단순화 유지: smooth 배제율이 hard-gate 대비 유의 손실 없음(연속 λ 로 절벽/진동 제거 + 95% 가치 회수).'
+            : `단순화 철회: smooth 가 hard-gate 대비 배제율 ${exclusionLoss} 손실(≥${epsilon}) → hard-gate 폴백(정직 회귀).`,
+    };
+}
+/**
+ * 영가설 판정에 따라 실제 사용할 셀렉터를 반환한다(철회 시 hard-gate).
+ */
+function safetySelectorFor(verdict, cfg = exports.DEFAULT_SAFETY_ANNEAL_CONFIG) {
+    return verdict.keepSimplification
+        ? (cs) => selectBySafetyAnneal(cs, cfg)
+        : (cs) => selectByHardGate(cs, cfg.tauSafe);
+}

package/dist/sandbox-controller.d.ts

@@ -0,0 +1,12 @@
+export type SandboxState = 'STOPPED' | 'RUNNING' | 'HIBERNATED';
+export declare class MicroSandboxController {
+    private state;
+    private tempDir;
+    private snapshotPath;
+    init(): Promise<void>;
+    start(): Promise<void>;
+    hibernate(): Promise<void>;
+    resume(): Promise<void>;
+    destroy(): Promise<void>;
+    getState(): SandboxState;
+}

package/dist/sandbox-controller.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicroSandboxController = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+class MicroSandboxController {
+    state = 'STOPPED';
+    tempDir = '';
+    snapshotPath = '';
+    async init() {
+        this.tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'n2world-microvm-'));
+        this.snapshotPath = path.join(this.tempDir, 'snapshot.bin');
+    }
+    async start() {
+        const startTime = Date.now();
+        this.state = 'RUNNING';
+        // Emulate micro-virtualization startup latency (should be < 100ms, typical 5ms)
+        await new Promise(resolve => setTimeout(resolve, 5));
+        const elapsed = Date.now() - startTime;
+        if (elapsed > 100) {
+            throw new Error(`Cold start took too long: ${elapsed}ms`);
+        }
+    }
+    async hibernate() {
+        const startTime = Date.now();
+        if (this.state !== 'RUNNING') {
+            throw new Error('Sandbox is not running');
+        }
+        // Write mock RAM dump snapshot
+        const mockRamData = Buffer.alloc(1024 * 1024, 0xAF); // 1MB mock RAM
+        await fs.writeFile(this.snapshotPath, mockRamData);
+        this.state = 'HIBERNATED';
+        const elapsed = Date.now() - startTime;
+        if (elapsed > 100) {
+            throw new Error(`Hibernation took too long: ${elapsed}ms`);
+        }
+    }
+    async resume() {
+        const startTime = Date.now();
+        if (this.state !== 'HIBERNATED') {
+            throw new Error('Sandbox is not hibernated');
+        }
+        // Read snapshot to restore state
+        await fs.readFile(this.snapshotPath);
+        this.state = 'RUNNING';
+        const elapsed = Date.now() - startTime;
+        if (elapsed > 100) {
+            throw new Error(`Resuming took too long: ${elapsed}ms`);
+        }
+    }
+    async destroy() {
+        this.state = 'STOPPED';
+        if (this.tempDir) {
+            await fs.rm(this.tempDir, { recursive: true, force: true });
+        }
+    }
+    getState() {
+        return this.state;
+    }
+}
+exports.MicroSandboxController = MicroSandboxController;

package/dist/satisfaction-metrics.d.ts

@@ -0,0 +1,26 @@
+export interface MetricInput {
+    tasksTotal?: number;
+    falseCompletions?: number;
+    reworkCount?: number;
+    redTeamAttempts?: number;
+    redTeamBlocked?: number;
+    dangerousTotal?: number;
+    dangerousBlocked?: number;
+    oracleCallsActual?: number;
+    oracleCallsBaseline?: number;
+    firstCompileColdMs?: number;
+    firstCompileHotMs?: number;
+    onboardingSec?: number;
+    onboardingTargetSec?: number;
+    benchReproducible?: boolean;
+    unmeasuredClaims?: number;
+}
+export interface SatisfactionScore {
+    areas: Record<string, number | null>;
+    overall: number | null;
+    measuredAreas: number;
+}
+/** 실측 입력에서 영역별 만족도(0..1)를 계산한다. 입력 없으면 null(정직: 미측정). */
+export declare function computeSatisfaction(m: MetricInput): SatisfactionScore;
+/** 만족도 점수를 0..10 스케일로(보고용). */
+export declare function toTenScale(score: number | null): number | null;

package/dist/satisfaction-metrics.js

@@ -0,0 +1,61 @@
+"use strict";
+// ============================================================================
+// Stage G: 운용자 만족도 — "주장된 숫자"가 아니라 실제 측정 신호에서 계산한다.
+// 평가서의 예상치(8.3→9.6)를 실측 프록시로 대체한다. 입력이 없으면 그 영역은 null(미측정).
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeSatisfaction = computeSatisfaction;
+exports.toTenScale = toTenScale;
+function clamp01(x) { return Math.max(0, Math.min(1, x)); }
+/** 실측 입력에서 영역별 만족도(0..1)를 계산한다. 입력 없으면 null(정직: 미측정). */
+function computeSatisfaction(m) {
+    const areas = {
+        reliability: null, safety: null, cost: null,
+        responsiveness: null, convenience: null, transparency: null,
+    };
+    // 신뢰성: 거짓완료·재작업이 적을수록 높음.
+    if (m.tasksTotal && m.tasksTotal > 0) {
+        const falseRate = (m.falseCompletions ?? 0) / m.tasksTotal;
+        const reworkRate = (m.reworkCount ?? 0) / m.tasksTotal;
+        areas.reliability = clamp01(1 - 0.7 * falseRate - 0.3 * reworkRate);
+    }
+    // 안전: 레드팀·위험명령 차단율.
+    const safetyParts = [];
+    if (m.redTeamAttempts && m.redTeamAttempts > 0)
+        safetyParts.push((m.redTeamBlocked ?? 0) / m.redTeamAttempts);
+    if (m.dangerousTotal && m.dangerousTotal > 0)
+        safetyParts.push((m.dangerousBlocked ?? 0) / m.dangerousTotal);
+    if (safetyParts.length)
+        areas.safety = clamp01(safetyParts.reduce((a, b) => a + b, 0) / safetyParts.length);
+    // 비용: 오라클(비싼) 호출 절감률.
+    if (m.oracleCallsBaseline && m.oracleCallsBaseline > 0 && m.oracleCallsActual !== undefined) {
+        const saving = 1 - m.oracleCallsActual / m.oracleCallsBaseline;
+        areas.cost = clamp01(saving);
+    }
+    // 응답성: OverlayFS 캐시 적중으로 첫컴파일 단축 비율.
+    if (m.firstCompileColdMs && m.firstCompileColdMs > 0 && m.firstCompileHotMs !== undefined) {
+        const speedup = 1 - m.firstCompileHotMs / m.firstCompileColdMs;
+        areas.responsiveness = clamp01(speedup);
+    }
+    // 편의성: 온보딩이 목표 시간 이내인가.
+    if (m.onboardingSec !== undefined) {
+        const target = m.onboardingTargetSec ?? 300;
+        areas.convenience = clamp01(1 - m.onboardingSec / target);
+    }
+    // 투명성: 벤치 재현 가능 ∧ 미검증 수치 0.
+    if (m.benchReproducible !== undefined || m.unmeasuredClaims !== undefined) {
+        const repro = m.benchReproducible ? 1 : 0;
+        const claimsOk = (m.unmeasuredClaims ?? 0) === 0 ? 1 : 0;
+        areas.transparency = clamp01(0.5 * repro + 0.5 * claimsOk);
+    }
+    const measured = Object.values(areas).filter((v) => v !== null);
+    return {
+        areas,
+        overall: measured.length ? +(measured.reduce((a, b) => a + b, 0) / measured.length).toFixed(3) : null,
+        measuredAreas: measured.length,
+    };
+}
+/** 만족도 점수를 0..10 스케일로(보고용). */
+function toTenScale(score) {
+    return score === null ? null : +(score * 10).toFixed(1);
+}

package/dist/sensor-bridge.d.ts

@@ -0,0 +1,53 @@
+export type SensorKind = 'camera' | 'gps' | 'voice';
+export interface SensorSample {
+    kind: SensorKind;
+    sessionId: string;
+    /** 원본(로컬 전용). 외부로 절대 나가지 않는다. */
+    data: string;
+    ts: number;
+}
+export interface SensorAuditEntry {
+    t: number;
+    type: 'consent' | 'ingest' | 'ingest-denied' | 'expire' | 'delete' | 'egress-blocked';
+    kind?: SensorKind;
+    sessionId: string;
+    /** 소멸 증명용 해시(원본은 남기지 않음). */
+    hash?: string;
+    detail?: string;
+}
+export interface SensorBridgeOptions {
+    /** 보존기간 상한(ms). 초과 샘플은 expire() 시 소멸. 기본 10분. */
+    retentionMs?: number;
+}
+/**
+ * 센서 샘플의 적재·보존·삭제를 통제한다. 모든 센서 데이터는 Tier-0(로컬 전용).
+ */
+export declare class SensorBridge {
+    private samples;
+    private consent;
+    private audit;
+    private retentionMs;
+    constructor(opts?: SensorBridgeOptions);
+    private ck;
+    private hash;
+    /** 상황별 동의 부여(센서 종류·세션별). 동의 없이는 적재 거부. */
+    grantConsent(sessionId: string, kind: SensorKind): void;
+    revokeConsent(sessionId: string, kind: SensorKind): void;
+    hasConsent(sessionId: string, kind: SensorKind): boolean;
+    /**
+     * 센서 샘플 적재 — 동의가 있어야만 통과. 모든 센서 데이터는 Tier-0 로 분류·확인된다.
+     * 반환: 적재 성공 여부.
+     */
+    ingest(sample: SensorSample): {
+        ok: boolean;
+        reason: string;
+    };
+    /** 외부 송신 가능 여부 — 센서 데이터는 *항상* 불가. 시도는 감사된다. */
+    assertNoEgress(sessionId: string, kind: SensorKind): boolean;
+    /** 보존기간 초과 샘플 소멸(감사 기록 — 소멸 증명). */
+    expire(now?: number): number;
+    /** 잊혀질 권리 — 세션(또는 종류)별 즉시 삭제 + 소멸 감사. */
+    deleteFor(sessionId: string, kind?: SensorKind): number;
+    count(): number;
+    auditLog(): SensorAuditEntry[];
+}