ccgx-workflow 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2029 @@
+import { h as collectSkills } from './shared/ccgx-workflow.WgUzkiC3.mjs';
+export { j as changeLanguage, F as checkForUpdates, H as collectInvocableSkills, G as compareVersions, l as createDefaultConfig, m as createDefaultRouting, I as generateCommandContent, n as getCcgDir, o as getConfigPath, D as getCurrentVersion, E as getLatestVersion, q as getWorkflowById, p as getWorkflowConfigs, c as i18n, e as init, b as initI18n, x as installAceTool, y as installAceToolRs, J as installSkillCommands, t as installWorkflows, B as migrateToV1_4_0, C as needsMigration, K as parseFrontmatter, a as readCcgConfig, s as showMainMenu, A as uninstallAceTool, z as uninstallWorkflows, u as update, k as writeCcgConfig } from './shared/ccgx-workflow.WgUzkiC3.mjs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, statSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync } from 'node:child_process';
+import 'ansis';
+import 'inquirer';
+import 'ora';
+import 'node:util';
+import 'node:url';
+import 'pathe';
+import 'fs-extra';
+import 'smol-toml';
+import 'i18next';
+
+function phaseDir(workdir, phase) {
+  return join(workdir, ".context", sanitizePhase(phase));
+}
+function contextPath(workdir, phase) {
+  return join(phaseDir(workdir, phase), "CONTEXT.md");
+}
+function summaryPath(workdir, phase) {
+  return join(phaseDir(workdir, phase), "SUMMARY.md");
+}
+function sanitizePhase(phase) {
+  return phase.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function extractFrontmatter(content) {
+  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  return m ? m[1] : null;
+}
+function parseFrontmatterFields(yaml) {
+  const out = {};
+  const lines = yaml.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.trim() || line.trim().startsWith("#")) {
+      i += 1;
+      continue;
+    }
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/);
+    if (!match) {
+      throw new Error(`phase-context: malformed frontmatter line: ${line}`);
+    }
+    const key = match[1];
+    const rest = match[2].trim();
+    if (rest === "") {
+      const items = [];
+      i += 1;
+      while (i < lines.length && /^\s+-\s+/.test(lines[i])) {
+        items.push(unquote(lines[i].replace(/^\s+-\s+/, "").trim()));
+        i += 1;
+      }
+      out[key] = items;
+      continue;
+    }
+    if (rest.startsWith("[") && rest.endsWith("]")) {
+      const inner = rest.slice(1, -1).trim();
+      out[key] = inner ? inner.split(",").map((s) => unquote(s.trim())) : [];
+    } else if (rest === "true" || rest === "false") {
+      out[key] = rest === "true";
+    } else {
+      out[key] = unquote(rest);
+    }
+    i += 1;
+  }
+  return out;
+}
+function unquote(s) {
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function serializeScalar(value) {
+  if (/[:#\[\],&*!|>'"%@`]/.test(value) || value === "" || /^\s|\s$/.test(value)) {
+    return `"${value.replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
+function serializeList(values) {
+  if (values.length === 0)
+    return "[]";
+  return `[${values.map(serializeScalar).join(", ")}]`;
+}
+function writeContext(workdir, ctx) {
+  const target = contextPath(workdir, ctx.phase);
+  mkdirSync(dirname(target), { recursive: true });
+  const frontmatter = [
+    "---",
+    `phase: ${serializeScalar(ctx.phase)}`,
+    `plan: ${serializeScalar(ctx.plan)}`,
+    `goal: ${serializeScalar(ctx.goal)}`,
+    `decisions: ${serializeList(ctx.decisions)}`,
+    `constraints: ${serializeList(ctx.constraints)}`,
+    `files: ${serializeList(ctx.files)}`,
+    `created_at: ${serializeScalar(ctx.createdAt)}`,
+    "---",
+    ""
+  ].join("\n");
+  const body = [
+    `# Phase Context: ${ctx.phase}`,
+    "",
+    `**Plan**: ${ctx.plan}`,
+    `**Goal**: ${ctx.goal}`,
+    "",
+    "## Decisions (frozen)",
+    ...ctx.decisions.length ? ctx.decisions.map((d) => `- ${d}`) : ["_(none)_"],
+    "",
+    "## Constraints",
+    ...ctx.constraints.length ? ctx.constraints.map((c) => `- ${c}`) : ["_(none)_"],
+    "",
+    "## Files",
+    ...ctx.files.length ? ctx.files.map((f) => `- \`${f}\``) : ["_(none)_"],
+    ""
+  ].join("\n");
+  writeFileSync(target, frontmatter + body, "utf8");
+  return target;
+}
+function readContext(workdir, phase) {
+  const target = contextPath(workdir, phase);
+  if (!existsSync(target))
+    return null;
+  const content = readFileSync(target, "utf8");
+  const fm = extractFrontmatter(content);
+  if (!fm)
+    return null;
+  const fields = parseFrontmatterFields(fm);
+  return {
+    phase: String(fields.phase ?? phase),
+    plan: String(fields.plan ?? ""),
+    goal: String(fields.goal ?? ""),
+    decisions: toList(fields.decisions),
+    constraints: toList(fields.constraints),
+    files: toList(fields.files),
+    createdAt: String(fields.created_at ?? "")
+  };
+}
+function writeSummary(workdir, summary) {
+  const target = summaryPath(workdir, summary.phase);
+  mkdirSync(dirname(target), { recursive: true });
+  const frontmatter = [
+    "---",
+    `phase: ${serializeScalar(summary.phase)}`,
+    `plan: ${serializeScalar(summary.plan)}`,
+    `provides: ${serializeList(summary.provides)}`,
+    `affects: ${serializeList(summary.affects)}`,
+    `key_files: ${serializeList(summary.keyFiles)}`,
+    `completed: ${summary.completed ? "true" : "false"}`,
+    ...summary.completedAt ? [`completed_at: ${serializeScalar(summary.completedAt)}`] : [],
+    ...summary.notes ? [`notes: ${serializeScalar(summary.notes)}`] : [],
+    "---",
+    ""
+  ].join("\n");
+  const body = [
+    `# Phase Summary: ${summary.phase}`,
+    "",
+    `**Plan**: ${summary.plan}  `,
+    `**Status**: ${summary.completed ? "completed" : "in-progress"}`,
+    summary.completedAt ? `**Completed**: ${summary.completedAt}` : "",
+    "",
+    "## Provides",
+    ...summary.provides.length ? summary.provides.map((p) => `- ${p}`) : ["_(none)_"],
+    "",
+    "## Affects",
+    ...summary.affects.length ? summary.affects.map((a) => `- ${a}`) : ["_(none)_"],
+    "",
+    "## Key files",
+    ...summary.keyFiles.length ? summary.keyFiles.map((f) => `- \`${f}\``) : ["_(none)_"],
+    "",
+    summary.notes ? `## Notes
+
+${summary.notes}
+` : ""
+  ].filter(Boolean).join("\n");
+  writeFileSync(target, frontmatter + body, "utf8");
+  return target;
+}
+function readSummary(workdir, phase) {
+  const target = summaryPath(workdir, phase);
+  if (!existsSync(target))
+    return null;
+  const content = readFileSync(target, "utf8");
+  const fm = extractFrontmatter(content);
+  if (!fm)
+    return null;
+  const fields = parseFrontmatterFields(fm);
+  return {
+    phase: String(fields.phase ?? phase),
+    plan: String(fields.plan ?? ""),
+    provides: toList(fields.provides),
+    affects: toList(fields.affects),
+    keyFiles: toList(fields.key_files),
+    completed: fields.completed === true,
+    completedAt: fields.completed_at ? String(fields.completed_at) : void 0,
+    notes: fields.notes ? String(fields.notes) : void 0
+  };
+}
+function readSummaryFrontmatter(workdir, phase) {
+  const target = summaryPath(workdir, phase);
+  if (!existsSync(target))
+    return null;
+  const content = readFileSync(target, "utf8");
+  return extractFrontmatter(content);
+}
+function summaryTokenEstimate(frontmatter) {
+  return Math.ceil(frontmatter.length / 3.5);
+}
+function toList(value) {
+  if (Array.isArray(value))
+    return value.map(String);
+  if (typeof value === "string" && value)
+    return [value];
+  return [];
+}
+
+const PHASE_HEADER_RE = /^## Phase ([0-9]+(?:\.[0-9]+)?)\s*:\s*(.+?)\s*\(([a-z_]+)\)\s*$/;
+const DEPENDS_ON_RE = /^-\s+\*\*Depends on\*\*\s*:\s*(.+)$/;
+function parseRoadmap(content) {
+  const phases = [];
+  const lines = content.split(/\r?\n/);
+  let current = null;
+  const seen = /* @__PURE__ */ new Set();
+  const flushCurrent = () => {
+    if (current) {
+      if (seen.has(current.id))
+        throw new Error(`wave-scheduler: duplicate Phase ${current.id} declaration`);
+      seen.add(current.id);
+      phases.push(current);
+    }
+  };
+  for (const line of lines) {
+    const headerMatch = line.match(PHASE_HEADER_RE);
+    if (headerMatch) {
+      flushCurrent();
+      const [, id, name, statusRaw] = headerMatch;
+      if (!isPhaseStatus(statusRaw))
+        throw new Error(`wave-scheduler: Phase ${id} has illegal status "${statusRaw}"`);
+      current = {
+        id,
+        name: name.trim(),
+        status: statusRaw,
+        dependsOn: []
+      };
+      continue;
+    }
+    if (current) {
+      const depMatch = line.match(DEPENDS_ON_RE);
+      if (depMatch)
+        current.dependsOn = parseDependsOn(depMatch[1]);
+    }
+  }
+  flushCurrent();
+  return phases;
+}
+function parseDependsOn(raw) {
+  const trimmed = raw.trim().replace(/[。.]+$/, "");
+  if (!trimmed || /^\(none\)$/i.test(trimmed))
+    return [];
+  const out = [];
+  for (const tokenRaw of trimmed.split(",")) {
+    const token = tokenRaw.trim();
+    if (!token)
+      continue;
+    const rangeMatch = token.match(/^([0-9]+)\s*-\s*([0-9]+)$/);
+    if (rangeMatch) {
+      const lo = Number(rangeMatch[1]);
+      const hi = Number(rangeMatch[2]);
+      if (lo > hi)
+        throw new Error(`wave-scheduler: malformed range "${token}" (lo > hi)`);
+      for (let i = lo; i <= hi; i++)
+        out.push(String(i));
+      continue;
+    }
+    const phaseMatch = token.match(/^(?:Phase\s+)?([0-9]+(?:\.[0-9]+)?)$/i);
+    if (!phaseMatch)
+      throw new Error(`wave-scheduler: cannot parse depends-on token "${token}"`);
+    out.push(phaseMatch[1]);
+  }
+  return out;
+}
+function isPhaseStatus(s) {
+  return s === "pending" || s === "in_progress" || s === "completed" || s === "failed" || s === "skipped";
+}
+function buildWaves(phases) {
+  if (phases.length === 0)
+    return [];
+  const idToPhase = /* @__PURE__ */ new Map();
+  for (const p of phases)
+    idToPhase.set(p.id, p);
+  for (const p of phases) {
+    for (const dep of p.dependsOn) {
+      if (!idToPhase.has(dep))
+        throw new Error(`wave-scheduler: Phase ${p.id} depends on unknown Phase ${dep}`);
+    }
+  }
+  const remaining = new Set(phases.map((p) => p.id));
+  const remainingDeps = /* @__PURE__ */ new Map();
+  for (const p of phases)
+    remainingDeps.set(p.id, new Set(p.dependsOn));
+  const waves = [];
+  while (remaining.size > 0) {
+    const ready = [];
+    for (const p of phases) {
+      if (!remaining.has(p.id))
+        continue;
+      if ((remainingDeps.get(p.id)?.size ?? 0) === 0)
+        ready.push(p.id);
+    }
+    if (ready.length === 0) {
+      const stuck = Array.from(remaining).join(", ");
+      throw new Error(`wave-scheduler: dependency cycle detected among phases: ${stuck}`);
+    }
+    waves.push(ready);
+    for (const id of ready) {
+      remaining.delete(id);
+      for (const set of remainingDeps.values())
+        set.delete(id);
+    }
+  }
+  return waves;
+}
+function cascadeSkip(phases) {
+  const idToPhase = /* @__PURE__ */ new Map();
+  for (const p of phases)
+    idToPhase.set(p.id, p);
+  const blocked = /* @__PURE__ */ new Set();
+  for (const p of phases) {
+    if (p.status === "failed" || p.status === "skipped")
+      blocked.add(p.id);
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const p of phases) {
+      if (blocked.has(p.id))
+        continue;
+      for (const dep of p.dependsOn) {
+        if (blocked.has(dep)) {
+          blocked.add(p.id);
+          changed = true;
+          break;
+        }
+      }
+    }
+  }
+  const result = [];
+  for (const p of phases) {
+    if (blocked.has(p.id) && p.status !== "failed" && p.status !== "skipped")
+      result.push(p.id);
+  }
+  return result;
+}
+function batchByMaxConcurrent(wave, maxConcurrent) {
+  if (maxConcurrent < 1)
+    throw new Error(`wave-scheduler: maxConcurrent must be \u2265 1, got ${maxConcurrent}`);
+  if (wave.length === 0)
+    return [];
+  const batches = [];
+  for (let i = 0; i < wave.length; i += maxConcurrent)
+    batches.push(wave.slice(i, i + maxConcurrent));
+  return batches;
+}
+function schedule(phases, options = {}) {
+  const skipCompleted = options.skipCompleted ?? true;
+  const cascaded = cascadeSkip(phases);
+  const cascadedSet = new Set(cascaded);
+  const schedulable = phases.filter((p) => {
+    if (skipCompleted && p.status === "completed")
+      return false;
+    if (p.status === "failed" || p.status === "skipped")
+      return false;
+    if (cascadedSet.has(p.id))
+      return false;
+    return true;
+  });
+  const completedSet = new Set(
+    phases.filter((p) => p.status === "completed").map((p) => p.id)
+  );
+  const filtered = schedulable.map((p) => ({
+    ...p,
+    dependsOn: p.dependsOn.filter((d) => !completedSet.has(d))
+  }));
+  const droppedDeps = /* @__PURE__ */ new Set([...cascadedSet, ...phases.filter((p) => p.status === "failed" || p.status === "skipped").map((p) => p.id)]);
+  const finalPhases = filtered.map((p) => ({
+    ...p,
+    dependsOn: p.dependsOn.filter((d) => !droppedDeps.has(d))
+  }));
+  const waves = buildWaves(finalPhases);
+  let batches;
+  if (typeof options.maxConcurrent === "number") {
+    const cap = options.maxConcurrent;
+    batches = waves.map((w) => batchByMaxConcurrent(w, cap));
+  }
+  return { waves, skipped: cascaded, batches };
+}
+
+function rolePromptFile(role) {
+  switch (role) {
+    case "architect":
+      return "architect.md";
+    case "critic":
+      return "reviewer.md";
+    // reused with adversarial framing
+    case "implementer":
+      return null;
+    case "tester":
+      return "tester.md";
+    case "writer":
+      return null;
+  }
+}
+function routeSpecialist(role, layer) {
+  const adversarial = role === "critic";
+  const promptFile = rolePromptFile(role);
+  if (role === "writer") {
+    return {
+      models: ["claude"],
+      promptFiles: [null],
+      adversarial: false,
+      runnerDecides: false
+    };
+  }
+  if (role === "implementer") {
+    if (layer === "fullstack") {
+      return {
+        models: ["codex", "gemini"],
+        promptFiles: [null, null],
+        adversarial: false,
+        runnerDecides: true
+      };
+    }
+    return {
+      models: ["claude"],
+      promptFiles: [null],
+      adversarial: false,
+      runnerDecides: false
+    };
+  }
+  if (layer === "fullstack" && role === "tester") {
+    return {
+      models: ["codex", "gemini"],
+      promptFiles: [promptFile, promptFile],
+      adversarial: false,
+      runnerDecides: true
+    };
+  }
+  if (layer === "fullstack") {
+    return {
+      models: ["codex", "gemini"],
+      promptFiles: [promptFile, promptFile],
+      adversarial,
+      runnerDecides: false
+    };
+  }
+  if (layer === "backend") {
+    return {
+      models: ["codex"],
+      promptFiles: [promptFile],
+      adversarial,
+      runnerDecides: false
+    };
+  }
+  return {
+    models: ["gemini"],
+    promptFiles: [promptFile],
+    adversarial,
+    runnerDecides: false
+  };
+}
+function parseRoleFlag(args) {
+  const m = args.match(/--role[=\s]+([a-z]+)/i);
+  if (!m) return null;
+  const candidate = m[1].toLowerCase();
+  if (!["architect", "critic", "implementer", "tester", "writer"].includes(candidate)) {
+    return null;
+  }
+  return candidate;
+}
+function promptFilePath(model, promptFile) {
+  if (promptFile === null || model === "claude") return null;
+  return `~/.claude/.ccg/prompts/${model}/${promptFile}`;
+}
+
+const DESCRIPTION_SOFT_LIMIT = 80;
+const CONTEXT_BUDGET_THRESHOLD = 8e3;
+function auditSkillDescriptions(skills) {
+  const rows = skills.map((s) => ({
+    name: s.name,
+    category: s.category,
+    length: s.description.length,
+    overLimit: s.description.length > DESCRIPTION_SOFT_LIMIT,
+    description: s.description
+  }));
+  const totalLength = rows.reduce((sum, r) => sum + r.length, 0);
+  const overLimitCount = rows.filter((r) => r.overLimit).length;
+  return {
+    rows,
+    totalLength,
+    overLimitCount,
+    budgetExceeded: totalLength > CONTEXT_BUDGET_THRESHOLD,
+    budgetThreshold: CONTEXT_BUDGET_THRESHOLD
+  };
+}
+function auditSkillsDirectory(skillsDir) {
+  const skills = collectSkills(skillsDir);
+  return auditSkillDescriptions(skills);
+}
+function renderAuditMarkdown(report) {
+  const sorted = [...report.rows].sort((a, b) => b.length - a.length);
+  const lines = [];
+  lines.push("# Skill Description Audit");
+  lines.push("");
+  lines.push(
+    `> Soft limit: ${DESCRIPTION_SOFT_LIMIT} chars per description. Context budget threshold: ${report.budgetThreshold} chars (~1% of 200k token window).`
+  );
+  lines.push("");
+  lines.push(`- Total skills: **${report.rows.length}**`);
+  lines.push(`- Total description length: **${report.totalLength}** chars`);
+  lines.push(`- Over-limit skills: **${report.overLimitCount}**`);
+  lines.push(
+    `- Budget status: ${report.budgetExceeded ? "**EXCEEDED** \u26A0\uFE0F" : "within budget \u2705"}`
+  );
+  lines.push("");
+  lines.push("| Skill | Category | Length | Over Limit? |");
+  lines.push("|-------|----------|--------|-------------|");
+  for (const row of sorted) {
+    lines.push(
+      `| \`${row.name}\` | ${row.category} | ${row.length} | ${row.overLimit ? "\u26A0\uFE0F YES" : "no"} |`
+    );
+  }
+  if (report.budgetExceeded) {
+    lines.push("");
+    lines.push(
+      `> \u26A0\uFE0F Total description length exceeds 1% context budget threshold (${report.budgetThreshold} chars). Consider shortening over-limit descriptions while preserving trigger keywords.`
+    );
+  }
+  return lines.join("\n");
+}
+
+function planChallengerSpawns(input) {
+  if (!input.critical) {
+    return {
+      skipped: true,
+      skipReason: "phase not Critical (Critical: false or unset)",
+      spawns: [],
+      degraded: false
+    };
+  }
+  const desired = desiredAgentsForType(input.phaseType);
+  const spawns = [];
+  const dropped = [];
+  for (const agent of desired) {
+    if (agent === "codex:codex-rescue" && !input.plugins.codex) {
+      dropped.push(agent);
+      continue;
+    }
+    if (agent === "gemini:gemini-rescue" && !input.plugins.gemini) {
+      dropped.push(agent);
+      continue;
+    }
+    spawns.push({
+      agent,
+      adversarial: true,
+      rationale: rationaleFor(agent, input.phaseType)
+    });
+  }
+  const degraded = dropped.length > 0;
+  return {
+    skipped: false,
+    spawns,
+    degraded,
+    degradeNote: degraded ? `plugin(s) unavailable, dropped: ${dropped.join(", ")}; specialists only` : void 0
+  };
+}
+function desiredAgentsForType(type) {
+  switch (type) {
+    case "backend":
+      return ["codex:codex-rescue", "assumptions-analyzer"];
+    case "frontend":
+      return ["gemini:gemini-rescue", "nyquist-auditor"];
+    case "fullstack":
+      return [
+        "codex:codex-rescue",
+        "gemini:gemini-rescue",
+        "assumptions-analyzer",
+        "nyquist-auditor"
+      ];
+    case "docs":
+    case "generic":
+      return ["assumptions-analyzer"];
+  }
+}
+function rationaleFor(agent, type) {
+  switch (agent) {
+    case "codex:codex-rescue":
+      return `backend logic adversarial review (${type})`;
+    case "gemini:gemini-rescue":
+      return `frontend/UX adversarial review (${type})`;
+    case "assumptions-analyzer":
+      return "plan assumption audit (CCG specialist)";
+    case "nyquist-auditor":
+      return "boundary / edge-case deep audit (CCG specialist)";
+  }
+}
+function parseChallengerSummary(agent, text) {
+  const get = (key) => {
+    const re = new RegExp(`^\\s*${key}\\s*:\\s*(.+)$`, "mi");
+    const m = text.match(re);
+    return m ? m[1].trim() : null;
+  };
+  const statusRaw = get("STATUS");
+  if (!statusRaw) {
+    throw new Error(`challenger ${agent} summary missing required STATUS field`);
+  }
+  const statusLower = statusRaw.toLowerCase().split(/\s+/)[0];
+  const status = statusLower === "complete" || statusLower === "completed" ? "complete" : statusLower === "error" || statusLower === "failed" ? "error" : (() => {
+    throw new Error(
+      `challenger ${agent} summary STATUS=${statusRaw} not one of complete|error`
+    );
+  })();
+  const findingsRaw = get("FINDINGS");
+  const findings = findingsRaw ? parseFindings(findingsRaw) : [];
+  const notes = get("NOTES") ?? "";
+  return { agent, status, findings, notes, raw: text };
+}
+function parseFindings(raw) {
+  let trimmed = stripJsonFence(raw.trim());
+  const direct = tryParseJsonArray(trimmed);
+  if (direct !== null) return direct;
+  const normalized = normalizeQuotes(trimmed);
+  const secondTry = tryParseJsonArray(normalized);
+  if (secondTry !== null) return secondTry;
+  const blocks = splitTopLevelObjects(trimmed);
+  const findings = [];
+  for (const block of blocks) {
+    const parsedSingle = tryParseJsonObject(stripJsonFence(block)) ?? tryParseJsonObject(normalizeQuotes(block));
+    if (parsedSingle) {
+      const f2 = normalizeFinding(parsedSingle);
+      if (f2) findings.push(f2);
+      continue;
+    }
+    const f = extractFindingViaRegex(block);
+    if (f) findings.push(f);
+  }
+  return findings;
+}
+function stripJsonFence(s) {
+  const m = s.match(/^```(?:json|JSON)?\s*\n?([\s\S]*?)\n?```$/);
+  if (m) return m[1].trim();
+  const inline = s.match(/^```\s*([\s\S]*?)\s*```$/);
+  if (inline) return inline[1].trim();
+  return s;
+}
+function tryParseJsonArray(s) {
+  if (!s.startsWith("[")) return null;
+  try {
+    const parsed = JSON.parse(s);
+    if (Array.isArray(parsed)) {
+      return parsed.map(normalizeFinding).filter((f) => f !== null);
+    }
+  } catch {
+  }
+  return null;
+}
+function tryParseJsonObject(s) {
+  const t = s.trim();
+  if (!t.startsWith("{")) return null;
+  try {
+    const v = JSON.parse(t);
+    return typeof v === "object" && v !== null ? v : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeQuotes(s) {
+  let out = s.replace(/'/g, '"');
+  out = out.replace(/([{,]\s*)([a-zA-Z_][a-zA-Z0-9_]*)\s*:/g, '$1"$2":');
+  return out;
+}
+function splitTopLevelObjects(raw) {
+  const out = [];
+  let depth = 0;
+  let inString = null;
+  let escape = false;
+  let start = -1;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = ch;
+      continue;
+    }
+    if (ch === "{") {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0 && start >= 0) {
+        out.push(raw.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+  return out;
+}
+function extractFindingViaRegex(block) {
+  const sev = block.match(/severity\s*:\s*['"]?(critical|major|info)['"]?/i)?.[1]?.toLowerCase();
+  if (!sev) return null;
+  const cat = block.match(/category\s*:\s*['"]?([^,'"}\s]+)/i)?.[1] ?? "unknown";
+  const msg = block.match(/message\s*:\s*['"]([^'"]*)['"]/i)?.[1] ?? block.match(/message\s*:\s*([^,}]+)/i)?.[1]?.trim() ?? "";
+  return {
+    severity: sev,
+    category: cat.trim(),
+    message: msg.trim()
+  };
+}
+function normalizeFinding(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const r = raw;
+  const sev = String(r.severity ?? "").toLowerCase();
+  if (!["critical", "major", "info"].includes(sev)) return null;
+  return {
+    severity: sev,
+    category: String(r.category ?? "unknown").trim(),
+    message: String(r.message ?? "").trim()
+  };
+}
+function decideFromSummaries(summaries) {
+  if (summaries.length === 0) return "advance";
+  const hasError = summaries.some((s) => s.status === "error");
+  if (hasError) return "escalate";
+  const hasCritical = summaries.some(
+    (s) => s.findings.some((f) => f.severity === "critical")
+  );
+  if (hasCritical) return "revise";
+  return "advance";
+}
+function synthesizeRevisionFeedback(summaries) {
+  const critical = summaries.flatMap(
+    (s) => s.findings.filter((f) => f.severity === "critical").map((f) => ({ from: s.agent, ...f }))
+  );
+  if (critical.length === 0) return "";
+  const lines = [
+    "## Challenger \u53CD\u9988\uFF08critical \u5FC5\u4FEE\uFF09",
+    "",
+    "\u672C phase \u6807\u8BB0 Critical=true\uFF0C\u4E0B\u5217 critical findings \u5FC5\u987B\u5728\u4FEE\u8BA2\u8F6E\u5904\u7406\uFF1A",
+    "",
+    ...critical.map(
+      (c, i) => `${i + 1}. [${c.from}] (${c.category}) ${c.message}`
+    ),
+    "",
+    "\u4FEE\u8BA2\u8981\u6C42\uFF1A\u4EC5\u4FEE\u590D\u4E0A\u8FF0 critical \u9879\uFF0C\u4E0D\u91CD\u505A\u6574\u4E2A phase\uFF1B\u4FDD\u7559\u539F commit \u5386\u53F2\u3002"
+  ];
+  return lines.join("\n");
+}
+
+function pluginRoot(home = homedir()) {
+  return join(home, ".claude", "plugins");
+}
+const PLUGIN_MARKERS = ["SKILL.md", "plugin.json", "package.json", "manifest.json"];
+const PLUGIN_PREFIXES = {
+  codex: ["codex@", "codex-rescue@", "openai-codex@"],
+  gemini: ["gemini@", "gemini-rescue@", "google-gemini@"]
+};
+function detectPlugin(name, homeDir = homedir()) {
+  const root = pluginRoot(homeDir);
+  const probedPath = root;
+  if (!existsSync(root)) {
+    return { name, installed: false, probedPath, reason: "missing-dir" };
+  }
+  let entries = [];
+  try {
+    const { readdirSync } = require("node:fs");
+    entries = readdirSync(root);
+  } catch {
+    return { name, installed: false, probedPath, reason: "fs-error" };
+  }
+  const prefixes = PLUGIN_PREFIXES[name];
+  for (const entry of entries) {
+    const matchesPrefix = prefixes.some((p) => entry.startsWith(p));
+    if (!matchesPrefix) continue;
+    const dir = join(root, entry);
+    try {
+      if (!statSync(dir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    for (const marker of PLUGIN_MARKERS) {
+      const markerPath = join(dir, marker);
+      if (existsSync(markerPath)) {
+        return { name, installed: true, probedPath: dir };
+      }
+    }
+  }
+  return { name, installed: false, probedPath, reason: "missing-marker" };
+}
+function detectPluginAvailability(homeDir = homedir()) {
+  return {
+    codex: detectPlugin("codex", homeDir).installed,
+    gemini: detectPlugin("gemini", homeDir).installed
+  };
+}
+function bothPluginsInstalled(homeDir = homedir()) {
+  const avail = detectPluginAvailability(homeDir);
+  return avail.codex && avail.gemini;
+}
+
+const ALL_LAYERS = [
+  "backend",
+  "frontend",
+  "fullstack",
+  "docs",
+  "generic"
+];
+function isLayer(value) {
+  return typeof value === "string" && ALL_LAYERS.includes(value);
+}
+const ROUTING_SCHEMA_VERSION = "4.2.0";
+
+const CCG_PROMPT_BASE$1 = "~/.claude/.ccg/prompts";
+function buildBashDirectCommand(plugin) {
+  const vendor = plugin === "codex" ? "openai-codex" : "google-gemini";
+  const scriptName = `${plugin}-companion.mjs`;
+  return `node "$(ls ~/.claude/plugins/cache/${vendor}/${plugin}/*/scripts/${scriptName} | head -1)" task -p "<PROMPT>" --json`;
+}
+function planVerifyWave(tier, layer, plugins, options = {}) {
+  if (!["fast", "triple", "debate"].includes(tier)) {
+    throw new Error(`planVerifyWave: invalid tier "${tier}"`);
+  }
+  const useBashDirect = options.useDirectBashInvocation === true;
+  const dual = tier === "triple" || tier === "debate";
+  const spawns = [];
+  let degraded = false;
+  const dropped = [];
+  const pluginEntry = (plugin, rationale) => {
+    const base = {
+      agent: `${plugin}:${plugin}-rescue`,
+      rationale
+    };
+    if (useBashDirect) {
+      base.invocationMode = "bash-direct";
+      base.bashCommand = buildBashDirectCommand(plugin);
+    } else {
+      base.invocationMode = "agent";
+    }
+    return base;
+  };
+  if (dual) {
+    if (plugins.codex) {
+      spawns.push(pluginEntry("codex", "cross-vendor verify (codex)"));
+    } else {
+      spawns.push({
+        agent: "general-purpose",
+        rationale: "codex plugin unavailable \u2014 main-thread fallback (codex/reviewer prompt)",
+        ccgPromptFile: `${CCG_PROMPT_BASE$1}/codex/reviewer.md`
+      });
+      degraded = true;
+      dropped.push("codex:codex-rescue");
+    }
+    if (plugins.gemini) {
+      spawns.push(pluginEntry("gemini", "cross-vendor verify (gemini)"));
+    } else {
+      spawns.push({
+        agent: "general-purpose",
+        rationale: "gemini plugin unavailable \u2014 main-thread fallback (gemini/reviewer prompt)",
+        ccgPromptFile: `${CCG_PROMPT_BASE$1}/gemini/reviewer.md`
+      });
+      degraded = true;
+      dropped.push("gemini:gemini-rescue");
+    }
+  } else {
+    const preferred = layer === "frontend" ? "codex" : "gemini";
+    const fallback = preferred === "codex" ? "gemini" : "codex";
+    if (plugins[preferred]) {
+      spawns.push(pluginEntry(preferred, `cross-vendor verify (${preferred}, layer=${layer})`));
+    } else if (plugins[fallback]) {
+      spawns.push(pluginEntry(fallback, `verify fallback (${fallback}, preferred ${preferred} unavailable)`));
+      degraded = true;
+      dropped.push(`${preferred}:${preferred}-rescue`);
+    } else {
+      spawns.push({
+        agent: "general-purpose",
+        rationale: "both plugins unavailable \u2014 main-thread reviewer fallback",
+        ccgPromptFile: `${CCG_PROMPT_BASE$1}/claude/reviewer.md`
+      });
+      degraded = true;
+      dropped.push("codex:codex-rescue", "gemini:gemini-rescue");
+    }
+  }
+  return {
+    mode: dual ? "dual" : "single",
+    spawns,
+    degraded,
+    degradeNote: degraded ? `verify wave plugin(s) unavailable: ${dropped.join(", ")}` : void 0
+  };
+}
+function parseVerifyReport(agent, text) {
+  let raw;
+  try {
+    raw = parseChallengerSummary(agent, text);
+  } catch (e) {
+    return {
+      agent,
+      status: "error",
+      criticals: [],
+      majors: [],
+      notes: e instanceof Error ? e.message : String(e),
+      raw: text
+    };
+  }
+  const criticals = raw.findings.filter((f) => f.severity === "critical");
+  const majors = raw.findings.filter((f) => f.severity === "major");
+  return {
+    agent,
+    status: raw.status,
+    criticals,
+    majors,
+    notes: raw.notes,
+    raw: text
+  };
+}
+function synthesizeVerifyResults(reports) {
+  if (!Array.isArray(reports) || reports.length === 0) {
+    return "escalate";
+  }
+  const hasError = reports.some((r) => r.status === "error");
+  if (hasError) return "escalate";
+  const hasCritical = reports.some((r) => r.criticals.length > 0);
+  if (hasCritical) return "revise";
+  return "advance";
+}
+function synthesizeVerifyFeedback(reports) {
+  const critical = reports.flatMap(
+    (r) => r.criticals.map((f) => ({ from: r.agent, ...f }))
+  );
+  if (critical.length === 0) return "";
+  const lines = [
+    "## Verify \u53CD\u9988\uFF08critical \u5FC5\u4FEE\uFF09",
+    "",
+    "verify wave \u6807\u51FA\u4E0B\u5217 critical findings\uFF0C\u4FEE\u8BA2\u8F6E\u5FC5\u987B\u5904\u7406\uFF1A",
+    "",
+    ...critical.map(
+      (c, i) => `${i + 1}. [${c.from}] (${c.category}) ${c.message}`
+    ),
+    "",
+    "\u4FEE\u8BA2\u8981\u6C42\uFF1A\u4EC5\u4FEE\u590D\u4E0A\u8FF0 critical \u9879\uFF0C\u4E0D\u91CD\u505A\u6574\u4E2A phase\uFF1B\u4FDD\u7559\u539F commit \u5386\u53F2\u3002"
+  ];
+  return lines.join("\n");
+}
+
+const ALL_TIERS = ["fast", "triple", "debate"];
+const DEBATE_MAX_ROUNDS = 3;
+const CCG_PROMPT_BASE = "~/.claude/.ccg/prompts";
+function isQualityTier(v) {
+  return typeof v === "string" && ALL_TIERS.includes(v);
+}
+function parseQualityFlag(args) {
+  if (typeof args !== "string" || args.length === 0) return null;
+  const m = args.match(/--quality[=\s]+([a-z]+)/i);
+  if (!m) return null;
+  const candidate = m[1].toLowerCase();
+  return isQualityTier(candidate) ? candidate : null;
+}
+function resolveQualityTier(input) {
+  if (input.phaseQuality && isQualityTier(input.phaseQuality)) {
+    return { tier: input.phaseQuality, source: "phase-override" };
+  }
+  const flag = parseQualityFlag(input.cliArgs);
+  if (flag) {
+    return { tier: flag, source: "cli-flag" };
+  }
+  return { tier: "triple", source: "default" };
+}
+const PHASE_RUNNER_BUDGET_USD = {
+  fast: 1,
+  triple: 2,
+  debate: 5
+};
+function shellSingleQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function buildPhaseRunnerBashCommand(phase, _promptText, jobId, options = {}) {
+  const tier = options.tier ?? phase.quality ?? "triple";
+  if (!isQualityTier(tier)) {
+    throw new Error(`buildPhaseRunnerBashCommand: invalid tier "${tier}"`);
+  }
+  const budget = options.maxBudgetUsd ?? PHASE_RUNNER_BUDGET_USD[tier];
+  if (typeof budget !== "number" || budget <= 0 || !Number.isFinite(budget)) {
+    throw new Error(`buildPhaseRunnerBashCommand: invalid maxBudgetUsd ${budget}`);
+  }
+  const resolvedJobId = jobId ?? phase.jobId ?? "<JOB_ID>";
+  const resolvedWorkdir = options.workdir ?? phase.workdir ?? "<WORKDIR>";
+  const promptFile = options.promptFile ?? `.context/jobs/${resolvedJobId}/prompt.txt`;
+  const progressFile = `.context/jobs/${resolvedJobId}/progress.jsonl`;
+  const budgetStr = String(Number(budget.toFixed(4)));
+  const parts = [
+    `claude -p "$(cat ${shellSingleQuote(promptFile)})"`,
+    `--agent ccg/phase-runner`,
+    `--output-format stream-json`,
+    `--verbose`,
+    `--include-partial-messages`,
+    `--max-budget-usd ${budgetStr}`,
+    `--dangerously-skip-permissions`,
+    `--add-dir ${shellSingleQuote(resolvedWorkdir)}`,
+    `> ${shellSingleQuote(progressFile)} 2>&1`
+  ];
+  return parts.join(" ");
+}
+const DEFAULT_LAUNCHER_PATH = "~/.claude/.ccg/scripts/ccg-phase-runner-launcher.mjs";
+function buildPhaseRunnerLauncherCommand(phase, options = {}) {
+  const tier = options.tier ?? phase.quality ?? "triple";
+  if (!isQualityTier(tier)) {
+    throw new Error(`buildPhaseRunnerLauncherCommand: invalid tier "${tier}"`);
+  }
+  const resolvedJobId = options.jobId ?? phase.jobId ?? "<JOB_ID>";
+  const resolvedWorkdir = options.workdir ?? phase.workdir ?? "<WORKDIR>";
+  const promptFile = options.promptFile ?? `.context/jobs/${resolvedJobId}/prompt.txt`;
+  const progressFile = `.context/jobs/${resolvedJobId}/progress.jsonl`;
+  const launcher = options.launcherPath ?? DEFAULT_LAUNCHER_PATH;
+  const graceMs = options.graceMs ?? 5e3;
+  const parts = [
+    `node ${shellSingleQuote(launcher)}`,
+    `--job-id ${shellSingleQuote(resolvedJobId)}`,
+    `--workdir ${shellSingleQuote(resolvedWorkdir)}`,
+    `--prompt-file ${shellSingleQuote(promptFile)}`,
+    `--tier ${shellSingleQuote(tier)}`
+  ];
+  if (typeof options.maxBudgetUsd === "number" && Number.isFinite(options.maxBudgetUsd) && options.maxBudgetUsd > 0) {
+    parts.push(`--max-budget-usd ${String(Number(options.maxBudgetUsd.toFixed(4)))}`);
+  }
+  parts.push(`--grace-ms ${String(graceMs)}`);
+  parts.push(`> ${shellSingleQuote(progressFile)} 2>&1`);
+  return parts.join(" ");
+}
+function buildPlanWave(index, phase, plugins) {
+  const spawns = [];
+  let degraded = false;
+  const dropped = [];
+  if (plugins.codex) {
+    spawns.push({
+      agent: "codex:codex-rescue",
+      role: "planner",
+      rationale: `backend / system-design plan path (${phase.phaseType})`
+    });
+  } else {
+    spawns.push({
+      agent: "general-purpose",
+      role: "planner",
+      rationale: "codex plugin unavailable \u2014 main-thread fallback with codex/architect prompt",
+      ccgPromptFile: `${CCG_PROMPT_BASE}/codex/architect.md`
+    });
+    degraded = true;
+    dropped.push("codex:codex-rescue");
+  }
+  if (plugins.gemini) {
+    spawns.push({
+      agent: "gemini:gemini-rescue",
+      role: "planner",
+      rationale: `frontend / UX plan path (${phase.phaseType})`
+    });
+  } else {
+    spawns.push({
+      agent: "general-purpose",
+      role: "planner",
+      rationale: "gemini plugin unavailable \u2014 main-thread fallback with gemini/architect prompt",
+      ccgPromptFile: `${CCG_PROMPT_BASE}/gemini/architect.md`
+    });
+    degraded = true;
+    dropped.push("gemini:gemini-rescue");
+  }
+  spawns.push({
+    agent: "general-purpose",
+    role: "planner",
+    rationale: "claude opus 3rd-perspective plan (lateral diversity)",
+    ccgPromptFile: `${CCG_PROMPT_BASE}/claude/architect.md`
+  });
+  return {
+    kind: "plan",
+    index,
+    spawns,
+    degraded,
+    degradeNote: degraded ? `plan wave plugin(s) unavailable: ${dropped.join(", ")}; fallback to general-purpose` : void 0
+  };
+}
+function buildCriticWave(index, phase) {
+  const spawns = [
+    {
+      agent: "assumptions-analyzer",
+      role: "critic",
+      rationale: `assumption / hidden-dep audit (${phase.phaseType})`
+    },
+    {
+      agent: "nyquist-auditor",
+      role: "critic",
+      rationale: `boundary / edge-case audit (${phase.phaseType})`
+    }
+  ];
+  return { kind: "critic", index, spawns, degraded: false };
+}
+function buildImplWave(index, phase, options = {}) {
+  const useBashDirect = options.useDirectBashInvocation === true;
+  const useLauncher = useBashDirect && options.useLauncherWiring === true;
+  const entry = {
+    agent: "phase-runner",
+    role: "implementer",
+    rationale: `single strong implementer (${phase.phaseType}); consistency > diversity`
+  };
+  if (useBashDirect) {
+    entry.invocationMode = "bash-direct";
+    if (useLauncher) {
+      entry.bashCommand = buildPhaseRunnerLauncherCommand(phase, {
+        tier: options.tier
+      });
+    } else {
+      entry.bashCommand = buildPhaseRunnerBashCommand(phase, "", phase.jobId, {
+        tier: options.tier
+      });
+    }
+  }
+  return {
+    kind: "impl",
+    index,
+    spawns: [entry],
+    degraded: false
+  };
+}
+function verifyWavePlanToWavePlan(vwp, index) {
+  const spawns = vwp.spawns.map((s) => ({
+    agent: s.agent,
+    role: "verifier",
+    rationale: s.rationale,
+    ccgPromptFile: s.ccgPromptFile,
+    // v4.4.2: 透传 invocationMode/bashCommand（之前 adapter drop 这两字段，
+    // 导致 useDirectBashInvocation 仅对直接调 planVerifyWave 的路径生效；
+    // autonomous Step 4.1 走 quality-router 路径时 silent fallback 风险残留）
+    invocationMode: s.invocationMode,
+    bashCommand: s.bashCommand
+  }));
+  return {
+    kind: "verify",
+    index,
+    spawns,
+    degraded: vwp.degraded,
+    degradeNote: vwp.degradeNote
+  };
+}
+function buildVerifyWave(index, phase, plugins, tier) {
+  const vwp = planVerifyWave(tier, phase.phaseType, plugins, {
+    useDirectBashInvocation: true
+  });
+  const wavePlan = verifyWavePlanToWavePlan(vwp, index);
+  if (tier === "triple" || tier === "debate") {
+    wavePlan.spawns.push({
+      agent: "interface-auditor",
+      role: "verifier",
+      rationale: `cross-phase interface audit (${phase.phaseType}; SSoT / leftover / magic-string / commit-drift / mock-drift)`
+    });
+  }
+  return wavePlan;
+}
+function buildDebateRound(index, round, phase, plugins) {
+  const cycle = (round - 1) % 3;
+  const kind = cycle === 0 ? "propose" : cycle === 1 ? "challenge" : "respond";
+  const layer = phase.phaseType;
+  const proposerSide = layer === "backend" ? ["codex"] : layer === "frontend" ? ["gemini"] : ["codex", "gemini"];
+  const challengerSide = layer === "backend" ? ["gemini"] : layer === "frontend" ? ["codex"] : ["codex", "gemini"];
+  const rawModels = kind === "challenge" ? challengerSide : proposerSide;
+  const promptName = kind === "challenge" ? "reviewer.md" : "architect.md";
+  const spawns = [];
+  let degraded = false;
+  const dropped = [];
+  for (const m of rawModels) {
+    if (plugins[m]) {
+      spawns.push({
+        agent: `${m}:${m}-rescue`,
+        role: "debater",
+        rationale: `debate r${round} ${kind} (${m})`
+      });
+    } else {
+      spawns.push({
+        agent: "general-purpose",
+        role: "debater",
+        rationale: `${m} plugin unavailable \u2014 main-thread fallback (debate r${round} ${kind})`,
+        ccgPromptFile: `${CCG_PROMPT_BASE}/${m}/${promptName}`
+      });
+      degraded = true;
+      dropped.push(`${m}:${m}-rescue`);
+    }
+  }
+  return {
+    kind: "debate",
+    index,
+    round,
+    spawns,
+    degraded,
+    degradeNote: degraded ? `debate r${round} plugin(s) unavailable: ${dropped.join(", ")}` : void 0
+  };
+}
+function planWavesForTier(tier, phase, plugins, options = {}) {
+  if (!isQualityTier(tier)) {
+    throw new Error(`planWavesForTier: invalid tier "${tier}"`);
+  }
+  const bothMissing = !plugins.codex && !plugins.gemini;
+  let effective = tier;
+  let degradedTo;
+  let degradeNote;
+  if (tier === "debate" && bothMissing) {
+    effective = "fast";
+    degradedTo = "fast";
+    degradeNote = "debate \u2192 fast: both plugins unavailable; debate loses lateral diversity";
+  } else if (tier === "debate" && (!plugins.codex || !plugins.gemini)) {
+    effective = "triple";
+    degradedTo = "triple";
+    degradeNote = "debate \u2192 triple: one plugin unavailable; debate needs both for adversarial pairing";
+  } else if (tier === "triple" && bothMissing) {
+    effective = "fast";
+    degradedTo = "fast";
+    degradeNote = "triple \u2192 fast: both plugins unavailable; plan/verify diversity collapsed";
+  }
+  const waves = [];
+  let waveIdx = 1;
+  const implOpts = {
+    useDirectBashInvocation: options.useDirectBashInvocation === true,
+    useLauncherWiring: options.useLauncherWiring === true,
+    tier: effective
+  };
+  switch (effective) {
+    case "fast":
+      waves.push(buildImplWave(waveIdx++, phase, implOpts));
+      waves.push(buildVerifyWave(waveIdx++, phase, plugins, "fast"));
+      break;
+    case "triple":
+      waves.push(buildPlanWave(waveIdx++, phase, plugins));
+      waves.push(buildCriticWave(waveIdx++, phase));
+      waves.push(buildImplWave(waveIdx++, phase, implOpts));
+      waves.push(buildVerifyWave(waveIdx++, phase, plugins, "triple"));
+      break;
+    case "debate": {
+      waves.push(buildPlanWave(waveIdx++, phase, plugins));
+      for (let r = 1; r <= DEBATE_MAX_ROUNDS; r++) {
+        waves.push(buildDebateRound(waveIdx++, r, phase, plugins));
+      }
+      waves.push(buildCriticWave(waveIdx++, phase));
+      waves.push(buildImplWave(waveIdx++, phase, implOpts));
+      waves.push(buildVerifyWave(waveIdx++, phase, plugins, "debate"));
+      break;
+    }
+  }
+  const anyWaveDegraded = waves.some((w) => w.degraded);
+  const tierDegraded = degradedTo !== void 0;
+  return {
+    effectiveTier: effective,
+    waves,
+    degraded: tierDegraded || anyWaveDegraded,
+    degradedTo,
+    degradeNote
+  };
+}
+function buildQualityPlan(resolveInput, phase, plugins, options = {}) {
+  const { tier, source } = resolveQualityTier({
+    cliArgs: resolveInput.cliArgs,
+    phaseQuality: phase.quality ?? resolveInput.phaseQuality
+  });
+  const planResult = planWavesForTier(tier, phase, plugins, options);
+  return {
+    tier,
+    source,
+    waves: planResult.waves,
+    degraded: planResult.degraded,
+    degradedTo: planResult.degradedTo,
+    degradeNote: planResult.degradeNote
+  };
+}
+
+const SIMILARITY_THRESHOLD = 0.7;
+const MIN_BULLET_LEN = 8;
+const HIGH_STAKES_KEYWORDS = [
+  "\u67B6\u6784",
+  "\u7834\u574F",
+  "\u7834\u574F\u6027",
+  "\u5B89\u5168",
+  "schema",
+  "\u8FC1\u79FB",
+  "migration",
+  "breaking",
+  "security",
+  "architecture",
+  "auth",
+  "data loss",
+  "\u6570\u636E\u4E22\u5931",
+  "\u4E0D\u517C\u5BB9"
+];
+const MIN_SHARED_TOKENS = 2;
+const BRIEF_MAX_TOKENS = 500;
+function splitIntoBullets(text) {
+  if (typeof text !== "string" || text.trim().length === 0) return [];
+  const lines = text.split(/\r?\n/);
+  const bullets = [];
+  let buffer = [];
+  const flush = () => {
+    const joined = buffer.join(" ").trim();
+    if (joined.length >= MIN_BULLET_LEN) bullets.push(joined);
+    buffer = [];
+  };
+  let hasExplicitBullet = false;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (line.length === 0) {
+      flush();
+      continue;
+    }
+    const bulletMatch = line.match(/^(?:[-*+•]|\d+[.)])\s+(.+)$/);
+    if (bulletMatch) {
+      hasExplicitBullet = true;
+      flush();
+      buffer.push(bulletMatch[1].trim());
+    } else {
+      buffer.push(line);
+    }
+  }
+  flush();
+  if (hasExplicitBullet) return bullets;
+  const fallback = [];
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (line.length >= MIN_BULLET_LEN) fallback.push(line);
+  }
+  return fallback;
+}
+function normalizeBullet(s) {
+  return s.toLowerCase().replace(/[，。、：；！？,.:;!?'"`()（）【】\[\]{}<>]/g, " ").replace(/\s+/g, " ").replace(/\b(the|a|an|and|or|of|to|in|for|is|are)\b/g, " ").replace(/[的了和与及之而]/g, " ").replace(/\s+/g, " ").trim();
+}
+function similarity(a, b) {
+  const tokensA = tokenize(a);
+  const tokensB = tokenize(b);
+  if (tokensA.size === 0 || tokensB.size === 0) return 0;
+  let intersect = 0;
+  for (const t of tokensA) {
+    if (tokensB.has(t)) intersect++;
+  }
+  const union = tokensA.size + tokensB.size - intersect;
+  return union === 0 ? 0 : intersect / union;
+}
+function tokenize(s) {
+  const out = /* @__PURE__ */ new Set();
+  const words = s.match(/[a-z0-9]+/g) ?? [];
+  for (const w of words) {
+    if (w.length >= 2) out.add(w);
+  }
+  const chineseChars = s.match(/[一-鿿]/g) ?? [];
+  for (const c of chineseChars) out.add(c);
+  return out;
+}
+function flattenContributions(contributions) {
+  const bullets = [];
+  const warnings = [];
+  for (const c of contributions) {
+    if (typeof c.plan !== "string" || c.plan.trim().length === 0) {
+      warnings.push(`plan from ${c.model} empty or non-string; skipped`);
+      continue;
+    }
+    const items = splitIntoBullets(c.plan);
+    if (items.length === 0) {
+      warnings.push(`plan from ${c.model} produced no parseable bullets; skipped`);
+      continue;
+    }
+    for (const b of items) {
+      const norm = normalizeBullet(b);
+      if (norm.length === 0) continue;
+      bullets.push({ source: c.model, raw: b, norm });
+    }
+  }
+  return { bullets, warnings };
+}
+function extractConsensus(bullets) {
+  const consensus = [];
+  const consumed = /* @__PURE__ */ new Set();
+  for (let i = 0; i < bullets.length; i++) {
+    if (consumed.has(i)) continue;
+    const cluster = [i];
+    const sources = /* @__PURE__ */ new Set([bullets[i].source]);
+    for (let j = i + 1; j < bullets.length; j++) {
+      if (consumed.has(j)) continue;
+      const sim = similarity(bullets[i].norm, bullets[j].norm);
+      if (sim >= SIMILARITY_THRESHOLD) {
+        cluster.push(j);
+        sources.add(bullets[j].source);
+      }
+    }
+    if (sources.size >= 2) {
+      for (const idx of cluster) consumed.add(idx);
+      consensus.push(bullets[i].raw);
+    }
+  }
+  return { consensus, consumedIndices: consumed };
+}
+function extractDivergences(bullets, consumed) {
+  const remaining = bullets.map((b, i) => ({ ...b, idx: i, tokens: tokenize(b.norm) })).filter((b) => !consumed.has(b.idx));
+  if (remaining.length === 0) return [];
+  const parent = remaining.map((_, i) => i);
+  const find = (x) => {
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  for (let i = 0; i < remaining.length; i++) {
+    for (let j = i + 1; j < remaining.length; j++) {
+      if (remaining[i].source === remaining[j].source) continue;
+      const shared = countSharedTokens(remaining[i].tokens, remaining[j].tokens);
+      if (shared >= MIN_SHARED_TOKENS) {
+        union(i, j);
+      }
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < remaining.length; i++) {
+    const root = find(i);
+    const arr = groups.get(root) ?? [];
+    arr.push(remaining[i]);
+    groups.set(root, arr);
+  }
+  const divergences = [];
+  const seenRoots = /* @__PURE__ */ new Set();
+  for (let i = 0; i < remaining.length; i++) {
+    const root = find(i);
+    if (seenRoots.has(root)) continue;
+    seenRoots.add(root);
+    const group = groups.get(root);
+    divergences.push({
+      topic: group[0].raw.slice(0, 60),
+      options: group.map((g) => ({ from: g.source, option: g.raw }))
+    });
+  }
+  return divergences;
+}
+function countSharedTokens(a, b) {
+  let n = 0;
+  for (const t of a) {
+    if (b.has(t)) n++;
+  }
+  return n;
+}
+function extractDecisionRequired(divergences) {
+  const required = [];
+  for (const d of divergences) {
+    const lower = d.topic.toLowerCase();
+    const hit = HIGH_STAKES_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()));
+    if (hit) required.push(d.topic);
+  }
+  return required;
+}
+function aggregatePlans(contributions) {
+  if (!Array.isArray(contributions)) {
+    throw new Error("aggregatePlans: contributions must be array");
+  }
+  if (contributions.length === 0) {
+    return {
+      consensus: [],
+      divergences: [],
+      decision_required: [],
+      warnings: ["no plan contributions"]
+    };
+  }
+  const { bullets, warnings } = flattenContributions(contributions);
+  if (bullets.length === 0) {
+    return {
+      consensus: [],
+      divergences: [],
+      decision_required: [],
+      warnings: [...warnings, "no parseable bullets across all contributions"]
+    };
+  }
+  const { consensus, consumedIndices } = extractConsensus(bullets);
+  const divergences = extractDivergences(bullets, consumedIndices);
+  const decision_required = extractDecisionRequired(divergences);
+  return { consensus, divergences, decision_required, warnings };
+}
+function estimateTokens(text) {
+  if (typeof text !== "string" || text.length === 0) return 0;
+  let tokens = 0;
+  const englishWords = text.match(/[a-zA-Z]+/g) ?? [];
+  for (const w of englishWords) {
+    tokens += w.length <= 5 ? 1 : Math.max(1, Math.round(w.length / 4));
+  }
+  const chineseChars = text.match(/[一-鿿]/g) ?? [];
+  tokens += chineseChars.length;
+  const otherCharCount = text.replace(/[a-zA-Z]+/g, "").replace(/[一-鿿]/g, "").length;
+  tokens += Math.ceil(otherCharCount * 0.3);
+  return Math.ceil(tokens);
+}
+function serializeBriefForPrompt(brief) {
+  const lines = [];
+  lines.push("## Design Brief\uFF08plan wave \u7EFC\u5408\uFF09");
+  lines.push("");
+  if (brief.consensus.length > 0) {
+    lines.push("### \u5171\u8BC6\u8981\u70B9");
+    for (const c of brief.consensus) lines.push(`- ${truncate(c, 120)}`);
+    lines.push("");
+  }
+  if (brief.divergences.length > 0) {
+    lines.push("### \u5206\u6B67\u4E3B\u9898");
+    for (const d of brief.divergences) {
+      lines.push(`- **${truncate(d.topic, 60)}**`);
+      for (const opt of d.options) {
+        lines.push(`  - [${opt.from}] ${truncate(opt.option, 100)}`);
+      }
+    }
+    lines.push("");
+  }
+  if (brief.decision_required.length > 0) {
+    lines.push("### \u5FC5\u51B3\u7B56\u70B9\uFF08high-stakes\uFF0C\u4E3B\u7EBF / \u7528\u6237\u88C1\u5B9A\uFF09");
+    for (const r of brief.decision_required) lines.push(`- ${truncate(r, 80)}`);
+    lines.push("");
+  }
+  if (brief.warnings.length > 0) {
+    lines.push("### \u89E3\u6790\u544A\u8B66");
+    for (const w of brief.warnings) lines.push(`- ${truncate(w, 100)}`);
+  }
+  let out = lines.join("\n").trim();
+  if (estimateTokens(out) > BRIEF_MAX_TOKENS) {
+    let lo = 0;
+    let hi = out.length;
+    const marker = "\n...(truncated)";
+    const markerTokens = estimateTokens(marker);
+    const budget = BRIEF_MAX_TOKENS - markerTokens;
+    while (lo < hi) {
+      const mid = Math.ceil((lo + hi) / 2);
+      if (estimateTokens(out.slice(0, mid)) <= budget) lo = mid;
+      else hi = mid - 1;
+    }
+    out = out.slice(0, lo) + marker;
+  }
+  return out;
+}
+function truncate(s, n) {
+  if (typeof s !== "string") return "";
+  return s.length <= n ? s : s.slice(0, n - 3) + "...";
+}
+function estimateBriefLength(brief) {
+  return estimateTokens(serializeBriefForPrompt(brief));
+}
+
+function runPnpmPack(workdir) {
+  const out = execSync("pnpm pack", {
+    cwd: workdir,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const lines = out.trim().split(/\r?\n/).filter((l) => l.trim().length > 0);
+  if (lines.length === 0) {
+    throw new Error("pnpm pack produced no output");
+  }
+  const tarballName = lines[lines.length - 1].trim();
+  if (!tarballName.endsWith(".tgz")) {
+    throw new Error(`pnpm pack last line is not a tgz: "${tarballName}"`);
+  }
+  return join(workdir, tarballName);
+}
+function auditTarballContents(tarballPath) {
+  const out = execSync(`tar -tzf "${tarballPath}"`, {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return out.trim().split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+}
+function verifyAllCommandsIncluded(workdir, tarballEntries) {
+  const result = {
+    packageFiles: [],
+    actualCommands: [],
+    missingInPackageJson: [],
+    missingInTarball: []
+  };
+  const pkgPath = join(workdir, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (Array.isArray(pkg.files)) result.packageFiles = pkg.files;
+    } catch {
+    }
+  }
+  const cmdDir = join(workdir, "templates", "commands");
+  if (existsSync(cmdDir)) {
+    const files = readdirSync(cmdDir).filter((f) => f.endsWith(".md"));
+    result.actualCommands = files.map((f) => `templates/commands/${f}`);
+  }
+  for (const cmd of result.actualCommands) {
+    const matched = result.packageFiles.some((entry) => {
+      if (entry === cmd) return true;
+      if (entry.endsWith("/") && cmd.startsWith(entry)) return true;
+      if (cmd.startsWith(entry + "/")) return true;
+      return false;
+    });
+    if (!matched) result.missingInPackageJson.push(cmd);
+  }
+  if (tarballEntries) {
+    const tarballSet = new Set(
+      tarballEntries.map((e) => e.replace(/^package\//, "")).filter((e) => e.startsWith("templates/commands/") && e.endsWith(".md"))
+    );
+    for (const cmd of result.actualCommands) {
+      if (!tarballSet.has(cmd)) result.missingInTarball.push(cmd);
+    }
+  }
+  return result;
+}
+function runPipelineCheck(opts = {}) {
+  const workdir = opts.workdir ?? process.cwd();
+  const doPnpmPack = opts.doPnpmPack ?? true;
+  const errors = [];
+  const warnings = [];
+  let tarballPath;
+  let tarballEntries;
+  if (doPnpmPack) {
+    try {
+      tarballPath = runPnpmPack(workdir);
+    } catch (e) {
+      errors.push({
+        category: "pack-failed",
+        message: "pnpm pack \u5931\u8D25 \u2014 \u53EF\u80FD\u662F build \u9519\u6216 pnpm \u672A\u88C5",
+        detail: e instanceof Error ? e.message : String(e)
+      });
+    }
+    if (tarballPath) {
+      try {
+        tarballEntries = auditTarballContents(tarballPath);
+      } catch (e) {
+        errors.push({
+          category: "tar-extract-failed",
+          message: "tar -tzf \u5931\u8D25 \u2014 \u53EF\u80FD\u662F tar \u5DE5\u5177\u672A\u88C5\u6216 tarball \u635F\u574F",
+          detail: e instanceof Error ? e.message : String(e)
+        });
+      }
+    }
+  }
+  const verifyResult = verifyAllCommandsIncluded(workdir, tarballEntries);
+  if (verifyResult.packageFiles.length === 0) {
+    const pkgPath = join(workdir, "package.json");
+    if (!existsSync(pkgPath)) {
+      errors.push({
+        category: "package-json-missing",
+        message: `package.json \u4E0D\u5B58\u5728: ${pkgPath}`
+      });
+    } else {
+      errors.push({
+        category: "package-json-invalid",
+        message: "package.json `files` \u6570\u7EC4\u4E3A\u7A7A\u6216\u89E3\u6790\u5931\u8D25"
+      });
+    }
+  }
+  if (verifyResult.missingInPackageJson.length > 0) {
+    const list = verifyResult.missingInPackageJson;
+    errors.push({
+      category: "missing-from-tarball",
+      message: `${list.length} \u4E2A templates/commands/*.md \u6587\u4EF6\u5B58\u5728\u4F46 package.json files \u6F0F\u5217\uFF08\u8FD9\u662F v4.2.0 debate.md \u6F0F register \u540C\u7C7B\u578B\u4E8B\u6545\uFF09\uFF1A${list.slice(0, 5).join(", ")}${list.length > 5 ? `, ...\u8FD8\u6709 ${list.length - 5} \u4E2A` : ""}`,
+      detail: list.join("\n")
+    });
+  }
+  if (verifyResult.missingInTarball.length > 0) {
+    const list = verifyResult.missingInTarball;
+    errors.push({
+      category: "missing-from-tarball",
+      message: `${list.length} \u4E2A templates/commands/*.md \u6587\u4EF6\u5B58\u5728\u4F46 tarball \u5B9E\u9645\u672A\u6253\u5305\uFF1A${list.slice(0, 5).join(", ")}${list.length > 5 ? `, ...\u8FD8\u6709 ${list.length - 5} \u4E2A` : ""}`,
+      detail: list.join("\n")
+    });
+  }
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    tarballPath,
+    tarballEntries,
+    missingFromPackageJson: verifyResult.missingInPackageJson
+  };
+}
+function renderPipelineReport(report) {
+  const lines = [];
+  lines.push(`## Pipeline Check ${report.ok ? "\u2705" : "\u274C"}`);
+  lines.push("");
+  if (report.tarballPath) {
+    lines.push(`- Tarball: \`${report.tarballPath}\``);
+  }
+  if (report.tarballEntries) {
+    lines.push(`- Tarball \u542B ${report.tarballEntries.length} \u6587\u4EF6`);
+  }
+  lines.push("");
+  if (report.errors.length > 0) {
+    lines.push("### \u274C Errors");
+    for (const err of report.errors) {
+      lines.push(`- [${err.category}] ${err.message}`);
+    }
+    lines.push("");
+  }
+  if (report.warnings.length > 0) {
+    lines.push("### \u26A0\uFE0F Warnings");
+    for (const w of report.warnings) lines.push(`- ${w}`);
+    lines.push("");
+  }
+  if (report.ok) {
+    lines.push("All checks passed. Tarball \u5185\u5BB9\u8DDF templates/commands/ \u4E00\u81F4\u3002");
+  }
+  return lines.join("\n");
+}
+
+const KNOWN_SUBAGENT_HINTS = {
+  codex: ["codex:codex-rescue", "codex:setup"],
+  gemini: ["gemini:gemini-rescue", "gemini:setup"],
+  "frontend-design": ["frontend-design:frontend-design"],
+  "code-review": ["code-review:code-review"]
+};
+function shortNameOf(pluginKey) {
+  const at = pluginKey.indexOf("@");
+  return at > 0 ? pluginKey.slice(0, at) : pluginKey;
+}
+function samplePluginList(homeDir = homedir()) {
+  const warnings = [];
+  const path = join(homeDir, ".claude", "plugins", "installed_plugins.json");
+  if (!existsSync(path)) {
+    return { plugins: [], warnings: [`installed_plugins.json not found at ${path}`] };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (e) {
+    warnings.push(`installed_plugins.json parse failed: ${e instanceof Error ? e.message : String(e)}`);
+    return { plugins: [], warnings };
+  }
+  if (!raw?.plugins || typeof raw.plugins !== "object") {
+    warnings.push("installed_plugins.json missing `plugins` object");
+    return { plugins: [], warnings };
+  }
+  const out = [];
+  for (const [name, instances] of Object.entries(raw.plugins)) {
+    if (!Array.isArray(instances) || instances.length === 0) continue;
+    const inst = instances[0];
+    const shortName = shortNameOf(name);
+    out.push({
+      name,
+      shortName,
+      version: typeof inst?.version === "string" ? inst.version : "unknown",
+      installPath: typeof inst?.installPath === "string" ? inst.installPath : void 0,
+      subagentTypeHints: KNOWN_SUBAGENT_HINTS[shortName]
+    });
+  }
+  return { plugins: out, warnings };
+}
+function inferSkillCategory(relPath) {
+  if (relPath.includes("/tools/") || relPath.startsWith("tools/")) return "tool";
+  if (relPath.includes("/domains/") || relPath.startsWith("domains/")) return "domain";
+  if (relPath.includes("/impeccable/") || relPath.startsWith("impeccable/")) return "impeccable";
+  if (relPath.includes("/orchestration/") || relPath.startsWith("orchestration/")) return "orchestration";
+  return "unknown";
+}
+const SKILL_FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+function parseFrontmatterField(fm, key) {
+  const re = new RegExp(`^\\s*${key}\\s*:\\s*(.+)$`, "mi");
+  const m = fm.match(re);
+  if (!m) return void 0;
+  return m[1].trim().replace(/^["']|["']$/g, "");
+}
+function walkSkills(baseDir, currentDir, out, warnings) {
+  let entries;
+  try {
+    entries = readdirSync(currentDir);
+  } catch (e) {
+    warnings.push(`readdir failed at ${currentDir}: ${e instanceof Error ? e.message : String(e)}`);
+    return;
+  }
+  for (const entry of entries) {
+    const full = join(currentDir, entry);
+    let stat;
+    try {
+      stat = statSync(full);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      walkSkills(baseDir, full, out, warnings);
+      continue;
+    }
+    if (entry !== "SKILL.md") continue;
+    let content;
+    try {
+      content = readFileSync(full, "utf-8");
+    } catch {
+      continue;
+    }
+    const fmMatch = content.match(SKILL_FRONTMATTER_RE);
+    if (!fmMatch) continue;
+    const fm = fmMatch[1];
+    const name = parseFrontmatterField(fm, "name");
+    const invocableRaw = parseFrontmatterField(fm, "user-invocable");
+    if (!name) continue;
+    const relPath = full.slice(baseDir.length + 1).replace(/\\/g, "/");
+    out.push({
+      name,
+      path: full,
+      userInvocable: invocableRaw === "true",
+      category: inferSkillCategory(relPath)
+    });
+  }
+}
+function sampleSkillList(homeDir = homedir()) {
+  const warnings = [];
+  const root = join(homeDir, ".claude", "skills", "ccg");
+  if (!existsSync(root)) {
+    return { skills: [], warnings: [`skills/ccg/ not found at ${root}`] };
+  }
+  const out = [];
+  walkSkills(root, root, out, warnings);
+  const seen = /* @__PURE__ */ new Set();
+  const dedup = out.filter((s) => {
+    const key = `${s.name}\0${s.path}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  return { skills: dedup, warnings };
+}
+function classifyMatcher(matcher) {
+  if (matcher === void 0) return "absent";
+  if (matcher === null) return "null";
+  if (typeof matcher === "string") return "string";
+  if (Array.isArray(matcher)) return "array";
+  if (typeof matcher === "object") return "object";
+  return "other";
+}
+function sampleHookSchema(homeDir = homedir()) {
+  const warnings = [];
+  const path = join(homeDir, ".claude", "settings.json");
+  if (!existsSync(path)) {
+    return { hooks: [], warnings: [`settings.json not found at ${path}`] };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (e) {
+    warnings.push(`settings.json parse failed: ${e instanceof Error ? e.message : String(e)}`);
+    return { hooks: [], warnings };
+  }
+  const hooksObj = raw?.hooks;
+  if (!hooksObj || typeof hooksObj !== "object") {
+    return { hooks: [], warnings: ["settings.json no hooks section"] };
+  }
+  const out = [];
+  for (const [event, entries] of Object.entries(hooksObj)) {
+    if (!Array.isArray(entries) || entries.length === 0) continue;
+    const first = entries[0];
+    const matcher = first && typeof first === "object" ? first.matcher : void 0;
+    const cmd = first?.hooks?.[0]?.command;
+    out.push({
+      event,
+      matcherType: classifyMatcher(matcher),
+      hookCount: entries.length,
+      firstCommandPreview: typeof cmd === "string" ? cmd.slice(0, 80) : void 0
+    });
+  }
+  return { hooks: out, warnings };
+}
+function samplePackageStructure(workdir) {
+  const warnings = [];
+  const pkgPath = join(workdir, "package.json");
+  if (!existsSync(pkgPath)) {
+    return { info: null, warnings: [`package.json not found at ${pkgPath}`] };
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  } catch (e) {
+    warnings.push(`package.json parse failed: ${e instanceof Error ? e.message : String(e)}`);
+    return { info: null, warnings };
+  }
+  const packageFiles = Array.isArray(pkg.files) ? pkg.files : [];
+  let templateCommands = [];
+  const cmdDir = join(workdir, "templates", "commands");
+  if (existsSync(cmdDir)) {
+    try {
+      templateCommands = readdirSync(cmdDir).filter((f) => f.endsWith(".md")).map((f) => `templates/commands/${f}`);
+    } catch {
+      warnings.push(`readdir templates/commands failed`);
+    }
+  }
+  const missingFromPackageFiles = templateCommands.filter((cmd) => {
+    return !packageFiles.some((entry) => {
+      if (entry === cmd) return true;
+      if (entry.endsWith("/") && cmd.startsWith(entry)) return true;
+      if (cmd.startsWith(`${entry}/`)) return true;
+      return false;
+    });
+  });
+  return {
+    info: { packageFiles, templateCommands, missingFromPackageFiles },
+    warnings
+  };
+}
+function sampleAll(opts = {}) {
+  const homeDir = opts.homeDir ?? homedir();
+  const allWarnings = [];
+  const pluginRes = samplePluginList(homeDir);
+  allWarnings.push(...pluginRes.warnings);
+  const skillRes = sampleSkillList(homeDir);
+  allWarnings.push(...skillRes.warnings);
+  const hookRes = sampleHookSchema(homeDir);
+  allWarnings.push(...hookRes.warnings);
+  const result = {
+    sampledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    plugins: pluginRes.plugins,
+    skills: skillRes.skills,
+    hooks: hookRes.hooks,
+    warnings: allWarnings
+  };
+  if (opts.workdir) {
+    const pkgRes = samplePackageStructure(opts.workdir);
+    if (pkgRes.info) result.packageStructure = pkgRes.info;
+    allWarnings.push(...pkgRes.warnings);
+  }
+  return result;
+}
+function summarizeGroundTruth(gt) {
+  const lines = [];
+  lines.push(`# Ground Truth (sampled ${gt.sampledAt})`);
+  lines.push("");
+  lines.push(`## Plugins (${gt.plugins.length})`);
+  for (const p of gt.plugins.slice(0, 20)) {
+    const hints = p.subagentTypeHints?.join(", ") ?? "(no hints)";
+    lines.push(`- ${p.name} v${p.version} \u2192 subagent hints: ${hints}`);
+  }
+  if (gt.plugins.length > 20) lines.push(`- ...\u8FD8\u6709 ${gt.plugins.length - 20} \u4E2A`);
+  lines.push("");
+  lines.push(`## Skills (${gt.skills.length}, ${gt.skills.filter((s) => s.userInvocable).length} user-invocable)`);
+  const invocable = gt.skills.filter((s) => s.userInvocable);
+  for (const s of invocable.slice(0, 30)) {
+    lines.push(`- ${s.name} (${s.category})`);
+  }
+  if (invocable.length > 30) lines.push(`- ...\u8FD8\u6709 ${invocable.length - 30} \u4E2A invocable`);
+  lines.push("");
+  lines.push(`## Hooks (${gt.hooks.length} events)`);
+  for (const h of gt.hooks) {
+    lines.push(`- ${h.event}: matcher=${h.matcherType}, ${h.hookCount} entry`);
+  }
+  lines.push("");
+  if (gt.packageStructure) {
+    const ps = gt.packageStructure;
+    lines.push("## Package Structure");
+    lines.push(`- package.json files: ${ps.packageFiles.length} entries`);
+    lines.push(`- templates/commands/*.md: ${ps.templateCommands.length} files`);
+    if (ps.missingFromPackageFiles.length > 0) {
+      lines.push(`- \u26A0\uFE0F ${ps.missingFromPackageFiles.length} commands NOT in package.json files: ${ps.missingFromPackageFiles.join(", ")}`);
+    } else {
+      lines.push("- \u2705 all commands listed in package.json files");
+    }
+    lines.push("");
+  }
+  if (gt.warnings.length > 0) {
+    lines.push(`## Warnings (${gt.warnings.length})`);
+    for (const w of gt.warnings.slice(0, 10)) lines.push(`- ${w}`);
+    if (gt.warnings.length > 10) lines.push(`- ...\u8FD8\u6709 ${gt.warnings.length - 10} \u6761`);
+  }
+  return lines.join("\n");
+}
+
+const VALID_CATEGORIES = [
+  "ssot-violation",
+  "leftover",
+  "magic-string-mismatch",
+  "commit-diff-drift",
+  "mock-drift",
+  "alien-files-staged",
+  "unknown"
+];
+function parseInterfaceAuditorReport(text) {
+  let raw;
+  try {
+    raw = parseChallengerSummary("interface-auditor", text);
+  } catch (e) {
+    return {
+      status: "error",
+      findings: [],
+      notes: e instanceof Error ? e.message : String(e),
+      raw: text
+    };
+  }
+  const findings = raw.findings.map(normalizeFindingCategory);
+  return {
+    status: raw.status,
+    findings,
+    notes: raw.notes,
+    raw: text
+  };
+}
+function normalizeFindingCategory(f) {
+  const cat = f.category.toLowerCase().trim();
+  const matched = VALID_CATEGORIES.find((c) => c === cat);
+  return {
+    severity: f.severity,
+    category: matched ?? "unknown",
+    message: f.message
+  };
+}
+function criticalFindings(report) {
+  return report.findings.filter((f) => f.severity === "critical");
+}
+function majorFindings(report) {
+  return report.findings.filter((f) => f.severity === "major");
+}
+function hasBlockingFindings(report) {
+  return report.findings.some((f) => f.severity === "critical");
+}
+
+export { ALL_LAYERS, CONTEXT_BUDGET_THRESHOLD, DESCRIPTION_SOFT_LIMIT, ROUTING_SCHEMA_VERSION, aggregatePlans, auditSkillDescriptions, auditSkillsDirectory, auditTarballContents, batchByMaxConcurrent, bothPluginsInstalled, buildQualityPlan, buildWaves, cascadeSkip, collectSkills, contextPath, decideFromSummaries, detectPlugin, detectPluginAvailability, estimateBriefLength, estimateTokens, extractFrontmatter, criticalFindings as interfaceAuditCriticals, hasBlockingFindings as interfaceAuditHasBlocking, majorFindings as interfaceAuditMajors, isLayer, parseChallengerSummary, parseDependsOn, parseFrontmatterFields, parseInterfaceAuditorReport, parseQualityFlag, parseRoadmap, parseRoleFlag, parseVerifyReport, phaseDir, planChallengerSpawns, planVerifyWave, planWavesForTier, promptFilePath, readContext, readSummary, readSummaryFrontmatter, renderAuditMarkdown, renderPipelineReport, resolveQualityTier, routeSpecialist, runPipelineCheck, runPnpmPack, sampleAll, sampleHookSchema, samplePackageStructure, samplePluginList, sampleSkillList, sanitizePhase, schedule, serializeBriefForPrompt, summarizeGroundTruth, summaryPath, summaryTokenEstimate, synthesizeRevisionFeedback, synthesizeVerifyFeedback, synthesizeVerifyResults, verifyAllCommandsIncluded, writeContext, writeSummary };