@bongos/core 1.19.783 → 1.19.785

package/modules/sessions/db.js

@@ -490,6 +490,11 @@ const SESSION_ORDER = Object.freeze({
   tokens: 'sr.total_tokens DESC, sr.uploaded_at DESC',
   duration: 'sr.duration_seconds DESC NULLS LAST, sr.uploaded_at DESC',
   drachmae: 'sr.drachmae_earned DESC, sr.uploaded_at DESC',
+  // task 1002516 — WORST FIRST, like tool_errors: the sessions worth coaching are
+  // the low-scoring ones. NULLS LAST keeps the un-scorable rows (a fully-waived
+  // expert profile, or a row uploaded before the dimension existed) off the top
+  // of a ranking they have no score to earn.
+  accessibility: "(sr.metrics->'accessibility'->>'score')::numeric ASC NULLS LAST, sr.uploaded_at DESC",
 });
 function resolveSessionOrder(key) {
   return Object.prototype.hasOwnProperty.call(SESSION_ORDER, key) ? SESSION_ORDER[key] : SESSION_ORDER.recent;
@@ -544,6 +549,12 @@ const SESSION_SUMMARY_COLS = `
   sr.task_ids, sr.drachmae_earned, sr.total_tokens, sr.duration_seconds,
   COALESCE((sr.metrics->>'tool_error_count')::int, 0)  AS tool_errors,
   COALESCE((sr.metrics->>'assistant_turns')::int, 0)   AS assistant_turns,
+  -- task 1002516: the transcript accessibility dimension. NOT coalesced to 0 —
+  -- a missing score means "not scored" (waived, or pre-dating the dimension) and
+  -- a zero would read as the worst possible session. The band travels with it so
+  -- the ledger does not have to re-derive the thresholds in the browser.
+  (sr.metrics->'accessibility'->>'score')::numeric      AS accessibility_score,
+  (sr.metrics->'accessibility'->>'band')                AS accessibility_band,
   sr.uploaded_at`;
 
 // searchSessions — cross-builder search over the corpus, filtered by session

package/modules/sessions/routes/sessions.js

@@ -31,7 +31,12 @@ const express = require('express');
 const api = require('../../../src/module-api');
 const auth = api; // requireBuilder / requireRank live on the doorway surface
 const db = require('../db');
-const seams = api; // resolveOptional('reward') — the economy port, kernel-mediated
+// task 1002516 (clause 4 of `accessibility-fluency-profile`): the transcript
+// accessibility dimension. The scorer is this module's own PURE file — it takes
+// the interaction profile as data precisely so it does not have to require
+// builder-settings, which ADR 0083 forbids.
+const { scoreAccessibility } = require('../accessibility');
+const seams = api; // resolveOptional('reward' | 'builder-settings') — kernel-mediated ports
 const { validateOrRespond, parseId } = api;
 
 const UPLOAD_BODY_LIMIT = '4mb';
@@ -237,6 +242,35 @@ module.exports = function buildSessionsRouter() {
       const metrics = body.metrics && typeof body.metrics === 'object' ? { ...body.metrics } : {};
       delete metrics.total_tokens;
       delete metrics.model_usage; // promoted to its own column; avoid two copies
+      // task 1002516 — the accessibility dimension is computed HERE, server-side,
+      // for the same reason drachmae is: a score the uploader could supply is a
+      // score nobody can read. It is also the only place the builder's own
+      // interaction profile is available without another round trip — the
+      // SessionEnd hook runs under a 6-second watchdog, so asking it to fetch
+      // /me would trade a coaching metric for dropped uploads.
+      delete metrics.accessibility; // never trusted from the client
+      const settings = seams.resolveOptional('builder-settings');
+      let interactionProfile = null;
+      let profileUnavailable = false;
+      if (settings && settings.getBuilderBehaviorPrefs && settings.describeInteraction) {
+        // Best-effort: a coaching score must never be the reason an upload 500s.
+        // The failure is RECORDED ON THE ROW rather than logged — a durable flag
+        // a reader of the score can see beats a console line nobody correlates
+        // with the session it degraded.
+        try {
+          const prefs = await settings.getBuilderBehaviorPrefs(req.builder.id);
+          interactionProfile = settings.describeInteraction(prefs).effective;
+        } catch (_) {
+          profileUnavailable = true;
+        }
+      }
+      // With the module off (or the read failed) the scorer falls back to the
+      // accessible-leaning DEFAULT profile, which is the right posture: an
+      // instance that never configured a profile has every builder on it.
+      metrics.accessibility = {
+        ...scoreAccessibility(detailArr, { profile: interactionProfile }),
+        ...(profileUnavailable ? { profile_unavailable: true } : {}),
+      };
       const modelUsage = body.model_usage && typeof body.model_usage === 'object'
         ? body.model_usage : {};
       // upsert + cost-plus token reward in ONE transaction (task 1005). The

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.783",
+  "version": "1.19.785",
   "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/artifact-audit.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+'use strict';
+//
+// scripts/gds/artifact-audit.js — does the work a task CLAIMS actually exist? (task 1003200)
+//
+// THE GAP. `confirmed` means verified and credited, awaiting land. A task can therefore be
+// paid for and reported as done while its artifact exists nowhere reachable. On 2026-08-23
+// three such tasks were found BY ACCIDENT, one at a time: 1003158 (body said "BUILT, tested,
+// 33 tests green"; branch absent from origin), 1002459 (`confirmed` — verified and credited;
+// no branch anywhere), 1002792 (`completed`; the validator it claimed to change was
+// untouched). Nothing compared "the task claims an artifact" against "an artifact exists".
+//
+// WHY THE RECONCILER IS NOT THIS. publish-reconciler.js already proves a land — but only for
+// tasks it is sweeping at `confirmed`, and it writes its misses to a log line. It says nothing
+// about `shipped`, which is where a false "done" is most dangerous: the credit is booked, the
+// ledger reads finished, and no sweep will ever look again.
+//
+// SHAPE COPIED FROM deploy-divergence.js / strand-watch.js, deliberately: cheap, bounded,
+// fail-open, and SILENT when the board is clean. A check that cries wolf gets ignored, and an
+// ignored check is worse than none — which is why the narrowing below is documented step by
+// step rather than tuned until the number looked nice.
+//
+// THE NARROWING (measured 2026-09-16, and every step exists because the previous one lied):
+//
+//   2617  tasks at shipped/confirmed/completed
+//    650  shipped on or after the ship-assurance gate (2026-08-19, task 1002483 / ADR 0184).
+//         Before that gate a DB-only ship recorded no declaration at all, so "no artifact"
+//         is unprovable rather than suspicious — 1469 older ships would be pure noise.
+//     33  with no COMMIT MESSAGE on main naming the task
+//     25  …and no FILE CONTENT on main naming it either. This second source is not optional:
+//         task 1003212's fix is on main and cited in a code comment, but the commit that
+//         carried it never named the task, so a message-only index calls it stranded. That
+//         is the "landed under another branch" case, and it is why this check reads both.
+//      3  …and which actually DECLARE a code artifact (non-empty touches[]). The other 22
+//         declare none — goal edits, claim releases, triage, deploys — and are codeless by
+//         shape, reported quietly instead of as alarms.
+//
+// WHAT THIS CHECK CANNOT DO, stated so nobody trusts it further than it earns. The assurance
+// ledger (`no_artifact` + reason, ship-assurance.js) is written into the audit log, and NO API
+// route exposes it. So "declares no artifact" here is inferred from an EMPTY touches[], not
+// read from the declaration the ship actually made. Exposing the assurance would make the
+// codeless bucket exact; until then it is a shape, and a deploy/ops task whose touches[]
+// describes what a RELEASE carried (rather than what it committed) can land in `stranded`.
+//
+// Usage:
+//   node scripts/gds/artifact-audit.js              # human-readable report
+//   node scripts/gds/artifact-audit.js --line       # ONE line, or nothing; always exit 0
+//   node scripts/gds/artifact-audit.js --json       # machine shape
+//   node scripts/gds/artifact-audit.js --all        # include the pre-gate ships too
+//   node scripts/gds/artifact-audit.js --since YYYY-MM-DD   # override the gate date
+//   node scripts/gds/artifact-audit.js --file-blocker       # ALSO file findings as a blocker
+//
+// Exit codes: 0 always on --line (fail-open). Otherwise 0 clean, 1 strands found, 2 undetermined.
+
+const { execFileSync } = require('node:child_process');
+const { apiCall, arg, hasFlag } = require('./cli-lib');
+const { TASK_LIST_MAX_LIMIT, buildTaskPageQuery } = require('../../modules/lifecycle/task-list-limits.js');
+
+// The statuses where a claimed artifact is supposed to already exist. `shipped` is the one the
+// reconciler never revisits, and the reason this file exists.
+const AUDITED_STATUSES = Object.freeze(['shipped', 'confirmed', 'completed']);
+
+// task 1002483 / ADR 0184 landed the ship-assurance gate on this date. It is the earliest point
+// at which a no-artifact ship had to say so, and therefore the earliest point at which silence
+// means anything at all.
+const ASSURANCE_GATE_DATE = '2026-08-19';
+
+// How a task id is written when something references it: `task 1003200`, `task-1003200`,
+// `task #1003200`. Ids are 6–7 digits; anything shorter is a PR or an issue, not ours.
+const TASK_REF = /task[ _-]#?(\d{6,7})/gi;
+
+const GIT_MAX_BUFFER = 256 * 1024 * 1024;
+
+// ---- pure core --------------------------------------------------------------------------
+// Everything below this comment is IO. Everything above the next one is a pure function of
+// (tasks, two evidence sets), which is what tests/artifact_audit.mjs drives with the three
+// real 2026-08-23 cases as fixtures.
+
+function taskIdsIn(text) {
+  const out = new Set();
+  for (const m of String(text || '').matchAll(TASK_REF)) out.add(m[1]);
+  return out;
+}
+
+// Does this task DECLARE a code artifact? touches[] is the task's own statement about which
+// files its work lands in, so a non-empty one is a promise that something reached the tree.
+function declaresArtifact(task) {
+  return Array.isArray(task.touches) && task.touches.some((p) => String(p || '').trim().length > 0);
+}
+
+// The audit. `messageIds` / `contentIds` are sets of task ids evidenced on main by a commit
+// message and by file content respectively; keeping them separate is what lets the report say
+// HOW a task was proven, which is the difference between a finding and an accusation.
+function auditArtifacts(tasks, { messageIds, contentIds, gateDate = ASSURANCE_GATE_DATE } = {}) {
+  const msg = messageIds instanceof Set ? messageIds : new Set(messageIds || []);
+  const content = contentIds instanceof Set ? contentIds : new Set(contentIds || []);
+  const out = { evidenced: [], preGate: [], codeless: [], stranded: [] };
+
+  for (const t of Array.isArray(tasks) ? tasks : []) {
+    if (!t || !AUDITED_STATUSES.includes(String(t.status))) continue;
+    const id = String(t.id);
+    const row = {
+      id,
+      status: String(t.status),
+      shipped_at: t.shipped_at ? String(t.shipped_at).slice(0, 10) : null,
+      title: String(t.title || ''),
+      touches: Array.isArray(t.touches) ? t.touches : [],
+    };
+
+    // Evidence first, and cheapest first. A task named by a commit message landed under its
+    // own branch; one named only in file content landed under someone else's.
+    if (msg.has(id)) { out.evidenced.push({ ...row, how: 'commit-message' }); continue; }
+    if (content.has(id)) { out.evidenced.push({ ...row, how: 'file-content' }); continue; }
+
+    // Unevidenced. Before the assurance gate, silence is not a signal — see the header.
+    if (!row.shipped_at || row.shipped_at < gateDate) { out.preGate.push(row); continue; }
+
+    (declaresArtifact(t) ? out.stranded : out.codeless).push(row);
+  }
+  return out;
+}
+
+// ---- IO ---------------------------------------------------------------------------------
+
+function gitLines(args) {
+  // `git grep` exits 1 when it matches nothing, which is a legitimate empty result, not a
+  // failure. Anything else is genuinely broken and must not read as "no strands".
+  try {
+    return execFileSync('git', args, { encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER });
+  } catch (e) {
+    if (e && e.status === 1 && typeof e.stdout === 'string') return e.stdout;
+    throw e;
+  }
+}
+
+// Evidence A — every task id named by a commit message reachable from origin/main.
+function messageEvidence(ref) {
+  return taskIdsIn(gitLines(['log', ref, '--format=%s%n%b']));
+}
+
+// Evidence B — every task id named by the CONTENT of a tracked file on origin/main. The repo's
+// doc-comment convention (ADR 0095) cites the task that made a change, so the tree itself is a
+// second, independent record of what landed. -I skips binaries; without it a matching byte run
+// in an image would be counted as a citation.
+function contentEvidence(ref) {
+  return taskIdsIn(gitLines(['grep', '-hoIE', 'task[ _-]#?[0-9]{6,7}', ref]));
+}
+
+// Every task in an audited status, paged — the corpus is well past one page, and asking for
+// more than the cap is a 400 (task 1003752, which is why buildTaskPageQuery exists).
+// `call` is injected (the strand-watch.js pattern) so tests can drive the paging loop with
+// no session and no network.
+async function fetchAuditedTasks({ call = apiCall } = {}) {
+  const rows = [];
+  for (const status of AUDITED_STATUSES) {
+    let offset = 0;
+    for (let page = 0; page < 100; page++) {
+      const q = buildTaskPageQuery({ status, limit: TASK_LIST_MAX_LIMIT, offset });
+      const qs = new URLSearchParams(q).toString();
+      const r = await call('GET', `/api/gds/tasks?${qs}`);
+      if (!r || !r.ok) throw new Error(`GET /tasks?status=${status} → ${r && r.status}`);
+      const page_rows = (r.data && r.data.tasks) || [];
+      rows.push(...page_rows);
+      if (page_rows.length < q.limit) break;
+      offset += q.limit;
+    }
+  }
+  return rows;
+}
+
+module.exports = {
+  auditArtifacts, declaresArtifact, taskIdsIn,
+  AUDITED_STATUSES, ASSURANCE_GATE_DATE, TASK_REF,
+  messageEvidence, contentEvidence, fetchAuditedTasks,
+  blockerSourceRef, blockerBody, fileBlocker,
+};
+
+// ---- the human surface ------------------------------------------------------------------
+// A journal line is where the previous three strands went to die: the reconciler DID diagnose
+// 1002459 and wrote 'land_not_proven' down, and nobody ever read the field. So a finding goes
+// to the Archon blocker surface, where a person actually looks.
+//
+// IDEMPOTENT BY THE FINDING SET, not by the run. POST /blockers dedupes on
+// (source, source_ref), so re-running with the same findings returns 200 {skipped} instead of
+// filing a second copy — but a CHANGED set (a new unproven task) has a different source_ref
+// and files a fresh blocker. A check that spams is a check that gets muted.
+function blockerSourceRef(stranded) {
+  return `unproven:${stranded.map((s) => s.id).sort().join(',')}`;
+}
+
+function blockerBody(stranded) {
+  const lines = [
+    `${stranded.length} task(s) at shipped/confirmed/completed declare a code artifact that nothing on \`main\` names — neither a commit message nor any file's content.`,
+    '',
+    'A task in these statuses has already been credited. If the work is genuinely absent, the ledger is reporting finished work that does not exist (task 1003200).',
+    '',
+  ];
+  for (const s of stranded) {
+    lines.push(`- **task ${s.id}** (${s.status}, shipped ${s.shipped_at}) — ${s.title.slice(0, 90)}`);
+    lines.push(`  - declares: ${s.touches.join(', ')}`);
+  }
+  lines.push('');
+  lines.push('**Confirm each by hand before acting.** A deploy/ops task often lists what a RELEASE carried rather than what it committed, and this check cannot tell those apart: the ship-assurance ledger (a no_artifact declaration and its reason) is written to the audit log and no API route exposes it, so "declares no artifact" is inferred from an empty touches[]. Exposing that declaration would make this exact.');
+  lines.push('');
+  lines.push('Re-run: node scripts/gds/artifact-audit.js');
+  return lines.join('\n');
+}
+
+async function fileBlocker(stranded, { call = apiCall } = {}) {
+  if (!stranded.length) return { filed: false, reason: 'nothing to report' };
+  const r = await call('POST', '/api/gds/blockers', {
+    title: `${stranded.length} shipped task(s) claim an artifact nothing on main names`,
+    body_md: blockerBody(stranded),
+    source: 'artifact-audit',
+    source_ref: blockerSourceRef(stranded),
+  });
+  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 for this exact finding set' };
+  return { filed: true, id: r.data && r.data.blocker && r.data.blocker.id };
+}
+
+// ---- CLI --------------------------------------------------------------------------------
+
+function strandLine(s) {
+  return `Unproven artifact: task ${s.id} (${s.status}, shipped ${s.shipped_at}) claims `
+    + `${s.touches.length} path(s) but nothing on main names it — ${s.touches.slice(0, 2).join(', ')}`;
+}
+
+async function main() {
+  const asJson = hasFlag('--json');
+  const asLine = hasFlag('--line');
+  const includeAll = hasFlag('--all');
+  const gateDate = arg('--since') || ASSURANCE_GATE_DATE;
+  const wantBlocker = hasFlag('--file-blocker');
+  const ref = arg('--ref') || 'origin/main';
+
+  let result;
+  try {
+    const [tasks, messageIds, contentIds] = await Promise.all([
+      fetchAuditedTasks(),
+      Promise.resolve(messageEvidence(ref)),
+      Promise.resolve(contentEvidence(ref)),
+    ]);
+    result = auditArtifacts(tasks, { messageIds, contentIds, gateDate });
+    result.scanned = tasks.length;
+  } catch (e) {
+    // Fail-open, loudly on the full report and silently on --line. A check that cannot run
+    // must never be mistaken for a check that found nothing (task 1003752's whole lesson).
+    if (asLine) return 0;
+    console.error(`artifact-audit: could not complete (${e.message})`);
+    return 2;
+  }
+
+  const { stranded, codeless, preGate, evidenced, scanned } = result;
+
+  if (asLine) {
+    if (stranded.length) {
+      console.log(
+        `${stranded.length} task(s) claim an artifact nothing on main names: `
+        + `${stranded.slice(0, 3).map((s) => s.id).join(', ')}${stranded.length > 3 ? '…' : ''}. `
+        + 'Run `node scripts/gds/artifact-audit.js` — a shipped task whose work never landed is credited work that does not exist.'
+      );
+    }
+    return 0;
+  }
+
+  if (asJson) {
+    // preGate collapses to a COUNT unless --all: it is ~1456 rows that are
+    // unprovable by construction, and emitting them by default would bury the
+    // handful of rows a consumer actually has to act on.
+    console.log(JSON.stringify(includeAll ? result : { ...result, preGate: preGate.length }, null, 2));
+    return stranded.length ? 1 : 0;
+  }
+
+  console.log(
+    `artifact-audit: ${scanned} task(s) at ${AUDITED_STATUSES.join('/')} — `
+    + `${evidenced.length} proven on ${ref}, ${preGate.length} predate the assurance gate (${gateDate}), `
+    + `${codeless.length} declare no artifact, ${stranded.length} UNPROVEN\n`
+  );
+
+  for (const s of stranded) {
+    console.log(`[UNPROVEN] ${strandLine(s)}`);
+    console.log(`           all paths: ${s.touches.join(', ')}`);
+    console.log(`           ${s.title.slice(0, 78)}`);
+    console.log('           → confirm by hand before acting: a deploy/ops task may list what a RELEASE');
+    console.log('             carried rather than what it committed. If the work is genuinely absent, it');
+    console.log('             must be redone or the ship corrected — it was credited.\n');
+  }
+
+  if (wantBlocker && stranded.length) {
+    const filed = await fileBlocker(stranded);
+    console.log(filed.filed
+      ? `Filed blocker ${filed.id} on the Archon surface.`
+      : `Blocker not filed: ${filed.reason}.`);
+  }
+
+  if (!stranded.length) {
+    console.log('Nothing unproven — every post-gate task that claims a code artifact is named on main.');
+  }
+  if (includeAll && preGate.length) {
+    console.log(`\nPre-gate (unprovable by design, ${preGate.length}): ${preGate.slice(0, 20).map((p) => p.id).join(', ')}${preGate.length > 20 ? '…' : ''}`);
+  }
+  return stranded.length ? 1 : 0;
+}
+
+if (require.main === module) {
+  main().then((c) => { process.exitCode = c; })
+    .catch((e) => { console.error('artifact-audit:', e.message); process.exit(2); });
+}

package/scripts/gds/session-eval.js

@@ -19,6 +19,13 @@
 // Pure helper (no I/O) — resolves the per-rank wandering default so the
 // off-task signal below only fires for the CONSTRAINING ranks (task 1268).
 const wanderingPrefs = require('../../modules/builder-settings/wandering-prefs'); // carved → modules/builder-settings/ (BV1.R80 / ADR 0093 §1)
+// task 1002516 (clause 4 of criterion `accessibility-fluency-profile`): the
+// transcript accessibility dimension. The upload route scores it server-side and
+// stores it on the session row; this file re-scores a row that predates the
+// dimension so the BFG's history is not a blank column. Same sibling-read
+// posture as wanderingPrefs above — scripts/ is outside the module boundary
+// fitness scans (modules/sessions/CLAUDE.md, "NOT in this module").
+const { scoreAccessibility } = require('../../modules/sessions/accessibility');
 const { resolveDefaultVersion } = require('./version-select.js');
 
 // ---- classification vocabularies -----------------------------------------
@@ -229,9 +236,37 @@ function detectFootguns(detail, overhead = {}, opts = {}) {
     push('off_task_wandering', wander, firstWander);
   }
 
+  // 8. unplain speech (task 1002516). The accessibility dimension is scored by
+  //    modules/sessions/accessibility.js and arrives here already profile-relative
+  //    — an engineer's session waives every signal and scores null, so it can
+  //    never reach this branch. Two guards keep the finding worth reading:
+  //    the rubric's own 6.0 threshold (below it is the 'dense'/'opaque' bands),
+  //    and a sample big enough to stand behind. count is 1 because this is a
+  //    property of the WHOLE session, not a tally of turns.
+  const acc = opts.accessibility;
+  if (acc && acc.score != null && acc.confidence !== 'low' && acc.score < 6) {
+    const worst = (acc.signals || [])
+      .filter((s) => !s.waived && s.penalty > 0)
+      .sort((a, b) => b.penalty - a.penalty)[0];
+    push('unplain_speech', 1, `accessibility ${acc.score}/10 (${acc.band})${worst ? ` — worst signal: ${worst.type}${worst.evidence ? `; ${worst.evidence}` : ''}` : ''}`);
+  }
+
   return out;
 }
 
+// accessibilityFor — the dimension for one session record. Prefers the score the
+// upload route already computed (it had the builder's real profile in hand);
+// falls back to re-scoring the stored detail for a row uploaded before the
+// dimension existed. The fallback scores at the DEFAULT profile, which is
+// deliberately stated on the result rather than guessed at — a historical row
+// does not carry what the builder's settings were at the time.
+function accessibilityFor(record) {
+  const r = record || {};
+  const stored = r.metrics && typeof r.metrics === 'object' ? r.metrics.accessibility : null;
+  if (stored && typeof stored === 'object') return stored;
+  return { ...scoreAccessibility(Array.isArray(r.detail) ? r.detail : []), rescored: true };
+}
+
 // verdictFor — a coarse label off the overhead ratio, for ranking + reporting.
 function verdictFor(overheadRatio) {
   if (overheadRatio >= 0.7) return 'wasteful';
@@ -246,7 +281,8 @@ function evaluateSession(record) {
   const detail = Array.isArray(r.detail) ? r.detail : [];
   const metrics = r.metrics && typeof r.metrics === 'object' ? r.metrics : {};
   const overhead = computeOverhead(detail);
-  const footguns = detectFootguns(detail, overhead, { rank: r.rank });
+  const accessibility = accessibilityFor(r);
+  const footguns = detectFootguns(detail, overhead, { rank: r.rank, accessibility });
   return {
     session_id: r.session_id,
     builder: r.github_login,
@@ -268,6 +304,10 @@ function evaluateSession(record) {
     buckets: overhead.buckets,
     recovery_user_turns: overhead.recoveryUserTurns,
     footguns,
+    // task 1002516 — the accessibility dimension, per builder (the record carries
+    // github_login + rank), scored against THIS builder's own interaction profile.
+    // Advisory: it is reported and coached, and gates nothing.
+    accessibility,
     // Verdict is driven off the TURN-weighted ratio (task 961) so cache-dominated
     // marathons can no longer hide their ceremony behind a huge token-work bucket.
     verdict: verdictFor(overhead.overheadRatioTurns),
@@ -312,6 +352,10 @@ const FINDING_TEMPLATES = {
     title: 'Wrong-path / worktree↔main-checkout confusion — the corpus #1 error class',
     body: 'The session evaluator saw repeated wrong-path / wrong-worktree failures (File does not exist, EISDIR, Cannot find module, command not found: psql/timeout) — an edit or command aimed at a path/tool not present on this tree (the worktree↔main-checkout split, feedback_edit_under_worktree_path). Make the claim-time context pack push the worktree root + held paths (V4.R04), keep the worktree write guard loud (V4.R13), and ensure the box has psql/timeout on PATH.',
   },
+  unplain_speech: {
+    title: 'Sessions read as jargon, terminal-first or implementation-framed to the builder they were pitched at (task 1002516)',
+    body: 'The session evaluator scored the accessibility dimension below the 6.0 threshold on sessions whose OWN interaction profile did not sanction it — unexplained SWE vocabulary, a terminal command where the hall already has a click-path, or a trade-off framed as architecture instead of cost, time and what the reader will see. The score is profile-relative (an engineer\'s session waives every signal and is never marked down), so a recurring finding means the accessible-by-default posture is not actually arriving. Sharpen the interaction contract the Conductor injects (modules/builder-settings/interaction-prefs.js), or the click-path table in modules/sessions/accessibility.js if a finding named a UI that does not exist.',
+  },
   off_task_wandering: {
     title: 'Off-task wandering — focused-rank agents offering tangents/investigations beyond the claim (task 1268)',
     body: 'The session evaluator saw a constraining-rank builder (Xenos/Thetes, whose wandering default is Locked/Focused) offered to open a new thread beyond the claim — "want me to investigate…", "worth a closer look" — the escalation the wandering knob suppresses (the motivating phantom "credit discrepancy → want me to dig in?" derailment). If this recurs, sharpen the per-rank wandering contract (src/bongos/wandering-prefs.js) the Conductor injects, or build out the level-relative session penalty (the grade-it layer).',
@@ -388,6 +432,7 @@ module.exports = {
   computeOverhead,
   detectFootguns,
   verdictFor,
+  accessibilityFor,
   evaluateSession,
   summarizeSystemicFindings,
   findingsByBuilder,
@@ -477,8 +522,8 @@ if (require.main === module) {
       '',
       `Evaluated ${evaluated.length} candidate session(s) (search order=${order}${minKarma != null ? `, min_karma=${minKarma}` : ''}).`,
       '',
-      '| session | builder | overhead (turn / tok) | verdict | footguns | tokens | drachmae |',
-      '|---|---|---|---|---|---|---|',
+      '| session | builder | overhead (turn / tok) | verdict | plain speech | footguns | tokens | drachmae |',
+      '|---|---|---|---|---|---|---|---|',
     ];
     for (const e of evaluated) {
       const fg = cell(e.footguns.map((f) => `${f.type}×${f.count}`).join(', ') || '—');
@@ -487,7 +532,12 @@ if (require.main === module) {
       const oh = `${Math.round((e.overhead_ratio_turns || 0) * 100)}% / ${Math.round((e.overhead_ratio || 0) * 100)}%`;
       // drachmae_earned alongside the overhead (task 722) so a reviewer can weigh
       // efficiency against the reward the session produced.
-      lines.push(`| ${cell(e.session_id ? e.session_id.slice(0, 8) : '?')} | ${cell(e.builder || '?')} | ${oh} | ${cell(e.verdict)} | ${fg} | ${e.total_tokens || 0} | ${e.drachmae_earned || 0} |`);
+      // task 1002516: an em dash means NOT SCORED — the builder's own profile
+      // waived every signal — never a zero. `~` marks a score re-derived here at
+      // the default profile because the row predates the dimension.
+      const a = e.accessibility || {};
+      const acc = a.score == null ? '—' : `${a.score}/10 ${a.band}${a.rescored ? ' ~' : ''}${a.confidence === 'low' ? ' (thin)' : ''}`;
+      lines.push(`| ${cell(e.session_id ? e.session_id.slice(0, 8) : '?')} | ${cell(e.builder || '?')} | ${oh} | ${cell(e.verdict)} | ${cell(acc)} | ${fg} | ${e.total_tokens || 0} | ${e.drachmae_earned || 0} |`);
     }
     // Systemic findings (footgun classes seen across multiple sessions).
     const systemic = summarizeSystemicFindings(evaluated);

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.783'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.785'; // 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');