@mingyuxu/check 0.1.0

package/dist/planner.js

@@ -0,0 +1,785 @@
+/**
+ * VerificationAgent —— typed domain capabilities + 旧相位兼容宿主。
+ * Commander 只见 Ontology/Method/CheckSkill 领域函数；legacy phase 仅供旧 API/冻结适配。
+ * LLM 异步：runPhase 直接 await builder；ToolRegistry 只放同步展示/推进/知识工具。
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, cpSync, copyFileSync } from "node:fs";
+import { join, basename } from "node:path";
+import { Session, ToolRegistry, Sandbox, spawnSubagent, waitSubagent, reconcile, } from "@mingyuxu/core";
+import { Ledger } from "@mingyuxu/ai";
+import { Target, PipelineSpec, DocumentIR } from "./schemas/index.js";
+import { ScenarioBuilder, defaultSchemaProfile } from "./scenario-builder.js";
+import { loadPack } from "./knowledge/loader.js";
+import { proposeKnowledgeDelta } from "./knowledge/write.js";
+import { Knowledge } from "./knowledge/retrieval.js";
+import { basePackContext } from "./project.js";
+import { reviseFromReport } from "./forge/reflect.js";
+import { fileURLToPath } from "node:url";
+import { loadOntology } from "./ontology/loader.js";
+import { loadMethods, methodRef, selectMethod } from "./methods/loader.js";
+import { inferRuleKind, instantiateDomain, targetDigest } from "./domain/registers.js";
+import { clearStale, isStale, loadStale, markChanged } from "./domain/invalidation.js";
+import { ScenarioOntologyStore } from "./ontology/store.js";
+import { createVerificationActionRegistry } from "./domain/actions.js";
+const WHITELIST = new Set([
+    "read_rules", "read_samples", "analyze_rules", "observe_samples", "propose_specs",
+    "write_pack", "bakeoff", "load_targets", "write_asset", "revise_targets",
+    "show_targets", "show_specs", "show_report", "advance_phase", "propose_knowledge_delta",
+]);
+export class VerificationAgent {
+    workspace;
+    root;
+    policy;
+    llm;
+    ledger;
+    builder;
+    tools;
+    curSession = null;
+    constructor(opts) {
+        this.workspace = opts.workspace;
+        this.root = opts.root ?? opts.workspace;
+        this.policy = opts.policy;
+        this.llm = opts.llm;
+        this.ledger = opts.ledger ?? new Ledger();
+        this.builder = new ScenarioBuilder(opts.llm, this.root);
+        this.tools = new ToolRegistry(WHITELIST, { now: () => this.now() });
+        this.tools.register("load_targets", (a) => this.loadTargets(a.session));
+        this.tools.register("write_asset", (a) => this.writeAsset(a.session, a.rel, a.data));
+        this.tools.register("show_targets", (a) => this.showTargets(a.session));
+        this.tools.register("show_specs", (a) => this.showSpecs(a.session));
+        this.tools.register("show_report", (a) => this.showReport(a.session));
+        this.tools.register("advance_phase", (a) => { throw new Error("advance_phase 走 orchestrator advance 动作"); });
+        this.tools.register("propose_knowledge_delta", (a) => this.proposeKnowledge(a));
+        this.tools.register("revise_targets", (a) => this.confirmTargets(a.session, { drop: a.drop, feedback: a.feedback }));
+    }
+    _lastNow = 0;
+    // ①b 需求确认：drop 按展示编号删除（确定性），feedback 走 LLM 修订。返回人读摘要。
+    async confirmTargets(session, o) {
+        let targets = this.loadTargets(session);
+        if (o.drop?.length) {
+            const kept = targets.filter((_, i) => !o.drop.includes(i + 1));
+            if (!kept.length)
+                return "不能删光所有目标——至少保留一个，或用调整要求重写。";
+            targets = kept;
+            session.event(this.workspace, "targets_dropped", { dropped: o.drop, remain: targets.length }, this.now());
+        }
+        if (o.feedback) {
+            targets = await this.builder.reviseTargets(targets, o.feedback, session.taskType);
+            session.event(this.workspace, "targets_revised", { feedback: o.feedback, count: targets.length }, this.now());
+        }
+        this.writeTargets(session, targets);
+        markChanged(session.home(this.workspace), "rule_model", "用户修订了核查目标或规则映射", this.now());
+        session.event(this.workspace, "assets_invalidated", { source: "rule_model", reason: "targets revised" }, this.now());
+        return `已修订为 ${targets.length} 个目标：\n` + this.showTargets(session).split("\n").slice(1).join("\n");
+    }
+    now() {
+        this._lastNow = Math.max(Date.now() / 1000, this._lastNow + 1e-4);
+        return this._lastNow;
+    }
+    ledgerSummary() { return { ...this.ledger.summary() }; }
+    // ---- Commander 自主循环能力面 -----------------------------------------
+    // 能力是领域原语，不是控制流。Commander 每轮看盘上状态后自行选择、执行、再观察。
+    capabilities(session) {
+        const state = this.stateSnapshot(session);
+        const reflections = Number(state.reflections ?? 0);
+        const maxReflect = Number(this.policy.loop?.max_reflect_iterations ?? 3);
+        const evalMet = state.evaluation?.met;
+        const lastCapability = String(state.last_capability ?? "");
+        const recommended = !state.rule_clauses ? "extract_rule_clauses"
+            : !state.observations ? "observe_examples"
+                : !state.checkskills?.current ? "synthesize_checkskills"
+                    : !state.workflow ? "compose_workflow"
+                        : !state.report || lastCapability === "diagnose_attempt" ? "evaluate_attempt"
+                            : evalMet === false && reflections < maxReflect ? "diagnose_attempt"
+                                : "";
+        return [
+            { name: "extract_rule_clauses", description: "extractRules(Regulation) → RuleClause[] + VerificationTarget[]", ready: true, recommended: recommended === "extract_rule_clauses" },
+            { name: "observe_examples", description: "从样本文档观察真实章节与取证锚点，可在合成前后重跑", ready: state.targets, reason: state.targets ? "已有目标对象" : "需要 RuleClause/Target", recommended: recommended === "observe_examples" },
+            { name: "synthesize_checkskills", description: "按 rule_kind 选择 Method，执行 synthesizeSkill(Target) → CheckSkill", ready: state.rule_clauses, reason: state.rule_clauses ? "RuleClause 已实例化" : "需要先提取 RuleClause", recommended: recommended === "synthesize_checkskills" },
+            { name: "compose_workflow", description: "composeWorkflow(CheckSkill[]) → 候选 Workflow，并保留技能绑定", ready: Boolean(state.checkskills?.current), reason: state.checkskills?.current ? "CheckSkill 与当前目标一致" : "需先合成最新 CheckSkill", recommended: recommended === "compose_workflow" },
+            { name: "evaluate_attempt", description: "在独立 judge 中评测当前 attempt，写 trace/grounding/场景快照", ready: Boolean(state.checkskills?.current && state.workflow), reason: state.workflow ? "Workflow 已装配" : "需要 CheckSkill 与 Workflow", recommended: recommended === "evaluate_attempt" },
+            { name: "diagnose_attempt", description: "读取失败 attempt/trace，判断修改 CheckSkill 还是升级 Method", ready: Boolean(state.report && evalMet === false && reflections < maxReflect), reason: evalMet === false ? `评测未达标，可诊断 ${maxReflect - reflections} 轮` : "仅在失败 attempt 后可用", recommended: recommended === "diagnose_attempt" },
+        ];
+    }
+    async executeCapability(session, name) {
+        return await createVerificationActionRegistry(this, session).execute(name, {}, { agent: this, session });
+    }
+    /** 仅供 DomainActionRegistry 的受控 handler 调用；外部必须走 executeCapability。 */
+    async executeCapabilityUnchecked(session, name) {
+        if (name === "extract_rule_clauses")
+            return this.runNamedBuildCapability(session, "analyze", "已实例化 Regulation、RuleClause 与 VerificationTarget");
+        if (name === "observe_examples")
+            return this.runNamedBuildCapability(session, "observe", "已从样本观察取证锚点；旧 CheckSkill 如有将自动标为 stale");
+        if (name === "synthesize_checkskills") {
+            await this.synthesizeCheckSkills(session);
+            session.phase = this.deriveLifecycle(session);
+            session.save(this.workspace, this.now());
+            return { observation: "已按 rule_kind 选择 Method 并合成带完整血缘的 CheckSkill", changed: true };
+        }
+        if (name === "compose_workflow")
+            return this.runNamedBuildCapability(session, "propose", "已由当前 CheckSkill 集合装配候选 Workflow");
+        if (name === "evaluate_attempt") {
+            session.phase = "test";
+            const ev = await this.selfEvaluate(session);
+            session.event(this.workspace, "commander_self_eval", { met: ev.met, summary: ev.summary }, this.now());
+            if (ev.met === true || ev.met === null)
+                session.phase = "freeze";
+            session.save(this.workspace, this.now());
+            return { observation: ev.summary, changed: true };
+        }
+        if (name === "diagnose_attempt") {
+            session.phase = "test";
+            const rr = await this.reflect(session);
+            if (rr.revised)
+                markChanged(session.home(this.workspace), "rule_model", "失败归因后修订了目标", this.now());
+            session.event(this.workspace, "commander_reflect", { revised: rr.revised, note: rr.note }, this.now());
+            session.save(this.workspace, this.now());
+            return { observation: rr.revised ? `已按 trace 归因修订目标级 CheckSkill 输入：${rr.note}；需重新合成后再评测` : `诊断未找到目标级修订项：${rr.note}；应考虑升级对应 Method`, changed: rr.revised };
+        }
+        throw new Error(`未注册构建能力 ${name}`);
+    }
+    stateSnapshot(session) {
+        const home = session.home(this.workspace);
+        const has = (rel) => existsSync(join(home, rel));
+        const report = has("build/test_report.json") ? this.readTestReport(session) : null;
+        const planPath = join(home, ".session", "agent-plan.json");
+        let plan = null;
+        try {
+            if (existsSync(planPath))
+                plan = JSON.parse(readFileSync(planPath, "utf-8"));
+        }
+        catch { /* ignore malformed observability file */ }
+        const capabilitySteps = (plan?.steps ?? []).filter((s) => s.status === "done" && s.action?.op === "capability");
+        const lastCapability = capabilitySteps.at(-1)?.action?.capability ?? "";
+        const met = report ? this.meetsStandard(report) : undefined;
+        const stale = loadStale(home).entries;
+        let skillIndex = null;
+        try {
+            if (has("build/checkskills/index.json"))
+                skillIndex = JSON.parse(readFileSync(join(home, "build", "checkskills", "index.json"), "utf-8"));
+        }
+        catch { /* malformed = stale */ }
+        let currentDigest = "";
+        try {
+            if (has("build/targets.json"))
+                currentDigest = targetDigest(this.loadTargets(session));
+        }
+        catch { /* incomplete target set */ }
+        const attempts = existsSync(join(home, "build")) ? readdirSync(join(home, "build")).filter((n) => /^attempt-\d+$/.test(n)).sort() : [];
+        return {
+            lifecycle: session.phase,
+            ontology_version: (() => { try {
+                return loadOntology(this.root).version;
+            }
+            catch {
+                return "";
+            } })(),
+            targets: has("build/targets.json"),
+            rule_clauses: has("build/rule_clauses.json"),
+            observations: has("build/observations.json"),
+            checkskills: skillIndex ? { count: Number(skillIndex.count ?? 0), current: skillIndex.target_digest === currentDigest && !stale.checkskills, target_digest: currentDigest, methods: skillIndex.methods ?? [], stale: stale.checkskills ?? null } : null,
+            workflow: has("build/specs.json") && has("build/proposals.json") && has("build/workflow_manifest.json") && !stale.workflow,
+            specs: has("build/specs.json") && has("build/proposals.json"),
+            report: Boolean(report) && !stale.evaluation,
+            evaluation: report ? { met, oracle: Boolean(report.oracle), winner: report.winner ?? "", current: !stale.evaluation, stale: stale.evaluation ?? null } : null,
+            grounding: has("build/cross_check.json") ? JSON.parse(readFileSync(join(home, "build", "cross_check.json"), "utf-8")) : null,
+            reflections: capabilitySteps.filter((s) => s.action.capability === "diagnose_attempt").length,
+            last_capability: lastCapability,
+            attempts: { count: attempts.length, latest: attempts.at(-1) ?? "" },
+            traces: has("build/eval/history.jsonl") ? readFileSync(join(home, "build", "eval", "history.jsonl"), "utf-8").split("\n").filter(Boolean).length : 0,
+            budget: this.ledgerSummary(),
+            stale,
+        };
+    }
+    promotionState(session) {
+        if (session.phase === "frozen")
+            return { ready: false, reason: "生产线已经冻结" };
+        const home = session.home(this.workspace);
+        const stale = loadStale(home).entries;
+        // pack stale 表示“旧冻结包需要重编”，它本身不应阻止当前候选进入冻结门；
+        // 上游 checkskills/workflow/evaluation stale 才是晋升硬阻断。
+        const staleOrder = ["checkskills", "workflow", "evaluation"];
+        const firstStale = staleOrder.find((name) => stale[name]);
+        if (firstStale)
+            return { ready: false, reason: `${firstStale} 已失效：${stale[firstStale].reason}` };
+        if (!existsSync(join(home, "build", "targets.json")))
+            return { ready: false, reason: "缺 VerificationTarget" };
+        const digest = targetDigest(this.loadTargets(session));
+        if (!this.checkSkillsCurrent(session))
+            return { ready: false, reason: "CheckSkill 缺失或已 stale，需按 Method 重新合成" };
+        const wfPath = join(home, "build", "workflow_manifest.json");
+        if (!existsSync(wfPath))
+            return { ready: false, reason: "缺 Workflow manifest" };
+        const wf = JSON.parse(readFileSync(wfPath, "utf-8"));
+        if (wf.target_digest !== digest)
+            return { ready: false, reason: "Workflow 绑定的是旧 CheckSkill 集合，需重新 compose" };
+        const reportPath = join(home, "build", "test_report.json");
+        if (!existsSync(reportPath))
+            return { ready: false, reason: "缺测试报告" };
+        const attempts = readdirSync(join(home, "build")).filter((n) => /^attempt-\d+$/.test(n)).sort();
+        const latest = attempts.at(-1);
+        if (!latest)
+            return { ready: false, reason: "缺可复现 attempt 快照" };
+        const attempt = JSON.parse(readFileSync(join(home, "build", latest, "attempt.json"), "utf-8"));
+        if (attempt.target_digest !== digest)
+            return { ready: false, reason: "测试报告属于旧 target digest，必须重评当前资产" };
+        const report = this.readTestReport(session);
+        const met = this.meetsStandard(report);
+        if (met === false)
+            return { ready: false, reason: "自评未达到 policy 门槛，必须反思后重评" };
+        const ccPath = join(home, "build", "cross_check.json");
+        if (existsSync(ccPath)) {
+            const cc = JSON.parse(readFileSync(ccPath, "utf-8"));
+            if ((cc.grounding_flags ?? []).length)
+                return { ready: false, reason: "grounding 复验有未清零标记" };
+        }
+        const note = met === null ? "无 oracle，无法自动判达标，需人工评估" : "自评达标且 grounding 干净";
+        return { ready: true, reason: note, summary: `${note}\n${this.showReport(session)}\n批准冻结仍是人工专属动作。` };
+    }
+    async runNamedBuildCapability(session, phase, observation) {
+        session.phase = phase;
+        await this.runPhase(session);
+        const missing = reconcile(session.home(this.workspace), phase, session.artifacts[phase] ?? []);
+        if (missing.length)
+            throw new Error(`能力 ${phase} 声称完成但磁盘缺产物：${missing.join("、")}`);
+        session.phase = this.deriveLifecycle(session);
+        session.event(this.workspace, "commander_capability_completed", { capability: phase, next: session.phase }, this.now());
+        session.save(this.workspace, this.now());
+        return { observation, changed: true };
+    }
+    deriveLifecycle(session) {
+        const home = session.home(this.workspace);
+        if (!existsSync(join(home, "build", "targets.json")))
+            return "analyze";
+        if (!existsSync(join(home, "build", "observations.json")))
+            return "observe";
+        if (!existsSync(join(home, "build", "checkskills", "index.json")))
+            return "propose";
+        if (!(existsSync(join(home, "build", "specs.json")) && existsSync(join(home, "build", "workflow_manifest.json"))))
+            return "propose";
+        return "test";
+    }
+    // ---- 会话 --------------------------------------------------------------
+    start(o) {
+        const state = join(this.workspace, o.scenarioKey, ".session", "state.json");
+        if (existsSync(state))
+            throw new Error(`会话已存在：${state}`);
+        const s = new Session({
+            scenarioKey: o.scenarioKey, goal: o.goal, taskType: o.taskType ?? "predicate",
+            inputs: { rules: o.rules, samples: o.samples, oracle: o.oracle ?? "" },
+            createdAt: this.now(), lastProgressAt: this.now(),
+        });
+        s.save(this.workspace, this.now());
+        s.event(this.workspace, "session_started", { goal: o.goal }, this.now());
+        return s;
+    }
+    resume(scenarioKey) { return Session.load(this.workspace, scenarioKey); }
+    // ---- 旧相位调度（兼容 advanceOnePhase / freeze，不是 Commander 控制流）---
+    async runPhase(session) {
+        this.curSession = session;
+        const impl = {
+            analyze: () => this.analyze(session), observe: () => this.observe(session),
+            propose: () => this.propose(session), test: () => this.test(session), freeze: () => this.freeze(session),
+        };
+        await impl[session.phase]();
+        for (const line of this.builder.log)
+            session.event(this.workspace, "builder_log", { line }, this.now());
+        this.builder.log.length = 0;
+    }
+    // ---- 目标驱动循环能力（v2）：自评 + 反思 ------------------------------
+    // 自评：跑一次评测体系（bakeoff/grounding，test() 内含隔离判卷），读报告判是否达标。
+    async selfEvaluate(session) {
+        await this.test(session);
+        const rep = this.readTestReport(session);
+        const met = this.meetsStandard(rep);
+        const row = (rep.ranking ?? []).find((r) => r.candidate === rep.winner) ?? (rep.ranking ?? [])[0];
+        const acc = row?.accuracy;
+        const bar = Number(this.policy.eval?.accuracy_bar ?? 0.9);
+        const summary = rep.oracle ? `准确率 ${acc ?? "?"}（门槛 ${bar}）→ ${met ? "达标" : "未达标"}` : "无 oracle：评测体系无法自判达标，交人裁决";
+        return { met, summary };
+    }
+    // 反思：读评测体系的 per-target FN/FP 明细 → 逐目标归因 → 定向修改（漏报放宽取证 / 误报收紧+负向词）。
+    async reflect(session) {
+        const rep = this.readTestReport(session);
+        const wrep = rep.winner_report;
+        if (!wrep || !(wrep.mismatches ?? []).length) { // 无明细/无错判 → 无从定向改
+            session.event(this.workspace, "reflect_diagnose", { note: "无 winner 明细或无错判，改无可改" }, this.now());
+            return { revised: false, note: "无 winner 明细可归因" };
+        }
+        const oraclePath = session.inputs.oracle ?? "";
+        const oracle = oraclePath && existsSync(oraclePath) ? JSON.parse(readFileSync(oraclePath, "utf-8")) : undefined;
+        const targets = this.loadTargets(session);
+        const { revised, diagnoses } = reviseFromReport(targets, wrep, oracle);
+        if (revised)
+            this.writeTargets(session, targets);
+        this.writeAsset(session, "build/reflection.json", { diagnoses }); // 可观测：每目标归因+动作
+        for (const d of diagnoses)
+            session.event(this.workspace, "reflect_diagnose", { target: d.target_id, fn: d.fn, fp: d.fp, suspect: d.suspect, action: d.action }, this.now());
+        const note = diagnoses.map((d) => `${d.target_id}:${d.suspect}`).join("；") || "无定向修改";
+        return { revised, note };
+    }
+    meetsStandard(rep) {
+        if (!rep.oracle)
+            return null; // 无评测体系可判 → 交人
+        const row = (rep.ranking ?? []).find((r) => r.candidate === rep.winner) ?? (rep.ranking ?? [])[0];
+        const acc = row?.accuracy;
+        if (acc == null)
+            return null;
+        return Number(acc) >= Number(this.policy.eval?.accuracy_bar ?? 0.9);
+    }
+    readTestReport(session) {
+        const p = join(session.home(this.workspace), "build", "test_report.json");
+        return existsSync(p) ? JSON.parse(readFileSync(p, "utf-8")) : { oracle: false, ranking: [] };
+    }
+    async analyze(session) {
+        let rulesText = readFileSync(session.inputs.rules, "utf-8");
+        const base = basePackContext(this.root, Number(this.policy.context?.project_memory_cap_kb ?? 5));
+        if (base) { // 领域背景包：术语参考，不是规则本身
+            rulesText = `【领域背景参考——帮助理解术语，本身不是待拆解的规则】\n${base}\n\n【规则文本】\n${rulesText}`;
+            session.event(this.workspace, "base_packs_injected", { chars: base.length }, this.now());
+        }
+        const chunkChars = Number(this.policy.build?.rule_chunk_chars ?? 3000);
+        const targets = await this.builder.analyzeRules(rulesText, session.taskType, 8, chunkChars);
+        const regulationId = basename(session.inputs.rules);
+        for (const t of targets) {
+            const prov = t.meta.provenance ??= {};
+            prov.regulation_id = regulationId;
+            prov.source = session.inputs.rules;
+            t.meta.rule_clause_id = `${regulationId}:${t.target_id}`;
+            t.meta.rule_kind = inferRuleKind(t);
+        }
+        const chunks = this.builder.lastChunks;
+        this.writeAsset(session, "build/chunking.json", { chunk_chars: chunkChars, n_chunks: chunks.length, chunks: chunks.map((c) => ({ chunk_id: c.chunk_id, section: c.section, chars: c.text.length })) });
+        if (!existsSync(join(session.home(this.workspace), "build", "schema_profile.json"))) {
+            this.writeAsset(session, "build/schema_profile.json", defaultSchemaProfile(session.taskType));
+        }
+        this.writeTargets(session, targets);
+        this.writeAsset(session, "build/rule_clauses.json", {
+            regulation: { regulation_id: regulationId, source_file: session.inputs.rules },
+            clauses: targets.map((t) => ({
+                clause_id: t.meta.rule_clause_id,
+                source_ref: { regulation_id: regulationId, article: t.meta.provenance?.section ?? t.meta.provenance?.chunk_id },
+                text: t.meta.provenance?.source_quote || t.judge.rubric_text || "",
+                rule_kind: t.meta.rule_kind || "unclassified",
+                target_ref: t.target_id,
+            })),
+        });
+        markChanged(session.home(this.workspace), "rule_model", "规则条款和核查目标已重新实例化", this.now());
+    }
+    async observe(session) {
+        let targets = this.loadTargets(session);
+        const samples = this.readSamples(session.inputs.samples);
+        targets = this.builder.observeSamples(targets, samples);
+        this.writeTargets(session, targets);
+        this.writeAsset(session, "build/observations.json", { sample_count: samples.length, enriched: targets.filter((t) => (t.retrieval.chapter_keywords ?? []).length).map((t) => t.target_id) });
+        this.research(session, targets); // researcher：查领域知识丰富理解（回流）
+        markChanged(session.home(this.workspace), "observations", "样本观察或领域知识引用已更新", this.now());
+    }
+    // ② researcher 知识注入（回流）：查领域知识库，综述喂 refine，命中概念挂 target ---
+    research(session, targets) {
+        const kbRoot = this.knowledgeRoot();
+        if (!kbRoot)
+            return;
+        const kb = new Knowledge(kbRoot);
+        const terms = [];
+        for (const t of targets)
+            terms.push(...(t.retrieval.content_keywords ?? []).slice(0, 3));
+        const query = [...new Set(terms)].join(" ") || session.goal;
+        const hits = kb.retrieve(query, { limit: 5 });
+        const entries = hits.map((e) => ({ id: e.id, kind: e.kind, scope: e.scope, title: e.title, source: e.source, score: e.score, excerpt: e.text.slice(0, 500) }));
+        this.writeAsset(session, "build/research.json", { query, n: entries.length, entries });
+        // 回流①：综述喂 refine 的 rubric 修订
+        this.builder.domainContext = entries.slice(0, 4).map((e) => `[${e.kind}] ${e.title}：${e.excerpt.slice(0, 200)}`).join("\n");
+        // 回流②：命中概念挂到关键词相关 target（知识↔规则连接）
+        for (const t of targets) {
+            const kws = new Set(t.retrieval.content_keywords ?? []);
+            const refs = entries.filter((e) => [...kws].some((k) => (e.title + e.excerpt).includes(k))).slice(0, 5).map((e) => ({ id: e.id, kind: e.kind, source: e.source }));
+            if (refs.length)
+                t.meta.knowledge_refs = refs;
+        }
+        this.writeTargets(session, targets);
+        session.event(this.workspace, "research_done", { query, hits: entries.length }, this.now());
+    }
+    knowledgeRoot() {
+        const proj = join(this.root, "knowledge");
+        if (existsSync(join(proj, "domain")))
+            return proj;
+        // 回落包内知识库（check 包目录的 ../knowledge，若存在）
+        try {
+            const here = fileURLToPath(new URL(".", import.meta.url));
+            const pkg = join(here, "..", "knowledge");
+            if (existsSync(join(pkg, "domain")))
+                return pkg;
+        }
+        catch { /* ignore */ }
+        return null;
+    }
+    async propose(session) {
+        if (!this.checkSkillsCurrent(session))
+            await this.synthesizeCheckSkills(session); // legacy 五步适配器：确保依赖对象存在
+        const specs = this.builder.proposeSpecs(session.taskType, session.scenarioKey);
+        const rationale = {};
+        for (const name of Object.keys(specs)) {
+            const bias = name.endsWith("_wide") ? "recall_first" : "cost_first";
+            rationale[name] = { proposer: bias, rationale: bias === "recall_first" ? "召回优先：宽证据窗口，防漏召" : "成本优先：窄证据窗口，省 LLM 输入" };
+        }
+        this.writeAsset(session, "build/specs.json", Object.fromEntries(Object.entries(specs).map(([n, s]) => [n, specDict(s)])));
+        this.writeAsset(session, "build/proposals.json", { n_proposers: Object.keys(specs).length, candidates: rationale, arbitration: "胜负由 bake-off 沙箱分数定，不由说服力定" });
+        const idx = JSON.parse(readFileSync(join(session.home(this.workspace), "build", "checkskills", "index.json"), "utf-8"));
+        this.writeAsset(session, "build/workflow_manifest.json", {
+            function: "composeWorkflow",
+            input_checkskills: idx.skills,
+            target_digest: idx.target_digest,
+            candidates: Object.keys(specs),
+            note: "Workflow 只编排 CheckSkill，不内嵌规则判据；判据与 Method 血缘留在 skill.json。",
+        });
+        markChanged(session.home(this.workspace), "workflow", "Workflow 已重新编排", this.now());
+        clearStale(session.home(this.workspace), "workflow");
+    }
+    /** v5 三寄存器真正接线：Ontology 对象实例 → Method 选择 → CheckSkill 数据资产。 */
+    async synthesizeCheckSkills(session) {
+        const targets = this.loadTargets(session);
+        const ontology = loadOntology(this.root);
+        const methods = loadMethods(this.root);
+        await this.applyMethodRecipes(targets, methods);
+        const domain = instantiateDomain(targets, methods, {
+            ontologyVersion: ontology.version,
+            regulationPath: session.inputs.rules,
+            lifecycle: "draft",
+        });
+        this.writeAsset(session, "build/domain/unresolved.json", { unresolved: domain.unresolved });
+        if (domain.unresolved.length) {
+            throw new Error("Method 选择失败：" + domain.unresolved.map((x) => `${x.target_id}(${x.rule_kind})`).join("、"));
+        }
+        const graph = new ScenarioOntologyStore(session.home(this.workspace), ontology).replace(domain.objects, domain.links, "synthesize_checkskills");
+        this.writeTargets(session, targets); // 持久化 rule_kind / built_by_method / function_ref
+        this.writeAsset(session, "build/domain/objects.json", { ontology_version: ontology.version, objects: domain.objects });
+        this.writeAsset(session, "build/domain/links.json", { ontology_version: ontology.version, links: domain.links });
+        this.writeAsset(session, "build/method_selection.json", { selections: domain.method_selection });
+        for (const [targetId, skill] of Object.entries(domain.checkskills)) {
+            this.writeAsset(session, `build/checkskills/${targetId}/skill.json`, skill);
+        }
+        this.writeAsset(session, "build/checkskills/index.json", {
+            ontology_version: ontology.version,
+            target_digest: domain.target_digest,
+            count: Object.keys(domain.checkskills).length,
+            skills: Object.keys(domain.checkskills).map((id) => ({ target_id: id, path: `checkskills/${id}/skill.json` })),
+            methods: [...new Set(domain.method_selection.map((s) => s.method_ref))],
+            graph_revision: graph.revision,
+        });
+        markChanged(session.home(this.workspace), "checkskills", "CheckSkill 集合已重新合成", this.now());
+        clearStale(session.home(this.workspace), "checkskills");
+        session.event(this.workspace, "checkskills_synthesized", { count: domain.method_selection.length, methods: [...new Set(domain.method_selection.map((s) => s.method_ref))] }, this.now());
+    }
+    /**
+     * Method 是构建期 prompt/program，不是标签。真实模型读取正文来生成目标级参数；
+     * 输出仍被字段白名单收口，Method 指定的 function_ref 由代码盖章，之后还必须过 eval。
+     */
+    async applyMethodRecipes(targets, methods) {
+        for (const t of targets) {
+            const ruleKind = inferRuleKind(t);
+            const method = selectMethod(methods, ruleKind);
+            if (!method)
+                continue;
+            const system = [
+                "你在执行一个受控 Method，把 RuleClause/VerificationTarget 合成为 CheckSkill 草稿。",
+                "严格遵守下方 Method；只输出 JSON，可给 retrieval、judge、applicability 三个对象。",
+                "不得编造规则事实；无法从输入确定的字段保持原值。function_ref 不由你决定。",
+                `【Method ${methodRef(method)}】\n${method.body}`,
+            ].join("\n\n");
+            let out = {};
+            try {
+                out = await this.llm.completeJson(system, JSON.stringify({
+                    rule_kind: ruleKind,
+                    clause: { id: t.meta.rule_clause_id, source: t.meta.provenance },
+                    target: targetJson(t),
+                }));
+            }
+            catch (e) {
+                this.builder.log.push(`Method ${methodRef(method)} 模型编译失败，保留确定性草稿：${e.message}`);
+            }
+            if (out.retrieval && typeof out.retrieval === "object") {
+                for (const k of ["content_keywords", "chapter_keywords", "negative_keywords"]) {
+                    if (Array.isArray(out.retrieval[k]))
+                        t.retrieval[k] = out.retrieval[k].map(String).filter(Boolean);
+                }
+                if (Number.isFinite(Number(out.retrieval.limit)))
+                    t.retrieval.limit = Number(out.retrieval.limit);
+            }
+            if (out.judge && typeof out.judge === "object") {
+                for (const k of ["kind", "strategy", "rubric_text"])
+                    if (typeof out.judge[k] === "string" && out.judge[k].trim())
+                        t.judge[k] = out.judge[k];
+                if (out.judge.constraint && typeof out.judge.constraint === "object")
+                    t.judge.constraint = out.judge.constraint;
+            }
+            if (out.applicability && typeof out.applicability === "object" && !Array.isArray(out.applicability))
+                t.applicability = out.applicability;
+            t.meta.method_compilation = { method_ref: methodRef(method), source: method.source, model_applied: Object.keys(out).length > 0 };
+        }
+    }
+    checkSkillsCurrent(session) {
+        if (isStale(session.home(this.workspace), "checkskills"))
+            return false;
+        const p = join(session.home(this.workspace), "build", "checkskills", "index.json");
+        if (!existsSync(p))
+            return false;
+        try {
+            return JSON.parse(readFileSync(p, "utf-8")).target_digest === targetDigest(this.loadTargets(session));
+        }
+        catch {
+            return false;
+        }
+    }
+    async test(session) {
+        const home = session.home(this.workspace);
+        const targets = this.loadTargets(session);
+        const specs = this.loadSpecs(session);
+        const oraclePath = session.inputs.oracle ?? "";
+        const evalCfg = this.policy.eval ?? {};
+        const bar = Number(evalCfg.accuracy_bar ?? 0.9);
+        const report = { oracle: Boolean(oraclePath), ranking: [], accuracy_bar: bar };
+        if (oraclePath && existsSync(oraclePath)) {
+            const packDir = join(home, "build", "pack");
+            this.builder.writePack(packDir, session.scenarioKey, targets, specs);
+            const oracle = JSON.parse(readFileSync(oraclePath, "utf-8"));
+            // ④ bake-off 判卷在独立进程跑（I6 判卷≠做题）；失败降级进程内
+            const rep = await this.bakeoffIsolated(session, packDir, oraclePath, bar, evalCfg.winner_metric ?? "accuracy");
+            session.winner = rep.winner ?? "";
+            Object.assign(report, { ranking: rep.ranking, winner: session.winner, eval_isolation: rep.eval_isolation, winner_report: rep.winner_report ?? null });
+            // 冻结从草稿生成，写回最终包（含 schema_profile 与 oracle）
+            this.builder.writePack(packDir, session.scenarioKey, targets, specs, { winner: session.winner, oracle, schemaProfile: this.schemaProfile(session) });
+            // judge 只判卷，不在同一动作里改 doer 资产。未达标时 Commander 另选 diagnose_attempt。
+            report.refine_history = [];
+            const refined = loadPack(packDir).targets;
+            // 评审页占位（就绪门要求存在）—— L1 沙箱：只能写进 build home 内（越界 fail-closed）
+            new Sandbox(home).safeWrite(join(home, "build", "review.html"), `<h1>review · ${session.scenarioKey}</h1>`);
+            session.recordArtifact("build/review.html", this.now());
+            // ④ 对抗 grounding 复验：胜者证据是否真在原文（防幻觉证据溜进冻结包）
+            await this.crossCheck(session, refined, packDir, oracle);
+        }
+        else {
+            session.winner = Object.keys(specs)[0];
+            Object.assign(report, { winner: session.winner, warning: "无 oracle：Eval 门无法自动判达标，晋升只剩人工批准一道门。" });
+        }
+        this.writeAsset(session, "build/test_report.json", report);
+        this.snapshotAttempt(session, report);
+        markChanged(home, "evaluation", "当前资产已产生新的评测结果", this.now());
+        clearStale(home, "evaluation");
+    }
+    /** v3 attempt = 可复现沙箱 Scenario；每轮评测都保留输入、产物、分数和 trace 指针。 */
+    snapshotAttempt(session, report) {
+        const home = session.home(this.workspace);
+        const build = join(home, "build");
+        const nums = readdirSync(build).map((n) => /^attempt-(\d+)$/.exec(n)?.[1]).filter(Boolean).map(Number);
+        const n = (nums.length ? Math.max(...nums) : 0) + 1;
+        const name = `attempt-${String(n).padStart(3, "0")}`;
+        const out = join(build, name);
+        mkdirSync(out, { recursive: true });
+        for (const rel of ["targets.json", "rule_clauses.json", "observations.json", "method_selection.json", "specs.json", "proposals.json", "workflow_manifest.json", "test_report.json", "cross_check.json"]) {
+            const src = join(build, rel);
+            if (existsSync(src))
+                copyFileSync(src, join(out, rel));
+        }
+        for (const rel of ["checkskills", "domain", "pack", "eval"]) {
+            const src = join(build, rel);
+            if (existsSync(src))
+                cpSync(src, join(out, rel), { recursive: true });
+        }
+        writeFileSync(join(out, "attempt.json"), JSON.stringify({
+            attempt_id: name,
+            scenario: session.scenarioKey,
+            target_digest: targetDigest(this.loadTargets(session)),
+            winner: report.winner ?? "",
+            oracle: report.oracle ?? false,
+            created_at: this.now(),
+            immutable_snapshot: true,
+        }, null, 2), "utf-8");
+        session.recordArtifact(`build/${name}/attempt.json`, this.now());
+        session.event(this.workspace, "attempt_snapshot", { attempt: name, winner: report.winner ?? "" }, this.now());
+    }
+    // ④ bake-off 判卷隔离（I6）：独立 node 进程跑，与出方案/改资产的主 agent 物理分开；失败降级内联。
+    async bakeoffIsolated(session, packDir, oraclePath, bar, winnerMetric) {
+        const home = session.home(this.workspace);
+        const history = join(home, "build", "eval", "history.jsonl");
+        const longrun = this.policy.longrun ?? {};
+        const brief = {
+            goal: `对 ${session.scenarioKey} 的候选流水线做 bake-off 打分，只认 oracle`,
+            inputs: [packDir, oraclePath],
+            output_schema: { winner: "str", ranking: "list", ledger: "dict" },
+            budget: { max_llm_calls: Number(this.policy.budget?.max_llm_calls_per_build ?? 500) },
+            items_declared: 2,
+        };
+        const workerScript = fileURLToPath(new URL("./subagents/worker.js", import.meta.url));
+        try {
+            const handle = spawnSubagent(join(home, ".session"), "bakeoff", { pack_dir: packDir, oracle_path: oraclePath, history_path: history, accuracy_bar: bar, winner_metric: winnerMetric }, brief, { workerScript });
+            const rep = await waitSubagent(handle, Number(longrun.subagent_timeout_seconds ?? 1800));
+            const led = rep.ledger ?? {}; // subagent 的账并进主账本
+            this.ledger.calls += led.calls ?? 0;
+            this.ledger.promptTokens += led.promptTokens ?? 0;
+            this.ledger.completionTokens += led.completionTokens ?? 0;
+            rep.eval_isolation = "subagent";
+            session.event(this.workspace, "eval_subagent_done", { dir: handle.dir, winner: rep.winner }, this.now());
+            return rep;
+        }
+        catch (e) {
+            session.event(this.workspace, "eval_isolation_fallback", { error: e.message }, this.now());
+            const pack = loadPack(packDir);
+            const oracle = JSON.parse(readFileSync(oraclePath, "utf-8"));
+            const rep = await this.builder.bakeoff({ profile: pack.profile, refdata: pack.refdata, targets: pack.targets }, pack.frozen, oracle, { llm: this.llm, accuracyBar: bar, winnerMetric, historyPath: history });
+            rep.eval_isolation = "inline";
+            return rep;
+        }
+    }
+    // ④ 对抗 grounding：独立复验胜者证据是否真在原文，落 build/cross_check.json ---------
+    async crossCheck(session, targets, packDir, oracle) {
+        const pack = loadPack(packDir);
+        const executor = pack.executor("", { llm: this.llm });
+        if (executor.spec.unit() !== "per_doc_rule")
+            return;
+        const flags = [];
+        let n = 0;
+        for (const c of oracle.cases ?? []) {
+            for (const d of c.docs ?? []) {
+                const docText = d.text ?? "";
+                const res = await executor.runDocument(new DocumentIR(d.document_id), targets, { rawText: docText });
+                for (const r of res.results) {
+                    for (const e of r.evidence ?? []) {
+                        const quote = (e.quote ?? e.text ?? "").trim();
+                        if (!quote)
+                            continue;
+                        n += 1;
+                        if (!docText.includes(quote))
+                            flags.push({ id: `${c.case_id}:${r.target_id}`, reason: "证据未在原文中找到（疑似幻觉/过度推断）", evidence: quote.slice(0, 200) });
+                    }
+                }
+            }
+        }
+        this.writeAsset(session, "build/cross_check.json", { n_evidence: n, grounding_flags: flags, clean: flags.length === 0 });
+        session.event(this.workspace, "cross_check_done", { grounding_flags: flags.length, clean: flags.length === 0 }, this.now());
+    }
+    async freeze(session) {
+        if (!session.approved)
+            throw new Error("晋升门未批准：freeze 前必须显式 approve。");
+        const home = session.home(this.workspace);
+        const targets = this.loadTargets(session);
+        const audit = auditTargets(targets);
+        if (audit.length)
+            throw new Error("桩产物审计不通过，拒绝冻结：\n  - " + audit.join("\n  - "));
+        const ccPath = join(home, "build", "cross_check.json"); // 对抗 grounding 门（证据必落原文）
+        if (existsSync(ccPath)) {
+            const cc = JSON.parse(readFileSync(ccPath, "utf-8"));
+            if ((cc.grounding_flags ?? []).length) {
+                session.event(this.workspace, "grounding_gate_rejected", { flags: cc.grounding_flags.length }, this.now());
+                throw new Error(`对抗 grounding 门不通过：${cc.grounding_flags.length} 处证据未落原文，拒绝冻结。`);
+            }
+        }
+        const promotion = this.promotionState(session);
+        if (!promotion.ready)
+            throw new Error(`晋升资产门不通过：${promotion.reason}`);
+        const specs = this.loadSpecs(session);
+        const oracleRaw = session.inputs.oracle ?? "";
+        const oracle = oracleRaw && existsSync(oracleRaw) ? JSON.parse(readFileSync(oracleRaw, "utf-8")) : undefined;
+        const packRoot = join(home, "pack");
+        const frozenAt = this.now();
+        const report = this.readTestReport(session);
+        this.builder.writePack(packRoot, session.scenarioKey, targets, specs, { winner: session.winner || Object.keys(specs)[0], oracle, schemaProfile: this.schemaProfile(session), lifecycle: "frozen", frozenAt, eval: { winner: report.winner, ranking: report.ranking, accuracy_bar: report.accuracy_bar } });
+        const methodIndex = existsSync(join(home, "build", "checkskills", "index.json")) ? JSON.parse(readFileSync(join(home, "build", "checkskills", "index.json"), "utf-8")) : {};
+        const manifest = { scenario_key: session.scenarioKey, goal: session.goal, task_type: session.taskType, winner: session.winner, n_targets: targets.length, approved: true, frozen_at: frozenAt, ontology_version: loadOntology(this.root).version, methods: methodIndex.methods ?? [], checkskill_digest: methodIndex.target_digest ?? "", ledger: this.ledgerSummary(), stub_audit: "passed" };
+        writeFileSync(join(packRoot, "freeze_manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+        clearStale(home, "pack");
+        session.recordArtifact("pack/pack.json", this.now());
+        session.recordArtifact("pack/freeze_manifest.json", this.now());
+    }
+    // ---- 盘上产物 ----------------------------------------------------------
+    writeAsset(session, rel, data) {
+        const path = join(session.home(this.workspace), rel);
+        mkdirSync(join(path, ".."), { recursive: true });
+        writeFileSync(path, JSON.stringify(data, null, 2), "utf-8");
+        session.recordArtifact(rel, this.now());
+    }
+    writeTargets(session, targets) {
+        this.writeAsset(session, "build/targets.json", { task_type: session.taskType, targets: targets.map((t) => targetJson(t)) });
+    }
+    loadTargets(session) {
+        const data = JSON.parse(readFileSync(join(session.home(this.workspace), "build", "targets.json"), "utf-8"));
+        return data.targets.map((d) => Target.fromDict(d));
+    }
+    loadSpecs(session) {
+        const raw = JSON.parse(readFileSync(join(session.home(this.workspace), "build", "specs.json"), "utf-8"));
+        return Object.fromEntries(Object.entries(raw).map(([n, d]) => [n, PipelineSpec.fromDict(d)]));
+    }
+    schemaProfile(session) {
+        const p = join(session.home(this.workspace), "build", "schema_profile.json");
+        return existsSync(p) ? JSON.parse(readFileSync(p, "utf-8")) : null;
+    }
+    readSamples(dir) {
+        if (!existsSync(dir))
+            return [];
+        return readdirSync(dir).filter((f) => /\.(txt|md)$/i.test(f)).sort().map((f) => readFileSync(join(dir, f), "utf-8"));
+    }
+    // ---- 展示/知识工具 -----------------------------------------------------
+    showTargets(session) {
+        const targets = this.loadTargets(session);
+        const lines = [`当前 ${targets.length} 个核查目标（相位 ${session.phase}）：`];
+        targets.forEach((t, i) => {
+            const rubric = (t.judge.rubric_text ?? "").replace(/\n/g, " ").slice(0, 60);
+            const kws = (t.retrieval.content_keywords ?? []).slice(0, 4).join("、");
+            lines.push(`  ${i + 1}. [${t.target_id}] ${t.meta.name ?? t.target_id}`, `     判据: ${rubric}`);
+            if (kws)
+                lines.push(`     定位词: ${kws}`);
+        });
+        return lines.join("\n");
+    }
+    showSpecs(session) {
+        const p = join(session.home(this.workspace), "build", "specs.json");
+        if (!existsSync(p))
+            return "还没有候选生产线（③出方案 尚未执行）。";
+        const specs = JSON.parse(readFileSync(p, "utf-8"));
+        return `候选生产线 ${Object.keys(specs).length} 条（胜负由测试定）：\n` + Object.keys(specs).map((n) => `  - ${n}`).join("\n");
+    }
+    showReport(session) {
+        const p = join(session.home(this.workspace), "build", "test_report.json");
+        if (!existsSync(p))
+            return "还没有测试报告（④测试 尚未执行）。";
+        const rep = JSON.parse(readFileSync(p, "utf-8"));
+        const lines = ["测试报告（bake-off 沙箱分数）："];
+        for (const row of rep.ranking ?? [])
+            lines.push(`  ${row.candidate}: 准确率 ${row.accuracy} · LLM ${row.llm_calls} 次` + (row.recall != null ? ` · 召回 ${row.recall}（漏报 ${row.fn}）` : ""));
+        if (rep.winner)
+            lines.push(`胜出: ${rep.winner}`);
+        if (rep.warning)
+            lines.push(`⚠ ${rep.warning}`);
+        return lines.join("\n");
+    }
+    proposeKnowledge(a) {
+        const delta = proposeKnowledgeDelta(this.root, { kind: a.kind, name: a.name, scope: a.scope ?? "finance", body: a.body ?? "", sections: a.sections, now: this.now(), provenance: { via: "orchestrator", scenario: a.session?.scenarioKey } });
+        a.session?.event(this.workspace, "knowledge_delta_proposed", { id: delta.id, kind: a.kind, name: a.name }, this.now());
+        return `已提议知识 delta ${delta.id}（${delta.supersedes ? "更新" : "新增"} ${a.kind}「${a.name}」）。人工确认：kcagent knowledge apply --id ${delta.id}（写入后跑 eval --gate）`;
+    }
+}
+// ---- 桩审计（机器门半边）---------------------------------------------------
+export function auditTargets(targets) {
+    const issues = [];
+    if (!targets.length)
+        return ["目标集为空：没有任何核查目标，无物可冻结"];
+    const seen = new Set();
+    for (const t of targets) {
+        if (seen.has(t.target_id))
+            issues.push(`${t.target_id}: target_id 重复`);
+        seen.add(t.target_id);
+        const rubric = t.judge.rubric_text || t.judge.strategy || "";
+        if (!String(rubric).trim())
+            issues.push(`${t.target_id}: 无判据（rubric/strategy 均为空）——空壳目标`);
+        if (!(t.retrieval.content_keywords?.length || t.retrieval.chapter_keywords?.length))
+            issues.push(`${t.target_id}: 无任何检索线索`);
+    }
+    return issues;
+}
+function targetJson(t) {
+    return { target_id: t.target_id, task_type: t.task_type, applicability: t.applicability, retrieval: t.retrieval, judge: t.judge, outcome_domain: t.outcome_domain, postprocess: t.postprocess, reference: t.reference, meta: t.meta };
+}
+function specDict(s) {
+    return { spec_version: s.spec_version, scenario_key: s.scenario_key, skeleton: s.skeleton, skip: s.skip, fanout: s.fanout, budget: s.budget };
+}
+//# sourceMappingURL=planner.js.map