@dawipong/opcflow 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,4550 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// core/config.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+function findProjectRoot(from = process.cwd()) {
+  let dir = resolve(from);
+  while (true) {
+    if (existsSync(join(dir, CONFIG_FILENAME))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return resolve(from);
+    dir = parent;
+  }
+}
+function loadConfig(root) {
+  const file = join(root, CONFIG_FILENAME);
+  if (!existsSync(file)) return { ...DEFAULTS };
+  const raw = JSON.parse(
+    readFileSync(file, "utf-8")
+  );
+  return {
+    ...DEFAULTS,
+    ...raw,
+    docs: { ...DEFAULTS.docs, ...raw.docs },
+    gates: { ...DEFAULTS.gates, ...raw.gates },
+    machineChecks: { ...DEFAULTS.machineChecks, ...raw.machineChecks },
+    roleProduces: { ...DEFAULTS.roleProduces, ...raw.roleProduces },
+    pipeline: raw.pipeline ?? DEFAULTS.pipeline,
+    git: { ...DEFAULTS.git, ...raw.git },
+    platforms: raw.platforms ?? DEFAULTS.platforms
+  };
+}
+var CONFIG_FILENAME, PKG_NAME, WORKBENCH_BIN, WORKBENCH_DIR, DEFAULTS;
+var init_config = __esm({
+  "core/config.ts"() {
+    "use strict";
+    CONFIG_FILENAME = "workbench.config.json";
+    PKG_NAME = "@dawipong/opcflow";
+    WORKBENCH_BIN = `npx -y ${PKG_NAME}`;
+    WORKBENCH_DIR = resolve(join(import.meta.dirname, ".."));
+    DEFAULTS = {
+      endpoints: ["service", "admin", "weapp", "app"],
+      docs: {
+        prd: "docs/prd",
+        architecture: "docs/architecture",
+        design: "docs/design",
+        acceptance: "docs/acceptance"
+      },
+      codeRoots: {},
+      machineChecks: { enabled: false },
+      protocolLints: [],
+      moduleMapping: {},
+      feedbackHalfLifeDays: 15,
+      gates: { approvalMode: "warn", writeGate: "observe" },
+      git: { taskTrailer: "off", trailerKey: "Task" },
+      legacyDb: "tasks/task.db",
+      dataDir: ".workbench",
+      cli: WORKBENCH_BIN,
+      pipeline: ["product-manager", "architect", "designer", "developer", "qa"],
+      roleProduces: {
+        "product-manager": [
+          "project",
+          "roles",
+          "glossary",
+          "flow",
+          "module-prd",
+          "page-prd"
+        ],
+        architect: ["db-doc", "api-doc"],
+        designer: ["design-system", "design-prompt", "prototype"],
+        developer: ["code"],
+        qa: ["acceptance"]
+      },
+      platforms: ["claude"],
+      language: "zh"
+    };
+  }
+});
+
+// core/db.ts
+var db_exports = {};
+__export(db_exports, {
+  CURRENT_SCHEMA_VERSION: () => CURRENT_SCHEMA_VERSION,
+  MIGRATIONS: () => MIGRATIONS,
+  SCHEMA_V1: () => SCHEMA_V1,
+  ensureSchema: () => ensureSchema,
+  openWorkbench: () => openWorkbench,
+  openWorkbenchAt: () => openWorkbenchAt
+});
+import Database from "better-sqlite3";
+import { mkdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+function ensureSchema(db) {
+  db.exec(
+    "CREATE TABLE IF NOT EXISTS schema_version (version INTEGER PRIMARY KEY, applied_at DATETIME DEFAULT CURRENT_TIMESTAMP)"
+  );
+  let current = db.prepare("SELECT MAX(version) AS v FROM schema_version").get().v ?? 0;
+  if (current === 0) {
+    const hasArtifacts = db.prepare("SELECT COUNT(*) AS c FROM sqlite_master WHERE type = 'table' AND name = 'artifacts'").get();
+    if (hasArtifacts.c > 0) {
+      const cols = db.prepare("PRAGMA table_info(artifacts)").all().map((c) => c.name);
+      if (!cols.includes("submitted_hash")) {
+        db.exec("ALTER TABLE artifacts ADD COLUMN submitted_hash TEXT");
+      }
+      db.prepare("INSERT INTO schema_version (version) VALUES (1)").run();
+      current = 1;
+    }
+  }
+  for (const m of MIGRATIONS) {
+    if (m.version <= current) continue;
+    const tx = db.transaction(() => {
+      m.up(db);
+      db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(m.version);
+    });
+    tx();
+  }
+}
+function openDb(root, config) {
+  const dataDir = join2(root, config.dataDir);
+  mkdirSync(dataDir, { recursive: true });
+  const db = new Database(join2(dataDir, "workbench.db"));
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.pragma("busy_timeout = 5000");
+  ensureSchema(db);
+  return db;
+}
+function openWorkbench(rootArg) {
+  const root = findProjectRoot(rootArg);
+  const config = loadConfig(root);
+  return { root, config, db: openDb(root, config) };
+}
+function openWorkbenchAt(root) {
+  const config = loadConfig(root);
+  return { root, config, db: openDb(root, config) };
+}
+var SCHEMA_V1, MIGRATION_2, MIGRATIONS, CURRENT_SCHEMA_VERSION;
+var init_db = __esm({
+  "core/db.ts"() {
+    "use strict";
+    init_config();
+    SCHEMA_V1 = `
+CREATE TABLE IF NOT EXISTS artifacts (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  kind          TEXT NOT NULL,
+  module        TEXT,
+  endpoint      TEXT,
+  page          TEXT,
+  path          TEXT NOT NULL UNIQUE,
+  content_hash  TEXT NOT NULL,
+  approved_hash TEXT,
+  reviewed_by   TEXT,
+  reviewed_at   DATETIME,
+  submitted_at  DATETIME,
+  submitted_hash TEXT,
+  created_at    DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at    DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS artifact_edges (
+  id      INTEGER PRIMARY KEY AUTOINCREMENT,
+  from_id INTEGER NOT NULL REFERENCES artifacts(id) ON DELETE CASCADE,
+  to_id   INTEGER NOT NULL REFERENCES artifacts(id) ON DELETE CASCADE,
+  UNIQUE(from_id, to_id)
+);
+
+CREATE TABLE IF NOT EXISTS tasks (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  module     TEXT,
+  role       TEXT NOT NULL,
+  endpoint   TEXT NOT NULL,
+  page       TEXT,
+  type       TEXT NOT NULL DEFAULT 'build',
+  status     TEXT NOT NULL DEFAULT 'pending',
+  assignee   TEXT,
+  creator    TEXT NOT NULL,
+  content    TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  CHECK (role IN ('product-manager', 'architect', 'designer', 'developer', 'qa')),
+  CHECK (type IN ('build', 'review', 'qa', 'hotfix', 'baseline', 'legacy')),
+  CHECK (status IN ('pending', 'in_progress', 'completed', 'cancelled'))
+);
+
+CREATE TABLE IF NOT EXISTS task_inputs (
+  task_id     INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  artifact_id INTEGER NOT NULL REFERENCES artifacts(id),
+  input_hash  TEXT NOT NULL,
+  UNIQUE(task_id, artifact_id)
+);
+
+CREATE TABLE IF NOT EXISTS task_outputs (
+  task_id     INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  artifact_id INTEGER NOT NULL REFERENCES artifacts(id),
+  UNIQUE(task_id, artifact_id)
+);
+
+CREATE TABLE IF NOT EXISTS events (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_type TEXT NOT NULL,
+  entity_id   INTEGER NOT NULL,
+  event       TEXT NOT NULL,
+  actor       TEXT NOT NULL,
+  payload     TEXT,
+  module      TEXT,
+  endpoint    TEXT,
+  page        TEXT,
+  created_at  DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS artifact_feedback (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  artifact_id  INTEGER NOT NULL REFERENCES artifacts(id) ON DELETE CASCADE,
+  task_id      INTEGER REFERENCES tasks(id) ON DELETE SET NULL,
+  verdict      INTEGER NOT NULL CHECK (verdict IN (1, -1)),
+  comment      TEXT,
+  content_hash TEXT NOT NULL,
+  actor        TEXT NOT NULL,
+  created_at   DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_artifacts_coord ON artifacts(module, endpoint, page);
+CREATE INDEX IF NOT EXISTS idx_artifacts_kind ON artifacts(kind);
+CREATE INDEX IF NOT EXISTS idx_tasks_coord ON tasks(module, role, endpoint, status);
+CREATE INDEX IF NOT EXISTS idx_events_entity ON events(entity_type, entity_id);
+CREATE INDEX IF NOT EXISTS idx_feedback_artifact ON artifact_feedback(artifact_id);
+`;
+    MIGRATION_2 = `
+CREATE TABLE tasks_new (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  module       TEXT,
+  role         TEXT NOT NULL,
+  endpoint     TEXT,
+  page         TEXT,
+  type         TEXT NOT NULL DEFAULT 'build',
+  status       TEXT NOT NULL DEFAULT 'pending',
+  assignee     TEXT,
+  creator      TEXT NOT NULL,
+  content      TEXT,
+  external_ref TEXT,
+  created_at   DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at   DATETIME DEFAULT CURRENT_TIMESTAMP,
+  CHECK (status IN ('pending', 'in_progress', 'completed', 'cancelled'))
+);
+INSERT INTO tasks_new (id, module, role, endpoint, page, type, status, assignee, creator, content, external_ref, created_at, updated_at)
+  SELECT id, module, role, endpoint, page, type, status, assignee, creator, content, NULL, created_at, updated_at FROM tasks;
+DROP TABLE tasks;
+ALTER TABLE tasks_new RENAME TO tasks;
+CREATE INDEX idx_tasks_coord ON tasks(module, role, endpoint, status);
+CREATE INDEX IF NOT EXISTS idx_events_module ON events(module);
+CREATE INDEX IF NOT EXISTS idx_events_event ON events(event);
+`;
+    MIGRATIONS = [
+      { version: 1, up: (db) => db.exec(SCHEMA_V1) },
+      {
+        version: 2,
+        up: (db) => {
+          db.pragma("foreign_keys = OFF");
+          db.exec(MIGRATION_2);
+          db.pragma("foreign_keys = ON");
+          const violations = db.pragma("foreign_key_check");
+          if (violations.length > 0) {
+            throw new Error(`\u8FC1\u79FB 2 \u540E\u5916\u952E\u6821\u9A8C\u5931\u8D25: ${JSON.stringify(violations)}`);
+          }
+        }
+      },
+      // 迁移 3:claim 时记录 git HEAD,供 hotfix 契约触碰检测与 trailer 交叉验证
+      { version: 3, up: (db) => db.exec("ALTER TABLE tasks ADD COLUMN claim_commit TEXT") }
+    ];
+    CURRENT_SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;
+  }
+});
+
+// core/types.ts
+var init_types = __esm({
+  "core/types.ts"() {
+    "use strict";
+  }
+});
+
+// core/hash.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "node:fs";
+import { join as join3 } from "node:path";
+function sha1(input) {
+  return createHash("sha1").update(input).digest("hex");
+}
+function isBinary(buf) {
+  const len = Math.min(buf.length, 8192);
+  for (let i = 0; i < len; i++) {
+    if (buf[i] === 0) return true;
+  }
+  return false;
+}
+function hashFile(absPath) {
+  const buf = readFileSync2(absPath);
+  if (isBinary(buf)) return sha1(buf);
+  return sha1(buf.toString("utf-8").replace(/\r\n?/g, "\n"));
+}
+function hashDirectory(absDir) {
+  const entries = [];
+  const walk = (dir, rel) => {
+    for (const name of readdirSync(dir).sort()) {
+      if (IGNORE_DIRS.has(name) || IGNORE_FILES.has(name)) continue;
+      const full = join3(dir, name);
+      const relPath = rel ? `${rel}/${name}` : name;
+      const st = statSync(full);
+      if (st.isDirectory()) {
+        walk(full, relPath);
+      } else {
+        entries.push(`${relPath}:${hashFile(full)}`);
+      }
+    }
+  };
+  walk(absDir, "");
+  return sha1(entries.join("\n"));
+}
+function hashPath(absPath) {
+  if (!existsSync2(absPath)) return null;
+  return statSync(absPath).isDirectory() ? hashDirectory(absPath) : hashFile(absPath);
+}
+var IGNORE_DIRS, IGNORE_FILES;
+var init_hash = __esm({
+  "core/hash.ts"() {
+    "use strict";
+    IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".workbench"]);
+    IGNORE_FILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "package-lock.json", "yarn.lock", ".DS_Store", "Thumbs.db"]);
+  }
+});
+
+// core/events.ts
+var events_exports = {};
+__export(events_exports, {
+  listEvents: () => listEvents,
+  logEvent: () => logEvent
+});
+function logEvent(db, e) {
+  const result = db.prepare(
+    `INSERT INTO events (entity_type, entity_id, event, actor, payload, module, endpoint, page, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, COALESCE(?, CURRENT_TIMESTAMP))`
+  ).run(
+    e.entityType,
+    e.entityId,
+    e.event,
+    e.actor,
+    e.payload === void 0 ? null : JSON.stringify(e.payload),
+    e.module ?? null,
+    e.endpoint ?? null,
+    e.page ?? null,
+    e.createdAt ?? null
+  );
+  return result.lastInsertRowid;
+}
+function listEvents(db, f = {}) {
+  let query = "SELECT * FROM events WHERE 1=1";
+  const params = [];
+  if (f.entityType) {
+    query += " AND entity_type = ?";
+    params.push(f.entityType);
+  }
+  if (f.entityId !== void 0) {
+    query += " AND entity_id = ?";
+    params.push(f.entityId);
+  }
+  if (f.module) {
+    query += " AND module = ?";
+    params.push(f.module);
+  }
+  if (f.event) {
+    query += " AND event = ?";
+    params.push(f.event);
+  }
+  if (f.afterId !== void 0) {
+    query += " AND id > ?";
+    params.push(f.afterId);
+  }
+  query += " ORDER BY id " + (f.afterId !== void 0 ? "ASC" : "DESC");
+  if (f.limit) {
+    query += " LIMIT ?";
+    params.push(f.limit);
+  }
+  return db.prepare(query).all(...params);
+}
+var init_events = __esm({
+  "core/events.ts"() {
+    "use strict";
+  }
+});
+
+// core/platforms.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+function claudeMemory(role, lang) {
+  return lang === "en" ? `# Persistent Agent Memory
+
+With \`memory: project\`, your cross-session memory lives in \`.claude/agent-memory/${role}/\`, indexed by \`MEMORY.md\`. Write directly (no mkdir); verify a memory file exists before relying on it.` : `# \u6301\u4E45\u8BB0\u5FC6(Agent Memory)
+
+\u542F\u7528 \`memory: project\` \u540E,\u4F60\u7684\u8DE8\u4F1A\u8BDD\u8BB0\u5FC6\u5728 \`.claude/agent-memory/${role}/\`,\u4EE5 \`MEMORY.md\` \u4E3A\u7D22\u5F15\u3002\u76F4\u63A5 Write(\u52FF mkdir);\u547D\u540D\u5177\u4F53\u6587\u4EF6\u7684\u8BB0\u5FC6\u4F7F\u7528\u524D\u5148\u9A8C\u8BC1\u5B58\u5728\u3002`;
+}
+function agentsMdMemory(name, lang) {
+  return lang === "en" ? `# Cross-session lessons (AGENTS.md)
+
+${name} has no per-agent memory directory \u2014 the durable layer is \`AGENTS.md\`. Persist the cross-session lessons below by appending them to its relevant section (append only, never overwrite existing instructions).` : `# \u8DE8\u4F1A\u8BDD\u7ECF\u9A8C(\u5199\u5165 AGENTS.md)
+
+${name} \u6CA1\u6709 per-agent \u8BB0\u5FC6\u76EE\u5F55,\u6301\u4E45\u5C42\u662F\u9879\u76EE\u6839 \`AGENTS.md\`\u3002\u628A\u4E0B\u9762\u8FD9\u7C7B\u8DE8\u4F1A\u8BDD\u7ECF\u9A8C\u8FFD\u52A0\u8FDB\u5B83\u7684\u5BF9\u5E94\u5C0F\u8282(\u53EA\u8FFD\u52A0,\u52FF\u8986\u76D6\u65E2\u6709\u6307\u4EE4)\u3002`;
+}
+function cursorMemory(lang) {
+  return lang === "en" ? `# Cross-session lessons (Cursor Memories / rules)
+
+Cursor has no per-agent memory. Persist the cross-session lessons below via Cursor's native Memories (auto-generated & auto-recalled) or a committable rule under \`.cursor/rules/\`.` : `# \u8DE8\u4F1A\u8BDD\u7ECF\u9A8C(Cursor Memories / rules)
+
+Cursor \u65E0 per-agent \u8BB0\u5FC6\u3002\u628A\u4E0B\u9762\u8FD9\u7C7B\u8DE8\u4F1A\u8BDD\u7ECF\u9A8C\u4EA4\u7ED9 Cursor \u539F\u751F Memories(\u81EA\u52A8\u751F\u6210\u3001\u81EA\u52A8\u53EC\u56DE),\u6216\u5199\u8FDB\u53EF\u63D0\u4EA4\u7684 \`.cursor/rules/\` \u89C4\u5219\u6587\u4EF6\u3002`;
+}
+function ensureDir(abs) {
+  mkdirSync2(dirname2(abs), { recursive: true });
+}
+function writeFile(root, rel, content) {
+  const abs = join4(root, rel);
+  ensureDir(abs);
+  writeFileSync(abs, content);
+  return rel;
+}
+function readJson(root, rel) {
+  const abs = join4(root, rel);
+  if (!existsSync3(abs)) return {};
+  try {
+    return JSON.parse(readFileSync3(abs, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function readToml(root, rel) {
+  const abs = join4(root, rel);
+  if (!existsSync3(abs)) return {};
+  try {
+    return parseToml(readFileSync3(abs, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function hasCommand(list, cmd) {
+  if (!Array.isArray(list)) return false;
+  return JSON.stringify(list).includes(cmd);
+}
+function yamlFrontmatter(fields, body) {
+  const fm = fields.map(([k, v]) => `${k}: ${v}`).join("\n");
+  return `---
+${fm}
+---
+
+${body.replace(/^\n+/, "")}
+`;
+}
+function getAdapter(id) {
+  const a = ADAPTERS[id];
+  if (!a) throw new Error(`\u672A\u77E5\u5E73\u53F0: ${id}(\u652F\u6301 ${PLATFORM_IDS.join(", ")})`);
+  return a;
+}
+function resolvePlatforms(platforms) {
+  const ids = platforms && platforms.length ? platforms : ["claude"];
+  return ids.map((id) => getAdapter(id));
+}
+function resolveModel(model, adapter) {
+  if (!model) return adapter.defaultModel;
+  if (typeof model === "string") return model;
+  return model[adapter.id] ?? adapter.defaultModel;
+}
+var PLATFORM_IDS, claude, codex, opencode, cursor, ADAPTERS;
+var init_platforms = __esm({
+  "core/platforms.ts"() {
+    "use strict";
+    PLATFORM_IDS = ["claude", "codex", "opencode", "cursor"];
+    claude = {
+      id: "claude",
+      dotDir: ".claude",
+      agentsDir: ".claude/agents",
+      skillsDir: ".claude/skills",
+      hooksScanDir: ".claude/hooks",
+      defaultModel: "opus",
+      memoryBlock: (role, lang) => claudeMemory(role, lang),
+      notes: [],
+      agentFile: (role) => `${role}.md`,
+      renderAgent: (spec) => yamlFrontmatter(
+        [
+          ["name", spec.name],
+          ["description", spec.description],
+          ["model", spec.model],
+          ["memory", "project"],
+          ["tools", spec.tools.join(", ")]
+        ],
+        spec.body
+      ),
+      writeMcp(root, server) {
+        const rel = ".mcp.json";
+        const json2 = readJson(root, rel);
+        json2.mcpServers = json2.mcpServers ?? {};
+        json2.mcpServers[server.name] = { command: server.command, args: server.args };
+        return writeFile(root, rel, JSON.stringify(json2, null, 2) + "\n");
+      },
+      writeHooks(root, wire) {
+        const rel = ".claude/settings.json";
+        const json2 = readJson(root, rel);
+        json2.hooks = json2.hooks ?? {};
+        const matcher = "Edit|Write|MultiEdit";
+        for (const [event, cmd] of [
+          ["PreToolUse", wire.preCommand],
+          ["PostToolUse", wire.postCommand]
+        ]) {
+          json2.hooks[event] = json2.hooks[event] ?? [];
+          if (!hasCommand(json2.hooks[event], cmd))
+            json2.hooks[event].push({ matcher, hooks: [{ type: "command", command: cmd }] });
+        }
+        return [writeFile(root, rel, JSON.stringify(json2, null, 2) + "\n")];
+      }
+    };
+    codex = {
+      id: "codex",
+      dotDir: ".codex",
+      agentsDir: ".codex/agents",
+      skillsDir: ".agents/skills",
+      hooksScanDir: null,
+      defaultModel: "gpt-5.1-codex",
+      memoryBlock: (_role, lang) => agentsMdMemory("Codex", lang),
+      notes: [
+        'Codex:\u9879\u76EE\u7EA7 .codex/* \u4EC5\u5F53\u9879\u76EE\u88AB\u6807\u8BB0 trusted \u624D\u52A0\u8F7D \u2014\u2014 \u5728 ~/.codex/config.toml \u91CC\u4E3A\u672C\u9879\u76EE\u8BBE trust_level="trusted"',
+        "Codex:skill \u8D70 .agents/skills/(\u975E .codex/skills)"
+      ],
+      agentFile: (role) => `${role}.toml`,
+      renderAgent: (spec) => stringifyToml({
+        name: spec.name,
+        description: spec.description,
+        model: spec.model,
+        developer_instructions: spec.body.replace(/^\n+/, "")
+      }) + "\n",
+      writeMcp(root, server) {
+        const rel = ".codex/config.toml";
+        const cfg = readToml(root, rel);
+        cfg.mcp_servers = cfg.mcp_servers ?? {};
+        cfg.mcp_servers[server.name] = { command: server.command, args: server.args };
+        return writeFile(root, rel, stringifyToml(cfg) + "\n");
+      },
+      writeHooks(root, wire) {
+        const rel = ".codex/config.toml";
+        const cfg = readToml(root, rel);
+        cfg.hooks = cfg.hooks ?? {};
+        for (const [event, cmd] of [
+          ["PreToolUse", wire.preCommand],
+          ["PostToolUse", wire.postCommand]
+        ]) {
+          cfg.hooks[event] = Array.isArray(cfg.hooks[event]) ? cfg.hooks[event] : [];
+          if (!hasCommand(cfg.hooks[event], cmd)) cfg.hooks[event].push({ hooks: [{ command: cmd }] });
+        }
+        return [writeFile(root, rel, stringifyToml(cfg) + "\n")];
+      }
+    };
+    opencode = {
+      id: "opencode",
+      dotDir: ".opencode",
+      agentsDir: ".opencode/agents",
+      skillsDir: ".opencode/skills",
+      hooksScanDir: null,
+      defaultModel: "anthropic/claude-opus-4-8",
+      memoryBlock: (_role, lang) => agentsMdMemory("OpenCode", lang),
+      notes: [
+        "OpenCode:\u6A21\u578B\u4E32\u662F provider/model \u683C\u5F0F(\u89C1 models.dev);API key \u5EFA\u8BAE\u8D70\u73AF\u5883\u53D8\u91CF\u6216 {env:...}"
+      ],
+      agentFile: (role) => `${role}.md`,
+      renderAgent: (spec) => {
+        const canEdit = spec.tools.some((t) => t === "Edit" || t === "Write");
+        const canBash = spec.tools.includes("Bash");
+        const body = spec.body.replace(/^\n+/, "");
+        return `---
+description: ${spec.description}
+mode: subagent
+model: ${spec.model}
+permission:
+  edit: ${canEdit ? "allow" : "deny"}
+  bash: ${canBash ? "allow" : "deny"}
+---
+
+${body}
+`;
+      },
+      writeMcp(root, server) {
+        const rel = "opencode.json";
+        const json2 = readJson(root, rel);
+        json2["$schema"] = json2["$schema"] ?? "https://opencode.ai/config.json";
+        json2.mcp = json2.mcp ?? {};
+        json2.mcp[server.name] = {
+          type: "local",
+          command: [server.command, ...server.args],
+          enabled: true
+        };
+        return writeFile(root, rel, JSON.stringify(json2, null, 2) + "\n");
+      },
+      writeHooks(root, wire) {
+        const rel = ".opencode/plugins/opcflow.ts";
+        const plugin = `// opcflow:\u628A\u5DE5\u5177\u8C03\u7528\u524D\u540E\u4E8B\u4EF6\u8F6C\u53D1\u7ED9 hook \u811A\u672C(\u89C2\u6D4B\u5199\u95E8\u7981 + \u5237\u65B0 hash)
+import { spawn } from "node:child_process"
+
+function runHook(cmd: string, payload: unknown): Promise<void> {
+  return new Promise(resolve => {
+    const parts = cmd.split(" ")
+    const p = spawn(parts[0], parts.slice(1), { stdio: ["pipe", "ignore", "ignore"] })
+    p.on("error", () => resolve())
+    p.on("close", () => resolve())
+    p.stdin.write(JSON.stringify(payload))
+    p.stdin.end()
+  })
+}
+
+export const opcflow = async () => ({
+  "tool.execute.before": async (_input: unknown, output: unknown) => {
+    await runHook(${JSON.stringify(wire.preCommand)}, output)
+  },
+  "tool.execute.after": async (_input: unknown, output: unknown) => {
+    await runHook(${JSON.stringify(wire.postCommand)}, output)
+  }
+})
+`;
+        return [writeFile(root, rel, plugin)];
+      }
+    };
+    cursor = {
+      id: "cursor",
+      dotDir: ".cursor",
+      agentsDir: ".cursor/agents",
+      skillsDir: ".cursor/skills",
+      hooksScanDir: null,
+      defaultModel: "claude-opus-4-8",
+      memoryBlock: (_role, lang) => cursorMemory(lang),
+      notes: [
+        "Cursor:\u4E3B agent \u6A21\u578B\u7531 UI \u9009,--model \u53EA\u4F5C\u7528\u4E8E\u751F\u6210\u7684 subagent(.cursor/agents/*.md)"
+      ],
+      agentFile: (role) => `${role}.md`,
+      renderAgent: (spec) => yamlFrontmatter(
+        [
+          ["name", spec.name],
+          ["description", spec.description],
+          ["model", spec.model]
+        ],
+        spec.body
+      ),
+      writeMcp(root, server) {
+        const rel = ".cursor/mcp.json";
+        const json2 = readJson(root, rel);
+        json2.mcpServers = json2.mcpServers ?? {};
+        json2.mcpServers[server.name] = { command: server.command, args: server.args };
+        return writeFile(root, rel, JSON.stringify(json2, null, 2) + "\n");
+      },
+      writeHooks(root, wire) {
+        const rel = ".cursor/hooks.json";
+        const json2 = readJson(root, rel);
+        json2.version = json2.version ?? 1;
+        json2.hooks = json2.hooks ?? {};
+        for (const [event, cmd] of [
+          ["preToolUse", wire.preCommand],
+          ["afterFileEdit", wire.postCommand]
+        ]) {
+          json2.hooks[event] = Array.isArray(json2.hooks[event]) ? json2.hooks[event] : [];
+          if (!hasCommand(json2.hooks[event], cmd)) json2.hooks[event].push({ command: cmd });
+        }
+        return [writeFile(root, rel, JSON.stringify(json2, null, 2) + "\n")];
+      }
+    };
+    ADAPTERS = { claude, codex, opencode, cursor };
+  }
+});
+
+// core/kind.ts
+var kind_exports = {};
+__export(kind_exports, {
+  DEFAULT_KIND_REGISTRY: () => DEFAULT_KIND_REGISTRY,
+  KIND_TIERS: () => KIND_TIERS,
+  META_KINDS: () => META_KINDS,
+  PM_KINDS: () => PM_KINDS,
+  contractKinds: () => contractKinds,
+  getKindRegistry: () => getKindRegistry,
+  inferKind: () => inferKind,
+  kindSpec: () => kindSpec,
+  normalizeModule: () => normalizeModule
+});
+function getKindRegistry(config) {
+  const merged = { ...DEFAULT_KIND_REGISTRY };
+  if (config.kinds) {
+    for (const [kind, override] of Object.entries(config.kinds)) {
+      const base = merged[kind];
+      if (base) merged[kind] = { ...base, ...override };
+    }
+  }
+  const adapters = resolvePlatforms(config.platforms);
+  const uniq = (xs) => [...new Set(xs)];
+  merged["agent-def"] = { ...merged["agent-def"], pathPatterns: uniq(adapters.map((a) => `${a.agentsDir}/`)) };
+  merged.skill = { ...merged.skill, pathPatterns: uniq(adapters.map((a) => `${a.skillsDir}/`)) };
+  merged["hook-script"] = {
+    ...merged["hook-script"],
+    pathPatterns: uniq(adapters.map((a) => a.hooksScanDir).filter((d) => !!d).map((d) => `${d}/`))
+  };
+  return merged;
+}
+function kindSpec(config, kind) {
+  return getKindRegistry(config)[kind] ?? DEFAULT_KIND_REGISTRY.doc;
+}
+function contractKinds(config) {
+  const reg = getKindRegistry(config);
+  return Object.keys(reg).filter((k) => reg[k].approval === "human" && !reg[k].meta);
+}
+function expandPattern(pattern, config) {
+  return pattern.replace("{prd}", config.docs.prd).replace("{architecture}", config.docs.architecture).replace("{design}", config.docs.design).replace("{acceptance}", config.docs.acceptance);
+}
+function inferKind(relPath, config) {
+  const p = relPath.replace(/\\/g, "/");
+  const registry = getKindRegistry(config);
+  for (const [kind, spec] of Object.entries(registry)) {
+    for (const raw of spec.pathPatterns ?? []) {
+      const pattern = expandPattern(raw, config);
+      if (pattern.endsWith("/") ? p.startsWith(pattern) : p === pattern) return kind;
+    }
+  }
+  if (p.endsWith(".html")) return "prototype";
+  if (p.endsWith(".md")) return "doc";
+  return "code";
+}
+function normalizeModule(module, config) {
+  if (!module) return null;
+  return config.moduleMapping[module] ?? module;
+}
+var DEFAULT_KIND_REGISTRY, META_KINDS, PM_KINDS, KIND_TIERS;
+var init_kind = __esm({
+  "core/kind.ts"() {
+    "use strict";
+    init_platforms();
+    DEFAULT_KIND_REGISTRY = {
+      // 元产物在前:与业务路径无重叠,但显式优先更稳
+      "agent-def": { level: "project", approval: "human", parents: [], drivesStale: false, hashMode: "text-normalize", retrieval: "full", meta: true, pathPatterns: [".claude/agents/"] },
+      skill: { level: "project", approval: "human", parents: [], drivesStale: false, hashMode: "text-normalize", retrieval: "full", meta: true, pathPatterns: [".claude/skills/"] },
+      "hook-script": { level: "project", approval: "human", parents: [], drivesStale: false, hashMode: "text-normalize", retrieval: "full", meta: true, pathPatterns: [".claude/hooks/"] },
+      plan: { level: "project", approval: "human", parents: [], drivesStale: false, hashMode: "text-normalize", retrieval: "summary", meta: true, pathPatterns: ["docs/workbench/PLAN.md"] },
+      baseline: { level: "project", approval: "human", parents: [], drivesStale: true, hashMode: "text-normalize", retrieval: "summary", pathPatterns: ["ARCHITECTURE.md", "TECH.md"] },
+      project: { level: "project", approval: "human", parents: [], drivesStale: true, hashMode: "text-normalize", retrieval: "summary", pathPatterns: ["{prd}/project.md"] },
+      roles: { level: "project", approval: "human", parents: ["project"], drivesStale: true, hashMode: "text-normalize", retrieval: "full", pathPatterns: ["{prd}/roles.md"] },
+      glossary: { level: "project", approval: "human", parents: ["project"], drivesStale: true, hashMode: "text-normalize", retrieval: "full", pathPatterns: ["{prd}/glossary.md"] },
+      flow: { level: "module", approval: "human", parents: ["project", "roles", "glossary"], drivesStale: true, hashMode: "text-normalize", retrieval: "full", pathPatterns: ["{prd}/flows/"] },
+      "module-prd": { level: "module", approval: "human", parents: ["flow"], drivesStale: true, hashMode: "text-normalize", retrieval: "full", pathPatterns: ["{prd}/modules/"] },
+      "page-prd": { level: "page", approval: "human", parents: ["module-prd"], drivesStale: true, hashMode: "text-normalize", retrieval: "full", pathPatterns: ["{prd}/pages/"] },
+      "db-doc": { level: "module", approval: "human", parents: ["module-prd"], drivesStale: true, hashMode: "text-normalize", retrieval: "full", pathPatterns: ["{architecture}/database/"] },
+      "api-doc": { level: "module", approval: "human", parents: ["module-prd", "db-doc"], drivesStale: true, hashMode: "text-normalize", retrieval: "full", pathPatterns: ["{architecture}/api/"] },
+      "design-system": { level: "endpoint", approval: "human", parents: ["baseline"], drivesStale: true, hashMode: "text-normalize", retrieval: "full", pathPatterns: ["{design}/systems/"] },
+      "design-prompt": { level: "page", approval: "none", parents: ["page-prd", "api-doc", "design-system"], drivesStale: false, hashMode: "text-normalize", retrieval: "summary", pathPatterns: ["{design}/prompts/"] },
+      prototype: { level: "page", approval: "thumbs", parents: ["design-prompt", "design-system"], drivesStale: true, hashMode: "text-normalize", retrieval: "summary", pathPatterns: ["{design}/prototypes/"] },
+      acceptance: { level: "page", approval: "human", parents: ["page-prd", "prototype"], drivesStale: true, hashMode: "text-normalize", retrieval: "full", pathPatterns: ["{acceptance}/"] },
+      code: { level: "module", approval: "machine", parents: ["baseline", "api-doc", "prototype"], drivesStale: false, hashMode: "directory", retrieval: "semantic" },
+      doc: { level: "module", approval: "none", parents: [], drivesStale: false, hashMode: "text-normalize", retrieval: "summary" }
+    };
+    META_KINDS = Object.keys(DEFAULT_KIND_REGISTRY).filter(
+      (k) => DEFAULT_KIND_REGISTRY[k].meta
+    );
+    PM_KINDS = ["project", "roles", "glossary", "flow", "module-prd", "page-prd"];
+    KIND_TIERS = [
+      ["baseline", "project", "roles", "glossary"],
+      ["flow"],
+      ["module-prd"],
+      ["page-prd"],
+      ["db-doc", "api-doc", "design-system"],
+      ["design-prompt"],
+      ["prototype", "acceptance"],
+      ["code"]
+    ];
+  }
+});
+
+// core/derive.ts
+var derive_exports = {};
+__export(derive_exports, {
+  everApproved: () => everApproved,
+  moduleCleared: () => moduleCleared,
+  prototypeEndorsed: () => prototypeEndorsed,
+  reviewStatus: () => reviewStatus,
+  taskStaleness: () => taskStaleness
+});
+function reviewStatus(a) {
+  if (a.approved_hash !== null && a.approved_hash === a.content_hash) return "approved";
+  if (a.submitted_hash !== null && a.submitted_hash === a.content_hash) return "pending";
+  if (a.approved_hash !== null) return "invalidated";
+  return "draft";
+}
+function everApproved(a) {
+  return a.approved_hash !== null;
+}
+function taskStaleness(db, taskId) {
+  const rows = db.prepare(
+    `SELECT ti.artifact_id, ti.input_hash, a.path, a.content_hash
+       FROM task_inputs ti JOIN artifacts a ON a.id = ti.artifact_id
+       WHERE ti.task_id = ?`
+  ).all(taskId);
+  const changed = rows.filter((r) => r.input_hash !== r.content_hash).map((r) => ({ artifactId: r.artifact_id, path: r.path, inputHash: r.input_hash, currentHash: r.content_hash }));
+  return { stale: changed.length > 0, changed };
+}
+function moduleCleared(db, module) {
+  const rows = db.prepare("SELECT approved_hash, content_hash, submitted_hash FROM artifacts WHERE kind = 'module-prd' AND module = ?").all(module);
+  return rows.some((r) => reviewStatus(r) === "approved");
+}
+function prototypeEndorsed(db, artifact) {
+  if (artifact.kind !== "prototype") return false;
+  const row = db.prepare(
+    `SELECT COUNT(*) AS c FROM artifact_feedback
+       WHERE artifact_id = ? AND verdict = 1 AND content_hash = ?`
+  ).get(artifact.id, artifact.content_hash);
+  return row.c > 0;
+}
+var init_derive = __esm({
+  "core/derive.ts"() {
+    "use strict";
+  }
+});
+
+// core/lints.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+function walkFiles(abs, rel, out) {
+  const st = statSync2(abs);
+  if (st.isFile()) {
+    out.push(rel);
+    return;
+  }
+  for (const name of readdirSync2(abs).sort()) {
+    if (IGNORE.has(name) || name.startsWith(".")) continue;
+    walkFiles(join5(abs, name), `${rel}/${name}`, out);
+  }
+}
+function runProtocolLints(ctx, scope) {
+  const violations = [];
+  const rules = ctx.config.protocolLints.filter((rule) => {
+    const ruleRole = rule.role ?? "developer";
+    if (ruleRole !== scope.role) return false;
+    if (rule.endpoint && scope.endpoint && rule.endpoint !== scope.endpoint) return false;
+    if (rule.endpoint && !scope.endpoint) return false;
+    return true;
+  });
+  for (const rule of rules) {
+    const regex = new RegExp(rule.grep);
+    const allow = new Set((rule.allow ?? []).map((p) => p.replace(/\\/g, "/")));
+    for (const base of rule.paths) {
+      const abs = join5(ctx.root, base);
+      if (!existsSync4(abs)) continue;
+      const files = [];
+      walkFiles(abs, base.replace(/\\/g, "/"), files);
+      for (const file of files) {
+        if (allow.has(file)) continue;
+        if (/\.(png|jpg|jpeg|gif|webp|woff2?|ttf|ico|db)$/i.test(file)) continue;
+        const lines = readFileSync4(join5(ctx.root, file), "utf-8").split("\n");
+        lines.forEach((text, i) => {
+          if (regex.test(text)) {
+            violations.push({
+              lint: rule.name,
+              file,
+              line: i + 1,
+              text: text.trim().slice(0, 120),
+              message: rule.message ?? rule.name
+            });
+          }
+        });
+      }
+    }
+  }
+  return violations;
+}
+var IGNORE;
+var init_lints = __esm({
+  "core/lints.ts"() {
+    "use strict";
+    IGNORE = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".workbench"]);
+  }
+});
+
+// core/gates.ts
+import { execSync } from "node:child_process";
+function findByKinds(ctx, kinds, f) {
+  if (kinds.length === 0) return [];
+  let query = `SELECT * FROM artifacts WHERE kind IN (${kinds.map(() => "?").join(",")})`;
+  const params = [...kinds];
+  if (f.module) {
+    query += " AND module = ?";
+    params.push(f.module);
+  }
+  if (f.endpoint) {
+    query += " AND endpoint = ?";
+    params.push(f.endpoint);
+  }
+  if (f.page) {
+    query += " AND page = ?";
+    params.push(f.page);
+  }
+  return ctx.db.prepare(query).all(...params);
+}
+function levelFilter(level, task) {
+  switch (level) {
+    case "project":
+      return {};
+    case "module":
+      return { module: task.module };
+    case "endpoint":
+      return { endpoint: task.endpoint };
+    case "page":
+      return { module: task.module, endpoint: task.endpoint, page: task.page };
+  }
+}
+function producedKinds(ctx, task) {
+  const declared = ctx.config.roleProduces[task.role] ?? [];
+  if (task.role === "designer") {
+    return task.page ? declared.filter((k) => k !== "design-system") : ["design-system"];
+  }
+  return declared;
+}
+function existRequirements(task) {
+  const m = task.module;
+  switch (task.role) {
+    case "architect":
+    case "designer":
+      return [{ desc: "PM \u4EA7\u51FA(\u6A21\u5757/\u9875\u9762 PRD)", level: "exist", kinds: PM_KINDS, filter: { module: m } }];
+    case "developer": {
+      if (task.endpoint === "service") {
+        return [{ desc: "\u6570\u636E\u5E93\u6587\u6863", level: "exist", kinds: ["db-doc"], filter: { module: m } }];
+      }
+      return [
+        { desc: "\u6570\u636E\u5E93\u6587\u6863", level: "exist", kinds: ["db-doc"], filter: { module: m } },
+        { desc: "API \u6587\u6863", level: "exist", kinds: ["api-doc"], filter: { module: m } },
+        { desc: `designer ${task.endpoint} \u8BBE\u8BA1\u7A3F`, level: "exist", kinds: ["design-prompt", "prototype"], filter: { module: m, endpoint: task.endpoint } }
+      ];
+    }
+    default:
+      return [];
+  }
+}
+function approvedRequirements(ctx, task) {
+  const registry = getKindRegistry(ctx.config);
+  const produced = producedKinds(ctx, task);
+  const parentSet = /* @__PURE__ */ new Set();
+  for (const kind of produced) {
+    for (const parent of registry[kind]?.parents ?? []) {
+      if (!produced.includes(parent)) parentSet.add(parent);
+    }
+  }
+  const reqs = [];
+  for (const parent of parentSet) {
+    const spec = registry[parent];
+    if (!spec || spec.approval === "none" || spec.approval === "machine") continue;
+    if (spec.level === "page" && !task.page) continue;
+    if (spec.level === "endpoint" && !task.endpoint) continue;
+    if (spec.level === "module" && !task.module) continue;
+    reqs.push({
+      desc: `\u4E0A\u6E38 ${parent} \u5DF2\u8FBE\u4FE1\u4EFB\u72B6\u6001(${spec.approval === "thumbs" ? "\u{1F44D} \u653E\u884C" : "approved"})`,
+      level: "approved",
+      kinds: [parent],
+      filter: levelFilter(spec.level, task)
+    });
+  }
+  return reqs;
+}
+function claimRequirements(ctx, task) {
+  if (task.type !== "build" && task.type !== "qa") return [];
+  if (task.role === "product-manager") return [];
+  return [...existRequirements(task), ...approvedRequirements(ctx, task)];
+}
+function requirementSatisfied(ctx, req, matched) {
+  if (req.level === "exist") return matched.length > 0;
+  if (matched.length === 0) return false;
+  return matched.some(
+    (a) => kindSpec(ctx.config, a.kind).approval === "thumbs" ? prototypeEndorsed(ctx.db, a) : reviewStatus(a) === "approved"
+  );
+}
+function validateClaim(ctx, task) {
+  const warnings = [];
+  const inputs = /* @__PURE__ */ new Map();
+  const mode = ctx.config.gates.approvalMode;
+  if (task.role === "qa" && task.type === "qa") {
+    const dev = ctx.db.prepare(
+      `SELECT COUNT(*) AS c FROM tasks
+         WHERE role = 'developer' AND status = 'completed' AND module IS ? AND endpoint IS ?
+           AND (? IS NULL OR page IS ?)`
+    ).get(task.module, task.endpoint, task.page, task.page);
+    if (dev.c === 0) {
+      throw new Error(`[\u524D\u7F6E\u6761\u4EF6] \u5BF9\u5E94\u7684 developer ${task.endpoint} \u4EFB\u52A1\u5C1A\u672A\u5B8C\u6210,\u65E0\u6CD5\u9886\u53D6 qa \u4EFB\u52A1\u3002`);
+    }
+  }
+  if (task.module && (task.type === "build" || task.type === "hotfix") && !moduleCleared(ctx.db, task.module)) {
+    warnings.push(
+      `[\u6E05\u7B97] \u6A21\u5757 ${task.module} \u672A\u6E05\u7B97(module-prd \u672A\u5BA1\u6279)\u3002\u5EFA\u8BAE\u5148\u5BF9\u8D26:${ctx.config.cli} audit --module=${task.module}`
+    );
+  }
+  for (const req of claimRequirements(ctx, task)) {
+    const matched = findByKinds(ctx, req.kinds, req.filter);
+    for (const a of matched) {
+      if (kindSpec(ctx.config, a.kind).drivesStale) inputs.set(a.id, a);
+    }
+    if (requirementSatisfied(ctx, req, matched)) continue;
+    if (req.level === "exist") {
+      throw new Error(`[\u524D\u7F6E\u6761\u4EF6] ${req.desc} \u4E0D\u5B58\u5728,\u65E0\u6CD5\u9886\u53D6\u4EFB\u52A1\u3002`);
+    }
+    const msg = `[\u4FE1\u4EFB\u8B66\u544A] ${req.desc}:\u672A\u6EE1\u8DB3`;
+    if (mode === "enforce") throw new Error(`[\u524D\u7F6E\u6761\u4EF6] ${msg}`);
+    warnings.push(msg);
+  }
+  for (const b of findByKinds(ctx, ["baseline"], {})) inputs.set(b.id, b);
+  return { warnings, inputs: [...inputs.values()] };
+}
+function completeOutputRequirement(ctx, task) {
+  if (task.role === "developer" || task.role === "qa") return null;
+  const kinds = producedKinds(ctx, task);
+  if (kinds.length === 0) return null;
+  const spec = kindSpec(ctx.config, kinds[0]);
+  return { desc: `${task.role} \u4EA7\u51FA`, level: "exist", kinds, filter: levelFilter(spec.level === "page" && !task.page ? "module" : spec.level, task) };
+}
+function validateComplete(ctx, task, status, opts = {}) {
+  const warnings = [];
+  if (status !== "completed") return { warnings, inputs: [] };
+  if (task.role !== "product-manager" && task.assignee === null) {
+    throw new Error(`\u4EFB\u52A1\u5C1A\u672A\u88AB\u9886\u53D6,\u65E0\u6CD5\u66F4\u65B0\u72B6\u6001`);
+  }
+  if (task.type === "legacy") return { warnings, inputs: [] };
+  const staleness = taskStaleness(ctx.db, task.id);
+  if (staleness.stale) {
+    const detail = staleness.changed.map((c) => c.path).join(", ");
+    if (!opts.force) {
+      throw new Error(`[\u524D\u7F6E\u6761\u4EF6] \u4EFB\u52A1\u5DF2 stale(\u4E0A\u6E38\u53D8\u66F4: ${detail})\u3002\u8BF7\u5148\u5BF9\u9F50\u53D8\u66F4,\u6216 --force=true \u653E\u884C(\u7559\u75D5)\u3002`);
+    }
+    warnings.push(`[\u5F3A\u5236\u653E\u884C] \u5FFD\u7565 stale \u4E0A\u6E38: ${detail}`);
+  }
+  const req = completeOutputRequirement(ctx, task);
+  if (req) {
+    const linked = ctx.db.prepare("SELECT COUNT(*) AS c FROM task_outputs WHERE task_id = ?").get(task.id);
+    if (linked.c === 0) {
+      const matched = findByKinds(ctx, req.kinds, req.filter);
+      if (matched.length === 0) {
+        throw new Error(`[\u524D\u7F6E\u6761\u4EF6] ${task.role} \u4EFB\u52A1\u5FC5\u987B\u6DFB\u52A0\u4EA7\u51FA\u6587\u4EF6\u540E\u624D\u80FD\u6807\u8BB0\u4E3A\u5B8C\u6210\u3002`);
+      }
+    }
+  }
+  if (task.role === "designer" && task.type === "build" && task.page) {
+    const prototypes = findByKinds(ctx, ["prototype"], { module: task.module, endpoint: task.endpoint, page: task.page });
+    const endorsed = prototypes.some((p) => prototypeEndorsed(ctx.db, p));
+    if (!endorsed) {
+      const msg = "[\u4FE1\u4EFB\u8B66\u544A] \u539F\u578B\u5C1A\u672A\u83B7\u5F97 \u{1F44D} \u653E\u884C";
+      if (ctx.config.gates.approvalMode === "enforce") throw new Error(`[\u524D\u7F6E\u6761\u4EF6] ${msg}`);
+      warnings.push(msg);
+    }
+  }
+  if (task.role === "developer" || task.role === "architect") {
+    const violations = runProtocolLints(ctx, { role: task.role, endpoint: task.endpoint });
+    if (violations.length > 0) {
+      const detail = violations.slice(0, 10).map((v) => `  ${v.file}:${v.line} [${v.lint}] ${v.message}
+    ${v.text}`).join("\n");
+      throw new Error(
+        `[\u534F\u8BAE lint \u5931\u8D25] ${violations.length} \u5904\u8FDD\u4F8B,\u4FEE\u590D\u540E\u518D\u5B8C\u6210:
+${detail}${violations.length > 10 ? `
+  ...\u7B49 ${violations.length} \u5904` : ""}`
+      );
+    }
+  }
+  if (task.role === "developer" && task.endpoint && ctx.config.machineChecks.enabled) {
+    const cmds = ctx.config.machineChecks[task.endpoint];
+    if (Array.isArray(cmds)) {
+      for (const cmd of cmds) {
+        try {
+          execSync(cmd, { cwd: ctx.root, stdio: "pipe" });
+        } catch (err) {
+          const e = err;
+          const detail = `${e.stdout ?? ""}${e.stderr ?? ""}`.slice(-2e3) || String(err);
+          throw new Error(`[\u673A\u5668\u68C0\u67E5\u5931\u8D25] ${cmd}
+${detail}`);
+        }
+      }
+    }
+  }
+  return { warnings, inputs: [] };
+}
+var init_gates = __esm({
+  "core/gates.ts"() {
+    "use strict";
+    init_derive();
+    init_kind();
+    init_lints();
+  }
+});
+
+// core/tree.ts
+function worse(a, b) {
+  return HEALTH_RANK[a] >= HEALTH_RANK[b] ? a : b;
+}
+function coordFailed(ctx, module, endpoint, page) {
+  const row = ctx.db.prepare(
+    `SELECT event FROM events
+       WHERE event IN ('qa_passed', 'qa_failed', 'machine_check_failed')
+         AND module IS ? AND (? IS NULL OR endpoint IS ?) AND (? IS NULL OR page IS ?)
+       ORDER BY id DESC LIMIT 1`
+  ).get(module, endpoint, endpoint, page, page);
+  return row !== void 0 && row.event !== "qa_passed";
+}
+function taskBlocked(ctx, task) {
+  if (task.status !== "pending" || task.type === "legacy") return false;
+  try {
+    validateClaim(ctx, task);
+    return false;
+  } catch (err) {
+    return err instanceof Error && err.message.includes("\u4E0D\u5B58\u5728");
+  }
+}
+function coordHealth(ctx, artifacts, tasks) {
+  let health = "ok";
+  if (artifacts.some((a) => a.review_status === "invalidated")) health = worse(health, "stale");
+  if (tasks.some((t) => t.status !== "completed" && t.status !== "cancelled" && t.stale)) health = worse(health, "stale");
+  if (tasks.some((t) => taskBlocked(ctx, t))) health = worse(health, "blocked");
+  return health;
+}
+function coordPhase(ctx, tasks) {
+  const en = ctx.config.language === "en";
+  if (tasks.length === 0) return en ? "not dispatched" : "\u672A\u6D3E\u53D1";
+  const labels = STATUS_LABEL[en ? "en" : "zh"];
+  for (const role of ctx.config.pipeline) {
+    const roleTasks = tasks.filter((t) => t.role === role && t.status !== "cancelled");
+    if (roleTasks.length === 0) continue;
+    const unfinished = roleTasks.find((t) => t.status !== "completed");
+    if (unfinished) return `${role} ${labels[unfinished.status] ?? unfinished.status}`;
+  }
+  return en ? "all done" : "\u5168\u90E8\u5B8C\u6210";
+}
+function decorate(ctx, a) {
+  return {
+    ...a,
+    review_status: reviewStatus(a),
+    ever_approved: everApproved(a),
+    endorsed: a.kind === "prototype" ? prototypeEndorsed(ctx.db, a) : false
+  };
+}
+function buildTree(ctx, opts = {}) {
+  const registry = getKindRegistry(ctx.config);
+  const artifacts = ctx.db.prepare("SELECT * FROM artifacts ORDER BY path").all().filter((a) => opts.includeMeta || !registry[a.kind]?.meta).map((a) => decorate(ctx, a));
+  const tasks = ctx.db.prepare("SELECT * FROM tasks ORDER BY id").all().map((t) => ({
+    ...t,
+    stale: t.status === "completed" || t.status === "cancelled" ? false : taskStaleness(ctx.db, t.id).stale
+  }));
+  const moduleNames = [
+    ...new Set([...artifacts.map((a) => a.module), ...tasks.map((t) => t.module)].filter((m) => !!m))
+  ].sort();
+  const makeCounts = (as, ts) => ({
+    artifacts: as.length,
+    tasksDone: ts.filter((t) => t.status === "completed").length,
+    tasksTotal: ts.filter((t) => t.status !== "cancelled").length
+  });
+  const moduleNodes = moduleNames.map((module) => {
+    const mArtifacts = artifacts.filter((a) => a.module === module);
+    const mTasks = tasks.filter((t) => t.module === module);
+    const endpoints = [
+      ...new Set([...mArtifacts.map((a) => a.endpoint), ...mTasks.map((t) => t.endpoint)].filter((e) => !!e))
+    ].sort();
+    const endpointNodes = endpoints.map((endpoint) => {
+      const eArtifacts = mArtifacts.filter((a) => a.endpoint === endpoint);
+      const eTasks = mTasks.filter((t) => t.endpoint === endpoint);
+      const pages = [
+        ...new Set([...eArtifacts.map((a) => a.page), ...eTasks.map((t) => t.page)].filter((p) => !!p))
+      ].sort();
+      const pageNodes = pages.map((page) => {
+        const pArtifacts = eArtifacts.filter((a) => a.page === page);
+        const pTasks = eTasks.filter((t) => t.page === page);
+        let health3 = coordHealth(ctx, pArtifacts, pTasks);
+        if (coordFailed(ctx, module, endpoint, page)) health3 = "failed";
+        return {
+          key: `${module}/${endpoint}/${page}`,
+          title: page.includes("/") ? page.split("/").pop() : page,
+          level: "page",
+          module,
+          endpoint,
+          page,
+          health: health3,
+          phase: coordPhase(ctx, pTasks),
+          counts: makeCounts(pArtifacts, pTasks),
+          children: []
+        };
+      });
+      let health2 = coordHealth(
+        ctx,
+        eArtifacts.filter((a) => !a.page),
+        eTasks.filter((t) => !t.page)
+      );
+      for (const child of pageNodes) health2 = worse(health2, child.health);
+      return {
+        key: `${module}/${endpoint}`,
+        title: endpoint,
+        level: "endpoint",
+        module,
+        endpoint,
+        page: null,
+        health: health2,
+        phase: coordPhase(ctx, eTasks),
+        counts: makeCounts(eArtifacts, eTasks),
+        children: pageNodes
+      };
+    });
+    let health = coordHealth(
+      ctx,
+      mArtifacts.filter((a) => !a.endpoint),
+      mTasks.filter((t) => !t.endpoint)
+    );
+    for (const child of endpointNodes) health = worse(health, child.health);
+    if (coordFailed(ctx, module, null, null)) health = "failed";
+    return {
+      key: module,
+      title: module,
+      level: "module",
+      module,
+      endpoint: null,
+      page: null,
+      health,
+      phase: coordPhase(ctx, mTasks),
+      counts: makeCounts(mArtifacts, mTasks),
+      children: endpointNodes
+    };
+  });
+  const bucket = (key, title, rows) => rows.length > 0 ? {
+    key,
+    title,
+    level: "endpoint",
+    module: null,
+    endpoint: null,
+    page: null,
+    health: rows.some((a) => a.review_status === "invalidated") ? "stale" : "ok",
+    phase: "-",
+    counts: { artifacts: rows.length, tasksDone: 0, tasksTotal: 0 },
+    children: []
+  } : null;
+  const en = ctx.config.language === "en";
+  const projectLevel = artifacts.filter((a) => !a.module);
+  const projectBucket = bucket("__project__", en ? "Project contracts" : "\u9879\u76EE\u7EA7\u5951\u7EA6", projectLevel.filter((a) => !registry[a.kind]?.meta));
+  const metaBucket = bucket("__meta__", en ? "Meta (agent/skill/plan)" : "\u5143\u4EA7\u7269(agent/skill/plan)", projectLevel.filter((a) => registry[a.kind]?.meta));
+  let rootHealth = "ok";
+  for (const b of [projectBucket, metaBucket]) if (b) rootHealth = worse(rootHealth, b.health);
+  for (const m of moduleNodes) rootHealth = worse(rootHealth, m.health);
+  return {
+    key: "__root__",
+    title: en ? "Project" : "\u9879\u76EE",
+    level: "project",
+    module: null,
+    endpoint: null,
+    page: null,
+    health: rootHealth,
+    phase: "-",
+    counts: makeCounts(artifacts, tasks),
+    children: [...projectBucket ? [projectBucket] : [], ...metaBucket ? [metaBucket] : [], ...moduleNodes]
+  };
+}
+function nodeDetail(ctx, f) {
+  const registry = getKindRegistry(ctx.config);
+  let aq = "SELECT * FROM artifacts WHERE 1=1";
+  let tq = "SELECT * FROM tasks WHERE 1=1";
+  const ap = [];
+  const tp = [];
+  if (f.module !== void 0) {
+    aq += " AND module IS ?";
+    tq += " AND module IS ?";
+    ap.push(f.module);
+    tp.push(f.module);
+  }
+  if (f.endpoint != null) {
+    aq += " AND endpoint IS ?";
+    tq += " AND endpoint IS ?";
+    ap.push(f.endpoint);
+    tp.push(f.endpoint);
+  }
+  if (f.page != null) {
+    aq += " AND page IS ?";
+    tq += " AND page IS ?";
+    ap.push(f.page);
+    tp.push(f.page);
+  }
+  const artifacts = ctx.db.prepare(aq + " ORDER BY kind, path").all(...ap).filter((a) => {
+    const isMeta = !!registry[a.kind]?.meta;
+    if (f.metaOnly) return isMeta;
+    return f.includeMeta || !isMeta;
+  }).map((a) => decorate(ctx, a));
+  const tasks = ctx.db.prepare(tq + " ORDER BY id DESC").all(...tp).map((t) => ({
+    ...t,
+    stale: t.status === "completed" || t.status === "cancelled" ? false : taskStaleness(ctx.db, t.id).stale
+  }));
+  return { artifacts, tasks };
+}
+var HEALTH_RANK, STATUS_LABEL;
+var init_tree = __esm({
+  "core/tree.ts"() {
+    "use strict";
+    init_derive();
+    init_gates();
+    init_kind();
+    HEALTH_RANK = { ok: 0, stale: 1, blocked: 2, failed: 3 };
+    STATUS_LABEL = {
+      zh: { pending: "\u5F85\u9886\u53D6", in_progress: "\u8FDB\u884C\u4E2D", completed: "\u5DF2\u5B8C\u6210", cancelled: "\u5DF2\u53D6\u6D88" },
+      en: { pending: "unclaimed", in_progress: "in progress", completed: "done", cancelled: "cancelled" }
+    };
+  }
+});
+
+// core/git.ts
+import { execFileSync } from "node:child_process";
+function gitHead(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "HEAD"], { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+  } catch {
+    return null;
+  }
+}
+function touchedSince(cwd, sinceCommit) {
+  const files = /* @__PURE__ */ new Set();
+  try {
+    if (sinceCommit) {
+      const out = execFileSync("git", ["diff", "--name-only", `${sinceCommit}..HEAD`], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString();
+      for (const line of out.split("\n")) if (line.trim()) files.add(line.trim());
+    }
+    const status = execFileSync("git", ["status", "--porcelain"], { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString();
+    for (const line of status.split("\n")) {
+      const p = line.slice(3).trim().replace(/^"|"$/g, "");
+      if (p) files.add(p);
+    }
+  } catch {
+  }
+  return [...files];
+}
+function headCommitInfo(cwd, trailerKey) {
+  try {
+    const hash = execFileSync("git", ["rev-parse", "HEAD"], { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    const trailer = execFileSync("git", ["log", "-1", `--format=%(trailers:key=${trailerKey},valueonly)`], {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    const files = execFileSync("git", ["show", "--name-only", "--format=", "HEAD"], {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().split("\n").map((l) => l.trim()).filter(Boolean);
+    return { hash, trailer: trailer || null, files };
+  } catch {
+    return null;
+  }
+}
+function touchedByTaskTrailer(cwd, sinceCommit, trailerKey, taskId) {
+  const files = /* @__PURE__ */ new Set();
+  try {
+    const log = execFileSync(
+      "git",
+      ["log", "--format=%H%x00%(trailers:key=" + trailerKey + ",valueonly)", `${sinceCommit}..HEAD`],
+      { cwd, stdio: ["ignore", "pipe", "ignore"] }
+    ).toString();
+    const mine = [];
+    for (const line of log.split("\n")) {
+      const [hash, trailer] = line.split("\0");
+      if (hash && trailer?.trim() === `#${taskId}`) mine.push(hash);
+    }
+    for (const hash of mine) {
+      const out = execFileSync("git", ["show", "--name-only", "--format=", hash], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString();
+      for (const line of out.split("\n")) if (line.trim()) files.add(line.trim());
+    }
+  } catch {
+  }
+  return [...files];
+}
+var init_git = __esm({
+  "core/git.ts"() {
+    "use strict";
+  }
+});
+
+// core/gh.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+function closeLinkedIssue(ctx, externalRef, taskId) {
+  const match = externalRef.match(/^gh#(\d+)$/);
+  if (!match) return false;
+  try {
+    execFileSync2("gh", ["issue", "close", match[1], "--comment", `\u5DF2\u5904\u7406,\u5173\u8054\u4EFB\u52A1 #${taskId}`], {
+      cwd: ctx.root,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_gh = __esm({
+  "core/gh.ts"() {
+    "use strict";
+  }
+});
+
+// core/commands/artifact.commands.ts
+var artifact_commands_exports = {};
+__export(artifact_commands_exports, {
+  approveArtifact: () => approveArtifact,
+  approvedContent: () => approvedContent,
+  feedbackArtifact: () => feedbackArtifact,
+  listArtifacts: () => listArtifacts,
+  moveArtifact: () => moveArtifact,
+  normalizeRelPath: () => normalizeRelPath,
+  refreshArtifact: () => refreshArtifact,
+  registerOutput: () => registerOutput,
+  rejectArtifact: () => rejectArtifact,
+  resolveArtifact: () => resolveArtifact,
+  submitArtifact: () => submitArtifact
+});
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, realpathSync, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { isAbsolute, join as join6, relative } from "node:path";
+function normalizeRelPath(ctx, p) {
+  let abs = isAbsolute(p) ? p : join6(ctx.root, p);
+  if (existsSync5(abs)) {
+    try {
+      abs = realpathSync.native(abs);
+    } catch {
+    }
+  }
+  return relative(realpathSync.native(ctx.root), abs).replace(/\\/g, "/");
+}
+function dumpApprovals(ctx) {
+  const rows = ctx.db.prepare(
+    `SELECT path, approved_hash, reviewed_by, reviewed_at FROM artifacts
+       WHERE approved_hash IS NOT NULL ORDER BY path`
+  ).all();
+  writeFileSync2(join6(ctx.root, ctx.config.dataDir, "approvals.json"), JSON.stringify(rows, null, 2) + "\n");
+}
+function resolveArtifact(ctx, ref) {
+  let row;
+  if (ref.id !== void 0) {
+    row = ctx.db.prepare("SELECT * FROM artifacts WHERE id = ?").get(ref.id);
+  } else if (ref.path) {
+    row = ctx.db.prepare("SELECT * FROM artifacts WHERE path = ?").get(normalizeRelPath(ctx, ref.path));
+  }
+  if (!row) throw new Error(`\u4EA7\u7269\u4E0D\u5B58\u5728: ${ref.id ?? ref.path}`);
+  return row;
+}
+function refreshArtifact(ctx, ref, actor = "system") {
+  const row = resolveArtifact(ctx, ref);
+  const current = hashPath(join6(ctx.root, row.path));
+  if (current === null || current === row.content_hash) return row;
+  const tx = ctx.db.transaction(() => {
+    ctx.db.prepare("UPDATE artifacts SET content_hash = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(current, row.id);
+    logEvent(ctx.db, {
+      entityType: "artifact",
+      entityId: row.id,
+      event: "content_changed",
+      actor,
+      payload: { from: row.content_hash, to: current },
+      module: row.module,
+      endpoint: row.endpoint,
+      page: row.page
+    });
+    if (row.approved_hash !== null && row.approved_hash !== current) {
+      logEvent(ctx.db, {
+        entityType: "artifact",
+        entityId: row.id,
+        event: "approval_invalidated",
+        actor,
+        payload: { approvedHash: row.approved_hash, currentHash: current },
+        module: row.module,
+        endpoint: row.endpoint,
+        page: row.page
+      });
+    }
+    if (row.submitted_hash !== null && row.submitted_hash !== current) {
+      logEvent(ctx.db, {
+        entityType: "artifact",
+        entityId: row.id,
+        event: "submission_stale",
+        actor,
+        payload: { submittedHash: row.submitted_hash, currentHash: current },
+        module: row.module,
+        endpoint: row.endpoint,
+        page: row.page
+      });
+    }
+  });
+  tx();
+  return resolveArtifact(ctx, { id: row.id });
+}
+function registerOutput(ctx, p) {
+  if (p.role === "developer") {
+    throw new Error(`developer \u89D2\u8272\u7684\u4EA7\u51FA\u4E0D\u9700\u8981\u8BB0\u5F55\u5230 task_outputs,\u4EE3\u7801\u76F4\u63A5\u5B9E\u73B0\u5230\u9879\u76EE\u8DEF\u5F84\u5373\u53EF\u3002`);
+  }
+  const relPath = normalizeRelPath(ctx, p.filePath);
+  const abs = join6(ctx.root, relPath);
+  if (!existsSync5(abs)) {
+    throw new Error(`\u4EA7\u51FA\u6587\u4EF6\u4E0D\u5B58\u5728: ${relPath},\u8BF7\u5148\u5199\u6587\u4EF6\u518D\u767B\u8BB0`);
+  }
+  const existing = ctx.db.prepare("SELECT id FROM artifacts WHERE path = ?").get(relPath);
+  if (existing) {
+    throw new Error(`\u4EA7\u51FA\u6587\u4EF6\u5DF2\u5B58\u5728: ${relPath}`);
+  }
+  const kind = inferKind(relPath, ctx.config);
+  const level = kindSpec(ctx.config, kind).level;
+  const module = level === "project" || level === "endpoint" ? null : normalizeModule(p.module, ctx.config);
+  const hash = hashPath(abs);
+  const actor = p.actor ?? p.role;
+  let linkedTaskId = p.taskId ?? null;
+  if (linkedTaskId === null) {
+    const match = ctx.db.prepare(
+      `SELECT id FROM tasks
+         WHERE role = ? AND endpoint = ? AND module IS ? AND assignee IS NOT NULL
+           AND status IN ('pending', 'in_progress')
+           AND (? IS NULL OR page IS NULL OR page = ?)
+         ORDER BY id DESC LIMIT 1`
+    ).get(p.role, p.endpoint, module, p.page ?? null, p.page ?? null);
+    linkedTaskId = match?.id ?? null;
+  }
+  const tx = ctx.db.transaction(() => {
+    const result = ctx.db.prepare(
+      `INSERT INTO artifacts (kind, module, endpoint, page, path, content_hash)
+         VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(kind, module, p.endpoint, p.page ?? null, relPath, hash);
+    const artifactId = result.lastInsertRowid;
+    if (linkedTaskId !== null) {
+      ctx.db.prepare("INSERT OR IGNORE INTO task_outputs (task_id, artifact_id) VALUES (?, ?)").run(linkedTaskId, artifactId);
+    }
+    logEvent(ctx.db, {
+      entityType: "artifact",
+      entityId: artifactId,
+      event: "output_added",
+      actor,
+      payload: { path: relPath, kind, taskId: linkedTaskId },
+      module,
+      endpoint: p.endpoint,
+      page: p.page ?? null
+    });
+    return artifactId;
+  });
+  return { artifactId: tx(), linkedTaskId, kind };
+}
+function submitArtifact(ctx, ref, actor) {
+  const row = refreshArtifact(ctx, ref, actor);
+  const tx = ctx.db.transaction(() => {
+    ctx.db.prepare(
+      "UPDATE artifacts SET submitted_at = CURRENT_TIMESTAMP, submitted_hash = content_hash, updated_at = CURRENT_TIMESTAMP WHERE id = ?"
+    ).run(row.id);
+    logEvent(ctx.db, {
+      entityType: "artifact",
+      entityId: row.id,
+      event: "submitted",
+      actor,
+      module: row.module,
+      endpoint: row.endpoint,
+      page: row.page
+    });
+  });
+  tx();
+  return resolveArtifact(ctx, { id: row.id });
+}
+function approveArtifact(ctx, ref, actor, opts = {}) {
+  const row = refreshArtifact(ctx, ref, actor);
+  const via = opts.via ?? "review";
+  const tx = ctx.db.transaction(() => {
+    ctx.db.prepare(
+      `UPDATE artifacts SET approved_hash = content_hash, reviewed_by = ?, reviewed_at = CURRENT_TIMESTAMP,
+         updated_at = CURRENT_TIMESTAMP WHERE id = ?`
+    ).run(actor, row.id);
+    logEvent(ctx.db, {
+      entityType: "artifact",
+      entityId: row.id,
+      event: "approved",
+      actor,
+      payload: { via, hash: row.content_hash, trivial: opts.trivial ?? false },
+      module: row.module,
+      endpoint: row.endpoint,
+      page: row.page
+    });
+    if (opts.trivial) {
+      ctx.db.prepare(
+        `UPDATE task_inputs SET input_hash = (SELECT content_hash FROM artifacts WHERE id = ?)
+           WHERE artifact_id = ?`
+      ).run(row.id, row.id);
+      const reviews = ctx.db.prepare(
+        `SELECT t.id FROM tasks t JOIN task_inputs ti ON ti.task_id = t.id
+           WHERE t.type = 'review' AND t.status = 'pending' AND ti.artifact_id = ?`
+      ).all(row.id);
+      for (const r of reviews) {
+        ctx.db.prepare("UPDATE tasks SET status = 'cancelled', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(r.id);
+        logEvent(ctx.db, {
+          entityType: "task",
+          entityId: r.id,
+          event: "review_auto_closed",
+          actor,
+          payload: { source: row.path, reason: "trivial \u5BA1\u6279" }
+        });
+      }
+    }
+  });
+  tx();
+  dumpApprovals(ctx);
+  archiveApprovedContent(ctx, row.id);
+  return resolveArtifact(ctx, { id: row.id });
+}
+function archiveApprovedContent(ctx, artifactId) {
+  try {
+    const row = resolveArtifact(ctx, { id: artifactId });
+    const abs = join6(ctx.root, row.path);
+    if (!existsSync5(abs) || statSync3(abs).isDirectory()) return;
+    const dir = join6(ctx.root, ctx.config.dataDir, "approved");
+    mkdirSync3(dir, { recursive: true });
+    writeFileSync2(join6(dir, String(artifactId)), readFileSync5(abs));
+  } catch {
+  }
+}
+function approvedContent(ctx, artifactId) {
+  const file = join6(ctx.root, ctx.config.dataDir, "approved", String(artifactId));
+  if (!existsSync5(file)) return null;
+  return readFileSync5(file, "utf-8");
+}
+function rejectArtifact(ctx, ref, actor, reason) {
+  if (!reason || !reason.trim()) throw new Error("\u6253\u56DE\u5FC5\u987B\u9644\u539F\u56E0");
+  const row = resolveArtifact(ctx, ref);
+  const tx = ctx.db.transaction(() => {
+    ctx.db.prepare(
+      "UPDATE artifacts SET submitted_at = NULL, submitted_hash = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?"
+    ).run(row.id);
+    logEvent(ctx.db, {
+      entityType: "artifact",
+      entityId: row.id,
+      event: "rejected",
+      actor,
+      payload: { reason },
+      module: row.module,
+      endpoint: row.endpoint,
+      page: row.page
+    });
+  });
+  tx();
+  return resolveArtifact(ctx, { id: row.id });
+}
+function feedbackArtifact(ctx, ref, p) {
+  if (p.verdict === -1 && (!p.comment || !p.comment.trim())) {
+    throw new Error("\u8D1F\u53CD\u9988\u5FC5\u987B\u9644\u4E00\u53E5\u539F\u56E0,\u5426\u5219\u65E0\u6CD5\u6C89\u6DC0\u4E3A\u7ECF\u9A8C");
+  }
+  const row = refreshArtifact(ctx, ref, p.actor);
+  const tx = ctx.db.transaction(() => {
+    const result = ctx.db.prepare(
+      `INSERT INTO artifact_feedback (artifact_id, task_id, verdict, comment, content_hash, actor)
+         VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(row.id, p.taskId ?? null, p.verdict, p.comment ?? null, row.content_hash, p.actor);
+    logEvent(ctx.db, {
+      entityType: "artifact",
+      entityId: row.id,
+      event: "feedback",
+      actor: p.actor,
+      payload: { verdict: p.verdict, comment: p.comment ?? null },
+      module: row.module,
+      endpoint: row.endpoint,
+      page: row.page
+    });
+    return result.lastInsertRowid;
+  });
+  const feedbackId = tx();
+  let endorsed = false;
+  if (row.kind === "prototype" && p.verdict === 1) {
+    approveArtifact(ctx, { id: row.id }, p.actor, { via: "feedback" });
+    endorsed = true;
+  }
+  return { feedbackId, endorsed };
+}
+function moveArtifact(ctx, { from, to, actor }) {
+  const row = resolveArtifact(ctx, { path: from });
+  const toRel = normalizeRelPath(ctx, to);
+  if (!existsSync5(join6(ctx.root, toRel))) {
+    throw new Error(`\u76EE\u6807\u6587\u4EF6\u4E0D\u5B58\u5728: ${toRel},\u8BF7\u5148\u79FB\u52A8\u78C1\u76D8\u6587\u4EF6\u518D\u6267\u884C move`);
+  }
+  const dup = ctx.db.prepare("SELECT id FROM artifacts WHERE path = ?").get(toRel);
+  if (dup && dup.id !== row.id) throw new Error(`\u76EE\u6807\u8DEF\u5F84\u5DF2\u88AB artifact #${dup.id} \u5360\u7528: ${toRel}`);
+  const tx = ctx.db.transaction(() => {
+    ctx.db.prepare("UPDATE artifacts SET path = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(toRel, row.id);
+    logEvent(ctx.db, {
+      entityType: "artifact",
+      entityId: row.id,
+      event: "moved",
+      actor,
+      payload: { from: row.path, to: toRel },
+      module: row.module,
+      endpoint: row.endpoint,
+      page: row.page
+    });
+  });
+  tx();
+  return refreshArtifact(ctx, { id: row.id }, actor);
+}
+function listArtifacts(ctx, f = {}) {
+  let query = "SELECT * FROM artifacts WHERE 1=1";
+  const params = [];
+  if (f.module) {
+    query += " AND module = ?";
+    params.push(f.module);
+  }
+  if (f.endpoint) {
+    query += " AND endpoint = ?";
+    params.push(f.endpoint);
+  }
+  if (f.page) {
+    query += " AND page = ?";
+    params.push(f.page);
+  }
+  if (f.kind) {
+    query += " AND kind = ?";
+    params.push(f.kind);
+  }
+  query += " ORDER BY id DESC";
+  const rows = ctx.db.prepare(query).all(...params);
+  for (const row of rows) row.review_status = reviewStatus(row);
+  return rows;
+}
+var init_artifact_commands = __esm({
+  "core/commands/artifact.commands.ts"() {
+    "use strict";
+    init_derive();
+    init_events();
+    init_hash();
+    init_kind();
+  }
+});
+
+// core/commands/sync.command.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join7 } from "node:path";
+function ownerRole(ctx, kind) {
+  for (const [role, kinds] of Object.entries(ctx.config.roleProduces)) {
+    if (kinds.includes(kind)) return role;
+  }
+  if (kind === "code") return "developer";
+  return null;
+}
+function hasOpenReview(ctx, artifactId) {
+  const row = ctx.db.prepare(
+    `SELECT COUNT(*) AS c FROM tasks t
+       JOIN task_inputs ti ON ti.task_id = t.id
+       WHERE t.type = 'review' AND t.status IN ('pending', 'in_progress') AND ti.artifact_id = ?`
+  ).get(artifactId);
+  return row.c > 0;
+}
+function spawnReviews(ctx, source, reason) {
+  if (hasOpenReview(ctx, source.id)) return 0;
+  const registry = getKindRegistry(ctx.config);
+  const downstream = ctx.db.prepare(`SELECT a.* FROM artifacts a JOIN artifact_edges e ON e.to_id = a.id WHERE e.from_id = ?`).all(source.id);
+  const targets = /* @__PURE__ */ new Map();
+  for (const child of downstream) {
+    if (registry[child.kind]?.meta) continue;
+    const role = ownerRole(ctx, child.kind);
+    if (!role) continue;
+    const key = `${role}|${child.endpoint ?? ""}|${child.module ?? source.module ?? ""}`;
+    targets.set(key, { role, endpoint: child.endpoint, module: child.module ?? source.module });
+  }
+  let spawned = 0;
+  const tx = ctx.db.transaction(() => {
+    for (const t of targets.values()) {
+      const result = ctx.db.prepare(
+        `INSERT INTO tasks (module, role, endpoint, type, status, assignee, creator, content)
+           VALUES (?, ?, ?, 'review', 'pending', ?, 'system', ?)`
+      ).run(t.module, t.role, t.endpoint, t.role, `[\u590D\u5BA1] \u4E0A\u6E38 ${source.path} ${reason},\u8BF7\u590D\u6838\u4F60\u57FA\u4E8E\u5B83\u7684\u4EA7\u51FA\u5E76\u5BF9\u9F50`);
+      const taskId = result.lastInsertRowid;
+      ctx.db.prepare("INSERT OR REPLACE INTO task_inputs (task_id, artifact_id, input_hash) VALUES (?, ?, ?)").run(taskId, source.id, source.content_hash);
+      logEvent(ctx.db, {
+        entityType: "task",
+        entityId: taskId,
+        event: "review_spawned",
+        actor: "system",
+        payload: { source: source.path, reason },
+        module: t.module,
+        endpoint: t.endpoint
+      });
+      spawned++;
+    }
+  });
+  tx();
+  return spawned;
+}
+function syncArtifacts(ctx, actor = "sync") {
+  const summary = { checked: 0, changed: 0, invalidated: 0, tombstoned: 0, reviewsSpawned: 0 };
+  const artifacts = ctx.db.prepare("SELECT * FROM artifacts").all();
+  for (const artifact of artifacts) {
+    summary.checked++;
+    try {
+      const abs = join7(ctx.root, artifact.path);
+      if (!existsSync6(abs)) {
+        const already = ctx.db.prepare("SELECT COUNT(*) AS c FROM events WHERE entity_type='artifact' AND entity_id=? AND event='tombstoned'").get(artifact.id);
+        if (already.c === 0) {
+          logEvent(ctx.db, {
+            entityType: "artifact",
+            entityId: artifact.id,
+            event: "tombstoned",
+            actor,
+            payload: { path: artifact.path },
+            module: artifact.module,
+            endpoint: artifact.endpoint,
+            page: artifact.page
+          });
+          summary.tombstoned++;
+          summary.reviewsSpawned += spawnReviews(ctx, artifact, "\u5DF2\u4ECE\u78C1\u76D8\u5220\u9664");
+        }
+        continue;
+      }
+      const before = artifact.content_hash;
+      const wasApproved = reviewStatus(artifact) === "approved";
+      const after = refreshArtifact(ctx, { id: artifact.id }, actor);
+      if (after.content_hash === before) continue;
+      summary.changed++;
+      if (wasApproved && reviewStatus(after) === "invalidated") {
+        summary.invalidated++;
+        summary.reviewsSpawned += spawnReviews(ctx, after, "\u5DF2\u53D8\u66F4(\u5BA1\u6279\u5931\u6548)");
+      }
+    } catch {
+    }
+  }
+  return summary;
+}
+function detectOrphanCommit(ctx) {
+  if (ctx.config.git.taskTrailer !== "on") return { orphan: false, hits: [] };
+  const head = headCommitInfo(ctx.root, ctx.config.git.trailerKey);
+  if (!head || head.trailer) return { orphan: false, hits: [] };
+  const registry = getKindRegistry(ctx.config);
+  const managed = ctx.db.prepare("SELECT * FROM artifacts").all().filter((a) => {
+    const spec = registry[a.kind];
+    return spec && !spec.meta && (spec.approval === "human" || a.kind === "code");
+  });
+  const hits = /* @__PURE__ */ new Set();
+  for (const file of head.files) {
+    for (const a of managed) {
+      if (file === a.path || file.startsWith(a.path + "/")) {
+        hits.add(file);
+        break;
+      }
+    }
+  }
+  if (hits.size === 0) return { orphan: false, hits: [] };
+  const already = ctx.db.prepare("SELECT COUNT(*) AS c FROM events WHERE event = 'orphan_commit' AND payload LIKE ?").get(`%${head.hash}%`);
+  if (already.c === 0) {
+    const tx = ctx.db.transaction(() => {
+      logEvent(ctx.db, {
+        entityType: "artifact",
+        entityId: 0,
+        event: "orphan_commit",
+        actor: "post-commit",
+        payload: { commit: head.hash, hits: [...hits].slice(0, 20) }
+      });
+    });
+    tx();
+  }
+  return { orphan: true, hits: [...hits] };
+}
+function disputeArtifact(ctx, ref, actor, reason) {
+  if (!reason?.trim()) throw new Error("\u5F02\u8BAE\u5FC5\u987B\u8BF4\u660E\u7406\u7531");
+  const artifact = resolveArtifact(ctx, ref);
+  const tx = ctx.db.transaction(() => {
+    logEvent(ctx.db, {
+      entityType: "artifact",
+      entityId: artifact.id,
+      event: "dispute",
+      actor,
+      payload: { reason },
+      module: artifact.module,
+      endpoint: artifact.endpoint,
+      page: artifact.page
+    });
+  });
+  tx();
+}
+var init_sync_command = __esm({
+  "core/commands/sync.command.ts"() {
+    "use strict";
+    init_derive();
+    init_events();
+    init_git();
+    init_kind();
+    init_artifact_commands();
+  }
+});
+
+// core/commands/task.commands.ts
+function createTask(ctx, p) {
+  const type = p.type ?? "build";
+  if (!VALID_TYPES.includes(type)) throw new Error(`\u65E0\u6548\u7684\u4EFB\u52A1\u7C7B\u578B: ${type},\u53EF\u9009\u503C: ${VALID_TYPES.join(", ")}`);
+  if (!VALID_ROLES.includes(p.role)) throw new Error(`\u65E0\u6548\u7684\u89D2\u8272: ${p.role},\u53EF\u9009\u503C: ${VALID_ROLES.join(", ")}`);
+  const module = normalizeModule(p.module, ctx.config);
+  const tx = ctx.db.transaction(() => {
+    const result = ctx.db.prepare(
+      `INSERT INTO tasks (module, role, endpoint, page, type, assignee, creator, content, external_ref)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(module, p.role, p.endpoint ?? null, p.page ?? null, type, p.assignee ?? null, p.creator, p.content ?? null, p.externalRef ?? null);
+    const id = result.lastInsertRowid;
+    logEvent(ctx.db, {
+      entityType: "task",
+      entityId: id,
+      event: "created",
+      actor: p.creator,
+      payload: { role: p.role, type },
+      module,
+      endpoint: p.endpoint ?? null,
+      page: p.page ?? null
+    });
+    return id;
+  });
+  return tx();
+}
+function getTaskRow(ctx, id) {
+  const task = ctx.db.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+  if (!task) throw new Error(`\u4EFB\u52A1 #${id} \u4E0D\u5B58\u5728`);
+  return task;
+}
+function claimTask(ctx, { id, assignee }) {
+  const task = getTaskRow(ctx, id);
+  const { warnings, inputs } = validateClaim(ctx, task);
+  const claimCommit = gitHead(ctx.root);
+  const tx = ctx.db.transaction(() => {
+    const result = ctx.db.prepare(
+      `UPDATE tasks SET assignee = ?, status = 'in_progress', claim_commit = ?, updated_at = CURRENT_TIMESTAMP
+         WHERE id = ? AND status = 'pending' AND (assignee IS NULL OR assignee = ?)`
+    ).run(assignee, claimCommit, id, assignee);
+    if (result.changes === 0) {
+      throw new Error(`\u4EFB\u52A1 #${id} \u65E0\u6CD5\u9886\u53D6:\u5DF2\u88AB\u4ED6\u4EBA\u9886\u53D6\u6216\u72B6\u6001\u4E0D\u662F pending(\u5F53\u524D ${task.status}${task.assignee ? `,\u6267\u884C\u4EBA ${task.assignee}` : ""})`);
+    }
+    const snapshot = ctx.db.prepare(
+      "INSERT OR REPLACE INTO task_inputs (task_id, artifact_id, input_hash) VALUES (?, ?, ?)"
+    );
+    for (const a of inputs) snapshot.run(id, a.id, a.content_hash);
+    logEvent(ctx.db, {
+      entityType: "task",
+      entityId: id,
+      event: "claimed",
+      actor: assignee,
+      payload: { warnings, inputCount: inputs.length },
+      module: task.module,
+      endpoint: task.endpoint,
+      page: task.page
+    });
+  });
+  tx();
+  return { id, warnings };
+}
+function updateTask(ctx, { id, status, operator, force = false }) {
+  const task = getTaskRow(ctx, id);
+  if (!VALID_STATUS.includes(status)) {
+    throw new Error(`\u65E0\u6548\u7684\u72B6\u6001: ${status},\u53EF\u9009\u503C: ${VALID_STATUS.join(", ")}`);
+  }
+  if (task.assignee !== null && task.assignee !== operator) {
+    throw new Error(`\u53EA\u6709\u6267\u884C\u4EBA\u624D\u80FD\u66F4\u65B0\u4EFB\u52A1\u72B6\u6001`);
+  }
+  const { warnings } = validateComplete(ctx, task, status, { force });
+  const tx = ctx.db.transaction(() => {
+    ctx.db.prepare("UPDATE tasks SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(status, id);
+    logEvent(ctx.db, {
+      entityType: "task",
+      entityId: id,
+      event: status === "completed" ? "completed" : "status_changed",
+      actor: operator,
+      payload: { status, warnings, ...force ? { force: true } : {} },
+      module: task.module,
+      endpoint: task.endpoint,
+      page: task.page
+    });
+  });
+  tx();
+  if (task.type === "hotfix" && status === "completed") {
+    warnings.push(...checkContractTouch(ctx, task, operator));
+  }
+  if (task.type === "rework" && status === "completed") {
+    const qaId = spawnFollowupQa(ctx, task);
+    warnings.push(`[\u590D\u9A8C] \u5DF2\u81EA\u52A8\u6D3E\u65B0\u4E00\u8F6E qa \u4EFB\u52A1 #${qaId}`);
+  }
+  if (status === "completed" && task.external_ref?.startsWith("gh#")) {
+    const closed = closeLinkedIssue(ctx, task.external_ref, task.id);
+    warnings.push(closed ? `[issue] \u5DF2\u5173\u95ED ${task.external_ref}` : `[issue] ${task.external_ref} \u5173\u95ED\u5931\u8D25(gh \u4E0D\u53EF\u7528),\u8BF7\u624B\u52A8\u5904\u7406`);
+  }
+  return { id, warnings };
+}
+function spawnFollowupQa(ctx, reworkTask) {
+  const tx = ctx.db.transaction(() => {
+    const result = ctx.db.prepare(
+      `INSERT INTO tasks (module, role, endpoint, page, type, status, assignee, creator, content)
+         VALUES (?, 'qa', ?, ?, 'qa', 'pending', 'qa', 'system', ?)`
+    ).run(reworkTask.module, reworkTask.endpoint, reworkTask.page, `[\u590D\u9A8C] rework #${reworkTask.id} \u5DF2\u5B8C\u6210,\u8BF7\u91CD\u65B0\u9A8C\u6536`);
+    const qaId = result.lastInsertRowid;
+    logEvent(ctx.db, {
+      entityType: "task",
+      entityId: qaId,
+      event: "qa_respawned",
+      actor: "system",
+      payload: { rework: reworkTask.id },
+      module: reworkTask.module,
+      endpoint: reworkTask.endpoint,
+      page: reworkTask.page
+    });
+    return qaId;
+  });
+  return tx();
+}
+function checkContractTouch(ctx, task, operator) {
+  const warnings = [];
+  const touched = ctx.config.git.taskTrailer === "on" && task.claim_commit ? touchedByTaskTrailer(ctx.root, task.claim_commit, ctx.config.git.trailerKey, task.id) : touchedSince(ctx.root, task.claim_commit);
+  if (touched.length === 0) return warnings;
+  const kinds = contractKinds(ctx.config);
+  const contracts = ctx.db.prepare(`SELECT * FROM artifacts WHERE kind IN (${kinds.map(() => "?").join(",")})`).all(...kinds);
+  for (const contract of contracts) {
+    const hit = touched.some((t) => t === contract.path || t.startsWith(contract.path + "/"));
+    if (!hit) continue;
+    const open = ctx.db.prepare(
+      `SELECT COUNT(*) AS c FROM tasks t JOIN task_inputs ti ON ti.task_id = t.id
+         WHERE t.type = 'review' AND t.status IN ('pending','in_progress') AND ti.artifact_id = ?`
+    ).get(contract.id);
+    if (open.c > 0) continue;
+    const role = ownerRole(ctx, contract.kind) ?? "architect";
+    const tx = ctx.db.transaction(() => {
+      const result = ctx.db.prepare(
+        `INSERT INTO tasks (module, role, endpoint, type, status, assignee, creator, content)
+           VALUES (?, ?, ?, 'review', 'pending', ?, 'system', ?)`
+      ).run(
+        contract.module,
+        role,
+        contract.endpoint,
+        role,
+        `[\u5951\u7EA6\u89E6\u78B0] hotfix #${task.id} \u89E6\u78B0\u4E86\u5951\u7EA6 ${contract.path},\u8BF7\u8865\u6587\u6863\u5E76\u91CD\u65B0\u9001\u5BA1`
+      );
+      const reviewId = result.lastInsertRowid;
+      ctx.db.prepare("INSERT OR REPLACE INTO task_inputs (task_id, artifact_id, input_hash) VALUES (?, ?, ?)").run(reviewId, contract.id, contract.content_hash);
+      logEvent(ctx.db, {
+        entityType: "task",
+        entityId: reviewId,
+        event: "contract_touched",
+        actor: operator,
+        payload: { hotfix: task.id, contract: contract.path },
+        module: contract.module,
+        endpoint: contract.endpoint
+      });
+    });
+    tx();
+    warnings.push(`[\u5951\u7EA6\u89E6\u78B0] ${contract.path} \u88AB\u672C hotfix \u4FEE\u6539,\u5DF2\u81EA\u52A8\u6D3E\u8865\u6587\u6863 review \u4EFB\u52A1`);
+  }
+  return warnings;
+}
+function removeTask(ctx, { id, operator, force = false }) {
+  const task = getTaskRow(ctx, id);
+  if (!force && task.creator !== operator) {
+    throw new Error(`\u53EA\u6709\u521B\u5EFA\u4EBA(${task.creator})\u624D\u80FD\u5220\u9664\u4EFB\u52A1`);
+  }
+  const tx = ctx.db.transaction(() => {
+    logEvent(ctx.db, {
+      entityType: "task",
+      entityId: id,
+      event: "removed",
+      actor: operator,
+      payload: { force },
+      module: task.module,
+      endpoint: task.endpoint,
+      page: task.page
+    });
+    ctx.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+  });
+  tx();
+}
+function addTaskInput(ctx, { id, path, operator }) {
+  const task = getTaskRow(ctx, id);
+  const artifact = ctx.db.prepare("SELECT * FROM artifacts WHERE path = ?").get(normalizeRelPath(ctx, path));
+  if (!artifact) throw new Error(`\u4EA7\u7269\u672A\u767B\u8BB0: ${path},\u65E0\u6CD5\u7533\u62A5\u4F9D\u8D56`);
+  const tx = ctx.db.transaction(() => {
+    ctx.db.prepare("INSERT OR REPLACE INTO task_inputs (task_id, artifact_id, input_hash) VALUES (?, ?, ?)").run(id, artifact.id, artifact.content_hash);
+    logEvent(ctx.db, {
+      entityType: "task",
+      entityId: id,
+      event: "input_added",
+      actor: operator,
+      payload: { path: artifact.path, artifactId: artifact.id },
+      module: task.module,
+      endpoint: task.endpoint,
+      page: task.page
+    });
+  });
+  tx();
+}
+function recordNote(ctx, { id, content, operator }) {
+  const task = getTaskRow(ctx, id);
+  const tx = ctx.db.transaction(() => {
+    logEvent(ctx.db, {
+      entityType: "task",
+      entityId: id,
+      event: "note",
+      actor: operator,
+      payload: { content },
+      module: task.module,
+      endpoint: task.endpoint,
+      page: task.page
+    });
+  });
+  tx();
+}
+function listTasks(ctx, f = {}) {
+  let query = "SELECT * FROM tasks WHERE 1=1";
+  const params = [];
+  if (f.status) {
+    query += " AND status = ?";
+    params.push(f.status);
+  }
+  if (f.assignee) {
+    query += " AND assignee = ?";
+    params.push(f.assignee);
+  }
+  if (f.module) {
+    query += " AND module LIKE ?";
+    params.push(`%${f.module}%`);
+  }
+  if (f.role) {
+    query += " AND role = ?";
+    params.push(f.role);
+  }
+  if (f.endpoint) {
+    query += " AND endpoint = ?";
+    params.push(f.endpoint);
+  }
+  if (f.type) {
+    query += " AND type = ?";
+    params.push(f.type);
+  }
+  query += " ORDER BY id DESC";
+  const rows = ctx.db.prepare(query).all(...params);
+  if (f.withStale) {
+    for (const row of rows) row.stale = taskStaleness(ctx.db, row.id).stale;
+  }
+  return rows;
+}
+function getTaskDetail(ctx, id) {
+  const task = getTaskRow(ctx, id);
+  const events = listEvents(ctx.db, { entityType: "task", entityId: id });
+  const outputs = ctx.db.prepare(
+    `SELECT a.* FROM artifacts a JOIN task_outputs t ON t.artifact_id = a.id WHERE t.task_id = ? ORDER BY a.id ASC`
+  ).all(id);
+  if (outputs.length === 0 && task.module) {
+    const fallback = ctx.db.prepare(`SELECT * FROM artifacts WHERE module = ? AND endpoint = ? ORDER BY id ASC`).all(task.module, task.endpoint);
+    outputs.push(...fallback);
+  }
+  return { task, events, outputs, staleness: taskStaleness(ctx.db, id) };
+}
+var VALID_STATUS, VALID_TYPES, VALID_ROLES;
+var init_task_commands = __esm({
+  "core/commands/task.commands.ts"() {
+    "use strict";
+    init_derive();
+    init_events();
+    init_gates();
+    init_git();
+    init_gh();
+    init_kind();
+    init_artifact_commands();
+    init_sync_command();
+    VALID_STATUS = ["pending", "in_progress", "completed", "cancelled"];
+    VALID_TYPES = ["build", "review", "qa", "hotfix", "baseline", "legacy", "rework"];
+    VALID_ROLES = ["product-manager", "architect", "designer", "developer", "qa"];
+  }
+});
+
+// core/commands/graph.command.ts
+function graphModule(ctx, module) {
+  const artifacts = ctx.db.prepare("SELECT * FROM artifacts WHERE module = ? OR (module IS NULL AND kind IN ('baseline','project','roles','glossary')) ORDER BY id").all(module);
+  if (artifacts.length === 0) return `%% \u6A21\u5757 ${module} \u6CA1\u6709\u767B\u8BB0\u4EFB\u4F55\u4EA7\u7269`;
+  const ids = artifacts.map((a) => a.id);
+  const edges = ctx.db.prepare(
+    `SELECT from_id, to_id FROM artifact_edges
+       WHERE from_id IN (${ids.map(() => "?").join(",")}) AND to_id IN (${ids.map(() => "?").join(",")})`
+  ).all(...ids, ...ids);
+  const lines = ["flowchart TD"];
+  const label = (a) => {
+    const name = a.path.split("/").pop() ?? a.path;
+    const suffix = a.endpoint ? ` (${a.endpoint}${a.page ? `/${a.page}` : ""})` : "";
+    return `${name}${suffix}`.replace(/["[\]]/g, "");
+  };
+  KIND_TIERS.forEach((kinds, i) => {
+    const tierArtifacts = artifacts.filter((a) => kinds.includes(a.kind));
+    if (tierArtifacts.length === 0) return;
+    lines.push(`  subgraph T${i}["${TIER_LABELS[i]}"]`);
+    for (const a of tierArtifacts) {
+      lines.push(`    a${a.id}["${label(a)}"]:::${reviewStatus(a)}`);
+    }
+    lines.push("  end");
+  });
+  const inTiers = new Set(artifacts.filter((a) => KIND_TIERS.flat().includes(a.kind)).map((a) => a.id));
+  const others = artifacts.filter((a) => !inTiers.has(a.id));
+  for (const a of others) {
+    lines.push(`  a${a.id}["${label(a)}"]:::${reviewStatus(a)}`);
+  }
+  for (const e of edges) {
+    lines.push(`  a${e.from_id} --> a${e.to_id}`);
+  }
+  lines.push("  classDef approved fill:#e1f5ee,stroke:#0f6e56");
+  lines.push("  classDef draft fill:#f1efe8,stroke:#888780");
+  lines.push("  classDef pending fill:#faeeda,stroke:#ba7517");
+  lines.push("  classDef invalidated fill:#fcebeb,stroke:#a32d2d");
+  return lines.join("\n");
+}
+var TIER_LABELS;
+var init_graph_command = __esm({
+  "core/commands/graph.command.ts"() {
+    "use strict";
+    init_derive();
+    init_kind();
+    TIER_LABELS = ["\u5951\u7EA6\u57FA\u7EBF", "\u4E1A\u52A1\u6D41\u7A0B", "\u6A21\u5757 PRD", "\u9875\u9762 PRD", "\u67B6\u6784/\u8BBE\u8BA1\u7CFB\u7EDF", "\u8BBE\u8BA1\u63D0\u793A\u8BCD", "\u539F\u578B/\u9A8C\u6536", "\u4EE3\u7801"];
+  }
+});
+
+// core/commands/migrate-legacy.command.ts
+import Database2 from "better-sqlite3";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join8 } from "node:path";
+function migrateLegacy(ctx, legacyDbPath) {
+  const relPath = legacyDbPath ?? ctx.config.legacyDb;
+  const absPath = join8(ctx.root, relPath);
+  if (!existsSync7(absPath)) throw new Error(`\u65E7\u5E93\u4E0D\u5B58\u5728: ${relPath}`);
+  const existing = ctx.db.prepare("SELECT COUNT(*) AS c FROM tasks WHERE type = 'legacy'").get();
+  if (existing.c > 0) throw new Error(`\u5DF2\u8FC1\u79FB\u8FC7(\u5B58\u5728 ${existing.c} \u6761 legacy \u4EFB\u52A1),\u4E0D\u53EF\u91CD\u590D\u8FC1\u79FB`);
+  const legacy = new Database2(absPath, { readonly: true, fileMustExist: true });
+  const oldTasks = legacy.prepare("SELECT * FROM tasks ORDER BY id").all();
+  const oldOutputs = legacy.prepare("SELECT * FROM task_outputs ORDER BY id").all();
+  const oldRecords = legacy.prepare("SELECT * FROM task_records ORDER BY id").all();
+  legacy.close();
+  const summary = { tasks: 0, artifacts: 0, linkedOutputs: 0, missingFiles: [], notes: 0 };
+  const tx = ctx.db.transaction(() => {
+    const insertTask = ctx.db.prepare(
+      `INSERT INTO tasks (id, module, role, endpoint, page, type, status, assignee, creator, content, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, 'legacy', ?, ?, ?, ?, ?, ?)`
+    );
+    for (const t of oldTasks) {
+      insertTask.run(
+        t.id,
+        normalizeModule(t.module, ctx.config),
+        t.role,
+        t.endpoint,
+        t.page,
+        t.status,
+        t.assignee,
+        t.creator,
+        t.content,
+        t.created_at,
+        t.updated_at
+      );
+      summary.tasks++;
+    }
+    const insertArtifact = ctx.db.prepare(
+      `INSERT INTO artifacts (kind, module, endpoint, page, path, content_hash, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    );
+    const findTask = ctx.db.prepare(
+      `SELECT id FROM tasks
+       WHERE type = 'legacy' AND role = ? AND endpoint = ? AND module IS ?
+         AND (? IS NULL OR page IS ?)
+       ORDER BY id DESC LIMIT 1`
+    );
+    const linkOutput = ctx.db.prepare("INSERT OR IGNORE INTO task_outputs (task_id, artifact_id) VALUES (?, ?)");
+    for (const o of oldOutputs) {
+      const relFile = o.file_path.replace(/\\/g, "/");
+      const module = normalizeModule(o.module, ctx.config);
+      const hash = hashPath(join8(ctx.root, relFile));
+      if (hash === null) summary.missingFiles.push(relFile);
+      const dup = ctx.db.prepare("SELECT id FROM artifacts WHERE path = ?").get(relFile);
+      if (dup) continue;
+      const result = insertArtifact.run(
+        inferKind(relFile, ctx.config),
+        module,
+        o.endpoint,
+        o.page,
+        relFile,
+        hash ?? "",
+        o.created_at
+      );
+      const artifactId = result.lastInsertRowid;
+      summary.artifacts++;
+      const match = findTask.get(o.role, o.endpoint, module, o.page, o.page);
+      if (match) {
+        linkOutput.run(match.id, artifactId);
+        summary.linkedOutputs++;
+      }
+    }
+    const taskIds = new Set(oldTasks.map((t) => t.id));
+    for (const r of oldRecords) {
+      if (!taskIds.has(r.task_id)) continue;
+      logEvent(ctx.db, {
+        entityType: "task",
+        entityId: r.task_id,
+        event: "note",
+        actor: r.operator ?? "unknown",
+        payload: { content: r.content, migrated: true },
+        createdAt: r.created_at
+      });
+      summary.notes++;
+    }
+    logEvent(ctx.db, {
+      entityType: "task",
+      entityId: 0,
+      event: "migrated",
+      actor: "system",
+      payload: { ...summary, source: relPath }
+    });
+  });
+  tx();
+  return summary;
+}
+var init_migrate_legacy_command = __esm({
+  "core/commands/migrate-legacy.command.ts"() {
+    "use strict";
+    init_events();
+    init_hash();
+    init_kind();
+  }
+});
+
+// core/commands/meta.command.ts
+import { existsSync as existsSync8, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
+import { join as join9 } from "node:path";
+function metaSources(config) {
+  const seen = /* @__PURE__ */ new Set();
+  const sources = [];
+  const add = (s) => {
+    if (!seen.has(s.dir)) {
+      seen.add(s.dir);
+      sources.push(s);
+    }
+  };
+  for (const a of resolvePlatforms(config.platforms)) {
+    add({ dir: a.agentsDir, filter: (n) => n.endsWith(".md") || n.endsWith(".toml") });
+    add({ dir: a.skillsDir, filter: (n) => n === "SKILL.md", recursive: true });
+    if (a.hooksScanDir) add({ dir: a.hooksScanDir, recursive: true });
+  }
+  add({ dir: "docs/workbench", filter: (n) => n === "PLAN.md" });
+  return sources;
+}
+function collectFiles(root, dir, filter, recursive) {
+  const abs = join9(root, dir);
+  if (!existsSync8(abs)) return [];
+  const results = [];
+  const walk = (d, rel) => {
+    for (const name of readdirSync3(d).sort()) {
+      const full = join9(d, name);
+      const relPath = `${rel}/${name}`;
+      if (statSync4(full).isDirectory()) {
+        if (recursive) walk(full, relPath);
+      } else if (!filter || filter(name)) {
+        results.push(relPath);
+      }
+    }
+  };
+  walk(abs, dir);
+  return results;
+}
+function registerMetaArtifacts(ctx, actor = "system") {
+  const result = { registered: [], skipped: [] };
+  const files = [];
+  for (const src of metaSources(ctx.config)) {
+    files.push(...collectFiles(ctx.root, src.dir, src.filter, src.recursive));
+  }
+  const insert = ctx.db.prepare(
+    `INSERT INTO artifacts (kind, module, endpoint, page, path, content_hash) VALUES (?, NULL, NULL, NULL, ?, ?)`
+  );
+  const exists = ctx.db.prepare("SELECT id FROM artifacts WHERE path = ?");
+  const tx = ctx.db.transaction(() => {
+    for (const file of files) {
+      const relPath = normalizeRelPath(ctx, file);
+      if (exists.get(relPath)) {
+        result.skipped.push(relPath);
+        continue;
+      }
+      const kind = inferKind(relPath, ctx.config);
+      const hash = hashPath(join9(ctx.root, relPath));
+      if (hash === null) continue;
+      const inserted = insert.run(kind, relPath, hash);
+      logEvent(ctx.db, {
+        entityType: "artifact",
+        entityId: inserted.lastInsertRowid,
+        event: "meta_registered",
+        actor,
+        payload: { path: relPath, kind }
+      });
+      result.registered.push({ path: relPath, kind });
+    }
+  });
+  tx();
+  return result;
+}
+var init_meta_command = __esm({
+  "core/commands/meta.command.ts"() {
+    "use strict";
+    init_events();
+    init_hash();
+    init_kind();
+    init_platforms();
+    init_artifact_commands();
+  }
+});
+
+// core/commands/scan.command.ts
+import { existsSync as existsSync9, readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
+import { join as join10 } from "node:path";
+function parseCoords(ctx, kind, relPath) {
+  const none = { module: null, endpoint: null, page: null };
+  const base = (p) => p.split("/").pop().replace(/\.(md|html)$/i, "");
+  const seg = relPath.split("/");
+  const mod = (raw) => normalizeModule(raw, ctx.config);
+  switch (kind) {
+    case "flow":
+    case "module-prd":
+      return { module: mod(base(relPath)), endpoint: "common", page: null };
+    case "db-doc":
+      return { module: mod(base(relPath)), endpoint: "common", page: null };
+    case "api-doc":
+      return { module: mod(base(relPath)), endpoint: "service", page: null };
+    case "design-system":
+      return { module: null, endpoint: base(relPath), page: null };
+    case "page-prd":
+    case "design-prompt":
+    case "prototype":
+    case "acceptance": {
+      if (seg.length < 3) return none;
+      const endpoint = seg[seg.length - 3];
+      const module = mod(seg[seg.length - 2]);
+      return { module, endpoint, page: `${module}/${base(relPath)}` };
+    }
+    default:
+      return none;
+  }
+}
+function isMetaPath(ctx, relPath) {
+  const registry = getKindRegistry(ctx.config);
+  for (const spec of Object.values(registry)) {
+    if (!spec.meta) continue;
+    for (const pattern of spec.pathPatterns ?? []) {
+      if (pattern.endsWith("/") ? relPath.startsWith(pattern) : relPath === pattern) return true;
+    }
+  }
+  return false;
+}
+function walkFiles2(absDir, rel, out) {
+  for (const name of readdirSync4(absDir).sort()) {
+    if (name.startsWith(".") || name === "node_modules") continue;
+    const full = join10(absDir, name);
+    const relPath = `${rel}/${name}`;
+    if (statSync5(full).isDirectory()) {
+      walkFiles2(full, relPath, out);
+    } else if (/\.(md|html)$/i.test(name)) {
+      out.push(relPath);
+    }
+  }
+}
+function expandCodeRoots(ctx) {
+  const results = [];
+  for (const [endpoint, patterns] of Object.entries(ctx.config.codeRoots)) {
+    for (const pattern of patterns) {
+      const segments = pattern.replace(/\\/g, "/").split("/");
+      let candidates = [{ dir: "", module: null }];
+      for (const segment of segments) {
+        const next = [];
+        const ph = /^\{(\w+)\}(.*)$/.exec(segment);
+        for (const c of candidates) {
+          if (ph) {
+            const [, placeholder, suffix] = ph;
+            const abs = join10(ctx.root, c.dir);
+            if (!existsSync9(abs)) continue;
+            for (const name of readdirSync4(abs).sort()) {
+              const isDir = statSync5(join10(abs, name)).isDirectory();
+              if (suffix === "" ? !isDir : isDir || !name.endsWith(suffix)) continue;
+              const captured = suffix === "" ? name : name.slice(0, -suffix.length);
+              next.push({ dir: c.dir ? `${c.dir}/${name}` : name, module: placeholder === "module" ? captured : c.module });
+            }
+          } else {
+            next.push({ dir: c.dir ? `${c.dir}/${segment}` : segment, module: c.module });
+          }
+        }
+        candidates = next;
+      }
+      for (const c of candidates) {
+        if (c.module && existsSync9(join10(ctx.root, c.dir))) {
+          results.push({ dir: c.dir, endpoint, module: normalizeModule(c.module, ctx.config) });
+        }
+      }
+    }
+  }
+  return results;
+}
+function deriveEdges(ctx) {
+  const registry = getKindRegistry(ctx.config);
+  const artifacts = ctx.db.prepare("SELECT * FROM artifacts").all();
+  const nonMeta = artifacts.filter((a) => !registry[a.kind]?.meta);
+  const byKind = /* @__PURE__ */ new Map();
+  for (const a of nonMeta) {
+    const list = byKind.get(a.kind) ?? [];
+    list.push(a);
+    byKind.set(a.kind, list);
+  }
+  const insert = ctx.db.prepare("INSERT OR IGNORE INTO artifact_edges (from_id, to_id) VALUES (?, ?)");
+  let created = 0;
+  const tx = ctx.db.transaction(() => {
+    for (const child of nonMeta) {
+      const parents = registry[child.kind]?.parents ?? [];
+      for (const parentKind of parents) {
+        const level = registry[parentKind]?.level ?? "module";
+        const candidates = (byKind.get(parentKind) ?? []).filter((p) => {
+          if ((level === "module" || level === "page") && child.module && p.module !== child.module) return false;
+          if ((level === "endpoint" || level === "page") && child.endpoint && p.endpoint !== child.endpoint) return false;
+          if (level === "page" && child.page && p.page !== child.page) return false;
+          return true;
+        });
+        for (const parent of candidates) {
+          created += insert.run(parent.id, child.id).changes;
+        }
+      }
+    }
+  });
+  tx();
+  return created;
+}
+function scanArtifacts(ctx, actor = "system") {
+  const summary = { registered: 0, refreshed: 0, edges: 0, skipped: [] };
+  const files = [];
+  for (const dir of Object.values(ctx.config.docs)) {
+    const abs = join10(ctx.root, dir);
+    if (existsSync9(abs)) walkFiles2(abs, dir, files);
+  }
+  for (const p of ["ARCHITECTURE.md", "TECH.md"]) {
+    if (existsSync9(join10(ctx.root, p))) files.push(p);
+  }
+  const exists = ctx.db.prepare("SELECT id, content_hash FROM artifacts WHERE path = ?");
+  const insert = ctx.db.prepare(
+    "INSERT INTO artifacts (kind, module, endpoint, page, path, content_hash) VALUES (?, ?, ?, ?, ?, ?)"
+  );
+  const registerOne = (relPath, kind, coords) => {
+    const row = exists.get(relPath);
+    if (row) {
+      const before = row.content_hash;
+      const after = refreshArtifact(ctx, { id: row.id }, actor);
+      if (after.content_hash !== before) summary.refreshed++;
+      return;
+    }
+    const hash = hashPath(join10(ctx.root, relPath));
+    if (hash === null) return;
+    const tx = ctx.db.transaction(() => {
+      const result = insert.run(kind, coords.module, coords.endpoint, coords.page, relPath, hash);
+      logEvent(ctx.db, {
+        entityType: "artifact",
+        entityId: result.lastInsertRowid,
+        event: "scan_registered",
+        actor,
+        payload: { path: relPath, kind },
+        module: coords.module,
+        endpoint: coords.endpoint,
+        page: coords.page
+      });
+    });
+    tx();
+    summary.registered++;
+  };
+  for (const relPath of files) {
+    if (isMetaPath(ctx, relPath)) {
+      summary.skipped.push(relPath);
+      continue;
+    }
+    const kind = inferKind(relPath, ctx.config);
+    registerOne(relPath, kind, parseCoords(ctx, kind, relPath));
+  }
+  for (const code of expandCodeRoots(ctx)) {
+    registerOne(code.dir, "code", { module: code.module, endpoint: code.endpoint, page: null });
+  }
+  summary.edges = deriveEdges(ctx);
+  return summary;
+}
+var init_scan_command = __esm({
+  "core/commands/scan.command.ts"() {
+    "use strict";
+    init_events();
+    init_hash();
+    init_kind();
+    init_artifact_commands();
+  }
+});
+
+// core/commands/qa.command.ts
+function recordQaResult(ctx, p) {
+  const task = getTaskRow(ctx, p.id);
+  if (task.role !== "qa") throw new Error(`\u4EFB\u52A1 #${p.id} \u4E0D\u662F qa \u4EFB\u52A1`);
+  if (task.assignee !== p.operator) throw new Error(`\u53EA\u6709\u6267\u884C\u4EBA\u624D\u80FD\u8BB0\u5F55\u9A8C\u6536\u7ED3\u679C`);
+  if (p.result === "fail" && !p.reason?.trim()) throw new Error(`\u9A8C\u6536\u4E0D\u901A\u8FC7\u5FC5\u987B\u9644\u539F\u56E0,\u5B83\u5C06\u6210\u4E3A rework \u4EFB\u52A1\u7684\u5185\u5BB9`);
+  const eventName = p.result === "pass" ? "qa_passed" : "qa_failed";
+  const tx = ctx.db.transaction(() => {
+    logEvent(ctx.db, {
+      entityType: "task",
+      entityId: task.id,
+      event: eventName,
+      actor: p.operator,
+      payload: { reason: p.reason ?? null },
+      module: task.module,
+      endpoint: task.endpoint,
+      page: task.page
+    });
+  });
+  tx();
+  updateTask(ctx, { id: task.id, status: "completed", operator: p.operator, force: true });
+  if (p.result === "pass") {
+    const codes = ctx.db.prepare("SELECT * FROM artifacts WHERE kind = 'code' AND module IS ? AND (endpoint IS ? OR ? IS NULL)").all(task.module, task.endpoint, task.endpoint);
+    for (const code of codes) {
+      try {
+        feedbackArtifact(ctx, { id: code.id }, { verdict: 1, comment: "QA \u9A8C\u6536\u901A\u8FC7(\u81EA\u52A8)", actor: "qa-auto", taskId: task.id });
+      } catch {
+      }
+    }
+    return { reworkTaskId: null };
+  }
+  const tx2 = ctx.db.transaction(() => {
+    const result = ctx.db.prepare(
+      `INSERT INTO tasks (module, role, endpoint, page, type, status, assignee, creator, content)
+         VALUES (?, 'developer', ?, ?, 'rework', 'pending', 'developer', 'system', ?)`
+    ).run(task.module, task.endpoint, task.page, `[\u8FD4\u5DE5] QA #${task.id} \u9A8C\u6536\u4E0D\u901A\u8FC7:${p.reason}`);
+    const reworkId = result.lastInsertRowid;
+    logEvent(ctx.db, {
+      entityType: "task",
+      entityId: reworkId,
+      event: "rework_spawned",
+      actor: "system",
+      payload: { qaTask: task.id, reason: p.reason },
+      module: task.module,
+      endpoint: task.endpoint,
+      page: task.page
+    });
+    return reworkId;
+  });
+  return { reworkTaskId: tx2() };
+}
+var init_qa_command = __esm({
+  "core/commands/qa.command.ts"() {
+    "use strict";
+    init_events();
+    init_artifact_commands();
+    init_task_commands();
+  }
+});
+
+// core/commands/retro.command.ts
+var retro_command_exports = {};
+__export(retro_command_exports, {
+  AUTO_ACTOR_WEIGHT: () => AUTO_ACTOR_WEIGHT,
+  RED_FLAG_THRESHOLD: () => RED_FLAG_THRESHOLD,
+  SKILL_CANDIDATE_THRESHOLD: () => SKILL_CANDIDATE_THRESHOLD,
+  approvalStats: () => approvalStats,
+  distillFeedback: () => distillFeedback,
+  exportEventLog: () => exportEventLog,
+  runRetrospective: () => runRetrospective
+});
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join11 } from "node:path";
+function parseDbTime(s) {
+  return Date.parse(s.includes("T") ? s : s.replace(" ", "T") + "Z");
+}
+function distillFeedback(ctx, opts = {}) {
+  const now = (opts.now ?? /* @__PURE__ */ new Date()).getTime();
+  const halfLifeMs = ctx.config.feedbackHalfLifeDays * 24 * 60 * 60 * 1e3;
+  let query = `
+    SELECT f.artifact_id, f.verdict, f.comment, f.actor, f.created_at,
+           a.kind, a.module, a.endpoint, a.path
+    FROM artifact_feedback f JOIN artifacts a ON a.id = f.artifact_id`;
+  const params = [];
+  if (opts.module) {
+    query += " WHERE a.module = ?";
+    params.push(opts.module);
+  }
+  query += " ORDER BY f.id";
+  const rows = ctx.db.prepare(query).all(...params);
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const endpoint = row.endpoint ?? "common";
+    const key = `${endpoint}/${row.kind}`;
+    let group = groups.get(key);
+    if (!group) {
+      group = { endpoint, kind: row.kind, posScore: 0, negScore: 0, bucket: "observation", evidence: [] };
+      groups.set(key, group);
+    }
+    const ageMs = Math.max(0, now - parseDbTime(row.created_at));
+    const actorWeight = row.actor.endsWith("-auto") ? AUTO_ACTOR_WEIGHT : 1;
+    const weight = actorWeight * Math.pow(0.5, ageMs / halfLifeMs);
+    if (row.verdict === 1) group.posScore += weight;
+    else group.negScore += weight;
+    group.evidence.push({
+      artifactId: row.artifact_id,
+      path: row.path,
+      module: row.module,
+      verdict: row.verdict,
+      weight: Math.round(weight * 100) / 100,
+      comment: row.comment,
+      actor: row.actor,
+      createdAt: row.created_at
+    });
+  }
+  const result = [...groups.values()];
+  for (const g of result) {
+    g.posScore = Math.round(g.posScore * 100) / 100;
+    g.negScore = Math.round(g.negScore * 100) / 100;
+    const pos = g.posScore >= SKILL_CANDIDATE_THRESHOLD;
+    const neg = g.negScore >= RED_FLAG_THRESHOLD;
+    if (pos && neg) {
+      g.bucket = "observation";
+      g.reason = "mixed";
+    } else if (pos) {
+      g.bucket = "skill-candidate";
+    } else if (neg) {
+      g.bucket = "red-flag";
+    } else {
+      g.bucket = "observation";
+      g.reason = "insufficient";
+    }
+  }
+  const order = { "skill-candidate": 0, "red-flag": 1, observation: 2 };
+  return result.sort((a, b) => order[a.bucket] - order[b.bucket] || `${a.endpoint}/${a.kind}`.localeCompare(`${b.endpoint}/${b.kind}`));
+}
+function approvalStats(ctx) {
+  const rows = ctx.db.prepare(
+    `SELECT e.entity_id, e.event, e.created_at, a.kind
+       FROM events e JOIN artifacts a ON a.id = e.entity_id
+       WHERE e.entity_type = 'artifact' AND e.event IN ('submitted', 'approved', 'rejected')
+       ORDER BY e.entity_id, e.id`
+  ).all();
+  const perKind = /* @__PURE__ */ new Map();
+  const kindOf = (kind) => {
+    let k = perKind.get(kind);
+    if (!k) {
+      k = { approved: 0, rejected: 0, durations: [] };
+      perKind.set(kind, k);
+    }
+    return k;
+  };
+  let currentEntity = -1;
+  let lastSubmittedAt = null;
+  for (const row of rows) {
+    if (row.entity_id !== currentEntity) {
+      currentEntity = row.entity_id;
+      lastSubmittedAt = null;
+    }
+    const k = kindOf(row.kind);
+    if (row.event === "submitted") {
+      lastSubmittedAt = parseDbTime(row.created_at);
+    } else if (row.event === "approved") {
+      k.approved++;
+      if (lastSubmittedAt !== null) {
+        k.durations.push(parseDbTime(row.created_at) - lastSubmittedAt);
+        lastSubmittedAt = null;
+      }
+    } else {
+      k.rejected++;
+      lastSubmittedAt = null;
+    }
+  }
+  const hours = (ds) => ds.length === 0 ? null : Math.round(ds.reduce((s, d) => s + d, 0) / ds.length / 36e5 * 100) / 100;
+  const byKind = [...perKind.entries()].map(([kind, k]) => ({ kind, approved: k.approved, rejected: k.rejected, avgApprovalHours: hours(k.durations) })).sort((a, b) => a.kind.localeCompare(b.kind));
+  const approved = byKind.reduce((s, k) => s + k.approved, 0);
+  const rejected = byKind.reduce((s, k) => s + k.rejected, 0);
+  const allDurations = [...perKind.values()].flatMap((k) => k.durations);
+  return {
+    approved,
+    rejected,
+    rejectionRate: approved + rejected === 0 ? null : Math.round(rejected / (approved + rejected) * 100) / 100,
+    avgApprovalHours: hours(allDurations),
+    byKind
+  };
+}
+function runRetrospective(ctx, opts = {}) {
+  const groups = distillFeedback(ctx, opts);
+  const candidates = groups.filter((g) => g.bucket === "skill-candidate").length;
+  const redFlags = groups.filter((g) => g.bucket === "red-flag").length;
+  const cli = ctx.config.cli;
+  const guidance = [];
+  if (candidates > 0) {
+    guidance.push(
+      `\u53D1\u73B0 ${candidates} \u4E2A skill \u5019\u9009\u7EC4:\u4F9D\u636E\u5176 evidence(\u8DEF\u5F84+comment)\u8D77\u8349 .claude/skills/<\u540D\u79F0>/SKILL.md,\u7136\u540E \`${cli} register-meta\` \u6CE8\u518C + \`${cli} submit --actor=<\u89D2\u8272> -- .claude/skills/<\u540D\u79F0>/SKILL.md\` \u9001\u4EBA\u5BA1;approved \u540E\u624D\u4F5C\u4E3A\u7ECF\u9A8C\u751F\u6548`
+    );
+  }
+  if (redFlags > 0) {
+    guidance.push(
+      `\u53D1\u73B0 ${redFlags} \u4E2A Red Flags \u7EC4:\u8D1F\u4F8B comment \u5373\u7D20\u6750,\u5199\u5165\u5BF9\u5E94 skill \u8349\u7A3F\u7684 Red Flags \u7AE0\u8282;\u80FD\u673A\u5668\u67E5\u7684\u7EA6\u5B9A\u5E94\u964D\u7EA7\u4E3A protocolLints \u5361\u70B9(workbench.config.json)`
+    );
+  }
+  if (guidance.length === 0) {
+    guidance.push("\u53CD\u9988\u6837\u672C\u4E0D\u8DB3,\u7EE7\u7EED\u79EF\u7D2F(QA pass \u81EA\u52A8\u5582 +1,\u4EBA\u5DE5 \u{1F44D}\u{1F44E} \u662F\u66F4\u5F3A\u4FE1\u53F7)");
+  }
+  return {
+    halfLifeDays: ctx.config.feedbackHalfLifeDays,
+    module: opts.module ?? null,
+    groups,
+    candidates,
+    redFlags,
+    approval: approvalStats(ctx),
+    guidance
+  };
+}
+function exportEventLog(ctx) {
+  ctx.db.pragma("wal_checkpoint(TRUNCATE)");
+  const dir = join11(ctx.root, ctx.config.dataDir);
+  mkdirSync4(dir, { recursive: true });
+  const dump = (table, file) => {
+    const rows = ctx.db.prepare(`SELECT * FROM ${table} ORDER BY id`).all();
+    writeFileSync3(join11(dir, file), rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : ""));
+    return rows.length;
+  };
+  return {
+    events: dump("events", "events.jsonl"),
+    feedbacks: dump("artifact_feedback", "feedback.jsonl"),
+    files: [`${ctx.config.dataDir}/events.jsonl`, `${ctx.config.dataDir}/feedback.jsonl`]
+  };
+}
+var SKILL_CANDIDATE_THRESHOLD, RED_FLAG_THRESHOLD, AUTO_ACTOR_WEIGHT;
+var init_retro_command = __esm({
+  "core/commands/retro.command.ts"() {
+    "use strict";
+    SKILL_CANDIDATE_THRESHOLD = 3;
+    RED_FLAG_THRESHOLD = 2;
+    AUTO_ACTOR_WEIGHT = 0.5;
+  }
+});
+
+// core/commands/plan.command.ts
+function planModule(ctx, moduleRaw, creator = "product-manager") {
+  const module = normalizeModule(moduleRaw, ctx.config);
+  const summary = { created: [], skipped: 0, cancelled: 0, warnings: [] };
+  const artifacts = ctx.db.prepare("SELECT * FROM artifacts WHERE module IS ? OR module IS NULL").all(module);
+  const byKind = (kind) => artifacts.filter((a) => a.kind === kind && a.module === module);
+  const projectLevel = (kind) => artifacts.filter((a) => a.kind === kind && a.module === null);
+  const modulePrd = byKind("module-prd");
+  if (modulePrd.length === 0) {
+    throw new Error(`[\u524D\u7F6E\u6761\u4EF6] \u6A21\u5757 ${module} \u6CA1\u6709\u767B\u8BB0 module-prd,PM \u5148\u4EA7\u51FA\u5E76\u767B\u8BB0\u540E\u624D\u80FD\u6D3E\u53D1`);
+  }
+  const trustChecks = [
+    { desc: "\u6280\u672F\u57FA\u7EBF(baseline)", rows: projectLevel("baseline") },
+    { desc: "\u9879\u76EE\u5168\u666F(project)", rows: projectLevel("project") },
+    { desc: `flow(${module})`, rows: byKind("flow") },
+    { desc: `\u6A21\u5757 PRD(${module})`, rows: modulePrd }
+  ];
+  for (const check of trustChecks) {
+    const ok = check.rows.some((r) => reviewStatus(r) === "approved");
+    if (ok) continue;
+    const msg = `[\u4FE1\u4EFB\u8B66\u544A] ${check.desc} \u672A\u8FBE approved`;
+    if (ctx.config.gates.approvalMode === "enforce") throw new Error(`[\u524D\u7F6E\u6761\u4EF6] ${msg}`);
+    summary.warnings.push(msg);
+  }
+  const pagePrds = byKind("page-prd").filter((a) => a.endpoint && a.page);
+  const endpoints = [...new Set(pagePrds.map((a) => a.endpoint))];
+  const desired = [
+    { role: "architect", endpoint: "common", page: null, type: "build", assignee: "architect", content: `\u8BBE\u8BA1 ${module} \u6A21\u5757\u6570\u636E\u5E93` },
+    { role: "architect", endpoint: "service", page: null, type: "build", assignee: "architect", content: `\u8BBE\u8BA1 ${module} \u6A21\u5757 API \u6587\u6863` },
+    { role: "developer", endpoint: "service", page: null, type: "build", assignee: "developer", content: `\u5B9E\u73B0 ${module} \u6A21\u5757 service \u7AEF` }
+  ];
+  for (const endpoint of endpoints) {
+    const hasDesignSystem = artifacts.some((a) => a.kind === "design-system" && a.endpoint === endpoint);
+    if (!hasDesignSystem) {
+      desired.push({
+        role: "designer",
+        endpoint,
+        page: null,
+        type: "build",
+        assignee: "designer",
+        content: `\u5EFA\u7ACB ${endpoint} \u7AEF\u8BBE\u8BA1\u7CFB\u7EDF(\u8BE5\u7AEF\u9996\u4E2A\u9875\u9762\u8BBE\u8BA1\u524D\u7F6E)`
+      });
+    }
+  }
+  for (const prd of pagePrds) {
+    desired.push(
+      { role: "designer", endpoint: prd.endpoint, page: prd.page, type: "build", assignee: "designer", content: `\u8BBE\u8BA1 ${prd.endpoint}/${prd.page} \u9875\u9762(\u63D0\u793A\u8BCD+\u539F\u578B)` },
+      { role: "developer", endpoint: prd.endpoint, page: prd.page, type: "build", assignee: "developer", content: `\u5B9E\u73B0 ${prd.endpoint}/${prd.page} \u9875\u9762` },
+      { role: "qa", endpoint: prd.endpoint, page: prd.page, type: "qa", assignee: "qa", content: `\u9A8C\u6536 ${prd.endpoint}/${prd.page} \u9875\u9762` }
+    );
+  }
+  const activeRoles = new Set(ctx.config.pipeline);
+  const filtered = desired.filter((d) => activeRoles.has(d.role));
+  desired.length = 0;
+  desired.push(...filtered);
+  const exists = ctx.db.prepare(
+    `SELECT COUNT(*) AS c FROM tasks
+     WHERE module IS ? AND role = ? AND endpoint IS ? AND page IS ? AND type = ? AND status != 'cancelled'`
+  );
+  for (const d of desired) {
+    const row = exists.get(module, d.role, d.endpoint, d.page, d.type);
+    if (row.c > 0) {
+      summary.skipped++;
+      continue;
+    }
+    const id = createTask(ctx, { module, role: d.role, endpoint: d.endpoint, page: d.page, type: d.type, assignee: d.assignee, creator, content: d.content });
+    summary.created.push({ id, role: d.role, endpoint: d.endpoint, page: d.page, type: d.type });
+  }
+  const validPages = new Set(pagePrds.map((p) => `${p.endpoint}|${p.page}`));
+  const pending = ctx.db.prepare(
+    `SELECT id, role, endpoint, page FROM tasks
+       WHERE module IS ? AND status = 'pending' AND page IS NOT NULL AND type IN ('build', 'qa')`
+  ).all(module);
+  for (const t of pending) {
+    if (validPages.has(`${t.endpoint}|${t.page}`)) continue;
+    const tx = ctx.db.transaction(() => {
+      ctx.db.prepare("UPDATE tasks SET status = 'cancelled', updated_at = CURRENT_TIMESTAMP WHERE id = ?").run(t.id);
+      logEvent(ctx.db, {
+        entityType: "task",
+        entityId: t.id,
+        event: "plan_cancelled",
+        actor: creator,
+        payload: { reason: "\u9875\u9762 PRD \u5DF2\u5220\u9664" },
+        module,
+        endpoint: t.endpoint,
+        page: t.page
+      });
+    });
+    tx();
+    summary.cancelled++;
+  }
+  return summary;
+}
+var init_plan_command = __esm({
+  "core/commands/plan.command.ts"() {
+    "use strict";
+    init_derive();
+    init_events();
+    init_kind();
+    init_task_commands();
+  }
+});
+
+// core/commands/install-hooks.command.ts
+import { chmodSync, existsSync as existsSync10, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join12 } from "node:path";
+function installGitHooks(ctx) {
+  const hooksDir = join12(ctx.root, ".git", "hooks");
+  if (!existsSync10(join12(ctx.root, ".git"))) throw new Error("\u4E0D\u662F git \u4ED3\u5E93");
+  mkdirSync5(hooksDir, { recursive: true });
+  const installed = [];
+  const postCommit = `#!/bin/sh
+# opcflow:\u63D0\u4EA4\u540E\u5BF9\u8D26(fail-open,\u540E\u53F0\u6267\u884C\u4E0D\u963B\u585E git)
+${WORKBENCH_BIN} postcommit >/dev/null 2>&1 &
+exit 0
+`;
+  writeFileSync4(join12(hooksDir, "post-commit"), postCommit);
+  try {
+    chmodSync(join12(hooksDir, "post-commit"), 493);
+  } catch {
+  }
+  installed.push("post-commit(sync \u5BF9\u8D26)");
+  if (ctx.config.git.taskTrailer === "on") {
+    const prepare = `#!/bin/sh
+# workbench:\u6CE8\u5165\u4EFB\u52A1\u5F52\u56E0 trailer(\u73AF\u5883\u53D8\u91CF WORKBENCH_TASK_ID \u5B58\u5728\u65F6)
+if [ -n "$WORKBENCH_TASK_ID" ] && [ "$2" != "merge" ]; then
+  if ! grep -q "^${ctx.config.git.trailerKey}: #" "$1"; then
+    printf '\\n${ctx.config.git.trailerKey}: #%s\\n' "$WORKBENCH_TASK_ID" >> "$1"
+  fi
+fi
+exit 0
+`;
+    writeFileSync4(join12(hooksDir, "prepare-commit-msg"), prepare);
+    try {
+      chmodSync(join12(hooksDir, "prepare-commit-msg"), 493);
+    } catch {
+    }
+    installed.push(`prepare-commit-msg(${ctx.config.git.trailerKey} trailer \u6CE8\u5165)`);
+  }
+  return installed;
+}
+var init_install_hooks_command = __esm({
+  "core/commands/install-hooks.command.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// core/commands/gen-agents.command.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync6, readdirSync as readdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname3, join as join13 } from "node:path";
+function expandPath(ctx, kind) {
+  const spec = getKindRegistry(ctx.config)[kind];
+  const raw = spec?.pathPatterns?.[0] ?? "";
+  return raw.replace("{prd}", ctx.config.docs.prd).replace("{architecture}", ctx.config.docs.architecture).replace("{design}", ctx.config.docs.design).replace("{acceptance}", ctx.config.docs.acceptance);
+}
+function parseTemplate(rawInput) {
+  const raw = rawInput.replace(/\r\n/g, "\n");
+  const m = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!m) throw new Error("\u6A21\u677F\u7F3A\u5C11 frontmatter");
+  const meta = {};
+  for (const line of m[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    meta[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+  return {
+    name: meta.name ?? "",
+    description: meta.description ?? "",
+    tools: (meta.tools ?? "").split(",").map((t) => t.trim()).filter(Boolean),
+    body: m[2].replace(/^\n+/, "")
+  };
+}
+function genAgents(ctx, templatesDir) {
+  const lang = ctx.config.language;
+  const blocks = SHARED[lang] ?? SHARED.zh;
+  const dir = templatesDir ?? join13(WORKBENCH_DIR, "templates/agents", lang);
+  if (!existsSync11(dir)) throw new Error(`\u6A21\u677F\u76EE\u5F55\u4E0D\u5B58\u5728: ${dir}`);
+  const cli = ctx.config.cli;
+  const baseTokens = {
+    CLI: cli,
+    TRUST_PROTOCOL: blocks.trust.replaceAll("{{CLI}}", cli),
+    CLI_GUIDE: blocks.guide.replaceAll("{{CLI}}", cli),
+    PATH_PROJECT: expandPath(ctx, "project"),
+    PATH_ROLES: expandPath(ctx, "roles"),
+    PATH_GLOSSARY: expandPath(ctx, "glossary"),
+    PATH_FLOWS: expandPath(ctx, "flow"),
+    PATH_MODULES: expandPath(ctx, "module-prd"),
+    PATH_PAGES: expandPath(ctx, "page-prd"),
+    PATH_DB_DOCS: expandPath(ctx, "db-doc"),
+    PATH_API_DOCS: expandPath(ctx, "api-doc"),
+    PATH_DESIGN_SYSTEMS: expandPath(ctx, "design-system"),
+    PATH_DESIGN_PROMPTS: expandPath(ctx, "design-prompt"),
+    PATH_PROTOTYPES: expandPath(ctx, "prototype"),
+    PATH_ACCEPTANCE: expandPath(ctx, "acceptance"),
+    ENDPOINTS: ctx.config.endpoints.join(" / "),
+    PIPELINE: ctx.config.pipeline.join(" \u2192 "),
+    CODE_ROOTS: ctx.config.endpoints.map((e) => `| ${e} | ${(ctx.config.codeRoots[e] ?? []).join(blocks.sep) || blocks.todo} |`).join("\n")
+  };
+  const renderTokens = (text, memory) => {
+    let content = text;
+    const tokens = { ...baseTokens, MEMORY: memory };
+    for (const [token, value] of Object.entries(tokens)) content = content.replaceAll(`{{${token}}}`, value);
+    const leftover = content.match(/\{\{[A-Z_]+\}\}/);
+    if (leftover) throw new Error(`\u6A21\u677F\u5B58\u5728\u672A\u89E3\u6790 token: ${leftover[0]}`);
+    return content;
+  };
+  const adapters = resolvePlatforms(ctx.config.platforms);
+  const pipeline = new Set(ctx.config.pipeline);
+  const written = [];
+  for (const file of readdirSync5(dir)) {
+    if (!file.endsWith(".md")) continue;
+    const role = file.replace(/\.md$/, "");
+    if (!pipeline.has(role)) continue;
+    const tpl = parseTemplate(readFileSync6(join13(dir, file), "utf-8"));
+    for (const adapter of adapters) {
+      const memory = adapter.memoryBlock(role, lang);
+      const spec = {
+        name: tpl.name,
+        description: renderTokens(tpl.description, memory),
+        tools: tpl.tools,
+        model: resolveModel(ctx.config.model, adapter),
+        body: renderTokens(tpl.body, memory)
+      };
+      const rel = `${adapter.agentsDir}/${adapter.agentFile(role)}`;
+      const abs = join13(ctx.root, rel);
+      mkdirSync6(dirname3(abs), { recursive: true });
+      writeFileSync5(abs, adapter.renderAgent(spec));
+      written.push(rel);
+    }
+  }
+  return { written };
+}
+var TRUST_PROTOCOL_ZH, CLI_GUIDE_ZH, TRUST_PROTOCOL_EN, CLI_GUIDE_EN, SHARED;
+var init_gen_agents_command = __esm({
+  "core/commands/gen-agents.command.ts"() {
+    "use strict";
+    init_config();
+    init_kind();
+    init_platforms();
+    TRUST_PROTOCOL_ZH = `## \u4FE1\u4EFB\u534F\u8BAE(\u6700\u9AD8\u4F18\u5148\u7EA7)
+
+| \u4E0A\u6E38\u4EA7\u7269\u72B6\u6001 | \u4F60\u7684\u884C\u4E3A |
+| --- | --- |
+| approved | \u89C6\u4E3A\u771F\u76F8\u76F4\u63A5\u4F7F\u7528;**\u7981\u6B62**\u91CD\u65B0\u63A8\u5BFC\u3001\u7981\u6B62\u5411\u7528\u6237\u91CD\u590D\u786E\u8BA4\u5DF2\u62CD\u677F\u5185\u5BB9 |
+| draft / pending(\u4ECE\u672A\u83B7\u6279) | \u53EF\u7528,\u4F46\u4EA7\u51FA\u4E2D\u6807\u6CE8"\u57FA\u4E8E\u672A\u5BA1\u6587\u6863";\u9047\u7591\u70B9\u505C\u4E0B\u6765\u95EE |
+| pending \u4E14\u66FE\u83B7\u6279(\u590D\u5BA1\u4E2D) | **\u7981\u7528**,\u7B49\u590D\u5BA1\u901A\u8FC7 |
+| invalidated | **\u7981\u7528**,\u505C\u6B62\u5E76\u8981\u6C42\u4E0A\u6E38\u590D\u5BA1 |
+
+\u72B6\u6001\u67E5\u8BE2:\`{{CLI}} artifacts --module=<\u6A21\u5757>\`
+\u5BF9 approved \u5185\u5BB9\u6709\u5B9E\u8D28\u5F02\u8BAE\u65F6**\u7981\u6B62\u64C5\u81EA\u504F\u79BB**,\u7559\u75D5\u540E\u505C\u6B62\u7B49\u7528\u6237\u88C1\u51B3:
+\`{{CLI}} dispute --actor=<\u89D2\u8272> --reason="..." -- <\u6587\u4EF6\u8DEF\u5F84>\``;
+    CLI_GUIDE_ZH = `## \u4EFB\u52A1\u64CD\u4F5C
+
+MCP \u5DF2\u6CE8\u518C\u65F6\u4F18\u5148\u7528 \`wb_*\` typed tools(\u4E0E CLI \u540C\u6E90\u540C\u4E8B\u52A1);CLI \u7B49\u4EF7:
+
+\`\`\`bash
+{{CLI}} list --role=<\u89D2\u8272> --status=pending   # \u67E5\u770B\u5F85\u529E
+{{CLI}} claim <id> --assignee=<\u89D2\u8272>          # \u9886\u53D6(gate \u81EA\u52A8\u6821\u9A8C,\u4F9D\u8D56\u81EA\u52A8\u5FEB\u7167)
+{{CLI}} input <id> --operator=<\u89D2\u8272> -- <\u8DEF\u5F84> # \u8865\u5145\u7533\u62A5 gate \u4E4B\u5916\u8BFB\u8FC7\u7684\u4EA7\u7269
+{{CLI}} output --module=<\u6A21\u5757> --role=<\u89D2\u8272> --endpoint=<\u7AEF> [--page=<\u6A21\u5757>/<\u9875\u9762>] -- <\u8DEF\u5F84>
+{{CLI}} submit --actor=<\u89D2\u8272> -- <\u8DEF\u5F84>        # \u5951\u7EA6\u7C7B\u6587\u6863\u5199\u5B8C\u5373\u9001\u5BA1
+{{CLI}} update <id> --status=completed --operator=<\u89D2\u8272>
+{{CLI}} record <id> --operator=<\u89D2\u8272> "\u5907\u6CE8"
+\`\`\`
+
+- \u9886\u53D6\u65F6 gate \u62A5\u9519\u90FD\u662F**\u53EF\u884C\u52A8\u7684**:\u6309\u63D0\u793A\u7B49\u4E0A\u6E38\u4EA7\u51FA/\u5BA1\u6279,\u7981\u6B62\u7ED5\u8FC7
+- \u4EFB\u52A1 stale(\u4E0A\u6E38\u53D8\u66F4)\u65F6 complete \u4F1A\u88AB\u62E6\u622A:\u5148\u5BF9\u9F50\u53D8\u66F4;\u786E\u8BA4\u65E0\u5F71\u54CD\u624D \`--force=true\`(\u7559\u75D5)
+- \u4EA7\u51FA\u5FC5\u987B**\u5148\u5199\u6587\u4EF6\u518D\u767B\u8BB0**;\u767B\u8BB0\u4F1A\u81EA\u52A8\u5173\u8054\u4F60\u9886\u53D6\u7684\u4EFB\u52A1
+- **git \u5F52\u56E0**:\u9886\u53D6\u4EFB\u52A1\u540E\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF \`WORKBENCH_TASK_ID=<\u4EFB\u52A1id>\`,
+  \u63D0\u4EA4\u65F6 hook \u81EA\u52A8\u6CE8\u5165 \`Task: #id\` trailer(\u591A agent \u540C\u5206\u652F\u7684\u5F52\u56E0\u4F9D\u636E,\u4E0D\u8BBE\u5373\u4E3A\u5B64\u513F\u63D0\u4EA4)`;
+    TRUST_PROTOCOL_EN = `## Trust Protocol (highest priority)
+
+| Upstream state | Your behavior |
+| --- | --- |
+| approved | Treat as truth, use directly; **do not** re-derive or re-confirm settled content |
+| draft / pending (never approved) | Usable, but flag outputs as "based on unreviewed docs"; stop and ask on doubt |
+| pending & previously approved (under re-review) | **Forbidden**, wait for re-review |
+| invalidated | **Forbidden**, stop and require upstream re-review |
+
+Query state: \`{{CLI}} artifacts --module=<module>\`
+On a substantive objection to approved content, **do not silently deviate** \u2014 leave a trace and stop for a ruling:
+\`{{CLI}} dispute --actor=<role> --reason="..." -- <file path>\``;
+    CLI_GUIDE_EN = `## Task operations
+
+When MCP is registered, prefer the \`wb_*\` typed tools (same source & transaction as the CLI); CLI equivalents:
+
+\`\`\`bash
+{{CLI}} list --role=<role> --status=pending   # your queue
+{{CLI}} claim <id> --assignee=<role>          # claim (gate auto-checks, deps auto-snapshotted)
+{{CLI}} input <id> --operator=<role> -- <path> # declare a dep read outside the gate
+{{CLI}} output --module=<module> --role=<role> --endpoint=<endpoint> [--page=<module>/<page>] -- <path>
+{{CLI}} submit --actor=<role> -- <path>        # submit a contract doc once written
+{{CLI}} update <id> --status=completed --operator=<role>
+{{CLI}} record <id> --operator=<role> "note"
+\`\`\`
+
+- Gate errors on claim are **actionable**: follow them to wait for upstream output/approval, never bypass
+- A stale task (upstream changed) blocks complete: align with the change first; only \`--force=true\` (traced) once you confirm no impact
+- Outputs must be **written to a file, then registered**; registration auto-links your claimed task
+- **git attribution**: after claiming, set env var \`WORKBENCH_TASK_ID=<task id>\`; the commit hook injects a \`Task: #id\` trailer (attribution for multi-agent shared branches; unset = orphan commit)`;
+    SHARED = {
+      zh: { trust: TRUST_PROTOCOL_ZH, guide: CLI_GUIDE_ZH, todo: "(\u5F85\u914D\u7F6E:workbench.config.json \u7684 codeRoots)", sep: "\u3001" },
+      en: { trust: TRUST_PROTOCOL_EN, guide: CLI_GUIDE_EN, todo: "(configure codeRoots in workbench.config.json)", sep: ", " }
+    };
+  }
+});
+
+// core/commands/audit.command.ts
+import { existsSync as existsSync12 } from "node:fs";
+import { join as join14 } from "node:path";
+function auditModule(ctx, moduleRaw) {
+  const module = normalizeModule(moduleRaw, ctx.config);
+  const kinds = contractKinds(ctx.config);
+  const artifacts = ctx.db.prepare(`SELECT * FROM artifacts WHERE module = ? ORDER BY kind, path`).all(module);
+  const contracts = artifacts.filter((a) => kinds.includes(a.kind)).map((a) => ({
+    kind: a.kind,
+    path: a.path,
+    status: reviewStatus(a),
+    everApproved: everApproved(a),
+    onDisk: existsSync12(join14(ctx.root, a.path))
+  }));
+  const codeDirs = artifacts.filter((a) => a.kind === "code").map((a) => ({ path: a.path, endpoint: a.endpoint, onDisk: existsSync12(join14(ctx.root, a.path)) }));
+  return {
+    module,
+    cleared: moduleCleared(ctx.db, module),
+    contracts,
+    codeDirs,
+    suggestedSubmits: contracts.filter((c) => c.status === "draft" && c.onDisk).map((c) => c.path)
+  };
+}
+var init_audit_command = __esm({
+  "core/commands/audit.command.ts"() {
+    "use strict";
+    init_derive();
+    init_kind();
+  }
+});
+
+// core/commands/intake.command.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+function intakeIssues(ctx) {
+  const summary = { fetched: 0, created: [], skipped: 0 };
+  let issues = [];
+  try {
+    const out = execFileSync3("gh", ["issue", "list", "--state", "open", "--json", "number,title,url,labels", "--limit", "50"], {
+      cwd: ctx.root,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString();
+    issues = JSON.parse(out);
+  } catch {
+    throw new Error("gh CLI \u4E0D\u53EF\u7528\u6216\u975E GitHub \u4ED3\u5E93(intake \u4F9D\u8D56 gh issue list)");
+  }
+  summary.fetched = issues.length;
+  const exists = ctx.db.prepare("SELECT COUNT(*) AS c FROM tasks WHERE external_ref = ?");
+  for (const issue of issues) {
+    const ref = `gh#${issue.number}`;
+    if (exists.get(ref).c > 0) {
+      summary.skipped++;
+      continue;
+    }
+    const isBug = issue.labels.some((l) => l.name.toLowerCase() === "bug");
+    const id = createTask(ctx, {
+      role: isBug ? "developer" : "product-manager",
+      endpoint: isBug ? null : null,
+      type: isBug ? "hotfix" : "build",
+      assignee: isBug ? "developer" : "product-manager",
+      creator: "intake",
+      content: `[gh#${issue.number}] ${issue.title}
+${issue.url}`,
+      externalRef: ref
+    });
+    summary.created.push({ issue: issue.number, taskId: id, lane: isBug ? "hotfix" : "pm" });
+  }
+  return summary;
+}
+var init_intake_command = __esm({
+  "core/commands/intake.command.ts"() {
+    "use strict";
+    init_task_commands();
+  }
+});
+
+// core/commands/init.command.ts
+import {
+  copyFileSync,
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync7,
+  readdirSync as readdirSync6,
+  writeFileSync as writeFileSync6
+} from "node:fs";
+import { dirname as dirname4, join as join15 } from "node:path";
+function deployPreset(root) {
+  const deployed = [];
+  if (!existsSync13(PRESET_DIR)) return deployed;
+  const walk = (rel) => {
+    for (const ent of readdirSync6(join15(PRESET_DIR, rel), {
+      withFileTypes: true
+    })) {
+      const childRel = rel ? join15(rel, ent.name) : ent.name;
+      if (ent.isDirectory()) {
+        walk(childRel);
+      } else if (ent.isFile()) {
+        const dest = join15(root, childRel);
+        if (existsSync13(dest)) continue;
+        mkdirSync7(dirname4(dest), { recursive: true });
+        copyFileSync(join15(PRESET_DIR, childRel), dest);
+        deployed.push(childRel);
+      }
+    }
+  };
+  walk("");
+  return deployed;
+}
+function ensureRootTsx(root) {
+  const pkgPath = join15(root, "package.json");
+  if (!existsSync13(pkgPath)) return false;
+  const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+  if (pkg.devDependencies?.tsx) return false;
+  pkg.devDependencies = { ...pkg.devDependencies ?? {}, tsx: TSX_VERSION };
+  writeFileSync6(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  return true;
+}
+function initProject(root, opts) {
+  const configPath = join15(root, CONFIG_FILENAME);
+  if (existsSync13(configPath)) {
+    throw new Error(
+      `${CONFIG_FILENAME} \u5DF2\u5B58\u5728,init \u53EA\u7528\u4E8E\u7A7A\u9879\u76EE\u5F15\u5BFC(\u6539\u914D\u7F6E\u8BF7\u76F4\u63A5\u7F16\u8F91\u8BE5\u6587\u4EF6)`
+    );
+  }
+  if (opts.endpoints.length === 0)
+    throw new Error("\u81F3\u5C11\u58F0\u660E\u4E00\u4E2A\u7AEF(--endpoints=service,...)");
+  const hasFrontend = opts.endpoints.some((e) => e !== "service");
+  const pipeline = opts.pipeline ?? (hasFrontend ? ["product-manager", "architect", "designer", "developer", "qa"] : ["product-manager", "architect", "developer", "qa"]);
+  const config = {
+    endpoints: opts.endpoints,
+    pipeline,
+    docs: {
+      prd: "docs/prd",
+      architecture: "docs/architecture",
+      design: "docs/design",
+      acceptance: "docs/acceptance"
+    },
+    codeRoots: opts.codeRoots ?? {},
+    cli: WORKBENCH_BIN,
+    machineChecks: { enabled: false },
+    protocolLints: [],
+    moduleMapping: {},
+    feedbackHalfLifeDays: 15,
+    gates: { approvalMode: "warn", writeGate: "observe" },
+    git: { taskTrailer: "off", trailerKey: "Task" },
+    platforms: opts.platforms && opts.platforms.length ? opts.platforms : ["claude"],
+    language: opts.language ?? "zh",
+    ...opts.model ? { model: opts.model } : {}
+  };
+  writeFileSync6(configPath, JSON.stringify(config, null, 2) + "\n");
+  const scaffolded = [];
+  if (opts.scaffold !== false) {
+    for (const dir of DOC_DIRS) {
+      const abs = join15(root, dir);
+      if (!existsSync13(abs)) {
+        mkdirSync7(abs, { recursive: true });
+        writeFileSync6(join15(abs, ".gitkeep"), "");
+        scaffolded.push(dir);
+      }
+    }
+  }
+  const preset = opts.preset !== false ? deployPreset(root) : [];
+  const rootTsxAdded = ensureRootTsx(root);
+  const ctx = openWorkbenchAt(root);
+  const { written } = genAgents(ctx);
+  const meta = registerMetaArtifacts(ctx);
+  const adapters = resolvePlatforms(config.platforms);
+  const server = {
+    name: "opcflow",
+    command: "npx",
+    args: ["-y", PKG_NAME, "mcp"]
+  };
+  const mcpPaths = [];
+  if (opts.mcp !== false) for (const a of adapters) mcpPaths.push(a.writeMcp(root, server));
+  const hookPaths = [];
+  if (opts.writeHooks !== false) {
+    const preBase = `${WORKBENCH_BIN} hook pre`;
+    const postBase = `${WORKBENCH_BIN} hook post`;
+    for (const a of adapters)
+      hookPaths.push(
+        ...a.writeHooks(root, {
+          preCommand: `${preBase} --platform=${a.id}`,
+          postCommand: `${postBase} --platform=${a.id}`
+        })
+      );
+  }
+  const notes = adapters.flatMap((a) => a.notes);
+  let hooks = [];
+  if (opts.gitHooks !== false && existsSync13(join15(root, ".git"))) {
+    try {
+      hooks = installGitHooks(ctx);
+    } catch {
+    }
+  }
+  return {
+    ctx,
+    configPath,
+    agents: written,
+    metaRegistered: meta.registered.length,
+    hooks,
+    scaffolded,
+    mcpPaths,
+    hookPaths,
+    platforms: config.platforms,
+    notes,
+    preset,
+    rootTsxAdded
+  };
+}
+var DOC_DIRS, PRESET_DIR, TSX_VERSION;
+var init_init_command = __esm({
+  "core/commands/init.command.ts"() {
+    "use strict";
+    init_config();
+    init_db();
+    init_platforms();
+    init_gen_agents_command();
+    init_install_hooks_command();
+    init_meta_command();
+    DOC_DIRS = [
+      "docs/prd/flows",
+      "docs/prd/modules",
+      "docs/prd/pages",
+      "docs/architecture/database",
+      "docs/architecture/api",
+      "docs/design/systems",
+      "docs/design/prompts",
+      "docs/design/prototypes",
+      "docs/acceptance"
+    ];
+    PRESET_DIR = join15(WORKBENCH_DIR, "preset");
+    TSX_VERSION = "^4";
+  }
+});
+
+// core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  AUTO_ACTOR_WEIGHT: () => AUTO_ACTOR_WEIGHT,
+  CONFIG_FILENAME: () => CONFIG_FILENAME,
+  CURRENT_SCHEMA_VERSION: () => CURRENT_SCHEMA_VERSION,
+  DEFAULT_KIND_REGISTRY: () => DEFAULT_KIND_REGISTRY,
+  KIND_TIERS: () => KIND_TIERS,
+  META_KINDS: () => META_KINDS,
+  MIGRATIONS: () => MIGRATIONS,
+  PKG_NAME: () => PKG_NAME,
+  PLATFORM_IDS: () => PLATFORM_IDS,
+  PM_KINDS: () => PM_KINDS,
+  RED_FLAG_THRESHOLD: () => RED_FLAG_THRESHOLD,
+  SCHEMA_V1: () => SCHEMA_V1,
+  SKILL_CANDIDATE_THRESHOLD: () => SKILL_CANDIDATE_THRESHOLD,
+  WORKBENCH_BIN: () => WORKBENCH_BIN,
+  WORKBENCH_DIR: () => WORKBENCH_DIR,
+  addTaskInput: () => addTaskInput,
+  approvalStats: () => approvalStats,
+  approveArtifact: () => approveArtifact,
+  approvedContent: () => approvedContent,
+  auditModule: () => auditModule,
+  buildTree: () => buildTree,
+  claimTask: () => claimTask,
+  closeLinkedIssue: () => closeLinkedIssue,
+  contractKinds: () => contractKinds,
+  createTask: () => createTask,
+  deriveEdges: () => deriveEdges,
+  detectOrphanCommit: () => detectOrphanCommit,
+  disputeArtifact: () => disputeArtifact,
+  distillFeedback: () => distillFeedback,
+  ensureSchema: () => ensureSchema,
+  everApproved: () => everApproved,
+  exportEventLog: () => exportEventLog,
+  feedbackArtifact: () => feedbackArtifact,
+  findProjectRoot: () => findProjectRoot,
+  genAgents: () => genAgents,
+  getAdapter: () => getAdapter,
+  getKindRegistry: () => getKindRegistry,
+  getTaskDetail: () => getTaskDetail,
+  getTaskRow: () => getTaskRow,
+  gitHead: () => gitHead,
+  graphModule: () => graphModule,
+  hashDirectory: () => hashDirectory,
+  hashFile: () => hashFile,
+  hashPath: () => hashPath,
+  headCommitInfo: () => headCommitInfo,
+  inferKind: () => inferKind,
+  initProject: () => initProject,
+  installGitHooks: () => installGitHooks,
+  intakeIssues: () => intakeIssues,
+  kindSpec: () => kindSpec,
+  listArtifacts: () => listArtifacts,
+  listEvents: () => listEvents,
+  listTasks: () => listTasks,
+  loadConfig: () => loadConfig,
+  logEvent: () => logEvent,
+  migrateLegacy: () => migrateLegacy,
+  moduleCleared: () => moduleCleared,
+  moveArtifact: () => moveArtifact,
+  nodeDetail: () => nodeDetail,
+  normalizeModule: () => normalizeModule,
+  normalizeRelPath: () => normalizeRelPath,
+  openWorkbench: () => openWorkbench,
+  openWorkbenchAt: () => openWorkbenchAt,
+  ownerRole: () => ownerRole,
+  planModule: () => planModule,
+  prototypeEndorsed: () => prototypeEndorsed,
+  recordNote: () => recordNote,
+  recordQaResult: () => recordQaResult,
+  refreshArtifact: () => refreshArtifact,
+  registerMetaArtifacts: () => registerMetaArtifacts,
+  registerOutput: () => registerOutput,
+  rejectArtifact: () => rejectArtifact,
+  removeTask: () => removeTask,
+  resolveArtifact: () => resolveArtifact,
+  resolveModel: () => resolveModel,
+  resolvePlatforms: () => resolvePlatforms,
+  reviewStatus: () => reviewStatus,
+  runProtocolLints: () => runProtocolLints,
+  runRetrospective: () => runRetrospective,
+  scanArtifacts: () => scanArtifacts,
+  spawnFollowupQa: () => spawnFollowupQa,
+  spawnReviews: () => spawnReviews,
+  submitArtifact: () => submitArtifact,
+  syncArtifacts: () => syncArtifacts,
+  taskStaleness: () => taskStaleness,
+  touchedByTaskTrailer: () => touchedByTaskTrailer,
+  touchedSince: () => touchedSince,
+  updateTask: () => updateTask,
+  validateClaim: () => validateClaim,
+  validateComplete: () => validateComplete
+});
+var init_core = __esm({
+  "core/index.ts"() {
+    "use strict";
+    init_types();
+    init_config();
+    init_db();
+    init_hash();
+    init_events();
+    init_kind();
+    init_platforms();
+    init_derive();
+    init_lints();
+    init_tree();
+    init_gates();
+    init_task_commands();
+    init_artifact_commands();
+    init_graph_command();
+    init_migrate_legacy_command();
+    init_meta_command();
+    init_scan_command();
+    init_sync_command();
+    init_qa_command();
+    init_retro_command();
+    init_plan_command();
+    init_install_hooks_command();
+    init_gen_agents_command();
+    init_audit_command();
+    init_intake_command();
+    init_init_command();
+    init_gh();
+    init_git();
+  }
+});
+
+// server/mcp.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  buildMcpServer: () => buildMcpServer
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+function buildMcpServer(ctx) {
+  const server = new McpServer({ name: "opcflow", version: "0.1.0" });
+  server.registerTool(
+    "wb_list_tasks",
+    {
+      description: "\u67E5\u770B\u4EFB\u52A1\u5217\u8868(gate \u62A5\u9519\u53EF\u884C\u52A8;\u9886\u53D6\u7528 wb_claim)",
+      inputSchema: { role: z.string().optional(), status: z.string().optional(), module: z.string().optional(), type: z.string().optional() }
+    },
+    async (args) => json(listTasks(ctx, { ...args, withStale: true }))
+  );
+  server.registerTool(
+    "wb_claim",
+    { description: "\u9886\u53D6\u4EFB\u52A1(gate \u81EA\u52A8\u6821\u9A8C,\u4E0A\u6E38\u4F9D\u8D56\u81EA\u52A8\u5FEB\u7167)", inputSchema: { id: z.number(), assignee: z.string() } },
+    async (args) => json(claimTask(ctx, args))
+  );
+  server.registerTool(
+    "wb_update_status",
+    {
+      description: "\u66F4\u65B0\u4EFB\u52A1\u72B6\u6001;completed \u4F1A\u8DD1 stale \u62E6\u622A/\u4EA7\u51FA\u4E49\u52A1/\u534F\u8BAE lint/\u673A\u5668\u68C0\u67E5",
+      inputSchema: { id: z.number(), status: z.string(), operator: z.string(), force: z.boolean().optional() }
+    },
+    async (args) => json(updateTask(ctx, args))
+  );
+  server.registerTool(
+    "wb_output",
+    {
+      description: "\u767B\u8BB0\u4EA7\u51FA\u6587\u4EF6(\u5FC5\u987B\u5148\u5199\u6587\u4EF6;\u81EA\u52A8\u63A8\u65AD kind \u5E76\u5173\u8054\u5DF2\u9886\u53D6\u4EFB\u52A1)",
+      inputSchema: {
+        role: z.string(),
+        endpoint: z.string().optional(),
+        module: z.string().optional(),
+        page: z.string().optional(),
+        filePath: z.string()
+      }
+    },
+    async (args) => json(registerOutput(ctx, { ...args, endpoint: args.endpoint ?? "common" }))
+  );
+  server.registerTool(
+    "wb_submit",
+    { description: "\u5951\u7EA6\u6587\u6863\u9001\u5BA1(\u8FDB\u5165\u7528\u6237\u5F85\u5BA1\u961F\u5217)", inputSchema: { path: z.string(), actor: z.string() } },
+    async (args) => json(submitArtifact(ctx, { path: args.path }, args.actor))
+  );
+  server.registerTool(
+    "wb_feedback",
+    {
+      description: "\u5BF9\u539F\u578B/\u4EE3\u7801\u4EA7\u7269\u8BB0\u5F55 \u{1F44D}(+1)/\u{1F44E}(-1);\u{1F44E} \u5FC5\u9644 comment;\u539F\u578B \u{1F44D}=\u653E\u884C",
+      inputSchema: { path: z.string(), verdict: z.union([z.literal(1), z.literal(-1)]), comment: z.string().optional(), actor: z.string() }
+    },
+    async (args) => json(feedbackArtifact(ctx, { path: args.path }, args))
+  );
+  server.registerTool(
+    "wb_dispute",
+    {
+      description: "\u5BF9 approved \u5185\u5BB9\u6709\u5B9E\u8D28\u5F02\u8BAE\u65F6\u7559\u75D5\u5E76\u505C\u6B62(\u7B49\u7528\u6237\u88C1\u51B3,\u7981\u6B62\u64C5\u81EA\u504F\u79BB)",
+      inputSchema: { path: z.string(), actor: z.string(), reason: z.string() }
+    },
+    async (args) => {
+      disputeArtifact(ctx, { path: args.path }, args.actor, args.reason);
+      return json({ ok: true });
+    }
+  );
+  server.registerTool(
+    "wb_input",
+    {
+      description: "\u8865\u5145\u7533\u62A5\u4EFB\u52A1\u4F9D\u8D56(gate \u4E4B\u5916\u8BFB\u8FC7\u7684\u767B\u8BB0\u4EA7\u7269,\u8FDB\u5165 stale \u76D1\u63A7)",
+      inputSchema: { id: z.number(), path: z.string(), operator: z.string() }
+    },
+    async (args) => {
+      addTaskInput(ctx, args);
+      return json({ ok: true });
+    }
+  );
+  server.registerTool(
+    "wb_record",
+    { description: "\u4EFB\u52A1\u5907\u6CE8\u7559\u75D5", inputSchema: { id: z.number(), content: z.string(), operator: z.string() } },
+    async (args) => {
+      recordNote(ctx, args);
+      return json({ ok: true });
+    }
+  );
+  server.registerTool(
+    "wb_plan",
+    { description: "\u6309\u5DF2\u767B\u8BB0 page-prd \u6D3E\u53D1\u6A21\u5757\u6574\u7EC4\u4EFB\u52A1(\u5E42\u7B49,\u5220\u9875\u81EA\u52A8 cancel)", inputSchema: { module: z.string(), creator: z.string().optional() } },
+    async (args) => json(planModule(ctx, args.module, args.creator))
+  );
+  server.registerTool(
+    "wb_sync",
+    { description: "\u5168\u91CF\u5BF9\u8D26:\u5931\u6548\u68C0\u6D4B+review \u6D3E\u53D1+tombstone", inputSchema: {} },
+    async () => json(syncArtifacts(ctx, "mcp"))
+  );
+  server.registerTool(
+    "wb_audit",
+    { description: "\u6A21\u5757\u5BF9\u8D26\u62A5\u544A(\u6E05\u7B97\u72B6\u6001/\u5951\u7EA6\u4FE1\u4EFB\u72B6\u6001/\u9001\u5BA1\u5EFA\u8BAE)", inputSchema: { module: z.string() } },
+    async (args) => json(auditModule(ctx, args.module))
+  );
+  server.registerTool(
+    "wb_qa",
+    {
+      description: "\u8BB0\u5F55 QA \u9A8C\u6536\u7ED3\u679C;fail \u5FC5\u9644 reason(\u81EA\u52A8\u6D3E rework,\u5B8C\u6210\u540E\u81EA\u52A8\u590D\u9A8C)",
+      inputSchema: { id: z.number(), result: z.enum(["pass", "fail"]), reason: z.string().optional(), operator: z.string() }
+    },
+    async (args) => json(recordQaResult(ctx, args))
+  );
+  server.registerTool(
+    "wb_retro",
+    {
+      description: "retrospective \u8BC1\u636E\u5305:\u53CD\u9988\u534A\u8870\u671F\u52A0\u6743\u63D0\u70BC(skill \u5019\u9009/Red Flags/\u89C2\u5BDF)+ \u5BA1\u6279\u541E\u5410\u62A5\u8868\u3002\u4F9D\u636E evidence \u8D77\u8349 .claude/skills/<\u540D\u79F0>/SKILL.md \u540E register-meta + submit \u9001\u4EBA\u5BA1,approved \u624D\u751F\u6548",
+      inputSchema: { module: z.string().optional() }
+    },
+    async (args) => json(runRetrospective(ctx, args))
+  );
+  server.registerTool(
+    "wb_artifacts",
+    {
+      description: "\u67E5\u770B\u4EA7\u7269\u4FE1\u4EFB\u72B6\u6001(approved=\u771F\u76F8\u76F4\u63A5\u7528;invalidated/\u590D\u5BA1\u4E2D=\u7981\u7528)",
+      inputSchema: { module: z.string().optional(), kind: z.string().optional(), endpoint: z.string().optional() }
+    },
+    async (args) => json(listArtifacts(ctx, args))
+  );
+  return server;
+}
+var json;
+var init_mcp = __esm({
+  "server/mcp.ts"() {
+    "use strict";
+    init_core();
+    json = (data) => ({ content: [{ type: "text", text: JSON.stringify(data, null, 2) }] });
+    if (process.argv[1]?.replace(/\\/g, "/").endsWith("server/mcp.ts")) {
+      Promise.resolve().then(() => (init_db(), db_exports)).then(async ({ openWorkbench: openWorkbench2 }) => {
+        const ctx = openWorkbench2(process.env.WORKBENCH_PROJECT);
+        const server = buildMcpServer(ctx);
+        await server.connect(new StdioServerTransport());
+      });
+    }
+  }
+});
+
+// server/app.ts
+var app_exports = {};
+__export(app_exports, {
+  createServer: () => createServer
+});
+import fastifyCors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import Fastify from "fastify";
+import { existsSync as existsSync14, readFileSync as readFileSync8, readdirSync as readdirSync7, statSync as statSync6 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join16, normalize, relative as relative2 } from "node:path";
+function getArtifact(ctx, id) {
+  const row = ctx.db.prepare("SELECT * FROM artifacts WHERE id = ?").get(id);
+  if (!row) throw Object.assign(new Error(`artifact #${id} \u4E0D\u5B58\u5728`), { statusCode: 404 });
+  return row;
+}
+function guardedAbsPath(ctx, artifact, rel) {
+  const base = normalize(join16(ctx.root, artifact.path));
+  if (!rel) return base;
+  const target = normalize(join16(base, rel));
+  const r = relative2(base, target);
+  if (r === "" || r === "." || r.startsWith("..") || isAbsolute2(r)) {
+    throw Object.assign(new Error("\u8DEF\u5F84\u8D8A\u754C"), { statusCode: 403 });
+  }
+  return target;
+}
+async function createServer(ctx) {
+  const app = Fastify({ logger: false });
+  await app.register(fastifyCors, { origin: true });
+  const webDist = join16(WORKBENCH_DIR, "web/dist");
+  if (existsSync14(webDist)) {
+    await app.register(fastifyStatic, { root: webDist });
+  }
+  app.get("/api/meta", async () => ({
+    root: ctx.root,
+    language: ctx.config.language,
+    pipeline: ctx.config.pipeline,
+    endpoints: ctx.config.endpoints,
+    approvalMode: ctx.config.gates.approvalMode
+  }));
+  app.get("/api/tree", async (req) => {
+    return buildTree(ctx, { includeMeta: req.query.includeMeta === "1" });
+  });
+  app.get(
+    "/api/node",
+    async (req) => {
+      const { module, endpoint, page, includeMeta } = req.query;
+      const isBucket = module === "__project__" || module === "__meta__";
+      return nodeDetail(ctx, {
+        module: isBucket ? null : module,
+        endpoint: endpoint || null,
+        page: page || null,
+        includeMeta: includeMeta === "1",
+        metaOnly: module === "__meta__"
+      });
+    }
+  );
+  app.get("/api/artifact/:id", async (req) => {
+    const artifact = getArtifact(ctx, parseInt(req.params.id));
+    const abs = guardedAbsPath(ctx, artifact);
+    const feedback = ctx.db.prepare("SELECT * FROM artifact_feedback WHERE artifact_id = ? ORDER BY id DESC").all(artifact.id);
+    const events = listEvents(ctx.db, { entityType: "artifact", entityId: artifact.id, limit: 50 });
+    let content = null;
+    let isDirectory = false;
+    let missing = false;
+    if (!existsSync14(abs)) {
+      missing = true;
+    } else if (statSync6(abs).isDirectory()) {
+      isDirectory = true;
+    } else if (statSync6(abs).size <= MAX_INLINE_SIZE) {
+      content = readFileSync8(abs, "utf-8");
+    }
+    return { artifact, content, isDirectory, missing, feedback, events };
+  });
+  app.get("/api/artifact/:id/raw", async (req, reply) => {
+    const artifact = getArtifact(ctx, parseInt(req.params.id));
+    const abs = guardedAbsPath(ctx, artifact);
+    if (!existsSync14(abs) || statSync6(abs).isDirectory()) {
+      return reply.code(404).send("not found");
+    }
+    reply.header("content-type", artifact.path.endsWith(".html") ? "text/html; charset=utf-8" : "text/plain; charset=utf-8");
+    return reply.send(readFileSync8(abs));
+  });
+  app.get("/api/artifact/:id/files", async (req) => {
+    const artifact = getArtifact(ctx, parseInt(req.params.id));
+    const base = guardedAbsPath(ctx, artifact);
+    const files = [];
+    const walk = (dir, rel) => {
+      for (const name of readdirSync7(dir).sort()) {
+        if (name === "node_modules" || name.startsWith(".")) continue;
+        const full = join16(dir, name);
+        const relPath = rel ? `${rel}/${name}` : name;
+        const st = statSync6(full);
+        if (st.isDirectory()) walk(full, relPath);
+        else files.push({ rel: relPath, size: st.size });
+      }
+    };
+    if (existsSync14(base) && statSync6(base).isDirectory()) walk(base, "");
+    return { files };
+  });
+  app.get("/api/artifact/:id/file", async (req) => {
+    const artifact = getArtifact(ctx, parseInt(req.params.id));
+    const abs = guardedAbsPath(ctx, artifact, req.query.rel);
+    if (!existsSync14(abs) || statSync6(abs).isDirectory()) {
+      throw Object.assign(new Error("\u6587\u4EF6\u4E0D\u5B58\u5728"), { statusCode: 404 });
+    }
+    if (statSync6(abs).size > MAX_INLINE_SIZE) {
+      throw Object.assign(new Error("\u6587\u4EF6\u8FC7\u5927"), { statusCode: 413 });
+    }
+    return { rel: req.query.rel, content: readFileSync8(abs, "utf-8") };
+  });
+  app.get("/api/events", async (req) => {
+    return listEvents(ctx.db, {
+      afterId: req.query.afterId ? parseInt(req.query.afterId) : void 0,
+      module: req.query.module,
+      limit: req.query.limit ? parseInt(req.query.limit) : 100
+    });
+  });
+  app.get("/api/sse", (req, reply) => {
+    reply.raw.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive",
+      "access-control-allow-origin": "*"
+    });
+    let cursor2 = ctx.db.prepare("SELECT MAX(id) AS id FROM events").get().id ?? 0;
+    reply.raw.write(`event: hello
+data: {"cursor":${cursor2}}
+
+`);
+    const timer = setInterval(() => {
+      try {
+        const rows = listEvents(ctx.db, { afterId: cursor2, limit: 200 });
+        if (rows.length > 0) {
+          cursor2 = rows[rows.length - 1].id;
+          reply.raw.write(`data: ${JSON.stringify(rows)}
+
+`);
+        }
+      } catch {
+      }
+    }, 500);
+    req.raw.on("close", () => clearInterval(timer));
+  });
+  app.get("/api/review-queue", async () => {
+    return listArtifacts(ctx, {}).filter((r) => r.review_status === "pending" || r.review_status === "invalidated").map((r) => ({
+      ...r,
+      ever_approved: everApproved(r),
+      endorsed: r.kind === "prototype" ? prototypeEndorsed(ctx.db, r) : false
+    }));
+  });
+  app.get("/api/skill-candidates", async () => {
+    const report = runRetrospective(ctx);
+    return {
+      groups: report.groups.filter((g) => g.bucket === "skill-candidate" || g.bucket === "red-flag"),
+      candidates: report.candidates,
+      redFlags: report.redFlags,
+      halfLifeDays: report.halfLifeDays,
+      guidance: report.guidance
+    };
+  });
+  app.get("/api/artifact/:id/diff", async (req) => {
+    const artifact = getArtifact(ctx, parseInt(req.params.id));
+    const abs = guardedAbsPath(ctx, artifact);
+    const current = existsSync14(abs) && !statSync6(abs).isDirectory() ? readFileSync8(abs, "utf-8") : null;
+    return { approved: approvedContent(ctx, artifact.id), current };
+  });
+  app.post(
+    "/api/artifact/:id/approve",
+    async (req) => approveArtifact(ctx, { id: parseInt(req.params.id) }, req.body.actor, { trivial: req.body.trivial })
+  );
+  app.post(
+    "/api/artifact/:id/reject",
+    async (req) => rejectArtifact(ctx, { id: parseInt(req.params.id) }, req.body.actor, req.body.reason)
+  );
+  app.post(
+    "/api/artifact/:id/submit",
+    async (req) => submitArtifact(ctx, { id: parseInt(req.params.id) }, req.body.actor)
+  );
+  app.post(
+    "/api/artifact/:id/feedback",
+    async (req) => feedbackArtifact(ctx, { id: parseInt(req.params.id) }, {
+      verdict: req.body.verdict,
+      comment: req.body.comment,
+      actor: req.body.actor
+    })
+  );
+  app.post("/api/sync", async () => syncArtifacts(ctx, "opcflow"));
+  app.post(
+    "/api/task/:id/claim",
+    async (req) => claimTask(ctx, { id: parseInt(req.params.id), assignee: req.body.assignee })
+  );
+  app.post(
+    "/api/task/:id/status",
+    async (req) => updateTask(ctx, {
+      id: parseInt(req.params.id),
+      status: req.body.status,
+      operator: req.body.operator,
+      force: req.body.force
+    })
+  );
+  app.setErrorHandler((err, _req, reply) => {
+    const e = err;
+    reply.code(e.statusCode ?? 500).send({ error: e.message ?? String(err) });
+  });
+  return app;
+}
+var MAX_INLINE_SIZE;
+var init_app = __esm({
+  "server/app.ts"() {
+    "use strict";
+    init_artifact_commands();
+    init_retro_command();
+    init_sync_command();
+    init_config();
+    init_task_commands();
+    init_derive();
+    init_events();
+    init_tree();
+    MAX_INLINE_SIZE = 1024 * 1024;
+  }
+});
+
+// scripts/hook-input.ts
+function hookPlatform() {
+  const arg = process.argv.find((a) => a.startsWith("--platform="));
+  return arg ? arg.slice("--platform=".length) : "claude";
+}
+function extractFilePath(input) {
+  return input?.tool_input?.file_path ?? // claude PreToolUse/PostToolUse
+  input?.tool_input?.filePath ?? input?.file_path ?? // cursor afterFileEdit / 通用
+  input?.filePath ?? input?.args?.file_path ?? // opencode tool 参数
+  input?.args?.filePath ?? input?.arguments?.file_path ?? // codex 兜底
+  input?.arguments?.filePath ?? input?.input?.file_path ?? void 0;
+}
+function hookProjectDir() {
+  return process.env.CLAUDE_PROJECT_DIR ?? process.env.CODEX_PROJECT_DIR ?? process.env.CURSOR_PROJECT_DIR ?? process.env.OPENCODE_PROJECT_DIR ?? process.env.WORKBENCH_PROJECT ?? void 0;
+}
+async function readStdinJson() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+  } catch {
+    return {};
+  }
+}
+var init_hook_input = __esm({
+  "scripts/hook-input.ts"() {
+    "use strict";
+  }
+});
+
+// scripts/hook-pretooluse.ts
+var hook_pretooluse_exports = {};
+__export(hook_pretooluse_exports, {
+  writeGateHook: () => writeGateHook
+});
+async function writeGateHook(platform) {
+  const input = await readStdinJson();
+  const filePath = extractFilePath(input);
+  if (!filePath) return;
+  const { openWorkbench: openWorkbench2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+  const { normalizeRelPath: normalizeRelPath2 } = await Promise.resolve().then(() => (init_artifact_commands(), artifact_commands_exports));
+  const { reviewStatus: reviewStatus2 } = await Promise.resolve().then(() => (init_derive(), derive_exports));
+  const { contractKinds: contractKinds2 } = await Promise.resolve().then(() => (init_kind(), kind_exports));
+  const { logEvent: logEvent2 } = await Promise.resolve().then(() => (init_events(), events_exports));
+  const ctx = openWorkbench2(hookProjectDir());
+  const mode = ctx.config.gates.writeGate;
+  if (mode === "off") return;
+  const rel = normalizeRelPath2(ctx, filePath);
+  const artifact = ctx.db.prepare("SELECT * FROM artifacts WHERE path = ?").get(rel);
+  if (!artifact) return;
+  if (!contractKinds2(ctx.config).includes(artifact.kind)) return;
+  if (reviewStatus2(artifact) !== "approved") return;
+  const taskEnv = Number(process.env.WORKBENCH_TASK_ID);
+  if (Number.isInteger(taskEnv) && taskEnv > 0) {
+    const task = ctx.db.prepare("SELECT COUNT(*) AS c FROM tasks WHERE id = ? AND assignee IS NOT NULL AND status IN ('pending','in_progress')").get(taskEnv);
+    if (task.c > 0) return;
+  }
+  logEvent2(ctx.db, {
+    entityType: "artifact",
+    entityId: artifact.id,
+    event: "would_block",
+    actor: "write-gate",
+    payload: { path: rel, kind: artifact.kind, platform, taskEnv: process.env.WORKBENCH_TASK_ID ?? null, mode },
+    module: artifact.module,
+    endpoint: artifact.endpoint,
+    page: artifact.page
+  });
+  if (mode === "enforce") {
+    const msg = `\u8BE5\u6587\u4EF6\u662F\u5DF2\u5BA1\u6279\u5951\u7EA6(${artifact.kind}): ${rel}\u3002
+\u4FEE\u6539\u524D\u8BF7\u5148\u9886\u53D6\u5BF9\u5E94\u4EFB\u52A1:${ctx.config.cli} list --module=${artifact.module ?? ""} --status=pending
+\u9886\u53D6\u540E\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF WORKBENCH_TASK_ID=<\u4EFB\u52A1id> \u518D\u4FEE\u6539;\u82E5\u5BF9\u5185\u5BB9\u672C\u8EAB\u6709\u5F02\u8BAE,\u7528 dispute \u547D\u4EE4\u7559\u75D5\u5E76\u505C\u6B62\u3002`;
+    if (platform === "cursor") {
+      process.stdout.write(JSON.stringify({ permission: "deny", userMessage: msg, agentMessage: msg }));
+      process.exit(0);
+    }
+    console.error(msg);
+    process.exit(2);
+  }
+}
+var init_hook_pretooluse = __esm({
+  "scripts/hook-pretooluse.ts"() {
+    "use strict";
+    init_hook_input();
+    if (process.argv[1]?.replace(/\\/g, "/").endsWith("hook-pretooluse.ts")) {
+      writeGateHook(hookPlatform()).catch(() => {
+      }).finally(() => process.exit(0));
+    }
+  }
+});
+
+// scripts/hook-refresh.ts
+var hook_refresh_exports = {};
+__export(hook_refresh_exports, {
+  refreshHook: () => refreshHook
+});
+async function refreshHook(_platform) {
+  const input = await readStdinJson();
+  const filePath = extractFilePath(input);
+  if (!filePath) return;
+  const { openWorkbench: openWorkbench2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+  const { refreshArtifact: refreshArtifact2, normalizeRelPath: normalizeRelPath2 } = await Promise.resolve().then(() => (init_artifact_commands(), artifact_commands_exports));
+  const ctx = openWorkbench2(hookProjectDir());
+  const rel = normalizeRelPath2(ctx, filePath);
+  const exact = ctx.db.prepare("SELECT id FROM artifacts WHERE path = ?").get(rel);
+  if (exact) {
+    refreshArtifact2(ctx, { id: exact.id }, "hook");
+    return;
+  }
+  const dirs = ctx.db.prepare("SELECT id, path FROM artifacts WHERE kind = 'code'").all();
+  for (const d of dirs) {
+    if (rel.startsWith(d.path + "/")) {
+      refreshArtifact2(ctx, { id: d.id }, "hook");
+      return;
+    }
+  }
+}
+var init_hook_refresh = __esm({
+  "scripts/hook-refresh.ts"() {
+    "use strict";
+    init_hook_input();
+    if (process.argv[1]?.replace(/\\/g, "/").endsWith("hook-refresh.ts")) {
+      refreshHook(hookPlatform()).catch(() => {
+      }).finally(() => process.exit(0));
+    }
+  }
+});
+
+// cli.ts
+init_db();
+
+// cli-runner.ts
+init_core();
+import chalk from "chalk";
+var STATUS_TEXT = { pending: "\u23F3 \u5F85\u9886\u53D6", in_progress: "\u{1F504} \u8FDB\u884C\u4E2D", completed: "\u2705 \u5DF2\u5B8C\u6210", cancelled: "\u274C \u5DF2\u53D6\u6D88" };
+var STATUS_COLOR = { pending: chalk.gray, in_progress: chalk.blue, completed: chalk.green, cancelled: chalk.red };
+var REVIEW_TEXT = { draft: "\u{1F4DD} \u8349\u7A3F", pending: "\u23F3 \u5F85\u5BA1", approved: "\u2705 \u5DF2\u5BA1\u6279", invalidated: "\u26A0\uFE0F \u5DF2\u5931\u6548" };
+function parseArgs(argv) {
+  if (argv.length === 0) return { a: {} };
+  const [command, ...rest] = argv;
+  const a = {};
+  for (const arg of rest) {
+    if (arg === "--") continue;
+    const match = arg.match(/^--(\w+)=([\s\S]+)$/);
+    if (match) a[match[1]] = match[2];
+    else if (arg.match(/^\d+$/)) a.id = parseInt(arg);
+    else if (a._ === void 0) a._ = arg;
+    else fail(`\u591A\u4F59\u7684\u4F4D\u7F6E\u53C2\u6570: ${arg}(\u5DF2\u6709 ${a._});\u542B\u7A7A\u683C\u7684\u5185\u5BB9\u8BF7\u52A0\u5F15\u53F7`);
+  }
+  return { command, a };
+}
+function printWarnings(warnings) {
+  for (const w of warnings) console.log(chalk.yellow(`  \u26A0 ${w}`));
+}
+function printTasks(rows) {
+  if (rows.length === 0) return console.log(chalk.yellow("\u6CA1\u6709\u627E\u5230\u4EFB\u52A1"));
+  console.log(chalk.bold("\n ID   | \u6A21\u5757     | \u89D2\u8272        | \u7AEF      | \u9875\u9762                  | \u7C7B\u578B    | \u72B6\u6001       | \u6267\u884C\u4EBA        | \u521B\u5EFA\u65F6\u95F4"));
+  console.log(chalk.gray("------|---------|-------------|---------|----------------------|--------|-----------|--------------|-------------------"));
+  for (const row of rows) {
+    const colorFn = STATUS_COLOR[row.status] || chalk.white;
+    const pageDisplay = row.page && row.page.length > 20 ? row.page.substring(0, 17) + "..." : row.page || "";
+    const staleMark = row.stale ? chalk.yellow(" \u26A0stale") : "";
+    console.log(
+      colorFn(` ${String(row.id).padEnd(5)} | ${(row.module || "-").padEnd(8)} | ${row.role.padEnd(12)} | ${(row.endpoint || "-").padEnd(8)} | ${pageDisplay.padEnd(22)} | ${row.type.padEnd(7)} | ${(STATUS_TEXT[row.status] || row.status).padEnd(10)} | ${(row.assignee || "-").padEnd(13)} | ${row.created_at}`) + staleMark
+    );
+  }
+  console.log();
+}
+function printArtifacts(rows) {
+  if (rows.length === 0) return console.log(chalk.yellow("\u6CA1\u6709\u627E\u5230\u4EA7\u7269"));
+  console.log(chalk.bold("\n ID   | kind          | \u6A21\u5757     | \u7AEF      | \u5BA1\u6279\u72B6\u6001   | \u8DEF\u5F84"));
+  console.log(chalk.gray("------|---------------|---------|---------|-----------|-------------------"));
+  for (const row of rows) {
+    const p = row.path.length > 60 ? "..." + row.path.substring(row.path.length - 57) : row.path;
+    console.log(` ${String(row.id).padEnd(5)} | ${row.kind.padEnd(14)} | ${(row.module || "-").padEnd(8)} | ${(row.endpoint || "-").padEnd(8)} | ${(REVIEW_TEXT[row.review_status] || row.review_status).padEnd(10)} | ${p}`);
+  }
+  console.log();
+}
+function printTaskDetail(ctx, id) {
+  const { task, events, outputs, staleness } = getTaskDetail(ctx, id);
+  console.log(chalk.bold(`
+\u2550\u2550\u2550 \u4EFB\u52A1 #${task.id} \u2550\u2550\u2550`));
+  console.log(`  \u6A21\u5757: ${task.module || "-"}   \u89D2\u8272: ${task.role}   \u7AEF: ${task.endpoint || "-"}   \u9875\u9762: ${task.page || "-"}`);
+  console.log(`  \u7C7B\u578B: ${task.type}   \u72B6\u6001: ${STATUS_COLOR[task.status]?.(STATUS_TEXT[task.status]) || task.status}${staleness.stale ? chalk.yellow("  \u26A0 STALE(\u4E0A\u6E38\u5DF2\u53D8\u66F4)") : ""}`);
+  console.log(`  \u6267\u884C\u4EBA: ${task.assignee || "-"}   \u521B\u5EFA\u4EBA: ${task.creator}`);
+  if (task.content) console.log(chalk.bold("\n  \u{1F4C4} \u5185\u5BB9: ") + task.content);
+  if (staleness.stale) {
+    console.log(chalk.yellow("\n  \u26A0 \u53D8\u66F4\u7684\u4E0A\u6E38\u4EA7\u7269:"));
+    for (const c of staleness.changed) console.log(chalk.yellow(`    - ${c.path}`));
+  }
+  console.log(chalk.bold(`
+  \u{1F4E6} \u4EA7\u51FA (${outputs.length})`));
+  for (const o of outputs) console.log(chalk.cyan(`    \u251C\u2500 [${o.kind}] ${o.path}`));
+  console.log(chalk.bold(`
+  \u{1F4DD} \u4E8B\u4EF6 (${events.length})`));
+  for (const e of events.slice(0, 20)) {
+    const payload = e.payload ? JSON.parse(e.payload) : {};
+    const extra = e.event === "note" ? ` ${payload.content}` : "";
+    console.log(chalk.gray(`    \u251C\u2500 ${e.created_at} [${e.event}] ${e.actor}${extra}`));
+  }
+  console.log();
+}
+var ALL_PLATFORMS = ["claude", "codex", "opencode", "cursor"];
+var PRIORITY_PROVIDERS = [
+  "anthropic",
+  "openai",
+  "google",
+  "xai",
+  "deepseek",
+  "mistral",
+  "meta",
+  "groq",
+  "qwen",
+  "moonshotai",
+  "zhipuai",
+  "z-ai",
+  "cohere"
+];
+async function fetchProviders() {
+  try {
+    const res = await fetch("https://models.dev/api.json");
+    const j = await res.json();
+    const providers = [];
+    for (const [pid, pv] of Object.entries(j)) {
+      const models = Object.entries(pv.models ?? {}).filter(([, mv]) => mv.tool_call).map(([mid, mv]) => ({ id: mv.id ?? mid, name: mv.name ?? mid }));
+      if (models.length) providers.push({ id: pv.id ?? pid, name: pv.name ?? pid, models });
+    }
+    const rank = (id) => {
+      const i = PRIORITY_PROVIDERS.indexOf(id);
+      return i === -1 ? PRIORITY_PROVIDERS.length : i;
+    };
+    return providers.sort((a, b) => rank(a.id) - rank(b.id) || a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+}
+async function promptInit() {
+  const { input, select } = await import("@inquirer/prompts");
+  const language = await select({
+    message: "\u8BED\u8A00 / Language",
+    choices: [
+      { name: "\u4E2D\u6587", value: "zh" },
+      { name: "English", value: "en" }
+    ]
+  });
+  const zh = language === "zh";
+  const platform = await select({
+    message: zh ? "\u5E73\u53F0" : "Platform",
+    choices: ALL_PLATFORMS.map((p) => ({ name: p, value: p })),
+    default: "claude"
+  });
+  const platforms = [platform];
+  const endpoints = (await input({
+    message: zh ? "\u7AEF(\u9017\u53F7\u5206\u9694)" : "Endpoints (comma-separated)",
+    default: "service,web"
+  })).split(",").map((s) => s.trim()).filter(Boolean);
+  const providers = await fetchProviders();
+  const modelObj = {};
+  for (const p of platforms) {
+    if (!providers.length) break;
+    const provId = await select({
+      message: zh ? `${p} \u2014\u2014 \u4F9B\u5E94\u5546(\u9009\u201C\u9ED8\u8BA4\u201D\u7528\u8BE5\u5E73\u53F0\u7F3A\u7701\u6A21\u578B)` : `${p} \u2014 provider ("default" keeps the platform default)`,
+      choices: [
+        { name: zh ? "(\u9ED8\u8BA4 / default)" : "(default)", value: "" },
+        ...providers.map((pr) => ({ name: pr.name, value: pr.id }))
+      ],
+      pageSize: 12
+    });
+    if (!provId) continue;
+    const prov = providers.find((pr) => pr.id === provId);
+    if (!prov) continue;
+    const modelId = await select({
+      message: zh ? `${p} \u2014\u2014 \u6A21\u578B` : `${p} \u2014 model`,
+      choices: prov.models.map((m) => ({ name: m.name, value: m.id })),
+      pageSize: 12
+    });
+    if (modelId) modelObj[p] = p === "opencode" ? `${provId}/${modelId}` : modelId;
+  }
+  return { platforms, endpoints, model: Object.keys(modelObj).length ? modelObj : void 0, language };
+}
+async function runInit(root, a) {
+  const { existsSync: existsSync15 } = await import("node:fs");
+  const { join: join17 } = await import("node:path");
+  if (existsSync15(join17(root, "workbench.config.json"))) {
+    console.log(chalk.red("\u9519\u8BEF: workbench.config.json \u5DF2\u5B58\u5728,init \u53EA\u7528\u4E8E\u7A7A\u9879\u76EE\u5F15\u5BFC(\u6539\u914D\u7F6E\u8BF7\u76F4\u63A5\u7F16\u8F91\u8BE5\u6587\u4EF6)"));
+    process.exit(1);
+  }
+  let opts;
+  if (!a.platforms && !a.endpoints && process.stdin.isTTY) {
+    const p = await promptInit();
+    opts = { endpoints: p.endpoints, platforms: p.platforms, model: p.model, language: p.language };
+  } else {
+    if (!a.endpoints) {
+      console.log(chalk.red("\u9519\u8BEF: \u9700\u8981 --endpoints=service,admin,...(\u6216\u5728\u7EC8\u7AEF\u76F4\u63A5\u8FD0\u884C init \u8FDB\u5165\u4EA4\u4E92)"));
+      process.exit(1);
+    }
+    const platforms = a.platforms ? String(a.platforms).split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+    let model;
+    if (a.model) {
+      const raw = String(a.model).trim();
+      model = raw.startsWith("{") ? JSON.parse(raw) : raw;
+    }
+    const language = a.language === "en" ? "en" : a.language === "zh" ? "zh" : void 0;
+    opts = { endpoints: String(a.endpoints).split(","), platforms, model, language };
+  }
+  const r = initProject(root, {
+    ...opts,
+    gitHooks: a.hooks !== "false",
+    preset: a.preset !== "false",
+    writeHooks: a.writehooks !== "false"
+  });
+  const cli = r.ctx.config.cli;
+  console.log(chalk.green(`
+\u2705 \u9879\u76EE\u5F15\u5BFC\u5B8C\u6210
+`));
+  console.log(`  \u914D\u7F6E\u6587\u4EF6   ${r.configPath}`);
+  console.log(`  \u8BED\u8A00       ${r.ctx.config.language}`);
+  console.log(`  \u76EE\u6807\u5E73\u53F0   ${r.platforms.join(", ")}`);
+  console.log(`  \u6587\u6863\u9AA8\u67B6   ${r.scaffolded.length} \u4E2A\u76EE\u5F55`);
+  console.log(`  \u9884\u7F6E\u6587\u4EF6   ${r.preset.length ? r.preset.join(", ") : "\u65E0(preset/ \u4E3A\u7A7A\u6216\u5747\u5DF2\u5B58\u5728)"}`);
+  console.log(`  agent \u5B9A\u4E49 ${r.agents.length} \u4EFD`);
+  console.log(`  \u5143\u4EA7\u7269\u6CE8\u518C ${r.metaRegistered} \u4EFD(draft)`);
+  console.log(`  MCP        ${r.mcpPaths.join(", ") || "\u672A\u5199"}`);
+  console.log(`  hooks \u63A5\u7EBF ${r.hookPaths.join(", ") || "\u672A\u5199(--writehooks=false)"}`);
+  console.log(`  git hooks  ${r.hooks.join(", ") || "\u672A\u5B89\u88C5(\u975E git \u4ED3\u5E93)"}`);
+  if (r.notes.length) {
+    console.log(chalk.yellow(`
+\u5E73\u53F0\u63D0\u9192:`));
+    for (const n of r.notes) console.log(chalk.yellow(`  \u2022 ${n}`));
+  }
+  console.log(chalk.bold(`
+\u4E0B\u4E00\u6B65:`));
+  console.log(`  1. \u7F16\u8F91 workbench.config.json \u7684 codeRoots(\u586B\u6BCF\u4E2A\u7AEF\u7684\u4EE3\u7801\u76EE\u5F55\u7EA6\u5B9A)`);
+  console.log(`  2. \u542F\u52A8\u5DE5\u4F5C\u53F0:  ${cli} serve   \u2192 http://127.0.0.1:5620`);
+  console.log(`  3. \u5BF9 AI \u63D0\u7B2C\u4E00\u4E2A\u9700\u6C42,\u5B83\u8D70\u6D41\u6C34\u7EBF\u4EA7\u51FA\u5951\u7EA6,\u4F60\u5728\u5F85\u5BA1\u961F\u5217\u70B9\u5934`);
+  console.log(`  4. \u5951\u7EA6\u5BA1\u6279\u540E:  ${cli} plan --module=<\u6A21\u5757>  \u4E00\u952E\u6D3E\u53D1
+`);
+  r.ctx.db.close();
+}
+var HELP = `opcflow CLI
+
+\u4EFB\u52A1   list / show <id> / create / claim / update / remove / record
+\u4EA7\u51FA   output / artifacts / scan / move / input
+\u4FE1\u4EFB   submit / approve / reject / feedback / queue / dispute / sync
+\u6D41\u7A0B   plan / qa / audit / intake / lint / graph / events
+\u8FDB\u5316   retro [--module= --json=] / export
+\u7EF4\u62A4   init / gen-agents / register-meta / install-hooks / migrate`;
+async function runCommand(ctx, command, a) {
+  switch (command) {
+    case "create": {
+      if (!a.role || !a.creator) return fail("--role, --creator \u5FC5\u586B");
+      const id = createTask(ctx, { module: a.module, role: a.role, endpoint: a.endpoint, page: a.page, type: a.type, assignee: a.assignee, creator: a.creator, content: a.content });
+      console.log(chalk.green(`\u2705 \u4EFB\u52A1 #${id} \u521B\u5EFA\u6210\u529F`));
+      break;
+    }
+    case "claim": {
+      if (!a.id || !a.assignee) return fail("\u9700\u8981\u4EFB\u52A1 ID \u548C --assignee");
+      const { warnings } = claimTask(ctx, { id: a.id, assignee: a.assignee });
+      console.log(chalk.green(`\u2705 \u4EFB\u52A1 #${a.id} \u5DF2\u7531 ${a.assignee} \u9886\u53D6`));
+      printWarnings(warnings);
+      break;
+    }
+    case "update": {
+      if (!a.id || !a.status || !a.operator) return fail("\u9700\u8981\u4EFB\u52A1 ID, --status \u548C --operator");
+      const { warnings } = updateTask(ctx, { id: a.id, status: a.status, operator: a.operator, force: a.force === "true" });
+      console.log(chalk.green(`\u2705 \u4EFB\u52A1 #${a.id} \u72B6\u6001\u5DF2\u66F4\u65B0\u4E3A ${a.status}`));
+      printWarnings(warnings);
+      break;
+    }
+    case "remove":
+    case "delete": {
+      if (!a.id || !a.operator) return fail("\u9700\u8981\u4EFB\u52A1 ID \u548C --operator");
+      removeTask(ctx, { id: a.id, operator: a.operator, force: a.force === "true" });
+      console.log(chalk.green(`\u2705 \u4EFB\u52A1 #${a.id} \u5DF2\u5220\u9664`));
+      break;
+    }
+    case "record": {
+      if (!a.id || !a._ || !a.operator) return fail("\u9700\u8981\u4EFB\u52A1 ID, --operator \u548C\u5185\u5BB9\u6587\u672C");
+      recordNote(ctx, { id: a.id, content: a._, operator: a.operator });
+      console.log(chalk.green(`\u2705 \u4EFB\u52A1 #${a.id} \u8BB0\u5F55\u5DF2\u6DFB\u52A0`));
+      break;
+    }
+    case "output": {
+      if (!a.role || !a.endpoint || !a._) return fail("\u9700\u8981 --role, --endpoint \u548C\u6587\u4EF6\u8DEF\u5F84");
+      const { artifactId, linkedTaskId, kind } = registerOutput(ctx, { module: a.module, role: a.role, endpoint: a.endpoint, page: a.page, filePath: a._, taskId: a.task ? parseInt(a.task) : void 0 });
+      console.log(chalk.green(`\u2705 \u8F93\u51FA\u6587\u4EF6\u5DF2\u6DFB\u52A0 (artifact #${artifactId}, kind=${kind}${linkedTaskId ? `, \u5173\u8054\u4EFB\u52A1 #${linkedTaskId}` : ""})`));
+      break;
+    }
+    case "outputs":
+    case "artifacts":
+      printArtifacts(listArtifacts(ctx, { module: a.module, endpoint: a.endpoint, page: a.page, kind: a.kind }));
+      break;
+    case "list":
+      printTasks(listTasks(ctx, { status: a.status, assignee: a.assignee, module: a.module, role: a.role, endpoint: a.endpoint, type: a.type, withStale: a.stale === "true" }));
+      break;
+    case "show": {
+      if (!a.id) return fail("\u9700\u8981\u4EFB\u52A1 ID");
+      if (a.json === "true") console.log(JSON.stringify(getTaskDetail(ctx, a.id), null, 2));
+      else printTaskDetail(ctx, a.id);
+      break;
+    }
+    case "records":
+    case "events": {
+      const rows = listEvents(ctx.db, { entityId: a.taskId ? parseInt(a.taskId) : a.id, entityType: a.taskId || a.id ? "task" : void 0, module: a.module, event: a.event, limit: a.limit ? parseInt(a.limit) : 50 });
+      if (a.json === "true") return void console.log(JSON.stringify(rows, null, 2));
+      for (const e of rows) {
+        const payload = e.payload ? JSON.parse(e.payload) : {};
+        const extra = e.event === "note" ? ` ${payload.content}` : "";
+        console.log(chalk.gray(` ${e.created_at} [${e.entity_type}#${e.entity_id}] ${e.event} by ${e.actor}${extra}`));
+      }
+      break;
+    }
+    case "submit": {
+      if (!a._ || !a.actor) return fail("\u9700\u8981\u6587\u4EF6\u8DEF\u5F84\u548C --actor");
+      submitArtifact(ctx, { path: a._ }, a.actor);
+      console.log(chalk.green(`\u2705 \u5DF2\u9001\u5BA1: ${a._}`));
+      break;
+    }
+    case "approve": {
+      if (!a._ || !a.actor) return fail("\u9700\u8981\u6587\u4EF6\u8DEF\u5F84\u548C --actor");
+      const trivial = a.trivial === "true";
+      const row = approveArtifact(ctx, { path: a._ }, a.actor, { trivial });
+      console.log(chalk.green(`\u2705 \u5DF2\u5BA1\u6279\u901A\u8FC7${trivial ? "(trivial:\u5DF2 re-bless \u4E0B\u6E38\u5E76\u5173\u95ED\u6D3E\u751F review)" : ""}: ${row.path} (hash=${row.approved_hash?.slice(0, 8)})`));
+      break;
+    }
+    case "reject": {
+      if (!a._ || !a.actor || !a.reason) return fail("\u9700\u8981\u6587\u4EF6\u8DEF\u5F84, --actor \u548C --reason");
+      rejectArtifact(ctx, { path: a._ }, a.actor, a.reason);
+      console.log(chalk.yellow(`\u21A9 \u5DF2\u6253\u56DE: ${a._}`));
+      break;
+    }
+    case "feedback": {
+      if (!a._ || !a.actor || !a.verdict) return fail("\u9700\u8981\u6587\u4EF6\u8DEF\u5F84, --actor \u548C --verdict=+1|-1");
+      const verdict = a.verdict === "+1" || a.verdict === "1" ? 1 : -1;
+      const { endorsed } = feedbackArtifact(ctx, { path: a._ }, { verdict, comment: a.comment, actor: a.actor, taskId: a.task ? parseInt(a.task) : void 0 });
+      console.log(chalk.green(`\u2705 \u53CD\u9988\u5DF2\u8BB0\u5F55 (${verdict > 0 ? "\u{1F44D}" : "\u{1F44E}"})${endorsed ? " \u2014 \u539F\u578B\u5DF2\u653E\u884C" : ""}`));
+      break;
+    }
+    case "queue":
+      printArtifacts(listArtifacts(ctx, {}).filter((r) => r.review_status === "pending" || r.review_status === "invalidated"));
+      break;
+    case "dispute": {
+      if (!a._ || !a.actor || !a.reason) return fail("\u9700\u8981\u6587\u4EF6\u8DEF\u5F84, --actor \u548C --reason");
+      disputeArtifact(ctx, { path: a._ }, a.actor, a.reason);
+      console.log(chalk.yellow(`\u2696 \u5F02\u8BAE\u5DF2\u7559\u75D5,\u7B49\u5F85\u7528\u6237\u88C1\u51B3: ${a._}`));
+      break;
+    }
+    case "sync": {
+      const s = syncArtifacts(ctx, a.actor || "sync");
+      console.log(chalk.green(`\u2705 \u5BF9\u8D26\u5B8C\u6210:\u68C0\u67E5 ${s.checked},\u53D8\u66F4 ${s.changed},\u5931\u6548 ${s.invalidated},\u5893\u7891 ${s.tombstoned},\u6D3E review ${s.reviewsSpawned}`));
+      break;
+    }
+    case "plan": {
+      if (!a.module) return fail("\u9700\u8981 --module");
+      const s = planModule(ctx, a.module, a.creator || "product-manager");
+      console.log(chalk.green(`\u2705 \u6D3E\u53D1\u5B8C\u6210:\u65B0\u5EFA ${s.created.length},\u8DF3\u8FC7 ${s.skipped},\u53D6\u6D88 ${s.cancelled}`));
+      for (const t of s.created) console.log(chalk.cyan(`  + #${t.id} ${t.role} ${t.endpoint ?? "-"} ${t.page ?? ""} (${t.type})`));
+      printWarnings(s.warnings);
+      break;
+    }
+    case "qa": {
+      if (!a.id || !a.result || !a.operator) return fail("\u9700\u8981\u4EFB\u52A1 ID, --result=pass|fail \u548C --operator;fail \u9700 --reason");
+      const { reworkTaskId } = recordQaResult(ctx, { id: a.id, result: a.result, reason: a.reason, operator: a.operator });
+      console.log(chalk.green(`\u2705 \u9A8C\u6536\u7ED3\u679C\u5DF2\u8BB0\u5F55: ${a.result}${reworkTaskId ? `,\u5DF2\u6D3E rework #${reworkTaskId}` : ""}`));
+      break;
+    }
+    case "audit": {
+      if (!a.module) return fail("\u9700\u8981 --module");
+      const r = auditModule(ctx, a.module);
+      console.log(chalk.bold(`
+\u2550\u2550\u2550 \u6A21\u5757 ${r.module} \u5BF9\u8D26\u62A5\u544A \u2550\u2550\u2550  \u6E05\u7B97\u72B6\u6001: ${r.cleared ? chalk.green("\u2705 \u5DF2\u6E05\u7B97") : chalk.yellow("\u26A0 \u672A\u6E05\u7B97")}
+`));
+      for (const c of r.contracts) {
+        const st = { draft: chalk.gray("\u{1F4DD} \u8349\u7A3F"), pending: chalk.yellow("\u23F3 \u5F85\u5BA1"), approved: chalk.green("\u2705 \u5DF2\u5BA1\u6279"), invalidated: chalk.red("\u26A0 \u5DF2\u5931\u6548") }[c.status];
+        console.log(`  ${st} [${c.kind}] ${c.path}${c.onDisk ? "" : chalk.red(" (\u78C1\u76D8\u7F3A\u5931!)")}`);
+      }
+      console.log(chalk.bold(`
+  code \u76EE\u5F55 ${r.codeDirs.length} \u4E2A`));
+      if (r.suggestedSubmits.length > 0) {
+        console.log(chalk.cyan(`
+  \u5BF9\u8D26\u540E\u53EF\u6279\u91CF\u9001\u5BA1(\u4E0E\u4EE3\u7801\u6838\u5B9E\u4E00\u81F4\u540E\u6267\u884C):`));
+        for (const p of r.suggestedSubmits) console.log(chalk.gray(`    ${ctx.config.cli} submit --actor=architect -- ${p}`));
+      }
+      console.log();
+      break;
+    }
+    case "intake": {
+      const s = intakeIssues(ctx);
+      console.log(chalk.green(`\u2705 intake:\u62C9\u53D6 ${s.fetched},\u65B0\u5EFA ${s.created.length},\u5DF2\u5173\u8054\u8DF3\u8FC7 ${s.skipped}`));
+      for (const c of s.created) console.log(chalk.cyan(`  gh#${c.issue} \u2192 \u4EFB\u52A1 #${c.taskId} (${c.lane === "hotfix" ? "\u5FEB\u8F66\u9053 hotfix" : "PM \u5206\u6790"})`));
+      break;
+    }
+    case "retro":
+    case "retrospective": {
+      const report = runRetrospective(ctx, { module: a.module });
+      if (a.json === "true") return void console.log(JSON.stringify(report, null, 2));
+      const BUCKET_TEXT = {
+        "skill-candidate": chalk.green("\u{1F331} skill \u5019\u9009"),
+        "red-flag": chalk.red("\u{1F6A9} Red Flag"),
+        observation: chalk.gray("\u{1F440} \u89C2\u5BDF")
+      };
+      console.log(chalk.bold(`
+\u2550\u2550\u2550 Retrospective${report.module ? `(\u6A21\u5757 ${report.module})` : ""} \u2550\u2550\u2550  \u534A\u8870\u671F ${report.halfLifeDays} \u5929
+`));
+      if (report.groups.length === 0) console.log(chalk.yellow("  \u5C1A\u65E0\u53CD\u9988\u6570\u636E"));
+      for (const g of report.groups) {
+        const reason = g.reason === "mixed" ? "(\u4FE1\u53F7\u77DB\u76FE)" : g.reason === "insufficient" ? "(\u6837\u672C\u4E0D\u8DB3)" : "";
+        console.log(`  ${BUCKET_TEXT[g.bucket]}${reason} [${g.endpoint}/${g.kind}]  +${g.posScore} / -${g.negScore}(${g.evidence.length} \u6761\u53CD\u9988)`);
+        for (const e of g.evidence.filter((e2) => e2.verdict === -1 && e2.comment)) {
+          console.log(chalk.red(`      \u{1F44E} ${e.comment}  (${e.path})`));
+        }
+      }
+      const ap = report.approval;
+      console.log(chalk.bold(`
+  \u5BA1\u6279\u541E\u5410:`) + ` \u901A\u8FC7 ${ap.approved},\u6253\u56DE ${ap.rejected}${ap.rejectionRate !== null ? `,\u6253\u56DE\u7387 ${Math.round(ap.rejectionRate * 100)}%` : ""}${ap.avgApprovalHours !== null ? `,\u9001\u5BA1\u2192\u901A\u8FC7\u5E73\u5747 ${ap.avgApprovalHours} \u5C0F\u65F6` : ""}`);
+      console.log(chalk.bold(`
+  \u4E0B\u4E00\u6B65:`));
+      for (const gd of report.guidance) console.log(chalk.cyan(`    \u2192 ${gd}`));
+      console.log();
+      break;
+    }
+    case "export": {
+      const r = exportEventLog(ctx);
+      console.log(chalk.green(`\u2705 \u5DF2\u5BFC\u51FA events ${r.events} \u6761,feedback ${r.feedbacks} \u6761 \u2192 ${r.files.join(", ")}`));
+      break;
+    }
+    case "lint": {
+      const role = a.role || "developer";
+      const violations = runProtocolLints(ctx, { role, endpoint: a.endpoint });
+      if (violations.length === 0) console.log(chalk.green("\u2705 \u534F\u8BAE lint \u901A\u8FC7,\u65E0\u8FDD\u4F8B"));
+      else {
+        console.log(chalk.red(`\u2717 ${violations.length} \u5904\u8FDD\u4F8B:`));
+        for (const v of violations) console.log(chalk.red(`  ${v.file}:${v.line} [${v.lint}] ${v.message}`));
+        process.exit(1);
+      }
+      break;
+    }
+    case "graph": {
+      if (!a.module) return fail("\u9700\u8981 --module");
+      console.log(graphModule(ctx, a.module));
+      break;
+    }
+    case "scan": {
+      const s = scanArtifacts(ctx, a.actor || "system");
+      console.log(chalk.green(`\u2705 \u626B\u63CF\u5B8C\u6210:\u65B0\u767B\u8BB0 ${s.registered},\u5185\u5BB9\u5237\u65B0 ${s.refreshed},\u65B0\u589E\u8FB9 ${s.edges},\u6392\u9664\u5143\u4EA7\u7269 ${s.skipped.length}`));
+      break;
+    }
+    case "move": {
+      if (!a.from || !a.to || !a.actor) return fail("\u9700\u8981 --from, --to \u548C --actor");
+      const moved = moveArtifact(ctx, { from: a.from, to: a.to, actor: a.actor });
+      console.log(chalk.green(`\u2705 \u5DF2\u79FB\u52A8(\u4FDD id #${moved.id}): ${a.from} \u2192 ${moved.path}`));
+      break;
+    }
+    case "input": {
+      if (!a.id || !a._ || !a.operator) return fail("\u9700\u8981\u4EFB\u52A1 ID, --operator \u548C\u4EA7\u7269\u8DEF\u5F84");
+      addTaskInput(ctx, { id: a.id, path: a._, operator: a.operator });
+      console.log(chalk.green(`\u2705 \u4EFB\u52A1 #${a.id} \u5DF2\u8865\u5145\u7533\u62A5\u4F9D\u8D56: ${a._}`));
+      break;
+    }
+    case "gen-agents": {
+      const { written } = genAgents(ctx);
+      console.log(chalk.green(`\u2705 agent \u5B9A\u4E49\u5DF2\u4ECE\u6A21\u677F\u751F\u6210(\u8DEF\u5F84\u7531\u6CE8\u518C\u8868\u6CE8\u5165):`));
+      for (const w of written) console.log(chalk.cyan(`  \u2192 ${w}`));
+      break;
+    }
+    case "register-meta": {
+      const { registered, skipped } = registerMetaArtifacts(ctx, a.actor || "system");
+      console.log(chalk.green(`\u2705 \u5143\u4EA7\u7269\u6CE8\u518C:\u65B0\u589E ${registered.length},\u5DF2\u5B58\u5728\u8DF3\u8FC7 ${skipped.length}`));
+      for (const r of registered) console.log(chalk.cyan(`  + [${r.kind}] ${r.path}`));
+      break;
+    }
+    case "install-hooks": {
+      const installed = installGitHooks(ctx);
+      console.log(chalk.green(`\u2705 git hooks \u5DF2\u5B89\u88C5: ${installed.join(", ")}`));
+      break;
+    }
+    case "migrate": {
+      const summary = migrateLegacy(ctx, a.from);
+      console.log(chalk.green(`\u2705 \u8FC1\u79FB\u5B8C\u6210:\u4EFB\u52A1 ${summary.tasks},\u4EA7\u7269 ${summary.artifacts}(\u5173\u8054 ${summary.linkedOutputs}),\u8BB0\u5F55 ${summary.notes}`));
+      if (summary.missingFiles.length > 0) {
+        console.log(chalk.yellow(`\u26A0 ${summary.missingFiles.length} \u4E2A\u4EA7\u51FA\u6587\u4EF6\u5DF2\u4E0D\u5728\u78C1\u76D8\u4E0A(hash \u7F6E\u7A7A)`));
+      }
+      break;
+    }
+    case "help":
+      console.log(HELP);
+      break;
+    default:
+      console.log(chalk.red(`\u672A\u77E5\u547D\u4EE4: ${command}`));
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+function fail(msg) {
+  console.log(chalk.red(`\u9519\u8BEF: ${msg}`));
+  process.exit(1);
+}
+
+// cli.ts
+init_core();
+async function main() {
+  const { command, a } = parseArgs(process.argv.slice(2));
+  if (command === "init") {
+    await runInit(a.project || process.cwd(), a);
+    return;
+  }
+  if (command === "mcp") {
+    const { buildMcpServer: buildMcpServer2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+    const { StdioServerTransport: StdioServerTransport2 } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+    const ctx2 = openWorkbench(a.project ?? process.env.WORKBENCH_PROJECT);
+    await buildMcpServer2(ctx2).connect(new StdioServerTransport2());
+    return;
+  }
+  if (command === "serve") {
+    const { createServer: createServer2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+    const net = await import("node:net");
+    const ctx2 = openWorkbench(a.project ?? process.env.WORKBENCH_PROJECT);
+    const start = parseInt(a.port ?? process.env.WORKBENCH_PORT ?? "5620");
+    const host = a.host ?? process.env.WORKBENCH_HOST ?? "0.0.0.0";
+    const inUse = (p) => new Promise((resolve2) => {
+      const sock = net.connect({ port: p, host: "127.0.0.1" });
+      sock.setTimeout(400);
+      sock.once("connect", () => {
+        sock.destroy();
+        resolve2(true);
+      });
+      sock.once("timeout", () => {
+        sock.destroy();
+        resolve2(false);
+      });
+      sock.once("error", () => resolve2(false));
+    });
+    let port = start;
+    for (let i = 0; i < 30 && await inUse(port); i++) port++;
+    if (port !== start) console.error(`\u7AEF\u53E3 ${start} \u88AB\u5360\u7528,\u6539\u7528 ${port}`);
+    const app = await createServer2(ctx2);
+    await app.listen({ port, host });
+    console.log(`opcflow: http://127.0.0.1:${port}  (host: ${host}, project: ${ctx2.root})`);
+    return;
+  }
+  if (command === "hook") {
+    const platform = a.platform ?? "claude";
+    if (a._ === "pre") {
+      const { writeGateHook: writeGateHook2 } = await Promise.resolve().then(() => (init_hook_pretooluse(), hook_pretooluse_exports));
+      await writeGateHook2(platform).catch(() => {
+      });
+    } else if (a._ === "post") {
+      const { refreshHook: refreshHook2 } = await Promise.resolve().then(() => (init_hook_refresh(), hook_refresh_exports));
+      await refreshHook2(platform).catch(() => {
+      });
+    }
+    process.exit(0);
+  }
+  if (command === "postcommit") {
+    try {
+      const { scanArtifacts: scanArtifacts2, syncArtifacts: syncArtifacts2, detectOrphanCommit: detectOrphanCommit2 } = await Promise.resolve().then(() => (init_core(), core_exports));
+      const { exportEventLog: exportEventLog2 } = await Promise.resolve().then(() => (init_retro_command(), retro_command_exports));
+      const ctx2 = openWorkbench(process.cwd());
+      scanArtifacts2(ctx2, "post-commit");
+      syncArtifacts2(ctx2, "post-commit");
+      detectOrphanCommit2(ctx2);
+      exportEventLog2(ctx2);
+    } catch {
+    }
+    return;
+  }
+  const ctx = openWorkbench(a.project);
+  if (!command) {
+    printTasks(listTasks(ctx, {}));
+    return;
+  }
+  try {
+    await runCommand(ctx, command, a);
+  } catch (err) {
+    console.error(`
+\u2717 ${err.message}
+`);
+    process.exit(1);
+  }
+}
+main();