@miphamai/cli 0.40.0 → 0.42.0

package/bin/mipham.ts

@@ -1204,49 +1204,20 @@ npm:  https://www.npmjs.com/package/@miphamai/cli`)
   const handled = await runWorkflowCLI()
   if (handled) return
 
-  // ── Unknown command detection ──────────────────────────────────────────────
-  // After all known subcommands are checked, any remaining positional argument
-  // is probably a typo. Show error + suggestions instead of silently launching CLI.
-  const KNOWN_COMMANDS = [
-    'update',
-    'upgrade',
-    'plugin',
-    'workflow',
-    'daemon',
-    'attach',
-    'agents',
-    'agent',
-    'goal',
-    'schedule',
-    'token',
-    'help',
-  ]
-  const firstArg = process.argv.slice(2).find((a) => !a.startsWith('-'))
-  if (firstArg) {
-    // Levenshtein distance to find closest match
-    const distance = (a: string, b: string): number => {
-      const m = a.length
-      const n = b.length
-      const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0))
-      for (let i = 0; i <= m; i++) dp[i]![0] = i
-      for (let j = 0; j <= n; j++) dp[0]![j] = j
-      for (let i = 1; i <= m; i++)
-        for (let j = 1; j <= n; j++)
-          dp[i]![j] =
-            a[i - 1] === b[j - 1]
-              ? dp[i - 1]![j - 1]!
-              : 1 + Math.min(dp[i - 1]![j]!, dp[i]![j - 1]!, dp[i - 1]![j - 1]!)
-      return dp[m]![n]!
-    }
-
-    const best = KNOWN_COMMANDS.map((cmd) => ({ cmd, dist: distance(firstArg, cmd) }))
-      .filter((c) => c.dist <= 3)
-      .sort((a, b) => a.dist - b.dist)
-    const suggestions = best.map((c) => `'mipham ${c.cmd}'`).join(', ')
-
-    console.error(`Unknown command: mipham ${firstArg}`)
-    if (suggestions) {
-      console.error(`Did you mean: ${suggestions}?`)
+  // ── Unknown command / option detection ─────────────────────────────────────
+  // After all known subcommands are checked, any remaining argument is probably
+  // a typo. Show error + suggestions instead of silently launching the CLI.
+  const { detectUnknownArgument } = await import('../src/shared/arg-validation')
+  const unknown = detectUnknownArgument(process.argv.slice(2))
+  if (unknown) {
+    const isOption = unknown.kind === 'option'
+    const prefix = isOption ? '' : 'mipham '
+    console.error(`Unknown ${unknown.kind}: ${prefix}${unknown.arg}`)
+    if (unknown.suggestions.length > 0) {
+      const rendered = unknown.suggestions
+        .map((s) => (isOption ? `'${s}'` : `'mipham ${s}'`))
+        .join(', ')
+      console.error(`Did you mean: ${rendered}?`)
     }
     console.error(`Run 'mipham --help' for usage.`)
     process.exit(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.40.0",
+  "version": "0.42.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/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/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)
 

package/src/shared/arg-validation.ts

@@ -0,0 +1,78 @@
+/**
+ * CLI argument validation for the `mipham` entry point.
+ *
+ * After every known subcommand (`update`, `daemon`, `attach`, ...) has been
+ * dispatched, any remaining argument is a likely typo. This module classifies
+ * a leftover argument as an unknown command (positional) or unknown option
+ * (leading `-`/`--`) and suggests the closest known alternative via
+ * Levenshtein distance, instead of silently launching the interactive CLI.
+ */
+
+export interface UnknownArgument {
+  kind: 'command' | 'option'
+  arg: string
+  suggestions: string[]
+}
+
+const KNOWN_COMMANDS = [
+  'update',
+  'upgrade',
+  'plugin',
+  'workflow',
+  'daemon',
+  'attach',
+  'agents',
+  'agent',
+  'goal',
+  'schedule',
+  'token',
+  'help',
+]
+
+const KNOWN_FLAGS = ['--version', '-v', '-V', '--help', '-h', '--dump-config', '--safe-mode']
+
+/** Levenshtein edit distance between two strings. */
+function levenshtein(a: string, b: string): number {
+  const m = a.length
+  const n = b.length
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0))
+  for (let i = 0; i <= m; i++) dp[i]![0] = i
+  for (let j = 0; j <= n; j++) dp[0]![j] = j
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      dp[i]![j] =
+        a[i - 1] === b[j - 1]
+          ? dp[i - 1]![j - 1]!
+          : 1 + Math.min(dp[i - 1]![j]!, dp[i]![j - 1]!, dp[i - 1]![j - 1]!)
+  return dp[m]![n]!
+}
+
+/** Closest candidates within `maxDist` edits, nearest first. */
+function closest(target: string, candidates: string[], maxDist = 3): string[] {
+  return candidates
+    .map((c) => ({ c, dist: levenshtein(target, c) }))
+    .filter((x) => x.dist <= maxDist)
+    .sort((a, b) => a.dist - b.dist)
+    .map((x) => x.c)
+}
+
+/**
+ * Return the first unknown argument (command or option), or null if all
+ * arguments are recognized. Positional commands are checked first so an
+ * unknown command keeps its existing message; unknown options (e.g.
+ * `--cersion`, a typo of `--version`) are reported when no positional
+ * command is present, instead of falling through to the interactive CLI.
+ */
+export function detectUnknownArgument(args: string[]): UnknownArgument | null {
+  const firstArg = args.find((a) => !a.startsWith('-'))
+  if (firstArg && !KNOWN_COMMANDS.includes(firstArg)) {
+    return { kind: 'command', arg: firstArg, suggestions: closest(firstArg, KNOWN_COMMANDS) }
+  }
+
+  const unknownFlag = args.find((a) => a.startsWith('-') && !KNOWN_FLAGS.includes(a))
+  if (unknownFlag) {
+    return { kind: 'option', arg: unknownFlag, suggestions: closest(unknownFlag, KNOWN_FLAGS) }
+  }
+
+  return null
+}

package/src/shared/package-info.ts

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

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
 }