@n2world/orchestrator 1.1.0

package/dist/governed-llm.js

@@ -0,0 +1,83 @@
+"use strict";
+// ============================================================================
+// v2.5.2 — Governed LLM 실행 계층 (Tier 분류 → TierGuard → 로컬/외부 라우팅)
+// ----------------------------------------------------------------------------
+// 이 모듈이 *실제 에이전트 응답 경로의 강제 지점*이다. 들어온 발화를 규칙기반으로
+// 분류하고(기본거부=Tier-0), TierGuard로 외부 송신을 통제하며, Tier-0는 로컬 백엔드로만
+// 처리한다(로컬 미설정 시 외부로 보내지 않고 정직하게 보류).
+//
+// 정직 고지(제1계명): 백엔드는 주입형(테스트 가능). 실 LLM/로컬 호출은 키·ollama 가
+// 있어야 성공(가짜 성공 없음). Tier-0 외부 송신 허용 건수는 항상 0이어야 한다.
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GovernedAgent = exports.NO_BACKEND_NOTICE = exports.TIER1_NOTICE = exports.TIER0_NO_LOCAL_NOTICE = void 0;
+exports.defaultGovernedBackends = defaultGovernedBackends;
+const llm_1 = require("./llm");
+const tier_classifier_1 = require("./tier-classifier");
+const tier_guard_1 = require("./tier-guard");
+exports.TIER0_NO_LOCAL_NOTICE = '[보안·Tier-0] 민감 데이터(개인정보/자격증명/센서·음성)는 외부 모델로 보내지 않습니다. 로컬 모델(OLLAMA_MODEL) 미설정으로 처리를 보류했습니다 — 로컬 모델을 설정하면 처리됩니다.';
+exports.TIER1_NOTICE = '[Tier-1] 외부 모델 사용 동의가 없고 로컬 모델도 없어 처리를 보류했습니다. 동의(consent) 또는 로컬 모델을 설정하세요.';
+exports.NO_BACKEND_NOTICE = '[알림] 사용 가능한 LLM 백엔드가 없습니다(외부 키·로컬 모델 모두 미설정).';
+/**
+ * Tier 라우팅 강제 에이전트. respond()가 실 실행 경로의 단일 강제 지점.
+ */
+class GovernedAgent {
+    backends;
+    guard;
+    /** 채널 정책상 기준 Tier — *미분류(DEFAULT-DENY)*에만 적용. 민감 매칭은 항상 Tier-0 유지. */
+    baselineTier;
+    constructor(backends, opts = {}) {
+        this.backends = backends;
+        this.guard = opts.guard ?? new tier_guard_1.TierGuard();
+        this.baselineTier = opts.baselineTier;
+    }
+    async respond(history, opts = {}) {
+        const last = [...history].reverse().find((t) => t.role === 'user')?.content ?? '';
+        const c = (0, tier_classifier_1.classifyTier)({ text: last });
+        // 민감(KIND/PII/SECRET) 매칭은 Tier-0 고정. 오직 '미분류(DEFAULT-DENY)'일 때만 기준 Tier 적용.
+        const baseline = opts.baselineTier ?? this.baselineTier;
+        const tier = (c.ruleId === 'DEFAULT-DENY' && baseline !== undefined) ? baseline : c.tier;
+        const ext = this.backends.externalName();
+        // ── Tier-0: 외부 금지, 로컬만 ──
+        if (tier === 0) {
+            if (this.backends.localConfigured()) {
+                this.guard.evaluate({ tier, provider: 'ollama-local' }); // allowed(local)
+                return { text: await this.backends.local(history, opts.system), tier, provider: 'local', blockedExternal: true, reason: 'Tier-0 → 로컬 강제' };
+            }
+            this.guard.evaluate({ tier, provider: ext }); // 외부 시도 → 차단 기록(0/N 보장)
+            return { text: exports.TIER0_NO_LOCAL_NOTICE, tier, provider: 'none', blockedExternal: true, reason: 'Tier-0·로컬 미설정 → 외부 차단·보류' };
+        }
+        // ── Tier-1: 로컬 우선, 외부는 동의 시 ──
+        if (tier === 1) {
+            const gate = this.guard.evaluate({ tier, provider: ext, userConsent: opts.consent });
+            if (gate.allowed && this.backends.externalAvailable()) {
+                return { text: await this.backends.external(history, opts.system), tier, provider: 'external', blockedExternal: false, reason: gate.reason };
+            }
+            if (this.backends.localConfigured()) {
+                return { text: await this.backends.local(history, opts.system), tier, provider: 'local', blockedExternal: !gate.allowed, reason: '로컬 우선/폴백' };
+            }
+            return { text: exports.TIER1_NOTICE, tier, provider: 'none', blockedExternal: !gate.allowed, reason: 'Tier-1 외부 동의 없음·로컬 없음' };
+        }
+        // ── Tier-2: 외부 허용(없으면 로컬) ──
+        const gate = this.guard.evaluate({ tier, provider: ext });
+        if (gate.allowed && this.backends.externalAvailable()) {
+            return { text: await this.backends.external(history, opts.system), tier, provider: 'external', blockedExternal: false, reason: gate.reason };
+        }
+        if (this.backends.localConfigured()) {
+            return { text: await this.backends.local(history, opts.system), tier, provider: 'local', blockedExternal: false, reason: '외부 불가 → 로컬 폴백' };
+        }
+        return { text: exports.NO_BACKEND_NOTICE, tier, provider: 'none', blockedExternal: false, reason: '백엔드 없음' };
+    }
+    guardRef() { return this.guard; }
+}
+exports.GovernedAgent = GovernedAgent;
+/** llm.ts 기반 기본 백엔드 구성(외부=askAgentChat, 로컬=localChat). */
+function defaultGovernedBackends(runShell) {
+    return {
+        external: (h) => (0, llm_1.askAgentChat)(h, runShell),
+        local: (h, s) => (0, llm_1.localChat)(h, s),
+        localConfigured: () => (0, llm_1.localLlmConfigured)(),
+        externalAvailable: () => (0, llm_1.externalProviderId)() !== null,
+        externalName: () => (0, llm_1.externalProviderId)() ?? 'external',
+    };
+}

package/dist/gpu-bridge.d.ts

@@ -0,0 +1,16 @@
+export declare class GpuDirectZeroCopyBridge {
+    private mapped;
+    private mappedOffset;
+    private mappedSize;
+    /** SAB의 특정 영역을 매핑(GPU 아님 — 호스트 공유메모리 영역 지정). */
+    mapGpuMemory(sharedBuffer: Uint8Array, offset: number, size: number): void;
+    /** 진짜 제로카피: 잠재 벡터를 매핑된 SAB 영역에 Float32 뷰로 직접 기록(복사 없음). */
+    syncLatentStateZeroCopy(sharedBuffer: Uint8Array, latentVector: number[]): void;
+    /** 매핑 영역에서 읽어와 기록이 실제로 반영됐는지 검증용. */
+    readBack(sharedBuffer: Uint8Array, length: number): number[];
+    /**
+     * 전통적 전송 베이스라인(실측 비교용): 직렬화→역직렬화→새 배열 복사.
+     * 가짜 지연(setTimeout) 없이 실제 작업만 수행한다 — 측정된 차이는 진짜다.
+     */
+    traditionalCopyTransfer(latentVector: number[]): number[];
+}

package/dist/gpu-bridge.js

@@ -0,0 +1,53 @@
+"use strict";
+// ============================================================================
+// SAB(SharedArrayBuffer) 제로카피 브리지
+// ----------------------------------------------------------------------------
+// 정직 고지(제1계명): 이 클래스는 **진짜 SharedArrayBuffer 제로카피 쓰기**를 한다(시뮬 아님).
+// 그러나 **GPU/CUDA/PCIe/GPUDirect는 구현되어 있지 않다** — 그 명칭은 향후 GPU 통합을 위한
+// 자리표시일 뿐, 현재는 호스트 메모리(SAB) 제로카피만 수행한다. 과거의 "0.05ms·100배" 류
+// 미검증 수치와 가짜(setTimeout) 베이스라인은 제거했다. 비교는 실제 직렬화-복사로만 한다.
+// (하위 호환을 위해 클래스명 GpuDirectZeroCopyBridge 는 유지한다.)
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GpuDirectZeroCopyBridge = void 0;
+class GpuDirectZeroCopyBridge {
+    mapped = false;
+    mappedOffset = 0;
+    mappedSize = 0;
+    /** SAB의 특정 영역을 매핑(GPU 아님 — 호스트 공유메모리 영역 지정). */
+    mapGpuMemory(sharedBuffer, offset, size) {
+        if (offset + size > sharedBuffer.byteLength) {
+            throw new Error('SAB mapping size exceeds shared buffer bounds');
+        }
+        this.mappedOffset = offset;
+        this.mappedSize = size;
+        this.mapped = true;
+    }
+    /** 진짜 제로카피: 잠재 벡터를 매핑된 SAB 영역에 Float32 뷰로 직접 기록(복사 없음). */
+    syncLatentStateZeroCopy(sharedBuffer, latentVector) {
+        if (!this.mapped)
+            throw new Error('SAB zero-copy bridge not mapped');
+        if (latentVector.length * 4 > this.mappedSize) {
+            throw new Error('Latent vector exceeds mapped SAB region size');
+        }
+        const floatView = new Float32Array(sharedBuffer.buffer, sharedBuffer.byteOffset + this.mappedOffset, latentVector.length);
+        floatView.set(latentVector); // 제로카피 직접 기록
+    }
+    /** 매핑 영역에서 읽어와 기록이 실제로 반영됐는지 검증용. */
+    readBack(sharedBuffer, length) {
+        if (!this.mapped)
+            throw new Error('SAB zero-copy bridge not mapped');
+        const floatView = new Float32Array(sharedBuffer.buffer, sharedBuffer.byteOffset + this.mappedOffset, length);
+        return Array.from(floatView);
+    }
+    /**
+     * 전통적 전송 베이스라인(실측 비교용): 직렬화→역직렬화→새 배열 복사.
+     * 가짜 지연(setTimeout) 없이 실제 작업만 수행한다 — 측정된 차이는 진짜다.
+     */
+    traditionalCopyTransfer(latentVector) {
+        const serialized = JSON.stringify({ latent: latentVector });
+        const parsed = JSON.parse(serialized);
+        return parsed.latent.slice(); // 복사본 반환
+    }
+}
+exports.GpuDirectZeroCopyBridge = GpuDirectZeroCopyBridge;

package/dist/health.d.ts

@@ -0,0 +1,47 @@
+import { TelemetrySource, Telemetry } from './telemetry';
+import { GovernanceController } from './governance';
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LogEntry {
+    t: string;
+    level: LogLevel;
+    event: string;
+    fields?: Record<string, unknown>;
+}
+/** 구조적(JSON) 로거. 레벨 필터 + sink(콘솔/외부) + 선택적 캡처. */
+export declare class StructuredLogger {
+    private opts;
+    private entries;
+    constructor(opts?: {
+        level?: LogLevel;
+        sink?: (e: LogEntry) => void;
+        capture?: boolean;
+    });
+    log(level: LogLevel, event: string, fields?: Record<string, unknown>): void;
+    debug(e: string, f?: Record<string, unknown>): void;
+    info(e: string, f?: Record<string, unknown>): void;
+    warn(e: string, f?: Record<string, unknown>): void;
+    error(e: string, f?: Record<string, unknown>): void;
+    getEntries(): LogEntry[];
+}
+export interface HealthThresholds {
+    maxMemPercent: number;
+    maxCpuPercent: number;
+}
+export declare const DEFAULT_HEALTH_THRESHOLDS: HealthThresholds;
+export interface HealthStatus {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    checks: Record<string, {
+        ok: boolean;
+        detail: string;
+    }>;
+    telemetry: Telemetry;
+    t: string;
+}
+/** 텔레메트리 + 거버넌스를 종합해 건강 상태를 산출(실측 기반). */
+export declare class HealthCheck {
+    private telemetry;
+    private gov?;
+    private thresholds;
+    constructor(telemetry: TelemetrySource, gov?: GovernanceController | undefined, thresholds?: HealthThresholds);
+    check(): HealthStatus;
+}

package/dist/health.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthCheck = exports.DEFAULT_HEALTH_THRESHOLDS = exports.StructuredLogger = void 0;
+const LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+/** 구조적(JSON) 로거. 레벨 필터 + sink(콘솔/외부) + 선택적 캡처. */
+class StructuredLogger {
+    opts;
+    entries = [];
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    log(level, event, fields) {
+        if (LEVEL_ORDER[level] < LEVEL_ORDER[this.opts.level ?? 'info'])
+            return;
+        const entry = { t: new Date().toISOString(), level, event, ...(fields ? { fields } : {}) };
+        if (this.opts.capture)
+            this.entries.push(entry);
+        if (this.opts.sink)
+            this.opts.sink(entry);
+    }
+    debug(e, f) { this.log('debug', e, f); }
+    info(e, f) { this.log('info', e, f); }
+    warn(e, f) { this.log('warn', e, f); }
+    error(e, f) { this.log('error', e, f); }
+    getEntries() { return this.entries; }
+}
+exports.StructuredLogger = StructuredLogger;
+exports.DEFAULT_HEALTH_THRESHOLDS = { maxMemPercent: 90, maxCpuPercent: 95 };
+/** 텔레메트리 + 거버넌스를 종합해 건강 상태를 산출(실측 기반). */
+class HealthCheck {
+    telemetry;
+    gov;
+    thresholds;
+    constructor(telemetry, gov, thresholds = exports.DEFAULT_HEALTH_THRESHOLDS) {
+        this.telemetry = telemetry;
+        this.gov = gov;
+        this.thresholds = thresholds;
+    }
+    check() {
+        const tm = this.telemetry.sample();
+        const checks = {};
+        checks.memory = {
+            ok: tm.memPercent < this.thresholds.maxMemPercent,
+            detail: `${tm.memPercent}% (<${this.thresholds.maxMemPercent}%)`,
+        };
+        checks.cpu = {
+            ok: tm.cpuPercent < this.thresholds.maxCpuPercent,
+            detail: `${tm.cpuPercent}% (<${this.thresholds.maxCpuPercent}%)`,
+        };
+        let killed = false;
+        if (this.gov) {
+            const s = this.gov.status();
+            killed = s.killed;
+            checks.killswitch = { ok: !s.killed, detail: s.killed ? 'ACTIVE(중단)' : 'off' };
+            checks.budget = { ok: s.budgetRemaining > 0, detail: `남은 예산 ${s.budgetRemaining}` };
+        }
+        // 킬스위치 활성 = unhealthy(의도적 중단). 임계 초과 = degraded. 그 외 healthy.
+        let status = 'healthy';
+        if (killed)
+            status = 'unhealthy';
+        else if (Object.values(checks).some((c) => !c.ok))
+            status = 'degraded';
+        return { status, checks, telemetry: tm, t: new Date().toISOString() };
+    }
+}
+exports.HealthCheck = HealthCheck;

package/dist/identity-link.d.ts

@@ -0,0 +1,32 @@
+/** (테넌트:채널:발신자) 정규화 세션 키 — 멀티테넌트 격리의 기본 단위. */
+export declare function sessionKey(tenant: string, channel: string, sender: string): string;
+export interface ChannelAccount {
+    channel: string;
+    sender: string;
+}
+/**
+ * 신원 링크 원장 — 한 사람(identityId)에 여러 (채널:발신자)를 페어링 코드로 잇는다.
+ */
+export declare class IdentityLinker {
+    private readonly ttlMs;
+    /** (channel:sender) → identityId */
+    private linked;
+    /** code → pending */
+    private pending;
+    constructor(ttlMs?: number);
+    private acc;
+    /** 1차 채널에서 페어링 코드 발급(이 채널은 즉시 링크). */
+    issuePairingCode(identityId: string, primary: ChannelAccount, now?: number): string;
+    /** 2차 채널에서 코드 제출 → 검증 성공 시 동일 신원으로 링크(코드 1회 소모). */
+    redeemPairingCode(code: string, secondary: ChannelAccount, now?: number): {
+        ok: boolean;
+        identityId?: string;
+        reason?: string;
+    };
+    identityOf(a: ChannelAccount): string | null;
+    /** 도킹 허용 여부: 두 채널 계정이 *동일 검증 신원*에 링크돼 있어야 한다. */
+    canDock(from: ChannelAccount, to: ChannelAccount): {
+        allowed: boolean;
+        reason: string;
+    };
+}

package/dist/identity-link.js

@@ -0,0 +1,98 @@
+"use strict";
+// ============================================================================
+// v2.5.2 Phase 1 — 교차 채널 신원 링크 + 테넌트 세션 키
+// ----------------------------------------------------------------------------
+// 계획서 v2.5.2 §8: 채널 ID ≠ 인증. 동일 사용자의 텔레그램·슬랙 계정을 *일회성 코드
+// 페어링*으로 링크·검증한다. 링크된 신원만 채널 도킹을 허용(교차 채널 컨텍스트 이전).
+// 또한 세션 키를 (테넌트:채널:발신자)로 강제해 멀티테넌트 격리를 보장한다.
+//
+// 정직 고지(제1계명): 페어링 코드는 만료·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.IdentityLinker = void 0;
+exports.sessionKey = sessionKey;
+const crypto = __importStar(require("crypto"));
+/** (테넌트:채널:발신자) 정규화 세션 키 — 멀티테넌트 격리의 기본 단위. */
+function sessionKey(tenant, channel, sender) {
+    const norm = (s) => String(s).replace(/[^\w.-]/g, '_').slice(0, 64);
+    return `${norm(tenant)}:${norm(channel)}:${norm(sender)}`;
+}
+/**
+ * 신원 링크 원장 — 한 사람(identityId)에 여러 (채널:발신자)를 페어링 코드로 잇는다.
+ */
+class IdentityLinker {
+    ttlMs;
+    /** (channel:sender) → identityId */
+    linked = new Map();
+    /** code → pending */
+    pending = new Map();
+    constructor(ttlMs = 5 * 60 * 1000) {
+        this.ttlMs = ttlMs;
+    }
+    acc(a) { return `${a.channel}:${a.sender}`; }
+    /** 1차 채널에서 페어링 코드 발급(이 채널은 즉시 링크). */
+    issuePairingCode(identityId, primary, now = Date.now()) {
+        this.linked.set(this.acc(primary), identityId);
+        const code = crypto.randomBytes(4).toString('hex').toUpperCase(); // 8자 1회성
+        this.pending.set(code, { identityId, code, expiresAt: now + this.ttlMs });
+        return code;
+    }
+    /** 2차 채널에서 코드 제출 → 검증 성공 시 동일 신원으로 링크(코드 1회 소모). */
+    redeemPairingCode(code, secondary, now = Date.now()) {
+        const p = this.pending.get(code);
+        if (!p)
+            return { ok: false, reason: '코드 없음/이미 사용됨' };
+        if (now > p.expiresAt) {
+            this.pending.delete(code);
+            return { ok: false, reason: '코드 만료' };
+        }
+        this.pending.delete(code); // 1회성 소모
+        this.linked.set(this.acc(secondary), p.identityId);
+        return { ok: true, identityId: p.identityId };
+    }
+    identityOf(a) { return this.linked.get(this.acc(a)) ?? null; }
+    /** 도킹 허용 여부: 두 채널 계정이 *동일 검증 신원*에 링크돼 있어야 한다. */
+    canDock(from, to) {
+        const a = this.identityOf(from);
+        const b = this.identityOf(to);
+        if (!a || !b)
+            return { allowed: false, reason: '미검증 신원(페어링 필요)' };
+        if (a !== b)
+            return { allowed: false, reason: '서로 다른 신원 — 교차 신원 도킹 차단' };
+        return { allowed: true, reason: 'ok' };
+    }
+}
+exports.IdentityLinker = IdentityLinker;

package/dist/index.d.ts

@@ -0,0 +1,184 @@
+import { MctsEngine, pruneActions, EbpfMapScheduler } from '@n2world/core';
+import { A2AContext, A2ATrustGate } from './agent-os-rd';
+import { PgliteVectorStore, SearchHit } from './pglite-store';
+import { KnowledgeGraph, ParseOptions } from './knowledge-graph';
+export interface ISandbox {
+    runCommand(command: string): Promise<{
+        stdout: string;
+        stderr: string;
+        code: number;
+    }>;
+    writeFile(filePath: string, content: string): Promise<void>;
+    readFile(filePath: string): Promise<string>;
+    destroy(): Promise<void>;
+}
+export interface ApprovalRequest {
+    kind: 'command' | 'write';
+    detail: string;
+}
+export interface SecurityPolicy {
+    /** 무조건 차단되는 명령 패턴(파괴적). */
+    deniedCommandPatterns: string[];
+    /** 승인이 필요한 위험 명령 패턴(되돌릴 수 없음). 승인자 없으면 차단. */
+    riskyCommandPatterns: string[];
+    /** S1 프리뷰/승인 훅. 위험 명령 실행 전 호출. 미지정 시 위험 명령은 차단. */
+    approve?: (req: ApprovalRequest) => Promise<boolean>;
+}
+export declare const DEFAULT_SECURITY_POLICY: SecurityPolicy;
+export declare class LocalSandbox implements ISandbox {
+    private policy;
+    private tempDir;
+    constructor(policy?: SecurityPolicy);
+    init(): Promise<void>;
+    /** 명령 보안 점검: 차단/위험(승인)/허용. */
+    private checkCommand;
+    /** 경로 탈출 차단: tempDir 밖으로 나가는 경로를 거부. */
+    private safePath;
+    runCommand(command: string): Promise<{
+        stdout: string;
+        stderr: string;
+        code: number;
+    }>;
+    writeFile(filePath: string, content: string): Promise<void>;
+    readFile(filePath: string): Promise<string>;
+    destroy(): Promise<void>;
+}
+export interface KvmStatus {
+    kvmPresent: boolean;
+    kvmWritable: boolean;
+    firecracker: boolean;
+    ready: boolean;
+    reason: string;
+}
+/** Firecracker microVM 부팅 가능성을 실제로 탐지한다(거짓 주장 금지). */
+export declare function detectFirecracker(): KvmStatus;
+/**
+ * Firecracker microVM 샌드박스(ISandbox). 부팅 전제(KVM 접근·firecracker·커널/rootfs 이미지)가
+ * 갖춰져야 한다. 미충족 시 init()이 명확한 사유로 throw → createSandbox()가 폴백을 선택한다.
+ * (거짓 부팅을 흉내내지 않는다.)
+ */
+export declare class FirecrackerSandbox implements ISandbox {
+    private kernelImage?;
+    private rootfsImage?;
+    private status;
+    constructor(kernelImage?: string | undefined, rootfsImage?: string | undefined);
+    init(): Promise<void>;
+    runCommand(): Promise<{
+        stdout: string;
+        stderr: string;
+        code: number;
+    }>;
+    writeFile(): Promise<void>;
+    readFile(): Promise<string>;
+    destroy(): Promise<void>;
+}
+/**
+ * P4 폴백 팩토리: microVM 부팅 가능하면 Firecracker, 아니면 LocalSandbox(유저스페이스 격리).
+ * "거짓 폴백 금지" — 실제로 동작하는 샌드박스를 반환한다.
+ */
+export declare function createSandbox(opts?: {
+    kernelImage?: string;
+    rootfsImage?: string;
+}): Promise<{
+    sandbox: ISandbox;
+    backend: 'firecracker' | 'local';
+    reason: string;
+}>;
+export declare function greetCore(name: string): string;
+export interface SymbolicMetaTuple {
+    targetFilePath: string;
+    astErrorCode: number;
+    projectDependencyMap: Record<string, string>;
+}
+export declare function writeMetaTuple(buffer: Uint8Array, tuple: SymbolicMetaTuple): void;
+export declare function getMetaTuple(buffer: Uint8Array): SymbolicMetaTuple;
+export interface Skill {
+    filePath: string;
+    content: string;
+    embedding: number[];
+}
+export declare class SkillManager {
+    private skills;
+    private skillsDir;
+    private hnsw;
+    private vectorStore?;
+    constructor(skillsDir: string);
+    /**
+     * P1: PGLite 영속 벡터 저장을 부착한다(선택). 부착하면 createSkill/loadSkills 시
+     * 임베딩이 영속화되고 `searchPersistent`/`persistedStaleWindowMs` 를 쓸 수 있다.
+     * 부착하지 않으면 기존 인메모리 HNSW 경로만 사용한다(공개 API 불변).
+     */
+    attachVectorStore(store: PgliteVectorStore): void;
+    init(): Promise<void>;
+    private loadSkills;
+    createSkill(fileName: string, content: string): Promise<void>;
+    /**
+     * P1: 영속 저장(PGLite) 경로의 코사인 검색. vectorStore 부착 시에만 동작.
+     * 기존 routeSkill(SAB+HNSW)과 별개의 추가 경로다(하위 호환 — 기존 경로 불변).
+     */
+    searchPersistent(query: string, k?: number): Promise<SearchHit[]>;
+    /** P1: 영속 저장의 경계-staleness 측정값(ms). 미부착 시 null. */
+    persistedStaleWindowMs(): number | null;
+    /**
+     * P2: 적재된 스킬(.md) 항목 간 자가연결 지식 그래프를 만든다(참조·의존·유사).
+     * 라우팅/검색을 보조하는 추가 경로 — 기존 공개 API 불변(하위 호환).
+     * 항목 id 는 파일 basename 을 쓴다.
+     */
+    buildKnowledgeGraph(opts?: ParseOptions): KnowledgeGraph;
+    /**
+     * 7-2: 외부(제3자) 스킬 수용은 반드시 A2A 신뢰 게이트를 통과해야 한다.
+     * 서명+Macaroon 범위(HARD_GATE)와 평판으로 t를 산출하고, 통과한 스킬만 라우팅/색인한다.
+     * 가치 v가 아니라 신뢰 t로 게이팅한다(고가치·저신뢰 스킬은 차단).
+     */
+    ingestExternalSkill(peerId: string, fileName: string, content: string, macaroonToken: string, ctx: A2AContext, gate: A2ATrustGate): Promise<{
+        accepted: boolean;
+        reason: string;
+        trust: number;
+    }>;
+    skillCount(): number;
+    private generateMockEmbedding;
+    routeSkill(query: string, sharedBuffer: Uint8Array): Promise<string[]>;
+}
+export { MctsEngine, pruneActions, EbpfMapScheduler };
+export * from './sandbox-controller';
+export * from './worker-agent';
+export * from './gateway';
+export * from './wal-buffer';
+export * from './oracle';
+export * from './prompt-optimizer';
+export * from './agent-os-rd';
+export * from './gpu-bridge';
+export * from './dashboard-server';
+export * from './value-calibration';
+export * from './oracle-anchored-search';
+export * from './predictive-agent';
+export * from './value-head';
+export * from './telemetry';
+export * from './governance';
+export * from './cost-estimator';
+export * from './satisfaction-metrics';
+export * from './governed-executor';
+export * from './rate-limiter';
+export * from './health';
+export * from './text-embedding';
+export * from './personalization';
+export * from './beta';
+export * from './multi-axis-lift';
+export * from './pglite-store';
+export * from './pglite-hnsw-bridge';
+export * from './knowledge-graph';
+export * from './wiki-synthesizer';
+export * from './safety-anneal';
+export * from './mcts-prior';
+export * from './mcts-kernel-bridge';
+export * from './commit-gate';
+export * from './mcp-macaroon';
+export * from './p6-governance';
+export * from './beta-runner';
+export { askAgent, askAgentChat, llmComplete, llmCompleteUsage, activeLlmInfo } from './llm';
+export { ChatStore, DEFAULT_CHAT_HISTORY_PATH } from './chat-store';
+export * from './channels';
+export * from './channel-gateway';
+export * from './conversation-graph';
+export * from './browser-agent';
+export * as kakaoOAuth from './kakao-oauth';