@guanlin4924/devflow-pi 0.1.93 → 0.1.95

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

@@ -109,7 +109,7 @@ def validate_authority(root: Path, feature: str, expectations: list) -> tuple[li
                 issues.append(f"{item['id']}: authority_ref must identify a Core graph node and revision")
                 continue
             node_id, revision = ref[len("core-graph:"):].rsplit("@", 1)
-            graph_path = f".planning/requirements/{feature}/governance.json"
+            graph_path = f".devflow/planning/requirements/{feature}/governance.json"
             graph_file = safe_file(root, graph_path)
             authority = read_json(graph_file)
             node = next((n for n in authority.get("nodes", []) if isinstance(n, dict) and n.get("id") == node_id), None)
@@ -132,7 +132,7 @@ def validate_authority(root: Path, feature: str, expectations: list) -> tuple[li
 
 
 def db_open(root: Path) -> sqlite3.Connection:
-    planning = root / ".planning"
+    planning = root / ".devflow/planning"
     if planning.is_symlink():
         raise ValueError("unsafe planning directory")
     directory = planning / "review-runs"
@@ -174,7 +174,7 @@ def response(status: str, chain_id: str | None, round_no: int, **details: Any) -
 
 def locate_index(root: Path, accepted: list, target_paths: list[str], questions: list[str]) -> dict:
     """Ask the index for bounded leads, never for authoritative conclusions."""
-    index = root / ".planning" / "code-index"
+    index = root / ".devflow/planning" / "code-index"
     script = Path(__file__).resolve().parents[3].parent / "devflow-intel" / "skills" / "workflow-code-index" / "scripts" / "code_index.py"
     if not index.exists() or not script.exists():
         return {"status": "unavailable", "reason": "No local code-index snapshot; source evidence is independent"}
@@ -218,7 +218,7 @@ def verify_core_result(root: Path, feature: str, evidence: Any, expected_status:
     """Accept only a Core-owned TC result bound to the feature and frozen suite."""
     if not isinstance(evidence, dict):
         return False, "missing Core acceptance-test result reference"
-    relative = f".planning/test-runs/{feature}/acceptance-results.json"
+    relative = f".devflow/planning/test-runs/{feature}/acceptance-results.json"
     if evidence.get("path") != relative or not isinstance(evidence.get("tc_id"), str):
         return False, "result must reference a Core acceptance TC for this feature"
     try:
@@ -226,7 +226,7 @@ def verify_core_result(root: Path, feature: str, evidence: Any, expected_status:
         if digest(result_file.read_bytes()) != evidence.get("sha256"):
             return False, "acceptance result hash mismatch"
         payload = read_json(result_file)
-        suite = read_json(safe_file(root, f".planning/requirements/{feature}/tests.json"))
+        suite = read_json(safe_file(root, f".devflow/planning/requirements/{feature}/tests.json"))
         if payload.get("origin") != "core_acceptance_test_runner" or payload.get("feature") != feature:
             return False, "not a Core acceptance-test run"
         if payload.get("test_suite") != {"graph_revision": suite.get("graph_revision"), "fingerprint": suite.get("view_meta", {}).get("fingerprint")}:
@@ -252,7 +252,7 @@ def verify_core_result(root: Path, feature: str, evidence: Any, expected_status:
 def verify_core_impact(root: Path, feature: str, evidence: dict, impact: str, trigger: str) -> tuple[bool, str]:
     """A failed TC alone does not establish the reviewer's causal/impact label."""
     try:
-        suite = read_json(safe_file(root, f".planning/requirements/{feature}/tests.json"))
+        suite = read_json(safe_file(root, f".devflow/planning/requirements/{feature}/tests.json"))
         node = next((n for n in suite.get("nodes", []) if isinstance(n, dict) and n.get("id") == evidence.get("tc_id")), None)
         data = node.get("data", {}) if node else {}
         if data.get("review_impact") == impact and data.get("review_trigger") == trigger:
@@ -263,7 +263,7 @@ def verify_core_impact(root: Path, feature: str, evidence: dict, impact: str, tr
 
 
 def declared_change_paths(root: Path, feature: str) -> tuple[set[str], str, str]:
-    relative = f".planning/features/{feature}/变更清单.md"
+    relative = f".devflow/planning/features/{feature}/变更清单.md"
     source = safe_file(root, relative)
     declarations = re.findall(r"^\s*-\s*\*\*文件\*\*\s*[：:]\s*(.+)$", source.read_text(encoding="utf-8"), re.MULTILINE)
     paths = set()
@@ -295,7 +295,7 @@ def verify_coverage(root: Path, feature: str, required: list[str], coverage_evid
         if not valid:
             issues.append(f"{tag}: {reason}")
             continue
-        suite = read_json(safe_file(root, f".planning/requirements/{feature}/tests.json"))
+        suite = read_json(safe_file(root, f".devflow/planning/requirements/{feature}/tests.json"))
         node = next((n for n in suite.get("nodes", []) if isinstance(n, dict) and n.get("id") == ref["tc_id"]), None)
         types = {"scenario:normal": {"api", "page"}, "scenario:unauthorized": {"permission"}, "scenario:failure_rollback": {"resilience", "boundary"}, "scenario:compatibility": {"migration"}}
         data = node.get("data", {}) if node else {}
@@ -310,7 +310,7 @@ def verify_coverage(root: Path, feature: str, required: list[str], coverage_evid
 
 def suite_has_failures(root: Path, feature: str) -> bool:
     try:
-        payload = read_json(safe_file(root, f".planning/test-runs/{feature}/acceptance-results.json"))
+        payload = read_json(safe_file(root, f".devflow/planning/test-runs/{feature}/acceptance-results.json"))
         return any(isinstance(item, dict) and item.get("status") != "passed" for item in payload.get("results", []))
     except (OSError, ValueError, TypeError, json.JSONDecodeError):
         return True
@@ -322,13 +322,13 @@ def gate_status(root: Path, feature: str, contract_id: str | None = None) -> dic
     if not contract_id:
         return {"status": "human_confirmation", "reason": "Current Core review contract identity is required"}
     try:
-        contract = read_json(safe_file(root, f".planning/contracts/{feature}/{contract_id}.json"))
+        contract = read_json(safe_file(root, f".devflow/planning/contracts/{feature}/{contract_id}.json"))
         if contract.get("origin") != "core_execution_contract" or contract.get("step") != "code-review" or contract.get("feature") != feature or contract.get("contract_id") != contract_id:
             return {"status": "core_contract_conflict", "reason": "Review contract identity is not a frozen Core code-review contract"}
         sys.path.insert(0, str(Path(__file__).resolve().parent))
         from review_preflight import load_state
-        state = load_state(safe_file(root, ".planning/STATE.md"))
-        graph = read_json(safe_file(root, f".planning/requirements/{feature}/governance.json"))
+        state = load_state(safe_file(root, ".devflow/planning/STATE.md"))
+        graph = read_json(safe_file(root, f".devflow/planning/requirements/{feature}/governance.json"))
         workflow = safe_file(root, contract["workflow_path"])
         if (state.get("current_feature") != feature or state.get("current_step") != "code-review"
             or state.get("revision") != contract.get("state_revision")
@@ -337,7 +337,7 @@ def gate_status(root: Path, feature: str, contract_id: str | None = None) -> dic
             return {"status": "stale_evidence", "reason": "Review contract differs from current Core state, graph, or workflow"}
     except (OSError, ValueError, KeyError, TypeError, ImportError, json.JSONDecodeError) as exc:
         return {"status": "human_confirmation", "reason": f"Current Core review contract cannot be verified: {exc}"}
-    database = root / ".planning" / "review-runs" / "review-runs.sqlite"
+    database = root / ".devflow/planning" / "review-runs" / "review-runs.sqlite"
     if not database.is_file() or database.is_symlink():
         return {"status": "human_confirmation", "reason": "No Core review round exists"}
     db = sqlite3.connect(f"file:{database}?mode=ro", uri=True)
@@ -366,7 +366,7 @@ def gate_status(root: Path, feature: str, contract_id: str | None = None) -> dic
         index_generation = fixed.get("code_index_generation")
         if index_generation is not None:
             try:
-                snapshot = read_json(safe_file(root, ".planning/code-index/SNAPSHOT.json"))
+                snapshot = read_json(safe_file(root, ".devflow/planning/code-index/SNAPSHOT.json"))
                 if snapshot.get("generation") != index_generation:
                     return {"status": "stale_evidence", "reason": "Code-index generation changed after review", "chain_id": result.get("chain_id")}
             except (OSError, ValueError, json.JSONDecodeError):
@@ -415,11 +415,11 @@ def review_markdown(result: dict) -> str:
 
 def render_review(root: Path, feature: str, contract_id: str) -> dict:
     root = root.resolve(strict=True)
-    contract = read_json(safe_file(root, f".planning/contracts/{feature}/{contract_id}.json"))
+    contract = read_json(safe_file(root, f".devflow/planning/contracts/{feature}/{contract_id}.json"))
     path = next((item for item in contract.get("allowed_paths", []) if isinstance(item, str) and item.endswith("/REVIEW.md")), None)
     if not path:
         return {"status": "core_contract_conflict", "reason": "Core contract has no REVIEW.md output"}
-    database = root / ".planning/review-runs/review-runs.sqlite"
+    database = root / ".devflow/planning/review-runs/review-runs.sqlite"
     if not database.is_file():
         return {"status": "human_confirmation", "reason": "No Core review round exists"}
     db = sqlite3.connect(f"file:{database}?mode=ro", uri=True)
@@ -616,7 +616,7 @@ def run(root: Path, request: dict) -> dict:
                 db.commit()
                 return result
         if index_discovery.get("generation"):
-            current_snapshot = root / ".planning" / "code-index" / "SNAPSHOT.json"
+            current_snapshot = root / ".devflow/planning" / "code-index" / "SNAPSHOT.json"
             if not current_snapshot.exists() or read_json(current_snapshot).get("generation") != index_discovery["generation"]:
                 result = response("stale_evidence", chain_id, round_no, questions=["Code-index generation changed during review"])
                 db.execute("INSERT INTO events(chain_id,status,detail_json) VALUES(?,?,?)", (chain_id, result["status"], canonical(result)))
@@ -645,7 +645,7 @@ def run(root: Path, request: dict) -> dict:
                 db.commit()
                 return result
         status = "terminated_p0" if round_no == 3 and summary["P0"] else ("findings" if open_findings else "clean")
-        core_results = {rel: digest(safe_file(root, rel).read_bytes()) for rel in (f".planning/requirements/{target['feature']}/tests.json", f".planning/test-runs/{target['feature']}/acceptance-results.json")}
+        core_results = {rel: digest(safe_file(root, rel).read_bytes()) for rel in (f".devflow/planning/requirements/{target['feature']}/tests.json", f".devflow/planning/test-runs/{target['feature']}/acceptance-results.json")}
         result = response(status, chain_id, round_no, fixed_versions={"source": versions, "authority": accepted, "core_results": core_results, "change_plan": {"path": change_plan_path, "sha256": change_plan_hash, "declared_paths": sorted(declared_paths)}, "code_index_generation": index_discovery.get("generation")}, index_discovery=index_discovery, coverage={"covered": sorted(covered), "gaps": gaps, "index_gap": index_discovery.get("reason") if index_discovery["status"] != "located" else None}, findings=findings, risk_summary=summary, improvement_plan=[{"finding_id": f["finding_id"], "severity": f["severity"], "action": f["improvement"]} for f in sorted(open_findings, key=lambda x: x["severity"])], all_p0_resolved=summary["P0"] == 0, severity_source="independent_reviewer_core_evidence_bound", semantic_causality_verified=True, automatic_release_allowed=status == "clean", termination_scope="current_task_only" if status == "terminated_p0" else None, reviewer_task={key: binding[key] for key in ("agent", "feature", "contract_id", "task_call_id", "report_sha256")}, history=[{"round": r, "status": json.loads(raw)["status"]} for r, raw in db.execute("SELECT round,result_json FROM rounds WHERE chain_id=? ORDER BY round", (chain_id,))])
         db.execute("INSERT INTO reviewer_tasks(task_call_id,chain_id,round,report_sha256) VALUES(?,?,?,?)", (binding["task_call_id"], chain_id, round_no, binding["report_sha256"]))
         db.execute("INSERT INTO rounds(chain_id,round,result_json) VALUES(?,?,?)", (chain_id, round_no, canonical(result)))

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

@@ -14,8 +14,8 @@ require_relative "control_io"
 
 module RuntimeContextCollector
   SCHEMA_VERSION = 1
-  HISTORY_DIR = File.join(".context", "runtime-context", "revisions")
-  POINTER = File.join(".context", "runtime-context.json")
+  HISTORY_DIR = File.join(".devflow/context", "runtime-context", "revisions")
+  POINTER = File.join(".devflow/context", "runtime-context.json")
   EXTRACTORS = {
     "package.json" => :extract_package_json,
     "requirements.txt" => :extract_requirements_txt,
@@ -170,7 +170,7 @@ module RuntimeContextCollector
     history = File.join(root, HISTORY_DIR, "#{revision}.json")
     DevflowControlIO.atomic_create(history, JSON.pretty_generate(snapshot) + "\n")
     DevflowControlIO.atomic_write(File.join(root, POINTER), JSON.pretty_generate({ "current_revision" => revision, "path" => history.sub("#{root}/", "") }) + "\n")
-    DevflowControlIO.append_audit(File.join(root, ".context", "runtime-context", "audit.jsonl"), {
+    DevflowControlIO.append_audit(File.join(root, ".devflow/context", "runtime-context", "audit.jsonl"), {
       "event" => "snapshot_collected", "snapshot_revision" => revision,
       "repository_revision" => repository_revision, "coverage_status" => coverage_status
     })

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

@@ -69,7 +69,7 @@ def lease_expiry(seconds)
 end
 
 root = Dir.pwd
-state_path, = DevflowControlIO.resolve_control_path(root, ".planning/STATE.md", :state)
+state_path, = DevflowControlIO.resolve_control_path(root, ".devflow/planning/STATE.md", :state)
 result = catch(:transition_done) do
   lock = DevflowControlIO.acquire_project_lock(root)
   begin
@@ -129,7 +129,7 @@ result = catch(:transition_done) do
       throw :transition_done, result
     end
     rollover_id = "ROL-#{SecureRandom.uuid}"
-    relative_path = ".planning/handoffs/#{state.fetch("current_feature")}/#{rollover_id}.json"
+    relative_path = ".devflow/planning/handoffs/#{state.fetch("current_feature")}/#{rollover_id}.json"
     absolute_path, = DevflowControlIO.resolve_control_path(root, relative_path, :handoff)
     payload = {
       "schema_version" => 1,
@@ -144,9 +144,9 @@ result = catch(:transition_done) do
         "status" => state["status"], "completed_steps" => state["completed_steps"], "pending_steps" => state["pending_steps"]
       },
       "references" => {
-        "state_path" => ".planning/STATE.md",
+        "state_path" => ".devflow/planning/STATE.md",
         "workflow_path" => state["workflow_config"],
-        "artifact_registry" => ".planning/artifacts/index.yaml"
+        "artifact_registry" => ".devflow/planning/artifacts/index.yaml"
       }
     }
     serialized = JSON.generate(payload) + "\n"

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

@@ -17,9 +17,9 @@ require_relative "control_io"
 module StaticRuntimeContextCollector
   SCHEMA_VERSION = 2
   COLLECTOR_VERSION = "static-runtime-context-v2.1"
-  ROOT_DIR = File.join(".context", "static-runtime-context")
+  ROOT_DIR = File.join(".devflow/context", "static-runtime-context")
   HISTORY_DIR = File.join(ROOT_DIR, "revisions")
-  POINTER = ".context/static-runtime-context.json"
+  POINTER = ".devflow/context/static-runtime-context.json"
   AUDIT_PATH = File.join(ROOT_DIR, "audit.jsonl")
   MAX_COMPOSE_BYTES = 1_048_576
   EXCLUDED_ROOTS = %w[node_modules vendor dist build .git].freeze

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

@@ -11,7 +11,7 @@ require_relative "control_io"
 require_relative "phase_ownership"
 
 options = {
-  state: ".planning/STATE.md",
+  state: ".devflow/planning/STATE.md",
   workflow: nil,
   output: nil,
   write: false,
@@ -72,10 +72,10 @@ unless ownership["ok"]
   puts JSON.pretty_generate(ownership.merge("written" => false))
   exit 0
 end
-workflow_source = options[:workflow] || state["workflow_config"] || ".planning/workflows/#{state.fetch("current_flow")}.yaml"
+workflow_source = options[:workflow] || state["workflow_config"] || ".devflow/planning/workflows/#{state.fetch("current_flow")}.yaml"
 workflow_path, = DevflowControlIO.resolve_control_path(root, workflow_source, :workflow)
 workflow = load_yaml_file(workflow_path)
-registry_source = options[:output] || workflow.dig("artifact_registry", "source") || ".planning/artifacts/index.yaml"
+registry_source = options[:output] || workflow.dig("artifact_registry", "source") || ".devflow/planning/artifacts/index.yaml"
 existing_registry_path, registry_path = DevflowControlIO.resolve_control_path(root, registry_source, :registry)
 existing_by_path = {}
 if options[:preserve] && File.exist?(existing_registry_path)
@@ -112,7 +112,7 @@ end
 
 def questions_registry_entry(root, state, existing_by_path)
   feature = state.fetch("current_feature", "").to_s
-  path = ".planning/features/#{feature}/questions.yaml"
+  path = ".devflow/planning/features/#{feature}/questions.yaml"
   absolute, = DevflowControlIO.resolve_control_path(root, path, :artifact)
   exists = File.exist?(absolute)
   entry = {
@@ -180,7 +180,7 @@ artifacts = collect_outputs(workflow).map do |step, output|
   }.reject { |_, value| value.nil? || value == [] }
 end
 
-questions_path = ".planning/features/#{state.fetch("current_feature", "")}/questions.yaml"
+questions_path = ".devflow/planning/features/#{state.fetch("current_feature", "")}/questions.yaml"
 questions_entry = questions_registry_entry(root, state, existing_by_path)
 question_index = artifacts.index { |artifact| artifact["path"] == questions_path }
 if question_index

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

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""RFC 8785 JSON Canonicalization Scheme (JCS) and the single tc_sha256 implementation.
+
+tc_sha256 = lowercase hex SHA-256 of JCS(node.data).  Generators, validators and
+approval pins must call this module; the Runtime only echoes the value back.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import sys
+from typing import Any
+
+
+_ESCAPES = {'"': '\\"', "\\": "\\\\", "\b": "\\b", "\f": "\\f", "\n": "\\n", "\r": "\\r", "\t": "\\t"}
+
+
+def _string(value: str) -> str:
+    out = ['"']
+    for char in value:
+        if char in _ESCAPES:
+            out.append(_ESCAPES[char])
+        elif ord(char) < 0x20:
+            out.append(f"\\u{ord(char):04x}")
+        elif 0xD800 <= ord(char) <= 0xDFFF:
+            raise ValueError("lone surrogate cannot be canonicalized")
+        else:
+            out.append(char)
+    out.append('"')
+    return "".join(out)
+
+
+def _number(value: int | float) -> str:
+    """ECMAScript Number.prototype.toString for an IEEE-754 double (RFC 8785 §3.2.2.3)."""
+    if isinstance(value, int):
+        converted = float(value)
+        if int(converted) != value:
+            raise ValueError(f"integer {value} is not exactly representable as an IEEE-754 double")
+        value = converted
+    if math.isnan(value) or math.isinf(value):
+        raise ValueError("NaN and Infinity are not valid JSON numbers")
+    if value == 0:
+        return "0"
+    sign = "-" if value < 0 else ""
+    text = repr(abs(value))  # shortest round-trip digits
+    mantissa, _, exponent = text.partition("e")
+    integer, _, fraction = mantissa.partition(".")
+    raw = integer + fraction
+    leading = len(raw) - len(raw.lstrip("0"))
+    digits = raw.lstrip("0").rstrip("0")
+    point = len(integer) + int(exponent or 0) - leading  # value = 0.digits * 10**point
+    count = len(digits)
+    if count <= point <= 21:
+        body = digits + "0" * (point - count)
+    elif 0 < point <= 21:
+        body = digits[:point] + "." + digits[point:]
+    elif -6 < point <= 0:
+        body = "0." + "0" * (-point) + digits
+    else:
+        power = point - 1
+        suffix = f"e{'+' if power >= 0 else '-'}{abs(power)}"
+        body = (digits if count == 1 else digits[0] + "." + digits[1:]) + suffix
+    return sign + body
+
+
+def _utf16_key(key: str) -> list[int]:
+    encoded = key.encode("utf-16-be")
+    return [int.from_bytes(encoded[index:index + 2], "big") for index in range(0, len(encoded), 2)]
+
+
+def _serialize(value: Any, out: list[str]) -> None:
+    if value is None:
+        out.append("null")
+    elif value is True:
+        out.append("true")
+    elif value is False:
+        out.append("false")
+    elif isinstance(value, (int, float)):
+        out.append(_number(value))
+    elif isinstance(value, str):
+        out.append(_string(value))
+    elif isinstance(value, (list, tuple)):
+        out.append("[")
+        for index, item in enumerate(value):
+            if index:
+                out.append(",")
+            _serialize(item, out)
+        out.append("]")
+    elif isinstance(value, dict):
+        if not all(isinstance(key, str) for key in value):
+            raise ValueError("object keys must be strings")
+        out.append("{")
+        for index, key in enumerate(sorted(value, key=_utf16_key)):
+            if index:
+                out.append(",")
+            out.append(_string(key))
+            out.append(":")
+            _serialize(value[key], out)
+        out.append("}")
+    else:
+        raise ValueError(f"unsupported JSON value type: {type(value).__name__}")
+
+
+def canonicalize(value: Any) -> bytes:
+    out: list[str] = []
+    _serialize(value, out)
+    return "".join(out).encode("utf-8")
+
+
+def jcs_sha256(value: Any) -> str:
+    return hashlib.sha256(canonicalize(value)).hexdigest()
+
+
+def tc_sha256(data: Any) -> str:
+    if not isinstance(data, dict):
+        raise ValueError("TC data must be an object")
+    return jcs_sha256(data)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Print tc_sha256 (JCS SHA-256) of a JSON document read from a file or stdin.")
+    parser.add_argument("path", nargs="?")
+    args = parser.parse_args()
+    text = open(args.path, encoding="utf-8").read() if args.path else sys.stdin.read()
+    print(jcs_sha256(json.loads(text)))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -92,7 +92,7 @@ def task_binding(root: Path, feature: str, task_id: str) -> tuple[dict[str, Any]
     validation = validate_bindings(root, feature)
     if not validation.get("ok"):
         return None, [str(item) for item in validation.get("errors", ["invalid test bindings"])]
-    bindings = read_json(root / ".planning" / "features" / feature / "test-bindings.json")
+    bindings = read_json(root / ".devflow/planning" / "features" / feature / "test-bindings.json")
     if bindings is None:
         return None, ["missing test bindings"]
     matches = [item for item in bindings.get("tasks", []) if isinstance(item, dict) and item.get("id") == task_id]
@@ -105,7 +105,7 @@ def task_binding(root: Path, feature: str, task_id: str) -> tuple[dict[str, Any]
 
 
 def evidence_path(root: Path, feature: str, task_id: str) -> Path:
-    return root / ".planning" / "test-runs" / feature / "tdd" / f"{task_id}.json"
+    return root / ".devflow/planning" / "test-runs" / feature / "tdd" / f"{task_id}.json"
 
 
 def command_hash(argv: list[str]) -> str:
@@ -233,7 +233,7 @@ def validate_feature(root: Path, feature: str) -> dict[str, Any]:
     errors = [str(item) for item in binding_result.get("errors", [])]
     if errors:
         return response(False, feature=feature, errors=errors)
-    bindings = read_json(root / ".planning" / "features" / feature / "test-bindings.json")
+    bindings = read_json(root / ".devflow/planning" / "features" / feature / "test-bindings.json")
     assert bindings is not None
     checked: list[str] = []
     for task in bindings.get("tasks", []):

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

@@ -6,18 +6,25 @@ from pathlib import Path
 from typing import Any
 import json
 import os
+import re
 import sqlite3
 
+from approval_store import devflow_home
 
-def database_toolchain(root: Path) -> list[str] | None:
+
+PACKAGE_RUNNERS = {"npm", "pnpm", "yarn"}
+RUNTIME_MARKERS = ("devflow-quality/runtime/playwright", "runtime-manifest.json", "runner.spec.mjs", "devflow-test-dsl-v1.schema.json")
+MARKDOWN_ROW_RE = re.compile(r"^\|(.+)\|\s*$")
+
+
+def database_toolchain_facts(root: Path) -> list[dict[str, Any]] | None:
     manifest_path = root / ".devflow" / "project.json"
     if not manifest_path.is_file():
         return None
     try:
         project_id = json.loads(manifest_path.read_text(encoding="utf-8"))["projectId"]
-        data_home = Path(os.environ.get("DEVFLOW_HOME", Path.home() / ".devflow-pi"))
-        database = data_home / "projects" / project_id / "control.db"
-        connection = sqlite3.connect(f"file:{database}?mode=ro", uri=True)
+        database = devflow_home() / "projects" / project_id / "control.db"
+        connection = sqlite3.connect(f"{database.as_uri()}?mode=ro", uri=True)
         connection.row_factory = sqlite3.Row
         try:
             authority = connection.execute("SELECT authority FROM authority_state WHERE project_id=?", (project_id,)).fetchone()
@@ -32,13 +39,87 @@ def database_toolchain(root: Path) -> list[str] | None:
                    ORDER BY c.revision DESC""",
                 (project_id, str(root.resolve())),
             ).fetchall()
-            return [str(json.loads(row["value_json"]).get("command", "")) for row in rows]
+            facts = [json.loads(row["value_json"]) for row in rows]
+            return [fact for fact in facts if isinstance(fact, dict)]
         finally:
             connection.close()
     except (OSError, KeyError, ValueError, json.JSONDecodeError, sqlite3.Error):
         return None
 
 
+def database_toolchain(root: Path) -> list[str] | None:
+    facts = database_toolchain_facts(root)
+    return None if facts is None else [str(fact.get("command", "")) for fact in facts]
+
+
+def _root_directory(value: Any) -> bool:
+    return value in (None, "", ".", "./")
+
+
+def registered_scripts(root: Path, facts: list[dict[str, Any]] | None) -> tuple[set[str], str]:
+    """Package script names Core may run from the project root, and their source.
+
+    Toolchain facts (package-json@1) carry {name, command, workingDirectory};
+    the compatibility toolchain.md projects them as a 名称/工作目录 table.  A
+    legacy free-form toolchain.md has no script names, so only then fall back
+    to the root package.json scripts.
+    """
+    if facts is not None:
+        return {str(fact["name"]) for fact in facts if isinstance(fact.get("name"), str) and "command" in fact and _root_directory(fact.get("workingDirectory"))}, "toolchain facts"
+    names: set[str] = set()
+    toolchain = root / ".devflow/planning" / "toolchain.md"
+    header: list[str] | None = None
+    if toolchain.is_file():
+        for line in toolchain.read_text(encoding="utf-8").splitlines():
+            match = MARKDOWN_ROW_RE.match(line.strip())
+            if not match:
+                header = None
+                continue
+            cells = [cell.strip() for cell in match.group(1).split("|")]
+            if header is None:
+                header = cells
+            elif "名称" in header and "命令" in header and not set("".join(cells)) <= set("-: "):
+                row = dict(zip(header, cells))
+                if row.get("名称") not in (None, "", "undefined") and row.get("命令") not in (None, "", "undefined") and _root_directory(row.get("工作目录")):
+                    names.add(row["名称"])
+        if names:
+            return names, "toolchain.md"
+    try:
+        scripts = json.loads((root / "package.json").read_text(encoding="utf-8")).get("scripts", {})
+        return ({name for name in scripts if isinstance(name, str)} if isinstance(scripts, dict) else set()), "package.json"
+    except (OSError, ValueError, AttributeError):
+        return set(), "package.json"
+
+
+def package_script(argv: list[str]) -> tuple[str | None, str | None]:
+    """Return (script name, error) for npm/pnpm/yarn test|run argv."""
+    if argv[1] == "test":
+        rest, name = argv[2:], "test"
+    else:
+        if len(argv) < 3 or argv[2].startswith("-"):
+            return None, f"{Path(argv[0]).name} run must name a script immediately after 'run' (options before the script name are rejected)"
+        rest, name = argv[3:], argv[2]
+    if rest and rest[0] != "--":
+        return None, f"{Path(argv[0]).name} {argv[1]} extra arguments must follow '--'"
+    return name, None
+
+
+def reserved_reference(root: Path, argv: list[str]) -> str | None:
+    runtime_dirs: list[str] = []
+    try:
+        from dsl_v1 import runtime_dir_candidates
+        runtime_dirs = [str(path) for path in runtime_dir_candidates()]
+    except ImportError:
+        pass
+    for token in argv:
+        if "DEVFLOW_" in token:
+            return "test command must not reference DEVFLOW_ reserved variables"
+        normalized = token.replace("\\", "/")
+        if any(marker in normalized for marker in RUNTIME_MARKERS) or any(directory and directory in token for directory in runtime_dirs):
+            return "test command must not reference the Devflow Playwright Runtime; use the devflow_playwright adapter"
+    return None
+
+
 def runner_marker(argv: list[str]) -> str | None:
     if not argv:
         return None
@@ -73,18 +154,31 @@ def runner_marker(argv: list[str]) -> str | None:
 def validate_test_command(root: Path, argv: Any) -> str | None:
     if not isinstance(argv, list) or not argv or not all(isinstance(token, str) and token and "\x00" not in token for token in argv):
         return "test command must be a non-empty argv array"
+    reserved = reserved_reference(root, argv)
+    if reserved:
+        return reserved
     marker = runner_marker(argv)
     if marker is None:
+        if Path(argv[0]).name in PACKAGE_RUNNERS and len(argv) >= 2 and argv[1].startswith("-"):
+            return f"{Path(argv[0]).name} global options before the command are rejected (they can switch to another package)"
         return "test command runner is not in the Core allowlist"
-    commands = database_toolchain(root)
-    if commands is None:
-        toolchain = root / ".planning" / "toolchain.md"
+    facts = database_toolchain_facts(root)
+    if facts is None:
+        toolchain = root / ".devflow/planning" / "toolchain.md"
         if not toolchain.is_file():
-            return "initialized toolchain context (database or .planning/toolchain.md compatibility projection) is required before Core can execute a test command"
+            return "initialized toolchain context (database or .devflow/planning/toolchain.md compatibility projection) is required before Core can execute a test command"
         content = toolchain.read_text(encoding="utf-8").lower()
     else:
-        content = "\n".join(commands).lower()
+        content = "\n".join(str(fact.get("command", "")) for fact in facts).lower()
     aliases = {"pytest": ("pytest",), "unittest": ("unittest",), "bun test": ("bun test",), "npm": ("npm",), "pnpm": ("pnpm",), "yarn": ("yarn",), "go test": ("go test",), "newman": ("newman",), "playwright": ("playwright",), "vitest": ("vitest",)}
+    if marker in PACKAGE_RUNNERS:
+        script, error = package_script(argv)
+        if error:
+            return error
+        names, source = registered_scripts(root, facts)
+        if script not in names:
+            return f"package script '{script}' is not registered in the initialization toolchain ({source})"
+        return None
     if not any(alias in content for alias in aliases[marker]):
         return f"test runner '{marker}' was not discovered in the initialization toolchain snapshot"
     return None

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

@@ -74,7 +74,7 @@ def view_pin(suite: dict[str, Any]) -> dict[str, Any]:
 
 
 def freeze_attestation_path(root: Path, feature: str) -> Path:
-    return root / ".planning" / "features" / feature / "test-suite-freeze.json"
+    return root / ".devflow/planning" / "features" / feature / "test-suite-freeze.json"
 
 
 def validated_attestation(
@@ -108,8 +108,8 @@ def validated_attestation(
 
 def validate(root: Path, feature: str, stage: str = "frozen") -> dict[str, Any]:
     errors: list[str] = []
-    suite_path = root / ".planning" / "requirements" / feature / "tests.json"
-    binding_path = root / ".planning" / "features" / feature / "test-bindings.json"
+    suite_path = root / ".devflow/planning" / "requirements" / feature / "tests.json"
+    binding_path = root / ".devflow/planning" / "features" / feature / "test-bindings.json"
     suite = read_json(suite_path, errors, "TC suite")
     bindings = read_json(binding_path, errors, "test bindings")
     if suite is None or bindings is None:

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

@@ -33,7 +33,7 @@ options = {
   route: nil,
   reason: nil,
   blocking_question: nil,
-  state: ".planning/STATE.md",
+  state: ".devflow/planning/STATE.md",
   write: false,
   json: false
 }
@@ -76,7 +76,7 @@ result = if !ROUTE_NEXT_SKILL.key?(options[:route].to_s)
            if feature.to_s.empty?
              fail_result("missing_feature", "message" => "Pass --feature or provide current_feature in STATE.md")
            else
-             meta_path = File.join(root, ".planning", "requirements", feature, "入口分诊.meta.json")
+             meta_path = File.join(root, ".devflow/planning", "requirements", feature, "入口分诊.meta.json")
              meta = File.exist?(meta_path) ? JSON.parse(File.read(meta_path)) : { "feature_name" => feature }
              route = options[:route]
 
@@ -101,7 +101,7 @@ result = if !ROUTE_NEXT_SKILL.key?(options[:route].to_s)
              {
                "ok" => true,
                "written" => options[:write],
-               "path" => ".planning/requirements/#{feature}/入口分诊.meta.json",
+               "path" => ".devflow/planning/requirements/#{feature}/入口分诊.meta.json",
                "meta" => meta
              }
            end