progmune-runtime 2.0.4 → 2.1.0

package/.mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "progmune": {
+      "type": "stdio",
+      "command": "node",
+      "args": [
+        "dist/mcp-server.mjs"
+      ]
+    }
+  }
+}

package/.progmune_allowlist

@@ -0,0 +1,50 @@
+# Progmune Allowlist — files exempt from @progmune-generated requirement
+# Add patterns (one per line) for files that don't need the marker.
+# Lines starting with # are comments.
+
+# Configuration files
+\\.json$
+\\.md$
+\\.sh$
+\\.css$
+\\.html$
+
+# Test files
+test-.*
+.*\\.test\\.ts$
+.*\\.spec\\.ts$
+test_.*\\.ts$
+test_.*\\.mjs$
+test_.*\\.js$
+
+# Build artifacts
+dist/
+node_modules/
+
+# Progmune's own infrastructure (core files that predate Phase 4.5)
+src/runtime-types\\.ts$
+src/runtime-invariants\\.ts$
+src/ssg-validator\\.ts$
+src/failure-corpus\\.ts$
+src/memory-layer\\.ts$
+src/planner\\.ts$
+src/emitter\\.ts$
+src/extract-ir.*\\.ts$
+src/validator\\.ts$
+src/semantic-validator\\.ts$
+src/action-runtime\\.ts$
+src/actions\\.ts$
+src/llm\\.ts$
+src/utils\\.ts$
+src/feedback\\.ts$
+src/immune-reporter\\.ts$
+src/report\\.ts$
+src/file-lock\\.ts$
+src/consolidate\\.ts$
+src/mcp-server\\.ts$
+src/check\\.ts$
+src/semantic-trace\\.ts$
+src/semantic-snapshot\\.ts$
+src/obs-web\\.ts$
+src/p0_ssg_demo\\.ts$
+src/main\\.ts$

package/.test_report/test_report.md

@@ -0,0 +1,87 @@
+# Progmune Runtime 综合测试报告
+
+**测试时间**: 2026-05-23 14:15:09
+**运行时长**: 3171ms
+**测试版本**: 2.0.5
+**LLM 后端**: DeepSeek Chat (deepseek-chat)
+**Node 版本**: v20.11.1
+
+---
+
+## 测试结果摘要
+
+| 指标 | 数值 |
+|------|------|
+| 总用例 | 29 |
+| 通过 | 29 |
+| 失败 | 0 |
+| 通过率 | 100.0% |
+
+## 逐项测试详情
+
+| # | 测试项 | 状态 | 说明 |
+|---|--------|------|------|
+| 1 | MCP tools/list 返回工具列表 | ✅ PASS | 返回 2 个工具 |
+| 2 | MCP 暴露 progmune_generate 工具 | ✅ PASS | 工具名: progmune_generate |
+| 3 | 工具包含 intent 参数 | ✅ PASS |  |
+| 4 | 工具包含 projectPath 参数 | ✅ PASS |  |
+| 5 | SVL-1: 调用存在的函数通过 | ✅ PASS |  |
+| 6 | SVL-1: 拦截不存在的函数 | ✅ PASS | 错误: 函数 'nonexistent_func' 不存在 |
+| 7 | SVL-1: 错误消息包含"不存在" | ✅ PASS | 函数 'nonexistent_func' 不存在 |
+| 8 | SVL-2: 参数数量匹配通过 | ✅ PASS |  |
+| 9 | SVL-2: 拦截参数数量不匹配 | ✅ PASS | 错误: 参数数量不匹配: 期望 2, 实际 1 |
+| 10 | SVL-2: 错误消息包含"参数数量" | ✅ PASS | 参数数量不匹配: 期望 2, 实际 1 |
+| 11 | SVL-3: 变量先声明后使用通过 | ✅ PASS |  |
+| 12 | SVL-3: 拦截未声明变量 | ✅ PASS | 错误: 变量 'undeclaredVar' 在赋值前未声明 |
+| 13 | SVL-3: 拦截条件中未声明变量 | ✅ PASS | 错误: 条件中引用了未声明的变量 'undefinedVar' |
+| 14 | SVL-3: 复杂嵌套变量流通过 | ✅ PASS |  |
+| 15 | SVL-4: 认证动作合法 | ✅ PASS | 状态: UNAUTHENTICATED -> AUTHENTICATED |
+| 16 | SVL-4: 认证后签发令牌合法 | ✅ PASS | 状态: AUTHENTICATED -> TOKEN_ISSUED |
+| 17 | SVL-4: 拦截未认证直接签发令牌 | ✅ PASS | 错误: [PROGMUNE] L4 协议违规：issue_token
+  当前状态：UNAUTHENTICATED
+  期望前置状态：AUTHENTICATED
+  缺失步骤：authenticate → AUTHENTICATED |
+| 18 | Failure Corpus: 记录失败案例 | ✅ PASS | 共 17 条 |
+| 19 | Failure Corpus: 按 SVL-1 过滤 | ✅ PASS | 找到 2 条 |
+| 20 | Failure Corpus: 生成失败模式统计 | ✅ PASS | [{"pattern":"SVL-4:protocol","count":11},{"pattern":"SVL-1:symbol_existence","count":2},{"pattern":"SVL-2:type_mismatch","count":2}] |
+| 21 | 记忆系统: 记录情景记忆 | ✅ PASS | 共 5 条 |
+| 22 | 记忆系统: 过滤成功情景 | ✅ PASS | 共 5 条 |
+| 23 | 记忆系统: 语义模板巩固与匹配 | ✅ PASS | 模板: tmpl_1779545707638, 成功率: 1 |
+| 24 | 边界: 空动作序列通过 | ✅ PASS |  |
+| 25 | 边界: 拦截未知动作类型 | ✅ PASS | 无效动作类型: 'invalid_kind' |
+| 26 | 边界: 多层嵌套通过 | ✅ PASS |  |
+| 27 | 白名单: 内置函数通过校验 | ✅ PASS | console.log, JSON.stringify |
+| 28 | 端到端: 生成动作序列 | ✅ PASS | 共 2 个动作 |
+| 29 | 端到端: 生成 Python 代码 | ✅ PASS | 代码长度: 144 字符 |
+
+---
+
+## SVL 层级覆盖矩阵
+
+| SVL 级别 | 名称 | 测试覆盖 | 状态 |
+|:---------:|:----|:---------|:----:|
+| SVL-1 | 符号存在性 | 调用存在/不存在函数校验 | ✅ |
+| SVL-2 | 类型有效性 | 参数数量匹配校验 | ✅ |
+| SVL-3 | 数据流正确性 | 变量声明/使用、嵌套作用域 | ✅ |
+| SVL-4 | 协议合法性 | SSG 状态机、非法跃迁拦截 | ✅ |
+
+## 系统组件覆盖
+
+| 组件 | 测试覆盖 | 状态 |
+|:-----|:---------|:----:|
+| MCP 协议层 | tools/list、tools/call | ✅ |
+| 校验引擎 (Validator) | SVL-1~3 校验 | ✅ |
+| SSG 状态机 | 协议跃迁校验 | ✅ |
+| Failure Corpus | 记录/查询/模式统计 | ✅ |
+| 三层记忆系统 | 情景记忆/语义模板 | ✅ |
+| 代码生成器 | 动作序列 → Python | ✅ |
+| 内置白名单 | console.log / fetch 等 | ✅ |
+| 边界情况 | 空序列/嵌套/非法类型 | ✅ |
+
+## 结论
+
+**全部测试通过。** Progmune Runtime 各核心组件运行正常，约束引擎、SSG 协议校验、记忆系统和 Failure Corpus 均按预期工作。
+
+---
+
+*报告由 Progmune Runtime 综合测试套件自动生成*

package/Dockerfile

@@ -1,17 +1,9 @@
 FROM node:18-alpine
-
 WORKDIR /app
-
-# 只复制运行时需要的文件
 COPY server/ ./server/
 COPY dist/ ./dist/
+COPY public/ ./public/
 COPY package.json package-lock.json* ./
-
-# 安装生产依赖
 RUN npm install --production
-
-# 暴露端口
-EXPOSE 3000
-
-# 启动中央免疫服务器
+EXPOSE 8080
 CMD ["node", "server/hub.js"]

package/FAQ.md

@@ -0,0 +1,167 @@
+# Progmune Runtime 常见问题 (FAQ)
+
+## 安装与配置
+
+### 如何获取 LLM API 密钥？
+
+Progmune 需要 LLM API 密钥来生成代码。目前支持 DeepSeek 和 OpenAI 兼容接口。
+
+**DeepSeek:**
+1. 访问 https://platform.deepseek.com/api_keys
+2. 注册账号并创建 API 密钥
+3. 密钥格式：`sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
+
+**OpenAI:**
+1. 访问 https://platform.openai.com/api-keys
+2. 创建 API 密钥
+3. 设置环境变量 `LLM_BASE_URL=https://api.openai.com/v1` 和 `LLM_MODEL=gpt-4`
+
+### 如何配置 API 密钥？
+
+**方式一：MCP 客户端配置（推荐）**
+在 `~/.claude/settings.json` 中：
+```json
+{
+  "mcpServers": {
+    "progmune": {
+      "command": "npx",
+      "args": ["progmune-runtime"],
+      "env": {
+        "LLM_API_KEY": "你的密钥",
+        "LLM_BASE_URL": "https://api.deepseek.com/v1"
+      }
+    }
+  }
+}
+```
+
+**方式二：环境变量**
+```bash
+export LLM_API_KEY="你的密钥"
+npx progmune-runtime
+```
+
+**方式三：快速配置命令**
+```bash
+npx progmune-runtime setup 你的密钥
+```
+
+### 如何验证安装是否成功？
+
+```bash
+# 检查版本
+npx progmune-runtime --version
+
+# 检查 MCP 工具列表（需在 MCP 客户端中）
+# 应看到 progmune_generate 和 progmune_status 两个工具
+
+# 运行内置测试
+npx progmune-runtime test
+```
+
+### 为什么浏览器打不开仪表板？
+
+如果运行 `open http://localhost:8080/` 无效：
+
+1. **确认 Hub 服务器正在运行：**
+   ```bash
+   curl http://localhost:8080/api/dashboard
+   ```
+   如果返回 JSON 数据，说明服务器运行正常。
+
+2. **手动在浏览器打开：**
+   - 在地址栏输入 `http://localhost:8080/`
+   - 注意使用 `http://` 而非 `https://`（本地服务器不支持 HTTPS）
+
+3. **端口冲突：**
+   - 默认端口 8080，可通过 `PORT` 环境变量修改
+   - 检查是否有其他程序占用：`lsof -i :8080`
+
+## 使用问题
+
+### MCP 配置失败怎么办？
+
+**症状：** Claude Code 提示 "MCP server progmune not found"
+
+**排查步骤：**
+1. 确认 `~/.claude/settings.json` 中配置格式正确
+2. 确认 Node.js >= 18 已安装：`node --version`
+3. 尝试手动启动验证：`npx progmune-runtime`
+4. 检查 Claude Code 日志中是否有错误信息
+
+**症状：** 调用 `progmune_generate` 返回 "未设置 LLM_API_KEY"
+
+即使已在终端 `export` 了密钥，MCP 子进程也可能无法继承。必须在 `settings.json` 的 `env` 字段中显式配置。
+
+### 如何开启免疫网络上报？
+
+```bash
+# 开启（推荐）
+npx progmune-runtime opt-in enable
+
+# 关闭
+npx progmune-runtime opt-in disable
+
+# 查看状态
+npx progmune-runtime opt-in status
+```
+
+开启后，每次代码生成的脱敏错误指纹会自动上报到中央免疫服务器。
+
+### 如何部署中央免疫服务器？
+
+```bash
+# 启动本地 Hub
+cd progmune-runtime
+node server/hub.js
+
+# 设置环境变量让 MCP 服务器自动上报
+export PROGMUNE_HUB=http://localhost:8080/report
+```
+
+仪表板访问：`http://localhost:8080/`
+
+## 错误与调试
+
+### "无法生成满足约束的代码"
+
+这意味着 LLM 生成的代码未能通过 Progmune 的约束校验（SVL-1~4）。常见原因：
+
+1. **IR 为空：** 项目目录中没有提取到函数定义。确认 `projectPath` 指向包含 `.py` 文件的目录。
+2. **LLM 输出不符合格式：** DeepSeek/OpenAI 返回了非预期的格式。重试通常可以解决。
+3. **SSG 协议违规：** 生成的代码跳过了必要的业务步骤。错误信息会提示缺失的步骤。
+
+### "函数 'xxx' 不存在"
+
+这是 SVL-1 符号存在性校验的拦截。说明 LLM 幻觉调用了一个项目中不存在的函数。这是 Progmune 的正常保护行为。
+
+### 如何查看运行状态？
+
+通过 MCP 调用 `progmune_status` 工具，返回 JSON 格式的运行状态，包括：
+- LLM 模型和调用次数
+- 免疫网络状态
+- Failure Corpus 统计
+- 记忆系统状态
+
+## 技术细节
+
+### Progmune 支持哪些语言？
+
+目前代码生成支持 **Python**。IR 提取支持 Python 项目（通过 `extract-ir-python.ts`）。
+
+### 数据隐私如何保障？
+
+上报到中央免疫服务器的数据**只包含**：
+- 函数名序列（如 `verify_password → generate_jwt`）
+- SVL 违规级别
+- 约束类型
+
+**绝不包含**：
+- 代码片段
+- 变量值
+- 文件内容
+- 用户数据
+
+### 如何贡献？
+
+欢迎通过 GitHub Issues 提交"看似合法但实际危险"的生成案例，帮助我们完善语义状态图（SSG）协议。

package/demo-project/auth.ts

@@ -0,0 +1,55 @@
+/**
+ * Demo 项目: 用户认证系统
+ * 用于展示 SSG (Semantic State Graph) 协议验证
+ *
+ * 每个函数通过 JSDoc @protocol 注解声明其状态转换规则。
+ * 这些注解在 IR 提取时被解析，驱动 SSG 状态机。
+ */
+
+/**
+ * 验证用户密码
+ * @protocol pre_states=["UNAUTHENTICATED"] post_states=["PASSWORD_VERIFIED"]
+ */
+export function verify_password(username: string, password: string): boolean {
+  return password === "correct";
+}
+
+/**
+ * 签发 JWT 令牌
+ * @protocol pre_states=["PASSWORD_VERIFIED"] post_states=["TOKEN_ISSUED"] invalidate=["PASSWORD_VERIFIED"]
+ */
+export function generate_jwt(userId: string, expiresIn: number): string {
+  return "eyJhbGciOi...";
+}
+
+/**
+ * 创建用户会话
+ * @protocol pre_states=["TOKEN_ISSUED"] post_states=["SESSION_ACTIVE"] invalidate=["TOKEN_ISSUED"]
+ */
+export function create_session(token: string): { sessionId: string } {
+  return { sessionId: "sess_abc123" };
+}
+
+/**
+ * 撤销令牌
+ * @protocol pre_states=["TOKEN_ISSUED"] post_states=["UNAUTHENTICATED"] invalidate=["TOKEN_ISSUED"]
+ */
+export function revoke_token(token: string): void {
+  // 将 token 加入黑名单
+}
+
+/**
+ * 登出
+ * @protocol pre_states=["SESSION_ACTIVE"] post_states=["UNAUTHENTICATED"] invalidate=["SESSION_ACTIVE"]
+ */
+export function logout(sessionId: string): void {
+  // 销毁会话
+}
+
+/**
+ * 获取用户资料（无协议约束）
+ * @protocol pre_states=[] post_states=[]
+ */
+export function get_user_profile(userId: string): { name: string; email: string } {
+  return { name: "Alice", email: "alice@example.com" };
+}

package/demo-project/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "strict": true
+  },
+  "include": ["*.ts"]
+}

package/dist/ab-stats.js

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

package/dist/acl-breakdown.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343994721_xgc40 timestamp=2026-06-01T19:59:59.184Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 400 functions, 17 protocol rules
+const failure_corpus_1 = require("./failure-corpus");
+const semantic_trace_1 = require("./semantic-trace");
+function main() {
+    const stats = (0, failure_corpus_1.getAntibodyStats)();
+    const formatted = (0, semantic_trace_1.formatAntibodyStats)();
+    return formatted;
+}
+main();

package/dist/all-sessions.js

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

package/dist/antibody-stats.js

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

package/dist/audit.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Phase 4.5: Progmune Audit — 扫描代码库中的 @progmune-generated 标记，统计覆盖率
+ *
+ * Usage:
+ *   npx ts-node src/audit.ts <directory>
+ *   npx ts-node src/audit.ts src/
+ */
+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.auditDirectory = auditDirectory;
+exports.formatAuditResult = formatAuditResult;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Scan a directory recursively for TypeScript files and check for @progmune-generated markers. */
+const DEFAULT_THRESHOLD = 0.8;
+function auditDirectory(dir, threshold = DEFAULT_THRESHOLD) {
+    const result = {
+        directory: dir,
+        totalFiles: 0,
+        progmuneFiles: 0,
+        coverage: 0,
+        threshold,
+        warning: null,
+        nonProgmuneFiles: [],
+        sessions: [],
+    };
+    if (!fs.existsSync(dir)) {
+        return result;
+    }
+    const stat = fs.statSync(dir);
+    if (!stat.isDirectory()) {
+        return result;
+    }
+    scanDir(dir, dir, result);
+    result.coverage = result.totalFiles > 0
+        ? result.progmuneFiles / result.totalFiles
+        : 0;
+    if (result.coverage < result.threshold && result.totalFiles > 0) {
+        const pct = (result.coverage * 100).toFixed(0);
+        const target = (result.threshold * 100).toFixed(0);
+        result.warning = `Coverage ${pct}% below ${target}% threshold. ${result.nonProgmuneFiles.length} file(s) are not @progmune-generated.`;
+    }
+    // Sort sessions by timestamp (most recent first)
+    result.sessions.sort((a, b) => (b.timestamp || "").localeCompare(a.timestamp || ""));
+    if (result.sessions.length > 0) {
+        result.lastGeneration = result.sessions[0].timestamp;
+    }
+    return result;
+}
+const MARKER_REGEX = /@progmune-generated\s+session=(\S+)(?:\s+timestamp=(\S+))?(?:\s+ruleHash=(\S+))?/;
+const EXCLUDED_DIRS = new Set(["node_modules", ".git", "dist", ".progmune_corpus", ".progmune_memory"]);
+function scanDir(rootDir, currentDir, result) {
+    let entries;
+    try {
+        entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            if (!EXCLUDED_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+                scanDir(rootDir, fullPath, result);
+            }
+            continue;
+        }
+        // Only check TypeScript source files
+        if (!entry.name.endsWith(".ts") && !entry.name.endsWith(".tsx") && !entry.name.endsWith(".mjs")) {
+            continue;
+        }
+        result.totalFiles++;
+        try {
+            const content = fs.readFileSync(fullPath, "utf-8");
+            // Only check first 5 lines for the marker (performance)
+            const head = content.split("\n").slice(0, 5).join("\n");
+            const match = head.match(MARKER_REGEX);
+            if (match) {
+                result.progmuneFiles++;
+                result.sessions.push({
+                    sessionId: match[1],
+                    file: path.relative(rootDir, fullPath),
+                    timestamp: match[2],
+                    ruleHash: match[3],
+                });
+            }
+            else {
+                result.nonProgmuneFiles.push(path.relative(rootDir, fullPath));
+            }
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+}
+/** Format audit result as human-readable text. */
+function formatAuditResult(result) {
+    const pct = (result.coverage * 100).toFixed(1);
+    const lines = [];
+    lines.push(`Progmune Audit: ${result.directory}`);
+    lines.push("═".repeat(56));
+    lines.push(`  Total source files:   ${result.totalFiles}`);
+    lines.push(`  @progmune-generated:  ${result.progmuneFiles}  (${pct}%)`);
+    lines.push(`  Threshold:            ${(result.threshold * 100).toFixed(0)}%`);
+    if (result.warning) {
+        lines.push(`  ⚠️  ${result.warning}`);
+    }
+    lines.push(`  Not covered:          ${result.nonProgmuneFiles.length}`);
+    lines.push("");
+    // Phase 7: Execution metrics
+    try {
+        const { getExecutionMetrics } = require("./execute");
+        const m = getExecutionMetrics();
+        if (m.generated > 0) {
+            const repairRate = m.repaired > 0 ? ` | Repaired: ${m.repaired}` : "";
+            lines.push(`  Executions: ${m.generated} total${repairRate}`);
+            if (m.lastGeneration) {
+                lines.push(`  Last: ${m.lastGeneration}`);
+            }
+            if (m.history.length >= 2) {
+                const recent = m.history.slice(-5);
+                lines.push(`  Recent: ${recent.map((r) => r.repaired ? '🔧' : '✅').join(' ')}`);
+            }
+            lines.push("");
+        }
+    }
+    catch { }
+    // Phase 7: Violation Analytics
+    try {
+        const repairDir = ".progmune_corpus/repairs";
+        if (fs.existsSync(repairDir)) {
+            const repairs = fs.readdirSync(repairDir).filter((f) => f.endsWith(".json"));
+            if (repairs.length > 0) {
+                const bySvl = {};
+                const byConstraint = {};
+                for (const f of repairs) {
+                    try {
+                        const r = JSON.parse(fs.readFileSync(`${repairDir}/${f}`, "utf-8"));
+                        bySvl[r.violation] = (bySvl[r.violation] || 0) + 1;
+                        byConstraint[r.constraint] = (byConstraint[r.constraint] || 0) + 1;
+                    }
+                    catch { }
+                }
+                lines.push(`  Repairs recorded: ${repairs.length}`);
+                const svlSummary = Object.entries(bySvl).map(([k, v]) => `${k}: ${v}`).join(" | ");
+                lines.push(`  By SVL: ${svlSummary}`);
+                if (Object.keys(byConstraint).length > 1) {
+                    const cSummary = Object.entries(byConstraint).map(([k, v]) => `${k}: ${v}`).join(" | ");
+                    lines.push(`  By constraint: ${cSummary}`);
+                }
+                lines.push("");
+            }
+        }
+    }
+    catch { }
+    if (result.sessions.length > 0) {
+        lines.push(`  Last generation: ${result.lastGeneration || "unknown"}`);
+        lines.push(`  Unique sessions:  ${new Set(result.sessions.map(s => s.sessionId)).size}`);
+        lines.push("");
+        lines.push("  Generated files:");
+        for (const s of result.sessions.slice(0, 10)) {
+            lines.push(`    ${s.file}`);
+        }
+        if (result.sessions.length > 10) {
+            lines.push(`    ... and ${result.sessions.length - 10} more`);
+        }
+        lines.push("");
+    }
+    if (result.nonProgmuneFiles.length > 0) {
+        lines.push(`  Files without Progmune marker (${result.nonProgmuneFiles.length}):`);
+        for (const f of result.nonProgmuneFiles.slice(0, 20)) {
+            lines.push(`    ${f}`);
+        }
+        if (result.nonProgmuneFiles.length > 20) {
+            lines.push(`    ... and ${result.nonProgmuneFiles.length - 20} more`);
+        }
+    }
+    return lines.join("\n");
+}
+// CLI entry
+if (require.main === module) {
+    const dir = process.argv[2] || "src";
+    const result = auditDirectory(dir);
+    console.log(formatAuditResult(result));
+}

package/dist/benchmark-count.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.benchmarkCount = benchmarkCount;
+const load_benchmarks_1 = require("./load-benchmarks");
+function benchmarkCount() {
+    return (0, load_benchmarks_1.loadBenchmarks)().length;
+}