@n2world/orchestrator 1.1.0

package/dist/value-calibration.js

@@ -0,0 +1,133 @@
+"use strict";
+// ============================================================================
+// 7-5. 가치 v 보정 — 일급 신뢰경계 (식(2)/계층2 소비 앞단)
+// ----------------------------------------------------------------------------
+// v 가 틀리면 계층2·3이 동시 오작동(단일 장애점)하므로, 소비 직전에 보정한다:
+//   ① 정규화(min-max) ② 이상치 윈저라이즈 ③ 적대적 팽창 탐지(오라클 실제결과와의 괴리)
+//   ④ 감사 로그 + 예산 상한 + 킬스위치
+// 보정 통과한 v 만 계층2·3이 소비한다.
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BudgetGuard = exports.ValueCalibrator = void 0;
+exports.winsorize = winsorize;
+exports.normalize = normalize;
+function mean(xs) {
+    if (xs.length === 0)
+        return 0;
+    return xs.reduce((a, b) => a + b, 0) / xs.length;
+}
+/** 배열을 [pLow, pHigh] 분위수로 윈저라이즈(이상치 클리핑). */
+function winsorize(values, pLow = 0.01, pHigh = 0.99) {
+    if (values.length === 0)
+        return [];
+    const sorted = [...values].sort((a, b) => a - b);
+    const q = (p) => sorted[Math.min(sorted.length - 1, Math.max(0, Math.floor(p * (sorted.length - 1))))];
+    const lo = q(pLow);
+    const hi = q(pHigh);
+    return values.map((v) => Math.min(hi, Math.max(lo, v)));
+}
+/** 루트 자식 Q들을 min-max 정규화 → v_norm∈[0,1]. */
+function normalize(q, qMin, qMax) {
+    if (qMax - qMin < 1e-9)
+        return 0.5;
+    return Math.max(0, Math.min(1, (q - qMin) / (qMax - qMin)));
+}
+class ValueCalibrator {
+    minObservations;
+    history = new Map();
+    auditLog = [];
+    killed = false;
+    constructor(minObservations = 3) {
+        this.minObservations = minObservations;
+    }
+    /** 적대적 팽창 관측 기록: 소스가 주장한 v 와 오라클이 매긴 실제 결과를 비교용으로 저장. */
+    observe(source, claimedV, actualOutcome) {
+        let h = this.history.get(source);
+        if (!h) {
+            h = { claimed: [], actual: [] };
+            this.history.set(source, h);
+        }
+        h.claimed.push(Math.max(0, Math.min(1, claimedV)));
+        h.actual.push(Math.max(0, Math.min(1, actualOutcome)));
+    }
+    /** 소스의 과거 과대평가 정도 → 감쇠 계수∈[0.1,1]. 부풀릴수록 1에서 멀어진다. */
+    inflationPenalty(source) {
+        const h = this.history.get(source);
+        if (!h || h.claimed.length < this.minObservations)
+            return 1.0;
+        const mc = mean(h.claimed);
+        const ma = mean(h.actual);
+        if (mc <= ma + 0.05)
+            return 1.0; // 정직(또는 과소평가) → 감쇠 없음
+        const gap = Math.min(1, mc - ma);
+        return Math.max(0.1, 1 - gap);
+    }
+    /**
+     * 소비 직전 보정: 정규화된 v_norm 에 팽창 감쇠를 적용하고 감사 로그에 남긴다.
+     * 킬스위치가 내려가 있으면 0(자원 차단)을 반환한다.
+     */
+    calibrate(source, vNorm) {
+        if (this.killed) {
+            this.auditLog.push({ source, raw: vNorm, calibrated: 0, penalty: 0, t: Date.now() });
+            return 0;
+        }
+        const v = Math.max(0, Math.min(1, vNorm));
+        const penalty = this.inflationPenalty(source);
+        const calibrated = Math.max(0, Math.min(1, v * penalty));
+        this.auditLog.push({ source, raw: vNorm, calibrated, penalty, t: Date.now() });
+        return calibrated;
+    }
+    /** v 와 오라클 실제 결과의 상관(영가설 판정용). |corr| 낮으면 v 스케줄링 근거 약함. */
+    correlationWithOracle(source) {
+        const h = this.history.get(source);
+        if (!h || h.claimed.length < 2)
+            return 0;
+        const mc = mean(h.claimed);
+        const ma = mean(h.actual);
+        let num = 0;
+        let dc = 0;
+        let da = 0;
+        for (let i = 0; i < h.claimed.length; i++) {
+            const x = h.claimed[i] - mc;
+            const y = h.actual[i] - ma;
+            num += x * y;
+            dc += x * x;
+            da += y * y;
+        }
+        if (dc === 0 || da === 0)
+            return 0;
+        return num / Math.sqrt(dc * da);
+    }
+    getAuditLog() {
+        return this.auditLog;
+    }
+    // ---- S3 경계 보장 킬스위치 ----
+    kill() {
+        this.killed = true;
+    }
+    reset() {
+        this.killed = false;
+    }
+    isKilled() {
+        return this.killed;
+    }
+}
+exports.ValueCalibrator = ValueCalibrator;
+/** 예산 상한 가드: 누적 토큰/비용이 상한을 넘으면 추가 소비를 차단. */
+class BudgetGuard {
+    cap;
+    spent = 0;
+    constructor(cap) {
+        this.cap = cap;
+    }
+    trySpend(amount) {
+        if (this.spent + amount > this.cap)
+            return false;
+        this.spent += amount;
+        return true;
+    }
+    remaining() {
+        return Math.max(0, this.cap - this.spent);
+    }
+}
+exports.BudgetGuard = BudgetGuard;

package/dist/value-head.d.ts

@@ -0,0 +1,20 @@
+/** 해시 n-gram 특징화: 후보 텍스트 + 목표 컨텍스트 → 고정차원 밀집 벡터(부호 해시). */
+export declare function featurize(text: string, context: string, dim?: number): Float64Array;
+/** 선형 로지스틱 회귀(경사하강 + L2). 오라클 라벨(pass=1/fail=0)로 학습. */
+export declare class ValueHead {
+    private dim;
+    private w;
+    private b;
+    constructor(dim?: number);
+    /** X: 특징 벡터 배열, y: 0/1 라벨. */
+    fit(X: Float64Array[], y: number[], opts?: {
+        epochs?: number;
+        lr?: number;
+        l2?: number;
+    }): void;
+    predictProba(x: Float64Array): number;
+}
+/** 예상 오라클 호출 수(첫 통과까지) — 랭킹 품질 지표. 낮을수록 좋음. */
+export declare function oracleCallsToFirstPass(ranked: {
+    pass: boolean;
+}[]): number;

package/dist/value-head.js

@@ -0,0 +1,91 @@
+"use strict";
+// ============================================================================
+// G4 착수 — 학습 가치 예측기(신경 잠재의 최소 실측 대리).
+// ----------------------------------------------------------------------------
+//  목적: g_fast 필터가 발동하지 않는 영역(δ=0, 또는 후보가 모두 타입-유효 = §4k 실 LLM 실측)에서
+//   남은 유일한 지렛대는 "통과할 후보를 먼저 시도하도록 정렬"이다. 현재는 `gfastValue`(토큰겹침 휴리스틱).
+//   여기서 **오라클 결과(pass/fail)로 학습**한 선형 로지스틱 회귀가 그 휴리스틱보다 나은 랭킹을 주는지 측정한다.
+//
+//  정직(제1계명): 이것은 **해시 특징 위의 선형 로지스틱**이다. 논문의 잠재 z_t·마스킹 브리지(비선형·학습 잠재)는
+//   **미구현(설계단계 🔶)**. 본 모듈은 "학습이 δ=0 랭킹을 개선하는가"의 최소 반증 가능한 측정 도구다.
+//   fit 은 실제 경사하강, predict 는 실제 시그모이드 — mock 없음. 이득은 held-out 측정으로만 주장한다.
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueHead = void 0;
+exports.featurize = featurize;
+exports.oracleCallsToFirstPass = oracleCallsToFirstPass;
+/** 해시 n-gram 특징화: 후보 텍스트 + 목표 컨텍스트 → 고정차원 밀집 벡터(부호 해시). */
+function featurize(text, context, dim = 256) {
+    const v = new Float64Array(dim);
+    const toks = (s) => (s || '').toLowerCase().match(/[a-z0-9_]+/g) ?? [];
+    const hash = (s) => { let h = 2166136261 >>> 0; for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619) >>> 0;
+    } return h; };
+    const add = (tok, w) => { const h = hash(tok); v[h % dim] += ((h >>> 31) ? -1 : 1) * w; };
+    const ctx = new Set(toks(context));
+    const ct = toks(text);
+    for (let i = 0; i < ct.length; i++) {
+        add(ct[i], 1); // 단일 토큰
+        if (i + 1 < ct.length)
+            add(ct[i] + '_' + ct[i + 1], 1); // 바이그램
+        if (ctx.has(ct[i]))
+            add('__ctxhit', 1); // 컨텍스트 겹침 신호
+    }
+    add('__len', Math.min(ct.length / 50, 2)); // 길이(과대 후보 벌점 여지)
+    // L2 정규화(스케일 안정).
+    let n = 0;
+    for (let i = 0; i < dim; i++)
+        n += v[i] * v[i];
+    n = Math.sqrt(n) || 1;
+    for (let i = 0; i < dim; i++)
+        v[i] /= n;
+    return v;
+}
+const sigmoid = (z) => 1 / (1 + Math.exp(-z));
+/** 선형 로지스틱 회귀(경사하강 + L2). 오라클 라벨(pass=1/fail=0)로 학습. */
+class ValueHead {
+    dim;
+    w;
+    b = 0;
+    constructor(dim = 256) {
+        this.dim = dim;
+        this.w = new Float64Array(dim);
+    }
+    /** X: 특징 벡터 배열, y: 0/1 라벨. */
+    fit(X, y, opts = {}) {
+        const epochs = opts.epochs ?? 300, lr = opts.lr ?? 0.3, l2 = opts.l2 ?? 1e-3;
+        const n = X.length;
+        if (n === 0)
+            return;
+        for (let e = 0; e < epochs; e++) {
+            const gw = new Float64Array(this.dim);
+            let gb = 0;
+            for (let i = 0; i < n; i++) {
+                const p = this.predictProba(X[i]);
+                const err = p - y[i];
+                const xi = X[i];
+                for (let j = 0; j < this.dim; j++)
+                    gw[j] += err * xi[j];
+                gb += err;
+            }
+            for (let j = 0; j < this.dim; j++)
+                this.w[j] -= lr * (gw[j] / n + l2 * this.w[j]);
+            this.b -= lr * (gb / n);
+        }
+    }
+    predictProba(x) {
+        let z = this.b;
+        for (let j = 0; j < this.dim; j++)
+            z += this.w[j] * x[j];
+        return sigmoid(z);
+    }
+}
+exports.ValueHead = ValueHead;
+/** 예상 오라클 호출 수(첫 통과까지) — 랭킹 품질 지표. 낮을수록 좋음. */
+function oracleCallsToFirstPass(ranked) {
+    for (let i = 0; i < ranked.length; i++)
+        if (ranked[i].pass)
+            return i + 1;
+    return ranked.length; // 통과 없음 = 전부 시도
+}

package/dist/wal-buffer.d.ts

@@ -0,0 +1,23 @@
+export interface Message {
+    id?: number;
+    channel: string;
+    content: string;
+    timestamp: number;
+}
+export declare class SQLiteWalBuffer {
+    private db;
+    private dbPath;
+    constructor(dbPath: string);
+    init(): Promise<void>;
+    pushMessage(channel: string, content: string): Promise<void>;
+    popAllMessages(): Promise<Message[]>;
+    /**
+     * 7-6: ack 기반 at-least-once 읽기. 메시지를 삭제하지 않고 조회만 한다.
+     * 소비자가 처리 후 ackMessages(ids)로 명시 확인할 때까지 WAL에 남아 유실을 막는다.
+     */
+    peekMessages(): Promise<Message[]>;
+    /** 처리 완료된 메시지를 id로 확인(삭제). 멱등: 이미 없는 id는 무시된다. */
+    ackMessages(ids: number[]): Promise<void>;
+    getPendingCount(): Promise<number>;
+    close(): Promise<void>;
+}

package/dist/wal-buffer.js

@@ -0,0 +1,144 @@
+"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.SQLiteWalBuffer = void 0;
+const sqlite3 = __importStar(require("sqlite3"));
+class SQLiteWalBuffer {
+    db = null;
+    dbPath;
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+    }
+    async init() {
+        return new Promise((resolve, reject) => {
+            this.db = new sqlite3.Database(this.dbPath, (err) => {
+                if (err)
+                    return reject(err);
+                // Enable WAL (Write-Ahead Logging) mode
+                this.db.run('PRAGMA journal_mode=WAL;', (walErr) => {
+                    if (walErr)
+                        return reject(walErr);
+                    this.db.run(`CREATE TABLE IF NOT EXISTS messages (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              channel TEXT,
+              content TEXT,
+              timestamp INTEGER
+            )`, (tableErr) => {
+                        if (tableErr)
+                            return reject(tableErr);
+                        resolve();
+                    });
+                });
+            });
+        });
+    }
+    async pushMessage(channel, content) {
+        return new Promise((resolve, reject) => {
+            const timestamp = Date.now();
+            this.db.run('INSERT INTO messages (channel, content, timestamp) VALUES (?, ?, ?)', [channel, content, timestamp], (err) => {
+                if (err)
+                    return reject(err);
+                resolve();
+            });
+        });
+    }
+    async popAllMessages() {
+        return new Promise((resolve, reject) => {
+            this.db.all('SELECT * FROM messages ORDER BY timestamp ASC', (err, rows) => {
+                if (err)
+                    return reject(err);
+                const messages = rows.map(r => ({
+                    id: r.id,
+                    channel: r.channel,
+                    content: r.content,
+                    timestamp: r.timestamp
+                }));
+                // Delete all read messages to clear the queue
+                this.db.run('DELETE FROM messages', (delErr) => {
+                    if (delErr)
+                        return reject(delErr);
+                    resolve(messages);
+                });
+            });
+        });
+    }
+    /**
+     * 7-6: ack 기반 at-least-once 읽기. 메시지를 삭제하지 않고 조회만 한다.
+     * 소비자가 처리 후 ackMessages(ids)로 명시 확인할 때까지 WAL에 남아 유실을 막는다.
+     */
+    async peekMessages() {
+        return new Promise((resolve, reject) => {
+            this.db.all('SELECT * FROM messages ORDER BY id ASC', (err, rows) => {
+                if (err)
+                    return reject(err);
+                resolve(rows.map((r) => ({ id: r.id, channel: r.channel, content: r.content, timestamp: r.timestamp })));
+            });
+        });
+    }
+    /** 처리 완료된 메시지를 id로 확인(삭제). 멱등: 이미 없는 id는 무시된다. */
+    async ackMessages(ids) {
+        if (ids.length === 0)
+            return;
+        return new Promise((resolve, reject) => {
+            const placeholders = ids.map(() => '?').join(',');
+            this.db.run(`DELETE FROM messages WHERE id IN (${placeholders})`, ids, (err) => {
+                if (err)
+                    return reject(err);
+                resolve();
+            });
+        });
+    }
+    async getPendingCount() {
+        return new Promise((resolve, reject) => {
+            this.db.get('SELECT COUNT(*) as count FROM messages', (err, row) => {
+                if (err)
+                    return reject(err);
+                resolve(row ? row.count : 0);
+            });
+        });
+    }
+    async close() {
+        if (this.db) {
+            return new Promise((resolve, reject) => {
+                this.db.close((err) => {
+                    if (err)
+                        return reject(err);
+                    resolve();
+                });
+            });
+        }
+    }
+}
+exports.SQLiteWalBuffer = SQLiteWalBuffer;

package/dist/wiki-synthesizer.d.ts

@@ -0,0 +1,80 @@
+import { KnowledgeGraph, KnowledgeItem } from './knowledge-graph';
+export interface WikiInput {
+    id: string;
+    content: string;
+}
+export type WikiSource = 'llm' | 'local-extractive';
+export interface TokenMeasure {
+    /** 측정 방식: 제공자 실 usage 또는 오프라인 근사. */
+    method: 'provider-usage' | 'offline-approx';
+    rawChars: number;
+    wikiChars: number;
+    rawApproxTokens: number;
+    wikiApproxTokens: number;
+    /** 제공자 실 입력 토큰(LLM 합성 호출). 오프라인이면 null. */
+    providerInputTokens: number | null;
+    /** 문자 기준 절감률(원본 주입 대비). */
+    charSavedRatio: number;
+    /** 토큰 기준 절감률(근사 또는 제공자 기준). */
+    tokenSavedRatio: number;
+}
+export interface WikiResult {
+    clusterId: string;
+    wiki: string;
+    source: WikiSource;
+    provider: string | null;
+    /** 원본 항목들의 콘텐츠 해시(캐시 무효화 키). */
+    sourceHash: string;
+    tokens: TokenMeasure;
+    /** 정확성 프록시: 원본 핵심 토큰 중 WIKI 에 보존된 비율∈[0,1]. (오라클 과제성공과는 별개.) */
+    fidelity: number;
+}
+export interface SynthesizeOptions {
+    /** 강제로 로컬 추출만 사용(테스트·오프라인). 기본 false(키 있으면 LLM). */
+    forceLocal?: boolean;
+    /** 로컬 추출 시 최대 라인 수(기본 24). */
+    maxLines?: number;
+    /** 로컬 추출 시 최대 문자 수(기본 1200). */
+    maxChars?: number;
+}
+export declare function approxTokenCount(text: string): number;
+export declare function contentHash(items: {
+    id: string;
+    content: string;
+}[]): string;
+/**
+ * 그래프에서 seed 노드의 1-hop 클러스터(참조·의존 이웃)를 모은다.
+ * similarity 엣지는 잡음이 많아 기본 제외(includeSimilarity 로 포함 가능).
+ */
+export declare function clusterAround(graph: KnowledgeGraph, items: KnowledgeItem[], seedId: string, opts?: {
+    includeSimilarity?: boolean;
+}): KnowledgeItem[];
+/**
+ * 클러스터를 WIKI 로 합성한다. 키 있으면 LLM(`llm.ts` 재사용), 없거나 forceLocal 이면 로컬 추출.
+ * 토큰 절감과 충실도를 실측해 함께 반환한다.
+ */
+export declare function synthesizeWiki(clusterId: string, cluster: WikiInput[], opts?: SynthesizeOptions): Promise<WikiResult>;
+/**
+ * WIKI 캐시 — 원본 콘텐츠 해시로 무효화. 원본이 바뀌면(해시 변경) stale 로 판정해 재합성을 유도한다.
+ */
+export declare class WikiCache {
+    private store;
+    private hits;
+    private misses;
+    /** 캐시 조회. 저장된 해시와 현재 sourceHash 가 일치할 때만 반환(아니면 stale → null). */
+    get(clusterId: string, sourceHash: string): WikiResult | null;
+    isStale(clusterId: string, sourceHash: string): boolean;
+    set(result: WikiResult): void;
+    stats(): {
+        size: number;
+        hits: number;
+        misses: number;
+    };
+}
+/**
+ * 캐시를 거친 합성: stale(원본 변경/미존재)일 때만 재합성하고, 아니면 캐시 재사용.
+ */
+export declare function synthesizeWikiCached(cache: WikiCache, clusterId: string, cluster: WikiInput[], opts?: SynthesizeOptions): Promise<{
+    result: WikiResult;
+    recomputed: boolean;
+}>;

package/dist/worker-agent.d.ts

@@ -0,0 +1,10 @@
+import { ISandbox } from './index';
+export declare class WorkerAgent {
+    private sandbox;
+    constructor(sandbox: ISandbox);
+    executeTask(command: string): Promise<{
+        stdout: string;
+        stderr: string;
+        success: boolean;
+    }>;
+}

package/dist/worker-agent.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerAgent = void 0;
+class WorkerAgent {
+    sandbox;
+    constructor(sandbox) {
+        this.sandbox = sandbox;
+    }
+    // Stateless execution without MCTS
+    async executeTask(command) {
+        const result = await this.sandbox.runCommand(command);
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            success: result.code === 0
+        };
+    }
+}
+exports.WorkerAgent = WorkerAgent;

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@n2world/orchestrator",
+  "version": "1.1.0",
+  "description": "N2World 오케스트레이터 — 예측 실행 에이전트, A2A, 가치 스케줄러, PWA 대시보드",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/suhopark1-tech/n2world.git",
+    "directory": "packages/orchestrator"
+  },
+  "homepage": "https://github.com/suhopark1-tech/n2world#readme",
+  "bugs": {
+    "url": "https://github.com/suhopark1-tech/n2world/issues"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "n2world": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').mkdirSync('dist/dashboard', {recursive:true}); ['index.html', 'chat.html', 'dental.html', 'manifest.json', 'service-worker.js', 'icon-192.png', 'freebie.png'].forEach(file => require('fs').copyFileSync('src/dashboard/' + file, 'dist/dashboard/' + file))\"",
+    "test": "jest",
+    "test:pglite": "node --experimental-vm-modules ../../node_modules/jest/bin/jest.js tests/phase_P1",
+    "bench:pglite": "node ../../benchmarks/pglite_p1.mjs && node ../../benchmarks/pglite_p1_5.mjs",
+    "bench:p2": "node ../../benchmarks/p2_relations.mjs",
+    "bench:p3": "node ../../benchmarks/p3_wiki.mjs",
+    "bench:p3.5": "node ../../benchmarks/p3_5_anneal.mjs",
+    "bench:p4": "node ../../benchmarks/p4_priors.mjs",
+    "bench:p4.7": "node ../../benchmarks/p4_7_commitgate.mjs",
+    "bench:p5": "node ../../benchmarks/p5_macaroon.mjs",
+    "bench:dod": "node ../../benchmarks/v2_dod.mjs",
+    "test:e2e-benchmark": "jest tests/phase6.test.ts -t \"E2E Coding Tasks\"",
+    "test:perf-benchmark": "jest tests/phase6.test.ts -t \"Performance Benchmarking\"",
+    "test:a2a-security": "jest tests/phase7.test.ts -t \"Macaroon A2A Secure Collaboration\"",
+    "test:overlay-compilation": "jest tests/phase7.test.ts -t \"OverlayFS Compilation Cache\"",
+    "test:ebpf-scheduler": "jest tests/phase7.test.ts -t \"eBPF cgroups v2 Scheduler Driver\"",
+    "test:advanced": "jest tests/advanced-features.test.ts"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^2.0.0",
+    "@ai-sdk/google": "^3.0.82",
+    "@electric-sql/pglite": "^0.5.3",
+    "@n2world/core": "*",
+    "ai": "^6.0.204",
+    "chalk": "^4.1.2",
+    "dotenv": "^17.4.2",
+    "sqlite3": "^6.0.1",
+    "string-width": "^4.2.3",
+    "wrap-ansi": "^7.0.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  }
+}