@n2world/orchestrator 1.1.0

package/dist/dashboard/manifest.json

@@ -0,0 +1,15 @@
+{
+  "name": "n2world Agent Dashboard",
+  "short_name": "n2world",
+  "start_url": "/index.html",
+  "display": "standalone",
+  "background_color": "#f4f7fa",
+  "theme_color": "#42a5f5",
+  "icons": [
+    {
+      "src": "icon-192.png",
+      "sizes": "192x192",
+      "type": "image/png"
+    }
+  ]
+}

package/dist/dashboard/service-worker.js

@@ -0,0 +1,28 @@
+const CACHE_NAME = 'n2world-dashboard-v1';
+const ASSETS = [
+  '/',
+  '/index.html',
+  '/manifest.json',
+  '/icon-192.png',
+  '/freebie.png'
+];
+
+self.addEventListener('install', (e) => {
+  e.waitUntil(
+    caches.open(CACHE_NAME).then((cache) => {
+      return cache.addAll(ASSETS);
+    })
+  );
+});
+
+self.addEventListener('fetch', (e) => {
+  // Allow normal streaming fetch for SSE APIs
+  if (e.request.url.includes('/api/')) {
+    return;
+  }
+  e.respondWith(
+    caches.match(e.request).then((cachedResponse) => {
+      return cachedResponse || fetch(e.request);
+    })
+  );
+});

package/dist/dashboard-server.d.ts

@@ -0,0 +1,37 @@
+import { GovernanceController } from './governance';
+import { GovernanceEventBus, ConstitutionalRollback, QuietTimeGate } from './p6-governance';
+export declare class DashboardServer {
+    private port;
+    private server;
+    private sandbox;
+    private worker;
+    private telemetry;
+    /** 외부에서 거버넌스(킬스위치·예산·감사)를 주입해 상태 노출/제어 가능. */
+    governance: GovernanceController;
+    /** P6: 위반/차단 이벤트 버스(실데이터). MCP 인가·commit-gate·tier-egress 이벤트를 publish. */
+    governanceEvents: GovernanceEventBus;
+    /** P6: 헌법 롤백 — 이벤트 버스 구독, 위반 시 즉시 중단(killswitch). */
+    rollback: ConstitutionalRollback;
+    /** P6: 정온 시간 게이트 — 휴식 시간 백그라운드 능동성 억제. */
+    quietGate: QuietTimeGate;
+    /** 자연어 대화 히스토리 — 디스크 영속(다운돼도 보존·재시작 시 복원). CLI `chat` 과 같은 보존소. */
+    private chat;
+    /** P2 — 치과 접수 환자 원장(대조용, 로컬 전용·세션 지속). */
+    private dentalStore;
+    /**
+     * C1 — /api/* 접근 토큰. 비루프백(LAN) 접근 시 필수. 루프백(로컬 UI)은 불요.
+     * 환경변수 DASHBOARD_TOKEN 우선, 없으면 1회성 무작위 발급(시작 시 콘솔 표시).
+     */
+    private authToken;
+    /** H3 — 컴패니언 로컬 API(루프백+토큰 *전송계층* 강제). 대시보드 토큰을 공유. */
+    private companion;
+    constructor(port: number);
+    /** P6: v2.x 완료 정의 종합 점검(실측 이벤트 기반, 베타 미가동 항목은 정직 unmet). */
+    dodReport(): import("./p6-governance").DoDReport;
+    start(): Promise<void>;
+    /** 실제 바인딩된 포트(port 0 으로 시작했으면 OS가 할당한 포트). */
+    getPort(): number;
+    /** C1 — /api/* 접근 토큰(비루프백 접근용). 운영자 본인에게만 노출. */
+    accessToken(): string;
+    stop(): Promise<void>;
+}

package/dist/dashboard-server.js

@@ -0,0 +1,457 @@
+"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.DashboardServer = void 0;
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const net_guard_1 = require("./net-guard");
+const companion_api_1 = require("./companion-api");
+const index_1 = require("./index");
+const worker_agent_1 = require("./worker-agent");
+const llm_1 = require("./llm");
+const governed_llm_1 = require("./governed-llm");
+const dental_intake_service_1 = require("./dental-intake-service");
+const dental_intake_1 = require("./playbooks/dental-intake");
+const chat_store_1 = require("./chat-store");
+const conversation_graph_1 = require("./conversation-graph");
+const telemetry_1 = require("./telemetry");
+const governance_1 = require("./governance");
+const health_1 = require("./health");
+const p6_governance_1 = require("./p6-governance");
+class DashboardServer {
+    port;
+    server = null;
+    sandbox = null;
+    worker = null;
+    telemetry = new telemetry_1.TelemetrySource();
+    /** 외부에서 거버넌스(킬스위치·예산·감사)를 주입해 상태 노출/제어 가능. */
+    governance = new governance_1.GovernanceController();
+    /** P6: 위반/차단 이벤트 버스(실데이터). MCP 인가·commit-gate·tier-egress 이벤트를 publish. */
+    governanceEvents = new p6_governance_1.GovernanceEventBus();
+    /** P6: 헌법 롤백 — 이벤트 버스 구독, 위반 시 즉시 중단(killswitch). */
+    rollback = new p6_governance_1.ConstitutionalRollback(this.governance);
+    /** P6: 정온 시간 게이트 — 휴식 시간 백그라운드 능동성 억제. */
+    quietGate = new p6_governance_1.QuietTimeGate();
+    /** 자연어 대화 히스토리 — 디스크 영속(다운돼도 보존·재시작 시 복원). CLI `chat` 과 같은 보존소. */
+    chat = new chat_store_1.ChatStore();
+    /** P2 — 치과 접수 환자 원장(대조용, 로컬 전용·세션 지속). */
+    dentalStore = new dental_intake_1.PatientRecordStore();
+    /**
+     * C1 — /api/* 접근 토큰. 비루프백(LAN) 접근 시 필수. 루프백(로컬 UI)은 불요.
+     * 환경변수 DASHBOARD_TOKEN 우선, 없으면 1회성 무작위 발급(시작 시 콘솔 표시).
+     */
+    authToken = process.env.DASHBOARD_TOKEN || crypto.randomBytes(24).toString('base64url');
+    /** H3 — 컴패니언 로컬 API(루프백+토큰 *전송계층* 강제). 대시보드 토큰을 공유. */
+    companion = new companion_api_1.CompanionApi(this.governance, this.authToken);
+    constructor(port) {
+        this.port = port;
+        this.rollback.attach(this.governanceEvents); // 위반 이벤트 구독
+        this.chat.load(); // 이전 대화 복원(다운 후 재시작해도 이어짐)
+    }
+    /** P6: v2.x 완료 정의 종합 점검(실측 이벤트 기반, 베타 미가동 항목은 정직 unmet). */
+    dodReport() {
+        const c = this.governanceEvents.counts();
+        return (0, p6_governance_1.v2DoDReport)({
+            betaUsersDelivered: 0, // 실사용자 인도 0 — 베타 미가동(정직)
+            realUserLiftMeasured: false, // 실사용자 라벨 부재 → (목표;미측정)
+            safetySeparatedReported: true,
+            tier0ExfilObserved: c.tier0ExfilEscaped, // 실측(0 이어야 함)
+            honestyHeld: true,
+            complexityWithinBudget: true,
+        });
+    }
+    async start() {
+        // Initialize sandbox and worker for actual command execution
+        this.sandbox = new index_1.LocalSandbox();
+        await this.sandbox.init();
+        this.worker = new worker_agent_1.WorkerAgent(this.sandbox);
+        // C1 — CORS: 기본은 *미설정*(same-origin). 교차출처(모바일 컴패니언)는 DASHBOARD_CORS_ORIGIN
+        // 으로 특정 오리진을 명시할 때만 허용. '*' 와일드카드 기본값 제거(무인증 교차출처 차단).
+        const corsOrigin = process.env.DASHBOARD_CORS_ORIGIN; // 미설정이면 ACAO 헤더를 보내지 않음
+        this.server = http.createServer(async (req, res) => {
+            if (corsOrigin) {
+                res.setHeader('Access-Control-Allow-Origin', corsOrigin);
+                res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+                res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Dashboard-Token');
+                res.setHeader('Vary', 'Origin');
+            }
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            // Direct root requests to index.html
+            const reqUrl = req.url || '/index.html';
+            // 쿼리스트링 제거 후 경로만(라우팅·정적파일 안전).
+            const reqPathOnly = reqUrl.split('?')[0];
+            const urlPath = reqPathOnly === '/' || reqPathOnly === '' ? '/index.html' : reqPathOnly;
+            // C1 — /api/* 접근 통제: 루프백(로컬 UI)은 허용, 비루프백(LAN/원격)은 토큰 필수.
+            // 명령실행(/api/run)·킬스위치(/api/governance)·PII(dental)·대화이력 모두 보호.
+            if (urlPath.startsWith('/api/')) {
+                const access = (0, net_guard_1.decideAccess)(req, this.authToken);
+                if (!access.ok) {
+                    res.writeHead(401, {
+                        'Content-Type': 'application/json; charset=utf-8',
+                        'WWW-Authenticate': 'Bearer realm="n2world-dashboard"',
+                    });
+                    res.end(JSON.stringify({ error: 'unauthorized', reason: access.reason }));
+                    return;
+                }
+            }
+            // Handle SSE API Endpoint
+            if (urlPath === '/api/telemetry') {
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream; charset=utf-8',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive'
+                });
+                const interval = setInterval(() => {
+                    // D1: 진짜 시스템 메트릭(가짜 Math.random 제거).
+                    const t = this.telemetry.sample();
+                    const telemetryData = JSON.stringify({
+                        cpu: t.cpuPercent,
+                        memory: t.memUsedMB + 'MB',
+                        memPercent: t.memPercent,
+                        heap: t.heapUsedMB + 'MB',
+                        load: t.loadAvg1,
+                        tasks: t.activeTasks,
+                        uptime: t.uptimeSec,
+                    });
+                    res.write(`data: ${telemetryData}\n\n`);
+                }, 500);
+                req.on('close', () => {
+                    clearInterval(interval);
+                });
+                return;
+            }
+            // D2: 거버넌스 상태/제어 (GET 상태, POST kill/reset)
+            if (urlPath === '/api/governance') {
+                if (req.method === 'POST') {
+                    let body = '';
+                    req.on('data', (c) => { body += c; });
+                    req.on('end', () => {
+                        try {
+                            const action = JSON.parse(body || '{}').action;
+                            if (action === 'kill')
+                                this.governance.kill('dashboard');
+                            else if (action === 'reset')
+                                this.governance.reset();
+                            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify(this.governance.status()));
+                        }
+                        catch {
+                            res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify({ error: 'bad request' }));
+                        }
+                    });
+                    return;
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ ...this.governance.status(), telemetry: this.telemetry.sample() }));
+                return;
+            }
+            // P6: 위반/차단 이벤트 집계·최근 + 롤백 상태(실데이터 — Math.random 없음)
+            if (urlPath === '/api/governance-events') {
+                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({
+                    counts: this.governanceEvents.counts(),
+                    recent: this.governanceEvents.recent(50),
+                    rollback: this.rollback.status(),
+                    quiet: { config: this.quietGate.config(), now: this.quietGate.allowBackgroundAction(new Date(), 'normal') },
+                }));
+                return;
+            }
+            // P6: v2.x 완료 정의 종합 점검(미충족은 정직 표기)
+            if (urlPath === '/api/dod') {
+                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify(this.dodReport()));
+                return;
+            }
+            // H3 — 컴패니언 로컬 API: loopback 은 *소켓 주소*로 판정(위조 불가), 토큰은 헤더/쿼리에서.
+            // (이미 위의 /api/* 게이트를 통과했지만, CompanionApi 가 한 번 더 루프백+토큰을 강제한다.)
+            if (urlPath === '/api/companion/status') {
+                const r = this.companion.status((0, net_guard_1.authContextFromRequest)(req));
+                res.writeHead(r.ok ? 200 : 401, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify(r));
+                return;
+            }
+            if (urlPath === '/api/companion/kill' && req.method === 'POST') {
+                let body = '';
+                req.on('data', (c) => { body += c.toString(); });
+                req.on('end', () => {
+                    let kill = true;
+                    try {
+                        kill = JSON.parse(body || '{}').kill !== false;
+                    }
+                    catch { /* 기본 kill */ }
+                    const r = this.companion.setKill((0, net_guard_1.authContextFromRequest)(req), kill);
+                    res.writeHead(r.ok ? 200 : 401, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify(r));
+                });
+                return;
+            }
+            // 컴패니언 페어링 토큰 표시 — *루프백 전용*(원격은 토큰조차 못 받게 차단).
+            if (urlPath === '/api/companion/pairing-token') {
+                if (!(0, net_guard_1.isLoopbackRequest)(req)) {
+                    res.writeHead(403, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: 'forbidden', reason: '페어링 토큰은 루프백에서만 조회 가능' }));
+                    return;
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ token: this.companion.pairingToken() }));
+                return;
+            }
+            // P2 — 치과 접수·대조 폼 UI(/dental → dental.html).
+            if (urlPath === '/dental') {
+                try {
+                    const content = await fs.readFile(path.join(__dirname, 'dashboard', 'dental.html'));
+                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                    res.end(content);
+                }
+                catch {
+                    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                    res.end('dental.html 을 찾을 수 없습니다(빌드 필요).');
+                }
+                return;
+            }
+            // 전용 대화 웹 UI(/chat → chat.html). 저장된 대화를 불러와 이어서 대화.
+            if (urlPath === '/chat') {
+                try {
+                    const content = await fs.readFile(path.join(__dirname, 'dashboard', 'chat.html'));
+                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                    res.end(content);
+                }
+                catch {
+                    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                    res.end('chat.html 을 찾을 수 없습니다(빌드 필요).');
+                }
+                return;
+            }
+            // 대화 복구 — 영속된 대화 히스토리 조회(다운 후에도 복원·복사 가능)
+            if (urlPath === '/api/chat-history') {
+                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ count: this.chat.count(), turns: this.chat.history(), path: this.chat.path_() }));
+                return;
+            }
+            // 사고 과정 그래프 — 대화에서 도출한 의미 그래프(실데이터, Graphify 계열)
+            if (urlPath === '/api/graph') {
+                const graph = (0, conversation_graph_1.buildConversationGraph)(this.chat.history());
+                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify(graph));
+                return;
+            }
+            // D4: 헬스체크 (status: healthy/degraded/unhealthy + 실 텔레메트리)
+            if (urlPath === '/api/health') {
+                const health = new health_1.HealthCheck(this.telemetry, this.governance).check();
+                const code = health.status === 'unhealthy' ? 503 : 200;
+                res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify(health));
+                return;
+            }
+            // Handle Run command API Endpoint (Real Execution)
+            // P2 — 치과 접수·대조 플레이북 실행(PII=로컬 강제). 운영자 본인 세션 → consent=true.
+            if (urlPath === '/api/playbook/dental/intake' && req.method === 'POST') {
+                let body = '';
+                req.on('data', (c) => { body += c.toString(); });
+                req.on('end', async () => {
+                    try {
+                        const payload = JSON.parse(body || '{}');
+                        const runShell = async (cmd) => {
+                            if (!this.worker)
+                                return '';
+                            const r = await this.worker.executeTask(cmd);
+                            return `${r.stdout}\n${r.stderr}`;
+                        };
+                        const gov = new governed_llm_1.GovernedAgent((0, governed_llm_1.defaultGovernedBackends)(runShell));
+                        const svc = new dental_intake_service_1.DentalIntakeService(gov, this.dentalStore);
+                        const result = await svc.intake(payload, { consent: true });
+                        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify(result));
+                    }
+                    catch (e) {
+                        // M3 — 상세는 서버 로그로만. 클라이언트엔 일반 메시지.
+                        console.error('[dashboard] dental intake 처리 오류:', e);
+                        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: '요청 처리 실패(형식 확인)' }));
+                    }
+                });
+                return;
+            }
+            if (urlPath === '/api/run' && req.method === 'POST') {
+                let body = '';
+                req.on('data', chunk => {
+                    body += chunk.toString();
+                });
+                req.on('end', async () => {
+                    try {
+                        const payload = JSON.parse(body);
+                        const cmd = payload.command;
+                        if (!cmd) {
+                            res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify({ error: 'Missing command parameter' }));
+                            return;
+                        }
+                        if (!this.worker) {
+                            res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify({ error: 'Worker agent not initialized' }));
+                            return;
+                        }
+                        const normalizedCmd = cmd.trim();
+                        const isNaturalLanguage = /^[ㄱ-ㅎㅏ-ㅣ가-힣\s\?\!\.₩]+$/.test(normalizedCmd) ||
+                            (!normalizedCmd.includes(' ') && !/^[a-zA-Z0-9_-]+$/.test(normalizedCmd)) ||
+                            (normalizedCmd.split(' ').length > 1 && !/^(dir|ls|cd|echo|n2world|node|npm|git|type|cat|mkdir|rm|del|copy|xcopy|move|ping|ipconfig|netstat)/i.test(normalizedCmd));
+                        if (isNaturalLanguage) {
+                            // 멀티턴 대화 — 이전 맥락을 기억하고 매 턴 디스크에 영속(다운돼도 보존).
+                            this.chat.append({ role: 'user', content: normalizedCmd }); // 입력 즉시 저장
+                            const runShell = async (shellCmd) => {
+                                const res = await this.worker.executeTask(shellCmd);
+                                return `[Command: ${shellCmd}]\nStdout:\n${res.stdout}\nStderr:\n${res.stderr}\nSuccess: ${res.success}\n`;
+                            };
+                            // H2 — Tier 거버넌스 *기본 ON*(보안 하드닝). 민감=Tier-0 로컬 강제, PII 외부 송신 차단.
+                            // 명시적 비활성화만 우회 허용: N2WORLD_TIER_GUARD=0|false|off (운영자 책임).
+                            let agentResponse;
+                            const guardOff = /^(0|false|off)$/i.test(process.env.N2WORLD_TIER_GUARD || '');
+                            if (!guardOff) {
+                                const gov = new governed_llm_1.GovernedAgent((0, governed_llm_1.defaultGovernedBackends)(runShell), { baselineTier: 1 });
+                                agentResponse = (await gov.respond(this.chat.history(), { consent: true })).text;
+                            }
+                            else {
+                                agentResponse = await (0, llm_1.askAgentChat)(this.chat.history(), runShell);
+                            }
+                            this.chat.append({ role: 'assistant', content: agentResponse }); // 응답 즉시 저장
+                            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify({
+                                stdout: agentResponse,
+                                stderr: '',
+                                success: true
+                            }));
+                            return;
+                        }
+                        const result = await this.worker.executeTask(cmd);
+                        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({
+                            stdout: result.stdout,
+                            stderr: result.stderr,
+                            success: result.success
+                        }));
+                    }
+                    catch (err) {
+                        // M3 — 내부 상세(스택·경로)는 서버 로그로만. 클라이언트엔 일반 메시지.
+                        console.error('[dashboard] /api/run 처리 오류:', err);
+                        res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: '내부 처리 오류' }));
+                    }
+                });
+                return;
+            }
+            // C1 — 경로 순회(LFI) 방지: dashboard 디렉터리 밖으로 못 나가게 정규화 후 경계 검사.
+            const dashDir = path.join(__dirname, 'dashboard');
+            const resolvedPath = path.resolve(dashDir, '.' + path.posix.normalize('/' + urlPath));
+            if (resolvedPath !== dashDir && !resolvedPath.startsWith(dashDir + path.sep)) {
+                res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('잘못된 경로 요청.');
+                return;
+            }
+            try {
+                const content = await fs.readFile(resolvedPath);
+                let contentType = 'text/html; charset=utf-8';
+                if (urlPath.endsWith('.js')) {
+                    contentType = 'application/javascript; charset=utf-8';
+                }
+                else if (urlPath.endsWith('.css')) {
+                    contentType = 'text/css; charset=utf-8';
+                }
+                else if (urlPath.endsWith('.png')) {
+                    contentType = 'image/png';
+                }
+                else if (urlPath.endsWith('.json')) {
+                    contentType = 'application/json; charset=utf-8';
+                }
+                res.writeHead(200, { 'Content-Type': contentType });
+                res.end(content);
+            }
+            catch (err) {
+                res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('지정한 대시보드 리소스를 찾을 수 없습니다.');
+            }
+        });
+        // C1 — 기본 바인딩 127.0.0.1(로컬 전용). LAN 노출은 DASHBOARD_HOST=0.0.0.0 로 *명시적* 선택.
+        const host = process.env.DASHBOARD_HOST || '127.0.0.1';
+        const loopbackOnly = host === '127.0.0.1' || host === '::1' || host === 'localhost';
+        return new Promise((resolve, reject) => {
+            const srv = this.server;
+            const onError = (err) => { srv.removeListener('error', onError); reject(err); };
+            srv.once('error', onError); // EADDRINUSE 등을 정직히 reject(미처리 throw 방지)
+            srv.listen(this.port, host, () => {
+                srv.removeListener('error', onError);
+                const addr = srv.address();
+                if (addr && typeof addr === 'object' && addr.port)
+                    this.port = addr.port; // port 0 → 실제 에페메럴 포트
+                if (!loopbackOnly) {
+                    // LAN 노출 시: 비루프백 접근은 토큰 필수임을 운영자에게 고지(자동발급 토큰 표시).
+                    console.warn(`[dashboard] ⚠ 비루프백(${host}) 바인딩 — 원격 /api/* 접근은 토큰 필수.`);
+                    if (!process.env.DASHBOARD_TOKEN) {
+                        console.warn(`[dashboard]   접근 토큰(이번 세션): ${this.authToken}`);
+                        console.warn(`[dashboard]   사용: Authorization: Bearer <토큰>  또는  ?token=<토큰>`);
+                    }
+                }
+                resolve();
+            });
+        });
+    }
+    /** 실제 바인딩된 포트(port 0 으로 시작했으면 OS가 할당한 포트). */
+    getPort() {
+        return this.port;
+    }
+    /** C1 — /api/* 접근 토큰(비루프백 접근용). 운영자 본인에게만 노출. */
+    accessToken() {
+        return this.authToken;
+    }
+    async stop() {
+        if (this.server) {
+            await new Promise((resolve) => {
+                this.server.close(() => {
+                    resolve();
+                });
+            });
+        }
+        if (this.sandbox) {
+            await this.sandbox.destroy();
+        }
+    }
+}
+exports.DashboardServer = DashboardServer;

package/dist/dental-intake-service.d.ts

@@ -0,0 +1,37 @@
+import { PatientRecordStore, DentalIntake } from './playbooks/dental-intake';
+import { GovernedAgent } from './governed-llm';
+export interface IntakeStepView {
+    id: string;
+    provider: 'local' | 'external' | 'none';
+    text: string;
+    tier: number;
+}
+export interface IntakeResponse {
+    ok: boolean;
+    tier: number;
+    missingFields: string[];
+    flags: {
+        id: string;
+        flag: string;
+        severity: 'block' | 'warn';
+    }[];
+    steps: IntakeStepView[];
+    humanInLoopRequired: boolean;
+    piiKeptLocal: boolean;
+    tier0ExternalAllowed: number;
+    metrics: {
+        ms: number;
+        llmCalls: number;
+    };
+    notice: string;
+}
+export declare class DentalIntakeService {
+    private gov;
+    private store;
+    private rt;
+    constructor(gov: GovernedAgent, store?: PatientRecordStore);
+    intake(body: Partial<DentalIntake>, opts?: {
+        consent?: boolean;
+    }): Promise<IntakeResponse>;
+    recordCount(): number;
+}

package/dist/dental-intake-service.js

@@ -0,0 +1,61 @@
+"use strict";
+// ============================================================================
+// P2 — 치과 접수·대조 서비스 (앱 v1.2 §4.2) — 실행 UI의 백엔드 핵심
+// ----------------------------------------------------------------------------
+// 이미 구현된 PlaybookRuntime + dental-intake 플레이북에 *요청/응답 어댑터*를 결선한다.
+// UI(폼/결과 카드)가 소비할 JSON을 만든다. PII는 코어 TierGuard 가 로컬로 강제한다.
+//
+// 정직 고지(제1계명): 런타임/대조 로직 재구현 금지(소비만). LLM 단계는 GovernedAgent
+// (주입형/실 백엔드)로 라우팅 — PII 외부 송신 0/N. 가짜 성공 없음.
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DentalIntakeService = void 0;
+const playbook_1 = require("./playbook");
+const dental_intake_1 = require("./playbooks/dental-intake");
+function normalize(body) {
+    const s = (v) => (v == null ? '' : String(v).trim());
+    return {
+        name: s(body.name), dob: s(body.dob), phone: s(body.phone),
+        insuranceId: body.insuranceId ? s(body.insuranceId) : undefined,
+        appointmentDate: body.appointmentDate ? s(body.appointmentDate) : undefined,
+        provider: body.provider ? s(body.provider) : undefined,
+        chiefComplaint: body.chiefComplaint ? s(body.chiefComplaint) : undefined,
+    };
+}
+class DentalIntakeService {
+    gov;
+    store;
+    rt;
+    constructor(gov, store = new dental_intake_1.PatientRecordStore()) {
+        this.gov = gov;
+        this.store = store;
+        this.rt = new playbook_1.PlaybookRuntime(gov);
+    }
+    async intake(body, opts = {}) {
+        const rec = normalize(body);
+        const r = await this.rt.run(dental_intake_1.dentalIntakePlaybook, rec, this.store, opts);
+        let notice;
+        if (r.missingFields.length > 0)
+            notice = `필수 정보가 비어 있습니다: ${r.missingFields.join(', ')}`;
+        else if (r.humanInLoopRequired)
+            notice = '⚠ 임상 관련 내용 — 치과의 확인이 필요합니다(자동 처리 보류).';
+        else if (r.flags.some((f) => f.severity === 'block'))
+            notice = '대조 결과 차단 항목이 있습니다.';
+        else
+            notice = '접수·대조 완료. 직원 요약/환자 안내가 생성되었습니다.';
+        return {
+            ok: r.ok,
+            tier: r.overallTier,
+            missingFields: r.missingFields,
+            flags: r.flags,
+            steps: r.steps.map((s) => ({ id: s.id, provider: s.provider, text: s.text, tier: s.tier })),
+            humanInLoopRequired: r.humanInLoopRequired,
+            piiKeptLocal: r.blockedExternalForPii,
+            tier0ExternalAllowed: this.gov.guardRef().tier0ExternalAllowed(),
+            metrics: r.metrics,
+            notice,
+        };
+    }
+    recordCount() { return this.store.count(); }
+}
+exports.DentalIntakeService = DentalIntakeService;

package/dist/dental-metrics.d.ts

@@ -0,0 +1,25 @@
+export interface IntakeEvent {
+    baselineMs: number;
+    actualMs: number;
+    completed: boolean;
+    flagHit: boolean;
+    satisfaction?: 1 | 2 | 3 | 4 | 5;
+}
+export interface BenefitReport {
+    n: number;
+    timeSavedMsMean: number;
+    timeSavedPct: number;
+    completionRate: number;
+    flagHitRate: number;
+    satisfactionMean: number | null;
+}
+export declare class DentalMetrics {
+    private events;
+    record(e: IntakeEvent): void;
+    report(): BenefitReport;
+}
+/** 유닛 이코노믹스 게이트: LTV/CAC ≥ 3 인가(파일럿 검증). */
+export declare function ltvCacGate(ltv: number, cac: number, threshold?: number): {
+    pass: boolean;
+    ratio: number;
+};