@guanlin4924/devflow-pi 0.1.104 → 0.1.106

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

@@ -9,6 +9,8 @@ require "open3"
 require "optparse"
 require "yaml"
 require_relative "control_io"
+require_relative "artifact_specs"
+require_relative "gate_policy"
 require_relative "validate_state"
 require_relative "phase_ownership"
 require_relative "requirement_graph"
@@ -84,9 +86,7 @@ def gate_contract_enabled?(workflow)
   workflow.dig("governance", "gate_contract_version").to_i >= 3
 end
 
-def core_hard_gate_mode(workflow)
-  workflow.dig("governance", "hard_gate_mode").to_s.empty? ? "chain" : workflow.dig("governance", "hard_gate_mode").to_s
-end
+
 
 # Build the runtime view from the existing workflow declaration.  This keeps
 # governance.step_checkers as the single checker namespace and avoids creating
@@ -125,7 +125,6 @@ def transition_gate_contract(workflow, step)
       "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"])) },
-    "hard_gate_mode" => core_hard_gate_mode(workflow),
     "concurrency" => { "project_lock" => "required", "optimistic_revision" => "required", "registry_view" => "candidate_overlay" },
     "recovery" => { "allowed" => ["sync_artifacts", "repair_outputs"], "max_attempts" => 2 }
   }
@@ -419,19 +418,7 @@ def track_allowed_steps(track)
 end
 
 def next_pending_step_id(state, pending_ids, step_by_id, completed_ids)
-  track = active_track(state)
-  unless track
-    return pending_ids.find do |step_id|
-      step_by_id[step_id] && dependencies_satisfied?(step_by_id[step_id], completed_ids)
-    end
-  end
-
-  allowed = track_allowed_steps(track)
-  pending_ids.find do |step_id|
-    allowed.include?(step_id) &&
-      step_by_id[step_id] &&
-      dependencies_satisfied?(step_by_id[step_id], completed_ids)
-  end
+  pending_ids.find { |id| step_by_id[id] && dependencies_satisfied?(step_by_id[id], completed_ids) } || pending_ids.find { |id| step_by_id[id] }
 end
 
 def conditional_skip_policies(workflow, checkpoint_id)
@@ -535,7 +522,11 @@ def join_parallel_window(root, state, workflow, current_revision)
   raise ArgumentError, "parallel run not found" unless record
   branches = Array(record["branches"])
   incomplete = branches.reject { |branch| branch["status"].to_s == "succeeded" }
-  raise ArgumentError, "parallel join requires every branch to succeed" unless branches.any? && incomplete.empty?
+  raise ArgumentError, "parallel run has no branches" if branches.empty?
+  if incomplete.any?
+    $devflow_advisories << { "reason" => "parallel_branches_not_succeeded", "branches" => incomplete.map { |branch| branch.slice("branch_id", "status") } }
+    record["completion_with_warnings"] = true
+  end
 
   branch_steps = branches.map { |branch| branch.fetch("workflow_step").to_s }
   state["completed_steps"] = (Array(state["completed_steps"]) + branch_steps).uniq
@@ -597,45 +588,19 @@ end
 # a small safety floor for malformed control-plane state and unsafe writes, but
 # Core-generated test/traceability/merge findings no longer strand the serial
 # workflow before the AI review can decide what to do.
-SOFT_GATE_MODE = ENV.fetch("DEVFLOW_SOFT_GATES", "1") != "0"
-HARD_FAILURE_REASONS = %w[
-  missing_state_file
-  missing_state_front_matter
-  stale_revision
-  invalid_control_path
-  unknown_step
-  gate_target_step_unknown
-  gate_current_step_mismatch
-  parallel_transition_requires_write
-  feature_not_active
-  cancel_reason_required
-  session_rollover_in_progress
-  failure_branch_incomplete
-  parallel_machine_evidence_failed
-  parallel_join_failed
-  parallel_branch_transition_failed
-  conditional_step_skip_failed
-  cross_track_consistency_failed
-  business_cross_model_check_failed
-  gate_boundary_rejected
-  acceptance_results_not_passed
-  execution_surface_mismatch
-  approval_invalid
-  human_result_unapproved
-  dsl_not_approved
-  environment_profile_not_approved
-  runtime_integrity_error
-  acceptance_test_suite_freeze_failed
-  acceptance_test_suite_freeze_attestation_invalid
-  acceptance_test_suite_freeze_attestation_failed
-  acceptance_test_suite_candidate_binding_failed
-  acceptance_test_suite_freeze_recovery_failed
+OPERATION_FAILURE_REASONS = %w[
+  missing_state_file missing_state_front_matter stale_revision invalid_control_path
+  unknown_step gate_target_step_unknown gate_current_step_mismatch
+  parallel_transition_requires_write feature_not_active cancel_reason_required
+  session_rollover_in_progress parallel_branch_not_found gate_boundary_rejected
+  parallel_join_failed parallel_branch_transition_failed state_validation_failed
+  phase_ownership_claim_failed phase_ownership_completion_failed not_waiting_checkpoint no_pending_step
 ].freeze
 $devflow_advisories = []
 
 def fail_result(reason, details = {})
   failure = { "ok" => false, "reason" => reason, "details" => details }
-  if SOFT_GATE_MODE && !HARD_FAILURE_REASONS.include?(reason.to_s)
+  if !OPERATION_FAILURE_REASONS.include?(reason.to_s)
     $devflow_advisories << failure
     return nil
   end
@@ -660,8 +625,8 @@ rescue JSON::ParserError => error
   { "ok" => false, "reason" => "test_task_binding_#{stage}_check_failed", "errors" => ["checker returned invalid JSON: #{error.message}"] }
 end
 
-# Acceptance results are a hard gate even in the default soft mode: Core itself
-# re-validates the frozen-suite results instead of trusting a checker summary.
+# Always re-check acceptance results. Soft mode retains failures as advisories
+# without changing the canonical test verdict.
 ACCEPTANCE_RESULT_GATED_STEPS = %w[run-acceptance-tests release-closeout].freeze
 
 def acceptance_results_check(root, feature)
@@ -956,7 +921,9 @@ result =
          !%w[prepared claimed].include?(state.dig("rollover", "status")) &&
          (options[:complete_step] || options[:confirm_checkpoint] || options[:enter_failure_branch] || options[:exit_failure_branch] || options[:parallel_action])
         topology_errors = WorkflowGateContract.validate(workflow)
-        unless topology_errors.empty?
+        if !topology_errors.empty?
+          $devflow_advisories.concat(topology_errors)
+        elsif !topology_errors.empty?
           result = fail_result("gate_boundary_rejected", "gate" => {
             "verdict" => "deny",
             "reason" => "workflow_gate_contract_invalid",
@@ -1014,7 +981,8 @@ result =
             transition_kind: transition_kind,
             checkpoint_authorized: options[:runtime_confirmed]
           )
-          if gate_result && gate_result["verdict"] != "allow"
+          $devflow_advisories.concat(Array(gate_result && gate_result["warnings"]))
+          if gate_result && !gate_result["ok"]
             result = fail_result("gate_boundary_rejected", "gate" => gate_result)
           end
         end
@@ -1129,24 +1097,22 @@ result =
           state.delete("checkpoint_decision")
 
           if step["checkpoint"]
-            state["current_step"] = step_id
-            state["status"] = "waiting_checkpoint"
-            state["checkpoint"] = step["checkpoint"]
-            state["checkpoint_label"] = checkpoint_label(workflow, step["checkpoint"])
-            action_description = "Step completed: #{step["label"]} (#{step_id}). Now waiting at #{step["checkpoint"]}."
-          elsif (parallel_window = parallel_window_for(workflow, step_id))
+            $devflow_advisories << { "reason" => "checkpoint_advisory", "checkpoint" => step["checkpoint"], "approval_recorded" => false }
+            state["checkpoint_decision"] = "continued_with_warning"
+            begin
+              apply_conditional_step_skips!(root, state, workflow, step["checkpoint"], current_revision + 1)
+              pending = Array(state["pending_steps"])
+              completed = Array(state["completed_steps"])
+            rescue JSON::ParserError, KeyError, ArgumentError => error
+              $devflow_advisories << { "reason" => "conditional_step_skip_failed", "message" => error.message }
+            end
+          end
+          if (parallel_window = parallel_window_for(workflow, step_id))
             state["current_step"] = parallel_window.fetch("join_step")
             state["status"] = "in_progress"
             state.delete("checkpoint")
             state.delete("checkpoint_label")
             action_description = "Step completed: #{step["label"]} (#{step_id}). Entered parallel window #{parallel_window["id"]}; awaiting Core prepare."
-          elsif track_boundary?(state, pending)
-            state["current_step"] = step_id
-            state["status"] = "blocked"
-            state["block_reason"] = "track_scope_complete"
-            state.delete("checkpoint")
-            state.delete("checkpoint_label")
-            action_description = "Step completed: #{step["label"]} (#{step_id}). Active track output scope is complete."
           elsif (next_id = next_pending_step_id(state, pending, step_by_id, completed))
             state["current_step"] = next_id
             state["status"] = "in_progress"
@@ -1178,125 +1144,6 @@ result =
         elsif Array(state["pending_steps"]).empty?
           result = fail_result("no_pending_step")
         else
-          # CP-API turns the shared candidate contract into confirmed graph
-          # fact inside the same user checkpoint. Skills cannot self-confirm
-          # API nodes and downstream generated TC imports can require a
-          # reviewed contract revision.
-          if state["checkpoint"] == "CP-API" && steps.any? { |step| step["id"] == "api-contract" }
-            feature = state.fetch("current_feature")
-            graph, = RequirementGraph.load_graph(root, feature)
-            schema_check = api_test_schema_check(root, feature, graph)
-            if !schema_check["ok"]
-              result = fail_result("api_test_schema_incomplete", "api_test_schema" => schema_check)
-            else
-              api_confirmation = RequirementGraph.confirm_api_contracts!(root, graph, "CP-API: state revision #{current_revision} approved")
-              if api_confirmation["ok"]
-                actions << "api_contract_confirmed" unless Array(api_confirmation["confirmed_api_ids"]).empty?
-              else
-                result = fail_result("api_contract_confirmation_failed", "api_contract" => api_confirmation)
-              end
-            end
-          end
-
-          # CP-3 authorizes exactly one immutable TC freeze. It is deliberately
-          # inside the checkpoint transition so the user does not have to
-          # approve an extra model-issued dialog and a Skill cannot freeze its
-          # own candidates early.
-          if result.nil? && state["checkpoint"] == "CP-3" && steps.any? { |step| %w[acceptance-test-design regression-test-design].include?(step["id"]) }
-            feature = state.fetch("current_feature")
-            graph, = RequirementGraph.load_graph(root, feature)
-            regression = regression_workflow?(state, steps)
-            attestation_path, = test_suite_freeze_attestation_path(root, feature)
-
-            if File.exist?(attestation_path)
-              frozen_check = if regression
-                regression_freeze_attestation_check(graph, feature, attestation_path)
-              else
-                test_task_binding_check(root, feature, "frozen")
-              end
-              unless frozen_check["ok"]
-                result = fail_result("acceptance_test_suite_freeze_attestation_invalid", "test_suite" => frozen_check)
-              else
-                actions << "acceptance_test_suite_freeze_attestation_verified"
-              end
-            elsif cp3_freeze_provenance?(graph, current_revision)
-              # A process can die after graph/view writes but before the
-              # attestation is published. Recover only if each TC proves that
-              # this exact CP-3 already froze it; never use this path to bless
-              # a generic confirmed suite.
-              recovery_check = if regression
-                { "ok" => true, "regression" => true, "candidate_test_suite" => graph.dig("views", "tests") }
-              else
-                test_task_binding_check(root, feature, "recovery")
-              end
-              unless recovery_check["ok"]
-                result = fail_result("acceptance_test_suite_freeze_recovery_failed", "test_suite" => recovery_check)
-              else
-                recovered = {
-                  "ok" => true,
-                  "tests_view" => graph.dig("views", "tests"),
-                  "frozen_case_ids" => Array(graph["nodes"]).select { |node| node.is_a?(Hash) && node["kind"] == "test_case" }.map { |node| node["id"] }
-                }
-                begin
-                  write_test_suite_freeze_attestation(root, feature, current_revision, recovery_check, recovered)
-                  frozen_check = if regression
-                    regression_freeze_attestation_check(graph, feature, attestation_path)
-                  else
-                    test_task_binding_check(root, feature, "frozen")
-                  end
-                  if frozen_check["ok"]
-                    actions << "acceptance_test_suite_freeze_attestation_recovered"
-                  else
-                    result = fail_result("acceptance_test_suite_freeze_attestation_invalid", "test_suite" => frozen_check)
-                  end
-                rescue DevflowControlIO::InvalidControlPath, SystemCallError => error
-                  result = fail_result("acceptance_test_suite_freeze_attestation_failed", "message" => error.message)
-                end
-              end
-            else
-              matrix_check = api_test_matrix_check(root, feature, graph)
-              # A new freeze requires every TC to declare a consistent
-              # execution_surface; this is a hard failure even in soft mode.
-              surface_check = matrix_check["ok"] ? execution_surface_check(root, feature) : nil
-              unless matrix_check["ok"]
-                result = fail_result("api_test_matrix_incomplete", "api_test_matrix" => matrix_check)
-              else
-                result = fail_result("execution_surface_mismatch", "execution_surface" => surface_check) unless surface_check["ok"]
-              end
-              if matrix_check["ok"] && surface_check["ok"]
-                candidate_check = if regression
-                  { "ok" => true, "regression" => true, "candidate_test_suite" => graph.dig("views", "tests") }
-                else
-                  test_task_binding_check(root, feature, "candidate")
-                end
-                unless candidate_check["ok"]
-                  result = fail_result("acceptance_test_suite_candidate_binding_failed", "test_suite" => candidate_check)
-                else
-                  frozen = RequirementGraph.freeze_test_cases!(
-                    root,
-                    graph,
-                    "CP-3: state revision #{current_revision} approved",
-                    confirm_prerequisites: options[:confirm_test_prerequisites] && options[:runtime_confirmed],
-                    regression: regression,
-                    persist: false
-                  )
-                  unless frozen["ok"]
-                    result = fail_result("acceptance_test_suite_freeze_failed", "test_suite" => frozen)
-                  else
-                    actions << "acceptance_test_prerequisites_confirmed" unless Array(frozen["confirmed_prerequisite_ids"]).empty?
-                    test_suite_freeze_to_write = {
-                      "feature" => feature,
-                      "state_revision" => current_revision,
-                      "graph" => graph,
-                      "candidate_check" => candidate_check,
-                      "frozen" => frozen
-                    }
-                    actions << "acceptance_test_suite_frozen"
-                  end
-                end
-              end
-            end
-          end
           if result.nil?
             begin
               applied_skips = apply_conditional_step_skips!(root, state, workflow, state["checkpoint"], current_revision + 1)
@@ -1313,7 +1160,7 @@ result =
             completed = Array(state["completed_steps"])
             next_id = next_pending_step_id(state, pending, step_by_id, completed)
             if next_id.nil? && track_boundary?(state, pending)
-              state["checkpoint_decision"] = "approved"
+              state["checkpoint_decision"] = "continued_with_warning"
               state["status"] = "blocked"
               state["block_reason"] = "track_scope_complete"
               state.delete("checkpoint")
@@ -1323,7 +1170,7 @@ result =
               action_description = "Checkpoint confirmed. Active track output scope is complete."
               next_intent_requested = true
             else
-              state["checkpoint_decision"] = "approved"
+              state["checkpoint_decision"] = "continued_with_warning"
               state["current_step"] = next_id || pending.first
               state["status"] = "in_progress"
               state.delete("checkpoint")
@@ -1408,7 +1255,9 @@ result =
           phase_owner_override: prospective_owner
         )
 
-        if changed && !validation["ok"] && !SOFT_GATE_MODE
+        $devflow_advisories.concat(Array(validation["warnings"]))
+        state["gate_advisories"] = JSON.parse(JSON.generate(Array(state["gate_advisories"]) + $devflow_advisories)) if changed
+        if changed && !validation["ok"]
           result = fail_result("state_validation_failed", "validation" => validation)
         elsif changed && options[:write]
           ownership = PhaseOwnership.claim(

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ArtifactSpecs
+  module_function
+
+  def for_step(step)
+    outputs = Array(step["outputs"]).select { |entry| entry.is_a?(Hash) }.map(&:dup)
+    meta = step["meta_output"]
+    outputs << { "type" => "json" }.merge(meta).merge("required" => true) if meta.is_a?(Hash) && meta["path"]
+    outputs.uniq { |entry| entry["path"] }
+  end
+end

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

@@ -10,6 +10,7 @@ require "yaml"
 require_relative "control_io"
 require_relative "requirement_graph"
 require_relative "checker_registry"
+require_relative "parallel_run"
 
 POLICY = {
   "domain-modeling" => { "checkers" => %w[requirement-graph-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[term object behavior rule boundary] },
@@ -134,10 +135,46 @@ begin
       devflow_architecture_constraint devflow_architecture_feasibility devflow_architecture_brief
       devflow_approval
     ],
-    "tool_budget" => policy["budget"], "hard_gate_mode" => (workflow.dig("governance", "hard_gate_mode").to_s.empty? ? "chain" : workflow.dig("governance", "hard_gate_mode").to_s), "acceptance" => Array(graph["nodes"]).select { |node| node["kind"] == "acceptance" }.map { |node| node["id"] },
+    "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"
   }
+  # While a durable parallel run is attached, current_step is the join
+  # anchor, not permission to execute the join before its branches finish.
+  if state["parallel_run_ref"]
+    run = ParallelRun.load(root, options[:feature])
+    raise ArgumentError, "parallel run reference mismatch" unless run && run["run_id"] == state["parallel_run_ref"]
+    raise ArgumentError, "parallel run state revision mismatch" unless run["bound_state_revision"] == state["revision"]
+    window = Array(workflow["parallel_windows"]).find { |item| item["id"] == run["workflow_window"] }
+    raise ArgumentError, "parallel window unavailable" unless window && Array(state["completed_steps"]).include?(window["after_step"])
+    declared = window.fetch("branches", {}).values.flatten
+    branches = Array(run["branches"])
+    raise ArgumentError, "parallel run has no branches" if branches.empty?
+    branch_contracts = branches.map do |branch|
+      id = branch["workflow_step"]
+      raise ArgumentError, "parallel branch outside declared window" unless declared.include?(id)
+      definition = Array(workflow["steps"]).find { |item| item["id"] == id }
+      branch_policy = POLICY.fetch(id)
+      raise ArgumentError, "parallel branch definition unavailable" unless definition
+      {
+        "branch_id" => branch["branch_id"], "step" => id,
+        "allowed_agents" => branch_policy.fetch("agents"),
+        "allowed_paths" => (Array(definition["outputs"]).map { |output| output["path"] } + [definition.dig("meta_output", "path")]).compact.map { |value| interpolate(value, state) }.uniq,
+        "tool_budget" => branch_policy.fetch("budget"),
+        "allowed_graph_delta" => Array(branch_policy["allowed_graph_delta"])
+      }
+    end
+    contract.merge!(
+      "scope" => "parallel_window", "parallel_run_id" => run["run_id"],
+      "parallel_window_id" => window["id"], "join_step" => window["join_step"],
+      "branch_contracts" => branch_contracts,
+      "allowed_paths" => branch_contracts.flat_map { |item| item["allowed_paths"] }.uniq,
+      "allowed_agents" => branch_contracts.flat_map { |item| item["allowed_agents"] }.uniq,
+      "tool_budget" => branch_contracts.sum { |item| item["tool_budget"] },
+      "allowed_graph_delta" => branch_contracts.flat_map { |item| item["allowed_graph_delta"] }.uniq,
+      "checker_ids" => []
+    )
+  end
   frozen = contract.merge("frozen_hash" => Digest::SHA256.hexdigest(JSON.generate(contract)))
   contract_id = "EC-#{frozen["frozen_hash"][0, 16]}"
   frozen["contract_id"] = contract_id

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# One policy for workflow diagnostics. Failed checks retain their evidence;
+# advisory execution never changes a failed test/check into a passing result.
+module GatePolicy
+  module_function
+
+  def advisory(entry)
+    entry.merge("severity" => "warning", "soft_gate" => true)
+  end
+end

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

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require_relative "gate_policy"
+
 module GateResult
   VERDICTS = %w[allow allow_with_warning await_user waiting_external_input block_unsafe].freeze
   CONTROL_PLANE_ERROR = "control_plane_error"
@@ -11,6 +13,16 @@ module GateResult
     valid = VERDICTS.include?(verdict.to_s) || verdict.to_s == CONTROL_PLANE_ERROR
     raise ArgumentError, "invalid gate verdict: #{verdict}" unless valid
 
+    if !%w[allow allow_with_warning].include?(verdict.to_s)
+      codes = Array(errors).map { |entry| entry.is_a?(Hash) ? entry["code"].to_s : "" }
+      structural = codes.any? { |code| %w[REVISION_CONFLICT BUSINESS_GATE_POLICY_INVALID].include?(code) }
+      unless structural
+        warnings = Array(warnings) + Array(errors).map { |entry| GatePolicy.advisory(entry.is_a?(Hash) ? entry : { "message" => entry.to_s }) }
+        warnings << { "code" => "SOFT_GATE", "original_verdict" => verdict.to_s } if warnings.empty?
+        errors = []
+        verdict = "allow_with_warning"
+      end
+    end
     {
       "ok" => %w[allow allow_with_warning].include?(verdict.to_s),
       "verdict" => verdict.to_s,

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

@@ -32,14 +32,6 @@ module GateRuntime
     gate_id = contract.fetch("gate_id")
     step_id = contract.fetch("step_id")
     base = { gate_id: gate_id, step_id: step_id, evidence: evidence.merge("collector" => source), revisions: { "state" => current_revision } }
-    # During the chain-skill migration Core is diagnostic-only. It still
-    # validates the contract shape above, but never blocks a transition on
-    # graph, artifact, output, checker, review, or topology observations.
-    # Checkpoint confirmation remains fail-closed because approval-path outputs
-    # do not exist until the user approves the waiting checkpoint.
-    if contract.fetch("hard_gate_mode", "core").to_s == "chain" && transition_kind.to_s != "confirm_checkpoint"
-      return GateResult.allow(**base.merge(evidence: base.fetch(:evidence).merge("core_hard_gate_mode" => "chain", "core_hard_gate_bypassed" => true)))
-    end
     return GateResult.block(**base, code: "REVISION_CONFLICT", message: "current revision does not match expected revision", recovery: { "kind" => "reinspect", "expected_revision" => expected_revision }) unless expected_revision.nil? || current_revision.to_i == expected_revision.to_i
     unless WORKFLOW_STATUSES.include?(workflow_state["status"].to_s)
       return GateResult.block(**base, code: "WORKFLOW_STATUS_INVALID", message: "workflow status is not recognized")
@@ -191,10 +183,13 @@ module GateRuntime
 
   def run_checker(contract:, workflow_state:, current_revision:, expected_revision:, checker:, **kwargs)
     boundary = evaluate(contract: contract, workflow_state: workflow_state, current_revision: current_revision, expected_revision: expected_revision, **kwargs)
-    return boundary unless boundary["verdict"] == "allow"
+    return boundary unless boundary["ok"]
     result = checker.call
     raise ArgumentError, "checker must return a GateResult hash" unless result.is_a?(Hash) && result["verdict"]
+    warnings = Array(boundary["warnings"]) + Array(result["warnings"])
     result.merge(
+      "warnings" => warnings,
+      "verdict" => result["verdict"] == "allow" && warnings.any? ? "allow_with_warning" : result["verdict"],
       "gate_id" => result["gate_id"] || boundary["gate_id"],
       "step_id" => result["step_id"] || boundary["step_id"],
       "evidence" => boundary.fetch("evidence", {}).merge(result.fetch("evidence", {})),

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

@@ -6,6 +6,7 @@ require "optparse"
 require "yaml"
 require_relative "validate_state"
 require_relative "checkpoint_meta"
+require_relative "gate_policy"
 
 options = { json: false, state: nil }
 OptionParser.new do |opts|
@@ -192,19 +193,7 @@ def track_allowed_steps(track)
 end
 
 def next_pending_step_id(state, pending_ids, step_by_id, completed_ids)
-  track = active_track(state)
-  unless track
-    return pending_ids.find do |step_id|
-      step_by_id[step_id] && dependencies_satisfied?(step_by_id[step_id], completed_ids)
-    end
-  end
-
-  allowed = track_allowed_steps(track)
-  pending_ids.find do |step_id|
-    allowed.include?(step_id) &&
-      step_by_id[step_id] &&
-      dependencies_satisfied?(step_by_id[step_id], completed_ids)
-  end
+  pending_ids.find { |id| step_by_id[id] && dependencies_satisfied?(step_by_id[id], completed_ids) } || pending_ids.find { |id| step_by_id[id] }
 end
 
 def track_boundary(state, pending_ids, completed_ids)
@@ -366,27 +355,12 @@ result =
 
       if missing.any?
         fail_result("missing_state_fields", fields: missing)
-      elsif project_context_missing?(root)
-        project_context_result(
-          "incomplete_project_context",
-          missing: [
-            ".devflow/planning/PROJECT.md",
-            ".devflow/planning/navigation/INDEX.md",
-            ".devflow/context/spec/index.md"
-          ]
-        )
       else
         pending_template_blockers = Array(state["blockers"]).select do |blocker|
           blocker.is_a?(Hash) && blocker["type"] == "PENDING_TEMPLATE"
         end
 
-        if pending_template_blockers.any?
-          fail_result(
-            "pending_depth_spec_templates",
-            blockers: pending_template_blockers,
-            recovery: "add the missing template or mark the topic NOT_APPLICABLE, then rerun workflow-project-context"
-          )
-        else
+        begin
           workflow_path = state["workflow_config"] ||
                           File.join(".devflow/planning", "workflows", "#{state["current_flow"]}.yaml")
           abs_workflow_path = File.join(root, workflow_path)
@@ -413,6 +387,8 @@ result =
             strict_artifact_status: true
           )
 
+          validation["warnings"] << GatePolicy.advisory({ "code" => "incomplete_project_context", "message" => "project context indexes are missing" }) if project_context_missing?(root)
+          validation["warnings"].concat(pending_template_blockers.map { |entry| GatePolicy.advisory(entry) })
           if !validation["ok"]
             {
               current_flow: state["current_flow"],
@@ -429,6 +405,8 @@ result =
               },
               next_step: nil,
               workflow_config: workflow_path,
+              warnings: Array(state["gate_advisories"]) + Array(validation["warnings"]),
+              gate_mode: "soft",
               artifact_registry: artifact_registry_summary(root, artifact_by_path).merge(
                 "path" => artifact_registry_path,
                 "error" => artifact_registry_error,
@@ -446,41 +424,6 @@ result =
               },
               recovery: "Fix missing/invalid artifacts or call devflow_artifact with action=sync and preserve=false, then call devflow_state with action=inspect."
             }
-          elsif (drift = validation["warnings"].find { |issue| issue["code"] == "current_output_registry_drift" })
-            {
-              current_flow: state["current_flow"],
-              current_feature: state["current_feature"],
-              current_phase: state["current_phase"],
-              status: state["status"],
-              completed_steps: completed_ids,
-              pending_steps: pending_ids,
-              current_step: current_step && {
-                id: current_step["id"],
-                label: current_step["label"],
-                skill: current_step["skill"],
-                action: current_step["action"]
-              },
-              next_step: nil,
-              workflow_config: workflow_path,
-              artifact_registry: artifact_registry_summary(root, artifact_by_path).merge(
-                "path" => artifact_registry_path,
-                "error" => artifact_registry_error,
-                "current_outputs_registered" => 0
-              ),
-              action: "recover_artifact_registry",
-              reason: "current_output_registry_drift",
-              drift: drift,
-              recovery_plan: {
-                classification: "safe_repairable",
-                state_transition: "none",
-                registry_write: true,
-                confirmation_required: true,
-                expected_revision: state.fetch("revision", 0),
-                diff: [{ path: drift["path"], registry_exists: drift["registry_exists"], filesystem_exists: true,
-                         registry_content_valid: drift["registry_content_valid"], filesystem_content_valid: true }]
-              },
-              recovery: "After reviewing this diff, call devflow_recovery(expectedRevision=#{state.fetch("revision", 0)}, confirm=true). It only reconciles registry metadata; explicitly complete the step separately when ready."
-            }
           elsif current_step.nil?
             fallback_next_id = next_pending_step_id(state, pending_ids, step_by_id, completed_ids)
             fallback_next_step = fallback_next_id && step_by_id[fallback_next_id]
@@ -563,6 +506,7 @@ result =
             next_step = next_id && step_by_id[next_id]
             checkpoint_id = state["checkpoint"] || current_step["checkpoint"]
             checkpoint = checkpoint_id && workflow.fetch("checkpoints", {})[checkpoint_id]
+            checkpoint = checkpoint.merge("id" => checkpoint_id) if checkpoint.is_a?(Hash)
             parallel_window = active_parallel_window(workflow, state, root, step_by_id, completed_ids, pending_ids, artifact_by_path)
             failure_branch = active_failure_branch(workflow, state, current_step, current_outputs, root)
 
@@ -603,6 +547,8 @@ result =
               },
               parallel_window: parallel_window,
               workflow_config: workflow_path,
+              warnings: Array(state["gate_advisories"]) + Array(validation["warnings"]),
+              gate_mode: "soft",
               artifact_registry: artifact_registry_summary(root, artifact_by_path).merge(
                 "path" => artifact_registry_path,
                 "error" => artifact_registry_error,
@@ -613,34 +559,23 @@ result =
 
             boundary = track_boundary(state, pending_ids, completed_ids)
 
-            if artifact_registry_error
-              base.merge(
-                action: "blocked",
-                reason: artifact_registry_error,
-                recovery: "Call devflow_artifact with action=sync."
-              )
-            elsif boundary
-              base.merge(
-                action: "blocked",
-                reason: boundary["reason"],
-                message: boundary["message"],
-                active_track: active_track(state)
-              )
-            elsif failure_branch
-              base.merge(
-                action: "route_failure_branch",
-                reason: "failure_branch_triggered",
-                failure_branch: failure_branch
-              )
-            elsif state["status"] == "waiting_checkpoint"
+            if state["status"] == "waiting_checkpoint"
               missing_outputs = current_outputs
                                 .select { |output| output["required"] && !output["exists"] }
                                 .map { |output| output["resolved_path"] }
-              checkpoint_meta_errors = CheckpointMeta.validate(root: root, state: state, checkpoint: checkpoint)
+              # Approval-path outputs are written by Core only after the user
+              # confirms; they must not block entry into the waiting checkpoint.
+              meta_path = checkpoint.is_a?(Hash) && checkpoint["required_meta_output"]
+              checkpoint_meta_errors = if CheckpointMeta.approval_output?(checkpoint, meta_path)
+                                         []
+                                       else
+                                         CheckpointMeta.validate(root: root, state: state, checkpoint: checkpoint)
+                                       end
               missing_outputs.concat(checkpoint_meta_errors.map { |entry| entry["path"] }.compact)
               base.merge(
-                action: missing_outputs.empty? ? "await_user_confirmation" : "blocked",
-                reason: missing_outputs.empty? ? nil : "missing_checkpoint_outputs",
+                action: "await_user_confirmation",
+                reason: nil,
+                warnings: Array(base[:warnings]) + (missing_outputs.empty? ? [] : [{ code: "missing_checkpoint_outputs", paths: missing_outputs, soft_gate: true }]),
                 missing_outputs: missing_outputs,
                 checkpoint_meta_errors: checkpoint_meta_errors,
                 resume_behavior: checkpoint && checkpoint["resume_behavior"],