@guanlin4924/devflow-pi 0.1.55 → 0.1.57

package/package.json

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

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

@@ -1017,11 +1017,20 @@ function normalizedProjectPath(raw: unknown, cwd: string): string | null {
   return relative.replace(/^\.\//, "");
 }
 
-function inputPaths(input: unknown, cwd: string): string[] {
-  if (!input || typeof input !== "object") return [];
-  const record = input as Record<string, unknown>;
-  const values = [record.file_path, record.filePath, record.path, record.target];
-  if (Array.isArray(record.paths)) values.push(...record.paths);
+function encodedEditPaths(value: unknown): string[] {
+  if (typeof value !== "string") return [];
+  const hashline = /^\[([^#\r\n]+)(?:#[0-9a-fA-F]{4})?\]/m.exec(value)?.[1];
+  const patchPaths = [...value.matchAll(/^\*\*\* (?:Add|Update|Delete) File:\s*(.+)$/gm)]
+    .map(match => match[1].trim());
+  return [...(hashline ? [hashline] : []), ...patchPaths];
+}
+
+export function inputPaths(input: unknown, cwd: string): string[] {
+  const record = input && typeof input === "object" ? input as Record<string, unknown> : undefined;
+  const values = record
+    ? [record.file_path, record.filePath, record.path, record.target, ...encodedEditPaths(record.input), ...encodedEditPaths(record.patch)]
+    : encodedEditPaths(input);
+  if (record && Array.isArray(record.paths)) values.push(...record.paths);
   return values
     .map(value => normalizedProjectPath(value, cwd))
     .filter((value): value is string => value !== null);

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

@@ -114,7 +114,7 @@ After each step completes, verify the step's gate before advancing:
 | requirement-triage | triage.meta.json `status` is `routed` AND `route` is `ready_for_wayfinder` | Reject advance to requirement-wayfinder |
 | requirement-wayfinder | 决策地图.meta.json `status=ready_for_baseline` AND `ready_for_baseline=true` | Reject advance to domain-modeling |
 | domain-modeling | 领域模型记录及 meta 存在且标识当前功能 | Reject advance to requirement-feasibility-review |
-| requirement-feasibility-review | 可实现性审查.meta.json `status=ready_for_baseline`、`baseline_gate=pass`、`gap_count=0` 且无 critical finding | Reject advance to requirement-baseline |
+| requirement-feasibility-review | 可实现性审查.meta.json `status=ready_for_baseline`、`baseline_gate=pass`、`blocking_gap_count=0` 且无 critical finding；`gap_count` 记录全部发现数 | Reject advance to requirement-baseline |
 | requirement-baseline | baseline.md review conclusion is "通过" AND baseline.meta.json `review_status` / `traceability_status` are `passed` AND blocking counters are all 0 | Reject advance to api-contract |
 | api-contract | api-contract.meta.json `review_status` / `traceability_status` are `passed` AND `pending_contract_count` is 0 | Reject advance to dual tracks |
 | architecture-feasibility | Core-derived `architecture-brief.md` / meta exist. If `assessment_level=full`, require `assessment_status=ready` and `comparison_status=confirmed`; a lightweight incomplete result may proceed only as an explicitly unresolved downstream input. | Reject advance to dual tracks for an incomplete full assessment |

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

@@ -619,8 +619,12 @@ unless %w[prepared claimed consumed superseded failed].include?(status)
   def validate_requirement_feasibility_review_gate(issues, step, data)
     return unless step["id"] == "requirement-feasibility-review"
 
+    # gap_count is the review's full finding inventory. Older artifacts did not
+    # distinguish accepted downstream work from baseline-blocking gaps, so they
+    # retain the conservative interpretation until regenerated.
+    blocking_gap_count = data.key?("blocking_gap_count") ? data["blocking_gap_count"].to_i : data["gap_count"].to_i
     pass = data["status"] == "ready_for_baseline" && data["baseline_gate"] == "pass"
-    pass &&= data["gap_count"].to_i.zero?
+    pass &&= blocking_gap_count.zero?
     pass &&= Array(data["critical_finding_ids"]).empty?
     return if pass
 
@@ -632,6 +636,7 @@ unless %w[prepared claimed consumed superseded failed].include?(status)
       status: data["status"],
       baseline_gate: data["baseline_gate"],
       gap_count: data["gap_count"],
+      blocking_gap_count: blocking_gap_count,
       critical_finding_ids: data["critical_finding_ids"]
     )
   end

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

@@ -478,6 +478,7 @@ steps:
         claim_count: { type: integer, required: true }
         proven_count: { type: integer, required: true }
         gap_count: { type: integer, required: true }
+        blocking_gap_count: { type: integer, required: true }
         critical_finding_ids: { type: array, required: true }
         next_action: { type: string, required: true }
 

package/plugins/devflow-requirements/skills/requirement-feasibility-review/SKILL.md

@@ -44,11 +44,17 @@ Use this minimum metadata shape:
   "claim_count": 0,
   "proven_count": 0,
   "gap_count": 0,
+  "blocking_gap_count": 0,
   "critical_finding_ids": [],
   "next_action": ""
 }
 ```
 
+`gap_count` counts every registered finding. `blocking_gap_count` counts only
+findings that prevent requirement baseline. A pass requires
+`blocking_gap_count: 0`; accepted non-blocking findings must stay in the
+review's register with an owner and re-entry condition.
+
 ## Workflow
 
 ### 1. Atomize The Source Rules Before Summarizing

package/src/constants.ts

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

package/src/runtime.ts

@@ -278,6 +278,29 @@ export async function runInteractiveRuntime(project: ProjectContext, options: Ru
       void consumeControlledRollover();
     }, delay);
   };
+  const waitForControlledRollover = async (): Promise<void> => {
+    const requestPath = path.join(project.root, ".planning", "rollover-request.json");
+    let requestObserved = false;
+    // The input hook may finish its async state transition just after
+    // submitInteractiveInput resolves. Wait briefly for that durable request
+    // so approval starts the fresh session without requiring another input.
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+      try {
+        await readFile(requestPath, "utf8");
+        requestObserved = true;
+      } catch {
+        if (requestObserved) return;
+      }
+      await consumeControlledRollover();
+      try {
+        await readFile(requestPath, "utf8");
+      } catch {
+        if (requestObserved) return;
+      }
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    scheduleControlledRolloverRetry();
+  };
   // A control-plane request may be created by an extension input handler that
   // marks the message handled, so it is not guaranteed to pass through the
   // normal submitInteractiveInput return path. Keep a small runtime-owned
@@ -298,11 +321,16 @@ export async function runInteractiveRuntime(project: ProjectContext, options: Ru
     } finally {
       interactiveSubmissionInFlight = false;
     }
-    await consumeControlledRollover();
+    // Only an explicit approval can create a user-driven rollover after this
+    // input. Ordinary chat messages must return to the prompt immediately.
+    if (/^(?:批准|确认|同意|通过)(?:\s*(?:(?:full|完整|全量)?\s*初始化|执行|完成|继续|推进|当前(?:方案|步骤|计划)))?[。！!]?$/i.test(input.trim())) {
+      await waitForControlledRollover();
+    } else {
+      await consumeControlledRollover();
+      scheduleControlledRolloverRetry();
+    }
     // The submitted turn may create a durable rollover request after the
-    // immediate check above returns. Poll once while the UI is waiting for the
-    // next user input so a successful step does not require a dummy message to
-    // trigger the fresh-session handoff.
-    scheduleControlledRolloverRetry();
+    // input hook settles; the bounded wait above handles the normal path and
+    // the poller remains as a recovery path for a slow or interrupted hook.
   }
 }