@arjunkhera/atlas 0.4.30 → 0.4.32

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "atlas",
-  "version": "0.4.30",
+  "version": "0.4.32",
   "description": "Atlas: the delivery lifecycle, its crews and the Atlas tools, for any repository.",
   "author": {
     "name": "Arjun Khera"

package/door/lib/fails-before.mjs

@@ -186,17 +186,26 @@ function caseTexts(xml) {
 
 // The results of one report: Map of case name to pass, assertion, error or skipped.
 // For pytest, a name with parameters ("test_x[1]") counts under its function name.
-export function readReport(xml) {
+// `known` holds the case names that the case reader found in the file. node --test writes a test
+// whose body holds subtests as a <testsuite> with the subtests as its cases, and no case of its own
+// name. So a subtest counts under the outermost suite around it whose name is known (item
+// 30badd46). A suite of describe() has no known name, so its cases count under their own names.
+// Limit: node writes no failure for a parent test that fails outside its subtests, so that failure
+// does not show here.
+export function readReport(xml, known = []) {
   const cases = readJunit(xml);
   const texts = caseTexts(xml);
   const rank = { pass: 0, skipped: 1, error: 2, assertion: 3 };
+  const named = new Set(known);
+  // The junit reporter of node writes a double quote as "&amp;quot;", so one
+  // unescape leaves "&quot;" (f2d07e35). Undo the second escape here.
+  const unquote = (text) => text.replaceAll('&quot;', '"');
   const out = new Map();
   cases.forEach((c, i) => {
     let result = c.result;
     if (result === 'fail') result = /AssertionError|ERR_ASSERTION/.test(`${c.message ?? ''}\n${texts[i] ?? ''}`) ? 'assertion' : 'error';
-    // The junit reporter of node writes a double quote as "&amp;quot;", so one
-    // unescape leaves "&quot;" (f2d07e35). Undo the second escape here.
-    const name = c.name.replaceAll('&quot;', '"').replace(/\[.*\]$/, '');
+    const parent = (c.suites ?? []).map(unquote).find((s) => named.has(s));
+    const name = parent ?? unquote(c.name).replace(/\[.*\]$/, '');
     // When one name holds several results, the worst one counts: a fail beats a pass.
     if (!out.has(name) || rank[result] > rank[out.get(name)]) out.set(name, result);
   });
@@ -336,7 +345,7 @@ export function runSide({ top, changed, plans, side, work = join(tmpdir(), 'atla
       if (r.error) why = `the runner did not finish: ${r.error.message}`;
       else if (!existsSync(report)) why = `the runner wrote no report (exit ${r.status})`;
       else {
-        try { cases = Object.fromEntries(readReport(readFileSync(report, 'utf8'))); } catch (error) { why = `the report does not read: ${error.message}`; }
+        try { cases = Object.fromEntries(readReport(readFileSync(report, 'utf8'), p.known)); } catch (error) { why = `the report does not read: ${error.message}`; }
       }
       out.files[p.path] = { command, cases, why };
     }

package/door/lib/passes-after.mjs

@@ -84,7 +84,7 @@ export function plan({ root, base, head = 'HEAD', list = null }) {
     if (!picked.length && !all) continue;
     if (!runner) { files.push({ path, runner: null, result: 'not run', why: 'no runner for this file yet' }); plans.push({ path, runner: null, picked, all }); continue; }
     files.push({ path, runner, result: 'ran', why: null });
-    plans.push({ path, runner, picked, all, head: r.status === 'removed' ? null : r.path });
+    plans.push({ path, runner, picked, all, head: r.status === 'removed' ? null : r.path, known: before ? [...before.cases.keys()] : [] });
   }
   files.sort((x, y) => (x.path < y.path ? -1 : 1));
   return {
@@ -131,7 +131,7 @@ export function runOld({ top, changed, plans, work = join(tmpdir(), 'atlas-after
       if (r.error) why = `the runner did not finish: ${r.error.message}`;
       else if (!existsSync(report)) why = `the runner wrote no report (exit ${r.status})`;
       else {
-        try { cases = Object.fromEntries(readReport(readFileSync(report, 'utf8'))); } catch (error) { why = `the report does not read: ${error.message}`; }
+        try { cases = Object.fromEntries(readReport(readFileSync(report, 'utf8'), p.known)); } catch (error) { why = `the report does not read: ${error.message}`; }
       }
       out.files[p.path] = { command, cases, why };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arjunkhera/atlas",
-  "version": "0.4.30",
+  "version": "0.4.32",
   "description": "Atlas: the delivery lifecycle, its crews and the Atlas tools, as a Claude Code plugin for any repository.",
   "type": "module",
   "license": "UNLICENSED",

package/skills/sdlc-task/SKILL.md

@@ -202,9 +202,10 @@ next action. One short paragraph.
    option (owner, 22 October 2026). Fix the test first. If the owner still
    approved a merge with one known red test, record the words
    with `decision_record` on the item. The words must name the pull request
-   and quote the exact test. One decision accepts one red check. Then pass
-   `accepted_red` to `item_done`; it needs the owner present. Any other red
-   check still refuses the mark.
+   and quote the exact test. One decision accepts one red check. The owner
+   then signs a waiver act on his Mac with `atlas approve` and posts the
+   block on the pull request. Then pass `accepted_red` to `item_done`; it
+   needs the owner present. Any other red check still refuses the mark.
 2. If anything was a struggle, run the `atlas:learnings` skill. It picks the
    home and the form of the fix, and records the lesson.
 3. Rebuild the design's page and the hub, so both read "Shipped". The

package/tests/junit.mjs

@@ -3,8 +3,10 @@
 // write this report: node --test (--test-reporter=junit), pytest
 // (--junitxml), TestNG, JUnit, Vitest and Jest.
 //
-//   readJunit(xml) -> [{ name, classname, file, suite, result, message }]
+//   readJunit(xml) -> [{ name, classname, file, suite, suites, result, message }]
 //   result: "pass", "fail" or "skipped". An <error> is a fail too.
+//   suites: the names of the <testsuite> elements around the case, outermost
+//   first. node --test writes a test with subtests as a <testsuite>.
 //
 // The reader has no dependency. It reads only the parts it needs: the
 // <testsuite> nesting, each <testcase> and its <failure>, <error> and
@@ -44,9 +46,10 @@ export function readJunit(xml) {
     if (tag === 'testcase') {
       if (closing) { current = null; continue; }
       const a = attributes(attrs);
-      const suite = suites.map((s) => s.name).filter(Boolean).join(' > ');
+      const names = suites.map((s) => s.name).filter(Boolean);
+      const suite = names.join(' > ');
       const file = a.file ?? suites.map((s) => s.file).filter(Boolean).at(-1) ?? null;
-      const one = { name: a.name ?? '', classname: a.classname ?? null, file, suite: suite || null, result: 'pass', message: null };
+      const one = { name: a.name ?? '', classname: a.classname ?? null, file, suite: suite || null, suites: names, result: 'pass', message: null };
       cases.push(one);
       current = selfClosing ? null : one;
       continue;

package/work/lib/delivery.mjs

@@ -16,6 +16,7 @@ import { refuse, text, isoDate, url, stringList, sha256, repoKinds, LIVE_KINDS }
 import { oneLine, ROW_LINE_MAX, priorityOrderOf, byPriority, orderNote, waitsOnLine, blockersOf, blocksOf, blockedPhrase, waitsShown } from './questions.mjs';
 import { parseYaml } from '../../shape/check.mjs';
 import { ACTIONS_APP_ID } from '../../door/lib/gate.mjs';
+import { MARKER as SIGNED_MARKER, SIGNERS_FILE, parseSigners, verifyTexts, findAct } from '../../door/lib/signed-act.mjs';
 
 export const DELIVERY_WRITE_VERBS = Object.freeze(['item_done', 'item_reopen']);
 export const DELIVERY_READ_VERBS = Object.freeze(['in_flight']);
@@ -147,10 +148,20 @@ export function requiredStates(names, headRuns, mergeRuns) {
   });
 }
 
+// R17 line 2: a skipped check names what each commit saw. A check can be
+// skipped on the head and never run on the merge commit.
+const SIDE = { head: 'the head', merge: 'the merge commit' };
+function skippedSides(row) {
+  const seen = Array.isArray(row.seen) ? row.seen : [];
+  if (seen.every((one) => one.state === 'skipped')) return 'was skipped on the head and on the merge commit';
+  return seen.map((one) => (one.state === 'skipped' ? `was skipped on ${SIDE[one.on] ?? one.on}`
+    : one.state === 'missing' ? `never ran on ${SIDE[one.on] ?? one.on}` : `ended ${one.conclusion ?? one.state} on ${SIDE[one.on] ?? one.on}`)).join(' and ');
+}
+
 export const requiredWhy = (row) => ({
   pending: `${row.name} is still running`,
   red: `${row.name} is red (${row.seen.map((one) => `${one.on} ${one.conclusion ?? one.state}`).join(', ')})`,
-  skipped: `${row.name} was skipped on the head and on the merge commit: a path filter or a condition skipped it, so it proved nothing`,
+  skipped: `${row.name} ${skippedSides(row)}: a path filter or a condition skipped it, so it proved nothing`,
   missing: `${row.name} never ran on the head or on the merge commit`,
 }[row.state] ?? `${row.name} ended ${row.state}`);
 
@@ -424,6 +435,46 @@ export function createDeliveryVerbs(core) {
   // passing accepted_red needs the owner-present flag, the same flag that
   // decision_record needs. A forged record then gives a caller nothing it
   // could not write itself (security review of this change, finding 1).
+  // R17 line 6: a decision record alone does not waive a red check. The owner
+  // signs a waiver act with his security key (R72, design
+  // docs/design-docs/signed-act/) and posts the block on the pull request.
+  // The act names the repo, the pull request, its head, the decision and the
+  // check. The key must be in atlas/owner-signers on the base of the merge,
+  // its first parent, so a key that the pull request added does not count.
+  async function signedWaiver(pull, decisionId, check) {
+    const head = String(pull.head_sha ?? '').toLowerCase();
+    if (!/^[0-9a-f]{40}$/.test(head)) refuse(`GitHub names no head commit of ${pull.url}, so no signed waiver can match it`);
+    const commit = await github(`repos/${pull.repo}/commits/${pull.merge_commit_sha}`);
+    const parent = commit?.parents?.[0]?.sha;
+    if (typeof parent !== 'string' || !/^[0-9a-f]{40}$/i.test(parent)) refuse(`GitHub names no parent of the merge commit ${pull.merge_commit_sha} of ${pull.url}`);
+    // A rebase merge makes the first parent a commit of the pull request, so
+    // the key must also be on the merge base of that parent and the head: a
+    // commit the pull request did not write (verifier of atlas#240).
+    const compared = await github(`repos/${pull.repo}/compare/${parent}...${head}`);
+    const forkPoint = compared?.merge_base_commit?.sha;
+    if (typeof forkPoint !== 'string' || !/^[0-9a-f]{40}$/i.test(forkPoint)) refuse(`GitHub names no merge base of ${pull.url}, so no signed waiver can be checked`);
+    const keysAt = async (ref) => {
+      const file = await githubOrNull(`repos/${pull.repo}/contents/${SIGNERS_FILE}?ref=${ref}`);
+      return parseSigners(file && typeof file.content === 'string' ? Buffer.from(file.content, 'base64').toString('utf8') : '').keys;
+    };
+    const atFork = forkPoint.toLowerCase() === parent.toLowerCase() ? null : new Set((await keysAt(forkPoint)).map((key) => key.fingerprint));
+    const keys = (await keysAt(parent)).filter((key) => !atFork || atFork.has(key.fingerprint));
+    if (!keys.length) refuse(`accepted_red needs the owner's signed waiver, and ${SIGNERS_FILE} on the base of ${pull.url} holds no owner key`);
+    const texts = [];
+    for (let page = 1; page <= 10; page += 1) {
+      const rows = await github(`repos/${pull.repo}/issues/${pull.number}/comments?per_page=100&page=${page}`);
+      for (const row of Array.isArray(rows) ? rows : []) if (typeof row?.body === 'string' && row.body.includes(SIGNED_MARKER)) texts.push(row.body);
+      if (!Array.isArray(rows) || rows.length < 100) break;
+    }
+    const verified = verifyTexts(texts, keys);
+    const found = findAct(verified, { kind: 'waiver', repo: pull.repo, pr: pull.number, head, decision: decisionId, check });
+    if (!found) {
+      const why = verified.find((row) => row.error)?.error;
+      refuse(`accepted_red needs the owner's signed waiver on ${pull.url} for check ${check}, head ${head.slice(0, 12)} and decision ${decisionId}; none counts${why ? ` (a block was refused: ${why})` : ''}. The owner runs: atlas approve act waiver, and posts the block on the pull request`);
+    }
+    return { key: found.key, signed_at: found.signed_at };
+  }
+
   async function acceptedRed(value, pulls, item) {
     if (value === undefined) return [];
     if (!Array.isArray(value)) refuse('accepted_red must be an array of { pr, check, test, decision_id }');
@@ -471,7 +522,8 @@ export function createDeliveryVerbs(core) {
         || new RegExp(`(?:^|[^A-Za-z0-9_/.-])#${pull.number}(?![0-9])`).test(words);
       if (!namesPull) refuse(`decision ${decisionId} does not name ${pull.url}; the owner's words must name the pull request (its URL or #${pull.number})`);
       if (!words.includes(testName)) refuse(`decision ${decisionId} does not quote the test "${testName}"; the owner's own words must name the exact test`);
-      rows.push({ pr: pull.url, check, test: testName, decision_id: decision.id, decision_version: decision.version ?? null, decision });
+      const waiver = await signedWaiver(pull, decision.id, check);
+      rows.push({ pr: pull.url, check, test: testName, decision_id: decision.id, decision_version: decision.version ?? null, waiver, decision });
     }
     return rows;
   }
@@ -639,7 +691,7 @@ export function createDeliveryVerbs(core) {
           if (!run) refuse(`accepted_red names check ${row.check} on ${pull.url}, but that check is not red in the merge gate; drop the entry`);
           const { decision: _record, ...kept } = row;
           acceptedRows.push({ ...kept, conclusion: run.conclusion, run_url: run.url,
-            detail: `${row.check} concluded ${run.conclusion} for ${pull.url}. The owner accepted the red test "${row.test}" in decision ${row.decision_id}. The gate names the check, not the test, so the verb proved the check level only.` });
+            detail: `${row.check} concluded ${run.conclusion} for ${pull.url}. The owner accepted the red test "${row.test}" in decision ${row.decision_id}, and signed the waiver with key ${row.waiver.key}. The gate names the check, not the test, so the verb proved the check level only.` });
         }
         if (!required.length && !passed.length) refuse(`no check run succeeded for ${pull.url}; the merge gate is the independent record and it says nothing`);
         // A check name whose LATEST run succeeded is green. A name whose earlier

package/work/mcp.mjs

@@ -68,7 +68,7 @@ export const TOOLS = [
   { name: 'question_ask', description: `Ask the owner one question that blocks work on an item, and say what waiting costs. When: an agent is blocked and cannot decide by itself. Any in-session agent may call it; no owner flag. The question shows in the "Needs me" view until it is answered. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'text', 'item_id', 'product', 'cost'], properties: { request_id: REQUEST_ID, text: S('The question, in plain words, answerable without opening a source.'), item_id: S('Entity id of the work item the question blocks.'), product: S('Product id of that item.'), cost: S(`What waiting costs. One of: ${COSTS.map((cost) => `${cost} (${COST_MEANING[cost]})`).join('; ')}.`), context: { type: 'object', description: 'What the owner needs to answer without opening a source.', properties: { current_behavior: S('What happens today.'), change: S('What would change.'), affected: { type: 'array', items: { type: 'string' }, description: 'Parts that change.' }, options: { type: 'array', items: { type: 'string' }, description: 'The options, one per entry.' }, consequences: S('What follows from each option.'), sources: { type: 'array', items: { type: 'string' }, description: 'Absolute http or https URLs that back the context.' } } } }, additionalProperties: false } },
   { name: 'question_answer', description: `Record the owner's answer to one open question. One call writes the decision in the owner's words, keeps the rendered answer as a receipt, and closes the question, so the "Needs me" view loses the row. Refuses an unknown question and one that is already answered. Owner present only. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'question_id', 'text', 'date'], properties: { request_id: REQUEST_ID, question_id: S('Entity id of the open question.'), text: S("The owner's answer, verbatim."), date: S('ISO date the owner said it, in the form YYYY-MM-DD.'), source: S('Where the words are on record: a chat turn, a doc URL, an issue.'), kind: S(`One of ${DECISION_KINDS.join(', ')}. Default answer.`), items: { type: 'array', items: { type: 'string' }, description: 'Item ids the decision touches. Default: the question\'s item.' }, priority_order: { type: 'array', items: { type: 'string' }, description: 'Item ids in the order the owner set.' }, replaces: S('Entity id of the decision this one replaces.'), rendered: S('The view text the owner acted on. Default: the question and the answer.'), view: S('Which view the owner read, for example needs-me.') }, additionalProperties: false } },
   { name: 'decision_record', description: `Record what the owner decided outside a question, in their own words. Refuses missing text and a missing date. Pass rendered to keep the view the owner acted on as a receipt in the same call. Owner present only. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'text', 'date'], properties: { request_id: REQUEST_ID, text: S("The owner's words, verbatim."), date: S('ISO date the owner said it.'), source: S('Where the words are on record.'), kind: S(`One of ${DECISION_KINDS.join(', ')}. Default decision.`), product: S('Product id the decision is about.'), items: { type: 'array', items: { type: 'string' }, description: 'Item ids the decision touches.' }, priority_order: { type: 'array', items: { type: 'string' }, description: 'Item ids in the order the owner set.' }, replaces: S('Entity id of the decision this one replaces.'), rendered: S('The view text the owner acted on.'), view: S('Which view the owner read.') }, additionalProperties: false } },
-  { name: 'item_done', description: `Mark an item delivered. What proves it follows the repo kind (amendment A1.7). A service or schema repo gets the three read-only live checks: the deployed commit carries the pull requests, the health endpoint answers, and a functional check scoped to the change passes. Every check is a GET. The merge state of each pull request and the gate runs come from GitHub; the caller supplies none of them, and a red gate (${FATAL_CONCLUSIONS.join(', ')}) refuses the mark. One exception, a last resort for an extraordinary case with no other option: the owner can accept a known red test on one merged pull request. Name it in accepted_red with the decision that records the owner's words; those words must name the pull request and quote the exact test, and one decision accepts one red check. accepted_red needs the owner present. The gate names a check, not a test, so the verb proves the check level, and every other red check still refuses the mark. A library repo has no deploy target, so its delivery is proven by the merge and the gate alone: pass no functional, and the product needs no health_url. A schema repo keeps the three checks, because its migration runs after the merge. When atlas.yaml on the base of a merge lists required_checks, each one needs a successful newest GitHub Actions run on the pull request head or on the merge commit; a skipped check and a check that never ran are named apart. When atlas.yaml says live: release, a published release must hold each merge commit, and the mark stores that version; a red run on the merge commit is then a warning on the mark, because the release was built from a later green main. An item with no registered repo, or a repo whose kind was never set, keeps the three checks. The delivering agent calls this; the lead calls it to catch up a delivery made outside a session. No owner flag. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'prs'], properties: { request_id: REQUEST_ID, item_id: S('Item id. The item must be active. Unless every repo it names is a library, its product must carry a health_url.'), prs: { type: 'array', items: { type: 'string' }, description: 'The merged GitHub pull request URLs this delivery shipped. Required: the item\'s own pr links are not read, because a link can be a design or a lock, not a delivery.' }, functional: { type: 'object', required: ['url', 'contains'], description: 'The read-only functional check. Required for a service or schema repo, and refused for a library repo. The verb GETs this URL once. No method, body or headers are accepted.', properties: { url: S('Absolute URL on the product health endpoint\'s origin, under one of the product\'s check_paths, and not the health endpoint itself.'), contains: { type: 'array', items: { type: 'string' }, description: 'Required. Strings the answer must carry, chosen so they exist only because of this change. Only whether each was found is recorded; the answer itself never enters the graph.' }, status: { type: 'number', description: 'Expected HTTP status, 2xx only. Default 200.' } } }, note: S('One line on what was delivered.'), accepted_red: { type: 'array', description: 'Red checks the owner accepted, one entry for each pull request and check. Owner present only. The decision must be a decision or an answer on this item, written by decision_record or question_answer and not replaced. Its words must name the pull request and quote the test. One decision accepts one check on one pull request. A listed check that is not red is refused.', items: { type: 'object', required: ['pr', 'check', 'test', 'decision_id'], additionalProperties: false, properties: { pr: S('One of the prs of this delivery.'), check: S('The name of the red check run in the merge gate, for example "test".'), test: S('The exact name of the red test, as the owner\'s words quote it.'), decision_id: S('The decision that records the owner\'s acceptance.') } } } }, additionalProperties: false } },
+  { name: 'item_done', description: `Mark an item delivered. What proves it follows the repo kind (amendment A1.7). A service or schema repo gets the three read-only live checks: the deployed commit carries the pull requests, the health endpoint answers, and a functional check scoped to the change passes. Every check is a GET. The merge state of each pull request and the gate runs come from GitHub; the caller supplies none of them, and a red gate (${FATAL_CONCLUSIONS.join(', ')}) refuses the mark. One exception, a last resort for an extraordinary case with no other option: the owner can accept a known red test on one merged pull request. Name it in accepted_red with the decision that records the owner's words; those words must name the pull request and quote the exact test, and one decision accepts one red check. The owner must also sign a waiver act for the repo, the pull request, its head, the decision and the check (atlas approve act waiver) and post the block on the pull request; the key must be in atlas/owner-signers on the base of the merge. accepted_red needs the owner present. The gate names a check, not a test, so the verb proves the check level, and every other red check still refuses the mark. A library repo has no deploy target, so its delivery is proven by the merge and the gate alone: pass no functional, and the product needs no health_url. A schema repo keeps the three checks, because its migration runs after the merge. When atlas.yaml on the base of a merge lists required_checks, each one needs a successful newest GitHub Actions run on the pull request head or on the merge commit; a skipped check and a check that never ran are named apart. When atlas.yaml says live: release, a published release must hold each merge commit, and the mark stores that version; a red run on the merge commit is then a warning on the mark, because the release was built from a later green main. An item with no registered repo, or a repo whose kind was never set, keeps the three checks. The delivering agent calls this; the lead calls it to catch up a delivery made outside a session. No owner flag. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'prs'], properties: { request_id: REQUEST_ID, item_id: S('Item id. The item must be active. Unless every repo it names is a library, its product must carry a health_url.'), prs: { type: 'array', items: { type: 'string' }, description: 'The merged GitHub pull request URLs this delivery shipped. Required: the item\'s own pr links are not read, because a link can be a design or a lock, not a delivery.' }, functional: { type: 'object', required: ['url', 'contains'], description: 'The read-only functional check. Required for a service or schema repo, and refused for a library repo. The verb GETs this URL once. No method, body or headers are accepted.', properties: { url: S('Absolute URL on the product health endpoint\'s origin, under one of the product\'s check_paths, and not the health endpoint itself.'), contains: { type: 'array', items: { type: 'string' }, description: 'Required. Strings the answer must carry, chosen so they exist only because of this change. Only whether each was found is recorded; the answer itself never enters the graph.' }, status: { type: 'number', description: 'Expected HTTP status, 2xx only. Default 200.' } } }, note: S('One line on what was delivered.'), accepted_red: { type: 'array', description: 'Red checks the owner accepted, one entry for each pull request and check. Owner present only. The decision must be a decision or an answer on this item, written by decision_record or question_answer and not replaced. Its words must name the pull request and quote the test. One decision accepts one check on one pull request. A listed check that is not red is refused.', items: { type: 'object', required: ['pr', 'check', 'test', 'decision_id'], additionalProperties: false, properties: { pr: S('One of the prs of this delivery.'), check: S('The name of the red check run in the merge gate, for example "test".'), test: S('The exact name of the red test, as the owner\'s words quote it.'), decision_id: S('The decision that records the owner\'s acceptance.') } } } }, additionalProperties: false } },
   { name: 'item_reopen', description: `Reopen a delivered item: the lifecycle goes back to active and a reopen mark is appended, citing the failed check by URL. The delivery mark is never erased; the reopen points at it with the corrects relation. The owner, or the lead in this session, calls it. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'reason', 'failed_check'], properties: { request_id: REQUEST_ID, item_id: S('Item id carrying at least one delivery mark.'), reason: S('Why it is reopened, in plain words.'), failed_check: S('Absolute URL of the check that failed: a CI run, a monitor, an issue.'), corrects: S('Mark id of the delivery this reopen corrects. Default: the item\'s latest delivery mark.') }, additionalProperties: false } },
   { name: 'in_flight', description: 'Answer "what are we working on, and what changed since a date?". Active items per product, ordered by the owner\'s current priority decision first, when it carries an order, then by days since the last change with the latest on top, and the days shown on each row. Each row says what the item waits on. Movement is read from the marks and from each registered repo\'s recent pull requests: the item\'s own pr links, plus any pull request whose title, body or branch names the item id. Merged pull requests with no delivery mark are listed as "merged, not marked". A legacy seal reads as a delivery mark with verdict "legacy". Computed at read time and never stored. Scope: read, no owner flag needed.', inputSchema: { type: 'object', properties: { product: S('Limit the view to one product id.'), since: S('ISO date. Adds what was delivered since then.') }, additionalProperties: false } },
   { name: 'needs_me', description: 'Answer "what needs me?": every open question on a proposed, active or paused item, per product, ordered by what waiting costs. A row on an item that is not active names its lifecycle. Each row is three lines, the question, the item and the cost, with the context folded under it. Computed at read time and never stored. Scope: read, no owner flag needed. Pass the row text back as rendered when the owner answers.', inputSchema: { type: 'object', properties: { product: S('Limit the view to one product id.') }, additionalProperties: false } },
@@ -213,6 +213,10 @@ export const GITHUB_READS = Object.freeze([
   new RegExp(`^repos/${REPO}/contents/atlas\\.yaml\\?ref=(?:${SHA}|${BRANCH})$`),
   new RegExp(`^repos/${REPO}/releases\\?per_page=\\d{1,3}$`),
   new RegExp(`^repos/${REPO}/compare/${SHA}\\.\\.\\.${TAG}$`),
+  // R17 line 6: the signed waiver on the comments of a pull request, and the
+  // owner's key file on the base of its merge.
+  new RegExp(`^repos/${REPO}/issues/\\d{1,9}/comments\\?per_page=100&page=\\d{1,2}$`),
+  new RegExp(`^repos/${REPO}/contents/atlas/owner-signers\\?ref=[0-9a-fA-F]{40}$`),
   // Roadmap R16: the numbers page past 100 pull requests, and read the
   // files of each merge to find a changed test.
   new RegExp(`^repos/${REPO}/pulls\\?state=all&sort=updated&direction=desc&per_page=\\d{1,3}&page=\\d{1,3}$`),