@guanlin4924/devflow-pi 0.1.82 → 0.1.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanlin4924/devflow-pi",
-  "version": "0.1.82",
+  "version": "0.1.85",
   "type": "module",
   "description": "Devflow 专项研发 Pi，基于固定版本 OMP Runtime 组装研发状态机、代码智能、设计、实现与质量门禁。",
   "license": "UNLICENSED",

package/plugins/devflow-core/extensions/devflow-core.ts

@@ -968,7 +968,9 @@ export function workflowResumeDisposition(snapshot: Record<string, unknown>): Wo
 
   const feature = typeof snapshot.current_feature === "string" ? snapshot.current_feature : "";
   const revision = snapshot.revision;
-  const selectedStep = compactStep(snapshot.next_step) ?? compactStep(snapshot.current_step);
+  const selectedStep = snapshot.action === "run_parallel_window"
+    ? compactStep(snapshot.next_step) ?? compactStep(snapshot.current_step)
+    : compactStep(snapshot.current_step) ?? compactStep(snapshot.next_step);
   const stepId = typeof selectedStep?.id === "string" ? selectedStep.id : "";
   if (!feature || !stepId || typeof revision !== "number" || !Number.isInteger(revision)) return "idle";
 
@@ -985,7 +987,9 @@ export function workflowResumeDisposition(snapshot: Record<string, unknown>): Wo
 }
 
 function workflowDirective(snapshot: Record<string, unknown>, source: "start" | "approval", requirementDraft?: string): string {
-  const selectedStep = compactStep(snapshot.next_step) ?? compactStep(snapshot.current_step);
+  const selectedStep = snapshot.action === "run_parallel_window"
+    ? compactStep(snapshot.next_step) ?? compactStep(snapshot.current_step)
+    : compactStep(snapshot.current_step) ?? compactStep(snapshot.next_step);
   const envelope = {
     source,
     action: snapshot.action,
@@ -3818,6 +3822,31 @@ export default function devflowCore(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerTool({
+    name: "devflow_review_run",
+    label: "Devflow Fact-Bound Review",
+    description: "Run an independent, read-only review against approved expectations and hash-verified source evidence. Core records immutable rounds; this does not approve a release.",
+    parameters: z.object({
+      chain_id: z.string().nullable().optional(),
+      target: z.object({ feature: z.string(), paths: z.array(z.string()), change_ref: z.literal("worktree") }),
+      expectations: z.array(z.object({ id: z.string(), statement: z.string(), authority_ref: z.string() })),
+      review_plan: z.object({ questions: z.array(z.string()), surfaces: z.array(z.string()), required_scenarios: z.array(z.string()) }),
+      observations: z.array(z.unknown()).default([]),
+      coverage_evidence: z.record(z.string(), z.unknown()).optional(),
+      regression_evidence: z.record(z.string(), z.unknown()).optional(),
+    }),
+    approval: "write",
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      assertRuntimeProjectBoundary(ctx.cwd);
+      return renderResult(await runProcess(
+        ["python3", path.join(resolveKitRoot(ctx.cwd), "workflow-orchestrator/scripts/review_run.py"), ctx.cwd],
+        ctx.cwd,
+        {},
+        JSON.stringify(params),
+      ));
+    },
+  });
+
   pi.registerTool({
     name: "devflow_artifact",
     label: "Devflow Artifact Registry",

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/advance_state.rb

@@ -112,8 +112,14 @@ def transition_gate_contract(workflow, step)
       "allowed_reentry" => reentries,
       "checkpoint" => checkpoint && checkpoint.merge("id" => checkpoint_id)
     },
+    # Inputs can be produced by the step itself. Keep one declaration, but
+    # give the gate separate entry/completion semantics so an input may be
+    # absent on entry while still being mandatory before completion.
     "entry" => { "required_inputs" => Array(step["inputs"]) },
-    "outputs" => { "required" => Array(step["outputs"]).select { |output| output["required"] } },
+    "outputs" => {
+      "required" => Array(step["outputs"]).select { |output| output["required"] },
+      "required_inputs" => Array(step["inputs"]).select { |input| input.is_a?(Hash) && input["required_at_completion"] == true }
+    },
     "quality" => { "checker_ids" => Array(workflow.dig("governance", "step_checkers", step["id"])) },
     "concurrency" => { "project_lock" => "required", "optimistic_revision" => "required", "registry_view" => "candidate_overlay" },
     "recovery" => { "allowed" => ["sync_artifacts", "repair_outputs"], "max_attempts" => 2 }

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/execution_contract.rb

@@ -15,6 +15,12 @@ POLICY = {
   "requirement-baseline" => { "checkers" => %w[requirement-graph-check business-closure-check slice-independence-check acceptance-coverage-check change-impact-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[requirement rule boundary slice acceptance] },
   "api-contract" => { "checkers" => %w[requirement-graph-check contract-coverage-check api-test-schema-check change-impact-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[api] },
   "architecture-feasibility" => { "checkers" => %w[requirement-graph-check change-impact-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[workload_shape workload_constraint decision risk metric read_model] },
+  "backend-tech-spec" => { "checkers" => %w[requirement-graph-check change-impact-check], "agents" => ["implementation-worker"], "budget" => 1, "allowed_graph_delta" => %w[decision risk] },
+  "api-call-guide" => { "checkers" => %w[requirement-graph-check contract-coverage-check], "agents" => ["implementation-worker"], "budget" => 1, "allowed_graph_delta" => %w[api decision] },
+  "ui-spec" => { "checkers" => %w[requirement-graph-check change-impact-check], "agents" => ["implementation-worker"], "budget" => 1, "allowed_graph_delta" => %w[decision risk] },
+  "feature-breakdown" => { "checkers" => %w[requirement-graph-check], "agents" => ["implementation-worker"], "budget" => 1, "allowed_graph_delta" => %w[requirement rule] },
+  "frontend-tech-spec" => { "checkers" => %w[requirement-graph-check change-impact-check], "agents" => ["implementation-worker"], "budget" => 1, "allowed_graph_delta" => %w[decision risk] },
+  "api-supplement" => { "checkers" => %w[requirement-graph-check contract-coverage-check], "agents" => ["implementation-worker"], "budget" => 1, "allowed_graph_delta" => %w[api decision] },
   "integration-verify" => { "checkers" => %w[requirement-graph-check slice-independence-check contract-coverage-check change-impact-check cross-track-consistency-check business-claim-reference-check business-cross-model-check], "agents" => ["verification-runner"], "budget" => 1, "allowed_graph_delta" => %w[requirement risk decision] },
   "acceptance-test-design" => { "checkers" => %w[requirement-graph-check contract-coverage-check acceptance-coverage-check api-test-matrix-check test-coverage-check test-obligation-check change-impact-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[test_case] },
   "change-plan" => { "checkers" => %w[requirement-graph-check slice-independence-check contract-coverage-check api-test-matrix-check test-coverage-check test-obligation-check test-task-binding-check change-impact-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[acceptance] },
@@ -45,6 +51,27 @@ def interpolate(value, state)
   value.gsub("{feature}", state.fetch("current_feature").to_s).gsub("{phase}", state.fetch("current_phase").to_s)
 end
 
+def render_execution_contract_markdown(contract)
+  lines = [
+    "# Execution Contract",
+    "",
+    "> Core-generated derived view. The immutable contract JSON under `.planning/contracts/` is authoritative.",
+    "",
+    "- Contract ID: `#{contract.fetch("contract_id")}`",
+    "- Feature: `#{contract.fetch("feature")}`",
+    "- Step: `#{contract.fetch("step")}`",
+    "- STATE revision: `#{contract.fetch("state_revision")}`",
+    "- Requirement graph revision: `#{contract.fetch("graph_revision")}`",
+    "- Frozen hash: `#{contract.fetch("frozen_hash")}`",
+    "",
+    "## Allowed paths",
+    "",
+  ]
+  lines.concat(Array(contract["allowed_paths"]).map { |path| "- `#{path}`" })
+  lines.concat(["", "## Allowed agents", "", *Array(contract["allowed_agents"]).map { |agent| "- `#{agent}`" }, "", "## Checkers", "", *Array(contract["checker_ids"]).map { |checker| "- `#{checker}`" }, "", "## Allowed tools", "", *Array(contract["allowed_tools"]).map { |tool| "- `#{tool}`" }, ""])
+  lines.join("\n")
+end
+
 root = Dir.pwd
 lock = %w[create inspect].include?(command) ? DevflowControlIO.acquire_project_lock(root) : nil
 begin
@@ -70,7 +97,15 @@ begin
     "state_revision" => state["revision"], "graph_revision" => graph["revision"], "workflow_path" => workflow_relative,
     "workflow_fingerprint" => Digest::SHA256.hexdigest(workflow_raw), "manifest_id" => "devflow-core-execution-policy-v2",
     "allowed_paths" => paths, "allowed_agents" => policy["agents"], "checker_ids" => policy["checkers"],
-    "allowed_tools" => %w[read grep find glob lsp search write edit apply_patch bash shell exec_command task devflow_api_test_matrix devflow_tdd_evidence devflow_run_acceptance_tests devflow_mainflow],
+    # Core read/write tools required by the architecture feasibility skill are
+    # part of the frozen contract.  The tool layer still applies per-tool
+    # mutation ownership and the step's allowed paths.
+    "allowed_tools" => %w[
+      read grep find glob lsp search write edit apply_patch bash shell exec_command task
+      devflow_api_test_matrix devflow_tdd_evidence devflow_run_acceptance_tests devflow_mainflow
+      devflow_requirement_graph devflow_static_runtime_context
+      devflow_architecture_constraint devflow_architecture_feasibility devflow_architecture_brief
+    ],
     "tool_budget" => policy["budget"], "acceptance" => Array(graph["nodes"]).select { |node| node["kind"] == "acceptance" }.map { |node| node["id"] },
     "allowed_graph_delta" => Array(policy["allowed_graph_delta"]),
     "on_unknown" => "block_and_escalate"
@@ -84,6 +119,7 @@ begin
     raise ArgumentError, "--write is required" unless options[:write]
     destination = File.join(root, ".planning/contracts", options[:feature], "#{contract_id}.json")
     DevflowControlIO.atomic_write(destination, JSON.pretty_generate(frozen) + "\n")
+    DevflowControlIO.atomic_write(File.join(root, ".planning/execution-contract.md"), render_execution_contract_markdown(frozen) + "\n")
     audit = File.join(root, ".planning/contracts", options[:feature], "control-events.jsonl")
     existing = File.exist?(audit) ? File.read(audit) : ""
     DevflowControlIO.atomic_write(audit, existing + JSON.generate({ "event" => "execution_contract_frozen", "contract_id" => contract_id, "state_revision" => state["revision"], "graph_revision" => graph["revision"], "frozen_hash" => frozen["frozen_hash"] }) + "\n")

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/gate_runtime.rb

@@ -7,8 +7,10 @@ require_relative "gate_contract"
 require_relative "checker_registry"
 require_relative "parallel_run"
 require_relative "business_model_gate"
+require_relative "requirement_graph"
 
 module GateRuntime
+  KNOWN_VALIDATIONS = %w[static-runtime-context requirement-graph].freeze
   WORKFLOW_STATUSES = %w[not_started in_progress waiting_checkpoint completed blocked failed cancelled remediation].freeze
 
   module_function
@@ -59,11 +61,16 @@ module GateRuntime
         return GateResult.block(**base, code: "STEP_PREDECESSOR_INVALID", message: "previous step is not allowed by GateContract")
       end
       if root
-        missing = required_paths(contract.dig("entry", "required_inputs"), root, workflow_state, allow_missing_collections: true)
+        missing = required_paths(contract.dig("entry", "required_inputs"), root, workflow_state, allow_missing_collections: true, purpose: :entry)
         return GateResult.block(**base, code: "REQUIRED_INPUT_MISSING", message: "required gate input is missing", details: { "missing" => missing }) unless missing.empty?
+        invalid = validate_declared_inputs(contract.dig("entry", "required_inputs"), root, workflow_state, purpose: :entry)
+        return GateResult.block(**base, code: "REQUIRED_INPUT_INVALID", message: "required gate input is invalid", details: { "invalid" => invalid }) unless invalid.empty?
         if check_outputs
           missing_outputs = required_paths(contract.dig("outputs", "required"), root, workflow_state)
+          missing_outputs.concat(required_paths(contract.dig("outputs", "required_inputs"), root, workflow_state, purpose: :completion))
           return GateResult.block(**base, code: "REQUIRED_OUTPUT_MISSING", message: "required step output is missing", details: { "missing" => missing_outputs }) unless missing_outputs.empty?
+          invalid_outputs = validate_declared_inputs(contract.dig("outputs", "required_inputs"), root, workflow_state, purpose: :completion)
+          return GateResult.block(**base, code: "REQUIRED_OUTPUT_INVALID", message: "required step input/output fact is invalid", details: { "invalid" => invalid_outputs }) unless invalid_outputs.empty?
         end
       end
     end
@@ -148,9 +155,14 @@ module GateRuntime
     )
   end
 
-  def required_paths(entries, root, state, allow_missing_collections: false)
+  def required_paths(entries, root, state, allow_missing_collections: false, purpose: :entry)
     Array(entries).each_with_object([]) do |entry, missing|
       raw = entry.is_a?(Hash) ? entry["path"] : entry
+      if entry.is_a?(Hash)
+        next if purpose == :entry && entry["required"] == false
+        next if purpose == :entry && entry.key?("required_at_entry") && entry["required_at_entry"] == false
+        next if purpose == :completion && entry["required_at_completion"] != true
+      end
       next if raw.to_s.empty?
       relative = raw.to_s.gsub("{feature}", state.fetch("current_feature", "").to_s).gsub("{phase}", state.fetch("current_phase", "").to_s)
       absolute = File.expand_path(relative, root)
@@ -163,4 +175,47 @@ module GateRuntime
       missing << relative
     end
   end
+
+  def validate_declared_inputs(entries, root, state, purpose: :entry)
+    Array(entries).each_with_object([]) do |entry, invalid|
+      next unless entry.is_a?(Hash)
+      next if purpose == :completion && entry["required_at_completion"] != true
+      next if purpose == :entry && entry["required"] == false
+      next if purpose == :entry && entry.key?("required_at_entry") && entry["required_at_entry"] == false
+      validation = entry["validation"].to_s
+      next if validation.empty?
+      unless KNOWN_VALIDATIONS.include?(validation)
+        invalid << "#{entry["path"]}: unknown validation #{validation}"
+        next
+      end
+      raw = entry["path"].to_s
+      relative = raw.gsub("{feature}", state.fetch("current_feature", "").to_s).gsub("{phase}", state.fetch("current_phase", "").to_s)
+      absolute = File.expand_path(relative, root)
+      begin
+        payload = JSON.parse(File.read(absolute))
+        case validation
+        when "static-runtime-context"
+          pointer_path = payload.fetch("path")
+          raise "invalid pointer path" unless pointer_path.start_with?(".context/static-runtime-context/revisions/")
+          root_real = File.realpath(root)
+          revisions_root = File.realpath(File.join(root, ".context/static-runtime-context/revisions"))
+          snapshot_real = File.realpath(File.expand_path(pointer_path, root))
+          raise "snapshot path escapes project root" unless snapshot_real.start_with?("#{root_real}#{File::SEPARATOR}")
+          raise "snapshot path escapes revisions directory" unless snapshot_real.start_with?("#{revisions_root}#{File::SEPARATOR}")
+          raise "snapshot is not a regular file" unless File.file?(snapshot_real)
+          snapshot = JSON.parse(File.read(snapshot_real))
+          raise "unsupported schema" unless snapshot["schema_version"] == 2
+          raise "collector identity missing" unless snapshot["collector_version"] == "static-runtime-context-v2.1"
+          raise "revision mismatch" unless payload["current_revision"] == snapshot["snapshot_revision"] && snapshot["snapshot_revision"].is_a?(Integer) && snapshot["snapshot_revision"] > 0
+        when "requirement-graph"
+          raise "unsupported graph schema" unless RequirementGraph::SUPPORTED_SCHEMA_VERSIONS.include?(payload["schema_version"])
+          raise "invalid graph shape" unless payload["feature"] == state.fetch("current_feature") && payload["revision"].is_a?(Integer) && payload["nodes"].is_a?(Array) && payload["edges"].is_a?(Array) && payload["stale"].is_a?(Array)
+          graph_errors = RequirementGraph.validate(payload)
+          raise "graph validation failed: #{graph_errors.join("; ")}" unless graph_errors.empty?
+        end
+      rescue StandardError => error
+        invalid << "#{relative}: #{error.message}"
+      end
+    end
+  end
 end

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/inspect_state.rb

@@ -212,6 +212,10 @@ def track_boundary(state, pending_ids, completed_ids)
 end
 
 def active_parallel_window(workflow, state, root, step_by_id, completed_ids, pending_ids, artifact_by_path)
+  # A failed/unsupported parallel dispatch may be explicitly converted to the
+  # declared serial fallback. Keep the join topology in the workflow, but do
+  # not re-enter the same parallel window on every inspection.
+  return nil if state["parallel_execution_mode"].to_s == "serial_fallback"
   Array(workflow["parallel_windows"]).each do |window|
     after_step = window["after_step"]
     branch_map = window["branches"].is_a?(Hash) ? window["branches"] : {}

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/parallel_run.rb

@@ -206,7 +206,7 @@ if $PROGRAM_NAME == __FILE__
   begin
   options = { action: nil, feature: nil, state_revision: nil, run_revision: nil, branch_id: nil, status: nil, workflow_window: nil, branches: [], state_path: ".planning/STATE.md", json: false }
   OptionParser.new do |opts|
-    opts.on("--action ACTION", %w[inspect prepare update retry rebase]) { |value| options[:action] = value }
+    opts.on("--action ACTION", %w[inspect prepare update retry rebase serial-fallback]) { |value| options[:action] = value }
     opts.on("--feature FEATURE") { |value| options[:feature] = value }
     opts.on("--state-revision REV", Integer) { |value| options[:state_revision] = value }
     opts.on("--run-revision REV", Integer) { |value| options[:run_revision] = value }
@@ -214,6 +214,8 @@ if $PROGRAM_NAME == __FILE__
     opts.on("--status STATUS") { |value| options[:status] = value }
     opts.on("--workflow-window NAME") { |value| options[:workflow_window] = value }
     opts.on("--state PATH") { |value| options[:state_path] = value }
+    opts.on("--step STEP") { |value| options[:serial_step] = value }
+    opts.on("--expected-state-revision REV", Integer) { |value| options[:expected_state_revision] = value }
     opts.on("--branch STEP:TRACK", "Register a branch as workflow_step:track") do |value|
       workflow_step, track = value.split(":", 2)
       raise ArgumentError, "--branch must be WORKFLOW_STEP:TRACK" if workflow_step.to_s.empty? || track.to_s.empty?
@@ -233,7 +235,55 @@ if $PROGRAM_NAME == __FILE__
              ParallelRun.update_branch(root: Dir.pwd, feature: options[:feature], branch_id: options[:branch_id], expected_revision: options[:run_revision], status: options[:status])
            when "retry"
              ParallelRun.retry_branch(root: Dir.pwd, feature: options[:feature], branch_id: options[:branch_id], expected_revision: options[:run_revision])
-           when "rebase"
+  when "serial-fallback"
+    root = Dir.pwd
+    feature = ParallelRun.safe_feature(options[:feature])
+    lock = DevflowControlIO.acquire_project_lock(root)
+    begin
+      record = ParallelRun.load(root, feature) || raise(ArgumentError, "parallel run not found")
+      state_path, = DevflowControlIO.resolve_control_path(root, options[:state_path], :state)
+      state_text = File.read(state_path)
+      front = state_text.match(/\A---\n(.*?)\n---\n/m)&.[](1)
+      raise ArgumentError, "STATE.md has no YAML front matter" unless front
+      state = YAML.safe_load(front, permitted_classes: [], aliases: false)
+      raise ArgumentError, "STATE feature mismatch" unless state["current_feature"].to_s == feature
+      raise ArgumentError, "STATE does not reference this parallel run" unless state["parallel_run_ref"].to_s == record["run_id"].to_s
+      actual_revision = Integer(state.fetch("revision"))
+      if options[:expected_state_revision] && actual_revision != options[:expected_state_revision]
+        raise ArgumentError, "STATE revision conflict"
+      end
+      branches = Array(record["branches"])
+      raise ArgumentError, "serial fallback is only safe before any branch succeeds or runs" if branches.any? { |branch| %w[running succeeded].include?(branch["status"].to_s) }
+      workflow_path, = DevflowControlIO.resolve_control_path(root, state.fetch("workflow_config"), :workflow)
+      workflow = YAML.safe_load(File.read(workflow_path), permitted_classes: [], aliases: false)
+      policy = Array(workflow["parallel_windows"]).find { |window| window.is_a?(Hash) && window["id"].to_s == record["workflow_window"].to_s }&.dig("execution_policy", "serial_fallback_order")
+      order = Array(policy).map(&:to_s)
+      selected = options[:serial_step].to_s
+      selected = order.find do |step_id|
+        branch = branches.find { |item| item["workflow_step"].to_s == step_id }
+        branch && branch["status"].to_s == "pending"
+      end if selected.empty?
+      raise ArgumentError, "serial fallback has no pending branch" if selected.to_s.empty?
+      raise ArgumentError, "serial fallback step is not a pending branch" unless branches.any? { |branch| branch["workflow_step"].to_s == selected && branch["status"].to_s == "pending" }
+
+      state.delete("parallel_run_ref")
+      state["parallel_execution_mode"] = "serial_fallback"
+      state["current_step"] = selected
+      state["revision"] = actual_revision + 1
+      state["state_updated_at"] = Date.today.to_s
+      body = state_text.sub(/\A---\n.*?\n---\n/m, "---\n#{state.to_yaml.sub(/\A---\n/, "")}---\n")
+      DevflowControlIO.atomic_write(state_path, body)
+      record["status"] = "abandoned_serial_fallback"
+      record["abandoned_at"] = Time.now.utc.iso8601
+      record["abandon_reason"] = "no child Agent lifecycle started; converted to declared serial_fallback_order"
+      record["serial_fallback_step"] = selected
+      record["updated_at"] = Time.now.utc.iso8601
+      ParallelRun.write(root, feature, record)
+      result = { "ok" => true, "state_revision" => state["revision"], "serial_step" => selected, "run" => record }
+    ensure
+      DevflowControlIO.release_lock(lock)
+    end
+  when "rebase"
              raise ArgumentError, "--state-revision is required" if options[:state_revision].nil?
              ParallelRun.rebase_state_revision(root: Dir.pwd, feature: options[:feature], state_revision: options[:state_revision])
                .then { |run| run ? { "ok" => true, "run" => run } : { "ok" => false, "reason" => "parallel_run_not_found" } }

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/review_run.py

@@ -0,0 +1,472 @@
+#!/usr/bin/env python3
+"""Fact-bound, append-only review ledger. Input is one JSON object on stdin.
+
+This service validates review evidence; it does not execute untrusted review plans or
+pretend that a source excerpt alone proves runtime behaviour.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import secrets
+import sqlite3
+import subprocess
+import sys
+from typing import Any
+
+SURFACES = {"entry", "service", "storage", "tests"}
+SCENARIOS = {"normal", "unauthorized", "concurrency", "failure_rollback", "compatibility"}
+IMPACTS = {
+    "cross_boundary_exposure": "P0", "irrecoverable_data_loss": "P0",
+    "major_security_failure": "P0", "core_promise_failure": "P0",
+    "critical_behavior": "P1", "important_coverage_gap": "P1",
+    "local_correctness": "P2", "compatibility": "P2", "maintainability": "P2",
+    "low_risk_improvement": "P3",
+}
+
+
+def digest(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def canonical(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def safe_file(root: Path, relative: str) -> Path:
+    if not isinstance(relative, str) or not relative or Path(relative).is_absolute() or "\x00" in relative:
+        raise ValueError("path must be a nonempty project-relative path")
+    target = (root / relative).resolve(strict=True)
+    if not target.is_relative_to(root) or not target.is_file():
+        raise ValueError(f"path escapes project or is not a file: {relative}")
+    return target
+
+
+def read_json(path: Path) -> Any:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def source_evidence(root: Path, evidence: dict) -> dict:
+    relative = evidence.get("path")
+    path = safe_file(root, relative)
+    data = path.read_bytes()
+    expected = evidence.get("sha256")
+    if not isinstance(expected, str) or expected != digest(data):
+        raise StaleEvidence(f"source hash mismatch: {relative}")
+    line = evidence.get("line")
+    lines = data.decode("utf-8").splitlines()
+    if type(line) is not int or line < 1 or line > len(lines):
+        raise ValueError(f"invalid source line: {relative}:{line}")
+    excerpt = evidence.get("excerpt")
+    if not isinstance(excerpt, str) or not excerpt or excerpt not in lines[line - 1]:
+        raise StaleEvidence(f"source line mismatch: {relative}:{line}")
+    return {"path": relative, "line": line, "sha256": expected, "excerpt": excerpt}
+
+
+class StaleEvidence(Exception):
+    pass
+
+
+def validate_authority(root: Path, feature: str, expectations: list) -> tuple[list, list]:
+    issues = []
+    accepted = []
+    for item in expectations:
+        if not isinstance(item, dict) or not all(isinstance(item.get(k), str) and item[k] for k in ("id", "statement", "authority_ref")):
+            issues.append("Each expectation needs id, statement, and authority_ref")
+            continue
+        ref = item["authority_ref"]
+        try:
+            # Only the Core-owned governance graph can authorize an expectation.
+            # Ordinary approved:true JSON is never an authority source.
+            if not ref.startswith("core-graph:") or "@" not in ref:
+                issues.append(f"{item['id']}: authority_ref must identify a Core graph node and revision")
+                continue
+            node_id, revision = ref[len("core-graph:"):].rsplit("@", 1)
+            graph_path = f".planning/requirements/{feature}/governance.json"
+            graph_file = safe_file(root, graph_path)
+            authority = read_json(graph_file)
+            node = next((n for n in authority.get("nodes", []) if isinstance(n, dict) and n.get("id") == node_id), None)
+            data = node.get("data", {}) if node else {}
+            values = {data.get(k) for k in ("statement", "text", "name", "description") if isinstance(data.get(k), str)}
+            stale_ids = {n.get("node_id") for n in authority.get("stale", []) if isinstance(n, dict)}
+            if (authority.get("feature") != feature or str(authority.get("revision")) != revision or not node
+                or node.get("kind") not in {"requirement", "rule", "boundary", "acceptance"}
+                or node.get("status") != "confirmed" or node.get("confirmation", {}).get("origin") != "core"
+                or not node.get("confirmation", {}).get("evidence") or node_id in stale_ids
+                or item["statement"] not in values):
+                issues.append(f"{item['id']}: Core graph node is unconfirmed, stale, mismatched, or has no exact statement: {ref}")
+            else:
+                accepted.append({**item, "authority_revision": revision, "authority_sha256": digest(graph_file.read_bytes()), "authority_path": graph_path, "node_id": node_id})
+        except (OSError, ValueError, json.JSONDecodeError) as exc:
+            issues.append(f"{item['id']}: unreadable authority {ref}: {exc}")
+    if not expectations:
+        issues.append("At least one approved expectation is required")
+    return accepted, issues
+
+
+def db_open(root: Path) -> sqlite3.Connection:
+    planning = root / ".planning"
+    if planning.is_symlink():
+        raise ValueError("unsafe planning directory")
+    directory = planning / "review-runs"
+    if directory.is_symlink():
+        raise ValueError("unsafe review ledger directory")
+    directory.mkdir(parents=True, exist_ok=True)
+    if directory.is_symlink() or not directory.resolve().is_relative_to(root):
+        raise ValueError("unsafe review ledger directory")
+    database_path = directory / "review-runs.sqlite"
+    if database_path.is_symlink():
+        raise ValueError("unsafe review ledger database")
+    db = sqlite3.connect(database_path, timeout=10)
+    db.execute("PRAGMA foreign_keys=ON")
+    db.executescript("""
+      CREATE TABLE IF NOT EXISTS chains (
+        chain_id TEXT PRIMARY KEY, target_key TEXT NOT NULL, authority_key TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, terminal TEXT NOT NULL DEFAULT ''
+      );
+      CREATE TABLE IF NOT EXISTS rounds (
+        chain_id TEXT NOT NULL, round INTEGER NOT NULL, result_json TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY(chain_id, round), FOREIGN KEY(chain_id) REFERENCES chains(chain_id)
+      );
+      CREATE TABLE IF NOT EXISTS events (
+        id INTEGER PRIMARY KEY, chain_id TEXT, status TEXT NOT NULL, detail_json TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+      );
+    """)
+    return db
+
+
+def response(status: str, chain_id: str | None, round_no: int, **details: Any) -> dict:
+    return {"status": status, "chain_id": chain_id, "round": round_no, **details}
+
+
+def locate_index(root: Path, accepted: list, target_paths: list[str], questions: list[str]) -> dict:
+    """Ask the index for bounded leads, never for authoritative conclusions."""
+    index = root / ".planning" / "code-index"
+    script = Path(__file__).resolve().parents[3].parent / "devflow-intel" / "skills" / "workflow-code-index" / "scripts" / "code_index.py"
+    if not index.exists() or not script.exists():
+        return {"status": "unavailable", "reason": "No local code-index snapshot; source evidence is independent"}
+    leads = []
+    generation = None
+    tokens = []
+    for candidate in [*questions, *(e["statement"] for e in accepted)]:
+        tokens.extend(re.findall(r"[A-Za-z_][A-Za-z_0-9]{2,}|[\u3400-\u9fff]{2,12}", candidate))
+    terms = list(dict.fromkeys(tokens))[:16]
+    if not terms:
+        return {"status": "unavailable", "reason": "No bounded search terms could be extracted"}
+    for expectation in accepted[:8]:
+        plan = {"featureTerms": terms, "identifiers": terms, "phases": ["search_symbols", "search_content", "verify_evidence"], "limit": 50}
+        try:
+            result = subprocess.run([sys.executable, str(script), "query-plan", "--index", str(index), "--plan", canonical(plan)], cwd=root, text=True, capture_output=True, timeout=8, check=False)
+            payload = json.loads(result.stdout)
+            if result.returncode or payload.get("_meta", {}).get("status") == "stale_index":
+                return {"status": "unavailable", "reason": payload.get("_meta", {}).get("reason", "Index stale or query unavailable")}
+            meta = payload.get("_meta", {})
+            current = meta.get("snapshot") or meta.get("code_generation")
+            if generation and current and generation != current:
+                return {"status": "stale_evidence", "reason": "Index generation changed between queries"}
+            generation = current or generation
+            verified = []
+            for hit in payload.get("results", []):
+                if not isinstance(hit, dict) or hit.get("path") not in target_paths:
+                    continue
+                relative = hit["path"]
+                try:
+                    source = safe_file(root, relative)
+                    verified.append({"path": relative, "source_sha256": digest(source.read_bytes()), "index_entity_version_id": hit.get("entity_version_id"), "index_snapshot": hit.get("snapshot"), "result_type": hit.get("result_type")})
+                except (OSError, ValueError):
+                    continue
+            leads.append({"expectation_id": expectation["id"], "verified_target_leads": verified, "index_status": meta.get("status")})
+        except (OSError, subprocess.TimeoutExpired, ValueError, json.JSONDecodeError) as exc:
+            return {"status": "unavailable", "reason": str(exc)}
+    return {"status": "located", "generation": generation, "leads": leads}
+
+
+def verify_core_result(root: Path, feature: str, evidence: Any, expected_status: str, authority_node_id: str | None = None) -> tuple[bool, str]:
+    """Accept only a Core-owned TC result bound to the feature and frozen suite."""
+    if not isinstance(evidence, dict):
+        return False, "missing Core acceptance-test result reference"
+    relative = f".planning/test-runs/{feature}/acceptance-results.json"
+    if evidence.get("path") != relative or not isinstance(evidence.get("tc_id"), str):
+        return False, "result must reference a Core acceptance TC for this feature"
+    try:
+        result_file = safe_file(root, relative)
+        if digest(result_file.read_bytes()) != evidence.get("sha256"):
+            return False, "acceptance result hash mismatch"
+        payload = read_json(result_file)
+        suite = read_json(safe_file(root, f".planning/requirements/{feature}/tests.json"))
+        if payload.get("origin") != "core_acceptance_test_runner" or payload.get("feature") != feature:
+            return False, "not a Core acceptance-test run"
+        if payload.get("test_suite") != {"graph_revision": suite.get("graph_revision"), "fingerprint": suite.get("view_meta", {}).get("fingerprint")}:
+            return False, "acceptance result is not bound to the current frozen suite"
+        if suite.get("frozen") is not True:
+            return False, "acceptance suite is not frozen"
+        frozen_nodes = {node.get("id"): node for node in suite.get("nodes", []) if isinstance(node, dict) and node.get("kind") == "test_case" and node.get("status") == "confirmed"}
+        if evidence["tc_id"] not in frozen_nodes:
+            return False, "TC is not in the frozen suite"
+        if authority_node_id:
+            refs = frozen_nodes[evidence["tc_id"]].get("data", {})
+            bound = set(refs.get("requirement_refs", [])) | set(refs.get("acceptance_refs", []))
+            if authority_node_id not in bound:
+                return False, "failed TC is not bound to the expectation's Core requirement or acceptance node"
+        cases = [r for r in payload.get("results", []) if isinstance(r, dict) and r.get("tc_id") == evidence["tc_id"]]
+        if len(cases) != 1 or cases[0].get("status") != expected_status or cases[0].get("mode") != "automated":
+            return False, "TC status or automation mode does not support the assertion"
+        return True, ""
+    except (OSError, ValueError, KeyError, TypeError, json.JSONDecodeError) as exc:
+        return False, f"unreadable Core acceptance result: {exc}"
+
+
+def verify_coverage(root: Path, feature: str, required: list[str], coverage_evidence: Any) -> tuple[set[str], list[str]]:
+    if not isinstance(coverage_evidence, dict):
+        return set(), ["Each review surface and scenario needs a distinct Core TC binding"]
+    covered, issues, used = set(), [], set()
+    for tag in required:
+        ref = coverage_evidence.get(tag)
+        if not isinstance(ref, dict) or not isinstance(ref.get("tc_id"), str):
+            issues.append(f"{tag}: missing Core TC binding")
+            continue
+        if ref["tc_id"] in used:
+            issues.append(f"{tag}: TC already used for a different coverage claim")
+            continue
+        used.add(ref["tc_id"])
+        valid, reason = verify_core_result(root, feature, ref, "passed")
+        if not valid:
+            issues.append(f"{tag}: {reason}")
+            continue
+        suite = read_json(safe_file(root, f".planning/requirements/{feature}/tests.json"))
+        node = next((n for n in suite.get("nodes", []) if isinstance(n, dict) and n.get("id") == ref["tc_id"]), None)
+        types = {"scenario:normal": {"api", "page"}, "scenario:unauthorized": {"permission"}, "scenario:failure_rollback": {"resilience", "boundary"}, "scenario:compatibility": {"migration"}}
+        if not node or node.get("kind") != "test_case" or node.get("status") != "confirmed" or node.get("data", {}).get("test_type") not in types.get(tag, set()):
+            issues.append(f"{tag}: frozen TC type cannot prove this coverage obligation; request human confirmation")
+            continue
+        covered.add(tag)
+    return covered, issues
+
+
+def suite_has_failures(root: Path, feature: str) -> bool:
+    try:
+        payload = read_json(safe_file(root, f".planning/test-runs/{feature}/acceptance-results.json"))
+        return any(isinstance(item, dict) and item.get("status") != "passed" for item in payload.get("results", []))
+    except (OSError, ValueError, TypeError, json.JSONDecodeError):
+        return True
+
+
+def run(root: Path, request: dict) -> dict:
+    root = root.resolve(strict=True)
+    if not isinstance(request, dict):
+        raise ValueError("request must be an object")
+    if "round" in request or "findings" in request or "severity" in request:
+        raise ValueError("Core assigns rounds and findings; caller-supplied authority fields are forbidden")
+    target = request.get("target")
+    if not isinstance(target, dict) or not isinstance(target.get("feature"), str) or not target["feature"]:
+        raise ValueError("target.feature is required")
+    if target.get("change_ref") != "worktree":
+        return response("evidence_unavailable", request.get("chain_id"), 0, questions=["Only verified worktree source is supported; historical source blobs are unavailable"])
+    paths = target.get("paths")
+    if not isinstance(paths, list) or not paths or not all(isinstance(p, str) for p in paths):
+        raise ValueError("target.paths must list reviewed source files")
+    plan = request.get("review_plan")
+    if not isinstance(plan, dict) or not isinstance(plan.get("questions"), list) or not plan["questions"]:
+        raise ValueError("review_plan.questions must be nonempty")
+    if not all(isinstance(q, str) and q.strip() for q in plan["questions"]):
+        raise ValueError("review questions must be strings")
+    surfaces, scenarios = plan.get("surfaces"), plan.get("required_scenarios")
+    if not isinstance(surfaces, list) or not set(surfaces) <= SURFACES or not isinstance(scenarios, list) or not set(scenarios) <= SCENARIOS:
+        raise ValueError("review plan uses an unsupported surface or scenario")
+    # A plan is not an exclusion list: the standard adversarial coverage is required.
+    required = sorted({f"surface:{s}" for s in SURFACES} | {f"scenario:{s}" for s in SCENARIOS} | {f"question:{q}" for q in plan["questions"]})
+    expectations = request.get("expectations", [])
+    if not isinstance(expectations, list):
+        raise ValueError("expectations must be a list")
+    accepted, questions = validate_authority(root, target["feature"], expectations)
+    chain_id = request.get("chain_id")
+    if chain_id is not None and (not isinstance(chain_id, str) or not chain_id.startswith("rev_")):
+        raise ValueError("invalid chain_id")
+    target_key = digest(canonical({"feature": target["feature"], "paths": sorted(paths), "change_ref": "worktree"}).encode())
+    authority_key = digest(canonical(accepted).encode())
+    db = db_open(root)
+    try:
+        db.execute("BEGIN IMMEDIATE")
+        prior = None
+        if chain_id:
+            row = db.execute("SELECT target_key, authority_key, terminal FROM chains WHERE chain_id=?", (chain_id,)).fetchone()
+            if row is None:
+                raise ValueError("unknown chain_id")
+            if row[0] != target_key or (not questions and row[1] != authority_key):
+                raise ValueError("target or approved expectations changed; continue the original chain")
+            if row[2]:
+                raise ValueError(f"chain is terminal: {row[2]}")
+            row = db.execute("SELECT round, result_json FROM rounds WHERE chain_id=? ORDER BY round DESC LIMIT 1", (chain_id,)).fetchone()
+            if row:
+                prior = json.loads(row[1])
+                round_no = row[0] + 1
+            else:
+                round_no = 1
+            if round_no > 3:
+                raise ValueError("three completed review rounds exhausted")
+        else:
+            round_no = 1
+        if questions:
+            result = response("awaiting_human_confirmation", chain_id, round_no, questions=questions)
+            db.execute("INSERT INTO events(chain_id,status,detail_json) VALUES(?,?,?)", (chain_id, result["status"], canonical(result)))
+            db.commit()
+            return result
+        if not chain_id:
+            # A new ID cannot erase an unresolved P0 for the same target and authority.
+            for old_id, raw in db.execute("SELECT c.chain_id,r.result_json FROM chains c JOIN rounds r ON r.chain_id=c.chain_id AND r.round=(SELECT MAX(round) FROM rounds WHERE chain_id=c.chain_id) WHERE c.target_key=? AND c.authority_key=?", (target_key, authority_key)):
+                old = json.loads(raw)
+                if old.get("risk_summary", {}).get("P0", 0) and not old.get("all_p0_resolved"):
+                    raise ValueError(f"unresolved P0 belongs to existing chain {old_id}; human-authorized new task is required")
+            chain_id = "rev_" + secrets.token_hex(16)
+            db.execute("INSERT INTO chains(chain_id,target_key,authority_key) VALUES(?,?,?)", (chain_id, target_key, authority_key))
+        versions = {}
+        for rel in paths:
+            versions[rel] = digest(safe_file(root, rel).read_bytes())
+        index_discovery = locate_index(root, accepted, paths, plan["questions"])
+        if index_discovery["status"] == "stale_evidence":
+            result = response("stale_evidence", chain_id, round_no, questions=[index_discovery["reason"]])
+            db.execute("INSERT INTO events(chain_id,status,detail_json) VALUES(?,?,?)", (chain_id, result["status"], canonical(result)))
+            db.commit()
+            return result
+        observations = request.get("observations", [])
+        if not isinstance(observations, list):
+            raise ValueError("observations must be a list")
+        findings = []
+        covered, coverage_issues = verify_coverage(root, target["feature"], required, request.get("coverage_evidence"))
+        evidence_issues = []
+        for item in observations:
+            if not isinstance(item, dict) or item.get("expectation_id") not in {e["id"] for e in accepted}:
+                raise ValueError("observation has unknown expectation")
+            try:
+                evidence = source_evidence(root, item.get("source", {}))
+            except StaleEvidence as exc:
+                result = response("stale_evidence", chain_id, round_no, questions=[str(exc)])
+                db.execute("INSERT INTO events(chain_id,status,detail_json) VALUES(?,?,?)", (chain_id, result["status"], canonical(result)))
+                db.commit()
+                return result
+            if evidence["path"] not in versions:
+                raise ValueError("observation source is outside target.paths")
+            tags = item.get("covers", [])
+            if not isinstance(tags, list) or not all(isinstance(t, str) and t in required for t in tags):
+                raise ValueError("observation has invalid coverage tags")
+            # Caller tags are hints only; coverage is proved by distinct Core TCs.
+            if item.get("outcome") == "pass":
+                valid, reason = verify_core_result(root, target["feature"], item.get("runtime_evidence"), "passed")
+                if not valid:
+                    evidence_issues.append(f"{evidence['path']}:{evidence['line']}: {reason}")
+                continue
+            if item.get("outcome") != "fail" or item.get("impact") not in IMPACTS:
+                raise ValueError("observation needs pass or fail with a known impact")
+            for field in ("trigger", "actual", "improvement", "reproduction"):
+                if not isinstance(item.get(field), str) or not item[field].strip():
+                    evidence_issues.append(f"{evidence['path']}:{evidence['line']}: missing {field}")
+            if IMPACTS[item["impact"]] in {"P0", "P1"}:
+                authority_node_id = next(e["node_id"] for e in accepted if e["id"] == item["expectation_id"])
+                valid, reason = verify_core_result(root, target["feature"], item.get("runtime_evidence"), "failed", authority_node_id)
+                if not valid:
+                    evidence_issues.append(f"{evidence['path']}:{evidence['line']}: {reason}")
+            fingerprint = digest(canonical([item["expectation_id"], evidence["path"], evidence["line"], item["impact"], item.get("trigger")]).encode())[:20]
+            findings.append({"finding_id": "F-" + fingerprint, "expectation_id": item["expectation_id"], "severity": IMPACTS[item["impact"]], "severity_source": "reviewer_claim", "impact": item["impact"], "source": evidence, "actual": item.get("actual"), "trigger": item.get("trigger"), "reproduction": item.get("reproduction"), "improvement": item.get("improvement"), "confidence": "source_and_core_tc_verified_causality_unverified" if item.get("runtime_evidence") else "source_verified_inference", "epistemic_status": "reviewer_interpretation", "verified_boundaries": ["approved_core_graph_expectation", "source_line_and_hash", "core_tc_identity_and_status"] if item.get("runtime_evidence") else ["approved_core_graph_expectation", "source_line_and_hash"]})
+        gaps = sorted(set(required) - covered)
+        evidence_issues.extend(coverage_issues)
+        if gaps:
+            evidence_issues.append("Unverified review coverage: " + ", ".join(gaps))
+        if not observations:
+            evidence_issues.append("No source-verified observations were supplied")
+        previous = {f["finding_id"]: f for f in (prior or {}).get("findings", []) if f.get("state") != "resolved"}
+        current_ids = {f["finding_id"] for f in findings}
+        for finding in findings:
+            finding["state"] = "persisting" if finding["finding_id"] in previous else "new"
+        # Resolution requires source change and a separately hash-verified regression artifact.
+        for old_id, old in previous.items():
+            if old_id not in current_ids:
+                old_path = old["source"]["path"]
+                if versions.get(old_path) == (prior or {}).get("fixed_versions", {}).get("source", {}).get(old_path):
+                    evidence_issues.append(f"{old_id}: source unchanged; cannot resolve by removing a report observation")
+                else:
+                    regression = request.get("regression_evidence", {}).get(old_id)
+                    try:
+                        if not isinstance(regression, dict) or digest(safe_file(root, regression.get("path")).read_bytes()) != regression.get("sha256"):
+                            evidence_issues.append(f"{old_id}: missing verified regression evidence")
+                        else:
+                            findings.append({**old, "state": "resolved"})
+                    except (OSError, ValueError, TypeError):
+                        evidence_issues.append(f"{old_id}: missing verified regression evidence")
+        for rel, start_hash in versions.items():
+            if digest(safe_file(root, rel).read_bytes()) != start_hash:
+                result = response("stale_evidence", chain_id, round_no, questions=[f"Source changed during review: {rel}"])
+                db.execute("INSERT INTO events(chain_id,status,detail_json) VALUES(?,?,?)", (chain_id, result["status"], canonical(result)))
+                db.commit()
+                return result
+        for authority in accepted:
+            if digest(safe_file(root, authority["authority_path"]).read_bytes()) != authority["authority_sha256"]:
+                result = response("stale_evidence", chain_id, round_no, questions=[f"Authority changed during review: {authority['authority_ref']}"])
+                db.execute("INSERT INTO events(chain_id,status,detail_json) VALUES(?,?,?)", (chain_id, result["status"], canonical(result)))
+                db.commit()
+                return result
+        if index_discovery.get("generation"):
+            current_snapshot = root / ".planning" / "code-index" / "SNAPSHOT.json"
+            if not current_snapshot.exists() or read_json(current_snapshot).get("generation") != index_discovery["generation"]:
+                result = response("stale_evidence", chain_id, round_no, questions=["Code-index generation changed during review"])
+                db.execute("INSERT INTO events(chain_id,status,detail_json) VALUES(?,?,?)", (chain_id, result["status"], canonical(result)))
+                db.commit()
+                return result
+        hard_issues = [issue for issue in evidence_issues if not issue.startswith("Unverified review coverage:") and "coverage obligation" not in issue and "missing Core TC binding" not in issue and "different coverage claim" not in issue and not issue.startswith("Each review surface")]
+        if hard_issues:
+            result = response("awaiting_human_confirmation", chain_id, round_no, questions=evidence_issues, coverage={"covered": sorted(covered), "gaps": gaps})
+            db.execute("INSERT INTO events(chain_id,status,detail_json) VALUES(?,?,?)", (chain_id, result["status"], canonical(result)))
+            db.commit()
+            return result
+        open_findings = [f for f in findings if f["state"] != "resolved"]
+        summary = {p: sum(f["severity"] == p for f in open_findings) for p in ("P0", "P1", "P2", "P3")}
+        if open_findings:
+            # Source and TC hashes establish identity, not that the reviewer's
+            # causal story or impact category is true. Until Core has a
+            # verifiable independent-review attestation, these are proposals,
+            # not completed rounds that can terminate a task after three tries.
+            result = response(
+                "awaiting_human_confirmation", chain_id, round_no,
+                questions=["Independent reviewer identity and business causality/impact require confirmation"],
+                proposed_findings=open_findings,
+                proposed_risk_summary=summary,
+                proposed_improvement_plan=[{"finding_id": f["finding_id"], "severity": f["severity"], "action": f["improvement"]} for f in open_findings],
+                coverage={"covered": sorted(covered), "gaps": gaps},
+            )
+            db.execute("INSERT INTO events(chain_id,status,detail_json) VALUES(?,?,?)", (chain_id, result["status"], canonical(result)))
+            db.commit()
+            return result
+        if not summary["P0"] and not summary["P1"]:
+            reasons = [*evidence_issues]
+            if suite_has_failures(root, target["feature"]):
+                reasons.append("The same Core acceptance run contains failed or blocked TCs; clean cannot be inferred from selected passed cases")
+            reasons.append("No Core-verifiable independent reviewer identity or causal semantic attestation is available; clean needs human confirmation")
+            result = response("awaiting_human_confirmation", chain_id, round_no, questions=reasons, coverage={"covered": sorted(covered), "gaps": gaps})
+            db.execute("INSERT INTO events(chain_id,status,detail_json) VALUES(?,?,?)", (chain_id, result["status"], canonical(result)))
+            db.commit()
+            return result
+        status = "terminated_p0" if round_no == 3 and summary["P0"] else ("findings" if summary["P0"] or summary["P1"] else "clean")
+        result = response(status, chain_id, round_no, fixed_versions={"source": versions, "authority": accepted, "code_index_generation": index_discovery.get("generation")}, index_discovery=index_discovery, coverage={"covered": sorted(covered), "gaps": gaps, "index_gap": index_discovery.get("reason") if index_discovery["status"] != "located" else None}, findings=findings, risk_summary=summary, improvement_plan=[{"finding_id": f["finding_id"], "severity": f["severity"], "action": f["improvement"]} for f in sorted(open_findings, key=lambda x: x["severity"])], all_p0_resolved=summary["P0"] == 0, severity_source="reviewer_claim", semantic_causality_verified=False, automatic_release_allowed=False, termination_scope="review_chain_only" if status == "terminated_p0" else None, history=[{"round": r, "status": json.loads(raw)["status"]} for r, raw in db.execute("SELECT round,result_json FROM rounds WHERE chain_id=? ORDER BY round", (chain_id,))])
+        db.execute("INSERT INTO rounds(chain_id,round,result_json) VALUES(?,?,?)", (chain_id, round_no, canonical(result)))
+        if status == "terminated_p0":
+            db.execute("UPDATE chains SET terminal=? WHERE chain_id=?", (status, chain_id))
+        db.commit()
+        return result
+    except Exception:
+        db.rollback()
+        raise
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    try:
+        project = Path(sys.argv[1] if len(sys.argv) > 1 else os.getcwd())
+        print(canonical(run(project, json.load(sys.stdin))))
+    except (ValueError, OSError, json.JSONDecodeError, sqlite3.Error, StaleEvidence) as error:
+        print(canonical({"status": "error", "error": str(error)}))
+        sys.exit(2)

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/validate_state.rb

@@ -175,7 +175,13 @@ unless %w[prepared claimed consumed superseded failed].include?(status)
       return nil
     end
 
-    YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
+    raw = File.read(path)
+    if code == "workflow_config"
+      WorkflowGateContract.duplicate_yaml_keys(raw).each do |key_path|
+        issues << issue("error", "duplicate_workflow_yaml_key", "Workflow contains a duplicate YAML mapping key", path: key_path)
+      end
+    end
+    YAML.safe_load(raw, permitted_classes: [], aliases: false)
   rescue Psych::SyntaxError => e
     issues << issue("error", "invalid_#{code}", e.message, path: path)
     nil
@@ -525,7 +531,7 @@ unless %w[prepared claimed consumed superseded failed].include?(status)
     validate_wayfinder_coverage_gate(issues, root, state, step, workflow)
     validate_domain_modeling_gate(issues, step, data)
     validate_requirement_feasibility_review_gate(issues, step, data)
-    validate_requirement_baseline_gate(issues, step, data)
+    validate_requirement_baseline_gate(issues, root, state, step, data)
     validate_api_contract_gate(issues, step, data)
     validate_architecture_feasibility_gate(issues, step, data)
     validate_architecture_consumption_gate(issues, root, state, step, data)
@@ -641,7 +647,7 @@ unless %w[prepared claimed consumed superseded failed].include?(status)
     )
   end
 
-  def validate_requirement_baseline_gate(issues, step, data)
+  def validate_requirement_baseline_gate(issues, root, state, step, data)
     return unless step["id"] == "requirement-baseline"
 
     if data["review_status"] != "passed"
@@ -657,6 +663,28 @@ unless %w[prepared claimed consumed superseded failed].include?(status)
     if data["traceability_status"] != "passed"
       issues << issue("error", "baseline_traceability_not_passed", "Requirement traceability must pass before technical design", step: step["id"], status: data["traceability_status"])
     end
+
+    graph_path, graph_relative = RequirementGraph.graph_path(root, state["current_feature"])
+    unless File.file?(graph_path)
+      issues << issue("error", "baseline_governance_graph_missing", "Requirement baseline must bind a Core-owned governance graph", step: step["id"], path: graph_relative)
+      return
+    end
+    begin
+      graph, = RequirementGraph.load_graph(root, state["current_feature"])
+      graph_errors = RequirementGraph.validate(graph)
+      unless graph_errors.empty?
+        issues << issue("error", "baseline_governance_graph_invalid", "Requirement baseline is bound to an invalid governance graph", step: step["id"], path: graph_relative, errors: graph_errors)
+      end
+      if data["graph_revision"].to_i != graph["revision"].to_i
+        issues << issue("error", "baseline_graph_revision_mismatch", "Baseline graph_revision does not match governance graph", step: step["id"], expected: graph["revision"], actual: data["graph_revision"])
+      end
+      actual_hash = Digest::SHA256.file(graph_path).hexdigest
+      if data["governance_graph_sha256"].to_s != actual_hash
+        issues << issue("error", "baseline_graph_hash_mismatch", "Baseline governance_graph_sha256 does not match governance graph", step: step["id"], expected: actual_hash, actual: data["governance_graph_sha256"])
+      end
+    rescue ArgumentError, JSON::ParserError => error
+      issues << issue("error", "baseline_governance_graph_invalid", error.message, step: step["id"], path: graph_relative)
+    end
   end
 
   def validate_api_contract_gate(issues, step, data)

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/workflow_gate_contract.rb

@@ -14,6 +14,31 @@ module WorkflowGateContract
 
   module_function
 
+  # Psych silently keeps the last value for duplicate mapping keys. Detect
+  # duplicates before loading a workflow so a checker declaration can never be
+  # overwritten without a gate failure.
+  def duplicate_yaml_keys(yaml)
+    duplicates = []
+    walk = lambda do |node, path|
+      return unless node
+      if node.is_a?(Psych::Nodes::Mapping)
+        seen = {}
+        children = node.children
+        children.each_slice(2) do |key_node, value_node|
+          key = key_node.respond_to?(:value) ? key_node.value.to_s : key_node.to_s
+          key_path = path.empty? ? key : "#{path}.#{key}"
+          duplicates << key_path if seen.key?(key)
+          seen[key] = true
+          walk.call(value_node, key_path)
+        end
+      elsif node.respond_to?(:children)
+        Array(node.children).each { |child| walk.call(child, path) }
+      end
+    end
+    Psych.parse_stream(yaml).children.each { |document| walk.call(document.root, "") }
+    duplicates.uniq
+  end
+
   def validate(workflow)
     errors = []
     unless workflow.is_a?(Hash)
@@ -139,7 +164,11 @@ if $PROGRAM_NAME == __FILE__
     opts.on("--json") { options[:json] = true }
   end.parse!
   raise ArgumentError, "--workflow is required" unless options[:workflow]
-  result = WorkflowGateContract.validate(YAML.safe_load(File.read(options[:workflow]), permitted_classes: [], aliases: false))
+  raw = File.read(options[:workflow])
+  duplicate_errors = WorkflowGateContract.duplicate_yaml_keys(raw).map do |path|
+    WorkflowGateContract.error("DUPLICATE_YAML_KEY", "workflow contains a duplicate YAML mapping key", path: path)
+  end
+  result = duplicate_errors + WorkflowGateContract.validate(YAML.safe_load(raw, permitted_classes: [], aliases: false))
   puts(options[:json] ? JSON.generate(result) : YAML.dump(result))
   rescue StandardError => e
     warn e.message

package/plugins/devflow-core/skills/workflow-orchestrator/templates/feature-development.yaml

@@ -70,10 +70,7 @@ governance:
       - api-test-matrix-check
       - test-coverage-check
       - acceptance-test-results-check
-      - change-impact-check
-    run-acceptance-tests:
       - acceptance-coverage-check
-      - acceptance-test-results-check
       - change-impact-check
 
 artifact_registry:
@@ -372,7 +369,6 @@ steps:
     inputs:
       - ".planning/PROJECT.md"
       - ".planning/navigation/INDEX.md"
-      - ".planning/requirements/baseline.md"
       - ".planning/features/"
       - ".planning/milestones/"
     outputs:
@@ -492,6 +488,14 @@ steps:
       - requirement-feasibility-review
     inputs:
       - ".planning/PROJECT.md"
+      - ".planning/requirements/{feature}/入口分诊.md"
+      - ".planning/requirements/{feature}/决策地图.md"
+      - ".planning/requirements/{feature}/领域模型记录.md"
+      - ".planning/requirements/{feature}/可实现性审查.md"
+      - ".planning/requirements/{feature}/入口分诊.meta.json"
+      - ".planning/requirements/{feature}/决策地图.meta.json"
+      - ".planning/requirements/{feature}/领域模型记录.meta.json"
+      - ".planning/requirements/{feature}/可实现性审查.meta.json"
       - ".planning/navigation/INDEX.md"
     outputs:
       - path: ".planning/requirements/baseline.md"
@@ -500,6 +504,9 @@ steps:
       - path: ".planning/requirements/{feature}/traceability.json"
         type: requirement-traceability
         required: true
+      - path: ".planning/requirements/{feature}/governance.json"
+        type: requirement-governance-graph
+        required: true
     meta_output:
       path: ".planning/requirements/baseline.meta.json"
       fields:
@@ -517,6 +524,8 @@ steps:
         risks: { type: array, required: false }
         key_decisions: { type: array, max: 5, required: false }
         traceability_status: { type: string, required: true }
+        graph_revision: { type: integer, required: true }
+        governance_graph_sha256: { type: string, required: true }
     checkpoint: CP-1
 
   - id: wireframe-proposal
@@ -610,6 +619,8 @@ steps:
       - requirement-baseline
     inputs:
       - ".planning/requirements/baseline.md"
+      - ".planning/requirements/{feature}/traceability.json"
+      - ".planning/requirements/baseline.meta.json"
       - ".planning/navigation/INDEX.md"
     outputs:
       - path: ".planning/features/{feature}/api-contract.md"
@@ -638,8 +649,15 @@ steps:
     inputs:
       - ".planning/requirements/baseline.md"
       - ".planning/features/{feature}/api-contract.md"
-      - ".planning/requirements/{feature}/governance.json"
-      - ".context/static-runtime-context.json"
+      - path: ".planning/requirements/{feature}/governance.json"
+        required_at_entry: true
+        producer: "requirement-baseline/devflow_requirement_graph"
+        validation: requirement-graph
+      - path: ".context/static-runtime-context.json"
+        required_at_entry: false
+        required_at_completion: true
+        producer: "devflow_static_runtime_context(action=collect)"
+        validation: static-runtime-context
       - ".planning/navigation/INDEX.md"
     outputs:
       - path: ".planning/features/{feature}/architecture-brief.md"
@@ -671,6 +689,8 @@ steps:
     inputs:
       - ".planning/requirements/baseline.md"
       - ".planning/features/{feature}/api-contract.md"
+      - ".planning/features/{feature}/architecture-brief.md"
+      - ".planning/features/{feature}/architecture-brief.meta.json"
       - ".planning/navigation/INDEX.md"
     outputs:
       - path: ".planning/features/{feature}/UI-SPEC.md"
@@ -790,6 +810,7 @@ steps:
     inputs:
       - ".planning/features/{feature}/api-contract.md"
       - ".planning/features/{feature}/前端技术方案.md"
+      - ".planning/features/{feature}/后端技术方案.md"
       - ".planning/features/{feature}/UI-SPEC.md"
     outputs:
       - path: ".planning/features/{feature}/api-supplement-requests.md"
@@ -818,6 +839,7 @@ steps:
       - ".planning/features/{feature}/前端技术方案.md"
       - ".planning/features/{feature}/后端技术方案.md"
       - ".planning/features/{feature}/api-supplement-requests.md"
+      - ".planning/features/{feature}/architecture-brief.meta.json"
     outputs:
       - path: ".planning/features/{feature}/integration-report.md"
         type: integration-report
@@ -877,7 +899,6 @@ steps:
       - integration-verify
     inputs:
       - ".planning/requirements/{feature}/governance.json"
-      - ".planning/requirements/{feature}/tests.json"
       - ".planning/features/{feature}/integration-report.md"
       - ".planning/features/{feature}/api-contract.md"
       - ".planning/features/{feature}/UI-SPEC.md"

package/plugins/devflow-design/skills/workflow-architecture-feasibility/SKILL.md

@@ -9,7 +9,7 @@ description: "Use after API contract and before frontend/backend technical speci
 
 ## 固定流程
 
-1. 读取 `devflow_requirement_graph(action="inspect")`、`devflow_static_runtime_context(action="inspect")`、API 契约和需求基线。
+1. 读取 `devflow_requirement_graph(action="inspect")`、`devflow_static_runtime_context(action="inspect")`、API 契约和需求基线。若静态上下文指针不存在或检查结果明确为未生成，先调用 `devflow_static_runtime_context(action="collect")`，再重新 inspect；收集结果必须作为本步骤的输入 revision 记录在 meta 中，不得用手写内容替代。
 2. 调用 `devflow_architecture_feasibility(feature=...)`。保留返回的 graph revision、static snapshot revision、触发码和未决码；不得自行改写等级。
 3. 对命中的工作负载补充 candidate：先用 `devflow_architecture_constraint` 校验，再用 `devflow_requirement_graph(action="propose")` 写入。
    - WSH 使用 `workload_shape`，并连接 `REQ/BEH/API → WSH`，relation 为 `shapes_workload`。

package/plugins/devflow-requirements/skills/workflow-requirement-baseline/SKILL.md

@@ -731,6 +731,8 @@ Completion gate: baseline and baseline.meta.json are written and contain no unre
 
 Before claiming baseline readiness, submit `requirement`、`rule`、`boundary`、`slice` and `acceptance` candidates through `devflow_requirement_graph`. Each requirement candidate must cite source IDs and reference behavior/acceptance IDs returned by the writer. Run `devflow_requirement_graph(action="validate")` and record its result in baseline metadata. Do not directly create `governance.json`, allocate IDs, or set candidate status to `confirmed`.
 
+The baseline handoff must also call `devflow_requirement_graph(action="inspect")` after all proposals and validation. Record the returned graph `revision` and the SHA-256 of `.planning/requirements/{feature}/governance.json` as `graph_revision` and `governance_graph_sha256` in `baseline.meta.json`. The step is not complete if the Core-owned graph file, revision, or hash is missing.
+
 ```markdown
 - [ ] 每个原始需求映射到 FP-*/BR-*/BC-* 或 out-of-scope
 - [ ] 追溯表完整，来源→FP 映射可验证

package/src/constants.ts

@@ -1,5 +1,5 @@
 export const PRODUCT_NAME = "Devflow Pi";
-export const PRODUCT_VERSION = "0.1.82";
+export const PRODUCT_VERSION = "0.1.85";
 export const PROJECT_SCHEMA_VERSION = 1;
 export const OMP_RUNTIME_VERSION = "17.2.7";