@arjunkhera/atlas 0.4.51 → 0.4.53

package/.claude-plugin/plugin.json

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

package/door/cli.mjs

@@ -155,6 +155,8 @@ const HELP = `atlas — the door into a repo's Atlas files
       --json                           print the whole answer as JSON
   atlas runner claim --repo <owner/name> --issue <n> --holder <run id>   claim one atlas-job issue; the oldest live claim holds it
   atlas runner line --from <file>      print the last line of a run, from a JSON file of ids and counts
+      --notice                         print the comment that hands the run facts to the notice workflow
+  atlas runner notice --repo <owner/name> --issue <n> --comment <id>   in the notice workflow only: post the run line of one run comment as the bot
                                        Until the A2 exit test, the runner works on the scratch repo only
 
   atlas upkeep check --root <repo>     the upkeep check: the docs index, dead doc links, the code each doc names, stale pages, and in a pull request its tracker item, its changed designs and STE on its changed lines
@@ -173,6 +175,7 @@ const HELP = `atlas — the door into a repo's Atlas files
   atlas gate audit --repo <owner/name> [--since <date>]   each merge since the date (default: one day) that came before its checks were green
   atlas gate audit --repo <owner/name> --commit <sha> [--forced] [--findings <file>]   one commit on the main branch: red when no pull request merged it, one merged it before its checks were green, or a gate run is not from the base workflow
   atlas gate audit --repo <owner/name> --errors [--findings <file>]   red when the gate errored on 3 pull requests in a row
+  atlas gate hold --repo <owner/name> --root <clone> --commit <sha> --from <sha>   the release job only, from the copy on npm: exit 3 holds the release while a merge since --from went to the owner with no act of his
   atlas gate check --base <ref> --head <sha>   the gate: judge a pull request with this copy of Atlas; success, owner or red
       --pr <n> --base-ref <branch>     with --repo: read the comments of the pull request, and let the owner's signed act for this base and head clear owner
       --root <repo>                    the clone that holds both commits (default: this folder); the head is read as git data only
@@ -235,9 +238,9 @@ export const FLAGS = Object.freeze({
   view: { product: 'value', name: 'value', out: 'value' },
   tests: { root: 'optional', halves: 'value', evidence: 'value', 'guards-from': 'value', tests: 'value', 'dry-run': 'switch', run: 'value', own: 'value', base: 'value', head: 'value', list: 'value', side: 'value', old: 'value', new: 'value', covers: 'switch', findings: 'value', repo: 'value', max: 'value', bot: 'value', since: 'value', out: 'value', text: 'switch', json: 'switch', scenario: 'value', language: 'value' },
   jobs: { root: 'optional', repo: 'value', branch: 'value', out: 'value', findings: 'value', max: 'value', 'dry-run': 'switch' },
-  runner: { repo: 'value', issue: 'value', holder: 'value', from: 'value', json: 'switch' },
+  runner: { repo: 'value', issue: 'value', holder: 'value', from: 'value', comment: 'value', notice: 'switch', json: 'switch' },
   upkeep: { root: 'optional', event: 'value', json: 'switch', last: 'value', base: 'value' },
-  gate: { repo: 'value', root: 'optional', 'dry-run': 'switch', off: 'switch', on: 'switch', pr: 'value', since: 'value', commit: 'value', base: 'value', 'base-ref': 'value', head: 'value', body: 'value', json: 'switch', summary: 'value', output: 'value', days: 'value', branch: 'value', errors: 'switch', forced: 'switch', findings: 'value' },
+  gate: { repo: 'value', root: 'optional', 'dry-run': 'switch', off: 'switch', on: 'switch', pr: 'value', since: 'value', commit: 'value', from: 'value', base: 'value', 'base-ref': 'value', head: 'value', body: 'value', json: 'switch', summary: 'value', output: 'value', days: 'value', branch: 'value', errors: 'switch', forced: 'switch', findings: 'value' },
   approve: { repo: 'value', root: 'optional', key: 'value', provider: 'value', yes: 'switch', out: 'value', file: 'value', signers: 'value', commit: 'value', item: 'value', card: 'value', words: 'value', pr: 'value', head: 'value', decision: 'value', check: 'value' },
   judge: { tasks: 'value', verdict: 'value', seal: 'value', runs: 'value', out: 'value', repo: 'value', budget: 'value', model: 'value' },
   install: { local: 'switch', from: 'value', 'skip-global': 'switch', yes: 'switch', cloud: 'switch' },
@@ -496,7 +499,7 @@ function jobsVerb(chosen) {
 }
 
 function runnerVerb(chosen) {
-  return runnerCommand({ what: chosen._[1], repo: chosen.repo, issue: chosen.issue, holder: chosen.holder, from: chosen.from, json: Boolean(chosen.json), args: [...chosen._, ...Object.values(chosen).filter((v) => typeof v === 'string')] }, line);
+  return runnerCommand({ what: chosen._[1], repo: chosen.repo, issue: chosen.issue, holder: chosen.holder, from: chosen.from, comment: chosen.comment, notice: Boolean(chosen.notice), json: Boolean(chosen.json), args: [...chosen._, ...Object.values(chosen).filter((v) => typeof v === 'string')] }, line);
 }
 
 function upkeepVerb(chosen) {
@@ -504,7 +507,7 @@ function upkeepVerb(chosen) {
 }
 
 function gateVerb(chosen) {
-  return gateCommand({ what: chosen._[1], repo: chosen.repo, root: rootOf(chosen), dryRun: Boolean(chosen['dry-run']), off: Boolean(chosen.off), on: Boolean(chosen.on), pr: chosen.pr, since: chosen.since, commit: chosen.commit, base: chosen.base, baseRef: chosen['base-ref'], head: chosen.head, body: chosen.body, json: Boolean(chosen.json), summary: chosen.summary, output: chosen.output, days: chosen.days, branch: chosen.branch, errors: Boolean(chosen.errors), forced: Boolean(chosen.forced), findings: chosen.findings }, line);
+  return gateCommand({ what: chosen._[1], repo: chosen.repo, root: rootOf(chosen), dryRun: Boolean(chosen['dry-run']), off: Boolean(chosen.off), on: Boolean(chosen.on), pr: chosen.pr, since: chosen.since, commit: chosen.commit, from: chosen.from, base: chosen.base, baseRef: chosen['base-ref'], head: chosen.head, body: chosen.body, json: Boolean(chosen.json), summary: chosen.summary, output: chosen.output, days: chosen.days, branch: chosen.branch, errors: Boolean(chosen.errors), forced: Boolean(chosen.forced), findings: chosen.findings }, line);
 }
 
 function approveVerb(chosen) {

package/door/lib/gate.mjs

@@ -22,7 +22,7 @@ import { childEnvironment } from '../../work/lib/child-env.mjs';
 import { parseYaml } from '../../shape/check.mjs';
 import { checkCommand, replayCommand, judge, jobNames, GATE_CHECK, GATE_WORKFLOW } from './gate-check.mjs';
 import { keepFindings, gateErrors, pinCode, slug, AUDIT_JOB } from './gate-audit.mjs';
-import { MARKER as SIGNED_MARKER } from './signed-act.mjs';
+import { MARKER as SIGNED_MARKER, SIGNERS_FILE, AUDIT_CHECK, parseSigners, verifyTexts, findAct, auditCodeDiff } from './signed-act.mjs';
 import { brakeFacts, windowCommits, ciTrips, BrakeError } from './brake.mjs';
 
 export const BRANCH_RULESET = 'atlas gate';
@@ -708,6 +708,93 @@ export function prComments(gh, repo, pr) {
   return kept;
 }
 
+// `atlas gate hold --root <clone> --commit <sha> --from <sha>` (item 4af66381,
+// the release hold). The release job runs it from the trusted copy, the
+// version that npm holds as latest, never from the commit that it judges.
+// `--from` is the commit of that version, from its release record, as
+// `atlas upgrade` finds it. The hold judges
+// each first-parent merge from there to the release commit again, with the
+// rules and the brake of its parent, at the time of its merge. Only a merge
+// that the gate judges success passes: an owner or a red answer holds the
+// release (security review of #290, S1), unless the owner signed one of
+// three acts on the pull request:
+//   1. a merge act for its head (the gate counts it already, so the answer
+//      is success);
+//   2. an accept act for its head, from `atlas approve audit`, for a merge
+//      that changed no audit code;
+//   3. an accept-code act for its merge commit and its audit-code diff, from
+//      `atlas approve audit-code`.
+// It fails closed: a push past the gate, a merge that it cannot judge, a
+// start that the release commit does not hold, or more than HOLD_MAX merges
+// also hold. Exit 0: publish. Exit 3: hold. Any other exit is an error.
+export const HOLD_MAX = 200;
+// git's word for the ancestor test, joined so the package names no ancestry verb (test/package D9).
+const MERGE_BASE = ['merge', 'base'].join('-');
+export const HOLD_EXIT = 3;
+export function holdCommand({ repo, root, commit, from }, line, gh) {
+  const full = (value) => typeof value === 'string' && /^[0-9a-f]{40}$/.test(value);
+  if (!full(commit)) throw new GateError('atlas gate hold needs --commit <full sha>.');
+  if (!full(from)) throw new GateError('atlas gate hold needs --from <full sha>: the commit of the version that npm holds as latest.');
+  if (!root || root === true) throw new GateError('atlas gate hold needs --root <clone>.');
+  const git = (args) => execFileSync('git', ['-C', root, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024 }).trim();
+  try { git(['cat-file', '-e', `${commit}^{commit}`]); } catch { throw new GateError(`${commit} is not a commit in ${root}.`); }
+  try { git([MERGE_BASE, '--is-ancestor', '--end-of-options', from, commit]); } catch {
+    line(`HOLD: the published commit ${from.slice(0, 7)} is not in the history of ${commit.slice(0, 7)}, so the hold cannot tell which merges npm does not hold yet.`);
+    return HOLD_EXIT;
+  }
+  const commits = git(['rev-list', '--first-parent', '--reverse', `--max-count=${HOLD_MAX + 1}`, `${from}..${commit}`]).split('\n').filter(Boolean);
+  if (commits.length > HOLD_MAX) { line(`HOLD: more than ${HOLD_MAX} merges since the published commit ${from.slice(0, 7)}.`); return HOLD_EXIT; }
+  const held = [];
+  for (const sha of commits) {
+    const why = holdRow({ repo, root, sha }, gh, git);
+    if (why) { held.push(why); line(`  ✗ ${why}`); }
+  }
+  if (held.length) {
+    line(`HOLD: ${held.length} of ${commits.length} merge(s) since the published commit ${from.slice(0, 7)} went to the owner, and no act of his clears them. The owner signs them with atlas approve audit (atlas approve audit-code <pr> for a merge that changed the audit code). The next release run after his touch publishes.`);
+    return HOLD_EXIT;
+  }
+  line(`atlas gate hold: ${commits.length} merge(s) since the published commit ${from.slice(0, 7)}, each green or signed by the owner. Publish.`);
+  return 0;
+}
+
+// Why one first-parent commit holds the release, or null.
+export function holdRow({ repo, root, sha }, gh, git) {
+  let pull;
+  try { pull = (gh('GET', `repos/${repo}/commits/${sha}/pulls`) ?? []).find((each) => each.merged_at && each.merge_commit_sha === sha); } catch { return `${sha.slice(0, 7)}: GitHub did not say which pull request merged it`; }
+  if (!pull) return `${sha.slice(0, 7)} reached the branch with no pull request: a push past the gate`;
+  const head = String(pull.head?.sha ?? '');
+  let parent;
+  try { parent = git(['rev-parse', '--verify', '--end-of-options', `${sha}^1`]); } catch { return `#${pull.number}: the parent of ${sha.slice(0, 7)} is not in this clone`; }
+  try { git(['cat-file', '-e', `${head}^{commit}`]); } catch { return `#${pull.number}: its head ${head.slice(0, 7)} is not in this clone`; }
+  let texts;
+  try { texts = prComments(gh, repo, pull.number); } catch { return `#${pull.number}: GitHub did not give its comments, so no act of the owner can be read`; }
+  let answer;
+  try {
+    const at = new Date(pull.merged_at);
+    const brake = { ci: brakeRead({ root, base: parent, now: at }, gh, repo), clears: { repo, commentsOf: (one) => commitComments(gh, repo, one) } };
+    // The red main checks of its parent, as the gate read them, so a fix of a red main check is judged as the gate judged it.
+    answer = judge({ root, base: parent, head, body: String(pull.body ?? ''), now: at, brake, redMain: redMain({ root, base: parent }, gh, repo), signed: { repo, pr: Number(pull.number), baseRef: pull.base?.ref ?? null, texts } });
+  } catch (error) { return `#${pull.number}: it cannot be judged (${String(error?.message ?? error).split('\n')[0].slice(0, 160)})`; }
+  if (answer.result === 'success') return null;
+  // The gate did not say success. An accept act, or an accept-code act for a
+  // merge that changed audit code, checked with the keys of its parent,
+  // clears it now. The audit-code test is the one that `atlas approve audit`
+  // keeps, so the hold does not rest on the Mac tool alone.
+  let keys = [];
+  try { keys = parseSigners(git(['show', `${parent}:${SIGNERS_FILE}`])).keys; } catch { keys = []; }
+  const verified = verifyTexts(texts, keys);
+  let code;
+  try { code = auditCodeDiff(gh('GET', `repos/${repo}/commits/${sha}`)?.files); } catch { code = { unknown: true }; }
+  const accepted = code.unknown ? null
+    : code.files.length ? findAct(verified, { kind: 'accept-code', repo, pr: String(pull.number), head, merge: sha, diff: code.print })
+      : findAct(verified, { kind: 'accept', repo, pr: String(pull.number), head, check: AUDIT_CHECK });
+  if (accepted) return null;
+  const row = (answer.rows ?? []).find((each) => each.kind === answer.result) ?? (answer.rows ?? []).find((each) => each.kind === 'owner');
+  const what = answer.result === 'red' ? 'the gate said red' : 'went to the owner';
+  if (code.unknown) return `#${pull.number} (${sha.slice(0, 7)}) ${what}, and GitHub gave no full file list of its merge, so no accept act can be checked`;
+  return `#${pull.number} (${sha.slice(0, 7)}) ${what}${row ? `: ${row.class ?? answer.result}${row.path ? ` ${row.path}` : ''}` : ''}, and no ${code.files.length ? 'merge or accept-code' : 'merge or accept'} act names it`;
+}
+
 // The comment texts of one commit on main that carry the signed-act marker:
 // where the owner posts a brake clear (roadmap R13 line 6). At most three
 // pages of a hundred. A read that fails gives null, so no clear counts.
@@ -763,9 +850,9 @@ export function brakeRead({ root, base, now = new Date() }, gh, repo, pages = 3)
   return ciTrips({ commits, runs, homes, checks, live: facts.live, liveChecks }, jobsOf);
 }
 
-// `atlas gate apply|ready|audit|check|replay`. Returns the exit code.
-export function gateCommand({ what, repo, root, dryRun = false, off = false, on = false, pr, since, commit, base, baseRef, head, body, json = false, summary, output, days, branch, errors = false, forced = false, findings, home = homedir() }, line, gh = ghApi) {
-  if (!['apply', 'ready', 'audit', 'check', 'replay'].includes(what)) throw new GateError(`there is no gate verb "${what ?? ''}". Use apply, ready, audit, check or replay.`);
+// `atlas gate apply|ready|audit|check|replay|hold`. Returns the exit code.
+export function gateCommand({ what, repo, root, dryRun = false, off = false, on = false, pr, since, commit, from, base, baseRef, head, body, json = false, summary, output, days, branch, errors = false, forced = false, findings, home = homedir() }, line, gh = ghApi) {
+  if (!['apply', 'ready', 'audit', 'check', 'replay', 'hold'].includes(what)) throw new GateError(`there is no gate verb "${what ?? ''}". Use apply, ready, audit, check, replay or hold.`);
   // With --repo, check reads the red main checks from GitHub; without, it judges git data alone.
   const named = repo && repo !== true && /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo) && !repo.split('/').some((part) => /^\.+$/.test(part));
   if (what === 'check') {
@@ -787,6 +874,7 @@ export function gateCommand({ what, repo, root, dryRun = false, off = false, on
     }
     return code;
   }
+  if (what === 'hold') return holdCommand({ repo, root, commit, from }, line, gh);
   if (what === 'audit') return auditCommand({ repo, root, since, commit, errors, forced, findings }, line, gh);
   if (off && on) throw new GateError('pick --off or --on, not both.');
   const mode = off ? 'off' : on ? 'on' : 'apply';

package/door/lib/runner.mjs

@@ -3,7 +3,8 @@
 //
 //   atlas runner start --repo <owner/name> [--json]
 //   atlas runner claim --repo <owner/name> --issue <n> --holder <run id>
-//   atlas runner line --from <file>
+//   atlas runner line --from <file> [--notice]
+//   atlas runner notice --repo <owner/name> --issue <n> --comment <id>
 //
 // The runner is one scheduled Claude session for each repo. It follows the
 // atlas:runner skill, and that skill calls these commands. The commands read
@@ -15,6 +16,12 @@
 //   claim  posts one claim on an issue, then reads the claims back. The
 //          oldest live claim holds the issue, so two runs build it once.
 //   line   prints the last line of a run, built by code from ids and counts.
+//          With --notice it prints the comment that hands the run facts to
+//          the notice workflow.
+//   notice runs in the notice workflow, as github-actions[bot]. It reads one
+//          run comment of the owner's login, builds the run line again from
+//          its facts, and posts the line, so GitHub tells the owner's phone
+//          (R25 line 10). It never copies the comment's text.
 //
 // Rules that hold everywhere here:
 // 1. Until the owner records the A2 exit test as passed, the runner works on
@@ -28,7 +35,7 @@
 // 4. No call here merges, pushes or changes a branch.
 import { readFileSync } from 'node:fs';
 import { jobMarker, typedFindings, JOBS_LABEL, atlasJobs } from './jobs.mjs';
-import { repoOk, TOKEN_SHAPE, DEFAULT_BOT } from './issues.mjs';
+import { repoOk, TOKEN_SHAPE, DEFAULT_BOT, api, apiBase } from './issues.mjs';
 import { ghApi } from './gate.mjs';
 import { PACKAGE_NAME } from './gate-audit.mjs';
 
@@ -253,14 +260,56 @@ export function runLine({ repo, at, you = [], landed = [], opened = [], open_job
   return parts.join(' · ');
 }
 
+// ------------------------------------------------------------ the notice
+
+// R25 line 10. The runner session acts as the owner's login, and GitHub does
+// not tell a person about his own comment. So the session posts its run facts
+// in one comment on the notice issue, and the notice workflow posts the run
+// line as the bot. The workflow trusts no text: it reads the facts as JSON,
+// and runLine refuses any field that is not an id, a count or a known form.
+export const RUN_MARKER = '<!-- atlas-runner:run -->';
+export const NOTICE_LABEL = 'atlas-notice';
+export const noticeBody = (facts) => [RUN_MARKER, '```json', JSON.stringify(facts), '```'].join('\n');
+
+export function factsOf(body) {
+  const text = String(body ?? '');
+  if (!text.startsWith(`${RUN_MARKER}\n`)) return null;
+  const blocks = [...text.matchAll(/```json\n([\s\S]*?)\n```/g)];
+  if (blocks.length !== 1) return null;
+  try { return JSON.parse(blocks[0][1]); } catch { return null; }
+}
+
+export async function runnerNotice({ repo, issue, comment, env = process.env, call = null, allowed = RUNNER_REPOS }) {
+  if (!repoAllowed(repo, allowed)) throw usage(`${repo} is not a runner repo`);
+  const gh = call ?? ((method, path, body) => api(apiBase(env), env.GITHUB_TOKEN, method, path, body));
+  if (!call && !env.GITHUB_TOKEN) throw usage('the notice needs GITHUB_TOKEN, the token of the workflow run');
+  const got = await gh('GET', `/repos/${repo}/issues/comments/${comment}`);
+  if (!got.ok) return { posted: false, why: `GitHub answered ${got.status} for comment ${comment}` };
+  const note = got.data;
+  if (!String(note?.issue_url ?? '').endsWith(`/repos/${repo}/issues/${issue}`)) return { posted: false, why: `comment ${comment} is not on issue #${issue}` };
+  if (note?.author_association !== 'OWNER') return { posted: false, why: `comment ${comment} is not by the owner's login, so no runner wrote it` };
+  const thread = await gh('GET', `/repos/${repo}/issues/${issue}`);
+  const labels = (thread.data?.labels ?? []).map((one) => (typeof one === 'string' ? one : one?.name));
+  if (!thread.ok || !labels.includes(NOTICE_LABEL)) return { posted: false, why: `issue #${issue} is not the notice issue (label ${NOTICE_LABEL})` };
+  const facts = factsOf(note.body);
+  if (!facts) return { posted: false, why: `comment ${comment} holds no run facts` };
+  if (String(facts.repo ?? '').toLowerCase() !== repo.toLowerCase()) return { posted: false, why: `the run facts name ${facts.repo}, not ${repo}` };
+  const runLineText = runLine(facts);
+  const posted = await gh('POST', `/repos/${repo}/issues/${issue}/comments`, { body: runLineText });
+  if (!posted.ok) return { posted: false, why: `GitHub answered ${posted.status} to the notice` };
+  return { posted: true, line: runLineText };
+}
+
 // ------------------------------------------------------------ the command
 
-export async function runnerCommand({ what, repo, issue, holder, from, json = false, args = [] }, line, env = process.env) {
+export async function runnerCommand({ what, repo, issue, holder, from, comment, notice = false, json = false, args = [] }, line, env = process.env) {
   try {
     if ([...args, repo, holder, from].some((a) => typeof a === 'string' && TOKEN_SHAPE.test(a))) throw usage('a token must never be an argument');
     if (what === 'line') {
       if (!from) throw usage('give the run as --from <file>, a JSON object of ids and counts');
-      line(runLine(JSON.parse(readFileSync(from, 'utf8'))));
+      const facts = JSON.parse(readFileSync(from, 'utf8'));
+      const text = runLine(facts);
+      line(notice ? noticeBody(facts) : text);
       return 0;
     }
     if (!repoOk(repo)) throw usage('give the repo as --repo <owner/name>');
@@ -278,7 +327,14 @@ export async function runnerCommand({ what, repo, issue, holder, from, json = fa
       line(result.held ? `HELD: issue #${issue} is this run's` : `TAKEN: issue #${issue} is held by ${result.holder}; leave it`);
       return result.held ? 0 : 1;
     }
-    throw usage('use atlas runner start, atlas runner claim or atlas runner line');
+    if (what === 'notice') {
+      if (!/^[1-9][0-9]{0,8}$/.test(String(issue ?? ''))) throw usage('give the notice issue as --issue <number>');
+      if (!/^[1-9][0-9]{0,11}$/.test(String(comment ?? ''))) throw usage('give the run comment as --comment <id>');
+      const result = await runnerNotice({ repo, issue: Number(issue), comment: Number(comment), env });
+      line(result.posted ? `POSTED: ${result.line}` : `NOT POSTED: ${result.why}`);
+      return result.posted ? 0 : 1;
+    }
+    throw usage('use atlas runner start, claim, line or notice');
   } catch (error) {
     line(`atlas runner: ${error.message}`);
     return error.usage ? 2 : 1;

package/door/lib/signed-act.mjs

@@ -113,13 +113,14 @@ export const AUDIT_CHECKS = Object.freeze(['gate · push audit', AUDIT_CHECK]);
 // The files whose change lets a merge write its own audit: every repo file
 // of the gate and audit groups of GATE_FILE_GROUPS in gate-audit.mjs (a test
 // keeps this list a superset), the signed act that the gate reads, and the
-// job file of the audit. `atlas approve audit` never signs a merge that
+// job file of the audit, and the release job, which runs the release hold
+// (item 4af66381). `atlas approve audit` never signs a merge that
 // changed one (security review 2 of item 0ca9fced, S3). Such a merge takes
 // an accept-code act instead, and its words quote the test AUDIT_CODE_TEST
 // (item f36c6b0f).
 export const AUDIT_WORKFLOW = '.github/workflows/atlas-gate-audit.yml';
 export const AUDIT_CODE = Object.freeze([
-  AUDIT_WORKFLOW, '.github/workflows/atlas-gate.yml', '.github/workflows/atlas-jobs.yml',
+  AUDIT_WORKFLOW, '.github/workflows/atlas-gate.yml', '.github/workflows/atlas-jobs.yml', '.github/workflows/release.yml',
   'packages/atlas/bin/atlas', 'packages/atlas/door/cli.mjs', 'packages/atlas/owner-only.yaml', 'packages/atlas/door/jobs/gate-audit.yaml',
   ...['gate.mjs', 'gate-audit.mjs', 'gate-check.mjs', 'owner-only.mjs', 'jobs.mjs', 'issues.mjs', 'signed-act.mjs'].map((name) => `packages/atlas/door/lib/${name}`),
   'packages/atlas/shape/check.mjs', 'packages/atlas/work/lib/child-env.mjs',

package/door/lib/tooling.mjs

@@ -63,6 +63,11 @@ function packagedPinned(packageRoot, source) {
 export const packagedJobsWorkflow = (packageRoot) => packagedPinned(packageRoot, PACKAGE_JOBS_SOURCE);
 export const packagedUpkeepWorkflow = (packageRoot) => packagedPinned(packageRoot, PACKAGE_UPKEEP_SOURCE);
 export const packagedProceduresWorkflow = (packageRoot) => packagedPinned(packageRoot, PACKAGE_PROCEDURES_SOURCE);
+// The notice workflow of the runner (R25 line 10). It is not in PINNED: until
+// the owner records the A2 exit test, only the scratch repo gets it, by hand.
+export const RUNNER_NOTICE_PATH = '.github/workflows/atlas-runner-notice.yml';
+export const PACKAGE_RUNNER_NOTICE_SOURCE = 'door/templates/atlas-runner-notice.yml';
+export const packagedRunnerNotice = (packageRoot) => packagedPinned(packageRoot, PACKAGE_RUNNER_NOTICE_SOURCE);
 const pinOf = (text) => /@arjunkhera\/atlas@(\d+)\.(\d+)\.(\d+)\b/.exec(text)?.slice(1).map(Number) ?? null;
 const older = (a, b) => { for (let i = 0; i < 3; i += 1) if (a[i] !== b[i]) return a[i] < b[i]; return false; };
 // written, refreshed, unchanged or kept: what the writer does with one pinned workflow.

package/door/templates/atlas-runner-notice.yml

@@ -0,0 +1,41 @@
+name: atlas-runner-notice
+# The notice of the Atlas runner (roadmap R25 line 10). Atlas wrote this file
+# from the Atlas package; do not edit it by hand.
+#
+# A runner session acts as the owner's login, and GitHub does not tell a
+# person about his own comment. So the session posts its run facts in one
+# comment on the notice issue (label atlas-notice), and this job posts the run
+# line as github-actions[bot]. GitHub then tells the owner's phone.
+#
+# It holds no secret, only issues write. It never copies the comment's text:
+# Atlas code reads the facts as JSON and builds the line from ids and counts.
+# Until the owner records the A2 exit test, only the scratch repo has it.
+on:
+  issue_comment:
+    types: [created]
+
+permissions: {}
+
+jobs:
+  notice:
+    if: >-
+      github.event.comment.author_association == 'OWNER' &&
+      startsWith(github.event.comment.body, '<!-- atlas-runner:run -->') &&
+      contains(github.event.issue.labels.*.name, 'atlas-notice')
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      issues: write
+    steps:
+      # actions/setup-node v7.0.0
+      - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020
+        with:
+          node-version: "22.22.0"
+      - name: Post the run line as the bot
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+          ISSUE: ${{ github.event.issue.number }}
+          COMMENT: ${{ github.event.comment.id }}
+        run: |
+          set -euo pipefail
+          npx --yes --ignore-scripts @arjunkhera/atlas@__ATLAS_VERSION__ runner notice --repo "$GITHUB_REPOSITORY" --issue "$ISSUE" --comment "$COMMENT" | tee -a "$GITHUB_STEP_SUMMARY"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arjunkhera/atlas",
-  "version": "0.4.51",
+  "version": "0.4.53",
   "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/lead/SKILL.md

@@ -127,7 +127,7 @@ set. A test keeps the two lists equal.
 | `atlas jobs` | The `atlas-jobs` workflow calls `check`, then `file`, once a day. A session calls it only to see what the watcher would file: `check`, then `file --dry-run` |
 | `atlas runner` | Only in a runner run, as the `atlas:runner` skill says: `start` first, `claim` before each build, `line` last. A lead session never runs the runner |
 | `atlas upkeep` | `check` before you ask for a merge. It reads the docs index, dead doc links, the code each doc names and stale pages. In a pull request it also reads the tracker item, the changed designs, and STE on the changed lines. The daily upkeep run calls it on the main branch. `replay` before the doc-sources rule changes how it gates. `procedures` runs the procedure steps tagged `atlas-run`; CI runs it with `--base` on each pull request |
-| `atlas gate` | `apply` once per repo, by the owner on his Mac, after the repo's `required_checks` exist. `--dry-run` first. `--off` and `--on` are the break glass. On a plan with no rulesets it reports advisory mode. `ready` before each merge, `check` in the `atlas-gate` workflow, `replay` before a change to the owner-only list. `audit` in the daily upkeep run, and with `--commit` in the push job of a repo that has one |
+| `atlas gate` | `apply` once per repo, by the owner on his Mac, after the repo's `required_checks` exist. `--dry-run` first. `--off` and `--on` are the break glass. On a plan with no rulesets it reports advisory mode. `ready` before each merge, `check` in the `atlas-gate` workflow, `replay` before a change to the owner-only list, `hold` only in the release job. `audit` in the daily upkeep run, and with `--commit` in the push job of a repo that has one |
 | `atlas approve` | Never from a session. Only the owner runs it, on his Mac, with his key's touch. When the gate says "owner" for a pull request, ask him once for the signed act: name each pull request, its class and its cause. Put the owner pull requests of one day in one ask, so one touch signs them. `act`, `verify` and `key-check` work the same way. Each morning with open audit issues, ask him for `audit`, and `audit-code <pr>` per audit-code merge; record its words as one decision, then close each issue |
 | `atlas judge` | In the fresh-agent test only, as the `atlas:fresh-agent-test` skill says. `seal` after the pick, `brief` to read a sealed ask, `run` for each sealed task, `check` after the grade |
 

package/skills/runner/SKILL.md

@@ -72,9 +72,12 @@ its environment come from `trigger.yaml` beside this file.
    `the merge door is off in the runner`, `start stopped`. A landed pull
    request carries its `number`, its `release`, and the id of its proof
    comment as `proof`. The command refuses any other text.
-8. Run `atlas runner line --from <file>`. Its output is the last message of
-   the run, word for word. The notice workflow posts it on the repo's notice
-   issue.
+8. Run `atlas runner line --from <file> --notice`. Post its output, word for
+   word, as one comment on the repo's notice issue (label `atlas-notice`).
+   The notice workflow reads the facts and posts the run line as the bot,
+   so GitHub tells the owner.
+9. Run `atlas runner line --from <file>`. Its output is the last message of
+   the run, word for word.
 
 ## Until the exit test