@mrciphersmith/keryx 0.3.28 → 0.3.29

package/README.md

@@ -623,9 +623,12 @@ Grouped by what you are trying to do, not by internal module layout.
   rounds-with-cost/rounds-total count for partial coverage), project-wide
   trigger spend (never attributed to a flow — the run record carries no flow
   reference), who confirmed each acceptance criterion and who signed
-  completion (with identity basis), and every `flow complete` attempt's gate
-  outcomes. A figure nobody recorded is reported as "not recorded", never as
-  zero. Writes `.metaproject/data/governance/artifacts/latest.{md,json}`, the
+  completion (with identity basis), every `flow complete` attempt's gate
+  outcomes, and each flow's acceptance coverage — how many criteria carry a
+  runnable `[verify: exec ...]` or `[verify: invariant ...]` marker (a flow
+  with no recorded kinds counts as fully unclassified; see `keryx flow ac kinds`
+  in the [CLI reference](docs/docs/cli-reference.md#verification-kinds)). A
+  figure nobody recorded is reported as "not recorded", never as zero. Writes `.metaproject/data/governance/artifacts/latest.{md,json}`, the
   same convention `keryx health run` uses; `--all-projects` also covers every
   project in the user-global registry. In the TUI, the sidebar's
   **Governance** row shows `no report — click to run`,

package/dist/cli.js

@@ -13447,7 +13447,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@mrciphersmith/keryx",
-    version: "0.3.28",
+    version: "0.3.29",
     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: {
@@ -49602,6 +49602,162 @@ var init_confirm_token = __esm(() => {
   CONFIRMATION_CAVEAT = "The token proves an interactive confirmation step ran outside the agent's tool roster, within its TTL, " + "for this criteria checksum \u2014 not that a human ran it, and not who.";
 });
 
+// src/flow/ac-kinds.ts
+function maskCodeSpans(text) {
+  return text.replace(/`[^`]*`/g, (span) => " ".repeat(span.length));
+}
+function scanMarkers(text) {
+  const masked = maskCodeSpans(text);
+  let occurrences = 0;
+  let lastStart = -1;
+  for (let at = masked.indexOf(MARKER_OPEN);at !== -1; at = masked.indexOf(MARKER_OPEN, at + MARKER_OPEN.length)) {
+    occurrences += 1;
+    lastStart = at;
+  }
+  const end = text.trimEnd().length;
+  return { occurrences, lastStart, trailing: occurrences > 0 && end > lastStart && text[end - 1] === "]", end };
+}
+function stripVerifyMarker(text) {
+  const scan = scanMarkers(text);
+  if (!scan.trailing || scan.occurrences !== 1)
+    return text;
+  return text.slice(0, scan.lastStart).trimEnd();
+}
+function unclassified(error) {
+  return error === undefined ? { record: { kind: "unclassified" } } : { record: { kind: "unclassified" }, error };
+}
+function parseAcKindText(text) {
+  const scan = scanMarkers(text);
+  if (scan.occurrences === 0)
+    return unclassified();
+  if (scan.occurrences > 1) {
+    return unclassified("a second [verify: \u2026] marker \u2014 a criterion carries exactly one, as the last thing on its line");
+  }
+  if (!scan.trailing) {
+    return unclassified("the [verify: \u2026] marker must be the last thing on the line and close with `]`");
+  }
+  const payload = text.slice(scan.lastStart + MARKER_OPEN.length, scan.end - 1).trim();
+  if (payload.length === 0)
+    return unclassified(`an empty [verify: \u2026] marker \u2014 expected ${KIND_WORDS}`);
+  const word = /^[A-Za-z]+/.exec(payload)?.[0] ?? "";
+  const rest = payload.slice(word.length).trim();
+  switch (word) {
+    case "judged":
+      return rest.length === 0 ? { record: { kind: "judged" } } : unclassified("`judged` takes no arguments \u2014 write [verify: judged]");
+    case "exec":
+    case "invariant": {
+      if (rest.length === 0)
+        return unclassified(`\`${word}\` requires a backticked command, e.g. [verify: ${word} \`bun test path/to.test.ts\`]`);
+      const command = /^`([^`]*)`$/.exec(rest);
+      if (command === null)
+        return unclassified(`\`${word}\` requires exactly one backticked command after the kind, e.g. [verify: ${word} \`bun test path/to.test.ts\`]`);
+      const check = (command[1] ?? "").trim();
+      if (check.length === 0)
+        return unclassified(`\`${word}\` has an empty backticked command`);
+      return { record: { kind: word, check } };
+    }
+    case "none": {
+      if (rest.length === 0)
+        return unclassified("`none` requires a reason after an em dash, e.g. [verify: none \u2014 <reason>]");
+      const reason = /^\u2014\s*([\s\S]*)$/.exec(rest);
+      if (reason === null)
+        return unclassified("`none` requires its reason after an em dash (\u2014), e.g. [verify: none \u2014 <reason>]");
+      const why = (reason[1] ?? "").trim();
+      if (why.length === 0)
+        return unclassified("`none` has an empty reason after the em dash");
+      return { record: { kind: "none", reason: why } };
+    }
+    default:
+      return unclassified(`unknown verification kind "${word.length > 0 ? word : payload}" \u2014 expected ${KIND_WORDS}`);
+  }
+}
+function parseAcKinds(content) {
+  const criteria = [];
+  const errors = [];
+  for (const line of content.split(/\r?\n/)) {
+    const match = AC_LINE.exec(line);
+    if (!match?.[1])
+      continue;
+    const id = match[1].toUpperCase();
+    const rawText = (match[2] ?? "").trim();
+    const parsed = parseAcKindText(rawText);
+    if (parsed.error !== undefined)
+      errors.push({ id, message: parsed.error });
+    criteria.push({ id, text: stripVerifyMarker(rawText), rawText, record: parsed.record });
+  }
+  return { criteria, errors };
+}
+function emptyCounts() {
+  return { exec: 0, invariant: 0, judged: 0, none: 0, unclassified: 0 };
+}
+function buildAcKindReport(flowId, content) {
+  const parsed = parseAcKinds(content);
+  const criteria = {};
+  for (const criterion of parsed.criteria) {
+    if (!(criterion.id in criteria))
+      criteria[criterion.id] = criterion.record;
+  }
+  return { report: reportFromRecords(flowId, criteria), errors: parsed.errors };
+}
+function reportFromRecords(flowId, criteria) {
+  const counts = emptyCounts();
+  for (const record of Object.values(criteria))
+    counts[record.kind] += 1;
+  return {
+    flowId,
+    criteria,
+    counts,
+    runnable: counts.exec + counts.invariant,
+    total: Object.keys(criteria).length
+  };
+}
+function renderAcKindDistribution(report) {
+  const { counts } = report;
+  const percent = report.total === 0 ? 0 : Math.round(report.runnable / report.total * 100);
+  const tail = [`${counts.none} accepted as unverifiable`, `${counts.judged} judged`, ...counts.unclassified > 0 ? [`${counts.unclassified} unclassified`] : []];
+  return [
+    `acceptance kinds: exec ${counts.exec}  invariant ${counts.invariant}  judged ${counts.judged}  none ${counts.none}  unclassified ${counts.unclassified}   (${report.total} criteria)`,
+    `coverage: ${report.runnable}/${report.total} runnable (${percent}%)  \xB7  ${tail.join("  \xB7  ")}`
+  ];
+}
+function describeAcKind(record) {
+  switch (record.kind) {
+    case "exec":
+    case "invariant":
+      return `${record.kind} \`${record.check}\``;
+    case "none":
+      return `none \u2014 ${record.reason}`;
+    default:
+      return record.kind;
+  }
+}
+function readAcKindRecords(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return;
+  const out = {};
+  for (const [id, raw] of Object.entries(value)) {
+    if (typeof raw !== "object" || raw === null)
+      return;
+    const record = raw;
+    const kind = record["kind"];
+    if ((kind === "exec" || kind === "invariant") && typeof record["check"] === "string")
+      out[id] = { kind, check: record["check"] };
+    else if (kind === "judged")
+      out[id] = { kind };
+    else if (kind === "none" && typeof record["reason"] === "string")
+      out[id] = { kind, reason: record["reason"] };
+    else if (kind === "unclassified")
+      out[id] = { kind };
+    else
+      return;
+  }
+  return out;
+}
+var AC_LINE, MARKER_OPEN = "[verify:", KIND_WORDS = "exec, invariant, judged or none";
+var init_ac_kinds = __esm(() => {
+  AC_LINE = /^\s*[-*]\s*(AC\d+)\s*:\s?(.*)$/i;
+});
+
 // src/review/cost.ts
 function estimateTokens2(text) {
   return Math.ceil(text.length / 4);
@@ -49676,7 +49832,7 @@ import path120 from "path";
 function parseAcceptanceCriteria(content) {
   const out = [];
   for (const line of content.split(/\r?\n/)) {
-    const match = AC_LINE.exec(line);
+    const match = AC_LINE2.exec(line);
     if (match?.[1]) {
       out.push({ id: match[1].toUpperCase(), text: (match[2] ?? "").trim() });
     }
@@ -49715,6 +49871,9 @@ function classifyNotCheckable(criterionText) {
     reason: `not-checkable: every clause of this criterion names a condition no diff records (${labels.join(", ")}) \u2014 assigned without asking Jev.`
   };
 }
+function classifyAcCriterionNotCheckable(criterion) {
+  return classifyNotCheckable(stripVerifyMarker(criterion.text));
+}
 function extractCriterionTokens(text) {
   const tokens = new Set;
   for (const match of text.matchAll(/`([^`]+)`/g)) {
@@ -49732,7 +49891,7 @@ function extractCriterionTokens(text) {
   return [...tokens];
 }
 function computeAcFacts(criterion, diffText, changedFiles) {
-  const tokens = extractCriterionTokens(criterion.text);
+  const tokens = extractCriterionTokens(stripVerifyMarker(criterion.text));
   const tokensPresent = tokens.filter((token) => diffText.includes(token) || changedFiles.some((file) => file.includes(token)));
   const tokensAbsent = tokens.filter((token) => !tokensPresent.includes(token));
   const testFiles = changedFiles.filter((file) => /\.(test|spec)\.[a-z]+$/i.test(file));
@@ -49757,7 +49916,7 @@ function computeAcFacts(criterion, diffText, changedFiles) {
 function questionFor(criterion) {
   return {
     type: "noul",
-    instructions: `Given the deterministic facts and the redacted diff evidence above, does this change LIKELY SATISFY this frozen ` + `acceptance criterion? Criterion ${criterion.id}: ${redactSensitiveText(criterion.text)}`
+    instructions: `Given the deterministic facts and the redacted diff evidence above, does this change LIKELY SATISFY this frozen ` + `acceptance criterion? Criterion ${criterion.id}: ${redactSensitiveText(stripVerifyMarker(criterion.text))}`
   };
 }
 function selectMatchedHunks(facts, regions) {
@@ -49918,12 +50077,13 @@ function renderAcCheckAdvisoryNotice(verdicts) {
   const inDoubt = verdicts.filter((v) => v.status === "not-evident").map((v) => v.id);
   return `acceptance-criteria check (advisory): ${counts.likelyMet} likely met, ${counts.notEvident} not evident, ${counts.notCheckable} not checkable` + (inDoubt.length > 0 ? ` \u2014 in doubt: ${inDoubt.join(", ")}` : "") + ` (\`keryx flow check-ac\` for detail)`;
 }
-var AC_LINE, NOT_CHECKABLE_MARKERS, AC_CHECK_TOKEN_BUDGET = 64000, MAX_MATCHED_HUNKS_PER_ITEM = 8, BATCH_BUDGET_FRACTION = 0.5, MAX_ITEMS_PER_BATCH = 6, DEFAULT_AC_CHECK_THRESHOLD = 0.5, STATUS_LABEL;
+var AC_LINE2, NOT_CHECKABLE_MARKERS, AC_CHECK_TOKEN_BUDGET = 64000, MAX_MATCHED_HUNKS_PER_ITEM = 8, BATCH_BUDGET_FRACTION = 0.5, MAX_ITEMS_PER_BATCH = 6, DEFAULT_AC_CHECK_THRESHOLD = 0.5, STATUS_LABEL;
 var init_check_ac = __esm(() => {
   init_service2();
   init_fs();
   init_review_gate();
-  AC_LINE = /^\s*[-*]\s*(AC\d+)\s*:\s?(.*)$/i;
+  init_ac_kinds();
+  AC_LINE2 = /^\s*[-*]\s*(AC\d+)\s*:\s?(.*)$/i;
   NOT_CHECKABLE_MARKERS = [
     { label: "live check", re: /\blive[- ]?check\b|\brun(?:s|ning)? with\b.*\benv\b|\blive[- ]?run\b/i },
     { label: "CI green", re: /\bCI (?:is )?green\b|\bCI passes\b/i },
@@ -50385,6 +50545,10 @@ var init_templates3 = __esm(() => {
 // src/flow/service.ts
 import { mkdir as mkdir30, readFile as readFile58 } from "fs/promises";
 import path122 from "path";
+async function deriveAcKinds(cwd, dir, flowId) {
+  const { report } = buildAcKindReport(flowId, await readFile58(acPath(cwd, dir), "utf8"));
+  return { ...report.criteria };
+}
 function recordAttempt(task, outcome, at, detail) {
   const attempts = task.attempts ?? { count: 0, log: [] };
   attempts.count += 1;
@@ -50579,6 +50743,7 @@ function createFlowService(deps) {
           throw new Error("Cannot freeze: acceptance-criteria.md must contain at least one real `- ACn:` criterion.");
         }
         flow.acChecksum = await acChecksum(cwd, dir);
+        flow.acKinds = await deriveAcKinds(cwd, dir, flow.id);
         flow.status = "ready";
         return save(cwd, dir, flow, "frozen", `${criteria.length} criteria; checksum recorded`);
       });
@@ -50723,10 +50888,15 @@ function createFlowService(deps) {
           detail = `${normalizedCriterion}: "${previousText ?? "(new)"}" -> "${normalizedText}" (${reason.trim()})`;
         }
         flow.acChecksum = await acChecksum(cwd, dir);
+        flow.acKinds = await deriveAcKinds(cwd, dir, flow.id);
         flow.acConfirmed = {};
         return save(cwd, dir, flow, "ac-updated", detail);
       });
     },
+    async acKinds({ cwd, id }) {
+      const { dir, flow } = await load(cwd, id);
+      return buildAcKindReport(flow.id, await readFile58(acPath(cwd, dir), "utf8"));
+    },
     async acReseal({ cwd, id, reason }) {
       if (!reason?.trim()) {
         throw new Error('flow ac reseal requires --reason "<why the checksum is stale>"');
@@ -50745,6 +50915,7 @@ function createFlowService(deps) {
           throw new Error(`flow ac reseal: refusing \u2014 ${evidence.reason}. ` + "Reseal only re-seals a stale checksum over an unchanged file; it is not a way to " + 'accept an edit. If the criteria really changed, use `keryx flow ac update <id> --reason "..."`, ' + "which re-seals AND voids the prior confirmations.");
         }
         flow.acChecksum = current;
+        flow.acKinds = await deriveAcKinds(cwd, dir, flow.id);
         return save(cwd, dir, flow, "ac-resealed", reason);
       });
     },
@@ -51418,6 +51589,8 @@ var init_service9 = __esm(() => {
   init_confirm_token();
   init_confirm_token();
   init_store3();
+  init_ac_kinds();
+  init_ac_kinds();
   init_review_gate();
   init_check_ac();
   init_store3();
@@ -94059,6 +94232,25 @@ var init_modal_host = __esm(() => {
   hosts = new WeakMap;
 });
 
+// src/tui/ac-kinds-surface.ts
+function formatAcKindLines(item) {
+  if (item.acKinds === undefined) {
+    if (item.acFrozen === false) {
+      return ["Verification kinds: not frozen yet (kinds are read when the criteria are frozen)."];
+    }
+    return [
+      "Verification kinds: not recorded (this flow was frozen before kinds existed; every criterion reads unclassified)."
+    ];
+  }
+  const report = reportFromRecords(item.id, item.acKinds);
+  const rows = Object.entries(report.criteria).map(([id, record]) => `${id.padEnd(ID_WIDTH)}${describeAcKind(record)}`);
+  return [...renderAcKindDistribution(report), "", ...rows.length === 0 ? ["(no criteria)"] : rows];
+}
+var ID_WIDTH = 5;
+var init_ac_kinds_surface = __esm(() => {
+  init_service9();
+});
+
 // src/review/scope.ts
 function classifyPath2(path, config = DEFAULT_REVIEW_SCOPE_CONFIG) {
   const normalized = path.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -94333,7 +94525,7 @@ function isCommentOnly(hunk, block, path) {
   }
   return sawComment;
 }
-function emptyCounts() {
+function emptyCounts2() {
   const droppedByReason = Object.fromEntries(SCOPE_DROP_REASONS.map((reason) => [reason, 0]));
   return {
     filesSeen: 0,
@@ -94376,7 +94568,7 @@ function windowsFor(blocks, contextLines) {
 }
 function buildReviewScope(diff, config) {
   const resolved = resolveConfig(config);
-  const counts = emptyCounts();
+  const counts = emptyCounts2();
   const drops = [];
   const regions = [];
   const files = [];
@@ -94488,7 +94680,7 @@ function buildReviewScope(diff, config) {
 }
 function buildPathScope(paths, config) {
   const resolved = resolveConfig(config);
-  const counts = emptyCounts();
+  const counts = emptyCounts2();
   const drops = [];
   const files = [];
   for (const path of paths) {
@@ -95192,7 +95384,7 @@ async function runCheckAc(cwd, id, opts = {}, deps = {}) {
   const changedFiles = scope.files;
   const notCheckable = [];
   const checkableCriteria = criteria.filter((criterion) => {
-    const classification = classifyNotCheckable(criterion.text);
+    const classification = classifyAcCriterionNotCheckable(criterion);
     if (classification === undefined)
       return true;
     notCheckable.push(notCheckableVerdict(criterion, classification.reason));
@@ -95992,6 +96184,11 @@ async function loadInspectorFlows(cwd) {
         if (await isCompletionInterrupted(cwd, flow, dir)) {
           item.interrupted = interruptedCompletionLine(flow.id);
         }
+        const kinds = readAcKindRecords(flow.acKinds);
+        item.acFrozen = flow.acChecksum !== null;
+        if (kinds !== undefined) {
+          item.acKinds = kinds;
+        }
         try {
           const cache = await readAcCheckCache(acCheckCachePath(cwd, dir));
           if (cache !== undefined) {
@@ -96209,6 +96406,7 @@ function presentFlows(openModal, otui, chrome, options) {
   let selected = 0;
   let listScroll = 0;
   let detailScroll = 0;
+  let acScroll = 0;
   let listNode;
   let detailNode;
   let acNode;
@@ -96231,7 +96429,7 @@ function presentFlows(openModal, otui, chrome, options) {
     if (checking) {
       return ["Checking\u2026", "", "Running `keryx flow check-ac` against the frozen criteria \u2014 this can take a few seconds."];
     }
-    const raw = item !== undefined ? formatAcCheckLines(item) : ["No flow selected."];
+    const raw = item !== undefined ? [...formatAcKindLines(item), "", ...formatAcCheckLines(item)] : ["No flow selected."];
     const withError = checkError !== undefined ? [...raw, "", `Error: ${checkError}`] : raw;
     return wrapLines(withError.join(`
 `), tabWidth).split(`
@@ -96250,7 +96448,8 @@ function presentFlows(openModal, otui, chrome, options) {
 `);
     }
     if (acNode !== undefined) {
-      acNode.content = windowLines(acLines(), 0, bodyRows).join(`
+      acScroll = clampScroll(acScroll, acLines().length, bodyRows);
+      acNode.content = windowLines(acLines(), acScroll, bodyRows).join(`
 `);
     }
   };
@@ -96264,6 +96463,7 @@ function presentFlows(openModal, otui, chrome, options) {
     }
     selected = clamped;
     detailScroll = 0;
+    acScroll = 0;
     paintSelection();
   };
   const handle = openModal(otui, chrome, {
@@ -96284,7 +96484,8 @@ function presentFlows(openModal, otui, chrome, options) {
         return;
       }
       if (tabId === "ac") {
-        acNode = paintLines(otui, renderer, body, windowLines(acLines(), 0, bodyRows));
+        acScroll = clampScroll(acScroll, acLines().length, bodyRows);
+        acNode = paintLines(otui, renderer, body, windowLines(acLines(), acScroll, bodyRows));
         return;
       }
       detailScroll = clampScroll(detailScroll, detailLines().length, bodyRows);
@@ -96354,6 +96555,12 @@ function presentFlows(openModal, otui, chrome, options) {
         }
         return;
       }
+      if (handle.activeTab() === "ac" && (token === "pageup" || token === "pagedown")) {
+        const step = token === "pageup" ? -bodyRows : bodyRows;
+        acScroll = clampScroll(acScroll + step, acLines().length, bodyRows);
+        paintSelection();
+        return;
+      }
       if (onDetail && (token === "pageup" || token === "pagedown")) {
         const step = token === "pageup" ? -bodyRows : bodyRows;
         detailScroll = clampScroll(detailScroll + step, detailLines().length, bodyRows);
@@ -96369,6 +96576,7 @@ function openFlows(otui, chrome, options) {
 var FLOWS_COMMAND = "/flows", AC_COMMAND = "/ac", FLOWS_FOOTER, MARKER_GLYPH;
 var init_flow_inspector = __esm(() => {
   init_modal_host();
+  init_ac_kinds_surface();
   init_inspector_sources();
   FLOWS_FOOTER = [
     { key: "[/]", label: "flow" },
@@ -97271,12 +97479,30 @@ function summarizeConfirmations(flow) {
     }
   };
 }
+function summarizeAcceptance(flow, criteriaInFile) {
+  const records = readAcKindRecords(flow.acKinds);
+  if (records === undefined) {
+    const total = criteriaInFile;
+    return {
+      recorded: false,
+      frozen: flow.acChecksum !== null,
+      total,
+      counts: { exec: 0, invariant: 0, judged: 0, none: 0, unclassified: total ?? 0 },
+      runnable: 0
+    };
+  }
+  const report = reportFromRecords(flow.id, records);
+  return { recorded: true, total: report.total, counts: { ...report.counts }, runnable: report.runnable };
+}
 function summarizeGateOutcomes(flow) {
   if (flow.completionAttempts === undefined) {
     return { recorded: false };
   }
   return { recorded: true, attempts: flow.completionAttempts };
 }
+var init_accountability = __esm(() => {
+  init_ac_kinds();
+});
 
 // src/governance/aggregate.ts
 async function collectFlowGovernance(cwd, ledger) {
@@ -97285,6 +97511,14 @@ async function collectFlowGovernance(cwd, ledger) {
   for (const dir of dirs) {
     const flow = await readFlow(cwd, dir);
     const manifests = await readFlowReviewManifests(cwd, dir);
+    let criteriaInFile;
+    if (readAcKindRecords(flow.acKinds) === undefined) {
+      try {
+        criteriaInFile = (await readAcCriteria(cwd, dir)).length;
+      } catch {
+        criteriaInFile = undefined;
+      }
+    }
     flows.push({
       id: flow.id,
       dir,
@@ -97297,6 +97531,7 @@ async function collectFlowGovernance(cwd, ledger) {
       spend: summarizeReviewSpend(manifests),
       confirmations: summarizeConfirmations(flow),
       gateOutcomes: summarizeGateOutcomes(flow),
+      acceptance: summarizeAcceptance(flow, criteriaInFile),
       dispatch: collectFlowDispatch(ledger, flow.id)
     });
   }
@@ -97335,9 +97570,11 @@ async function collectProjectGovernance(root, filters, displayName) {
 }
 var POLICY_DECISIONS_NOT_RECORDED;
 var init_aggregate = __esm(() => {
+  init_ac_kinds();
   init_store3();
   init_record2();
   init_spend();
+  init_accountability();
   POLICY_DECISIONS_NOT_RECORDED = {
     recorded: false,
     reason: "no durable log of an interactive session's own allow/ask/deny policy decisions exists in this build " + "(unattended dispatch runs are different: their denials are recorded per run, and reported under each " + "flow's own dispatch section below)"
@@ -97419,6 +97656,19 @@ function identityLine(identity) {
   }
   return `${identity.value ?? "unknown"} [${identity.basis}]`;
 }
+function renderAcceptanceLine(acceptance) {
+  if (acceptance === undefined || !acceptance.recorded) {
+    const total = acceptance?.total;
+    if (acceptance?.frozen === false) {
+      return `acceptance coverage: not frozen yet (${total ?? 0} criteria drafted; kinds are read at freeze)`;
+    }
+    return total === undefined ? "acceptance coverage: not recorded (predates verification kinds; every criterion reads unclassified)" : `acceptance coverage: 0/${total} runnable (0%) \u2014 all ${total} unclassified (predates verification kinds)`;
+  }
+  const { counts } = acceptance;
+  const total = acceptance.total ?? 0;
+  const percent = total === 0 ? 0 : Math.round(acceptance.runnable / total * 100);
+  return `acceptance coverage: ${acceptance.runnable}/${total} runnable (${percent}%) \u2014 ` + `exec ${counts.exec}, invariant ${counts.invariant}, judged ${counts.judged}, none ${counts.none}, unclassified ${counts.unclassified}`;
+}
 function renderGovernanceMarkdown(report) {
   const lines = [
     "# Governance report",
@@ -97451,6 +97701,7 @@ function renderGovernanceMarkdown(report) {
       lines.push(`status: ${flow.status}`);
       lines.push(`owner: ${identityLine(flow.owner)}`);
       lines.push(`review spend: spent=${usd(flow.spend.spentUsd)} (rounds_with_spent=${flow.spend.roundsWithSpentUsd}), ` + `input_tokens=${tokens(flow.spend.inputTokens)} (rounds=${flow.spend.roundsWithInputTokens}), ` + `output_tokens=${tokens(flow.spend.outputTokens)} (rounds=${flow.spend.roundsWithOutputTokens}), ` + `rounds_with_cost=${flow.spend.roundsWithCost}/${flow.spend.roundsTotal}`);
+      lines.push(renderAcceptanceLine(flow.acceptance));
       if (!flow.confirmations.recorded) {
         lines.push("confirmations: not recorded (predates signing)");
       } else {
@@ -121586,6 +121837,47 @@ async function runSimple(args, action) {
   const id = requireId(args);
   const flow = await getService2()[action]({ cwd: process.cwd(), id });
   console.log(`  ${style.green(symbols.ok)} Flow ${flow.id} ${style.cyan(symbols.arrow)} ${flowStatusLabel(flow.status)}`);
+  if (action === "freeze") {
+    await printAcKindDistribution(process.cwd(), flow.id);
+  }
+}
+async function printAcKindDistribution(cwd, id) {
+  try {
+    const { report, errors } = await getService2().acKinds({ cwd, id });
+    for (const line of renderAcKindDistribution(report)) {
+      console.log(`  ${style.dim(line)}`);
+    }
+    for (const error of errors) {
+      console.log(`  ${style.yellow(WARN)} ${error.id}: ${error.message} ${style.dim("(read as unclassified)")}`);
+    }
+    if (errors.length > 0) {
+      note(`\`keryx flow ac kinds ${id}\` names each malformed marker. The freeze went through: a kind never refuses one.`);
+    }
+  } catch {}
+}
+async function runAcKinds(args) {
+  const asJson = args.includes("--json");
+  const { positionals } = parseAcArgs(args.filter((arg) => arg !== "--json"), "kinds", [], 1);
+  const id = requireId(positionals);
+  const { report, errors } = await getService2().acKinds({ cwd: process.cwd(), id });
+  if (errors.length > 0) {
+    process.exitCode = 1;
+  }
+  if (asJson) {
+    console.log(JSON.stringify({ ...report, errors }, null, 2));
+    return;
+  }
+  heading(`Flow ${report.flowId}: acceptance kinds`);
+  for (const [criterionId, record] of Object.entries(report.criteria)) {
+    console.log(`  ${style.bold(criterionId.padEnd(5))} ${describeAcKind(record)}`);
+  }
+  console.log("");
+  for (const line of renderAcKindDistribution(report)) {
+    console.log(`  ${line}`);
+  }
+  for (const error of errors) {
+    console.error(`${style.red(symbols.cross)} ${error.id}: ${error.message}`);
+  }
 }
 async function runTask(args) {
   const sub = args[0];
@@ -121731,6 +122023,9 @@ async function runAc(args) {
     }
     return;
   }
+  if (sub === "kinds") {
+    return await runAcKinds(args.slice(1));
+  }
   if (sub === "reseal") {
     const { positionals, values } = parseAcArgs(args.slice(1), "reseal", AC_RESEAL_FLAGS, 1);
     const id = requireId(positionals);
@@ -121742,7 +122037,7 @@ async function runAc(args) {
     console.log(`  ${style.green(symbols.ok)} Checksum re-sealed over the unchanged file; ${style.dim(`${Object.keys(flow.acConfirmed).length} confirmation(s) kept`)}.`);
     return;
   }
-  throw new Error('Usage: keryx flow ac <confirm <id> <ACn> | update <id> --reason "<why>" [--criterion ACn --text "<criterion>"] | reseal <id> --reason "<why>"> ...');
+  throw new Error('Usage: keryx flow ac <confirm <id> <ACn> | update <id> --reason "<why>" [--criterion ACn --text "<criterion>"] | reseal <id> --reason "<why>" | kinds <id> [--json]> ...');
 }
 async function runCheckAcCommand(args) {
   const id = requireId(args);
@@ -122030,6 +122325,7 @@ function printHelp5() {
     'keryx flow ac update <id> --reason "<why>"   (re-freeze the file as already edited; VOIDS prior confirmations)',
     'keryx flow ac update <id> --criterion ACn --text "<criterion>" --reason "<why>"   (rewrite/append that one criterion, then re-freeze; VOIDS prior confirmations)',
     'keryx flow ac reseal <id> --reason "<why>"   (checksum stale, file unchanged; KEEPS confirmations)',
+    "keryx flow ac kinds <id> [--json]   (verification kind per criterion; read-only, never gates)",
     "  every `flow ac` subcommand refuses an argument it does not use \u2014 an extra positional, an unknown flag, or --criterion/--text given alone",
     "keryx flow check-ac <id> [--diff <ref>|--pr <n>] [--json] [--refresh]   (ADVISORY: Jev vs. the frozen criteria; never changes flow state)",
     "keryx flow implemented <id> --pr <url>",
@@ -158414,6 +158710,19 @@ var init_command_registry = __esm(() => {
       read: false,
       sideEffects: ["writes flow.json's acChecksum to match the file on disk; acConfirmed is left untouched"]
     },
+    {
+      module: "tasks",
+      command: "flow ac kinds",
+      summary: "Read a flow's acceptance-criteria.md and report each criterion's verification kind \u2014 exec, invariant, " + "judged, none or unclassified \u2014 from its trailing `[verify: ...]` marker, with the distribution and the " + "runnable coverage. Reads only: never gates, never runs a check, never calls a model. Exits 1 when a " + "marker is malformed, naming the criterion; that criterion reads unclassified.",
+      intent: ["\u0432\u0438\u0434\u044B \u043F\u0440\u043E\u0432\u0435\u0440\u043A\u0438 \u043A\u0440\u0438\u0442\u0435\u0440\u0438\u0435\u0432", "flow ac kinds", "acceptance criteria verification kinds", "ac coverage"],
+      args: [
+        { name: "<id>", type: "string", required: true, desc: "flow id" },
+        { name: "json", type: "bool", required: false, desc: "print the report as JSON, with the per-criterion records and any marker errors" }
+      ],
+      json: true,
+      read: true,
+      sideEffects: []
+    },
     {
       module: "tasks",
       command: "flow complete",
@@ -177115,6 +177424,10 @@ ledger (.metaproject/data/trigger/runs.jsonl). Never re-runs a gate, never
 calls a model or a network service. A figure nobody recorded is reported as
 "not recorded", never as zero.
 
+Each flow also shows its acceptance coverage: how many criteria are runnable
+(exec or invariant) of all of them. A flow frozen before verification kinds
+existed reads as fully unclassified, not as zero criteria.
+
 \`report\` writes .metaproject/data/governance/artifacts/latest.md and
 latest.json (schema-versioned), then prints the report. \`show\` reprints the
 most recently written report without regenerating it.

package/dist/core.js

@@ -21627,6 +21627,7 @@ init_validator();
 var exports_service2 = {};
 __export(exports_service2, {
   AC_CHECK_TOKEN_BUDGET: () => AC_CHECK_TOKEN_BUDGET,
+  AC_KINDS: () => AC_KINDS,
   CONFIRMATION_CAVEAT: () => CONFIRMATION_CAVEAT,
   REVIEW_GATE_CONFIG_PATH: () => REVIEW_GATE_CONFIG_PATH,
   acCheckCacheKey: () => acCheckCacheKey,
@@ -21636,10 +21637,13 @@ __export(exports_service2, {
   assertAcIntact: () => assertAcIntact,
   baseBranchCondition: () => baseBranchCondition,
   batchAcCheckItems: () => batchAcCheckItems,
+  buildAcKindReport: () => buildAcKindReport,
+  classifyAcCriterionNotCheckable: () => classifyAcCriterionNotCheckable,
   classifyNotCheckable: () => classifyNotCheckable,
   computeAcFacts: () => computeAcFacts,
   confirmPreconditionError: () => confirmPreconditionError,
   createFlowService: () => createFlowService,
+  describeAcKind: () => describeAcKind,
   evaluatedVerdict: () => evaluatedVerdict,
   extractCriterionTokens: () => extractCriterionTokens,
   factsOnlyVerdict: () => factsOnlyVerdict,
@@ -21649,12 +21653,16 @@ __export(exports_service2, {
   parseAcceptanceCriteria: () => parseAcceptanceCriteria,
   readAcCheckCache: () => readAcCheckCache,
   readAcCheckEnabled: () => readAcCheckEnabled,
+  readAcKindRecords: () => readAcKindRecords,
   readFlow: () => readFlow,
   renderAcCheckAdvisoryNotice: () => renderAcCheckAdvisoryNotice,
   renderAcCheckReport: () => renderAcCheckReport,
+  renderAcKindDistribution: () => renderAcKindDistribution,
+  reportFromRecords: () => reportFromRecords,
   resolveFlowDir: () => resolveFlowDir,
   selectMatchedHunks: () => selectMatchedHunks,
   statusLabel: () => statusLabel,
+  stripVerifyMarker: () => stripVerifyMarker,
   summarizeVerdicts: () => summarizeVerdicts,
   validateCriterionName: () => validateCriterionName,
   writeAcCheckCache: () => writeAcCheckCache
@@ -23979,6 +23987,161 @@ async function readRequireConfirmationDefault(cwd) {
     return false;
   }
 }
+// src/flow/ac-kinds.ts
+var AC_KINDS = ["exec", "invariant", "judged", "none", "unclassified"];
+var AC_LINE = /^\s*[-*]\s*(AC\d+)\s*:\s?(.*)$/i;
+var MARKER_OPEN = "[verify:";
+function maskCodeSpans(text) {
+  return text.replace(/`[^`]*`/g, (span) => " ".repeat(span.length));
+}
+function scanMarkers(text) {
+  const masked = maskCodeSpans(text);
+  let occurrences = 0;
+  let lastStart = -1;
+  for (let at = masked.indexOf(MARKER_OPEN);at !== -1; at = masked.indexOf(MARKER_OPEN, at + MARKER_OPEN.length)) {
+    occurrences += 1;
+    lastStart = at;
+  }
+  const end = text.trimEnd().length;
+  return { occurrences, lastStart, trailing: occurrences > 0 && end > lastStart && text[end - 1] === "]", end };
+}
+function stripVerifyMarker(text) {
+  const scan = scanMarkers(text);
+  if (!scan.trailing || scan.occurrences !== 1)
+    return text;
+  return text.slice(0, scan.lastStart).trimEnd();
+}
+var KIND_WORDS = "exec, invariant, judged or none";
+function unclassified(error) {
+  return error === undefined ? { record: { kind: "unclassified" } } : { record: { kind: "unclassified" }, error };
+}
+function parseAcKindText(text) {
+  const scan = scanMarkers(text);
+  if (scan.occurrences === 0)
+    return unclassified();
+  if (scan.occurrences > 1) {
+    return unclassified("a second [verify: \u2026] marker \u2014 a criterion carries exactly one, as the last thing on its line");
+  }
+  if (!scan.trailing) {
+    return unclassified("the [verify: \u2026] marker must be the last thing on the line and close with `]`");
+  }
+  const payload = text.slice(scan.lastStart + MARKER_OPEN.length, scan.end - 1).trim();
+  if (payload.length === 0)
+    return unclassified(`an empty [verify: \u2026] marker \u2014 expected ${KIND_WORDS}`);
+  const word = /^[A-Za-z]+/.exec(payload)?.[0] ?? "";
+  const rest = payload.slice(word.length).trim();
+  switch (word) {
+    case "judged":
+      return rest.length === 0 ? { record: { kind: "judged" } } : unclassified("`judged` takes no arguments \u2014 write [verify: judged]");
+    case "exec":
+    case "invariant": {
+      if (rest.length === 0)
+        return unclassified(`\`${word}\` requires a backticked command, e.g. [verify: ${word} \`bun test path/to.test.ts\`]`);
+      const command = /^`([^`]*)`$/.exec(rest);
+      if (command === null)
+        return unclassified(`\`${word}\` requires exactly one backticked command after the kind, e.g. [verify: ${word} \`bun test path/to.test.ts\`]`);
+      const check = (command[1] ?? "").trim();
+      if (check.length === 0)
+        return unclassified(`\`${word}\` has an empty backticked command`);
+      return { record: { kind: word, check } };
+    }
+    case "none": {
+      if (rest.length === 0)
+        return unclassified("`none` requires a reason after an em dash, e.g. [verify: none \u2014 <reason>]");
+      const reason = /^\u2014\s*([\s\S]*)$/.exec(rest);
+      if (reason === null)
+        return unclassified("`none` requires its reason after an em dash (\u2014), e.g. [verify: none \u2014 <reason>]");
+      const why = (reason[1] ?? "").trim();
+      if (why.length === 0)
+        return unclassified("`none` has an empty reason after the em dash");
+      return { record: { kind: "none", reason: why } };
+    }
+    default:
+      return unclassified(`unknown verification kind "${word.length > 0 ? word : payload}" \u2014 expected ${KIND_WORDS}`);
+  }
+}
+function parseAcKinds(content) {
+  const criteria = [];
+  const errors = [];
+  for (const line of content.split(/\r?\n/)) {
+    const match = AC_LINE.exec(line);
+    if (!match?.[1])
+      continue;
+    const id = match[1].toUpperCase();
+    const rawText = (match[2] ?? "").trim();
+    const parsed = parseAcKindText(rawText);
+    if (parsed.error !== undefined)
+      errors.push({ id, message: parsed.error });
+    criteria.push({ id, text: stripVerifyMarker(rawText), rawText, record: parsed.record });
+  }
+  return { criteria, errors };
+}
+function emptyCounts() {
+  return { exec: 0, invariant: 0, judged: 0, none: 0, unclassified: 0 };
+}
+function buildAcKindReport(flowId, content) {
+  const parsed = parseAcKinds(content);
+  const criteria = {};
+  for (const criterion of parsed.criteria) {
+    if (!(criterion.id in criteria))
+      criteria[criterion.id] = criterion.record;
+  }
+  return { report: reportFromRecords(flowId, criteria), errors: parsed.errors };
+}
+function reportFromRecords(flowId, criteria) {
+  const counts = emptyCounts();
+  for (const record of Object.values(criteria))
+    counts[record.kind] += 1;
+  return {
+    flowId,
+    criteria,
+    counts,
+    runnable: counts.exec + counts.invariant,
+    total: Object.keys(criteria).length
+  };
+}
+function renderAcKindDistribution(report) {
+  const { counts } = report;
+  const percent = report.total === 0 ? 0 : Math.round(report.runnable / report.total * 100);
+  const tail = [`${counts.none} accepted as unverifiable`, `${counts.judged} judged`, ...counts.unclassified > 0 ? [`${counts.unclassified} unclassified`] : []];
+  return [
+    `acceptance kinds: exec ${counts.exec}  invariant ${counts.invariant}  judged ${counts.judged}  none ${counts.none}  unclassified ${counts.unclassified}   (${report.total} criteria)`,
+    `coverage: ${report.runnable}/${report.total} runnable (${percent}%)  \xB7  ${tail.join("  \xB7  ")}`
+  ];
+}
+function describeAcKind(record) {
+  switch (record.kind) {
+    case "exec":
+    case "invariant":
+      return `${record.kind} \`${record.check}\``;
+    case "none":
+      return `none \u2014 ${record.reason}`;
+    default:
+      return record.kind;
+  }
+}
+function readAcKindRecords(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return;
+  const out = {};
+  for (const [id, raw] of Object.entries(value)) {
+    if (typeof raw !== "object" || raw === null)
+      return;
+    const record = raw;
+    const kind = record["kind"];
+    if ((kind === "exec" || kind === "invariant") && typeof record["check"] === "string")
+      out[id] = { kind, check: record["check"] };
+    else if (kind === "judged")
+      out[id] = { kind };
+    else if (kind === "none" && typeof record["reason"] === "string")
+      out[id] = { kind, reason: record["reason"] };
+    else if (kind === "unclassified")
+      out[id] = { kind };
+    else
+      return;
+  }
+  return out;
+}
 // src/flow/check-ac.ts
 import { createHash as createHash8 } from "crypto";
 import { chmod as chmod4, mkdir as mkdir9, readFile as readFile21 } from "fs/promises";
@@ -23992,11 +24155,11 @@ function estimateTokens(text) {
 // src/flow/check-ac.ts
 init_service2();
 init_fs();
-var AC_LINE = /^\s*[-*]\s*(AC\d+)\s*:\s?(.*)$/i;
+var AC_LINE2 = /^\s*[-*]\s*(AC\d+)\s*:\s?(.*)$/i;
 function parseAcceptanceCriteria(content) {
   const out = [];
   for (const line of content.split(/\r?\n/)) {
-    const match = AC_LINE.exec(line);
+    const match = AC_LINE2.exec(line);
     if (match?.[1]) {
       out.push({ id: match[1].toUpperCase(), text: (match[2] ?? "").trim() });
     }
@@ -24043,6 +24206,9 @@ function classifyNotCheckable(criterionText) {
     reason: `not-checkable: every clause of this criterion names a condition no diff records (${labels.join(", ")}) \u2014 assigned without asking Jev.`
   };
 }
+function classifyAcCriterionNotCheckable(criterion) {
+  return classifyNotCheckable(stripVerifyMarker(criterion.text));
+}
 function extractCriterionTokens(text) {
   const tokens = new Set;
   for (const match of text.matchAll(/`([^`]+)`/g)) {
@@ -24060,7 +24226,7 @@ function extractCriterionTokens(text) {
   return [...tokens];
 }
 function computeAcFacts(criterion, diffText, changedFiles) {
-  const tokens = extractCriterionTokens(criterion.text);
+  const tokens = extractCriterionTokens(stripVerifyMarker(criterion.text));
   const tokensPresent = tokens.filter((token) => diffText.includes(token) || changedFiles.some((file) => file.includes(token)));
   const tokensAbsent = tokens.filter((token) => !tokensPresent.includes(token));
   const testFiles = changedFiles.filter((file) => /\.(test|spec)\.[a-z]+$/i.test(file));
@@ -24086,7 +24252,7 @@ var AC_CHECK_TOKEN_BUDGET = 64000;
 function questionFor(criterion) {
   return {
     type: "noul",
-    instructions: `Given the deterministic facts and the redacted diff evidence above, does this change LIKELY SATISFY this frozen ` + `acceptance criterion? Criterion ${criterion.id}: ${redactSensitiveText(criterion.text)}`
+    instructions: `Given the deterministic facts and the redacted diff evidence above, does this change LIKELY SATISFY this frozen ` + `acceptance criterion? Criterion ${criterion.id}: ${redactSensitiveText(stripVerifyMarker(criterion.text))}`
   };
 }
 var MAX_MATCHED_HUNKS_PER_ITEM = 8;
@@ -24431,6 +24597,10 @@ function renderJournal(createdAt) {
 }
 
 // src/flow/service.ts
+async function deriveAcKinds(cwd, dir, flowId) {
+  const { report } = buildAcKindReport(flowId, await readFile23(acPath(cwd, dir), "utf8"));
+  return { ...report.criteria };
+}
 function recordAttempt(task, outcome, at, detail) {
   const attempts = task.attempts ?? { count: 0, log: [] };
   attempts.count += 1;
@@ -24628,6 +24798,7 @@ function createFlowService(deps) {
           throw new Error("Cannot freeze: acceptance-criteria.md must contain at least one real `- ACn:` criterion.");
         }
         flow.acChecksum = await acChecksum(cwd, dir);
+        flow.acKinds = await deriveAcKinds(cwd, dir, flow.id);
         flow.status = "ready";
         return save(cwd, dir, flow, "frozen", `${criteria.length} criteria; checksum recorded`);
       });
@@ -24772,10 +24943,15 @@ function createFlowService(deps) {
           detail = `${normalizedCriterion}: "${previousText ?? "(new)"}" -> "${normalizedText}" (${reason.trim()})`;
         }
         flow.acChecksum = await acChecksum(cwd, dir);
+        flow.acKinds = await deriveAcKinds(cwd, dir, flow.id);
         flow.acConfirmed = {};
         return save(cwd, dir, flow, "ac-updated", detail);
       });
     },
+    async acKinds({ cwd, id }) {
+      const { dir, flow } = await load(cwd, id);
+      return buildAcKindReport(flow.id, await readFile23(acPath(cwd, dir), "utf8"));
+    },
     async acReseal({ cwd, id, reason }) {
       if (!reason?.trim()) {
         throw new Error('flow ac reseal requires --reason "<why the checksum is stale>"');
@@ -24794,6 +24970,7 @@ function createFlowService(deps) {
           throw new Error(`flow ac reseal: refusing \u2014 ${evidence.reason}. ` + "Reseal only re-seals a stale checksum over an unchanged file; it is not a way to " + 'accept an edit. If the criteria really changed, use `keryx flow ac update <id> --reason "..."`, ' + "which re-seals AND voids the prior confirmations.");
         }
         flow.acChecksum = current;
+        flow.acKinds = await deriveAcKinds(cwd, dir, flow.id);
         return save(cwd, dir, flow, "ac-resealed", reason);
       });
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrciphersmith/keryx",
-  "version": "0.3.28",
+  "version": "0.3.29",
   "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": {

package/src/gdskills/bundled/rules/core/requirements-package-standard.mdc

@@ -62,11 +62,26 @@ document changes.
 - problem;
 - goal;
 - users;
-- requirements;
-- success criteria;
+- requirements, each carrying a verification field (see Verification Field below);
+- success criteria, split into two lists (see Success Contract below);
 - risks;
 - recommendation.
 
+### Success Contract
+
+The PRD's success criteria are two lists, never one:
+
+- **Release criteria** are checkable when the work ships: a test, a command, a
+  file, a count. Each is something a release can be blocked on.
+- **Outcome criteria** are what should be true some time after release: adoption,
+  a measured change, a behavior seen in use. Each outcome criterion either names
+  the observation that would confirm it (what is looked at, where, and when) or
+  declares `not measured — <reason>`.
+
+An outcome criterion with neither an observation nor a `not measured — <reason>`
+is not a criterion. A list whose every entry is `not measured` is acceptable: it
+is honest. A PRD with no outcome list at all is not.
+
 ## Specification Contract
 
 `specification.md` must state:
@@ -79,6 +94,21 @@ document changes.
 - integration points;
 - acceptance criteria.
 
+### Verification Field
+
+Every requirement in the PRD (each `R<n>` under Requirements) carries one verification field, in the
+same vocabulary a flow criterion's trailing marker uses:
+
+```markdown
+Verification: exec `<command>`            # a command whose exit code decides it
+Verification: invariant `<command>`       # a command that must keep passing
+Verification: judged                      # a person reads the evidence
+Verification: none — <reason>             # honestly unverifiable, with the reason
+```
+
+`exec` and `invariant` name a backticked command; `none` names its reason after
+an em dash. A requirement with no field is a defect, not a `none`.
+
 ## Verification Contract
 
 Before finishing:
@@ -88,6 +118,11 @@ Before finishing:
 - verify README links to all package files;
 - verify schemas are referenced from specification when present;
 - verify status is honest: `draft`, `spec ready`, `implemented`, or `future`;
+- verify every PRD requirement carries a `Verification:` field, and
+  fail the package when one does not, naming that requirement;
+- verify the PRD has both a release-criteria list and an outcome-criteria list,
+  and fail the package when the outcome list is missing (an outcome list whose
+  entries are all `not measured — <reason>` passes);
 - update `docs/requirements/roadmap.md` when the package represents a module or
   standard capability.
 

package/src/gdskills/bundled/skills/planning/docpack-orchestrator/SKILL.md

@@ -109,10 +109,8 @@ Add optional files only when justified:
 Write concise Markdown with explicit headings. Required contracts:
 
 - README: purpose, status, document index, scope, related modules.
-- PRD: problem, goal, users, requirements, success criteria, risks,
-  recommendation.
-- Specification: identity, structure, manifest/config, CLI/skill surface, data
-  contracts, integrations, acceptance criteria.
+- PRD: problem, goal, users, requirements (each `R<n>` carries a `Verification:` field: `exec`/`invariant` with a backticked command, `judged`, or `none — <reason>`), success criteria (a release list and an outcome list; an outcome criterion names its observation or declares `not measured — <reason>`), risks, recommendation.
+- Specification: identity, structure, manifest/config, CLI/skill surface, data contracts, integrations, acceptance criteria.
 
 When updating existing docs, preserve useful content and bump versions.
 
@@ -125,6 +123,7 @@ Run a local verification pass:
 - README links to every package file;
 - schema files are valid JSON;
 - specification references schemas when present;
+- every PRD requirement has a `Verification:` field (a package with a requirement that omits it FAILS, naming that requirement); the PRD has a release list and an outcome list (no outcome list FAILS; an outcome list whose entries are all `not measured — <reason>` passes);
 - roadmap is updated for new module/standard capabilities;
 - no implementation status is overstated.
 
@@ -154,6 +153,7 @@ Do not emit the Final Response until all of these hold:
 - Every Markdown file in the package carries a `Version`, and every file you changed has a bumped one.
 - `README.md` links to every file in the package; the specification links to each schema it defines.
 - Every `schemas/*.json` parses as valid JSON.
+- Every specification requirement carries a `Verification:` field, and the PRD carries both a release list and an outcome list; a package missing either was reported as `verification: fail`, naming the requirement.
 - `docs/requirements/roadmap.md` is updated when the package represents a new module or capability, or the report states why it does not.
 - No implementation claim appears that code does not support; anything unbuilt is marked planned or future.
 - `docpack-review` has been run in Phase 5 and reports zero blockers. Remaining warnings appear verbatim in `remaining_gaps`.