@bongos/core 1.19.176 → 1.19.178

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.176",
-  "core_contract": "1.19.176",
-  "source_commit": "9b6c711a358a67610bdb81e8776bc689a0b9cdd8",
+  "core_version": "1.19.178",
+  "core_contract": "1.19.178",
+  "source_commit": "039017134d5f7aee3cc1df34e7238847f878d51c",
   "source_ref": "HEAD",
-  "built_at": "2026-08-16T20:39:00.850Z",
+  "built_at": "2026-08-16T20:52:11.709Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 306,
     "agent_docs_stubbed": 21,
-    "functional_verbatim": 1273,
+    "functional_verbatim": 1274,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 1600,
-  "tree_sha256": "fe346cc282c27c1ec0f17e6dc13d3a82795f14343fa9e42f120b3df9a3138546",
+  "file_count": 1601,
+  "tree_sha256": "c2eb9f930075434353ce4f1fccd3189b5a30229ff5083e7fd9b4f7ee57508e45",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -2832,7 +2832,7 @@
     {
       "path": "modules/economy/credits.js",
       "mode": "0000644",
-      "sha256": "38526b1d7a095fc48d062ddd645df074f381d2ef0e0aac6593ff306601659904"
+      "sha256": "b6f8c6fcabe6cb9f5eb83e936d129509004c86969d5e0d16a9653ff06b88f7ac"
     },
     {
       "path": "modules/economy/migrations/economy_001_fix_gds_shipper_description.sql",
@@ -2847,7 +2847,7 @@
     {
       "path": "modules/economy/reward.js",
       "mode": "0000644",
-      "sha256": "2c0e17de0497d642dd28be0d810dd24bfcfc263fd805612f2f0cc05bc330f1d8"
+      "sha256": "2a354daf06e344a613c8ad7df12ed6e534a9920f49b9f62b54e29b64ead59546"
     },
     {
       "path": "modules/economy/routes/cost.js",
@@ -3477,7 +3477,7 @@
     {
       "path": "modules/ideas/module.json",
       "mode": "0000644",
-      "sha256": "7aa38c4dc690735cea2c1ab1ea61b9fa34281ec6f3505ed091990949f741b77d"
+      "sha256": "64116b6abe3b2e13e3e6697b5c53e12534de698376410e2a14e319d4836481be"
     },
     {
       "path": "modules/ideas/routes/blockers.js",
@@ -3487,7 +3487,7 @@
     {
       "path": "modules/ideas/routes/inbox.js",
       "mode": "0000644",
-      "sha256": "8604c627617cc90fa3197dcf3776ce708546d754b9acc2d45c16dfea97a478cb"
+      "sha256": "d6307869ae1b4388aa33244a1807f74ca2442122dea597e2f1ea5b7fe4533495"
     },
     {
       "path": "modules/ideas/templates.js",
@@ -4227,12 +4227,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "07c720a5ef0a0e1e93727688e9c6c87e00ab43f289efa7cbb8eebea6f3cdbba9"
+      "sha256": "1048f3d5207f880d23989332e8eebcaf55edcbd117046b2e72e6ce65f9fc5f42"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "d014a9180d2a66087029d00f9f10da48fbc8ee3be7a88db11280bc35da7fd611"
+      "sha256": "8792a5baa25590aacff1a8ff0ea6690fce9d800d1ac1ce74fc64f998e2038c3c"
     },
     {
       "path": "public-docs/index.html",
@@ -5642,7 +5642,7 @@
     {
       "path": "src/bongos/llm-pricing.js",
       "mode": "0000644",
-      "sha256": "c421166d7d5099f96b2b46cf9fb46b2c0b3594fb59d318c1a512751bd00a9969"
+      "sha256": "f7688e75a873f9c287f6559311877081830798cb1b5f1e548ceff3fcbed9e31d"
     },
     {
       "path": "src/bongos/metrics.js",
@@ -5837,7 +5837,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "9459525829ea38080db6cc5e757ef7be130c3da00c6563324e892bf605313d8d"
+      "sha256": "56077ebaf7d23e7e524497ae087473677b8a7ca34e5695ccbf0a54544884be83"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -6367,7 +6367,7 @@
     {
       "path": "tests/cost_reconcile.mjs",
       "mode": "0000644",
-      "sha256": "a94de0a9ebd15b8aeb80fa2fc976d847334e733bd0c2a65a869bac5c4b6b4dd8"
+      "sha256": "8356250d8fc753afb2960d867f81586531053afd15f4e66da1a1b7b62b6b5db7"
     },
     {
       "path": "tests/cost_summary_shape.mjs",
@@ -6964,6 +6964,11 @@
       "mode": "0000644",
       "sha256": "95b53f1acfa61f723741b4d33b5e882525903ccc549ae01f3094a788251a60ec"
     },
+    {
+      "path": "tests/idea_full_pass_credit.mjs",
+      "mode": "0000644",
+      "sha256": "1ae98ae22202e6a6dbf42a48e0133654eeda32eec36b697c59f6b9d630936817"
+    },
     {
       "path": "tests/idea_grades.mjs",
       "mode": "0000644",
@@ -7102,7 +7107,7 @@
     {
       "path": "tests/llm-pricing.mjs",
       "mode": "0000644",
-      "sha256": "dec4e9ab447bfac75c6298c6f47d0f0f85e643c7519e192ca704d9a93a834499"
+      "sha256": "de3fabaeafb3eb3ad500becf565f3b6d7118a763f1e80d085f94b6ba990d5c58"
     },
     {
       "path": "tests/local_preview.mjs",

package/modules/economy/credits.js

@@ -107,6 +107,17 @@ const KIND_MULTIPLIERS = Object.freeze({
 });
 const IDEA_BONUS_FRACTION = 0.25; // 25% slice to the idea's original capturer
 
+// =========================================================================
+// The IDEATOR credit lane — stream 2 (ADR 0172 / goal 1000067 IC2).
+// =========================================================================
+// A Full Idea that clears the completeness bar pays its author a flat credit,
+// ONCE. This is the ideator lane, NOT the builder per-task estimate — it gates
+// on config.ideatorCredit, never perTaskCredit, so cost-plus-only does not
+// suppress it (that is the whole point of ADR 0172). The other two streams
+// (per-task-ship IC4, governance-pass IC5) will be siblings of this function.
+const IDEA_FULL_PASS_CREDIT = 5;   // owner: "gives 5 credits"
+const IDEA_FULL_PASS_BAR = 60;     // completeness 0-100; ADR 0172 proposed default
+
 // =========================================================================
 // Session token reward (flat cost-plus) — task 1005 (ADR 0054).
 // =========================================================================
@@ -321,6 +332,59 @@ async function maybeAwardIdeaPromotionBonus(client, taskId, shipperBuilderId, mu
   };
 }
 
+// Stream 2 (ADR 0172 / IC2): a Full Idea with a passing completeness score pays
+// its author IDEA_FULL_PASS_CREDIT, ONCE. Transaction-participant like the rest
+// of the reward port — the caller passes its `client` (a pool works too, since
+// the write is a single idempotent statement).
+//
+//   client              — pg client or pool
+//   ideaId, authorId    — the idea and its captured_by builder
+//   completenessScore   — the R142 score (0-100) or null (unscorable)
+//   config              — resolved reward policy; gates on config.ideatorCredit
+//
+// Returns { credited, reason }:
+//   { credited: 5,  reason: 'paid' }          — first pass, booked
+//   { credited: 0,  reason: 'already_paid' }  — a prior row for this idea exists
+//   { credited: 0,  reason: 'below_bar' }     — null or < IDEA_FULL_PASS_BAR
+//   { credited: 0,  reason: 'ideator_lane_off' } — instance opted the lane out
+//
+// IDEMPOTENCY is the reason string: `idea.credit.full_pass:<ideaId>` is unique
+// per idea, and the INSERT ... WHERE NOT EXISTS is a single atomic statement, so
+// a re-grade / re-capture / concurrent request can never double-pay — no unique
+// constraint or extra column on the core credit_log table needed (which a module
+// migration may not add anyway). task_id is NULL: an idea credit has no task.
+async function awardIdeaFullPassCredit(client, { ideaId, authorId, completenessScore, config = rewardConfig() } = {}) {
+  if (config && config.ideatorCredit === false) {
+    return { credited: 0, reason: 'ideator_lane_off' };
+  }
+  if (completenessScore == null || !Number.isFinite(Number(completenessScore)) || Number(completenessScore) < IDEA_FULL_PASS_BAR) {
+    return { credited: 0, reason: 'below_bar' };
+  }
+  if (authorId == null || ideaId == null) {
+    return { credited: 0, reason: 'missing_author_or_idea' };
+  }
+  const reason = `idea.credit.full_pass:${ideaId}`;
+  const description = `Full Idea #${ideaId} passed (completeness ${Math.round(Number(completenessScore))}/100) → ${IDEA_FULL_PASS_CREDIT}c to its author (ideator lane, ADR 0172)`;
+  // Idempotency predicate is `builder_id = author AND reason = <per-idea key>`.
+  // The `builder_id` term is NOT for correctness — the reason string is already
+  // globally unique per idea — it exists to hit the existing
+  // `idx_credit_log_builder (builder_id, recorded_at)` index: the NOT EXISTS
+  // narrows to the author's handful of credit rows (index scan) instead of a
+  // sequential scan of a credit_log that grows with total platform activity.
+  // credit_log is a CORE table, so a module migration cannot add an index on
+  // `reason` (the additive-namespace rule) — reusing the builder index is the
+  // in-scope fix. (R143/IC2 grader finding.)
+  const { rowCount } = await client.query(
+    `INSERT INTO credit_log (builder_id, task_id, delta, reason, description)
+     SELECT $1, NULL, $2, $3, $4
+      WHERE NOT EXISTS (SELECT 1 FROM credit_log WHERE builder_id = $1 AND reason = $3)`,
+    [authorId, IDEA_FULL_PASS_CREDIT, reason, description]
+  );
+  return rowCount > 0
+    ? { credited: IDEA_FULL_PASS_CREDIT, reason: 'paid' }
+    : { credited: 0, reason: 'already_paid' };
+}
+
 // Award the flat cost-plus session token reward, idempotent per session_id
 // (task 1005, ADR 0054). Called inside the same transaction as the session
 // upsert (see upsertSessionRecordWithReward).
@@ -531,6 +595,9 @@ module.exports = {
   applyKindMultiplier,
   insertMultipliedConfirmCredit,
   maybeAwardIdeaPromotionBonus,
+  awardIdeaFullPassCredit,
+  IDEA_FULL_PASS_CREDIT,
+  IDEA_FULL_PASS_BAR,
   awardSessionTokenReward,
   NET_NEGATIVE_BONUS,
   SUBTRACTOR_THRESHOLD,

package/modules/economy/reward.js

@@ -24,6 +24,8 @@ module.exports = {
   // credit allocation — transaction-participant: caller passes its tx `client`
   insertMultipliedConfirmCredit: (...a) => credits.insertMultipliedConfirmCredit(...a),
   maybeAwardIdeaPromotionBonus: (...a) => credits.maybeAwardIdeaPromotionBonus(...a),
+  // ADR 0172 IC2 — the ideator credit lane (stream 2): a passing Full Idea pays its author, once.
+  awardIdeaFullPassCredit: (...a) => credits.awardIdeaFullPassCredit(...a),
   awardNetNegativeBonus: (...a) => credits.awardNetNegativeBonus(...a),
   awardSessionTokenReward: (...a) => credits.awardSessionTokenReward(...a),
   // gamification hooks the lifecycle fires at claim/ship

package/modules/ideas/module.json

@@ -1,11 +1,22 @@
 {
   "key": "ideas",
   "title": "Ideas",
-  "description": "The idea inbox (capture, triage, criterion-proposal ratification) and the blockers queue — the methodology surfaces that feed the backlog. A core-domain module carved out of the GDS core in BV1.R78 (ADR 0093 §1); default-on because every instance captures ideas and tracks what's stuck on its owner. Registers the `ideas.capture` kernel PORT the discord #ideas inbound resolves (ADR 0093 §5 — retiring the temporary `captureIdea` doorway leak).",
+  "description": "The idea inbox (capture, triage, criterion-proposal ratification) and the blockers queue \u2014 the methodology surfaces that feed the backlog. A core-domain module carved out of the GDS core in BV1.R78 (ADR 0093 \u00a71); default-on because every instance captures ideas and tracks what's stuck on its owner. Registers the `ideas.capture` kernel PORT the discord #ideas inbound resolves (ADR 0093 \u00a75 \u2014 retiring the temporary `captureIdea` doorway leak).",
   "coreVersion": "^1.8.0",
   "default": true,
-  "maintenance": { "status": "core-maintained" },
-  "contributes": { "routes": ["inbox", "blockers"] },
-  "provides": ["ideas.capture"],
-  "consumes": []
+  "maintenance": {
+    "status": "core-maintained"
+  },
+  "contributes": {
+    "routes": [
+      "inbox",
+      "blockers"
+    ]
+  },
+  "provides": [
+    "ideas.capture"
+  ],
+  "consumes": [
+    "reward"
+  ]
 }

package/modules/ideas/routes/inbox.js

@@ -120,6 +120,32 @@ module.exports = function buildInboxRouter() {
           idea.template_key = row.template_key;
           idea.field_values = row.field_values;
           idea.completeness_score = row.completeness_score;
+
+          // Stream 2 (ADR 0172 / IC2): a Full Idea that clears the completeness
+          // bar pays its author, once, on the IDEATOR credit lane — a separate
+          // reward from the builder estimate, so cost-plus-only does NOT
+          // suppress it. Resolved through the economy `reward` port (this
+          // module declares `reward` in its consumes), never a direct import.
+          // FAIL-OPEN, inside the same guard: a credit hiccup must never lose
+          // the capture — the idea is already stored. The port method is
+          // idempotent (reason = idea.credit.full_pass:<id>), so this cannot
+          // double-pay on a re-capture. The pool is the tx client — the write
+          // is one atomic idempotent statement.
+          try {
+            const reward = api.resolveOptional && api.resolveOptional('reward');
+            if (reward && reward.awardIdeaFullPassCredit) {
+              const r = await reward.awardIdeaFullPassCredit(api.pool, {
+                ideaId: idea.id,
+                authorId: req.builder.id,
+                completenessScore: row.completeness_score,
+              });
+              if (r && r.credited > 0) idea.ideator_credit = r.credited;
+            }
+          } catch (creditErr) {
+            console.error('[gds] POST /inbox full-idea pass-credit failed (idea captured + graded, credit skipped):', creditErr);
+            // no warning surfaced — the idea and its grade are intact; the credit
+            // is the only thing missed, and a reconcile/re-grade path can pay it.
+          }
         } catch (gradeErr) {
           console.error('[gds] POST /inbox full-grade write failed (idea captured, landing as quick):', gradeErr);
           grade_warning = 'captured_but_ungraded';

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.176",
+  "version": "1.19.178",
   "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/src/bongos/llm-pricing.js

@@ -34,20 +34,42 @@
 // Family-based pricing assumes the CURRENT model in each family (what this
 // instance runs). A historical id like claude-opus-4-1 ($15/$75) would be
 // mis-priced low here — acceptable: the platform only runs 4.x-current models.
+//
+// VERIFIED 2026-08-16 against the live Anthropic pricing page (task 1002883):
+// added the `fable` family. familyFor() previously matched only opus/sonnet/
+// haiku, so claude-fable-5 — the owner's top-model default and this instance's
+// `assumed_builder_model` (modules/grading/grader-rubric.json) — fell through to
+// null and was priced at the opus fallback with unknown_model=true. Fable is
+// 2× opus, so every cost-plus reward computed from a Fable session was priced at
+// HALF its true cost (not conservative: cost-plus UNDER-pays the builder). The
+// grading side already carried the family token (grader.js MODEL_FAMILY_TOKENS);
+// this table is the surface that never caught up.
+//   - fable  = Claude Fable 5 / Mythos 5 ($10 in / $50 out) — identical rates,
+//              which is why one family token covers both.
+//   - opus   = Claude Opus 5 / 4.8 / 4.7  ($5 in / $25 out)  [re-verified]
+//   - sonnet = Claude Sonnet 4.6          ($3 in / $15 out)  [re-verified]
+//   - haiku  = Claude Haiku 4.5           ($1 in / $5 out)   [re-verified]
+// NOTE (deliberately NOT changed here — its own task, per the rule above):
+// Claude Sonnet 5 is now $2/$10, not the $3/$15 this `sonnet` row carries. The
+// grader's default worker model is claude-sonnet-5, so grade costs are currently
+// OVER-priced ~1.5×. That is a separate price-table decision; see task 1003001.
 const PRICES = {
   // family : { input, output, cache_write_5m, cache_write_1h, cache_read }  (USD / 1e6 tokens)
+  fable:  { input: 10, output: 50, cache_write_5m: 12.5, cache_write_1h: 20, cache_read: 1   },
   opus:   { input: 5,  output: 25, cache_write_5m: 6.25, cache_write_1h: 10, cache_read: 0.5 },
   sonnet: { input: 3,  output: 15, cache_write_5m: 3.75, cache_write_1h: 6,  cache_read: 0.3 },
   haiku:  { input: 1,  output: 5,  cache_write_5m: 1.25, cache_write_1h: 2,  cache_read: 0.1 },
 };
 
-// Resolve a model id (e.g. 'claude-opus-4-8', 'claude-sonnet-4-6',
-// 'claude-haiku-4-5') to a price family by substring — mirrors grader.js's
-// family-token convention (all live Claude ids contain one of these three).
-// Unknown → null (caller decides: we conservatively price at the opus rate AND
-// flag it, so an unpriced model is loud, never silently $0).
+// Resolve a model id (e.g. 'claude-fable-5', 'claude-opus-4-8',
+// 'claude-sonnet-4-6', 'claude-haiku-4-5') to a price family by substring —
+// mirrors grader.js's MODEL_FAMILY_TOKENS convention, including the fable/mythos
+// pair it checks first (all live Claude ids contain one of these tokens).
+// Unknown → null (caller decides: we price at the opus rate AND flag it, so an
+// unpriced model is loud, never silently $0 — see priceUsage on why opus).
 function familyFor(model) {
   const m = String(model || '').toLowerCase();
+  if (m.includes('fable') || m.includes('mythos')) return 'fable';
   if (m.includes('opus')) return 'opus';
   if (m.includes('sonnet')) return 'sonnet';
   if (m.includes('haiku')) return 'haiku';
@@ -70,7 +92,14 @@ function priceUsage(model, usage) {
   const u = usage || {};
   const fam = familyFor(model);
   const unknownModel = fam === null;
-  const priceFamily = fam || 'opus'; // conservative default for an unrecognized model
+  // Unrecognized → price at the opus rate. Since `fable` landed (task 1002883)
+  // opus is no longer the ceiling, so this is a MID-range fallback, not a
+  // conservative one: an unknown Fable-class model prices at half its true rate.
+  // That is why unknown_model=true rides along — the loudness is the safeguard,
+  // not the rate. (Deliberately left at opus: every model this platform actually
+  // runs is now matched, so raising the fallback would only over-price genuinely
+  // foreign ids like gpt-4o.)
+  const priceFamily = fam || 'opus';
   const p = PRICES[priceFamily];
 
   const input = Number(u.input_tokens) || 0;          // uncached input
@@ -179,7 +208,7 @@ function priceModelUsage(modelUsage) {
  * Like priceModelUsage, model_usage has NO 5m/1h cache-creation breakdown — the
  * `cache_creation` lump is priced at the 5m rate, exactly as session-cost.js
  * priceTranscript does in its `else` branch (no breakdown → 5m). Unknown model
- * ids are conservatively priced as opus AND collected, so an unpriced model is
+ * ids are priced as opus AND collected, so an unpriced model is
  * loud, never silently $0. Pure: no I/O, no Date.now().
  *
  * @param {Object<string, {input?:number,output?:number,cache_read?:number,cache_creation?:number}>} modelUsage
@@ -199,7 +228,7 @@ function componentsFromModelUsage(modelUsage) {
     const usage = u || {};
     const fam = familyFor(rawId);
     if (fam === null) unknown.push(canonicalizeModelId(rawId));
-    const p = PRICES[fam || 'opus']; // conservative default for an unrecognized model
+    const p = PRICES[fam || 'opus']; // mid-range fallback; unknown ids ride the `unknown` list
     fresh_input_usd += ((Number(usage.input) || 0) * p.input) / 1e6;
     output_usd += ((Number(usage.output) || 0) * p.output) / 1e6;
     cache_read_usd += ((Number(usage.cache_read) || 0) * p.cache_read) / 1e6;

package/src/module-api.js

@@ -779,8 +779,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.174 with no explicit bump. run 31970199477. (task 1002620)
 //   1.19.176 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.175 with no explicit bump. run 31971125373. (task 1002620)
+//   1.19.177 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.176 with no explicit bump. run 31971532260. (task 1002620)
+//   1.19.178 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.177 with no explicit bump. run 31971769062. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.176'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.178'; // CI auto-patch carrier (ADR 0161); see changelog above
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/cost_reconcile.mjs

@@ -100,3 +100,33 @@ test('1366 missing per-tier fields default to 0 (partial model_usage)', () => {
   assert.equal(out.cache_write_usd, 0);
   assert.ok(near(out.total_usd, 5));
 });
+
+// ---------- fable / mythos family (task 1002883) ----------
+// The reconciler is the SECOND pricing path the missing fable family broke: a
+// cloud-box / overnight Fable session whose client cost hook never posted lands
+// here, and before the fix it re-priced at the opus fallback — half the true
+// cost, and flagged unknown on the platform's own default model.
+
+test('1002883 fable 1M/1M/10M/1M → $10 / $50 / $10 / $12.50, total $82.50, not flagged', () => {
+  const out = componentsFromModelUsage({
+    'claude-fable-5': { input: M, output: M, cache_read: 10 * M, cache_creation: M },
+  });
+  assert.ok(near(out.fresh_input_usd, 10), `fresh ${out.fresh_input_usd}`);
+  assert.ok(near(out.output_usd, 50), `output ${out.output_usd}`);
+  assert.ok(near(out.cache_read_usd, 10), `cache_read ${out.cache_read_usd}`); // 10M * 1/M
+  assert.ok(near(out.cache_write_usd, 12.5), `cache_write ${out.cache_write_usd}`);
+  assert.ok(near(out.total_usd, 82.5), `total ${out.total_usd}`);
+  const sum = out.fresh_input_usd + out.cache_read_usd + out.cache_write_usd + out.output_usd;
+  assert.ok(near(sum, out.total_usd), `tiers sum ${sum} must equal total ${out.total_usd}`);
+  assert.deepEqual(out.unknown_models, [], 'fable is the platform default — never "unknown"');
+});
+
+test('1002883 mythos prices as fable, and a fable session is 2× the same opus session', () => {
+  const usage = { input: M, output: M };
+  const fable = componentsFromModelUsage({ 'claude-fable-5': usage });
+  const mythos = componentsFromModelUsage({ 'claude-mythos-5': usage });
+  const opus = componentsFromModelUsage({ 'claude-opus-5': usage });
+  assert.ok(near(fable.total_usd, mythos.total_usd), 'mythos shares fable rates');
+  assert.deepEqual(mythos.unknown_models, []);
+  assert.ok(near(fable.total_usd, opus.total_usd * 2), `fable ${fable.total_usd} != 2× opus ${opus.total_usd}`);
+});

package/tests/idea_full_pass_credit.mjs

@@ -0,0 +1,113 @@
+// tests/idea_full_pass_credit.mjs
+//
+// task 1002996 (BV1.R172 / IC2, goal 1000067) — stream 2 of the ideator credit
+// lane: a Full Idea with a passing completeness score pays its author 5 credits,
+// once. ADR 0172.
+//
+// The done-when as assertions: a passing Full Idea books exactly 5; a thin /
+// null-scored one books 0; re-running never double-pays; cost-plus-only does NOT
+// suppress it (it gates on ideatorCredit, never perTaskCredit); an instance that
+// opts the ideator lane out pays nothing.
+//
+// The credit fn (awardIdeaFullPassCredit) is exercised over a stub client that
+// records statements and simulates the WHERE-NOT-EXISTS idempotency, so the
+// idempotency logic is proven without a DB. Pure module import.
+//
+// Run:  node tests/idea_full_pass_credit.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const credits = require('../modules/economy/credits.js');
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// A stub client whose credit_log "table" is an in-memory set of reasons, so the
+// INSERT ... WHERE NOT EXISTS (SELECT 1 ... WHERE reason=$3) behaves exactly like
+// Postgres: the second insert of the same reason is a no-op (rowCount 0).
+function stubClient() {
+  const rows = [];
+  return {
+    rows,
+    async query(sql, params) {
+      // our fn issues exactly one INSERT ... SELECT ... WHERE NOT EXISTS, whose
+      // subquery filters on builder_id AND reason (the index-friendly predicate).
+      // Mirror both terms so the stub matches the real query.
+      const builderId = params[0];
+      const reason = params[2];
+      assert.match(sql, /builder_id = \$1 AND reason = \$3/, 'idempotency check must scope by builder_id to hit the index');
+      const exists = rows.some((r) => r.builder_id === builderId && r.reason === reason);
+      if (exists) return { rowCount: 0, rows: [] };
+      rows.push({ builder_id: builderId, delta: params[1], reason, description: params[3] });
+      return { rowCount: 1, rows: [] };
+    },
+  };
+}
+
+const PASS = 72;   // clears the 60 bar
+const THIN = 40;   // below the bar
+
+await test('a passing Full Idea books exactly 5 credits to its author', async () => {
+  const c = stubClient();
+  const r = await credits.awardIdeaFullPassCredit(c, { ideaId: 9, authorId: 3, completenessScore: PASS, config: { ideatorCredit: true } });
+  assert.equal(r.credited, credits.IDEA_FULL_PASS_CREDIT);
+  assert.equal(r.reason, 'paid');
+  assert.equal(c.rows.length, 1);
+  assert.equal(c.rows[0].delta, 5);
+  assert.equal(c.rows[0].builder_id, 3);
+  assert.equal(c.rows[0].reason, 'idea.credit.full_pass:9');
+});
+
+await test('re-running pays nothing — idempotent per idea', async () => {
+  const c = stubClient();
+  const opts = { ideaId: 9, authorId: 3, completenessScore: PASS, config: { ideatorCredit: true } };
+  const first = await credits.awardIdeaFullPassCredit(c, opts);
+  const second = await credits.awardIdeaFullPassCredit(c, opts);
+  const third = await credits.awardIdeaFullPassCredit(c, opts);
+  assert.equal(first.credited, 5);
+  assert.equal(second.credited, 0);
+  assert.equal(second.reason, 'already_paid');
+  assert.equal(third.credited, 0);
+  assert.equal(c.rows.length, 1, 'exactly one credit_log row ever, across three calls');
+});
+
+await test('a below-bar or null score books 0 — scoring gates the pay, not capture', async () => {
+  const c = stubClient();
+  assert.equal((await credits.awardIdeaFullPassCredit(c, { ideaId: 1, authorId: 3, completenessScore: THIN, config: { ideatorCredit: true } })).reason, 'below_bar');
+  assert.equal((await credits.awardIdeaFullPassCredit(c, { ideaId: 2, authorId: 3, completenessScore: null, config: { ideatorCredit: true } })).reason, 'below_bar');
+  assert.equal((await credits.awardIdeaFullPassCredit(c, { ideaId: 3, authorId: 3, completenessScore: undefined, config: { ideatorCredit: true } })).reason, 'below_bar');
+  assert.equal(c.rows.length, 0, 'nothing written for any sub-bar score');
+});
+
+await test('COST-PLUS-ONLY does NOT suppress it: the ideator lane pays regardless of perTaskCredit', async () => {
+  // the live cloudbongos.com policy: builder estimate off, ideator lane on
+  const policy = credits.rewardPolicy({ mode: 'cost-plus-only' });
+  assert.equal(policy.perTaskCredit, false);
+  assert.equal(policy.ideatorCredit, true);
+  const c = stubClient();
+  const r = await credits.awardIdeaFullPassCredit(c, { ideaId: 5, authorId: 3, completenessScore: PASS, config: policy });
+  assert.equal(r.credited, 5, 'paid despite cost-plus-only — this is the whole point of ADR 0172');
+});
+
+await test('an instance that opts the ideator lane out pays nothing', async () => {
+  const c = stubClient();
+  const r = await credits.awardIdeaFullPassCredit(c, { ideaId: 6, authorId: 3, completenessScore: PASS, config: { ideatorCredit: false } });
+  assert.equal(r.credited, 0);
+  assert.equal(r.reason, 'ideator_lane_off');
+  assert.equal(c.rows.length, 0);
+});
+
+await test('a missing author or idea is a safe 0, never a throw', async () => {
+  const c = stubClient();
+  assert.equal((await credits.awardIdeaFullPassCredit(c, { ideaId: 6, authorId: null, completenessScore: PASS, config: { ideatorCredit: true } })).reason, 'missing_author_or_idea');
+  assert.equal((await credits.awardIdeaFullPassCredit(c, { ideaId: null, authorId: 3, completenessScore: PASS, config: { ideatorCredit: true } })).reason, 'missing_author_or_idea');
+});
+
+console.log(`\nidea_full_pass_credit: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/llm-pricing.mjs

@@ -2,6 +2,9 @@
 // Prices VERIFIED 2026-06-20 against the live Anthropic models/pricing page
 // (GDS-V4 task 1343): opus (4.8/4.7) $5/$25, sonnet (4.6) $3/$15, haiku (4.5)
 // $1/$5; flat across the 1M window (no long-context premium).
+// Re-VERIFIED + extended 2026-08-16 (task 1002883): fable (Fable 5 / Mythos 5)
+// $10/$50 — the family familyFor() used to miss, so Fable sessions priced at the
+// opus fallback and cost-plus under-paid by half.
 // Run:  node tests/llm-pricing.mjs
 
 import { strict as assert } from 'node:assert';
@@ -18,6 +21,9 @@ const M = 1_000_000;
 const near = (a, b) => Math.abs(a - b) < 1e-6;
 
 test('familyFor matches by substring; unknown → null', () => {
+  assert.equal(familyFor('claude-fable-5'), 'fable');
+  assert.equal(familyFor('claude-mythos-5'), 'fable');   // same rates → same family
+  assert.equal(familyFor('claude-mythos-preview'), 'fable');
   assert.equal(familyFor('claude-opus-4-8'), 'opus');
   assert.equal(familyFor('claude-sonnet-4-6'), 'sonnet');
   assert.equal(familyFor('claude-haiku-4-5'), 'haiku');
@@ -26,6 +32,68 @@ test('familyFor matches by substring; unknown → null', () => {
   assert.equal(familyFor(undefined), null);
 });
 
+// ---------- fable / mythos family (task 1002883) ----------
+// The regression this locks: claude-fable-5 is the owner's top-model default and
+// the grader's assumed_builder_model, but familyFor() matched only opus/sonnet/
+// haiku — so it fell to the opus fallback (unknown_model=true) at HALF its rate,
+// and every cost-plus reward from a Fable session under-paid the builder.
+
+test('fable 5: 1M input + 1M output = $10 + $50 = $60, and is NOT flagged unknown', () => {
+  const r = priceUsage('claude-fable-5', { input_tokens: M, output_tokens: M });
+  assert.ok(near(r.usd, 60), `got ${r.usd}`);
+  assert.equal(r.unknown_model, false, 'fable must resolve, not ride the opus fallback');
+  assert.equal(r.family, 'fable');
+});
+
+test('mythos 5 prices identically to fable 5 (one family, shared rates)', () => {
+  const f = priceUsage('claude-fable-5', { input_tokens: M, output_tokens: M });
+  const m = priceUsage('claude-mythos-5', { input_tokens: M, output_tokens: M });
+  assert.ok(near(f.usd, m.usd), `fable ${f.usd} != mythos ${m.usd}`);
+  assert.equal(m.family, 'fable');
+});
+
+test('fable cache tiers: read $1, 5m write $12.50, 1h write $20 per 1M', () => {
+  assert.ok(near(priceUsage('claude-fable-5', { cache_read_input_tokens: M }).usd, 1));
+  assert.ok(near(priceUsage('claude-fable-5', {
+    cache_creation_input_tokens: M,
+    cache_creation: { ephemeral_5m_input_tokens: M, ephemeral_1h_input_tokens: 0 },
+  }).usd, 12.5));
+  assert.ok(near(priceUsage('claude-fable-5', {
+    cache_creation_input_tokens: M,
+    cache_creation: { ephemeral_5m_input_tokens: 0, ephemeral_1h_input_tokens: M },
+  }).usd, 20));
+});
+
+test('fable rides the published cache multipliers off its own base input (1.25× / 2× / 0.1×)', () => {
+  const { fable } = PRICES;
+  assert.ok(near(fable.cache_write_5m, fable.input * 1.25));
+  assert.ok(near(fable.cache_write_1h, fable.input * 2));
+  assert.ok(near(fable.cache_read, fable.input * 0.1));
+});
+
+test('fable is exactly 2× opus — the size of the pre-fix cost-plus shortfall', () => {
+  const usage = { input_tokens: M, output_tokens: M };
+  const fable = priceUsage('claude-fable-5', usage).usd;
+  const opus = priceUsage('claude-opus-5', usage).usd;
+  assert.ok(near(fable, opus * 2), `fable ${fable} != 2× opus ${opus}`);
+});
+
+test('priceModelUsage: a fable session costs $60 / 1M+1M and reports no unknown models', () => {
+  const r = priceModelUsage({ 'claude-fable-5': { input: M, output: M } });
+  assert.ok(near(r.true_cost_usd, 60), `got ${r.true_cost_usd}`);
+  assert.deepEqual(r.unknown_models, [], 'fable must not be reported as unpriced');
+});
+
+test('canonicalizeModelId collapses fable variants without changing the price', () => {
+  assert.equal(canonicalizeModelId('claude-fable-5[1m]'), 'claude-fable-5');
+  const r = priceModelUsage({
+    'claude-fable-5': { input: M },
+    'claude-fable-5[1m]': { input: M },
+  });
+  assert.equal(r.per_model.length, 2, 'raw keys kept as separate breakdown rows');
+  assert.ok(near(r.true_cost_usd, 20), `got ${r.true_cost_usd}`); // 10 + 10
+});
+
 test('opus 4.8: 1M input + 1M output = $5 + $25 = $30', () => {
   const r = priceUsage('claude-opus-4-8', { input_tokens: M, output_tokens: M });
   assert.ok(near(r.usd, 30), `got ${r.usd}`);