@mrciphersmith/keryx 0.2.72 → 0.2.73

package/dist/cli.js

@@ -10618,7 +10618,13 @@ function renderCrossFamilyDecision(decision) {
   lines.push("");
   lines.push("## record");
   lines.push("");
-  lines.push("Embed this block in the round's structured output so a later recall comparison can group rounds by the family that reviewed them.");
+  lines.push("Record it on the round, and read it back:");
+  lines.push("");
+  lines.push("    keryx providers cross-family --opt-in --json > cross-family.json");
+  lines.push("    keryx review ingest ... --cross-family-review cross-family.json");
+  lines.push("    keryx review status <review-id>   # reads it off disk and refuses a self-contradictory record");
+  lines.push("");
+  lines.push("A round that records nothing reports `not recorded`, which is NOT `single-family`: nobody decided.");
   lines.push("");
   lines.push("```json");
   lines.push(JSON.stringify({ cross_family_review: decision }, null, 2));
@@ -23811,6 +23817,74 @@ function isUnknownDisposition(task) {
   }
   return !GATE_PASSING_DISPOSITIONS.has(task.disposition);
 }
+function isSatisfied(task) {
+  return task?.status === "done";
+}
+function nextTask(tasks) {
+  const byId = new Map(tasks.map((task) => [task.id.toUpperCase(), task]));
+  const blocked = [];
+  for (const task of tasks) {
+    if (task.status === "done") {
+      continue;
+    }
+    const waitingOn = (task.dependsOn ?? []).map((dependency) => dependency.toUpperCase()).filter((dependency) => !isSatisfied(byId.get(dependency)));
+    if (waitingOn.length === 0) {
+      return { kind: "ready", task };
+    }
+    blocked.push({ task, waitingOn });
+  }
+  return blocked.length === 0 ? { kind: "none" } : { kind: "blocked", blocked };
+}
+function dependencyIssues(tasks) {
+  const known = new Set(tasks.map((task) => task.id.toUpperCase()));
+  const issues = [];
+  for (const task of tasks) {
+    for (const raw of task.dependsOn ?? []) {
+      const dependency = raw.toUpperCase();
+      if (dependency === task.id.toUpperCase()) {
+        issues.push({
+          task: task.id,
+          kind: "self-dependency",
+          message: `${task.id} depends on itself, so it can never become ready`
+        });
+        continue;
+      }
+      if (!known.has(dependency)) {
+        issues.push({
+          task: task.id,
+          kind: "unknown-dependency",
+          message: `${task.id} depends on ${dependency}, which is not a task in this flow \u2014 the dependency can never be satisfied`
+        });
+      }
+    }
+  }
+  for (const id of tasksInCycles(tasks)) {
+    issues.push({
+      task: id,
+      kind: "cycle",
+      message: `${id} is part of a dependsOn cycle, so neither it nor anything waiting on it can ever start`
+    });
+  }
+  return issues;
+}
+function tasksInCycles(tasks) {
+  const known = new Set(tasks.map((task) => task.id.toUpperCase()));
+  const remaining = new Map(tasks.map((task) => [
+    task.id.toUpperCase(),
+    (task.dependsOn ?? []).map((dependency) => dependency.toUpperCase()).filter((dependency) => known.has(dependency) && dependency !== task.id.toUpperCase())
+  ]));
+  let peeled = true;
+  while (peeled) {
+    peeled = false;
+    for (const [id, dependencies] of remaining) {
+      if (dependencies.every((dependency) => !remaining.has(dependency))) {
+        remaining.delete(id);
+        peeled = true;
+      }
+    }
+  }
+  return [...remaining.keys()].sort();
+}
 function evaluateTaskGate(tasks) {
   const open2 = [];
   const failed = [];
@@ -26368,6 +26442,13 @@ var init_allocation = __esm(() => {
 // src/flow/service.ts
 import { mkdir as mkdir40, readFile as readFile58, rename as rename5 } from "fs/promises";
 import path112 from "path";
+function recordAttempt(task, outcome, at, detail) {
+  const attempts = task.attempts ?? { count: 0, log: [] };
+  attempts.count += 1;
+  attempts.log.push({ at, outcome, ...detail?.trim() ? { detail: detail.trim() } : {} });
+  task.attempts = attempts;
+  return attempts;
+}
 function createFlowService(deps) {
   const now = () => deps.now().toISOString();
   async function load(cwd, id) {
@@ -26484,6 +26565,9 @@ function createFlowService(deps) {
     async get({ cwd, id }) {
       return (await load(cwd, id)).flow;
     },
+    async next({ cwd, id }) {
+      return nextTask((await load(cwd, id)).flow.tasks);
+    },
     async freeze({ cwd, id }) {
       return mutate(cwd, id, async ({ dir, flow }) => {
         assertTransition(flow.status, "ready");
@@ -26541,6 +26625,9 @@ function createFlowService(deps) {
         if (runLink !== undefined) {
           task.runLink = runLink;
         }
+        if (task.disposition === "failed" || task.disposition === "blocked") {
+          recordAttempt(task, task.disposition, now(), task.dispositionReason);
+        }
         return save(cwd, dir, flow, "task-done", `${task.id}: ${task.title}`);
       });
     },
@@ -26551,10 +26638,7 @@ function createFlowService(deps) {
         if (!task) {
           throw new Error(`Task not found: ${taskId}. Known: ${flow.tasks.map((t) => t.id).join(", ")}`);
         }
-        const attempts = task.attempts ?? { count: 0, log: [] };
-        attempts.count += 1;
-        attempts.log.push({ at: now(), outcome, ...detail?.trim() ? { detail: detail.trim() } : {} });
-        task.attempts = attempts;
+        const attempts = recordAttempt(task, outcome, now(), detail);
         return save(cwd, dir, flow, "task-attempt", `${task.id}: ${outcome} (attempt ${attempts.count})${detail?.trim() ? ` \u2014 ${detail.trim()}` : ""}`);
       });
     },
@@ -26837,6 +26921,22 @@ function createFlowService(deps) {
         if (flow.status === "done" && !flow.pr.url && !flow.merged) {
           issues.push({ flow: dir, kind: "state", message: "done without a recorded PR" });
         }
+        for (const issue of dependencyIssues(flow.tasks)) {
+          issues.push({ flow: dir, kind: "dependency", message: issue.message });
+        }
+        for (const task of flow.tasks) {
+          if (task.disposition !== "failed" && task.disposition !== "blocked") {
+            continue;
+          }
+          if ((task.attempts?.count ?? 0) > 0) {
+            continue;
+          }
+          issues.push({
+            flow: dir,
+            kind: "attempts",
+            message: `${task.id} is recorded ${task.disposition} with attempts.count 0 \u2014 a task that failed without a ` + "single recorded attempt describes work nobody can audit. Record what was tried with: " + `keryx flow task attempt ${flow.id} ${task.id} --outcome ${task.disposition} --detail "<what happened>"`
+          });
+        }
       }
       return { ok: issues.length === 0, issues };
     }
@@ -32337,6 +32437,18 @@ var CONTRACTS = [
     name: "subagent-result",
     fileName: "subagent-result.schema.json",
     description: "Subagent-to-orchestrator result payload."
+  },
+  {
+    name: "task-implementer-input",
+    fileName: "task-implementer-input-contract.schema.json",
+    description: "Task request handed to task-implementer (task + workspace + automation), validated before dispatch.",
+    sourcePath: "src/gdskills/bundled/skills/orchestration/task-implementer/input-contract.schema.json"
+  },
+  {
+    name: "task-implementer-output",
+    fileName: "task-implementer-output-contract.schema.json",
+    description: "JSON result task-implementer writes in Phase 6.1 before it emits its STATUS line.",
+    sourcePath: "src/gdskills/bundled/skills/orchestration/task-implementer/output-contract.schema.json"
   }
 ];
 function normalizeContractName(value) {
@@ -32431,6 +32543,18 @@ async function validateValue(value, schema, valuePath, errors, rootSchema, schem
       message: `Expected number >= ${schema.minimum}`
     });
   }
+  if (typeof value === "number" && schema.maximum !== undefined && value > schema.maximum) {
+    errors.push({
+      path: valuePath,
+      message: `Expected number <= ${schema.maximum}`
+    });
+  }
+  if (Array.isArray(value) && schema.minItems !== undefined && value.length < schema.minItems) {
+    errors.push({
+      path: valuePath,
+      message: `Expected array length >= ${schema.minItems}`
+    });
+  }
   if (typeof value === "string") {
     if (schema.minLength !== undefined && value.length < schema.minLength) {
       errors.push({
@@ -41936,7 +42060,8 @@ var BUNDLED_SKILL_CHECKS = [
   "persona:marker",
   "path:personal-home",
   "xref:skill",
-  "xref:path"
+  "xref:path",
+  "document:addressable"
 ];
 var PERSONA_PATTERNS = [
   { pattern: /\bb091\b/i, why: "the reviewer's handle as it appeared on disk" },
@@ -42057,7 +42182,14 @@ function normaliseReferencePath(reference) {
   const root = reference.split("/")[0] ?? "";
   return CHECKED_PATH_ROOTS.includes(root) ? reference : undefined;
 }
-function bundledSkillFiles(root) {
+var SKILL_DOCUMENT_NAMES = new Set(HARNESS_SKILL_RUNTIMES.map((runtime) => skillBuildFileName(runtime)));
+var KNOWN_SKILL_COMPANION_DOCUMENTS = new Map([
+  [
+    "SKILL.detail.md",
+    "overflow reference for `orchestration/feature-analyzer`, linked from its SKILL.md; carries no frontmatter and is not addressed by any runtime"
+  ]
+]);
+function walkSkillDocuments(root, accept) {
   if (!existsSync23(root))
     return [];
   const out = [];
@@ -42068,26 +42200,40 @@ function bundledSkillFiles(root) {
         walk4(full);
         continue;
       }
-      if (entry.name === "SKILL.md")
+      if (accept(entry.name))
         out.push(full);
     }
   };
   walk4(root);
   return out.sort();
 }
+function bundledSkillFiles(root) {
+  return walkSkillDocuments(root, (name) => name === "SKILL.md");
+}
+function bundledSkillDocuments(root) {
+  return walkSkillDocuments(root, (name) => SKILL_DOCUMENT_NAMES.has(name));
+}
 function defaultBundledRoot() {
-  return path125.join(import.meta.dir, "bundled");
+  const directPath = path125.join(import.meta.dir, "bundled");
+  if (existsSync23(directPath))
+    return directPath;
+  const packagedPath = path125.join(import.meta.dir, "..", "src", "gdskills", "bundled");
+  if (existsSync23(packagedPath))
+    return packagedPath;
+  return directPath;
 }
 function evaluateBundledTree(root = defaultBundledRoot()) {
   const skillsRoot = path125.join(root, "skills");
-  const files = bundledSkillFiles(skillsRoot);
-  const skillNames = [...new Set(files.map((file) => path125.basename(path125.dirname(file))))].sort();
+  const canonical = bundledSkillFiles(skillsRoot);
+  const files = bundledSkillDocuments(skillsRoot);
+  const skillNames = [...new Set(canonical.map((file) => path125.basename(path125.dirname(file))))].sort();
   const known = new Set(skillNames);
   const findings = [];
   const declaredNames = new Map;
   const catalogued = new Set(BUNDLED_GDSKILLS.map((entry) => `${entry.category}/${entry.name}`));
   for (const file of files) {
-    const skill2 = path125.basename(path125.dirname(file));
+    const skillDir = path125.dirname(file);
+    const skill2 = path125.basename(skillDir);
     const rel = path125.relative(skillsRoot, file).split(path125.sep).join("/");
     const text = readFileSync8(file, "utf8");
     const add = (check, line, message2) => {
@@ -42110,10 +42256,10 @@ function evaluateBundledTree(root = defaultBundledRoot()) {
       const declaredName = name === undefined ? undefined : name.replace(/^["']|["']$/g, "");
       if (declaredName !== undefined && declaredName.length > 0) {
         const previous = declaredNames.get(declaredName);
-        if (previous !== undefined) {
-          add("frontmatter:name-unique", 1, `frontmatter \`name: ${declaredName}\` is already declared by \`${previous}\`; a harness registers skills by this name and cannot tell two of them apart.`);
-        } else {
-          declaredNames.set(declaredName, rel);
+        if (previous === undefined) {
+          declaredNames.set(declaredName, { dir: skillDir, file: rel });
+        } else if (previous.dir !== skillDir) {
+          add("frontmatter:name-unique", 1, `frontmatter \`name: ${declaredName}\` is already declared by \`${previous.file}\`; a harness registers skills by this name and cannot tell two of them apart.`);
         }
       }
       const description = keys.get("description");
@@ -42171,7 +42317,26 @@ function evaluateBundledTree(root = defaultBundledRoot()) {
       }
     });
   }
-  return { root, skills: files.length, skillNames, findings };
+  for (const dir of [...new Set(files.map((file) => path125.dirname(file)))].sort()) {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      if (!entry.isFile())
+        continue;
+      if (!/^SKILL\..+\.md$/.test(entry.name))
+        continue;
+      if (SKILL_DOCUMENT_NAMES.has(entry.name))
+        continue;
+      if (KNOWN_SKILL_COMPANION_DOCUMENTS.has(entry.name))
+        continue;
+      findings.push({
+        check: "document:addressable",
+        skill: path125.basename(dir),
+        file: path125.relative(skillsRoot, path125.join(dir, entry.name)).split(path125.sep).join("/"),
+        line: null,
+        message: `\`${entry.name}\` is spelled like a harness build, but no runtime in HARNESS_SKILL_RUNTIMES resolves to it (${[...SKILL_DOCUMENT_NAMES].join(", ")}). Nothing exports it, installs it, or reads it \u2014 delete it, rename it to the build it was meant to be, or register it in KNOWN_SKILL_COMPANION_DOCUMENTS with a reason.`
+      });
+    }
+  }
+  return { root, skills: canonical.length, documents: files.length, skillNames, findings };
 }
 function renderBundledEvaluation(evaluation) {
   const lines = [];
@@ -42179,9 +42344,10 @@ function renderBundledEvaluation(evaluation) {
   lines.push("");
   lines.push(`root: ${evaluation.root}`);
   lines.push(`skills_evaluated: ${evaluation.skills}`);
+  lines.push(`documents_evaluated: ${evaluation.documents} (SKILL.md + harness builds)`);
   lines.push(`findings: ${evaluation.findings.length}`);
   lines.push("");
-  if (evaluation.skills === 0) {
+  if (evaluation.documents === 0) {
     lines.push("NOTHING WAS EVALUATED. The root holds no SKILL.md, so `findings: 0` means the sweep walked an empty tree \u2014 not that the tree is clean.");
     return lines.join(`
 `);
@@ -44029,6 +44195,8 @@ async function flowCommand(args2) {
         return await runSimple(args2.slice(1), "freeze");
       case "start":
         return await runSimple(args2.slice(1), "start");
+      case "next":
+        return await runNext(args2.slice(1));
       case "task":
         return await runTask(args2.slice(1));
       case "ac":
@@ -44159,13 +44327,46 @@ async function runStatus4(args2) {
   const doneCount = flow.tasks.filter((task) => task.status === "done").length;
   heading(`Tasks (${doneCount}/${flow.tasks.length})`);
   for (const task of flow.tasks) {
-    statusLine(`${task.id} ${task.title}`, task.status === "done", task.kind);
+    const attempts = task.attempts?.count ?? 0;
+    const declared = task.dependsOn ?? [];
+    const annotations = [
+      ...declared.length === 0 ? [] : [`depends on ${declared.join(", ")}`],
+      ...attempts === 0 ? [] : [`${attempts} attempt(s)`]
+    ];
+    statusLine(`${task.id} ${task.title}${annotations.length === 0 ? "" : ` ${style.dim(`[${annotations.join("; ")}]`)}`}`, task.status === "done", task.kind);
   }
   heading("Recent history");
   for (const event of flow.history.slice(-5)) {
     console.log(`  ${style.dim(event.at)} ${event.event}${event.detail ? style.dim(`: ${event.detail}`) : ""}`);
   }
 }
+async function runNext(args2) {
+  const id = requireId(args2);
+  const decision = await getService3().next({ cwd: process.cwd(), id });
+  if (args2.includes("--json")) {
+    console.log(JSON.stringify(decision, null, 2));
+    if (decision.kind === "blocked") {
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (decision.kind === "ready") {
+    console.log(`  ${style.cyan(symbols.arrow)} ${style.bold(decision.task.id)} ${decision.task.title} ${style.dim(`(${decision.task.kind})`)}`);
+    const declared = decision.task.dependsOn ?? [];
+    note(declared.length === 0 ? "no declared dependencies; this is the first task that is not done" : `all declared dependencies are done: ${declared.join(", ")}`);
+    return;
+  }
+  if (decision.kind === "none") {
+    console.log(`  ${style.green(symbols.ok)} Every task is done.`);
+    return;
+  }
+  heading(`${style.red(symbols.cross)} ${decision.blocked.length} task(s) remain and none can start`);
+  for (const entry of decision.blocked) {
+    console.log(`  ${style.red(symbols.cross)} ${style.bold(entry.task.id)} ${entry.task.title} ${style.dim(`waiting on ${entry.waitingOn.join(", ")}`)}`);
+  }
+  note("A dependency that is not done, does not exist, or forms a cycle. `keryx flow check` names which.");
+  process.exitCode = 1;
+}
 async function runSimple(args2, action) {
   const id = requireId(args2);
   const flow = await getService3()[action]({ cwd: process.cwd(), id });
@@ -44367,6 +44568,7 @@ function printHelp10() {
     "keryx flow status <id>",
     "keryx flow freeze <id>",
     "keryx flow start <id>",
+    "keryx flow next <id> [--json]   (first task not done whose dependsOn are all done)",
     'keryx flow task add <id> --title "<t>" [--kind context|implement|test|verify|review|docs] [--depends T1,T2]',
     'keryx flow task done <id> <taskId> [--disposition completed|blocked|failed|skipped] [--reason "<why>"]',
     'keryx flow task attempt <id> <taskId> --outcome started|failed|blocked [--detail "<what happened>"]',
@@ -44486,7 +44688,7 @@ var IMPLEMENT = [
   { id: "implement", type: "implement", agent: "task-implementer", depends: ["tests-creator"] },
   { id: "sanity-check", type: "check", agent: "orchestrator", depends: ["implement"] },
   { id: "verify", type: "verify", agent: "code-verifier", depends: ["sanity-check"] },
-  { id: "review", type: "review", agent: "code-review", depends: ["verify"] },
+  { id: "review", type: "review", agent: "review-orchestrator", depends: ["verify"] },
   { id: "security", type: "security", agent: "security-audit", depends: ["implement"], conditional: true },
   { id: "fix", type: "fix", agent: "task-implementer", depends: ["review"], conditional: true },
   { id: "verify-post-fix", type: "verify", agent: "code-verifier", depends: ["fix"], conditional: true },
@@ -47544,6 +47746,7 @@ function packagePath(cwd, mode, reviewId, flowMatch) {
   return path133.join(reviewsRoot(cwd), reviewId);
 }
 function buildManifest2(args2) {
+  const crossFamily = args2.input.crossFamilyReview;
   const artifactPath = (name) => path133.relative(args2.input.cwd, path133.join(args2.packageDir, name));
   const manifest = {
     schemaVersion: 1,
@@ -47561,6 +47764,7 @@ function buildManifest2(args2) {
     },
     coverage: args2.coverage,
     filter_stats: args2.filterStats,
+    ...crossFamily === undefined ? {} : { cross_family_review: crossFamily },
     createdAt: args2.at,
     updatedAt: args2.at
   };
@@ -48282,6 +48486,94 @@ async function loadDocpackSchema(cwd) {
   return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
 }
 
+// src/review/cross-family.ts
+var CROSS_FAMILY_MODES = ["cross-family", "single-family"];
+function parseCrossFamilyReviewInput(raw, source) {
+  const candidate = typeof raw === "object" && raw !== null && !Array.isArray(raw) && "cross_family_review" in raw ? raw.cross_family_review : raw;
+  const problems = checkCrossFamilyReview(candidate);
+  if (problems.length > 0) {
+    throw new Error(`${source} is not a usable cross_family_review block: ${problems.map((problem) => `[${problem.code}] ${problem.message}`).join("; ")}. Produce one with \`keryx providers cross-family --json\`.`);
+  }
+  return candidate;
+}
+function checkCrossFamilyReview(value) {
+  if (value === undefined || value === null) {
+    return [
+      {
+        code: "not-recorded",
+        message: "cross_family_review: not recorded. The round did not run `keryx providers cross-family`, or the package predates the field. This is NOT `single-family` \u2014 nobody decided."
+      }
+    ];
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return [{ code: "shape", message: "cross_family_review is not an object." }];
+  }
+  const record = value;
+  const problems = [];
+  const shape = (message2) => {
+    problems.push({ code: "shape", message: message2 });
+  };
+  const contradiction = (message2) => {
+    problems.push({ code: "contradiction", message: message2 });
+  };
+  if (record.schemaVersion !== 1) {
+    shape(`schemaVersion must be 1; found ${JSON.stringify(record.schemaVersion)}.`);
+  }
+  const mode = record.mode;
+  if (typeof mode !== "string" || !CROSS_FAMILY_MODES.includes(mode)) {
+    shape(`mode must be one of ${CROSS_FAMILY_MODES.join(", ")}; found ${JSON.stringify(mode)}.`);
+  }
+  if (typeof record.requested !== "boolean") {
+    shape(`requested must be a boolean; found ${JSON.stringify(record.requested)}.`);
+  }
+  for (const field3 of ["author_family", "reviewer_family", "reviewer_provider", "reviewer_model"]) {
+    const held = record[field3];
+    if (held !== null && typeof held !== "string") {
+      shape(`${field3} must be a string or null; found ${JSON.stringify(held)}.`);
+    }
+  }
+  if (typeof record.reason !== "string" || record.reason.trim() === "") {
+    shape("reason must be a non-empty string \u2014 the decision is unreadable later without it.");
+  }
+  const candidates = record.candidates;
+  if (!Array.isArray(candidates)) {
+    shape(`candidates must be an array; found ${JSON.stringify(candidates)}.`);
+  }
+  if (problems.length > 0) {
+    return problems;
+  }
+  const reviewerFamily = record.reviewer_family;
+  const reviewerProvider = record.reviewer_provider;
+  const authorFamily = record.author_family;
+  const options = candidates;
+  if (mode === "cross-family") {
+    if (record.requested !== true) {
+      contradiction("mode is `cross-family` while requested is false. Cross-family review is opt-in; a granted review nobody asked for means the record was assembled rather than decided.");
+    }
+    if (reviewerFamily === null || reviewerProvider === null) {
+      contradiction("mode is `cross-family` but the reviewer family or provider is null. `cross-family` without naming the other side cannot be grouped later, which is the whole reason the block exists.");
+    }
+    if (reviewerFamily !== null && reviewerFamily === authorFamily) {
+      contradiction(`mode is \`cross-family\` and the reviewer family (${reviewerFamily}) is the family that authored the change. That is a single-family review recorded as a cross-family one.`);
+    }
+    if (reviewerFamily !== null && !options.some((option) => option.family === reviewerFamily && option.provider === reviewerProvider)) {
+      contradiction(`the chosen reviewer (${reviewerFamily} via ${reviewerProvider}) is not among the ${options.length} candidate(s) recorded on the decision. A reviewer that was never an option was not chosen from them.`);
+    }
+  } else {
+    if (reviewerFamily !== null || reviewerProvider !== null || record.reviewer_model !== null) {
+      contradiction("mode is `single-family` while a reviewer family, provider or model is named. Single-family review has no other side; naming one says a dispatch happened that the mode denies.");
+    }
+  }
+  return problems;
+}
+function renderCrossFamilyReviewLine(decision) {
+  if (decision === undefined) {
+    return "cross_family_review: not recorded (no --cross-family-review supplied to this ingest; this is NOT `single-family`)";
+  }
+  const reviewer = decision.mode === "cross-family" ? `${decision.reviewer_family ?? "?"} via ${decision.reviewer_provider ?? "?"}${decision.reviewer_model === null ? "" : ` (${decision.reviewer_model})`}` : "none (single-family review)";
+  return `cross_family_review: mode=${decision.mode} requested=${decision.requested ? "yes" : "no"} author_family=${decision.author_family ?? "not classified"} reviewer=${reviewer} candidates=${decision.candidates.length}`;
+}
+
 // src/commands/review.ts
 init_github();
 init_query();
@@ -48706,6 +48998,7 @@ var CREATE_FLAGS = [
   "--verification-mode",
   "--scope",
   "--blast-radius",
+  "--cross-family-review",
   "--refuted",
   "--max-findings",
   "--spent",
@@ -48901,6 +49194,7 @@ async function runCreate(mode, args2) {
     verificationMode: parseVerificationMode(optionValue(args2, "--verification-mode")),
     scope: await readScope(optionValue(args2, "--scope")),
     blastRadius: await readBlastRadiusRecord(optionValue(args2, "--blast-radius")),
+    crossFamilyReview: await readCrossFamilyReview(optionValue(args2, "--cross-family-review")),
     maxFindingsPerReviewer: parseNonNegativeInteger(optionValue(args2, "--max-findings"), "--max-findings"),
     spend: parseMoney(optionValue(args2, "--spent"), "--spent"),
     spendCeiling: parseMoney(optionValue(args2, "--spend-ceiling"), "--spend-ceiling"),
@@ -48929,6 +49223,7 @@ async function runCreate(mode, args2) {
   console.log(preFilter === undefined ? "pre-filter: not recorded (no --scope supplied; this is not `dropped 0`)" : `pre-filter: files_dropped=${preFilter.counts.filesDropped} blocks_dropped=${preFilter.counts.blocksDropped} changed_lines_dropped=${preFilter.counts.changedLinesDropped} drop_rows=${preFilter.drops.length}`);
   console.log(renderFilterStatsLine(result.filterStats));
   reportFilterStatsProblems(result.filterStats, `${result.path}/manifest.json`);
+  console.log(renderCrossFamilyReviewLine(result.manifest.cross_family_review));
   const caps = result.caps;
   const findingsCap = caps.findings;
   if (findingsCap !== undefined) {
@@ -49494,6 +49789,19 @@ async function readBlastRadiusRecord(source) {
   }
   return { ...parsed, files: parsed.files, changedFiles: parsed.changedFiles };
 }
+async function readCrossFamilyReview(source) {
+  if (source === undefined) {
+    return;
+  }
+  const raw = source === "-" ? await Bun.stdin.text() : await Bun.file(source).text();
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error2) {
+    throw new Error(`--cross-family-review ${source} is not JSON: ${error2 instanceof Error ? error2.message : String(error2)}. Pass the output of \`keryx providers cross-family --json\`.`);
+  }
+  return parseCrossFamilyReviewInput(parsed, `--cross-family-review ${source}`);
+}
 function parseVerificationMode(raw) {
   if (raw === undefined) {
     return DEFAULT_VERIFICATION_MODE;
@@ -49665,6 +49973,8 @@ async function runStatus6(args2) {
   console.log(`head: ${manifest.target.head ?? "not recorded (`flow complete` will refuse this round)"}`);
   console.log(`flow: ${manifest.flow?.id ?? "none"}`);
   console.log(`coverage: ${manifest.coverage.length}`);
+  console.log(renderCrossFamilyReviewLine(manifest.cross_family_review));
+  reportCrossFamilyReviewProblems(manifest.cross_family_review, `${ref}/manifest.json`);
   const stats = manifest.filter_stats;
   if (stats === undefined) {
     console.log("filter_stats: not recorded \u2014 this package predates it. Re-ingest the round to record what it filtered.");
@@ -49679,6 +49989,16 @@ async function runStatus6(args2) {
   }
   reportFilterStatsProblems(stats, `${ref}/manifest.json`);
 }
+function reportCrossFamilyReviewProblems(decision, where) {
+  const problems = checkCrossFamilyReview(decision).filter((problem) => problem.code !== "not-recorded");
+  if (problems.length === 0) {
+    return;
+  }
+  for (const problem of problems) {
+    console.error(`cross_family_review [${problem.code}] in ${where}: ${problem.message}`);
+  }
+  process.exitCode = 1;
+}
 function reportFilterStatsProblems(stats, where) {
   const problems = checkFilterStats(stats).filter((problem) => problem.code !== "not-recorded");
   if (problems.length === 0) {
@@ -49767,6 +50087,7 @@ Usage:
   keryx review ingest --report <path> [--flow <id>] --ref <ref> [--head <sha>]
                       [--verifications <file|->] [--verification-mode ${VERIFICATION_MODES.join("|")}]
                       [--scope <scope.json>] [--blast-radius <blast-radius.json>]
+                      [--cross-family-review <file|->]
                     [--refuted <file|->]
                       [--max-findings <n>] [--spent <usd>] [--spend-ceiling <usd>]
                       [--parallel <n>] [--outstanding <n>]
@@ -49831,6 +50152,15 @@ blast-radius:
   Requires a built graph (\`keryx gdgraph build\`); an absent graph is refused
   rather than reported as an empty radius.
 
+cross-family-review:
+  The block \`keryx providers cross-family --json\` prints: which model family
+  reviewed this round, and why. Recorded on \`manifest.cross_family_review\` and
+  read back \u2014 and CHECKED \u2014 by \`keryx review status\`, which exits non-zero on a
+  record that contradicts itself (\`cross-family\` naming no reviewer, naming the
+  authoring family, or naming a reviewer that was never a candidate).
+  Omitted, the round records NOTHING, and \`status\` says \`not recorded\`.
+  That is not \`single-family\`: nobody decided.
+
 complete:
   --finding/--disposition/--evidence record what became of a named finding, and
   are repeatable. States: ${FINDING_DISPOSITION_STATES.join(", ")}.
@@ -62549,7 +62879,7 @@ import { spawnSync as spawnSync2 } from "child_process";
 // package.json
 var package_default = {
   name: "@mrciphersmith/keryx",
-  version: "0.2.72",
+  version: "0.2.73",
   description: "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
   private: false,
   publishConfig: {
@@ -62591,7 +62921,7 @@ var package_default = {
     check: "tsc --noEmit && bun test",
     "check:doc-links": "bun scripts/check-doc-links.ts",
     "baseline:review-precision": "bun scripts/review-precision-baseline.ts",
-    "test:guards": "bun test src/lib/config-dir.ast.test.ts src/lib/config-dir.readers.test.ts src/lib/production-graph.test.ts src/harness/policy/profiles.test.ts src/lib/serve-server.test.ts"
+    "test:guards": "bun test src/lib/config-dir.ast.test.ts src/lib/config-dir.readers.test.ts src/lib/production-graph.test.ts src/harness/policy/profiles.test.ts src/lib/serve-server.test.ts src/gdskills/agent-catalogue-xref.test.ts src/gdskills/enforcement-claims.test.ts"
   },
   files: [
     "dist",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrciphersmith/keryx",
-  "version": "0.2.72",
+  "version": "0.2.73",
   "description": "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
   "private": false,
   "publishConfig": {
@@ -42,7 +42,7 @@
     "check": "tsc --noEmit && bun test",
     "check:doc-links": "bun scripts/check-doc-links.ts",
     "baseline:review-precision": "bun scripts/review-precision-baseline.ts",
-    "test:guards": "bun test src/lib/config-dir.ast.test.ts src/lib/config-dir.readers.test.ts src/lib/production-graph.test.ts src/harness/policy/profiles.test.ts src/lib/serve-server.test.ts"
+    "test:guards": "bun test src/lib/config-dir.ast.test.ts src/lib/config-dir.readers.test.ts src/lib/production-graph.test.ts src/harness/policy/profiles.test.ts src/lib/serve-server.test.ts src/gdskills/agent-catalogue-xref.test.ts src/gdskills/enforcement-claims.test.ts"
   },
   "files": [
     "dist",

package/src/gdskills/bundled/rules/core/gproject-contracts.mdc

@@ -33,7 +33,7 @@ Every dispatch from gproject-orchestrator MUST include:
 ```yaml
 # Required (from base protocol)
 description: "<phase>: <task>"
-subagent_type: "general"
+subagent_type: "general-purpose"
 prompt: "<structured prompt — see template below>"
 
 # gproject-specific (inside prompt)

package/src/gdskills/bundled/rules/core/jobs-documentation.mdc

@@ -80,7 +80,7 @@ Every job folder MUST contain at minimum:
     ...
 ```
 
-> **`results/` folder:** Created by `task-implementer` during Phase 6 (one file per task). The orchestrator and wave-executor never receive full task results inline — they read these files only when a task reports `DONE_WITH_CONCERNS` or `BLOCKED`. This keeps the orchestrator context bounded.
+> **`results/` folder:** Written by `task-implementer` during Phase 6.1 (one file per task), then validated with `keryx skills contracts validate … --schema task-implementer-output` and recorded with `keryx job document <job-name> --type implementation-report --file <that file>`, which refuses if the file was never written. There is no `wave-executor` agent: the orchestrator dispatches each task itself, never receives a full task result inline, and reads a `results/` file only when a task reports `DONE_WITH_CONCERNS` or `BLOCKED`. This keeps the orchestrator context bounded.
 
 ## README.md Format
 

package/src/gdskills/bundled/rules/core/subagent-context-construction.md

@@ -62,7 +62,7 @@ Use this template for every subagent dispatch:
 ```
 Task({
   description: "<one-line summary for logs>",
-  subagent_type: "general",
+  subagent_type: "general-purpose",
   prompt: |
     ## Task
     <Exactly what to do — no ambiguity>