@arjunkhera/atlas 0.3.30 → 0.3.31

package/.claude-plugin/plugin.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arjunkhera/atlas",
-  "version": "0.3.30",
+  "version": "0.3.31",
   "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

@@ -175,6 +175,13 @@ next action. One short paragraph.
    `library` repo proves it by merged pull requests and a green gate. A
    `service` or `schema` repo also needs its live checks, because a schema
    migration reaches the running node after the merge.
+   A red check is a last resort, for an extraordinary case with no other
+   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.
 2. If anything was a struggle, encode the fix where it stops a repeat — a lint,
    then a tool, then a skill, then a doc — and say which.
 3. Rebuild the design's page and the hub, so both read "Shipped". The

package/work/lib/delivery.mjs

@@ -24,6 +24,12 @@ export const FATAL_CONCLUSIONS = Object.freeze(['failure', 'timed_out', 'action_
 const PASSING_CONCLUSION = 'success';
 
 const MAX_PRS = 32;
+const MAX_ACCEPTED_RED = 16;
+// The decision kinds that can carry the owner's acceptance of a red check. A
+// sweep or a priority order says nothing about one merge.
+const ACCEPTING_KINDS = Object.freeze(['decision', 'answer']);
+const OWNER_DECISION_VERBS = Object.freeze(['decision_record', 'question_answer']);
+const MIN_TEST_NAME = 8;
 const MAX_REPOS = 16;
 const MAX_ITEMS = 500;
 const PRS_PER_REPO = 100;
@@ -193,7 +199,7 @@ export function correctionsOf(marks = []) {
 }
 
 export function createDeliveryVerbs(core) {
-  const { client, label, now, typeNamed, registry, requireProduct, requireItem, ownerPresent, patch, create, edge, landed, alreadyPatched, readGitHub, readLive } = core;
+  const { client, label, now, typeNamed, kindOf, registry, requireProduct, requireItem, ownerPresent, patch, create, edge, landed, alreadyPatched, readGitHub, readLive } = core;
 
   const github = async (path) => {
     if (typeof readGitHub !== 'function') refuse('this verb needs a GitHub reader; the server supplies one');
@@ -304,11 +310,76 @@ export function createDeliveryVerbs(core) {
     };
   }
 
+  // Issue #158: the owner can accept one known red check on one merged pull
+  // request, for example a test that only a run after the merge can turn
+  // green. The gate never changes after the merge, so without this the item
+  // could never be marked. GitHub's gate names a check run, not a test, so the
+  // verb proves the check level, and the owner's own recorded words must name
+  // the pull request and the exact test.
+  //
+  // A decision record is an Engram entity, and any Engram writer can make one
+  // that looks right. So the acceptance is not taken from the record alone:
+  // 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).
+  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 }');
+    if (value.length > MAX_ACCEPTED_RED) refuse(`accepted_red holds at most ${MAX_ACCEPTED_RED} entries`);
+    const decisionType = await typeNamed('decision');
+    let replacedIds = null;
+    const rows = [], seen = new Set();
+    for (const entry of value) {
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) refuse('each accepted_red entry must be an object { pr, check, test, decision_id }');
+      for (const key of Object.keys(entry)) if (!['pr', 'check', 'test', 'decision_id'].includes(key)) refuse(`accepted_red does not take ${key}`);
+      const parsed = parsePullUrl(entry.pr, 'accepted_red pr');
+      const pull = pulls.find((one) => one.url === parsed.url);
+      if (!pull) refuse(`accepted_red names ${parsed.url}, which is not one of the prs of this delivery`);
+      const check = text(entry.check, 'accepted_red check', { max: 200 }).trim();
+      const testName = text(entry.test, 'accepted_red test', { max: 500 }).trim();
+      if (!check) refuse('accepted_red check must not be empty');
+      if (testName.length < MIN_TEST_NAME) refuse(`accepted_red test must be the full test name, at least ${MIN_TEST_NAME} characters`);
+      if (seen.has(`${pull.url} check ${check}`)) refuse(`accepted_red names check ${check} on ${pull.url} twice`);
+      seen.add(`${pull.url} check ${check}`);
+      const decisionId = text(entry.decision_id, 'accepted_red decision_id', { max: 200 });
+      // One decision accepts one red check on one pull request. A second
+      // entry with the same decision would stretch the owner's words over a
+      // check the owner never named (finding 2).
+      const key = `${pull.url} ${decisionId}`;
+      if (seen.has(key)) refuse(`accepted_red uses decision ${decisionId} twice on ${pull.url}; one decision accepts one red check`);
+      seen.add(key);
+      let decision;
+      try { decision = await client.getEntity(decisionId); }
+      catch (error) { if (error?.status === 404) refuse(`unknown decision id: ${decisionId}`); throw error; }
+      if ((await kindOf(decision)) !== 'decision') refuse(`entity ${decisionId} is not a decision record`);
+      if (decision.state && decision.state !== 'active') refuse(`decision ${decisionId} is ${decision.state}, not active in the graph`);
+      const said = decision.fields ?? {};
+      const madeBy = Object.values(said.atlas_receipts ?? {}).map((receipt) => receipt?.verb);
+      if (!madeBy.some((verb) => OWNER_DECISION_VERBS.includes(verb))) refuse(`decision ${decisionId} was not written by decision_record or question_answer`);
+      if (!ACCEPTING_KINDS.includes(said.kind)) refuse(`decision ${decisionId} is a ${said.kind} record; the owner accepts a red check with a decision or an answer`);
+      if (!(Array.isArray(said.items) ? said.items : []).includes(item.id)) refuse(`decision ${decisionId} does not name item ${item.id}; the owner's acceptance is recorded on the item it delivers`);
+      // A decision the owner later replaced no longer stands (finding 4).
+      replacedIds ??= new Set((await client.listAllEntities({ type: decisionType.name, state: 'any' })).map((row) => row.fields?.replaces).filter(Boolean));
+      if (replacedIds.has(decision.id)) refuse(`decision ${decisionId} is replaced by a later decision; it no longer stands`);
+      const words = typeof said.text === 'string' ? said.text : '';
+      const source = typeof said.source === 'string' ? said.source : '';
+      // The owner's words name the pull request by its URL, by repo#N, or by
+      // #N; the source counts only when it holds the full URL (finding 5).
+      const namesPull = words.includes(pull.url) || source.includes(pull.url) || words.includes(`${pull.repo}#${pull.number}`)
+        || 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 });
+    }
+    return rows;
+  }
+
   const verbs = {
     // The delivering agent marks its own change done, after the verb runs the
     // three live checks itself. No owner flag: the agent that shipped it calls
     // this, and the lead catches up a delivery made outside a session (R2).
     async item_done(args, requestId, meta) {
+      if (args.accepted_red !== undefined && !ownerPresent) refuse('accepted_red needs the owner-present flag on the server host (ATLAS_WORK_OWNER_PRESENT=1): only the owner waives a red check');
       const item = await requireItem(args.item_id);
       const fields = item.fields ?? {};
       const replay = alreadyPatched(item, requestId, meta);
@@ -336,6 +407,7 @@ export function createDeliveryVerbs(core) {
           delivered_at: standing.fields.marked_at, prs: (standing.fields.prs ?? []).map((pull) => pull.url), deployed_commit: standing.fields.deployed?.commit ?? null,
           checks: (standing.fields.checks ?? []).map((check) => ({ name: check.name, result: check.result, detail: check.detail })),
           verified_by: (standing.fields.verified_by ?? []).map((row) => ({ pr: row.pr, passed: row.passed })), gate_warnings: standing.fields.gate_warnings ?? [],
+          accepted_red: (standing.fields.accepted_red ?? []).map((row) => ({ pr: row.pr, check: row.check, test: row.test, decision_id: row.decision_id, detail: row.detail })),
           replayed_from_graph: true };
       }
 
@@ -394,6 +466,7 @@ export function createDeliveryVerbs(core) {
         const mergeCommit = text(pr.merge_commit_sha, `merge_commit_sha of ${parsed.url}`, { max: 64 });
         pulls.push({ ...parsed, title: oneLine(pr.title ?? '', 200), merged_at: pr.merged_at ?? '', merge_commit_sha: mergeCommit, branch: pr.head?.ref ?? '', base: pr.base?.ref ?? '' });
       }
+      const accepted = await acceptedRed(args.accepted_red, pulls, item);
 
       // The three live checks, for a delivery that reaches a running service.
       let health = null, contains = null, functional = null;
@@ -410,13 +483,25 @@ export function createDeliveryVerbs(core) {
       }
 
       // The gate run, fetched from GitHub for each merge commit (R10).
-      const verified = [], warnings = [];
+      const verified = [], warnings = [], acceptedRows = [];
       for (const pull of pulls) {
         const answer = await github(`repos/${pull.repo}/commits/${pull.merge_commit_sha}/check-runs?per_page=${CHECK_RUNS}`);
         const runs = latestCheckRuns(answer?.check_runs);
         const failed = runs.filter((run) => FATAL_CONCLUSIONS.includes(run.conclusion ?? ''));
         const passed = runs.filter((run) => run.conclusion === PASSING_CONCLUSION);
-        if (failed.length) refuse(`the merge gate is red for ${pull.url}: ${failed.map((run) => `${run.name} ${run.conclusion} (${run.url})`).join(', ')}`);
+        const mine = accepted.filter((row) => row.pr === pull.url);
+        const unaccepted = failed.filter((run) => !mine.some((row) => row.check === run.name));
+        if (unaccepted.length) 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' : ''}`);
+        // An acceptance of a check that is not red is stale: the owner
+        // accepted a red that the gate does not show, so the verb refuses
+        // rather than write an acceptance nobody needed.
+        for (const row of mine) {
+          const run = failed.find((one) => one.name === row.check);
+          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.` });
+        }
         if (!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
         // run was red and whose later run was skipped or neutral is not red and
@@ -431,7 +516,7 @@ export function createDeliveryVerbs(core) {
           warnings.push({ pr: pull.url, check: run.name, earlier: last.conclusion, earlier_url: last.url, latest: run.conclusion, latest_url: run.url,
             detail: `${run.name} concluded ${last.conclusion} for ${pull.url}, and its later run concluded ${run.conclusion}, not success. The verb cannot tell a fixed gate from a gate that was switched off.` });
         }
-        verified.push({ pr: pull.url, commit: pull.merge_commit_sha, runs, passed: passed.map((run) => run.name) });
+        verified.push({ pr: pull.url, commit: pull.merge_commit_sha, runs, passed: passed.map((run) => run.name), ...(mine.length ? { accepted_red: mine.map((row) => row.check) } : {}) });
       }
 
       // One row per check that ran. For a repo with no deploy target the row
@@ -451,11 +536,12 @@ export function createDeliveryVerbs(core) {
           kind: 'delivery', verdict: 'delivered', item: item.id, product: product.fields.registry_id, marked_at: now(),
           prs: pulls.map((pull) => ({ url: pull.url, repo: pull.repo, number: pull.number, title: pull.title, branch: pull.branch, merged_at: pull.merged_at, merge_commit_sha: pull.merge_commit_sha })),
           ...(live ? { deployed: { health_url: healthUrl, commit: health.deployed_commit, reported: health.reported, status: health.status, checked_at: health.checked_at } } : {}),
-          checks, verified_by: verified, ...(warnings.length ? { gate_warnings: warnings } : {}), ...(note ? { note } : {}),
+          checks, verified_by: verified, ...(warnings.length ? { gate_warnings: warnings } : {}), ...(acceptedRows.length ? { accepted_red: acceptedRows } : {}), ...(note ? { note } : {}),
         },
         tags: ['atlas-mark', `product:${product.fields.registry_id}`, ...pulls.map((pull) => `repo:${pull.repo}`)],
       });
       await edge(mark, item, 'references', requestId);
+      for (const row of accepted) await edge(mark, row.decision, 'references', requestId);
       const marks = Array.isArray(fields.delivery_marks) ? fields.delivery_marks : [];
       const patched = replay ? item : await patch(item, 'item_done', requestId, {
         lifecycle: 'done', delivery_state: 'delivered', delivered_at: mark.fields.marked_at,
@@ -467,6 +553,7 @@ export function createDeliveryVerbs(core) {
         proof: live ? 'live-checks' : 'merge-and-gate',
         checks: checks.map((check) => ({ name: check.name, result: check.result, detail: check.detail })),
         verified_by: verified.map((row) => ({ pr: row.pr, passed: row.passed })), gate_warnings: warnings,
+        accepted_red: acceptedRows.map((row) => ({ pr: row.pr, check: row.check, test: row.test, decision_id: row.decision_id, detail: row.detail })),
         ...(replay ? { replayed_from_graph: true } : {}),
       };
     },

package/work/mcp.mjs

@@ -64,7 +64,7 @@ export const TOOLS = [
   { 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: 'receipt_keep', description: `Keep the rendered answer the owner acted on and attach it to a decision. Refuses when there is no decision to attach to. Secret patterns are redacted before the write. Owner present only. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'decision_id', 'rendered'], properties: { request_id: REQUEST_ID, decision_id: S('Entity id of the decision this receipt belongs to.'), rendered: S('The answer as the owner read it.'), view: S('Which view it came from, for example needs-me.') }, 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. 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. 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.') }, 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. 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: 'sweep_check', description: 'Check the sweep against the "In flight" view: the newest decision record of kind sweep names the items the owner called in flight, and this reads the view and names every difference — what is listed and not in flight, and what is in flight and not listed. A product with no sweep on record is named too. It answers two things apart: `matches` says each product\'s view holds exactly what its sweep lists, and `complete` says that and that no item in the tenant sits outside every product. An item nobody adopted is missing from both sides, so `matches` alone can read "equal" over an unfinished sweep. Computed at read time and never stored. Scope: read, no owner flag needed.', inputSchema: { type: 'object', properties: { product: S('Limit the check to one product id.') }, additionalProperties: false } },