@guanlin4924/devflow-pi 0.1.105 → 0.1.107

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

@@ -9,10 +9,18 @@ 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"
 require_relative "gate_runtime"
+require_relative "dynamic_plan"
+
+if DynamicPlan.read_state(Dir.pwd)&.dig("current_flow") == "dynamic"
+  puts JSON.generate({ "ok" => false, "reason" => "dynamic_plan_requires_evidence", "message" => "Use devflow_plan; legacy complete-step cannot complete dynamic tasks." })
+  exit 1
+end
 
 options = {
   state: nil,
@@ -84,9 +92,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 +131,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 +424,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 +528,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 +594,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 +631,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 +927,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 +987,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 +1103,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 +1150,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 +1166,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 +1176,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 +1261,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