@n2world/orchestrator 1.1.0

package/dist/agent-os-rd.d.ts

@@ -0,0 +1,100 @@
+export declare class Macaroon {
+    identifier: string;
+    caveats: string[];
+    signature: string;
+    constructor(identifier: string, caveats: string[], signature: string);
+    static create(secret: string, identifier: string, target: string): Macaroon;
+    static attenuate(macaroon: Macaroon, caveat: string): Macaroon;
+    static serialize(macaroon: Macaroon): string;
+    static deserialize(token: string): Macaroon;
+}
+export declare class MacaroonVerifier {
+    static verify(token: string, secret: string, context: {
+        target: string;
+        time: number;
+        path: string;
+    }): boolean;
+}
+export interface A2AContext {
+    target: string;
+    time: number;
+    path: string;
+}
+/** 동료(에이전트)별 평판 원장. 위반에 민감(위반 시 강하게 감점). */
+export declare class ReputationLedger {
+    private rep;
+    private entry;
+    recordSuccess(peerId: string): void;
+    recordViolation(peerId: string): void;
+    /** 신규 동료는 중립(0.5)에서 시작. 위반이 누적될수록 0에 수렴. */
+    get(peerId: string): number;
+}
+export declare class A2ATrustGate {
+    private secret;
+    private ledger;
+    private minTrust;
+    constructor(secret: string, ledger?: ReputationLedger, minTrust?: number);
+    /** 신뢰 t 산출. HARD_GATE(서명+범위) 통과해야 t>0. 미달이면 allowed=false. */
+    evaluate(peerId: string, macaroonToken: string, ctx: A2AContext): {
+        trust: number;
+        allowed: boolean;
+        reason: string;
+    };
+    ledgerRef(): ReputationLedger;
+}
+export interface OverlayResult {
+    supported: boolean;
+    coldMs: number;
+    hotMs: number;
+    coldResult: string;
+    hotResult: string;
+}
+export declare class OverlayFsCompilerOptimizer {
+    /**
+     * [시뮬레이션] 실제 마운트 없이 cold/hot 지연을 흉내낸다. 정직 표기: 이것은 측정이 아니다.
+     * 실제 측정은 realOverlayCacheDemo() 사용.
+     */
+    simulateCompile(mode: 'cold' | 'hot'): Promise<{
+        latencyMs: number;
+        buildOutput: string;
+    }>;
+    /**
+     * [실측] 무권한 user namespace로 진짜 OverlayFS를 마운트해, 캐시된 툴체인이 재컴파일을
+     * 제거함을 측정한다(sudo 불필요, Linux 한정). 비-Linux는 supported=false 로 정직히 표기.
+     */
+    realOverlayCacheDemo(): Promise<OverlayResult>;
+}
+export interface SchedulerConfig {
+    kappa: number;
+    v0: number;
+    wMin: number;
+    wMax: number;
+}
+export declare const DEFAULT_SCHEDULER_CONFIG: SchedulerConfig;
+/** 식(2)의 시그모이드 σ(x)=1/(1+e^-x). P3.5 SmoothSafetyAnneal 등에서 재사용한다. */
+export declare function sigmoid(x: number): number;
+export declare class EbpfSchedulerDriver {
+    private currentWeights;
+    private cfg;
+    constructor(cfg?: Partial<SchedulerConfig>);
+    /** 식(2): 정규화된 v_norm∈[0,1] → cgroups CPU 가중치. 단조 증가·조정 가능. */
+    weightForValue(vNorm: number): number;
+    /** 루트 자식 Q들을 min-max 정규화해 v_norm∈[0,1]로(교차과제 비교가능화). */
+    static normalize(q: number, qMin: number, qMax: number): number;
+    /**
+     * 정규화된 v_norm 으로 cgroups 가중치를 적용한다.
+     * - `weight`: 식(2)로 계산한 의도 가중치(플랫폼 무관, 항상 기록).
+     * - `success`: 커널 cpu.weight 실기입 성공 여부(Linux+유효 cgroup+권한일 때만 true. 비-Linux는 false — 정직).
+     */
+    adjustResourceByValue(cgroupPath: string, vNorm: number): {
+        weight: number;
+        success: boolean;
+    };
+    /** 원시 Q와 분포(min,max)를 받아 정규화 후 적용하는 편의 메서드. */
+    adjustResourceByRawValue(cgroupPath: string, q: number, qMin: number, qMax: number): {
+        weight: number;
+        vNorm: number;
+        success: boolean;
+    };
+    getWeight(cgroupPath: string): number | undefined;
+}

package/dist/agent-os-rd.js

@@ -0,0 +1,258 @@
+"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.EbpfSchedulerDriver = exports.DEFAULT_SCHEDULER_CONFIG = exports.OverlayFsCompilerOptimizer = exports.A2ATrustGate = exports.ReputationLedger = exports.MacaroonVerifier = exports.Macaroon = void 0;
+exports.sigmoid = sigmoid;
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const core_1 = require("@n2world/core");
+// ============================================================================
+// 7.1. Macaroon Token based A2A (Agent-to-Agent) Secure Collaboration Protocol
+// ============================================================================
+class Macaroon {
+    identifier;
+    caveats;
+    signature;
+    constructor(identifier, caveats, signature) {
+        this.identifier = identifier;
+        this.caveats = caveats;
+        this.signature = signature;
+    }
+    static create(secret, identifier, target) {
+        const rootSig = crypto.createHmac('sha256', secret).update(identifier).digest('hex');
+        const targetCaveat = `target = ${target}`;
+        const delegatedSig = crypto.createHmac('sha256', rootSig).update(targetCaveat).digest('hex');
+        return new Macaroon(identifier, [targetCaveat], delegatedSig);
+    }
+    static attenuate(macaroon, caveat) {
+        const newSig = crypto.createHmac('sha256', macaroon.signature).update(caveat).digest('hex');
+        return new Macaroon(macaroon.identifier, [...macaroon.caveats, caveat], newSig);
+    }
+    static serialize(macaroon) {
+        return Buffer.from(JSON.stringify(macaroon)).toString('base64');
+    }
+    static deserialize(token) {
+        const json = Buffer.from(token, 'base64').toString('utf8');
+        const obj = JSON.parse(json);
+        return new Macaroon(obj.identifier, obj.caveats, obj.signature);
+    }
+}
+exports.Macaroon = Macaroon;
+class MacaroonVerifier {
+    static verify(token, secret, context) {
+        try {
+            const macaroon = Macaroon.deserialize(token);
+            // Verify signature chain integrity
+            let currentSig = crypto.createHmac('sha256', secret).update(macaroon.identifier).digest('hex');
+            for (const caveat of macaroon.caveats) {
+                currentSig = crypto.createHmac('sha256', currentSig).update(caveat).digest('hex');
+            }
+            if (currentSig !== macaroon.signature) {
+                return false; // Signature validation failed
+            }
+            // Verify contextual caveats (expire, target path, target agent ID)
+            for (const caveat of macaroon.caveats) {
+                if (caveat.startsWith('target = ')) {
+                    const t = caveat.substring(9);
+                    if (t !== context.target)
+                        return false;
+                }
+                if (caveat.startsWith('expires < ')) {
+                    const t = parseInt(caveat.substring(10), 10);
+                    if (context.time >= t)
+                        return false;
+                }
+                if (caveat.startsWith('path = ')) {
+                    const p = caveat.substring(7);
+                    if (!context.path.startsWith(p))
+                        return false;
+                }
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.MacaroonVerifier = MacaroonVerifier;
+/** 동료(에이전트)별 평판 원장. 위반에 민감(위반 시 강하게 감점). */
+class ReputationLedger {
+    rep = new Map();
+    entry(peerId) {
+        let r = this.rep.get(peerId);
+        if (!r) {
+            r = { success: 0, violation: 0 };
+            this.rep.set(peerId, r);
+        }
+        return r;
+    }
+    recordSuccess(peerId) {
+        this.entry(peerId).success += 1;
+    }
+    recordViolation(peerId) {
+        this.entry(peerId).violation += 2; // 위반은 성공보다 무겁게
+    }
+    /** 신규 동료는 중립(0.5)에서 시작. 위반이 누적될수록 0에 수렴. */
+    get(peerId) {
+        const r = this.rep.get(peerId);
+        if (!r)
+            return 0.5;
+        const total = r.success + r.violation;
+        if (total === 0)
+            return 0.5;
+        return r.success / (total + 1);
+    }
+}
+exports.ReputationLedger = ReputationLedger;
+class A2ATrustGate {
+    secret;
+    ledger;
+    minTrust;
+    constructor(secret, ledger = new ReputationLedger(), minTrust = 0.25) {
+        this.secret = secret;
+        this.ledger = ledger;
+        this.minTrust = minTrust;
+    }
+    /** 신뢰 t 산출. HARD_GATE(서명+범위) 통과해야 t>0. 미달이면 allowed=false. */
+    evaluate(peerId, macaroonToken, ctx) {
+        const hardGate = MacaroonVerifier.verify(macaroonToken, this.secret, ctx);
+        if (!hardGate) {
+            this.ledger.recordViolation(peerId); // 위조/범위 밖 시도 → 평판 감점
+            return { trust: 0, allowed: false, reason: 'HARD_GATE 실패(서명 또는 Macaroon 범위)' };
+        }
+        const reputation = this.ledger.get(peerId);
+        const trust = 1 * reputation; // HARD_GATE=1
+        if (trust < this.minTrust) {
+            return { trust, allowed: false, reason: `신뢰 미달(t=${trust.toFixed(3)} < ${this.minTrust})` };
+        }
+        return { trust, allowed: true, reason: 'ok' };
+    }
+    ledgerRef() {
+        return this.ledger;
+    }
+}
+exports.A2ATrustGate = A2ATrustGate;
+class OverlayFsCompilerOptimizer {
+    /**
+     * [시뮬레이션] 실제 마운트 없이 cold/hot 지연을 흉내낸다. 정직 표기: 이것은 측정이 아니다.
+     * 실제 측정은 realOverlayCacheDemo() 사용.
+     */
+    async simulateCompile(mode) {
+        const t0 = performance.now();
+        if (mode === 'cold') {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            return { latencyMs: performance.now() - t0, buildOutput: '[sim] compiled from scratch' };
+        }
+        await Promise.resolve();
+        return { latencyMs: performance.now() - t0, buildOutput: '[sim] OverlayFS cache mount' };
+    }
+    /**
+     * [실측] 무권한 user namespace로 진짜 OverlayFS를 마운트해, 캐시된 툴체인이 재컴파일을
+     * 제거함을 측정한다(sudo 불필요, Linux 한정). 비-Linux는 supported=false 로 정직히 표기.
+     */
+    async realOverlayCacheDemo() {
+        if (process.platform !== 'linux') {
+            return { supported: false, coldMs: 0, hotMs: 0, coldResult: 'n/a', hotResult: 'n/a' };
+        }
+        const script = path.join(__dirname, '..', '..', '..', 'scripts', 'overlay-cache-demo.sh');
+        return new Promise((resolve) => {
+            (0, child_process_1.execFile)('bash', [script], { timeout: 30000, env: process.env }, (err, stdout) => {
+                if (err) {
+                    resolve({ supported: false, coldMs: 0, hotMs: 0, coldResult: 'error', hotResult: 'error' });
+                    return;
+                }
+                try {
+                    const line = stdout.trim().split('\n').pop();
+                    const j = JSON.parse(line);
+                    resolve({ supported: true, coldMs: j.coldMs, hotMs: j.hotMs, coldResult: j.coldResult, hotResult: j.hotResult });
+                }
+                catch {
+                    resolve({ supported: false, coldMs: 0, hotMs: 0, coldResult: 'parse-error', hotResult: 'parse-error' });
+                }
+            });
+        });
+    }
+}
+exports.OverlayFsCompilerOptimizer = OverlayFsCompilerOptimizer;
+exports.DEFAULT_SCHEDULER_CONFIG = {
+    kappa: 12, v0: 0.5, wMin: 100, wMax: 10000,
+};
+/** 식(2)의 시그모이드 σ(x)=1/(1+e^-x). P3.5 SmoothSafetyAnneal 등에서 재사용한다. */
+function sigmoid(x) {
+    return 1 / (1 + Math.exp(-x));
+}
+class EbpfSchedulerDriver {
+    currentWeights = new Map();
+    cfg;
+    constructor(cfg = {}) {
+        this.cfg = { ...exports.DEFAULT_SCHEDULER_CONFIG, ...cfg };
+    }
+    /** 식(2): 정규화된 v_norm∈[0,1] → cgroups CPU 가중치. 단조 증가·조정 가능. */
+    weightForValue(vNorm) {
+        const { kappa, v0, wMin, wMax } = this.cfg;
+        const v = Math.max(0, Math.min(1, vNorm));
+        const w = wMin + (wMax - wMin) * sigmoid(kappa * (v - v0));
+        return Math.round(Math.max(wMin, Math.min(wMax, w)));
+    }
+    /** 루트 자식 Q들을 min-max 정규화해 v_norm∈[0,1]로(교차과제 비교가능화). */
+    static normalize(q, qMin, qMax) {
+        if (qMax - qMin < 1e-9)
+            return 0.5; // 분산이 없으면 중립값
+        return Math.max(0, Math.min(1, (q - qMin) / (qMax - qMin)));
+    }
+    /**
+     * 정규화된 v_norm 으로 cgroups 가중치를 적용한다.
+     * - `weight`: 식(2)로 계산한 의도 가중치(플랫폼 무관, 항상 기록).
+     * - `success`: 커널 cpu.weight 실기입 성공 여부(Linux+유효 cgroup+권한일 때만 true. 비-Linux는 false — 정직).
+     */
+    adjustResourceByValue(cgroupPath, vNorm) {
+        const weight = this.weightForValue(vNorm);
+        this.currentWeights.set(cgroupPath, weight); // 의도 가중치는 항상 기록
+        const success = (0, core_1.setCgroupCpuWeight)(cgroupPath, weight); // 실제 커널 기입
+        return { weight, success };
+    }
+    /** 원시 Q와 분포(min,max)를 받아 정규화 후 적용하는 편의 메서드. */
+    adjustResourceByRawValue(cgroupPath, q, qMin, qMax) {
+        const vNorm = EbpfSchedulerDriver.normalize(q, qMin, qMax);
+        const { weight, success } = this.adjustResourceByValue(cgroupPath, vNorm);
+        return { weight, vNorm, success };
+    }
+    getWeight(cgroupPath) {
+        return this.currentWeights.get(cgroupPath);
+    }
+}
+exports.EbpfSchedulerDriver = EbpfSchedulerDriver;

package/dist/audit-store.d.ts

@@ -0,0 +1,14 @@
+import { AuditEvent, AuditSink } from './governance';
+export declare const DEFAULT_AUDIT_PATH: string;
+export declare class JsonlAuditStore {
+    private readonly filePath;
+    constructor(filePath?: string);
+    /** GovernanceController 에 주입할 영속 sink. append + fsync 로 내구 기록. */
+    readonly sink: AuditSink;
+    private append;
+    /** 디스크에서 감사 이벤트 복원(파일 없음/손상 줄은 건너뜀 — 정직). */
+    load(): AuditEvent[];
+    /** 기록 건수(디스크 기준). */
+    count(): number;
+    path(): string;
+}

package/dist/audit-store.js

@@ -0,0 +1,107 @@
+"use strict";
+// ============================================================================
+// JsonlAuditStore — 거버넌스 감사 로그 디스크 영속(append-only JSONL + fsync)
+// ----------------------------------------------------------------------------
+// GovernanceController 의 AuditSink 로 결선해 모든 감사 이벤트를 내구 기록한다.
+// 감사 로그는 append-only 가 자연스럽다(불변 추적). 각 줄은 1 이벤트(JSON).
+// 내구성: append 후 fsync 로 디스크 반영(프로세스가 죽어도 직전 기록까지 보존).
+// 헌법 제4조: 감사 로그는 **로컬 파일에만** 저장한다(외부 전송 없음).
+//
+// 정직 고지(제1계명): 가짜 복원 금지 — 파일 없음/손상 라인은 건너뛰고 정직히 부분 복원.
+// ============================================================================
+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.JsonlAuditStore = exports.DEFAULT_AUDIT_PATH = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.DEFAULT_AUDIT_PATH = path.join('audit-data', 'governance-audit.jsonl');
+class JsonlAuditStore {
+    filePath;
+    constructor(filePath = exports.DEFAULT_AUDIT_PATH) {
+        this.filePath = filePath;
+    }
+    /** GovernanceController 에 주입할 영속 sink. append + fsync 로 내구 기록. */
+    sink = (e) => {
+        this.append(e);
+    };
+    append(e) {
+        const dir = path.dirname(this.filePath);
+        if (dir && !fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        const line = JSON.stringify(e) + '\n';
+        // append + fsync: 크래시 시에도 직전 줄까지 내구 보존(가짜 ack 금지).
+        const fd = fs.openSync(this.filePath, 'a');
+        try {
+            fs.writeSync(fd, line);
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    /** 디스크에서 감사 이벤트 복원(파일 없음/손상 줄은 건너뜀 — 정직). */
+    load() {
+        let raw;
+        try {
+            raw = fs.readFileSync(this.filePath, 'utf8');
+        }
+        catch {
+            return []; // 파일 없음 → 빈 로그(날조 금지)
+        }
+        const out = [];
+        for (const line of raw.split('\n')) {
+            const s = line.trim();
+            if (!s)
+                continue;
+            try {
+                const o = JSON.parse(s);
+                if (o && typeof o.t === 'number' && typeof o.type === 'string')
+                    out.push(o);
+            }
+            catch {
+                /* 손상 줄 건너뜀 */
+            }
+        }
+        return out;
+    }
+    /** 기록 건수(디스크 기준). */
+    count() {
+        return this.load().length;
+    }
+    path() {
+        return this.filePath;
+    }
+}
+exports.JsonlAuditStore = JsonlAuditStore;

package/dist/beta-runner.d.ts

@@ -0,0 +1,95 @@
+import { ConsentGate, ConsentScope, OnboardingTracker, FeedbackStore, TierGuard, ConsentRecord, OnboardingRecord, FeedbackLabel, EgressAttempt } from './beta';
+import { MultiAxisReport } from './multi-axis-lift';
+export type Arm = 'on' | 'off';
+/** 실행 시 누적되는 arm 별 런타임 지표(효율·안전) — 피드백(정오·만족)과 별개로 집계. */
+interface ArmRuntime {
+    tasks: number;
+    oracleCalls: number;
+    totalTimeMs: number;
+    safetyChecked: number;
+    safetyBlocked: number;
+}
+export interface BetaTaskResult {
+    userId: string;
+    taskId: string;
+    arm: Arm;
+    output: string;
+    oracleCalls: number;
+    timeMs: number;
+    personalizationContext: string;
+}
+/** 과제 실행 로그 — 에이전트 출력을 보존해 참가자 라벨링 워크시트를 만든다(라벨 자체는 인간이 입력). */
+export interface BetaTaskLog {
+    userId: string;
+    taskId: string;
+    arm: Arm;
+    taskText: string;
+    output: string;
+    t: number;
+}
+export interface BetaRunnerState {
+    consent: ConsentRecord[];
+    onboarding: OnboardingRecord[];
+    feedback: FeedbackLabel[];
+    egress: EgressAttempt[];
+    armRuntime: Record<Arm, ArmRuntime>;
+    taskLog: BetaTaskLog[];
+}
+export type ShellRunner = (cmd: string) => Promise<string>;
+/**
+ * 한 클로즈드 베타 운영 세션. 참가자별 온보딩→과제→피드백을 누적하고 B1 리프트를 산출한다.
+ * runShell 은 실 샌드박스 실행기(주입). 미주입 시 과제는 도구 없이 LLM 응답만 받는다.
+ */
+export declare class BetaSession {
+    readonly consent: ConsentGate;
+    readonly onboarding: OnboardingTracker;
+    readonly feedback: FeedbackStore;
+    readonly tierGuard: TierGuard;
+    private profiles;
+    private runtime;
+    private taskLog;
+    /** 참가자 온보딩 — 동의 범위 부여 + signup 기록(실 타임스탬프). */
+    onboard(userId: string, scopes?: ConsentScope[], at?: number): void;
+    private profile;
+    /**
+     * 실 LLM 파이프라인으로 과제를 실행한다. arm='on' 이면 누적 사용자 컨텍스트를 주입(얕은 개인화),
+     * 'off' 면 주입하지 않는다(A/B 비교군). 효율(①호출·시간)을 실측 누적한다.
+     */
+    runTask(userId: string, taskId: string, taskText: string, arm: Arm, runShell?: ShellRunner): Promise<BetaTaskResult>;
+    /**
+     * 참가자(인간)의 라벨을 기록한다. satisfaction1to5 는 1..5 별점(0..1로 정규화), correct 는 정오 판정.
+     * **이 라벨은 인간이 준다 — 자체 생성 금지(제1계명).**
+     */
+    recordFeedback(userId: string, taskId: string, satisfaction1to5: number, correct: boolean | null, arm: Arm, note?: string): void;
+    /** 안전 점검 결과를 arm 에 누적(③ 안전 퇴행 — commit-gate/거버넌스 연동 지점). */
+    recordSafetyCheck(arm: Arm, blocked: boolean): void;
+    onboardedCount(): number;
+    /** arm 별 ArmMetrics 구성 — 피드백(정오·만족) + 런타임(효율·안전)에서. */
+    private armMetrics;
+    /**
+     * B1 MultiAxisLift 보고. **실 라벨이 없으면 정직하게 미측정**을 반환한다(자기 채점 금지).
+     * 두 arm 모두에 응답된 정오 라벨이 있어야 의미 있는 리프트가 산출된다.
+     */
+    liftReport(): {
+        status: 'measured';
+        report: MultiAxisReport;
+        onboarded: number;
+    } | {
+        status: '(목표; 미측정)';
+        reason: string;
+        onboarded: number;
+    };
+    /** 이미 라벨된 (task,arm) 인가(중복 라벨 안내 회피용). */
+    private isLabeled;
+    /**
+     * 참가자 라벨링 워크시트(Markdown). 에이전트 출력과 **빈 라벨 칸** + 정확한 feedback 명령을 만든다.
+     * ★ 라벨(정오·만족)은 **실참가자가 직접 채운다** — 운영자/에이전트가 대신 채우지 않는다(제1계명).
+     */
+    worksheet(userId: string): string;
+    taskLogFor(userId: string): BetaTaskLog[];
+    /** 로컬 영속(헌법 제4조 — 외부 전송 아님). 디렉터리 자동 생성. */
+    save(filePath: string): void;
+    /** 로컬 스냅샷에서 세션 복원(이어서 운영). */
+    static load(filePath: string): BetaSession;
+}
+export {};