@dommaker/harness 0.11.1 → 0.12.1

package/dist/core/constraints/checker.js

@@ -44,7 +44,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ironLawChecker = exports.IronLawChecker = exports.constraintChecker = exports.ConstraintChecker = void 0;
 exports.checkConstraint = checkConstraint;
 exports.checkConstraints = checkConstraints;
+exports.checkConstraintsSafe = checkConstraintsSafe;
 exports.checkBeforeExecution = checkBeforeExecution;
+exports.buildConstraintPrompt = buildConstraintPrompt;
 exports.checkIronLaw = checkIronLaw;
 exports.checkAllIronLaws = checkAllIronLaws;
 const constraint_1 = require("../../types/constraint");
@@ -55,6 +57,7 @@ const exec_2 = require("../../utils/exec");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const yaml = __importStar(require("js-yaml"));
+const check_cache_1 = require("./check-cache");
 /**
  * 例外名称 → ConstraintContext 中布尔字段的映射
  */
@@ -91,6 +94,8 @@ class ConstraintChecker {
     static instance;
     /** 自定义约束配置（项目级） */
     customConfig = null;
+    /** 检查结果缓存（S7：减少重复 git diff / src scan I/O，TTL=1s 防跨测试污染） */
+    cache = new check_cache_1.CheckCache({ ttlMs: 1000 });
     constructor() { }
     /**
      * 获取单例实例
@@ -103,26 +108,31 @@ class ConstraintChecker {
     }
     /**
      * 设置项目级约束配置
+     *
+     * @deprecated 修改单例状态，多项目并发时存在污染风险。
+     * 请改用 checkConstraints() / beforeExecution() 的 customConfig 参数实现 per-request 隔离。
      */
     setCustomConfig(config) {
         this.customConfig = config;
     }
     /**
      * 获取当前的约束集合（内置 + 自定义）
+     *
+     * @param customConfig 可选，per-request 自定义配置（优先级高于 setCustomConfig 的单例状态）
      */
-    getConstraints() {
-        if (this.customConfig) {
-            return {
-                ironLaws: this.customConfig.ironLaws,
-                guidelines: this.customConfig.guidelines,
-                tips: this.customConfig.tips,
-            };
-        }
-        return {
-            ironLaws: definitions_1.IRON_LAWS,
-            guidelines: definitions_1.GUIDELINES,
-            tips: definitions_1.TIPS,
+    getConstraints(customConfig) {
+        const config = customConfig ?? this.customConfig;
+        const source = config
+            ? { ironLaws: config.ironLaws, guidelines: config.guidelines, tips: config.tips }
+            : { ironLaws: definitions_1.IRON_LAWS, guidelines: definitions_1.GUIDELINES, tips: definitions_1.TIPS };
+        // Wire unified check() method on every constraint
+        const wire = (constraints) => {
+            for (const c of Object.values(constraints)) {
+                c.check = (ctx) => this.check(c, ctx);
+            }
+            return constraints;
         };
+        return { ironLaws: wire(source.ironLaws), guidelines: wire(source.guidelines), tips: wire(source.tips) };
     }
     /**
      * 检查单个约束
@@ -234,6 +244,28 @@ class ConstraintChecker {
             case 'no_implementation_without_requirement':
                 // 检查是否有需求文档
                 return context.hasRequirement === true;
+            case 'must_use_worktree':
+                // 检查是否在 worktree 中执行
+                return context.hasWorktree === true;
+            case 'no_fuzzy_completion_claim':
+                // 检查完成声明是否包含模糊词（含"我记得""之前说""大部分"等无验证模式）
+                return this.checkNoFuzzyWords(context.completionClaimText || '');
+            case 'no_claim_without_evidence':
+                // 检查是否提供了验证证据（test output / file check / spec AC matrix）
+                return context.hasVerificationEvidence === true ||
+                    (context.taskDescription || '').includes('test') ||
+                    context.hasTest === true;
+            case 'no_delete_without_context':
+                // 检查删除前是否审查了设计文档
+                return context.hasRequirementReview === true ||
+                    context.hasRequirement === true ||
+                    context.isExistingDesign === true;
+            case 'no_performative_agreement':
+                // 检查是否有表演性同意（主要由 promptInjection 驱动，这里做辅助检查）
+                return this.checkNoPerformativePatterns(context.taskDescription || '');
+            case 'two_stage_review_required':
+                // 检查是否完成两阶段审查
+                return context.hasTwoStageReview === true;
             // Guidelines
             case 'no_fix_without_root_cause':
                 // 检查是否有根本原因调查
@@ -266,6 +298,21 @@ class ConstraintChecker {
                 return await this.checkContextDocSync(projectPath);
             case 'docs_freshness':
                 return await this.checkDocsFreshness(projectPath);
+            case 'no_excuse_patterns':
+                // 检查是否使用了借口模式
+                return this.checkNoExcusePatterns(context.completionClaimText || context.taskDescription || '');
+            case 'yagni_check':
+                // 检查是否有过度设计（主要由 promptInjection 驱动）
+                return this.checkYagni(projectPath, context.changedFiles);
+            // Mnilax guidelines + first-principles (injectPrompt=true, behavior-level, always pass — post-checked)
+            case 'surgical_changes_only':
+            case 'no_model_for_deterministic':
+            case 'no_conflict_blending':
+            case 'read_before_write':
+            case 'follow_conventions':
+            case 'first_principles_first':
+                // Guideline: behavior constraints, enforced via promptInjection + post-check
+                return true;
             // Tips - 总是返回 true（仅提示）
             case 'readme_required':
                 return true;
@@ -276,6 +323,118 @@ class ConstraintChecker {
                 return true;
         }
     }
+    /**
+     * 检查文本中是否包含模糊词
+     */
+    checkNoFuzzyWords(text) {
+        if (!text)
+            return true; // 没有文本时默认通过（由其他检查覆盖）
+        const fuzzyPatterns = [
+            /应该没问题/,
+            /应该可以/,
+            /大概/,
+            /可能/,
+            /好像/,
+            /似乎/,
+            /差不多/,
+            /基本完成/,
+            /大部分/,
+            // audit-learned (2026-05-18): unverified completion claims
+            /我记得删[过掉]了/,
+            /之前说删了/,
+            /已删除.*但/,
+            /大部分实现/,
+            /大部分完成/,
+            /已修复.*但/,
+        ];
+        return !fuzzyPatterns.some(p => p.test(text));
+    }
+    /**
+     * 检查文本中是否包含表演性同意模式
+     */
+    checkNoPerformativePatterns(text) {
+        if (!text)
+            return true;
+        // 检查是否只有"好的/明白了"等同意词，没有后续分析
+        const performativeStart = /^(好的[，,]*\s*我[来去]做|明白了[，,]*|没问题[，,]*|ok[，,]*\s*i.?ll)/i;
+        // 如果以表演性模式开头，且总长度很短（< 50 字符），视为表演性同意
+        if (performativeStart.test(text) && text.length < 100) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * 检查文本中是否包含借口模式
+     */
+    checkNoExcusePatterns(text) {
+        if (!text)
+            return true;
+        const excusePatterns = [
+            /稍后修复/,
+            /小问题/,
+            /不影响功能/,
+            /以后再说/,
+            /先这样/,
+            /临时方案/,
+            /暂时这样/,
+        ];
+        return !excusePatterns.some(p => p.test(text));
+    }
+    /**
+     * 检查 YAGNI：过度设计信号
+     *
+     * 检查是否存在只有一个实现的 interface/abstract class。
+     * 主要由 promptInjection 驱动，这里是辅助检查。
+     */
+    async checkYagni(projectPath, changedFiles) {
+        // 无上下文时默认通过（主要由 promptInjection 驱动）
+        if (!projectPath || !changedFiles || changedFiles.length === 0)
+            return true;
+        try {
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+            for (const file of changedFiles) {
+                if (!file.endsWith('.ts') && !file.endsWith('.tsx'))
+                    continue;
+                const filePath = path.join(projectPath, file);
+                if (!fs.existsSync(filePath))
+                    continue;
+                const content = fs.readFileSync(filePath, 'utf-8');
+                // 检查是否有 export interface/abstract class
+                const hasInterface = /export\s+(?:default\s+)?interface\s+(\w+)/g;
+                const hasAbstract = /export\s+(?:default\s+)?abstract\s+class\s+(\w+)/g;
+                const interfaces = [...content.matchAll(hasInterface)].map(m => m[1]);
+                const abstracts = [...content.matchAll(hasAbstract)].map(m => m[1]);
+                const exportedTypes = [...interfaces, ...abstracts];
+                for (const typeName of exportedTypes) {
+                    // 检查同一个 typeName 的 implements/extends 出现次数
+                    const implPattern = new RegExp(`(?:implements|extends)\\s+${typeName}\\b`, 'g');
+                    // 在整个项目中搜索（简化版：只在 changedFiles 中搜索）
+                    let implCount = 0;
+                    for (const f of changedFiles) {
+                        if (!f.endsWith('.ts') && !f.endsWith('.tsx'))
+                            continue;
+                        const fp = path.join(projectPath, f);
+                        if (!fs.existsSync(fp))
+                            continue;
+                        const fc = fs.readFileSync(fp, 'utf-8');
+                        const matches = fc.match(implPattern);
+                        if (matches)
+                            implCount += matches.length;
+                    }
+                    // 只有一个实现者 → YAGNI 违规
+                    if (implCount <= 1) {
+                        return false;
+                    }
+                }
+            }
+        }
+        catch {
+            // 文件读取失败，默认通过
+            return true;
+        }
+        return true;
+    }
     /**
      * 检查 no_bypass_checkpoint：检查代码中是否有 skip/bypass 关键词
      */
@@ -372,35 +531,48 @@ class ConstraintChecker {
         }
     }
     /**
-     * 检查 capability_sync：检查 CAPABILITIES.md 是否更新
+     * 检查 capability_sync：检查 CAPABILITIES.md 是否与代码同步
+     *
+     * 两步验证：
+     *   1. Git diff 检查 — 当前变更的非测试文件是否在文档中有记录（增量检查）
+     *   2. 全量扫描 — src/ 下的所有源文件是否都在 CAPABILITIES.md 中（完整性检查）
      */
     async checkCapabilitySync(projectPath) {
         try {
-            // 检查是否有代码变更
-            const diff = await (0, exec_2.runCommand)('git diff --cached --name-only', projectPath);
-            const changedCodeFiles = diff.split('\n').filter((f) => f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js'));
-            if (changedCodeFiles.length === 0) {
-                return true; // 无代码变更
-            }
-            // 检查 CAPABILITIES.md 是否存在
             const capabilitiesPath = (0, path_1.join)(projectPath, 'CAPABILITIES.md');
             if (!(0, fs_1.existsSync)(capabilitiesPath)) {
-                return false; // 有代码变更但没有 CAPABILITIES.md
+                // 检查是否有代码变更，无变更则跳过
+                const diff = await (0, exec_2.runCommand)('git diff --cached --name-only', projectPath);
+                const changedCodeFiles = diff.split('\n').filter((f) => f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js'));
+                return changedCodeFiles.length === 0;
             }
-            // 解析 CAPABILITIES.md 中的文件列表
             const listedFiles = this.parseCapabilitiesFiles(capabilitiesPath);
-            // 无表格内容 → 向后兼容，存在即通过
-            if (listedFiles.length === 0) {
-                return true;
+            // ── Step 1: Git diff 增量检查 ──
+            const diff = await (0, exec_2.runCommand)('git diff --cached --name-only', projectPath);
+            const changedCodeFiles = diff.split('\n').filter((f) => f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js'));
+            if (changedCodeFiles.length > 0 && listedFiles.length > 0) {
+                const significantChanges = changedCodeFiles.filter((f) => !f.includes('__tests__') && !f.includes('.test.') && !f.includes('.spec.'));
+                if (significantChanges.length > 0) {
+                    const covered = significantChanges.some((changed) => listedFiles.some((listed) => changed.endsWith(listed) || changed.includes(listed)));
+                    if (!covered)
+                        return false;
+                }
             }
-            // 检查变更的非测试代码文件是否在 CAPABILITIES.md 中有记录
-            const significantChanges = changedCodeFiles.filter((f) => !f.includes('__tests__') && !f.includes('.test.') && !f.includes('.spec.'));
-            if (significantChanges.length === 0) {
-                return true; // 只有测试文件变更
+            // ── Step 2: 全量 src/ 扫描（T-058 修复核心）──
+            // 检查是否有 src/ 下的源文件未在 CAPABILITIES.md 中记录
+            if (listedFiles.length > 0) {
+                const srcDir = (0, path_1.join)(projectPath, 'src');
+                if ((0, fs_1.existsSync)(srcDir)) {
+                    // S7: 缓存 src/ 递归扫描结果
+                    const actualFiles = this.cache.getSync('src_scan', projectPath, () => this.findSourceFiles(srcDir, projectPath));
+                    for (const file of actualFiles) {
+                        if (!listedFiles.includes(file)) {
+                            return false; // 有新增文件未在 CAPABILITIES.md 中列出
+                        }
+                    }
+                }
             }
-            // 至少有一个变更文件被 CAPABILITIES.md 覆盖
-            const covered = significantChanges.some((changed) => listedFiles.some((listed) => changed.endsWith(listed) || changed.includes(listed)));
-            return covered;
+            return true;
         }
         catch {
             return true; // 检查失败，默认通过
@@ -501,9 +673,20 @@ class ConstraintChecker {
         }
     }
     /**
-     * 检查 docs_freshness：CAPABILITIES.md 是否与源码同步
+     * 检查 docs_freshness：CAPABILITIES.md + CLAUDE.md 是否与源码同步
      */
     async checkDocsFreshness(projectPath) {
+        // 检查 CAPABILITIES.md
+        const capResult = await this.checkCapabilitiesFreshness(projectPath);
+        if (!capResult)
+            return false;
+        // CONTEXT.md 已删除。harness 的目录描述集中在 CLAUDE.md 的 Key Subsystems 表中。不再检查。
+        return true;
+    }
+    /**
+     * 检查 CAPABILITIES.md 是否与源码同步
+     */
+    async checkCapabilitiesFreshness(projectPath) {
         try {
             const capabilitiesPath = (0, path_1.join)(projectPath, 'CAPABILITIES.md');
             const content = (0, fs_1.readFileSync)(capabilitiesPath, 'utf-8');
@@ -518,12 +701,16 @@ class ConstraintChecker {
             if (listedFiles.length === 0) {
                 return true;
             }
-            // 扫描 src/ 目录中的实际文件
+            // 扫描 src/ 目录中的实际文件（S7: 缓存）
             const srcDir = (0, path_1.join)(projectPath, 'src');
-            const actualFiles = this.findSourceFiles(srcDir, projectPath);
+            const actualFiles = this.cache.getSync('src_scan', projectPath, () => this.findSourceFiles(srcDir, projectPath));
+            // 标准化路径: 去掉 src/ 前缀（sync-docs 和 scanner 可能用不同格式）
+            const normalize = (f) => f.replace(/^src\//, '');
+            const normalizedListed = listedFiles.map(normalize);
+            const normalizedActual = actualFiles.map(normalize);
             // 检查是否有新增文件未列出
-            for (const file of actualFiles) {
-                if (!listedFiles.includes(file)) {
+            for (const file of normalizedActual) {
+                if (!normalizedListed.includes(file)) {
                     return false; // 有新增文件未列出
                 }
             }
@@ -533,6 +720,103 @@ class ConstraintChecker {
             return true; // CAPABILITIES.md 不存在或检查失败，跳过
         }
     }
+    /**
+     * 检查 CLAUDE.md 的 Domain Packages 和 Key Architecture Paths 段落是否与实际代码结构同步
+     */
+    async checkClaudeMdFreshness(projectPath) {
+        try {
+            const claudePath = (0, path_1.join)(projectPath, 'CLAUDE.md');
+            if (!(0, fs_1.existsSync)(claudePath))
+                return true; // 无 CLAUDE.md，跳过
+            const content = (0, fs_1.readFileSync)(claudePath, 'utf-8');
+            // 1. 检查 Domain Packages 段落：packages/studio-* 目录是否存在
+            const domainPkgResult = this.checkDomainPackages(projectPath, content);
+            if (!domainPkgResult)
+                return false;
+            // 2. 检查 Key Architecture Paths 段落：引用的文件/目录是否存在
+            const archPathsResult = this.checkArchitecturePaths(projectPath, content);
+            if (!archPathsResult)
+                return false;
+            return true;
+        }
+        catch {
+            return true; // 检查失败，跳过
+        }
+    }
+    /**
+     * 检查 CLAUDE.md Domain Packages 段落中列出的 packages/studio-* 目录是否都存在
+     */
+    checkDomainPackages(projectPath, claudeContent) {
+        try {
+            // 提取 Domain Packages 段落内容（到下一个 ## 或 --- 为止）
+            const sectionMatch = claudeContent.match(/## Domain Packages\s*\n([\s\S]*?)(?=\n## |\n---|\n$)/);
+            if (!sectionMatch)
+                return true; // 段落不存在，跳过
+            const section = sectionMatch[1];
+            // 提取 CLAUDE.md 中 packages/* 的包名
+            const pkgRegex = /packages\/([\w-]+)/g;
+            let match;
+            while ((match = pkgRegex.exec(section)) !== null) {
+                const pkgDir = (0, path_1.join)(projectPath, 'packages', match[1]);
+                if (!(0, fs_1.existsSync)(pkgDir)) {
+                    return false; // CLAUDE.md 引用的包目录不存在
+                }
+            }
+            // 反向检查：实际存在的包目录是否都在 CLAUDE.md 中被提及
+            const packagesDir = (0, path_1.join)(projectPath, 'packages');
+            if ((0, fs_1.existsSync)(packagesDir)) {
+                const entries = (0, fs_1.readdirSync)(packagesDir);
+                for (const entry of entries) {
+                    if (entry.startsWith('.') || entry.includes('node_modules'))
+                        continue;
+                    const entryStat = (0, fs_1.statSync)((0, path_1.join)(packagesDir, entry));
+                    if (!entryStat.isDirectory())
+                        continue;
+                    if (!section.includes(entry)) {
+                        return false; // 实际包未在 CLAUDE.md 中记录
+                    }
+                }
+            }
+            return true;
+        }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * 检查 CLAUDE.md Key Architecture Paths 段落中引用的路径是否存在
+     */
+    checkArchitecturePaths(projectPath, claudeContent) {
+        try {
+            // 提取 Key Architecture Paths 段落
+            const sectionMatch = claudeContent.match(/## Key Architecture Paths\s*\n([\s\S]*?)(?=\n## |\n---|\n$)/);
+            if (!sectionMatch)
+                return true; // 段落不存在，跳过
+            const section = sectionMatch[1];
+            // 从表格中提取路径（第二列，格式 `path/to/file.ts` 或 `path/to/dir/`）
+            const pathRegex = /\|\s*`([^`]+)`\s*\|/g;
+            let match;
+            while ((match = pathRegex.exec(section)) !== null) {
+                const refPath = match[1].trim();
+                // 跳过非路径内容（如命令、URL）
+                if (refPath.startsWith('http') || refPath.startsWith('搜'))
+                    continue;
+                const fullPath = (0, path_1.join)(projectPath, refPath);
+                // 检查文件或目录是否存在（也尝试去掉尾部 /）
+                if (!(0, fs_1.existsSync)(fullPath) && !(0, fs_1.existsSync)(fullPath.replace(/\/$/, ''))) {
+                    // 路径可能指向模块内部（如 `src/modules/example/`），尝试去掉通配符
+                    const basePath = refPath.replace(/\/?\*$/, '');
+                    if (!(0, fs_1.existsSync)((0, path_1.join)(projectPath, basePath))) {
+                        return false; // 引用的路径不存在
+                    }
+                }
+            }
+            return true;
+        }
+        catch {
+            return true;
+        }
+    }
     /**
      * 查找 src/ 目录中的源文件
      */
@@ -566,10 +850,13 @@ class ConstraintChecker {
     }
     /**
      * 查找适用于当前操作的约束
+     *
+     * @param context 约束上下文
+     * @param customConfig 可选，per-request 自定义配置（避免多请求间的单例状态污染）
      */
-    findApplicableConstraints(context) {
+    findApplicableConstraints(context, customConfig) {
         const trigger = context.operation;
-        const constraints = this.getConstraints();
+        const constraints = this.getConstraints(customConfig);
         const filterByTrigger = (constraintSet) => {
             return Object.values(constraintSet).filter(constraint => {
                 const triggers = Array.isArray(constraint.trigger)
@@ -590,8 +877,11 @@ class ConstraintChecker {
      * - Iron Laws：检查失败立即抛出异常
      * - Guidelines：检查失败记录警告
      * - Tips：检查失败记录提示
+     *
+     * @param context 约束上下文
+     * @param customConfig 可选，per-request 自定义配置（避免多请求间的单例状态污染）
      */
-    async checkConstraints(context) {
+    async checkConstraints(context, customConfig) {
         const result = {
             ironLaws: [],
             guidelines: [],
@@ -601,7 +891,7 @@ class ConstraintChecker {
             tipCount: 0,
         };
         const traceCollector = (0, traces_1.getTraceCollector)();
-        const constraints = this.getConstraints();
+        const constraints = this.getConstraints(customConfig);
         // 1. Iron Laws: 必须全部通过
         for (const constraint of Object.values(constraints.ironLaws)) {
             if (!this.matchesTrigger(constraint, context.operation))
@@ -638,13 +928,61 @@ class ConstraintChecker {
         }
         return result;
     }
+    /**
+     * S11: 安全全量检查 — 全部三层约束检查，不抛异常
+     *
+     * 区别 checkConstraints(): Iron Law 违规收集在结果中而不是抛异常。
+     * 调用方通过 result.passed + result.warningCount 判断状态。
+     */
+    async checkConstraintsSafe(context, customConfig) {
+        const result = {
+            ironLaws: [],
+            guidelines: [],
+            tips: [],
+            passed: true,
+            warningCount: 0,
+            tipCount: 0,
+        };
+        const traceCollector = (0, traces_1.getTraceCollector)();
+        const constraints = this.getConstraints(customConfig);
+        for (const constraint of Object.values(constraints.ironLaws)) {
+            if (!this.matchesTrigger(constraint, context.operation))
+                continue;
+            const checkResult = await this.check(constraint, context);
+            result.ironLaws.push(checkResult);
+            this.recordTrace(traceCollector, constraint, checkResult, context);
+            if (!checkResult.satisfied)
+                result.passed = false;
+        }
+        for (const constraint of Object.values(constraints.guidelines)) {
+            if (!this.matchesTrigger(constraint, context.operation))
+                continue;
+            const checkResult = await this.check(constraint, context);
+            result.guidelines.push(checkResult);
+            this.recordTrace(traceCollector, constraint, checkResult, context);
+            if (!checkResult.satisfied)
+                result.warningCount++;
+        }
+        for (const constraint of Object.values(constraints.tips)) {
+            if (!this.matchesTrigger(constraint, context.operation))
+                continue;
+            const checkResult = await this.check(constraint, context);
+            result.tips.push(checkResult);
+            this.recordTrace(traceCollector, constraint, checkResult, context);
+            if (!checkResult.satisfied)
+                result.tipCount++;
+        }
+        return result;
+    }
     /**
      * 执行前检查（仅检查 Iron Laws）
      *
+     * @param context 约束上下文
+     * @param customConfig 可选，per-request 自定义配置（避免多请求间的单例状态污染）
      * @throws ConstraintViolationError 如果有铁律违规
      */
-    async beforeExecution(context) {
-        const constraints = this.getConstraints();
+    async beforeExecution(context, customConfig) {
+        const constraints = this.getConstraints(customConfig);
         const operations = (0, exec_1.normalizeTriggers)(context.operation);
         for (const constraint of Object.values(constraints.ironLaws)) {
             if (!(0, exec_1.normalizeTriggers)(constraint.trigger).some((t) => operations.includes(t)))
@@ -682,15 +1020,62 @@ async function checkConstraint(constraintId, context) {
 }
 /**
  * 快捷函数：执行三层检查
+ *
+ * @param context 约束上下文
+ * @param customConfig 可选，per-request 自定义配置
+ */
+async function checkConstraints(context, customConfig) {
+    return ConstraintChecker.getInstance().checkConstraints(context, customConfig);
+}
+/**
+ * S11: 快捷函数 — 安全全量检查（不抛异常）
  */
-async function checkConstraints(context) {
-    return ConstraintChecker.getInstance().checkConstraints(context);
+async function checkConstraintsSafe(context, customConfig) {
+    return ConstraintChecker.getInstance().checkConstraintsSafe(context, customConfig);
 }
 /**
  * 快捷函数：执行前检查
+ *
+ * @param context 约束上下文
+ * @param customConfig 可选，per-request 自定义配置
  */
-async function checkBeforeExecution(context) {
-    return ConstraintChecker.getInstance().beforeExecution(context);
+async function checkBeforeExecution(context, customConfig) {
+    return ConstraintChecker.getInstance().beforeExecution(context, customConfig);
+}
+/**
+ * 构建约束注入 prompt
+ *
+ * 收集所有适用约束的 promptInjection 字段，格式化为 Agent system prompt 片段。
+ * 纯计算函数，无副作用，不调用 LLM。
+ *
+ * @param context 约束上下文（至少需要 operation 字段）
+ * @returns 格式化的约束提示文本，可直接注入 Agent system prompt；无匹配约束时返回空字符串
+ */
+function buildConstraintPrompt(context) {
+    const constraints = (0, definitions_1.findConstraintsByTrigger)(context.operation);
+    // Iron laws: always injected (blocking — Agent must know)
+    // Guidelines: only injected if explicitly marked injectPrompt: true
+    const injected = constraints
+        .filter(c => c.promptInjection && (c.level === 'iron_law' || c.injectPrompt === true))
+        .map(c => ({ level: c.level, text: c.promptInjection }));
+    if (injected.length === 0)
+        return '';
+    const ironLaws = injected.filter(i => i.level === 'iron_law');
+    const guidelines = injected.filter(i => i.level === 'guideline');
+    const lines = [];
+    // Iron laws section
+    if (ironLaws.length > 0) {
+        lines.push('## 铁律（违反将阻断执行）', '');
+        ironLaws.forEach(i => lines.push(`- ${i.text.slice(0, 80)}${i.text.length > 80 ? '...' : ''}`));
+        lines.push('');
+    }
+    // Behavior guidelines section
+    if (guidelines.length > 0) {
+        lines.push('## 行为准则', '');
+        guidelines.forEach(i => lines.push(`- ${i.text.slice(0, 80)}${i.text.length > 80 ? '...' : ''}`));
+        lines.push('');
+    }
+    return lines.join('\n');
 }
 // 导出单例
 exports.constraintChecker = ConstraintChecker.getInstance();