@guanlin4924/devflow-pi 0.1.105 → 0.1.107

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

@@ -6,6 +6,8 @@ require "optparse"
 require "yaml"
 require_relative "validate_state"
 require_relative "checkpoint_meta"
+require_relative "gate_policy"
+require_relative "dynamic_plan"
 
 options = { json: false, state: nil }
 OptionParser.new do |opts|
@@ -15,6 +17,11 @@ OptionParser.new do |opts|
 end.parse!
 
 root = Dir.pwd
+dynamic_state = DynamicPlan.read_state(root)
+if dynamic_state && dynamic_state["current_flow"] == "dynamic"
+  puts JSON.pretty_generate(DynamicPlan.snapshot(root, dynamic_state))
+  exit 0
+end
 state_path = options[:state] ? File.expand_path(options[:state], root) : File.join(root, ".devflow/planning", "STATE.md")
 
 def fail_result(reason, details = {})
@@ -192,19 +199,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 +361,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 +393,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 +411,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 +430,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]
@@ -604,6 +553,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,
@@ -614,26 +565,7 @@ 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"] }
@@ -647,8 +579,9 @@ result =
                                        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"],

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

@@ -15,6 +15,8 @@ require "optparse"
 require "time"
 require "yaml"
 require_relative "control_io"
+require_relative "artifact_specs"
+require_relative "gate_policy"
 require_relative "parallel_run"
 
 options = {
@@ -54,9 +56,8 @@ def interpolate_path(path, state)
 end
 
 def required_output_specs(step)
-  outputs = Array(step["outputs"]).select { |item| item.is_a?(Hash) && item["required"] == true }
-  outputs << step["meta_output"] if step["meta_output"].is_a?(Hash)
-  outputs
+  ArtifactSpecs.for_step(step).select { |item| item["required"] == true }
+
 end
 
 def actual_content_issues(path, checks)
@@ -143,12 +144,13 @@ def generate_machine_evidence(root, feature, state_revision, branch, expected_pa
   packed_paths = Array(pack["files"]).select { |item| item.is_a?(Hash) && item["required"] == true }.map { |item| item["path"].to_s }.sort
   errors << "machine evidence required outputs mismatch" unless packed_paths == expected_paths.sort
   errors << "machine evidence contains a missing required file" unless Array(pack["files"]).all? { |item| item.is_a?(Hash) && item["exists"] == true && item["sha256"].to_s.match?(/\A[0-9a-f]{64}\z/) }
-  raise ArgumentError, errors.join("; ") unless errors.empty?
+  recovery_check(errors.empty?, errors.join("; "))
 
   output_fingerprint = Digest::SHA256.hexdigest(
     Array(pack["files"]).map { |item| [item["path"].to_s, item["sha256"].to_s] }.sort.to_json,
   )
   {
+    "valid" => errors.empty?,
     "evidence_path" => evidence_path,
     "evidence_sha256" => Digest::SHA256.file(absolute).hexdigest,
     "output_fingerprint" => output_fingerprint,
@@ -213,6 +215,13 @@ rescue JSON::ParserError => error
   { "ok" => false, "reason" => "join_returned_invalid_json", "message" => error.message, "stderr" => stderr.strip, "exit_status" => status.exitstatus }
 end
 
+def recovery_check(condition, message)
+  return if condition
+
+  $recovery_advisories << GatePolicy.advisory({ "code" => "parallel_recovery_check_failed", "message" => message })
+end
+
+$recovery_advisories = []
 root = Dir.pwd
 feature = options[:feature].to_s
 result = nil
@@ -244,7 +253,7 @@ begin
     raise ArgumentError, "parallel run not found" unless run
     recovery = recovery_id(run, options[:expected_state_revision], options[:expected_run_revision])
     branches = Array(run["branches"])
-    already_joined = state["parallel_run_ref"].nil? && run["status"] == "completed" && branches.any? && branches.all? { |branch| branch["status"] == "succeeded" }
+    already_joined = state["parallel_run_ref"].nil? && run["status"] == "completed" && branches.any? && (branches.all? { |branch| branch["status"] == "succeeded" } || run["completion_with_warnings"])
     if already_joined
       append_audit(root, feature, {
         "schema_version" => 1, "origin" => "core.parallel_recovery/v1", "event" => "idempotent_noop",
@@ -264,7 +273,7 @@ begin
       raise ArgumentError, "parallel run is bound to stale STATE revision" unless Integer(run.fetch("bound_state_revision")) == state_revision
       raise ArgumentError, "parallel run has no branches" if branches.empty?
       ineligible = branches.select { |branch| %w[failed aborted].include?(branch["status"].to_s) }
-      raise ArgumentError, "failed/aborted branches require explicit retry: #{ineligible.map { |branch| branch['branch_id'] }.join(', ')}" unless ineligible.empty?
+      recovery_check(ineligible.empty?, "failed/aborted branches were not retried: #{ineligible.map { |branch| branch['branch_id'] }.join(', ')}")
       previous_validation = prior_validation(root, feature, recovery, run)
       unless current_run_revision == options[:expected_run_revision] || previous_validation
         raise ArgumentError, "stale parallel run revision: expected=#{options[:expected_run_revision]}, actual=#{current_run_revision}"
@@ -275,9 +284,10 @@ begin
     registry_source = workflow.dig("artifact_registry", "source").to_s
     raise ArgumentError, "workflow artifact_registry.source is required for recovery" if registry_source.empty?
     registry_path, = DevflowControlIO.resolve_control_path(root, registry_source, :registry)
-    registry = load_yaml_mapping(registry_path, "artifact registry")
-    raise ArgumentError, "artifact registry revision mismatch" unless Integer(registry.fetch("state_revision")) == state_revision
-    raise ArgumentError, "artifact registry feature mismatch" unless registry.dig("registry_scope", "feature").to_s == feature
+    registry = File.file?(registry_path) ? load_yaml_mapping(registry_path, "artifact registry") : {}
+    recovery_check(!registry.empty?, "artifact registry missing")
+    recovery_check(registry["state_revision"] == state_revision, "artifact registry revision mismatch")
+    recovery_check(registry.dig("registry_scope", "feature").to_s == feature, "artifact registry feature mismatch")
     registry_by_path = Array(registry["artifacts"]).each_with_object({}) do |artifact, index|
       raise ArgumentError, "artifact registry entry must be a mapping" unless artifact.is_a?(Hash)
       path = artifact["path"].to_s
@@ -292,7 +302,8 @@ begin
       raise ArgumentError, "parallel branch workflow step is unknown: #{branch['workflow_step']}" unless step
       artifacts = validate_registered_outputs(root, workflow, state, step, registry_by_path)
       invalid = artifacts.reject { |artifact| artifact["valid"] }
-      raise ArgumentError, "branch #{branch['branch_id']} artifact validation failed: #{invalid.to_json}" unless invalid.empty?
+      recovery_check(invalid.empty?, "branch #{branch['branch_id']} artifact validation failed: #{invalid.to_json}")
+      next unless invalid.empty?
       machine = generate_machine_evidence(root, feature, state_revision, branch, artifacts.map { |artifact| artifact["path"] })
       validation_records << {
         "branch_id" => branch["branch_id"], "workflow_step" => branch["workflow_step"],
@@ -310,6 +321,7 @@ begin
 
     validation_records.each do |validated|
       machine = validated.fetch("machine_evidence")
+      next unless machine["valid"]
       updated = ParallelRun.update_branch(
         root: root, feature: feature, branch_id: validated.fetch("branch_id"),
         expected_revision: current_run_revision, status: "succeeded",
@@ -320,9 +332,7 @@ begin
       recovered_branches << validated.fetch("branch_id")
     end
     final_run = ParallelRun.load(root, feature)
-    unless Array(final_run["branches"]).all? { |branch| branch["status"] == "succeeded" }
-      raise ArgumentError, "recovery did not produce an all-succeeded run"
-    end
+    recovery_check(Array(final_run["branches"]).all? { |branch| branch["status"] == "succeeded" }, "recovery did not produce an all-succeeded run; branch statuses preserved")
       append_audit(root, feature, {
         "schema_version" => 1, "origin" => "core.parallel_recovery/v1", "event" => "branches_recovered",
         "recovery_id" => recovery, "reason" => options[:reason], "run_id" => final_run["run_id"],
@@ -382,5 +392,6 @@ rescue StandardError => error
   result = { "ok" => false, "reason" => "parallel_recovery_refused", "message" => error.message, "recovery_id" => recovery }
 end
 
+result["warnings"] = $recovery_advisories + Array(result.dig("details", "advisories")) unless $recovery_advisories.empty?
 puts(options[:json] ? JSON.generate(result) : JSON.pretty_generate(result))
 exit exit_status

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

@@ -6,6 +6,8 @@ require "json"
 require "optparse"
 require "yaml"
 require_relative "control_io"
+require_relative "artifact_specs"
+require_relative "gate_policy"
 require_relative "validate_state"
 require_relative "phase_ownership"
 
@@ -30,7 +32,7 @@ end
 def build_registry(root, workflow, state)
   checks = workflow.dig("artifact_registry", "content_checks") || {}
   artifacts = Array(workflow["steps"]).flat_map do |step|
-    Array(step["outputs"]).map do |output|
+    ArtifactSpecs.for_step(step).map do |output|
       path = interpolate_path(output.fetch("path"), state)
       abs, = DevflowControlIO.resolve_control_path(root, path, :artifact)
       exists = File.exist?(abs)
@@ -90,9 +92,7 @@ begin
           output_path, = DevflowControlIO.resolve_control_path(root, path, :artifact)
           path unless File.exist?(output_path)
         end.compact
-        if missing_current_outputs.any?
-          result = { "ok" => false, "classification" => "unsafe", "reason" => "missing_required_output", "missing_outputs" => missing_current_outputs, "plan" => { "state_transition" => "none", "registry_write" => false } }
-        elsif !validation["ok"]
+        if !validation["ok"]
           result = { "ok" => false, "classification" => "unsafe", "reason" => "ambiguous_or_invalid_state", "issues" => validation["errors"], "plan" => { "state_transition" => "none", "registry_write" => false } }
         elsif !options[:confirm] || !options[:write]
           result = { "ok" => false, "classification" => "safe_repairable", "reason" => "confirmation_required", "revision" => state.fetch("revision", 0), "plan" => { "state_transition" => "none", "registry_write" => true, "registry" => candidate } }

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

@@ -8,6 +8,8 @@ require "json"
 require "optparse"
 require "yaml"
 require_relative "control_io"
+require_relative "artifact_specs"
+require_relative "gate_policy"
 require_relative "phase_ownership"
 
 options = {
@@ -56,7 +58,7 @@ end
 
 def collect_outputs(workflow)
   Array(workflow["steps"]).flat_map do |step|
-    Array(step["outputs"]).map do |output|
+    ArtifactSpecs.for_step(step).map do |output|
       [step, output]
     end
   end
@@ -67,6 +69,10 @@ project_lock = DevflowControlIO.acquire_project_lock(root) if options[:write]
 begin
 state_path, = DevflowControlIO.resolve_control_path(root, options[:state], :state)
 state = load_state(state_path)
+if state["current_flow"] == "dynamic"
+  puts JSON.generate({ "ok" => true, "written" => false, "mode" => "dynamic", "reason" => "task evidence is maintained in STATE; no per-skill artifact registry required" })
+  exit 0
+end
 ownership = PhaseOwnership.validate_state(root: root, state: state)
 unless ownership["ok"]
   puts JSON.pretty_generate(ownership.merge("written" => false))

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

@@ -33,8 +33,7 @@ module WorkflowStateValidator
   # Core quality checks are advisory by default. Keep only structural and
   # write-safety failures hard; AI review decides whether business-quality
   # drift, stale metadata, or incomplete generated evidence should pause work.
-  SOFT_GATE_MODE = ENV.fetch("DEVFLOW_SOFT_GATES", "1") != "0"
-  HARD_VALIDATION_CODES = %w[
+    OPERATION_VALIDATION_CODES = %w[
     invalid_control_path
     missing_state_file
     missing_state_front_matter
@@ -44,36 +43,8 @@ module WorkflowStateValidator
     workflow_step_unknown
     phase_ownership_conflict
   ].freeze
-  # Acceptance-execution trust failures are never downgraded by soft gates.
-  ACCEPTANCE_HARD_VALIDATION_CODES = %w[
-    acceptance_results_not_passed
-    execution_surface_mismatch
-    approval_invalid
-    human_result_unapproved
-    dsl_not_approved
-    environment_profile_not_approved
-    runtime_integrity_error
-    acceptance_tests_not_passed
-    acceptance_tests_empty
-    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
-  ].freeze
-
-  def self.hard_validation_code?(code)
-    value = code.to_s
-    return true if HARD_VALIDATION_CODES.include?(value)
-    return true if ACCEPTANCE_HARD_VALIDATION_CODES.include?(value)
-    return true if value.start_with?("artifact_registry_", "parallel_", "PARALLEL_")
-    return true if value.start_with?("duplicate_", "unknown_", "missing_tracked_step")
-    return true if value.start_with?("step_in_", "completed_", "terminal_", "non_completed_")
-    return true if value.start_with?("waiting_checkpoint_")
-    return true if value.start_with?("skipped_")
-    return true if %w[missing_required_output output_not_registered].include?(value)
-
-    false
+  def self.operation_validation_code?(code)
+    OPERATION_VALIDATION_CODES.include?(code.to_s)
   end
 
   module_function
@@ -89,6 +60,15 @@ module WorkflowStateValidator
     issues = []
 
     state = state_override || load_state(state_path, issues)
+    if state && state["current_flow"] == "dynamic"
+      require_relative "dynamic_plan"
+      begin
+        DynamicPlan.validate!(root, state.fetch("plan"))
+      rescue ArgumentError, KeyError => error
+        issues << issue("error", "invalid_dynamic_plan", error.message)
+      end
+      return result(issues.empty?, state_path, nil, nil, issues)
+    end
     return result(false, state_path, nil, nil, issues) unless state
 
     REQUIRED_STATE_FIELDS.each do |field|
@@ -159,14 +139,12 @@ module WorkflowStateValidator
       end
     end
 
-    if SOFT_GATE_MODE
-      issues.each do |entry|
-        next unless entry["severity"] == "error"
-        next if hard_validation_code?(entry["code"])
+    issues.each do |entry|
+      next unless entry["severity"] == "error"
+      next if operation_validation_code?(entry["code"])
 
-        entry["severity"] = "warning"
-        entry["soft_gate"] = true
-      end
+      entry["severity"] = "warning"
+      entry["soft_gate"] = true
     end
     ok = issues.none? { |entry| entry["severity"] == "error" }
     result(ok, state_path, workflow_path, registry_path, issues)

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

@@ -107,10 +107,46 @@ def canonical_fingerprint(canonical)
 end
 
 def read_source_fingerprint(root, feature)
-  path = File.join(root, ".devflow/planning", "requirements", feature, "traceability.json")
-  return "" unless File.file?(path)
+  units_path, = DevflowControlIO.resolve_control_path(root, ".devflow/planning/requirements/#{feature}/source_units.yaml", :artifact)
+  # Core source unitization owns this value. Both the baseline template and
+  # graph-generated traceability views legitimately omit the legacy mirror.
+  traceability_path, = DevflowControlIO.resolve_control_path(root, ".devflow/planning/requirements/#{feature}/traceability.json", :artifact)
+  legacy = if File.file?(traceability_path)
+             traceability = JSON.parse(File.read(traceability_path))
+             raise ArgumentError, "traceability.json must be an object" unless traceability.is_a?(Hash)
+             traceability["source_document_fingerprint"].to_s
+           else
+             ""
+           end
+  unless File.exist?(units_path) || File.symlink?(units_path)
+    return legacy unless legacy.strip.empty?
 
-  JSON.parse(File.read(path))["source_document_fingerprint"].to_s
+    raise ArgumentError, "source_units.yaml is missing and traceability.json has no legacy source_document_fingerprint; restore requirement-wayfinder source provenance"
+  end
+
+  units = YAML.safe_load(File.read(units_path), permitted_classes: [], aliases: false)
+  raise ArgumentError, "source_units.yaml must be an object" unless units.is_a?(Hash)
+  fingerprint = units["source_document_fingerprint"].to_s
+  digest = fingerprint.delete_prefix("sha256:")
+  unless digest.match?(/\A[0-9a-f]{64}\z/)
+    raise ArgumentError, "source_units.yaml source_document_fingerprint must be a SHA-256 digest"
+  end
+  source = units["source_document"].to_s
+  if source.empty? || Pathname.new(source).absolute? || source.split(/[\\\/]/).include?("..")
+    raise ArgumentError, "source_units.yaml source_document must be a project-relative path"
+  end
+  root_real = File.realpath(root)
+  source_path = File.realpath(File.join(root_real, source))
+  unless source_path.start_with?(root_real + File::SEPARATOR)
+    raise ArgumentError, "source_units.yaml source_document escapes project root"
+  end
+  unless Digest::SHA256.file(source_path).hexdigest == digest
+    raise ArgumentError, "source_units.yaml source_document_fingerprint is stale; regenerate source units and review the changed requirements"
+  end
+  unless legacy.empty? || legacy.delete_prefix("sha256:") == digest
+    raise ArgumentError, "traceability.json source_document_fingerprint conflicts with source_units.yaml; reconcile requirement provenance"
+  end
+  fingerprint
 end
 
 def verify_business_action_refs(canonical, path)

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

@@ -13,13 +13,12 @@ phase_scope:
   failure_branch_enabled: true
   parallel_window_enabled: true
 
-# P2 preset: new work fail-closes at the defined checkpoints. Existing STATE
+# Gate checks are advisory. Existing STATE
 # files without governance_started_revision remain legacy_unattested and are
 # only reported until their next newly-started governed step.
 governance:
   # Chain skill owns orchestration while Core remains an evidence/diagnostic
-  # service. Set to `core` only after the hard-gate migration is complete.
-  hard_gate_mode: chain
+  # service. Core checks only produce diagnostics.
   gate_contract_version: 3
   requirement_graph_gate: enforced
   requirement_coverage_gate: enforced

package/plugins/devflow-core/skills/workflow-orchestrator/templates/regression-acceptance.yaml

@@ -9,7 +9,6 @@ entry:
   initial_step: regression-test-design
 
 governance:
-  hard_gate_mode: core
   gate_contract_version: 3
   requirement_graph_gate: enforced
   enforced_checkpoints:

package/plugins/devflow-core/skills/workflow-pipeline/SKILL.md

@@ -3,11 +3,19 @@ name: workflow-pipeline
 description: Use when running or resuming the full .devflow/planning delivery pipeline from requirements through implementation, frozen acceptance tests, and Devflow release closeout.
 ---
 
+Dynamic plan mode: when Core reports `mode: dynamic`, use `workflow-dynamic` as the execution protocol. The selected task supplies scope, dependencies, required outputs and verification. Use this skill's relevant technical guidance, but do not create legacy stage documents/meta pairs, require fixed checkpoints, or advance legacy STATE. Return activity/evidence to `devflow_plan`; only Core records verification.
+
+
+## 默认软门禁策略
+
+工作流硬门禁已移除。下文及各步骤中的产物、索引、合同、审查、质量、恢复和 CP 审批条件均为诊断建议：保留失败证据和缺项，允许继续执行。用户说“下一步”即可推进，无需额外批准弹窗；不得把继续执行记录成人工批准，也不得把失败、未执行的测试改写为通过。真实读写/执行失败、无法解析的状态和并发版本冲突须如实报告。硬门禁及其恢复开关已移除。
+
+
 <objective>
 全链路研发交付入口。解析用户参数，先确保需求主链“入口分诊 → 探索地图 → 领域建模 → 可实现性审查”完成，再检测当前状态，然后委托 workflow-orchestrator 接管后续所有步骤调度。
 pipeline 本身不包含执行规则——所有门禁、CP 协议、失败分支、并行窗口、lessons 注入规则均由 orchestrator 维护。
 
-当前迁移阶段由本 skill 作为链路编排器：按 `next_step.skill` 依次调用各技能、传递上一技能的产物与诊断、再决定下一技能。Core 的 contract/checker/output/review 硬门禁暂不参与阻断；Core 结果只作为事实和风险提示。只有控制面损坏、危险写入或需要人工确认时才停止链路。
+当前迁移阶段由本 skill 作为链路编排器：按 `next_step.skill` 依次调用各技能、传递上一技能的产物与诊断、再决定下一技能。Core 的 contract/checker/output/review 硬门禁暂不参与阻断；Core 结果只作为事实和风险提示。真实操作无法完成时报告原因；CP 默认带警告继续，仅显式恢复确认时等待人工决定。
 </objective>
 
 <process>
@@ -55,10 +63,10 @@ pipeline 本身不包含执行规则——所有门禁、CP 协议、失败分
 
 - **`--track A`**：后端/API 轨道产物模式。可跑 `requirement-triage → requirement-wayfinder → domain-modeling → requirement-feasibility-review → requirement-baseline → api-contract → architecture-feasibility → backend-tech-spec → api-call-guide`，但不能自动进入 `integration-verify / change-plan / execute`。
 - **`--track B`**：前端/UI 轨道产物模式。要求 `api-contract` 与 `architecture-feasibility` 已完成；新需求从需求主链开始，已有共同事实可跑 `ui-spec → feature-breakdown → frontend-tech-spec`，但不能自动进入 `change-plan / execute`。
-- **未设置 track**：完整交付模式。必须完成双轨并通过 `integration-verify` 后才能进入 `change-plan`。
+- **未设置 track**：完整交付模式。完成双轨并执行 `integration-verify` 检查；未通过项作为风险传给 `change-plan`。
 - **`--no-review`**：保留参数位，但当前双轨 workflow 不自动跳过 CP-2。Merge Gate 不能跳过。
 
-双轨制原则：API 契约是分叉前的共同事实，`integration-verify` 是合并前的强门禁。单轨只产出局部轨道文档，不代表完整交付。
+双轨制原则：API 契约是分叉前的共同事实，`integration-verify` 是合并前的软门禁。单轨只产出局部轨道文档，不代表完整交付。
 
 `workflow-generate-mainflow-cases` 不是独立 workflow step，而是 `run-acceptance-tests` 绑定阶段的组成部分：对执行面为 `ui` / `api_flow` 且绑定为 `automated` 的 TC，必须先生成 v1 DSL 并经 `devflow_approval` 批准执行计划，否则该 TC 保持 blocked。人工 TC 结果同样只经 `human_result` 批准计入聚合门禁。
 
@@ -72,7 +80,7 @@ pipeline 本身不包含执行规则——所有门禁、CP 协议、失败分
 2. `workflow-wayfinder` 建立目标、已知事实、边界、迷雾与 ticket；只有活动切片的 L1/L2 迷雾收束后才可完成。
 3. `workflow-domain-modeling` 固化共同语言、所有权、状态和边缘案例。
 4. `requirement-feasibility-review` 以流程证明、代码事实和外部能力检查作为进入基线前的最终门禁。
-5. 仅当审查 meta 的 `baseline_gate = pass` 时，才可进入 `workflow-requirement-baseline`。
+5. 检查审查 meta 的 `baseline_gate`，未通过项保留为诊断并传给 `workflow-requirement-baseline`。
 
 若分诊结论为 `already_done`、`wontfix`、`ready_for_human` 或 `needs_info`，停止主链并报告最小下一步。`workflow-demand-clarify` 不再作为固定主链步骤；需要业务问答时，由 Wayfinder 的 Grilling ticket 调用。
 
@@ -113,7 +121,7 @@ devflow_state(action="inspect")
 
 ## 3. 委托 orchestrator
 
-在当前 `hard_gate_mode: chain` 下，pipeline 继续调用 `workflow-orchestrator` 获取步骤拓扑，但由本链路规则串联实际技能调用，不把 Core gate 的 `block` 结果当作自动停止条件：
+当前pipeline 继续调用 `workflow-orchestrator` 获取步骤拓扑，但由本链路规则串联实际技能调用，不把 Core gate 的 `block` 结果当作自动停止条件：
 
 ```
 /workflow-orchestrator

package/plugins/devflow-core/skills/workflow-pipeline/references/pipeline-flow.md

@@ -41,7 +41,7 @@ workflow-pipeline
   → 完成
 ```
 
-`workflow-generate-mainflow-cases` 不参与独立排序，而是 `run-acceptance-tests` 绑定阶段的组成部分：automated 的 ui / api_flow TC 需要先生成 v1 DSL 并批准执行计划。人工验收结果（经 `human_result` 批准）会与自动执行结果聚合，验收失败是硬门禁。
+`workflow-generate-mainflow-cases` 不参与独立排序，而是 `run-acceptance-tests` 绑定阶段的组成部分：automated 的 ui / api_flow TC 需要先生成 v1 DSL 并批准执行计划。人工验收结果（经 `human_result` 批准）会与自动执行结果聚合，验收失败是软门禁：保留 failed/blocked 结果与风险，默认不阻止流程推进或收口。
 
 ## 双轨与 Checkpoint 规则
 

package/plugins/devflow-core/skills/workflow-project-context/SKILL.md

@@ -3,6 +3,8 @@ name: workflow-project-context
 description: "Use when a project needs database-backed initialization, repository discovery, project facts, code indexing, navigation, or initialization recovery."
 ---
 
+门禁策略：默认软门禁，门禁行为以本段为准。本文及引用材料中的前置检查、审查、质量、完成条件和 CP 确认用于诊断；未满足时记录缺项、风险与后续处理，继续可执行的工作，不自动阻断阶段推进。保留真实的 failed/blocked/未审批状态，不把继续执行写成通过或人工批准。硬门禁及其恢复开关已移除。
+
 # Project Initialization
 
 Initialize project context only. Do not create requirements, approved API contracts, prototypes, roadmaps, commits, tags, repositories, or workflow state.

package/plugins/devflow-design/skills/workflow-api-call-guide/SKILL.md

@@ -3,6 +3,8 @@ name: workflow-api-call-guide
 description: "Use after backend-tech-spec, before integration-verify. Generates a step-by-step API call guide for frontend developers. This is NOT a change list — no code changes, just calling instructions based on the confirmed API contract and backend tech spec."
 ---
 
+门禁策略：默认软门禁，门禁行为以本段为准。本文及引用材料中的前置检查、审查、质量、完成条件和 CP 确认用于诊断；未满足时记录缺项、风险与后续处理，继续可执行的工作，不自动阻断阶段推进。保留真实的 failed/blocked/未审批状态，不把继续执行写成通过或人工批准。硬门禁及其恢复开关已移除。
+
 # API 调用指南
 
 ## 定位

package/plugins/devflow-design/skills/workflow-api-contract/SKILL.md

@@ -3,6 +3,8 @@ name: workflow-api-contract
 description: "Use after requirement-baseline, before dual-track fork. Defines shared API contracts (endpoints, request/response shapes, data models) that both Track A and Track B reference. This is the fork point — contract changes after this step are exception paths."
 ---
 
+门禁策略：默认软门禁，门禁行为以本段为准。本文及引用材料中的前置检查、审查、质量、完成条件和 CP 确认用于诊断；未满足时记录缺项、风险与后续处理，继续可执行的工作，不自动阻断阶段推进。保留真实的 failed/blocked/未审批状态，不把继续执行写成通过或人工批准。硬门禁及其恢复开关已移除。
+
 # API 契约生成器
 
 ## 定位
@@ -27,7 +29,7 @@ description: "Use after requirement-baseline, before dual-track fork. Defines sh
 - `.devflow/planning/features/{功能名}/api-contract.md`
 - `.devflow/planning/features/{功能名}/api-contract.meta.json`
 
-The meta file must also set `traceability_status: "passed"` only after every API design has been written to `traceability.json.designs` and `traceability_check.py --stage design` succeeds; otherwise set `failed` and do not advance.
+The meta file must also set `traceability_status: "passed"` only after every API design has been written to `traceability.json.designs` and `traceability_check.py --stage design` succeeds; otherwise set `failed`, record the traceability gaps, and continue with these advisories in soft mode.
 
 ## 输入
 

package/plugins/devflow-design/skills/workflow-api-supplement/SKILL.md

@@ -3,6 +3,8 @@ name: workflow-api-supplement
 description: "Use when Track B (frontend-tech-spec) discovers API gaps that the shared API contract doesn't cover. This is an EXCEPTION PATH — not a normal pipeline step. Submits API supplement requests for Track A evaluation."
 ---
 
+门禁策略：默认软门禁，门禁行为以本段为准。本文及引用材料中的前置检查、审查、质量、完成条件和 CP 确认用于诊断；未满足时记录缺项、风险与后续处理，继续可执行的工作，不自动阻断阶段推进。保留真实的 failed/blocked/未审批状态，不把继续执行写成通过或人工批准。硬门禁及其恢复开关已移除。
+
 # API 补充需求（异常路径）
 
 ## 定位

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

@@ -3,6 +3,8 @@ name: workflow-architecture-feasibility
 description: "Use after API contract and before frontend/backend technical specifications to compare implementation paths against confirmed workload facts and repository-static context. Use for async or scheduled work, batch operations, external calls, fanout, migrations, workload/SLA constraints, or when a feature may not fit the current framework and integrations."
 ---
 
+门禁策略：默认软门禁，门禁行为以本段为准。本文及引用材料中的前置检查、审查、质量、完成条件和 CP 确认用于诊断；未满足时记录缺项、风险与后续处理，继续可执行的工作，不自动阻断阶段推进。保留真实的 failed/blocked/未审批状态，不把继续执行写成通过或人工批准。硬门禁及其恢复开关已移除。
+
 # 架构可行性与方案比较
 
 生成一份由 Core 派生的架构简报；不把自由 Markdown 当作架构真相，也不把仓库声明当成生产容量。