@guanlin4924/devflow-pi 0.1.36 → 0.1.38

package/README.md

@@ -11,7 +11,7 @@ Devflow Pi 是一个面向项目研发交付的独立 OMP 产品入口，内置
 安装与启动：
 
 ```bash
-npm install -g @guanlin4924/devflow-pi@0.1.36
+npm install -g @guanlin4924/devflow-pi@0.1.38
 cd /path/to/your-project
 devflow-pi init
 devflow-pi doctor

package/package.json

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

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

@@ -1285,6 +1285,22 @@ export default function devflowCore(pi: ExtensionAPI) {
     return { result, snapshot: parseJsonResult(result) };
   }
 
+  async function inspectWorkflowWithRegistryRecovery(cwd: string): Promise<{ result: ProcessResult; snapshot: Record<string, unknown> | null }> {
+    let inspected = await inspectWorkflow(cwd);
+    const errors = Array.isArray(inspected.snapshot?.state_validation && (inspected.snapshot.state_validation as Record<string, unknown>).errors)
+      ? (inspected.snapshot!.state_validation as Record<string, unknown>).errors as Array<Record<string, unknown>>
+      : [];
+    const onlyRegistryDrift = inspected.snapshot?.reason === "state_validation_failed" &&
+      errors.length > 0 && errors.every(error => error.code === "artifact_registry_revision_mismatch");
+    if (!onlyRegistryDrift) return inspected;
+    const synced = await runRuby(cwd, "workflow-orchestrator/scripts/sync_artifacts.rb", [
+      "--write", "--no-preserve", "--json",
+    ]);
+    if (!synced.ok) return inspected;
+    inspected = await inspectWorkflow(cwd);
+    return inspected;
+  }
+
   let activeWorkflowTurn = false;
   let pendingProjectInitialization: ProjectInitializationRequest | undefined;
   let pendingRollover: { snapshot: Record<string, unknown>; preparedRevision: number; rolloverId: string } | undefined;
@@ -1362,7 +1378,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       }
     }
     if (rolloverState && typeof rolloverState.revision === "number" && rollover?.status === "prepared" && typeof rollover.id === "string") {
-      const workflow = await inspectWorkflow(ctx.cwd);
+      const workflow = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
       const expectedStateRevision = typeof rollover.expected_state_revision === "number" ? rollover.expected_state_revision : undefined;
       if (workflow.result.ok && workflow.snapshot && expectedStateRevision !== undefined && expectedStateRevision + 1 === rolloverState.revision) {
         pendingRollover = { snapshot: workflow.snapshot, preparedRevision: rolloverState.revision, rolloverId: rollover.id };
@@ -1373,8 +1389,13 @@ export default function devflowCore(pi: ExtensionAPI) {
       const consumed = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/session_rollover.rb", [
         "consume", "--write", "--json", "--expected-revision", String(rolloverState.revision), "--target-session-id", currentSessionId,
       ]);
-      const after = await inspectWorkflow(ctx.cwd);
+      const after = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
       if (consumed.ok && after.result.ok && after.snapshot) {
+        if (after.snapshot.action === "blocked") {
+          setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "启动恢复校验失败" });
+          ctx.ui.notify(`会话已恢复，但工作流校验失败，未启动 AI：${String(after.snapshot.reason ?? "state validation failed")}`, "error");
+          return;
+        }
         setControlState(ctx, executingState("恢复已认领的干净会话"));
         await triggerWorkflow(after.snapshot, "approval");
       } else if (!consumed.ok) {
@@ -1421,8 +1442,14 @@ export default function devflowCore(pi: ExtensionAPI) {
     pendingRollover = undefined;
     activeContract = undefined;
     contractAgentCalls = 0;
+    const next = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
+    if (!next.result.ok || !next.snapshot || next.snapshot.action === "blocked") {
+      setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "启动恢复校验失败" });
+      ctx.ui.notify(`会话已切换，但工作流校验失败，未启动 AI：${String(next.snapshot?.reason ?? next.result.stderr ?? next.result.stdout ?? "state validation failed")}`, "error");
+      return;
+    }
     setControlState(ctx, executingState("在干净会话中执行下一工作流步骤"));
-    await triggerWorkflow(pending.snapshot, "approval");
+    await triggerWorkflow(next.snapshot, "approval");
   });
 
   pi.on("before_agent_start", async event => ({
@@ -1444,7 +1471,7 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (controlState.intent === "requirement-draft" && controlState.phase === "planning") {
       const requirementDraft = event.text.trim();
       if (!requirementDraft) return { handled: true };
-      const inspected = await inspectWorkflow(ctx.cwd);
+      const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
       if (!inspected.result.ok || !inspected.snapshot) {
         ctx.ui.notify(`需求分诊启动失败：${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
         return { handled: true };
@@ -1468,13 +1495,37 @@ export default function devflowCore(pi: ExtensionAPI) {
         return { handled: true };
       }
     }
+    // A step transition can succeed before the runtime manages to prepare the
+    // fresh-session handoff. Keep approval useful in this recovery state, but
+    // retry only the handoff; never repeat the already-persisted transition.
+    if (controlState.phase === "blocked" && controlState.label === "会话轮换准备失败" && controlAction === "approve") {
+      const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
+      if (!inspected.result.ok || !inspected.snapshot) {
+        ctx.ui.notify(`会话交接重试失败：${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
+        return { handled: true };
+      }
+      if (inspected.snapshot.action === "workflow_complete") {
+        setControlState(ctx, initialControlState());
+        ctx.ui.notify("工作流已完成。", "info");
+        return { handled: true };
+      }
+      setControlState(ctx, waitingUserState("正在重试干净会话交接"));
+      try {
+        await requestControlledRollover(ctx, inspected.snapshot);
+        ctx.ui.notify("已重新登记会话交接；当前回合结束后将自动切换到下一节点。", "info");
+      } catch (error) {
+        setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "会话轮换准备失败" });
+        ctx.ui.notify(`会话交接仍未完成：${String(error)}`, "error");
+      }
+      return { handled: true };
+    }
     if (controlState.phase === "awaiting-approval" || controlState.phase === "waiting-user") {
       if (controlAction === "reject") {
         ctx.ui.notify("已保留当前步骤和产物。请直接说明需要修改的内容；未执行任何推进。", "info");
         return { handled: true };
       }
       if (controlAction === "approve") {
-        const inspected = await inspectWorkflow(ctx.cwd);
+        const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
         if (!inspected.result.ok || !inspected.snapshot) {
           ctx.ui.notify(`审批处理失败：${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
           return { handled: true };
@@ -1499,7 +1550,7 @@ export default function devflowCore(pi: ExtensionAPI) {
           ctx.ui.notify(`未推进：${result.stderr || result.stdout}`, "error");
           return { handled: true };
         }
-        const after = await inspectWorkflow(ctx.cwd);
+        const after = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
         activeContract = undefined;
         contractAgentCalls = 0;
         if (!after.result.ok || !after.snapshot || after.snapshot.action === "workflow_complete") {
@@ -2489,7 +2540,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         }
         args.push("--checkpoint-decision", params.decision);
       } else if (params.action === "cancel-feature") {
-        const inspected = await inspectWorkflow(ctx.cwd);
+        const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
         const snapshot = inspected.snapshot;
         const feature = typeof snapshot?.current_feature === "string" ? snapshot.current_feature : "当前需求";
         const revision = typeof snapshot?.revision === "number" ? snapshot.revision : undefined;
@@ -2617,7 +2668,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         return;
       }
       if (trimmed === "explain-state") {
-        const inspected = await inspectWorkflow(ctx.cwd);
+        const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
         ctx.ui.notify(
           inspected.result.ok ? explainWorkflowSnapshot(inspected.snapshot) : `状态读取失败：${inspected.result.stderr || inspected.result.stdout}`,
           inspected.result.ok ? "info" : "error",
@@ -2626,7 +2677,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         return;
       }
       if (trimmed === "recover") {
-        const inspected = await inspectWorkflow(ctx.cwd);
+        const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
         const plan = inspected.snapshot?.recovery_plan as Record<string, unknown> | undefined;
         const revision = plan?.expected_revision;
         if (!inspected.result.ok || !plan || plan.classification !== "safe_repairable" || typeof revision !== "number") {
@@ -2665,7 +2716,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         return;
       }
       if (trimmed === "abandon" || trimmed.startsWith("abandon ") || trimmed === "cancel" || trimmed.startsWith("cancel ")) {
-        const inspected = await inspectWorkflow(ctx.cwd);
+        const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
         const snapshot = inspected.snapshot;
         const revision = typeof snapshot?.revision === "number" ? snapshot.revision : undefined;
         const feature = typeof snapshot?.current_feature === "string" ? snapshot.current_feature : undefined;
@@ -2734,7 +2785,7 @@ export default function devflowCore(pi: ExtensionAPI) {
           ctx.ui.notify(formatDoctorReport(report).slice(0, 10000), "error");
           return;
         }
-        const inspected = await inspectWorkflow(ctx.cwd);
+        const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
         if (!inspected.result.ok || !inspected.snapshot) {
           ctx.ui.notify(
             `Devflow resume failed: ${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`,

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

@@ -98,8 +98,22 @@ result = catch(:transition_done) do
         result = fail_result("handoff_integrity_failure", "rollover" => rollover)
         throw :transition_done, result
       end
-      result = fail_result("rollover_in_progress", "rollover" => rollover)
-      throw :transition_done, result
+      if expected_state_revision.is_a?(Integer) && expected_state_revision < revision - 1
+        # The state has moved beyond the revision captured by this prepared
+        # handoff. It is an orphan from an interrupted/retried runtime turn,
+        # not an active lock. Verify its immutable evidence, preserve the
+        # handoff file on disk, and replace the STATE pointer with a handoff
+        # for the current revision.
+        existing_path, = DevflowControlIO.resolve_control_path(root, rollover["handoff_path"], :handoff)
+        unless File.exist?(existing_path) && Digest::SHA256.hexdigest(File.binread(existing_path)) == rollover["handoff_sha256"]
+          result = fail_result("handoff_integrity_failure", "rollover" => rollover)
+          throw :transition_done, result
+        end
+        rollover = nil
+      else
+        result = fail_result("rollover_in_progress", "rollover" => rollover)
+        throw :transition_done, result
+      end
     elsif rollover && rollover["status"] == "claimed"
       result = fail_result("rollover_in_progress", "rollover" => rollover)
       throw :transition_done, result

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

@@ -132,7 +132,7 @@ module WorkflowStateValidator
       return
     end
     status = rollover["status"]
-    unless %w[prepared claimed consumed failed].include?(status)
+unless %w[prepared claimed consumed superseded failed].include?(status)
       issues << issue("error", "invalid_rollover_status", "STATE.rollover.status is invalid", status: status)
       return
     end

package/src/constants.ts

@@ -1,5 +1,5 @@
 export const PRODUCT_NAME = "Devflow Pi";
-export const PRODUCT_VERSION = "0.1.36";
+export const PRODUCT_VERSION = "0.1.38";
 export const PROJECT_SCHEMA_VERSION = 1;
 export const OMP_RUNTIME_VERSION = "17.2.7";