scene-capability-engine 3.6.45 → 3.6.47

package/lib/workspace/takeover-baseline.js

@@ -12,6 +12,122 @@ const {
 } = require('../state/state-storage-policy');
 
 const TAKEOVER_BASELINE_SCHEMA_VERSION = '1.0';
+const CLARIFICATION_FIRST_CORE_PRINCIPLE_HEADING = '## 11. 业务场景未知时必须先澄清，禁止直接彻底禁用';
+const CLARIFICATION_FIRST_CORE_PRINCIPLE_SECTION = [
+  CLARIFICATION_FIRST_CORE_PRINCIPLE_HEADING,
+  '',
+  '- 不了解业务场景、模块、页面、实体或业务约束时，默认动作是先补上下文、缩小范围、生成澄清问题。',
+  '- 禁止把“未知业务场景”直接等同于 `deny`、`disable`、answer-only 或其他一刀切兜底禁用。',
+  '- 只有在明确命中安全/权限/合规/破坏性规则后，才允许进入阻断；否则必须先完成业务范围澄清。',
+  '- 这条规则适用于所有接入 SCE 的项目、模式和交互面，不允许按项目例外绕过。'
+].join('\n');
+const NO_BLIND_FIX_CORE_PRINCIPLE_HEADING = '## 12. 禁止盲改问题，必须先建立问题契约和证据';
+const NO_BLIND_FIX_CORE_PRINCIPLE_SECTION = [
+  NO_BLIND_FIX_CORE_PRINCIPLE_HEADING,
+  '',
+  '- 修改问题前，必须先明确现象、复现条件、影响范围、预期行为和验证方式。',
+  '- 缺少日志、数据、接口样本、最小复现或问题契约时，应先补证据，不得靠猜测连续改代码碰运气。',
+  '- 若两轮修改仍未收敛，必须回到调试、定位和根因分析，禁止在未理解问题前盲目扩大改动面。'
+].join('\n');
+const STEERING_CHANGE_EVALUATION_CORE_PRINCIPLE_HEADING = '## 13. Steering 条目变更必须先评估，禁止随意增删';
+const STEERING_CHANGE_EVALUATION_CORE_PRINCIPLE_SECTION = [
+  STEERING_CHANGE_EVALUATION_CORE_PRINCIPLE_HEADING,
+  '',
+  '- 新增、删除或重写 steering 条目前，必须先评估它是否真属于长期原则，是否与现有条目重复，是否应迁移到 `CURRENT_CONTEXT.md`、Spec 或项目文档。',
+  '- steering 变更必须说明触发原因、适用范围以及与现有规则的关系；未经评估，不得把临时偏好、短期任务或偶发结论直接固化进去。',
+  '- 接管、升级和治理脚本只能补齐基线、修复漂移，不能把未经评估的项目习惯直接塞进 steering。'
+].join('\n');
+const BACKEND_API_PRECEDENCE_CORE_PRINCIPLE_HEADING = '## 14. 问题修复时前后端接口不一致默认以后端契约为准';
+const BACKEND_API_PRECEDENCE_CORE_PRINCIPLE_SECTION = [
+  BACKEND_API_PRECEDENCE_CORE_PRINCIPLE_HEADING,
+  '',
+  '- 在修改问题的场景下，若前端调用后端 API 出现路径、方法、字段、状态码或响应结构不匹配，默认以后端现有接口契约为准。',
+  '- 除非明确要求新建接口或修改后端接口，否则禁止为了迁就前端错误调用去随意改后端实现或契约。',
+  '- 默认优先修正前端请求、映射、类型和兼容处理，使其与后端接口保持一致；若怀疑后端契约错误，应先确认再改。'
+].join('\n');
+const REQUIRED_CORE_PRINCIPLE_SECTIONS = Object.freeze([
+  {
+    heading: CLARIFICATION_FIRST_CORE_PRINCIPLE_HEADING,
+    section: CLARIFICATION_FIRST_CORE_PRINCIPLE_SECTION
+  },
+  {
+    heading: NO_BLIND_FIX_CORE_PRINCIPLE_HEADING,
+    section: NO_BLIND_FIX_CORE_PRINCIPLE_SECTION
+  },
+  {
+    heading: STEERING_CHANGE_EVALUATION_CORE_PRINCIPLE_HEADING,
+    section: STEERING_CHANGE_EVALUATION_CORE_PRINCIPLE_SECTION
+  },
+  {
+    heading: BACKEND_API_PRECEDENCE_CORE_PRINCIPLE_HEADING,
+    section: BACKEND_API_PRECEDENCE_CORE_PRINCIPLE_SECTION
+  }
+]);
+
+const ERRORBOOK_REGISTRY_DEFAULTS = Object.freeze({
+  enabled: true,
+  search_mode: 'remote',
+  cache_file: '.sce/errorbook/registry-cache.json',
+  sources: [
+    {
+      name: 'central',
+      enabled: true,
+      url: 'https://raw.githubusercontent.com/heguangyong/sce-errorbook-registry/main/registry/errorbook-registry.json',
+      index_url: 'https://raw.githubusercontent.com/heguangyong/sce-errorbook-registry/main/registry/errorbook-registry.index.json'
+    }
+  ]
+});
+
+const ERRORBOOK_CONVERGENCE_DEFAULTS = Object.freeze({
+  enabled: true,
+  canonical_mechanism: 'errorbook',
+  absorb_project_defined_mechanisms: true,
+  disallow_parallel_mechanisms: true,
+  intake_inventory_path: '.sce/errorbook/project-intake/custom-mechanism-inventory.json',
+  strategy: 'absorb_into_sce_errorbook'
+});
+
+const ERRORBOOK_PARALLEL_MECHANISM_KEYWORDS = Object.freeze([
+  '错题本',
+  '错题',
+  '故障复盘',
+  '事故复盘',
+  '问题复盘',
+  '复盘册',
+  'mistake-book',
+  'mistake_book',
+  'mistakebook',
+  'fault-book',
+  'fault_book',
+  'postmortem',
+  'post-mortem',
+  'lessons-learned',
+  'lessons_learned',
+  'defect-ledger',
+  'defect_ledger',
+  'issue-ledger',
+  'issue_ledger',
+  'incident-review',
+  'incident_review'
+]);
+
+const ERRORBOOK_SCAN_IGNORED_DIRS = new Set([
+  '.git',
+  '.hg',
+  '.svn',
+  '.sce',
+  'node_modules',
+  'dist',
+  'build',
+  'coverage',
+  '.next',
+  '.turbo',
+  '.idea',
+  '.vscode',
+  'tmp',
+  'temp',
+  '.tmp'
+]);
 
 const SESSION_GOVERNANCE_DEFAULTS = Object.freeze({
   schema_version: '1.0',
@@ -217,6 +333,7 @@ const TAKEOVER_DEFAULTS = Object.freeze({
     max_direct_fix_rounds_before_debug: 2,
     forbid_bypass_workarounds: true
   },
+  errorbook_convergence: _clone(ERRORBOOK_CONVERGENCE_DEFAULTS),
   migration_policy: {
     legacy_kiro_supported: false,
     require_manual_legacy_migration_confirmation: true
@@ -335,6 +452,113 @@ function _buildTakeoverBaselineConfig(existing, sceVersion) {
   };
 }
 
+function _buildErrorbookRegistryConfig(existing) {
+  const base = _isObject(existing) ? _clone(existing) : {};
+  return {
+    ..._clone(ERRORBOOK_REGISTRY_DEFAULTS),
+    ...base,
+    sources: Array.isArray(base.sources) && base.sources.length > 0
+      ? _clone(base.sources)
+      : _clone(ERRORBOOK_REGISTRY_DEFAULTS.sources)
+  };
+}
+
+function _normalizeRelativePath(value) {
+  return `${value || ''}`.replace(/\\/g, '/');
+}
+
+function _findParallelErrorbookKeyword(relativePath) {
+  const normalized = _normalizeRelativePath(relativePath).toLowerCase();
+  return ERRORBOOK_PARALLEL_MECHANISM_KEYWORDS.find((keyword) => normalized.includes(keyword.toLowerCase())) || null;
+}
+
+function _shouldSkipErrorbookScanDir(dirName) {
+  return ERRORBOOK_SCAN_IGNORED_DIRS.has(`${dirName || ''}`.trim());
+}
+
+async function _scanProjectDefinedErrorbookMechanisms(projectPath, fileSystem, currentDir = projectPath, depth = 0, findings = []) {
+  let entries = [];
+  try {
+    entries = await fileSystem.readdir(currentDir, { withFileTypes: true });
+  } catch (_error) {
+    return findings;
+  }
+
+  for (const entry of entries) {
+    const absolutePath = path.join(currentDir, entry.name);
+    const relativePath = _toRelativePosix(projectPath, absolutePath);
+
+    if (entry.isDirectory()) {
+      if (_shouldSkipErrorbookScanDir(entry.name)) {
+        continue;
+      }
+
+      const keyword = _findParallelErrorbookKeyword(relativePath);
+      if (keyword) {
+        findings.push({
+          path: relativePath,
+          kind: 'directory',
+          keyword,
+          action: 'absorb_into_sce_errorbook'
+        });
+      }
+
+      if (depth < 5) {
+        await _scanProjectDefinedErrorbookMechanisms(projectPath, fileSystem, absolutePath, depth + 1, findings);
+      }
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const keyword = _findParallelErrorbookKeyword(relativePath);
+    if (!keyword) {
+      continue;
+    }
+
+    findings.push({
+      path: relativePath,
+      kind: 'file',
+      keyword,
+      action: 'absorb_into_sce_errorbook'
+    });
+  }
+
+  return findings;
+}
+
+function _dedupeFindings(findings = []) {
+  const seen = new Set();
+  return findings.filter((item) => {
+    const key = `${item.kind}:${item.path}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  }).sort((left, right) => `${left.path}`.localeCompare(`${right.path}`));
+}
+
+function _buildErrorbookConvergenceInventory(sceVersion, findings = []) {
+  const dedupedFindings = _dedupeFindings(findings);
+  return {
+    schema_version: TAKEOVER_BASELINE_SCHEMA_VERSION,
+    canonical_mechanism: 'errorbook',
+    strategy: 'absorb_into_sce_errorbook',
+    last_aligned_sce_version: sceVersion,
+    summary: {
+      detected_custom_mechanisms: dedupedFindings.length
+    },
+    guidance: [
+      'Absorb reusable failure-remediation knowledge into .sce/errorbook instead of keeping project-defined parallel mistake-book flows.',
+      'Use `sce errorbook record` for curated entries and `sce errorbook incident *` for short trial-and-error loops before curation.'
+    ],
+    findings: dedupedFindings
+  };
+}
+
 async function _reconcileJsonFile(filePath, desired, options = {}) {
   const {
     projectPath,
@@ -403,6 +627,37 @@ async function _reconcileSteeringContract(projectPath, options = {}) {
   };
 }
 
+async function _reconcileCorePrinciplesBaseline(projectPath, options = {}) {
+  const { apply, fileSystem } = options;
+  const corePrinciplesPath = path.join(projectPath, SCE_STEERING_DIR, DEFAULT_LAYER_FILES.core_principles);
+  const exists = await fileSystem.pathExists(corePrinciplesPath);
+  const existingContent = exists ? await fileSystem.readFile(corePrinciplesPath, 'utf8') : '';
+  const missingSections = REQUIRED_CORE_PRINCIPLE_SECTIONS.filter(({ heading }) => !existingContent.includes(heading));
+  const changed = missingSections.length > 0;
+
+  if (apply && changed) {
+    const normalized = `${existingContent || ''}`.trimEnd();
+    const appendedSections = missingSections.map((item) => item.section).join('\n\n');
+    const nextContent = normalized
+      ? `${normalized}\n\n${appendedSections}\n`
+      : `${appendedSections}\n`;
+    await fileSystem.ensureDir(path.dirname(corePrinciplesPath));
+    await fileSystem.writeFile(corePrinciplesPath, nextContent, 'utf8');
+  }
+
+  return {
+    path: _toRelativePosix(projectPath, corePrinciplesPath),
+    existed: exists,
+    changed,
+    status: !exists ? (changed ? 'created' : 'unchanged') : (changed ? 'updated' : 'unchanged'),
+    managed_by: 'takeover-baseline',
+    details: {
+      missing_required_headings_before: missingSections.map((item) => item.heading),
+      required_headings: REQUIRED_CORE_PRINCIPLE_SECTIONS.map((item) => item.heading)
+    }
+  };
+}
+
 function _summarize(items) {
   const summary = {
     created: 0,
@@ -477,33 +732,38 @@ async function applyTakeoverBaseline(projectPath = process.cwd(), options = {})
   const adoptionPath = path.join(sceRoot, 'adoption-config.json');
   const autoConfigPath = path.join(sceRoot, 'auto', 'config.json');
   const takeoverConfigPath = path.join(sceRoot, 'config', 'takeover-baseline.json');
+  const errorbookRegistryPath = path.join(sceRoot, 'config', 'errorbook-registry.json');
   const sessionGovernancePath = path.join(sceRoot, 'config', 'session-governance.json');
   const specDomainPolicyPath = path.join(sceRoot, 'config', 'spec-domain-policy.json');
   const problemEvalPolicyPath = path.join(sceRoot, 'config', 'problem-eval-policy.json');
   const problemClosurePolicyPath = path.join(sceRoot, 'config', 'problem-closure-policy.json');
   const studioIntakePolicyPath = path.join(sceRoot, 'config', 'studio-intake-policy.json');
   const stateStoragePolicyPath = path.join(sceRoot, 'config', 'state-storage-policy.json');
+  const errorbookInventoryPath = path.join(sceRoot, 'errorbook', 'project-intake', 'custom-mechanism-inventory.json');
   const reportPath = path.join(sceRoot, 'reports', 'takeover-baseline-latest.json');
 
   const existingAdoption = await _readJsonSafe(adoptionPath, fileSystem);
   const existingAuto = await _readJsonSafe(autoConfigPath, fileSystem);
   const existingTakeover = await _readJsonSafe(takeoverConfigPath, fileSystem);
+  const existingErrorbookRegistry = await _readJsonSafe(errorbookRegistryPath, fileSystem);
   const existingSessionGovernance = await _readJsonSafe(sessionGovernancePath, fileSystem);
   const existingSpecDomainPolicy = await _readJsonSafe(specDomainPolicyPath, fileSystem);
   const existingProblemEvalPolicy = await _readJsonSafe(problemEvalPolicyPath, fileSystem);
   const existingProblemClosurePolicy = await _readJsonSafe(problemClosurePolicyPath, fileSystem);
   const existingStudioIntakePolicy = await _readJsonSafe(studioIntakePolicyPath, fileSystem);
   const existingStateStoragePolicy = await _readJsonSafe(stateStoragePolicyPath, fileSystem);
-
   const desiredAdoption = _buildAdoptionConfig(existingAdoption, nowIso, sceVersion);
   const desiredAutoConfig = _buildAutoConfig(existingAuto);
   const desiredTakeover = _buildTakeoverBaselineConfig(existingTakeover, sceVersion);
+  const desiredErrorbookRegistry = _buildErrorbookRegistryConfig(existingErrorbookRegistry);
   const desiredSessionGovernance = _deepMerge(existingSessionGovernance || {}, SESSION_GOVERNANCE_DEFAULTS);
   const desiredSpecDomainPolicy = _deepMerge(existingSpecDomainPolicy || {}, SPEC_DOMAIN_POLICY_DEFAULTS);
   const desiredProblemEvalPolicy = _deepMerge(existingProblemEvalPolicy || {}, PROBLEM_EVAL_POLICY_DEFAULTS);
   const desiredProblemClosurePolicy = _deepMerge(existingProblemClosurePolicy || {}, PROBLEM_CLOSURE_POLICY_DEFAULTS);
   const desiredStudioIntakePolicy = _deepMerge(existingStudioIntakePolicy || {}, STUDIO_INTAKE_POLICY_DEFAULTS);
   const desiredStateStoragePolicy = _deepMerge(existingStateStoragePolicy || {}, cloneStateStoragePolicyDefaults());
+  const customErrorbookFindings = await _scanProjectDefinedErrorbookMechanisms(projectPath, fileSystem);
+  const desiredErrorbookInventory = _buildErrorbookConvergenceInventory(sceVersion, customErrorbookFindings);
 
   const fileResults = [];
   fileResults.push(await _reconcileJsonFile(adoptionPath, desiredAdoption, {
@@ -521,6 +781,11 @@ async function applyTakeoverBaseline(projectPath = process.cwd(), options = {})
     apply,
     fileSystem
   }));
+  fileResults.push(await _reconcileJsonFile(errorbookRegistryPath, desiredErrorbookRegistry, {
+    projectPath,
+    apply,
+    fileSystem
+  }));
   fileResults.push(await _reconcileJsonFile(sessionGovernancePath, desiredSessionGovernance, {
     projectPath,
     apply,
@@ -551,10 +816,20 @@ async function applyTakeoverBaseline(projectPath = process.cwd(), options = {})
     apply,
     fileSystem
   }));
+  fileResults.push(await _reconcileJsonFile(errorbookInventoryPath, desiredErrorbookInventory, {
+    projectPath,
+    apply,
+    fileSystem,
+    managedBy: 'errorbook-convergence'
+  }));
   fileResults.push(await _reconcileSteeringContract(projectPath, {
     apply,
     fileSystem
   }));
+  fileResults.push(await _reconcileCorePrinciplesBaseline(projectPath, {
+    apply,
+    fileSystem
+  }));
 
   const auditFiles = _toAuditStatus(fileResults, apply);
   const summary = _summarize(auditFiles);
@@ -571,6 +846,12 @@ async function applyTakeoverBaseline(projectPath = process.cwd(), options = {})
     sce_version: sceVersion,
     drift_count: driftCount,
     enforced_defaults: _clone(TAKEOVER_DEFAULTS),
+    errorbook_convergence: {
+      canonical_mechanism: 'errorbook',
+      strategy: 'absorb_into_sce_errorbook',
+      detected_custom_mechanism_count: desiredErrorbookInventory.summary.detected_custom_mechanisms,
+      inventory_file: _toRelativePosix(projectPath, errorbookInventoryPath)
+    },
     files: auditFiles,
     summary
   };
@@ -595,6 +876,17 @@ async function applyTakeoverBaseline(projectPath = process.cwd(), options = {})
 }
 
 module.exports = {
+  CLARIFICATION_FIRST_CORE_PRINCIPLE_HEADING,
+  CLARIFICATION_FIRST_CORE_PRINCIPLE_SECTION,
+  NO_BLIND_FIX_CORE_PRINCIPLE_HEADING,
+  NO_BLIND_FIX_CORE_PRINCIPLE_SECTION,
+  STEERING_CHANGE_EVALUATION_CORE_PRINCIPLE_HEADING,
+  STEERING_CHANGE_EVALUATION_CORE_PRINCIPLE_SECTION,
+  BACKEND_API_PRECEDENCE_CORE_PRINCIPLE_HEADING,
+  BACKEND_API_PRECEDENCE_CORE_PRINCIPLE_SECTION,
+  REQUIRED_CORE_PRINCIPLE_SECTIONS,
+  ERRORBOOK_REGISTRY_DEFAULTS,
+  ERRORBOOK_CONVERGENCE_DEFAULTS,
   TAKEOVER_BASELINE_SCHEMA_VERSION,
   TAKEOVER_DEFAULTS,
   SESSION_GOVERNANCE_DEFAULTS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scene-capability-engine",
-  "version": "3.6.45",
+  "version": "3.6.47",
   "description": "SCE (Scene Capability Engine) - A CLI tool and npm package for spec-driven development with AI coding assistants.",
   "main": "index.js",
   "bin": {
@@ -10,6 +10,7 @@
   "files": [
     "bin/",
     "lib/",
+    "scripts/",
     "template/",
     "!template/.sce/tools/__pycache__/",
     "!template/.sce/tools/**/*.pyc",
@@ -37,10 +38,13 @@
     "test:interactive-flow-smoke": "node scripts/interactive-flow-smoke.js --json",
     "test:skip-audit": "node scripts/check-skip-allowlist.js",
     "test:sce-tracking": "node scripts/check-sce-tracking.js",
+    "gate:npm-runtime-assets": "node scripts/npm-package-runtime-asset-check.js --fail-on-violation",
     "test:brand-consistency": "node scripts/check-branding-consistency.js",
     "audit:steering": "node scripts/steering-content-audit.js --fail-on-error",
+    "audit:clarification-first": "node scripts/clarification-first-audit.js --fail-on-violation",
     "audit:state-storage": "node scripts/state-storage-tiering-audit.js",
     "report:steering-audit": "node scripts/steering-content-audit.js --json",
+    "report:clarification-first-audit": "node scripts/clarification-first-audit.js --json",
     "report:state-storage": "node scripts/state-storage-tiering-audit.js --json",
     "report:interactive-approval-projection": "node scripts/interactive-approval-event-projection.js --action doctor --json",
     "audit:interactive-approval-projection": "node scripts/interactive-approval-event-projection.js --action doctor --fail-on-drift --fail-on-parse-error",
@@ -82,7 +86,7 @@
     "gate:release-asset-integrity": "node scripts/release-asset-integrity-check.js",
     "report:release-risk-remediation": "node scripts/release-risk-remediation-bundle.js --json",
     "report:moqui-core-regression": "node scripts/moqui-core-regression-suite.js --json",
-    "prepublishOnly": "npm run test:release && npm run test:skip-audit && npm run test:sce-tracking && npm run test:brand-consistency && npm run audit:steering && npm run gate:git-managed && npm run gate:errorbook-registry-health && npm run gate:errorbook-release && npm run report:interactive-governance -- --fail-on-alert",
+    "prepublishOnly": "npm run test:release && npm run test:skip-audit && npm run test:sce-tracking && npm run gate:npm-runtime-assets && npm run test:brand-consistency && npm run audit:steering && npm run audit:clarification-first && npm run gate:git-managed && npm run gate:errorbook-registry-health && npm run gate:errorbook-release && npm run report:interactive-governance -- --fail-on-alert",
     "publish:manual": "npm publish --access public",
     "install-global": "npm install -g .",
     "uninstall-global": "npm uninstall -g scene-capability-engine"

package/scripts/auto-strategy-router.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function readJsonFile(filePath) {
+  const resolved = path.resolve(filePath);
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`file not found: ${filePath}`);
+  }
+  return JSON.parse(fs.readFileSync(resolved, 'utf8'));
+}
+
+function toBool(value, fallback = false) {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  if (typeof value === 'string') {
+    const lowered = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'y', 'on'].includes(lowered)) {
+      return true;
+    }
+    if (['0', 'false', 'no', 'n', 'off'].includes(lowered)) {
+      return false;
+    }
+  }
+  return fallback;
+}
+
+function toFiniteNumber(value, fallback = 0) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : fallback;
+}
+
+function normalizeInput(input = {}) {
+  const goalTypeRaw = typeof input.goal_type === 'string' ? input.goal_type.trim().toLowerCase() : '';
+  return {
+    goal_type: goalTypeRaw || 'unknown',
+    requires_write: toBool(input.requires_write, false),
+    high_risk: toBool(input.high_risk, false),
+    last_run_failed: toBool(input.last_run_failed, false),
+    has_rollback_checkpoint: toBool(input.has_rollback_checkpoint, false),
+    test_failures: toFiniteNumber(input.test_failures, 0),
+    changed_files: toFiniteNumber(input.changed_files, 0),
+    user_explicit_answer_only: toBool(input.user_explicit_answer_only, false),
+    user_explicit_rollback: toBool(input.user_explicit_rollback, false)
+  };
+}
+
+function resolvePolicy(policy = {}) {
+  const fallback = {
+    answer_only_goal_types: ['question', 'analysis', 'explain', 'summarize'],
+    rollback_when: {
+      require_checkpoint: true,
+      require_high_risk_or_explicit: true
+    },
+    code_fix_when_tests_fail: true
+  };
+  const answerTypes = Array.isArray(policy.answer_only_goal_types)
+    ? policy.answer_only_goal_types
+      .map(item => `${item || ''}`.trim().toLowerCase())
+      .filter(Boolean)
+    : fallback.answer_only_goal_types;
+  return {
+    answer_only_goal_types: answerTypes.length > 0 ? answerTypes : fallback.answer_only_goal_types,
+    rollback_when: {
+      require_checkpoint: toBool(
+        policy.rollback_when && policy.rollback_when.require_checkpoint,
+        fallback.rollback_when.require_checkpoint
+      ),
+      require_high_risk_or_explicit: toBool(
+        policy.rollback_when && policy.rollback_when.require_high_risk_or_explicit,
+        fallback.rollback_when.require_high_risk_or_explicit
+      )
+    },
+    code_fix_when_tests_fail: toBool(policy.code_fix_when_tests_fail, fallback.code_fix_when_tests_fail)
+  };
+}
+
+function evaluateStrategy(input = {}, policyInput = {}) {
+  const payload = normalizeInput(input);
+  const policy = resolvePolicy(policyInput);
+  const reasons = [];
+  let decision = 'answer_only';
+  let confidence = 'low';
+
+  if (payload.user_explicit_answer_only) {
+    decision = 'answer_only';
+    confidence = 'high';
+    reasons.push('explicit user instruction: answer only');
+  } else if (payload.user_explicit_rollback) {
+    const checkpointOk = !policy.rollback_when.require_checkpoint || payload.has_rollback_checkpoint;
+    const riskGateOk = !policy.rollback_when.require_high_risk_or_explicit || payload.high_risk || payload.user_explicit_rollback;
+    if (checkpointOk && riskGateOk) {
+      decision = 'rollback';
+      confidence = 'high';
+      reasons.push('explicit user instruction: rollback');
+    } else {
+      decision = 'answer_only';
+      confidence = 'medium';
+      reasons.push('rollback requested but preconditions are not met');
+    }
+  } else if (
+    payload.last_run_failed
+    && payload.has_rollback_checkpoint
+    && payload.high_risk
+    && payload.changed_files > 0
+  ) {
+    decision = 'rollback';
+    confidence = 'high';
+    reasons.push('last run failed with high risk and rollback checkpoint available');
+  } else if (
+    policy.answer_only_goal_types.includes(payload.goal_type)
+    && !payload.requires_write
+  ) {
+    decision = 'answer_only';
+    confidence = 'high';
+    reasons.push(`goal_type=${payload.goal_type} with no write requirement`);
+  } else if (
+    policy.code_fix_when_tests_fail
+    && payload.test_failures > 0
+    && payload.changed_files > 0
+  ) {
+    decision = 'code_fix';
+    confidence = 'high';
+    reasons.push('tests failing after code changes, prioritize focused repair');
+  } else if (payload.requires_write || payload.goal_type === 'feature' || payload.goal_type === 'bugfix') {
+    decision = 'code_change';
+    confidence = 'medium';
+    reasons.push('write-required goal needs implementation changes');
+  } else {
+    decision = 'answer_only';
+    confidence = 'low';
+    reasons.push('insufficient signals for safe code changes');
+  }
+
+  const next_actions = [];
+  if (decision === 'rollback') {
+    next_actions.push('execute rollback to latest stable checkpoint');
+    next_actions.push('collect failure evidence before reattempt');
+  } else if (decision === 'code_fix') {
+    next_actions.push('locate failing symbols and failing tests first');
+    next_actions.push('apply minimal patch and re-run targeted tests');
+  } else if (decision === 'code_change') {
+    next_actions.push('confirm affected scope and symbol locations');
+    next_actions.push('implement change and run validation tests');
+  } else {
+    next_actions.push('answer request with evidence and constraints');
+    next_actions.push('avoid repository writes in current turn');
+  }
+
+  return {
+    mode: 'auto-strategy-router',
+    decision,
+    confidence,
+    reasons,
+    next_actions,
+    input: payload,
+    policy
+  };
+}
+
+function parseArgs(argv = []) {
+  const options = {
+    input: null,
+    inputFile: '',
+    policyFile: '',
+    json: false
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === '--input') {
+      options.input = argv[i + 1] || '';
+      i += 1;
+      continue;
+    }
+    if (token === '--input-file') {
+      options.inputFile = argv[i + 1] || '';
+      i += 1;
+      continue;
+    }
+    if (token === '--policy-file') {
+      options.policyFile = argv[i + 1] || '';
+      i += 1;
+      continue;
+    }
+    if (token === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (token === '-h' || token === '--help') {
+      console.log([
+        'Usage:',
+        '  node scripts/auto-strategy-router.js --input-file <path> [--policy-file <path>] --json',
+        '  node scripts/auto-strategy-router.js --input \'{\"goal_type\":\"bugfix\",\"requires_write\":true}\' --json'
+      ].join('\n'));
+      process.exit(0);
+    }
+  }
+  return options;
+}
+
+if (require.main === module) {
+  const args = parseArgs(process.argv.slice(2));
+  let inputPayload = {};
+  let policyPayload = {};
+  if (args.inputFile) {
+    inputPayload = readJsonFile(args.inputFile);
+  } else if (args.input) {
+    inputPayload = JSON.parse(args.input);
+  }
+  if (args.policyFile) {
+    policyPayload = readJsonFile(args.policyFile);
+  }
+  const result = evaluateStrategy(inputPayload, policyPayload);
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  } else {
+    process.stdout.write(
+      `[auto-strategy-router] decision=${result.decision} confidence=${result.confidence} reasons=${result.reasons.join('; ')}\n`
+    );
+  }
+}
+
+module.exports = {
+  evaluateStrategy,
+  normalizeInput,
+  parseArgs,
+  resolvePolicy
+};