ccgx-workflow 2.4.1 → 2.5.0

package/dist/index.mjs

@@ -1,8 +1,9 @@
-import { h as collectSkills, j as resolvePluginBashCommand } from './shared/ccgx-workflow.j1spUsik.mjs';
-export { k as changeLanguage, G as checkForUpdates, I as collectInvocableSkills, H as compareVersions, m as createDefaultConfig, n as createDefaultRouting, J as generateCommandContent, o as getCcgDir, p as getConfigPath, E as getCurrentVersion, F as getLatestVersion, t as getWorkflowById, q as getWorkflowConfigs, c as i18n, e as init, b as initI18n, y as installAceTool, z as installAceToolRs, K as installSkillCommands, x as installWorkflows, C as migrateToV1_4_0, D as needsMigration, L as parseFrontmatter, a as readCcgConfig, s as showMainMenu, B as uninstallAceTool, A as uninstallWorkflows, u as update, l as writeCcgConfig } from './shared/ccgx-workflow.j1spUsik.mjs';
-import { mkdirSync, appendFileSync, existsSync, statSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
-import { dirname, resolve } from 'pathe';
-import { join, dirname as dirname$1 } from 'node:path';
+import { h as collectSkills, j as resolvePluginBashCommand } from './shared/ccgx-workflow.CdHnJLak.mjs';
+export { k as changeLanguage, G as checkForUpdates, I as collectInvocableSkills, H as compareVersions, m as createDefaultConfig, n as createDefaultRouting, J as generateCommandContent, o as getCcgDir, p as getConfigPath, E as getCurrentVersion, F as getLatestVersion, t as getWorkflowById, q as getWorkflowConfigs, c as i18n, e as init, b as initI18n, y as installAceTool, z as installAceToolRs, K as installSkillCommands, x as installWorkflows, C as migrateToV1_4_0, D as needsMigration, L as parseFrontmatter, a as readCcgConfig, s as showMainMenu, B as uninstallAceTool, A as uninstallWorkflows, u as update, l as writeCcgConfig } from './shared/ccgx-workflow.CdHnJLak.mjs';
+import { writeFileSync, renameSync, unlinkSync, mkdirSync, existsSync, readFileSync, readdirSync, appendFileSync, statSync, openSync, constants, writeSync, closeSync } from 'node:fs';
+import { join, dirname, resolve } from 'pathe';
+import { join as join$1, dirname as dirname$1 } from 'node:path';
+import { randomBytes } from 'node:crypto';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
 import 'ansis';
@@ -15,6 +16,322 @@ import 'smol-toml';
 import 'node:path/posix';
 import 'i18next';
 
+function atomicWriteFileSync(target, content) {
+  const rand = randomBytes(6).toString("hex");
+  const tmp = `${target}.tmp.${rand}`;
+  try {
+    writeFileSync(tmp, content, "utf-8");
+    renameSync(tmp, target);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+const TASKS_RELATIVE_PATH = ".context/tasks";
+const STATE_RELATIVE_PATH = ".context/STATE.json";
+const TERMINAL_STATUS_SYNONYMS = /* @__PURE__ */ new Set([
+  "completed",
+  "complete",
+  "done",
+  "finished",
+  "closed",
+  "archived",
+  "cancelled",
+  "canceled",
+  "abandoned",
+  "failed"
+]);
+const VALID_ARTIFACT_TYPES = /* @__PURE__ */ new Set([
+  "fix-log",
+  "spec-evolution",
+  "review",
+  "plan",
+  "summary",
+  "generic"
+]);
+function tasksRoot(workdir) {
+  return join(workdir, ".context", "tasks");
+}
+function taskDir(workdir, taskId) {
+  return join(tasksRoot(workdir), sanitizeTaskId(taskId));
+}
+function taskJsonPath(workdir, taskId) {
+  return join(taskDir(workdir, taskId), "task.json");
+}
+function projectStatePath(workdir) {
+  return join(workdir, ".context", "STATE.json");
+}
+function sanitizeTaskId(taskId) {
+  const trimmed = taskId.trim();
+  if (!trimmed) {
+    throw new Error("taskId cannot be empty");
+  }
+  const cleaned = trimmed.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  if (!cleaned) {
+    throw new Error(`taskId sanitizes to empty: ${taskId}`);
+  }
+  return cleaned;
+}
+function isTerminalStatus(status) {
+  if (typeof status !== "string") return false;
+  return TERMINAL_STATUS_SYNONYMS.has(status.trim().toLowerCase());
+}
+function normalizeProgress(progress) {
+  if (!progress || typeof progress !== "object") return void 0;
+  const total = progress.total_phases;
+  const done = progress.completed_phases;
+  if (typeof total !== "number" || typeof done !== "number") return void 0;
+  const percent = typeof progress.percent === "number" ? progress.percent : total > 0 ? Math.round(done / total * 100) : 0;
+  return { total_phases: total, completed_phases: done, percent };
+}
+function normalizeArtifactPath(p) {
+  return p.replace(/\\/g, "/");
+}
+function validateTaskRecord(record) {
+  if (record === null || typeof record !== "object") {
+    throw new Error("TaskRecord must be an object");
+  }
+  const r = record;
+  if (typeof r.id !== "string" || !r.id) {
+    throw new Error("TaskRecord missing required field: id");
+  }
+  if (typeof r.status !== "string" || !r.status) {
+    throw new Error("TaskRecord missing required field: status");
+  }
+  if (typeof r.created_at !== "string" || !r.created_at) {
+    throw new Error("TaskRecord missing required field: created_at");
+  }
+  if (!Array.isArray(r.artifacts)) {
+    r.artifacts = [];
+  }
+}
+function writeTaskRecord(workdir, record) {
+  const dir = taskDir(workdir, record.id);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  atomicWriteFileSync(taskJsonPath(workdir, record.id), JSON.stringify(record, null, 2));
+}
+function createTask(workdir, init) {
+  const id = sanitizeTaskId(init.id);
+  if (typeof init.title !== "string" || !init.title.trim()) {
+    throw new Error("task title cannot be empty");
+  }
+  if (existsSync(taskJsonPath(workdir, id))) {
+    throw new Error(`Task already exists: ${id}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const record = {
+    schema_version: 1,
+    id,
+    title: init.title,
+    status: "in_progress",
+    active_phase: init.active_phase ?? null,
+    next_action: init.next_action ?? null,
+    created_at: now,
+    updated_at: now,
+    artifacts: []
+  };
+  const progress = normalizeProgress(init.progress);
+  if (progress) record.progress = progress;
+  if (init.branch) record.branch = init.branch;
+  writeTaskRecord(workdir, record);
+  syncProjectState(workdir);
+  return record;
+}
+function getTask(workdir, taskId) {
+  const path = taskJsonPath(workdir, taskId);
+  if (!existsSync(path)) {
+    return null;
+  }
+  const raw = readFileSync(path, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Task ${taskId}: task.json is not valid JSON (${err.message})`);
+  }
+  validateTaskRecord(parsed);
+  return parsed;
+}
+function listTasks(workdir) {
+  const root = tasksRoot(workdir);
+  if (!existsSync(root)) {
+    return [];
+  }
+  const tasks = [];
+  for (const id of readdirSync(root)) {
+    if (id === "archive") continue;
+    if (!existsSync(taskJsonPath(workdir, id))) continue;
+    try {
+      const task = getTask(workdir, id);
+      if (task) tasks.push(task);
+    } catch {
+    }
+  }
+  tasks.sort((a, b) => b.created_at.localeCompare(a.created_at));
+  return tasks;
+}
+function getActiveTask(workdir) {
+  for (const task of listTasks(workdir)) {
+    if (!isTerminalStatus(task.status)) return task;
+  }
+  return null;
+}
+function updateTask(workdir, taskId, patch) {
+  const task = getTask(workdir, taskId);
+  if (!task) {
+    throw new Error(`Task not found: ${taskId}`);
+  }
+  if ("title" in patch && patch.title !== void 0) task.title = patch.title;
+  if ("status" in patch && patch.status !== void 0) task.status = patch.status;
+  if ("active_phase" in patch) task.active_phase = patch.active_phase ?? null;
+  if ("next_action" in patch) task.next_action = patch.next_action ?? null;
+  if ("branch" in patch && patch.branch !== void 0) task.branch = patch.branch;
+  if ("progress" in patch) {
+    const progress = normalizeProgress(patch.progress);
+    if (progress) task.progress = progress;
+    else delete task.progress;
+  }
+  task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  writeTaskRecord(workdir, task);
+  syncProjectState(workdir);
+  return task;
+}
+function registerArtifact(workdir, taskId, artifact) {
+  if (!VALID_ARTIFACT_TYPES.has(artifact.type)) {
+    throw new TypeError(`invalid artifact type: ${String(artifact.type)}`);
+  }
+  if (typeof artifact.path !== "string" || !artifact.path.trim()) {
+    throw new TypeError("artifact path cannot be empty");
+  }
+  const task = getTask(workdir, taskId);
+  if (!task) {
+    throw new Error(`Task not found: ${taskId}`);
+  }
+  const normPath = normalizeArtifactPath(artifact.path.trim());
+  const existing = task.artifacts.find((a) => a.type === artifact.type && a.path === normPath);
+  if (existing) {
+    if (artifact.status) existing.status = artifact.status;
+    if (artifact.note !== void 0) existing.note = artifact.note;
+  } else {
+    const entry = {
+      type: artifact.type,
+      path: normPath,
+      status: artifact.status ?? "active",
+      registered_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (artifact.note !== void 0) entry.note = artifact.note;
+    task.artifacts.push(entry);
+  }
+  task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  writeTaskRecord(workdir, task);
+  syncProjectState(workdir);
+  return task;
+}
+function registerArtifactForActiveTask(workdir, artifact) {
+  try {
+    const active = getActiveTask(workdir);
+    if (!active) return null;
+    return registerArtifact(workdir, active.id, artifact);
+  } catch {
+    return null;
+  }
+}
+function registerSpecEvolution(workdir, changeId) {
+  return registerArtifactForActiveTask(workdir, {
+    type: "spec-evolution",
+    path: `openspec/changes/${changeId}/SPEC_EVOLUTION.md`
+  });
+}
+function completeTask(workdir, taskId, opts) {
+  const task = getTask(workdir, taskId);
+  if (!task) {
+    throw new Error(`Task not found: ${taskId}`);
+  }
+  task.status = "completed";
+  task.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+  task.active_phase = null;
+  if (opts && "next_action" in opts) {
+    task.next_action = opts.next_action ?? null;
+  }
+  task.updated_at = task.completed_at;
+  writeTaskRecord(workdir, task);
+  syncProjectState(workdir);
+  return task;
+}
+function archiveTask(workdir, taskId, now = /* @__PURE__ */ new Date()) {
+  const task = getTask(workdir, taskId);
+  if (!task) return null;
+  task.status = "archived";
+  task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  writeTaskRecord(workdir, task);
+  const yearMonth = now.toISOString().slice(0, 7);
+  const destParent = join(tasksRoot(workdir), "archive", yearMonth);
+  const dest = join(destParent, sanitizeTaskId(taskId));
+  try {
+    mkdirSync(destParent, { recursive: true });
+    renameSync(taskDir(workdir, taskId), dest);
+  } catch {
+    syncProjectState(workdir);
+    return null;
+  }
+  syncProjectState(workdir);
+  return dest;
+}
+function readProjectState(workdir) {
+  const path = projectStatePath(workdir);
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeProjectState(workdir, partial) {
+  const state = {
+    schema_version: 1,
+    active_task_id: partial.active_task_id ?? null,
+    active_phase: partial.active_phase ?? null,
+    next_action: partial.next_action ?? null,
+    progress: normalizeProgress(partial.progress ?? void 0) ?? null,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (partial.status !== void 0) state.status = partial.status;
+  const path = projectStatePath(workdir);
+  mkdirSync(dirname(path), { recursive: true });
+  atomicWriteFileSync(path, JSON.stringify(state, null, 2));
+  return state;
+}
+function syncProjectState(workdir) {
+  let active = null;
+  try {
+    active = getActiveTask(workdir);
+  } catch {
+    active = null;
+  }
+  if (!active) {
+    return writeProjectState(workdir, {
+      active_task_id: null,
+      active_phase: null,
+      next_action: null,
+      progress: null
+    });
+  }
+  return writeProjectState(workdir, {
+    active_task_id: active.id,
+    active_phase: active.active_phase ?? null,
+    next_action: active.next_action ?? null,
+    progress: active.progress ?? null
+  });
+}
+
 const FIX_LOG_RELATIVE_PATH = ".context/fix-log.jsonl";
 function resolveFixLogPath(workdir) {
   return resolve(workdir, FIX_LOG_RELATIVE_PATH);
@@ -25,6 +342,10 @@ function appendFixLogEntry(workdir, entry) {
   mkdirSync(dirname(logPath), { recursive: true });
   appendFileSync(logPath, `${JSON.stringify(entry)}
 `, "utf-8");
+  try {
+    registerArtifactForActiveTask(workdir, { type: "fix-log", path: FIX_LOG_RELATIVE_PATH });
+  } catch {
+  }
 }
 function validateEntry(entry) {
   if (!entry || typeof entry !== "object") {
@@ -250,14 +571,122 @@ function formatAsMarkdown(approved, meta) {
   return lines.join("\n").trimEnd() + "\n";
 }
 
+const RETRY_DELAY_MS = 200;
+const STALE_THRESHOLD_MS = 1e4;
+const MAX_WAIT_MS = 3e4;
+const LOCK_RETRY_ERRNOS = /* @__PURE__ */ new Set([
+  "EPERM",
+  // Windows / macOS AV scanner holds the file open during delete
+  "EBUSY",
+  // Windows: file in use by another process
+  "EAGAIN",
+  // POSIX: resource temporarily unavailable
+  "EINTR",
+  // POSIX: syscall interrupted by signal
+  "EINVAL",
+  // Docker overlay-fs: transient during concurrent O_EXCL creation
+  "EIO",
+  // Docker overlay-fs / NFS: transient I/O error
+  "ENOENT",
+  // Docker overlay-fs: parent dir transiently missing during race
+  "ESTALE"
+  // NFS: stale file handle (self-resolves on retry)
+]);
+const heldLocks = /* @__PURE__ */ new Set();
+let exitHookInstalled = false;
+function installExitHook() {
+  if (exitHookInstalled)
+    return;
+  exitHookInstalled = true;
+  process.on("exit", () => {
+    for (const lockPath of heldLocks) {
+      try {
+        unlinkSync(lockPath);
+      } catch {
+      }
+    }
+    heldLocks.clear();
+  });
+}
+function lockPathFor(target) {
+  return `${target}.lock`;
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function acquireLock(target, opts = {}) {
+  const retryDelayMs = opts.retryDelayMs ?? RETRY_DELAY_MS;
+  const staleThresholdMs = opts.staleThresholdMs ?? STALE_THRESHOLD_MS;
+  const maxWaitMs = opts.maxWaitMs ?? MAX_WAIT_MS;
+  const lockPath = lockPathFor(target);
+  const startedAt = Date.now();
+  while (true) {
+    try {
+      const fd = openSync(lockPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+      writeSync(fd, String(process.pid));
+      closeSync(fd);
+      heldLocks.add(lockPath);
+      installExitHook();
+      return lockPath;
+    } catch (err) {
+      const code = err.code ?? "";
+      if (code === "EEXIST") {
+        let stale = false;
+        try {
+          const stat = statSync(lockPath);
+          stale = Date.now() - stat.mtimeMs > staleThresholdMs;
+        } catch {
+          continue;
+        }
+        if (stale) {
+          const tombstone = `${lockPath}.steal-${process.pid}-${Date.now()}`;
+          try {
+            renameSync(lockPath, tombstone);
+            try {
+              unlinkSync(tombstone);
+            } catch {
+            }
+            continue;
+          } catch {
+          }
+        }
+      } else if (!LOCK_RETRY_ERRNOS.has(code)) {
+        throw err;
+      }
+      const waited = Date.now() - startedAt;
+      if (waited >= maxWaitMs) {
+        throw new Error(
+          `state-lock: ${lockPath} not acquired after waiting ${waited}ms (budget ${maxWaitMs}ms, last errno ${code || "EEXIST"})`
+        );
+      }
+      sleepSync(retryDelayMs + Math.floor(Math.random() * 50));
+    }
+  }
+}
+function releaseLock(lockPath) {
+  heldLocks.delete(lockPath);
+  try {
+    unlinkSync(lockPath);
+  } catch {
+  }
+}
+function withLock(target, fn, opts) {
+  const lockPath = acquireLock(target, opts);
+  try {
+    return fn();
+  } finally {
+    releaseLock(lockPath);
+  }
+}
+
 function phaseDir(workdir, phase) {
-  return join(workdir, ".context", sanitizePhase(phase));
+  return join$1(workdir, ".context", sanitizePhase(phase));
 }
 function contextPath(workdir, phase) {
-  return join(phaseDir(workdir, phase), "CONTEXT.md");
+  return join$1(phaseDir(workdir, phase), "CONTEXT.md");
 }
 function summaryPath(workdir, phase) {
-  return join(phaseDir(workdir, phase), "SUMMARY.md");
+  return join$1(phaseDir(workdir, phase), "SUMMARY.md");
 }
 function sanitizePhase(phase) {
   return phase.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -377,19 +806,24 @@ function readContext(workdir, phase) {
 function writeSummary(workdir, summary) {
   const target = summaryPath(workdir, summary.phase);
   mkdirSync(dirname$1(target), { recursive: true });
-  const frontmatter = [
-    "---",
+  writeFileSync(target, renderSummaryDocument(summary), "utf8");
+  return target;
+}
+function summaryFrontmatterText(summary) {
+  return [
     `phase: ${serializeScalar(summary.phase)}`,
     `plan: ${serializeScalar(summary.plan)}`,
     `provides: ${serializeList(summary.provides)}`,
     `affects: ${serializeList(summary.affects)}`,
     `key_files: ${serializeList(summary.keyFiles)}`,
+    ...summary.tests && summary.tests.length ? [`tests: ${serializeList(summary.tests)}`] : [],
     `completed: ${summary.completed ? "true" : "false"}`,
     ...summary.completedAt ? [`completed_at: ${serializeScalar(summary.completedAt)}`] : [],
-    ...summary.notes ? [`notes: ${serializeScalar(summary.notes)}`] : [],
-    "---",
-    ""
+    ...summary.notes ? [`notes: ${serializeScalar(summary.notes)}`] : []
   ].join("\n");
+}
+function renderSummaryDocument(summary) {
+  const frontmatter = ["---", summaryFrontmatterText(summary), "---", ""].join("\n");
   const body = [
     `# Phase Summary: ${summary.phase}`,
     "",
@@ -411,8 +845,7 @@ function writeSummary(workdir, summary) {
 ${summary.notes}
 ` : ""
   ].filter(Boolean).join("\n");
-  writeFileSync(target, frontmatter + body, "utf8");
-  return target;
+  return frontmatter + body;
 }
 function readSummary(workdir, phase) {
   const target = summaryPath(workdir, phase);
@@ -429,6 +862,7 @@ function readSummary(workdir, phase) {
     provides: toList(fields.provides),
     affects: toList(fields.affects),
     keyFiles: toList(fields.key_files),
+    tests: toList(fields.tests),
     completed: fields.completed === true,
     completedAt: fields.completed_at ? String(fields.completed_at) : void 0,
     notes: fields.notes ? String(fields.notes) : void 0
@@ -451,9 +885,107 @@ function toList(value) {
     return [value];
   return [];
 }
+function unionPreserveOrder(a, b) {
+  return [.../* @__PURE__ */ new Set([...a, ...b])];
+}
+const SUMMARY_TOKEN_BUDGET = 200;
+function mergeSummaryFields(existing, phase, plan, patch, nowIso) {
+  const base = existing ?? {
+    phase,
+    plan,
+    provides: [],
+    affects: [],
+    keyFiles: [],
+    tests: [],
+    completed: false
+  };
+  const noteSegment = patch.notes ? `[${patch.taskId}] ${patch.notes.replace(/\r?\n+/g, " ").trim()}` : void 0;
+  const mergedNotes = [base.notes, noteSegment].filter(Boolean).join(" | ") || void 0;
+  const completed = patch.completed ?? base.completed;
+  return {
+    phase: base.phase || phase,
+    plan: base.plan || plan,
+    provides: unionPreserveOrder(base.provides, patch.provides ?? []),
+    affects: unionPreserveOrder(base.affects, patch.affects ?? []),
+    keyFiles: unionPreserveOrder(base.keyFiles, patch.keyFiles ?? []),
+    tests: unionPreserveOrder(base.tests ?? [], patch.tests ?? []),
+    completed,
+    completedAt: completed ? nowIso ?? (/* @__PURE__ */ new Date()).toISOString() : base.completedAt,
+    notes: mergedNotes
+  };
+}
+function enforceSummaryBudget(summary, budget = SUMMARY_TOKEN_BUDGET) {
+  let current = summary;
+  let guard = 0;
+  while (current.notes && summaryTokenEstimate(summaryFrontmatterText(current)) > budget && guard < 50) {
+    const excess = summaryTokenEstimate(summaryFrontmatterText(current)) - budget;
+    const cutChars = Math.ceil(excess * 3.5) + 1;
+    const trimmed = current.notes.slice(0, Math.max(0, current.notes.length - cutChars));
+    current = { ...current, notes: trimmed ? `${trimmed}\u2026` : void 0 };
+    guard += 1;
+  }
+  return current;
+}
+function mergeSummary(workdir, phase, plan, patch, opts) {
+  const target = summaryPath(workdir, phase);
+  mkdirSync(dirname$1(target), { recursive: true });
+  return withLock(target, () => {
+    const existing = readSummary(workdir, phase);
+    const merged = enforceSummaryBudget(mergeSummaryFields(existing, phase, plan, patch));
+    atomicWriteFileSync(target, renderSummaryDocument(merged));
+    return merged;
+  }, opts);
+}
+function isTestFilePath(p) {
+  const normalized = p.replace(/\\/g, "/").trim();
+  const base = normalized.split("/").pop() ?? "";
+  if (/(?:\.|_|-)(?:test|spec)\.[a-z0-9]+$/i.test(base))
+    return true;
+  if (/_test\.(?:go|py)$/i.test(base))
+    return true;
+  if (/^test_[^/]+\.py$/i.test(base))
+    return true;
+  if (/(?:^|\/)__tests__(?:\/|$)/.test(normalized))
+    return true;
+  if (/(?:^|\/)tests?(?:\/|$)/i.test(normalized))
+    return true;
+  return false;
+}
+const RESERVED_CONTEXT_DIRS = /* @__PURE__ */ new Set([
+  "jobs",
+  "debug",
+  "uat",
+  "codebase",
+  "tasks"
+]);
+function collectRegressionTests(workdir, excludePhases = []) {
+  const contextDir = join$1(workdir, ".context");
+  if (!existsSync(contextDir))
+    return [];
+  const excluded = /* @__PURE__ */ new Set();
+  for (const p of excludePhases) {
+    excluded.add(p);
+    excluded.add(sanitizePhase(p));
+  }
+  const out = [];
+  const names = readdirSync(contextDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  for (const name of names) {
+    if (RESERVED_CONTEXT_DIRS.has(name) || excluded.has(name))
+      continue;
+    const summary = readSummary(workdir, name);
+    if (!summary || !summary.completed)
+      continue;
+    const resolved = summary.tests && summary.tests.length ? summary.tests : summary.keyFiles.filter(isTestFilePath);
+    const deduped = [...new Set(resolved)];
+    if (deduped.length)
+      out.push({ phase: name, tests: deduped });
+  }
+  return out;
+}
 
 const PHASE_HEADER_RE = /^## Phase ([0-9]+(?:\.[0-9]+)?)\s*:\s*(.+?)\s*\(([a-z_]+)\)\s*$/;
 const DEPENDS_ON_RE = /^-\s+\*\*Depends on\*\*\s*:\s*(.+)$/;
+const REQUIREMENTS_RE = /^-\s+\*\*Requirements\*\*\s*:\s*(.+)$/;
 function parseRoadmap(content) {
   const phases = [];
   const lines = content.split(/\r?\n/);
@@ -486,6 +1018,11 @@ function parseRoadmap(content) {
       const depMatch = line.match(DEPENDS_ON_RE);
       if (depMatch)
         current.dependsOn = parseDependsOn(depMatch[1]);
+      const reqMatch = line.match(REQUIREMENTS_RE);
+      if (reqMatch) {
+        const raw = reqMatch[1].trim();
+        current.requirements = /^\(none\)$/i.test(raw) ? [] : raw.split(",").map((s) => s.trim()).filter(Boolean);
+      }
     }
   }
   flushCurrent();
@@ -632,6 +1169,109 @@ function schedule(phases, options = {}) {
   }
   return { waves, skipped: cascaded, batches };
 }
+function validateTaskGraph(tasks) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const t of tasks) {
+    if (seen.has(t.id))
+      errors.push(`duplicate task id "${t.id}"`);
+    seen.add(t.id);
+  }
+  for (const t of tasks) {
+    for (const dep of t.dependsOn) {
+      if (dep === t.id)
+        errors.push(`task "${t.id}" depends on itself`);
+      else if (!seen.has(dep))
+        errors.push(`task "${t.id}" depends on unknown task "${dep}"`);
+    }
+  }
+  return errors;
+}
+function normalizeTaskFile(p) {
+  return p.replace(/\\/g, "/").trim();
+}
+function splitWaveByFileOverlap(waveTaskIds, filesById) {
+  const subWaves = [];
+  const subWaveFiles = [];
+  for (const id of waveTaskIds) {
+    const files = (filesById.get(id) ?? []).map(normalizeTaskFile);
+    let placed = false;
+    for (let i = 0; i < subWaves.length; i++) {
+      if (!files.some((f) => subWaveFiles[i].has(f))) {
+        subWaves[i].push(id);
+        for (const f of files)
+          subWaveFiles[i].add(f);
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) {
+      subWaves.push([id]);
+      subWaveFiles.push(new Set(files));
+    }
+  }
+  return subWaves;
+}
+function findFileConflict(taskId, orderedIds, filesById) {
+  const files = new Set((filesById.get(taskId) ?? []).map(normalizeTaskFile));
+  for (const otherId of orderedIds) {
+    if (otherId === taskId)
+      break;
+    for (const f of (filesById.get(otherId) ?? []).map(normalizeTaskFile)) {
+      if (files.has(f))
+        return { otherId, file: f };
+    }
+  }
+  return null;
+}
+function buildTaskWaves(tasks) {
+  const errors = validateTaskGraph(tasks);
+  if (errors.length > 0) {
+    throw new Error(
+      `wave-scheduler: invalid task graph:
+- ${errors.join("\n- ")}`
+    );
+  }
+  const phases = tasks.map((t) => ({
+    id: t.id,
+    name: t.id,
+    status: t.status ?? "pending",
+    dependsOn: [...t.dependsOn]
+  }));
+  const { waves: rawWaves, skipped } = schedule(phases);
+  const filesById = /* @__PURE__ */ new Map();
+  for (const t of tasks)
+    filesById.set(t.id, t.files);
+  const warnings = [];
+  const finalWaves = [];
+  for (let w = 0; w < rawWaves.length; w++) {
+    const wave = rawWaves[w];
+    const subWaves = splitWaveByFileOverlap(wave, filesById);
+    if (subWaves.length > 1) {
+      for (let k = 1; k < subWaves.length; k++) {
+        for (const id of subWaves[k]) {
+          const conflict = findFileConflict(id, wave, filesById);
+          if (conflict)
+            warnings.push(`wave ${w + 1} split: ${conflict.otherId}/${id} share file ${conflict.file}`);
+        }
+      }
+    }
+    finalWaves.push(...subWaves);
+  }
+  const derivedWaveById = /* @__PURE__ */ new Map();
+  finalWaves.forEach((wave, i) => {
+    for (const id of wave)
+      derivedWaveById.set(id, i + 1);
+  });
+  for (const t of tasks) {
+    if (typeof t.declaredWave !== "number")
+      continue;
+    const derived = derivedWaveById.get(t.id);
+    if (derived !== void 0 && derived !== t.declaredWave)
+      warnings.push(`task ${t.id}: declared wave ${t.declaredWave} but derived wave ${derived} (derived wins)`);
+  }
+  return { waves: finalWaves, skipped, warnings };
+}
 
 function rolePromptFile(role) {
   switch (role) {
@@ -1005,7 +1645,7 @@ function synthesizeRevisionFeedback(summaries) {
 }
 
 function pluginRoot(home = homedir()) {
-  return join(home, ".claude", "plugins");
+  return join$1(home, ".claude", "plugins");
 }
 const PLUGIN_MARKERS = ["SKILL.md", "plugin.json", "package.json", "manifest.json"];
 const PLUGIN_PREFIXES = {
@@ -1029,14 +1669,14 @@ function detectPlugin(name, homeDir = homedir()) {
   for (const entry of entries) {
     const matchesPrefix = prefixes.some((p) => entry.startsWith(p));
     if (!matchesPrefix) continue;
-    const dir = join(root, entry);
+    const dir = join$1(root, entry);
     try {
       if (!statSync(dir).isDirectory()) continue;
     } catch {
       continue;
     }
     for (const marker of PLUGIN_MARKERS) {
-      const markerPath = join(dir, marker);
+      const markerPath = join$1(dir, marker);
       if (existsSync(markerPath)) {
         return { name, installed: true, probedPath: dir };
       }
@@ -1195,6 +1835,83 @@ function synthesizeVerifyFeedback(reports) {
   ];
   return lines.join("\n");
 }
+const GATE_REGISTRY = [
+  { gate: "execute-entry", gateType: "pre-flight", failurePath: ".claude/plan/<name>.md \u7F3A\u5931 \u2192 \u963B\u65AD\u5165\u53E3\uFF0C\u63D0\u793A\u5148\u8DD1 /ccg:plan\uFF1B\u4E0D\u4EA7\u751F\u90E8\u5206\u5DE5\u4F5C" },
+  { gate: "spec-impl-entry", gateType: "pre-flight", failurePath: "OPSX artifacts \u7F3A\u5931 \u2192 \u963B\u65AD\u5165\u53E3\uFF0C\u63D0\u793A\u5148\u8DD1 /ccg:spec-plan" },
+  { gate: "verify-work-entry", gateType: "pre-flight", failurePath: "task-id \u65E0\u6CD5\u63A8\u65AD\u4E14\u65E0 git diff \u2192 \u963B\u65AD\uFF0C\u8981\u6C42\u663E\u5F0F\u4F20 task-id" },
+  { gate: "verify-change", gateType: "revision-loop", maxLoops: 3, failurePath: "findings \u56DE\u5582\u4FEE\u590D\u2192\u91CD\u8DD1\uFF1B3 \u8F6E\u6216 stall \u2192 escalation \u4E09\u9009" },
+  { gate: "verify-quality", gateType: "revision-loop", maxLoops: 3, failurePath: "\u540C verify-change" },
+  { gate: "verify-module", gateType: "revision-loop", maxLoops: 3, failurePath: "\u7F3A\u6587\u6863/\u7ED3\u6784 \u2192 \u8865\u9F50\u91CD\u8DD1\uFF1B3 \u8F6E \u2192 escalation" },
+  { gate: "verify-security", gateType: "revision-loop", criticalOverride: "abort", maxLoops: 3, failurePath: "critical \u6F0F\u6D1E \u2192 abort\uFF08\u505C\u6B62\u4EA4\u4ED8\u3001\u4FDD\u7559 UAT/job \u72B6\u6001\u3001\u62A5\u539F\u56E0\u3001\u4FEE\u590D\u540E resume\uFF09\uFF1B\u975E critical \u2192 revision-loop" },
+  { gate: "plan-checker", gateType: "revision-loop", maxLoops: 3, failurePath: "BLOCKER \u56DE\u5582 planner\uFF08\u4EC5\u4FEE BLOCKER\uFF09\uFF1B3 \u8F6E\u6216 stall \u2192 escalation force/guide/abort" },
+  { gate: "requirements-coverage", gateType: "escalation", failurePath: "\u672A\u8986\u76D6 REQ-ID \u2192 \u963B\u65AD planning \u5B8C\u6210 + AskUserQuestion \u4E09\u9009\uFF1Are-plan \u8865\u8986\u76D6\uFF08\u63A8\u8350\uFF09/\u79FB\u5230\u4E0B\u4E00 phase/force \u63A5\u53D7\u5E76\u8BB0\u5F55" },
+  { gate: "verify-wave", gateType: "revision-loop", maxLoops: 3, failurePath: "critical \u2192 \u4FEE\u8BA2\u8F6E\uFF08\u4EC5\u4FEE critical\uFF09\uFF1Bstall \u6216 3 \u8F6E \u2192 escalation" },
+  { gate: "uat-convergence", gateType: "revision-loop", maxLoops: 3, failurePath: "diagnose\u2192planner --gaps\u2192plan-checker \u6536\u655B\u73AF\uFF1B3 \u8F6E \u2192 escalation \u4E09\u9009" }
+];
+function getGateClassification(gate) {
+  if (!gate || typeof gate !== "string") return void 0;
+  const lower = gate.trim().toLowerCase();
+  return GATE_REGISTRY.find((g) => g.gate === lower);
+}
+const ESCALATION_OPTIONS = [
+  "force: \u63A5\u53D7\u5F53\u524D\u7ED3\u679C\u5E76\u8BB0\u5F55\u98CE\u9669",
+  "guide: \u63D0\u4F9B\u6307\u5BFC\u518D\u8BD5\u4E00\u8F6E",
+  "abort: \u4E2D\u6B62\u5E76\u4FDD\u7559\u72B6\u6001"
+];
+function resolveVerifyGateAction(reports, loop = { currentLoop: 0 }) {
+  const rawMax = loop?.maxLoops;
+  const maxLoops = Number.isFinite(rawMax) ? Math.max(1, Math.floor(rawMax)) : 3;
+  const rawCur = loop?.currentLoop;
+  const cur = Number.isFinite(rawCur) ? Math.max(0, Math.floor(rawCur)) : 0;
+  if (synthesizeVerifyResults(reports) === "escalate") {
+    return {
+      gateType: "escalation",
+      action: "escalate",
+      currentLoop: cur,
+      maxLoops,
+      message: "Verify reports missing or contain errors \u2014 escalate to user.",
+      options: ESCALATION_OPTIONS
+    };
+  }
+  const criticalCount = reports.reduce((n, r) => n + r.criticals.length, 0);
+  if (criticalCount === 0) {
+    return {
+      gateType: "revision-loop",
+      action: "advance",
+      currentLoop: cur,
+      maxLoops,
+      message: "All verify reports complete with 0 critical findings \u2014 advance."
+    };
+  }
+  if (cur >= maxLoops) {
+    return {
+      gateType: "escalation",
+      action: "escalate",
+      currentLoop: cur,
+      maxLoops,
+      message: `Convergence loop exhausted (${cur}/${maxLoops}). Escalate to user with 3 options: (a) force-accept partial fix, (b) provide guidance & retry, (c) abort and roll back.`,
+      options: ESCALATION_OPTIONS
+    };
+  }
+  if (loop?.previousCriticalCount != null && Number.isFinite(loop.previousCriticalCount) && criticalCount >= loop.previousCriticalCount) {
+    return {
+      gateType: "escalation",
+      action: "escalate",
+      currentLoop: cur,
+      maxLoops,
+      message: `Stall detected: critical count did not decrease (${loop.previousCriticalCount} \u2192 ${criticalCount}). Escalate early without waiting for loop exhaustion.`,
+      options: ESCALATION_OPTIONS
+    };
+  }
+  return {
+    gateType: "revision-loop",
+    action: "revise",
+    currentLoop: cur,
+    maxLoops,
+    message: `Loop ${cur + 1}/${maxLoops} \u2014 feed critical findings back and re-run verify.`,
+    feedback: synthesizeVerifyFeedback(reports)
+  };
+}
 
 const ALL_TIERS = ["fast", "triple", "debate"];
 const DEBATE_MAX_ROUNDS = 3;
@@ -1380,7 +2097,7 @@ function verifyWavePlanToWavePlan(vwp, index) {
     ccgPromptFile: s.ccgPromptFile,
     // v4.4.2: 透传 invocationMode/bashCommand（之前 adapter drop 这两字段，
     // 导致 useDirectBashInvocation 仅对直接调 planVerifyWave 的路径生效；
-    // autonomous Step 4.1 走 quality-router 路径时 silent fallback 风险残留）
+    // autonomous 附录 A Step 4.1 走 quality-router 路径时 silent fallback 风险残留）
     invocationMode: s.invocationMode,
     bashCommand: s.bashCommand
   }));
@@ -1809,7 +2526,7 @@ function runPnpmPack(workdir) {
   if (!tarballName.endsWith(".tgz")) {
     throw new Error(`pnpm pack last line is not a tgz: "${tarballName}"`);
   }
-  return join(workdir, tarballName);
+  return join$1(workdir, tarballName);
 }
 function auditTarballContents(tarballPath) {
   const out = execSync(`tar -tzf "${tarballPath}"`, {
@@ -1825,7 +2542,7 @@ function verifyAllCommandsIncluded(workdir, tarballEntries) {
     missingInPackageJson: [],
     missingInTarball: []
   };
-  const pkgPath = join(workdir, "package.json");
+  const pkgPath = join$1(workdir, "package.json");
   if (existsSync(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
@@ -1833,7 +2550,7 @@ function verifyAllCommandsIncluded(workdir, tarballEntries) {
     } catch {
     }
   }
-  const cmdDir = join(workdir, "templates", "commands");
+  const cmdDir = join$1(workdir, "templates", "commands");
   if (existsSync(cmdDir)) {
     const files = readdirSync(cmdDir).filter((f) => f.endsWith(".md"));
     result.actualCommands = files.map((f) => `templates/commands/${f}`);
@@ -1888,7 +2605,7 @@ function runPipelineCheck(opts = {}) {
   }
   const verifyResult = verifyAllCommandsIncluded(workdir, tarballEntries);
   if (verifyResult.packageFiles.length === 0) {
-    const pkgPath = join(workdir, "package.json");
+    const pkgPath = join$1(workdir, "package.json");
     if (!existsSync(pkgPath)) {
       errors.push({
         category: "package-json-missing",
@@ -1967,7 +2684,7 @@ function shortNameOf(pluginKey) {
 }
 function samplePluginList(homeDir = homedir()) {
   const warnings = [];
-  const path = join(homeDir, ".claude", "plugins", "installed_plugins.json");
+  const path = join$1(homeDir, ".claude", "plugins", "installed_plugins.json");
   if (!existsSync(path)) {
     return { plugins: [], warnings: [`installed_plugins.json not found at ${path}`] };
   }
@@ -2020,7 +2737,7 @@ function walkSkills(baseDir, currentDir, out, warnings) {
     return;
   }
   for (const entry of entries) {
-    const full = join(currentDir, entry);
+    const full = join$1(currentDir, entry);
     let stat;
     try {
       stat = statSync(full);
@@ -2055,7 +2772,7 @@ function walkSkills(baseDir, currentDir, out, warnings) {
 }
 function sampleSkillList(homeDir = homedir()) {
   const warnings = [];
-  const root = join(homeDir, ".claude", "skills", "ccg");
+  const root = join$1(homeDir, ".claude", "skills", "ccg");
   if (!existsSync(root)) {
     return { skills: [], warnings: [`skills/ccg/ not found at ${root}`] };
   }
@@ -2080,7 +2797,7 @@ function classifyMatcher(matcher) {
 }
 function sampleHookSchema(homeDir = homedir()) {
   const warnings = [];
-  const path = join(homeDir, ".claude", "settings.json");
+  const path = join$1(homeDir, ".claude", "settings.json");
   if (!existsSync(path)) {
     return { hooks: [], warnings: [`settings.json not found at ${path}`] };
   }
@@ -2112,7 +2829,7 @@ function sampleHookSchema(homeDir = homedir()) {
 }
 function samplePackageStructure(workdir) {
   const warnings = [];
-  const pkgPath = join(workdir, "package.json");
+  const pkgPath = join$1(workdir, "package.json");
   if (!existsSync(pkgPath)) {
     return { info: null, warnings: [`package.json not found at ${pkgPath}`] };
   }
@@ -2125,7 +2842,7 @@ function samplePackageStructure(workdir) {
   }
   const packageFiles = Array.isArray(pkg.files) ? pkg.files : [];
   let templateCommands = [];
-  const cmdDir = join(workdir, "templates", "commands");
+  const cmdDir = join$1(workdir, "templates", "commands");
   if (existsSync(cmdDir)) {
     try {
       templateCommands = readdirSync(cmdDir).filter((f) => f.endsWith(".md")).map((f) => `templates/commands/${f}`);
@@ -2260,4 +2977,318 @@ function hasBlockingFindings(report) {
   return report.findings.some((f) => f.severity === "critical");
 }
 
-export { ALL_LAYERS, CONTEXT_BUDGET_THRESHOLD, DESCRIPTION_SOFT_LIMIT, FIX_LOG_RELATIVE_PATH, MAX_STATEMENT_CHARS, MIN_RATIONALE_CHARS, ROUTING_SCHEMA_VERSION, aggregatePlans, appendFixLogEntry, auditSkillDescriptions, auditSkillsDirectory, auditTarballContents, batchByMaxConcurrent, bothPluginsInstalled, buildQualityPlan, buildWaves, cascadeSkip, categorizeStatement, checkQuality, collectSkills, contextPath, convergeHistoryFromLog, decideFromSummaries, detectPlugin, detectPluginAvailability, estimateBriefLength, estimateTokens, extractCandidates, extractFrontmatter, formatAsMarkdown, criticalFindings as interfaceAuditCriticals, hasBlockingFindings as interfaceAuditHasBlocking, majorFindings as interfaceAuditMajors, isLayer, loadConvergeHistory, parseChallengerSummary, parseDependsOn, parseFrontmatterFields, parseInterfaceAuditorReport, parseQualityFlag, parseRoadmap, parseRoleFlag, parseVerifyReport, phaseDir, planChallengerSpawns, planVerifyWave, planWavesForTier, promptFilePath, readContext, readFixLog, readSummary, readSummaryFrontmatter, renderAuditMarkdown, renderPipelineReport, resolveFixLogPath, resolveQualityTier, routeSpecialist, runPipelineCheck, runPnpmPack, sampleAll, sampleHookSchema, samplePackageStructure, samplePluginList, sampleSkillList, sanitizePhase, schedule, serializeBriefForPrompt, summarizeGroundTruth, summaryPath, summaryTokenEstimate, synthesizeRevisionFeedback, synthesizeVerifyFeedback, synthesizeVerifyResults, verifyAllCommandsIncluded, writeContext, writeSummary };
+const AUTO_CONVERGE_CAP = 3;
+function blockingCount(findings, blocking) {
+  return blocking === "critical" ? findings.critical : findings.critical + findings.warning;
+}
+function decideConverge(history, cap = AUTO_CONVERGE_CAP, blocking = "critical_warning") {
+  if (history.length === 0) {
+    return "continue";
+  }
+  const last = history[history.length - 1];
+  const lastBlocking = blockingCount(last.findings, blocking);
+  if (lastBlocking === 0) {
+    return "converged";
+  }
+  if (history.length >= cap) {
+    return "escalate";
+  }
+  if (history.length >= 2) {
+    const prev = history[history.length - 2];
+    const prevBlocking = blockingCount(prev.findings, blocking);
+    if (lastBlocking >= prevBlocking) {
+      return "escalate";
+    }
+  }
+  return "continue";
+}
+
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const REQ_ID_SOURCE = "[A-Z][A-Z0-9]*-[A-Za-z0-9_-]+";
+const REQ_CHECKBOX_RE = new RegExp(`^\\s*-\\s*\\[[xX ]\\]\\s*\\*\\*(${REQ_ID_SOURCE})\\*\\*\\s*(.*)$`);
+const REQ_TABLE_ROW_RE = new RegExp(`^\\s*\\|\\s*(${REQ_ID_SOURCE})\\s*\\|(.*)$`);
+const TABLE_SEPARATOR_RE = /^\s*\|[\s:|-]+\|?\s*$/;
+function extractRequirementIds(text) {
+  if (!text || typeof text !== "string") return [];
+  const lines = text.split(/\r?\n/);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (TABLE_SEPARATOR_RE.test(line)) continue;
+    if (i + 1 < lines.length && TABLE_SEPARATOR_RE.test(lines[i + 1])) continue;
+    let id;
+    let desc = "";
+    const cb = REQ_CHECKBOX_RE.exec(line);
+    if (cb) {
+      id = cb[1];
+      desc = cb[2].trim();
+    } else {
+      const tr = REQ_TABLE_ROW_RE.exec(line);
+      if (tr) {
+        id = tr[1];
+        desc = (tr[2].split("|")[0] ?? "").trim();
+      }
+    }
+    if (!id) continue;
+    const key = id.toUpperCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ id, text: desc });
+  }
+  return out;
+}
+function extractPhaseRequirementIds(roadmapContent, phaseId) {
+  if (!roadmapContent || typeof roadmapContent !== "string") return [];
+  if (!phaseId || typeof phaseId !== "string") return [];
+  const target = phaseId.trim();
+  const headerRe = /^## Phase ([0-9]+(?:\.[0-9]+)?)\s*:/;
+  const reqRe = /^-\s+\*\*Requirements\*\*\s*:\s*(.+)$/;
+  let inBlock = false;
+  for (const line of roadmapContent.split(/\r?\n/)) {
+    const h = headerRe.exec(line);
+    if (h) {
+      inBlock = h[1] === target;
+      continue;
+    }
+    if (!inBlock) continue;
+    const m = reqRe.exec(line);
+    if (!m) continue;
+    const raw = m[1].trim();
+    if (/^\(none\)$/i.test(raw)) return [];
+    return raw.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  return [];
+}
+function checkRequirementsCoverage(phaseReqIds, plans) {
+  const ids = (phaseReqIds ?? []).filter((r) => typeof r === "string" && r.trim() !== "");
+  if (ids.length === 0) {
+    return {
+      gateType: "escalation",
+      passed: true,
+      skipped: true,
+      entries: [],
+      counts: { total: 0, covered: 0, mentionedOnly: 0, uncovered: 0 }
+    };
+  }
+  const safePlans = plans ?? [];
+  const entries = [];
+  let covered = 0;
+  let mentionedOnly = 0;
+  let uncovered = 0;
+  for (const id of ids) {
+    const upper = id.toUpperCase();
+    const coveredBy = [];
+    safePlans.forEach((p, idx) => {
+      const declared = (p.frontmatter?.requirements ?? []).some(
+        (r) => r.toUpperCase() === upper
+      );
+      if (declared) coveredBy.push(p.frontmatter?.plan || `plan#${idx + 1}`);
+    });
+    if (coveredBy.length > 0) {
+      covered += 1;
+      entries.push({ id, status: "covered", coveredBy });
+      continue;
+    }
+    const wordRe = new RegExp(`\\b${escapeRe(id)}\\b`, "i");
+    const mentioned = safePlans.some(
+      (p) => typeof p.body === "string" && wordRe.test(p.body)
+    );
+    if (mentioned) {
+      mentionedOnly += 1;
+      entries.push({ id, status: "mentioned-only", coveredBy: [] });
+    } else {
+      uncovered += 1;
+      entries.push({ id, status: "uncovered", coveredBy: [] });
+    }
+  }
+  return {
+    gateType: "escalation",
+    passed: mentionedOnly === 0 && uncovered === 0,
+    skipped: false,
+    entries,
+    counts: { total: ids.length, covered, mentionedOnly, uncovered }
+  };
+}
+function naturalSortKey(id) {
+  return id.replace(/\d+/g, (d) => d.padStart(8, "0")).toUpperCase();
+}
+function formatRequirementsCoverageReport(result) {
+  if (result.skipped) {
+    return "\u2713 Requirements coverage: skipped\uFF08\u5F53\u524D phase \u672A\u58F0\u660E Requirements \u884C\uFF09";
+  }
+  if (result.passed) {
+    return `\u2713 Requirements coverage: ${result.counts.covered}/${result.counts.total} REQ-IDs covered by plans`;
+  }
+  const lines = [];
+  lines.push("## \u26A0 Requirements Coverage Gap");
+  lines.push("");
+  lines.push(`- Covered: ${result.counts.covered}/${result.counts.total}`);
+  lines.push(`- Mentioned-only: ${result.counts.mentionedOnly}\uFF08\u6B63\u6587\u63D0\u53CA\u4F46\u672A\u5728 frontmatter \u58F0\u660E\uFF0C\u4E0D\u7B97\u901A\u8FC7\uFF09`);
+  lines.push(`- Uncovered: ${result.counts.uncovered}`);
+  lines.push("");
+  lines.push("| REQ-ID | Status | Covered By |");
+  lines.push("|--------|--------|------------|");
+  const sorted = [...result.entries].sort(
+    (a, b) => naturalSortKey(a.id).localeCompare(naturalSortKey(b.id))
+  );
+  for (const e of sorted) {
+    const by = e.coveredBy.length > 0 ? e.coveredBy.join(", ") : "\u2014";
+    lines.push(`| ${e.id} | ${e.status} | ${by} |`);
+  }
+  lines.push("");
+  lines.push("mentioned-only \u4FEE\u590D\u5EFA\u8BAE\uFF1A\u5728\u5BF9\u5E94 plan \u7684 frontmatter \u8865 `requirements: [<REQ-ID>]` \u663E\u5F0F\u58F0\u660E\u3002");
+  lines.push("");
+  lines.push("\u672A\u5168\u8986\u76D6 \u2192 \u963B\u65AD planning \u5B8C\u6210\uFF0CAskUserQuestion \u4E09\u9009\uFF1A");
+  lines.push("1. re-plan \u8865\u8986\u76D6\uFF08\u63A8\u8350\uFF09");
+  lines.push("2. \u79FB\u5230\u4E0B\u4E00 phase\uFF08\u540C\u6B65\u66F4\u65B0 roadmap Requirements \u884C\uFF09");
+  lines.push('3. force \u63A5\u53D7 gap\uFF08\u8BA1\u5212\u6587\u4EF6\u8FFD\u52A0 "## Coverage Override" \u6BB5\u8BB0\u5F55\uFF09');
+  return lines.join("\n");
+}
+
+const PHASE_SUMMARY_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["status", "commit", "tests", "typecheck", "handoff_taken", "context_delta", "notes"],
+  properties: {
+    status: { type: "string", enum: ["completed", "partial", "failed", "degraded"] },
+    commit: { type: "string", description: 'sha7 \u6216 "none"' },
+    tests: { type: "string", description: '"<pass>/<total> passed (delta +<n>)" \u6216 "n/a"' },
+    typecheck: { type: "string", enum: ["pass", "fail", "unknown"] },
+    handoff_taken: { type: "array", items: { type: "string" }, maxItems: 8 },
+    context_delta: { type: "string", maxLength: 100 },
+    notes: { type: "string", maxLength: 160 }
+  }
+};
+function flattenWaves(s) {
+  const out = [];
+  for (const wave of s.waves)
+    out.push(...wave);
+  return out;
+}
+function buildWorkflowScript(phases, opts) {
+  if (phases.length === 0)
+    throw new Error("workflow-autonomous: phases must be non-empty");
+  const metaPhases = phases.map((p) => `    { title: ${JSON.stringify(p.title)} },`).join("\n");
+  const phaseLiterals = phases.map((p) => [
+    "  {",
+    `    id: ${JSON.stringify(p.id)},`,
+    `    title: ${JSON.stringify(p.title)},`,
+    `    prompt: ${JSON.stringify(p.prompt)},`,
+    "  },"
+  ].join("\n")).join("\n");
+  const schemaLiteral = JSON.stringify(PHASE_SUMMARY_SCHEMA, null, 2);
+  return `export const meta = {
+  name: ${JSON.stringify(opts.name)},
+  description: ${JSON.stringify(opts.description)},
+  phases: [
+${metaPhases}
+  ],
+}
+
+const PHASES = [
+${phaseLiterals}
+]
+
+const SUMMARY_SCHEMA = ${schemaLiteral}
+
+export default async function run(args) {
+  const runAttempt = (args && args.runAttempt) || 1
+  const results = []
+  for (const p of PHASES) {
+    const upstream = results
+      .map(r => 'Phase ' + r.id + ': ' + r.status + ' \u2014 ' + r.notes)
+      .join('\\n')
+    const basePrompt = p.prompt + '\\n\\nupstream_summaries: |\\n' + (upstream || '(none)')
+    const opts = { label: 'phase-' + p.id, phase: p.title, schema: SUMMARY_SCHEMA, agentType: 'phase-runner' }
+    const canceled = x => x !== null && typeof x === 'object' && typeof x.notes === 'string' && x.notes.includes('cancel-flag-detected')
+    let s = await agent(basePrompt, opts)
+    if ((s === null || s.status === 'failed') && !canceled(s)) {
+      // \u5931\u8D25\u5904\u7406\uFF1A1 \u6B21\u91CD\u8BD5\u3002label \u63BA runAttempt \u2192 resume \u540E\u65E7\u5931\u8D25\u7ED3\u679C\u5373\u4F7F\u88AB\u7F13\u5B58\u4E5F\u5F3A\u5236\u91CD\u6267\u884C
+      s = await agent(
+        basePrompt + '\\n\\nretry_reason: \u9996\u6B21\u5931\u8D25\u6216\u8FD4\u56DE null\uFF0C\u4EC5\u4FEE\u590D\u5931\u8D25\u70B9',
+        { ...opts, label: 'phase-' + p.id + '-retry-r' + runAttempt },
+      )
+    }
+    if (s === null || s.status === 'failed' || s.status === 'partial') {
+      results.push({
+        id: p.id,
+        status: s === null ? 'failed' : s.status,
+        notes: s === null ? 'agent returned null after retry' : s.notes,
+        escalated: true,
+      })
+      break // \u5347\u7EA7\u6682\u505C\uFF1A\u4E0D\u63A8\u8FDB\u4E0B\u6E38\uFF0C\u4E3B\u7EBF\u6536\u5C3E\u8D70 blocker \u8DEF\u5F84
+    }
+    results.push({ id: p.id, ...s }) // completed / degraded \u5747\u63A8\u8FDB
+  }
+  return { runAttempt, results }
+}
+`;
+}
+const VALID_SUMMARY_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "partial",
+  "failed",
+  "degraded"
+]);
+const REQUIRED_SUMMARY_FIELDS = [
+  "status",
+  "commit",
+  "tests",
+  "typecheck",
+  "handoff_taken",
+  "context_delta",
+  "notes"
+];
+function summaryFromWorkflowResult(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v))
+    throw new Error("workflow-autonomous: summary must be a plain object");
+  const o = v;
+  for (const f of REQUIRED_SUMMARY_FIELDS) {
+    if (o[f] === void 0 || o[f] === null)
+      throw new Error(`workflow-autonomous: summary missing required field: ${f}`);
+  }
+  const status = String(o.status);
+  if (!VALID_SUMMARY_STATUSES.has(status))
+    throw new Error(`workflow-autonomous: summary status "${status}" not one of completed|partial|failed|degraded`);
+  if (!Array.isArray(o.handoff_taken))
+    throw new Error("workflow-autonomous: summary handoff_taken must be an array");
+  const commitRaw = String(o.commit).trim();
+  const commit = commitRaw.toLowerCase() === "none" ? null : commitRaw.match(/[0-9a-f]{7,40}/i)?.[0] ?? null;
+  const testsRaw = String(o.tests);
+  let tests = null;
+  const m = testsRaw.match(/(\d+)\s*\/\s*(\d+)\s+passed(?:.*?delta\s+\+?(\d+))?/i);
+  if (m) {
+    tests = {
+      passed: Number(m[1]),
+      total: Number(m[2]),
+      delta: m[3] ? Number(m[3]) : 0
+    };
+  }
+  const typecheckRaw = String(o.typecheck).toLowerCase();
+  const typecheck = typecheckRaw === "pass" ? "pass" : typecheckRaw === "fail" ? "fail" : "unknown";
+  return {
+    status,
+    commit,
+    tests,
+    typecheck,
+    handoffTaken: o.handoff_taken.map((x) => String(x)).filter(Boolean),
+    contextDelta: String(o.context_delta),
+    notes: String(o.notes),
+    raw: JSON.stringify(v)
+  };
+}
+function decideMilestoneOutcome(results) {
+  let sawPartial = false;
+  for (const r of results) {
+    if (r.escalated === true || r.status === "failed")
+      return "escalated";
+    if (r.status === "partial")
+      sawPartial = true;
+  }
+  return sawPartial ? "partial" : "completed";
+}
+
+export { ALL_LAYERS, AUTO_CONVERGE_CAP, CONTEXT_BUDGET_THRESHOLD, DESCRIPTION_SOFT_LIMIT, ESCALATION_OPTIONS, FIX_LOG_RELATIVE_PATH, GATE_REGISTRY, LOCK_RETRY_ERRNOS, MAX_STATEMENT_CHARS, MAX_WAIT_MS, MIN_RATIONALE_CHARS, PHASE_SUMMARY_SCHEMA, RETRY_DELAY_MS, ROUTING_SCHEMA_VERSION, STALE_THRESHOLD_MS, STATE_RELATIVE_PATH, SUMMARY_TOKEN_BUDGET, TASKS_RELATIVE_PATH, acquireLock, aggregatePlans, appendFixLogEntry, archiveTask, auditSkillDescriptions, auditSkillsDirectory, auditTarballContents, batchByMaxConcurrent, bothPluginsInstalled, buildQualityPlan, buildTaskWaves, buildWaves, buildWorkflowScript, cascadeSkip, categorizeStatement, checkQuality, checkRequirementsCoverage, collectRegressionTests, collectSkills, completeTask, contextPath, convergeHistoryFromLog, createTask, decideConverge, decideFromSummaries, decideMilestoneOutcome, detectPlugin, detectPluginAvailability, estimateBriefLength, estimateTokens, extractCandidates, extractFrontmatter, extractPhaseRequirementIds, extractRequirementIds, flattenWaves, formatAsMarkdown, formatRequirementsCoverageReport, getActiveTask, getGateClassification, getTask, criticalFindings as interfaceAuditCriticals, hasBlockingFindings as interfaceAuditHasBlocking, majorFindings as interfaceAuditMajors, isLayer, isTerminalStatus, isTestFilePath, listTasks, loadConvergeHistory, lockPathFor, mergeSummary, mergeSummaryFields, parseChallengerSummary, parseDependsOn, parseFrontmatterFields, parseInterfaceAuditorReport, parseQualityFlag, parseRoadmap, parseRoleFlag, parseVerifyReport, phaseDir, planChallengerSpawns, planVerifyWave, planWavesForTier, projectStatePath, promptFilePath, readContext, readFixLog, readProjectState, readSummary, readSummaryFrontmatter, registerArtifact, registerArtifactForActiveTask, registerSpecEvolution, releaseLock, renderAuditMarkdown, renderPipelineReport, resolveFixLogPath, resolveQualityTier, resolveVerifyGateAction, routeSpecialist, runPipelineCheck, runPnpmPack, sampleAll, sampleHookSchema, samplePackageStructure, samplePluginList, sampleSkillList, sanitizePhase, sanitizeTaskId, schedule, serializeBriefForPrompt, splitWaveByFileOverlap, summarizeGroundTruth, summaryFromWorkflowResult, summaryPath, summaryTokenEstimate, syncProjectState, synthesizeRevisionFeedback, synthesizeVerifyFeedback, synthesizeVerifyResults, taskDir, taskJsonPath, tasksRoot, updateTask, validateTaskGraph, verifyAllCommandsIncluded, withLock, writeContext, writeProjectState, writeSummary };