@bongos/core 1.19.794 → 1.19.796

package/modules/hall-ui/public/collab.html

@@ -98,7 +98,7 @@
 <script src="/builders/shell.js?v=2026-07-02-shell1"></script>
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/dom-utils.js?v=2026-06-23-contrib"></script>
-<script src="/builders/collab-lib.js?v=2026-09-16-blocks"></script>
-<script src="/builders/collab.js?v=2026-09-16-blocks"></script>
+<script src="/builders/collab-lib.js?v=2026-09-16-twosentence"></script>
+<script src="/builders/collab.js?v=2026-09-16-twosentence"></script>
 </body>
 </html>

package/modules/hall-ui/public/collab.js

@@ -13,11 +13,15 @@
 //
 // A row is the family's .ov-row--lead: the person's FACE first (collab-lib
 // faceOf: the asker on what was asked of you and on the board, the addressee on
-// your own asks), the ask's first sentence as the title and the rest as the sub
-// (titleOf), the direction as a fact with a door to their profile, the task or
-// goal as a chip, and the AGE as a state pill in the right column, so a glance
-// down a list reads the ages in words and in the verification colours. Every
-// rule that can be pure lives in collab-lib.js where a test can execute it.
+// your own asks), then the ask's first TWO sentences and no more (summaryOf),
+// then the direction as a fact with a door to their profile, the task or goal as
+// a chip, and the AGE as a state pill in the right column, so a glance down a
+// list reads the ages in words and in the verification colours. Every rule that
+// can be pure lives in collab-lib.js where a test can execute it.
+//
+// Under those two sentences, when there is more ask than fits: a door onto the
+// whole thing and a control that copies it verbatim for a fresh session (task
+// 1003960).
 //
 // MATCHING IS THE SERVER'S JOB, not this file's. GET /help-requests/for-me derives
 // the viewer's crafts from their own profile; sending a craft from here would be
@@ -55,10 +59,40 @@
     return `<span class="ov-row__when">${escapeHtml(d.toLocaleDateString(undefined, { day: 'numeric', month: 'short', year: 'numeric' }))}</span>`;
   }
 
-  function titleHtml(req) {
-    const t = L.titleOf(req.what_is_stuck);
-    return `<span class="ov-row__title">${escapeHtml(t.title)}</span>`
-      + (t.rest ? `<p class="ov-row__sub">${escapeHtml(t.rest)}</p>` : '');
+  // A DOM id per row that is stable, unique and safe to put in an attribute. The
+  // same request appears in up to three blocks at once, so the block's key is
+  // part of the id — without it "all open asks" and "your asks" would hand the
+  // same id to two elements and every aria-controls on the page would resolve to
+  // whichever painted first.
+  function askId(key, id) {
+    return `cb-ask-${key}-${String(id).replace(/[^A-Za-z0-9_-]/g, '')}`;
+  }
+
+  // THE FACE IS TWO SENTENCES, AND THE ASK ITSELF IS BEHIND A DOOR (owner
+  // direction, task 1003960: "the text here does not need to be visible, all we
+  // need is two sentences"). An ask is written to be answerable by someone with
+  // none of your context — the skill asks for what is stuck, why this person, the
+  // steps, how to verify and what was already tried, up to 4000 characters — so
+  // the words are worth keeping and were only ever at the wrong altitude.
+  //
+  // THE COPY CONTROL IS THE POINT OF THE DOOR, not an extra. What is behind it is
+  // a handoff: the reader's next move is usually to open a fresh session and
+  // paste the whole ask in as its opening context, and a page that made them
+  // expand, select and drag over four thousand characters would be asking them to
+  // do by hand the one thing it knows they came to do. It sits beside the door in
+  // the CLOSED state on purpose — taking the ask away does not require reading it
+  // here first.
+  function askHtml(req, key) {
+    const s = L.summaryOf(req.what_is_stuck);
+    let html = `<span class="ov-row__title">${escapeHtml(s.title)}</span>`;
+    if (s.lead) html += `<p class="ov-row__sub">${escapeHtml(s.lead)}</p>`;
+    if (!s.more) return html;
+    const fid = askId(key, req.id);
+    return html + `<div class="cb-ask">
+        <button class="cb-ask__door" type="button" data-ask-toggle aria-expanded="false" aria-controls="${fid}">Read the full ask</button>
+        <button class="cb-ask__copy" type="button" data-ask-copy="${fid}">Copy for Session Start</button>
+      </div>
+      <p class="cb-ask__full" id="${fid}" hidden>${escapeHtml(s.more)}</p>`;
   }
 
   function contextChip(req) {
@@ -142,11 +176,11 @@
   // chat mirror). What the page owes a helper is the request, its age, its
   // context, and who to answer — and their face. A by-name ask is the personal
   // call on this reader, so its row is the LIT one (.cb-row--live).
-  function forMeRow(req, nowMs, extra) {
+  function forMeRow(req, nowMs, extra, key) {
     const live = req.needs_builder_id != null ? ' cb-row--live' : '';
     return `<li class="ov-row ov-row--lead cb-row${live}" data-id="${escapeHtml(String(req.id))}"${extra ? ' data-extra hidden' : ''}>
       ${faceHtml(L.faceOf(req, 'in'))}
-      <div class="ov-row__main">${titleHtml(req)}
+      <div class="ov-row__main">${askHtml(req, key)}
         <div class="ov-row__facts">${directionFact(req, 'in')}${contextChip(req)}</div>
       </div>
       <div class="ov-row__right">${ageChip(req, nowMs)}${whenLine(req.created_at)}</div>
@@ -156,11 +190,11 @@
   // Your own ask, led by who you asked, with the two settle actions. Only the
   // asker can settle — the server enforces it in the UPDATE's WHERE, this is
   // just the affordance.
-  function mineRow(req, nowMs, extra) {
+  function mineRow(req, nowMs, extra, key) {
     const id = escapeHtml(String(req.id));
     return `<li class="ov-row ov-row--lead cb-row" data-id="${id}"${extra ? ' data-extra hidden' : ''}>
       ${faceHtml(L.faceOf(req, 'out'))}
-      <div class="ov-row__main">${titleHtml(req)}
+      <div class="ov-row__main">${askHtml(req, key)}
         <div class="ov-row__facts">${directionFact(req, 'out')}${contextChip(req)}</div>
       </div>
       <div class="ov-row__right">${ageChip(req, nowMs)}
@@ -174,10 +208,10 @@
 
   // A row on the board of everyone's asks: the asker's face, the third-person
   // line, no actions — settling is the asker's, in their own block.
-  function allRow(req, nowMs, extra) {
+  function allRow(req, nowMs, extra, key) {
     return `<li class="ov-row ov-row--lead cb-row" data-id="${escapeHtml(String(req.id))}"${extra ? ' data-extra hidden' : ''}>
       ${faceHtml(L.faceOf(req, 'in'))}
-      <div class="ov-row__main">${titleHtml(req)}
+      <div class="ov-row__main">${askHtml(req, key)}
         <div class="ov-row__facts">${boardFact(req)}${contextChip(req)}</div>
       </div>
       <div class="ov-row__right">${ageChip(req, nowMs)}${whenLine(req.created_at)}</div>
@@ -195,8 +229,8 @@
     const { shown, hidden } = L.splitShown(list, SHOWN);
     const host = $(`#cb-${key}`);
     if (host) {
-      host.innerHTML = shown.map((r) => rowFn(r, nowMs, false)).join('')
-        + hidden.map((r) => rowFn(r, nowMs, true)).join('');
+      host.innerHTML = shown.map((r) => rowFn(r, nowMs, false, key)).join('')
+        + hidden.map((r) => rowFn(r, nowMs, true, key)).join('');
     }
     const n = $(`#cb-${key}-n`);
     if (n) n.textContent = list.length ? String(list.length) : '';
@@ -213,6 +247,59 @@
     }
   }
 
+  // The per-row door. Independent of the block's "Show all N", which flips
+  // [data-extra] on the <li>s: this flips one <p> inside one row, so opening a
+  // row inside a condensed block and then expanding the block cannot leave either
+  // control describing a state the page is not in.
+  function toggleAsk(btn) {
+    const full = document.getElementById(btn.getAttribute('aria-controls'));
+    if (!full) return;
+    const open = btn.getAttribute('aria-expanded') === 'true';
+    full.hidden = open;
+    btn.setAttribute('aria-expanded', open ? 'false' : 'true');
+    btn.textContent = open ? 'Read the full ask' : 'Hide the full ask';
+  }
+
+  // Clipboard, with the hall's own fallback (copy-on-click.js's rule): the async
+  // API is absent outside a secure context, and a copy control that silently did
+  // nothing on a plain-http preview would be worse than no control at all — so
+  // the caller is always told which way it went.
+  function writeClipboard(text) {
+    if (navigator.clipboard && navigator.clipboard.writeText && window.isSecureContext) {
+      return navigator.clipboard.writeText(text).then(() => true, () => legacyCopy(text));
+    }
+    return Promise.resolve(legacyCopy(text));
+  }
+
+  function legacyCopy(text) {
+    try {
+      const ta = document.createElement('textarea');
+      ta.value = text;
+      ta.setAttribute('readonly', '');
+      ta.style.position = 'fixed';
+      ta.style.top = '-1000px';
+      ta.style.opacity = '0';
+      document.body.appendChild(ta);
+      ta.select();
+      const ok = document.execCommand('copy');
+      document.body.removeChild(ta);
+      return ok;
+    } catch (_) { return false; }
+  }
+
+  // textContent, not innerText: the hidden <p> holds the ask verbatim including
+  // its line breaks, and innerText on a hidden element is not guaranteed to
+  // return them. What lands on the clipboard is exactly what the asker wrote.
+  function copyAsk(btn) {
+    const full = document.getElementById(btn.getAttribute('data-ask-copy'));
+    if (!full) return;
+    const text = full.textContent || '';
+    if (!text) return;
+    writeClipboard(text).then((ok) => {
+      toast(ok ? 'Copied — paste it in to start a session on this.' : 'Could not copy — open the full ask and copy it by hand.');
+    });
+  }
+
   function toggleMore(btn) {
     const key = btn.id.replace(/^cb-|-more$/g, '');
     const host = $(`#cb-${key}`);
@@ -350,6 +437,10 @@
     const closest = (sel) => (ev.target && ev.target.closest ? ev.target.closest(sel) : null);
     const more = closest('.cb-more');
     if (more) { ev.preventDefault(); toggleMore(more); return; }
+    const door = closest('[data-ask-toggle]');
+    if (door) { ev.preventDefault(); toggleAsk(door); return; }
+    const copyBtn = closest('[data-ask-copy]');
+    if (copyBtn) { ev.preventDefault(); copyAsk(copyBtn); return; }
     const mingleBtn = closest('[data-mingle]');
     if (mingleBtn) {
       ev.preventDefault();

package/modules/ideas/inbox.js

@@ -42,6 +42,12 @@ const VALID_KINDS = [
   // ratify endpoint (assert kind='criterion-proposal' before promotion).
   // CHECK constraint updated in migration 042.
   'criterion-proposal',
+  // task 1003105 — `/planning-session` and `/priority-session` both instruct the
+  // agent to file a retrospective finding as kind='skill-friction', and both
+  // failed BAD_KIND until now. The DB CHECK constraint is widened to match in
+  // migrations/core_244_skill_friction_kind.sql, which also
+  // explains why the legacy title-prefix marker below stays alongside it.
+  'skill-friction',
 ];
 const VALID_STATUSES = ['open', 'promoted', 'discarded', 'merged'];
 
@@ -121,45 +127,13 @@ function ungradedProjection() {
 }
 
 // -------------------------------------------------------------------------
-// Skill-friction tagging (task V3.R70 / #289)
-//
-// The nightly `skill-usage-review` routine files one idea_inbox row per
-// friction pattern it detects. The done-when calls these "kind='skill-friction'"
-// rows, but the DB CHECK constraint on idea_inbox.kind (migration 006) only
-// admits the fixed task-kind enum — adding a literal 'skill-friction' kind
-// would need a new migration, and migrations are explicitly out of scope for
-// this task. So we tag friction rows the same way overnight-code-review tags
-// its findings: a stable title prefix. The underlying `kind` stays a valid
-// enum value (cleanup), and SKILL_FRICTION_TAG is the machine-checkable marker.
-//
-// When the GDS-V3 rank system (V3.R04) lands a real builders.rank column +
-// idea_inbox.kind migration, this prefix convention can be promoted to a
-// first-class kind value and this marker collapses to a kind check.
-const SKILL_FRICTION_TAG = '[skill-friction]';
-
-// -------------------------------------------------------------------------
-// Rank visibility (task V3.R70 / #289)
-//
-// Three ranks are planned in GDS-V3 (V3.R04): Xenos (default for any
-// GitHub-authed person), Metic (Archon-approved), Archon. Skill-friction
-// ideas are a system-evolution signal meant for trusted builders — Xenos
-// must NOT see them in their inbox view; Metic and Archon may.
-//
-// `builders.rank` does not exist in the schema yet (it lands with R04), and
-// requireBuilder does not yet populate req.builder.rank — so today every
-// caller passes viewerRank=null. The gate is written to be correct the moment
-// rank is threaded through: it hides skill-friction rows ONLY when the viewer
-// is positively known to be Xenos. Unknown/absent rank (today's reality, where
-// no Xenos exist yet) is treated as Metic+ and sees everything — so wiring this
-// in does not regress current all-builders behavior.
-const XENOS_RANK = 'xenos';
-
-function rankCanSeeSkillFriction(viewerRank) {
-  // Hide only when we KNOW the viewer is Xenos. null/undefined/anything else
-  // (Metic, Archon, or "rank system not deployed") => allowed.
-  if (viewerRank == null) return true;
-  return String(viewerRank).toLowerCase() !== XENOS_RANK;
-}
+// Skill-friction: the marker a row carries and the rank gate that hides it.
+// Pure, and its own file (./skill-friction.js) for the reason written there —
+// re-exported below so every existing caller keeps working.
+const {
+  SKILL_FRICTION_TAG, SKILL_FRICTION_KIND, XENOS_RANK,
+  rankCanSeeSkillFriction, skillFrictionHiddenClause,
+} = require('./skill-friction');
 
 // -------------------------------------------------------------------------
 // Fallback classifier — keyword heuristics over title+body.
@@ -511,9 +485,8 @@ async function routeIdeaToGoal({
 // see skill-friction rows; Metic+ (or unknown rank, pre-R04) see everything.
 // We filter in SQL when the viewer is positively Xenos so the LIMIT still
 // returns up to `limit` *visible* rows rather than `limit` rows that then get
-// thinned out in JS. The skill-friction marker is a title prefix (see
-// SKILL_FRICTION_TAG above) because the kind enum cannot take a new value
-// without a migration.
+// thinned out in JS. The marker is a kind OR a legacy title prefix — see
+// skillFrictionHiddenClause, which is the only place that knows that.
 async function listOpenIdeas({ kind = null, limit = 50, viewerRank = null } = {}) {
   const params = [];
   const where = [`i.status = 'open'`];
@@ -521,10 +494,8 @@ async function listOpenIdeas({ kind = null, limit = 50, viewerRank = null } = {}
     params.push(kind);
     where.push(`i.kind = $${params.length}`);
   }
-  if (!rankCanSeeSkillFriction(viewerRank)) {
-    params.push(`${SKILL_FRICTION_TAG}%`);
-    where.push(`i.title NOT LIKE $${params.length}`);
-  }
+  const hideFriction = skillFrictionHiddenClause(viewerRank, params, 'i');
+  if (hideFriction) where.push(hideFriction);
   params.push(limit);
   const { rows } = await pool.query(
     `SELECT ${IDEA_COLS_Q}, ${GRADE_COLS_Q}
@@ -570,10 +541,8 @@ async function getIdea(id) {
 async function countOpenIdeas({ viewerRank = null } = {}) {
   const params = [];
   const where = [`status = 'open'`];
-  if (!rankCanSeeSkillFriction(viewerRank)) {
-    params.push(`${SKILL_FRICTION_TAG}%`);
-    where.push(`title NOT LIKE $${params.length}`);
-  }
+  const hideFriction = skillFrictionHiddenClause(viewerRank, params);
+  if (hideFriction) where.push(hideFriction);
   const { rows } = await pool.query(
     `SELECT count(*)::int AS n FROM idea_inbox WHERE ${where.join(' AND ')}`,
     params
@@ -619,10 +588,8 @@ const IDEA_TRAIL_MAX_LIMIT = 100;
 function ideaTrailWhere(builderId, viewerRank, params) {
   params.push(builderId);
   const where = [`i.captured_by = $${params.length}`];
-  if (!rankCanSeeSkillFriction(viewerRank)) {
-    params.push(`${SKILL_FRICTION_TAG}%`);
-    where.push(`i.title NOT LIKE $${params.length}`);
-  }
+  const hideFriction = skillFrictionHiddenClause(viewerRank, params, 'i');
+  if (hideFriction) where.push(hideFriction);
   return where.join(' AND ');
 }
 
@@ -1029,10 +996,8 @@ async function countRoutedAwaitingNod(deps = {}) {
 // agreeing by construction beats them agreeing by accident.
 function sparkQueueWhere(viewerRank, params) {
   const where = [`g.grade = 'spark'`, `i.status = 'open'`];
-  if (!rankCanSeeSkillFriction(viewerRank)) {
-    params.push(`${SKILL_FRICTION_TAG}%`);
-    where.push(`i.title NOT LIKE $${params.length}`);
-  }
+  const hideFriction = skillFrictionHiddenClause(viewerRank, params, 'i');
+  if (hideFriction) where.push(hideFriction);
   return where;
 }
 
@@ -1455,10 +1420,13 @@ module.exports = {
   DEFAULT_TEMPLATE_KEY,
   TEMPLATE_KEY_MAX,
   FIELD_VALUES_MAX,
-  // skill-friction tagging + rank visibility gate (V3.R70 / #289)
+  // skill-friction marker + rank visibility gate (V3.R70 / #289; the kind
+  // itself landed in task 1003105 — both markers are live, see above)
   SKILL_FRICTION_TAG,
+  SKILL_FRICTION_KIND,
   XENOS_RANK,
   rankCanSeeSkillFriction,
+  skillFrictionHiddenClause,
   // capture
   captureIdea,
   // read

package/modules/ideas/skill-friction.js

@@ -0,0 +1,97 @@
+// modules/ideas/skill-friction.js — the skill-friction marker and the rank
+// gate that hides those rows, extracted from inbox.js (task 1003105).
+//
+// WHY ITS OWN FILE. Two reasons, and the second is the real one.
+//
+// `inbox.js` sits against the repo's per-file size budget, and adding the kind
+// plus the reasoning for keeping the legacy marker pushed it over — the fitness
+// ratchet's whole job. Trimming the explanation to fit would have deleted the
+// part a later reader needs most: WHY there are two markers rather than one.
+//
+// And this was always a separable concern. It is pure — no pool, no I/O, no
+// knowledge of a query beyond emitting a fragment — which is the same test
+// `./routing.js` and `./homeless-home.js` already passed when they were split
+// out of the same file. `inbox.js` re-exports everything here, so nothing that
+// reached these through it has to change.
+
+'use strict';
+
+// Skill-friction tagging (task V3.R70 / #289)
+//
+// A skill-friction row carries TWO markers, both first-class, both permanent.
+//
+// The nightly `skill-usage-review` routine files one idea_inbox row per
+// friction pattern it detects, and it has always worked — by tagging a stable
+// title prefix over a valid enum `kind`, because the CHECK constraint on
+// idea_inbox.kind admitted no such value. That workaround named its own exit
+// condition, here and in the routine's SKILL.md: promote the prefix to a real
+// kind once the rank system lands a `builders.rank` column and a migration.
+//
+// Both have landed — rank is live and enforced server-side (ADR 0016), and
+// `viewerRank` reaches all four read paths below from `req.builder.rank` — so
+// task 1003105 added the kind (core_244_skill_friction_kind.sql). What it did
+// NOT do is retire the prefix, and that is the part worth reading twice: the
+// deployed core pin runs behind `main` BY DESIGN (gate 3 of the release
+// pipeline), so there is a window where the database accepts the new kind and
+// the running instance does not yet offer it. A filer flipped inside that
+// window starts failing where it currently succeeds. So the prefix is not a
+// deprecated alias to be swept later — it is the marker every historical row
+// carries and the one the nightly routine still writes, and
+// `skillFrictionHiddenClause` below is the single place that knows both.
+const SKILL_FRICTION_TAG = '[skill-friction]';
+const SKILL_FRICTION_KIND = 'skill-friction';
+
+// -------------------------------------------------------------------------
+// Rank visibility (task V3.R70 / #289)
+//
+// Three ranks are planned in GDS-V3 (V3.R04): Xenos (default for any
+// GitHub-authed person), Metic (Archon-approved), Archon. Skill-friction
+// ideas are a system-evolution signal meant for trusted builders — Xenos
+// must NOT see them in their inbox view; Metic and Archon may.
+//
+// `builders.rank` does not exist in the schema yet (it lands with R04), and
+// requireBuilder does not yet populate req.builder.rank — so today every
+// caller passes viewerRank=null. The gate is written to be correct the moment
+// rank is threaded through: it hides skill-friction rows ONLY when the viewer
+// is positively known to be Xenos. Unknown/absent rank (today's reality, where
+// no Xenos exist yet) is treated as Metic+ and sees everything — so wiring this
+// in does not regress current all-builders behavior.
+const XENOS_RANK = 'xenos';
+
+function rankCanSeeSkillFriction(viewerRank) {
+  // Hide only when we KNOW the viewer is Xenos. null/undefined/anything else
+  // (Metic, Archon, or "rank system not deployed") => allowed.
+  if (viewerRank == null) return true;
+  return String(viewerRank).toLowerCase() !== XENOS_RANK;
+}
+
+// skillFrictionHiddenClause — the ONE predicate meaning "this row is not a
+// skill-friction row", for the four read paths that hide them from a Xenos.
+// It tests BOTH markers (see SKILL_FRICTION_TAG above).
+//
+// It exists as a function rather than four copied conditions because the four
+// gates have to agree and nothing made them: a copy that learned about the new
+// kind while its siblings did not would leak skill-friction rows into exactly
+// one Xenos-facing listing, which is the kind of gap nobody notices until it is
+// in front of the wrong reader. Filtering stays in SQL so a LIMIT still returns
+// up to `limit` VISIBLE rows rather than `limit` rows thinned out afterwards.
+//
+// Pushes its own params onto `params`. Returns null when the viewer may see
+// everything — callers push the clause only when it is non-null, so a viewer
+// with no rank restriction costs no bind parameters at all.
+function skillFrictionHiddenClause(viewerRank, params, alias = '') {
+  if (rankCanSeeSkillFriction(viewerRank)) return null;
+  const col = alias ? `${alias}.` : '';
+  params.push(SKILL_FRICTION_KIND);
+  const kindParam = params.length;
+  params.push(`${SKILL_FRICTION_TAG}%`);
+  return `(${col}kind <> $${kindParam} AND ${col}title NOT LIKE $${params.length})`;
+}
+
+module.exports = {
+  SKILL_FRICTION_TAG,
+  SKILL_FRICTION_KIND,
+  XENOS_RANK,
+  rankCanSeeSkillFriction,
+  skillFrictionHiddenClause,
+};

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.794",
+  "version": "1.19.796",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.794",
+      "version": "1.19.796",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.794",
+  "version": "1.19.796",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/scripts/gds/claude-materialize.js

@@ -16,8 +16,12 @@
 // package; this module copies+transforms them when they ARE present at the core root (today's single
 // checkout, and the core repo itself), and no-ops with a note when they aren't (an installed package).
 // Hooks self-resolve their core require()s at RUNTIME via the copied _core-resolve.js sibling
-// (task 2139, the former W3 follow-up), so no require-path rewriting happens here; shipping a
-// topology STARTER for a package-only install (hooks absent at the core root) stays a follow-up (task 1883).
+// (task 2139, the former W3 follow-up), so no require-path rewriting happens here. The topology
+// STARTER for a package-only install is now HALF built: settings.json is written from
+// renderStarterSettings() below — permissions only, no hooks — because an instance that received
+// the skills but no permissions met the classifier on every blessed command (task 1003962). A hooks
+// starter remains a follow-up (task 1883), and is a different question: hooks ARE gate machinery,
+// where a list of allowed command names is not.
 //
 // SELF-COPY GUARD. When the instance dir IS the core root (running init inside the core checkout /
 // OTB today), there is nothing to materialize — a self-copy would be a no-op at best and corrupting
@@ -296,6 +300,50 @@ function copyTreeTransformed(srcDir, destDir, { dryRun, onFile, overwrite = true
 
 // Transform settings.json: parse, rewrite every hook command through bongosify, re-serialize. Keeps
 // .claude/hooks/*.js commands (instance-local) untouched and rewrites the scripts/gds/*.js ones.
+// The blessed commands an instance builder runs to do the methodology, one rule
+// each (task 1003962). This MIRRORS the core repo's own `.claude/settings.json`
+// allow-list (ADR 0104 / task 1051), translated from `node scripts/gds/<x>.js`
+// into the verb form a materialized instance actually invokes — bongosify()
+// rewrites every skill to `bongos <verb>`, so a path-shaped rule would match
+// nothing there.
+//
+// THE GAP THIS CLOSES. `.claude/settings.json` is excluded from the published
+// package on purpose (PROTECTED_TOPOLOGY_EXCLUDE, beside infra/ and .github/):
+// the core's own copy is deploy and gate machinery that means nothing on an
+// instance. But the skills ship, so an instance received the methodology and
+// none of the permissions that let it run — every instance builder met the
+// auto-mode classifier on the normal workflow, which is how a live builder came
+// to be stuck mid-re-auth with no way forward.
+//
+// WHY THIS IS NOT AN AUTHORITY GRANT (ADR 0016). An allow-rule stops the local
+// agent REFUSING to run a command; it changes nothing about what the server
+// permits. Rank is read fresh from the database on every request by
+// `requireRank`, so a builder who edits this file grants themselves exactly
+// nothing. That is the distinction that makes shipping a list of command names
+// safe where shipping hooks — actual local gate machinery — is not.
+//
+// DELIBERATELY ABSENT: `bongos exec`. It runs any script inside the core by
+// path and is the agent's escape hatch, so allow-listing it would be a blanket
+// grant wearing a narrow rule's clothes. The one script the core's own list
+// blesses (`api.js`) is named in full instead.
+const STARTER_ALLOW = [
+  'Bash(bongos claim:*)',
+  'Bash(bongos ship:*)',
+  'Bash(bongos release:*)',
+  'Bash(bongos reauth:*)',
+  'Bash(bongos paste-token:*)',
+  'Bash(bongos exec scripts/gds/api.js:*)',
+];
+
+// The starter an instance gets when the core root carries no settings.json — a
+// package-only install. Permissions ONLY: no hooks (they are topology), no env.
+function renderStarterSettings() {
+  return `${JSON.stringify({
+    _doc: 'Starter written by scripts/gds/claude-materialize.js (task 1003962). Permissions only — the blessed Bongos commands, mirroring the core repo\'s own allow-list (ADR 0104). An allow-rule lets the local agent RUN a command; it grants no authority, which the server decides per request from your live rank (ADR 0016). Yours to edit: a later materialize never clobbers this file.',
+    permissions: { allow: STARTER_ALLOW },
+  }, null, 2)}\n`;
+}
+
 function transformSettings(srcPath) {
   const raw = fs.readFileSync(srcPath, 'utf8');
   let json;
@@ -484,7 +532,25 @@ function materializeClaude({ coreRoot, instanceDir, dryRun = false, overwrite =
       log(`  ${dryRun ? '[dry-run] would write' : '✓ wrote'} .claude/settings.json (hook commands→bongos, identity rebranded)`);
     }
   } else {
-    summary.notes.push('.claude/settings.json not present at the core root (topology, excluded from the package) — provide it from a starter.');
+    // Package-only install: the core root carries no settings.json to copy, so
+    // write the STARTER instead of leaving the instance with no permissions at
+    // all (task 1003962 — the note that used to sit here said "provide it from a
+    // starter" and nothing ever did). Written only when ABSENT, the same rule
+    // the starter CLAUDE.md below follows: an instance that has grown its own
+    // permissions owns them, and a later materialize must never clobber them.
+    const settingsDest = path.join(destClaude, 'settings.json');
+    if (fs.existsSync(settingsDest)) {
+      summary.skippedFiles.push('settings.json');
+      log('  • .claude/settings.json already present — left untouched (the instance owns it).');
+    } else {
+      if (!dryRun) {
+        fs.mkdirSync(destClaude, { recursive: true });
+        fs.writeFileSync(settingsDest, renderStarterSettings());
+      }
+      summary.settings = true;
+      summary.notes.push(`.claude/settings.json written from the starter — ${STARTER_ALLOW.length} blessed command(s), permissions only.`);
+      log(`  ${dryRun ? '[dry-run] would write' : '✓ wrote'} .claude/settings.json (starter: ${STARTER_ALLOW.length} blessed commands, no hooks)`);
+    }
   }
 
   // 3. hooks — topology; copied WITH an identity rebrand (their .js internals carried
@@ -650,4 +716,4 @@ if (require.main === module) {
   process.exit(s.refused.length ? 1 : 0);
 }
 
-module.exports = { scriptToVerb, bongosify, transformSettings, copyTreeTransformed, materializeClaude, materializeModuleSkillsIntoCore, isCoreCheckoutRoot, readModuleSkillsManifest, MODULE_SKILLS_MANIFEST, readInstanceSkillsManifest, INSTANCE_SKILLS_MANIFEST, GDS_INVOCATION_RE, buildRebrandRules, rebrandText, disabledModuleSkills, moduleSkillRoster, moduleSkillSources, vendoredSkillGate, SKILL_NAME_RE, VENDOR_DEFAULT_POLICY };
+module.exports = { scriptToVerb, bongosify, transformSettings, renderStarterSettings, STARTER_ALLOW, copyTreeTransformed, materializeClaude, materializeModuleSkillsIntoCore, isCoreCheckoutRoot, readModuleSkillsManifest, MODULE_SKILLS_MANIFEST, readInstanceSkillsManifest, INSTANCE_SKILLS_MANIFEST, GDS_INVOCATION_RE, buildRebrandRules, rebrandText, disabledModuleSkills, moduleSkillRoster, moduleSkillSources, vendoredSkillGate, SKILL_NAME_RE, VENDOR_DEFAULT_POLICY };

package/scripts/gds/ship-flow.js

@@ -9,7 +9,7 @@
 'use strict';
 
 const { cliClient, requireSession, arg, detectWorktreeName, cardFlagsFromMe } = require('./cli-lib');
-const { resolveProse, markShipProgress, smokeGateMessages, proseFlagPresent, regradeNotesRefusal } = require('./ship-honesty.js');
+const { resolveProse, markShipProgress, smokeGateMessages, proseFlagPresent, regradeNotesRefusal, staleSummaryNotice } = require('./ship-honesty.js');
 const { classifyEmptyShip } = require('../../modules/lifecycle/ship-preflight');
 const { scopeForModule, isModuleKey } = require('../../src/bongos/module-scope-map');
 const { matchOne } = require('../../src/bongos/path-match');
@@ -826,6 +826,12 @@ async function regradeMain() {
   // PATCH /tasks/:id is the route it uses, and `value_summary` was added to that
   // schema by this same task. tests/ship_cannot_lie.mjs pins the wiring.
   const summary = summaryArg || task.value_summary || '';
+  // task 1003693: the fallback above is silent, and on a re-grade silence means
+  // re-publishing the failed attempt's sentence. Say so while it can still be
+  // corrected — see staleSummaryNotice for the incident this comes from.
+  if (!summaryArg) {
+    for (const line of staleSummaryNotice(taskId, task.value_summary)) console.log(line);
+  }
 
   // The grader helpers want a claim-like object for touches[] (preflight's
   // working-tree-drift check) and head_sha (baseline fallback). The claim is