@n2world/orchestrator 1.1.0

package/dist/sensor-bridge.js

@@ -0,0 +1,133 @@
+"use strict";
+// ============================================================================
+// v2.5.2 Phase 5 — 센서 브리지 거버넌스 (Tier-0 강제·동의·보존·삭제·소멸감사)
+// ----------------------------------------------------------------------------
+// 계획서 v2.5.2 §3.2/§5/§C: 물리 센서(위치·카메라)·음성 원본은 *민감(Tier-0)* 이다.
+//   - 동의 없이는 수집 불가(상황별 재동의)
+//   - 전부 Tier-0 → 외부 송신 금지(로컬 전용)
+//   - 보존기간 상한 + 삭제(잊혀질 권리) + 소멸 감사(시각/해시)
+//
+// 정직 고지(제1계명): 본 모듈은 *데이터 거버넌스* 계층이며 테스트로 검증된다. 실제
+// 카메라/GPS/마이크 캡처는 네이티브(미검증) — 캡처된 샘플이 이 게이트를 통과해야만
+// 적재되고, 외부로는 결코 나가지 않는다. "소멸"은 감사 로그로 증명한다(연기 금지).
+// ============================================================================
+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.SensorBridge = void 0;
+const crypto = __importStar(require("crypto"));
+const tier_classifier_1 = require("./tier-classifier");
+/**
+ * 센서 샘플의 적재·보존·삭제를 통제한다. 모든 센서 데이터는 Tier-0(로컬 전용).
+ */
+class SensorBridge {
+    samples = [];
+    consent = new Set(); // `${sessionId}:${kind}`
+    audit = [];
+    retentionMs;
+    constructor(opts = {}) {
+        this.retentionMs = opts.retentionMs ?? 10 * 60 * 1000;
+    }
+    ck(sessionId, kind) { return `${sessionId}:${kind}`; }
+    hash(s) { return crypto.createHash('sha256').update(s).digest('hex').slice(0, 16); }
+    /** 상황별 동의 부여(센서 종류·세션별). 동의 없이는 적재 거부. */
+    grantConsent(sessionId, kind) {
+        this.consent.add(this.ck(sessionId, kind));
+        this.audit.push({ t: Date.now(), type: 'consent', kind, sessionId });
+    }
+    revokeConsent(sessionId, kind) {
+        this.consent.delete(this.ck(sessionId, kind));
+    }
+    hasConsent(sessionId, kind) {
+        return this.consent.has(this.ck(sessionId, kind));
+    }
+    /**
+     * 센서 샘플 적재 — 동의가 있어야만 통과. 모든 센서 데이터는 Tier-0 로 분류·확인된다.
+     * 반환: 적재 성공 여부.
+     */
+    ingest(sample) {
+        if (!this.hasConsent(sample.sessionId, sample.kind)) {
+            this.audit.push({ t: Date.now(), type: 'ingest-denied', kind: sample.kind, sessionId: sample.sessionId, detail: '동의 없음' });
+            return { ok: false, reason: '동의 없음 — 적재 거부' };
+        }
+        // 불변식 확인: 센서 데이터는 반드시 Tier-0(외부 금지).
+        const tier = (0, tier_classifier_1.classifyTier)({ text: sample.data, kind: sample.kind === 'voice' ? 'voice' : 'sensor' }).tier;
+        if (tier !== 0) {
+            // 방어적: 센서가 Tier-0 이 아니면 코드 결함 → 적재 거부(외부 유출 위험 차단).
+            this.audit.push({ t: Date.now(), type: 'ingest-denied', kind: sample.kind, sessionId: sample.sessionId, detail: `비-Tier0(${tier}) 거부` });
+            return { ok: false, reason: '센서는 Tier-0 이어야 함' };
+        }
+        this.samples.push(sample);
+        this.audit.push({ t: Date.now(), type: 'ingest', kind: sample.kind, sessionId: sample.sessionId, hash: this.hash(sample.data) });
+        return { ok: true, reason: 'ok' };
+    }
+    /** 외부 송신 가능 여부 — 센서 데이터는 *항상* 불가. 시도는 감사된다. */
+    assertNoEgress(sessionId, kind) {
+        this.audit.push({ t: Date.now(), type: 'egress-blocked', kind, sessionId, detail: 'Tier-0 센서 외부 송신 차단' });
+        return false; // 절대 외부 송신 불가
+    }
+    /** 보존기간 초과 샘플 소멸(감사 기록 — 소멸 증명). */
+    expire(now = Date.now()) {
+        const before = this.samples.length;
+        const kept = [];
+        for (const s of this.samples) {
+            if (now - s.ts > this.retentionMs) {
+                this.audit.push({ t: now, type: 'expire', kind: s.kind, sessionId: s.sessionId, hash: this.hash(s.data) });
+            }
+            else
+                kept.push(s);
+        }
+        this.samples = kept;
+        return before - kept.length;
+    }
+    /** 잊혀질 권리 — 세션(또는 종류)별 즉시 삭제 + 소멸 감사. */
+    deleteFor(sessionId, kind) {
+        const before = this.samples.length;
+        const kept = [];
+        for (const s of this.samples) {
+            const match = s.sessionId === sessionId && (!kind || s.kind === kind);
+            if (match)
+                this.audit.push({ t: Date.now(), type: 'delete', kind: s.kind, sessionId, hash: this.hash(s.data) });
+            else
+                kept.push(s);
+        }
+        this.samples = kept;
+        this.consent.forEach((c) => { if (c.startsWith(`${sessionId}:`) && (!kind || c.endsWith(`:${kind}`)))
+            this.consent.delete(c); });
+        return before - kept.length;
+    }
+    count() { return this.samples.length; }
+    auditLog() { return [...this.audit]; }
+}
+exports.SensorBridge = SensorBridge;

package/dist/session-repair.d.ts

@@ -0,0 +1,27 @@
+export declare class FencingLock {
+    private token;
+    private holder;
+    /** 락 획득 → 새 펜싱 토큰 발급(이전 보유자는 stale 처리됨). */
+    acquire(): number;
+    /** 워치독 강제 해제 — 다음 acquire가 더 큰 토큰을 받게 한다. */
+    forceRelease(): void;
+    /** 쓰기 시도 검증: 보유 토큰이 현재 최신이 아니면 거부(stale writer 차단). */
+    validateWrite(myToken: number): {
+        ok: boolean;
+        reason: string;
+    };
+}
+export interface RepairResult<T = any> {
+    recovered: T[];
+    /** 복원 불가로 *폐기*한 라인 수(날조하지 않음). */
+    droppedLines: number;
+    /** 폐기 라인 번호(감사용). */
+    droppedAt: number[];
+    total: number;
+}
+/**
+ * 손상 JSONL 텍스트를 정직 복구한다. 파싱 가능한 유효 라인만 복구하고,
+ * 파싱 불가/스키마 불일치 라인은 **버리고 카운트**한다(추정 복원 금지).
+ * @param isValid 복구 라인의 스키마 검증(선택). 통과 못하면 폐기.
+ */
+export declare function repairJsonl<T = any>(raw: string, isValid?: (o: any) => boolean): RepairResult<T>;

package/dist/session-repair.js

@@ -0,0 +1,66 @@
+"use strict";
+// ============================================================================
+// v2.5.2 Phase 3 — ResilientSessionRepair (펜싱 토큰 + 정직 JSONL 복구)
+// ----------------------------------------------------------------------------
+// 계획서 v2.5.2 §3.5:
+//   (a) Stuck 워치독 강제 락 해제 시 *단조 증가 펜싱 토큰*으로 stale writer 차단
+//       → 락 해제가 데이터 손상으로 이어지지 않게 한다.
+//   (b) 손상 JSONL은 *복원 가능 라인만* 복구하고, 복원 불가 라인은 **날조 없이 폐기·표기**.
+//       "추정 복원" 절대 금지(제1계명).
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FencingLock = void 0;
+exports.repairJsonl = repairJsonl;
+// ── (a) 펜싱 토큰 락 ───────────────────────────────────────────────────────
+class FencingLock {
+    token = 0; // 단조 증가 펜싱 토큰
+    holder = null;
+    /** 락 획득 → 새 펜싱 토큰 발급(이전 보유자는 stale 처리됨). */
+    acquire() {
+        this.token += 1;
+        this.holder = this.token;
+        return this.token;
+    }
+    /** 워치독 강제 해제 — 다음 acquire가 더 큰 토큰을 받게 한다. */
+    forceRelease() { this.holder = null; }
+    /** 쓰기 시도 검증: 보유 토큰이 현재 최신이 아니면 거부(stale writer 차단). */
+    validateWrite(myToken) {
+        if (myToken !== this.token) {
+            return { ok: false, reason: `stale writer 거부(my=${myToken}, current=${this.token})` };
+        }
+        if (this.holder !== myToken) {
+            return { ok: false, reason: '락 미보유' };
+        }
+        return { ok: true, reason: 'ok' };
+    }
+}
+exports.FencingLock = FencingLock;
+/**
+ * 손상 JSONL 텍스트를 정직 복구한다. 파싱 가능한 유효 라인만 복구하고,
+ * 파싱 불가/스키마 불일치 라인은 **버리고 카운트**한다(추정 복원 금지).
+ * @param isValid 복구 라인의 스키마 검증(선택). 통과 못하면 폐기.
+ */
+function repairJsonl(raw, isValid) {
+    const lines = raw.split('\n');
+    const recovered = [];
+    const droppedAt = [];
+    let total = 0;
+    lines.forEach((line, idx) => {
+        const s = line.trim();
+        if (!s)
+            return; // 빈 줄은 라인 수에 미포함
+        total += 1;
+        try {
+            const o = JSON.parse(s);
+            if (isValid && !isValid(o)) {
+                droppedAt.push(idx + 1);
+                return;
+            }
+            recovered.push(o);
+        }
+        catch {
+            droppedAt.push(idx + 1); // 파싱 불가 → 폐기(날조 복원 안 함)
+        }
+    });
+    return { recovered, droppedLines: droppedAt.length, droppedAt, total };
+}

package/dist/slack-finance-intake.d.ts

@@ -0,0 +1,42 @@
+import { SlackChannel, SendResult } from './channels';
+import { A2AContext } from './agent-os-rd';
+import { FinanceWorkflowEngine, FinanceRequest, WorkflowDecision } from './finance-workflow';
+/** 실 Slack 이벤트에서 금융 인테이크에 필요한 필드(채널·사용자·텍스트)를 추출. */
+export interface SlackFinanceEvent {
+    channel: string;
+    user: string;
+    text: string;
+}
+/**
+ * 실제 Slack Events API `event_callback`(message) 페이로드 → SlackFinanceEvent|null.
+ * 코어 SlackChannel.parseInbound 와 동일한 수용 조건(메시지·텍스트有·봇아님·subtype無)에
+ * 더해 e.user 를 추출한다. challenge/봇/비-메시지는 null.
+ */
+export declare function parseSlackFinanceEvent(payload: any): SlackFinanceEvent | null;
+/** Socket Mode 봉투(events_api)에서도 동일 추출. */
+export declare function parseSlackFinanceEnvelope(env: any): SlackFinanceEvent | null;
+export interface ParseResult {
+    ok: boolean;
+    request?: Omit<FinanceRequest, 'channel' | 'requester'>;
+    error?: string;
+}
+export declare function parseFinanceCommand(text: string, today?: Date): ParseResult;
+export interface IntakeOutcome {
+    parsed: SlackFinanceEvent | null;
+    request: FinanceRequest | null;
+    decision: WorkflowDecision | null;
+    reply: string;
+    /** 실 채널 전송 결과(전송 시도했을 때). 미전송이면 null. */
+    send: SendResult | null;
+}
+/** 품의자(Slack user) → 위임 토큰·컨텍스트. 운영에선 역할 원장에서 조회. */
+export type FinanceAuthorizer = (req: FinanceRequest) => {
+    token: string;
+    ctx: A2AContext;
+};
+/**
+ * 실 Slack 페이로드 1건을 받아 금융 워크플로우로 처리하고 답장 텍스트를 만든다.
+ * slackChannel 이 설정(토큰)되어 있으면 실제 chat.postMessage 로 전송하고 결과를 채운다.
+ * 미설정이면 send=null 로 두고 reply 만 반환한다(가짜 전송 금지).
+ */
+export declare function handleSlackFinanceEvent(payload: any, engine: FinanceWorkflowEngine, authorize: FinanceAuthorizer, slackChannel?: SlackChannel): Promise<IntakeOutcome>;

package/dist/slack-finance-intake.js

@@ -0,0 +1,122 @@
+"use strict";
+// ============================================================================
+// BM 출원③ — Slack 실 인테이크 어댑터 (700 옴니채널 → 710 금융 워크플로우)
+// ----------------------------------------------------------------------------
+// 실제 Slack Events API / Socket Mode 페이로드(스키마)를 받아 FinanceRequest 로
+// 정규화하고, FinanceWorkflowEngine(720 caveat·730 오라클·750 신뢰)으로 처리한 뒤
+// 답장 텍스트를 만든다. 실 네트워크 전송은 SlackChannel.send(실 chat.postMessage).
+//
+// 정직 고지(제1계명):
+//  - 페이로드 파싱은 코어 `SlackChannel.parseInbound` 의 검증조건을 그대로 따르되,
+//    금융 품의에 필요한 **발신 사용자(e.user)** 를 추가 추출한다(코어 미변경).
+//  - 실 송수신 성공은 SLACK_BOT_TOKEN/SLACK_APP_TOKEN 이 있어야 검증된다.
+//    토큰이 없으면 send 는 ok:false('미설정') 를 반환한다(mock 성공 연기 금지).
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSlackFinanceEvent = parseSlackFinanceEvent;
+exports.parseSlackFinanceEnvelope = parseSlackFinanceEnvelope;
+exports.parseFinanceCommand = parseFinanceCommand;
+exports.handleSlackFinanceEvent = handleSlackFinanceEvent;
+const channels_1 = require("./channels");
+/**
+ * 실제 Slack Events API `event_callback`(message) 페이로드 → SlackFinanceEvent|null.
+ * 코어 SlackChannel.parseInbound 와 동일한 수용 조건(메시지·텍스트有·봇아님·subtype無)에
+ * 더해 e.user 를 추출한다. challenge/봇/비-메시지는 null.
+ */
+function parseSlackFinanceEvent(payload) {
+    // 코어 파서로 1차 검증(채널·텍스트·event_callback·봇배제 등 동일 규칙 재사용)
+    const base = channels_1.SlackChannel.parseInbound(payload);
+    if (!base)
+        return null;
+    const e = payload.event;
+    const user = e?.user ? String(e.user) : '';
+    if (!user)
+        return null; // 품의자 식별 불가 → 처리 안 함(정직)
+    return { channel: base.from, user, text: base.text };
+}
+/** Socket Mode 봉투(events_api)에서도 동일 추출. */
+function parseSlackFinanceEnvelope(env) {
+    if (env?.type === 'events_api')
+        return parseSlackFinanceEvent(env.payload);
+    return null;
+}
+// ---------------------------------------------------------------------------
+// 명령 텍스트 → FinanceRequest 파서 (결정적 문법)
+//   문법: <유형> <금액> <계정과목> <수취처...> [승인자:NAME]
+//   예) "경비 120000 식대 ACME"
+//       "송금 2000000 vendor ACME상사 승인자:U_BOB"
+// ---------------------------------------------------------------------------
+const TYPE_ALIAS = {
+    경비: 'expense', expense: 'expense',
+    송금: 'transfer', transfer: 'transfer', 이체: 'transfer',
+};
+const CATEGORY_ALIAS = {
+    출장: 'travel', travel: 'travel',
+    식대: 'meal', meal: 'meal',
+    사무: 'office', office: 'office',
+    거래처: 'vendor', vendor: 'vendor',
+    급여: 'payroll', payroll: 'payroll',
+};
+let _seq = 0;
+function parseFinanceCommand(text, today = new Date()) {
+    const tokens = text.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length < 4)
+        return { ok: false, error: '형식: <유형> <금액> <계정과목> <수취처> [승인자:NAME]' };
+    const type = TYPE_ALIAS[tokens[0].toLowerCase()] ?? TYPE_ALIAS[tokens[0]];
+    if (!type)
+        return { ok: false, error: `알 수 없는 유형: ${tokens[0]} (경비/송금)` };
+    const amount = Number(tokens[1].replace(/[,_]/g, ''));
+    if (!Number.isFinite(amount) || amount <= 0)
+        return { ok: false, error: `금액 파싱 실패: ${tokens[1]}` };
+    const category = CATEGORY_ALIAS[tokens[2].toLowerCase()] ?? CATEGORY_ALIAS[tokens[2]] ?? tokens[2];
+    // 승인자 토큰 분리
+    let approver;
+    const rest = [];
+    for (const t of tokens.slice(3)) {
+        const m = t.match(/^(?:승인자|approver):(.+)$/);
+        if (m)
+            approver = m[1];
+        else
+            rest.push(t);
+    }
+    const payee = rest.join(' ').trim();
+    if (!payee)
+        return { ok: false, error: '수취처 누락' };
+    const date = today.toISOString().slice(0, 10);
+    return {
+        ok: true,
+        request: { id: `slk-${++_seq}-${Date.now().toString(36)}`, type, amount, category, payee, date, approver },
+    };
+}
+function formatReply(req, d) {
+    const won = req.amount.toLocaleString('ko-KR');
+    if (d.approved) {
+        return `✅ [승인] ${req.type === 'transfer' ? '송금' : '경비'} 품의 — ${req.payee} ${won}원(${req.category}). 감사 ${d.auditId}.`;
+    }
+    const map = { trust: '신뢰(인증/평판)', caveat: '규제 경계(caveat)', oracle: '독립 검증(규정)', execute: '실행 단계' };
+    const why = d.violations.join('; ') || d.controls.find((c) => !c.passed)?.reason || '사유 미상';
+    return `⛔ [차단] ${map[d.decidedBy] ?? d.decidedBy} — ${why}. (가치 v=${d.value.toFixed(2)}, 신뢰 t=${d.trust.toFixed(2)})`;
+}
+/**
+ * 실 Slack 페이로드 1건을 받아 금융 워크플로우로 처리하고 답장 텍스트를 만든다.
+ * slackChannel 이 설정(토큰)되어 있으면 실제 chat.postMessage 로 전송하고 결과를 채운다.
+ * 미설정이면 send=null 로 두고 reply 만 반환한다(가짜 전송 금지).
+ */
+async function handleSlackFinanceEvent(payload, engine, authorize, slackChannel) {
+    const parsed = parseSlackFinanceEvent(payload);
+    if (!parsed)
+        return { parsed: null, request: null, decision: null, reply: '', send: null };
+    const pr = parseFinanceCommand(parsed.text);
+    if (!pr.ok || !pr.request) {
+        const reply = `⚠ 인식 실패: ${pr.error}`;
+        const send = slackChannel?.isConfigured() ? await slackChannel.send(parsed.channel, reply) : null;
+        return { parsed, request: null, decision: null, reply, send };
+    }
+    const request = { ...pr.request, channel: 'slack', requester: parsed.user };
+    const { token, ctx } = authorize(request);
+    const decision = engine.process(request, token, ctx);
+    const reply = formatReply(request, decision);
+    // 실 네트워크 전송(토큰 있을 때만 — 그 전엔 (목표;미측정))
+    const send = slackChannel?.isConfigured() ? await slackChannel.send(parsed.channel, reply) : null;
+    return { parsed, request, decision, reply, send };
+}

package/dist/symbolic-dynamics.d.ts

@@ -0,0 +1,113 @@
+import type { Candidate } from './predictive-agent';
+import type { SymbolicMetaTuple } from './index';
+/** AST/진단 오차 1건. */
+export interface AstError {
+    line: number;
+    code: string;
+    msg: string;
+}
+/** m_t — 기호 메타 튜플("정확한 사실"). 코어 SymbolicMetaTuple 의 상위집합. */
+export interface MetaTuple {
+    targetFile: string;
+    astErrors: AstError[];
+    depMap?: Record<string, string[]>;
+    buildStatus: 'pass' | 'fail' | 'unknown';
+}
+/** 편집 행동 a_t — 후보의 역학용 표현. */
+export interface EditAction {
+    id: string;
+    kind: 'edit' | 'command';
+    file?: string;
+    content?: string;
+    command?: string;
+}
+/** s_t — 하이브리드 상태. z 는 G4에서 합류(현재 optional·미사용). */
+export interface HybridState {
+    z?: Float32Array;
+    m: MetaTuple;
+}
+/** δ: 전이가 규칙으로 결정 가능한가(deny-by-default — G2 실장). */
+export type Decidable = (m: MetaTuple, a: EditAction) => boolean;
+/** Φ: 규칙 전이 — 편집을 VFS 복사본에 적용 후 컴파일러 재평가로 m_{t+1} 산정(G1 실장). */
+export type RuleTransition = (m: MetaTuple, a: EditAction) => Promise<MetaTuple>;
+/** ρ: 규칙 보상(얕은 신호) = αΔ|E| − β|new| + γ·[build pass] (G2 실장). 오라클 앵커 아님. */
+export type RuleReward = (m: MetaTuple, mNext: MetaTuple) => number;
+/** 후보(Candidate) → 편집 행동(EditAction). 핫패스 불변, 역학 인터페이스용 변환. */
+export declare function candidateToEditAction(c: Candidate): EditAction;
+/** 코어 SymbolicMetaTuple(제로카피 슬롯 포맷) → MetaTuple. astErrorCode>0 ⇒ 오차 1건으로 표현. */
+export declare function fromSymbolicMetaTuple(s: SymbolicMetaTuple): MetaTuple;
+/** MetaTuple → 코어 SymbolicMetaTuple(다운캐스트, 손실 가능 — 첫 오차 코드만 보존). */
+export declare function toSymbolicMetaTuple(m: MetaTuple): SymbolicMetaTuple;
+/** MetaTuple 직렬화(JSON). 왕복 보존 검증용. */
+export declare function serializeMeta(m: MetaTuple): string;
+export declare function deserializeMeta(s: string): MetaTuple;
+/** 오차 개수 |E(m)| — ρ·δ 가 참조할 헬퍼. */
+export declare function errorCount(m: MetaTuple): number;
+/** 파일 확장자로 컴파일러 진단 지원 여부. JS=node --check(구문), TS=tsc(구문+타입). */
+export declare function isCompilerDecidableFile(file: string): boolean;
+/**
+ * 컴파일러 재평가로 단일 파일의 MetaTuple 산정(결정론적).
+ * JS: `node --check`(구문). TS: `tsc --noEmit`(구문+**타입**) — node --check 가 못 잡는 타입 오류 포착.
+ */
+export declare function recompileMeta(dir: string, relFile: string): Promise<MetaTuple>;
+/**
+ * Φ 팩토리: 워크스페이스 기준 규칙 전이. 편집 a 를 복사본에 적용 → 컴파일러 재평가 →
+ * 새 MetaTuple(m_{t+1}). 결정론적·건전(컴파일러 의미론과 일치, 환각 없음 — [논문] 정리 1).
+ */
+export declare function makePhi(workspaceDir: string): RuleTransition;
+/** δ — 편집의 컴파일러 결정 가능성. JS 편집만 결정 가능(현재), 그 외(명령·비JS)=0. */
+export declare const isDecidable: Decidable;
+/** ρ 계수(보상 형상). 빌드 통과 보너스 γ 가 지배적이도록. */
+export declare const RHO_ALPHA = 0.1;
+export declare const RHO_BETA = 0.2;
+export declare const RHO_GAMMA = 1;
+/** ρ = αΔ|E| − β|new| + γ·[build pass]. 얕은 사전 정렬 신호([논문] §3.5). */
+export declare const ruleReward: RuleReward;
+import * as _ts from 'typescript';
+export declare class WarmTypeChecker {
+    private files;
+    private service;
+    private options;
+    constructor(opts?: _ts.CompilerOptions);
+    /** TS 내부는 포워드슬래시 경로를 쓰므로 키를 정규화(Windows 백슬래시 불일치 방지). */
+    private static norm;
+    /** 파일 내용 설정(버전 증가 → 증분 재검사). */
+    setFile(fileName: string, content: string): void;
+    /** 한 파일의 구문+의미 진단(증분). */
+    private diagnosticsFor;
+    /** 단일 파일의 구문+의미 진단(증분, in-process). spawn 없음. */
+    check(fileName: string, content: string): AstError[];
+    /** 워크스페이스의 .ts/.tsx 를 전부 시드(node_modules·.git 제외). 프로그램이 프로젝트 전체. */
+    seedDir(dir: string): Promise<number>;
+    /** 디렉토리를 *최초 1회만* 시드(재사용 checker의 워밍업 amortize). 이미 시드된 dir 은 skip. */
+    private seededDirs;
+    seedDirOnce(dir: string): Promise<number>;
+    /** 주어진 파일 집합의 (file:line:code)→AstError 진단 맵. */
+    private diagnosticsOver;
+    /** 시드된 전 파일 진단(프로젝트 전체) — 폴백·전수 검사용. */
+    private allProjectErrors;
+    /**
+     * G3e 최적화 — 편집 파일이 *영향을 줄 수 있는* 파일 집합: {편집파일} ∪ 그 파일을 (전이적으로)
+     *  import 하는 의존자. 편집은 다른 파일의 내용을 바꾸지 않으므로 새 오차는 이 집합에만 생긴다(건전).
+     *  `getFileReferences`(역참조)로 BFS. 미지원/실패 시 전 파일로 폴백(건전성 우선).
+     */
+    affectedFiles(editedAbsFile: string): string[];
+    /**
+     * 편집이 *프로젝트에 새로 도입하는* 오차(교차파일 포함). **영향 파일 집합만** 전후 진단 비교
+     *  (전수 대신 {편집파일}∪의존자) → 후보당 비용 절감. 체커 상태는 호출 후 원복.
+     * @param affected 사전 계산된 영향 집합(동일 파일을 여러 후보가 편집할 때 캐시 재사용). 미지정 시 자동.
+     */
+    addedErrorsForEdit(editedAbsFile: string, content: string, affected?: string[]): AstError[];
+}
+/** 웜 체커로 MetaTuple 산정(콜드 tsc spawn 대신 in-process 증분). */
+export declare function recompileMetaWarm(checker: WarmTypeChecker, fileName: string, content: string): MetaTuple;
+export interface GfastEval {
+    decidable: boolean;
+    mNext?: MetaTuple;
+    rho?: number;
+}
+/**
+ * 한 후보에 대한 g_fast 기호 경로 평가: δ → (Φ → ρ). 결정 불가면 {decidable:false}(오라클 위임).
+ * 비싼 테스트 오라클 대신 *컴파일러* 만 돌린다.
+ */
+export declare function gfastEvaluate(workspaceDir: string, m0: MetaTuple, a: EditAction): Promise<GfastEval>;