@bongos/core 1.24.3 → 1.24.5

package/release-notes.json

@@ -10812,7 +10812,43 @@
       "text": "The payments decision record now carries the owner's answers: credits can be tuned but not switched off, pay rules live on the settings page, and Verro is Verro Labs."
     }
   ],
-  "1.24.3": [
+  "1.24.5": [
+    {
+      "id": "1004973",
+      "text": "A page tweak whose apply stopped partway, with nobody holding it any more, now goes back in the queue by itself with a note saying the apply stopped, instead of sitting stuck forever."
+    },
+    {
+      "id": "1005004",
+      "text": "Fixed a check that could wrongly stop a builder from handing back or finishing their own task when their ID arrived written as a number instead of text."
+    },
+    {
+      "id": "1005015",
+      "text": "AI agents now reliably flag when they need you (HUMAN TASK / HUMAN DECISION) and own up when a doc or tool misled them, on every machine, even ones running out-of-date copies."
+    },
+    {
+      "id": "1004972",
+      "text": "A page tweak someone opened but never wrote in now shows as \"Opened, nothing written yet\" instead of \"Needs to be reviewed\", and closes itself after one day with a note saying nothing was written."
+    },
+    {
+      "id": "1004978",
+      "text": "Deleted an old, out-of-date manifest file from the repository root that nothing used, so old scripts it listed no longer look like they are still in use."
+    },
+    {
+      "id": "1004968",
+      "text": "The setting that sizes credit rewards is now called a cost scale instead of a dollar peg, so it no longer reads like an exchange rate; old project settings keep working and nobody's rewards change."
+    },
+    {
+      "id": "1004940",
+      "text": "Every member of a project with Market Watch on now gets a 30-second weekly card in the hall asking what counts as a competitor and what else to watch, and each tap becomes a proposal the owner sees, with matching answers count"
+    },
+    {
+      "id": "1004969",
+      "text": "AI-written ship summaries, new ideas and board proposals that describe credits or models as an investment are now flagged for review, and a test fails if the project's own pages or guides ever say it."
+    },
+    {
+      "id": "1004994",
+      "text": "Someone who signed up with Google, with no GitHub account, can now apply to a project and sign in to its hall like anyone else, so they can work as an ideator or artist, earn credits and hold a rank there. Projects still on an"
+    },
     {
       "id": "1005006",
       "text": "The Treasury screen now counts builder rewards in credits instead of dollars, and no longer says one credit is a dollar."

package/scripts/bongos/backfill-subagent-rewards.js

@@ -111,9 +111,9 @@ const round4 = (n) => Math.round((Number(n) || 0) * 10000) / 10000;
 // unit-tested with no DB (tests/backfill_subagent_rewards.mjs).
 //
 // `row` is the shape fetchCandidates() returns. `cutoffMs` is the dedup-fix
-// boundary; `marginPct`/`usdPeg` come from the instance reward policy so the
+// boundary; `marginPct`/`costScale` come from the instance reward policy so the
 // arithmetic matches what actually pays.
-function classifySession(row, { cutoffMs, marginPct, usdPeg } = {}) {
+function classifySession(row, { cutoffMs, marginPct, costScale } = {}) {
   const sessionId = String(row.session_id);
   const builderId = Number(row.builder_id);
   const paid = Number(row.paid) || 0;
@@ -159,7 +159,7 @@ function classifySession(row, { cutoffMs, marginPct, usdPeg } = {}) {
     row.model_usage, row.total_tokens
   );
   const trueCostUsd = round4(interactiveUsd + subagentUsd);
-  const { drachmae: owed } = credits.computeSessionTokenReward(trueCostUsd, marginPct, usdPeg);
+  const { drachmae: owed } = credits.computeSessionTokenReward(trueCostUsd, marginPct, costScale);
   const delta = owed - paid;
 
   if (delta > 0) {
@@ -177,10 +177,10 @@ function classifySession(row, { cutoffMs, marginPct, usdPeg } = {}) {
 function buildBackfillPlan(rows, opts = {}) {
   const cutoffMs = Date.parse(opts.since || DEDUP_FIX_AT);
   const marginPct = opts.marginPct;
-  const usdPeg = opts.usdPeg;
+  const costScale = opts.costScale;
 
   const sessions = (Array.isArray(rows) ? rows : [])
-    .map((r) => classifySession(r, { cutoffMs, marginPct, usdPeg }));
+    .map((r) => classifySession(r, { cutoffMs, marginPct, costScale }));
 
   const counts = {};
   for (const k of Object.values(CLASSES)) counts[k] = 0;
@@ -393,13 +393,13 @@ async function main() {
     return 2;
   }
 
-  const { marginPct, usdPeg } = credits.rewardConfig();
+  const { marginPct, costScale } = credits.rewardConfig();
   const pool = loadPool();
   let plan;
   let rows;
   try {
     rows = await fetchCandidates(pool);
-    plan = buildBackfillPlan(rows, { since, marginPct, usdPeg });
+    plan = buildBackfillPlan(rows, { since, marginPct, costScale });
   } catch (err) {
     console.error(`could not read the ledger: ${err && err.message ? err.message : err}`);
     await pool.end().catch(() => {});

package/scripts/bongos/codemod-rename-scripts-gds.js

@@ -52,8 +52,7 @@
 //   - files that deliberately name BOTH spellings or the old one: this codemod, forwarder.js,
 //     the forwarder test, modules/lifecycle/executed-closure.js (lists both on purpose),
 //     rename-ledger-prose.js (masks `scripts/gds` as a protected identifier in ledger prose),
-//     the task-2004 codemod (a historical tool), and .bongos-core.json (the manifest of a
-//     core build cut from an older commit — its paths describe THAT build).
+//     and the task-2004 codemod (a historical tool).
 //
 // Usage:
 //   node scripts/bongos/codemod-rename-scripts-gds.js           # apply
@@ -81,7 +80,6 @@ const EXCLUDE = new Set([
   'tests/scripts_gds_forwarders.mjs',
   'modules/lifecycle/executed-closure.js',
   'scripts/bongos/rename-ledger-prose.js',
-  '.bongos-core.json',
 ]);
 
 const FROZEN_PATHS = [

package/scripts/bongos/dev-box-guard.js

@@ -85,7 +85,6 @@ const DEV_BOX_EXEMPT = new Map([
   // Captured data and seed history that name real records.
   ['scripts/bongos/seed-', 'one-shot task seeders: their subject is the historical tasks they filed'],
   ['scripts/hall-preview/fixtures/', 'captured API responses: the ledger still holds these task and goal rows'],
-  ['.bongos-core.json', 'a 1.0.0 seed manifest from July (commit b6ee5d29) that this repo never regenerates'],
 ]);
 
 const TEXT_EXT = /\.(js|mjs|cjs|json|md|sql|sh|html|css|yml|yaml|txt|toml)$/;

package/scripts/bongos/publish-manifest.js

@@ -316,7 +316,7 @@ const INSTANCE_EXCLUDE = [
   // the instance-recipe / game-design carve-outs above. (The portable ADRs + the README index still publish.)
   // The instance's OWN name + trademark decision. Its prose redacts cleanly, but the FILENAME
   // carries the brand and the publish manifest lists every path — so the literal shipped in
-  // .bongos-core.json no matter how well the body was redacted. It also genericizes to nothing:
+  // the tarball's inner .bongos-core.json no matter how well the body was redacted. It also genericizes to nothing:
   // "accepting trademark risk on <our name>" is not a decision another instance inherits.
   // (task 1003869 — the last literal in the artifact.)
   'docs/adr/0004-amazonprimea-name-and-trademark-acceptance.md',

package/scripts/bongos/run-unit-tests.js

@@ -93,6 +93,10 @@ const INTEGRATION = new Set([
   // idempotent and a resumed run unable to record an item twice. DB-free sibling:
   // market_watch_data.
   'market_watch_data_db',
+  // task 1004940: the weekly ask's SQL store — once per week by constraint, one pooled
+  // proposal per similar answer, the project guard on an answer. DB-free sibling:
+  // market_watch_ask.
+  'market_watch_ask_db',
   // bfg, bfg_write, memory_isolation, memory_pull and setup_smoke LEFT this set under task
   // 1004865: none of them ever needed a database. Each failed on a stale test harness (a fake
   // server without res.fail, a stub on the wrong module, an old error shape, a renamed session

package/scripts/hall-preview/server.js

@@ -188,6 +188,8 @@ const CANNED_WRITES = [
   // the owner choosing what a speciality offers (task 1004404): on create, and
   // afterwards from the card's "Offered skills" editor.
   ['POST', /^specialities$/, 'specialities.post'],
+  // the Market Watch weekly ask's answer (task 1004940), so its "sent." state renders.
+  ['POST', /^market-watch\/ask\/answer$/, 'market-watch__ask__answer.post'],
   ['PATCH', /^specialities\/\d+$/, 'specialities__12.patch'],
   // a vote cast from the street's matter card (task 1004528), so the card's
   // answer (the toast, the building lighting) renders here too.
@@ -423,6 +425,17 @@ for (const key of MODULES_ON) {
   const isOn = (k) => !!(mods.enabled && mods.enabled[k]);
   if (stamped['index.html']) stamped['index.html'] = injectModuleHallWidgets(stamped['index.html'], hallWidgetScripts({ isEnabled: isOn }));
   if (stamped['task.html']) stamped['task.html'] = injectModuleHallWidgets(stamped['task.html'], hallWidgetScripts({ isEnabled: isOn, file: 'task-widget.js' }), 'task');
+  // ...and their assets, for the same set. The real asset route (serve-internal.js) gates on
+  // the instance config's enabled set, which ignores --modules-on, so a widget injected for
+  // a module this checkout's config leaves off 404'd and the slot stayed empty (task 1004940).
+  app.get(/^\/modules\/([a-z][a-z0-9-]*)\/public\/([A-Za-z0-9_-][A-Za-z0-9._-]*)$/, (req, res, next) => {
+    // One file name, never a dot-led segment: `..` (or a dotfile) cannot match.
+    const key = req.params[0];
+    if (!isOn(key)) return next();
+    const abs = path.join(ROOT, 'modules', key, 'public', req.params[1]);
+    if (!fs.existsSync(abs)) return next();
+    return res.sendFile(abs);
+  });
 }
 
 function sendPage(res, name) {

package/src/bongos/agent-standing-rules.js

@@ -0,0 +1,44 @@
+'use strict';
+// src/bongos/agent-standing-rules.js — the rules every AI session obeys whoever the
+// builder is, served by the SERVER so a stale checkout still hears them (task 1005015).
+//
+// WHY THE SERVER. The human signal (task 1004922) lived only in the local Conductor
+// hook, told once on a session's first prompt. A hook runs from whatever checkout the
+// machine has, and on the owner's box that was 823 commits behind, so the markers never
+// appeared at all. Slop detection lived only as a CLAUDE.md table row nothing ever
+// triggered. GET /me's interaction contract is relayed verbatim by EVERY Conductor
+// since task 2010, stale ones included, so appending these rules to it reaches every
+// active user the moment the instance serving them runs this code.
+//
+// The wording is the rule's home for sessions; docs/voice.md is its home for people.
+// conductor.js and stop-slopcheck.js carry their own copies (they must work on a
+// checkout whose core cannot load), and tests/agent_standing_rules.mjs holds every
+// copy equal to the contract this file serves. Only withStandingRules is exported:
+// the hooks' dynamic core resolve is invisible to the dead-code scan.
+
+const HUMAN_SIGNAL_TEXT = 'When you need the person, start that line with `🙋 **HUMAN TASK:**` if they must DO something '
+  + 'only a person can do (try it on the live site, add a key, sign in, approve), or `🔀 **HUMAN DECISION:**` if they must '
+  + 'CHOOSE (list the options and mark your pick). Put the same marker at the start of a question-box question. Never use them for anything else.';
+
+const SLOP_TEXT = 'The moment you find you were wrong because something told you so (a doc, a hook\'s output, a script\'s message, '
+  + 'a stale file) — or the person corrects you — say `🐛 Bongo Slop Detected!!, Filing Bug 🐛`, name the source that misled you, '
+  + 'and file it: `node scripts/bongos/capture.js "<file>: says X, truth is Y" --kind bug`. The misleading source is the bug. '
+  + 'Your own plain mistake, with nothing misleading behind it, is not slop.';
+
+const HEADER = 'Standing rules for every session:';
+
+function standingRulesBlock() {
+  return `${HEADER}\n- ${HUMAN_SIGNAL_TEXT}\n- ${SLOP_TEXT}`;
+}
+
+// The interaction slice of GET /me with the standing rules appended. `interaction` is
+// describeInteraction's object or null (builder-settings module off); either way the
+// result injects, because these rules do not depend on any preference. Idempotent.
+function withStandingRules(interaction) {
+  const base = interaction && typeof interaction === 'object' ? interaction : {};
+  const contract = typeof base.contract === 'string' ? base.contract : '';
+  if (contract.includes(HEADER)) return { ...base, inject: true };
+  return { ...base, contract: contract ? `${contract}\n${standingRulesBlock()}` : standingRulesBlock(), inject: true };
+}
+
+module.exports = { withStandingRules };

package/src/bongos/auth-idp.js

@@ -31,11 +31,19 @@ const { loadIdpConfig } = require('./auth-config.js');
 const { newSessionToken } = require('./auth-github.js');
 const log = require('./logger').logger.child({ src: 'auth-idp' });
 
+// This hall can take a person who joined with Google: a negative person key and
+// a stand-in `~handle` login (ADR 0393/0396, task 1004994). The hub sends such a
+// person only to a hall whose authorize link says so, because an older core must
+// never receive one. Mirrored, boundary-forced, by the hub's PERSON_KEYS_PARAM
+// (modules/platform-identity/account-logins.js); tests/google_halls.mjs pins both.
+const PERSON_KEYS_PARAM = 'person_keys';
+
 function idpAuthorizeUrl(origin, clientId, state, redirectUri) {
   const u = new URL(`${String(origin).replace(/\/+$/, '')}/api/bongos/sso/authorize`);
   u.searchParams.set('client_id', clientId);
   u.searchParams.set('redirect_uri', redirectUri);
   u.searchParams.set('state', state);
+  u.searchParams.set(PERSON_KEYS_PARAM, '1');
   return u.toString();
 }
 
@@ -88,7 +96,7 @@ async function completeIdpFlow({ code, redirectUri, userAgent: ua }) {
   const ghLogin = identity.github_login;
   const existing = await getBuilderByGithubId(ghId);
   if (!existing && !openEnrollmentEnabled()) {
-    const approved = await hasInvitedAccessRequest(ghLogin);
+    const approved = await hasInvitedAccessRequest(ghLogin, ghId);
     if (firstTimeAdmissionBlocked({ existing, approved, login: ghLogin })) {
       const err = new Error('not_approved');
       err.code = 'NOT_APPROVED';
@@ -286,9 +294,12 @@ function applicationVouchIdentity(token, { githubLogin, publicKey, clientId, now
   }
   // The body's login is a string anyone may type: a vouch for another account is no vouch.
   if (String(payload.applicant_login).toLowerCase() !== String(githubLogin || '').toLowerCase()) return null;
-  // The hub mints only for a numeric GitHub id; anything else is not one, and the id
-  // feeds readApplicantProfileFromHub (defence in depth, the ADR 0171 D2 guard).
-  if (!/^\d+$/.test(String(payload.sub))) return null;
+  // The hub mints only for a numeric GitHub id, or for a person who joined with
+  // Google: a negative key that always travels with a stand-in `~handle` login
+  // (task 1004994). They come as a pair, so neither can borrow the other's shape.
+  // The id feeds readApplicantProfileFromHub (defence in depth, the ADR 0171 D2 guard).
+  const standIn = String(payload.applicant_login || '').startsWith('~');
+  if (!(standIn ? /^-\d+$/ : /^\d+$/).test(String(payload.sub))) return null;
   if (vouchJtiSeenAndRecord(payload.jti, payload.exp, nowMs)) return null;
   return {
     githubId: String(payload.sub),
@@ -321,7 +332,7 @@ async function completeDeviceExchange({ assertion, userAgent: ua }) {
   const ghLogin = payload.github_login;
   const existing = await getBuilderByGithubId(ghId);
   if (!existing && !openEnrollmentEnabled()) {
-    const approved = await hasInvitedAccessRequest(ghLogin);
+    const approved = await hasInvitedAccessRequest(ghLogin, ghId);
     if (firstTimeAdmissionBlocked({ existing, approved, login: ghLogin })) {
       const err = new Error('not_approved');
       err.code = 'NOT_APPROVED';
@@ -380,6 +391,7 @@ module.exports = {
   idpAuthorizeUrl,
   loadHubPublicKey,
   logoutTokenJtiSeenAndRecord,
+  PERSON_KEYS_PARAM,
   readApplicationVouch,
   verifyHubApplicationVouch,
   verifyHubAssertion,

package/src/bongos/db-kernel.js

@@ -239,7 +239,20 @@ async function getBuilderByGithubId(githubId) {
 // row at status='invited', case-insensitive)? The approval signal that lets a
 // first-time web sign-in through. An invite older than 30 days no longer counts
 // (inviteLiveSql, task 1002969 / ADR 0356); an approved application never expires.
-async function hasInvitedAccessRequest(login) {
+//
+// A person who joined with Google (a negative person key, ADR 0393) is matched by
+// the key the hub vouched for, never by their stand-in `~handle`: a handle can be
+// renamed and later taken by someone else, so an approval of `~ana` must not
+// admit whoever is `~ana` next (task 1004994).
+async function hasInvitedAccessRequest(login, githubId) {
+  if (/^-\d+$/.test(String(githubId ?? ''))) {
+    const { rows } = await pool.query(
+      `SELECT 1 FROM access_requests
+        WHERE applicant_github_id = $1 AND status = 'invited' AND ${inviteLiveSql()} LIMIT 1`,
+      [String(githubId)]
+    );
+    return rows.length > 0;
+  }
   const { rows } = await pool.query(
     `SELECT 1 FROM access_requests
       WHERE lower(github_login) = lower($1) AND status = 'invited' AND ${inviteLiveSql()} LIMIT 1`,

package/src/bongos/module-scope-map.js

@@ -198,6 +198,7 @@ const MODULE_GLOBS = {
     'modules/market-watch/', 'tests/market_watch_module.mjs',
     'tests/market_watch_data.mjs', 'tests/market_watch_data_db.mjs',
     'tests/market_watch_run.mjs',
+    'tests/market_watch_ask.mjs', 'tests/market_watch_ask_db.mjs',
   ],
   // --- builder prefs (wandering/skill/sound/render) + builder-needs ---
   // Carved into modules/builder-settings/ (BV1.R80 / ADR 0093 §1): the five pref
@@ -614,8 +615,9 @@ const SHARED_GLOBS = Object.freeze(
 // Assigning nineteen roots in one pass is the one-at-a-time churn task 1004132 was
 // filed to avoid; freezing the set and naming the arguable ones is the cheap half.
 const UNOWNED_ROOTS = Object.freeze({
-  // Generated packaging manifests — written by package-core.js, never hand-edited.
-  '.bongos-core.json': 'generated package manifest (scripts/bongos/package-core.js)',
+  // Generated packaging manifest — written by package-core.js, never hand-edited.
+  // (The repo-root .bongos-core.json, a stale July 1.0.0 seed, was deleted in task 1004978;
+  // the live one is the INNER manifest package-core writes into the tarball.)
   '.cloudbongos-core.json': 'generated package manifest (scripts/bongos/package-core.js)',
   // Governance + legal. Deliberately not methodology: methodology owns docs/, and
   // these are the project's constitutional documents rather than its handbook.

package/src/bongos/routes/me.js

@@ -34,6 +34,7 @@ const db = require('../db');
 // prefs-module-less instance so the slices simply render their unset/default shape.
 const { validateOrRespond } = require('./_helpers');
 const { readModes: readCraftModes, describeCraftMode } = require('../craft-mode'); // task 1002992
+const { withStandingRules } = require('../agent-standing-rules'); // task 1005015
 const { branding } = require('../../branding'); // task 2011: instance model-allocation default
 // The onboarding state machine carved into modules/onboarding/ (BV1.R81 / ADR
 // 0093 §1): the GET /me aggregator + PATCH /me/disciplines resolve the
@@ -565,7 +566,9 @@ module.exports = function buildMeRouter() {
       // contract. The old §2 "The Prompter" owner-defaults, now per-builder. The
       // session-start injection + /settings UI read this; describeInteraction is
       // the SSOT (builder-settings port). null when the prefs module is off.
-      interaction: lawed ? lawed.interaction : (settings && settings.describeInteraction ? settings.describeInteraction(behaviorPrefs) : null),
+      // task 1005015: the standing rules (human-task markers, slop detection) ride
+      // this contract because every Conductor, stale ones included, relays it.
+      interaction: withStandingRules(lawed ? lawed.interaction : (settings && settings.describeInteraction ? settings.describeInteraction(behaviorPrefs) : null)),
       // task 1004707: the project's LAWS, read into every AI session. The
       // Conductor hook relays `contract` verbatim beside the interaction profile
       // (inject:false, and no block, when no law is in force). `laws` is the book

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.24.3'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.24.5'; // 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('discord'); log.info('mounted');

package/tests/account_logins.mjs

@@ -307,7 +307,7 @@ test('GET /me/sign-in-methods fails closed on a read error', async () => {
   }
 });
 
-test('a Google-only person is not relayed to a project until halls can take one (task 1004994)', async () => {
+test('a Google-only person goes on to the project lookup like anyone else (task 1004994)', async () => {
   ME = '-3';
   scriptRoute([]);
   try {
@@ -319,8 +319,10 @@ test('a Google-only person is not relayed to a project until halls can take one
       });
       r.on('error', reject); r.end(body);
     });
-    assert.equal(res.status, 409);
-    assert.equal(res.body.error.code, 'google_join_not_yet');
-    assert.equal(routePool.log.length, 0, 'nothing was read or relayed');
+    // No project is scripted, so the lookup answers unknown_project: the point is
+    // that the join reached it rather than refusing the person first.
+    assert.equal(res.status, 404);
+    assert.equal(res.body.error.code, 'unknown_project');
+    assert.ok(routePool.log.length > 0, 'the registered project was looked up');
   } finally { ME = '4242'; }
 });

package/tests/agent_standing_rules.mjs

@@ -0,0 +1,142 @@
+// tests/agent_standing_rules.mjs — the human-task markers and the Slop Bongo rule reach
+// every session (task 1005015).
+//
+// They used to live only in the local Conductor hook (markers, first prompt only) and
+// a CLAUDE.md table row (slop, never triggered), so a stale checkout or a long session
+// lost them. Now: the SERVER appends them to the interaction contract every Conductor
+// relays; the Conductor re-says them when the person corrects the agent or is about to
+// be asked something; a Stop hook asks once when the agent reverses itself.
+//
+// .claude/hooks/ is package-excluded, so a clean core checkout skips this file
+// (tests/host_topology_skips.mjs carries the allowlist entry).
+//
+// Run:  node tests/agent_standing_rules.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { requireHostModule } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const rules = require('../src/bongos/agent-standing-rules.js');
+const conductor = requireHostModule(require, '../.claude/hooks/conductor.js');
+const slopcheck = requireHostModule(require, '../.claude/hooks/stop-slopcheck.js');
+
+// The words as the server serves them: a header line, then one '- ' line per rule.
+const [HEADER, HUMAN, SLOP] = rules.withStandingRules(null).contract.split('\n').map((l, i) => (i ? l.slice(2) : l));
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); } catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+t('the server appends both rules to a builder\'s interaction contract and keeps it injecting', () => {
+  const out = rules.withStandingRules({ inject: true, contract: 'Interaction profile — P', fields: [1] });
+  assert.ok(out.contract.startsWith('Interaction profile — P\n'), 'the profile stays first');
+  assert.ok(out.contract.includes(HUMAN));
+  assert.ok(out.contract.includes(SLOP));
+  assert.equal(out.inject, true);
+  assert.deepEqual(out.fields, [1], 'the rest of the slice is untouched');
+});
+
+t('with the settings module off (null) the rules still reach the session', () => {
+  const out = rules.withStandingRules(null);
+  assert.equal(out.inject, true);
+  assert.ok(out.contract.startsWith(HEADER));
+});
+
+t('appending is idempotent', () => {
+  const once = rules.withStandingRules({ inject: true, contract: 'P' });
+  assert.equal(rules.withStandingRules(once).contract, once.contract);
+});
+
+t('GET /me wraps the interaction slice (wiring pin)', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'routes', 'me.js'), 'utf8');
+  assert.match(src, /interaction: withStandingRules\(/);
+});
+
+t('the rules mark both markers and the slop line exactly as the owner set them', () => {
+  assert.ok(HUMAN.includes('🙋 **HUMAN TASK:**'));
+  assert.ok(HUMAN.includes('🔀 **HUMAN DECISION:**'));
+  assert.ok(SLOP.includes('🐛 Bongo Slop Detected!!, Filing Bug 🐛'));
+  assert.ok(fs.readFileSync(path.join(ROOT, 'CLAUDE.md'), 'utf8').includes('🐛 Bongo Slop Detected!!, Filing Bug 🐛'), 'CLAUDE.md says the same line');
+});
+
+t('the Conductor\'s copy says exactly what the server sends', () => {
+  assert.equal(conductor.HUMAN_SIGNAL_TEXT, HUMAN);
+  assert.equal(conductor.SLOP_TEXT, SLOP);
+  assert.equal(conductor.STANDING_HEADER, HEADER);
+});
+
+t('the first-prompt marker line is skipped when the server already sent the rules', () => {
+  const served = rules.withStandingRules({ inject: true, contract: 'P' });
+  const a = conductor.evaluateTriggers({ firstPrompt: true, interaction: served });
+  assert.ok(!a.some((x) => x.id === 'human-signal'));
+  assert.ok(a.some((x) => x.id === 'interaction' && x.text.includes('HUMAN TASK')));
+  const old = conductor.evaluateTriggers({ firstPrompt: true, interaction: { inject: true, contract: 'P' } });
+  assert.ok(old.some((x) => x.id === 'human-signal'), 'an older server still gets the local line');
+});
+
+t('an ask names the markers', () => {
+  const a = conductor.evaluateTriggers({ prompt: 'file a blocker for this' }).find((x) => x.id === 'ask-shape');
+  assert.ok(a && a.text.includes('🔀 **HUMAN DECISION:**') && a.text.includes('🙋 **HUMAN TASK:**'));
+});
+
+t('a person correcting the agent triggers the slop check, every time', () => {
+  for (const p of ["that's wrong, it is live", 'you said it needs a dev box', 'actually it already works', "it's already deployed", 'not true', 'is slop detection firing?']) {
+    const a = conductor.evaluateTriggers({ prompt: p }).find((x) => x.id === 'slop-check');
+    assert.ok(a, `no slop check for: ${p}`);
+    assert.equal(a.always, true, 'renders even when the advisory set repeats');
+  }
+});
+
+t('ordinary prompts do not trigger the slop check', () => {
+  for (const p of ['add a dark mode toggle', 'run the tests', 'what can I work on', 'make the button wider']) {
+    assert.ok(!conductor.evaluateTriggers({ prompt: p }).some((x) => x.id === 'slop-check'), p);
+  }
+});
+
+t('the Stop hook asks once when the agent reverses itself', () => {
+  for (const m of ['Turns out the deploy needs no ssh.', 'I was wrong about the branch.', 'My mistake — it is live.', 'I said it was stale but it is current.']) {
+    const r = slopcheck.evaluate(m);
+    assert.equal(r.block, true, m);
+    assert.ok(r.reason.includes('Bongo Slop Detected'));
+  }
+});
+
+t('the Stop hook stays quiet on ordinary text and when the rule was already followed', () => {
+  assert.equal(slopcheck.evaluate('Done. All 12 tests pass.').block, false);
+  assert.equal(slopcheck.evaluate('The old test was wrong about the count; I fixed it.').block, false);
+  assert.equal(slopcheck.evaluate('🐛 Bongo Slop Detected!!, Filing Bug 🐛 — turns out the doc was stale.').block, false);
+  assert.equal(slopcheck.evaluate('').block, false);
+});
+
+t('the Stop hook\'s copy says exactly what the server sends', () => {
+  assert.equal(slopcheck.SLOP_TEXT, SLOP);
+});
+
+t('the Stop hook reads only the transcript tail, and still finds the last message past a cut line', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'slopcheck-'));
+  const tp = path.join(dir, 't.jsonl');
+  const filler = JSON.stringify({ type: 'user', message: { content: 'x'.repeat(1000) } });
+  const lines = Array.from({ length: 600 }, () => filler); // ~600 KB, past the 256 KB tail
+  lines.push(JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'Turns out it was live.' }] } }));
+  lines.push(JSON.stringify({ type: 'assistant', message: { content: [{ type: 'tool_use', name: 'x' }] } }));
+  fs.writeFileSync(tp, lines.join('\n') + '\n');
+  assert.equal(slopcheck.lastAssistantText(tp), 'Turns out it was live.');
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+t('the Stop hook is wired through the node resolver', () => {
+  const s = JSON.parse(fs.readFileSync(path.join(ROOT, '.claude', 'settings.json'), 'utf8'));
+  const cmds = s.hooks.Stop.flatMap((e) => e.hooks.map((h) => h.command));
+  assert.ok(cmds.some((c) => /run-node\.sh.*stop-slopcheck\.js/.test(c)));
+});
+
+console.log(`\nagent_standing_rules: ${passed} passed, ${failed} failed`);
+process.exitCode = failed ? 1 : 0;

package/tests/backfill_subagent_rewards.mjs

@@ -26,7 +26,7 @@ const { test, summary } = makeRunner();
 
 const AFTER = '2026-08-25T00:00:00Z';  // safely after the de-dup cutoff
 const BEFORE = '2026-08-20T00:00:00Z'; // safely before it
-const OPTS = { cutoffMs: Date.parse(DEDUP_FIX_AT), marginPct: 20, usdPeg: 1 };
+const OPTS = { cutoffMs: Date.parse(DEDUP_FIX_AT), marginPct: 20, costScale: 1 };
 
 // 1M opus input tokens = $5.00 interactive (PRICES.opus.input = $5/M).
 const OPUS_1M = { 'claude-opus-4-8': { input: 1_000_000 } };
@@ -115,7 +115,7 @@ await test('no_subagent_record: the reason does not blame a failed cost hook for
   assert.doesNotMatch(note, /: the cost hook never ran/, 'does not assert the hook failure as the cause');
   assert.match(note, /cannot (be )?tell|cannot tell|indistinguishable|same trace/i, 'says the two cases look the same in the data');
   const plan = buildBackfillPlan([row({ subagent_usd: null, subagent_recorded_at: null })],
-    { since: DEDUP_FIX_AT, marginPct: 20, usdPeg: 1 });
+    { since: DEDUP_FIX_AT, marginPct: 20, costScale: 1 });
   const { text } = renderReport(plan);
   assert.doesNotMatch(text, /Sessions whose cost hook never ran left no trace at all/,
     'the closing summary no longer reads every no-record session as a lost hook');
@@ -164,7 +164,7 @@ await test('a folded session never reaches the mint, and is reported', () => {
   const plan = buildBackfillPlan([
     row({ session_id: 's1' }),                            // +4
     row({ session_id: 's2', has_folded_usage: true }),    // excluded
-  ], { since: DEDUP_FIX_AT, marginPct: 20, usdPeg: 1 });
+  ], { since: DEDUP_FIX_AT, marginPct: 20, costScale: 1 });
   assert.equal(plan.grandTotal, 4, 'only the un-folded session is paid');
   assert.equal(plan.counts[CLASSES.ALREADY_FOLDED], 1);
   assert.match(renderReport(plan).text, /already_folded/);
@@ -193,7 +193,7 @@ await test('the plan groups payables by builder and totals them', () => {
     row({ session_id: 's3', builder_id: 9 }),                       // +4
     row({ session_id: 's4', builder_id: 9, legacy_rows: 1 }),       // not paid
     row({ session_id: 's5', builder_id: 9, subagent_recorded_at: BEFORE }), // not paid
-  ], { since: DEDUP_FIX_AT, marginPct: 20, usdPeg: 1 });
+  ], { since: DEDUP_FIX_AT, marginPct: 20, costScale: 1 });
 
   assert.equal(plan.totalCandidates, 5);
   assert.equal(plan.plans.length, 2);
@@ -208,14 +208,14 @@ await test('the plan reports what it does NOT settle (ADR 0173 objected to a sil
   const plan = buildBackfillPlan([
     row({ session_id: 's1', subagent_usd: 7.5, subagent_recorded_at: BEFORE }),
     row({ session_id: 's2', paid: 25 }),
-  ], { since: DEDUP_FIX_AT, marginPct: 20, usdPeg: 1 });
+  ], { since: DEDUP_FIX_AT, marginPct: 20, costScale: 1 });
   assert.equal(plan.unpaidSubagentUsd, 7.5, 'inflated-but-real spend is surfaced, not hidden');
   assert.equal(plan.overpaidExcess, 15, 'correcting in one direction only is stated');
   assert.equal(plan.grandTotal, 0);
 });
 
 await test('an empty ledger plans nothing and totals zero', () => {
-  const plan = buildBackfillPlan([], { since: DEDUP_FIX_AT, marginPct: 20, usdPeg: 1 });
+  const plan = buildBackfillPlan([], { since: DEDUP_FIX_AT, marginPct: 20, costScale: 1 });
   assert.equal(plan.grandTotal, 0);
   assert.equal(plan.plans.length, 0);
   assert.match(renderReport(plan).text, /NOTHING PAYABLE/);
@@ -223,7 +223,7 @@ await test('an empty ledger plans nothing and totals zero', () => {
 
 await test('the report leads with the grand total and names every refusal reason', () => {
   const plan = buildBackfillPlan([row(), row({ session_id: 's2', legacy_rows: 1 })],
-    { since: DEDUP_FIX_AT, marginPct: 20, usdPeg: 1 });
+    { since: DEDUP_FIX_AT, marginPct: 20, costScale: 1 });
   const { text, total } = renderReport(plan, { loginFor: (id) => (id === 7 ? 'jaxri' : null) });
   assert.equal(total, 4);
   assert.match(text, /GRAND TOTAL to mint: 4 credits/);