soloforge 1.2.7 → 1.2.9

package/dist/bin/soloforge.js

@@ -1,15 +1,19 @@
 #!/usr/bin/env node
+import crypto from "node:crypto";
 import fss from "node:fs";
 import path from "node:path";
-import { loadProjectConfig, getProjectKnowledgeDir, getGlobalPatternsDir } from "../knowledge/loader.js";
+import { resolveProjectConfig, getProjectKnowledgeDir, getGlobalPatternsDir } from "../knowledge/loader.js";
 import { generateHooksConfig } from "../adapters/claude_code/hooks.js";
 import { generateClaudeMd } from "../adapters/claude_code/hooks.js";
 import { generateTraeRules } from "../adapters/trae/trae_rules.js";
 import { generateTraeMcpConfig } from "../adapters/trae/trae_config.js";
 import { generateCodexMcpConfig, generateCodexHooksConfig } from "../adapters/codex/codex_config.js";
 import { generateCodexAgentsMd } from "../adapters/codex/codex_rules.js";
-import { detectFingerprint, generateConfigDraft, validateConfigDraft } from "../engine/zero_config_init.js";
+import { detectFingerprint, generateConfigDraft, validateConfigDraft, generateConfigEvidence, canAutoWrite, parseBlueprint, generateBlueprintEvidence, } from "../engine/zero_config_init.js";
 import YAML from "yaml";
+import { cmdConfigResolve, cmdConfigExplain, cmdConfigConfirm, cmdConfigUnset, loadConfigEvidenceEntries, } from "./config_commands.js";
+import { resolveCurrentProjectConfigReports, validateConfigPrecedence, } from "../engine/config_precedence_contract.js";
+import { isReadForbidden } from "../engine/privacy_secret_contract.js";
 const command = process.argv[2];
 const args = process.argv.slice(3);
 async function main() {
@@ -18,6 +22,9 @@ async function main() {
             if (args.includes("--auto")) {
                 await cmdInitAuto();
             }
+            else if (args.includes("--blueprint")) {
+                await cmdInitBlueprint();
+            }
             else {
                 await cmdInit();
             }
@@ -40,6 +47,15 @@ async function main() {
         case "validate":
             await cmdValidate();
             break;
+        case "validate-mechanisms":
+            await cmdValidateMechanisms();
+            break;
+        case "audit-template-mechanisms":
+            await cmdAuditTemplateMechanisms();
+            break;
+        case "validate-batch1":
+            await cmdValidateBatch1();
+            break;
         case "generate-trae":
             await cmdGenerateTrae();
             break;
@@ -51,6 +67,31 @@ async function main() {
         case "--version":
             cmdVersion();
             break;
+        case "config": {
+            const subCommand = args[0];
+            switch (subCommand) {
+                case "resolve":
+                    await cmdConfigResolve();
+                    break;
+                case "explain":
+                    await cmdConfigExplain();
+                    break;
+                case "confirm":
+                    await cmdConfigConfirm();
+                    break;
+                case "unset":
+                    await cmdConfigUnset();
+                    break;
+                default:
+                    console.log("用法: soloforge config <resolve|explain|confirm|unset> [options]");
+                    console.log("");
+                    console.log("  resolve  解析配置字段优先级（只读，显示所有候选来源）");
+                    console.log("  explain  解释指定字段的来源和优先级（只读，中文输出）");
+                    console.log("  confirm  确认配置字段值（写入 config + evidence）");
+                    console.log("  unset    移除指定字段的确认配置和 evidence");
+            }
+            break;
+        }
         case "status":
             await cmdStatus();
             break;
@@ -71,29 +112,37 @@ async function main() {
   generate-codex      生成 .codex/ 配置和 AGENTS.md
   check-write         PreToolUse hook，用于范围检查（读取 TOOL_INPUT 环境变量）
   post-bash           PostToolUse hook，用于跟踪 Bash 执行结果
-  validate            验证 .soloforge/config.yaml 和知识文件
+  validate            验证项目配置和知识文件（config.yaml 可选，缺失时自动推断）
+  validate-mechanisms 验证双层机制承载模型完整性（模板层 + 机制层）
+  audit-template-mechanisms 扫描模板与机制注册表交叉校验（--json 输出完整报告，--changed-only 仅检查变更文件）
   version             显示 SoloForge 版本信息
-  status              显示当前项目的 SoloForge 状态
+  config resolve       解析配置字段优先级（只读）
+  config explain        解释配置字段来源（只读，中文）
+  config confirm <field> <value>  确认配置字段（写入 config + evidence）
+  config unset <field>  移除确认配置
+  status                显示当前项目的 SoloForge 状态
 `);
     }
 }
 async function cmdInitAuto() {
+    console.error("[soloForge] CLI: 执行 cmdInitAuto");
     const dryRun = args.includes("--dry-run");
-    const yesMode = args.includes("--yes");
     const projectPathArg = getArgValue("--project-path");
     const projectPath = projectPathArg ? path.resolve(projectPathArg) : process.cwd();
     // 层 1: 确定性指纹探测
     const fp = await detectFingerprint(projectPath);
     // 层 2: 规则推导 → config 草案
     const draft = generateConfigDraft(fp);
-    // 为每个关键配置项标注 confidence 和 evidence
-    const configItems = annotateConfigWithEvidence(fp, draft);
+    // 层 3: 字段级 evidence
+    const evidence = generateConfigEvidence(fp, draft, "auto");
+    // 展示探测结果 + evidence
     console.log("\nSoloForge 自动配置探测结果:");
     console.log("=".repeat(50));
-    for (const item of configItems) {
-        const icon = item.confidence === "high" ? "✅" : item.confidence === "medium" ? "⚠️" : "❓";
-        console.log(`  ${icon} ${item.key}: ${item.value} (${item.confidence})`);
-        console.log(`     evidence: ${item.evidence}`);
+    for (const [key, field] of Object.entries(evidence.fields)) {
+        const icon = field.confidence === "high" ? "✅" : field.confidence === "medium" ? "⚠️" : "❓";
+        const valStr = typeof field.value === "object" ? JSON.stringify(field.value) : String(field.value);
+        console.log(`  ${icon} ${key}: ${valStr} (${field.confidence}, ${field.confidence_source})`);
+        console.log(`     evidence: ${field.evidence.join(", ")}`);
     }
     console.log("=".repeat(50));
     console.log(`综合置信度: ${draft.confidence}`);
@@ -123,21 +172,20 @@ async function cmdInitAuto() {
         console.log("\n[dry-run] 不写入文件。使用不带 --dry-run 的命令执行写入。");
         return;
     }
-    // 渐进式确认: --yes 只接受高置信项，低/中置信项禁止写入
-    const hasLowOrMedium = configItems.some((i) => i.confidence !== "high");
-    if (hasLowOrMedium) {
-        if (yesMode) {
-            console.log("\n❌ --yes 只能接受高置信度确定项；存在低/中置信度配置，拒绝写入。");
-            console.log("请手动运行 `soloforge init` 或 `soloforge init --interactive` 补充配置。");
-            return;
+    // 写入门禁: 所有必要字段必须 high confidence + detected/user_declared/confirmed
+    const gate = canAutoWrite(evidence);
+    if (!gate.allowed) {
+        console.log(`\n⚠️ 存在低/中置信度配置项，拒绝写入:`);
+        for (const f of gate.blockedFields) {
+            console.log(`  - ${f}`);
         }
-        console.log("\n⚠️ 存在低/中置信度配置项，--yes 也不接受。请手动编辑 .soloforge/config.yaml。");
+        console.log("请使用 `soloforge init --interactive` 或 `soloforge init --blueprint \"...\"` 生成配置。");
         return;
     }
-    // 写入配置
-    await finishInitAutoConfig(projectPath, draft);
+    // 写入配置 + evidence
+    await finishInitAutoConfig(projectPath, draft, evidence);
 }
-async function finishInitAutoConfig(projectPath, draft) {
+async function finishInitAutoConfig(projectPath, draft, evidence) {
     const dirs = [
         ".soloforge/state", ".soloforge/state/debt",
         ".soloforge/knowledge/patterns", ".soloforge/knowledge/patterns/core",
@@ -151,7 +199,16 @@ async function finishInitAutoConfig(projectPath, draft) {
     for (const dir of dirs) {
         fss.mkdirSync(path.join(projectPath, dir), { recursive: true });
     }
+    writeConfigWithEvidence(projectPath, draft, evidence);
+    ensureGitignore(projectPath);
+    // 继续执行普通 init 的模板复制和适配器生成
+    await copyGlobalPatterns(projectPath);
+    await copyKnowledgeTemplates(projectPath);
+    await generateAdapterConfigs(projectPath, "claude-code");
+}
+function writeConfigWithEvidence(projectPath, draft, evidence) {
     const configPath = path.join(projectPath, ".soloforge", "config.yaml");
+    const evidencePath = path.join(projectPath, ".soloforge", "config.evidence.json");
     const yamlConfig = {
         schema_version: 1,
         name: draft.name,
@@ -162,48 +219,117 @@ async function finishInitAutoConfig(projectPath, draft) {
         scope: draft.scope,
     };
     fss.writeFileSync(configPath, YAML.stringify(yamlConfig), "utf-8");
-    console.log(`\n✅ .soloforge/config.yaml created (${draft.confidence} confidence)`);
+    // Write legacy evidence format (backward compat) + schema v2 entries
+    fss.writeFileSync(evidencePath, JSON.stringify(evidence, null, 2), "utf-8");
+    // Also write schema v2 entries
+    const v2Entries = Object.entries(evidence.fields).map(([key, field]) => ({
+        field_path: key,
+        value_hash: hashConfigValue(JSON.stringify(field.value)),
+        source: mapLegacySource(field.confidence_source),
+        confidence: field.confidence === "high" ? 1.0 : field.confidence === "medium" ? 0.6 : 0.3,
+        evidence_refs: field.evidence || [],
+        lifetime: "project_persistent",
+        collected_at: evidence.generated_at || new Date().toISOString(),
+    }));
+    // Merge v2 entries into the evidence file
+    try {
+        const existing = JSON.parse(fss.readFileSync(evidencePath, "utf-8"));
+        existing.entries = v2Entries;
+        existing.updated_at = new Date().toISOString();
+        fss.writeFileSync(evidencePath, JSON.stringify(existing, null, 2), "utf-8");
+    }
+    catch (e) {
+        console.error(`[soloForge] 更新 evidence 文件失败: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    console.log(`\n✅ .soloforge/config.yaml + config.evidence.json created`);
+}
+function hashConfigValue(str) {
+    return crypto.createHash("sha256").update(str).digest("hex").slice(0, 16);
+}
+function mapLegacySource(source) {
+    switch (source) {
+        case "detected": return "detected";
+        case "user_declared": return "user_declared";
+        case "confirmed": return "confirmed";
+        default: return "knowledge_default";
+    }
+}
+async function cmdInitBlueprint() {
+    console.error("[soloForge] CLI: 执行 cmdInitBlueprint");
+    const blueprintText = getArgValue("--blueprint");
+    if (!blueprintText) {
+        console.error("❌ --blueprint 需要提供描述文本，例如: soloforge init --blueprint \"Spring Boot + React 的 B2B 内部管理系统\"");
+        return;
+    }
+    const projectPathArg = getArgValue("--project-path");
+    const projectPath = projectPathArg ? path.resolve(projectPathArg) : process.cwd();
+    const parsed = parseBlueprint(blueprintText);
+    if (!parsed.parsed) {
+        console.log("⚠️ 无法从蓝图文本解析技术栈，请使用 --interactive。");
+        console.log("支持的框架关键词: Spring Boot, Go, Rust, Gradle, React, Vue, Angular, Next.js, Nuxt");
+        return;
+    }
+    // Build draft from parsed blueprint
+    const draft = {
+        name: path.basename(projectPath),
+        tech_stack: {
+            backend: parsed.tech_stack.backend ?? { lang: "", framework: "", version: "" },
+            frontend: parsed.tech_stack.frontend ?? { lang: "", framework: "", version: "" },
+        },
+        product_profile: parsed.product_profile ?? "default",
+        build_commands: {
+            backend: blueprintBackendCommands(parsed.tech_stack.backend?.framework),
+            frontend: blueprintFrontendCommands(parsed.tech_stack.frontend?.framework),
+        },
+        scope: {
+            backend: parsed.tech_stack.backend ? ["src/"] : [],
+            frontend: parsed.tech_stack.frontend ? ["src/"] : [],
+        },
+        advisory_notes: [],
+        confidence: "high",
+    };
+    const evidence = generateBlueprintEvidence(blueprintText, draft, projectPath);
+    // Create dirs + write config + evidence
+    const dirs = [
+        ".soloforge/state", ".soloforge/state/debt",
+        ".soloforge/knowledge/patterns", ".soloforge/knowledge/patterns/core",
+        ".soloforge/knowledge/patterns/temp",
+        ".soloforge/knowledge/procedures", ".soloforge/knowledge/domain/backend",
+        ".soloforge/knowledge/domain/frontend", ".soloforge/knowledge/acceptance_templates",
+        ".soloforge/knowledge/review_rules", ".soloforge/knowledge/product_profiles",
+        ".soloforge/knowledge/checklists", ".soloforge/knowledge/templates",
+        ".soloforge/staged",
+    ];
+    for (const dir of dirs) {
+        fss.mkdirSync(path.join(projectPath, dir), { recursive: true });
+    }
+    writeConfigWithEvidence(projectPath, draft, evidence);
     ensureGitignore(projectPath);
-    // 继续执行普通 init 的模板复制和适配器生成
     await copyGlobalPatterns(projectPath);
     await copyKnowledgeTemplates(projectPath);
     await generateAdapterConfigs(projectPath, "claude-code");
 }
-function annotateConfigWithEvidence(fp, draft) {
-    const items = [];
-    items.push({
-        key: "backend",
-        value: `${fp.backend?.lang ?? "unknown"}/${fp.backend?.framework ?? "unknown"} ${fp.backend?.version ?? "?"}`,
-        confidence: fp.backend ? "high" : "low",
-        evidence: fp.backend ? `detected: ${fp.backend.detected_from}` : "no backend marker found",
-    });
-    items.push({
-        key: "frontend",
-        value: `${fp.frontend?.lang ?? "unknown"}/${fp.frontend?.framework ?? "unknown"} ${fp.frontend?.version ?? "?"}`,
-        confidence: fp.frontend ? "high" : "low",
-        evidence: fp.frontend ? `detected: ${fp.frontend.detected_from}` : "no frontend marker found",
-    });
-    items.push({
-        key: "build_commands.backend",
-        value: draft.build_commands.backend?.build ?? "unknown",
-        confidence: fp.backend ? "high" : "low",
-        evidence: fp.backend ? `inferred from ${fp.backend.framework}` : "no backend framework to infer from",
-    });
-    items.push({
-        key: "build_commands.frontend",
-        value: draft.build_commands.frontend?.build ?? "unknown",
-        confidence: fp.frontend ? "high" : "low",
-        evidence: fp.frontend ? `inferred from ${fp.frontend.framework}` : "no frontend framework to infer from",
-    });
-    items.push({
-        key: "scope.backend",
-        value: draft.scope.backend?.join(", ") ?? "none",
-        confidence: fp.backend && (draft.scope.backend?.length ?? 0) > 0 ? "high" : fp.backend ? "medium" : "low",
-        evidence: fp.backend ? `inferred from ${fp.backend.framework} conventions` : "unknown backend, no scope inferred",
-    });
-    return items;
+function blueprintBackendCommands(framework) {
+    switch (framework) {
+        case "spring-boot": return { build: "./mvnw compile -q", test: "./mvnw test -q", full: "./mvnw verify -q" };
+        case "gradle": return { build: "./gradlew compileJava", test: "./gradlew test", full: "./gradlew check" };
+        case "stdlib": return { build: "go build ./...", test: "go test ./...", full: "go test -race ./..." };
+        case "cargo": return { build: "cargo build", test: "cargo test", full: "cargo test --all" };
+        default: return { build: "echo 'no backend build'", test: "echo 'no backend tests'", full: "echo 'no backend'" };
+    }
+}
+function blueprintFrontendCommands(framework) {
+    switch (framework) {
+        case "react":
+        case "vue":
+            return { build: "npm run build", test: "npm test", full: "npm run build && npm test" };
+        case "angular":
+            return { build: "npx ng build", test: "npx ng test", full: "npx ng build && npx ng test" };
+        default: return { build: "echo 'no frontend build'", test: "echo 'no frontend tests'", full: "echo 'no frontend'" };
+    }
 }
 async function cmdInit() {
+    console.error("[soloForge] CLI: 执行 cmdInit");
     const interactive = args.includes("--interactive");
     const adapter = getArgValue("--adapter") || "claude-code";
     const projectPathArg = getArgValue("--project-path");
@@ -228,14 +354,18 @@ async function cmdInit() {
     for (const dir of dirs) {
         fss.mkdirSync(path.join(projectPath, dir), { recursive: true });
     }
-    // 若不存在则生成 config.yaml
-    const configPath = path.join(projectPath, ".soloforge", "config.yaml");
-    if (!fss.existsSync(configPath) || interactive) {
-        const config = interactive ? await interactiveConfig() : defaultConfig(projectPath);
-        fss.writeFileSync(configPath, YAML.stringify(config), "utf-8");
-        console.log("✅ .soloforge/config.yaml created");
+    // 仅 --interactive 模式生成 config.yaml + evidence；普通 init 不再生成
+    if (interactive) {
+        const config = await interactiveConfig(projectPath);
+        if (config) {
+            // config is { draft, evidence }
+            writeConfigWithEvidence(projectPath, config.draft, config.evidence);
+        }
+        else if (!process.stdin.isTTY) {
+            console.log("⚠️ interactive requires TTY. 请使用 --auto 或 --blueprint。");
+        }
     }
-    // 生成 .mcp.json（SoloForge + Playwright + Figma）
+    // 生成 .mcp.json（SoloForge + Playwright）
     if (adapter === "claude-code" || adapter === "all") {
         const mcpPath = path.join(projectPath, ".mcp.json");
         if (!fss.existsSync(mcpPath)) {
@@ -250,14 +380,10 @@ async function cmdInit() {
                         command: "npx",
                         args: ["@playwright/mcp@latest", "--headless"],
                     },
-                    figma: {
-                        type: "http",
-                        url: "https://mcp.figma.com/mcp",
-                    },
                 },
             };
             fss.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
-            console.log("✅ .mcp.json created (soloforge + playwright + figma)");
+            console.log("✅ .mcp.json created (soloforge + playwright)");
         }
         // 生成 hooks
         await cmdGenerateHooks(projectPath);
@@ -333,11 +459,10 @@ async function generateAdapterConfigs(projectPath, adapter) {
                 mcpServers: {
                     soloforge: { command: "soloforge", args: ["mcp"], env: { SOLOFORGE_PROJECT: projectPath } },
                     playwright: { command: "npx", args: ["@playwright/mcp@latest", "--headless"] },
-                    figma: { type: "http", url: "https://mcp.figma.com/mcp" },
                 },
             };
             fss.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
-            console.log("✅ .mcp.json created (soloforge + playwright + figma)");
+            console.log("✅ .mcp.json created (soloforge + playwright)");
         }
         await cmdGenerateHooks(projectPath);
         await cmdGenerateClaudeMdInner(projectPath);
@@ -399,7 +524,7 @@ async function cmdGenerateCodexInner(projectPath) {
     fss.writeFileSync(path.join(codexDir, "hooks.json"), hooksContent, "utf-8");
     console.log("✅ .codex/hooks.json created");
     // 生成 AGENTS.md
-    const config = await loadProjectConfig(projectPath);
+    const { config } = await resolveProjectConfig(projectPath);
     const agentsContent = generateCodexAgentsMd(config);
     fss.writeFileSync(path.join(projectPath, "AGENTS.md"), agentsContent, "utf-8");
     console.log("✅ AGENTS.md created");
@@ -415,18 +540,19 @@ async function cmdGenerateTraeInner(projectPath) {
     // 生成 .trae/rules/project_rules.md
     const rulesDir = path.join(traeDir, "rules");
     fss.mkdirSync(rulesDir, { recursive: true });
-    const config = await loadProjectConfig(projectPath);
+    const { config } = await resolveProjectConfig(projectPath);
     const rulesContent = generateTraeRules(config);
     fss.writeFileSync(path.join(rulesDir, "project_rules.md"), rulesContent, "utf-8");
     console.log("✅ .trae/rules/project_rules.md created");
 }
 async function cmdGenerateClaudeMdInner(projectPath) {
-    const config = await loadProjectConfig(projectPath);
+    const { config } = await resolveProjectConfig(projectPath);
     const content = generateClaudeMd(config);
     fss.writeFileSync(path.join(projectPath, "CLAUDE.md"), content, "utf-8");
     console.log("✅ CLAUDE.md created");
 }
 async function cmdCheckWrite() {
+    console.error("[soloForge] CLI: 执行 cmdCheckWrite");
     try {
         // 检测运行环境: Claude Code 通过 TOOL_INPUT 环境变量，Codex 通过 stdin JSON
         const isClaudeCode = !!process.env.TOOL_INPUT;
@@ -466,7 +592,7 @@ async function cmdCheckWrite() {
         }
         // 加载配置
         const projectPath = resolveProjectPath();
-        const config = await loadProjectConfig(projectPath);
+        const { config } = await resolveProjectConfig(projectPath);
         // 从配置中收集所有允许路径
         const allowedPaths = [
             ...(config.scope.backend || []),
@@ -476,6 +602,28 @@ async function cmdCheckWrite() {
         // 使用 scope_controller 统一检查
         const { checkScope } = await import("../engine/scope_controller.js");
         const result = checkScope(filePath, allowedPaths, content || undefined);
+        // Privacy / Secret Contract: forbidden read patterns 
+        if (isReadForbidden(filePath)) {
+            if (isClaudeCode) {
+                console.error(JSON.stringify({
+                    allowed: false,
+                    reason: `隐私策略: ${filePath} 匹配禁止读取模式`,
+                    has_secrets: true,
+                    severity: "blocked",
+                }));
+                process.exit(1);
+            }
+            else {
+                process.stdout.write(JSON.stringify({
+                    hookSpecificOutput: {
+                        hookEventName: "PreToolUse",
+                        permissionDecision: "deny",
+                        permissionDecisionReason: `隐私策略: ${filePath} 匹配禁止读取模式`,
+                    },
+                }));
+                process.exit(0);
+            }
+        }
         if (result.severity === "blocked") {
             if (isClaudeCode) {
                 console.error(JSON.stringify(result));
@@ -504,7 +652,7 @@ async function cmdCheckWrite() {
     }
     catch (e) {
         console.error(`SoloForge check-write error: ${e instanceof Error ? e.message : String(e)}`);
-        process.exit(0); // 出错时放行（hooks 的 fail-open 策略）
+        process.exit(1); // 出错时拦截（fail-closed 策略：安全钩子宁可误拦也不放行）
     }
 }
 function resolveProjectPath() {
@@ -526,20 +674,122 @@ function resolveProjectPath() {
     return process.cwd();
 }
 async function cmdPostBash() {
+    console.error("[soloForge] CLI: 执行 cmdPostBash");
     // Bash 的 PostToolUse hook — 目前为空操作占位符
     // 未来: 跟踪命令结果，检测构建/测试失败
     process.exit(0);
 }
-async function cmdValidate() {
-    const projectPath = process.cwd();
+async function checkEvidenceWarnings(projectPath) {
+    console.error("[soloForge] CLI: 执行 checkEvidenceWarnings — " + projectPath);
+    const warnings = [];
     const configPath = path.join(projectPath, ".soloforge", "config.yaml");
-    if (!fss.existsSync(configPath)) {
-        console.error("❌ 未找到 .soloforge/config.yaml，请先运行 'soloforge init'。");
-        process.exit(1);
+    const evidencePath = path.join(projectPath, ".soloforge", "config.evidence.json");
+    if (!fss.existsSync(configPath))
+        return warnings;
+    if (!fss.existsSync(evidencePath)) {
+        warnings.push("config.yaml exists but config.evidence.json is missing — source traceability lost");
+        return warnings;
+    }
+    // Check mtime staleness
+    try {
+        const configStat = fss.statSync(configPath);
+        const evidenceStat = fss.statSync(evidencePath);
+        if (configStat.mtimeMs > evidenceStat.mtimeMs) {
+            warnings.push("config.evidence.json is stale (config.yaml was modified after evidence was generated)");
+        }
+    }
+    catch { }
+    // Legacy field consistency check (schema v1 evidence)
+    try {
+        const evidenceRaw = JSON.parse(fss.readFileSync(evidencePath, "utf-8"));
+        const configContent = fss.readFileSync(configPath, "utf-8");
+        const config = YAML.parse(configContent);
+        for (const [key, field] of Object.entries(evidenceRaw.fields)) {
+            const actualValue = getConfigFieldValue(config, key);
+            if (actualValue !== undefined && JSON.stringify(field.value) !== JSON.stringify(actualValue)) {
+                warnings.push(`evidence field '${key}' value does not match config.yaml`);
+            }
+        }
+    }
+    catch { }
+    // Config precedence validation using schema v2 entries
+    try {
+        const entries = loadConfigEvidenceEntries(projectPath);
+        // Check C-class auto-write violations
+        for (const e of entries) {
+            if (e.source === "cli_flag" || e.source === "mcp_param") {
+                if (e.lifetime === "project_persistent") {
+                    warnings.push(`CLI/MCP parameter (${e.source}) persisted to config — field: ${e.field_path}`);
+                }
+            }
+        }
+        // Run config precedence validation with live resolution
+        try {
+            const { reports } = await resolveCurrentProjectConfigReports(projectPath);
+            const findings = validateConfigPrecedence(reports, entries);
+            for (const f of findings) {
+                if (f.severity === "hard_fail") {
+                    warnings.push(`[${f.rule}] ${f.message}`);
+                }
+            }
+        }
+        catch { }
+    }
+    catch { }
+    return warnings;
+}
+function getConfigFieldValue(config, key) {
+    const parts = key.split(".");
+    let obj = config;
+    for (const part of parts) {
+        if (obj == null || typeof obj !== "object")
+            return undefined;
+        obj = obj[part];
     }
+    return obj;
+}
+async function cmdValidate() {
+    console.error("[soloForge] CLI: 执行 cmdValidate");
+    const projectPath = process.cwd();
     try {
-        const config = await loadProjectConfig(projectPath);
-        console.log("✅ config.yaml is valid");
+        const { config, source } = await resolveProjectConfig(projectPath);
+        if (source === "inferred") {
+            console.log("ℹ️  No .soloforge/config.yaml found — using auto-inferred configuration.");
+            console.log("   Run 'soloforge init --auto' to persist.");
+        }
+        else {
+            console.log("✅ config.yaml is valid");
+        }
+        // Config precedence validation using shared function
+        let hasHardFail = false;
+        try {
+            const { reports, entries } = await resolveCurrentProjectConfigReports(projectPath);
+            const findings = validateConfigPrecedence(reports, entries);
+            const hardFails = findings.filter(f => f.severity === "hard_fail");
+            const advisory = findings.filter(f => f.severity === "advisory");
+            if (hardFails.length > 0) {
+                hasHardFail = true;
+                console.log(`❌ 配置优先级: ${hardFails.length} hard_fail`);
+                for (const f of hardFails) {
+                    console.log(`  - [${f.rule}] ${f.field_path ?? "N/A"}: ${f.message}`);
+                }
+            }
+            if (advisory.length > 0) {
+                console.log(`⚠️  配置优先级: ${advisory.length} advisory`);
+                for (const f of advisory) {
+                    console.log(`  - [${f.rule}] ${f.field_path ?? "N/A"}: ${f.message}`);
+                }
+            }
+            if (hardFails.length === 0 && advisory.length === 0) {
+                console.log("✅ 配置优先级验证通过");
+            }
+        }
+        catch { }
+        // Evidence checks
+        const evidenceWarnings = await checkEvidenceWarnings(projectPath);
+        for (const w of evidenceWarnings) {
+            console.log(`⚠️  evidence: ${w}`);
+        }
         // 检查知识文件
         const knowledgeDir = getProjectKnowledgeDir(config);
         if (fss.existsSync(knowledgeDir)) {
@@ -556,19 +806,263 @@ async function cmdValidate() {
                 }
             }
         }
+        // 双层机制验证 (仅限 SoloForge 自身源码目录)
+        if (fss.existsSync(path.join(projectPath, "src", "engine", "dual_layer_mechanism_registry.ts"))) {
+            const { validateMechanismLayerMaps } = await import("../engine/dual_layer_mechanism_registry.js");
+            const dlFindings = validateMechanismLayerMaps();
+            const dlHard = dlFindings.filter((f) => f.severity === "hard_fail");
+            const dlAdvisory = dlFindings.filter((f) => f.severity === "advisory");
+            if (dlHard.length > 0) {
+                console.log(`❌ 双层机制验证: ${dlHard.length} hard_fail`);
+                for (const f of dlHard) {
+                    console.log(`  - [${f.finding_type}] ${f.mechanism_id}: ${f.message}`);
+                }
+                console.error(`❌ validate 失败: 双层机制存在 ${dlHard.length} hard_fail`);
+                process.exit(1);
+            }
+            else {
+                console.log(`✅ 双层机制验证: ${dlAdvisory.length} advisory, 0 hard_fail`);
+            }
+        } // end dual-layer check
+        if (hasHardFail) {
+            console.error("❌ validate 失败: 配置优先级存在 hard_fail");
+            process.exit(1);
+        }
     }
     catch (e) {
         console.error(`❌ 验证失败: ${e.message}`);
         process.exit(1);
     }
 }
+async function cmdValidateMechanisms() {
+    console.error("[soloForge] CLI: 执行 cmdValidateMechanisms");
+    // Resolve root from compiled binary location: dist/bin/soloforge.js -> project root
+    const soloforgeRoot = path.resolve(import.meta.dirname, "..", "..");
+    const projectPath = fss.existsSync(path.join(soloforgeRoot, "src", "engine"))
+        ? soloforgeRoot
+        : process.cwd();
+    try {
+        const { validateMechanismLayerMaps } = await import("../engine/dual_layer_mechanism_registry.js");
+        const findings = validateMechanismLayerMaps(undefined, projectPath);
+        const hardFails = findings.filter((f) => f.severity === "hard_fail");
+        const advisory = findings.filter((f) => f.severity === "advisory");
+        if (findings.length === 0) {
+            console.log("✅ 所有双层机制映射验证通过，无发现。");
+            process.exit(0);
+            return;
+        }
+        if (advisory.length > 0) {
+            console.log(`⚠️  advisory findings (${advisory.length}):`);
+            for (const f of advisory) {
+                console.log(`  - [${f.finding_type}] ${f.mechanism_id}: ${f.message}`);
+            }
+        }
+        if (hardFails.length > 0) {
+            console.log(`❌ hard_fail findings (${hardFails.length}):`);
+            for (const f of hardFails) {
+                console.log(`  - [${f.finding_type}] ${f.mechanism_id}: ${f.message}`);
+            }
+            console.log(`\n❌ 双层机制验证失败: ${hardFails.length} hard_fail`);
+            process.exit(1);
+        }
+        console.log(`\n✅ 双层机制验证通过，${advisory.length} advisory findings`);
+        // Audit summary
+        try {
+            const { auditTemplateMechanisms } = await import("../engine/template_mechanism_auditor.js");
+            const audit = auditTemplateMechanisms(projectPath);
+            if (audit.hard_fail_count > 0) {
+                console.log(`\n⚠️  模板审计摘要: ${audit.hard_fail_count} hard_fail, ${audit.unmapped_template_assets.length} unmapped`);
+            }
+            else {
+                console.log(`\n📊 模板审计: ${audit.total_template_files} 文件, ${audit.unmapped_template_assets.length} unmapped, ${audit.advisory_count} advisory`);
+            }
+        }
+        catch {
+            // audit is advisory, not blocking
+        }
+    }
+    catch (e) {
+        console.error(`❌ validate-mechanisms 失败: ${e.message}`);
+        process.exit(1);
+    }
+}
+async function cmdAuditTemplateMechanisms() {
+    console.error("[soloForge] CLI: 执行 cmdAuditTemplateMechanisms");
+    const asJson = args.includes("--json");
+    const changedOnly = args.includes("--changed-only");
+    // Resolve root from compiled binary location
+    const soloforgeRoot = path.resolve(import.meta.dirname, "..", "..");
+    const projectPath = fss.existsSync(path.join(soloforgeRoot, "src", "engine"))
+        ? soloforgeRoot
+        : process.cwd();
+    try {
+        const { auditTemplateMechanisms } = await import("../engine/template_mechanism_auditor.js");
+        const report = auditTemplateMechanisms(projectPath);
+        if (asJson) {
+            console.log(JSON.stringify(report, null, 2));
+            if (report.hard_fail_count > 0) {
+                process.exit(1);
+            }
+            return;
+        }
+        // Human-readable output
+        console.log(`模板-机制审计报告 (${report.generated_at})`);
+        console.log(`  模板文件: ${report.total_template_files}`);
+        console.log(`  注册资产: ${report.total_registered_assets}`);
+        console.log(`  机制总数: ${report.total_mechanisms}`);
+        console.log("");
+        if (report.unmapped_template_assets.length > 0) {
+            console.log(`⚠️  未注册模板 (${report.unmapped_template_assets.length}):`);
+            for (const u of report.unmapped_template_assets) {
+                console.log(`  - ${u.path}`);
+            }
+        }
+        if (report.unconsumed_template_assets.length > 0) {
+            console.log(`⚠️  未消费资产 (${report.unconsumed_template_assets.length}):`);
+            for (const u of report.unconsumed_template_assets) {
+                console.log(`  - ${u.path} (mode=${u.consumption_mode})`);
+            }
+        }
+        if (report.code_only_mechanisms.length > 0) {
+            console.log(`⚠️  仅代码机制 (无模板层):`);
+            for (const m of report.code_only_mechanisms) {
+                console.log(`  - ${m.mechanism_id} (${m.priority}, ${m.status})`);
+            }
+        }
+        if (report.template_only_mechanisms.length > 0) {
+            console.log(`⚠️  仅模板机制 (无代码层):`);
+            for (const m of report.template_only_mechanisms) {
+                console.log(`  - ${m.mechanism_id} (${m.priority}, ${m.status})`);
+            }
+        }
+        if (report.required_assets_without_enforcer.length > 0) {
+            console.log(`❌ Required 资产无 enforcer (${report.required_assets_without_enforcer.length}):`);
+            for (const r of report.required_assets_without_enforcer) {
+                console.log(`  - ${r.path} (mechanism=${r.owner_mechanism_id})`);
+            }
+        }
+        if (report.overpromised_adapter_rules.length > 0) {
+            console.log(`❌ 适配器过度承诺 (${report.overpromised_adapter_rules.length}):`);
+            for (const o of report.overpromised_adapter_rules) {
+                console.log(`  - ${o.source_file}: ${o.promised_mechanism_id} (${o.promise_keywords.join(",")})`);
+            }
+        }
+        if (report.deprecated_assets_injected.length > 0) {
+            console.log(`⚠️  Deprecated 资产仍被注入:`);
+            for (const d of report.deprecated_assets_injected) {
+                console.log(`  - ${d.path}`);
+            }
+        }
+        if (report.template_mechanism_drift.length > 0) {
+            const driftHard = report.template_mechanism_drift.filter((f) => f.severity === "hard_fail");
+            const driftAdvisory = report.template_mechanism_drift.filter((f) => f.severity === "advisory");
+            if (driftAdvisory.length > 0) {
+                console.log(`⚠️  漂移 advisory (${driftAdvisory.length}):`);
+                for (const f of driftAdvisory) {
+                    console.log(`  - [${f.finding_type}] ${f.mechanism_id}: ${f.message}`);
+                }
+            }
+            if (driftHard.length > 0) {
+                console.log(`❌ 漂移 hard_fail (${driftHard.length}):`);
+                for (const f of driftHard) {
+                    console.log(`  - [${f.finding_type}] ${f.mechanism_id}: ${f.message}`);
+                }
+            }
+        }
+        console.log("");
+        if (report.hard_fail_count > 0) {
+            console.log(`❌ 审计失败: ${report.hard_fail_count} hard_fail, ${report.advisory_count} advisory`);
+            process.exit(1);
+        }
+        else {
+            console.log(`✅ 审计通过: 0 hard_fail, ${report.advisory_count} advisory`);
+        }
+    }
+    catch (e) {
+        console.error(`❌ audit-template-mechanisms 失败: ${e.message}`);
+        process.exit(1);
+    }
+}
+async function cmdValidateBatch1() {
+    console.error("[soloForge] CLI: 执行 cmdValidateBatch1");
+    const { validateMechanismLayerMaps, listMechanismLayerMaps } = await import("../engine/dual_layer_mechanism_registry.js");
+    const { auditTemplateMechanisms } = await import("../engine/template_mechanism_auditor.js");
+    const { validateBatch1Scenarios, validateBatch1ProblemMatrix } = await import("../engine/batch1_scenario_registry.js");
+    const cwd = process.cwd();
+    const maps = listMechanismLayerMaps();
+    const mechFindings = validateMechanismLayerMaps(maps, cwd);
+    const mechanismsPass = mechFindings.filter((f) => f.severity === "hard_fail").length === 0;
+    const auditReport = auditTemplateMechanisms(cwd);
+    const auditPass = auditReport.hard_fail_count === 0;
+    const scenarioResults = await validateBatch1Scenarios(mechanismsPass, auditPass, true);
+    const allPass = scenarioResults.every((s) => s.status === "PASS");
+    const isJson = process.argv.includes("--json");
+    if (isJson) {
+        const problemMatrix = validateBatch1ProblemMatrix(cwd);
+        const problemAllPass = problemMatrix.every((p) => Object.values(p.dimensions).every((d) => d.status === "PASS"));
+        console.log(JSON.stringify({
+            mechanisms_pass: mechanismsPass,
+            audit_pass: auditPass,
+            all_pass: allPass && problemAllPass,
+            problem_matrix_count: problemMatrix.length,
+            problem_matrix: problemMatrix,
+            scenarios: scenarioResults,
+        }, null, 2));
+    }
+    else {
+        for (const s of scenarioResults) {
+            const icon = s.status === "PASS" ? "✓" : "✗";
+            console.log(`${icon} ${s.scenario_id}: ${s.scenario_name} — ${s.status}`);
+            for (const r of s.rules) {
+                const ri = r.status === "PASS" ? "  ✓" : "  ✗";
+                console.log(`${ri} ${r.rule}: ${r.evidence}`);
+            }
+        }
+        console.log(allPass ? "\nAll scenarios PASS" : "\nSome scenarios FAIL");
+    }
+    process.exit(allPass ? 0 : 1);
+}
 async function cmdStatus() {
+    console.error("[soloForge] CLI: 执行 cmdStatus");
     const projectPath = process.cwd();
     console.log(`SoloForge 状态: ${projectPath}`);
-    const config = await loadProjectConfig(projectPath);
+    const { config, source } = await resolveProjectConfig(projectPath);
+    console.log(`  配置来源: ${source === "config_file" ? "config.yaml" : "自动推断"}`);
     console.log(`  产品: ${config.product_profile}`);
     console.log(`  后端: ${config.tech_stack.backend.framework || "未配置"}`);
     console.log(`  前端: ${config.tech_stack.frontend.framework || "未配置"}`);
+    // Per-field config precedence status
+    try {
+        const { resolutions, entries } = await resolveCurrentProjectConfigReports(projectPath);
+        if (resolutions.length > 0) {
+            console.log("");
+            console.log("  字段解析状态:");
+            for (const r of resolutions) {
+                const stale = r.stale_warning ? " ⚠️ stale" : "";
+                const conflict = r.conflict_report ? " ⚠️ conflict" : "";
+                console.log(`    ${r.field_path}: ${JSON.stringify(r.resolved_value)} (${r.source}${stale}${conflict})`);
+            }
+        }
+        const schemaPath = path.join(projectPath, ".soloforge", "config.evidence.json");
+        if (fss.existsSync(schemaPath)) {
+            try {
+                const raw = JSON.parse(fss.readFileSync(schemaPath, "utf-8"));
+                console.log(`  evidence: schema_version=${raw.schema_version ?? 1}, ${entries.length} entries`);
+            }
+            catch {
+                console.log("  evidence: 无法解析");
+            }
+        }
+        else if (source === "config_file") {
+            console.log("  evidence: ⚠️ config.evidence.json 缺失");
+        }
+    }
+    catch { }
+    // Evidence warnings
+    const evidenceWarnings = await checkEvidenceWarnings(projectPath);
+    for (const w of evidenceWarnings) {
+        console.log(`  ⚠️  evidence: ${w}`);
+    }
     const knowledgeDir = getProjectKnowledgeDir(config);
     if (fss.existsSync(knowledgeDir)) {
         const { KnowledgeIndexManager } = await import("../knowledge/index_manager.js");
@@ -581,34 +1075,8 @@ async function cmdStatus() {
         console.log("  知识: 未初始化");
     }
 }
-function defaultConfig(projectPath) {
-    const backendLang = process.env.SOLOFORGE_BACKEND_LANG || "java";
-    const backendFramework = process.env.SOLOFORGE_BACKEND_FRAMEWORK || "spring-boot";
-    const frontendLang = process.env.SOLOFORGE_FRONTEND_LANG || "typescript";
-    const frontendFramework = process.env.SOLOFORGE_FRONTEND_FRAMEWORK || "react";
-    return {
-        schema_version: 1,
-        name: path.basename(projectPath),
-        tech_stack: {
-            backend: { lang: backendLang, framework: backendFramework, version: "3.x" },
-            frontend: { lang: frontendLang, framework: frontendFramework, version: "18" },
-        },
-        product_profile: "default",
-        repos: [
-            { name: "backend", path: "./backend", lang: backendLang, framework: backendFramework, scope: ["src/main/java", "src/test/java"] },
-            { name: "frontend", path: "./frontend", lang: frontendLang, framework: frontendFramework, scope: ["src"] },
-        ],
-        build_commands: {
-            backend: { build: "cd backend && mvn compile -q", test: "cd backend && mvn test", full: "cd backend && mvn verify" },
-            frontend: { build: "cd frontend && npm run build", test: "cd frontend && npm test", full: "cd frontend && npm run build && npm test" },
-        },
-        scope: {
-            backend: ["backend/src"],
-            frontend: ["frontend/src"],
-        },
-    };
-}
-async function interactiveConfig() {
+async function interactiveConfig(projectPath) {
+    console.error("[soloForge] CLI: 执行 interactiveConfig");
     if (!process.stdin.isTTY)
         return undefined;
     const readline = await import("node:readline");
@@ -619,20 +1087,42 @@ async function interactiveConfig() {
     const backendFramework = await ask("后端框架 (spring-boot): ") || "spring-boot";
     const frontendFramework = await ask("前端框架 (react): ") || "react";
     rl.close();
-    return {
-        schema_version: 1,
+    const draft = {
         name,
-        product_profile: product,
         tech_stack: {
-            backend: { lang: "java", framework: backendFramework, version: "" },
+            backend: { lang: backendFramework === "go" ? "go" : "java", framework: backendFramework, version: "" },
             frontend: { lang: "typescript", framework: frontendFramework, version: "" },
         },
-        repos: [],
-        build_commands: { backend: { build: "", test: "", full: "" }, frontend: { build: "", test: "", full: "" } },
-        scope: { backend: [], frontend: [] },
+        product_profile: product,
+        build_commands: {
+            backend: blueprintBackendCommands(backendFramework),
+            frontend: blueprintFrontendCommands(frontendFramework),
+        },
+        scope: { backend: ["src/"], frontend: ["src/"] },
+        advisory_notes: [],
+        confidence: "high",
+    };
+    const src = "confirmed";
+    const evidence = {
+        schema_version: 1,
+        generated_at: new Date().toISOString(),
+        mode: "interactive",
+        project_root: projectPath,
+        fields: {
+            "name": { value: name, confidence: "high", confidence_source: src, evidence: ["--interactive input"] },
+            "tech_stack.backend": { value: draft.tech_stack.backend, confidence: "high", confidence_source: src, evidence: ["--interactive input"] },
+            "tech_stack.frontend": { value: draft.tech_stack.frontend, confidence: "high", confidence_source: src, evidence: ["--interactive input"] },
+            "build_commands.backend": { value: draft.build_commands.backend, confidence: "high", confidence_source: src, evidence: ["--interactive input"] },
+            "build_commands.frontend": { value: draft.build_commands.frontend, confidence: "high", confidence_source: src, evidence: ["--interactive input"] },
+            "product_profile": { value: product, confidence: "high", confidence_source: src, evidence: ["--interactive input"] },
+            "scope.backend": { value: draft.scope.backend, confidence: "high", confidence_source: src, evidence: ["--interactive input"] },
+            "scope.frontend": { value: draft.scope.frontend, confidence: "high", confidence_source: src, evidence: ["--interactive input"] },
+        },
     };
+    return { draft, evidence };
 }
 function cmdVersion() {
+    console.error("[soloForge] CLI: 执行 cmdVersion");
     // dist/bin/soloforge.js → dist/package.json (local) 或 package.json (global npm)
     const pkgPath = path.resolve(import.meta.dirname, "..", "package.json");
     try {