@michaelxwb/code-flow 0.6.3 → 0.6.5

package/src/adapters/opencode/plugins/code-flow/index.js

@@ -2,12 +2,20 @@ import { execFile } from "child_process";
 import { join } from "path";
 import { appendFileSync, mkdirSync } from "fs";
 
+// Note: intentionally no `import { Plugin } from "@opencode/plugin"`.
+// The server does not auto-provide that package for local plugins, and
+// `Plugin.define` is only an identity wrapper — a plain default export
+// with `id` + `setup` satisfies the v2 plugin schema dependency-free,
+// so `code-flow init` works offline without npm install.
+
 const SCRIPT_DIR = ".code-flow/scripts";
+const STOP_CHECK_TIMEOUT = 35000;
+const HOOK_TIMEOUT = 5000;
 
 // Per-session queued feedback. Single map, append-only: idle/stop-check and
-// post-check feedback accumulate here and are consumed by the next
-// system.transform. Never overwrite — chat.message arriving between idle and
-// transform must not drop queued stop-check feedback.
+// post-check feedback accumulate here and are consumed by the next context
+// hook. Never overwrite — a prompt hook arriving between idle and context
+// must not drop queued stop-check feedback.
 const sessionContext = new Map();
 
 export function mergePending(existing, incoming) {
@@ -30,10 +38,10 @@ function pythonPath(projectRoot, script) {
   return join(projectRoot, SCRIPT_DIR, script);
 }
 
-function callHook(projectRoot, script, input, timeout = 5000) {
+function callHook(projectRoot, script, input, timeout = HOOK_TIMEOUT) {
   // Async child process: never block the plugin event thread. opencode's
   // idle event cannot interrupt a turn, so stop-check failures queue into
-  // sessionContext for the next system.transform (documented platform gap
+  // sessionContext for the next context hook (documented platform gap
   // vs. blocking Stop hooks).
   return new Promise((resolve) => {
     const child = execFile(
@@ -66,88 +74,140 @@ function callHook(projectRoot, script, input, timeout = 5000) {
   });
 }
 
-function extractPromptText(output) {
-  if (!output.parts) return "";
-  return output.parts
-    .filter((p) => p.type === "text" && !p.synthetic && !p.ignored)
-    .map((p) => p.text)
-    .join("\n");
+function queueFeedback(sessionID, text) {
+  if (!sessionID || !text) return;
+  sessionContext.set(sessionID, mergePending(sessionContext.get(sessionID), text));
+}
+
+function consumeFeedback(sessionID) {
+  const pending = sessionContext.get(sessionID);
+  if (pending) sessionContext.delete(sessionID);
+  return pending;
+}
+
+function toolInputFilePath(input) {
+  if (!input || typeof input !== "object") return "";
+  const args = input;
+  return args.filePath || args.file_path || args.path || "";
+}
+
+async function runStopCheck(projectRoot, sessionID) {
+  const result = await callHook(projectRoot, "cf_stop_hook.py", { session_id: sessionID }, STOP_CHECK_TIMEOUT);
+  if (result?.reason) {
+    // idle 无法阻断，校验失败排队到下一轮 context hook
+    queueFeedback(sessionID, result.reason);
+    debugLog(projectRoot, `stop-check feedback queued`);
+  }
+}
+
+async function registerPromptHook(ctx, projectRoot) {
+  await ctx.session.hook("prompt", async (event) => {
+    const promptText = event.prompt?.text || "";
+    if (!promptText) return;
+    debugLog(projectRoot, `prompt sid=${event.sessionID} prompt_len=${promptText.length}`);
+    const result = await callHook(projectRoot, "cf_user_prompt_hook.py", {
+      prompt: promptText,
+      session_id: event.sessionID,
+    });
+    const additional = result?.hookSpecificOutput?.additionalContext;
+    if (additional) {
+      // Append, never overwrite: queued stop-check feedback survives.
+      queueFeedback(event.sessionID, additional);
+      debugLog(projectRoot, `hook matched — context ${additional.length} chars cached`);
+    } else {
+      debugLog(projectRoot, `hook returned no context`);
+    }
+  });
 }
 
-export const CodeFlow = async (ctx) => {
-  const projectRoot = ctx.directory;
+async function registerToolHook(ctx, projectRoot) {
+  await ctx.tool.hook("execute.after", async (event) => {
+    const tool = String(event.tool || "").toLowerCase();
+    if (!["edit", "write", "multiedit", "patch"].includes(tool)) return;
+    const filePath = toolInputFilePath(event.input);
+    if (!filePath) return;
+    const result = await callHook(projectRoot, "cf_post_hook.py", {
+      tool_name: tool === "write" ? "Write" : "Edit",
+      tool_input: { file_path: filePath },
+      session_id: event.sessionID || "",
+    });
+    const additional = result?.hookSpecificOutput?.additionalContext;
+    if (additional) {
+      // 反馈排队，下一轮 context hook 注入（opencode 无法当轮插话）
+      queueFeedback(event.sessionID, additional);
+      debugLog(projectRoot, `post-check feedback queued ${additional.length} chars`);
+    }
+  });
+}
 
+async function registerContextHook(ctx) {
+  await ctx.session.hook("context", (event) => {
+    const pending = consumeFeedback(event.sessionID);
+    if (pending) {
+      event.system.push({ type: "text", text: pending });
+      debugLog(ctx.location.directory, `context — injected ${pending.length} chars`);
+    }
+  });
+}
+
+// 子会话（子 agent / worktree 并行任务）的 idle 不得触发主工作区 stop-check：
+// 子会话的编辑发生在自己的工作区，主区既无 active marker 也没有对应文件，
+// 触发只会重复执行主区 validators（全量测试）。用 session.created.parentID 标记子会话。
+export function createSessionRegistry() {
+  const children = new Set();
   return {
-    event: async (input) => {
-      if (input.event?.type === "session.created") {
-        const sid = input.event?.properties?.info?.id || "";
-        debugLog(projectRoot, `session.created sid=${sid}`);
-        if (sid) sessionContext.delete(sid);
+    observe(event) {
+      if (!event || typeof event.type !== "string") return null;
+      const sid = event.data?.sessionID || "";
+      if (!sid) return null;
+      if (event.type === "session.created") {
+        if (event.data?.parentID) children.add(sid);
+        return { type: "created", sid };
       }
-      if (input.event?.type === "session.idle") {
-        const sid =
-          input.event?.properties?.sessionID ||
-          input.event?.properties?.info?.id || "";
-        const result = await callHook(projectRoot, "cf_stop_hook.py", { session_id: sid }, 35000);
-        if (result?.reason) {
-          // idle 无法阻断，校验失败排队到下一轮 system prompt
-          sessionContext.set(sid, mergePending(sessionContext.get(sid), result.reason));
-          debugLog(projectRoot, `stop-check feedback queued`);
-        }
+      if (event.type === "session.idle") {
+        return { type: "idle", sid, child: children.has(sid) };
       }
+      return null;
     },
+  };
+}
 
-    "chat.message": async (input, output) => {
-      const promptText = extractPromptText(output);
-      if (!promptText) return;
-
-      debugLog(projectRoot, `chat.message sid=${input.sessionID} prompt_len=${promptText.length}`);
-
-      const result = await callHook(projectRoot, "cf_user_prompt_hook.py", {
-        prompt: promptText,
-        session_id: input.sessionID,
-      });
-
-      if (result?.hookSpecificOutput?.additionalContext) {
-        const ctxLen = result.hookSpecificOutput.additionalContext.length;
-        debugLog(projectRoot, `hook matched — context ${ctxLen} chars cached`);
-        // Append, never overwrite: queued stop-check feedback survives.
-        sessionContext.set(
-          input.sessionID,
-          mergePending(sessionContext.get(input.sessionID), result.hookSpecificOutput.additionalContext)
-        );
-      } else {
-        debugLog(projectRoot, `hook returned no context`);
+function startEventSubscription(ctx, projectRoot) {
+  const controller = new AbortController();
+  const registry = createSessionRegistry();
+  void (async () => {
+    try {
+      for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+        const observed = registry.observe(event);
+        if (!observed) continue;
+        if (observed.type === "created") {
+          debugLog(projectRoot, `session.created sid=${observed.sid}`);
+          sessionContext.delete(observed.sid);
+        } else if (observed.child) {
+          debugLog(projectRoot, `session.idle sid=${observed.sid} (child) — stop-check skipped`);
+        } else {
+          await runStopCheck(projectRoot, observed.sid);
+        }
       }
-    },
-
-    "tool.execute.after": async (input, output) => {
-      const tool = String(input?.tool || "").toLowerCase();
-      if (!["edit", "write", "multiedit", "patch"].includes(tool)) return;
-      const args = output?.args || input?.args || {};
-      const filePath = args.filePath || args.file_path || args.path;
-      if (!filePath) return;
-      const result = await callHook(projectRoot, "cf_post_hook.py", {
-        tool_name: tool === "write" ? "Write" : "Edit",
-        tool_input: { file_path: filePath },
-        session_id: input?.sessionID || "",
-      });
-      const ctx = result?.hookSpecificOutput?.additionalContext;
-      if (ctx) {
-        // 反馈排队，下一轮 system.transform 注入（opencode 无法当轮插话）
-        const sid = input?.sessionID || "";
-        sessionContext.set(sid, mergePending(sessionContext.get(sid), ctx));
-        debugLog(projectRoot, `post-check feedback queued ${ctx.length} chars`);
+    } catch (err) {
+      if (err?.name !== "AbortError") {
+        debugLog(projectRoot, `event subscription ended: ${err?.message || err}`);
       }
-    },
+    }
+  })();
+  return () => controller.abort();
+}
 
-    "experimental.chat.system.transform": async (input, output) => {
-      const ctx = sessionContext.get(input.sessionID);
-      if (ctx) {
-        output.system.push(ctx);
-        debugLog(projectRoot, `system.transform — injected ${ctx.length} chars, system now ${output.system.length} parts`);
-        sessionContext.delete(input.sessionID);
-      }
-    },
-  };
+const CodeFlowPlugin = {
+  id: "code-flow",
+  async setup(ctx) {
+    const projectRoot = ctx.location.directory;
+    await registerPromptHook(ctx, projectRoot);
+    await registerToolHook(ctx, projectRoot);
+    await registerContextHook(ctx);
+    const stopSubscription = startEventSubscription(ctx, projectRoot);
+    return () => stopSubscription();
+  },
 };
+
+export default CodeFlowPlugin;

package/src/adapters/opencode/plugins/code-flow/package.json

@@ -2,5 +2,5 @@
   "name": "code-flow-opencode",
   "type": "module",
   "main": "index.js",
-  "description": "code-flow spec injection plugin for OpenCode"
+  "description": "code-flow spec injection plugin for OpenCode v2"
 }

package/src/cli.js

@@ -237,6 +237,56 @@ function mergeSettingsJson(srcFile, destFile) {
   return added;
 }
 
+// OpenCode v2 merge: migrate the v1 `plugin` key to `plugins`, drop the
+// auto-discovered local path (`.opencode/plugins/*` loads without config),
+// and union template `plugins` entries without overwriting user content.
+function mergeOpencodeJson(srcFile, destFile) {
+  const src = JSON.parse(fs.readFileSync(srcFile, 'utf8'));
+  const dest = JSON.parse(fs.readFileSync(destFile, 'utf8'));
+  const added = [];
+  const isLocalEntry = (e) => {
+    const p = typeof e === 'string' ? e : (e && e.package);
+    return typeof p === 'string' && /(^|\/)\.opencode\/plugins\//.test(p);
+  };
+  if (Array.isArray(dest.plugin)) {
+    const carried = dest.plugin.filter((e) => !isLocalEntry(e));
+    delete dest.plugin;
+    added.push(`removed legacy 'plugin' key (v1 → v2)`);
+    if (carried.length > 0 && !Array.isArray(dest.plugins)) dest.plugins = carried;
+  } else if ('plugin' in dest) {
+    delete dest.plugin;
+    added.push(`removed legacy 'plugin' key (v1 → v2)`);
+  }
+  if (Array.isArray(dest.plugins)) {
+    const before = dest.plugins.length;
+    dest.plugins = dest.plugins.filter((e) => !isLocalEntry(e));
+    if (dest.plugins.length !== before) added.push('removed auto-discovered local plugin entry');
+  }
+  if (Array.isArray(src.plugins)) {
+    if (!Array.isArray(dest.plugins)) dest.plugins = [];
+    const seen = new Set(dest.plugins.map((e) => JSON.stringify(e)));
+    for (const entry of src.plugins) {
+      const key = JSON.stringify(entry);
+      if (!seen.has(key)) {
+        dest.plugins.push(entry);
+        seen.add(key);
+        added.push(`plugins +${typeof entry === 'string' ? entry : key}`.slice(0, 80));
+      }
+    }
+  }
+  for (const key of Object.keys(src)) {
+    if (key === 'plugins' || key === 'plugin') continue;
+    if (!(key in dest)) {
+      dest[key] = src[key];
+      added.push(key);
+    }
+  }
+  if (added.length > 0) {
+    fs.writeFileSync(destFile, JSON.stringify(dest, null, 2) + '\n');
+  }
+  return added;
+}
+
 function mergeConfigYml(srcFile, destFile) {
   const srcText = fs.readFileSync(srcFile, 'utf8');
   const destText = fs.readFileSync(destFile, 'utf8');
@@ -781,7 +831,7 @@ function runInit(force, platform, opts) {
       dest: path.join(cwd, 'opencode.json'),
       label: 'opencode.json',
       mode: platformMode,
-      mergeFn: mergeSettingsJson,
+      mergeFn: mergeOpencodeJson,
       toolOnUpgrade: false,
       results,
     });

package/src/core/code-flow/config.yml

@@ -24,7 +24,8 @@ budget:
 quality_loop:
     enabled: true
     post_check: true            # PostToolUse 违规反馈（只提示不阻断）
-    stop_check: true            # Stop 收尾按 validation.yml 校验
+    stop_check: true            # Stop 收尾按 validation.yml 校验（heavy 项跳过）
+    finish_check: true          # 任务 finish 时全量执行 validation.yml（含 heavy，每任务一次）
     correction_capture: true    # 纠正句式采集（喂 cf-learn 候选）
     # 注入时对 spec 内容做保守无损压缩（去行尾空白、折叠多空行、剥 HTML 注释、去重 bullet）
     # 缺省视为 true；仅显式 false 关闭

package/src/core/code-flow/scripts/cf_acceptance_manifest.py

@@ -10,7 +10,7 @@ import shlex
 from pathlib import Path
 import re
 import sys
-from typing import IO, Mapping, Optional, Sequence
+from typing import IO, Callable, Mapping, Optional, Sequence
 
 from cf_acceptance_schema import load_manifest, validate_scenarios
 
@@ -26,12 +26,18 @@ def _kind(level: str) -> str:
     - functional: auto-executed in Done Gate (unit, integration)
     - e2e: deferred until explicit --verify-e2e (needs external dependencies)
     - manual: user confirmation required, never auto-executed
+
+    层级单元格允许带注解（如 `E2E（Playwright）`、`e2e/chrome`、`manual(chrome)`），
+    取分隔符前的词元判定；避免带注解的 E2E 被误判为 functional 而每任务执行。
     """
-    normalized = level.strip().lower()
-    if normalized == "manual":
+    head = level.strip().lower()
+    for separator in ("(", "（", "[", "/", ",", "，", " ", "—", "-"):
+        head = head.split(separator, 1)[0]
+    head = head.strip()
+    if head in ("manual", "手工", "手动"):
         return "manual"
-    if normalized == "e2e":
-        return "e2e"  # Keep as separate kind, not functional
+    if head in ("e2e", "端到端", "end"):
+        return "e2e"
     return "functional"
 
 
@@ -70,7 +76,17 @@ def _manifest_hash(rows: list[dict[str, object]]) -> str:
     return hashlib.sha256(payload).hexdigest()
 
 
-def extract_manifest(task_file: str) -> dict[str, object]:
+def _legacy_kind(level: str) -> str:
+    """v1 精确匹配：仅用于识别旧版锁定的 manifest，不做新语义判定。"""
+    normalized = level.strip().lower()
+    if normalized == "manual":
+        return "manual"
+    if normalized == "e2e":
+        return "e2e"
+    return "functional"
+
+
+def _extract_rows(task_file: str, kind_fn: Callable[[str], str]) -> dict[str, object]:
     path = Path(task_file)
     text = path.read_text(encoding="utf-8")
     rows: list[dict[str, object]] = []
@@ -98,7 +114,7 @@ def extract_manifest(task_file: str) -> dict[str, object]:
             "id": match.group(1),
             "source": fields[0],
             "level": fields[1],
-            "kind": _kind(fields[1]),
+            "kind": kind_fn(fields[1]),
             "boundary": fields[2],
             "owner": fields[3],
             "status": fields[4],
@@ -113,6 +129,10 @@ def extract_manifest(task_file: str) -> dict[str, object]:
     return {"schema": _MANIFEST_SCHEMA, "task_file": str(path), "task_sha256": _manifest_hash(rows), "scenarios": rows}
 
 
+def extract_manifest(task_file: str, kind_fn: Callable[[str], str] = _kind) -> dict[str, object]:
+    return _extract_rows(task_file, kind_fn)
+
+
 def write_manifest(task_file: str, output: str) -> dict[str, object]:
     manifest = extract_manifest(task_file)
     target = Path(output)
@@ -130,14 +150,40 @@ _IMMUTABLE_SCENARIO_FIELDS = (
 )
 
 
+def _heal_legacy_kinds(manifest_file: Path, manifest: dict[str, object], expected: dict[str, object]) -> None:
+    """旧版 `_kind` 精确匹配把带注解的 E2E 锁成 functional；任务内容未变时
+    原地升级 kind 并重锁哈希，保留 execution evidence 等运行态字段。"""
+    by_id: dict[str, dict[str, object]] = {}
+    scenarios = expected.get("scenarios")
+    if isinstance(scenarios, list):
+        for item in scenarios:
+            if isinstance(item, dict) and isinstance(item.get("id"), str):
+                by_id[item["id"]] = item
+    current = manifest.get("scenarios")
+    if isinstance(current, list):
+        for item in current:
+            if not isinstance(item, dict):
+                continue
+            target = by_id.get(item.get("id")) if isinstance(item.get("id"), str) else None
+            if target is not None:
+                item["kind"] = target.get("kind")
+    manifest["task_sha256"] = expected["task_sha256"]
+    manifest_file.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
 def validate_manifest(task_file: str, manifest_file: str) -> tuple[bool, str]:
     try:
         manifest = load_manifest(Path(manifest_file))
         expected = extract_manifest(task_file)
     except (OSError, ValueError, json.JSONDecodeError) as exc:
         return False, f"acceptance_manifest_invalid: {exc}"
-    if manifest.get("schema") != _MANIFEST_SCHEMA or manifest.get("task_sha256") != expected["task_sha256"]:
+    if manifest.get("schema") != _MANIFEST_SCHEMA:
         return False, "acceptance_manifest_drift"
+    if manifest.get("task_sha256") != expected["task_sha256"]:
+        legacy = extract_manifest(task_file, _legacy_kind)
+        if manifest.get("task_sha256") != legacy["task_sha256"]:
+            return False, "acceptance_manifest_drift"
+        _heal_legacy_kinds(Path(manifest_file), manifest, expected)
     stored_task = manifest.get("task_file", "")
     if not stored_task or (Path(manifest_file).parent / stored_task).resolve() != Path(task_file).resolve():
         return False, "acceptance_manifest_task_mismatch"

package/src/core/code-flow/scripts/cf_core.py

@@ -55,6 +55,31 @@ def normalize_path(path: str) -> str:
     return path.replace("\\", "/")
 
 
+def effective_project_root(project_root: str, absolute_path: str) -> str:
+    """Resolve the project root that owns an edited file.
+
+    Parallel subagents edit `.code-flow/worktrees/<run>/<TASK>/...`; the nearest
+    `.code-flow` ancestor is that worktree's root, not the session root. Files
+    outside the session root and unresolvable paths fall back to `project_root`.
+    Lexical `abspath` (not `realpath`) keeps caller/returned paths in the same
+    coordinates (macOS /var ↔ /private/var symlink).
+    """
+    root = os.path.abspath(project_root)
+    target = os.path.abspath(absolute_path) if absolute_path else root
+    if target != root and not target.startswith(root + os.sep):
+        return root
+    current = target
+    while True:
+        if os.path.isdir(os.path.join(current, ".code-flow")):
+            return current
+        if current == root:
+            return root
+        parent = os.path.dirname(current)
+        if parent == current:
+            return root
+        current = parent
+
+
 def _spec_path_from_entry(entry) -> str:
     cfg = normalize_spec_entry(entry)
     return normalize_path(cfg.get("path", ""))
@@ -474,7 +499,8 @@ def resolve_quality_loop(config: dict) -> dict:
     """
     if not isinstance(config, dict):
         return {"enabled": False, "post_check": False,
-                "stop_check": False, "correction_capture": False,
+                "stop_check": False, "finish_check": False,
+                "correction_capture": False,
                 "compress_reminder": False}
     cfg = config.get("quality_loop")
     cfg = cfg if isinstance(cfg, dict) else {}
@@ -487,6 +513,7 @@ def resolve_quality_loop(config: dict) -> dict:
         "enabled": enabled,
         "post_check": _sub("post_check"),
         "stop_check": _sub("stop_check"),
+        "finish_check": _sub("finish_check"),
         "correction_capture": _sub("correction_capture"),
         "compress_reminder": _sub("compress_reminder"),
     }

package/src/core/code-flow/scripts/cf_post_hook.py

@@ -31,6 +31,7 @@ from cf_checks import (
 from cf_core import (
     _log,
     build_effective_mapping,
+    effective_project_root,
     ensure_utf8_io,
     is_code_file,
     load_config,
@@ -107,7 +108,10 @@ def main() -> None:
         if not isinstance(file_path, str) or not file_path:
             return
 
-        project_root = os.getcwd()
+        session_root = os.getcwd()
+        abs_path = file_path if os.path.isabs(file_path) else os.path.join(session_root, file_path)
+        # 并行子 agent 在 .code-flow/worktrees/... 内编辑时路由到该 worktree 的规格与状态
+        project_root = effective_project_root(session_root, abs_path)
         config = load_config(project_root)
         if not config:
             return
@@ -117,9 +121,6 @@ def main() -> None:
         if not quality_loop["post_check"]:
             return
 
-        abs_path = file_path
-        if not os.path.isabs(abs_path):
-            abs_path = os.path.join(project_root, file_path)
         rel_path = normalize_path(os.path.relpath(abs_path, project_root))
         sid = resolve_session_id(data)
         cf_log.append_event(project_root, "edit", {"file": rel_path, "tool": tool_name}, sid)

package/src/core/code-flow/scripts/cf_pre_tool_hook.py

@@ -11,7 +11,16 @@ from pathlib import Path
 import sys
 
 import cf_log
-from cf_core import _log, ensure_utf8_io, load_config, normalize_path, resolve_enforcement, resolve_session_id, timing_log
+from cf_core import (
+    _log,
+    effective_project_root,
+    ensure_utf8_io,
+    load_config,
+    normalize_path,
+    resolve_enforcement,
+    resolve_session_id,
+    timing_log,
+)
 from cf_session_state import load_session_state, save_session_state
 from cf_spec_context import injection_version, load_active_task, load_context
 from cf_spec_resolver import resolve_candidate_headers
@@ -49,11 +58,13 @@ def main() -> None:
         file_path = (data.get("tool_input") or {}).get("file_path", "")
         if tool_name not in {"Edit", "Write", "MultiEdit"} or not isinstance(file_path, str) or not file_path:
             return
-        root = os.getcwd()
+        session_root = os.getcwd()
+        absolute = file_path if os.path.isabs(file_path) else os.path.join(session_root, file_path)
+        # 并行子 agent 在 .code-flow/worktrees/... 内编辑时路由到该 worktree 的上下文
+        root = effective_project_root(session_root, absolute)
         sid = resolve_session_id(data)
         config = load_config(root)
         enforcement = resolve_enforcement(config) if config else "required"
-        absolute = file_path if os.path.isabs(file_path) else os.path.join(root, file_path)
         relative = normalize_path(os.path.relpath(absolute, root))
         try:
             expanded = _active_expansion(root, relative)