@guanlin4924/devflow-pi 0.1.40 → 0.1.48

package/plugins/devflow-intel/skills/workflow-code-index/scripts/code_index.py

@@ -5,6 +5,7 @@ import json
 import os
 import shutil
 import sqlite3
+import subprocess
 import sys
 import tempfile
 import uuid
@@ -14,8 +15,6 @@ from typing import Dict, Iterable, List, Set, Tuple
 
 import fcntl
 
-sys.dont_write_bytecode = True
-
 SCRIPT_DIR = Path(__file__).resolve().parent
 if str(SCRIPT_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPT_DIR))
@@ -58,13 +57,14 @@ def _index_lock(output: Path, exclusive: bool):
             fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
 
 
-def _publish_snapshot(staging: Path, output: Path, counts: Dict[str, int]) -> None:
+def _publish_snapshot(staging: Path, output: Path, counts: Dict[str, int], workspace_state: Dict[str, object]) -> None:
     generation = str(uuid.uuid4())
     snapshot = {
         "schemaVersion": 1,
         "generation": generation,
         "generatedAt": datetime.now(timezone.utc).isoformat(),
         "counts": counts,
+        "workspace": workspace_state,
         "artifacts": [*INDEX_FILES.values(), "index.sqlite", *MARKDOWN_FILES],
     }
     snapshot_path = staging / SNAPSHOT_FILE
@@ -72,8 +72,6 @@ def _publish_snapshot(staging: Path, output: Path, counts: Dict[str, int]) -> No
     with snapshot_path.open("rb") as handle:
         os.fsync(handle.fileno())
 
-    # Readers in this module hold the shared lock. SNAPSHOT.json is published
-    # last and is therefore the commit marker for external consumers.
     for name in snapshot["artifacts"]:
         os.replace(staging / name, output / name)
     os.replace(snapshot_path, output / SNAPSHOT_FILE)
@@ -84,6 +82,53 @@ def _publish_snapshot(staging: Path, output: Path, counts: Dict[str, int]) -> No
         os.close(directory_fd)
 
 
+def _workspace_state(root: Path, files: List[dict], changed: Set[str]) -> Dict[str, object]:
+    indexed_paths = sorted(record["path"] for record in files)
+    source_manifest_hash = _hash_lines(f"{record['path']}\0{record['content_hash']}" for record in files)
+    return {
+        "repositoryRevision": _git_output(root, ["rev-parse", "HEAD"]),
+        "contentManifestHash": source_manifest_hash,
+        "indexedPathsHash": _hash_lines(indexed_paths),
+        "dirtyPathsAtBuild": sorted(changed),
+    }
+
+
+def _worktree_signature(root: Path) -> str:
+    try:
+        proc = subprocess.run(
+            ["git", "status", "--porcelain=v1", "--untracked-files=all"],
+            cwd=str(root),
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+    except (OSError, FileNotFoundError):
+        return ""
+    if proc.returncode != 0:
+        return ""
+    kept = []
+    for line in proc.stdout.splitlines():
+        path = line[3:].strip() if len(line) > 3 else ""
+        if path.startswith(".planning/code-index/"):
+            continue
+        kept.append(line)
+    return "\n".join(kept)
+
+
+def _git_output(root: Path, args: List[str]) -> str:
+    try:
+        proc = subprocess.run(["git", *args], cwd=str(root), text=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, check=False)
+    except (OSError, FileNotFoundError):
+        return ""
+    return proc.stdout.strip() if proc.returncode == 0 else ""
+
+
+def _hash_lines(values) -> str:
+    digest = uuid.uuid5(uuid.NAMESPACE_URL, "\n".join(values))
+    return f"uuid5:{digest}"
+
+
 def main(argv=None) -> int:
     parser = argparse.ArgumentParser(description="Build and validate a generic code intelligence index.")
     sub = parser.add_subparsers(dest="command", required=True)
@@ -201,6 +246,7 @@ def command_scan(args) -> int:
                     "relations": len(relations),
                     "diagnostics": len(diagnostics),
                 },
+                _workspace_state(root, files, changed),
             )
         finally:
             shutil.rmtree(staging, ignore_errors=True)
@@ -212,38 +258,6 @@ def command_scan(args) -> int:
 
 def command_validate(args) -> int:
     output = Path(args.index).resolve()
-    with _index_lock(output, exclusive=False):
-        files, symbols, relations, diagnostics = _load_tuple(output)
-        errors = validate_index(files, symbols, relations, diagnostics)
-    if errors:
-        for error in errors:
-            print(error)
-        return 1
-    print("Code index schema validation passed.")
-    return 0
-
-
-def command_audit(args) -> int:
-    root = Path(args.root).resolve()
-    output = Path(args.index).resolve()
-    with _index_lock(output, exclusive=True):
-        files, symbols, relations, diagnostics = _load_tuple(output)
-        findings = []
-        findings.extend(audit_stale(root, files))
-        findings.extend(audit_relations(symbols, relations))
-        skill_root = Path(args.skill_root)
-        if skill_root.exists():
-            findings.extend(audit_project_binding([skill_root / "workflow-code-index", skill_root / "code-index-query"]))
-        write_audit(output, findings)
-    if findings:
-        for finding in findings[:200]:
-            location = f" {finding.get('path', '')}:{finding.get('line', '')}".rstrip(":")
-            print(f"{finding.get('severity', 'warning')}: {finding.get('kind', 'unknown')}: {finding.get('message', '')}{location}")
-        return 1
-    print("Code index audit passed.")
-    return 0
-
-
 def command_query(args) -> int:
     output = Path(args.index).resolve()
     with _index_lock(output, exclusive=False):
@@ -251,6 +265,11 @@ def command_query(args) -> int:
         if not index.exists():
             print(f"Missing index: {index}", file=sys.stderr)
             return 1
+        snapshot = _load_snapshot(output)
+        files = read_jsonl(output / INDEX_FILES["files"])
+        if not _query_is_fresh(output.parent.parent, snapshot, files):
+            print("Stale code index: refresh required before query.", file=sys.stderr)
+            return 1
         conn = sqlite3.connect(str(index))
         conn.row_factory = sqlite3.Row
         try:
@@ -283,6 +302,57 @@ def command_query(args) -> int:
     return 0
 
 
+def _load_snapshot(output: Path) -> Dict[str, object]:
+    path = output / SNAPSHOT_FILE
+    if not path.exists():
+        return {}
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _query_is_fresh(root: Path, snapshot: Dict[str, object], files: List[dict]) -> bool:
+    workspace = snapshot.get("workspace") if isinstance(snapshot, dict) else None
+    if not isinstance(workspace, dict):
+        return False
+    if workspace.get("repositoryRevision") and workspace.get("repositoryRevision") != _git_output(root, ["rev-parse", "HEAD"]):
+        return False
+    indexed_manifest = _hash_lines(f"{record['path']}\0{record['content_hash']}" for record in files)
+    if workspace.get("contentManifestHash") != indexed_manifest:
+        return False
+    return True
+
+
+
+def command_audit(args) -> int:
+    root = Path(args.root).resolve()
+    output = Path(args.index).resolve()
+    with _index_lock(output, exclusive=True):
+        files, symbols, relations, diagnostics = _load_tuple(output)
+        findings = []
+        findings.extend(audit_stale(root, files))
+        findings.extend(audit_relations(symbols, relations))
+        skill_root = Path(args.skill_root)
+        if skill_root.exists():
+            findings.extend(audit_project_binding([skill_root / "workflow-code-index", skill_root / "code-index-query"]))
+        write_audit(output, findings)
+    if findings:
+        for finding in findings[:200]:
+            location = f" {finding.get('path', '')}:{finding.get('line', '')}".rstrip(":")
+            print(f"{finding.get('severity', 'warning')}: {finding.get('kind', 'unknown')}: {finding.get('message', '')}{location}")
+        return 1
+    print("Code index audit passed.")
+    return 0
+
+
+def _load_snapshot(output: Path) -> Dict[str, object]:
+    path = output / SNAPSHOT_FILE
+    if not path.exists():
+        return {}
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+
+
+
 def _load_tuple(output: Path):
     return (
         read_jsonl(output / INDEX_FILES["files"]),

package/plugins/devflow-intel/skills/workflow-code-index/scripts/core/scanner.py

@@ -6,6 +6,7 @@ from typing import Iterable, List, Sequence
 
 DEFAULT_EXCLUDES = {
     ".git",
+    ".planning",
     "node_modules",
     "vendor",
     "dist",
@@ -59,7 +60,7 @@ TEXT_EXTENSIONS = {
 def scan_files(root: Path, excludes: Iterable[str] = (), max_bytes: int = 1_500_000) -> List[Path]:
     root = root.resolve()
     excluded = DEFAULT_EXCLUDES | set(excludes)
-    paths = _scan_with_rg(root, excluded) or _scan_with_walk(root, excluded)
+    paths = _scan_with_git(root, excluded) or _scan_with_rg(root, excluded) or _scan_with_walk(root, excluded)
     result: List[Path] = []
     for path in sorted(paths):
         if not path.is_file():
@@ -77,6 +78,24 @@ def scan_files(root: Path, excludes: Iterable[str] = (), max_bytes: int = 1_500_
     return result
 
 
+def _scan_with_git(root: Path, excluded: Sequence[str]) -> List[Path]:
+    try:
+        proc = subprocess.run(
+            ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+            cwd=str(root),
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+    except (OSError, FileNotFoundError):
+        return []
+    if proc.returncode != 0:
+        return []
+    return [root / line.strip() for line in proc.stdout.splitlines() if line.strip()]
+
+
+
 def _scan_with_rg(root: Path, excluded: Sequence[str]) -> List[Path]:
     ignore_args = []
     for name in excluded:

package/plugins/devflow-quality/skills/workflow-acceptance-test-design/SKILL.md

@@ -12,7 +12,7 @@ description: "Use after integration verification and before change planning to d
 本步骤的图谱写入受 ExecutionContract v2 约束：`devflow_requirement_graph(action="propose", kind="test_case")` 与 `devflow_api_test_matrix(action="import")` 仅在 active contract 的 step 为 `acceptance-test-design` 时放行。步骤开始且无 active contract 时：
 
 1. 先调用 `devflow_contract(action="status")` 检查当前会话是否有 active contract；
-2. 未激活时调用 `devflow_contract(action="activate", feature="<feature>", step="acceptance-test-design")` 合成并激活（planning / waiting-user / awaiting-approval 阶段均可，Core 校验 STATE 与图谱 revision 后由用户确认）；
+2. 未激活时调用 `devflow_contract(action="activate", feature="<feature>", step="acceptance-test-design")` 合成并激活（planning / waiting-user / awaiting-approval，或 Runtime 已触发当前步骤的 executing 回合均可；Core 校验 STATE 当前 feature/step 与图谱 revision 后由用户确认）；
 3. 会话中断后 contract 由 runtime 在 `session_start` 时从 `.planning/contracts/{feature}/EC-*.json` 自动恢复；恢复时校验 state/graph revision，推进后自动失效，需重新合成。
 
 ## 输入

package/src/constants.ts

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

package/src/runtime.ts

@@ -1,10 +1,12 @@
 import { mkdir, readFile, rm } from "node:fs/promises";
+import { homedir } from "node:os";
 import path from "node:path";
 
 import { OMP_RUNTIME_VERSION, PRODUCT_NAME, PRODUCT_VERSION } from "./constants.ts";
 import { createPlatformExtension } from "./platform-extension.ts";
 import { devflowAgentDir, devflowHome, pluginRoots, projectSessionDir, sharedOmpAgentDir } from "./paths.ts";
 import type { ProjectContext } from "./project-context.ts";
+import { injectOmpExtensionCliRoots } from "@oh-my-pi/pi-coding-agent/discovery/omp-extension-roots";
 
 export interface RuntimeOptions {
   initialPrompt?: string;
@@ -102,6 +104,12 @@ export async function createEmbeddedRuntime(project: ProjectContext, options: Ru
   utils.logger.setTransports({ file: path.join(productHome, "logs") });
   const omp = await import("@oh-my-pi/pi-coding-agent");
   const roots = pluginRoots();
+  // Task workers perform a fresh agent discovery after session creation. The
+  // SDK's temporary extension-root scope does not cover that later lookup,
+  // so register Devflow package roots as durable CLI roots for this process.
+  // Without this, packaged agents such as implementation-worker appear during
+  // startup but fail with Unknown agent when a parallel task is dispatched.
+  injectOmpExtensionCliRoots(roots, homedir(), project.root, { mode: "explicit-only", replace: true });
   // Reuse credentials and model discovery from the user's OMP agent, but not
   // its config.yml: a global modelRoles block would override choices made in
   // Devflow's own Roles screen after every restart.
@@ -134,28 +142,37 @@ export async function createEmbeddedRuntime(project: ProjectContext, options: Ru
   } else {
     sessionManager = omp.SessionManager.create(project.root, sessionDir);
   }
-  const runtime = await omp.createAgentSession({
-    cwd: project.root,
-    agentDir: productAgentDir,
-    settings,
-    authStorage,
-    modelRegistry,
-    sessionManager,
-    additionalExtensionPaths: roots,
-    disableExtensionDiscovery: true,
-    extensions: [
-      createPlatformExtension({
-        sessionRoot: sessionDir,
-        ompSessionRoot: path.join(sharedAgentDir, "sessions"),
-        projectId: project.manifest.projectId,
-        getConfiguredRole: role => settings.getModelRole(role),
-      }),
-    ],
-    hasUI: options.hasUI ?? true,
-    enableMCP: options.enableMCP ?? false,
-    enableLsp: options.enableLsp ?? true,
-    appendSystemPrompt: TOOL_CALL_SAFETY_PROMPT,
-  });
+  const previousCliResumeSignal = process.env.DEVFLOW_CLI_SESSION_RESUME;
+  if (options.resume) process.env.DEVFLOW_CLI_SESSION_RESUME = "1";
+  else delete process.env.DEVFLOW_CLI_SESSION_RESUME;
+  let runtime;
+  try {
+    runtime = await omp.createAgentSession({
+      cwd: project.root,
+      agentDir: productAgentDir,
+      settings,
+      authStorage,
+      modelRegistry,
+      sessionManager,
+      additionalExtensionPaths: roots,
+      disableExtensionDiscovery: true,
+      extensions: [
+        createPlatformExtension({
+          sessionRoot: sessionDir,
+          ompSessionRoot: path.join(sharedAgentDir, "sessions"),
+          projectId: project.manifest.projectId,
+          getConfiguredRole: role => settings.getModelRole(role),
+        }),
+      ],
+      hasUI: options.hasUI ?? true,
+      enableMCP: options.enableMCP ?? false,
+      enableLsp: options.enableLsp ?? true,
+      appendSystemPrompt: TOOL_CALL_SAFETY_PROMPT,
+    });
+  } finally {
+    if (previousCliResumeSignal === undefined) delete process.env.DEVFLOW_CLI_SESSION_RESUME;
+    else process.env.DEVFLOW_CLI_SESSION_RESUME = previousCliResumeSignal;
+  }
   return { omp, runtime, sessionDir };
 }
 
@@ -256,6 +273,15 @@ export async function runInteractiveRuntime(project: ProjectContext, options: Ru
       void consumeControlledRollover();
     }, delay);
   };
+  // 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
+  // poller alive for the lifetime of the interactive loop; it only touches the
+  // filesystem when a durable rollover request exists.
+  const rolloverPoller = setInterval(() => {
+    void consumeControlledRollover();
+  }, 500);
+  rolloverPoller.unref?.();
   // A prepared handoff is a durable runtime request, not something that
   // should wait for the user to type another command after a restart.
   await consumeControlledRollover();
@@ -263,5 +289,10 @@ export async function runInteractiveRuntime(project: ProjectContext, options: Ru
     const input = await mode.getUserInput();
     await omp.submitInteractiveInput(mode, runtime.session, input);
     await consumeControlledRollover();
+    // 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();
   }
 }