@guanlin4924/devflow-pi 0.1.53 → 0.1.55

package/package.json

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

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

@@ -1361,6 +1361,31 @@ export default function devflowCore(pi: ExtensionAPI) {
     return stateRevision === contract.stateRevision && graphRevision === contract.graphRevision;
   }
 
+  // A successful graph mutation is already constrained by the active contract's
+  // allowed kinds and the graph's compare-and-swap revision. Re-freeze the
+  // Core-derived contract at that new revision so the next candidate remains in
+  // the same approved step instead of being rejected as stale.
+  async function rebaseActiveContractAfterGraphWrite(ctx: { cwd: string }, feature: string, graphRevision?: number): Promise<string | undefined> {
+    const previous = activeContract;
+    if (!previous || previous.feature !== feature) return undefined;
+    const written = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/execution_contract.rb", [
+      "create", "--feature", previous.feature, "--step", previous.step, "--write", "--json",
+      ...(previous.stateRevision === undefined ? [] : ["--expected-state-revision", String(previous.stateRevision)]),
+      ...(graphRevision === undefined ? [] : ["--expected-graph-revision", String(graphRevision)]),
+    ]);
+    const payload = parseJsonResult(written);
+    const refreshed = payload?.contract && typeof payload.contract === "object"
+      ? contractFromRecord(payload.contract as Record<string, unknown>)
+      : null;
+    if (!controlPlaneSucceeded(written) || !refreshed) {
+      return written.stderr || written.stdout || "Core could not refresh the execution contract after graph write.";
+    }
+    refreshed.contractPath = typeof payload?.path === "string" ? payload.path : undefined;
+    activeContract = refreshed;
+    contractAgentCalls = 0;
+    return undefined;
+  }
+
   async function restoreActiveContract(cwd: string): Promise<ActiveExecutionContract | undefined> {
     try {
       const state = parseJsonResult(await runRuby(cwd, "workflow-orchestrator/scripts/inspect_state.rb", ["--json"]));
@@ -2975,10 +3000,17 @@ export default function devflowCore(pi: ExtensionAPI) {
           args.push("--confirmed-interactively");
         }
       }
-      return renderResult(
-        await runRuby(ctx.cwd, "workflow-orchestrator/scripts/requirement_graph.rb", args),
-        { action: params.action, feature: params.feature },
-      );
+      const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/requirement_graph.rb", args);
+      if (graphWrite && controlPlaneSucceeded(result)) {
+        const revision = parseJsonResult(result)?.revision;
+        const rebaseError = await rebaseActiveContractAfterGraphWrite(
+          ctx,
+          params.feature,
+          typeof revision === "number" ? revision : undefined,
+        );
+        if (rebaseError) ctx.ui.notify(`图谱候选已写入，但执行合同未能刷新；后续写入将保持阻塞：${rebaseError}`, "error");
+      }
+      return renderResult(result, { action: params.action, feature: params.feature });
     },
   });
 

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

@@ -11,6 +11,7 @@ require_relative "control_io"
 require_relative "requirement_graph"
 
 POLICY = {
+  "domain-modeling" => { "checkers" => %w[requirement-graph-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[term object behavior rule boundary] },
   "requirement-baseline" => { "checkers" => %w[requirement-graph-check business-closure-check slice-independence-check acceptance-coverage-check change-impact-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[requirement rule boundary slice acceptance] },
   "api-contract" => { "checkers" => %w[requirement-graph-check contract-coverage-check api-test-schema-check change-impact-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[api] },
   "architecture-feasibility" => { "checkers" => %w[requirement-graph-check change-impact-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[workload_shape workload_constraint decision risk metric read_model] },

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/src/constants.ts

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