@guanlin4924/devflow-pi 0.1.56 → 0.1.59

package/package.json

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

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

@@ -3722,6 +3722,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         "project-context-validate",
         "orchestrator-manage-lessons",
         "orchestrator-update-triage",
+        "wireframe-validate",
       ]),
       args: z.array(z.string()).default([]),
     }),
@@ -3732,6 +3733,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         "project-context-validate": ["python3", "workflow-project-context/scripts/validate_initialization.py"],
         "orchestrator-manage-lessons": ["ruby", "workflow-orchestrator/scripts/manage_lessons.rb"],
         "orchestrator-update-triage": ["ruby", "workflow-orchestrator/scripts/update_triage_route.rb"],
+        "wireframe-validate": ["python3", "workflow-orchestrator/scripts/wireframe_validate.py"],
       };
       const [runtime, relativeScript] = scripts[params.script];
       const result = await runProcess(

package/plugins/devflow-core/skills/wireframe-proposal/SKILL.md

@@ -11,3 +11,11 @@ Read the controlled requirement baseline and the wireframe schema/registry. Prod
 - .planning/features/{feature}/questions.yaml
 
 Use only registered element types and screen-level requirement_refs. Keep IDs stable during revision. Do not add API fields, coordinates, CSS, nested children, or approval fields. Emit valid YAML only and never claim that the proposal is validated or approved. The validator and Core decide legality, fingerprints, and approval.
+
+The proposal file is strict. Its only top-level keys are `schema_version`, `feature`, and `screens`. Each screen must contain `id`, `title`, `requirement_refs`, `elements`, and `states: [default]`; optional screen keys are only `presentation`, `platforms`, and `actions`.
+
+Allowed element types are only `page_header`, `filter_bar`, `table`, `card_list`, `bottom_navigation`, `tabs`, `input`, `select`, `button`, and `icon_button`. Do not emit `text`, `alert`, `modal`, `empty_state`, or `description_list`. Put explanatory text in supported `title`, `label`, or `meta` fields. `table.columns` must be objects shaped as `{id, label}`, and all nested item/field IDs must be stable IDs.
+
+The questions file is also strict. Its only top-level keys are `schema_version`, `feature`, and `questions`; do not add `step`, `notes`, or other metadata. Each question must contain `id`, `text`, `kind`, and `status`, with optional `target` and `answer`.
+
+Before finishing, compare both files against `skill://workflow-orchestrator/contracts/proposal.schema.yaml` and `skill://workflow-orchestrator/contracts/questions.schema.yaml`. Do not invent legacy fields such as `name`, `route_hint`, `proposal_id`, `source_refs`, `principles`, or `flows`.

package/plugins/devflow-core/skills/wireframe-validate/SKILL.md

@@ -5,4 +5,20 @@ description: Run deterministic validation for a wireframe proposal and build can
 
 # Wireframe Validate
 
-Call the workflow-orchestrator wireframe_validate.py script with the current proposal, traceability JSON, and questions file. Preserve its structured verdict: allow, await_user, or block_unsafe. Do not edit proposal or questions, repair unknown fields, write approval, or modify workflow state.
+Run the bundled validator through Core's `devflow_skill_script` tool:
+
+```text
+devflow_skill_script(
+  script="wireframe-validate",
+  args=[
+    "--proposal", ".planning/features/<feature>/proposal.yaml",
+    "--traceability", ".planning/requirements/<feature>/traceability.json",
+    "--questions", ".planning/features/<feature>/questions.yaml",
+    "--canonical-out", ".planning/features/<feature>/canonical.json"
+  ]
+)
+```
+
+The bundled script is `plugins/devflow-core/skills/workflow-orchestrator/scripts/wireframe_validate.py`.
+Do not read `skill://wireframe-validate/scripts/wireframe_validate.py`; that path does not exist.
+Preserve its structured verdict: allow, await_user, or block_unsafe. Do not edit proposal or questions, repair unknown fields, write approval, or modify workflow state.

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/wireframe_validate.py

@@ -55,6 +55,37 @@ def issue(errors: list[dict[str, str]], code: str, path: str, message: str) -> N
     errors.append({"code": code, "path": path, "message": message})
 
 
+def traceability_refs(traceability: Any) -> set[str]:
+    """Return graph-backed refs from both legacy and Core traceability views."""
+    if not isinstance(traceability, dict):
+        return set()
+    requirements = traceability.get("requirements")
+    if isinstance(requirements, list):
+        return {
+            item.get("id")
+            for item in requirements
+            if isinstance(item, dict)
+            and isinstance(item.get("id"), str)
+            and item.get("status") in {"confirmed", "approved"}
+            and item.get("scope", "in") == "in"
+        }
+    nodes = traceability.get("nodes")
+    if not isinstance(nodes, list):
+        return set()
+    allowed_kinds = {"requirement", "rule", "behavior", "boundary"}
+    refs: set[str] = set()
+    for node in nodes:
+        if not isinstance(node, dict) or node.get("kind") not in allowed_kinds:
+            continue
+        node_id = node.get("id")
+        status = node.get("status")
+        data = node.get("data") if isinstance(node.get("data"), dict) else {}
+        scope = data.get("scope", node.get("scope", "in"))
+        if isinstance(node_id, str) and status in {"candidate", "confirmed", "approved"} and scope != "out":
+            refs.add(node_id)
+    return refs
+
+
 def unknown_keys(value: Any, allowed: set[str], path: str, errors: list[dict[str, str]]) -> None:
     if not isinstance(value, dict):
         return
@@ -234,9 +265,7 @@ def validate(data: Any, traceability: Any, schema: dict[str, Any], business_mode
     if not isinstance(screens, list) or not screens:
         issue(errors, "WIREFRAME_SCREENS_MISSING", "screens", "must be a non-empty array")
         return errors, None
-    reqs = set()
-    if isinstance(traceability, dict):
-        reqs = {r.get("id") for r in traceability.get("requirements", []) if isinstance(r, dict) and r.get("status") in {"confirmed", "approved"} and r.get("scope", "in") == "in"}
+    reqs = traceability_refs(traceability)
     screen_ids: set[str] = set()
     canonical_screens: list[dict[str, Any]] = []
     for i, screen in enumerate(screens):

package/src/constants.ts

@@ -1,5 +1,5 @@
 export const PRODUCT_NAME = "Devflow Pi";
-export const PRODUCT_VERSION = "0.1.56";
+export const PRODUCT_VERSION = "0.1.59";
 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.
   }
 }