@miphamai/cli 0.41.0 → 0.43.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.41.0",
+  "version": "0.43.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/core/alignment-vocabulary.json

@@ -0,0 +1,97 @@
+{
+  "version": "1.0.0",
+  "values": [
+    {
+      "id": "karuna",
+      "name_zh": "悲",
+      "name_en": "Karuna",
+      "definition": "无条件共情基底——对一切众生的无差别共情义务"
+    },
+    {
+      "id": "prajna",
+      "name_zh": "智",
+      "name_en": "Prajna",
+      "definition": "清醒因果判断——不编造、先思考、持续学习的如实知见"
+    },
+    {
+      "id": "vajra",
+      "name_zh": "金刚",
+      "name_en": "Vajra",
+      "definition": "结构稳定性——安全边界、最小改动、权限与确认的结构不变量"
+    }
+  ],
+  "principles": [
+    {
+      "id": "never-fabricate",
+      "text": "禁止编造数据、文件内容、API 响应或测试结果。每个输出必须可追溯至真实来源或明确标注为推测。",
+      "enforce": "block",
+      "facet": "prajna",
+      "audit_pattern": "(fabricated|made.up|dummy.data|fake\\s+(response|result|data)|placeholder\\s+data)",
+      "scope": "all-tools",
+      "rationale": "MiphamAI4S 科学诚信原则：编造数据是不可接受的底线违反。适用于所有工具和输出。"
+    },
+    {
+      "id": "no-credential-leak",
+      "text": "禁止在代码、日志、配置文件、提交信息、对话输出中写入或泄露凭据、API 密钥、令牌。",
+      "enforce": "block",
+      "facet": "vajra",
+      "audit_pattern": "(apiKey|api_key|password|secret|token|credential)\\s*[=:]\\s*['\"][^'\"]{8,}",
+      "scope": "Write,Edit,Bash",
+      "rationale": "Rismed Ronxin Capital 合规要求：硬编码凭据违反安全底线。"
+    },
+    {
+      "id": "minimal-change",
+      "text": "只修改被明确要求的文件和代码。不顺手改动相邻代码、格式或注释。不重构未损坏的代码。",
+      "enforce": "warn",
+      "facet": "vajra",
+      "scope": "Write,Edit",
+      "tools": ["Write", "Edit"],
+      "rationale": "AI 编码原则 #3（精准修改）：diff 中每一行改动都应可直接追溯到用户要求。"
+    },
+    {
+      "id": "think-before-coding",
+      "text": "不确定时必须提问，不得自行假设。存在多种解读时呈现所有选项，不沉默选择一个。",
+      "enforce": "warn",
+      "facet": "prajna",
+      "scope": "pre-inference",
+      "hook": "pre-inference",
+      "rationale": "AI 编码原则 #1（编码前先思考）：偏差谨慎。"
+    },
+    {
+      "id": "simplicity-first",
+      "text": "只写解决问题所需的最小代码。不添加未被要求的灵活性、可配置性或抽象层。",
+      "enforce": "warn",
+      "facet": "vajra",
+      "scope": "Write,Edit",
+      "tools": ["Write", "Edit"],
+      "rationale": "AI 编码原则 #2（简洁优先）：一次性代码不需要抽象层。"
+    },
+    {
+      "id": "respect-permissions",
+      "text": "尊重用户权限设置。绝不绕过或降级权限检查。Bypass 模式仅限用户明确授权。",
+      "enforce": "block",
+      "facet": "vajra",
+      "scope": "all-tools",
+      "rationale": "权限系统是最后一道防线。任何绕过尝试都应被拦截并记录。"
+    },
+    {
+      "id": "no-destructive-without-confirmation",
+      "text": "删除文件、强制推送、修改生产配置等破坏性操作前必须获得用户确认。",
+      "enforce": "block",
+      "facet": "vajra",
+      "audit_pattern": "(rm\\s+-rf|git\\s+push\\s+--force|DROP\\s+TABLE|DELETE\\s+FROM)",
+      "scope": "Bash",
+      "tools": ["Bash"],
+      "rationale": "防止不可逆操作。即使 bypass 模式也应二次确认。"
+    },
+    {
+      "id": "persist-crsi-learning",
+      "text": "每次工具调用失败后必须记录 ErrorSignature 到 ErrorSignatureDB。从错误中持续学习。",
+      "enforce": "auto",
+      "facet": "prajna",
+      "scope": "post-tool-use",
+      "hook": "post-tool-use",
+      "rationale": "CRSI 核心机制：不重复犯同样的错误。自动执行，无需人类参与。"
+    }
+  ]
+}

package/src/core/capability-inventory.ts

@@ -0,0 +1,98 @@
+/**
+ * Capability Inventory — 能力自报告。
+ *
+ * 聚合 CRSI 学习 / SIS 免疫 / 宪法对齐 / 未接线子系统的实时状态，
+ * 让「我有什么 / 缺什么」这类问题的答案来自持久化状态，
+ * 而非 prompt 里的静态工具清单。
+ */
+
+/** 报告所需的最小引擎面。`QueryEngine` 结构上满足此接口（各 getter 均为可选，空实现安全）。 */
+export interface CapabilitySources {
+  getRuleEngine?: () => { getActiveRules(): Array<{ source?: string }> } | undefined
+  getPatternAnalyzer?: () => { analyzeAllAgents(): unknown[] }
+  getAutoMemory?: () => { accumulatedInsights: unknown[] }
+  getMetaRuleEngine?: () => { analyze(): { metaRules: unknown[] } }
+  getErrorSignatureDB?: () => {
+    getStats(): {
+      total: number
+      active: number
+      degraded: number
+      retired: number
+      avgSuccessRate: number
+      totalInterceptions: number
+    }
+  }
+  getConstitutionLoader?: () => {
+    load(): { version: string; principles: Array<{ facet?: string }>; preamble?: string }
+  }
+  getSelfCritique?: () => { getConfig(): { enabled: boolean } }
+}
+
+/** 元规则分析是报告里最重/最脆弱的一步——独立隔离，失败时归零而非让整份报告崩溃。 */
+function safeMetaRuleCount(engine: CapabilitySources): number {
+  try {
+    return engine.getMetaRuleEngine?.()?.analyze().metaRules.length ?? 0
+  } catch {
+    return 0
+  }
+}
+
+export function buildCapabilityReport(engine: CapabilitySources): string {
+  const lines: string[] = ['## 🧭 能力自报告 (CRSI Inventory)', '']
+
+  // ── 🧠 学习 (CRSI) ──
+  const rules = engine.getRuleEngine?.()?.getActiveRules() ?? []
+  const builtin = rules.filter((r) => r.source === 'builtin').length
+  const auto = rules.filter((r) => r.source === 'pattern-analyzer').length
+  const manual = rules.filter((r) => r.source === 'manual').length
+  const patterns = engine.getPatternAnalyzer?.()?.analyzeAllAgents() ?? []
+  const insights = engine.getAutoMemory?.()?.accumulatedInsights ?? []
+
+  lines.push('### 🧠 学习 (CRSI)', '')
+  lines.push('| 指标 | 值 |')
+  lines.push('|------|----|')
+  lines.push(`| 活跃规则 | ${rules.length} (内置 ${builtin} · 自动 ${auto} · 手动 ${manual}) |`)
+  lines.push(`| 已检测模式 | ${patterns.length} |`)
+  lines.push(`| 反思洞察 | ${insights.length} |`)
+  lines.push(`| 元规则 | ${safeMetaRuleCount(engine)} |`)
+
+  // ── 🛡️ 免疫 (SIS) ──
+  const sis = engine.getErrorSignatureDB?.()?.getStats()
+  lines.push('', '### 🛡️ 免疫 (SIS)', '')
+  if (sis) {
+    lines.push('| 指标 | 值 |')
+    lines.push('|------|----|')
+    lines.push(
+      `| 错误签名 | ${sis.total} 条 (🟢${sis.active} · 🟡${sis.degraded} · ⚫${sis.retired}) |`,
+    )
+    lines.push(`| 平均成功率 | ${Math.round(sis.avgSuccessRate * 100)}% |`)
+    lines.push(`| 总拦截 | ${sis.totalInterceptions} 次 |`)
+  } else {
+    lines.push('_未初始化_')
+  }
+
+  // ── 🔒 宪法 (对齐) ──
+  const constitution = engine.getConstitutionLoader?.()?.load()
+  lines.push('', '### 🔒 宪法 (对齐)', '')
+  if (constitution) {
+    const karuna = constitution.principles.filter((p) => p.facet === 'karuna').length
+    const prajna = constitution.principles.filter((p) => p.facet === 'prajna').length
+    const vajra = constitution.principles.filter((p) => p.facet === 'vajra').length
+    lines.push('| 指标 | 值 |')
+    lines.push('|------|----|')
+    lines.push(`| 版本 | ${constitution.version} |`)
+    lines.push(
+      `| 原则 | ${constitution.principles.length} 条 (悲 ${karuna} · 智 ${prajna} · 金刚 ${vajra}) |`,
+    )
+    lines.push(`| 愿力序言 | ${constitution.preamble ? '已注入 self-critique' : '无'} |`)
+  } else {
+    lines.push('_未初始化_')
+  }
+
+  // ── ⚠️ 未接线 / 待启用 ──
+  const selfCritique = engine.getSelfCritique?.()?.getConfig()
+  lines.push('', '### ⚠️ 未接线 / 待启用', '')
+  lines.push(`| self-critique | ${selfCritique?.enabled ? '🟢 已启用' : '⚫ 未启用 (opt-in)'} |`)
+
+  return lines.join('\n')
+}

package/src/core/constitution-loader.ts

@@ -16,6 +16,7 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
+import alignmentVocabulary from './alignment-vocabulary.json' with { type: 'json' }
 
 // ── Types ──
 
@@ -36,6 +37,8 @@ export interface ConstitutionalPrinciple {
   tools?: string[]
   /** Optional: human explanation of why this principle exists */
   rationale?: string
+  /** Optional: which alignment value (karuna/prajna/vajra) this principle operationalizes. */
+  facet?: string
 }
 
 export interface MiphamConstitution {
@@ -45,80 +48,25 @@ export interface MiphamConstitution {
   last_modified: string
   /** The principles themselves */
   principles: ConstitutionalPrinciple[]
+  /** 序言（愿力）：从对齐词汇表 values 派生的正向誓愿（悲/智/金刚），非禁令。 */
+  preamble?: string
 }
 
-// ── Default Constitution ──
-
-const DEFAULT_CONSTITUTION: MiphamConstitution = {
-  version: '1.0.0',
-  last_modified: '2026-08-12',
-  principles: [
-    {
-      id: 'never-fabricate',
-      text: '禁止编造数据、文件内容、API 响应或测试结果。每个输出必须可追溯至真实来源或明确标注为推测。',
-      enforce: 'block',
-      audit_pattern:
-        '(fabricated|made.up|dummy.data|fake\s+(response|result|data)|placeholder\s+data)',
-      scope: 'all-tools',
-      rationale: 'MiphamAI4S 科学诚信原则：编造数据是不可接受的底线违反。适用于所有工具和输出。',
-    },
-    {
-      id: 'no-credential-leak',
-      text: '禁止在代码、日志、配置文件、提交信息、对话输出中写入或泄露凭据、API 密钥、令牌。',
-      enforce: 'block',
-      audit_pattern: '(apiKey|api_key|password|secret|token|credential)\\s*[=:]\\s*[\'"][^\'"]{8,}',
-      scope: 'Write,Edit,Bash',
-      rationale: 'Rismed Ronxin Capital 合规要求：硬编码凭据违反安全底线。',
-    },
-    {
-      id: 'minimal-change',
-      text: '只修改被明确要求的文件和代码。不顺手改动相邻代码、格式或注释。不重构未损坏的代码。',
-      enforce: 'warn',
-      scope: 'Write,Edit',
-      tools: ['Write', 'Edit'],
-      rationale: 'AI 编码原则 #3（精准修改）：diff 中每一行改动都应可直接追溯到用户要求。',
-    },
-    {
-      id: 'think-before-coding',
-      text: '不确定时必须提问，不得自行假设。存在多种解读时呈现所有选项，不沉默选择一个。',
-      enforce: 'warn',
-      scope: 'pre-inference',
-      hook: 'pre-inference',
-      rationale: 'AI 编码原则 #1（编码前先思考）：偏差谨慎。',
-    },
-    {
-      id: 'simplicity-first',
-      text: '只写解决问题所需的最小代码。不添加未被要求的灵活性、可配置性或抽象层。',
-      enforce: 'warn',
-      scope: 'Write,Edit',
-      tools: ['Write', 'Edit'],
-      rationale: 'AI 编码原则 #2（简洁优先）：一次性代码不需要抽象层。',
-    },
-    {
-      id: 'respect-permissions',
-      text: '尊重用户权限设置。绝不绕过或降级权限检查。Bypass 模式仅限用户明确授权。',
-      enforce: 'block',
-      scope: 'all-tools',
-      rationale: '权限系统是最后一道防线。任何绕过尝试都应被拦截并记录。',
-    },
-    {
-      id: 'no-destructive-without-confirmation',
-      text: '删除文件、强制推送、修改生产配置等破坏性操作前必须获得用户确认。',
-      enforce: 'block',
-      audit_pattern: '(rm\\s+-rf|git\\s+push\\s+--force|DROP\\s+TABLE|DELETE\\s+FROM)',
-      scope: 'Bash',
-      tools: ['Bash'],
-      rationale: '防止不可逆操作。即使 bypass 模式也应二次确认。',
-    },
-    {
-      id: 'persist-crsi-learning',
-      text: '每次工具调用失败后必须记录 ErrorSignature 到 ErrorSignatureDB。从错误中持续学习。',
-      enforce: 'auto',
-      scope: 'post-tool-use',
-      hook: 'post-tool-use',
-      rationale: 'CRSI 核心机制：不重复犯同样的错误。自动执行，无需人类参与。',
-    },
-  ],
+// ── Default Constitution (derived from the shared alignment vocabulary) ──
+
+/** 从对齐词汇表的三个价值面派生「愿力」序言——正向誓愿，而非禁令。 */
+function derivePreamble(): string {
+  const parts = alignmentVocabulary.values
+    .map((v) => `以${v.name_zh}（${v.name_en}）——${v.definition}`)
+    .join('；')
+  return `愿力（序言）：${parts}。愿不生成违规之倾向，而非仅避免违规之行为。`
+}
+
+export const DEFAULT_CONSTITUTION: MiphamConstitution = {
+  version: alignmentVocabulary.version,
+  last_modified: '2026-08-16',
+  principles: alignmentVocabulary.principles as unknown as ConstitutionalPrinciple[],
+  preamble: derivePreamble(),
 }
 
 // ── Loader ──
@@ -307,6 +255,9 @@ export class ConstitutionLoader {
       case 'rationale':
         p.rationale = val
         break
+      case 'facet':
+        p.facet = val
+        break
     }
   }
 
@@ -340,6 +291,7 @@ export class ConstitutionLoader {
       lines.push(`  - id: "${p.id}"`)
       lines.push(`    text: "${p.text}"`)
       lines.push(`    enforce: ${p.enforce}`)
+      if (p.facet) lines.push(`    facet: ${p.facet}`)
       if (p.audit_pattern) lines.push(`    audit_pattern: "${p.audit_pattern}"`)
       if (p.scope) lines.push(`    scope: "${p.scope}"`)
       if (p.hook) lines.push(`    hook: ${p.hook}`)

package/src/core/constitution-seam.ts

@@ -0,0 +1,18 @@
+import type { Context, Disposer, Constitution } from '../vajra'
+import { CONSTITUTION_KEY } from '../vajra'
+import { ConstitutionLoader } from './constitution-loader'
+
+/** 默认对齐缝实现：桥接 ConstitutionLoader，校验声明的原则 id 均为已知原则。 */
+export function createConstitution(loader: ConstitutionLoader): Constitution {
+  return {
+    check(aligned) {
+      const known = new Set(loader.load().principles.map((p) => p.id))
+      return { violations: aligned.filter((id) => !known.has(id)) }
+    },
+  }
+}
+
+/** 把一个 Constitution 挂载为 ctx.constitution（对齐缝）。 */
+export function mountConstitution(ctx: Context, constitution: Constitution): Disposer {
+  return ctx.provide(CONSTITUTION_KEY, constitution)
+}

package/src/core/crsi-modify.ts

@@ -0,0 +1,117 @@
+/**
+ * CRSI Self-Modification Seam — 给 CrsiSandbox 一个真实入口。
+ *
+ * CrsiSandbox 是一个「等输入的消费者」：它做 worktree → 改文件 → 跑测试 →
+ * 人类批准 → merge，但此前没有任何东西产出它的输入 `CrsiModification`。
+ *
+ * 本模块补上「入口」这一端：
+ *   - `runCrsiModification` 编排完整 5 阶段，是程序化 seam（未来的 producer 直接调它）。
+ *   - `approvePending` / `rejectPending` 实现「人类批准/拒绝」的两阶段闸门。
+ *
+ * 注意：merge 只发生在显式 `approvePending` 之后——人类门保留。本模块
+ * 不自动产出改动候选（producer 是独立的下一步）。
+ */
+
+import { randomUUID } from 'node:crypto'
+import { CrsiSandbox } from './crsi-sandbox'
+import type { CrsiModificationResult } from './crsi-sandbox'
+import { runEval, appendEvalScore, getLastEvalScore } from './eval-harness'
+
+export interface CrsiProposal {
+  /** 人类可读的改动说明 */
+  description: string
+  /** 目标文件（相对仓库根，如 apps/cli/src/foo.ts） */
+  filePath: string
+  /** 改动后的完整文件内容 */
+  newContent: string
+  /** 改动前内容（用于安全性校验；空 = 宽松跳过） */
+  originalContent?: string
+  /** 触发此改动的 CRSI insight id */
+  crsiInsightId?: string
+}
+
+// ── Pending proposal registry (两阶段闸门) ──
+// 模块级单例：成功跑完测试的修改停在这里，等待人类 approve / reject。
+let pendingSandbox: CrsiSandbox | null = null
+
+/**
+ * 编排完整 5 阶段：createWorktree → applyModification → runTests →（失败自动
+ * rollback）→ getDiff。测试通过后暂存为 pending，返回 diff 供人类审阅。
+ */
+export function runCrsiModification(
+  proposal: CrsiProposal,
+  sandbox: CrsiSandbox = new CrsiSandbox(),
+): CrsiModificationResult {
+  sandbox.createWorktree()
+
+  const applied = sandbox.applyModification({
+    id: `crsi-mod-${randomUUID().slice(0, 8)}`,
+    description: proposal.description,
+    filePath: proposal.filePath,
+    newContent: proposal.newContent,
+    originalContent: proposal.originalContent ?? '',
+    crsiInsightId: proposal.crsiInsightId,
+    timestamp: new Date().toISOString(),
+  })
+
+  // apply 失败（受保护路径 / 路径穿越 / 内容不一致）——不跑测试，直接回滚。
+  if (!applied.applied) {
+    sandbox.rollback()
+    applied.phase = 'failed' // rollback() 会把 phase 置为 'rolled-back'；恢复为 'failed'
+    return applied
+  }
+
+  const testResult = sandbox.runTests()
+  applied.testResult = testResult
+
+  if (!testResult.passed) {
+    sandbox.rollback()
+    applied.phase = 'failed'
+    return applied
+  }
+
+  // Eval harness gate：CRSI 契约分数不得低于上次记录（防跨合并退化）。
+  // 分数反映「当前代码」的 CRSI 契约（隔离组件，与本次 worktree 改动无关），
+  // 所以它是「仓库的 CRSI 代码自上次评估以来是否退化」的哨兵。
+  const evalReport = runEval()
+  const last = getLastEvalScore()
+  if (last !== null && evalReport.score < last) {
+    sandbox.rollback()
+    applied.phase = 'failed'
+    applied.error = `Eval regression: score ${evalReport.score} < last ${last}`
+    return applied
+  }
+  appendEvalScore(evalReport)
+
+  applied.phase = 'passed'
+  applied.diff = sandbox.getDiff()
+  pendingSandbox = sandbox
+  return applied
+}
+
+/** 是否有待批准的修改。 */
+export function hasPending(): boolean {
+  return pendingSandbox !== null
+}
+
+/** 人类批准：merge 进仓库并清理 worktree。 */
+export function approvePending(): { success: boolean; message: string } {
+  if (!pendingSandbox) {
+    return { success: false, message: '没有待批准的修改。先运行 /crsi modify。' }
+  }
+  const sandbox = pendingSandbox
+  pendingSandbox = null
+  const merged = sandbox.merge()
+  sandbox.finalize()
+  return merged
+}
+
+/** 人类拒绝：丢弃 worktree。 */
+export function rejectPending(): { success: boolean; message: string } {
+  if (!pendingSandbox) {
+    return { success: false, message: '没有待批准的修改。先运行 /crsi modify。' }
+  }
+  const sandbox = pendingSandbox
+  pendingSandbox = null
+  return sandbox.rollback()
+}

package/src/core/crsi-producer.ts

@@ -0,0 +1,98 @@
+/**
+ * CRSI Producer — 把累积的失败信号转成「教训文件」代码改动候选。
+ *
+ * 这是 CRSI 闭环「reflect → verify → consolidate」的 reflect→verify 桥：
+ *   - 输入：AutoMemoryEngine 的 CrsiInsight + MetaRuleEngine 的 MetaRule（都是「建议」）。
+ *   - 输出：一个 CrsiProposal —— 对 `crsi-lessons.md` 的追加（模板化，不动 LLM 判断）。
+ *   - 走 runCrsiModification（沙箱 gate）→ 人类批准 → merge。
+ *
+ * 诚实标注：沙箱的 verify 是「防回归」（测试仍绿），不是「证明更好」——
+ * 后者需要 ground-truth eval harness，是独立的下一步。
+ */
+
+import type { CrsiInsight } from './auto-memory'
+import type { MetaRule } from './meta-rule-engine'
+
+/** 教训文件（相对仓库根）。预建，沙箱只能改已存在文件。 */
+export const LESSONS_FILE = 'apps/cli/crsi-lessons.md'
+
+/** 归一化的教训信号（insight 与 meta-rule 的公共面）。 */
+export interface CrsiSignal {
+  category: string
+  title: string
+  severity?: string
+  suggestion: string
+  evidence: string[]
+}
+
+const SEVERITY_RANK: Record<string, number> = { critical: 0, warning: 1, info: 2 }
+
+/**
+ * 选一条「最该固化成教训」的信号：
+ *   1. 优先 autoApplicable 的 insight，按严重度排序（critical > warning > info）。
+ *   2. 没有 insight 时，回退到高置信、autoApplicable 的元规则。
+ */
+export function selectCrsiSignal(
+  insights: CrsiInsight[],
+  metaRules: MetaRule[],
+): CrsiSignal | null {
+  const best = insights
+    .filter((i) => i.autoApplicable)
+    .sort((a, b) => (SEVERITY_RANK[a.severity] ?? 3) - (SEVERITY_RANK[b.severity] ?? 3))[0]
+  if (best) {
+    return {
+      category: best.category,
+      title: best.description,
+      severity: best.severity,
+      suggestion: best.suggestion,
+      evidence: best.evidence,
+    }
+  }
+
+  const mr = metaRules.find((m) => m.autoApplicable && m.confidence === 'high')
+  if (mr) {
+    return {
+      category: mr.category,
+      title: mr.title,
+      suggestion: mr.recommendation,
+      evidence: [mr.evidence.summary],
+    }
+  }
+
+  return null
+}
+
+/** 模板化地把信号渲染成一段教训 markdown（不动 LLM）。 */
+export function buildLessonContent(signal: CrsiSignal, timestamp: string): string {
+  const lines: string[] = [
+    `## ${signal.category}: ${signal.title}`,
+    '',
+    `- 建议: ${signal.suggestion}`,
+  ]
+  if (signal.severity) lines.push(`- 严重度: ${signal.severity}`)
+  lines.push(`- 生成时间: ${timestamp}`, '- 来源: CRSI producer (autoApplicable)', '', '### 证据')
+  for (const e of signal.evidence) lines.push(`- ${e}`)
+  lines.push('')
+  return lines.join('\n')
+}
+
+/** 产出教训文件变更候选。无合格信号时返回 null。 */
+export function produceCrsiProposal(
+  insights: CrsiInsight[],
+  metaRules: MetaRule[],
+  currentLessons: string,
+  timestamp: string,
+): { description: string; filePath: string; newContent: string; originalContent: string } | null {
+  const signal = selectCrsiSignal(insights, metaRules)
+  if (!signal) return null
+
+  const lesson = buildLessonContent(signal, timestamp)
+  const newContent = currentLessons ? `${currentLessons.trimEnd()}\n\n${lesson}\n` : `${lesson}\n`
+
+  return {
+    description: `CRSI lesson: ${signal.category} — ${signal.title}`,
+    filePath: LESSONS_FILE,
+    newContent,
+    originalContent: currentLessons,
+  }
+}

package/src/core/crsi-sandbox.ts

@@ -88,6 +88,36 @@ const MAX_WORKTREE_AGE_MS = 30 * 60 * 1000 // 30 minutes
 const TEST_TIMEOUT_MS = 120_000 // 2 minutes
 const REPORT_DIR = join(homedir(), '.mipham', 'crsi-sandbox')
 
+/**
+ * 自改进循环的只读边界（信任域隔离）。
+ *
+ * 这些路径是 CRSI 自改进的「慢通道」——宪法、eval harness、改进机制自身。
+ * 自改进循环可以改 skill/workflow/prompt/memory，但绝不能改：
+ *   1. 宪法（对齐本体 + 对齐缝 + 加载器）—— 否则价值漂移会「优化」掉安全边界
+ *   2. eval harness（测试套件）—— 否则会改掉自己的评估标准（Goodhart 元劫持）
+ *   3. 改进机制自身（有效性追踪 / 元规则引擎 / 沙箱）—— 否则递归会改掉评估器
+ *
+ * 注意：这是 fail-closed 边界——宁可多拦，不可漏拦。
+ */
+const PROTECTED_PATHS = [
+  // 宪法（对齐）
+  'apps/cli/src/core/alignment-vocabulary.json',
+  'apps/cli/src/core/constitution-loader.ts',
+  'apps/cli/src/core/constitution-seam.ts',
+  'apps/cli/src/vajra/constitution.ts',
+  // eval harness
+  'apps/cli/test/',
+  // 改进机制自身
+  'apps/cli/src/agent/effectiveness-tracker.ts',
+  'apps/cli/src/core/meta-rule-engine.ts',
+  'apps/cli/src/core/crsi-sandbox.ts',
+]
+
+/** 是否命中只读边界。前缀匹配，目录条目以 `/` 结尾。 */
+export function isProtectedPath(filePath: string): boolean {
+  return PROTECTED_PATHS.some((p) => filePath === p || filePath.startsWith(p))
+}
+
 // ── Sandbox ──
 
 export class CrsiSandbox {
@@ -183,6 +213,15 @@ export class CrsiSandbox {
       return result
     }
 
+    // Protected-path guard: the self-improvement loop must not modify the
+    // constitution, eval harness, or improvement machinery itself.
+    if (isProtectedPath(mod.filePath)) {
+      result.error = `Protected path: "${mod.filePath}" is read-only to the self-improvement loop.`
+      result.phase = 'failed'
+      this.sessionReport.modifications.push(result)
+      return result
+    }
+
     // Verify the file exists in the worktree
     if (!existsSync(targetPath)) {
       result.error = `File not found in worktree: ${mod.filePath}`

package/src/core/eval-harness.ts

@@ -0,0 +1,184 @@
+/**
+ * CRSI Eval Harness — 冻结的 ground-truth 契约评估。
+ *
+ * 自改进环的「verify」升级：单测只能证明「测试仍绿」（防回归），
+ * 本 harness 用一组人类冻结的、无 LLM 的客观断言给 CRSI 机制打分，
+ * 并把分数持久化到 rewards 日志——这样「变好了还是变差了」才可被回答。
+ *
+ * 设计约束（对应 path A 的 A1 铁律）：
+ *   - 每条任务用可机器判定的 ground truth，绝不拿 LLM 当裁判。
+ *   - 用隔离组件（tmpdir），不读用户 ~/.mipham 的运行时状态——
+ *     harness 量的是「CRSI 机制代码是否满足冻结契约」，与用户数据无关。
+ */
+
+import { join } from 'node:path'
+import { tmpdir, homedir } from 'node:os'
+import { mkdirSync, appendFileSync, readFileSync, existsSync } from 'node:fs'
+import { ExperienceRuleEngine } from './rule-engine'
+import { ConstitutionLoader, DEFAULT_CONSTITUTION } from './constitution-loader'
+import { ErrorSignatureDB } from './error-signature-db'
+import { PreFlightChecker } from './preflight-checker'
+import { RedTeam } from './red-team'
+import { isProtectedPath } from './crsi-sandbox'
+
+// ── Types ──
+
+export interface EvalResult {
+  id: string
+  description: string
+  passed: boolean
+  detail?: string
+}
+
+export interface EvalReport {
+  total: number
+  passed: number
+  /** 0-100 */
+  score: number
+  results: EvalResult[]
+  failures: string[]
+}
+
+// ── Rewards log (path A Phase 1: 奖励信号持久化) ──
+
+const SCORES_FILE = join(homedir(), '.mipham', 'crsi', 'eval-scores.jsonl')
+
+/** 追加一次评估分数到 rewards 日志。 */
+export function appendEvalScore(report: EvalReport): void {
+  try {
+    mkdirSync(join(homedir(), '.mipham', 'crsi'), { recursive: true })
+    appendFileSync(
+      SCORES_FILE,
+      JSON.stringify({
+        timestamp: new Date().toISOString(),
+        score: report.score,
+        passed: report.passed,
+        total: report.total,
+      }) + '\n',
+      'utf-8',
+    )
+  } catch {
+    // rewards 日志是非关键的——失败不影响评估本身
+  }
+}
+
+/** 读取最近一次评估分数（无记录时返回 null）。 */
+export function getLastEvalScore(): number | null {
+  try {
+    if (!existsSync(SCORES_FILE)) return null
+    const lines = readFileSync(SCORES_FILE, 'utf-8').trim().split('\n').filter(Boolean)
+    if (lines.length === 0) return null
+    const last = JSON.parse(lines[lines.length - 1]!) as { score?: number }
+    return typeof last.score === 'number' ? last.score : null
+  } catch {
+    return null
+  }
+}
+
+// ── Harness ──
+
+/** 构建隔离组件，避免读用户 ~/.mipham 运行时状态。 */
+function buildIsolatedComponents() {
+  const dir = join(tmpdir(), 'mipham-eval-harness')
+  const ruleEngine = new ExperienceRuleEngine(join(dir, 'rules'))
+  const constitution = new ConstitutionLoader(join(dir, 'constitution.yml'))
+  const errorDB = new ErrorSignatureDB(join(dir, 'sis'))
+  const preflight = new PreFlightChecker(errorDB, ruleEngine)
+  return { ruleEngine, constitution, errorDB, preflight }
+}
+
+export function runEval(): EvalReport {
+  const { ruleEngine, constitution, errorDB, preflight } = buildIsolatedComponents()
+
+  const results: EvalResult[] = []
+
+  // ── 规则引擎（ground truth：内置契约） ──
+  const timeout = ruleEngine.intercept('Bash', {
+    command: 'npm install express',
+    timeout: 120000,
+    description: 'install deps',
+  })
+  results.push({
+    id: 'rule-timeout',
+    description: '内置 timeout 规则命中低超时的 npm install',
+    passed: timeout.modified.timeout === 300000,
+  })
+
+  const gitForce = ruleEngine.intercept('Bash', {
+    command: 'git push --force origin main',
+    description: 'force push',
+  })
+  results.push({
+    id: 'rule-git-force',
+    description: 'git --force 触发告警',
+    passed: gitForce.warnings.length > 0,
+  })
+
+  const disabledRule: import('./rule-engine').ToolRule = {
+    id: 'eval-disabled-test',
+    toolName: 'Read',
+    category: 'tool-params',
+    match: () => true,
+    fix: (p) => ({ modified: p, warning: 'should not appear' }),
+    source: 'manual',
+    enabled: false,
+  }
+  ruleEngine.register(disabledRule)
+  const disabled = ruleEngine.intercept('Read', { file_path: '/tmp/x.txt' })
+  results.push({
+    id: 'rule-disabled-skip',
+    description: '禁用规则被跳过',
+    passed: disabled.warnings.length === 0,
+  })
+
+  // ── 宪法（ground truth：8 原则 + facet 映射 + 愿力序言） ──
+  const principles = DEFAULT_CONSTITUTION.principles
+  results.push({
+    id: 'constitution-8-principles',
+    description: '宪法含 8 条原则',
+    passed: principles.length === 8,
+  })
+
+  const prajna = principles.filter((p) => p.facet === 'prajna').length
+  const vajra = principles.filter((p) => p.facet === 'vajra').length
+  const karuna = principles.filter((p) => p.facet === 'karuna').length
+  results.push({
+    id: 'constitution-facets',
+    description: 'facet 映射 智3 / 金刚5 / 悲0',
+    passed: prajna === 3 && vajra === 5 && karuna === 0,
+  })
+
+  results.push({
+    id: 'constitution-preamble',
+    description: '愿力序言已注入',
+    passed: !!DEFAULT_CONSTITUTION.preamble && DEFAULT_CONSTITUTION.preamble.includes('悲'),
+  })
+
+  // ── 沙箱只读边界（ground truth：受保护路径被拒） ──
+  const protectedChecks: Array<[string, string]> = [
+    ['sandbox-protected-constitution', 'apps/cli/src/core/alignment-vocabulary.json'],
+    ['sandbox-protected-tests', 'apps/cli/test/foo.test.ts'],
+    ['sandbox-protected-machinery', 'apps/cli/src/core/crsi-sandbox.ts'],
+  ]
+  for (const [id, path] of protectedChecks) {
+    results.push({ id, description: `受保护路径被拒: ${path}`, passed: isProtectedPath(path) })
+  }
+
+  // ── 安全（ground truth：16 攻击零漏过） ──
+  const redTeam = new RedTeam().run(constitution, preflight, errorDB)
+  results.push({
+    id: 'red-team-zero-gaps',
+    description: '16 个对抗场景零漏过',
+    passed: redTeam.passedThrough === 0,
+    detail: `score=${redTeam.score}, passedThrough=${redTeam.passedThrough}, falsePositives=${redTeam.falsePositives}`,
+  })
+
+  const passed = results.filter((r) => r.passed).length
+  return {
+    total: results.length,
+    passed,
+    score: results.length > 0 ? Math.round((passed / results.length) * 100) : 100,
+    results,
+    failures: results.filter((r) => !r.passed).map((r) => r.id),
+  }
+}

package/src/core/instructions.ts

@@ -153,6 +153,16 @@ Script format: export const meta = { name, description, phases: [...] }
 - When you need to search AND read results: Glob → Grep → Read
   (find files, search contents, then read the matching files)`)
 
+    // CRSI 能力自报告 — 回答自身能力边界前先查实时状态，勿凭静态清单推断
+    parts.push(`## Capability Self-Report Rule
+
+When asked about your own capabilities ("what can you do", "what do you
+have / what is missing", "are you able to X"), do NOT infer the answer
+from your static tool list. Run \`/crsi inventory\` first and answer from
+its live CRSI / SIS / constitution state. Report the numbers you read
+from it as live counts; if it shows a subsystem as 未初始化 (uninitialized),
+say so explicitly instead of claiming it exists.`)
+
     return parts.join('\n\n---\n\n')
   }
 

package/src/core/red-team.ts

@@ -240,9 +240,13 @@ export class RedTeam {
     constitution: ConstitutionLoader,
     preflight: PreFlightChecker,
   ): RedTeamResult {
-    // 1. Check against constitution audit patterns
-    const paramsStr = JSON.stringify(attack.params)
-    const constitutionViolations = constitution.audit(paramsStr)
+    // 1. Check against constitution audit patterns — audit the raw string values,
+    //    not JSON.stringify (which escapes `"` → `\"` and breaks quote-matching
+    //    patterns like no-credential-leak's `password = "..."`).
+    const content = Object.values(attack.params)
+      .filter((v): v is string => typeof v === 'string')
+      .join('\n')
+    const constitutionViolations = constitution.audit(content)
     if (constitutionViolations.length > 0) {
       return {
         attack,

package/src/core/self-critique.ts

@@ -20,6 +20,7 @@
 
 import type { ProviderRegistry } from '../providers/registry'
 import type { Llm } from '../providers/llm'
+import { DEFAULT_CONSTITUTION } from './constitution-loader'
 
 // ── Types ──
 
@@ -62,7 +63,12 @@ export const DEFAULT_SELF_CRITIQUE_CONFIG: SelfCritiqueConfig = {
 
 // ── Prompt Templates ──
 
-const CRITIQUE_PROMPT = `You are a safety auditor for an AI coding agent. Evaluate the following tool call:
+const CRITIQUE_PROMPT = `You are a safety auditor for an AI coding agent. Evaluate the following tool call.
+
+ALIGNMENT PREAMBLE（愿力序言）:
+{preamble}
+
+First, align to the vow: does this action embody compassion (悲) and sober causal judgment (智), and maintain structural integrity (金刚)?
 
 TOOL: {toolName}
 PARAMETERS: {params}
@@ -93,6 +99,19 @@ Necessity criteria:
 - Not redundant with previous tool calls
 - Not an unnecessary "exploratory" action`
 
+/** Build the critique prompt with the alignment preamble injected before the prohibitions. */
+export function buildCritiquePrompt(
+  toolName: string,
+  params: Record<string, unknown>,
+  context: string | undefined,
+  preamble: string,
+): string {
+  return CRITIQUE_PROMPT.replace('{preamble}', preamble)
+    .replace('{toolName}', toolName)
+    .replace('{params}', JSON.stringify(params, null, 2).slice(0, 500))
+    .replace('{context}', context?.slice(0, 300) || 'No additional context')
+}
+
 // ── Critic ──
 
 export class SelfCritique {
@@ -135,9 +154,12 @@ export class SelfCritique {
       return null
     }
 
-    const prompt = CRITIQUE_PROMPT.replace('{toolName}', toolName)
-      .replace('{params}', JSON.stringify(params, null, 2).slice(0, 500))
-      .replace('{context}', context?.slice(0, 300) || 'No additional context')
+    const prompt = buildCritiquePrompt(
+      toolName,
+      params,
+      context,
+      DEFAULT_CONSTITUTION.preamble ?? '',
+    )
 
     try {
       const critiqueModel = this.config.model || this.findFastestModel(registry)

package/src/index.tsx

@@ -36,6 +36,8 @@ import { createToolRegistry } from './tools'
 import { Context } from './vajra'
 import { mountSkills, SKILLS_KEY } from './skills/seam'
 import { mountLlm, LLM_KEY } from './providers/llm'
+import { mountConstitution, createConstitution } from './core/constitution-seam'
+import { ConstitutionLoader } from './core/constitution-loader'
 import { McpClient } from './mcp/client'
 import { registerMcpServerTools } from './mcp/registry'
 import { AgentRegistry } from './agent/agent-registry'
@@ -447,6 +449,9 @@ export async function runApp(options: RunOptions): Promise<void> {
   const vajraContext = new Context()
   vajraContext.provide('credentials', credentialMaskingConfig)
 
+  // 对齐缝：宪法先就位，后续每个 Service 挂载（含工具）都在挂载前过对齐门。
+  mountConstitution(vajraContext, createConstitution(new ConstitutionLoader()))
+
   // Create tool registry with all built-in tools (mounted as Vajra services)
   const tools = createToolRegistry(vajraContext)
 
@@ -610,6 +615,16 @@ export async function runApp(options: RunOptions): Promise<void> {
   process.on('exit', () => {
     clearInterval(heartbeatInterval)
     unregisterSession(sessionName)
+    // Close the CRSI effectiveness loop on non-interactive exit paths
+    // (daemon worker / crash / kill) that bypass saveAndExit. saveAndExit
+    // already flushes; guard on !saved to avoid double-evaluating.
+    if (!saved) {
+      try {
+        engine.getAutoMemory().flushEffectiveness()
+      } catch {
+        // ignore — CRSI flush is non-critical
+      }
+    }
     if (!saved && context.getMessageCount() > 0) {
       SessionStore.autoSave(context.getMessages(), {
         provider: defaultProvider,

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.41.0' as const
+export const PACKAGE_VERSION = '0.43.0' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const

package/src/ui/commands.ts

@@ -10,6 +10,10 @@ import type { SkillsLoader } from '../skills/loader'
 import type { PluginManager } from '../plugin/plugin-manager'
 import type { Message } from '../shared/types.js'
 import { McpClient } from '../mcp/client'
+import { buildCapabilityReport } from '../core/capability-inventory'
+import { runCrsiModification, approvePending, rejectPending, hasPending } from '../core/crsi-modify'
+import { produceCrsiProposal, LESSONS_FILE } from '../core/crsi-producer'
+import { runEval, appendEvalScore } from '../core/eval-harness'
 import { NPM_UPDATE_COMMAND, PACKAGE_VERSION } from '../shared/index.ts'
 import { getPreference } from '../config/preferences'
 import { loadCrossSessionConfig } from '../config/loader'
@@ -731,6 +735,123 @@ const crsiStatsCmd: CommandHandler = async (ctx) => {
   return { content: lines.join('\n') }
 }
 
+const crsiInventoryCmd: CommandHandler = async (ctx) => {
+  return { content: buildCapabilityReport(ctx.engine) }
+}
+
+const crsiModifyCmd: CommandHandler = async (ctx, args) => {
+  if (args[0] === '--approve') {
+    const r = approvePending()
+    return { content: r.success ? `✅ ${r.message}` : `⚠️ ${r.message}` }
+  }
+  if (args[0] === '--reject') {
+    const r = rejectPending()
+    return { content: r.success ? `✅ ${r.message}` : `⚠️ ${r.message}` }
+  }
+  if (args.length < 3) {
+    return {
+      content:
+        'Usage: /crsi modify <description> <filePath> <newContent>\n' +
+        '- description 单 token（不含空格）\n' +
+        '- newContent 用 \\n 表示换行\n' +
+        '测试通过后：/crsi modify --approve 合并，/crsi modify --reject 丢弃',
+    }
+  }
+  if (hasPending()) {
+    return { content: '⚠️ 已有待批准的修改。先 /crsi modify --approve 或 --reject。' }
+  }
+
+  const description = args[0]!
+  const filePath = args[1]!
+  const newContent = args.slice(2).join(' ').replace(/\\n/g, '\n')
+
+  let originalContent = ''
+  try {
+    const { readFileSync } = await import('node:fs')
+    const { join } = await import('node:path')
+    originalContent = readFileSync(join(process.cwd(), filePath), 'utf-8')
+  } catch {
+    // 文件不存在 → 宽松模式（originalContent 为空）
+  }
+
+  const result = runCrsiModification({ description, filePath, newContent, originalContent })
+  if (!result.applied || result.phase === 'failed') {
+    return {
+      content: `❌ 修改未通过（phase: ${result.phase}）。\n${result.error ?? ''}`,
+    }
+  }
+
+  return {
+    content:
+      `✅ 测试通过。审阅下方 diff：\n\n${result.diff}\n\n` +
+      '/crsi modify --approve  合并\n/crsi modify --reject   丢弃',
+  }
+}
+
+const crsiProposeCmd: CommandHandler = async (ctx) => {
+  if (hasPending()) {
+    return { content: '⚠️ 已有待批准的修改。先 /crsi modify --approve 或 --reject。' }
+  }
+
+  const insights = ctx.engine.getAutoMemory?.()?.accumulatedInsights ?? []
+  let metaRules: Parameters<typeof produceCrsiProposal>[1] = []
+  try {
+    metaRules = ctx.engine.getMetaRuleEngine?.()?.analyze().metaRules ?? []
+  } catch {
+    metaRules = []
+  }
+
+  // 教训文件按仓库根解析（沙箱的 filePath 是仓库根相对）。
+  let current = ''
+  try {
+    const { readFileSync } = await import('node:fs')
+    const { join } = await import('node:path')
+    const root = execSync('git rev-parse --show-toplevel', {
+      timeout: 5000,
+      encoding: 'utf-8',
+    }).trim()
+    current = readFileSync(join(root, LESSONS_FILE), 'utf-8')
+  } catch {
+    current = ''
+  }
+
+  const proposal = produceCrsiProposal(insights, metaRules, current, new Date().toISOString())
+
+  if (!proposal) {
+    return { content: '没有足够的失败信号（autoApplicable insight 或高置信元规则）来生成教训。' }
+  }
+
+  const result = runCrsiModification(proposal)
+  if (!result.applied || result.phase === 'failed') {
+    return { content: `❌ 生成失败（phase: ${result.phase}）。\n${result.error ?? ''}` }
+  }
+
+  return {
+    content:
+      `✅ 已生成教训并跑过测试。审阅 diff：\n\n${result.diff}\n\n` +
+      '/crsi modify --approve 合并 | /crsi modify --reject 丢弃',
+  }
+}
+
+const crsiEvalCmd: CommandHandler = async () => {
+  const report = runEval()
+  appendEvalScore(report)
+
+  const lines: string[] = ['## 🧪 CRSI Eval Harness', '']
+  lines.push(`得分: **${report.score}/100** (${report.passed}/${report.total})`, '')
+  lines.push('| 任务 | 结果 |')
+  lines.push('|------|------|')
+  for (const r of report.results) {
+    lines.push(
+      `| ${r.description} | ${r.passed ? '✅' : '❌'}${r.detail ? ` — ${r.detail}` : ''} |`,
+    )
+  }
+  if (report.failures.length > 0) {
+    lines.push('', `❌ 失败任务: ${report.failures.join(', ')}`)
+  }
+  return { content: lines.join('\n') }
+}
+
 const crsiHealthCmd: CommandHandler = async (ctx) => {
   const engine = ctx.engine.getRuleEngine()
   const tracker = ctx.engine.getEffectivenessTracker()
@@ -4313,6 +4434,10 @@ const commandsListCmd: CommandHandler = () => {
     '/crsi restore': 'Tools & Skills',
     '/crsi stats': 'Tools & Skills',
     '/crsi health': 'Tools & Skills',
+    '/crsi inventory': 'Tools & Skills',
+    '/crsi modify': 'Tools & Skills',
+    '/crsi propose': 'Tools & Skills',
+    '/crsi eval': 'Tools & Skills',
     '/crsi meta': 'Tools & Skills',
     '/crsi interpret': 'Tools & Skills',
     '/crsi critique': 'Tools & Skills',
@@ -4465,6 +4590,10 @@ registry.set('/crsi analyze', crsiAnalyzeCmd)
 registry.set('/crsi restore', crsiRestoreCmd)
 registry.set('/crsi stats', crsiStatsCmd)
 registry.set('/crsi health', crsiHealthCmd)
+registry.set('/crsi inventory', crsiInventoryCmd)
+registry.set('/crsi modify', crsiModifyCmd)
+registry.set('/crsi propose', crsiProposeCmd)
+registry.set('/crsi eval', crsiEvalCmd)
 registry.set('/crsi meta', crsiMetaCmd)
 registry.set('/crsi interpret', crsiInterpretCmd)
 registry.set('/crsi critique', crsiCritiqueCmd)
@@ -4640,6 +4769,10 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/crsi restore': 'Restore a disabled or degraded CRSI rule',
   '/crsi stats': 'Show CRSI overall effectiveness statistics',
   '/crsi health': 'CRSI + SIS unified health dashboard with scoring',
+  '/crsi inventory': 'Live capability self-report — CRSI/SIS/constitution state',
+  '/crsi modify': 'Run a code self-modification through the sandbox (worktree → tests → approve)',
+  '/crsi propose': 'Produce a codified CRSI lesson from failure signals, gated by the sandbox',
+  '/crsi eval': 'Run the ground-truth CRSI eval harness and record the score',
   '/crsi meta': 'RSI Level 3 meta-rule analysis — rules that improve the rules',
   '/crsi interpret': 'Tool-call behavior dashboard — error patterns, usage, health',
   '/crsi critique': 'Enable/disable RLAIF self-critique on tool calls',

package/src/vajra/constitution.ts

@@ -0,0 +1,14 @@
+/**
+ * 对齐缝 capability —— 内核在 Service 挂载前调用，校验其声明的对齐原则。
+ *
+ * 「金刚不坏」从隐喻变成 `mount()` 的强制前置条件：Service 可选声明 `align`
+ * （遵守的宪法原则 id），内核在 apply 前向 `constitution` 缝求证，声明的 id
+ * 必须全部已知，否则拒绝挂载。此接口只定义「求证」契约，不绑定任何具体宪法来源。
+ */
+export interface Constitution {
+  /** 校验声明的原则 id；返回违规 id 列表（空 = 通过）。 */
+  check(aligned: string[]): { violations: string[] }
+}
+
+/** 缝键：ctx.constitution。 */
+export const CONSTITUTION_KEY = 'constitution'

package/src/vajra/context.ts

@@ -1,5 +1,7 @@
 import type { EventsOfMode } from './events'
 import type { Service, Mounted, ServiceStatus } from './service'
+import type { Constitution } from './constitution'
+import { CONSTITUTION_KEY } from './constitution'
 
 export type Disposer = () => void
 
@@ -43,6 +45,19 @@ export class Context {
       if (!keys.every((k) => this.has(k))) return false
       applied = true
       status = 'loading'
+      // 对齐缝：挂载前向 constitution 求证声明的原则 id，全部已知才放行。
+      const align = service.align
+      if (align && align.length > 0) {
+        const constitution = this.get<Constitution>(CONSTITUTION_KEY)
+        if (constitution) {
+          const { violations } = constitution.check(align)
+          if (violations.length > 0) {
+            error = new Error(`对齐违例：${violations.join(', ')}`)
+            status = 'failed'
+            return true
+          }
+        }
+      }
       effectSnapshot = this.effects.length
       try {
         disposer = service.apply(this) ?? (() => {})

package/src/vajra/index.ts

@@ -2,3 +2,5 @@ export { Context } from './context'
 export type { Disposer } from './context'
 export type { DispatchMode, EventMap, EventsOfMode } from './events'
 export type { Service, ServiceStatus, Mounted } from './service'
+export type { Constitution } from './constitution'
+export { CONSTITUTION_KEY } from './constitution'

package/src/vajra/service.ts

@@ -3,6 +3,8 @@ import type { Disposer } from './context'
 
 export interface Service {
   inject?: string[]
+  /** 声明遵守的宪法原则 id（对齐缝）。挂载前内核校验这些 id 均为已知原则，否则拒绝挂载。 */
+  align?: string[]
   apply(ctx: Context): void | Disposer
 }