@guanlin4924/devflow-pi 0.1.39 → 0.1.47

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

@@ -1,22 +1,29 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require "json"
 require_relative "gate_result"
 require_relative "gate_contract"
 require_relative "checker_registry"
+require_relative "parallel_run"
+require_relative "business_model_gate"
 
 module GateRuntime
-  WORKFLOW_STATUSES = %w[in_progress waiting_checkpoint completed blocked failed cancelled remediation].freeze
+  WORKFLOW_STATUSES = %w[not_started in_progress waiting_checkpoint completed blocked failed cancelled remediation].freeze
 
   module_function
 
+  def evaluate_business_model(violations:, transition_kind:, gate_id: "business-model-closure", step_id: "business-model")
+    BusinessModelGate.evaluate(violations: violations, transition_kind: transition_kind, gate_id: gate_id, step_id: step_id)
+  end
+
   def validate_contract!(contract)
     GateContract.validate!(contract)
     CheckerRegistry.validate!(Array(contract.dig("quality", "checker_ids")))
     contract
   end
 
-  def evaluate(contract:, workflow_state:, current_revision:, expected_revision:, track: nil, source: "harness", evidence: {}, root: nil, check_outputs: false, transition_kind: nil, checkpoint_authorized: false)
+  def evaluate(contract:, workflow_state:, current_revision:, expected_revision:, track: nil, branch_id: nil, attempt: nil, branch_revision: nil, source: "harness", evidence: {}, root: nil, check_outputs: false, transition_kind: nil, checkpoint_authorized: false)
     validate_contract!(contract)
     gate_id = contract.fetch("gate_id")
     step_id = contract.fetch("step_id")
@@ -25,18 +32,34 @@ module GateRuntime
     unless WORKFLOW_STATUSES.include?(workflow_state["status"].to_s)
       return GateResult.block(**base, code: "WORKFLOW_STATUS_INVALID", message: "workflow status is not recognized")
     end
-    unless %w[confirm_checkpoint enter_failure_branch exit_failure_branch].include?(transition_kind)
+    if workflow_state["parallel_run_ref"]
+      branch_error = validate_parallel_branch(
+        contract: contract,
+        workflow_state: workflow_state,
+        current_revision: current_revision,
+        track: track,
+        branch_id: branch_id,
+        attempt: attempt,
+        branch_revision: branch_revision,
+        evidence: evidence,
+        root: root,
+        transition_kind: transition_kind,
+      )
+      return GateResult.block(**base, **branch_error) if branch_error
+    end
+    unless %w[confirm_checkpoint enter_failure_branch exit_failure_branch parallel_join].include?(transition_kind)
       allowed_tracks = Array(contract.dig("topology", "allowed_tracks"))
       if track && !allowed_tracks.empty? && !allowed_tracks.include?(track)
         return GateResult.block(**base, code: "TRACK_SCOPE_VIOLATION", message: "current track is not allowed by GateContract", recovery: { "kind" => "registered_reentry" })
       end
       allowed_predecessors = Array(contract.dig("topology", "allowed_predecessors"))
+      allowed_intervening = Array(contract.dig("topology", "allowed_intervening_predecessors"))
       previous = workflow_state["last_completed_step"] || workflow_state["previous_step"]
-      if previous && !allowed_predecessors.empty? && !allowed_predecessors.include?(previous)
+      if previous && !allowed_predecessors.empty? && !allowed_predecessors.include?(previous) && !allowed_intervening.include?(previous)
         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)
+        missing = required_paths(contract.dig("entry", "required_inputs"), root, workflow_state, allow_missing_collections: true)
         return GateResult.block(**base, code: "REQUIRED_INPUT_MISSING", message: "required gate input is missing", details: { "missing" => missing }) unless missing.empty?
         if check_outputs
           missing_outputs = required_paths(contract.dig("outputs", "required"), root, workflow_state)
@@ -60,6 +83,58 @@ module GateRuntime
     GateResult.block(gate_id: contract.is_a?(Hash) ? contract["gate_id"] : "unknown", step_id: contract.is_a?(Hash) ? contract["step_id"] : "unknown", code: "GATE_CONTRACT_INVALID", message: e.message)
   end
 
+  def validate_parallel_branch(contract:, workflow_state:, current_revision:, track:, branch_id:, attempt:, branch_revision:, evidence:, root:, transition_kind:)
+    return { code: "PARALLEL_CONTEXT_MISSING", message: "parallel workflow requires root" } unless root
+
+    record = ParallelRun.load(root, workflow_state.fetch("current_feature"))
+    return { code: "PARALLEL_RUN_NOT_FOUND", message: "parallel_run_ref does not resolve to a run record" } unless record
+    return { code: "PARALLEL_RUN_REF_MISMATCH", message: "STATE parallel_run_ref does not match run record" } unless record["run_id"].to_s == workflow_state["parallel_run_ref"].to_s
+    bound_revision = Integer(record.fetch("bound_state_revision"))
+    return { code: "PARALLEL_STATE_REVISION_MISMATCH", message: "parallel run is bound to a different STATE revision", details: { expected_state_revision: bound_revision, actual_state_revision: current_revision } } unless bound_revision == current_revision.to_i
+
+    if transition_kind.to_s == "parallel_join"
+      branches = Array(record["branches"])
+      return { code: "PARALLEL_JOIN_INCOMPLETE", message: "parallel join requires every branch to succeed", details: { incomplete: branches.reject { |item| item["status"].to_s == "succeeded" }.map { |item| item["branch_id"] } } } unless branches.any? && branches.all? { |item| item["status"].to_s == "succeeded" }
+      return nil
+    end
+    return { code: "PARALLEL_CONTEXT_MISSING", message: "parallel workflow requires branch_id" } unless branch_id
+
+    branch = Array(record["branches"]).find { |item| item["branch_id"].to_s == branch_id.to_s }
+    return { code: "PARALLEL_BRANCH_NOT_FOUND", message: "branch is not registered in the parallel run", details: { branch_id: branch_id } } unless branch
+    return { code: "PARALLEL_STEP_MISMATCH", message: "branch is bound to a different workflow step", details: { branch_step: branch["workflow_step"], gate_step: contract["step_id"] } } unless branch["workflow_step"].to_s == contract["step_id"].to_s
+    expected_track = branch["track"].to_s.sub(/\Atrack_/, "").upcase
+    return { code: "PARALLEL_TRACK_MISMATCH", message: "branch track is not the requested track", details: { branch_track: expected_track, requested_track: track } } unless track.to_s.empty? || expected_track.empty? || expected_track == track.to_s
+    return { code: "PARALLEL_BRANCH_TERMINAL", message: "terminal branch cannot pass a gate; retry must create a new attempt" } if ParallelRun::TERMINAL_BRANCH_STATUSES.include?(branch["status"].to_s) && transition_kind.to_s != "parallel_branch_retry"
+    return { code: "PARALLEL_ATTEMPT_MISMATCH", message: "branch attempt does not match the current run record" } if attempt && Integer(branch.fetch("attempt", 0)) != attempt.to_i
+    return { code: "PARALLEL_BRANCH_REVISION_MISMATCH", message: "branch revision does not match the current run record" } if branch_revision && Integer(branch.fetch("branch_revision", 0)) != branch_revision.to_i
+
+    predecessor_ids = Array(contract.dig("topology", "allowed_predecessors"))
+    completed = Array(workflow_state["completed_steps"]).map(&:to_s)
+    completed.concat(Array(record["branches"]).select { |item| item["status"].to_s == "succeeded" }.map { |item| item["workflow_step"].to_s })
+    missing_predecessors = predecessor_ids.map(&:to_s).reject { |step| completed.include?(step) }
+    return { code: "PARALLEL_PREDECESSOR_INCOMPLETE", message: "parallel branch predecessor is incomplete", details: { missing: missing_predecessors } } unless missing_predecessors.empty?
+
+    if transition_kind.to_s == "parallel_branch_complete"
+      required = %w[branch_id attempt branch_revision]
+      missing = required.reject { |field| evidence.key?(field) }
+      return { code: "PARALLEL_EVIDENCE_MISSING", message: "branch completion requires independent evidence binding", details: { missing: missing } } unless missing.empty?
+      return { code: "PARALLEL_EVIDENCE_MISMATCH", message: "branch evidence does not match current branch", details: { branch_id: branch_id } } unless evidence["branch_id"].to_s == branch_id.to_s && evidence["attempt"].to_i == branch.fetch("attempt", 0).to_i && evidence["branch_revision"].to_i == branch.fetch("branch_revision", 0).to_i
+      evidence_path = evidence["evidence_path"].to_s
+      return { code: "PARALLEL_EVIDENCE_MISSING", message: "Core machine evidence file is required" } if evidence_path.empty? || !File.file?(File.expand_path(evidence_path, root))
+      begin
+        pack = JSON.parse(File.read(File.expand_path(evidence_path, root)))
+        binding = pack.dig("evidence", "parallel_binding")
+        expected = { "run_id" => record["run_id"], "branch_id" => branch["branch_id"], "attempt" => branch.fetch("attempt", 0), "branch_revision" => branch.fetch("branch_revision", 0), "state_revision" => current_revision.to_i }
+        return { code: "PARALLEL_EVIDENCE_MISMATCH", message: "machine evidence binding does not match current branch", details: { expected: expected, actual: binding } } unless binding.is_a?(Hash) && expected.all? { |key, value| binding[key].to_s == value.to_s }
+      rescue JSON::ParserError, Errno::ENOENT
+        return { code: "PARALLEL_EVIDENCE_MISMATCH", message: "machine evidence file is not valid JSON" }
+      end
+    end
+    nil
+  rescue KeyError, ArgumentError, TypeError
+    { code: "PARALLEL_RECORD_INVALID", message: "parallel run or branch record is invalid" }
+  end
+
   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"
@@ -73,13 +148,16 @@ module GateRuntime
     )
   end
 
-  def required_paths(entries, root, state)
+  def required_paths(entries, root, state, allow_missing_collections: false)
     Array(entries).each_with_object([]) do |entry, missing|
       raw = entry.is_a?(Hash) ? entry["path"] : entry
       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)
       root_real = File.realpath(root)
+      root_expanded = File.expand_path(root)
+      inside_root = absolute.start_with?("#{root_expanded}#{File::SEPARATOR}")
+      next if allow_missing_collections && raw.to_s.end_with?(File::SEPARATOR) && inside_root && !File.exist?(absolute)
       actual = File.exist?(absolute) ? File.realpath(absolute) : absolute
       next if actual.start_with?("#{root_real}#{File::SEPARATOR}") && File.exist?(actual)
       missing << relative

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

@@ -191,6 +191,9 @@ def active_parallel_window(workflow, state, root, step_by_id, completed_ids, pen
       step = step_by_id[step_id]
       pending_ids.include?(step_id) && step && dependencies_satisfied?(step, completed_ids)
     end
+    # A single runnable branch is an intentional serial fallback (for example
+    # when active_track limits the window to one track), not a missing window.
+    # Only a genuinely multi-branch runnable set enters the parallel scheduler.
     next unless runnable_ids.length > 1
 
     policy = window["execution_policy"] || {}

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

@@ -12,13 +12,17 @@ require_relative "control_io"
 require_relative "requirement_graph"
 require_relative "checker_registry"
 
-options = { feature: nil, step: nil, contract: nil, write: false, json: false }
+options = { feature: nil, step: nil, contract: nil, write: false, json: false, branch_id: nil, attempt: nil, branch_revision: nil, lock_held: false }
 OptionParser.new do |o|
   o.on("--feature NAME") { |v| options[:feature] = v }
   o.on("--step ID") { |v| options[:step] = v }
   o.on("--contract PATH") { |v| options[:contract] = v }
   o.on("--write") { options[:write] = true }
   o.on("--json") { options[:json] = true }
+  o.on("--parallel-branch-id ID") { |v| options[:branch_id] = v }
+  o.on("--parallel-attempt N", Integer) { |v| options[:attempt] = v }
+  o.on("--parallel-branch-revision N", Integer) { |v| options[:branch_revision] = v }
+  o.on("--lock-held") { options[:lock_held] = true }
 end.parse!
 abort "feature, step and --write are required" unless options[:feature] && options[:step] && options[:write]
 abort "invalid feature" unless RequirementGraph.valid_feature?(options[:feature])
@@ -41,7 +45,7 @@ def file_evidence(root, relative)
   { "path" => relative, "exists" => true, "sha256" => Digest::SHA256.file(absolute).hexdigest, "bytes" => File.size(absolute) }
 end
 
-def independent_evidence(root, feature, step, state, workflow, graph, files, checker_results)
+def independent_evidence(root, feature, step, state, workflow, graph, files, checker_results, binding = nil, inputs = [])
   source_nodes = Array(graph["nodes"]).select { |node| node.is_a?(Hash) && node["kind"] == "source" }
   authority = source_nodes.map do |node|
     evidence = node["evidence"].is_a?(Hash) ? node["evidence"] : {}
@@ -54,7 +58,9 @@ def independent_evidence(root, feature, step, state, workflow, graph, files, che
   # The harness may publish an append-only event log beside the machine pack.
   # Absence is represented as unavailable, never as false/zero, so the pack
   # cannot manufacture proof that an engine did not invoke AI.
-  event_path = File.join(".planning", "evidence", feature, "#{step}.engine-events.jsonl")
+  binding_attempt = binding && binding["attempt"]
+  event_name = binding_attempt.nil? ? "#{step}.engine-events.jsonl" : "#{step}.attempt-#{binding_attempt}.engine-events.jsonl"
+  event_path = File.join(".planning", "evidence", feature, event_name)
   event_absolute, = DevflowControlIO.resolve_control_path(root, event_path, :artifact)
   events = if File.file?(event_absolute)
              File.foreach(event_absolute).first(10_000).each_with_object([]) do |line, parsed|
@@ -72,10 +78,15 @@ def independent_evidence(root, feature, step, state, workflow, graph, files, che
              nil
            end
   ai_events = events ? events.select { |event| %w[ai_runtime_initialized ai_invocation].include?(event["event"]) } : []
+  dispatched_events = events ? events.select { |event| event["event"] == "engine_dispatched" } : []
+  ai_measurement_observed = !ai_events.empty?
 
   {
     "collector" => "core.machine_evidence/v1",
     "state" => { "revision" => state["revision"], "step" => step },
+    "parallel_binding" => binding,
+    "input_fingerprints" => inputs.select { |item| item["exists"] }.map { |item| item["sha256"] },
+    "output_fingerprints" => files.select { |item| item["exists"] }.map { |item| item["sha256"] },
     "source_authority" => { "status" => authority.empty? ? "unavailable" : "observed", "sources" => authority },
     "candidate_binding" => {
       "status" => "observed",
@@ -90,8 +101,13 @@ def independent_evidence(root, feature, step, state, workflow, graph, files, che
     "engine_evidence" => {
       "collector" => events ? "harness.engine-events/v1" : "unavailable",
       "event_log" => event_path,
-      "ai_runtime_initialized" => events ? ai_events.any? { |event| event["event"] == "ai_runtime_initialized" } : nil,
-      "ai_invocation_count" => events ? ai_events.count { |event| event["event"] == "ai_invocation" } : nil,
+      # engine_dispatched proves that the harness dispatched work, but it does
+      # not prove how many model calls the child session made. Keep unknown as
+      # nil instead of manufacturing false/zero values for branch evidence.
+      "ai_runtime_initialized" => ai_measurement_observed ? ai_events.any? { |event| event["event"] == "ai_runtime_initialized" } : nil,
+      "ai_invocation_count" => ai_measurement_observed ? ai_events.count { |event| event["event"] == "ai_invocation" } : nil,
+      "engine_dispatched_count" => events ? dispatched_events.length : nil,
+      "ai_capable_engine_dispatched" => events ? dispatched_events.any? { |event| event["ai_capable"] == true } : nil,
       "evidence_status" => events ? "observed" : "unavailable"
     }
   }
@@ -156,10 +172,21 @@ rescue JSON::ParserError => error
 end
 
 root = Dir.pwd
-lock = DevflowControlIO.acquire_project_lock(root)
+lock = options[:lock_held] ? nil : DevflowControlIO.acquire_project_lock(root)
 begin
   state = state_front_matter(root)
-  unless state["current_feature"] == options[:feature] && state["current_step"] == options[:step]
+  binding = nil
+  branch = nil
+  if options[:branch_id]
+    require_relative "parallel_run"
+    record = ParallelRun.load(root, options[:feature])
+    branch = Array(record && record["branches"]).find { |item| item["branch_id"].to_s == options[:branch_id].to_s }
+    raise "parallel branch not found" unless record && branch
+    raise "parallel branch attempt mismatch" unless options[:attempt].nil? || Integer(branch.fetch("attempt", 0)) == options[:attempt]
+    raise "parallel branch revision mismatch" unless options[:branch_revision].nil? || Integer(branch.fetch("branch_revision", 0)) == options[:branch_revision]
+    binding = { "run_id" => record["run_id"], "branch_id" => branch["branch_id"], "attempt" => branch["attempt"], "branch_revision" => branch["branch_revision"], "state_revision" => state["revision"] }
+  end
+  unless state["current_feature"] == options[:feature] && (state["current_step"] == options[:step] || branch)
     result = { "ok" => false, "reason" => "state_step_mismatch", "state_feature" => state["current_feature"], "state_step" => state["current_step"] }
     puts JSON.pretty_generate(result)
     exit 1
@@ -181,6 +208,7 @@ begin
     { "path" => relative, "required" => true, "exists" => exists, "bytes" => exists ? File.size(absolute) : 0,
       "sha256" => exists ? Digest::SHA256.file(absolute).hexdigest : nil }
   end.compact
+  input_files = Array(step["inputs"]).map { |input| file_evidence(root, interpolate(input.to_s, state)) }
 
   graph, = RequirementGraph.load_graph(root, options[:feature])
   checkers = RequirementGraph.checker_results(graph)
@@ -206,13 +234,17 @@ begin
     contract_hash = Digest::SHA256.file(contract_path).hexdigest
   end
   node_counts = Array(graph["nodes"]).group_by { |node| node["kind"] }.transform_values(&:length)
-  independent = independent_evidence(root, options[:feature], options[:step], state, workflow, graph, files, checker_results)
+  independent = independent_evidence(root, options[:feature], options[:step], state, workflow, graph, files, checker_results, binding, input_files)
   engine_evidence_complete = independent.dig("engine_evidence", "evidence_status") == "observed"
   evidence_complete = engine_evidence_gate != "enforced" || engine_evidence_complete
   pack = {
     "schema_version" => 2, "origin" => "core_machine", "feature" => options[:feature], "step" => options[:step],
     "state_revision" => state["revision"], "graph_revision" => graph["revision"], "workflow_fingerprint" => Digest::SHA256.hexdigest(workflow_raw),
-    "contract_hash" => contract_hash, "files" => files, "checkers" => checker_results, "evidence" => independent,
+    "run_id" => binding && binding["run_id"], "branch_id" => binding && binding["branch_id"],
+    "attempt" => binding && binding["attempt"], "branch_revision" => binding && binding["branch_revision"],
+    "input_fingerprints" => input_files.select { |item| item["exists"] }.map { |item| item["sha256"] },
+    "output_fingerprints" => files.select { |item| item["exists"] }.map { |item| item["sha256"] },
+    "contract_hash" => contract_hash, "files" => files, "input_files" => input_files, "checkers" => checker_results, "evidence" => independent,
     "counters" => { "required_file_count" => files.length, "existing_file_count" => files.count { |item| item["exists"] }, "nodes_by_kind" => node_counts,
                     "stale_node_count" => Array(graph["stale"]).length, "stale_view_count" => Hash(graph["views"]).count { |_name, view| view["needs_recheck"] } },
     "view_fingerprints" => Hash(graph["views"]).transform_values { |view| view.select { |key, _value| %w[fingerprint graph_revision state needs_recheck stale_fingerprint].include?(key) } },
@@ -220,12 +252,13 @@ begin
     "evidence_complete" => evidence_complete,
     "gate_mode" => gate.empty? ? "observe" : gate
   }.compact
-  destination = File.join(root, ".planning/evidence", options[:feature], "#{options[:step]}.machine.json")
+  suffix = binding ? ".attempt-#{binding["attempt"]}.branch-#{Digest::SHA256.hexdigest(binding["branch_id"].to_s)[0, 12]}" : ""
+  destination = File.join(root, ".planning/evidence", options[:feature], "#{options[:step]}#{suffix}.machine.json")
   DevflowControlIO.atomic_write(destination, JSON.pretty_generate(pack) + "\n")
-  result = { "ok" => true, "path" => destination.sub("#{root}/", ""), "complete" => pack["complete"], "state_revision" => pack["state_revision"], "graph_revision" => pack["graph_revision"], "checkers" => checker_results }
+  result = { "ok" => true, "path" => destination.sub("#{root}/", ""), "complete" => pack["complete"], "state_revision" => pack["state_revision"], "graph_revision" => pack["graph_revision"], "checkers" => checker_results, "parallel_binding" => binding }
 rescue StandardError => error
   result = { "ok" => false, "reason" => "machine_evidence_failed", "message" => error.message }
 ensure
-  DevflowControlIO.release_lock(lock)
+  DevflowControlIO.release_lock(lock) if lock
 end
 puts JSON.pretty_generate(result)