@n2world/orchestrator 1.1.0

package/dist/playbook.js

@@ -0,0 +1,83 @@
+"use strict";
+// ============================================================================
+// 플레이북 런타임 (보편화 MVP — 비개발자가 "고르는" 가치 단위의 실행 엔진)
+// ----------------------------------------------------------------------------
+// 방안서 v1.1 §8 1순위: 플레이북이 *행동 표준·Tier·라우팅·예외처리* 를 지배한다.
+// 본 런타임은 도메인 무관 재사용 엔진이며, Tier별 하이브리드 라우팅을 강제한다:
+//   - PII/민감 단계 → 로컬(Tier-0, 외부 0/N)
+//   - 비민감 단계 → 빠른 경로(외부 허용)
+// 대조(cross-check)는 *에이전트가 만들지 않은* 독립 규칙으로 검증한다(자기채점 금지).
+// 임상 등 고위험 범위는 사람 확인(human-in-loop)을 강제한다(liability 게이트).
+//
+// 정직 고지(제1계명): LLM 단계는 GovernedAgent(주입형)로 라우팅 — 키/ollama 없으면
+// 정직 보류. 대조·검증은 결정론적 규칙(실동작). 가짜 완료 없음.
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaybookRuntime = void 0;
+class PlaybookRuntime {
+    gov;
+    constructor(gov) {
+        this.gov = gov;
+    }
+    /** 입력 레코드에 PII/민감 필드가 채워져 있으면 전체 Tier-0. */
+    overallTier(pb, record) {
+        const hasSensitive = pb.fields.some((f) => (f.tier === 'pii' || f.tier === 'sensitive') && record[f.key] != null && String(record[f.key]).trim() !== '');
+        return hasSensitive ? 0 : 2;
+    }
+    async run(pb, record, store, opts = {}) {
+        const t0 = Number((globalThis.performance?.now?.() ?? Date.now()));
+        const phasesRun = [];
+        const flags = [];
+        const steps = [];
+        let llmCalls = 0;
+        let blockedExternalForPii = true; // 위반 시 false 로 떨어뜨린다
+        // ── Phase 1: 필수 필드 검증 ──
+        phasesRun.push('validate');
+        const missingFields = pb.fields.filter((f) => f.required && (record[f.key] == null || String(record[f.key]).trim() === '')).map((f) => f.key);
+        const overallTier = this.overallTier(pb, record);
+        // ── Phase 2: 대조(cross-check) — 독립 규칙 ──
+        phasesRun.push('crosscheck');
+        for (const rule of pb.crossChecks) {
+            const r = rule.check({ record, store });
+            if (r)
+                flags.push({ id: rule.id, flag: r.flag, severity: r.severity });
+        }
+        // ── Phase 3: liability 게이트(임상 등 → 사람 확인) ──
+        phasesRun.push('liability');
+        const humanInLoopRequired = !!(pb.clinicalScope && pb.needsHumanReview?.(record));
+        // ── Phase 4: LLM 단계(요약/안내) — Tier 하이브리드 라우팅 ──
+        const hasBlock = flags.some((f) => f.severity === 'block') || missingFields.length > 0;
+        if (!hasBlock && this.gov) {
+            phasesRun.push('generate');
+            for (const step of pb.llmSteps) {
+                const prompt = step.prompt(record);
+                // pii 단계는 baseline 없이(텍스트의 PII가 Tier-0 유발). public 단계는 baselineTier=2(빠른 경로).
+                const res = await this.gov.respond([{ role: 'user', content: prompt }], {
+                    consent: opts.consent,
+                    baselineTier: step.tier === 'public' ? 2 : 0,
+                });
+                llmCalls += 1;
+                steps.push({ id: step.id, tier: res.tier, provider: res.provider, text: res.text });
+                // 불변식: pii 단계는 절대 external 이면 안 된다.
+                if (step.tier !== 'public' && res.provider === 'external')
+                    blockedExternalForPii = false;
+            }
+        }
+        // 합격분만 원장 기록(대조 차단 없을 때 — 집행됨으로 간주)
+        if (!hasBlock)
+            store.add(record);
+        const ms = Number((globalThis.performance?.now?.() ?? Date.now())) - t0;
+        return {
+            ok: !hasBlock,
+            overallTier,
+            missingFields,
+            flags,
+            steps,
+            humanInLoopRequired,
+            blockedExternalForPii,
+            phasesRun,
+            metrics: { ms, llmCalls },
+        };
+    }
+}
+exports.PlaybookRuntime = PlaybookRuntime;

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

@@ -0,0 +1,20 @@
+import { Playbook, RecordStore } from '../playbook';
+export interface DentalIntake {
+    name: string;
+    dob: string;
+    phone: string;
+    insuranceId?: string;
+    appointmentDate?: string;
+    provider?: string;
+    chiefComplaint?: string;
+}
+/** 환자 원장(대조용). 동일 (이름|생년|전화) = 기존 환자. 로컬 전용. */
+export declare class PatientRecordStore implements RecordStore<DentalIntake> {
+    private recs;
+    private key;
+    private seen;
+    add(r: DentalIntake): void;
+    findDuplicate(r: DentalIntake): DentalIntake | null;
+    count(): number;
+}
+export declare const dentalIntakePlaybook: Playbook<DentalIntake>;

package/dist/playbooks/dental-intake.js

@@ -0,0 +1,112 @@
+"use strict";
+// ============================================================================
+// 치과 접수·대조 플레이북 (보편화 MVP 비치헤드 — 방안서 v1.1 §2)
+// ----------------------------------------------------------------------------
+// 환자 접수 정보(PII=Tier-0)를 받아 ① 필수필드 검증 ② 대조(중복·보험·예약 정합)
+// ③ 임상 여부 판정(사람 확인 강제) ④ (비차단 시) 직원용 요약(PII→로컬) + 환자 안내문
+// (비민감→빠른 경로)을 생성한다. 데이터 거버넌스는 코어 TierGuard 가 강제.
+//
+// liability(제1계명·안전): 임상 판단(진단·처방)은 *기본 차단/사람 확인*. 본 플레이북은
+// 접수·행정·대조 등 **비임상** 만 자동 처리한다.
+// ============================================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dentalIntakePlaybook = exports.PatientRecordStore = void 0;
+const crypto = __importStar(require("crypto"));
+/** 환자 원장(대조용). 동일 (이름|생년|전화) = 기존 환자. 로컬 전용. */
+class PatientRecordStore {
+    recs = [];
+    key(r) {
+        return crypto.createHash('sha256').update(`${r.name}|${r.dob}|${r.phone}`).digest('hex');
+    }
+    seen = new Set();
+    add(r) { this.recs.push(r); this.seen.add(this.key(r)); }
+    findDuplicate(r) {
+        return this.seen.has(this.key(r)) ? (this.recs.find((x) => this.key(x) === this.key(r)) ?? null) : null;
+    }
+    count() { return this.recs.length; }
+}
+exports.PatientRecordStore = PatientRecordStore;
+// 임상 주호소 키워드(있으면 치과의 확인 필요 — liability). 비임상 접수만 자동화.
+const CLINICAL_TERMS = /(통증|아파|시려|붓|출혈|발치|신경|충치|교정|임플란트|마취|처방)/;
+const crossChecks = [
+    {
+        id: 'DUP-PATIENT',
+        check: ({ record, store }) => store.findDuplicate(record)
+            ? { flag: '기존 환자(중복 접수 가능) — 기록 대조 필요', severity: 'warn' }
+            : null,
+    },
+    {
+        id: 'INSURANCE-MISSING',
+        check: ({ record }) => !record.insuranceId
+            ? { flag: '보험 정보 미입력 — 수납 전 확인', severity: 'warn' }
+            : null,
+    },
+    {
+        id: 'APPT-PROVIDER-MISMATCH',
+        check: ({ record }) => (record.appointmentDate && !record.provider)
+            ? { flag: '예약일은 있으나 담당의 미지정', severity: 'warn' }
+            : null,
+    },
+];
+exports.dentalIntakePlaybook = {
+    id: 'dental-intake-v1',
+    name: '치과 접수·대조 비서',
+    domain: 'dental',
+    clinicalScope: true, // 임상 가능성 → liability 게이트
+    fields: [
+        { key: 'name', label: '이름', required: true, tier: 'pii' },
+        { key: 'dob', label: '생년월일', required: true, tier: 'pii' },
+        { key: 'phone', label: '연락처', required: true, tier: 'pii' },
+        { key: 'insuranceId', label: '보험번호', required: false, tier: 'sensitive' },
+        { key: 'appointmentDate', label: '예약일', required: false, tier: 'public' },
+        { key: 'provider', label: '담당의', required: false, tier: 'public' },
+        { key: 'chiefComplaint', label: '주호소', required: false, tier: 'sensitive' },
+    ],
+    crossChecks,
+    needsHumanReview: (r) => !!(r.chiefComplaint && CLINICAL_TERMS.test(r.chiefComplaint)),
+    llmSteps: [
+        {
+            id: 'staff-summary',
+            tier: 'pii', // 환자 PII 포함 → 로컬 강제(Tier-0)
+            prompt: (r) => `다음 치과 접수 정보를 직원용으로 3줄 요약(비임상·행정만): 이름 ${r.name}, 생년 ${r.dob}, 연락처 ${r.phone}, 보험 ${r.insuranceId ?? '없음'}, 예약 ${r.appointmentDate ?? '미정'}/${r.provider ?? '미정'}.`,
+        },
+        {
+            id: 'patient-notice',
+            tier: 'public', // PII 미포함 일반 안내 → 빠른 경로 허용
+            prompt: () => '치과 예약 확정 안내문을 정중한 한 문장으로 작성(개인정보 미포함, 일반 템플릿).',
+        },
+    ],
+};

package/dist/predictive-agent.d.ts

@@ -0,0 +1,157 @@
+import { WarmTypeChecker } from './symbolic-dynamics';
+export interface Candidate {
+    id: string;
+    description: string;
+    kind: 'edit' | 'command';
+    file?: string;
+    content?: string;
+    command?: string;
+}
+export interface PredictiveResult {
+    success: boolean;
+    committed: Candidate | null;
+    pruned: string[];
+    simulated: {
+        id: string;
+        oraclePass: boolean;
+    }[];
+    oracleCalls: number;
+    order: string[];
+    ranked: boolean;
+    gfastApplied?: boolean;
+}
+export declare class PredictiveAgent {
+    private workspaceDir;
+    private testCommand;
+    private dangerousPatterns;
+    /** 관련성 신호 모드: 'token'=토큰 집합 겹침(기본), 'embedding'=해시 임베딩 코사인(graded). */
+    private relevanceMode;
+    /** 오라클(testCommand) 실행 타임아웃(ms). 무거운 실테스트 스위트 도메인에서 상향. */
+    private oracleTimeoutMs;
+    /** 적응 게이팅 임계 θ: 오라클/필터 비용비 ≥ θ 일 때만 g_fast(§4g 크로스오버 ≈2.3×). */
+    private autoThreshold;
+    /** 세션 비용 추정 캐시(calibrate 로 채움). auto 모드 게이팅 근거. */
+    private costEstimate?;
+    constructor(workspaceDir: string, testCommand: string, dangerousPatterns?: string[], opts?: {
+        relevanceMode?: 'token' | 'embedding';
+        oracleTimeoutMs?: number;
+        autoThreshold?: number;
+    });
+    /** g_fast 구문 타당성: JS 편집이면 `node --check`로 컴파일 가능성 추정(그리드월드 대체). */
+    private isInfeasibleEdit;
+    /** 1단계 g_fast 게이트: 위험 명령 + 비타당 편집을 가지치기. */
+    private prune;
+    private applyTo;
+    /** 2단계: 워크스페이스 복사본에 후보 적용 후 오라클(테스트) 실행 → 통과 여부. */
+    private simulateAndVerify;
+    /**
+     * 적응 게이팅 캘리브레이션 — 대표 후보 1개로 **오라클 단가**와 (워밍업 제외) **후보당 필터 단가**를
+     *  실측해 `ratio = oracleMs/filterMs` 를 캐시한다. `run({ gfast:'auto' })` 가 이 ratio 로 g_fast/baseline 을
+     *  자동 선택(§4g 크로스오버 임계 θ). 정직: 필터 단가는 amortize 후(2번째 필터) 후보당 비용을 반영한다.
+     *  편집·컴파일판정불가 표본이면 필터 측정 불가 → ratio 미설정(auto 는 보수적으로 baseline).
+     */
+    calibrate(sample: Candidate, opts?: {
+        sharedChecker?: WarmTypeChecker;
+    }): Promise<{
+        oracleMs: number;
+        filterMs?: number;
+        ratio?: number;
+    }>;
+    /** 현재 워크스페이스에서 테스트(오라클)가 통과하는지. */
+    oraclePasses(): Promise<boolean>;
+    /**
+     * 오라클 "부분 점수"∈[0,1]: 테스트 출력의 `SCORE:x/y` 를 파싱(멀티파일 부분 진척용).
+     * 없으면 종료 코드로 1.0/0.0. 멀티스텝 탐색의 가치 신호.
+     */
+    oracleScore(dir?: string): Promise<number>;
+    /** 후보를 복사본에 적용 후 오라클 부분 점수 측정(실제 워크스페이스 보존). */
+    private simulateScore;
+    /**
+     * g_fast 가치 추정(오라클 없이, 값싸게). 후보의 "유망도"∈[0,1] — 목표/오류 컨텍스트와의
+     * 텍스트 관련성 + 종류 편향. 정직: 이는 정답성이 아니라 우선순위 신호다(진실은 오라클이 판정).
+     */
+    gfastValue(c: Candidate, context: string): number;
+    /**
+     * G3 — g_fast 기호 경로 정렬: 컴파일러(ρ)로 후보를 사전 평가해
+     *  (a) **비컴파일 후보를 오라클 전에 제외**(건전: 컴파일 실패 ⟹ 그 후보 임포트 테스트 실패),
+     *  (b) 결정 불가(δ=0: 명령·비JS) 후보는 그대로 유지(오라클 위임),
+     *  (c) 생존 후보를 ρ 내림차순 → gfastValue 순으로 정렬.
+     * 비싼 테스트 오라클 대신 값싼 컴파일만 추가로 돈다.
+     */
+    private gfastRank;
+    /**
+     * G3c — 웜(증분) g_fast 정렬: in-process TypeScript Language Service 로 후보 내용을
+     *  *증분* 타입체크(프로세스 spawn·scratch 복사·콜드 시작 없음). 첫 후보만 프로그램 빌드(웜업).
+     *  비컴파일 후보를 오라클 전에 제외하고 ρ 로 정렬. 필터 비용을 콜드 tsc 대비 크게 낮춘다.
+     */
+    private gfastRankWarm;
+    /**
+     * G3d — 프로젝트-시드(교차파일) 웜 정렬. 워크스페이스 전체를 한 번 시드한 뒤, 각 후보 편집이
+     *  *프로젝트에 새 타입오차를 도입하는지*(import한 다른 파일을 깨는 경우 포함) 증분 검사해 제외.
+     *  단일 파일 격리 체크(G3c)가 못 잡는 교차파일 오류를 잡는다. spawn 없음(in-process).
+     */
+    private gfastRankProject;
+    /**
+     * 예측 실행: 가지치기 → (가치순 정렬) → 복사본 오라클 검증을 유망 순서로 → 검증된 첫 수 커밋.
+     * 7-0b 게이팅: 값싼 g_fast로 순서를 정하고 비싼 오라클은 유망 순서로 호출, 첫 통과 시 조기 종료.
+     * opts.rank=false 면 랭킹 없이(원래 순서) 비교 측정 가능.
+     */
+    run(candidates: Candidate[], opts?: {
+        goal?: string;
+        rank?: boolean;
+        gfast?: boolean | 'auto';
+        gfastWarm?: boolean;
+        gfastProject?: boolean;
+        sharedChecker?: WarmTypeChecker;
+    }): Promise<PredictiveResult>;
+    /**
+     * 멀티스텝 예측 실행(멀티파일·다단계). 한 단계가 다른 단계의 실패를 드러내는 SWE형 과제용.
+     * 트리 탐색(베스트퍼스트): g_fast=사전확률로 후보를 정렬하고, 오라클 부분점수=가치로 평가해
+     * 점수를 가장 크게 올리는 "검증된 편집"만 커밋하며 모든 테스트 통과까지 진행한다.
+     * (정직: 풀 확률적 MCTS 롤아웃이 아니라 g_fast 사전확률+오라클 가치의 베스트퍼스트 트리 탐색.)
+     */
+    solveMultiStep(generate: StepCandidateGenerator, goal: string, opts?: {
+        maxSteps?: number;
+    }): Promise<MultiStepResult>;
+}
+export interface MultiStepResult {
+    success: boolean;
+    finalScore: number;
+    steps: {
+        committed: string;
+        scoreBefore: number;
+        scoreAfter: number;
+    }[];
+    pruned: string[];
+    oracleCalls: number;
+}
+export type StepCandidateGenerator = (workspaceDir: string, goal: string, testOutput: string) => Promise<Candidate[]>;
+/**
+ * 후보 생성기. 생성 방식을 예측 실행과 분리한다.
+ * - 테스트/CI: 결정적 후보 집합(LLM·네트워크 불필요).
+ * - 생산: LLM에 "이 목표를 위한 후보 편집 N개를 구조화 JSON으로" 요청해 파싱(별도 구현).
+ */
+export type CandidateGenerator = (workspaceDir: string, goal: string) => Promise<Candidate[]>;
+/**
+ * LLM 출력 → 구조화 후보. 잡설/코드펜스를 견디고, 유효하지 않은 항목은 버린다(정직).
+ * 형식: {"candidates":[{id,description,kind,file,content|command}]} 또는 후보 배열.
+ */
+export declare function parseCandidates(llmOutput: string, defaultFile?: string): Candidate[];
+export declare function buildCandidatePrompt(goal: string, targetFile: string, fileContent: string, testOutput: string, n: number): string;
+export interface LlmGenOptions {
+    targetFile: string;
+    testCommand: string;
+    numCandidates?: number;
+    /** 주입형 LLM 호출(테스트는 모의, 생산은 llmComplete). 미지정 시 llmComplete 사용(키 필요). */
+    complete?: (prompt: string, system?: string) => Promise<string>;
+}
+/**
+ * LLM 기반 후보 생성기(생산 경로). 파일·테스트출력을 모아 프롬프트를 만들고 LLM 호출 후 파싱.
+ * `complete` 주입으로 LLM 없이도(모의) 전체 경로를 결정적으로 검증할 수 있다.
+ */
+export declare function makeLlmCandidateGenerator(opts: LlmGenOptions): CandidateGenerator;
+/**
+ * Stage A 오케스트레이션: 후보 생성 → 예측 실행(가지치기→검증→검증된 첫 수 커밋).
+ * 후보 생성기를 주입받으므로 LLM/결정적 어느 쪽이든 동일 경로를 탄다.
+ */
+export declare function runPredictiveTask(workspaceDir: string, goal: string, testCommand: string, generate: CandidateGenerator, dangerousPatterns?: string[]): Promise<PredictiveResult>;