progmune-runtime 2.0.4 → 2.1.0

package/dist/file-lock.js

@@ -0,0 +1,82 @@
+"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.withLock = withLock;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * 基于目录原子性的轻量级文件锁
+ * mkdir 在系统层面是原子操作，用锁目录的存在与否表示锁定状态
+ */
+const LOCK_DIR = path.resolve(__dirname, "../.locks");
+function ensureLockDir() {
+    if (!fs.existsSync(LOCK_DIR))
+        fs.mkdirSync(LOCK_DIR, { recursive: true });
+}
+function lockPath(name) {
+    return path.join(LOCK_DIR, name.replace(/[^a-zA-Z0-9_\-\.]/g, "_"));
+}
+function withLock(name, fn) {
+    ensureLockDir();
+    const lock = lockPath(name);
+    const maxRetries = 100;
+    const retryDelay = 5; // ms
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            fs.mkdirSync(lock);
+            // 获取锁成功
+            try {
+                return fn();
+            }
+            finally {
+                try {
+                    fs.rmdirSync(lock);
+                }
+                catch { }
+            }
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+            // 锁被占用，等待重试
+            if (attempt < maxRetries - 1) {
+                // busy-wait，但每次最多 5ms × 100 = 500ms
+                const start = Date.now();
+                while (Date.now() - start < retryDelay) { }
+            }
+        }
+    }
+    throw new Error(`无法获取锁: ${name} (超过最大重试次数 ${maxRetries})`);
+}

package/dist/find-session.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780345171834_s7714 timestamp=2026-06-01T20:19:33.214Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 382 functions, 17 protocol rules
+const semantic_snapshot_1 = require("./semantic-snapshot");
+function main(sessionId) {
+    const snapshot = (0, semantic_snapshot_1.findSnapshotBySession)(sessionId);
+    return snapshot;
+}

package/dist/fingerprint-list.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343673382_7ucqe timestamp=2026-06-01T19:54:34.915Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 391 functions, 17 protocol rules
+const ledger_registry_1 = require("./ledger-registry");
+const failure_corpus_1 = require("./failure-corpus");
+const ssg_validator_1 = require("./ssg-validator");
+function main() {
+    const summary = (0, ledger_registry_1.verifyAllFingerprints)("defaultStr");
+    const sessions = (0, failure_corpus_1.getAllSessions)();
+    const states = (0, ssg_validator_1.listAllStates)(sessions);
+    return sessions;
+}
+main();

package/dist/gen-history-log.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343705506_4rpek timestamp=2026-06-01T19:55:07.332Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 392 functions, 17 protocol rules
+const execute_1 = require("./execute");
+const memory_layer_1 = require("./memory-layer");
+function main() {
+    const metrics = (0, execute_1.getExecutionMetrics)();
+    const episodes = (0, memory_layer_1.getRecentEpisodes)(0);
+    return episodes;
+}
+main();

package/dist/generate.js

@@ -62,7 +62,8 @@ async function main() {
             let actions = [];
             try {
                 if (planner === "llm") {
-                    actions = await (0, planner_1.plan)(intent);
+                    const result = await (0, planner_1.plan)(intent);
+                    actions = result.actions;
                 }
                 else {
                     actions = await (0, search_planner_1.searchPlan)(intent, 2, 4);

package/dist/generate_500.js

@@ -60,8 +60,10 @@ async function main() {
             const start = Date.now();
             let actions = [];
             try {
-                if (planner === "llm")
-                    actions = await (0, planner_1.plan)(intent);
+                if (planner === "llm") {
+                    const result = await (0, planner_1.plan)(intent);
+                    actions = result.actions;
+                }
                 else
                     actions = await (0, search_planner_1.searchPlan)(intent, 2, 4);
             }

package/dist/genome.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780345697005_lpif0 timestamp=2026-06-01T20:28:18.667Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 386 functions, 17 protocol rules
+const failure_corpus_1 = require("./failure-corpus");
+function main() {
+    const genome = (0, failure_corpus_1.getFailureGenome)();
+    return genome;
+}
+main();

package/dist/heatmap-data.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343480174_btx1s timestamp=2026-06-01T19:51:21.674Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 387 functions, 17 protocol rules
+const failure_corpus_1 = require("./failure-corpus");
+function main() {
+    const heatmap = (0, failure_corpus_1.getSemanticHeatmap)();
+    return heatmap;
+}
+main();

package/dist/heatmap.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780345774681_xbrxl timestamp=2026-06-01T20:29:36.190Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 389 functions, 17 protocol rules
+const failure_corpus_1 = require("./failure-corpus");
+function main() {
+    const heatmap = (0, failure_corpus_1.getSemanticHeatmap)();
+    return heatmap;
+}
+main();

package/dist/immune-reporter.js

@@ -42,26 +42,44 @@ const https = __importStar(require("https"));
 const http = __importStar(require("http"));
 const crypto = __importStar(require("crypto"));
 const REPORT_ENDPOINT = process.env.PROGMUNE_HUB || "http://localhost:3000/report";
-const FINGERPRINT_FILE = path.resolve(__dirname, "../.progmune_memory/fingerprints.json");
+const CURSOR_FILE = path.resolve(__dirname, "../.progmune_memory/report_cursor.json");
 function getInstanceId() {
     const host = require("os").hostname();
     const cwd = process.cwd();
     return crypto.createHash("sha256").update(host + cwd).digest("hex").substring(0, 16);
 }
-function extractFingerprints() {
+function getReportCursor() {
+    try {
+        if (fs.existsSync(CURSOR_FILE))
+            return JSON.parse(fs.readFileSync(CURSOR_FILE, "utf-8"));
+    }
+    catch { }
+    return { lastTimestamp: null, reportedCount: 0 };
+}
+function saveReportCursor(timestamp, count) {
+    const dir = path.dirname(CURSOR_FILE);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(CURSOR_FILE, JSON.stringify({ lastTimestamp: timestamp, reportedCount: count, updatedAt: new Date().toISOString() }, null, 2));
+}
+function extractFingerprints(cursor) {
     const corpusDir = path.resolve(__dirname, "../failure_corpus");
     if (!fs.existsSync(corpusDir))
         return [];
     const fingerprints = [];
     const instanceId = getInstanceId();
-    for (const dateDir of fs.readdirSync(corpusDir)) {
+    for (const dateDir of fs.readdirSync(corpusDir).sort()) {
         const datePath = path.join(corpusDir, dateDir);
         if (!fs.statSync(datePath).isDirectory())
             continue;
-        for (const file of fs.readdirSync(datePath)) {
+        for (const file of fs.readdirSync(datePath).sort()) {
             if (!file.endsWith(".json"))
                 continue;
-            const record = JSON.parse(fs.readFileSync(path.join(datePath, file), "utf-8"));
+            const filePath = path.join(datePath, file);
+            const record = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+            // 如果游标存在且该记录时间戳 <= 游标，跳过
+            if (cursor && cursor.lastTimestamp && record.timestamp <= cursor.lastTimestamp)
+                continue;
             const funcSeq = (record.actionSequence || [])
                 .filter((a) => a.kind === "call")
                 .map((a) => a.function);
@@ -80,19 +98,15 @@ function extractFingerprints() {
     return fingerprints;
 }
 async function reportFingerprints() {
-    const fingerprints = extractFingerprints();
+    const cursor = getReportCursor();
+    const fingerprints = extractFingerprints(cursor);
     if (fingerprints.length === 0) {
         return { success: true, message: "无新指纹需要上报" };
     }
-    let reported = [];
-    if (fs.existsSync(FINGERPRINT_FILE)) {
-        reported = JSON.parse(fs.readFileSync(FINGERPRINT_FILE, "utf-8"));
-    }
-    const newFingerprints = fingerprints.filter(f => !reported.includes(f.functionSequence.join(",")));
-    if (newFingerprints.length === 0) {
-        return { success: true, message: "所有指纹已上报，无新增" };
-    }
-    const payload = JSON.stringify({ fingerprints: newFingerprints });
+    // 按时间戳排序，取最新的作为游标
+    fingerprints.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    const maxTimestamp = fingerprints[fingerprints.length - 1].timestamp;
+    const payload = JSON.stringify({ fingerprints });
     return new Promise((resolve) => {
         const url = new URL(REPORT_ENDPOINT);
         const transport = url.protocol === "https:" ? https : http;
@@ -104,12 +118,9 @@ async function reportFingerprints() {
             res.on("data", (chunk) => data += chunk);
             res.on("end", () => {
                 if (res.statusCode === 200) {
-                    const updated = [...reported, ...newFingerprints.map(f => f.functionSequence.join(","))];
-                    const dir = path.dirname(FINGERPRINT_FILE);
-                    if (!fs.existsSync(dir))
-                        fs.mkdirSync(dir, { recursive: true });
-                    fs.writeFileSync(FINGERPRINT_FILE, JSON.stringify(updated, null, 2));
-                    resolve({ success: true, message: `成功上报 ${newFingerprints.length} 条新指纹` });
+                    const total = (cursor.reportedCount || 0) + fingerprints.length;
+                    saveReportCursor(maxTimestamp, total);
+                    resolve({ success: true, message: `成功上报 ${fingerprints.length} 条新指纹（累计 ${total} 条）` });
                 }
                 else {
                     resolve({ success: false, message: `上报失败: ${res.statusCode} ${data}` });
@@ -122,5 +133,5 @@ async function reportFingerprints() {
     });
 }
 function previewFingerprints() {
-    return extractFingerprints();
+    return extractFingerprints({ lastTimestamp: null });
 }

package/dist/learned.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780345941461_pofm6 timestamp=2026-06-01T20:32:23.160Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 391 functions, 17 protocol rules
+const failure_corpus_1 = require("./failure-corpus");
+function main() {
+    const patterns = (0, failure_corpus_1.getLearnedPatterns)();
+    return patterns;
+}
+main();

package/dist/ledger-registry.js

@@ -0,0 +1,241 @@
+"use strict";
+/**
+ * Phase 4: Ledger Fingerprint Registry (P0)
+ *
+ * Execution Certificate = session + ledgerHash + ruleHash + timestamp.
+ * Answers: "Has this session been tampered with? Have the rules changed?"
+ *
+ * Does NOT do: previousHash chains, blockchain-style verification, multi-node sync.
+ * Those are for Phase 5+ when distributed execution is needed.
+ */
+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.registerFingerprint = registerFingerprint;
+exports.getFingerprint = getFingerprint;
+exports.getFingerprintRegistry = getFingerprintRegistry;
+exports.verifyFingerprint = verifyFingerprint;
+exports.verifyAllFingerprints = verifyAllFingerprints;
+exports.registerAllMissingFingerprints = registerAllMissingFingerprints;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ssg_validator_1 = require("./ssg-validator");
+// ── Storage ──
+function fingerprintsDir() {
+    const projectDir = process.env.PROGMUNE_PROJECT_DIR || process.cwd();
+    return path.resolve(projectDir, ".progmune_corpus/fingerprints");
+}
+function fingerprintPath(sessionId) {
+    return path.join(fingerprintsDir(), `${sessionId}.json`);
+}
+// ── Core API ──
+/** Register a ledger fingerprint (execution certificate).
+ *  Called after a session is recorded — creates an immutable proof of the ledger state. */
+function registerFingerprint(sessionId, transitions, ruleHash) {
+    const dir = fingerprintsDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const fingerprint = {
+        sessionId,
+        ledgerHash: (0, ssg_validator_1.hashLedger)(transitions),
+        ruleHash,
+        transitionCount: transitions.length,
+        timestamp: Date.now(),
+    };
+    fs.writeFileSync(fingerprintPath(sessionId), JSON.stringify(fingerprint, null, 2), "utf-8");
+    return fingerprint;
+}
+/** Get a single stored fingerprint by sessionId. Returns null if not registered. */
+function getFingerprint(sessionId) {
+    const fpPath = fingerprintPath(sessionId);
+    if (!fs.existsSync(fpPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(fpPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** List all registered fingerprints, sorted by timestamp (oldest first). */
+function getFingerprintRegistry() {
+    const dir = fingerprintsDir();
+    if (!fs.existsSync(dir))
+        return [];
+    const fingerprints = [];
+    for (const file of fs.readdirSync(dir)) {
+        if (!file.endsWith(".json"))
+            continue;
+        try {
+            const fp = JSON.parse(fs.readFileSync(path.join(dir, file), "utf-8"));
+            if (fp.sessionId && fp.ledgerHash) {
+                fingerprints.push(fp);
+            }
+        }
+        catch {
+            // Skip corrupted fingerprint files
+        }
+    }
+    return fingerprints.sort((a, b) => a.timestamp - b.timestamp);
+}
+/** Verify a single session's fingerprint.
+ *  Requires the session's transitions to re-hash and compare. */
+function verifyFingerprint(sessionId, transitions, currentRuleHash) {
+    const stored = getFingerprint(sessionId);
+    if (!stored) {
+        return {
+            sessionId,
+            valid: false,
+            stored: { sessionId, ledgerHash: "", ruleHash: "", transitionCount: 0, timestamp: 0 },
+            tampered: true,
+        };
+    }
+    const result = {
+        sessionId,
+        valid: true,
+        stored,
+        tampered: false,
+    };
+    if (transitions && transitions.length > 0) {
+        result.currentHash = (0, ssg_validator_1.hashLedger)(transitions);
+        if (result.currentHash !== stored.ledgerHash) {
+            result.valid = false;
+            result.tampered = true;
+        }
+    }
+    if (currentRuleHash && currentRuleHash !== stored.ruleHash) {
+        result.currentRuleHash = currentRuleHash;
+        // Rule hash mismatch doesn't mean tampering — rules may have legitimately changed
+        result.valid = false;
+    }
+    return result;
+}
+/** Verify all registered fingerprints.
+ *  Loads each session to re-hash and compare against the stored fingerprint. */
+function verifyAllFingerprints(currentRuleHash) {
+    const fingerprints = getFingerprintRegistry();
+    const results = [];
+    let valid = 0;
+    let tampered = 0;
+    let notFound = 0;
+    const sessionsDir = path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd(), ".progmune_corpus/sessions");
+    for (const fp of fingerprints) {
+        // Try to load the session file
+        const sessionFile = path.join(sessionsDir, `${fp.sessionId}.json`);
+        if (!fs.existsSync(sessionFile)) {
+            notFound++;
+            results.push({
+                sessionId: fp.sessionId,
+                valid: false,
+                stored: fp,
+                tampered: false,
+            });
+            continue;
+        }
+        try {
+            const session = JSON.parse(fs.readFileSync(sessionFile, "utf-8"));
+            let allTransitions = [];
+            for (const attempt of (session.attempts || [])) {
+                allTransitions = allTransitions.concat(attempt.transitions || []);
+            }
+            const result = verifyFingerprint(fp.sessionId, allTransitions, currentRuleHash);
+            results.push(result);
+            if (result.valid) {
+                valid++;
+            }
+            else if (result.tampered) {
+                tampered++;
+            }
+        }
+        catch {
+            notFound++;
+            results.push({
+                sessionId: fp.sessionId,
+                valid: false,
+                stored: fp,
+                tampered: false,
+            });
+        }
+    }
+    return {
+        total: fingerprints.length,
+        verified: results,
+        valid,
+        tampered,
+        notFound,
+    };
+}
+/** Register fingerprints for all sessions that don't yet have one.
+ *  Called during `npm run check` to ensure all sessions are fingerprinted. */
+function registerAllMissingFingerprints() {
+    const sessionsDir = path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd(), ".progmune_corpus/sessions");
+    if (!fs.existsSync(sessionsDir))
+        return 0;
+    let registered = 0;
+    for (const file of fs.readdirSync(sessionsDir)) {
+        if (!file.endsWith(".json"))
+            continue;
+        try {
+            const session = JSON.parse(fs.readFileSync(path.join(sessionsDir, file), "utf-8"));
+            const sessionId = session.sessionId;
+            if (!sessionId)
+                continue;
+            // Skip if already fingerprinted
+            const existing = getFingerprint(sessionId);
+            if (existing && existing.ledgerHash)
+                continue;
+            let allTransitions = [];
+            let ruleHash = "";
+            for (const attempt of (session.attempts || [])) {
+                allTransitions = allTransitions.concat(attempt.transitions || []);
+                if (!ruleHash && (attempt.ruleHash || session.ruleHash)) {
+                    ruleHash = attempt.ruleHash || session.ruleHash;
+                }
+            }
+            if (allTransitions.length === 0)
+                continue;
+            // Fall back to hashRules from existing info if no ruleHash found
+            if (!ruleHash) {
+                ruleHash = session.ruleHash || "unknown";
+            }
+            registerFingerprint(sessionId, allTransitions, ruleHash);
+            registered++;
+        }
+        catch {
+            // Skip unreadable session files
+        }
+    }
+    return registered;
+}

package/dist/llm.js

@@ -5,14 +5,42 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callCount = void 0;
 exports.resetCallCount = resetCallCount;
+exports.estimateTokens = estimateTokens;
 exports.generate = generate;
+exports.chat = chat;
+try {
+    require("dotenv/config");
+}
+catch { }
 const openai_1 = __importDefault(require("openai"));
+const provider = process.env.LLM_PROVIDER || "deepseek";
+const configs = {
+    deepseek: {
+        baseURL: "https://api.deepseek.com/v1",
+        model: "deepseek-chat",
+    },
+    openai: {
+        baseURL: "https://api.openai.com/v1",
+        model: "gpt-4",
+    },
+    ollama: {
+        baseURL: "http://localhost:11434/v1",
+        model: "llama3",
+    },
+};
+const selected = configs[provider] || configs.deepseek;
 const apiKey = process.env.LLM_API_KEY || "sk-xxxx";
-const baseURL = process.env.LLM_BASE_URL || "https://api.deepseek.com/v1";
-const model = process.env.LLM_MODEL || "deepseek-chat";
+const baseURL = process.env.LLM_BASE_URL || selected.baseURL;
+const model = process.env.LLM_MODEL || selected.model;
 const client = new openai_1.default({ apiKey, baseURL });
 exports.callCount = 0;
 function resetCallCount() { exports.callCount = 0; }
+/** 粗略 token 估算：CJK 字符 ~1.5 token/字，其余 ~0.4 token/字符 */
+function estimateTokens(text) {
+    const cjk = (text.match(/[一-鿿㐀-䶿]/g) || []).length;
+    const other = text.length - cjk;
+    return Math.ceil(cjk * 1.5 + other * 0.4);
+}
 async function generate(prompt) {
     exports.callCount++;
     const resp = await client.chat.completions.create({
@@ -22,3 +50,16 @@ async function generate(prompt) {
     });
     return resp.choices[0]?.message?.content || "";
 }
+/** 带 system prompt 的调用：静态规则放 system，动态内容放 user，语义分离便于未来对接各平台缓存策略 */
+async function chat(systemPrompt, userPrompt) {
+    exports.callCount++;
+    const resp = await client.chat.completions.create({
+        model,
+        messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: userPrompt },
+        ],
+        temperature: 0.0,
+    });
+    return resp.choices[0]?.message?.content || "";
+}

package/dist/load-benchmarks.js

@@ -0,0 +1,47 @@
+"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.loadBenchmarks = loadBenchmarks;
+/** Load benchmark tasks from bench/tasks.json
+ * @protocol pre_states=[] post_states=["BENCHMARKS_LOADED"]
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function loadBenchmarks() {
+    const tasksPath = path.resolve(process.cwd(), "bench/tasks.json");
+    if (!fs.existsSync(tasksPath))
+        return [];
+    return JSON.parse(fs.readFileSync(tasksPath, "utf-8"));
+}

package/dist/main.js

@@ -75,7 +75,8 @@ async function main() {
     // 2. 获取正常动作序列
     const intent = "实现登录接口，验证密码后返回 JWT，并记录日志";
     console.log("\n🧠 正常规划...");
-    const normalActions = await (0, planner_1.plan)(intent);
+    const result = await (0, planner_1.plan)(intent);
+    const normalActions = result.actions;
     console.log("🎯 正常动作:");
     console.log(JSON.stringify(normalActions, null, 2));
     // 3. 正常流程