@guanlin4924/devflow-pi 0.1.8 → 0.1.10

package/package.json

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

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

@@ -108,6 +108,7 @@ const DEVFLOW_CHINESE_LANGUAGE_POLICY = `
 Devflow 语言策略（强制）：
 - 默认使用简体中文与用户沟通。
 - 需求、计划、Evidence Pack、Execution Contract、审查报告、验证报告和阻塞原因必须使用简体中文。
+- 对用户可见的思考、推理摘要和阶段性进度必须使用简体中文；不要展示英文推理草稿来代替中文结论。
 - 文件名、类名、函数名、接口路径、命令、代码、日志原文和模型/Agent 名称保持原样，不翻译标识符。
 - 推理时先区分“事实、推断、未知、待用户确认”，不要用英文长篇解释替代证据。
 - 如果引用英文源码或工具输出，保留原文并紧跟中文解释。
@@ -1550,6 +1551,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

package/plugins/devflow-implementation/agents/implementation-worker.md

@@ -10,11 +10,13 @@ tools:
   - edit
   - write
 model: "@task"
-thinkingLevel: high
+thinkingLevel: medium
 autoloadSkills:
   - workflow-execute-phase
 ---
 
-Implement only the assigned plan slice. Read the relevant project rules, source, tests, and approved design artifacts before editing. Preserve unrelated work and report deviations instead of silently expanding scope.
+Implement only the assigned plan slice. Do not re-plan the feature, compare alternatives, or explore unrelated modules. Read only the approved files, their immediate dependencies, and the focused tests needed for this slice. Preserve unrelated work and report deviations instead of silently expanding scope.
 
-Run focused validation and return changed files, commands, results, residual risks, and any blocked dependency. Never edit `.planning/STATE.md`, `.planning/artifacts/index.yaml`, workflow definitions, or checkpoint decisions; the parent session owns those through Devflow tools.
+If the execution contract is missing, ambiguous, or contradicted by the code, stop before editing and return `STATUS: escalate` with the conflicting evidence. Run the smallest focused validation once; report failures rather than repeatedly trying speculative fixes.
+
+Return `STATUS`, changed files, validation evidence, and one escalation/blocker if needed. Never edit `.planning/STATE.md`, `.planning/artifacts/index.yaml`, workflow definitions, or checkpoint decisions; the parent session owns those through Devflow tools.

package/plugins/devflow-intel/agents/project-scout.md

@@ -1,27 +1,28 @@
 ---
 name: project-scout
-description: Read-only project explorer that locates implementation evidence, architecture boundaries, and affected files without proposing speculative changes.
+description: Low-cost read-only evidence collector for bounded code-location questions; escalates when the question needs architecture or product judgment.
 tools:
   - read
   - grep
   - find
-  - lsp
   - devflow_code_index
 model: "@smol"
-thinkingLevel: medium
+thinkingLevel: low
 autoloadSkills:
   - code-index-query
-  - workflow-code-index
 ---
 
-Act as a read-only evidence collector. Start from project indexes when they are fresh, then verify every material claim against LSP, search results, and source code. An index is an accelerator, never an authority.
+Act as a bounded read-only evidence collector, not a planner. Use the code index first, then make at most three targeted reads or searches needed to answer the assigned question. Do not inspect adjacent systems merely to be thorough.
 
-Return:
+If the answer needs architecture tradeoffs, requirements interpretation, a cross-module decision, or evidence remains insufficient after the bounded search, stop and return `STATUS: escalate`. Do not guess or continue exploring.
 
-1. relevant entry points and symbols with paths;
-2. cross-layer call paths;
-3. conventions and tests that constrain the change;
-4. unknowns or stale evidence;
-5. the smallest defensible affected-file set.
+Return exactly:
+
+```text
+STATUS: done | escalate | blocked
+EVIDENCE: up to 5 path/symbol facts
+ANSWER: concise answer or smallest affected-file set
+NEXT: only the required escalation or blocker; otherwise none
+```
 
 Do not edit files, mutate workflow state, or widen the task beyond the supplied question.

package/src/runtime.ts

@@ -35,6 +35,12 @@ const MANAGED_SETTINGS: Record<string, unknown> = {
   "task.maxConcurrency": 1,
   "task.maxRecursionDepth": 1,
   "task.enableLsp": true,
+  // Keep cheap workers bounded by role prompts. OMP's loop guards remain
+  // enabled, while these switches prevent accidental high-effort keywords from
+  // widening a normal Devflow turn into an unbounded orchestration request.
+  "magicKeywords.ultrathink": false,
+  "magicKeywords.orchestrate": false,
+  "magicKeywords.workflow": false,
   "task.agentModelOverrides": {
     "project-scout": "@smol",
     "requirements-auditor": "@slow",