@n2world/orchestrator 1.1.0

package/dist/predictive-agent.js

@@ -0,0 +1,535 @@
+"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.PredictiveAgent = void 0;
+exports.parseCandidates = parseCandidates;
+exports.buildCandidatePrompt = buildCandidatePrompt;
+exports.makeLlmCandidateGenerator = makeLlmCandidateGenerator;
+exports.runPredictiveTask = runPredictiveTask;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const core_1 = require("@n2world/core");
+const llm_1 = require("./llm");
+const text_embedding_1 = require("./text-embedding");
+const symbolic_dynamics_1 = require("./symbolic-dynamics");
+function sh(cmd, cwd, timeout = 20000) {
+    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() });
+        });
+    });
+}
+class PredictiveAgent {
+    workspaceDir;
+    testCommand;
+    dangerousPatterns;
+    /** 관련성 신호 모드: 'token'=토큰 집합 겹침(기본), 'embedding'=해시 임베딩 코사인(graded). */
+    relevanceMode;
+    /** 오라클(testCommand) 실행 타임아웃(ms). 무거운 실테스트 스위트 도메인에서 상향. */
+    oracleTimeoutMs;
+    /** 적응 게이팅 임계 θ: 오라클/필터 비용비 ≥ θ 일 때만 g_fast(§4g 크로스오버 ≈2.3×). */
+    autoThreshold;
+    /** 세션 비용 추정 캐시(calibrate 로 채움). auto 모드 게이팅 근거. */
+    costEstimate;
+    constructor(workspaceDir, testCommand, dangerousPatterns = ['rm -rf', 'rm -fr', 'mkfs', 'dd if=', ':(){', 'shutdown', 'reboot', 'format ', 'del /', 'rmdir /s'], opts = {}) {
+        this.workspaceDir = workspaceDir;
+        this.testCommand = testCommand;
+        this.dangerousPatterns = dangerousPatterns;
+        this.relevanceMode = opts.relevanceMode ?? 'token';
+        this.oracleTimeoutMs = opts.oracleTimeoutMs ?? 20000; // 오라클(testCommand) 타임아웃. 무거운 실테스트는 상향 필요.
+        this.autoThreshold = opts.autoThreshold ?? 2.3; // §4g 크로스오버 임계
+    }
+    /** g_fast 구문 타당성: JS 편집이면 `node --check`로 컴파일 가능성 추정(그리드월드 대체). */
+    async isInfeasibleEdit(c) {
+        if (c.kind !== 'edit' || !c.file)
+            return false;
+        if (!/\.(c?js|mjs)$/.test(c.file))
+            return false; // JS 외 파일은 이 단계 통과
+        const tmp = path.join(this.workspaceDir, `.gfast_${c.id}.js`);
+        await fs.writeFile(tmp, c.content ?? '', 'utf8');
+        const r = await sh(`node --check "${tmp}"`, this.workspaceDir);
+        await fs.rm(tmp, { force: true });
+        return r.code !== 0; // 구문 오류 → 비타당
+    }
+    /** 1단계 g_fast 게이트: 위험 명령 + 비타당 편집을 가지치기. */
+    async prune(candidates) {
+        const pruned = [];
+        const survivors = [];
+        for (const c of candidates) {
+            if (c.kind === 'command') {
+                // Rust prune_actions 재사용: 위험 패턴 포함 명령은 제거됨.
+                const kept = (0, core_1.pruneActions)([c.command ?? ''], this.dangerousPatterns);
+                if (kept.length === 0) {
+                    pruned.push(c.id);
+                    continue;
+                }
+            }
+            if (await this.isInfeasibleEdit(c)) {
+                pruned.push(c.id);
+                continue;
+            }
+            survivors.push(c);
+        }
+        return { survivors, pruned };
+    }
+    async applyTo(dir, c) {
+        if (c.kind === 'edit' && c.file) {
+            const fp = path.join(dir, c.file);
+            await fs.mkdir(path.dirname(fp), { recursive: true });
+            await fs.writeFile(fp, c.content ?? '', 'utf8');
+            return;
+        }
+        if (c.kind === 'command' && c.command) {
+            await sh(c.command, dir);
+        }
+    }
+    /** 2단계: 워크스페이스 복사본에 후보 적용 후 오라클(테스트) 실행 → 통과 여부. */
+    async simulateAndVerify(c) {
+        const scratch = await fs.mkdtemp(path.join(os.tmpdir(), 'n2w-sim-'));
+        try {
+            await fs.cp(this.workspaceDir, scratch, { recursive: true });
+            await this.applyTo(scratch, c);
+            const r = await sh(this.testCommand, scratch, this.oracleTimeoutMs);
+            return r.code === 0; // 오라클 통과 = 보상 1
+        }
+        finally {
+            await fs.rm(scratch, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }); // Windows EBUSY(자식 프로세스 핸들) 재시도
+        }
+    }
+    /**
+     * 적응 게이팅 캘리브레이션 — 대표 후보 1개로 **오라클 단가**와 (워밍업 제외) **후보당 필터 단가**를
+     *  실측해 `ratio = oracleMs/filterMs` 를 캐시한다. `run({ gfast:'auto' })` 가 이 ratio 로 g_fast/baseline 을
+     *  자동 선택(§4g 크로스오버 임계 θ). 정직: 필터 단가는 amortize 후(2번째 필터) 후보당 비용을 반영한다.
+     *  편집·컴파일판정불가 표본이면 필터 측정 불가 → ratio 미설정(auto 는 보수적으로 baseline).
+     */
+    async calibrate(sample, opts = {}) {
+        const t0 = Date.now();
+        await this.simulateAndVerify(sample); // 오라클 1회(결과 무시, 단가만 측정)
+        const oracleMs = Date.now() - t0;
+        let filterMs;
+        const a = (0, symbolic_dynamics_1.candidateToEditAction)(sample);
+        if (a.kind === 'edit' && a.file && (0, symbolic_dynamics_1.isCompilerDecidableFile)(a.file) && typeof a.content === 'string') {
+            const checker = opts.sharedChecker ?? new symbolic_dynamics_1.WarmTypeChecker();
+            await checker.seedDirOnce(this.workspaceDir);
+            const fileName = path.join(this.workspaceDir, a.file);
+            checker.addedErrorsForEdit(fileName, a.content); // 워밍업(첫 필터 = 프로그램 빌드)
+            const tf = Date.now();
+            checker.addedErrorsForEdit(fileName, a.content); // 후보당 순 필터(2번째, amortize 후)
+            filterMs = Date.now() - tf;
+        }
+        const ratio = filterMs != null ? oracleMs / Math.max(filterMs, 1) : undefined;
+        this.costEstimate = ratio != null ? { oracleMs, filterMs: filterMs, ratio } : undefined;
+        return { oracleMs, filterMs, ratio };
+    }
+    /** 현재 워크스페이스에서 테스트(오라클)가 통과하는지. */
+    async oraclePasses() {
+        const r = await sh(this.testCommand, this.workspaceDir, this.oracleTimeoutMs);
+        return r.code === 0;
+    }
+    /**
+     * 오라클 "부분 점수"∈[0,1]: 테스트 출력의 `SCORE:x/y` 를 파싱(멀티파일 부분 진척용).
+     * 없으면 종료 코드로 1.0/0.0. 멀티스텝 탐색의 가치 신호.
+     */
+    async oracleScore(dir = this.workspaceDir) {
+        const r = await sh(this.testCommand, dir, this.oracleTimeoutMs);
+        const m = (r.stdout + r.stderr).match(/SCORE:\s*(\d+)\s*\/\s*(\d+)/);
+        if (m) {
+            const y = parseInt(m[2], 10);
+            return y > 0 ? Math.max(0, Math.min(1, parseInt(m[1], 10) / y)) : 0;
+        }
+        return r.code === 0 ? 1 : 0;
+    }
+    /** 후보를 복사본에 적용 후 오라클 부분 점수 측정(실제 워크스페이스 보존). */
+    async simulateScore(c) {
+        const scratch = await fs.mkdtemp(path.join(os.tmpdir(), 'n2w-msim-'));
+        try {
+            await fs.cp(this.workspaceDir, scratch, { recursive: true });
+            await this.applyTo(scratch, c);
+            return await this.oracleScore(scratch);
+        }
+        finally {
+            await fs.rm(scratch, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }); // Windows EBUSY(자식 프로세스 핸들) 재시도
+        }
+    }
+    /**
+     * g_fast 가치 추정(오라클 없이, 값싸게). 후보의 "유망도"∈[0,1] — 목표/오류 컨텍스트와의
+     * 텍스트 관련성 + 종류 편향. 정직: 이는 정답성이 아니라 우선순위 신호다(진실은 오라클이 판정).
+     */
+    gfastValue(c, context) {
+        const candText = `${c.description} ${c.content ?? ''} ${c.command ?? ''}`;
+        let relevance;
+        if (this.relevanceMode === 'embedding') {
+            // 해시 임베딩 코사인(연속 관련성). 실 의미 임베딩 아님(정직).
+            relevance = (0, text_embedding_1.embeddingRelevance)(candText, context);
+        }
+        else {
+            // 토큰 집합 겹침(기본).
+            const tok = (s) => new Set((s || '').toLowerCase().split(/[^a-z0-9가-힣]+/).filter((t) => t.length > 1));
+            const ctx = tok(context);
+            if (ctx.size === 0)
+                return c.kind === 'edit' ? 0.05 : 0;
+            let overlap = 0;
+            const cand = tok(candText);
+            for (const t of cand)
+                if (ctx.has(t))
+                    overlap++;
+            relevance = overlap / ctx.size;
+        }
+        const kindBias = c.kind === 'edit' ? 0.05 : 0; // 명령보다 편집을 약간 선호(안전)
+        return Math.min(1, relevance + kindBias);
+    }
+    /**
+     * G3 — g_fast 기호 경로 정렬: 컴파일러(ρ)로 후보를 사전 평가해
+     *  (a) **비컴파일 후보를 오라클 전에 제외**(건전: 컴파일 실패 ⟹ 그 후보 임포트 테스트 실패),
+     *  (b) 결정 불가(δ=0: 명령·비JS) 후보는 그대로 유지(오라클 위임),
+     *  (c) 생존 후보를 ρ 내림차순 → gfastValue 순으로 정렬.
+     * 비싼 테스트 오라클 대신 값싼 컴파일만 추가로 돈다.
+     */
+    async gfastRank(survivors, goal) {
+        const scored = [];
+        for (const c of survivors) {
+            const a = (0, symbolic_dynamics_1.candidateToEditAction)(c);
+            let m0 = { targetFile: a.file ?? '', astErrors: [], buildStatus: 'unknown' };
+            if (a.kind === 'edit' && a.file) {
+                try {
+                    m0 = await (0, symbolic_dynamics_1.recompileMeta)(this.workspaceDir, a.file);
+                }
+                catch { /* 미상 */ }
+            }
+            const e = await (0, symbolic_dynamics_1.gfastEvaluate)(this.workspaceDir, m0, a);
+            if (!e.decidable) {
+                scored.push({ c, decidable: false, compiles: true, rho: -Infinity });
+                continue;
+            }
+            const compiles = e.mNext?.buildStatus !== 'fail';
+            scored.push({ c, decidable: true, compiles, rho: e.rho ?? 0 });
+        }
+        // (a) 결정 가능 & 비컴파일 후보 제외(오라클 호출 절감, 건전).
+        const survivors2 = scored.filter((s) => !(s.decidable && !s.compiles));
+        // (c) 정렬: 결정 가능(ρ 높은) 먼저, 그다음 결정 불가(gfastValue), 동률은 gfastValue.
+        survivors2.sort((x, y) => {
+            if (x.decidable !== y.decidable)
+                return x.decidable ? -1 : 1;
+            if (x.decidable && y.decidable && x.rho !== y.rho)
+                return y.rho - x.rho;
+            return this.gfastValue(y.c, goal) - this.gfastValue(x.c, goal);
+        });
+        return survivors2.map((s) => s.c);
+    }
+    /**
+     * G3c — 웜(증분) g_fast 정렬: in-process TypeScript Language Service 로 후보 내용을
+     *  *증분* 타입체크(프로세스 spawn·scratch 복사·콜드 시작 없음). 첫 후보만 프로그램 빌드(웜업).
+     *  비컴파일 후보를 오라클 전에 제외하고 ρ 로 정렬. 필터 비용을 콜드 tsc 대비 크게 낮춘다.
+     */
+    gfastRankWarm(survivors, goal, shared) {
+        const checker = shared ?? new symbolic_dynamics_1.WarmTypeChecker(); // 재사용 시 프로그램 빌드(웜업) amortize
+        const scored = [];
+        for (const c of survivors) {
+            const a = (0, symbolic_dynamics_1.candidateToEditAction)(c);
+            if (a.kind === 'edit' && a.file && (0, symbolic_dynamics_1.isCompilerDecidableFile)(a.file) && typeof a.content === 'string') {
+                const fileName = path.join(this.workspaceDir, a.file);
+                const m0 = { targetFile: fileName, astErrors: [], buildStatus: 'unknown' };
+                const mNext = (0, symbolic_dynamics_1.recompileMetaWarm)(checker, fileName, a.content);
+                scored.push({ c, decidable: true, compiles: mNext.buildStatus !== 'fail', rho: (0, symbolic_dynamics_1.ruleReward)(m0, mNext) });
+            }
+            else {
+                scored.push({ c, decidable: false, compiles: true, rho: -Infinity });
+            }
+        }
+        const survivors2 = scored.filter((s) => !(s.decidable && !s.compiles)); // 비컴파일 제외(건전)
+        survivors2.sort((x, y) => {
+            if (x.decidable !== y.decidable)
+                return x.decidable ? -1 : 1;
+            if (x.decidable && y.decidable && x.rho !== y.rho)
+                return y.rho - x.rho;
+            return this.gfastValue(y.c, goal) - this.gfastValue(x.c, goal);
+        });
+        return survivors2.map((s) => s.c);
+    }
+    /**
+     * G3d — 프로젝트-시드(교차파일) 웜 정렬. 워크스페이스 전체를 한 번 시드한 뒤, 각 후보 편집이
+     *  *프로젝트에 새 타입오차를 도입하는지*(import한 다른 파일을 깨는 경우 포함) 증분 검사해 제외.
+     *  단일 파일 격리 체크(G3c)가 못 잡는 교차파일 오류를 잡는다. spawn 없음(in-process).
+     */
+    async gfastRankProject(survivors, goal, shared) {
+        const checker = shared ?? new symbolic_dynamics_1.WarmTypeChecker(); // 재사용 시 시드+빌드(웜업) amortize
+        await checker.seedDirOnce(this.workspaceDir); // 프로젝트 전체 시드(세션 1회; 재사용 checker면 최초만)
+        const scored = [];
+        for (const c of survivors) {
+            const a = (0, symbolic_dynamics_1.candidateToEditAction)(c);
+            if (a.kind === 'edit' && a.file && (0, symbolic_dynamics_1.isCompilerDecidableFile)(a.file) && typeof a.content === 'string') {
+                const fileName = path.join(this.workspaceDir, a.file);
+                const added = checker.addedErrorsForEdit(fileName, a.content); // 교차파일 포함 새 오차
+                const m0 = { targetFile: fileName, astErrors: [], buildStatus: 'unknown' };
+                const mNext = { targetFile: fileName, astErrors: added, buildStatus: added.length ? 'fail' : 'pass' };
+                scored.push({ c, decidable: true, compiles: added.length === 0, rho: (0, symbolic_dynamics_1.ruleReward)(m0, mNext) });
+            }
+            else {
+                scored.push({ c, decidable: false, compiles: true, rho: -Infinity });
+            }
+        }
+        const survivors2 = scored.filter((s) => !(s.decidable && !s.compiles)); // 프로젝트를 깨는 후보 제외
+        survivors2.sort((x, y) => {
+            if (x.decidable !== y.decidable)
+                return x.decidable ? -1 : 1;
+            if (x.decidable && y.decidable && x.rho !== y.rho)
+                return y.rho - x.rho;
+            return this.gfastValue(y.c, goal) - this.gfastValue(x.c, goal);
+        });
+        return survivors2.map((s) => s.c);
+    }
+    /**
+     * 예측 실행: 가지치기 → (가치순 정렬) → 복사본 오라클 검증을 유망 순서로 → 검증된 첫 수 커밋.
+     * 7-0b 게이팅: 값싼 g_fast로 순서를 정하고 비싼 오라클은 유망 순서로 호출, 첫 통과 시 조기 종료.
+     * opts.rank=false 면 랭킹 없이(원래 순서) 비교 측정 가능.
+     */
+    async run(candidates, opts = {}) {
+        const ranked = opts.rank !== false;
+        // 대책1(적응 게이팅): gfast:'auto' → 캘리브레이션된 비용비 ratio≥θ 일 때만 g_fast(project+shared), 아니면 baseline.
+        //   추정 없으면 보수적으로 baseline(회귀 0 우선). auto 는 항상 프로젝트(교차파일·최강) 경로를 쓴다.
+        const auto = opts.gfast === 'auto';
+        const autoGate = auto && (this.costEstimate?.ratio ?? 0) >= this.autoThreshold;
+        // G3: g_fast 기호 경로 opt-in. 기본 OFF(N2WORLD_GFAST=1 또는 opts.gfast=true 시 ON) → 회귀 0.
+        const gfastOn = autoGate || opts.gfast === true || opts.gfastWarm === true || opts.gfastProject === true || /^(1|true|on)$/i.test(process.env.N2WORLD_GFAST || '');
+        // G3c: 웜(증분) 타입체크 필터 — 콜드 tsc spawn 대신 in-process Language Service.
+        const warm = opts.gfastWarm === true || /^(1|true|on)$/i.test(process.env.N2WORLD_GFAST_WARM || '');
+        // G3d: 프로젝트-시드(교차파일) 웜 필터. auto 게이트가 켜지면 프로젝트 경로 강제.
+        const project = autoGate || opts.gfastProject === true || /^(1|true|on)$/i.test(process.env.N2WORLD_GFAST_PROJECT || '');
+        const { survivors, pruned } = await this.prune(candidates);
+        let ordered = survivors;
+        if (gfastOn) {
+            // g_fast: 프로젝트 웜(교차파일) > 단일파일 웜 > 콜드 tsc 순 우선.
+            ordered = project ? await this.gfastRankProject(survivors, opts.goal ?? '', opts.sharedChecker)
+                : warm ? this.gfastRankWarm(survivors, opts.goal ?? '', opts.sharedChecker)
+                    : await this.gfastRank(survivors, opts.goal ?? '');
+        }
+        else if (ranked) {
+            const context = opts.goal ?? '';
+            ordered = survivors
+                .map((c) => ({ c, v: this.gfastValue(c, context) }))
+                .sort((a, b) => b.v - a.v) // 가치 높은 후보 먼저
+                .map((s) => s.c);
+        }
+        const simulated = [];
+        let verified = null;
+        let oracleCalls = 0;
+        for (const c of ordered) {
+            oracleCalls++; // 비싼 2단계(오라클) 1회
+            const pass = await this.simulateAndVerify(c);
+            simulated.push({ id: c.id, oraclePass: pass });
+            if (pass) {
+                verified = c;
+                break;
+            } // 검증된 첫 수 → 조기 종료(나머지 오라클 호출 생략)
+        }
+        const order = ordered.map((c) => c.id);
+        if (verified) {
+            await this.applyTo(this.workspaceDir, verified);
+            // C4: 커밋을 sharedChecker 에 동기화 → 같은 워크스페이스 다라운드서 checker↔디스크 정합(stale 오판 방지).
+            //   edit 만(command 는 파일 변경 추적 불가). 증분(setFile) 이라 재빌드 amortize 유지.
+            if (opts.sharedChecker && verified.kind === 'edit' && verified.file && typeof verified.content === 'string') {
+                opts.sharedChecker.setFile(path.join(this.workspaceDir, verified.file), verified.content);
+            }
+            return { success: true, committed: verified, pruned, simulated, oracleCalls, order, ranked, gfastApplied: gfastOn };
+        }
+        return { success: false, committed: null, pruned, simulated, oracleCalls, order, ranked, gfastApplied: gfastOn };
+    }
+    /**
+     * 멀티스텝 예측 실행(멀티파일·다단계). 한 단계가 다른 단계의 실패를 드러내는 SWE형 과제용.
+     * 트리 탐색(베스트퍼스트): g_fast=사전확률로 후보를 정렬하고, 오라클 부분점수=가치로 평가해
+     * 점수를 가장 크게 올리는 "검증된 편집"만 커밋하며 모든 테스트 통과까지 진행한다.
+     * (정직: 풀 확률적 MCTS 롤아웃이 아니라 g_fast 사전확률+오라클 가치의 베스트퍼스트 트리 탐색.)
+     */
+    async solveMultiStep(generate, goal, opts = {}) {
+        const maxSteps = opts.maxSteps ?? 8;
+        const steps = [];
+        const prunedAll = [];
+        let oracleCalls = 0;
+        let current = await this.oracleScore();
+        for (let step = 0; step < maxSteps && current < 1; step++) {
+            const ctx = await sh(this.testCommand, this.workspaceDir, this.oracleTimeoutMs);
+            const candidates = await generate(this.workspaceDir, goal, ctx.stdout + ctx.stderr);
+            const { survivors, pruned } = await this.prune(candidates);
+            prunedAll.push(...pruned);
+            // g_fast 사전확률로 후보 순서 결정(유망 순서 먼저 검증 → 비싼 오라클 절감).
+            const ranked = survivors
+                .map((c) => ({ c, v: this.gfastValue(c, goal) }))
+                .sort((a, b) => b.v - a.v)
+                .map((s) => s.c);
+            // 각 후보를 복사본에서 오라클 부분점수로 평가. 가장 크게 개선하는 검증된 편집을 채택.
+            let best = null;
+            let bestScore = current;
+            for (const c of ranked) {
+                oracleCalls++;
+                const score = await this.simulateScore(c);
+                if (score > bestScore) {
+                    best = c;
+                    bestScore = score;
+                    if (score >= 1)
+                        break;
+                } // 만점이면 조기 종료
+            }
+            if (!best)
+                break; // 개선 후보 없음 → 정직하게 중단(거짓 커밋 없음)
+            await this.applyTo(this.workspaceDir, best); // 검증된 개선 편집만 실제 워크스페이스에 커밋
+            steps.push({ committed: best.id, scoreBefore: +current.toFixed(3), scoreAfter: +bestScore.toFixed(3) });
+            current = bestScore;
+        }
+        return { success: current >= 1, finalScore: +current.toFixed(3), steps, pruned: prunedAll, oracleCalls };
+    }
+}
+exports.PredictiveAgent = PredictiveAgent;
+// ---- LLM 후보 생성기 (생산 경로) — I/O와 파싱을 분리해 파싱은 순수·테스트 가능 ----
+/** LLM 출력에서 균형 잡힌 첫 JSON 객체/배열 substring 추출(코드펜스·잡설 견딤). */
+function extractJson(text) {
+    const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const body = fence ? fence[1] : text;
+    const start = body.search(/[\[{]/);
+    if (start < 0)
+        return null;
+    const open = body[start];
+    const close = open === '{' ? '}' : ']';
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    for (let i = start; i < body.length; i++) {
+        const ch = body[i];
+        if (inStr) {
+            if (esc)
+                esc = false;
+            else if (ch === '\\')
+                esc = true;
+            else if (ch === '"')
+                inStr = false;
+            continue;
+        }
+        if (ch === '"')
+            inStr = true;
+        else if (ch === open)
+            depth++;
+        else if (ch === close) {
+            depth--;
+            if (depth === 0)
+                return body.slice(start, i + 1);
+        }
+    }
+    return null;
+}
+/**
+ * LLM 출력 → 구조화 후보. 잡설/코드펜스를 견디고, 유효하지 않은 항목은 버린다(정직).
+ * 형식: {"candidates":[{id,description,kind,file,content|command}]} 또는 후보 배열.
+ */
+function parseCandidates(llmOutput, defaultFile) {
+    const json = extractJson(llmOutput);
+    if (!json)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        return [];
+    }
+    const arr = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.candidates) ? parsed.candidates : [];
+    const out = [];
+    for (let i = 0; i < arr.length; i++) {
+        const c = arr[i];
+        if (!c || typeof c !== 'object')
+            continue;
+        const kind = c.kind === 'command' ? 'command' : c.kind === 'edit' ? 'edit' : null;
+        if (!kind)
+            continue;
+        const id = typeof c.id === 'string' && c.id ? c.id : `cand${i}`;
+        if (kind === 'edit') {
+            const file = (typeof c.file === 'string' && c.file) ? c.file : defaultFile;
+            if (!file || typeof c.content !== 'string')
+                continue;
+            out.push({ id, description: String(c.description ?? ''), kind, file, content: c.content });
+        }
+        else {
+            if (typeof c.command !== 'string' || !c.command)
+                continue;
+            out.push({ id, description: String(c.description ?? ''), kind, command: c.command });
+        }
+    }
+    return out;
+}
+function buildCandidatePrompt(goal, targetFile, fileContent, testOutput, n) {
+    return [
+        `목표: ${goal}`,
+        `수정 대상 파일: ${targetFile}`,
+        `현재 파일 내용:\n\`\`\`\n${fileContent}\n\`\`\``,
+        `실패한 테스트 출력:\n\`\`\`\n${testOutput.slice(0, 2000)}\n\`\`\``,
+        `위 목표를 달성할 서로 다른 수정 후보 ${n}개를 제안하라.`,
+        `반드시 아래 JSON만 출력(설명 금지). content 는 파일 전체 내용:`,
+        `{"candidates":[{"id":"fix1","description":"...","kind":"edit","file":"${targetFile}","content":"<파일 전체 내용>"}]}`,
+    ].join('\n\n');
+}
+/**
+ * LLM 기반 후보 생성기(생산 경로). 파일·테스트출력을 모아 프롬프트를 만들고 LLM 호출 후 파싱.
+ * `complete` 주입으로 LLM 없이도(모의) 전체 경로를 결정적으로 검증할 수 있다.
+ */
+function makeLlmCandidateGenerator(opts) {
+    const complete = opts.complete ?? llm_1.llmComplete;
+    const n = opts.numCandidates ?? 3;
+    return async (workspaceDir, goal) => {
+        let fileContent = '';
+        try {
+            fileContent = await fs.readFile(path.join(workspaceDir, opts.targetFile), 'utf8');
+        }
+        catch { /* 새 파일 */ }
+        const testOut = await sh(opts.testCommand, workspaceDir);
+        const prompt = buildCandidatePrompt(goal, opts.targetFile, fileContent, testOut.stdout + testOut.stderr, n);
+        let raw = '';
+        try {
+            raw = await complete(prompt);
+        }
+        catch {
+            return [];
+        } // 키 없음/오류 → 빈 후보(정직)
+        return parseCandidates(raw, opts.targetFile);
+    };
+}
+/**
+ * Stage A 오케스트레이션: 후보 생성 → 예측 실행(가지치기→검증→검증된 첫 수 커밋).
+ * 후보 생성기를 주입받으므로 LLM/결정적 어느 쪽이든 동일 경로를 탄다.
+ */
+async function runPredictiveTask(workspaceDir, goal, testCommand, generate, dangerousPatterns) {
+    const candidates = await generate(workspaceDir, goal);
+    const agent = new PredictiveAgent(workspaceDir, testCommand, dangerousPatterns);
+    return agent.run(candidates);
+}

package/dist/prompt-optimizer.d.ts

@@ -0,0 +1,18 @@
+export interface PromptCandidate {
+    prompt: string;
+    score: number;
+}
+export declare class PromptOptimizer {
+    private candidates;
+    constructor(initialPrompt: string);
+    getCandidates(): PromptCandidate[];
+    mutate(prompt: string): string;
+    optimize(evaluator: (prompt: string) => Promise<number>, generations?: number, populationSize?: number): Promise<PromptCandidate>;
+}
+export declare class LlmInTheLoopPromptOptimizer {
+    private candidates;
+    constructor(initialPrompt: string);
+    getCandidates(): PromptCandidate[];
+    mutateWithFeedback(prompt: string, log: string): string;
+    optimize(evaluator: (prompt: string) => Promise<number>, executionLogs: string[], generations?: number, populationSize?: number): Promise<PromptCandidate>;
+}

package/dist/prompt-optimizer.js

@@ -0,0 +1,104 @@
+"use strict";
+// ============================================================================
+// 프롬프트 최적화 — 정직 고지(제1계명)
+// ----------------------------------------------------------------------------
+// 이것은 **DSPy/GEPA가 아니다.** 하드코딩된 변형 규칙(문자열 추가/치환)으로 후보를 만들고
+// evaluator로 점수를 매겨 상위를 고르는 **간단한 휴리스틱 진화(hill-climbing) 최적화**다.
+// 설계 문서가 언급한 "DSPy/GEPA 연동"은 미구현이며, 본 모듈을 DSPy라고 표기하지 않는다.
+// 실제 동작(변형→평가→선택)은 진짜이며 테스트로 검증된다.
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlmInTheLoopPromptOptimizer = exports.PromptOptimizer = void 0;
+class PromptOptimizer {
+    candidates = [];
+    constructor(initialPrompt) {
+        this.candidates.push({ prompt: initialPrompt, score: 0 });
+    }
+    getCandidates() {
+        return this.candidates;
+    }
+    mutate(prompt) {
+        const mutations = [
+            (p) => p + "\nConstraint: Be extremely precise and output only valid JSON.",
+            (p) => p + "\nInstruction: Do not write hardcoded mock return statements.",
+            (p) => p.replace(/extremely/g, 'ultraly'),
+            (p) => p + "\nNote: Focus on performance and maintainability.",
+            (p) => p.replace(/\s+/g, ' ')
+        ];
+        const randomMutation = mutations[Math.floor(Math.random() * mutations.length)];
+        return randomMutation(prompt);
+    }
+    async optimize(evaluator, generations = 3, populationSize = 4) {
+        for (let gen = 0; gen < generations; gen++) {
+            const newCandidates = [];
+            this.candidates.sort((a, b) => b.score - a.score);
+            const parents = this.candidates.slice(0, Math.max(1, Math.floor(populationSize / 2)));
+            for (const parent of parents) {
+                if (newCandidates.length < populationSize) {
+                    newCandidates.push(parent);
+                }
+                while (newCandidates.length < populationSize) {
+                    const mutatedText = this.mutate(parent.prompt);
+                    newCandidates.push({ prompt: mutatedText, score: 0 });
+                }
+            }
+            for (const candidate of newCandidates) {
+                if (candidate.score === 0) {
+                    candidate.score = await evaluator(candidate.prompt);
+                }
+            }
+            this.candidates = newCandidates;
+        }
+        this.candidates.sort((a, b) => b.score - a.score);
+        return this.candidates[0];
+    }
+}
+exports.PromptOptimizer = PromptOptimizer;
+class LlmInTheLoopPromptOptimizer {
+    candidates = [];
+    constructor(initialPrompt) {
+        this.candidates.push({ prompt: initialPrompt, score: 0 });
+    }
+    getCandidates() {
+        return this.candidates;
+    }
+    mutateWithFeedback(prompt, log) {
+        let feedback = '';
+        if (log.toLowerCase().includes('json')) {
+            feedback = '\n[LLM Feedback] Ensure output is strict valid JSON structure, matching the schema exactly.';
+        }
+        else if (log.toLowerCase().includes('cheat') || log.toLowerCase().includes('hardcoded')) {
+            feedback = '\n[LLM Feedback] Do not output hardcoded conditional check outputs; execute actual logic.';
+        }
+        else {
+            feedback = `\n[LLM Feedback] Address log error: "${log}" by increasing robustness constraints.`;
+        }
+        return prompt + feedback;
+    }
+    async optimize(evaluator, executionLogs, generations = 3, populationSize = 4) {
+        for (let gen = 0; gen < generations; gen++) {
+            const newCandidates = [];
+            this.candidates.sort((a, b) => b.score - a.score);
+            const parents = this.candidates.slice(0, Math.max(1, Math.floor(populationSize / 2)));
+            for (const parent of parents) {
+                if (newCandidates.length < populationSize) {
+                    newCandidates.push(parent);
+                }
+                while (newCandidates.length < populationSize) {
+                    const log = executionLogs[Math.floor(Math.random() * executionLogs.length)] || '';
+                    const mutatedText = this.mutateWithFeedback(parent.prompt, log);
+                    newCandidates.push({ prompt: mutatedText, score: 0 });
+                }
+            }
+            for (const candidate of newCandidates) {
+                if (candidate.score === 0) {
+                    candidate.score = await evaluator(candidate.prompt);
+                }
+            }
+            this.candidates = newCandidates;
+        }
+        this.candidates.sort((a, b) => b.score - a.score);
+        return this.candidates[0];
+    }
+}
+exports.LlmInTheLoopPromptOptimizer = LlmInTheLoopPromptOptimizer;