@bongos/core 1.19.847 → 1.19.849

package/scripts/gds/ship-escalation.js

@@ -0,0 +1,148 @@
+'use strict';
+//
+// scripts/gds/ship-escalation.js — the exit for a no-artifact close (task 1003950)
+//
+// THE DEAD END THIS REPLACES. A task that is legitimately artifact-free — an ops
+// verification, a DB-only close, or one whose premise turned out to be already-done —
+// could not be closed by any builder below archon, and the two documented paths pointed
+// at each other:
+//
+//     ship.js NNNN --allow-empty   → implies --skip-grade → 403 task.confirm.grade_bypass
+//                                  → "re-run WITHOUT --skip-grade and use --regrade"
+//     ship.js NNNN --regrade       → "Nothing to grade: the committed diff is empty"
+//                                  → "if this task is DELIBERATELY artifact-free, use --allow-empty"
+//
+// Neither exit is reachable at metic. The task parks at `completed` with the claim
+// released — the strand shape the reconciler cannot heal (no branch, no diff, and
+// `completed` sits BEFORE the confirm gate the reconciler sweeps from). Reproduced live
+// 2026-09-16 on task 1003822.
+//
+// WHAT THIS DOES, AND DELIBERATELY DOES NOT DO. It does not move the gate. The owner
+// decision recorded on task 1003950 scoped this to the third of the three shapes the
+// bug offered — "give the refusal a working escalation that does not require the builder
+// to know an archon personally" — because `task.confirm.grade_bypass` is `system: true`
+// in modules/government/catalog.js, one of the four trust-boundary keys ADR 0157 names
+// in its escalation-chain argument. Lowering or forking it is a governance migration and
+// an ADR, filed as task 1004010; grading the NOTES instead of the diff is task 1004011.
+//
+// So the close stays archon-gated. What stops is the LOOP: the refusal now files the
+// escalation on the builder's behalf and terminates, instead of returning them to a flag
+// that will send them back here.
+//
+// IDEMPOTENT BY TASK, not by run — the same reasoning artifact-audit.js carries.
+// POST /blockers dedupes on (source, source_ref), so a builder who re-runs --allow-empty
+// three times while waiting gets ONE blocker, not three. A check that spams is a check
+// that gets muted, and this one is aimed at the surface a person actually reads.
+
+const NO_ARTIFACT_SOURCE = 'no-artifact-close';
+
+// One blocker per task. Deliberately NOT keyed on the builder or the run: two builders
+// hitting the same stuck task should land on the same blocker, not race to file two.
+function escalationSourceRef(taskId) {
+  return `${NO_ARTIFACT_SOURCE}:${taskId}`;
+}
+
+function escalationTitle(taskId, title) {
+  const t = String(title || '').slice(0, 90);
+  return `No-artifact close needs an archon: task ${taskId}${t ? ` — ${t}` : ''}`;
+}
+
+// Pure so the wording is unit-testable without git or network. The body has to carry
+// enough for the archon to make the call WITHOUT re-interviewing the builder — that is
+// the whole point of filing it rather than telling them to go find someone.
+function escalationBody({ taskId, title, floor, summary, notes, builder }) {
+  const reason = [summary, notes].filter(Boolean).join('\n\n');
+  const lines = [
+    `Task **${taskId}** is claimed to be legitimately artifact-free and cannot be closed by its builder.`,
+    '',
+    `- **Task:** ${title || '(untitled)'}`,
+    `- **Declared by:** ${builder || 'the claim holder'} (ran \`ship.js ${taskId} --allow-empty\`)`,
+    `- **Blocked on:** \`task.confirm.grade_bypass\`${floor ? ` (floor: ${floor})` : ''}`,
+    '',
+    '### Why it is stuck',
+    '',
+    'The committed diff is empty and the working tree is clean, so the subagent grader has',
+    'nothing to read. Confirming without a passing grade is archon-gated, and the builder',
+    'holds no route past it. Left alone the task parks at `completed` with the claim',
+    'released — the strand shape the publish reconciler cannot heal, because `completed`',
+    'sits before the `confirmed` gate it sweeps from.',
+    '',
+    '### The reason the builder gave',
+    '',
+    reason || '_(none given — the ship carried no --summary or --notes)_',
+    '',
+    '### What is being asked of you',
+    '',
+    'Decide whether this task is genuinely artifact-free. That claim is the thing worth',
+    'checking here; the absent diff is not evidence either way.',
+    '',
+    `- If yes: \`POST /api/bongos/tasks/${taskId}/confirm\`, or run \`node scripts/gds/ship.js ${taskId} --allow-empty\` yourself.`,
+    '- If no: the work was never done, or never committed — release the claim back to `ready` and say so here.',
+    '',
+    'Filed automatically by the ship path (task 1003950). Re-running `--allow-empty` will',
+    'not file a second copy.',
+  ];
+  return lines.join('\n');
+}
+
+// The terminating refusal. THE ONE INVARIANT: these lines must never send the builder to
+// --regrade, because --regrade on an empty diff sends them straight back to --allow-empty.
+// That mutual advice IS the bug (task 1003950). Pure + exported so a test can assert the
+// loop stays closed rather than trusting a reviewer to notice it reopening.
+function noArtifactRefusalLines({ taskId, floor, escalation }) {
+  const lines = [
+    '',
+    'This task has no artifact to grade, and confirming without a passing grade is',
+    `permission-gated: task.confirm.grade_bypass${floor ? ` (floor: ${floor})` : ''}.`,
+    'This is an authorization wall, not a verdict on your work.',
+    '',
+  ];
+  if (escalation && escalation.filed) {
+    lines.push(`Escalated for you: blocker ${escalation.id} is now on the archon review queue,`);
+    lines.push('carrying this task, the reason you gave, and what is being asked. You do not');
+    lines.push('need to know an archon personally, and there is nothing further to re-run.');
+  } else if (escalation && escalation.reason === 'already-filed') {
+    lines.push('Already escalated: a blocker for this task is open on the archon review queue.');
+    lines.push('Re-running will not speed it up. Nothing further to do here.');
+  } else {
+    // Fail-open: the close is still blocked, so the builder must not be told it worked.
+    const why = escalation && escalation.reason ? ` (${escalation.reason})` : '';
+    lines.push(`Could not file the escalation automatically${why}.`);
+    lines.push('File it by hand so this does not sit silently — post a blocker naming this task:');
+    lines.push('    node scripts/gds/api.js POST /blockers --body-file <path-to-json>');
+  }
+  lines.push('');
+  lines.push(`Your claim on task ${taskId} is unchanged. Do NOT re-run with --regrade:`);
+  lines.push('the diff is empty, so a re-grade has nothing to read and will point you back here.');
+  return lines;
+}
+
+// Best-effort by design: a failure to file must not turn a blocked close into a crash,
+// but it must also never read as success — noArtifactRefusalLines prints the manual
+// fallback when `filed` is false.
+async function fileNoArtifactEscalation({ taskId, title, floor, summary, notes, builder }, { call } = {}) {
+  const post = call || require('./cli-lib').apiCall;
+  let r;
+  try {
+    r = await post('POST', '/api/bongos/blockers', {
+      title: escalationTitle(taskId, title),
+      body_md: escalationBody({ taskId, title, floor, summary, notes, builder }),
+      source: NO_ARTIFACT_SOURCE,
+      source_ref: escalationSourceRef(taskId),
+    });
+  } catch (err) {
+    return { filed: false, reason: `POST /blockers threw: ${err && err.message}` };
+  }
+  if (!r || !r.ok) return { filed: false, reason: `POST /blockers -> ${r && r.status}` };
+  if (r.data && r.data.skipped) return { filed: false, reason: 'already-filed' };
+  return { filed: true, id: r.data && r.data.blocker && r.data.blocker.id };
+}
+
+module.exports = {
+  NO_ARTIFACT_SOURCE,
+  escalationSourceRef,
+  escalationTitle,
+  escalationBody,
+  noArtifactRefusalLines,
+  fileNoArtifactEscalation,
+};

package/scripts/gds/ship-flow.js

@@ -28,6 +28,7 @@ const { pushVia } = require('./ship-deploy-target.js');
 
 const { diffstatFor, finishShip } = require('./ship-finish.js');
 const { evaluateRegradeEligibility, evaluateResumeAction, resumeMerge, shouldConfirmWithoutGrade } = require('./ship-resume.js');
+const { fileNoArtifactEscalation, noArtifactRefusalLines } = require('./ship-escalation.js');
 const { noteServerReward } = require('./ship-state.js');
 
 // ---------- Main flow ----------
@@ -70,6 +71,9 @@ async function shipMain() {
   // empty diff is refused (it used to slip through under --skip-grade — the
   // task-1363 phantom ship). Never overrides a dirty working tree.
   const allowEmpty = args.includes('--allow-empty');
+  // task 1003950: set only when the empty-diff guard below classifies this ship as a
+  // deliberate no-artifact close. Gates the auto-escalation at the confirm wall.
+  let noArtifactClose = false;
   // task 1002605 (G-18): explicit opt-in to continue past a FAILED production
   // smoke run. Without it a smoke FAIL now ABORTS before the claim resolves
   // (claim intact); with it, the resolve proceeds and the task deliberately
@@ -266,6 +270,12 @@ async function shipMain() {
     // There is no committed diff for the subagent grader to read, so confirm
     // directly (this is the DB-only path the old --skip-grade route served).
     if (!skipGrade) skipGrade = true;
+    // task 1003950: mark WHY the grader is being skipped. A --skip-grade ship past a
+    // failing grade and a genuinely artifact-free close both reach the same archon
+    // gate below, but only the second one may be escalated automatically — the first
+    // has a diff the grader DID read and reject, and auto-filing a blocker for it
+    // would be a builder routing their own rejected work to an override queue.
+    noArtifactClose = true;
     console.log('--allow-empty: no committed diff (no-artifact / DB-only ship) — confirming directly without the subagent grader.');
   }
 
@@ -570,6 +580,19 @@ async function shipMain() {
         const details = (errObj && typeof errObj === 'object' && errObj.details) || {};
         const floor = details.floors && details.floors['task.confirm.grade_bypass'];
         const floorNote = floor ? ` (floor: ${floor})` : '';
+        // task 1003950: these two cases used to print the same advice, and for a
+        // no-artifact close that advice was a LOOP — --regrade on an empty diff
+        // refuses and points back at --allow-empty, which lands here again. Split
+        // them: a rejected-grade bypass still has a real diff and a real remedy
+        // (fix the findings, re-grade); an artifact-free close has neither, so it
+        // gets the escalation filed for it and terminates.
+        if (noArtifactClose) {
+          const escalation = await fileNoArtifactEscalation({
+            taskId, title: ac.title, floor, summary, notes, builder: (me.data.builder || {}).github_login,
+          });
+          for (const line of noArtifactRefusalLines({ taskId, floor, escalation })) console.error(line);
+          process.exit(1);
+        }
         console.error('');
         console.error(`✖ Confirming without a passing grade is permission-gated: task.confirm.grade_bypass${floorNote}.`);
         console.error('  This is an authorization wall, not a verdict on your work.');
@@ -907,10 +930,17 @@ async function regradeMain() {
         if (confirm.status === 403 && errCode === 'permission_forbidden') {
           const details = (errObj && typeof errObj === 'object' && errObj.details) || {};
           const floor = details.floors && details.floors['task.confirm.grade_bypass'];
-          console.error('');
-          console.error(`✖ Confirming without a passing grade is permission-gated: task.confirm.grade_bypass${floor ? ` (floor: ${floor})` : ''}.`);
-          console.error('  This is an authorization wall, not a verdict on your work.');
-          console.error(`  Ask a builder whose role holds it to POST /api/bongos/tasks/${taskId}/confirm.`);
+          // task 1003950: this branch is reached ONLY via shouldConfirmWithoutGrade,
+          // which requires both an empty committed diff and an explicit --allow-empty —
+          // so it is always a no-artifact close, and never a bypass of a failing grade.
+          // It used to end at "ask a builder whose role holds it", which is the exact
+          // dead end the bug names: a builder who knows no archon had nowhere to go.
+          const escalation = await fileNoArtifactEscalation({
+            // no `notes` on this path by design: regradeMain REFUSES --notes (see
+            // proseFlagPresent above), so the summary is the only reason the builder gave.
+            taskId, title: task && task.title, floor, summary, builder: builder.github_login,
+          });
+          for (const line of noArtifactRefusalLines({ taskId, floor, escalation })) console.error(line);
           process.exit(1);
         }
         console.error(`manual-confirm failed: ${apiErrorLine(confirm.data, confirm.status)}`);

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.847'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.849'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/no_artifact_escalation.mjs

@@ -0,0 +1,248 @@
+// tests/no_artifact_escalation.mjs
+//
+// Task 1003950 — a no-artifact close must TERMINATE, not loop.
+//
+// The bug: a legitimately artifact-free task (an ops verification, a DB-only close, one
+// whose premise turned out already-done) could not be closed below archon, and the two
+// documented exits advised each other:
+//
+//     --allow-empty  → 403 task.confirm.grade_bypass → "use --regrade"
+//     --regrade      → "the committed diff is empty" → "use --allow-empty"
+//
+// The fix keeps the gate where it is (`task.confirm.grade_bypass` is `system: true` —
+// one of the four trust-boundary keys ADR 0157 names; moving it is task 1004010) and
+// instead FILES the escalation for the builder, then stops.
+//
+// What these tests protect, in order of how easily each would rot:
+//   1. the loop stays closed — no refusal line may advise a command that comes back here;
+//   2. the escalation is actually WIRED at both 403 sites, not merely exported;
+//   3. only a no-artifact close is auto-escalated — a --skip-grade bypass of a FAILING
+//      grade must not be, or a builder could route their own rejected work to the
+//      override queue;
+//   4. filing is idempotent per task, and a filing failure never reads as success.
+//
+// Run:  node tests/no_artifact_escalation.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+import { shipCliSource } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const esc = require('../scripts/gds/ship-escalation.js');
+const {
+  escalationSourceRef, escalationTitle, escalationBody,
+  noArtifactRefusalLines, fileNoArtifactEscalation, NO_ARTIFACT_SOURCE,
+} = esc;
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try {
+    const r = fn();
+    if (r && typeof r.then === 'function') {
+      return r.then(() => { passed++; console.log(`  ok  ${name}`); },
+        (e) => { failed++; console.error(`FAIL  ${name}\n      ${e.message}`); });
+    }
+    passed++; console.log(`  ok  ${name}`);
+  } catch (e) {
+    failed++; console.error(`FAIL  ${name}\n      ${e.message}`);
+  }
+  return Promise.resolve();
+}
+
+const text = (o) => noArtifactRefusalLines(o).join('\n');
+
+// ---- 1. THE LOOP INVARIANT ---------------------------------------------------------
+// This is the whole point of the task. Asserted as "no COMMAND that loops", not "the
+// string --regrade never appears" — the refusal deliberately says *Do NOT* re-run with
+// --regrade, and a naive absence check would forbid that warning and pass a version
+// that quietly went back to recommending it.
+
+await test('the refusal never tells the builder to run a command that returns them here', () => {
+  for (const escalation of [
+    { filed: true, id: 42 },
+    { filed: false, reason: 'already-filed' },
+    { filed: false, reason: 'POST /blockers -> 500' },
+    undefined,
+  ]) {
+    const out = text({ taskId: 1003822, floor: 'archon', escalation });
+    assert.ok(!/node scripts\/gds\/ship\.js\s+\d+\s+--regrade/.test(out),
+      'a runnable --regrade command is the exact advice that loops');
+    assert.ok(!/node scripts\/gds\/ship\.js\s+\d+\s+--allow-empty/.test(out),
+      'and re-running --allow-empty lands on this same refusal');
+    // The refusal deliberately contains "Do NOT re-run with --regrade". Drop that
+    // negated sentence, then assert nothing REMAINING recommends it. A blanket
+    // absence check would forbid the warning while still passing a version that
+    // quietly went back to advising the loop.
+    const withoutWarning = out.replace(/Do NOT re-run with --regrade[^]*/i, '');
+    assert.ok(!/(use|try|re-run with|switch to)\s+`?--regrade/i.test(withoutWarning),
+      'nor may it advise --regrade in prose');
+  }
+});
+
+await test('the refusal explicitly warns AGAINST the old advice, so the loop is closed on the record', () => {
+  const out = text({ taskId: 1003822, floor: 'archon', escalation: { filed: true, id: 42 } });
+  assert.match(out, /Do NOT re-run with --regrade/,
+    'the builder who read the old message needs to be told it was wrong');
+  assert.match(out, /nothing to read/, 'and told why, or they will assume it is a fluke');
+});
+
+await test('every refusal shape names what happens next, so none of them dead-ends', () => {
+  const filed = text({ taskId: 7, escalation: { filed: true, id: 42 } });
+  assert.match(filed, /blocker 42/, 'a filed escalation must name the blocker it filed');
+  assert.match(filed, /nothing further to re-run/i, 'and say the builder is done');
+
+  const dup = text({ taskId: 7, escalation: { filed: false, reason: 'already-filed' } });
+  assert.match(dup, /Already escalated/, 'a second run must not read as a failure');
+  assert.ok(!/Could not file/.test(dup), 'a dedupe is a success, not an error');
+
+  const broke = text({ taskId: 7, escalation: { filed: false, reason: 'POST /blockers -> 500' } });
+  assert.match(broke, /Could not file the escalation/, 'a real failure must say so');
+  assert.match(broke, /500/, 'and name the cause');
+  assert.match(broke, /by hand/, 'and give the manual fallback — the close is still blocked');
+});
+
+await test('the claim is stated as intact — a builder who thinks they lost it will not retry', () => {
+  const out = text({ taskId: 1003822, escalation: { filed: true, id: 1 } });
+  assert.match(out, /claim on task 1003822 is unchanged/);
+});
+
+await test('a missing floor degrades to a clean sentence rather than "floor: undefined"', () => {
+  const out = text({ taskId: 7, floor: undefined, escalation: { filed: true, id: 1 } });
+  assert.ok(!/undefined/.test(out), out);
+  assert.match(out, /task\.confirm\.grade_bypass\./, 'still names the atom');
+});
+
+// ---- 2. WIRED, NOT MERELY EXPORTED -------------------------------------------------
+// A pure unit can be perfect and unreachable. These read the real ship CLI source.
+
+await test('both confirm walls call the escalation — not just the one that is easy to find', () => {
+  const src = shipCliSource();
+  // `await` is what makes this count CALLS: shipCliSource globs ship-*.js, so the
+  // module's own `async function fileNoArtifactEscalation({` is in this source too.
+  const calls = src.match(/await fileNoArtifactEscalation\(\{/g) || [];
+  assert.equal(calls.length, 2,
+    `expected the escalation at BOTH 403 sites (first-ship and --regrade), found ${calls.length}`);
+  assert.match(src, /noArtifactRefusalLines\(\{ taskId, floor, escalation \}\)/,
+    'and each must print the terminating refusal, not roll its own');
+});
+
+await test('ONLY a no-artifact close is auto-escalated, never a bypass of a FAILING grade', () => {
+  // The first-ship wall is reached by --skip-grade too, where the grader DID read a real
+  // diff and rejected it. Auto-filing a blocker there would let a builder route their own
+  // rejected work onto the override queue. The `noArtifactClose` guard is what separates
+  // them, so its absence is a security-shaped regression, not a cosmetic one.
+  const src = shipCliSource();
+  assert.match(src, /if \(noArtifactClose\) \{\s*\n\s*const escalation = await fileNoArtifactEscalation/,
+    'the first-ship escalation must sit behind the noArtifactClose guard');
+  assert.match(src, /noArtifactClose = true;/,
+    'and something must actually SET it, or the branch is unreachable and the guard is a lie');
+  // Reachability: the assignment has to live in the allow-empty branch specifically.
+  const allowEmptyBranch = src.slice(src.indexOf("verdict.reason === 'allow-empty'"));
+  assert.ok(allowEmptyBranch.indexOf('noArtifactClose = true;') > -1
+    && allowEmptyBranch.indexOf('noArtifactClose = true;') < 1200,
+    'noArtifactClose must be set in the allow-empty branch, not somewhere it can never run');
+});
+
+await test('the --regrade call site passes no `notes` — that variable does not exist there', () => {
+  // Caught live while building this: regradeMain REFUSES --notes (proseFlagPresent), so
+  // `notes` is undeclared in that scope. Passing it parses fine and throws a
+  // ReferenceError at the exact moment a blocked builder needs the escalation — the one
+  // moment nothing else is going right. node --check cannot see this; only this can.
+  const src = shipCliSource();
+  const site = src.slice(src.indexOf('title: task && task.title'));
+  const call = site.slice(0, site.indexOf('})'));
+  assert.ok(!/\bnotes\b/.test(call),
+    'the --regrade escalation must not reference `notes`: ' + call);
+});
+
+// ---- 3. IDEMPOTENCY + THE FILING CONTRACT ------------------------------------------
+
+await test('the source_ref is per-TASK, so re-running files one blocker and not three', () => {
+  assert.equal(escalationSourceRef(1003822), 'no-artifact-close:1003822');
+  assert.equal(escalationSourceRef(1003822), escalationSourceRef('1003822'),
+    'a numeric and string id must dedupe to the same ref, or a re-run files a twin');
+  assert.notEqual(escalationSourceRef(1), escalationSourceRef(2), 'different tasks stay distinct');
+});
+
+await test('fileNoArtifactEscalation: posts a well-formed blocker and returns its id', async () => {
+  let seen = null;
+  const r = await fileNoArtifactEscalation(
+    { taskId: 1003822, title: 'a stale premise', floor: 'archon', summary: 'already fixed by 1003529', builder: 'a-builder' },
+    { call: async (method, path, body) => { seen = { method, path, body }; return { ok: true, data: { blocker: { id: 77 } } }; } },
+  );
+  assert.deepEqual(r, { filed: true, id: 77 });
+  assert.equal(seen.method, 'POST');
+  assert.equal(seen.path, '/api/bongos/blockers');
+  assert.equal(seen.body.source, NO_ARTIFACT_SOURCE);
+  assert.equal(seen.body.source_ref, 'no-artifact-close:1003822');
+  assert.match(seen.body.title, /task 1003822/);
+  assert.match(seen.body.body_md, /already fixed by 1003529/, "the builder's reason must reach the archon");
+  assert.match(seen.body.body_md, /a-builder/, 'and so must who declared it');
+});
+
+await test('a dedupe response is reported as already-filed, not as a failure', async () => {
+  const r = await fileNoArtifactEscalation({ taskId: 1 },
+    { call: async () => ({ ok: true, data: { skipped: true } }) });
+  assert.deepEqual(r, { filed: false, reason: 'already-filed' });
+});
+
+await test('a filing failure NEVER reads as filed — the close is still blocked', async () => {
+  const bad = await fileNoArtifactEscalation({ taskId: 1 }, { call: async () => ({ ok: false, status: 500 }) });
+  assert.equal(bad.filed, false);
+  assert.match(bad.reason, /500/);
+
+  const threw = await fileNoArtifactEscalation({ taskId: 1 },
+    { call: async () => { throw new Error('ECONNREFUSED'); } });
+  assert.equal(threw.filed, false, 'a network error must not crash the ship path');
+  assert.match(threw.reason, /ECONNREFUSED/);
+
+  const nullish = await fileNoArtifactEscalation({ taskId: 1 }, { call: async () => null });
+  assert.equal(nullish.filed, false, 'a null response is not a success');
+});
+
+await test('the blocker body carries the decision the archon has to make, both ways', () => {
+  const body = escalationBody({ taskId: 9, title: 't', floor: 'archon', summary: 'ops verify only' });
+  assert.match(body, /If yes/, 'confirm path');
+  assert.match(body, /If no/, 'and the reject path — a one-sided ask gets rubber-stamped');
+  assert.match(body, /tasks\/9\/confirm/, 'with the actual route to run');
+  assert.match(body, /not file a second copy/, 'and reassurance that re-running is harmless');
+});
+
+await test('a reasonless ship still files a legible blocker rather than a blank one', () => {
+  const body = escalationBody({ taskId: 9 });
+  assert.match(body, /none given/, 'the absent reason must be visible, not an empty section');
+  assert.ok(!/undefined|\[object Object\]/.test(body), body);
+  assert.match(escalationTitle(9, null), /task 9/, 'and the title must survive a null title');
+});
+
+await test('the call sites resolve the builder login from me.data.builder, not me.data', () => {
+  // The grade caught this: `me.data.github_login` is ALWAYS undefined — /me returns
+  // { builder, ... } (src/bongos/routes/me.js), and ship-flow.js already proves the
+  // right pattern twice elsewhere. The failure is silent: escalationBody falls back to
+  // 'the claim holder', so the blocker still looks fine while naming nobody — and the
+  // whole reason it is filed is to spare the archon an interview.
+  //
+  // Asserted against SOURCE because both call sites sit behind a live confirm 403; the
+  // direct-call tests below cannot see the field path at all, which is exactly how 14
+  // green tests shipped the bug.
+  const src = shipCliSource();
+  assert.ok(!/me\.data\.github_login/.test(src),
+    'me.data.github_login is always undefined — the login is nested under me.data.builder');
+  assert.match(src, /builder: \(me\.data\.builder \|\| \{\}\)\.github_login/,
+    'the first-ship call site must reach through me.data.builder');
+  assert.match(src, /builder: builder\.github_login/,
+    'the --regrade call site must use the `builder` binding already in scope there');
+});
+
+await test('an unresolved builder degrades to a legible line, not "undefined"', () => {
+  // The fallback above is what the bug hid behind, so it has to stay honest.
+  const body = escalationBody({ taskId: 9, builder: undefined });
+  assert.match(body, /the claim holder/, 'a missing login must read as a role, not a blank');
+  assert.ok(!/undefined/.test(body), body);
+});
+
+console.log('');
+console.log(`no_artifact_escalation: ${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/tests/package_core.mjs

@@ -42,8 +42,11 @@ const {
   scanArtifactForLeaks, PRIOR_INSTANCE_LITERALS,
   // task 1002217 (audit H4) — the fixed neutral floor
   PRIOR_INSTANCE_FLOOR,
+  // task 1003995 — --from-worktree's enumerator, for a core checkout with no git history
+  walkWorktreeEntries,
 } = m;
 const { buildRedactionRules, collectSensitiveLiterals, redactText, findLeaks } = require('../scripts/gds/mirror-redact.js');
+const { isPublishable } = require('../scripts/gds/publish-manifest.js');
 
 // A synthetic instance brand for the classification tests (never the real OTB literals).
 const TEST_BRANDING = {
@@ -747,5 +750,67 @@ t('idea 1000543 (the fix): the isNpmStripped filter makes the pin reproduce agai
   } finally { rmSync(root, { recursive: true, force: true }); }
 });
 
+// ── --from-worktree: the git-less enumeration (task 1003995) ─────────────────────
+// package-core builds the core set from `git ls-tree`, so a core checkout with no .git —
+// the shipped self-host image, where .dockerignore excludes it by design — cannot build
+// the tarball its provisioning scaffold vendors into a child instance. walkWorktreeEntries
+// is the replacement source. It decides only what is OFFERED; isPublishable still decides
+// what is KEPT, so the core set stays defined in exactly one place.
+function worktreeFixture() {
+  const root = mkdtempSync(join(tmpdir(), 'wt-core-'));
+  const put = (rel, body = 'x') => {
+    mkdirSync(join(root, dirname(rel)), { recursive: true });
+    writeFileSync(join(root, rel), body);
+  };
+  put('src/module-api.js');
+  put('src/bongos/tasks.js');                       // nested, to prove the walk recurses
+  put('scripts/gds/package-core.js');
+  put('CLAUDE.md');                                  // an allowlisted FILE entry, not a subtree
+  put('node_modules/@bongos/core/index.js');         // huge + never core: must never be descended
+  put('dist/bongos-core-1.0.0.tgz');                 // this tool's own output
+  put('config/branding.json');                       // instance identity: outside every allowlist root
+  return { root, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+}
+
+t('walkWorktreeEntries: offers the allowlisted tree and never descends node_modules/ or dist/', () => {
+  const { root, cleanup } = worktreeFixture();
+  try {
+    const paths = walkWorktreeEntries(root).map((e) => e.path);
+    assert.deepEqual(
+      paths,
+      ['CLAUDE.md', 'scripts/gds/package-core.js', 'src/bongos/tasks.js', 'src/module-api.js'],
+      `unexpected set: ${paths.join(', ')}`,
+    );
+    assert.ok(!paths.some((p) => p.startsWith('node_modules/')), 'node_modules is never walked');
+    assert.ok(!paths.some((p) => p.startsWith('dist/')), 'the packager never re-enumerates its own output');
+    assert.ok(!paths.includes('config/branding.json'), 'instance identity is outside every allowlist root');
+  } finally { cleanup(); }
+});
+
+t('walkWorktreeEntries: rows match the git-tree shape — sorted blobs carrying a mode', () => {
+  const { root, cleanup } = worktreeFixture();
+  try {
+    const entries = walkWorktreeEntries(root);
+    assert.deepEqual([...entries].sort((a, b) => (a.path < b.path ? -1 : 1)), entries, 'sorted, so the pin is stable');
+    for (const e of entries) {
+      assert.equal(e.type, 'blob', 'only files, matching the ls-tree filter main() applies');
+      assert.ok(['100644', '100755'].includes(e.mode), `mode must be a git file mode, got ${e.mode}`);
+    }
+  } finally { cleanup(); }
+});
+
+t('walkWorktreeEntries: a DENIED path inside an allowlisted subtree is still offered — the denylist is main()’s job, not the walk’s', () => {
+  const { root, cleanup } = worktreeFixture();
+  try {
+    // A host-feature script lives under the allowlisted scripts/ root and is denied by name.
+    // If the walk pre-filtered it, the two enumeration paths would be applying different rules.
+    const denied = 'scripts/gds/art-stage.js';
+    writeFileSync(join(root, denied), 'x');
+    const offered = walkWorktreeEntries(root).map((e) => e.path);
+    assert.ok(offered.includes(denied), 'the walk offers it…');
+    assert.equal(isPublishable(denied), false, '…and isPublishable is what drops it');
+  } finally { cleanup(); }
+});
+
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed ? 1 : 0);