scene-capability-engine 3.4.5 → 3.4.6

package/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.4.6] - 2026-03-02
+
+### Added
+- Default problem-closure gate and policy baseline:
+  - new script: `scripts/problem-closure-gate.js`
+  - new managed config: `.sce/config/problem-closure-policy.json` (and template counterpart)
+  - `studio verify/release` standard profiles now execute `problem-closure-gate` when spec context is available
+- Spec domain modeling now includes a mandatory machine-readable problem contract artifact:
+  - `.sce/specs/<spec>/custom/problem-contract.json`
+  - generated via spec domain init/refresh/bootstrap flow
+
+### Changed
+- Problem evaluation policy and runtime now enforce stronger closure dimensions by default:
+  - mandatory dimensions: `problem_contract`, `ontology_alignment`, `convergence`
+  - stage-level block policy tightened for plan/apply/release closure control
+- Errorbook record contract now captures structured attempt context (`attempt_contract`) for better trial/verification traceability.
+- Errorbook release gate now incorporates quality policy checks (`min_quality`) for unresolved verified entries.
+- Takeover/adoption baseline and file classification now manage `problem-closure-policy.json` as first-class config.
+- README/README.zh/command reference updated to document problem-domain closed loop, two-failed-round debug escalation, and closure gate workflows.
+
 ## [3.4.5] - 2026-03-02
 
 ### Fixed

package/README.md

@@ -30,6 +30,7 @@ SCE is designed for teams that want AI agents to deliver software end-to-end wit
 | Autonomous delivery | `auto close-loop`, `close-loop-program`, `close-loop-controller` | Unattended bounded convergence |
 | Multi-agent orchestration | DAG scheduling, retries, 429 adaptive parallel control | Reliable parallel execution at scale |
 | Domain/ontology governance | problem-domain chain + scene template + gate validation | Fewer semantic regressions |
+| Problem closure loop | problem-domain map + chain + `problem-contract` + closure gate | Root-cause-first fixes with bounded convergence |
 | Problem evaluation routing | Stage-level risk/evidence/readiness scoring with mandatory policy | Adaptive execution strategy with guarded apply/release |
 | Local timeline safety | `timeline save/auto/list/show/restore/push` + key-event auto checkpoints | Recoverable local history |
 | Errorbook-driven repair | Local + registry-backed error patterns and release gates | Faster diagnosis and safer fixes |
@@ -94,6 +95,20 @@ git push origin vX.Y.Z
 
 ---
 
+## Default Problem-Solving Loop
+
+SCE now enforces a domain-closed diagnosis and repair route by default:
+
+1. Scope the problem first with scene artifacts (`problem-domain-map.md`, `scene-spec.md`, `problem-domain-chain.json`, `problem-contract.json`).
+2. Keep trial-and-error history in incident staging (`.sce/errorbook/staging/incidents/`) to avoid repeating failed attempts.
+3. Use problem evaluation to prioritize likely impact areas before applying/releasing changes.
+
+Hard rule defaults:
+- After two failed rounds on the same problem fingerprint, debug evidence is required in subsequent attempts.
+- `studio verify/release` run `problem-closure-gate` by default when a spec is bound.
+
+---
+
 ## AI Agent Compatibility
 
 SCE is tool-agnostic and works with Codex, Claude Code, Cursor, Windsurf, VS Code Copilot, and other CLI-capable agents.
@@ -103,6 +118,7 @@ SCE is tool-agnostic and works with Codex, Claude Code, Cursor, Windsurf, VS Cod
 - Spec work is attached as child sessions and auto-archived.
 - Startup now auto-detects adopted projects and aligns takeover baseline defaults automatically.
 - Problem evaluation policy is enabled by default (`.sce/config/problem-eval-policy.json`) and evaluates every Studio stage.
+- Problem closure policy is enabled by default (`.sce/config/problem-closure-policy.json`) and blocks verify/release bypass when required domain/problem evidence is missing.
 - Error handling now follows a full incident loop by default: every record attempt is staged first and auto-closed on verified/promoted outcomes.
 - You can inspect or force-align baseline explicitly:
   - `sce workspace takeover-audit --json`
@@ -110,6 +126,17 @@ SCE is tool-agnostic and works with Codex, Claude Code, Cursor, Windsurf, VS Cod
 
 ---
 
+## Important Version Changes
+
+- `3.4.6`: Added default `problem-closure-gate` + `problem-contract` baseline and strengthened mandatory problem evaluation dimensions (`problem_contract`/`ontology_alignment`/`convergence`) for verify/release convergence control.
+- `3.4.5`: `git-managed-gate` now treats worktree checks as advisory in default relaxed CI mode (`CI/GITHUB_ACTIONS`, non-strict), preventing false release blocking.
+- `3.4.4`: Added `SCE_GIT_MANAGEMENT_ALLOW_UNTRACKED=1` / `--allow-untracked`; release workflow uses it for npm publish after generating release evidence artifacts.
+- `3.4.3`: Introduced mandatory problem evaluation across Studio stages (`plan/generate/apply/verify/release`) with policy file `.sce/config/problem-eval-policy.json` and stage report artifacts.
+- `3.4.2`: Errorbook incident flow moved to full staging closed-loop (attempt history, incident inspection, resolved archive).
+- `3.4.1`: Added workspace takeover baseline automation (`takeover-audit` / `takeover-apply`) and startup alignment defaults.
+
+---
+
 ## Documentation Map
 
 Start here:
@@ -147,5 +174,5 @@ MIT. See [LICENSE](LICENSE).
 
 ---
 
-**Version**: 3.4.5  
+**Version**: 3.4.6  
 **Last Updated**: 2026-03-02

package/README.zh.md

@@ -30,6 +30,7 @@ SCE 面向希望让 AI Agent 端到端推进交付、同时保持治理可控的
 | 自动闭环交付 | `auto close-loop`、`close-loop-program`、`close-loop-controller` | 无人值守有界收敛 |
 | 多 Agent 编排 | DAG 调度、重试、429 自适应并行 | 并行执行稳定可控 |
 | 领域/本体治理 | problem-domain chain + scene template + gate 校验 | 降低语义回归 |
+| 问题闭环治理 | problem-domain map + chain + `problem-contract` + closure gate | 根因优先修复，过程有界收敛 |
 | 问题评估路由 | 分阶段风险/证据/就绪度评分 + 强制策略 | `apply/release` 可控阻断，执行路径自适应 |
 | 本地时间线安全 | `timeline save/auto/list/show/restore/push` + 关键节点自动打点 | 本地历史可回放可恢复 |
 | Errorbook 修复体系 | 本地 + 注册表错题库 + 发布门禁 | 定位更快、修复更稳 |
@@ -94,6 +95,20 @@ git push origin vX.Y.Z
 
 ---
 
+## 默认问题解决闭环
+
+SCE 默认按“问题域闭环”推进诊断与修复：
+
+1. 先收敛问题域边界：`problem-domain-map.md`、`scene-spec.md`、`problem-domain-chain.json`、`problem-contract.json`。
+2. 试错过程进入 incident staging（`.sce/errorbook/staging/incidents/`），避免重复犯错。
+3. 由 problem evaluation 在变更前优先排序高相关区域，再进入 apply/release。
+
+默认硬规则：
+- 同一问题指纹失败两轮后，后续尝试必须补充 debug 证据。
+- 当 spec 绑定时，`studio verify/release` 默认执行 `problem-closure-gate`。
+
+---
+
 ## AI Agent 适配
 
 SCE 对工具无锁定，可接入 Codex、Claude Code、Cursor、Windsurf、VS Code Copilot 等。
@@ -103,6 +118,7 @@ SCE 对工具无锁定，可接入 Codex、Claude Code、Cursor、Windsurf、VS
 - Spec 执行作为子会话自动归档，支持跨轮次追踪。
 - 启动时会自动识别已接管项目并对齐接管基线默认配置。
 - 问题评估策略默认启用（`.sce/config/problem-eval-policy.json`），Studio 各阶段都会执行评估。
+- 问题闭环策略默认启用（`.sce/config/problem-closure-policy.json`），缺失必要问题/领域证据时会在 verify/release 阶段阻断。
 - 错误处理默认进入完整 incident 闭环：每次记录先落到 staging 试错链路，verified/promoted 后自动收束归档。
 - 也可显式审计/修正接管基线：
   - `sce workspace takeover-audit --json`
@@ -110,6 +126,17 @@ SCE 对工具无锁定，可接入 Codex、Claude Code、Cursor、Windsurf、VS
 
 ---
 
+## 重要版本变更
+
+- `3.4.6`：新增默认 `problem-closure-gate` + `problem-contract` 基线，并强化问题评估强制维度（`problem_contract`/`ontology_alignment`/`convergence`），提升 verify/release 收敛控制。
+- `3.4.5`：`git-managed-gate` 在默认 CI 放宽模式下（`CI/GITHUB_ACTIONS` 且非 strict）对工作区变更改为告警，不再误阻断发布。
+- `3.4.4`：新增 `SCE_GIT_MANAGEMENT_ALLOW_UNTRACKED=1` / `--allow-untracked`；发布工作流在 npm publish 前生成证据资产时可放行未跟踪文件。
+- `3.4.3`：Studio 全阶段接入强制问题评估（`plan/generate/apply/verify/release`），并引入策略文件 `.sce/config/problem-eval-policy.json` 与评估报告落盘。
+- `3.4.2`：Errorbook 升级为完整 incident staging 闭环（尝试记录、incident 查询、resolved 归档）。
+- `3.4.1`：新增 workspace takeover baseline 自动化（`takeover-audit` / `takeover-apply`）与启动对齐能力。
+
+---
+
 ## 文档导航
 
 建议先看：
@@ -147,5 +174,5 @@ MIT，见 [LICENSE](LICENSE)。
 
 ---
 
-**版本**：3.4.5  
+**版本**：3.4.6  
 **最后更新**：2026-03-02

package/docs/command-reference.md

@@ -2,7 +2,7 @@
 
 > Quick reference for all `sce` commands
 
-**Version**: 3.4.5
+**Version**: 3.4.6
 **Last Updated**: 2026-03-02
 
 ---
@@ -11,7 +11,7 @@
 
 The CLI provides three command aliases:
 - `sce` - **Recommended primary command** (use this in all documentation)
-- `sce` - Legacy short alias (compatible)
+- `sco` - Legacy short alias (compatible)
 - `scene-capability-engine` - Legacy full alias (compatible)
 
 **Always use `sce` in new examples and documentation.**
@@ -24,7 +24,7 @@ The CLI provides three command aliases:
 npm install -g scene-capability-engine
 ```
 
-This creates the `sce` command globally. Legacy aliases `sce` and `scene-capability-engine` are still available.
+This creates the `sce` command globally. Legacy aliases `sco` and `scene-capability-engine` are still available.
 
 ---
 
@@ -61,6 +61,7 @@ sce spec bootstrap --name 01-00-feature-name --scene scene.customer-order-invent
 # - .sce/specs/<spec>/custom/problem-domain-map.md
 # - .sce/specs/<spec>/custom/scene-spec.md
 # - .sce/specs/<spec>/custom/problem-domain-chain.json (machine-readable chain model)
+# - .sce/specs/<spec>/custom/problem-contract.json (problem closure contract)
 
 # Run pipeline for one Spec
 sce spec pipeline run --spec 01-00-feature-name --scene scene.customer-order-inventory
@@ -92,11 +93,12 @@ Spec session governance:
 - `spec bootstrap|pipeline run|gate run` must bind to an active scene primary session (`--scene <scene-id>` or implicit binding from latest/unique active scene).
 - When multiple active scenes exist, you must pass `--scene` explicitly.
 - Multi-Spec orchestrate fallback (`--specs ...`) follows the same scene binding and writes per-spec child-session archive records.
-- `spec bootstrap` always generates problem-domain and scene-spec artifacts to force domain-first exploration.
+- `spec bootstrap` always generates problem-domain, scene-spec, and `problem-contract` artifacts to force domain-first exploration.
 - `spec gate` now hard-fails when either of the following is missing or structurally incomplete:
   - `.sce/specs/<spec>/custom/problem-domain-map.md`
   - `.sce/specs/<spec>/custom/scene-spec.md`
   - `.sce/specs/<spec>/custom/problem-domain-chain.json`
+- `problem-contract.json` is enforced by Studio stage gates (`problem-closure-gate`) during `verify/release`.
 - Closed-loop scene research baseline is now part of domain modeling artifacts:
   - `problem-domain-map.md` must include `Closed-Loop Research Coverage Matrix`
   - `scene-spec.md` must include `Closed-Loop Research Contract`
@@ -567,13 +569,17 @@ Stage guardrails are enforced by default:
 Problem evaluation mode (default required):
 - Studio now runs problem evaluation on every stage: `plan`, `generate`, `apply`, `verify`, `release`.
 - Default policy file: `.sce/config/problem-eval-policy.json` (also provisioned by template/adopt/takeover baseline).
-- Default hard-block stages: `apply`, `release`.
+- Mandatory dimensions: `problem_contract`, `ontology_alignment`, `convergence`.
+- Default hard-block behavior:
+  - stage block policy: `apply`, `release`
+  - dimension block policy: `problem_contract` blocks on `plan/apply/release`; `ontology_alignment` blocks on `apply/release`; `convergence` blocks on `release`
 - Evaluation combines risk/evidence/readiness and emits adaptive strategy:
   - `direct-execution`
   - `controlled-execution`
   - `evidence-first`
   - `explore-and-validate`
   - `debug-first`
+- Default retry rule: after two failed rounds on the same fingerprint, subsequent attempts must include debug evidence.
 - Evaluation report artifact is written to `.sce/reports/problem-eval/<job-id>-<stage>.json`.
 - Stage metadata and event payload now include `problem_evaluation` summary plus artifact pointer.
 - Environment overrides:
@@ -581,11 +587,35 @@ Problem evaluation mode (default required):
   - `SCE_PROBLEM_EVAL_DISABLED=1`
 
 Studio gate execution defaults:
-- `verify --profile standard` runs executable gates (unit test script when available, interactive governance report when present, scene package publish-batch dry-run when handoff manifest exists)
-- `release --profile standard` runs executable release preflight (npm pack dry-run, git managed gate, errorbook release gate, weekly ops gate when summary exists, release asset integrity when evidence directory exists, scene package publish-batch ontology gate, handoff capability matrix gate)
+- `verify --profile standard` runs executable gates (unit test script when available, interactive governance report when present, scene package publish-batch dry-run when handoff manifest exists, `problem-closure-gate` when spec context is available)
+- `release --profile standard` runs executable release preflight (npm pack dry-run, git managed gate, errorbook release gate, weekly ops gate when summary exists, release asset integrity when evidence directory exists, scene package publish-batch ontology gate, handoff capability matrix gate, `problem-closure-gate` when spec context is available)
 - `verify/release --profile strict` fails when any required gate step is skipped (for example missing manifest/evidence/scripts)
 - Required gate failures are auto-recorded into `.sce/errorbook` as `candidate` entries (tagged `release-blocker`) for follow-up triage.
 
+Problem closure gate (default policy):
+- Script: `node scripts/problem-closure-gate.js`
+- Policy file: `.sce/config/problem-closure-policy.json` (auto-provisioned by `init/adopt/takeover`)
+- Checks:
+  - verify stage: `problem-contract` + spec domain validation + domain coverage
+  - release stage: verify checks + verify report pass signal + governance high-alert block (configurable)
+
+```bash
+# Verify-stage closure gate
+node scripts/problem-closure-gate.js \
+  --stage verify \
+  --spec 01-00-customer-order-inventory \
+  --fail-on-block \
+  --json
+
+# Release-stage closure gate
+node scripts/problem-closure-gate.js \
+  --stage release \
+  --spec 01-00-customer-order-inventory \
+  --verify-report .sce/reports/studio/verify-<job-id>.json \
+  --fail-on-block \
+  --json
+```
+
 Authorization model (optional, policy-driven):
 - Enable policy: `SCE_STUDIO_REQUIRE_AUTH=1`
 - Secret env key: `SCE_STUDIO_AUTH_PASSWORD` (or override key name with `SCE_STUDIO_PASSWORD_ENV`)

package/lib/adoption/adoption-strategy.js

@@ -119,6 +119,7 @@ class AdoptionStrategy {
       'config/session-governance.json',
       'config/spec-domain-policy.json',
       'config/problem-eval-policy.json',
+      'config/problem-closure-policy.json',
       'specs/SPEC_WORKFLOW_GUIDE.md',
       'hooks/sync-tasks-on-edit.sce.hook',
       'hooks/check-spec-on-create.sce.hook',

package/lib/adoption/detection-engine.js

@@ -168,6 +168,7 @@ class DetectionEngine {
         'config/session-governance.json',
         'config/spec-domain-policy.json',
         'config/problem-eval-policy.json',
+        'config/problem-closure-policy.json',
         'README.md',
         'ultrawork-application-guide.md',
         'ultrawork-integration-summary.md',

package/lib/adoption/file-classifier.js

@@ -69,7 +69,8 @@ class FileClassifier {
       'config/takeover-baseline.json',
       'config/session-governance.json',
       'config/spec-domain-policy.json',
-      'config/problem-eval-policy.json'
+      'config/problem-eval-policy.json',
+      'config/problem-closure-policy.json'
     ];
 
     // Generated directory patterns

package/lib/adoption/smart-orchestrator.js

@@ -289,6 +289,7 @@ class SmartOrchestrator {
       'config/session-governance.json',
       'config/spec-domain-policy.json',
       'config/problem-eval-policy.json',
+      'config/problem-closure-policy.json',
       'README.md'
     ];
 

package/lib/commands/errorbook.js

@@ -48,6 +48,7 @@ const ONTOLOGY_TAG_ALIASES = Object.freeze({
   action_chain: 'execution_flow'
 });
 const DEFAULT_PROMOTE_MIN_QUALITY = 75;
+const DEFAULT_RELEASE_GATE_MIN_QUALITY = 70;
 const ERRORBOOK_RISK_LEVELS = Object.freeze(['low', 'medium', 'high']);
 const DEBUG_EVIDENCE_TAGS = Object.freeze([
   'debug-evidence',
@@ -515,11 +516,21 @@ async function writeIncident(paths, incident, fileSystem = fs) {
 }
 
 function createIncidentAttemptSignature(payload = {}) {
+  const attemptContract = payload && payload.attempt_contract && typeof payload.attempt_contract === 'object'
+    ? payload.attempt_contract
+    : {};
   const basis = JSON.stringify({
     root_cause: normalizeText(payload.root_cause),
     fix_actions: normalizeStringList(payload.fix_actions),
     verification_evidence: normalizeStringList(payload.verification_evidence),
     notes: normalizeText(payload.notes),
+    attempt_contract: {
+      hypothesis: normalizeText(attemptContract.hypothesis),
+      change_points: normalizeStringList(attemptContract.change_points),
+      verification_result: normalizeText(attemptContract.verification_result),
+      rollback_point: normalizeText(attemptContract.rollback_point),
+      conclusion: normalizeText(attemptContract.conclusion)
+    },
     source: {
       spec: normalizeText(payload?.source?.spec),
       files: normalizeStringList(payload?.source?.files),
@@ -600,6 +611,15 @@ async function syncIncidentLoopForRecord(paths, payload = {}, entry = {}, option
     tags: normalizeStringList(payload.tags || entry.tags),
     ontology_tags: normalizeOntologyTags(payload.ontology_tags || entry.ontology_tags),
     notes: normalizeText(payload.notes || entry.notes),
+    attempt_contract: {
+      hypothesis: normalizeText(payload?.attempt_contract?.hypothesis || entry?.attempt_contract?.hypothesis),
+      change_points: normalizeStringList(payload?.attempt_contract?.change_points || entry?.attempt_contract?.change_points),
+      verification_result: normalizeText(
+        payload?.attempt_contract?.verification_result || entry?.attempt_contract?.verification_result
+      ),
+      rollback_point: normalizeText(payload?.attempt_contract?.rollback_point || entry?.attempt_contract?.rollback_point),
+      conclusion: normalizeText(payload?.attempt_contract?.conclusion || entry?.attempt_contract?.conclusion)
+    },
     source: {
       spec: normalizeText(payload?.source?.spec || entry?.source?.spec),
       files: normalizeStringList(payload?.source?.files || entry?.source?.files),
@@ -695,6 +715,19 @@ function scoreQuality(entry = {}) {
   if (normalizeText(entry.symptom).length >= 24 && normalizeText(entry.root_cause).length >= 24) {
     score += 2;
   }
+  const attemptContract = entry && typeof entry.attempt_contract === 'object'
+    ? entry.attempt_contract
+    : {};
+  const attemptContractComplete = Boolean(
+    normalizeText(attemptContract.hypothesis)
+    && normalizeStringList(attemptContract.change_points).length > 0
+    && normalizeText(attemptContract.verification_result)
+    && normalizeText(attemptContract.rollback_point)
+    && normalizeText(attemptContract.conclusion)
+  );
+  if (attemptContractComplete) {
+    score += 5;
+  }
 
   return Math.max(0, Math.min(100, score));
 }
@@ -712,6 +745,24 @@ function validateRecordPayload(payload) {
   if (!Array.isArray(payload.fix_actions) || payload.fix_actions.length === 0) {
     throw new Error('at least one --fix-action is required');
   }
+  const attemptContract = payload.attempt_contract && typeof payload.attempt_contract === 'object'
+    ? payload.attempt_contract
+    : {};
+  if (!normalizeText(attemptContract.hypothesis)) {
+    throw new Error('attempt contract requires hypothesis');
+  }
+  if (!Array.isArray(attemptContract.change_points) || attemptContract.change_points.length === 0) {
+    throw new Error('attempt contract requires change_points');
+  }
+  if (!normalizeText(attemptContract.verification_result)) {
+    throw new Error('attempt contract requires verification_result');
+  }
+  if (!normalizeText(attemptContract.rollback_point)) {
+    throw new Error('attempt contract requires rollback_point');
+  }
+  if (!normalizeText(attemptContract.conclusion)) {
+    throw new Error('attempt contract requires conclusion');
+  }
 
   const status = normalizeStatus(payload.status, 'candidate');
   if (status === 'promoted') {
@@ -807,6 +858,42 @@ function normalizeRecordPayload(options = {}, fromFilePayload = {}) {
     })
   };
 
+  const attemptContractFromFile = fromFilePayload && typeof fromFilePayload.attempt_contract === 'object'
+    ? fromFilePayload.attempt_contract
+    : {};
+  payload.attempt_contract = {
+    hypothesis: normalizeText(
+      options.attemptHypothesis
+      || attemptContractFromFile.hypothesis
+      || payload.root_cause
+    ),
+    change_points: normalizeStringList(
+      options.attemptChangePoints,
+      attemptContractFromFile.change_points,
+      attemptContractFromFile.changePoints,
+      payload.fix_actions
+    ),
+    verification_result: normalizeText(
+      options.attemptVerificationResult
+      || attemptContractFromFile.verification_result
+      || attemptContractFromFile.verificationResult
+      || (payload.verification_evidence[0] || '')
+      || 'pending-verification'
+    ),
+    rollback_point: normalizeText(
+      options.attemptRollbackPoint
+      || attemptContractFromFile.rollback_point
+      || attemptContractFromFile.rollbackPoint
+      || 'not-required'
+    ),
+    conclusion: normalizeText(
+      options.attemptConclusion
+      || attemptContractFromFile.conclusion
+      || payload.notes
+      || payload.root_cause
+    )
+  };
+
   return payload;
 }
 
@@ -872,6 +959,30 @@ function mergeEntry(existingEntry, incomingPayload) {
     ontology_tags: normalizeOntologyTags(existingEntry.ontology_tags, incomingPayload.ontology_tags),
     status: selectStatus(existingEntry.status, incomingPayload.status),
     notes: normalizeText(incomingPayload.notes) || existingEntry.notes || '',
+    attempt_contract: {
+      hypothesis: normalizeText(incomingPayload?.attempt_contract?.hypothesis)
+        || normalizeText(existingEntry?.attempt_contract?.hypothesis)
+        || normalizeText(incomingPayload.root_cause)
+        || normalizeText(existingEntry.root_cause),
+      change_points: normalizeStringList(
+        existingEntry?.attempt_contract?.change_points,
+        incomingPayload?.attempt_contract?.change_points,
+        incomingPayload.fix_actions
+      ),
+      verification_result: normalizeText(incomingPayload?.attempt_contract?.verification_result)
+        || normalizeText(existingEntry?.attempt_contract?.verification_result)
+        || normalizeStringList(incomingPayload.verification_evidence, existingEntry.verification_evidence)[0]
+        || '',
+      rollback_point: normalizeText(incomingPayload?.attempt_contract?.rollback_point)
+        || normalizeText(existingEntry?.attempt_contract?.rollback_point)
+        || 'not-required',
+      conclusion: normalizeText(incomingPayload?.attempt_contract?.conclusion)
+        || normalizeText(existingEntry?.attempt_contract?.conclusion)
+        || normalizeText(incomingPayload.notes)
+        || normalizeText(existingEntry.notes)
+        || normalizeText(incomingPayload.root_cause)
+        || normalizeText(existingEntry.root_cause)
+    },
     source: {
       spec: normalizeText(incomingPayload?.source?.spec) || normalizeText(existingEntry?.source?.spec),
       files: normalizeStringList(existingEntry?.source?.files, incomingPayload?.source?.files),
@@ -1395,7 +1506,7 @@ function evaluateEntryRisk(entry = {}) {
   if (hasHighRiskTag) {
     return 'high';
   }
-  if (status === 'candidate' && qualityScore >= 85) {
+  if (status === 'candidate' && qualityScore > 85) {
     return 'high';
   }
   if (status === 'candidate' && qualityScore >= 75 && ontologyTags.includes('decision_policy')) {
@@ -1404,7 +1515,7 @@ function evaluateEntryRisk(entry = {}) {
   if (status === 'candidate') {
     return 'medium';
   }
-  if (qualityScore >= 85 && ontologyTags.includes('decision_policy')) {
+  if (qualityScore > 85 && ontologyTags.includes('decision_policy')) {
     return 'high';
   }
   return 'medium';
@@ -1417,6 +1528,9 @@ async function evaluateErrorbookReleaseGate(options = {}, dependencies = {}) {
   const index = await readErrorbookIndex(paths, fileSystem);
   const minRisk = normalizeRiskLevel(options.minRisk || options.min_risk || 'high', 'high');
   const includeVerified = options.includeVerified === true;
+  const minQuality = Number.isFinite(Number(options.minQuality || options.min_quality))
+    ? Math.max(0, Math.min(100, Number(options.minQuality || options.min_quality)))
+    : DEFAULT_RELEASE_GATE_MIN_QUALITY;
 
   const inspected = [];
   const mitigationInspected = [];
@@ -1474,6 +1588,14 @@ async function evaluateErrorbookReleaseGate(options = {}, dependencies = {}) {
       block_reasons: ['risk_threshold']
     }));
 
+  const curationBlocked = inspected
+    .filter((item) => item.status === 'verified' && Number(item.quality_score || 0) < minQuality)
+    .map((item) => ({
+      ...item,
+      block_reasons: ['curation_quality'],
+      policy_violations: [`quality_score<${minQuality}`]
+    }));
+
   const blockedById = new Map();
   for (const item of riskBlocked) {
     blockedById.set(item.id, {
@@ -1497,6 +1619,19 @@ async function evaluateErrorbookReleaseGate(options = {}, dependencies = {}) {
     }
     blockedById.set(existing.id, existing);
   }
+  for (const item of curationBlocked) {
+    const existing = blockedById.get(item.id);
+    if (!existing) {
+      blockedById.set(item.id, {
+        ...item,
+        policy_violations: normalizeStringList(item.policy_violations)
+      });
+      continue;
+    }
+    existing.block_reasons = normalizeStringList(existing.block_reasons, item.block_reasons);
+    existing.policy_violations = normalizeStringList(existing.policy_violations, item.policy_violations);
+    blockedById.set(existing.id, existing);
+  }
 
   const blocked = Array.from(blockedById.values())
     .sort((left, right) => {
@@ -1519,12 +1654,14 @@ async function evaluateErrorbookReleaseGate(options = {}, dependencies = {}) {
     mode: 'errorbook-release-gate',
     gate: {
       min_risk: minRisk,
+      min_quality: minQuality,
       include_verified: includeVerified,
       mitigation_policy_enforced: true
     },
     passed: blocked.length === 0,
     inspected_count: inspected.length,
     risk_blocked_count: riskBlocked.length,
+    curation_blocked_count: curationBlocked.length,
     mitigation_inspected_count: mitigationInspected.length,
     mitigation_blocked_count: mitigationBlocked.length,
     blocked_count: blocked.length,
@@ -1609,6 +1746,7 @@ async function runErrorbookRecordCommand(options = {}, dependencies = {}) {
       source: normalized.source,
       temporary_mitigation: mitigationPayload,
       notes: normalized.notes || '',
+      attempt_contract: normalized.attempt_contract,
       occurrences: 1
     };
     entry.quality_score = scoreQuality(entry);
@@ -2823,6 +2961,7 @@ function registerErrorbookCommands(program) {
     .command('release-gate')
     .description('Block release on unresolved high-risk entries and temporary-mitigation policy violations')
     .option('--min-risk <level>', 'Risk threshold (low|medium|high)', 'high')
+    .option('--min-quality <n>', `Minimum quality for unresolved entries (default: ${DEFAULT_RELEASE_GATE_MIN_QUALITY})`, parseInt)
     .option('--include-verified', 'Also inspect verified (non-promoted) entries')
     .option('--fail-on-block', 'Exit with error when gate is blocked')
     .option('--json', 'Emit machine-readable JSON')
@@ -2873,6 +3012,7 @@ module.exports = {
   HIGH_RISK_SIGNAL_TAGS,
   DEBUG_EVIDENCE_TAGS,
   DEFAULT_PROMOTE_MIN_QUALITY,
+  DEFAULT_RELEASE_GATE_MIN_QUALITY,
   ERRORBOOK_INCIDENT_INDEX_API_VERSION,
   ERRORBOOK_INCIDENT_API_VERSION,
   resolveErrorbookPaths,