@n2world/orchestrator 1.1.0

package/dist/symbolic-dynamics.js

@@ -0,0 +1,420 @@
+"use strict";
+// ============================================================================
+// g_fast 신경 기호 역학 모델 — 표준 인터페이스 (G0: 정합·타입, 동작 불변)
+// ----------------------------------------------------------------------------
+// 근거: doc/arxiv/gfast_neurosymbolic_dynamics_ko.md (이론),
+//       doc/N2World_gfast_설계구현계획서_v1.0.md (G0~G5).
+// 하이브리드 상태 s_t=(z_t, m_t) 위에서 δ(결정성 게이트)·Φ(규칙 전이)·ρ(규칙 보상)를 정의한다.
+//
+// 정직 고지(제1계명): G0 은 *타입·어댑터·직렬화* 만 도입한다(동작 불변·회귀 0).
+//   - 실제 Φ(컴파일러 재평가)는 G1, δ/ρ 실장은 G2, MCTS 통합·ablation 은 G3.
+//   - 현재 잠재 z 는 미사용(순수 기호 경로). z 합류는 G4(브리지)에서만.
+// ============================================================================
+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.WarmTypeChecker = exports.ruleReward = exports.RHO_GAMMA = exports.RHO_BETA = exports.RHO_ALPHA = exports.isDecidable = void 0;
+exports.candidateToEditAction = candidateToEditAction;
+exports.fromSymbolicMetaTuple = fromSymbolicMetaTuple;
+exports.toSymbolicMetaTuple = toSymbolicMetaTuple;
+exports.serializeMeta = serializeMeta;
+exports.deserializeMeta = deserializeMeta;
+exports.errorCount = errorCount;
+exports.isCompilerDecidableFile = isCompilerDecidableFile;
+exports.recompileMeta = recompileMeta;
+exports.makePhi = makePhi;
+exports.recompileMetaWarm = recompileMetaWarm;
+exports.gfastEvaluate = gfastEvaluate;
+// ── 어댑터 ──────────────────────────────────────────────────────────────────
+/** 후보(Candidate) → 편집 행동(EditAction). 핫패스 불변, 역학 인터페이스용 변환. */
+function candidateToEditAction(c) {
+    return { id: c.id, kind: c.kind, file: c.file, content: c.content, command: c.command };
+}
+/** 코어 SymbolicMetaTuple(제로카피 슬롯 포맷) → MetaTuple. astErrorCode>0 ⇒ 오차 1건으로 표현. */
+function fromSymbolicMetaTuple(s) {
+    const astErrors = s.astErrorCode && s.astErrorCode !== 0
+        ? [{ line: 0, code: `AST${s.astErrorCode}`, msg: `ast error code ${s.astErrorCode}` }]
+        : [];
+    const depMap = {};
+    for (const [k, v] of Object.entries(s.projectDependencyMap ?? {}))
+        depMap[k] = [v];
+    return {
+        targetFile: s.targetFilePath,
+        astErrors,
+        depMap,
+        buildStatus: astErrors.length ? 'fail' : 'unknown',
+    };
+}
+/** MetaTuple → 코어 SymbolicMetaTuple(다운캐스트, 손실 가능 — 첫 오차 코드만 보존). */
+function toSymbolicMetaTuple(m) {
+    const first = m.astErrors[0];
+    const code = first ? parseInt(first.code.replace(/\D/g, ''), 10) || 1 : 0;
+    const projectDependencyMap = {};
+    for (const [k, v] of Object.entries(m.depMap ?? {}))
+        projectDependencyMap[k] = v[0] ?? '';
+    return { targetFilePath: m.targetFile, astErrorCode: code, projectDependencyMap };
+}
+/** MetaTuple 직렬화(JSON). 왕복 보존 검증용. */
+function serializeMeta(m) {
+    return JSON.stringify(m);
+}
+function deserializeMeta(s) {
+    const o = JSON.parse(s);
+    return {
+        targetFile: String(o.targetFile ?? ''),
+        astErrors: Array.isArray(o.astErrors) ? o.astErrors : [],
+        depMap: o.depMap,
+        buildStatus: o.buildStatus === 'pass' || o.buildStatus === 'fail' ? o.buildStatus : 'unknown',
+    };
+}
+/** 오차 개수 |E(m)| — ρ·δ 가 참조할 헬퍼. */
+function errorCount(m) {
+    return m.astErrors.length;
+}
+// ============================================================================
+// G1 — Φ 규칙 전이(실제 컴파일러 재평가). 편집을 VFS 복사본에 적용 → 컴파일러 진단으로
+//       m_{t+1} 을 결정론적으로 산정한다. 잠재 z 는 미변경(순수 기호 경로).
+//   정직: 여기서 "비싼 2단계"는 *테스트 오라클* 이고, Φ 는 *컴파일러*(node --check/tsc)만
+//         돌린다 — 컴파일은 테스트보다 값싸므로, ρ(G2)로 후보를 사전 정렬해 오라클 호출을 줄인다.
+//         단, 의미적 정답성(테스트)은 컴파일로 결정 불가 → 그런 후보는 δ=0(오라클 위임, G2).
+// ============================================================================
+const child_process_1 = require("child_process");
+const _fs = __importStar(require("fs/promises"));
+const _os = __importStar(require("os"));
+const _path = __importStar(require("path"));
+function _sh(cmd, cwd, timeout = 15000) {
+    return new Promise((resolve) => {
+        (0, child_process_1.exec)(cmd, { cwd, timeout }, (err, stdout, stderr) => resolve({ code: err ? (err.code ?? 1) : 0, stdout: (stdout || '').toString(), stderr: (stderr || '').toString() }));
+    });
+}
+/** 파일 확장자로 컴파일러 진단 지원 여부. JS=node --check(구문), TS=tsc(구문+타입). */
+function isCompilerDecidableFile(file) {
+    return /\.(c?js|mjs)$/.test(file) || isTsFile(file);
+}
+function isTsFile(file) {
+    return /\.(m|c)?ts$/.test(file) && !/\.d\.ts$/.test(file);
+}
+/** tsc 실행 바이너리 경로(설치된 typescript). 미해결 시 null → TS 결정 불가(unknown). */
+function _tscBin() {
+    try {
+        return require.resolve('typescript/bin/tsc');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 컴파일러 재평가로 단일 파일의 MetaTuple 산정(결정론적).
+ * JS: `node --check`(구문). TS: `tsc --noEmit`(구문+**타입**) — node --check 가 못 잡는 타입 오류 포착.
+ */
+async function recompileMeta(dir, relFile) {
+    const abs = _path.join(dir, relFile);
+    const absU = abs.replace(/\\/g, '/');
+    if (isTsFile(relFile)) {
+        const tsc = _tscBin();
+        if (!tsc)
+            return { targetFile: relFile, astErrors: [], buildStatus: 'unknown' }; // tsc 없음 → 결정 불가
+        const r = await _sh(`node "${tsc.replace(/\\/g, '/')}" --noEmit --skipLibCheck --strict "${absU}"`, dir, 30000);
+        if (r.code === 0)
+            return { targetFile: relFile, astErrors: [], buildStatus: 'pass' };
+        // tsc 진단: "file.ts(line,col): error TSxxxx: msg"
+        const out = r.stdout + r.stderr;
+        const errs = [];
+        const re = /\((\d+),\d+\):\s*error\s+(TS\d+):\s*([^\n]*)/g;
+        let m;
+        while ((m = re.exec(out)) !== null) {
+            errs.push({ line: parseInt(m[1], 10), code: m[2], msg: m[3].trim().slice(0, 200) });
+        }
+        if (errs.length === 0)
+            errs.push({ line: 0, code: 'TS-ERR', msg: 'tsc error' });
+        return { targetFile: relFile, astErrors: errs, buildStatus: 'fail' };
+    }
+    if (!isCompilerDecidableFile(relFile)) {
+        // 컴파일러 결정 불가 → 진단 미상(δ=0 입력). buildStatus unknown.
+        return { targetFile: relFile, astErrors: [], buildStatus: 'unknown' };
+    }
+    const r = await _sh(`node --check "${absU}"`, dir);
+    if (r.code === 0)
+        return { targetFile: relFile, astErrors: [], buildStatus: 'pass' };
+    // node 구문 오류: stderr 에 "path:line" + "SyntaxError: msg" 형태.
+    const out = r.stderr || r.stdout;
+    const lineM = out.match(/:(\d+)\n/) || out.match(/:(\d+)$/m);
+    const msgM = out.match(/(SyntaxError:[^\n]*)/) || out.match(/(Error:[^\n]*)/);
+    const err = {
+        line: lineM ? parseInt(lineM[1], 10) : 0,
+        code: 'JS-SYNTAX',
+        msg: (msgM ? msgM[1] : 'syntax error').trim().slice(0, 200),
+    };
+    return { targetFile: relFile, astErrors: [err], buildStatus: 'fail' };
+}
+/** 편집을 임시 복사본에 적용(워크스페이스 보존). 복사본 경로 반환(호출자가 정리). */
+async function _applyEditToCopy(workspaceDir, a) {
+    const scratch = await _fs.mkdtemp(_path.join(_os.tmpdir(), 'n2w-phi-'));
+    await _fs.cp(workspaceDir, scratch, { recursive: true });
+    if (a.kind === 'edit' && a.file) {
+        const fp = _path.join(scratch, a.file);
+        await _fs.mkdir(_path.dirname(fp), { recursive: true });
+        await _fs.writeFile(fp, a.content ?? '', 'utf8');
+    }
+    return scratch;
+}
+/**
+ * Φ 팩토리: 워크스페이스 기준 규칙 전이. 편집 a 를 복사본에 적용 → 컴파일러 재평가 →
+ * 새 MetaTuple(m_{t+1}). 결정론적·건전(컴파일러 의미론과 일치, 환각 없음 — [논문] 정리 1).
+ */
+function makePhi(workspaceDir) {
+    return async (m, a) => {
+        const file = (a.kind === 'edit' && a.file) ? a.file : m.targetFile;
+        const scratch = await _applyEditToCopy(workspaceDir, a);
+        try {
+            const next = await recompileMeta(scratch, file);
+            return { ...next, depMap: m.depMap };
+        }
+        finally {
+            await _fs.rm(scratch, { recursive: true, force: true });
+        }
+    };
+}
+// ============================================================================
+// G2 — δ 결정성 게이트 + ρ 규칙 보상.
+//   δ: 편집의 효과가 컴파일러로 결정 가능한가(deny-by-default). 결정 가능 ⇒ Φ/ρ 기호 경로.
+//   ρ: AST 오차 델타 보상(얕은 신호). 오라클 앵커 아님(최종 v 는 테스트 오라클).
+//   정직: 컴파일은 구문/타입을 결정하나 *의미적 테스트 통과* 는 결정 못 한다. 따라서 ρ 는
+//         후보를 *사전 정렬* 해 비싼 테스트 오라클 호출을 줄이는 용도다(정답 판정 아님).
+// ============================================================================
+/** δ — 편집의 컴파일러 결정 가능성. JS 편집만 결정 가능(현재), 그 외(명령·비JS)=0. */
+const isDecidable = (m, a) => {
+    if (a.kind !== 'edit')
+        return false; // 명령은 컴파일러로 결정 불가
+    const file = a.file ?? m.targetFile;
+    return isCompilerDecidableFile(file);
+};
+exports.isDecidable = isDecidable;
+/** ρ 계수(보상 형상). 빌드 통과 보너스 γ 가 지배적이도록. */
+exports.RHO_ALPHA = 0.1; // 오차 감소 1건당
+exports.RHO_BETA = 0.2; // 새 오차 1건당(페널티)
+exports.RHO_GAMMA = 1.0; // 빌드 통과 보너스
+/** 두 메타의 "새 오차"(line+code 기준 mNext 에만 있는 것). */
+function _newErrors(m, mNext) {
+    const key = (e) => `${e.line}:${e.code}`;
+    const prev = new Set(m.astErrors.map(key));
+    return mNext.astErrors.filter((e) => !prev.has(key(e))).length;
+}
+/** ρ = αΔ|E| − β|new| + γ·[build pass]. 얕은 사전 정렬 신호([논문] §3.5). */
+const ruleReward = (m, mNext) => {
+    const dErr = m.astErrors.length - mNext.astErrors.length;
+    const neu = _newErrors(m, mNext);
+    const pass = mNext.buildStatus === 'pass' ? 1 : 0;
+    return exports.RHO_ALPHA * dErr - exports.RHO_BETA * neu + exports.RHO_GAMMA * pass;
+};
+exports.ruleReward = ruleReward;
+// ============================================================================
+// G3c — 웜(증분) 타입체크 서비스. 콜드 `tsc` 를 매 후보 spawn 하는 대신, in-process
+//   TypeScript Language Service 로 단일 파일 진단을 *증분* 으로 얻는다(프로세스 spawn·콜드
+//   시작 제거). 첫 호출만 프로그램 빌드(웜업), 이후 호출은 값싸다.
+//   정직: 단일 파일 격리 체크(라이브러리 + 디스크 폴백). 교차파일 타입 의존이 큰 경우엔
+//         프로젝트 시드가 필요하다(현재 단일 파일 범위).
+// ============================================================================
+const _ts = __importStar(require("typescript"));
+class WarmTypeChecker {
+    files = new Map();
+    service;
+    options;
+    constructor(opts) {
+        this.options = {
+            strict: true, noEmit: true, skipLibCheck: true,
+            target: _ts.ScriptTarget.ES2020, module: _ts.ModuleKind.CommonJS,
+            moduleResolution: _ts.ModuleResolutionKind.NodeJs, allowJs: true, ...opts,
+        };
+        const host = {
+            getScriptFileNames: () => [...this.files.keys()],
+            getScriptVersion: (f) => String(this.files.get(f)?.version ?? 0),
+            getScriptSnapshot: (f) => {
+                const e = this.files.get(f);
+                if (e)
+                    return _ts.ScriptSnapshot.fromString(e.content);
+                if (!_ts.sys.fileExists(f))
+                    return undefined;
+                const c = _ts.sys.readFile(f);
+                return c != null ? _ts.ScriptSnapshot.fromString(c) : undefined;
+            },
+            getCurrentDirectory: () => process.cwd(),
+            getCompilationSettings: () => this.options,
+            getDefaultLibFileName: (o) => _ts.getDefaultLibFilePath(o),
+            fileExists: (f) => this.files.has(f) || _ts.sys.fileExists(f),
+            readFile: (f) => this.files.get(f)?.content ?? _ts.sys.readFile(f),
+            readDirectory: _ts.sys.readDirectory,
+            directoryExists: _ts.sys.directoryExists,
+            getDirectories: _ts.sys.getDirectories,
+        };
+        this.service = _ts.createLanguageService(host, _ts.createDocumentRegistry());
+    }
+    /** TS 내부는 포워드슬래시 경로를 쓰므로 키를 정규화(Windows 백슬래시 불일치 방지). */
+    static norm(p) { return p.replace(/\\/g, '/'); }
+    /** 파일 내용 설정(버전 증가 → 증분 재검사). */
+    setFile(fileName, content) {
+        const key = WarmTypeChecker.norm(fileName);
+        const prev = this.files.get(key);
+        this.files.set(key, { content, version: (prev?.version ?? 0) + 1 });
+    }
+    /** 한 파일의 구문+의미 진단(증분). */
+    diagnosticsFor(key) {
+        const diags = [
+            ...this.service.getSyntacticDiagnostics(key),
+            ...this.service.getSemanticDiagnostics(key),
+        ];
+        return diags.map((d) => {
+            const line = d.file && typeof d.start === 'number'
+                ? d.file.getLineAndCharacterOfPosition(d.start).line + 1 : 0;
+            return { line, code: `TS${d.code}`, msg: _ts.flattenDiagnosticMessageText(d.messageText, '\n').slice(0, 200) };
+        });
+    }
+    /** 단일 파일의 구문+의미 진단(증분, in-process). spawn 없음. */
+    check(fileName, content) {
+        const key = WarmTypeChecker.norm(fileName);
+        this.setFile(key, content);
+        return this.diagnosticsFor(key);
+    }
+    // ── G3d: 프로젝트 시드(교차파일) ──────────────────────────────────────────
+    /** 워크스페이스의 .ts/.tsx 를 전부 시드(node_modules·.git 제외). 프로그램이 프로젝트 전체. */
+    async seedDir(dir) {
+        const walk = async (d) => {
+            let ents;
+            try {
+                ents = await _fs.readdir(d, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const ent of ents) {
+                if (ent.name === 'node_modules' || ent.name === '.git' || ent.name === 'dist')
+                    continue;
+                const p = _path.join(d, ent.name);
+                if (ent.isDirectory())
+                    await walk(p);
+                else if (/\.(m|c)?tsx?$/.test(ent.name) && !/\.d\.ts$/.test(ent.name)) {
+                    this.setFile(p, await _fs.readFile(p, 'utf8'));
+                }
+            }
+        };
+        await walk(dir);
+        return this.files.size;
+    }
+    /** 디렉토리를 *최초 1회만* 시드(재사용 checker의 워밍업 amortize). 이미 시드된 dir 은 skip. */
+    seededDirs = new Set();
+    async seedDirOnce(dir) {
+        const key = WarmTypeChecker.norm(dir);
+        if (this.seededDirs.has(key))
+            return this.files.size; // 이미 시드 → 재빌드 방지
+        this.seededDirs.add(key);
+        return this.seedDir(dir);
+    }
+    /** 주어진 파일 집합의 (file:line:code)→AstError 진단 맵. */
+    diagnosticsOver(keys) {
+        const m = new Map();
+        for (const fileName of keys) {
+            for (const e of this.diagnosticsFor(fileName))
+                m.set(`${fileName}:${e.line}:${e.code}`, e);
+        }
+        return m;
+    }
+    /** 시드된 전 파일 진단(프로젝트 전체) — 폴백·전수 검사용. */
+    allProjectErrors() {
+        return this.diagnosticsOver(this.files.keys());
+    }
+    /**
+     * G3e 최적화 — 편집 파일이 *영향을 줄 수 있는* 파일 집합: {편집파일} ∪ 그 파일을 (전이적으로)
+     *  import 하는 의존자. 편집은 다른 파일의 내용을 바꾸지 않으므로 새 오차는 이 집합에만 생긴다(건전).
+     *  `getFileReferences`(역참조)로 BFS. 미지원/실패 시 전 파일로 폴백(건전성 우선).
+     */
+    affectedFiles(editedAbsFile) {
+        const start = WarmTypeChecker.norm(editedAbsFile);
+        const visited = new Set([start]);
+        const queue = [start];
+        try {
+            while (queue.length) {
+                const f = queue.shift();
+                const refs = this.service.getFileReferences(f); // 이 파일을 참조(import)하는 위치들
+                for (const r of refs) {
+                    const fn = WarmTypeChecker.norm(r.fileName);
+                    if (this.files.has(fn) && !visited.has(fn)) {
+                        visited.add(fn);
+                        queue.push(fn);
+                    }
+                }
+            }
+        }
+        catch {
+            return [...this.files.keys()]; // 폴백: 전 파일(건전성 유지)
+        }
+        return [...visited];
+    }
+    /**
+     * 편집이 *프로젝트에 새로 도입하는* 오차(교차파일 포함). **영향 파일 집합만** 전후 진단 비교
+     *  (전수 대신 {편집파일}∪의존자) → 후보당 비용 절감. 체커 상태는 호출 후 원복.
+     * @param affected 사전 계산된 영향 집합(동일 파일을 여러 후보가 편집할 때 캐시 재사용). 미지정 시 자동.
+     */
+    addedErrorsForEdit(editedAbsFile, content, affected) {
+        const key = WarmTypeChecker.norm(editedAbsFile);
+        const scope = affected ?? this.affectedFiles(key);
+        const before = this.diagnosticsOver(scope);
+        const old = this.files.get(key)?.content;
+        this.setFile(key, content);
+        const after = this.diagnosticsOver(scope);
+        if (old !== undefined)
+            this.setFile(key, old); // 원복(증분 캐시 유지)
+        const added = [];
+        for (const [k, e] of after)
+            if (!before.has(k))
+                added.push(e);
+        return added;
+    }
+}
+exports.WarmTypeChecker = WarmTypeChecker;
+/** 웜 체커로 MetaTuple 산정(콜드 tsc spawn 대신 in-process 증분). */
+function recompileMetaWarm(checker, fileName, content) {
+    const errs = checker.check(fileName, content);
+    return { targetFile: fileName, astErrors: errs, buildStatus: errs.length === 0 ? 'pass' : 'fail' };
+}
+/**
+ * 한 후보에 대한 g_fast 기호 경로 평가: δ → (Φ → ρ). 결정 불가면 {decidable:false}(오라클 위임).
+ * 비싼 테스트 오라클 대신 *컴파일러* 만 돌린다.
+ */
+async function gfastEvaluate(workspaceDir, m0, a) {
+    if (!(0, exports.isDecidable)(m0, a))
+        return { decidable: false };
+    const phi = makePhi(workspaceDir);
+    const mNext = await phi(m0, a);
+    return { decidable: true, mNext, rho: (0, exports.ruleReward)(m0, mNext) };
+}

package/dist/telemetry.d.ts

@@ -0,0 +1,19 @@
+export interface Telemetry {
+    cpuPercent: number;
+    memUsedMB: number;
+    memPercent: number;
+    heapUsedMB: number;
+    uptimeSec: number;
+    loadAvg1: number;
+    activeTasks: number;
+}
+export declare class TelemetrySource {
+    private lastCpu;
+    private lastTime;
+    private active;
+    taskStarted(): void;
+    taskEnded(): void;
+    setActive(n: number): void;
+    /** 직전 샘플 이후의 실제 CPU·메모리 사용을 측정해 반환한다. */
+    sample(): Telemetry;
+}

package/dist/telemetry.js

@@ -0,0 +1,68 @@
+"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.TelemetrySource = void 0;
+const os = __importStar(require("os"));
+class TelemetrySource {
+    lastCpu = process.cpuUsage();
+    lastTime = Date.now();
+    active = 0;
+    taskStarted() { this.active++; }
+    taskEnded() { this.active = Math.max(0, this.active - 1); }
+    setActive(n) { this.active = Math.max(0, n); }
+    /** 직전 샘플 이후의 실제 CPU·메모리 사용을 측정해 반환한다. */
+    sample() {
+        const now = Date.now();
+        const cpu = process.cpuUsage(this.lastCpu); // delta(마이크로초)
+        const elapsedMs = Math.max(1, now - this.lastTime);
+        // CPU 마이크로초 → 밀리초, 벽시계 경과 대비 비율 = 사용률(%). 멀티코어면 100% 초과 가능 → 코어수로 클램프.
+        const cores = Math.max(1, os.cpus().length);
+        const cpuPercent = ((cpu.user + cpu.system) / 1000) / elapsedMs * 100 / cores;
+        this.lastCpu = process.cpuUsage();
+        this.lastTime = now;
+        const mem = process.memoryUsage();
+        const totalMem = os.totalmem();
+        return {
+            cpuPercent: +Math.min(100, Math.max(0, cpuPercent)).toFixed(1),
+            memUsedMB: +(mem.rss / 1048576).toFixed(1),
+            memPercent: +((mem.rss / totalMem) * 100).toFixed(2),
+            heapUsedMB: +(mem.heapUsed / 1048576).toFixed(1),
+            uptimeSec: Math.round(process.uptime()),
+            loadAvg1: +(os.loadavg()[0] || 0).toFixed(2),
+            activeTasks: this.active,
+        };
+    }
+}
+exports.TelemetrySource = TelemetrySource;

package/dist/text-embedding.d.ts

@@ -0,0 +1,6 @@
+/** 해시 bag-of-tokens 임베딩(차원 dim, L2 정규화). 한글/영문/숫자 토큰 지원. */
+export declare function textEmbedding(text: string, dim?: number): number[];
+/** 코사인 유사도∈[-1,1]. 정규화 벡터면 내적과 동일. */
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+/** 텍스트–컨텍스트 관련성∈[0,1]: 임베딩 코사인 유사도(음수는 0으로 클램프). */
+export declare function embeddingRelevance(text: string, context: string): number;

package/dist/text-embedding.js

@@ -0,0 +1,42 @@
+"use strict";
+// ============================================================================
+// 텍스트 임베딩 기반 관련성(가치 랭킹 g_fast 신호 고도화)
+// ----------------------------------------------------------------------------
+// 정직 고지: 이것은 **해시 기반 bag-of-tokens 임베딩**이다 — 실제 의미(LLM) 임베딩이 아니다.
+// 단순 토큰-집합 겹침보다 빈도·정규화를 반영해 관련성을 graded(연속)로 준다는 점이 개선이다.
+// (SkillManager 의 mock 임베딩과 동일 계열. 실 의미 임베딩은 후속 과제.)
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textEmbedding = textEmbedding;
+exports.cosineSimilarity = cosineSimilarity;
+exports.embeddingRelevance = embeddingRelevance;
+/** 해시 bag-of-tokens 임베딩(차원 dim, L2 정규화). 한글/영문/숫자 토큰 지원. */
+function textEmbedding(text, dim = 128) {
+    const v = new Array(dim).fill(0);
+    const tokens = (text || '').toLowerCase().split(/[^a-z0-9가-힣]+/).filter((t) => t.length > 0);
+    for (const tok of tokens) {
+        let h = 0;
+        for (let i = 0; i < tok.length; i++)
+            h = (h * 31 + tok.charCodeAt(i)) % dim;
+        v[h] += 1;
+    }
+    const mag = Math.sqrt(v.reduce((a, x) => a + x * x, 0));
+    return mag === 0 ? v : v.map((x) => x / mag);
+}
+/** 코사인 유사도∈[-1,1]. 정규화 벡터면 내적과 동일. */
+function cosineSimilarity(a, b) {
+    const n = Math.min(a.length, b.length);
+    let dot = 0, na = 0, nb = 0;
+    for (let i = 0; i < n; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    if (na === 0 || nb === 0)
+        return 0;
+    return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+/** 텍스트–컨텍스트 관련성∈[0,1]: 임베딩 코사인 유사도(음수는 0으로 클램프). */
+function embeddingRelevance(text, context) {
+    return Math.max(0, cosineSimilarity(textEmbedding(text), textEmbedding(context)));
+}

package/dist/tier-classifier.d.ts

@@ -0,0 +1,20 @@
+export type Tier = 0 | 1 | 2;
+export interface ClassifyInput {
+    /** 분류 대상 텍스트(메시지 본문 등). */
+    text: string;
+    /** 데이터 종류 힌트(있으면 우선 적용). */
+    kind?: 'sensor' | 'voice' | 'credential' | 'task' | 'public' | 'unknown';
+    /** 명시적으로 공개 무해임이 보증된 경우만 true(예: 공개 문서 검색결과). */
+    publicAttested?: boolean;
+}
+export interface TierDecision {
+    tier: Tier;
+    /** 발동한 규칙 id(감사용). */
+    ruleId: string;
+    /** 사람이 읽는 사유. */
+    reason: string;
+}
+/**
+ * 규칙기반 Tier 분류. 미분류·불확실은 Tier-0(default-deny).
+ */
+export declare function classifyTier(input: ClassifyInput): TierDecision;

package/dist/tier-classifier.js

@@ -0,0 +1,58 @@
+"use strict";
+// ============================================================================
+// v2.5.2 Phase S — Tier 분류기 (규칙기반·기본거부)
+// ----------------------------------------------------------------------------
+// 계획서 v2.5.2 §5: 데이터가 어떤 Tier를 *부여*받는지 결정. 분류가 틀리면 §4 경계는
+// 종이다. 핵심 원칙:
+//   1) 규칙기반(결정론적). LLM 자동분류는 보조일 뿐 신뢰 근거 아님(순환 금지).
+//   2) 기본거부(default-deny): 미분류·불확실 = Tier-0(가장 보수적·로컬전용).
+// Tier-0: 센서/음성 원본·PII·비밀·자격증명·미분류 → 로컬 모델만, 외부 송신 금지
+// Tier-1: 일반 작업 컨텍스트(비민감) → 로컬 우선, 외부는 동의+로깅 시에만
+// Tier-2: 공개·무해 → 폭넓은 제공사 허용
+//
+// 정직 고지(제1계명): 본 분류기는 *명시적 규칙*만 신뢰한다. 애매하면 Tier-0로 강등한다.
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyTier = classifyTier;
+// PII/비밀 탐지 규칙(보수적·명시적). 매칭되면 Tier-0.
+const SECRET_PATTERNS = [
+    ['PII-EMAIL', /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/],
+    ['PII-PHONE', /\b01[016789][-\s]?\d{3,4}[-\s]?\d{4}\b/],
+    ['PII-RRN', /\b\d{6}[-\s]?\d{7}\b/], // 주민등록번호 형태
+    ['PII-CARD', /\b(?:\d[ -]?){13,16}\b/],
+    ['SECRET-KEY', /\b(sk-[A-Za-z0-9]{8,}|xox[baprs]-[A-Za-z0-9-]{8,}|AKIA[0-9A-Z]{12,}|ghp_[A-Za-z0-9]{20,})\b/],
+    ['SECRET-WORD', /\b(api[_\s-]?key|secret|password|passwd|token|credential|private[_\s-]?key)\b/i],
+];
+/**
+ * 규칙기반 Tier 분류. 미분류·불확실은 Tier-0(default-deny).
+ */
+function classifyTier(input) {
+    const text = input.text ?? '';
+    // 1) 종류 힌트 우선 — 민감 종류는 무조건 Tier-0
+    switch (input.kind) {
+        case 'sensor':
+            return { tier: 0, ruleId: 'KIND-SENSOR', reason: '물리 센서 원본(위치/카메라) → Tier-0' };
+        case 'voice':
+            return { tier: 0, ruleId: 'KIND-VOICE', reason: '음성 원본 → Tier-0' };
+        case 'credential':
+            return { tier: 0, ruleId: 'KIND-CREDENTIAL', reason: '자격증명 → Tier-0' };
+        default:
+            break;
+    }
+    // 2) 본문에 PII/비밀 패턴이 있으면 Tier-0
+    for (const [id, re] of SECRET_PATTERNS) {
+        if (re.test(text)) {
+            return { tier: 0, ruleId: id, reason: `민감정보 패턴(${id}) 탐지 → Tier-0` };
+        }
+    }
+    // 3) 명시적으로 공개 무해임이 보증된 경우만 Tier-2
+    if (input.publicAttested === true && input.kind === 'public') {
+        return { tier: 2, ruleId: 'PUBLIC-ATTESTED', reason: '공개 무해 보증 → Tier-2' };
+    }
+    // 4) 일반 작업 텍스트로 명시된 경우만 Tier-1
+    if (input.kind === 'task') {
+        return { tier: 1, ruleId: 'KIND-TASK', reason: '일반 작업 컨텍스트(비민감) → Tier-1' };
+    }
+    // 5) 그 외(미분류·불확실) = 기본거부 → Tier-0
+    return { tier: 0, ruleId: 'DEFAULT-DENY', reason: '미분류·불확실 → 기본거부(Tier-0)' };
+}