@guanlin4924/devflow-pi 0.1.8 → 0.1.9

package/package.json

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

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

@@ -1550,6 +1550,26 @@ export default function devflowCore(pi: ExtensionAPI) {
           ctx.ui.notify(`Devflow advance failed: ${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
           return;
         }
+        if (inspected.snapshot.action === "workflow_complete" && inspected.snapshot.source_flow) {
+          const revision = typeof inspected.snapshot.revision === "number" ? inspected.snapshot.revision : undefined;
+          if (revision === undefined) {
+            ctx.ui.notify("补救分支缺少 revision，拒绝返回主流程。", "error");
+            return;
+          }
+          const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
+            "--write",
+            "--json",
+            "--expected-revision",
+            String(revision),
+            "--exit-failure-branch",
+          ]);
+          if (!result.ok) {
+            ctx.ui.notify(`补救分支返回失败：${result.stderr || result.stdout}`, "error");
+            return;
+          }
+          ctx.ui.notify("补救分支已返回主流程；仍需审查 reverify 结果，并在 CP-4 明确确认后才能继续。", "info");
+          return;
+        }
         if (inspected.snapshot.status === "waiting_checkpoint") {
           ctx.ui.notify("当前状态等待 checkpoint；请使用 /devflow checkpoint。", "warning");
           return;

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

@@ -16,6 +16,7 @@ options = {
   confirm_checkpoint: false,
   checkpoint_decision: nil,
   enter_failure_branch: false,
+  exit_failure_branch: false,
   expected_revision: nil,
   json: false
 }
@@ -28,6 +29,7 @@ OptionParser.new do |opts|
   opts.on("--confirm-checkpoint", "Advance from waiting checkpoint to the next pending step") { options[:confirm_checkpoint] = true }
   opts.on("--checkpoint-decision VALUE", "Set checkpoint decision, e.g. approved, rejected, needs_fix") { |value| options[:checkpoint_decision] = value }
   opts.on("--enter-failure-branch", "Transition into the configured failure branch for the current step") { options[:enter_failure_branch] = true }
+  opts.on("--exit-failure-branch", "Return from a completed failure branch to its configured source flow") { options[:exit_failure_branch] = true }
   opts.on("--expected-revision REVISION", Integer, "Reject a stale write unless STATE.md has this revision") { |value| options[:expected_revision] = value }
   opts.on("--json", "Print JSON output") { options[:json] = true }
 end.parse!
@@ -337,6 +339,46 @@ def fail_result(reason, details = {})
   { "ok" => false, "reason" => reason, "details" => details }
 end
 
+# Return from a completed failure branch using its declared return_to contract.
+# The caller must still explicitly confirm the returned checkpoint before any
+# subsequent source-flow step can proceed.
+def apply_return_to!(root, state, branch_workflow)
+  return_to = branch_workflow["return_to"]
+  source_flow = state["source_flow"]
+  source_workflow_config = state["source_workflow_config"]
+  return nil unless return_to && source_flow && source_workflow_config
+
+  main_workflow_path = File.join(root, source_workflow_config)
+  return nil unless File.exist?(main_workflow_path)
+
+  main_workflow = load_yaml_file(main_workflow_path)
+  main_steps = Array(main_workflow["steps"])
+  target_step_id = return_to["step"]
+  return nil unless main_steps.any? { |step| step.fetch("id") == target_step_id }
+
+  ordered_ids = main_steps.map { |step| step.fetch("id") }
+  idx = ordered_ids.index(target_step_id)
+  state["current_flow"] = return_to["flow"] || source_flow
+  state["workflow_config"] = source_workflow_config
+  state["current_step"] = target_step_id
+  state["status"] = return_to["status"] || "waiting_checkpoint"
+  state["completed_steps"] = ordered_ids[0..idx]
+  state["pending_steps"] = ordered_ids[(idx + 1)..-1] || []
+  state["last_completed_step"] = target_step_id
+  if return_to["checkpoint"]
+    state["checkpoint"] = return_to["checkpoint"]
+    state["checkpoint_label"] = checkpoint_label(main_workflow, return_to["checkpoint"])
+  else
+    state.delete("checkpoint")
+    state.delete("checkpoint_label")
+  end
+  state.delete("checkpoint_decision")
+  state.delete("source_flow")
+  state.delete("source_workflow_config")
+  "Failure branch completed. Returned to #{target_step_id} (#{state["current_flow"]})" \
+    "#{return_to["checkpoint"] ? ", waiting at #{return_to["checkpoint"]}" : ""}."
+end
+
 project_lock = DevflowControlIO.acquire_project_lock(root) if options[:write]
 
 begin
@@ -413,11 +455,16 @@ result =
             next_step = step_by_id[next_id]
             action_description = "Step completed: #{step["label"]} (#{step_id}). Advanced to #{next_step ? next_step["label"] : next_id}."
           else
-            state["current_step"] = step_id
-            state["status"] = "completed"
-            state.delete("checkpoint")
-            state.delete("checkpoint_label")
-            action_description = "Step completed: #{step["label"]} (#{step_id}). All steps complete."
+            return_description = state["source_flow"] ? apply_return_to!(root, state, workflow) : nil
+            if return_description
+              action_description = "Step completed: #{step["label"]} (#{step_id}). #{return_description}"
+            else
+              state["current_step"] = step_id
+              state["status"] = "completed"
+              state.delete("checkpoint")
+              state.delete("checkpoint_label")
+              action_description = "Step completed: #{step["label"]} (#{step_id}). All steps complete."
+            end
           end
 
           changed = true
@@ -483,10 +530,28 @@ result =
         end
       end
 
+      if result.nil? && options[:exit_failure_branch]
+        if state["source_flow"].nil? || state["source_workflow_config"].nil?
+          result = fail_result("not_in_failure_branch")
+        elsif state["status"] != "completed" || Array(state["pending_steps"]).any?
+          result = fail_result("failure_branch_incomplete", "status" => state["status"], "pending_steps" => state["pending_steps"])
+        else
+          return_description = apply_return_to!(root, state, workflow)
+          if return_description.nil?
+            result = fail_result("missing_return_to", "workflow" => state["current_flow"])
+          else
+            changed = true
+            actions << "failure_branch_exited"
+            action_description = return_description
+          end
+        end
+      end
+
       if result.nil?
         if changed
           state["state_updated_at"] = Date.today.to_s
           state["revision"] = current_revision + 1
+          workflow_path, workflow = load_workflow(root, state)
         end
         # Build the registry from the candidate state before validating it. A
         # step's output is normally written before this transition, so the

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

@@ -583,7 +583,11 @@ result =
   end
 
 if defined?(state) && state.is_a?(Hash) && result.is_a?(Hash)
-  result = result.merge(revision: Integer(state.fetch("revision", 0)))
+  result = result.merge(
+    revision: Integer(state.fetch("revision", 0)),
+    source_flow: state["source_flow"],
+    source_workflow_config: state["source_workflow_config"]
+  )
 end
 
 if options[:json]

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

@@ -63,26 +63,31 @@ begin
     state = YAML.safe_load(front_matter(File.read(state_path)), permitted_classes: [], aliases: false)
     workflow_path = File.expand_path(state.fetch("workflow_config"), root)
     workflow = YAML.safe_load(File.read(workflow_path), permitted_classes: [], aliases: false)
-    candidate = build_registry(root, workflow, state)
-    validation = WorkflowStateValidator.validate(root: root, state_path: state_path, state_override: state, workflow_override: workflow, artifact_registry_override: candidate, strict_artifact_status: true, strict_registry_revision: true)
-    current = Array(workflow["steps"]).find { |step| step["id"] == state["current_step"] }
-    missing_current_outputs = Array(current && current["outputs"]).map do |output|
-      next unless output["required"]
-      path = interpolate_path(output.fetch("path"), state)
-      path unless File.exist?(File.join(root, 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"]
-      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 } }
-    elsif options[:expected_revision] != state.fetch("revision", 0)
-      result = { "ok" => false, "classification" => "unsafe", "reason" => "stale_revision", "expected_revision" => options[:expected_revision], "actual_revision" => state.fetch("revision", 0) }
+    registry_source = workflow.dig("artifact_registry", "source")
+    if !registry_source.is_a?(String) || registry_source.empty?
+      result = { "ok" => false, "classification" => "unsafe", "reason" => "missing_artifact_registry_config", "plan" => { "state_transition" => "none", "registry_write" => false } }
     else
-      registry_path = File.join(root, workflow.dig("artifact_registry", "source"))
-      DevflowControlIO.atomic_write(registry_path, candidate.to_yaml)
-      result = { "ok" => true, "classification" => "safe_repairable", "written" => true, "revision" => state.fetch("revision", 0), "plan" => { "state_transition" => "none", "registry_write" => true } }
+      candidate = build_registry(root, workflow, state)
+      validation = WorkflowStateValidator.validate(root: root, state_path: state_path, state_override: state, workflow_override: workflow, artifact_registry_override: candidate, strict_artifact_status: true, strict_registry_revision: true)
+      current = Array(workflow["steps"]).find { |step| step["id"] == state["current_step"] }
+      missing_current_outputs = Array(current && current["outputs"]).map do |output|
+        next unless output["required"]
+        path = interpolate_path(output.fetch("path"), state)
+        path unless File.exist?(File.join(root, 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"]
+        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 } }
+      elsif options[:expected_revision] != state.fetch("revision", 0)
+        result = { "ok" => false, "classification" => "unsafe", "reason" => "stale_revision", "expected_revision" => options[:expected_revision], "actual_revision" => state.fetch("revision", 0) }
+      else
+        registry_path = File.join(root, registry_source)
+        DevflowControlIO.atomic_write(registry_path, candidate.to_yaml)
+        result = { "ok" => true, "classification" => "safe_repairable", "written" => true, "revision" => state.fetch("revision", 0), "plan" => { "state_transition" => "none", "registry_write" => true } }
+      end
     end
   end
 ensure

package/plugins/devflow-core/skills/workflow-orchestrator/templates/uat-remediation.yaml

@@ -4,6 +4,18 @@ name: Verify Failure Remediation
 description: >
   Generic remediation flow for failed verification or rejected acceptance checkpoints.
 
+artifact_registry:
+  source: ".planning/artifacts/index.yaml"
+  path_key: path
+  status_key: status
+  pending_statuses:
+    - planned
+    - pending_rerun
+  terminal_success_statuses:
+    - approved
+    - completed
+    - passed
+
 entry:
   from_flow: feature-development
   from_step: verify