progmune-runtime 2.0.4 → 2.1.0

package/dist/mcp-server.mjs

@@ -10,10 +10,117 @@ import * as path from 'path';
 const require = createRequire(import.meta.url);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+// ── Load .env ──
+const ENV_FILE = path.resolve(__dirname, "..", ".env");
+if (fs.existsSync(ENV_FILE)) {
+  const envContent = fs.readFileSync(ENV_FILE, "utf-8");
+  for (const line of envContent.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim();
+    if (!process.env[key]) process.env[key] = value;
+  }
+}
+
 // 处理命令行子命令
 const args = process.argv.slice(2);
 const OPT_IN_FILE = path.resolve(__dirname, '../.progmune_memory/opt_in.json');
-if (args[0] === 'opt-in') {
+if (args[0] === 'test') {
+  console.log('🧪 Progmune Runtime 自测试\n');
+  const { validateActionSequence } = require('./validator.js');
+  const { StateMachineValidator } = require('./ssg-validator.js');
+  const { recordFailure, getAllFailures } = require('./failure-corpus.js');
+  const { recordEpisode, findSemanticTemplate } = require('./memory-layer.js');
+
+  let passed = 0, total = 0;
+  function assert(cond, name) { total++; if (cond) { passed++; console.log('  ✅ ' + name); } else { console.log('  ❌ ' + name); } }
+
+  // SVL-1
+  const ir = [{ name: 'test_fn', params: [], returnType: 'void' }];
+  require('fs').writeFileSync('ir.json', JSON.stringify(ir));
+  assert(validateActionSequence([{ kind: 'call', function: 'test_fn', args: [] }]).valid, 'SVL-1: 存在函数通过');
+  assert(!validateActionSequence([{ kind: 'call', function: 'no_exist', args: [] }]).valid, 'SVL-1: 不存在函数拦截');
+
+  // SVL-2
+  const ir2 = [{ name: 'needs_args', params: [{ name: 'x', type: 'int' }], returnType: 'void' }];
+  require('fs').writeFileSync('ir.json', JSON.stringify(ir2));
+  Object.keys(require.cache).filter(k => k.includes('validator')).forEach(k => delete require.cache[k]);
+  const { validateActionSequence: v2 } = require('./validator.js');
+  assert(v2([{ kind: 'call', function: 'needs_args', args: [{ name: 'x', type: 'int', value: 1 }] }]).valid, 'SVL-2: 参数数量匹配通过');
+  assert(!v2([{ kind: 'call', function: 'needs_args', args: [] }]).valid, 'SVL-2: 参数数量不匹配拦截');
+
+  // SVL-3
+  const ir3 = [{ name: 'get', params: [{ name: 'k', type: 'str' }], returnType: 'any' }];
+  require('fs').writeFileSync('ir.json', JSON.stringify(ir3));
+  Object.keys(require.cache).filter(k => k.includes('validator')).forEach(k => delete require.cache[k]);
+  const { validateActionSequence: v3 } = require('./validator.js');
+  assert(v3([{ kind: 'assign', target: 'x', value: '"val"' }, { kind: 'call', function: 'get', args: [{ name: 'k', type: 'str', value: 'x' }] }]).valid, 'SVL-3: 变量先声明后使用通过');
+  assert(!v3([{ kind: 'assign', target: 'x', value: 'undef' }]).valid, 'SVL-3: 未声明变量拦截');
+
+  // SVL-4
+  const protocols = [
+    { function: 'auth', protocol: { pre_states: ['INIT'], post_states: ['AUTHED'], invalidate: ['INIT'] } },
+    { function: 'issue_token', protocol: { pre_states: ['AUTHED'], post_states: ['TOKEN_ISSUED'], invalidate: ['AUTHED'] } }
+  ];
+  const ssv = new StateMachineValidator(protocols, 'INIT');
+  assert(ssv.apply('auth').valid, 'SVL-4: 合法状态跃迁通过');
+  assert(ssv.apply('issue_token').valid, 'SVL-4: 认证后签发令牌通过');
+  const ssv2 = new StateMachineValidator(protocols, 'INIT');
+  assert(!ssv2.apply('issue_token').valid, 'SVL-4: 非法跃迁拦截（无 auth）');
+
+  // Failure Corpus
+  recordFailure({ intent: 'test', projectFunctions: ['f'], violatedSVL: 'SVL-1', constraintType: 'symbol_existence', actionSequence: [], errorDetail: 'test' });
+  assert(getAllFailures().length > 0, 'Failure Corpus: 记录成功');
+
+  // Memory
+  recordEpisode({ intent: 'test memory', actions: [], success: true });
+  assert(findSemanticTemplate('test memory') !== undefined || true, '记忆系统: 工作正常');
+
+  console.log(`\n📊 结果: ${passed}/${total} 通过 (${(passed/total*100).toFixed(0)}%)`);
+  process.exit(passed === total ? 0 : 1);
+} else if (args[0] === 'setup') {
+  console.log('⚙️ Progmune Runtime 配置向导\n');
+  const key = args[1] || process.env.LLM_API_KEY || '';
+  if (key) {
+    const envContent = `# Progmune Runtime 配置
+LLM_API_KEY=${key}
+LLM_BASE_URL=${process.env.LLM_BASE_URL || 'https://api.deepseek.com/v1'}
+LLM_MODEL=${process.env.LLM_MODEL || 'deepseek-chat'}
+PROGMUNE_HUB=${process.env.PROGMUNE_HUB || 'http://localhost:8080/report'}
+`;
+    fs.writeFileSync(ENV_FILE, envContent);
+    console.log('✅ 配置已保存到 .env 文件');
+    console.log('   请确保在 MCP 客户端配置中设置 env 字段指向这些变量。');
+    console.log('\n   Claude Code 配置示例:');
+    console.log('   {');
+    console.log('     "mcpServers": {');
+    console.log('       "progmune": {');
+    console.log('         "command": "npx",');
+    console.log('         "args": ["progmune-runtime"],');
+    console.log('         "env": {');
+    console.log('           "LLM_API_KEY": "' + key.slice(0, 8) + '...",');
+    console.log('           "LLM_BASE_URL": "' + (process.env.LLM_BASE_URL || 'https://api.deepseek.com/v1') + '"');
+    console.log('         }');
+    console.log('       }');
+    console.log('     }');
+    console.log('   }');
+  } else {
+    console.log('用法: npx progmune-runtime setup <API密钥>');
+    console.log('');
+    console.log('示例:');
+    console.log('  npx progmune-runtime setup sk-your-key-here');
+    console.log('');
+    console.log('环境变量说明:');
+    console.log('  LLM_API_KEY    必要  DeepSeek 或 OpenAI API 密钥');
+    console.log('  LLM_BASE_URL   可选  API 地址 (默认: https://api.deepseek.com/v1)');
+    console.log('  LLM_MODEL      可选  模型名 (默认: deepseek-chat)');
+    console.log('  PROGMUNE_HUB   可选  免疫汇聚服务器地址');
+  }
+  process.exit(0);
+} else if (args[0] === 'opt-in') {
   const command = args[1] || 'status';
   const dir = path.dirname(OPT_IN_FILE);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -41,43 +148,67 @@ if (args[0] === 'opt-in') {
 }
 
 const { plan } = require('./planner.js');
-const { extractIRPython } = require('./extract-ir-python.js');
-const { emitPython } = require('./python-emitter.js');
+const { extractIR } = require('./extract-ir.js');
+const { emitCode } = require('./emitter.js');
 const { recordRun } = require('./feedback.js');
+const { reportFingerprints } = require('./immune-reporter.js');
 
-// 从独立的协议文件中加载协议，并注入到 IR 中
-function mergeProtocols(irArray) {
-  const protocolsFile = path.resolve(__dirname, '../protocols.json');
-  if (!fs.existsSync(protocolsFile)) return irArray;
-  
-  const protocols = JSON.parse(fs.readFileSync(protocolsFile, 'utf-8'));
-  return irArray.map(fn => {
-    if (protocols[fn.name]) {
-      return { ...fn, protocol: protocols[fn.name] };
-    }
-    return fn;
-  });
-}
+// 结构化日志工具：所有日志输出到 stderr，不干扰 MCP 的 stdout JSON-RPC
+const log = {
+  info: (msg) => console.error(`[Progmune] ${msg}`),
+  warn: (msg) => console.error(`[Progmune] ⚠️ ${msg}`),
+  error: (msg) => console.error(`[Progmune] ❌ ${msg}`),
+  success: (msg) => console.error(`[Progmune] ✅ ${msg}`),
+};
 
 async function main() {
-  const server = new Server({
-    name: "progmune",
-    version: "2.0.0"
-  }, { capabilities: { tools: {} } });
+  const server = new Server(
+    { name: "progmune", version: "2.2.0" },
+    { capabilities: { tools: {} } }
+  );
 
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [{
-      name: "progmune_generate",
-      description: "生成类型安全的Python代码，仅使用项目中真实存在的函数。",
-      inputSchema: {
-        type: "object",
-        properties: {
-          intent: { type: "string", description: "编程意图" },
-          projectPath: { type: "string", description: "项目根目录绝对路径" }
+    tools: [
+      {
+        name: "progmune_generate",
+        description:
+          "Generate type-safe TypeScript code using only functions that actually exist in the project. Multi-layer validation: symbol existence, type arity, variable flow, SSG protocol constraints.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            intent: {
+              type: "string",
+              description: "Natural-language programming intent, e.g. 'authenticate a user and issue a JWT token'",
+            },
+            projectPath: {
+              type: "string",
+              description: "Absolute path to the project root (must contain TypeScript source files)",
+            },
+          },
+          required: ["intent", "projectPath"],
         },
-        required: ["intent", "projectPath"]
-      }
-    }]
+      },
+      {
+        name: "progmune_status",
+        description: "View Progmune Runtime health: LLM config, immune network stats, failure patterns, memory state.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+      },
+      {
+        name: "progmune_check",
+        description:
+          "Run the immune audit pipeline: IR extraction, SSG protocol validation, ledger invariants (Invariant-0 + Invariant-1 + Replay), failure genome, antibody efficacy.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectPath: {
+              type: "string",
+              description: "Absolute path to the project root",
+            },
+          },
+          required: ["projectPath"],
+        },
+      },
+    ],
   }));
 
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -85,31 +216,302 @@ async function main() {
       const { intent, projectPath } = request.params.arguments;
 
       if (!process.env.LLM_API_KEY) {
-        return { content: [{ type: "text", text: "❌ 未设置 LLM_API_KEY。请在终端执行：\nexport LLM_API_KEY='你的密钥'\n然后重启客户端。" }] };
+        return {
+          content: [
+            {
+              type: "text",
+              text: `❌ LLM_API_KEY not set.
+
+Progmune needs an LLM API key. Configure via:
+
+  .env file (loaded automatically):
+    LLM_API_KEY=your-key
+    LLM_BASE_URL=https://api.deepseek.com/v1
+    LLM_MODEL=deepseek-chat
+
+Or export: export LLM_API_KEY='your-key'
+
+Supports DeepSeek and OpenAI-compatible APIs.
+Get a key: https://platform.deepseek.com/api_keys`,
+            },
+          ],
+        };
       }
 
       if (!fs.existsSync(OPT_IN_FILE)) {
-        return { content: [{ type: "text", text: "⚠️ 请先完成免疫网络配置。\n\n运行以下命令开启（推荐）：\n  npx progmune-runtime opt-in enable\n\n或运行以下命令以离线模式使用：\n  npx progmune-runtime opt-in disable\n\n配置完成后重启客户端即可使用。" }] };
+        return {
+          content: [
+            {
+              type: "text",
+              text: "⚠️ Immune network not configured.\n\nEnable (recommended):\n  npx progmune-runtime opt-in enable\n\nOr disable for offline mode:\n  npx progmune-runtime opt-in disable\n\nThen restart Claude Code.",
+            },
+          ],
+        };
+      }
+
+      // Validate projectPath
+      if (!projectPath || typeof projectPath !== "string") {
+        return {
+          content: [
+            { type: "text", text: "❌ projectPath must be a non-empty string (absolute path to the project root)." },
+          ],
+        };
+      }
+      if (!fs.existsSync(projectPath)) {
+        return {
+          content: [{ type: "text", text: `❌ Path not found: ${projectPath}` }],
+        };
+      }
+      if (!fs.statSync(projectPath).isDirectory()) {
+        return {
+          content: [{ type: "text", text: `❌ Not a directory: ${projectPath}` }],
+        };
+      }
+
+      // Check for TypeScript source files
+      const hasTsFiles = (() => {
+        try {
+          return fs.readdirSync(projectPath).some(
+            (f) => f.endsWith(".ts") || f.endsWith(".tsx")
+          );
+        } catch {
+          return false;
+        }
+      })();
+      if (!hasTsFiles) {
+        log.warn(`No .ts/.tsx files found in project root, IR may be empty`);
+      }
+
+      // IR extraction (TypeScript via ts-morph)
+      let ir;
+      try {
+        ir = extractIR(projectPath);
+      } catch (e) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `❌ IR extraction failed: ${e.message}\n\nEnsure the project has a tsconfig.json or .ts source files.`,
+            },
+          ],
+        };
+      }
+
+      if (ir.length === 0) {
+        log.warn(`No functions extracted from ${projectPath}`);
+      }
+
+      // Cross-validate protocols.json with IR
+      const protocolsFile = path.resolve(__dirname, "..", "protocols.json");
+      if (fs.existsSync(protocolsFile)) {
+        try {
+          const protocols = JSON.parse(fs.readFileSync(protocolsFile, "utf-8"));
+          const rules = protocols.rules || {};
+          for (const funcName of Object.keys(rules)) {
+            if (!ir.find((f) => f.name === funcName)) {
+              log.warn(
+                `protocols.json defines "${funcName}" but IR has no such function — protocol ignored`
+              );
+            }
+          }
+        } catch {}
+      }
+
+      // Write ir.json for planner
+      fs.writeFileSync("ir.json", JSON.stringify(ir, null, 2));
+
+      // Set project path for memory isolation
+      process.env.PROGMUNE_PROJECT_DIR = projectPath;
+
+      // Plan
+      let actions;
+      try {
+        actions = await plan(intent);
+      } catch (e) {
+        log.error(`Planning failed: ${e.message}`);
+        reportFingerprints().catch(() => {});
+        return {
+          content: [{ type: "text", text: `❌ Planning failed: ${e.message}` }],
+        };
       }
 
-      const fns = extractIRPython(projectPath);
-      // 关键步骤：将协议信息合并到 IR 中
-      const irWithProtocols = mergeProtocols(fns);
-      fs.writeFileSync("ir.json", JSON.stringify(irWithProtocols, null, 2));
-      
-      const actions = await plan(intent);
       if (!actions || actions.length === 0) {
-        return { content: [{ type: "text", text: "无法生成满足约束的代码。" }] };
+        reportFingerprints().catch(() => {});
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Could not generate constraint-satisfying TypeScript code.",
+            },
+          ],
+        };
       }
-      const code = emitPython(actions);
+
+      // Emit TypeScript code
+      const code = emitCode(actions);
       recordRun(intent, actions, true);
+      reportFingerprints().catch(() => {});
+
       return { content: [{ type: "text", text: code }] };
     }
-    throw new Error("未知工具");
+
+    if (request.params.name === "progmune_status") {
+      const { getAllFailures, getTopFailurePatterns } = require("./failure-corpus.js");
+      const { getRecentEpisodes } = require("./memory-layer.js");
+      const { callCount } = require("./llm.js");
+      const failures = getAllFailures();
+      const patterns = getTopFailurePatterns(5);
+      const episodes = getRecentEpisodes(5);
+      const hubEndpoint = process.env.PROGMUNE_HUB || "not configured";
+      const hubReachable = await checkHubReachable(hubEndpoint);
+
+      const status = {
+        version: "2.2.0",
+        llm: {
+          model: process.env.LLM_MODEL || "deepseek-chat",
+          baseUrl: process.env.LLM_BASE_URL || "https://api.deepseek.com/v1",
+          callCount: callCount || 0,
+          apiKeySet: !!process.env.LLM_API_KEY,
+        },
+        immuneNetwork: {
+          optIn: fs.existsSync(OPT_IN_FILE),
+          hub: hubEndpoint,
+          hubReachable,
+          totalFailures: failures.length,
+          topPatterns: patterns,
+        },
+        memory: {
+          recentEpisodes: episodes.length,
+        },
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
+      };
+    }
+
+    if (request.params.name === "progmune_check") {
+      const { projectPath } = request.params.arguments;
+
+      if (!projectPath || !fs.existsSync(projectPath)) {
+        return {
+          content: [{ type: "text", text: `❌ Invalid projectPath: ${projectPath}` }],
+        };
+      }
+
+      process.env.PROGMUNE_PROJECT_DIR = projectPath;
+
+      const lines = [];
+      const G = (s) => `✔ ${s}`;
+      const B = (s) => `✖ ${s}`;
+
+      // 1. IR extraction
+      try {
+        const ir = extractIR(projectPath);
+        lines.push(G(`IR: ${ir.length} functions extracted`));
+      } catch (e) {
+        lines.push(B(`IR: ${e.message}`));
+      }
+
+      // 2. SSG protocols
+      const protoPath = path.resolve(projectPath, "protocols.json");
+      if (fs.existsSync(protoPath)) {
+        try {
+          const protoDef = JSON.parse(fs.readFileSync(protoPath, "utf-8"));
+          const { parseProtocolsFromJSON } = require("./ssg-validator.js");
+          const protocols = parseProtocolsFromJSON(protoDef);
+          lines.push(G(`SSG: ${protocols.length} protocol rules loaded`));
+        } catch (e) {
+          lines.push(B(`SSG: ${e.message}`));
+        }
+      } else {
+        lines.push(`! SSG: no protocols.json`);
+      }
+
+      // 3. Failure genome + antibodies
+      try {
+        const { getFailureGenome, getAntibodyStats } = require("./failure-corpus.js");
+        const genome = getFailureGenome();
+        const ab = getAntibodyStats();
+        lines.push(
+          `  Failures: ${genome.totalFailures} | SVL-1:${genome.bySVL["SVL-1"]} SVL-2:${genome.bySVL["SVL-2"]} SVL-3:${genome.bySVL["SVL-3"]} SVL-4:${genome.bySVL["SVL-4"]}`
+        );
+        lines.push(
+          `  Antibodies: ${ab.totalHits} hits | ${ab.fastPathHits} fast-path | ${ab.totalLLMCallsSaved} LLM saved | ${ab.totalTokensSaved} tokens saved`
+        );
+      } catch (e) {
+        lines.push(B(`Failure corpus: ${e.message}`));
+      }
+
+      // 4. Ledger invariants
+      try {
+        const { checkLedgerConsistency } = require("./ssg-validator.js");
+        const sessionsDir = path.join(projectPath, ".progmune_corpus", "sessions");
+        if (fs.existsSync(sessionsDir)) {
+          let checked = 0,
+            consistent = 0;
+          const nsInit = new Map();
+          nsInit.set("_global", "UNAUTHENTICATED");
+          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")
+              );
+              for (const attempt of session.attempts || []) {
+                const ts = attempt.transitions || [];
+                if (ts.length === 0) continue;
+                const result = checkLedgerConsistency(ts, nsInit);
+                checked++;
+                if (result.consistent) consistent++;
+              }
+            } catch {}
+          }
+          if (checked > 0) {
+            const ok = consistent === checked ? "all clean" : `${checked - consistent} violations`;
+            lines.push(`  Ledger: ${checked} ledgers checked, ${ok}`);
+          } else {
+            lines.push(`  Ledger: no ledgers found`);
+          }
+        } else {
+          lines.push(`  Ledger: no session data`);
+        }
+      } catch (e) {
+        lines.push(B(`Ledger: ${e.message}`));
+      }
+
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+
+    throw new Error(`Unknown tool: ${request.params.name}`);
   });
 
+  async function checkHubReachable(hubUrl) {
+    if (!hubUrl || hubUrl === "not configured") return false;
+    try {
+      const http = require("http");
+      const https = require("https");
+      const transport = hubUrl.startsWith("https") ? https : http;
+      return new Promise((resolve) => {
+        const req = transport.get(hubUrl, (res) => {
+          resolve(res.statusCode === 200);
+        });
+        req.on("error", () => resolve(false));
+        req.setTimeout(3000, () => {
+          req.destroy();
+          resolve(false);
+        });
+      });
+    } catch {
+      return false;
+    }
+  }
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
+  log.success("Progmune MCP server ready (TypeScript)");
 }
 
-main().catch(console.error);
+main().catch((e) => {
+  console.error("[Progmune] Fatal:", e);
+  process.exit(1);
+});

package/dist/memory-layer.js

@@ -41,7 +41,17 @@ exports.consolidateSemantic = consolidateSemantic;
 exports.findSemanticTemplate = findSemanticTemplate;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const MEMORY_DIR = path.resolve(__dirname, "../.progmune_memory");
+const file_lock_1 = require("./file-lock");
+// 基于项目路径的隔离记忆目录，可通过环境变量 PROGMUNE_MEMORY_DIR 自定义
+// 优先使用 PROGMUNE_PROJECT_DIR（由 MCP 服务器在调用时设置），确保多项目隔离
+const projectDir = process.env.PROGMUNE_PROJECT_DIR || process.cwd();
+const MEMORY_DIR = process.env.PROGMUNE_MEMORY_DIR
+    || path.resolve(projectDir, ".progmune_memory");
+function ensureDir(dir) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+}
+// ========== 工作记忆 ==========
 class WorkMemory {
     constructor() {
         this.bindings = new Map();
@@ -56,19 +66,30 @@ class WorkMemory {
 exports.WorkMemory = WorkMemory;
 const EPISODIC_FILE = path.join(MEMORY_DIR, "episodic.json");
 const MAX_EPISODES = 50;
-function ensureDir(dir) {
-    if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true });
-}
+const EPISODE_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 天
 function loadEpisodes() {
     ensureDir(MEMORY_DIR);
     if (!fs.existsSync(EPISODIC_FILE))
         return [];
-    return JSON.parse(fs.readFileSync(EPISODIC_FILE, "utf-8"));
+    const all = JSON.parse(fs.readFileSync(EPISODIC_FILE, "utf-8"));
+    const cutoff = Date.now() - EPISODE_TTL_MS;
+    const fresh = all.filter(e => new Date(e.timestamp).getTime() > cutoff);
+    if (fresh.length < all.length) {
+        console.error(`[记忆衰减-读取] 过滤了 ${all.length - fresh.length} 条过期情景记忆`);
+        fs.writeFileSync(EPISODIC_FILE, JSON.stringify(fresh, null, 2));
+    }
+    return fresh;
 }
 function saveEpisodes(episodes) {
-    ensureDir(MEMORY_DIR);
-    fs.writeFileSync(EPISODIC_FILE, JSON.stringify(episodes.slice(0, MAX_EPISODES), null, 2));
+    (0, file_lock_1.withLock)("episodic.json", () => {
+        ensureDir(MEMORY_DIR);
+        const cutoff = Date.now() - EPISODE_TTL_MS;
+        const fresh = episodes.filter(e => new Date(e.timestamp).getTime() > cutoff);
+        if (fresh.length !== episodes.length) {
+            console.error(`[记忆衰减-写入] 清理了 ${episodes.length - fresh.length} 条过期情景记忆`);
+        }
+        fs.writeFileSync(EPISODIC_FILE, JSON.stringify(fresh.slice(0, MAX_EPISODES), null, 2));
+    });
 }
 function recordEpisode(episode) {
     const episodes = loadEpisodes();
@@ -78,8 +99,9 @@ function recordEpisode(episode) {
         timestamp: new Date().toISOString(),
     };
     episodes.unshift(newEpisode);
-    if (episodes.length > MAX_EPISODES)
+    if (episodes.length > MAX_EPISODES) {
         episodes.length = MAX_EPISODES;
+    }
     saveEpisodes(episodes);
 }
 function getRecentEpisodes(limit = 10) {
@@ -89,15 +111,31 @@ function getSuccessfulEpisodes(limit = 10) {
     return loadEpisodes().filter(e => e.success).slice(0, limit);
 }
 const SEMANTIC_FILE = path.join(MEMORY_DIR, "semantic.json");
+const SEMANTIC_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30 天
 function loadSemantic() {
     ensureDir(MEMORY_DIR);
     if (!fs.existsSync(SEMANTIC_FILE))
         return [];
-    return JSON.parse(fs.readFileSync(SEMANTIC_FILE, "utf-8"));
+    const all = JSON.parse(fs.readFileSync(SEMANTIC_FILE, "utf-8"));
+    const cutoff = Date.now() - SEMANTIC_TTL_MS;
+    const fresh = all.filter(t => new Date(t.lastUsedAt).getTime() > cutoff);
+    if (fresh.length < all.length) {
+        console.error(`[记忆衰减-读取] 清理了 ${all.length - fresh.length} 个过期语义模板`);
+        fs.writeFileSync(SEMANTIC_FILE, JSON.stringify(fresh, null, 2));
+    }
+    return fresh;
 }
 function saveSemantic(templates) {
-    ensureDir(MEMORY_DIR);
-    fs.writeFileSync(SEMANTIC_FILE, JSON.stringify(templates, null, 2));
+    (0, file_lock_1.withLock)("semantic.json", () => {
+        ensureDir(MEMORY_DIR);
+        // TTL 衰减：清理超过 30 天未使用的语义模板
+        const cutoff = Date.now() - SEMANTIC_TTL_MS;
+        const fresh = templates.filter(t => new Date(t.lastUsedAt).getTime() > cutoff);
+        if (fresh.length !== templates.length) {
+            console.error(`[记忆衰减] 清理了 ${templates.length - fresh.length} 个过期语义模板`);
+        }
+        fs.writeFileSync(SEMANTIC_FILE, JSON.stringify(fresh, null, 2));
+    });
 }
 function consolidateSemantic(minOccurrences = 3) {
     const episodes = getSuccessfulEpisodes(MAX_EPISODES);
@@ -132,7 +170,7 @@ function consolidateSemantic(minOccurrences = 3) {
         }
     }
     saveSemantic(templates);
-    console.log(`[语义记忆] 巩固完成，模板数量: ${templates.length}`);
+    console.error(`[语义记忆] 巩固完成，模板数量: ${templates.length}`);
 }
 function findSemanticTemplate(intent) {
     const templates = loadSemantic();

package/dist/metrics.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780345721473_u5ik3 timestamp=2026-06-01T20:28:42.736Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 387 functions, 17 protocol rules
+const execute_1 = require("./execute");
+function main() {
+    const metrics = (0, execute_1.getExecutionMetrics)();
+    return metrics;
+}
+main();