@arjunkhera/atlas 0.4.41 → 0.4.43

package/.claude-plugin/plugin.json

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

package/door/lib/approve.mjs

@@ -34,6 +34,7 @@ import { ghApi, pinnedRuns } from './gate.mjs';
 import { GATE_CHECK } from './gate-check.mjs';
 import {
   ACTS, MAX_ACTS, AUDIT_CHECK, AUDIT_TEST, NAMESPACE, SIGNERS_FILE, payloadText, blockText, parseSigners, verifyBlock, verifyTexts, fingerprint, wordsFingerprint, SignedActError,
+  preKeyKeys,
 } from './signed-act.mjs';
 
 export class ApproveError extends Error {}
@@ -303,7 +304,7 @@ export function auditCause(deps, repo, { run, sha, pr, main }) {
 
 // One open audit issue, read from GitHub: the pull request that made the
 // merge, its head, and the red audit run. `skip` says why it is not signed.
-export function auditRow(deps, repo, issue, main, kinds = new Map()) {
+export async function auditRow(deps, repo, issue, main, kinds = new Map()) {
   const sha = AUDIT_ISSUE.exec(String(issue.title ?? ''))[1];
   const row = { issue: Number(issue.number), sha };
   const pull = (deps.gh('GET', `repos/${repo}/commits/${sha}/pulls`) ?? []).find((each) => each?.merged_at && each.merge_commit_sha === sha);
@@ -327,9 +328,17 @@ export function auditRow(deps, repo, issue, main, kinds = new Map()) {
   if (own) return { ...row, skip: `the merge changed ${own}, so its audit ran its own code: sign it by hand` };
   const parent = String(commit?.parents?.[0]?.sha ?? '');
   if (!/^[0-9a-f]{40}$/.test(parent)) return { ...row, skip: 'GitHub gave no parent of the merge commit' };
-  const keys = mergeKeys(deps, repo, parent, head);
-  if (!keys.length) return { ...row, skip: `${SIGNERS_FILE} on the base of this merge holds no owner key, so no act can count: close the issue by hand` };
-  return { ...row, run: String(run.id), keys };
+  let keys = mergeKeys(deps, repo, parent, head);
+  // Item 65c6c907: a merge made before the first owner key takes the keys
+  // at the tip of the default branch, within the limits of preKeyKeys.
+  let first = null;
+  if (!keys.length) {
+    const read = (path) => { try { return deps.gh('GET', path); } catch (error) { if (error?.status === 404 || /HTTP 404|Not Found/i.test(String(error?.message ?? ''))) return null; throw error; } };
+    try { first = await preKeyKeys(read, repo, { parent, branch: main }); } catch (error) { first = { why: `GitHub refused a read of the key file history (${plainText(error?.message ?? error).slice(0, 120)})` }; }
+    if (first.keys) keys = first.keys;
+  }
+  if (!keys.length) return { ...row, skip: `${SIGNERS_FILE} on the base of this merge holds no owner key, so no act can count: close the issue by hand. No first key counts: ${first?.why ?? 'no reason'}` };
+  return { ...row, run: String(run.id), keys, ...(first?.from ? { first_key: first.from } : {}) };
 }
 
 // `atlas approve audit [<pr>...]`. Exit 0 when each listed red got its act.
@@ -369,7 +378,7 @@ export async function approveAudit({ prs = [], repo, root, key, provider, yes =
   line(`  ${issues.length} open audit issue(s) of an owner merge with no touch. Each one can take about 5 seconds.`);
   const rows = [];
   for (const issue of issues) {
-    const row = auditRow(deps, name, issue, main, kinds);
+    const row = await auditRow(deps, name, issue, main, kinds);
     if (only.size && !only.has(row.pr)) continue;
     rows.push(row);
   }
@@ -378,6 +387,7 @@ export async function approveAudit({ prs = [], repo, root, key, provider, yes =
   for (const row of rows) {
     line(`  issue #${row.issue}  ${row.pr ? `#${row.pr}` : row.sha.slice(0, 7)}${row.head ? ` at ${row.head.slice(0, 7)}` : ''}${row.merged_at ? `  merged ${row.merged_at}` : ''}  ${row.skip ? 'NOT SIGNED' : 'SIGN'}  ${row.title ?? ''}`.trimEnd());
     if (row.skip) line(`      ${row.skip}`);
+    else if (row.first_key) line(`      merged before the first owner key: the act counts against the keys at the tip of ${main}, ${row.first_key.slice(0, 7)}`);
   }
   if (only.size) for (const pr of only) if (!rows.some((row) => row.pr === pr)) line(`  #${pr} has no open audit issue: nothing to accept.`);
   if (!sign.length) { line('Nothing to sign: no open audit red can take an act.'); return 1; }

package/door/lib/signed-act.mjs

@@ -100,6 +100,10 @@ export const fingerprint = (text) => createHash('sha256').update(String(text).re
 // review S3). The audit job finds; this job opens the issues and ends red.
 export const AUDIT_CHECK = 'gate · push audit issues';
 export const AUDIT_TEST = 'owner-unsigned';
+// Both jobs of the push audit workflow (.github/workflows/atlas-gate-audit.yml).
+// A red of either one is a question of the owner's consent, not of the
+// tests, so a release never turns it into a warning (item 9348568f).
+export const AUDIT_CHECKS = Object.freeze(['gate · push audit', AUDIT_CHECK]);
 
 // The fingerprint that an accept act names: the owner's words with each run
 // of white space made one space, and no space at the ends. A chat can wrap a
@@ -347,3 +351,67 @@ export function findAct(verified, want) {
   }
   return null;
 }
+
+// Item 65c6c907: the owner keys for a merge made before the first owner key.
+// Such a merge can take no act against the keys of its base, so its audit
+// red would block its item for good. It may take an accept act against the
+// keys of the default branch at its tip now, within four limits:
+//   1. No version of the key file in the history of the base held a key, so
+//      a key that was removed later never opens this path. A version that
+//      cannot be read counts as one that held a key.
+//   2. The tip is the branch ref, resolved to a commit (refs/heads only, so a
+//      tag with the same name changes nothing). The caller passes the default
+//      branch of the repo.
+//   3. Only a tip key that every keyed version of the file in the history of
+//      the tip holds counts. A key pushed after the first owner key, by anyone
+//      who can push to the branch, never counts here (security round 2, S2).
+//   4. A history that cannot be read in full counts as no history: no keys.
+// GitHub's history of a path leaves out a commit whose change did not reach
+// the branch line (history simplification); limits 1 and 3 hold for the rest.
+// `read(path)` answers GitHub's JSON for a GET, or null for a 404; it may
+// answer a promise. Returns { keys, from } or { why }.
+export const HISTORY_PAGES = 3;
+export const signersHistoryPath = (repo, sha, page) => `repos/${repo}/commits?path=${encodeURIComponent(SIGNERS_FILE)}&sha=${sha}&per_page=100&page=${page}`;
+export async function preKeyKeys(read, repo, { parent, branch }) {
+  const fileAt = async (sha) => {
+    const file = await read(`repos/${repo}/contents/${SIGNERS_FILE}?ref=${sha}`);
+    if (!file || typeof file.content !== 'string' || file.encoding !== 'base64') return null;
+    return parseSigners(Buffer.from(file.content, 'base64').toString('utf8')).keys;
+  };
+  // Each commit that changed the key file, from `sha` back; null when the
+  // history cannot be read in full.
+  const history = async (sha) => {
+    const shas = [];
+    for (let page = 1; page <= HISTORY_PAGES; page += 1) {
+      const rows = await read(signersHistoryPath(repo, sha, page));
+      if (!Array.isArray(rows) || rows.some((row) => !/^[0-9a-f]{40}$/.test(String(row?.sha ?? '')))) return null;
+      shas.push(...rows.map((row) => row.sha));
+      if (rows.length < 100) return shas;
+    }
+    return null;
+  };
+  if (!/^[0-9a-f]{40}$/.test(String(parent ?? ''))) return { why: 'no base commit is named' };
+  if (!/^[A-Za-z0-9._-]{1,100}$/.test(String(branch ?? '')) || String(branch).includes('..')) return { why: 'no branch is named' };
+  const before = await history(parent);
+  if (!before) return { why: `the history of ${SIGNERS_FILE} before the merge could not be read in full` };
+  for (const sha of before) {
+    const keys = await fileAt(sha);
+    if (keys === null) return { why: `${SIGNERS_FILE} at ${sha.slice(0, 7)}, before the merge, could not be read` };
+    if (keys.length) return { why: `${SIGNERS_FILE} held a key at ${sha.slice(0, 7)}, before the merge` };
+  }
+  const ref = await read(`repos/${repo}/git/ref/heads/${branch}`);
+  const tip = String(ref?.object?.sha ?? '');
+  if (ref?.ref !== `refs/heads/${branch}` || !/^[0-9a-f]{40}$/.test(tip)) return { why: `the tip of ${branch} could not be read` };
+  const atTip = await fileAt(tip);
+  if (!atTip?.length) return { why: `${SIGNERS_FILE} at the tip of ${branch} holds no owner key` };
+  const since = await history(tip);
+  if (!since) return { why: `the history of ${SIGNERS_FILE} at the tip of ${branch} could not be read in full` };
+  let keys = atTip;
+  for (const sha of since) {
+    const held = await fileAt(sha);
+    if (held === null) return { why: `${SIGNERS_FILE} at ${sha.slice(0, 7)}, before the tip of ${branch}, could not be read` };
+    if (held.length) keys = keys.filter((key) => held.some((one) => one.fingerprint === key.fingerprint));
+  }
+  if (!keys.length) return { why: `no key at the tip of ${branch} is in every keyed version of ${SIGNERS_FILE}` };
+  return { keys, from: tip };
+}

package/package.json

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

package/work/lib/delivery.mjs

@@ -16,7 +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, wordsFingerprint, AUDIT_CHECK, AUDIT_TEST } from '../../door/lib/signed-act.mjs';
+import { MARKER as SIGNED_MARKER, SIGNERS_FILE, parseSigners, verifyTexts, findAct, wordsFingerprint, AUDIT_CHECK, AUDIT_CHECKS, AUDIT_TEST, preKeyKeys } 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']);
@@ -462,8 +462,20 @@ export function createDeliveryVerbs(core) {
       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`);
+    let keys = (await keysAt(parent)).filter((key) => !atFork || atFork.has(key.fingerprint));
+    // Item 65c6c907: a merge made before the first owner key. Only an accept
+    // act for the push audit red may count, against the keys at the tip of
+    // the default branch (preKeyKeys in signed-act.mjs holds the limits). The
+    // audit runs only on the default branch, so the merge must be into it.
+    let prekey = null;
+    if (!keys.length && check === AUDIT_CHECK && testName === AUDIT_TEST) {
+      const main = (await github(`repos/${pull.repo}`))?.default_branch;
+      prekey = typeof main === 'string' && main === pull.base
+        ? await preKeyKeys(githubOrNull, pull.repo, { parent, branch: main })
+        : { why: `${pull.url} did not merge into the default branch` };
+      if (prekey.keys) keys = prekey.keys;
+    }
+    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${prekey?.why ? `; no first key counts either: ${prekey.why}` : ''}`);
     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}`);
@@ -472,7 +484,7 @@ export function createDeliveryVerbs(core) {
     }
     const verified = verifyTexts(texts, keys);
     const words = typeof decision.fields?.text === 'string' ? decision.fields.text : '';
-    let found = findAct(verified, { kind: 'waiver', repo: pull.repo, pr: pull.number, head, decision: decisionId, check });
+    let found = prekey ? null : findAct(verified, { kind: 'waiver', repo: pull.repo, pr: pull.number, head, decision: decisionId, check });
     // An accept act takes only the push audit's red of an owner merge
     // (security review S3). Its words name no decision, so exactly one
     // standing decision may hold them: a second decision with the same words
@@ -491,7 +503,7 @@ export function createDeliveryVerbs(core) {
       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; or, for an audit red, atlas approve audit, and the decision holds the words it printed`);
     }
-    return { key: found.key, signed_at: found.signed_at, act: found.act.kind, ...(found.act.kind === 'accept' ? { run: String(found.act.run) } : {}) };
+    return { key: found.key, signed_at: found.signed_at, act: found.act.kind, ...(found.act.kind === 'accept' ? { run: String(found.act.run) } : {}), ...(prekey?.from ? { first_key: prekey.from } : {}) };
   }
 
   async function acceptedRed(value, pulls, item) {
@@ -697,7 +709,12 @@ export function createDeliveryVerbs(core) {
         // a release that holds the merge was built from a later main that
         // passed the release tests, so the red is recorded on the mark as a
         // warning and the release proves the change (the atlas#188 case).
-        if (unaccepted.length && !release) refuse(`the merge gate is red for ${pull.url}: ${unaccepted.map((run) => `${run.name} ${run.conclusion} (${run.url})`).join(', ')}${mine.length ? '; accepted_red does not cover it' : ''}`);
+        // A release never proves the owner's consent, so a red of the push
+        // audit refuses with or without a release: only accepted_red with
+        // the owner's signed act clears it (item 9348568f).
+        const consent = unaccepted.filter((run) => AUDIT_CHECKS.includes(run.name));
+        const blocking = release ? consent : unaccepted;
+        if (blocking.length) refuse(`the merge gate is red for ${pull.url}: ${blocking.map((run) => `${run.name} ${run.conclusion} (${run.url})`).join(', ')}${mine.length ? '; accepted_red does not cover it' : ''}${release && consent.length ? `. Release ${release.version} holds the merge, but a release does not prove the owner's consent: accept the red with accepted_red and the owner's signed act (atlas approve audit)` : ''}`);
         for (const run of release ? unaccepted : []) {
           warnings.push({ pr: pull.url, check: run.name, latest: run.conclusion, latest_url: run.url, release: release.version,
             detail: `${run.name} concluded ${run.conclusion} on the merge commit of ${pull.url}. Release ${release.version} holds the merge and was built from a later main, so the release proves the change.` });

package/work/mcp.mjs

@@ -69,7 +69,7 @@ const TOOL_LIST = [
   { 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. 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. ${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. ${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. 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; for the push audit red of an owner merge, the accept act that atlas approve audit posts counts too, when the decision's words are the words it printed; the key must be in atlas/owner-signers on the base of the merge. 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. ${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. 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; for the push audit red of an owner merge, the accept act that atlas approve audit posts counts too, when the decision's words are the words it printed; the key must be in atlas/owner-signers on the base of the merge. 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. A red of the push audit is never a warning: a release does not prove the owner's consent, so only accepted_red clears it. 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. ${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. 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, every role.', 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, every role. 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 } },
@@ -221,6 +221,10 @@ export const GITHUB_READS = Object.freeze([
   // 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}$`),
+  // Item 65c6c907: for a merge made before the first owner key, the history
+  // of the key file on a commit, and the branch ref (heads only) of the tip.
+  new RegExp(`^repos/${REPO}/commits\\?path=atlas%2Fowner-signers&sha=[0-9a-f]{40}&per_page=100&page=[1-3]$`),
+  new RegExp(`^repos/${REPO}/git/ref/heads/${BRANCH}$`),
   // 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}$`),