@bongos/core 1.19.842 → 1.19.843

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.842",
-  "core_contract": "1.19.842",
-  "source_commit": "ffa8d1ce17675d5981142ca6588ef641d0893058",
+  "core_version": "1.19.843",
+  "core_contract": "1.19.843",
+  "source_commit": "7c57c44f66a63fda88681f46ac67857f8c8ed1e7",
   "source_ref": "HEAD",
-  "built_at": "2026-09-17T18:21:47.399Z",
+  "built_at": "2026-09-17T18:30:58.977Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 495,
     "agent_docs_stubbed": 26,
-    "functional_verbatim": 2266,
+    "functional_verbatim": 2270,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 2787,
-  "tree_sha256": "204ee5631e422b90ff1d79a7fde81706ca492bea501801a162421ebd04f6bfdb",
+  "file_count": 2791,
+  "tree_sha256": "9f6bfba9532caa1edab6600efaf86e006add511e45378f5cf2ccf8ad81d81231",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -2577,7 +2577,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "033de93b8ea7781edf94b6b1146741c2bde76443ecf7b6c8b1bf47d8919d6bab"
+      "sha256": "e2083366af3229b576d6d034f1d2e1c6e7e4fa61fba384ba0d0fca9b7911087f"
     },
     {
       "path": "docs/modules-contract.md",
@@ -3679,6 +3679,11 @@
       "mode": "0000644",
       "sha256": "0481e0b8205c707ed002f404c801d3f2059b2b0e0fcfa9bc436968f6665a296f"
     },
+    {
+      "path": "migrations/core_247_discipline_required.sql",
+      "mode": "0000644",
+      "sha256": "e8d3e3f764b61ea559df7f997758e639f8778ee24da4293908e9d45ca30a425b"
+    },
     {
       "path": "modules/agents/CLAUDE.md",
       "mode": "0000644",
@@ -3882,7 +3887,7 @@
     {
       "path": "modules/copy-desk/routes/copy-desk.js",
       "mode": "0000644",
-      "sha256": "63ed245f47d15758ef0926a489ad1fc7ef56d8539e836ed9e319e09b99a4a38e"
+      "sha256": "4839f077aee504947a3bada77fd9c3df882f9005f571ed2e2367b615c111b76b"
     },
     {
       "path": "modules/copy-desk/tests/copy_flags.mjs",
@@ -5477,7 +5482,7 @@
     {
       "path": "modules/ideas/inbox.js",
       "mode": "0000644",
-      "sha256": "683e2234893c9814c2ecec490099c140e273e764e993707bb1cc4c5c9d1baed3"
+      "sha256": "ff6c0346215d1b88309c4c9360cd60c59299b21b45e27cce09c4b748bf3411e1"
     },
     {
       "path": "modules/ideas/migrations/ideas_001_grades.sql",
@@ -5657,7 +5662,7 @@
     {
       "path": "modules/lifecycle/db-tasks.js",
       "mode": "0000644",
-      "sha256": "87b075187493e8026f99912dceb7195d09564bfe3f969f344141661c60ef6558"
+      "sha256": "5d17541d837a06903be832814a74218c9fee8b9119dd870c88273743be5a5efa"
     },
     {
       "path": "modules/lifecycle/db-versions.js",
@@ -5752,7 +5757,7 @@
     {
       "path": "modules/lifecycle/lifecycle.js",
       "mode": "0000644",
-      "sha256": "bdc23f748853a4a39ae416f731052bd29e4fe5788684cb83a166243d9240a364"
+      "sha256": "41ef55efff7f334ee8b19490f03944ca25f22454c718dfb81445539bc6a77aa4"
     },
     {
       "path": "modules/lifecycle/merge-lock.js",
@@ -5877,7 +5882,7 @@
     {
       "path": "modules/lifecycle/routes/goals.js",
       "mode": "0000644",
-      "sha256": "eb3137c30f6471aa0900f98f0fa45752808609e4e1e99f9ecb1f6df0d3e7c5ab"
+      "sha256": "17f7c0ccfc87eec24c662bf8d5599223562e773430802cd054b27a3ddadab46e"
     },
     {
       "path": "modules/lifecycle/routes/help-requests.js",
@@ -5922,7 +5927,7 @@
     {
       "path": "modules/lifecycle/routes/task-write-routes.js",
       "mode": "0000644",
-      "sha256": "9cff3bcd27467dc413aa975cd20262b47e8595a50a845d93b557a24828719bbf"
+      "sha256": "bb172485d8d5f84d96cdb611b0d57cd5f69ee768bdceddeb1eea42dc3f5676c1"
     },
     {
       "path": "modules/lifecycle/routes/tasks.js",
@@ -5962,7 +5967,7 @@
     {
       "path": "modules/lifecycle/task-classifier.js",
       "mode": "0000644",
-      "sha256": "9299590b71b194087174ff0212dc70f5f28fbafd5678923c81a3db13c6b78db5"
+      "sha256": "39047afd6440d589cee978887ce4b5fa285b00d55ed2b023546fce41e59bdc9c"
     },
     {
       "path": "modules/lifecycle/task-list-limits.js",
@@ -7892,12 +7897,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "21b80f9aba47da61edcb4a374ad4aad35f2e5c563cccb1daae278b6d892d0255"
+      "sha256": "090497aae4ab83f6ab3f821417ece5fcc50b86a09e026b3e4644aa660333d191"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "61f48c57b02632310e7ba92115fdc6939efe7967f2ee7542fa7b12834f8af6c2"
+      "sha256": "e7d47a1c39751137250a2cc087fb288d3c349b44d8faebc38f70e841f6475560"
     },
     {
       "path": "public-docs/index.html",
@@ -8064,6 +8069,11 @@
       "mode": "0000644",
       "sha256": "9c03bf914c4a1a6f5d9936bb5542a4e3952873de65b0518254808bfbd1901b40"
     },
+    {
+      "path": "scripts/gds/backfill-disciplines.js",
+      "mode": "0000644",
+      "sha256": "cc9bd2d437e6a7d6eb2b48504cc7d7c44a674403a0d00625a0526719825f88d2"
+    },
     {
       "path": "scripts/gds/backfill-session-earnings.js",
       "mode": "0000644",
@@ -8432,7 +8442,7 @@
     {
       "path": "scripts/gds/fitness-ratchets.js",
       "mode": "0000644",
-      "sha256": "b3f4092fffd30e50cb145b524beeed5d483132f52e77e37a7ab9c18bbf300bc7"
+      "sha256": "178d2cfb91c97c107d60cc3895ba1b3eff74c45d383646e7a64621d018c21b47"
     },
     {
       "path": "scripts/gds/fitness.js",
@@ -8577,7 +8587,7 @@
     {
       "path": "scripts/gds/init.js",
       "mode": "0000644",
-      "sha256": "9f0b3c283caf637ff6e3b514a417ae3e42572b323a14c83cd89beda270c49c37"
+      "sha256": "e1fbe45a7619cd5000b5bb34c80bbd63c2591dcc78a64188870847e5da049448"
     },
     {
       "path": "scripts/gds/install-git-hooks.js",
@@ -9367,7 +9377,7 @@
     {
       "path": "scripts/gds/triage.js",
       "mode": "0000644",
-      "sha256": "de0673313c1eb5e052f993138cd2d5686f9c1de1f9acd00f8a5fca73ed361db2"
+      "sha256": "a4af12591b829f9b89a5768858e8a2ba02a44d7e7ebd848e945e77f95fc55da7"
     },
     {
       "path": "scripts/gds/turn-end-sound.js",
@@ -9827,7 +9837,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "84e310a550189d0d3d86f825cc04d61d81e0c0dc78428056661357a1a5076e74"
+      "sha256": "a24a8e5c67584fff7c871ad60afaa3bc9f81a2c77189629597dd4fd63cd43c31"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -11989,6 +11999,11 @@
       "mode": "0000644",
       "sha256": "416d413757a13fbddb5841ea8a2c503077d7e6067bc1c58ce1f4d416b8d8487f"
     },
+    {
+      "path": "tests/knip_ratchet_ambient.mjs",
+      "mode": "0000644",
+      "sha256": "b48d7f46c4518ef7da8e252d8009edd25ec5771f7be320f889f437762af72b54"
+    },
     {
       "path": "tests/known_failing_ratchet.mjs",
       "mode": "0000644",
@@ -12862,7 +12877,7 @@
     {
       "path": "tests/rank_floor_wiring.mjs",
       "mode": "0000644",
-      "sha256": "f81f559b5428497b2246580c7921ecd1ba5a2f1034cf29eb5e5c21b04675f216"
+      "sha256": "973fc0768bd52f3e25c98306c21cc6a9c6268daae033e1329c68620a847bc0a9"
     },
     {
       "path": "tests/rank_gate.mjs",
@@ -12972,7 +12987,7 @@
     {
       "path": "tests/reward_gate.mjs",
       "mode": "0000644",
-      "sha256": "1ed242c879472dd872c1327c8e7c91de61886dcb108ece3fa455ae6be4b4e025"
+      "sha256": "0cd9f335da162c3562c099a2dbe4375b009f5a8a8321f4ef84b7a577be816bdc"
     },
     {
       "path": "tests/reward_mode_cost_plus_only.mjs",
@@ -13619,6 +13634,11 @@
       "mode": "0000644",
       "sha256": "0bc0d93696b5ce80fb4307b7991bff640316e46fd6fcdebf0ba5a62397ffbe8f"
     },
+    {
+      "path": "tests/task_discipline_required.mjs",
+      "mode": "0000644",
+      "sha256": "2fda6816614259699227a21f97b81d816f20fdd654c861e24a282c1d178ddff4"
+    },
     {
       "path": "tests/task_field_bounds_match_db.mjs",
       "mode": "0000644",
@@ -13637,7 +13657,7 @@
     {
       "path": "tests/task_goal_required.mjs",
       "mode": "0000644",
-      "sha256": "04e7a36f7c2f5a94f847fcb4b77f017f6399fc96041cdaee1123c9a6fecb3d5d"
+      "sha256": "073581d9a97095666ee2ed7ebb0a6b280f3e8ea1efc53015c2f77eb5d08c4975"
     },
     {
       "path": "tests/task_lib.mjs",

package/docs/module-api-changelog.md

@@ -2158,5 +2158,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.840 with no explicit bump. run 35257419225. (task 1002620)
   1.19.842 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.841 with no explicit bump. run 35258288930. (task 1002620)
+  1.19.843 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.842 with no explicit bump. run 35259228465. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/migrations/core_247_discipline_required.sql

@@ -0,0 +1,58 @@
+-- core_247_discipline_required.sql — task 1002988: every task row carries a craft.
+--
+-- `unclassified` is a triage state, not a craft. It was the DEFAULT on every create
+-- vector, so it accumulated: 1,189 rows on this instance as of 2026-09-17 (1,025
+-- real + 164 __smoke__ test rows), of which only 208 were live work. A row nobody's
+-- craft owns is a row nobody picks up.
+--
+-- THE ACCEPTED SET IS FOUR, NOT THREE. The task was written on 2026-08-16 naming
+-- {engineer, artist, ideator}. ADR 0272 (2026-09-09) postdates it and KEEPS `ui` as
+-- a module-contributed discipline, and the owner reconfirmed that on 2026-09-17 when
+-- abandoning the sibling task 1002987 ("Delete the ui role across the platform") for
+-- exactly this reason. Narrowing to three would break 50+ live `ui` rows and
+-- contradict a live ADR, so migration 176's `ui` entry survives untouched here.
+--
+-- WHY THE BACKFILL IS IN THE MIGRATION. The good classification is done by
+-- scripts/gds/backfill-disciplines.js, which runs the real JS heuristic
+-- (classifyTaskDiscipline) and cannot be expressed in SQL. But a migration that
+-- assumes a script was run by hand is a migration that breaks the next fresh
+-- install, the next instance, and any checkout where nobody remembered. So the
+-- UPDATE below is the LAST-RESORT NET, not the plan: it catches whatever the script
+-- left (or everything, if the script never ran) and parks it on 'engineer' — the
+-- value ~99% of confidently-classified rows resolve to.
+--
+-- That fallback is a GUESS and is recorded as one. The owner chose it on 2026-09-17
+-- over the alternative (backfill live work only, leave history alone), accepting
+-- that the ~273 rows the classifier refuses get a best guess rather than a known
+-- answer. Do not read a post-migration `discipline` on an old row as evidence that
+-- anyone determined it.
+--
+-- Idempotent: safe to re-run. The UPDATE matches nothing on a second pass, and the
+-- constraint is dropped before being re-added (the pattern of migrations 086/176).
+-- Forward-safe: the column is unchanged and the previous release wrote only values
+-- this constraint still accepts, EXCEPT 'unclassified' — a rolled-back deploy whose
+-- code still defaults to 'unclassified' would have its INSERTs rejected. That is the
+-- intended behaviour (it is the hole being closed), and it is why the application
+-- side of this task resolves the discipline at db-tasks.createTask, the single
+-- chokepoint every create vector passes through, rather than only at the two routes.
+
+BEGIN;
+
+-- 1. The last-resort net (see header). Everything the classifier could call should
+--    already have been PATCHed by backfill-disciplines.js before this runs.
+UPDATE tasks SET discipline = 'engineer' WHERE discipline = 'unclassified' OR discipline IS NULL;
+
+-- 2. Narrow the accepted set: drop 'unclassified', keep 'ui' (ADR 0272).
+ALTER TABLE tasks DROP CONSTRAINT IF EXISTS tasks_discipline_check;
+ALTER TABLE tasks ADD CONSTRAINT tasks_discipline_check
+  CHECK (discipline IN ('engineer', 'artist', 'ideator', 'ui'));
+
+-- builders.preferred_disciplines already excludes 'unclassified' (migration 176 —
+-- "Never carries 'unclassified' — that's a task state, not an interest area"), so it
+-- needs no change here. Named rather than silently skipped, so the next reader does
+-- not have to re-check.
+
+INSERT INTO schema_migrations (version) VALUES ('core_247_discipline_required')
+  ON CONFLICT (version) DO NOTHING;
+
+COMMIT;

package/modules/copy-desk/routes/copy-desk.js

@@ -429,6 +429,12 @@ module.exports = function buildCopyDeskRouter() {
         // opinion mint claimable work.
         status: 'backlog',
         kind: 'feature',
+        // task 1002988: named explicitly rather than inferred. A copy patch is
+        // reader-facing wording, which is artist work — cascade.js already treats
+        // `source: 'copy-proposal'` as an artist surface (hasCopyOrVisualWork), so
+        // inferring it from the patch text would risk the two disagreeing about
+        // the same row.
+        discipline: 'artist',
         priority: 4,
         touches: [patch.file],
         source: 'copy-proposal',

package/modules/ideas/inbox.js

@@ -405,9 +405,11 @@ async function routeIdeaToGoal({
     //    own floor and takes the HIGHER of the two, so this can raise the bar and
     //    never lower it. Deliberately NOT passed at all: `creditsReward` (server
     //    default — createTask auto-assigns the capped suggestion) and
-    //    `discipline` (left 'unclassified', exactly as the other non-authored
-    //    create vectors leave it).
+    //    `discipline` — NO LONGER 'unclassified' (task 1002988). createTask refuses a
+    //    craft it cannot infer; refusing a filer is the wrong trade for an INBOX, so we
+    //    ask the same question and fall back to 'engineer' (free to re-triage; a lost capture is not).
     const task = await lifecycle.createTask({
+      discipline: (lifecycle.resolveWriteDiscipline?.({ title, description: bodyMd, touches: declaredTouches })?.discipline) || 'engineer',
       versionId: goal.version_id,
       title,
       description: bodyMd,

package/modules/lifecycle/db-tasks.js

@@ -18,6 +18,7 @@ const { matchProtected } = api.permissionPathCheck;
 const { decorateGoalMembership, capNewcomerTasks } = require('./claim-feed.js');
 const { deriveRequiredRank, highestRank } = require('./db-rank-authz.js');
 const { executorFor } = require('./db-executor.js');
+const { resolveWriteDiscipline, WRITABLE_DISCIPLINES } = require('./task-classifier.js');
 
 // -------------------------------------------------------------------------
 // Tasks
@@ -123,7 +124,13 @@ async function createTask({
   sourceRef = null,
   valueSummary = null,
   kind = 'unclassified',
-  discipline = 'unclassified',
+  // task 1002988 — NOT defaulted to 'unclassified' any more. This is the single
+  // chokepoint every create vector passes through, including the ones that never
+  // touch an HTTP route (idea promotion, copy-desk, newcomer-restock, kickoff-seed,
+  // cascade), so resolving here is what makes "no row is born role-less" true of
+  // the whole path rather than of the two routes. Resolved just below; `undefined`
+  // means "work it out from the text".
+  discipline = undefined,
   parallelSafe = null,
   newcomerFriendly = false,
   needsMigration = false,
@@ -198,6 +205,25 @@ async function createTask({
     }
     goalIdEffective = await generalGoalIdForVersion(versionId);
   }
+
+  // task 1002988 (owner decision 2026-09-17): every row is born with a craft.
+  // An absent or 'unclassified' discipline is INFERRED from title + description +
+  // touches; a task whose text says nothing about its craft is REFUSED rather than
+  // filed under a word that means "nobody looked". Throwing here rather than
+  // silently defaulting is the point — 1,189 role-less rows accumulated precisely
+  // because the default was quiet. A caller that cannot tolerate a refusal passes
+  // an explicit discipline, which is then visible at its call site instead of
+  // hidden in this signature.
+  const resolvedDiscipline = resolveWriteDiscipline({ discipline, title, description, touches });
+  if (resolvedDiscipline.error) {
+    const err = new Error(resolvedDiscipline.unclassifiable
+      ? `Cannot infer a discipline for "${String(title).slice(0, 80)}" from its title and description. Pass discipline explicitly: ${Array.from(WRITABLE_DISCIPLINES).join(' | ')}.`
+      : `discipline must be one of ${Array.from(WRITABLE_DISCIPLINES).join(' | ')} (got ${JSON.stringify(discipline)}).`);
+    err.code = 'BAD_DISCIPLINE';
+    err.unclassifiable = resolvedDiscipline.unclassifiable === true;
+    throw err;
+  }
+  const disciplineEffective = resolvedDiscipline.discipline;
   // task 1498 / ADR 0084: every task carries a deliberate rank floor. Derive it,
   // then let an explicit requiresRank override only UPWARD (highestRank) — a
   // requested rank below the derived floor is clamped up to the floor
@@ -247,7 +273,7 @@ async function createTask({
       sourceRef,
       valueSummary,
       kind,
-      discipline,
+      disciplineEffective,
       parallelSafe,
       newcomerFriendly === true,
       needsMigration === true,

package/modules/lifecycle/lifecycle.js

@@ -37,6 +37,12 @@ module.exports = {
   // (consumer: core cascade-dispatch.js, the dormant System-3 lib).
   get VOTABLE_TASK_STATUSES() { return classifier.VOTABLE_TASK_STATUSES; },
   classifyTaskKind: (...a) => classifier.classifyTaskKind(...a),
+  // task 1002988: createTask now REFUSES a task whose craft it cannot work out, so
+  // a consumer that must not fail (idea capture, copy-desk) needs to ask the same
+  // question first and name its own fallback. Exposed on the port because a module
+  // may not require another module — the boundary rule — and a second copy of this
+  // heuristic living in modules/ideas is exactly the drift this port exists to stop.
+  resolveWriteDiscipline: (...a) => classifier.resolveWriteDiscipline(...a),
   // TASK_KINDS: the kind vocabulary, as an ordered array (consumer: GET /me,
   // which hands it to the hall so a filter can be BUILT from it instead of
   // retyped — task 1003453). VALID_KINDS is a Set and Sets do not survive

package/modules/lifecycle/routes/goals.js

@@ -31,7 +31,7 @@ const goalEdits = require('../goal-edits.js'); // task 1003102 — goal self-edi
 const goalCategory = require('../goal-category.js'); // task 1003275 — the ADVISORY human category (gates nothing)
 const goalRollup = require('../goal-rollup.js'); // task 1003278 — per-goal rollups computed in SQL, not in the browser
 const { suggestCriteria } = require('../criterion-suggest');
-const { classifyTaskKind, VALID_KINDS, VALID_DISCIPLINES, TASK_FIELD_BOUNDS } = require('../task-classifier');
+const { classifyTaskKind, VALID_KINDS, WRITABLE_DISCIPLINES, resolveWriteDiscipline, TASK_FIELD_BOUNDS } = require('../task-classifier');
 const { validateOrRespond, parseId, LIMITS } = api;
 const { isModuleKey, scopeIncludesProtected, moduleKeys } = api.moduleScopeMap;
 // goalScopeCheck — the PURE scope wall (BV1.R59 / ADR 0086 §3), reached through
@@ -1388,10 +1388,23 @@ module.exports = function buildGoalsRouter() {
         const result = classifyTaskKind(body.title, body.description || '');
         kind = result.confidence >= 0.5 ? result.kind : 'unclassified';
       }
-      const discipline = body.discipline ?? 'unclassified';
-      if (!VALID_DISCIPLINES.has(discipline)) {
-        return res.fail('bad_discipline', 400, { valid: Array.from(VALID_DISCIPLINES) });
+      // task 1002988 — the SECOND create path. It carried the same
+      // `body.discipline ?? 'unclassified'` line as POST /tasks, so a fix applied
+      // only there would have left this one minting the rows the task exists to
+      // remove. Both now share resolveWriteDiscipline().
+      const resolvedDiscipline = resolveWriteDiscipline({
+        discipline: body.discipline, title: body.title, description: body.description, touches: body.touches,
+      });
+      if (resolvedDiscipline.error) {
+        return res.fail('bad_discipline', {
+          status: 400,
+          message: resolvedDiscipline.unclassifiable
+            ? `discipline was not supplied and could not be inferred from the title and description. Pass one of ${Array.from(WRITABLE_DISCIPLINES).join(' | ')}.`
+            : `discipline must be one of ${Array.from(WRITABLE_DISCIPLINES).join(' | ')}.`,
+          details: { valid: Array.from(WRITABLE_DISCIPLINES) },
+        });
       }
+      const discipline = resolvedDiscipline.discipline;
 
       // Create. version = the goal's (not client-supplied); status 'ready' so the
       // author can claim it immediately; requiresRank OMITTED → auto-derived

package/modules/lifecycle/routes/task-write-routes.js

@@ -22,7 +22,7 @@ const db = require('../db');
 const hierarchy = require('../hierarchy');
 const { suggestCriteria } = require('../criterion-suggest');
 const { buildGoalAdvisory } = require('../goal-advisory');
-const { classifyTaskKind, VALID_KINDS, VALID_DISCIPLINES, VOTABLE_TASK_STATUSES, TASK_FIELD_BOUNDS } = require('../task-classifier');
+const { classifyTaskKind, VALID_KINDS, WRITABLE_DISCIPLINES, resolveWriteDiscipline, VOTABLE_TASK_STATUSES, TASK_FIELD_BOUNDS } = require('../task-classifier');
 const { isModuleKey, moduleKeys } = api.moduleScopeMap;
 const { validateOrRespond, LIMITS, parseId } = api;
 const { badKind, detectsMigration } = require('./task-route-helpers.js');
@@ -141,10 +141,22 @@ module.exports = function registerTaskWriteRoutes(router) {
       const result = classifyTaskKind(body.title, body.description || '');
       kind = result.confidence >= 0.5 ? result.kind : 'unclassified';
     }
-    const discipline = body.discipline ?? 'unclassified';
-    if (!VALID_DISCIPLINES.has(discipline)) {
-      return res.fail('bad_discipline', 400, { valid: Array.from(VALID_DISCIPLINES) });
+    // task 1002988: a create must never mint a role-less row. An omitted (or
+    // explicitly 'unclassified') discipline is INFERRED from the text; only a
+    // genuinely unclassifiable task is refused.
+    const resolved = resolveWriteDiscipline({
+      discipline: body.discipline, title: body.title, description: body.description, touches: body.touches,
+    });
+    if (resolved.error) {
+      return res.fail('bad_discipline', {
+        status: 400,
+        message: resolved.unclassifiable
+          ? `discipline was not supplied and could not be inferred from the title and description. Pass one of ${Array.from(WRITABLE_DISCIPLINES).join(' | ')}.`
+          : `discipline must be one of ${Array.from(WRITABLE_DISCIPLINES).join(' | ')}.`,
+        details: { valid: Array.from(WRITABLE_DISCIPLINES), inferred: false },
+      });
     }
+    const discipline = resolved.discipline;
     // task 1498 / ADR 0084: an explicit requires_rank must be a live rank. The
     // floor auto-derives from touches + security_sensitive; createTask clamps
     // any explicit value UP to that floor (never below), so this only rejects a
@@ -496,8 +508,15 @@ module.exports = function registerTaskWriteRoutes(router) {
     if (hasKind && !VALID_KINDS.has(body.kind)) {
       return badKind(res);
     }
-    if (hasDiscipline && !VALID_DISCIPLINES.has(body.discipline)) {
-      return res.fail('bad_discipline', 400, { valid: Array.from(VALID_DISCIPLINES) });
+    // task 1002988: a PATCH may not push a row BACK to 'unclassified' — that is a
+    // triage state, not a craft, and letting an edit re-create one would reopen the
+    // hole the create path above just closed.
+    if (hasDiscipline && !WRITABLE_DISCIPLINES.has(body.discipline)) {
+      return res.fail('bad_discipline', {
+        status: 400,
+        message: `discipline must be one of ${Array.from(WRITABLE_DISCIPLINES).join(' | ')}.`,
+        details: { valid: Array.from(WRITABLE_DISCIPLINES) },
+      });
     }
     if (hasNewcomerOrXenos) {
       // V3.R15 #239: prefer newcomer_friendly (canonical); fall back to

package/modules/lifecycle/task-classifier.js

@@ -163,6 +163,42 @@ function classifyTaskKind(title, description) {
 // /design work-mode (discipline-modes.json) instead of /paint.
 const VALID_DISCIPLINES = new Set(['engineer', 'artist', 'ideator', 'ui', 'unclassified']);
 
+// The disciplines a WRITE may set (task 1002988). 'unclassified' is deliberately
+// absent: it is a triage state, not a craft, and a create that lands one produces
+// a row no craft is accountable for — which is how 1,189 of them accumulated.
+// VALID_DISCIPLINES above stays the READ-side set so existing rows and the
+// ?discipline=unclassified filter keep resolving while the backfill runs.
+// 'ui' stays: ADR 0272 keeps it as a module-contributed discipline, and the owner
+// reconfirmed that on 2026-09-17 when abandoning task 1002987.
+const WRITABLE_DISCIPLINES = new Set(['engineer', 'artist', 'ideator', 'ui']);
+
+// Mirrors the `kind` branch in the create routes: act on the classifier only when
+// it is at least half sure, otherwise treat it as no answer at all.
+const DISCIPLINE_CONFIDENCE_FLOOR = 0.5;
+
+// Resolve the discipline for a task WRITE. Honours an explicit valid value,
+// otherwise INFERS from title + description + touches, and reports failure so the
+// caller can 400 — per the owner decision of 2026-09-17, a bare 400 on a missing
+// discipline was rejected because four live paths (idea capture, idea promotion,
+// adopt-import and the new-instance scaffold) create tasks without one.
+//
+// Shared deliberately: POST /tasks and POST /goals/:id/tasks BOTH carried the
+// `body.discipline ?? 'unclassified'` line, so a fix applied to one of them would
+// have left the other quietly minting the very rows this task exists to remove.
+// Returns { discipline, inferred?, confidence? } or { error, unclassifiable? }.
+function resolveWriteDiscipline({ discipline, title, description, touches } = {}) {
+  if (discipline != null && discipline !== 'unclassified') {
+    return WRITABLE_DISCIPLINES.has(discipline) ? { discipline } : { error: 'bad_discipline' };
+  }
+  // Absent, null, or an explicit 'unclassified' (what modules/ideas/inbox.js sends
+  // on promotion) all mean the same thing: nobody told us, so work it out.
+  const guess = classifyTaskDiscipline(title, description || '', touches);
+  if (guess.confidence >= DISCIPLINE_CONFIDENCE_FLOOR && WRITABLE_DISCIPLINES.has(guess.discipline)) {
+    return { discipline: guess.discipline, inferred: true, confidence: guess.confidence };
+  }
+  return { error: 'bad_discipline', unclassifiable: true };
+}
+
 // Numeric field bounds for task creation (POST /tasks). The single source of
 // truth: the route schema in routes/tasks.js references these so the validator
 // and the claim-time context pack (V4.R04 / sessions-start-knowing) can never
@@ -516,6 +552,9 @@ module.exports = {
   _resetVendorCacheForTests,
   VALID_KINDS,
   VALID_DISCIPLINES,
+  WRITABLE_DISCIPLINES,
+  DISCIPLINE_CONFIDENCE_FLOOR,
+  resolveWriteDiscipline,
   VOTABLE_TASK_STATUSES,
   TASK_FIELD_BOUNDS,
 };

package/package-lock.json

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

package/package.json

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

package/scripts/gds/backfill-disciplines.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+// scripts/gds/backfill-disciplines.js — task 1002988: give every role-less task a craft.
+//
+// WHY THIS EXISTS SEPARATELY FROM THE MIGRATION. core_247 narrows
+// tasks_discipline_check to {engineer, artist, ideator, ui} and carries a
+// last-resort `UPDATE ... SET discipline='engineer'` so a fresh install can never
+// be blocked on a human remembering to run a script. But that net is a blunt
+// guess. The real classification is classifyTaskDiscipline() — a JS heuristic over
+// title + description + touches that SQL cannot express — so the good pass runs
+// here, first, and the migration only catches what is left.
+//
+// Run this BEFORE deploying core_247. Order matters: rows this script resolves keep
+// a reasoned craft; rows it does not are parked on 'engineer' by the migration.
+//
+// USAGE
+//   node scripts/gds/backfill-disciplines.js              # dry run — the spot-check list
+//   node scripts/gds/backfill-disciplines.js --apply      # commit the PATCHes
+//   node scripts/gds/backfill-disciplines.js --sample 40  # widen the printed sample
+//
+// The dry run is the default on purpose: the task required a spot-check list for the
+// owner BEFORE anything was applied, and 1,189 rows is not a diff anyone reviews in
+// their head.
+
+'use strict';
+
+const { cliClient, requireSession } = require('./cli-lib');
+const { resolveWriteDiscipline, WRITABLE_DISCIPLINES } = require('../../modules/lifecycle/task-classifier.js');
+
+// Rows whose title marks them as test debris. The classifier already skips these
+// (they are not real work), but they still carry 'unclassified' and therefore still
+// violate the narrowed constraint — so they must be resolved, not skipped, or the
+// migration's net silently becomes the thing that handles 164 rows.
+const SMOKE_RE = /__smoke__/;
+
+// The fallback for anything the heuristic refuses. Stated as a constant with its
+// reasoning rather than inlined, because this value is a GUESS and every report
+// below labels it as one.
+const FALLBACK = 'engineer';
+
+function classify(task) {
+  const resolved = resolveWriteDiscipline({
+    title: task.title, description: task.description, touches: task.touches,
+  });
+  if (resolved.discipline) {
+    return { discipline: resolved.discipline, reasoned: true, confidence: resolved.confidence ?? null };
+  }
+  return { discipline: FALLBACK, reasoned: false, confidence: null };
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// PATCH one row, WAITING OUT the per-session rate limit rather than counting it as a
+// failure. The first run of this backfill treated a 429 as a failed row and stopped
+// having written 120 of 1,189 — the limiter was doing its job and the script was
+// reading "slow down" as "no". The server tells us how long to wait; honour it.
+// Re-running is safe either way: the query only returns rows still unclassified.
+async function patchWithBackoff(api, id, discipline, maxAttempts = 6) {
+  for (let attempt = 1; ; attempt += 1) {
+    const res = await api.tasks.patchTasksId({ id, body: { discipline } });
+    if (res.status !== 429 || attempt >= maxAttempts) return res;
+    const retryAfter = Number(res.data?.error?.details?.retry_after_seconds);
+    const waitMs = (Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : 2 ** attempt) * 1000;
+    console.log(`    rate limited — waiting ${Math.round(waitMs / 1000)}s (attempt ${attempt}/${maxAttempts - 1})`);
+    await sleep(waitMs + 500);
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const apply = args.includes('--apply');
+  const sampleIdx = args.indexOf('--sample');
+  const sampleSize = sampleIdx >= 0 ? Number(args[sampleIdx + 1]) || 20 : 20;
+
+  await requireSession();
+  const api = await cliClient();
+
+  const r = await api.tasks.getTasks({ query: { discipline: 'unclassified' } });
+  if (!r.ok) {
+    console.error(`failed to read tasks (${r.status}):`, r.data);
+    process.exit(1);
+  }
+  const tasks = r.data?.tasks || [];
+  if (!tasks.length) {
+    console.log('Nothing to do — no task carries discipline=unclassified.');
+    return;
+  }
+
+  const plan = tasks.map((t) => ({ task: t, ...classify(t), smoke: SMOKE_RE.test(t.title || '') }));
+  const reasoned = plan.filter((p) => p.reasoned);
+  const guessed = plan.filter((p) => !p.reasoned);
+  const byDiscipline = {};
+  for (const p of plan) byDiscipline[p.discipline] = (byDiscipline[p.discipline] || 0) + 1;
+
+  console.log(`\n${apply ? 'Applying' : 'DRY RUN —'} discipline backfill over ${plan.length} role-less task(s)\n`);
+  console.log('  Resolved by the classifier (a reasoned answer):');
+  for (const [d, n] of Object.entries(byDiscipline).sort((a, b) => b[1] - a[1])) {
+    const reasonedN = reasoned.filter((p) => p.discipline === d).length;
+    console.log(`    ${d.padEnd(12)} ${String(reasonedN).padStart(5)}`);
+  }
+  console.log(`\n  BEST GUESS (classifier refused → ${FALLBACK}): ${guessed.length}`);
+  console.log(`    of which __smoke__ test debris:            ${guessed.filter((p) => p.smoke).length}`);
+  console.log('    These are NOT determined answers. A later reader must not treat');
+  console.log('    them as evidence that anyone classified the row (owner decision 2026-09-17).\n');
+
+  console.log(`  Spot-check sample — reasoned (first ${sampleSize}):`);
+  for (const p of reasoned.slice(0, sampleSize)) {
+    console.log(`    ${p.discipline.padEnd(9)} ${p.confidence != null ? `(${p.confidence.toFixed(2)})` : '      '}  ${String(p.task.title).slice(0, 72)}`);
+  }
+  console.log(`\n  Spot-check sample — GUESSED (first ${sampleSize}):`);
+  for (const p of guessed.filter((x) => !x.smoke).slice(0, sampleSize)) {
+    console.log(`    ${p.discipline.padEnd(9)}          ${String(p.task.title).slice(0, 72)}`);
+  }
+
+  if (!apply) {
+    console.log(`\nDry run — nothing was written. Re-run with --apply to commit.\n`);
+    return;
+  }
+
+  let ok = 0;
+  const failures = [];
+  for (const p of plan) {
+    const res = await patchWithBackoff(api, p.task.id, p.discipline);
+    if (res.ok) ok += 1;
+    else failures.push({ id: p.task.id, status: res.status, detail: JSON.stringify(res.data).slice(0, 160) });
+    if (ok % 100 === 0 && res.ok) console.log(`  … ${ok}/${plan.length}`);
+  }
+  console.log(`\nApplied: ${ok}/${plan.length}`);
+  if (failures.length) {
+    console.log(`Failed:  ${failures.length}`);
+    for (const f of failures.slice(0, 20)) console.log(`   #${f.id} → ${f.status} ${f.detail}`);
+    process.exitCode = 1;
+  }
+  // Report the residue against the same query, so the number quoted afterwards is
+  // measured rather than assumed.
+  const after = await api.tasks.getTasks({ query: { discipline: 'unclassified' } });
+  const left = after.ok ? (after.data?.tasks || []).length : null;
+  console.log(`Remaining unclassified: ${left == null ? '(re-read failed)' : left}`);
+}
+
+if (require.main === module) {
+  main().catch((e) => { console.error(e && e.message ? e.message : e); process.exit(1); });
+}
+
+module.exports = { classify, FALLBACK, SMOKE_RE };

package/scripts/gds/fitness-ratchets.js

@@ -197,14 +197,65 @@ function docMetrics() {
 
 // ---------- knip (CI-only, fail-open on infra) ----------
 
+// WHY A LOCAL knip IS REQUIRED BEFORE SCORING (task 1003987).
+//
+// `npx --no-install` does not only look in THIS project: it walks up the directory
+// tree. A git worktree has no node_modules of its own, so the lookup climbs out and
+// finds the main checkout's copy — the command succeeds, and the number it produces is
+// wrong in a specific, repeatable way.
+//
+// MEASURED, not inferred, on 2026-09-17 against one tree:
+//   main checkout (knip local)   -> 221
+//   worktree      (knip ambient) -> 222, the extra being `binaries: package.json knip`
+// Diffed by name, the exports lists were IDENTICAL (221 both sides). knip was
+// reporting ITSELF as an unlisted binary, because from the worktree's point of view it
+// is not a declared dependency of anything resolvable.
+//
+// So the ratchet failed CLOSED on a phantom: 222 > baseline 221, on a tree whose real
+// findings had not moved. That cost a full elimination pass on task 1003848, where the
+// count was the loudest signal pointing away from the actual defect.
+//
+// This module's contract is fail-OPEN on infrastructure and fail-CLOSED on findings.
+// A count measured through an ambient knip is an infrastructure artefact, not a
+// finding, so it must not be scored at all. CI is unaffected: `npm ci` puts knip in
+// the project's own node_modules, which is exactly what this checks for.
+//
+// The row also offered "compare findings by NAME" as the fuller cure. That is a
+// baseline-format change (one integer today) and is deliberately NOT done here; naming
+// the unresolvable case is the "at minimum" it asked for, and it removes the false
+// failure without pretending the count is now environment-proof.
+function localKnipPath() {
+  for (const rel of ['node_modules/knip/package.json', 'node_modules/.bin/knip']) {
+    const p = path.join(ROOT, rel);
+    try { if (fs.existsSync(p)) return p; } catch { /* unreadable → treat as absent */ }
+  }
+  return null;
+}
+
+// Why the last knip score was skipped, or null when it was scored. Module-scoped so
+// the caller can NAME the cause instead of printing one generic line for every
+// unrelated reason knip might not run.
+let knipSkipReason = null;
+function lastKnipSkipReason() { return knipSkipReason; }
+
 function knipIssueCount() {
+  knipSkipReason = null;
+  if (!localKnipPath()) {
+    // Not "knip is missing" — an ambient one may well run. The point is that its
+    // answer is not comparable to the baseline, which was measured with a local one.
+    knipSkipReason = `no knip in ${path.join(ROOT, 'node_modules')} — `
+      + 'npx would resolve one from outside this tree and report it as an unlisted '
+      + 'binary, scoring one higher than the same code scores in CI (task 1003987)';
+    return null;
+  }
   let raw;
   try {
     raw = execSync('npx --no-install knip --reporter json --no-exit-code', {
       cwd: ROOT, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'],
     });
   } catch (e) {
-    if (e && e.stdout) raw = e.stdout.toString(); else return null; // knip unavailable → skip
+    if (e && e.stdout) { raw = e.stdout.toString(); }
+    else { knipSkipReason = `npx knip failed to run in ${ROOT}`; return null; }
   }
   try {
     const j = JSON.parse(raw);
@@ -219,6 +270,7 @@ function knipIssueCount() {
     }
     return files + items;
   } catch {
+    knipSkipReason = 'knip produced output this script could not parse as JSON';
     return null;
   }
 }
@@ -426,7 +478,10 @@ function main() {
   if (knipOnly) {
     const value = knipIssueCount();
     if (value === null) {
-      console.warn('fitness-ratchets: WARN — knip not runnable here (no node_modules / npx failure); failing OPEN.');
+      // Name WHY (task 1003987). "not runnable here" sent readers looking for a
+      // broken install when the real answer was that the number would have been
+      // wrong — a different problem with a different fix.
+      console.warn(`fitness-ratchets: WARN — knip not scored: ${lastKnipSkipReason() || 'knip unavailable'}; failing OPEN.`);
       process.exit(0);
     }
     const { metrics: knipBaselines, error: knipBaselineError } = readBaselines();
@@ -466,6 +521,8 @@ module.exports = {
   consoleCallCount,
   isServerPath,
   knipIssueCount,
+  localKnipPath,
+  lastKnipSkipReason,
   OVERSIZE_LINES,
   WINDOW,
   BASELINE_PATH,

package/scripts/gds/init.js

@@ -763,7 +763,12 @@ async function seedViaApi(spec, { dryRun, log = console.log, api = apiCall } = {
   // 2. starter task(s) — linked to the first goal so /status rolls them up
   let created = 0;
   for (const t of starters) {
-    if (await postTask(t, { kind: t.kind || 'unclassified', discipline: undefined, criterion_ids: [criterionId] })) created++;
+    // task 1002988: `discipline: undefined` used to sit in this extras object, and
+    // because `...extra` spreads AFTER postTask's own `t.discipline || 'engineer'`
+    // it clobbered that default back to nothing — which is why a freshly scaffolded
+    // instance was born with role-less starter tasks. Dropped, so starters inherit
+    // the same default every other seeded task already got.
+    if (await postTask(t, { kind: t.kind || 'unclassified', criterion_ids: [criterionId] })) created++;
   }
   // 3. kickoff steps as tracked tasks
   for (const t of kickoff) {

package/scripts/gds/triage.js

@@ -59,6 +59,7 @@ const readline = require('node:readline');
 const fs = require('node:fs');
 const { cliClient, requireSession } = require('./cli-lib');
 const { resolveDefaultVersion } = require('./version-select.js');
+const { resolveWriteDiscipline } = require('../../modules/lifecycle/task-classifier.js');
 
 function prompt(rl, question) {
   return new Promise((resolve) => rl.question(question, (a) => resolve(a)));
@@ -276,6 +277,12 @@ async function createTask({ versionId, title, description, priority, sourceRef,
     priority: priority ?? null,
     source: 'idea_inbox',
     source_ref: sourceRef ?? null,
+    // task 1002988: the server now refuses a task whose craft it cannot infer, and
+    // a 400 in the middle of an interactive triage loop would cost the operator the
+    // promotion they just decided on. So resolve it here with the SAME function the
+    // server uses, and name a fallback rather than letting the loop break — the
+    // identical trade modules/ideas/inbox.js makes for capture.
+    discipline: resolveWriteDiscipline({ title, description }).discipline || 'engineer',
   };
   if (goalId == null) {
     throw new Error('createTask: goal_id is required — every task belongs to a goal (task 1003598 deleted the catch-all fallback).');

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.842'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.843'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/knip_ratchet_ambient.mjs

@@ -0,0 +1,101 @@
+// tests/knip_ratchet_ambient.mjs — the knip ratchet refuses to score through an
+// ambient knip, instead of failing CLOSED on a number it cannot compare (task 1003987).
+//
+// THE DEFECT. `npx --no-install` walks UP the directory tree. A git worktree has no
+// node_modules of its own, so the lookup climbs out to the main checkout and succeeds —
+// and knip, unable to resolve itself as a declared dependency of the tree it is
+// scanning, reports ITSELF as an unlisted binary.
+//
+// MEASURED on one tree, 2026-09-17:
+//   main checkout (knip local)   -> 221, PASS
+//   worktree      (knip ambient) -> 222, FAIL against baseline 221
+// The extra was `binaries: package.json knip`. Diffed BY NAME the exports lists were
+// identical — 221 both sides. Nothing about the code had moved.
+//
+// That false red cost a full elimination pass on task 1003848: the count was the
+// loudest signal on the board and it pointed away from the real defect.
+//
+// The module's contract is fail-OPEN on infrastructure, fail-CLOSED on findings. A
+// count taken through an ambient knip is an infrastructure artefact, so it must not be
+// scored. CI is unaffected — `npm ci` puts knip in the project's own node_modules.
+//
+// Run:  node --test tests/knip_ratchet_ambient.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const ratchets = require('../scripts/gds/fitness-ratchets.js');
+const SRC = readFileSync(path.join(REPO_ROOT, 'scripts/gds/fitness-ratchets.js'), 'utf8');
+
+test('the local-knip check runs BEFORE npx, so an ambient knip is never scored', () => {
+  const fn = SRC.slice(SRC.indexOf('function knipIssueCount()'));
+  const body = fn.slice(0, fn.indexOf('\n}\n'));
+  const guard = body.indexOf('localKnipPath()');
+  const spawn = body.indexOf('execSync(');
+  assert.ok(guard > 0 && spawn > 0, 'both the guard and the spawn must be present');
+  assert.ok(guard < spawn,
+    'checking after spawning would score the ambient count first — the whole bug');
+});
+
+test('it returns null (skip) rather than a number when knip is not local', () => {
+  // The fail direction matters: a number here is compared against a baseline measured
+  // with a LOCAL knip, so returning one is worse than returning nothing.
+  const fn = SRC.slice(SRC.indexOf('function knipIssueCount()'));
+  const body = fn.slice(0, fn.indexOf('\n}\n'));
+  assert.match(body, /if \(!localKnipPath\(\)\)[\s\S]{0,600}return null;/,
+    'the unresolvable case must skip, not score');
+});
+
+test('the skip NAMES its cause — a generic line sent readers hunting a broken install', () => {
+  assert.equal(typeof ratchets.lastKnipSkipReason, 'function');
+  ratchets.knipIssueCount();
+  const reason = ratchets.lastKnipSkipReason();
+  // In this repo the test runs where knip IS local (CI, main checkout), so the reason
+  // is null; where it is NOT local the reason must be specific. Assert whichever case
+  // this machine is in, so the test is meaningful on both.
+  if (ratchets.localKnipPath()) {
+    assert.equal(reason, null, 'a scored run must not claim it was skipped');
+  } else {
+    assert.ok(reason && /knip/i.test(reason), 'the skip must say what was missing');
+    assert.match(reason, /node_modules/, 'and where it looked');
+  }
+});
+
+test('localKnipPath finds a knip that IS local, and reports none when it is not', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'knipprobe-'));
+  try {
+    // The predicate is about THIS repo's root, so prove it against the real answer
+    // rather than a reimplementation: it must agree with the filesystem.
+    const expected = ['node_modules/knip/package.json', 'node_modules/.bin/knip']
+      .some((rel) => fs.existsSync(path.join(REPO_ROOT, rel)));
+    assert.equal(!!ratchets.localKnipPath(), expected,
+      'localKnipPath must agree with what is actually on disk');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test('the caller fails OPEN on a skip — an unscorable metric is not a violation', () => {
+  assert.match(SRC, /knip not scored: \$\{lastKnipSkipReason\(\)/,
+    'the warning must carry the specific reason');
+  const warnIdx = SRC.indexOf('knip not scored:');
+  const after = SRC.slice(warnIdx, warnIdx + 300);
+  assert.match(after, /process\.exit\(0\)/,
+    'a skip must exit 0 — failing closed here is what this task removed');
+});
+
+test('a REAL regression still fails closed — the fix narrows nothing', () => {
+  // Guard against "fixed" by making the whole metric advisory.
+  const knipOnly = SRC.slice(SRC.indexOf('if (knipOnly)'));
+  const block = knipOnly.slice(0, knipOnly.indexOf('return;'));
+  assert.match(block, /violations\.length/, 'violations must still be evaluated');
+  assert.match(block, /process\.exit\(1\)/, 'and still fail the gate when present');
+});

package/tests/rank_floor_wiring.mjs

@@ -52,6 +52,10 @@ async function createdFloor({ scopeModules, needsMigration = false, requiresRank
   await createTask({
     versionId: 'BONGOS-V2',
     title: 'a task',
+    // Stated rather than inferred (task 1002988): createTask now refuses a craft it
+    // cannot work out, and "a task" says nothing. This fixture is about the RANK
+    // FLOOR, so it should not be at the mercy of the discipline heuristic.
+    discipline: 'engineer',
     goalId: '1000111',
     needsMigration,
     requiresRank,

package/tests/reward_gate.mjs

@@ -210,7 +210,7 @@ async function withStubbedCreatePool(run) {
 
 t('a task CREATED with NO reward is born with a positive, capped value', async () => {
   await withStubbedCreatePool(async (captured) => {
-    const row = await db.createTask({ versionId: 1, goalId: 77, title: 't', kind: 'feature', estMinutes: 40 });
+    const row = await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', kind: 'feature', estMinutes: 40 });
     assert.ok(captured.creditsReward > 0, 'INSERT must bind a positive credits_reward');
     assert.equal(captured.creditsReward, 40, 'feature @40min -> 40 drachmae');
     assert.ok(captured.creditsReward <= db.REWARD_SUGGESTION_CAP, 'must respect the cap');
@@ -220,7 +220,7 @@ t('a task CREATED with NO reward is born with a positive, capped value', async (
 
 t('a task CREATED with credits_reward 0 (the route default) is auto-assigned', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', creditsReward: 0, kind: 'bug', estMinutes: 40 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', creditsReward: 0, kind: 'bug', estMinutes: 40 });
     // bug weight 1.25 -> 50; 0 is treated as "unset" so the default kicks in.
     assert.equal(captured.creditsReward, 50);
   });
@@ -228,14 +228,14 @@ t('a task CREATED with credits_reward 0 (the route default) is auto-assigned', a
 
 t('a huge-est new task is CAPPED at creation, not ballooned', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', kind: 'feature', estMinutes: 9999 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', kind: 'feature', estMinutes: 9999 });
     assert.equal(captured.creditsReward, db.REWARD_SUGGESTION_CAP);
   });
 });
 
 t('an EXPLICIT positive credits_reward is PRESERVED (never overridden)', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', creditsReward: 17, kind: 'feature', estMinutes: 40 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', creditsReward: 17, kind: 'feature', estMinutes: 40 });
     assert.equal(captured.creditsReward, 17, 'author-set positive value must survive untouched');
   });
 });

package/tests/task_discipline_required.mjs

@@ -0,0 +1,163 @@
+// tests/task_discipline_required.mjs — task 1002988: every task row carries a craft.
+//
+// The thing under test is mostly an ABSENCE: that 'unclassified' can no longer be
+// written, by any vector, and that the DB constraint no longer accepts it. A suite
+// that only proved the four valid values work would have passed before this task and
+// will pass again once the guard rots, so each block below pins the refusal.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const classifier = require(path.join(ROOT, 'modules', 'lifecycle', 'task-classifier.js'));
+const { resolveWriteDiscipline, WRITABLE_DISCIPLINES, VALID_DISCIPLINES } = classifier;
+
+// --- the writable set -------------------------------------------------------
+
+test('the writable set is the four crafts — ui included, unclassified excluded', () => {
+  // FOUR, not three. The task was written 2026-08-16 naming three; ADR 0272
+  // (2026-09-09) keeps `ui` as a module-contributed discipline and the owner
+  // reconfirmed it on 2026-09-17 when abandoning task 1002987. Narrowing to three
+  // would break live ui rows — the backfill found 3 of them by classification alone.
+  assert.deepEqual([...WRITABLE_DISCIPLINES].sort(), ['artist', 'engineer', 'ideator', 'ui']);
+  assert.ok(!WRITABLE_DISCIPLINES.has('unclassified'), 'unclassified is a triage state, not a craft');
+});
+
+test('the READ set still carries unclassified, so old rows and filters resolve', () => {
+  // The two sets are deliberately different. Collapsing them would break the
+  // ?discipline=unclassified query the backfill itself reads through.
+  assert.ok(VALID_DISCIPLINES.has('unclassified'));
+});
+
+// --- resolveWriteDiscipline -------------------------------------------------
+
+test('an explicit valid discipline is honoured verbatim', () => {
+  for (const d of WRITABLE_DISCIPLINES) {
+    assert.deepEqual(resolveWriteDiscipline({ discipline: d, title: 'anything' }), { discipline: d });
+  }
+});
+
+test('an omitted discipline is INFERRED, and reports that it was', () => {
+  const r = resolveWriteDiscipline({ title: 'Refactor the database migration script' });
+  assert.equal(r.discipline, 'engineer');
+  assert.equal(r.inferred, true, 'the caller must be able to tell a guess from a statement');
+  assert.ok(r.confidence >= 0.5);
+});
+
+test('an explicit "unclassified" is treated as no answer at all, not as a value', () => {
+  // modules/ideas/inbox.js sent this literal string on every promotion. If it were
+  // honoured as a value, the create path would still mint the rows this task removes.
+  const r = resolveWriteDiscipline({ discipline: 'unclassified', title: 'Refactor the database migration script' });
+  assert.equal(r.discipline, 'engineer');
+  assert.equal(r.inferred, true);
+});
+
+test('an unclassifiable task is REFUSED, not filed under a filler value', () => {
+  const r = resolveWriteDiscipline({ title: 'asdf' });
+  assert.equal(r.discipline, undefined);
+  assert.equal(r.error, 'bad_discipline');
+  assert.equal(r.unclassifiable, true, 'the caller must be able to say WHY, to write a useful message');
+});
+
+test('a bogus discipline is refused, and is NOT reported as unclassifiable', () => {
+  const r = resolveWriteDiscipline({ discipline: 'wizard', title: 'Refactor the database migration script' });
+  assert.equal(r.error, 'bad_discipline');
+  assert.ok(!r.unclassifiable, 'the text was fine — the caller named a craft that does not exist');
+});
+
+// --- createTask: the single chokepoint --------------------------------------
+// Every create vector passes through here, including the ones that never touch an
+// HTTP route (idea promotion, copy-desk, newcomer-restock, kickoff-seed, cascade).
+// Fixing only the routes would have left those minting role-less rows.
+
+function recordingPool(captured) {
+  return {
+    query: async (text, params) => {
+      if (/^\s*INSERT INTO tasks/i.test(text)) {
+        captured.push({ text, params });
+        return { rows: [{ id: 1, discipline: params[params.findIndex(() => false)] }] };
+      }
+      return { rows: [{ id: 1 }] };
+    },
+  };
+}
+
+test('createTask REFUSES a task whose craft it cannot infer', async () => {
+  process.env.NODE_ENV = 'test';
+  const { createTask } = require(path.join(ROOT, 'modules', 'lifecycle', 'db-tasks.js'));
+  const captured = [];
+  await assert.rejects(
+    () => createTask({ versionId: 'V1', title: 'asdf', goalId: 1 }, { pool: recordingPool(captured) }),
+    (e) => e.code === 'BAD_DISCIPLINE' && e.unclassifiable === true,
+    'an unclassifiable create must throw, not default',
+  );
+  assert.equal(captured.length, 0, 'nothing may be inserted when the craft is unknown');
+});
+
+test('createTask no longer has an "unclassified" default to fall back on', () => {
+  // The default was the whole mechanism: 1,189 rows accumulated because it was quiet.
+  // Pinned as source text because the behavioural test above can only prove the
+  // refusal, not that the default is gone rather than merely unreachable.
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'lifecycle', 'db-tasks.js'), 'utf8');
+  assert.ok(!/^\s*discipline = 'unclassified',\s*$/m.test(src),
+    "createTask must not default discipline to 'unclassified'");
+});
+
+// --- the migration: the absence is the thing under test ---------------------
+
+test('core_247 narrows the CHECK to the four crafts and REJECTS unclassified', () => {
+  const sql = fs.readFileSync(path.join(ROOT, 'migrations', 'core_247_discipline_required.sql'), 'utf8');
+  const m = sql.match(/CHECK \(discipline IN \(([^)]*)\)\)/);
+  assert.ok(m, 'the migration must re-add a discipline CHECK constraint');
+  const accepted = m[1].split(',').map((s) => s.trim().replace(/'/g, '')).sort();
+  assert.deepEqual(accepted, ['artist', 'engineer', 'ideator', 'ui'],
+    'the accepted set must match WRITABLE_DISCIPLINES exactly');
+  assert.ok(!accepted.includes('unclassified'), 'the whole point: the constraint rejects it');
+  // The net that makes the migration safe on a checkout where nobody ran the script.
+  assert.match(sql, /UPDATE tasks SET discipline = 'engineer'[\s\S]*?WHERE discipline = 'unclassified'/,
+    'the migration must resolve residual rows itself, not assume a script was run');
+});
+
+test('the migration constraint and the code agree on the accepted set', () => {
+  // Two places state the vocabulary; a drift between them is a 500 at write time
+  // (code accepts a value the DB rejects) or dead validation (the reverse).
+  const sql = fs.readFileSync(path.join(ROOT, 'migrations', 'core_247_discipline_required.sql'), 'utf8');
+  const accepted = sql.match(/CHECK \(discipline IN \(([^)]*)\)\)/)[1]
+    .split(',').map((s) => s.trim().replace(/'/g, '')).sort();
+  assert.deepEqual(accepted, [...WRITABLE_DISCIPLINES].sort());
+});
+
+// --- the create vectors that must keep working ------------------------------
+// Acceptance 6: prove it per path, not in aggregate.
+
+test('every direct createTask call site names a discipline or resolves one', () => {
+  const sites = [
+    ['modules/ideas/inbox.js', /discipline: \(lifecycle\.resolveWriteDiscipline/],
+    ['modules/copy-desk/routes/copy-desk.js', /discipline: 'artist'/],
+    ['modules/onboarding/newcomer-restock.js', /^\s*discipline,\s*$/m],
+    ['modules/lifecycle/kickoff-seed.js', /discipline: t\.discipline \|\| 'engineer'/],
+    ['modules/lifecycle/cascade.js', /discipline: rule\.discipline/],
+    ['scripts/gds/triage.js', /discipline: resolveWriteDiscipline\(/],
+  ];
+  for (const [rel, re] of sites) {
+    const src = fs.readFileSync(path.join(ROOT, rel), 'utf8');
+    assert.match(src, re, `${rel} must supply a discipline — createTask now throws without one`);
+  }
+});
+
+test('init.js no longer clobbers its own discipline default with undefined', () => {
+  // The spread ran AFTER `t.discipline || 'engineer'`, so `discipline: undefined` in
+  // the extras object reset it to nothing — which is why a freshly scaffolded
+  // instance was born with role-less starter tasks.
+  // Comment lines are stripped first: the fix's own explanation names the old
+  // expression, and a scan that cannot tell code from prose would either fail here
+  // forever or be "fixed" by deleting the explanation.
+  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'init.js'), 'utf8')
+    .split('\n').filter((l) => !/^\s*(\/\/|\*|\/\*)/.test(l)).join('\n');
+  assert.ok(!/discipline: undefined/.test(src), 'a later spread must not undo the default');
+  assert.match(src, /discipline: t\.discipline \|\| 'engineer'/);
+});

package/tests/task_goal_required.mjs

@@ -47,13 +47,13 @@ const permissivePool = {
 
 test('a create with no goalId THROWS instead of quietly filing into a bucket', async () => {
   await assert.rejects(
-    () => createTask({ versionId: 'BONGOS-V1', title: 't' }, { pool: permissivePool }),
+    () => createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'engineer' }, { pool: permissivePool }),
     /goalId is required/,
     'the old behaviour was to succeed and say nothing');
 });
 
 test('the error tells the caller both ways out', async () => {
-  const err = await createTask({ versionId: 'BONGOS-V1', title: 't' }, { pool: permissivePool })
+  const err = await createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'engineer' }, { pool: permissivePool })
     .then(() => null, (e) => e);
   assert.ok(err, 'must reject');
   assert.match(err.message, /BV1\.R11/, 'names the rule, so the reason is findable');
@@ -63,7 +63,7 @@ test('the error tells the caller both ways out', async () => {
 test('only a literal true opts in — a truthy value still throws', async () => {
   for (const v of [1, 'yes', {}, 'true']) {
     await assert.rejects(
-      () => createTask({ versionId: 'BONGOS-V1', title: 't', allowCatchAll: v }, { pool: permissivePool }),
+      () => createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'engineer', allowCatchAll: v }, { pool: permissivePool }),
       /goalId is required/,
       `${JSON.stringify(v)} must not open the hatch`);
   }
@@ -73,7 +73,7 @@ test('naming a goal needs no flag at all', async () => {
   // The ordinary path must stay ordinary: a caller with a goal never learns this
   // parameter exists.
   await createTask(
-    { versionId: 'BONGOS-V1', title: 't', goalId: 77 },
+    { versionId: 'BONGOS-V1', title: 't', discipline: 'engineer', goalId: 77 },
     { pool: permissivePool, client: permissivePool },
   );
 });