@starci/skills 1.1.0 → 1.2.0

package/operators/frontend-presentation-resolve/self-test.mjs

@@ -1,7 +1,7 @@
 // Proves validate.mjs on a synthetic session branch: one conforming resolution of a three-node tree
 // (one application-owned gap, one Grammar-owned padding, one recorded gap), one branch with the
-// contract emission off, one blocked on RULE_MISSING before anything was written, and one mutation
-// per law, each of which must fail with a line that names the defect.
+// contract emission off, one blocked on RULE_MISSING before anything was written, one whose gap rule
+// claims no attribute because its node publishes no path for one, and one mutation per law, each of which must fail with a line that names the defect.
 import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -107,7 +107,7 @@ function writeBranch(files) {
   for (const d of ['request', 'response/data', 'response/artifacts']) mkdirSync(path.join(branch, d), { recursive: true });
   mkdirSync(path.join(session, 'step-1', 'parallel-1', 'response'), { recursive: true });
   writeFileSync(path.join(session, 'step-1', 'parallel-1', 'response', 'response.md'), '# frontend-direction-decision — plan-picker\n');
-  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', chain: [['1/1'], ['2/1']], steps: { '1/1': 'frontend.direction.decide', '2/1': 'frontend.presentation.resolve' }, current: '2/1', status: 'running' }));
+  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', project: 'starci-academy', startedAt: '2026-09-03T00:00:00Z', requestHashes: {}, chain: [['1/1'], ['2/1']], steps: { '1/1': 'frontend.direction.decide', '2/1': 'frontend.presentation.resolve' }, current: '2/1', status: 'running' }));
   for (const [name, content] of Object.entries(files)) {
     if (content === null) continue;
     writeFileSync(path.join(branch, name), typeof content === 'string' ? content : JSON.stringify(content, null, 2));
@@ -140,13 +140,14 @@ const mutate = (change) => { const m = inventory(); change(m); return { ...basel
 await expectValid(baseline(), 'one application-owned gap, one Grammar-owned padding, one recorded gap');
 await expectValid({ ...baseline(), 'request/request.json': requestJson({ extra: { contractEmission: 'off' } }), [TREE]: resolvedTree({ emission: 'off' }) }, 'contract emission off leaves the tree bare');
 await expectValid({ 'request/request.json': requestJson(), 'response/response.json': responseJson({ status: 'blocked', stop: 'RULE_MISSING', next: [], fields: {} }) }, 'blocked on RULE_MISSING before anything was written');
+await expectValid({ ...baseline(), [TREE]: resolvedTree().replace(' data-contract="GAP-1"', '') }, 'a rule whose only node is recorded under Gaps claims no attribute');
 
 await expectError({ ...baseline(), 'request/request.json': requestJson({ extra: { mystery: 1 } }) }, 'requirements.mystery is not a field', 'undeclared requirement');
 await expectError({ ...baseline(), 'request/request.json': requestJson({ extra: { maxRounds: 0 } }) }, 'maxRounds must be a positive whole number', 'no rounds allowed');
 await expectError(mutate((m) => { m.ruleIds.push('GAP-99'); }), 'is outside the published presentation inventory', 'unpublished rule');
 await expectError(mutate((m) => { m.classNames.push('gap-11'); }), 'is in the inventory and not in the resolved tree', 'class that never reached the tree');
 await expectError(mutate((m) => { m.treeFingerprint = 'nope'; }), 'treeFingerprint', 'inventory schema');
-await expectError({ ...baseline(), [TREE]: resolvedTree().replace(' data-contract="GAP-1"', '') }, 'no node claims it under data-contract', 'applied rule with no claim');
+await expectError({ ...baseline(), [TREE]: resolvedTree().replace(' data-contract="GAP-5"', '') }, 'no node claims it under data-contract', 'applied rule with no claim');
 await expectError({ ...baseline(), 'request/request.json': requestJson({ extra: { contractEmission: 'off' } }) }, 'contract emission is off and the resolved tree carries a data-contract', 'claims written under emission off');
 await expectError({ ...baseline(), 'response/response.md': responseMd().replace('| `body>main` | `GAP-5` | `gap-6` |', '| `body>main` | `GAP-5` | `gap-5` |'), 'response/data/inventory.json': (() => { const m = inventory(); m.classNames = ['gap-5', 'gap-1']; return m; })(), [TREE]: resolvedTree().replace('gap-6', 'gap-5') }, 'renders GAP-5 as gap-5, expected step 6', 'ordinal written as the step');
 await expectError({ ...baseline(), 'response/response.md': responseMd().replace(`| \`${SECTION}\` | padding | grammar | \`PADDING-4\` |`, `| \`${SECTION}\` | padding | app | \`PADDING-4\` |`) }, 'owns PADDING-4 and chooses no class for it', 'application claims an owned property and writes nothing');
@@ -160,4 +161,4 @@ await expectError({ ...baseline(), 'response/data/inventory.json': null, 'respon
 await expectError({ ...baseline(), 'response/response.json': responseJson({ status: 'blocked', stop: 'MADE_UP_CODE', next: [] }) }, 'not a registered code', 'unknown stop code');
 await expectError({ ...baseline(), 'response/response.json': responseJson({ fallbacks: ['RULE_MISSING'] }) }, 'has disposition terminate under these requirements', 'a terminate code taken as a fallback');
 
-process.stdout.write('frontend.presentation.resolve self-test: 3 valid branches, 18 rejected mutations\n');
+process.stdout.write('frontend.presentation.resolve self-test: 4 valid branches, 18 rejected mutations\n');

package/operators/frontend-presentation-resolve/validate.mjs

@@ -3,7 +3,8 @@
 // carries appears in the resolved tree; a Grammar-owned property emits no application class while an
 // application-owned one emits a class whose step matches the ordinal of its rule; the gaps the
 // receipt lists are exactly the gaps the inventory records; and with emission on every claimed rule
-// reaches the tree as a data-contract token.
+// reaches the tree as a data-contract token, except a rule whose every node the receipt records under
+// `## Gaps`, which has no attribute to reach.
 import { existsSync } from 'node:fs';
 import { readFile, readdir } from 'node:fs/promises';
 import path from 'node:path';
@@ -67,6 +68,21 @@ export async function validateResolutionStep(branchDir, root = ROOT) {
     if (!published.has(ruleId)) errors.push(`${at}: rule ${ruleId} is outside the published presentation inventory (UNKNOWN_RULE)`);
   }
 
+  // The receipt is read before the tree, because a rule recorded under `## Gaps` is a rule whose node
+  // publishes no path for the attribute: the emission check below must know that before it accuses the
+  // tree of hiding a claim that could never have been written.
+  const receiptText = present.has('frontend-presentation-resolution') && has('response/response.md') ? await read('response/response.md') : null;
+  const gapRows = receiptText === null ? [] : (tableUnder(receiptText, '## Gaps') ?? []);
+  const gapNodes = new Set(gapRows.map(([node]) => node));
+  const chosenRows = receiptText === null ? [] : (tableUnder(receiptText, '## Rules chosen') ?? []);
+  // A rule is exempt only when every node that chose it is a gap node; one ordinary node still owes
+  // its attribute.
+  const gapOnlyRules = new Set();
+  for (const [, rule] of chosenRows) {
+    const nodes = chosenRows.filter(([, r]) => r === rule).map(([n]) => n);
+    if (nodes.length && nodes.every((n) => gapNodes.has(n))) gapOnlyRules.add(String(rule).replace(/`/g, ''));
+  }
+
   // The resolved tree is the only place the classes may land, so every class the inventory claims
   // must actually be in it.
   const treeRefs = list(response.fields?.['resolved-tree']);
@@ -79,19 +95,23 @@ export async function validateResolutionStep(branchDir, root = ROOT) {
     }
     if (emission === 'on') {
       for (const ruleId of inventory.ruleIds) {
+        // A property the application owns on a Grammar component's className carries no attribute:
+        // the component forwards className and nothing else, so the claim is recorded under `## Gaps`
+        // instead of being demanded of a tree that cannot carry it.
+        if (gapOnlyRules.has(ruleId)) continue;
         const claimed = [...tree.matchAll(/data-contract="([^"]*)"/g)].some((m) => m[1].split(/\s+/).includes(ruleId));
         if (!claimed) errors.push(`${at}: rule ${ruleId} is applied and no node claims it under data-contract`);
       }
     } else if (/data-contract=/.test(tree)) errors.push('response/artifacts: contract emission is off and the resolved tree carries a data-contract attribute');
   }
 
-  if (present.has('frontend-presentation-resolution') && has('response/response.md')) {
-    const text = await read('response/response.md');
+  if (receiptText !== null) {
+    const text = receiptText;
     const rel = 'response/response.md';
     const owners = tableUnder(text, '## Owner map') ?? [];
-    const chosen = tableUnder(text, '## Rules chosen') ?? [];
+    const chosen = chosenRows;
     const removed = tableUnder(text, '## Removed') ?? [];
-    const gaps = tableUnder(text, '## Gaps') ?? [];
+    const gaps = gapRows;
 
     const appRules = new Set();
     const grammarRules = new Set();
@@ -129,7 +149,11 @@ export async function validateResolutionStep(branchDir, root = ROOT) {
     const receiptGaps = gaps.map(([node, property, missing]) => `${node}|${property}|${missing}`).sort();
     const dataGaps = inventory.gaps.map((g) => `${g.nodePath}|${g.property}|${g.missingPath}`).sort();
     if (receiptGaps.join('\n') !== dataGaps.join('\n')) {
-      errors.push(`${rel}: the Gaps table and inventory.gaps differ (${receiptGaps.length} rows against ${dataGaps.length})`);
+      // Two counts say nothing about which row is wrong, so the first row that differs is named.
+      const width = Math.max(receiptGaps.length, dataGaps.length);
+      let first = 0;
+      while (first < width && receiptGaps[first] === dataGaps[first]) first += 1;
+      errors.push(`${rel}: the Gaps table and inventory.gaps differ (${receiptGaps.length} rows against ${dataGaps.length}); the first differing row is the receipt's ${receiptGaps[first] ?? '(absent)'} against the inventory's ${dataGaps[first] ?? '(absent)'}`);
     }
   }
   return { errors };

package/operators/frontend-source-apply/operator.md

@@ -95,7 +95,9 @@ knows what it wrote, never how it renders.
 | 7 | Emit | — | everything above | `response/response.md`, `response/changes.md`, `response/response.json` | — |
 
 Under `mode = dry` the branch stops after step 4 with the plan alone: `writes.json` carries a null
-commit, `response.json` carries no commit, and the checkout is untouched. Under `apply`, step 5 writes
+commit, `response.json` carries no commit, and the checkout is untouched. A dry run is granted neither
+`@tools/sourcewrite` nor `@tools/git`, because a mode that writes nothing needs no tool that can
+write; the grant and this paragraph say the same thing so neither can drift. Under `apply`, step 5 writes
 and commits exactly once and step 6 proves that the committed tree is the resolved tree. `changes.md`
 is the record the next steps read: which paths moved, which claims they carry, which gates the
 checkout pins for them, and which surfaces must now be observed.

package/operators/frontend-source-apply/operator.vi.md

@@ -94,7 +94,9 @@ không bao giờ biết nó render ra sao.
 | 7 | Phát | — | mọi thứ ở trên | `response/response.md`, `response/changes.md`, `response/response.json` | — |
 
 Dưới `mode = dry`, nhánh dừng sau bước 4 với riêng bản kế hoạch: `writes.json` mang commit rỗng,
-`response.json` không mang commit nào, và checkout y nguyên. Dưới `apply`, bước 5 ghi rồi commit đúng
+`response.json` không mang commit nào, và checkout y nguyên. Một lượt dry không được cấp
+`@tools/sourcewrite` lẫn `@tools/git`, vì một chế độ không ghi gì thì không cần công cụ nào ghi được;
+phần cấp quyền và đoạn này nói cùng một điều nên chúng không thể trôi khỏi nhau. Dưới `apply`, bước 5 ghi rồi commit đúng
 một lần và bước 6 chứng minh rằng cây đã commit đúng là cây đã resolve. `changes.md` là bản ghi mà
 các bước sau đọc: path nào đã dịch chuyển, chúng mang lời khai nào, checkout ghim cổng nào cho chúng,
 và bề mặt nào bây giờ phải được quan sát.

package/operators/frontend-source-apply/self-test.mjs

@@ -145,7 +145,7 @@ function writeBranch(files, { inventoryDoc = inventory(), withInventory = true }
   writeFileSync(path.join(session, 'step-1', 'parallel-1', 'response', 'response.md'), '# frontend-direction-decision — plan-picker\n');
   writeFileSync(path.join(session, 'step-2', 'parallel-1', 'response', 'response.md'), '# frontend-presentation-resolution — plan-picker\n');
   if (withInventory) writeFileSync(path.join(upstream, 'inventory.json'), JSON.stringify(inventoryDoc, null, 2));
-  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: SESSION, chain: [['2/1'], ['3/1']], steps: { '2/1': 'frontend.presentation.resolve', '3/1': 'frontend.source.apply' }, current: '3/1', status: 'running' }));
+  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: SESSION, project: 'starci-academy', startedAt: '2026-09-03T00:00:00Z', requestHashes: {}, chain: [['2/1'], ['3/1']], steps: { '2/1': 'frontend.presentation.resolve', '3/1': 'frontend.source.apply' }, current: '3/1', status: 'running' }));
   for (const [name, content] of Object.entries(files)) {
     if (content === null) continue;
     writeFileSync(path.join(branch, name), typeof content === 'string' ? content : JSON.stringify(content, null, 2));

package/operators/frontend-surface-audit/self-test.mjs

@@ -123,7 +123,7 @@ function writeBranch(files) {
     mkdirSync(dir, { recursive: true });
     writeFileSync(path.join(dir, 'response.md'), `# ${name} — plan-picker\n`);
   }
-  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', chain: [['3/1'], ['4/1']], steps: { '3/1': 'frontend.source.apply', '4/1': 'frontend.surface.audit' }, current: '4/1', status: 'running' }));
+  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', project: 'starci-academy', startedAt: '2026-09-03T00:00:00Z', requestHashes: {}, chain: [['3/1'], ['4/1']], steps: { '3/1': 'frontend.source.apply', '4/1': 'frontend.surface.audit' }, current: '4/1', status: 'running' }));
   for (const [name, content] of Object.entries(files)) {
     if (content === null) continue;
     writeFileSync(path.join(branch, name), typeof content === 'string' ? content : JSON.stringify(content, null, 2));

package/operators/git-publish/self-test.mjs

@@ -102,7 +102,7 @@ function writeBranch(files) {
   const session = mkdtempSync(path.join(tmpdir(), 'publish-session-'));
   const branch = path.join(session, 'step-1', 'parallel-1');
   for (const d of ['request', 'response/data', 'response/artifacts']) mkdirSync(path.join(branch, d), { recursive: true });
-  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', chain: [['1/1']], steps: { '1/1': 'git.publish' }, current: '1/1', status: 'running' }));
+  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', project: 'starci-academy', startedAt: '2026-09-03T00:00:00Z', requestHashes: {}, chain: [['1/1']], steps: { '1/1': 'git.publish' }, current: '1/1', status: 'running' }));
   for (const name of ['response.md', 'changes.md', 'quality.md']) writeFileSync(path.join(branch, 'response', name), '# placeholder\n');
   for (const [name, content] of Object.entries(files)) {
     if (content === null) continue;

package/operators/platform-operate/self-test.mjs

@@ -122,7 +122,7 @@ function writeBranch(files) {
   const session = mkdtempSync(path.join(tmpdir(), 'platform-session-'));
   const branch = path.join(session, 'step-1', 'parallel-1');
   for (const d of ['request', 'response/data', 'response/artifacts']) mkdirSync(path.join(branch, d), { recursive: true });
-  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', chain: [['1/1']], steps: { '1/1': 'platform.operate' }, current: '1/1', status: 'running' }));
+  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', project: 'starci-academy', startedAt: '2026-09-03T00:00:00Z', requestHashes: {}, chain: [['1/1']], steps: { '1/1': 'platform.operate' }, current: '1/1', status: 'running' }));
   for (const [name, content] of Object.entries(files)) {
     if (content === null) continue;
     writeFileSync(path.join(branch, name), typeof content === 'string' ? content : JSON.stringify(content, null, 2));

package/operators/quality-verify/operator.md

@@ -15,7 +15,11 @@ predecessor receipt must report the same source head, and that head must be the
 `request/request.json` froze; two predecessors on different heads describe two different deliveries,
 and gating the union of them measures something nobody built. That is `PREDECESSOR_MIXED`, refused
 before a single command runs rather than discovered later as a confusing gate failure. A predecessor
-whose fingerprint no longer matches the frozen source is `PREDECESSOR_STALE`. What a predecessor
+whose fingerprint no longer matches the frozen source is `PREDECESSOR_STALE`. So is a predecessor
+produced under `mode: dry`: it carries no commit and describes a plan rather than a delivery, its
+change record says `nothing written` and its receipt's `Commit` reads `—`, and it is refused at step 2
+before any command runs, because a plan has no head to stand on and gating the base head would
+publish a green verdict about code nobody wrote. What a predecessor
 decided is consumed unchanged: this operator never re-plans the delivery, re-opens its boundary, or
 forms an opinion about whether the change was a good one.
 

package/operators/quality-verify/operator.vi.md

@@ -15,7 +15,11 @@ tiền nhiệm phải báo cùng một source head, và head đó phải là hea
 băng; hai tiền nhiệm trên hai head khác nhau mô tả hai delivery khác nhau, và gác hợp của chúng là đo
 một thứ không ai xây. Đó là `PREDECESSOR_MIXED`, bị từ chối trước khi có lệnh nào chạy thay vì lộ ra
 về sau dưới dạng một lỗi cổng khó hiểu. Một tiền nhiệm có fingerprint không còn khớp source đã đóng
-băng là `PREDECESSOR_STALE`. Điều tiền nhiệm đã quyết được tiêu thụ nguyên vẹn: operator này không
+băng là `PREDECESSOR_STALE`. Một tiền nhiệm làm ra dưới `mode: dry` cũng vậy: nó không mang commit nào
+và mô tả một bản kế hoạch chứ không phải một delivery, bản ghi thay đổi của nó ghi `nothing written`
+và ô `Commit` của biên nhận ghi `—`, nên nó bị từ chối ở bước 2 trước khi có lệnh nào chạy, bởi một
+bản kế hoạch không có head nào để đứng lên và gác head gốc là công bố một phán quyết xanh về đoạn code
+chưa ai viết. Điều tiền nhiệm đã quyết được tiêu thụ nguyên vẹn: operator này không
 bao giờ lập lại kế hoạch delivery, mở lại ranh giới của nó, hay có ý kiến về việc thay đổi ấy hay dở.
 
 ## Head được xác nhận ngay trong cổng vào

package/operators/quality-verify/self-test.mjs

@@ -109,10 +109,12 @@ function writeBranch(files) {
   const session = mkdtempSync(path.join(tmpdir(), 'quality-session-'));
   const branch = path.join(session, 'step-1', 'parallel-1');
   for (const d of ['request', 'response/data/gates', 'response/artifacts']) mkdirSync(path.join(branch, d), { recursive: true });
-  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', chain: [['1/1']], steps: { '1/1': 'quality.verify' }, current: '1/1', status: 'running' }));
+  writeFileSync(path.join(session, 'state.json'), JSON.stringify({ id: 's-test', project: 'starci-academy', startedAt: '2026-09-03T00:00:00Z', requestHashes: {}, chain: [['1/1']], steps: { '1/1': 'quality.verify' }, current: '1/1', status: 'running' }));
   mkdirSync(path.join(session, 'step-1', 'parallel-1', 'response'), { recursive: true });
   writeFileSync(path.join(session, 'step-1', 'parallel-1', 'response', 'changes.md'), '# changes\n');
+  if (files.__predecessorChanges !== undefined) writeFileSync(path.join(session, 'step-1', 'parallel-1', 'response', 'changes.md'), files.__predecessorChanges);
   for (const [name, content] of Object.entries(files)) {
+    if (name === '__predecessorChanges') continue;
     if (content === null) continue;
     writeFileSync(path.join(branch, name), typeof content === 'string' ? content : JSON.stringify(content, null, 2));
   }
@@ -206,5 +208,16 @@ await expectError(baseline({ 'response/response.md': responseMd().replace('## Ve
 await expectError(baseline({ 'response/data/gates/lint.json': { ...gateResult('lint'), sourceHead: 'nope' } }), 'sourceHead', 'gate-result schema');
 await expectError(baseline({ 'response/response.json': responseJson({ gates: ['response/data/gates/format.json', 'response/data/gates/lint.json'] }) }), 'gate-result does not list', 'a gate file the response never lists');
 await expectError(baseline({ 'request/request.json': requestJson({ inputs: {} }) }), 'needs at least one of', 'a verification with no producer receipt');
+await expectError(baseline({ __predecessorChanges: `# changes — backend.source.apply step-1/parallel-1
 
-process.stdout.write('quality.verify self-test: 3 valid branches, 25 rejected mutations\n');
+## Binding
+
+| Field | Value |
+| --- | --- |
+| Operator | \`backend.source.apply\` |
+| Step | \`step-1/parallel-1\` |
+| Checkout | \`@workspaces/be\` at \`${HEAD}\` on \`session/s-test\`, nothing written |
+| Predecessor | \`step-1/parallel-1/response/response.md\` |
+` }), 'PREDECESSOR_STALE', 'a predecessor produced under mode dry');
+
+process.stdout.write('quality.verify self-test: 3 valid branches, 26 rejected mutations\n');

package/operators/quality-verify/validate.mjs

@@ -1,6 +1,7 @@
 // quality.verify's own law over one branch, on top of the shared step check: the gate plan the
 // person declared is the plan that ran, one file per gate; every gate file stands on the same head,
-// which is the head the request pinned and the commit the predecessor recorded; e2e runs only under
+// which is the head the request pinned and the commit the predecessor recorded, and no predecessor was
+// produced under mode dry;  e2e runs only under
 // an explicit request and sonar carries the scope it was measured at; a result's exit code, evidence
 // and classification match its status; coverage exists exactly where the unit gate produced it and no
 // metric sits below its own threshold beside a green unit result; a debt is live, in-boundary and
@@ -11,6 +12,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { validateStep } from '../../scripts/validate-step.mjs';
+import { sessionRootOf } from '../../scripts/validate-request.mjs';
 import { tableUnder } from '../../scripts/validate-response.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
@@ -74,6 +76,24 @@ export async function validateQualityStep(branchDir, root = ROOT) {
   for (const d of debts) if (!plannedNames.includes(d.gate)) errors.push(`request.json: debt ${d.debtId} covers ${d.gate}, which is not a planned gate`);
 
   // At least one producer receipt: a verification with no predecessor has no delivery to measure.
+  // A dry predecessor is a plan, not a delivery: it has no commit, so there is no head for a gate to
+  // stand on. It is refused here, at step 2, rather than later as a confusing gate failure.
+  const sessionRoot = sessionRootOf(branchDir);
+  if (sessionRoot) {
+    for (const kind of ['changes', 'backend-source-application', 'frontend-source-application']) {
+      const ref = request?.inputs?.[kind];
+      if (!ref) continue;
+      const full = path.join(sessionRoot, ref);
+      if (!existsSync(full)) continue;
+      let text; try { text = await readFile(full, 'utf8'); } catch { continue; }
+      const binding = Object.fromEntries((tableUnder(text, '## Binding') ?? []).map(([k, v]) => [k, v]));
+      const wroteNothing = kind === 'changes'
+        ? /nothing written/.test(String(binding.Checkout ?? ''))
+        : empty(binding.Commit);
+      if (wroteNothing) errors.push(`request.json: PREDECESSOR_STALE — the ${kind} input ${ref} was produced under mode dry and carries no commit; a plan has no head for a gate to stand on`);
+    }
+  }
+
   const inputs = Object.keys(request?.inputs ?? {});
   if (response.status !== 'blocked' && !inputs.some((k) => ['backend-source-application', 'frontend-source-application', 'changes'].includes(k))) {
     errors.push('request.json: quality.verify needs at least one of backend-source-application, frontend-source-application, changes');