@bongos/core 1.19.814 → 1.19.816

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.814",
-  "core_contract": "1.19.814",
-  "source_commit": "1f01e14964d5ea0ba6bc679b6545e33b7858829c",
+  "core_version": "1.19.816",
+  "core_contract": "1.19.816",
+  "source_commit": "aa1a7485bebfc27a8b19c0acbff29287f1212828",
   "source_ref": "HEAD",
-  "built_at": "2026-09-17T07:24:36.013Z",
+  "built_at": "2026-09-17T08:14:24.758Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 489,
     "agent_docs_stubbed": 26,
-    "functional_verbatim": 2214,
+    "functional_verbatim": 2215,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 2729,
-  "tree_sha256": "7a2511fd82d8a030199059a73c74669bc0c447fb5860e4eca010231226cd32a1",
+  "file_count": 2730,
+  "tree_sha256": "78e804a2a5bda8a926f2f33af27c70ca3a6e0b4b5b3aa9a5b3bd8c66dd5cec24",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -2542,7 +2542,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "2e01c98f75c74643cc843b80f507635d1d674749fed9185414cfce51eeac3cf8"
+      "sha256": "c86194915e38b871c476151bdf00719d190411407942cfc8dd9f0a7734630ab0"
     },
     {
       "path": "docs/modules-contract.md",
@@ -3672,7 +3672,7 @@
     {
       "path": "modules/agents/lib/validate.js",
       "mode": "0000644",
-      "sha256": "cd3659ad5831c767fe6600fabbe883f33b3429107a0b999092158dfa7c95b4e7"
+      "sha256": "3ff56e388e9ae4cccb09fb072793b5544f771aeae51e8477f8a221f0c78b9515"
     },
     {
       "path": "modules/agents/migrations/agents_001_definitions.sql",
@@ -4167,7 +4167,7 @@
     {
       "path": "modules/discord/discord-channels.js",
       "mode": "0000644",
-      "sha256": "aeeb86c5d61b4a06ae5429fb69bb4720d54f4782ead5d23cdce640344a568246"
+      "sha256": "683174f64823c296d74acbdedff3c67085336aeae067d8014873a43c23eace68"
     },
     {
       "path": "modules/discord/discord-inbound.js",
@@ -4217,7 +4217,7 @@
     {
       "path": "modules/discord/routes/discord.js",
       "mode": "0000644",
-      "sha256": "2229a563e11bd05f0eb047f0afc0e1d66eaddb6a7fa2fb07c429e162684246f0"
+      "sha256": "6e771cafa4330cd6cba274040e8d0881f6a9b99dd566366fce266bd6f30b1ebf"
     },
     {
       "path": "modules/discord/ship-broadcast.js",
@@ -5412,7 +5412,7 @@
     {
       "path": "modules/ideas/inbox.js",
       "mode": "0000644",
-      "sha256": "d70b4564c8178f4752c5bd08c5cbb19e495828b5a3dd5081f71d3d7743609ab2"
+      "sha256": "36481a27a5921e3eb930268bf96bccd178259d3f7cce67b19b0dc4246f7d9bf1"
     },
     {
       "path": "modules/ideas/migrations/ideas_001_grades.sql",
@@ -5497,7 +5497,7 @@
     {
       "path": "modules/lifecycle/cascade.js",
       "mode": "0000644",
-      "sha256": "507fe63cf677dbe1a536d5fae1a55518f6fe5c8ec4d908ac1941164029b17593"
+      "sha256": "0f7c3c6b75216ddca36d49e9a112fce98de2e4123e9756879ba51b44b77c0f06"
     },
     {
       "path": "modules/lifecycle/claim-eligibility.js",
@@ -5557,7 +5557,7 @@
     {
       "path": "modules/lifecycle/db-goals.js",
       "mode": "0000644",
-      "sha256": "b4d1c8bd2254f93519a88302072c2f524a1acb4152382fb09bdc22b1ef95f0ed"
+      "sha256": "1b229bd4bf18563dd772c0be46f320ae533e71a5c7ba32aaa4b523ac9f97a4dc"
     },
     {
       "path": "modules/lifecycle/db-grade.js",
@@ -5597,7 +5597,7 @@
     {
       "path": "modules/lifecycle/db.js",
       "mode": "0000644",
-      "sha256": "a568b425560d8d8f4523995442454233b69016a31934810c5d4b7d83baab0b09"
+      "sha256": "30c8884948a8dee8213c55279c12f06e104c7d95ab3d7fad9dc67506ed1ac1ab"
     },
     {
       "path": "modules/lifecycle/dead-deps.js",
@@ -5657,7 +5657,7 @@
     {
       "path": "modules/lifecycle/goal-suggest.js",
       "mode": "0000644",
-      "sha256": "85117db645accd023f4f61735f9f22a8c5f6ef08a29c61db99fbade51d081147"
+      "sha256": "cdbfa36b58dc26b7ce9d7a3d1f2812edd0ea050c2b27fe3837be6b6edf7d9ac5"
     },
     {
       "path": "modules/lifecycle/help-requests.js",
@@ -5817,7 +5817,7 @@
     {
       "path": "modules/lifecycle/routes/lifecycle.js",
       "mode": "0000644",
-      "sha256": "09b84f7f8a39be03b690e220d10af135f43d845db67c5f86b7f846d548d6361f"
+      "sha256": "e09bbf8000ada41c6eac7ab64dcfe476650a246a0b561a8b693992885136b3bd"
     },
     {
       "path": "modules/lifecycle/routes/mingle.js",
@@ -7792,12 +7792,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "bc7f846af00793ffc9d682071391f110593648a25297cd15050385b9c3a8828f"
+      "sha256": "aa6749d880220869386e00488652da7ae32a0116855dba519e6b943c47f7180c"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "db09d4c1609d9b4b0547b052326785367cfe19a5838cd3f9d458dac40ef70685"
+      "sha256": "966ab00e5b62d0280043e13e156ce400cd3afa3f7c5bc04f02eea79392fd26f3"
     },
     {
       "path": "public-docs/index.html",
@@ -8057,7 +8057,7 @@
     {
       "path": "scripts/gds/capture.js",
       "mode": "0000644",
-      "sha256": "6779ebc36d51762777cb55352489a05ca9974f29c49d874b40c7486be83496ff"
+      "sha256": "7320809dacf61454d114d5c55c244e7eac3314f36302eab879950355540573f6"
     },
     {
       "path": "scripts/gds/category-advisory-guard.js",
@@ -9687,7 +9687,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "2b104850c999f4a9c71f7f205c640b9525a9a812031c1bad6d13cdcd06c05706"
+      "sha256": "575b32eed8f62dad0302816f97e77604488891d13188bf5b690a867c37a962ac"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -9847,7 +9847,7 @@
     {
       "path": "tests/agents_validate.mjs",
       "mode": "0000644",
-      "sha256": "82c7bcef316f5c0068cb53a43b2ef4a01367ff285939f132f01b0d8633d36353"
+      "sha256": "9376185bc6e11571b050dcf61a993faf780cea66aa4c0844d114b1cb738043e2"
     },
     {
       "path": "tests/agents_write_routes.mjs",
@@ -10312,7 +10312,7 @@
     {
       "path": "tests/capture_goal_routing.mjs",
       "mode": "0000644",
-      "sha256": "30c86ef5ae46c698b621dbe90e15210d162cc88d8b33bd0889330ff8686a065e"
+      "sha256": "2ddceb37d46eda5c3ab2a56b54c86f3cf55596479b5fe7f30646f45b1ac11ac2"
     },
     {
       "path": "tests/cascade-dispatch.mjs",
@@ -10732,7 +10732,7 @@
     {
       "path": "tests/discord_channels.mjs",
       "mode": "0000644",
-      "sha256": "981d34c2fb5ecb6e9b9f38ece947c6c7a400dceadf8bbcf09546c8b3a92eb899"
+      "sha256": "02e03ca2651755084e134ba0c4568c76d5eb7d1d66d0cec1fdd7cb3b4901f106"
     },
     {
       "path": "tests/discord_channels_snapshot.mjs",
@@ -11102,7 +11102,7 @@
     {
       "path": "tests/goal_suggest.mjs",
       "mode": "0000644",
-      "sha256": "d61e2bd5b5a65239f1410011a5035b124bf8e20c41eac08018635ec8cd3a49c7"
+      "sha256": "41cf7774b86acabe7621563430fc4784152dea05f6cd3136b00081eca876e74d"
     },
     {
       "path": "tests/goal_tier.mjs",
@@ -11584,6 +11584,11 @@
       "mode": "0000644",
       "sha256": "fb129f6ee327d946ba2e7ee46bab3b9795621f7f405637e1e8ed2b29807a84cf"
     },
+    {
+      "path": "tests/idea_cascade.mjs",
+      "mode": "0000644",
+      "sha256": "e14c3157cd9c1a5889fa2d5cc90bc036d5b9f3aa1e062bb13623a01adb81d20c"
+    },
     {
       "path": "tests/idea_completeness.mjs",
       "mode": "0000644",
@@ -13357,7 +13362,7 @@
     {
       "path": "tests/task_goal_required.mjs",
       "mode": "0000644",
-      "sha256": "2e311d02f87c562c2e8ed7cec24100efe3d1c750cb145e9e9e6bb1dac8043228"
+      "sha256": "04e7a36f7c2f5a94f847fcb4b77f017f6399fc96041cdaee1123c9a6fecb3d5d"
     },
     {
       "path": "tests/task_lib.mjs",

package/docs/module-api-changelog.md

@@ -2102,5 +2102,9 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.812 with no explicit bump. run 35193306517. (task 1002620)
   1.19.814 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.813 with no explicit bump. run 35194334679. (task 1002620)
+  1.19.815 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.814 with no explicit bump. run 35197139985. (task 1002620)
+  1.19.816 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.815 with no explicit bump. run 35198566737. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/agents/lib/validate.js

@@ -45,7 +45,7 @@
 
 // The WIRED event set for v1. Widening this is a deliberate act that must land
 // together with something that actually dispatches the new event.
-const EVENT_CATALOG = Object.freeze(['task.shipped']);
+const EVENT_CATALOG = Object.freeze(['task.shipped', 'idea.graded.full']);
 
 // Mirrors agents_definitions_trigger_type_chk. 'event' consumes the catalog above;
 // 'on-demand' is the historian shape (a builder asks, the agent answers).

package/modules/discord/discord-channels.js

@@ -40,7 +40,46 @@ const VIEW_CHANNEL = 1024n;
 // `view: "<rank>"` grants that rank and everyone above it.
 const RANK_LADDER = ['xenos', 'thetes', 'metic', 'archon'];
 
-const CONFIG_PATH = path.resolve(__dirname, '..', '..', 'docs', 'discord', 'channels.json');
+// WHERE channels.json LIVES (task 1003973). The layout file describes ONE
+// guild's channels, names and topics — instance identity, which ADR 0062 §7
+// puts on the HOST side of the core/host cut. So it is NOT published in the
+// neutral core, and resolving it against the core package (as this module used
+// to) means that on a deployed instance — where the module lives under
+// node_modules/@bongos/core/modules/discord/ — the file is simply not there and
+// every plan/apply died as a bare 500.
+//
+// Resolution order, first hit wins:
+//   1. <instance root>/docs/discord/channels.json  (ADR 0108's instance-root
+//      injection: <PREFIX>_INSTANCE_ROOT env, a bongos.config.json pointer, or
+//      process.cwd()) — each instance reads its OWN layout.
+//   2. <core root>/docs/discord/channels.json — the historical path, kept so a
+//      core checkout that is not the instance root still resolves.
+// In a single checkout (the live instance today) instance root === core root, so
+// this is byte-identical to the old constant.
+const CORE_CONFIG_PATH = path.resolve(__dirname, '..', '..', 'docs', 'discord', 'channels.json');
+
+function instanceConfigPath() {
+  // Through the published doorway (ADR 0083), which is where resolveInstanceRoot
+  // lives — the same core/host resolution the government pack already uses.
+  try {
+    const root = require('../../src/module-api').resolveInstanceRoot();
+    return path.resolve(root, 'docs', 'discord', 'channels.json');
+  } catch (e) { return null; }
+}
+
+// The path channels.json is actually read from, or the instance-root candidate
+// when neither exists (so the error names where the operator should put it).
+function resolveConfigPath() {
+  const inst = instanceConfigPath();
+  for (const c of [inst, CORE_CONFIG_PATH]) {
+    if (c && fs.existsSync(c)) return c;
+  }
+  return inst || CORE_CONFIG_PATH;
+}
+
+// Back-compat alias for the old export. Callers that want the live answer use
+// resolveConfigPath(); this stays the core-package path it always named.
+const CONFIG_PATH = CORE_CONFIG_PATH;
 
 // ---------------------------------------------------------------------------
 // PURE helpers (no Discord, no IO) — the load-bearing, fully-tested logic.
@@ -340,11 +379,41 @@ function planChannelReconcile(snapshot, config, ctx) {
 // IO + Discord REST (impure) — invoked by the bot sweep and the Archon command.
 // ---------------------------------------------------------------------------
 
-function loadConfig(configPath = CONFIG_PATH) {
-  const raw = fs.readFileSync(configPath, 'utf8');
+// Throws a TAGGED error when the layout file is absent (code CONFIG_NOT_FOUND,
+// carrying the path it looked at) so the callers below can report 'channels.json
+// not readable at <path>' instead of collapsing into a bare 500 — the silent
+// failure half of task 1003973.
+function loadConfig(configPath) {
+  const p = configPath || resolveConfigPath();
+  let raw;
+  try {
+    raw = fs.readFileSync(p, 'utf8');
+  } catch (e) {
+    if (e && e.code === 'ENOENT') {
+      const err = new Error(`channels.json not readable at ${p}`);
+      err.code = 'CONFIG_NOT_FOUND';
+      err.configPath = p;
+      throw err;
+    }
+    throw e;
+  }
   return JSON.parse(raw);
 }
 
+// Run a deps.loadConfig() that may be missing its file, and turn the tagged
+// CONFIG_NOT_FOUND into the same {ok:false, reason} shape the no_guild /
+// no_token paths already use, so every caller reports it the same way.
+function tryLoadConfig(deps) {
+  try {
+    return { config: deps.loadConfig() };
+  } catch (err) {
+    if (err && err.code === 'CONFIG_NOT_FOUND') {
+      return { fail: { ok: false, reason: 'no_config', configPath: err.configPath, detail: err.message } };
+    }
+    throw err;
+  }
+}
+
 // The managing bot's own user id, used to grant it an explicit VIEW overwrite on
 // any channel it restricts so it never locks itself out. Best-effort: returns
 // null if the client/user isn't resolvable (then the self-lockout guard is a
@@ -407,7 +476,9 @@ async function discordRest(token, method, urlPath, body) {
 function computePlan(deps = realDeps) {
   const guild = deps.getGuild();
   if (!guild) return { ok: false, reason: 'no_guild', ops: [], warnings: [] };
-  const config = deps.loadConfig();
+  const loaded = tryLoadConfig(deps);
+  if (loaded.fail) return { ...loaded.fail, ops: [], warnings: [] };
+  const config = loaded.config;
   const roleMap = deps.loadRoleMap();
   const ctx = { everyoneId: String(guild.id), roleMap, botId: botIdFromGuild(guild) };
   const snapshot = snapshotFromGuild(guild);
@@ -435,7 +506,9 @@ async function reconcileChannels(deps = realDeps) {
   const token = deps.loadBotToken();
   if (!token) return { ok: false, reason: 'no_token', applied: 0, failed: 0 };
 
-  const config = deps.loadConfig();
+  const loaded = tryLoadConfig(deps);
+  if (loaded.fail) return { ...loaded.fail, applied: 0, failed: 0 };
+  const config = loaded.config;
   const roleMap = deps.loadRoleMap();
   const ctx = { everyoneId: String(guild.id), roleMap, botId: botIdFromGuild(guild) };
   const snapshot = snapshotFromGuild(guild);
@@ -509,11 +582,13 @@ module.exports = {
   planChannelReconcile,
   // io
   loadConfig,
+  resolveConfigPath,
   snapshotFromGuild,
   computePlan,
   computeSnapshotConfig,
   reconcileChannels,
   CONFIG_PATH,
+  CORE_CONFIG_PATH,
   VIEW_CHANNEL,
   RANK_LADDER,
 };

package/modules/discord/routes/discord.js

@@ -79,6 +79,18 @@ function registerSeams() {
       console.log('[discord] role-sync (non-blocking):', e && e.message)));
 }
 
+// A !ok result from the channels module is either 'the bot is not connected'
+// or 'the layout file is not where I looked'. The second used to surface as a
+// bare 500 with the reason only in the server log, which made a missing
+// channels.json indistinguishable from a bot outage (task 1003973) — so it gets
+// its own code and names the path it tried.
+function failFor(res, r) {
+  if (r.reason === 'no_config') {
+    return res.fail('config_not_found', 503, { reason: r.reason, detail: r.detail, config_path: r.configPath });
+  }
+  return res.fail('bot_unavailable', 503, { reason: r.reason });
+}
+
 module.exports = function buildDiscordRouter() {
   registerSeams();
   const router = express.Router();
@@ -92,7 +104,7 @@ module.exports = function buildDiscordRouter() {
       const channels = require('../discord-channels');
       const plan = channels.computePlan();
       if (!plan.ok) {
-        return res.fail('bot_unavailable', 503, { reason: plan.reason });
+        return failFor(res, plan);
       }
       return res.json({ ok: true, guild_id: plan.guildId, op_count: plan.ops.length, ops: plan.ops, warnings: plan.warnings });
     } catch (err) {
@@ -131,7 +143,7 @@ module.exports = function buildDiscordRouter() {
       const channels = require('../discord-channels');
       const result = await channels.reconcileChannels();
       if (!result.ok) {
-        return res.fail('bot_unavailable', 503, { reason: result.reason });
+        return failFor(res, result);
       }
       return res.json({ ok: true, applied: result.applied, failed: result.failed, total: result.total, warnings: result.warnings });
     } catch (err) {

package/modules/ideas/inbox.js

@@ -1198,7 +1198,35 @@ async function developSpark(ideaId, { developedBy, templateKey = DEFAULT_TEMPLAT
   // null = "this row was not a developable spark when we looked". THREE ways to
   // get here, and the caller re-reads to say which: it was never a spark,
   // somebody else developed it first, or a triager closed the idea underneath us.
-  return rows[0] ?? null;
+  const graded = rows[0] ?? null;
+
+  // task 1003856: a Full Idea is the ideator's hand-off point, and the
+  // cross-role cascade that turns it into an engineer's scoping request needs a
+  // transition to hang on. Emitted only on a REAL transition — the UPDATE's
+  // `AND grade = 'spark'` means a no-op re-grade returns null and fires nothing,
+  // so the event cannot repeat for one idea.
+  //
+  // Wrapped and awaited-free by the same reasoning as every other kernel emit
+  // here: a listener must never be able to fail the write that preceded it. The
+  // cascade runner catches everything of its own accord as well.
+  if (graded) {
+    // The payload carries the WHOLE idea, not just its id. The listener lives in
+    // the lifecycle module, which owns no idea table and has no read port for one
+    // (ideas provides only `ideas.capture`) — so the read happens here, inside the
+    // module that owns the row, rather than by widening another module's surface.
+    try {
+      const idea = await getIdea(ideaId);
+      api.emit('idea.graded.full', {
+        ...(idea || {}),
+        id: ideaId,
+        idea_id: ideaId,
+        grade: 'full',
+        completeness_score: graded.completeness_score,
+        developed_by: graded.developed_by,
+      });
+    } catch { /* a listener, or the read that feeds it, must never cost the ideator their grade */ }
+  }
+  return graded;
 }
 
 // The grade row on its own. null = no row, which reads as grade='quick'

package/modules/lifecycle/cascade.js

@@ -168,6 +168,68 @@ const CASCADES = Object.freeze([
   }),
 ]);
 
+// THE TRIGGERS. A cascade reacts to a state transition; there are two, and this
+// table is what lets one runner serve both without either pretending to be the
+// other. `subject` names what the rule's when/title/body receive, and the pair is
+// what the generated task's preamble says happened. Adding a third trigger is a
+// row here plus a rule list — deliberately not a condition language.
+const TRIGGERS = Object.freeze({
+  ship: Object.freeze({ subject: 'task', happened: (s) => `task ${s.id} shipped` }),
+  idea: Object.freeze({ subject: 'idea', happened: (s) => `idea ${s.id} was graded Full` }),
+});
+
+// Cascades triggered by an IDEA reaching grade 'full' (the ideator's finished
+// article), rather than by a ship. Kept as its own list rather than a `trigger`
+// field on one list, so a rule cannot be evaluated against a subject shape it was
+// never written for — an idea has no touches[], a task has no completeness score.
+const IDEA_CASCADES = Object.freeze([
+  Object.freeze({
+    key: 'engineer-scoping-on-full-idea',
+    discipline: 'engineer',
+    kind: 'unclassified',
+    // A Full Idea is the ideator's hand-off point: the five questions are
+    // answered and the thing is described well enough to cost. What it still
+    // lacks is an engineer's read on what building it would actually mean, and
+    // that read is the scoping task this files.
+    //
+    // The anti-recursion guard is FIRST, as in the ship rule. An idea that a
+    // cascade itself filed cannot file another.
+    when: (idea) => !!idea
+      && idea.grade === 'full'
+      && idea.source !== CASCADE_SOURCE
+      && String(idea.status || 'open') === 'open',
+    title: (idea) => `Scope the Full Idea: ${String(idea.title || '').trim() || `idea ${idea.id}`}`,
+    body: fullIdeaScopingBody,
+  }),
+]);
+
+// The body of the engineer's scoping request. Says what the ideator already
+// settled so the engineer does not re-ask it, and what the scoping is FOR.
+function fullIdeaScopingBody(idea) {
+  const score = idea.completeness_score != null ? ` (completeness ${idea.completeness_score})` : '';
+  const author = idea.captured_by ? ` by builder ${idea.captured_by}` : '';
+  // The idea's goal HINT, surfaced for a triager rather than acted on. It is
+  // advisory by its column's own definition, so it may inform a human decision and
+  // may not silently place this task.
+  const hint = idea.suggested_goal_id != null
+    ? `\nThe idea carried a routing hint — it may belong to goal ${idea.suggested_goal_id}. That is advisory; place this task wherever triage decides.\n`
+    : '';
+  return [
+    `Idea ${idea.id} reached **Full**${score}${author} — the ideator's five questions are answered, so the WHAT is settled.`,
+    hint,
+    '',
+    'What this asks for is the engineer\'s read the idea cannot give itself:',
+    '',
+    '- What would building it actually touch, and roughly what size is it?',
+    '- What already exists that it should sit on rather than duplicate?',
+    '- What is genuinely unknown, and what would cheaply settle it?',
+    '',
+    'Answer by turning it into real tasks, or by saying plainly why it should not be built — a scoping that concludes "not worth it, because X" is a complete answer and a useful one.',
+    '',
+    `The idea's own body is the brief; read it at the hall rather than re-deriving it here.`,
+  ].join('\n');
+}
+
 // The (source, source_ref) pair the generated task is keyed on. `source` is a
 // constant so every cascade-generated row is findable as a class; the ref pins
 // it to one rule and one originating ship.
@@ -218,7 +280,7 @@ function validateCascades(rules = CASCADES) {
 // A rule whose `when` THROWS is treated as no-match and reported in `errors`,
 // never propagated: one broken predicate must not cost the other rules their
 // tasks, and it certainly must not reach the ship.
-function cascadesFor(task, rules = CASCADES, ctx = {}) {
+function cascadesFor(task, rules = CASCADES, ctx = {}, trigger = TRIGGERS.ship) {
   const matched = [];
   const errors = [];
   if (!task || task.id == null) return { matched, errors: ['no task'] };
@@ -234,7 +296,7 @@ function cascadesFor(task, rules = CASCADES, ctx = {}) {
     }
     if (!hit) continue;
     try {
-      matched.push({ rule, spec: cascadeTaskSpec(rule, task) });
+      matched.push({ rule, spec: cascadeTaskSpec(rule, task, trigger) });
     } catch (e) {
       errors.push(`cascade "${rule.key}": title/body threw (${e && e.message})`);
     }
@@ -244,17 +306,26 @@ function cascadesFor(task, rules = CASCADES, ctx = {}) {
 
 // The createTask payload for one matched rule. The attribution preamble is
 // prepended here rather than left to each rule, so no rule can forget it.
-function cascadeTaskSpec(rule, task) {
+function cascadeTaskSpec(rule, task, trigger = TRIGGERS.ship) {
   const body = String(rule.body(task) || '').trim();
   const preamble =
-    `Filed automatically when task ${task.id} shipped — the "${rule.key}" cascade `
+    `Filed automatically when ${trigger.happened(task)} — the "${rule.key}" cascade `
     + `(modules/lifecycle/cascade.js). Nobody typed this; it is a REQUEST, filed at backlog, `
     + `and it goes through the board's ordinary triage. If the rule that made it is wrong, fix `
     + `the rule rather than only this task.`;
   return {
-    versionId: task.version_id,
+    // An idea carries a GUESS where a task carries a fact. `suggested_version` is
+    // inherited because a version is a label; `suggested_goal_id` is NOT, because
+    // its own column header forbids exactly that read — see goalId below.
+    versionId: task.version_id != null ? task.version_id : (task.suggested_version ?? null),
     // A cascade INHERITS its parent's goal — the follow-up belongs wherever the
     // work that triggered it belongs.
+    // NOT inherited from an idea's `suggested_goal_id`. That column documents
+    // itself as "Strictly advisory: no rank check, no scope wall, and no payout
+    // may read it... The BINDING home for 'which goal' is tasks.goal_id" — and a
+    // generated task's goal is binding. So an idea-triggered cascade lands in the
+    // catch-all and gets triaged like any other homeless work; the hint travels in
+    // the body instead, where a human can act on it.
     goalId: task.goal_id != null ? Number(task.goal_id) : null,
     // BV1.R11 (task 1003598): …and when the parent has none, says so. A shipped
     // task can still be goal-less — the 53 legacy catch-all rows, or any task
@@ -283,6 +354,59 @@ function cascadeTaskSpec(rule, task) {
 // The runner — the only part that touches a database
 // ---------------------------------------------------------------------------
 
+// FILE ONE SUBJECT'S MATCHES. Shared by both runners so the idempotency read,
+// the per-rule isolation and the reporting cannot drift apart between triggers —
+// the two runners differ only in how they FETCH a subject and which rule list and
+// context they bring.
+async function fileMatches({ matched, deps, report, trigger, subject }) {
+  for (const { rule, spec } of matched) {
+    try {
+      const existing = deps.findTaskBySourceRef
+        ? await deps.findTaskBySourceRef({ source: CASCADE_SOURCE, sourceRef: spec.sourceRef })
+        : null;
+      if (existing) { report.skipped.push({ key: rule.key, taskId: existing.id, reason: 'already filed' }); continue; }
+      const created = await deps.createTask(spec);
+      report.created.push({ key: rule.key, taskId: created && created.id, discipline: rule.discipline });
+      deps.log?.info?.(`[cascade] ${trigger.happened(subject)} → filed ${created && created.id} for ${rule.discipline} ("${rule.key}")`);
+    } catch (e) {
+      // One rule failing costs that rule its task and nothing else.
+      report.errors.push(`cascade "${rule.key}": ${e && e.message}`);
+    }
+  }
+}
+
+// React to one idea reaching grade 'full'. Same guarantees as the ship runner —
+// returns a report, never throws, never rejects — because an ideator grading
+// their own idea must not be able to fail on a follow-up task's account.
+//
+//   deps.getIdea(id)                 -> the full idea row (the event payload may
+//                                       carry only the id)
+//   deps.findTaskBySourceRef({...})  -> an existing row or null
+//   deps.createTask(spec)            -> the created row
+//   deps.log                         -> optional { info, error }
+async function runCascadesForIdea(graded, deps = {}) {
+  const report = { created: [], skipped: [], errors: [] };
+  try {
+    const id = graded && (graded.id ?? graded.idea_id);
+    if (id == null) { report.errors.push('cascade: idea payload carried no idea id'); return report; }
+
+    // The emitter sends the whole idea (it owns the row; this module does not),
+    // so the payload IS the subject. deps.getIdea stays supported for a caller
+    // that would rather re-read — and when one is injected and returns nothing,
+    // that is an error rather than a silent fall-back to a payload it rejected.
+    const idea = deps.getIdea ? await deps.getIdea(id) : graded;
+    if (!idea) { report.errors.push(`cascade: idea ${id} not readable after grading`); return report; }
+
+    const { matched, errors } = cascadesFor(idea, deps.rules || IDEA_CASCADES, {}, TRIGGERS.idea);
+    report.errors.push(...errors);
+    await fileMatches({ matched, deps, report, trigger: TRIGGERS.idea, subject: idea });
+  } catch (e) {
+    report.errors.push(`cascade: ${e && e.message}`);
+  }
+  if (report.errors.length) deps.log?.error?.(`[cascade] ${report.errors.length} problem(s): ${report.errors.join(' | ')}`);
+  return report;
+}
+
 // React to one shipped task. Returns a report, NEVER throws and never rejects:
 // property 1 in the header. `deps` is injected so the whole runner is testable
 // with two stubs and no database.
@@ -323,20 +447,7 @@ async function runCascadesForShip(shipped, deps = {}) {
     const { matched, errors } = cascadesFor(task, deps.rules || CASCADES, ctx);
     report.errors.push(...errors);
 
-    for (const { rule, spec } of matched) {
-      try {
-        const existing = deps.findTaskBySourceRef
-          ? await deps.findTaskBySourceRef({ source: CASCADE_SOURCE, sourceRef: spec.sourceRef })
-          : null;
-        if (existing) { report.skipped.push({ key: rule.key, taskId: existing.id, reason: 'already filed' }); continue; }
-        const created = await deps.createTask(spec);
-        report.created.push({ key: rule.key, taskId: created && created.id, discipline: rule.discipline });
-        log?.info?.(`[cascade] task ${id} shipped → filed ${created && created.id} for ${rule.discipline} ("${rule.key}")`);
-      } catch (e) {
-        // One rule failing costs that rule its task and nothing else.
-        report.errors.push(`cascade "${rule.key}": ${e && e.message}`);
-      }
-    }
+    await fileMatches({ matched, deps: { ...deps, log }, report, trigger: TRIGGERS.ship, subject: task });
   } catch (e) {
     report.errors.push(`cascade: ${e && e.message}`);
   }
@@ -346,6 +457,10 @@ async function runCascadesForShip(shipped, deps = {}) {
 
 module.exports = {
   CASCADES,
+  IDEA_CASCADES,
+  TRIGGERS,
+  fullIdeaScopingBody,
+  runCascadesForIdea,
   CASCADE_SOURCE,
   COPY_VISUAL_MODULES,
   hasCopyOrVisualWork,