@guanlin4924/devflow-pi 0.1.54 → 0.1.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanlin4924/devflow-pi",
-  "version": "0.1.54",
+  "version": "0.1.56",
   "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/requirement_coverage.rb

@@ -92,10 +92,16 @@ module RequirementCoverage
       end
     end
 
+    disposition_ids = {}
     disposition_by_id = {}
     Array(coverage["units"]).each do |entry|
+      unless entry.is_a?(Hash)
+        add(errors, "COVERAGE_UNIT_SCHEMA_INVALID", "coverage unit must be a mapping")
+        next
+      end
       unit_id = entry["unit_id"].to_s
-      duplicate(errors, disposition_by_id, unit_id, "DUPLICATE_COVERAGE")
+      duplicate(errors, disposition_ids, unit_id, "DUPLICATE_COVERAGE")
+      disposition_by_id[unit_id] ||= entry
       add(errors, "UNIT_REF_NOT_FOUND", "coverage references an unknown unit", unit_id: unit_id) unless unit_by_id.key?(unit_id)
       disposition = entry["disposition"]
       unless disposition.is_a?(Hash) && %w[active deferred out_of_scope merged].include?(disposition["kind"].to_s)
@@ -138,17 +144,29 @@ module RequirementCoverage
     add(errors, "SOURCE_UNITS_SCHEMA_INVALID", "source_units schema_version must be 1") unless source["schema_version"].to_i == 1
     add(errors, "SOURCE_UNITS_NOT_CORE_GENERATED", "source_units must be produced by Core") unless source["produced_by"].to_s == "core.source_unitizer/v1"
     add(errors, "SOURCE_UNITS_SCHEMA_INVALID", "source_document_fingerprint is required") if source["source_document_fingerprint"].to_s.empty?
-    add(errors, "SOURCE_UNITS_SCHEMA_INVALID", "units must be an array") unless source["units"].is_a?(Array)
+    unless source["units"].is_a?(Array)
+      add(errors, "SOURCE_UNITS_SCHEMA_INVALID", "units must be an array")
+      return
+    end
     Array(source["units"]).each do |unit|
+      unless unit.is_a?(Hash)
+        add(errors, "SOURCE_UNIT_SCHEMA_INVALID", "source unit must be a mapping")
+        next
+      end
       add(errors, "UNIT_SCHEMA_INVALID", "stable_unit_id is required") if unit["stable_unit_id"].to_s.empty?
       add(errors, "SOURCE_UNIT_REUSED_STALE", "unit source fingerprint mismatch", unit_id: unit["stable_unit_id"]) unless unit["source_document_fingerprint"].to_s == source["source_document_fingerprint"].to_s
       add(errors, "EXCERPT_MODIFIED", "excerpt fingerprint mismatch", unit_id: unit["stable_unit_id"]) if unit["excerpt_fingerprint"] && sha(unit["excerpt"]) != unit["excerpt_fingerprint"].to_s
+      unless unit["required_assertions"].is_a?(Array) && unit["required_assertions"].all? { |assertion| assertion.is_a?(Hash) }
+        add(errors, "SOURCE_UNIT_SCHEMA_INVALID", "required_assertions must be an array of mappings", unit_id: unit["stable_unit_id"])
+      end
     end
   end
 
   def validate_coverage(coverage, errors)
     add(errors, "COVERAGE_SCHEMA_INVALID", "coverage schema_version must be 1") unless coverage["schema_version"].to_i == 1
     %w[claims units].each { |key| add(errors, "COVERAGE_SCHEMA_INVALID", "#{key} must be an array") unless coverage[key].is_a?(Array) }
+    Array(coverage["claims"]).each { |claim| add(errors, "CLAIM_SCHEMA_INVALID", "claim must be a mapping") unless claim.is_a?(Hash) }
+    Array(coverage["units"]).each { |unit| add(errors, "COVERAGE_UNIT_SCHEMA_INVALID", "coverage unit must be a mapping") unless unit.is_a?(Hash) }
   end
 
   def compare(assertion, inherited)

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.54";
+export const PRODUCT_VERSION = "0.1.56";
 export const PROJECT_SCHEMA_VERSION = 1;
 export const OMP_RUNTIME_VERSION = "17.2.7";