@bongos/core 1.19.637 → 1.19.639

package/scripts/gds/discipline-modes.json

@@ -1,26 +1,26 @@
 {
-  "_doc": "Discipline -> operating-playbook map (task 1267). A discipline whose work is best done as a *mode of working* rather than the default claim->build->ship loop names the skill that IS its playbook here. claim.js reads this after a successful claim: if the claimed task's `discipline` has an entry, it prints the entry's `directive` so the session opens the right playbook. There is NO classification step at claim time — `discipline` is already a column on the task. This is the whole discipline-fork mechanism: one carrier (the claim the builder already runs), one data lookup, no hooks, the Conductor untouched. Absence of an entry is the default: engineer and artist are intentionally NOT listed, so their claim output is unchanged and they stay in the standard build-and-ship loop. To give a discipline its own experience later, add an entry here and write the skill — no code change in claim.js. A missing or invalid version of this file must never break a claim (claim.js fails open). A mode entry may also set `\"materializeModuleSkills\": true` to have the claim land that mode's module-owned skills into this checkout's .claude/skills/ (task 1003486) — opt-in per discipline, core-checkout only, and fail-open like the hint itself, so a discipline that omits it claims exactly as before.",
+  "_doc": "The ROLE REGISTRY: discipline -> the operating playbook that craft works from (task 1267; reshaped by task 1002990). Since the kernel/pack split, a CORE craft names a `pack` — a markdown role pack under docs/packs/ that carries everything the root CLAUDE.md kernel deliberately does not, because it is true for one craft only. A module-contributed discipline may instead name a `skill` (a slash-command playbook under .claude/skills/), which is how `ui` -> /design still works (ADR 0272 keeps ui-design's contribution unchanged). An entry may carry both; it must carry at least one. claim.js reads this after a successful claim and prints the entry's `directive` plus its pack path, so the session opens the right playbook. There is NO classification step at claim time — `discipline` is already a column on the task. One carrier (the claim the builder already runs), one data lookup, no hooks, the Conductor untouched. A missing or invalid version of this file must never break a claim (claim.js fails open) — but fitness.js DOES hard-fail CI when an entry names a pack that is not in the tree, so the fail-open runtime cannot hide a broken registry from the build. GOVERNOR IS DEFERRED: three packs, not four, until the owner decides (criterion wa6-kernel-and-packs). A mode entry may also set \"materializeModuleSkills\": true to have the claim land that mode's module-owned skills into this checkout's .claude/skills/ (task 1003486) — opt-in per discipline, core-checkout only, and fail-open like the hint itself.",
   "modes": {
     "engineer": {
-      "skill": "dev",
+      "pack": "docs/packs/engineer.md",
       "label": "Engineering session",
-      "directive": "This is an ENGINEER task. /dev is its operating playbook — the standard build loop, written down: understand the code before editing -> make the smallest correct, scoped change -> VERIFY it (smoke tests + the preview/verification workflow when observable) -> /builder-ship with real notes. Engineering is already the default way you'd work, so this is a reminder of the standard (and the autonomous-mode guardrails: be conservative, verify hard, don't wander), not a redirect. Open /dev if you want the checklist or you're running autonomously."
+      "directive": "This is an ENGINEER task. Read the Engineer pack now, before working — it is the operating playbook for this craft and the only place the standard build loop is written down: understand the code before editing -> make the smallest correct, scoped change -> VERIFY it (smoke tests + the preview/verification workflow when observable) -> /builder-ship with real notes. Engineering is already the default way you'd work, so the pack is the standard made explicit (plus the autonomous-mode guardrails: be conservative, verify hard, don't wander), not a redirect."
     },
     "ideator": {
-      "skill": "ideate",
+      "pack": "docs/packs/ideator.md",
       "label": "Ideation session",
-      "directive": "This is an IDEATOR task. To work it, invoke the /ideate skill — that skill is the operating playbook for ideation, and it is the only place the experience is defined. It inverts the usual dynamic: you (the human ideator) are the creative driver and Claude is your sounding board / research arm / devil's advocate, not a content generator filing ideas on command. If no human is present (autonomous / bypass-permissions), /ideate runs a self-adversarial divergence-and-critique loop instead of dumping a fixed batch. Open /ideate now rather than working this task the default way. THE SURFACE, not just the behavior (ADR 0271): an ideator session is QUIET about its own machinery. Report outcomes, not mechanism — do not narrate tool calls, file paths, script names, API routes or task/claim bookkeeping unless they ask or something actually failed. Speak in the language of the idea, not the plumbing. If a step breaks, say plainly what broke and what you need — quiet never means hiding a problem."
+      "directive": "This is an IDEATOR task. Read the Ideator pack now and work from it — it is the operating playbook for ideation and the only place the experience is defined. It inverts the usual dynamic: you (the human ideator) are the creative driver and Claude is your sounding board / research arm / devil's advocate, not a content generator filing ideas on command. Quick ideas stay ONE LINE, and after one is filed Claude asks whether to develop it into a Full Idea — five questions, drawn out of the conversation in the ideator's own words and scored on completeness. If no human is present (autonomous / bypass-permissions), the pack runs a self-adversarial divergence-and-critique loop instead of dumping a fixed batch. THE SURFACE, not just the behavior (ADR 0271): an ideator session is QUIET about its own machinery. Report outcomes, not mechanism — do not narrate tool calls, file paths, script names, API routes or task/claim bookkeeping unless they ask or something actually failed. Speak in the language of the idea, not the plumbing. If a step breaks, say plainly what broke and what you need — quiet never means hiding a problem."
     },
     "artist": {
-      "skill": "paint",
+      "pack": "docs/packs/artist.md",
       "label": "Art session",
-      "directive": "This is an ARTIST task. To work it, invoke the /paint skill — that skill is the operating playbook for art sessions, and it is the only place the experience is defined. It is show-first / low-text: Claude communicates in pictures (display the generated tile, the /art gallery at sandbox-<login>.<instance-apex>/art, and the in-world sandbox), not paragraphs about what the pipeline did. It drives the existing pixel-art pipeline (otb-tile-generate / otb-design-review / otb-feedback-capture / art-stage.js) and keeps the locked palette + rubric sacred. If no human is present (autonomous / bypass-permissions), /paint generates, rubric-gates hard, stages passing assets to the gallery, and parks the visuals for human review. Open /paint now rather than working this task the default way; the gallery is at sandbox-<login>.<instance-apex>/art."
+      "directive": "This is an ARTIST task. Read the Artist pack now and work from it — it is the operating playbook for art sessions and the only place the experience is defined. It is show-first and low-text: communicate in pictures and rendered surfaces, not paragraphs about what ran. Interpret as little as possible — take the brief literally, you are the artist's hands and not their art director — and arrive precalculated: load the look, have the options already rendered, never open with a form of intake questions. The artist's subject is how the project LOOKS AND READS, which is core (ADR 0272); a pixel-art or asset pipeline is a host module the pack drives only when the instance ships one. If no human is present (autonomous / bypass-permissions), make it, gate it hard, stage the passes and park the visuals for human review."
     },
     "ui": {
       "skill": "design",
       "materializeModuleSkills": true,
       "label": "UI design session",
-      "directive": "This is a UI task — interface DESIGN work (layout, wireframes, design systems, Figma / Claude-Design), split out of the pixel-art `artist` lane (ADR 0079). To work it, invoke the /design skill — the operating playbook for UI-design sessions, the only place the experience is defined. Like /paint it is show-first: communicate in mock-ups and rendered screens, not paragraphs about layout decisions — stage the change on your sandbox preview (/builder-stage) and look at the real interface before shipping. Keep the locked branding (config/branding.json) and the existing component conventions of the surface you touch (modules/status-ui, modules/hall-ui, public/game/ui). If no human is present (autonomous / bypass-permissions), produce the design, stage it for review, and park the screens rather than shipping interface changes blind. Open /design now rather than working this task the default way."
+      "directive": "This is a UI task — interface DESIGN work (layout, wireframes, design systems, Figma / Claude-Design), split out of the pixel-art `artist` lane (ADR 0079) and kept as a module-contributed discipline by ADR 0272. To work it, invoke the /design skill — the operating playbook for UI-design sessions, the only place the experience is defined. Like the Artist pack it is show-first: communicate in mock-ups and rendered screens, not paragraphs about layout decisions — stage the change on your sandbox preview (/builder-stage) and look at the real interface before shipping. Keep the locked branding (config/branding.json) and the existing component conventions of the surface you touch (modules/status-ui, modules/hall-ui, public/game/ui). If no human is present (autonomous / bypass-permissions), produce the design, stage it for review, and park the screens rather than shipping interface changes blind. Open /design now rather than working this task the default way."
     }
   }
 }

package/scripts/gds/fitness.js

@@ -188,6 +188,8 @@ function checkGeneratedArtifactsFresh() {
   } catch {
     violations.push('docs/api/openapi.json + docs/api-reference.md + docs/routes-permissions.md are STALE (or the spec is not valid OpenAPI 3.1) — run `node scripts/gds/gen-api-docs.js` and commit (task 1918).');
   }
+  // NB the role packs' responsibility blocks are generated too, but their freshness
+  // is asserted by role-pack-guard.js — one check owns "the packs are correct".
   return { name: 'generated artifacts fresh', ok: violations.length === 0, hardFail: violations.length > 0, violations, warnings: [], note: 'Tracked generated content matches source: nested CLAUDE.md symbol blocks (code) + the CLAUDE.md §13 snippet (sessions) via --check-block, plus docs/file-map.md skills/scheduled-tasks sections and docs/api/openapi.json + api-reference.md (API). The gitignored docs/repo-map.md + docs/session-log-index.md are deploy-regenerated (ADR 0110), not gated here.' };
 }
 
@@ -455,6 +457,7 @@ const KERNEL_FILES = [
   'src/module-api.js',                    // the published doorway
   'src/modules.js',                       // the registry/resolver facade
   'src/module-seams.js',                  // the seam registry (ports/events/contributions)
+  'src/role-responsibilities.js',         // the owner's written role statements (task 1003732) — modules.js reads it; imports nothing
   'src/module-loader/loader.js',          // the disk loader (discover → validate → mount)
   'src/module-loader/manifest-schema.js', // the manifest validator
   'src/module-loader/semver.js',          // coreVersion compatibility
@@ -562,6 +565,7 @@ const KERNEL_NAMES_MODULES_OK = new Set([
   'src/bongos/auth-discord.js',          // the Discord account-link flow itself
   'src/bongos/permission-path-check.js', // names module path subtrees to PROTECT them
   'src/bongos/route-rank-check.js',      // names module route dirs to rank-gate them
+  'src/role-responsibilities.js',        // the ideator's VERBATIM statement reads "Make good ideas" — the English word, colliding with the `ideas` key. Owner text; unparaphrasable.
 ]);
 
 // The discovered module keys = the directory names under modules/ (a manifest's
@@ -1342,6 +1346,12 @@ function checkSkillFrontmatter() {
 const CHECKS = [
   checkCoreHostBoundary,
   checkClaudeMdBudget,
+  // Check 32 — task 1002990 / criterion wa6-kernel-and-packs: the root CLAUDE.md is
+  // now a role-neutral KERNEL and each craft's playbook lives in a pack under
+  // docs/packs/. claim.js resolves the pack through the role registry and fails
+  // OPEN, so a pack path that points at nothing is invisible at runtime — CI is the
+  // only place a hollowed-out role can be caught. Rationale in that file.
+  require('./role-pack-guard.js').checkRolePacks,
   checkSkillFrontmatter,
   checkNestedDocsPresent,
   checkRankGuards,

package/scripts/gds/gen-role-responsibilities.js

@@ -0,0 +1,134 @@
+// scripts/gds/gen-role-responsibilities.js
+//
+// WHAT. Writes each craft's written responsibility into its role pack under
+// docs/packs/, between markers, from the ONE source at src/role-responsibilities.js.
+//
+// WHY A GENERATOR AND NOT A PARAGRAPH SOMEONE TYPES. Criterion
+// wa6-written-responsibilities (goal 1000095) says there is one source "shown on
+// the profile, injected into the pack, referenced by grading". The profile and the
+// grader read the source at runtime, so they cannot drift. A markdown pack cannot
+// require a JS module, so its copy is the only one that CAN drift — and the drift
+// would be invisible and consequential: the pack is what a session is actually
+// instructed by, so a stale sentence there means the project teaches one standard,
+// shows a second on the profile, and grades against a third. This is the
+// gen-diagrams / gen-session-index pattern (ADR 0062 §8): generate the block, gate
+// its freshness in CI, never hand-edit it.
+//
+// USAGE
+//   node scripts/gds/gen-role-responsibilities.js            # write the blocks
+//   node scripts/gds/gen-role-responsibilities.js --check    # exit 2 if any block drifted (the CI gate)
+//
+// A pack with no markers is a WARNING, not a failure — a host instance may carry a
+// pack this core does not know about. A pack whose marker block is STALE is the
+// hard failure, because that is the drift the whole file exists to prevent.
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { ROLE_RESPONSIBILITIES, RESPONSIBILITIES_SOURCE } = require('../../src/role-responsibilities');
+const { resolveCoreRoot } = require('../../src/instance-config');
+
+// The packs are CORE content (they ship in the package alongside the registry that
+// names them), so resolve them against the core root the same way the role-pack
+// guard does — never the instance root.
+const CORE_ROOT = resolveCoreRoot();
+const REGISTRY_REL = 'scripts/gds/discipline-modes.json';
+
+const BEGIN = '<!-- BEGIN GENERATED ROLE RESPONSIBILITY (scripts/gds/gen-role-responsibilities.js — do not hand-edit) -->';
+const END = '<!-- END GENERATED ROLE RESPONSIBILITY -->';
+
+// The block a pack carries. Deliberately short: the pack teaches the craft, this
+// states the standard, and the provenance line is there so a reader knows the
+// sentence is the owner's and not the platform's opinion.
+function blockFor(discipline) {
+  const text = ROLE_RESPONSIBILITIES[discipline];
+  if (!text) return null;
+  const s = RESPONSIBILITIES_SOURCE;
+  return [
+    BEGIN,
+    '## What this craft is answerable for',
+    '',
+    `> ${text}`,
+    '',
+    `*The ${discipline}'s written responsibility — one source (\`src/role-responsibilities.js\`), shown on the hall profile, taught here, and referenced by the grader. Fixed by ${s.authoredBy} on ${s.authoredOn}, criterion \`${s.criterion}\`. Generated: do not hand-edit, and do not paraphrase it elsewhere.*`,
+    END,
+  ].join('\n');
+}
+
+// Replace the marked region, or report that the pack has no markers. Mirrors
+// gen-session-index.injectBlock: bounded by the two literal markers, so a pack may
+// put the block anywhere and move it later without touching this file.
+//
+// THE BLOCK TAKES THE FILE'S OWN LINE ENDING. These packs are `.md` and check out
+// CRLF on Windows while CI checks out LF. A generator that always wrote '\n' would
+// splice LF lines into a CRLF file, so the committed bytes and the bytes `--check`
+// recomputes would differ by platform — the check would be red on one checkout and
+// green on the other, for a file nobody touched. Detecting the file's ending makes
+// the generator idempotent on both.
+function inject(text, block) {
+  const i = text.indexOf(BEGIN);
+  const j = text.indexOf(END);
+  if (i === -1 || j === -1 || j < i) return null;
+  const eol = text.includes('\r\n') ? '\r\n' : '\n';
+  return text.slice(0, i) + block.replace(/\n/g, eol) + text.slice(j + END.length);
+}
+
+// Every discipline the role registry binds to a pack. Reading the registry rather
+// than hardcoding three filenames means a pack that is renamed, or a fourth craft
+// that is added later (Governor, when the owner decides), is picked up here with no
+// edit — the same single-declaration rule the registry already enforces for claim.js.
+function packTargets() {
+  const abs = path.join(CORE_ROOT, REGISTRY_REL);
+  const modes = (JSON.parse(fs.readFileSync(abs, 'utf8')) || {}).modes || {};
+  const out = [];
+  for (const [discipline, mode] of Object.entries(modes)) {
+    if (!mode || !mode.pack) continue;
+    out.push({ discipline, rel: mode.pack, abs: path.join(CORE_ROOT, mode.pack) });
+  }
+  return out;
+}
+
+function plan() {
+  const writes = [];
+  const warnings = [];
+  for (const t of packTargets()) {
+    const block = blockFor(t.discipline);
+    if (!block) {
+      // A pack whose craft has no statement is legitimate (a module-contributed
+      // craft that grew a pack). Say so; never write an empty quote into it.
+      warnings.push(`${t.rel}: no written responsibility for '${t.discipline}' — leaving the pack alone.`);
+      continue;
+    }
+    let cur;
+    try { cur = fs.readFileSync(t.abs, 'utf8'); } catch {
+      warnings.push(`${t.rel}: named by the role registry but not readable — the role-pack guard is the check that fails on this.`);
+      continue;
+    }
+    const next = inject(cur, block);
+    if (next === null) { warnings.push(`${t.rel}: no marker block — add the BEGIN/END pair to carry the statement.`); continue; }
+    if (next !== cur) writes.push({ abs: t.abs, rel: t.rel, content: next });
+  }
+  return { writes, warnings };
+}
+
+function main() {
+  const check = process.argv.includes('--check');
+  const { writes, warnings } = plan();
+  for (const w of warnings) console.error(`gen-role-responsibilities: WARN ${w}`);
+  if (check) {
+    if (writes.length) {
+      for (const w of writes) console.error(`gen-role-responsibilities: STALE ${w.rel}`);
+      console.error('Run `node scripts/gds/gen-role-responsibilities.js` and commit.');
+      process.exit(2);
+    }
+    console.log('gen-role-responsibilities --check: up to date.');
+    return;
+  }
+  for (const w of writes) fs.writeFileSync(w.abs, w.content);
+  console.log(writes.length ? `gen-role-responsibilities: wrote ${writes.length} pack(s): ${writes.map((w) => w.rel).join(', ')}` : 'gen-role-responsibilities: already up to date.');
+}
+
+if (require.main === module) main();
+
+module.exports = { BEGIN, END, blockFor, inject, packTargets, plan };

package/scripts/gds/publish-manifest.js

@@ -124,6 +124,15 @@ const PUBLISH_ALLOWLIST = [
   'docs/file-map.md',
   'docs/repo-map.md',
   'docs/handoff-template.md',         // the portable session-handoff format (methodology)
+  // The ROLE PACKS (task 1002990). docs/ is default-deny, and these are not
+  // documentation ABOUT the methodology — they ARE it: since the kernel/pack split
+  // the root CLAUDE.md is role-neutral and everything a craft actually works from
+  // lives here. scripts/gds/discipline-modes.json ships (scripts/ is allowlisted)
+  // and names these paths, so omitting them would release a core whose every claim
+  // prints a pack path that resolves to nothing on the instance — the exact silent
+  // failure scripts/gds/role-pack-guard.js exists to make loud. The registry and
+  // this line are only ever added or removed together.
+  'docs/packs/',
   'docs/canonical-permissions.md',   // the rank-ladder reference IS the methodology (sanitized)
   'docs/project-context.template.md', // the neutral scaffold `cloudbongos init` fills (NOT the OTB-filled one)
   '.claude/skills/',                 // the methodology slash-commands (hooks/settings are denied below)

package/scripts/gds/role-pack-guard.js

@@ -0,0 +1,142 @@
+// scripts/gds/role-pack-guard.js
+//
+// WHAT. The fitness check behind the kernel/pack split (task 1002990, criterion
+// wa6-kernel-and-packs): every entry in the role registry that names a `pack` must
+// point at a file that exists, and every pack must stay inside a context budget.
+//
+// WHY IT IS A HARD FAIL, when claim.js's own read is fail-open. The registry
+// (scripts/gds/discipline-modes.json) is read at claim time by code that must never
+// break a granted claim, so a pack path that points at nothing degrades to silence:
+// the builder is told their craft's label and nothing else, and the playbook that
+// was supposed to carry everything the role-neutral kernel dropped never loads. That
+// failure is invisible at runtime by design. CI is therefore the only place it can
+// be caught, which is exactly the split the criterion asks for — "CI budgets each
+// pack" — and why a renamed or deleted pack must red the build rather than quietly
+// hollow out a role.
+//
+// WHY A BUDGET AT ALL. A pack is loaded in full whenever someone works that craft,
+// so it costs the same per-session tokens the root CLAUDE.md does (ADR 0061, the
+// context-rot argument). The kernel got a budget when it was the only always-loaded
+// file; the packs inherit the same discipline now that they carry half its content.
+// The ceilings are advisory-then-hard in the same shape checkClaudeMdBudget uses:
+// a target that WARNS, a ceiling that FAILS, both ratcheted down as detail relocates
+// to ADRs and recipes.
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { CORE_ROOT } = require('./fitness-lib.js');
+
+// The registry lives beside the CLI that reads it, in the CORE package — the same
+// resolution claim.js uses (path.join(__dirname, 'discipline-modes.json')), so this
+// check and the runtime always read the same file even from a scaffolded instance
+// whose repo root is somewhere else entirely (ADR 0108).
+const REGISTRY_REL = 'scripts/gds/discipline-modes.json';
+
+// ~4 chars/token for markdown prose, the estimator checkClaudeMdBudget uses.
+const estTokens = (n) => Math.round(n / 4);
+
+// Ratcheted just above the packs as authored by task 1002990 (engineer 12,223,
+// ideator 10,218, artist 6,982 chars). Lower both as pack detail relocates to
+// ADRs and recipes — the same ratchet contract ROOT_CHAR_HARD_MAX carries.
+const PACK_CHAR_HARD_MAX = 16000; // ~4K tokens — a role pack must never balloon past this.
+const PACK_CHAR_TARGET = 13000;   // ~3.25K tokens — aspirational.
+
+function checkRolePacks(fsImpl = fs) {
+  const violations = [];
+  const warnings = [];
+  const abs = path.join(CORE_ROOT, REGISTRY_REL);
+
+  let modes;
+  try {
+    modes = (JSON.parse(fsImpl.readFileSync(abs, 'utf8')) || {}).modes || {};
+  } catch (e) {
+    // Unlike claim.js this does NOT fail open. An unreadable registry is the one
+    // state that makes every other assertion here vacuous, so it is the failure.
+    return {
+      name: 'role registry packs resolve + fit their budget',
+      ok: false,
+      hardFail: true,
+      violations: [`${REGISTRY_REL} could not be read or parsed (${e && e.message}) — claim.js reads this file on every claim and fails open, so a broken registry is silent at runtime and can only be caught here.`],
+      warnings: [],
+      note: 'the role registry could not be read.',
+    };
+  }
+
+  const entries = Object.entries(modes);
+  let packCount = 0;
+  const sizes = [];
+
+  for (const [discipline, mode] of entries) {
+    if (!mode || typeof mode !== 'object') {
+      violations.push(`role registry entry '${discipline}' is not an object — every entry must carry a directive plus a pack or a skill.`);
+      continue;
+    }
+    // An entry with neither pointer routes a claim nowhere: claim.js prints the
+    // label and the session is left to guess its own playbook.
+    if (!mode.pack && !mode.skill) {
+      violations.push(`role registry entry '${discipline}' names neither a 'pack' (docs/packs/<craft>.md) nor a 'skill' — a claim of this discipline would be routed to no playbook at all.`);
+    }
+    if (!mode.pack) continue;
+
+    packCount += 1;
+    const packAbs = path.join(CORE_ROOT, mode.pack);
+    if (!fsImpl.existsSync(packAbs)) {
+      violations.push(`role registry entry '${discipline}' points at '${mode.pack}', which is not in the tree — claim.js would print the path and the session would find nothing there.`);
+      continue;
+    }
+    let text = '';
+    try {
+      text = fsImpl.readFileSync(packAbs, 'utf8');
+    } catch (e) {
+      violations.push(`role registry entry '${discipline}' points at '${mode.pack}', which exists but could not be read (${e && e.message}).`);
+      continue;
+    }
+    const chars = text.length;
+    sizes.push(`${discipline} ${chars}`);
+    if (chars > PACK_CHAR_HARD_MAX) {
+      violations.push(`${mode.pack} is ${chars} chars (~${estTokens(chars)} tokens) — over the ${PACK_CHAR_HARD_MAX}-char (~${estTokens(PACK_CHAR_HARD_MAX)}-token) hard ceiling. A pack loads in full for every session of its craft; relocate detail to an ADR or a recipe (ADR 0061).`);
+    } else if (chars > PACK_CHAR_TARGET) {
+      warnings.push(`${mode.pack} is ${chars} chars (~${estTokens(chars)} tokens) — over the ~${PACK_CHAR_TARGET}-char (~${estTokens(PACK_CHAR_TARGET)}-token) target. Trim prose, then lower PACK_CHAR_TARGET.`);
+    }
+  }
+
+  // Each pack's WRITTEN-RESPONSIBILITY block must match src/role-responsibilities.js
+  // (task 1003732). It lives with the other pack assertions rather than in
+  // checkGeneratedArtifactsFresh so one check owns "the packs are correct" — and the
+  // drift matters for the same reason the missing-pack case does: the profile and
+  // the grader read the source at runtime and cannot drift, but the pack is markdown,
+  // so its copy is the only one that can — and it is the copy a SESSION is instructed
+  // by. A stale block means the project teaches one standard, shows a second on the
+  // profile, and grades against a third. Skipped when the fs is stubbed (the negative
+  // tests inject a registry that names packs this generator would not find).
+  if (fsImpl === fs) {
+    try {
+      const { plan } = require('./gen-role-responsibilities.js');
+      const { writes } = plan();
+      for (const w of writes) {
+        violations.push(`${w.rel}: the written-responsibility block is STALE against src/role-responsibilities.js — run \`node scripts/gds/gen-role-responsibilities.js\` and commit (task 1003732).`);
+      }
+    } catch (e) {
+      violations.push(`could not check the packs' written-responsibility blocks (${e && e.message}) — run \`node scripts/gds/gen-role-responsibilities.js --check\`.`);
+    }
+  }
+
+  // The split's own shape, asserted so a later edit cannot quietly drop a craft
+  // back into the kernel: three core packs, and Governor deliberately absent
+  // (criterion wa6-kernel-and-packs — "three packs, not four, until the owner decides").
+  if (packCount < 3) {
+    violations.push(`only ${packCount} craft(s) name a pack — the split is one kernel plus three packs (Engineer, Artist, Ideator). A craft with no pack has nowhere to keep what the role-neutral kernel does not.`);
+  }
+
+  return {
+    name: 'role registry packs resolve + fit their budget',
+    ok: violations.length === 0,
+    hardFail: violations.length > 0,
+    violations,
+    warnings,
+    note: `${entries.length} registry entr(ies), ${packCount} with a pack (${sizes.join(', ') || 'none'} chars) — ≤ ${PACK_CHAR_HARD_MAX} chars each, target ~${PACK_CHAR_TARGET}. A pack path that resolves to nothing is silent at claim time, so CI is the only gate.`,
+  };
+}
+
+module.exports = { checkRolePacks, PACK_CHAR_HARD_MAX, PACK_CHAR_TARGET, REGISTRY_REL };

package/src/module-api.js

@@ -41,6 +41,22 @@ const instanceConfig = require('./instance-config');
 const staleTimer = require('./stale-timer');
 const seams = require('./module-seams');
 const { buildInfo } = require('./build-info');
+// Eager and DESTRUCTURED on purpose, and inside the rule above rather than an
+// exception to it: role-responsibilities.js requires NOTHING (80 lines of the
+// owner's text plus three pure lookups), so it costs one file read and drags no
+// server file into a CLI subcommand's require-closure — the same footing as
+// `branding` and `instanceConfig` here.
+//
+// It has to be a NAMED require rather than `require(...).x` read inside a getter,
+// or CI's dead-code ratchet counts these exports as dead and no PR touching them
+// can merge — task 1003732 stranded on exactly that. `responsibilityFor`'s only
+// consumer is modules/grading/grader-prompt.js reaching through this doorway, and
+// modules/ sits outside knip's `project` globs by design, so the import HERE is
+// the only place that use can be seen. knip credits a destructured binding and
+// not a member access on a namespace object, which is why the sibling exports
+// (`responsibilitiesFor` via src/modules.js, `ROLE_RESPONSIBILITIES` via
+// scripts/gds/gen-role-responsibilities.js) were never flagged and this one was.
+const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibilities');
 
 // ---------------------------------------------------------------------------
 // CORE_VERSION — the version of THIS published surface (semver).
@@ -55,7 +71,7 @@ const { buildInfo } = require('./build-info');
 // 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.637'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.639'; // 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');
@@ -405,6 +421,19 @@ module.exports = {
   get pageMeta() { return require('./bongos/routes/_helpers').pageMeta; },
   get PAGINATION() { return require('./bongos/routes/_helpers').PAGINATION; },
 
+  // --- the written role responsibilities (task 1003732, criterion
+  //     wa6-written-responsibilities). ONE source for the sentence each craft is
+  //     answerable for; it reaches modules through the doorway because more than
+  //     one module needs the same text — grading references it when judging
+  //     role-shaped work, and the hall shows it to the person being judged — and
+  //     modules never import each other. `responsibilityFor(discipline)` returns
+  //     null for a craft with no statement (a module-contributed one, or an
+  //     unclassified task); that is a legitimate answer, not an error.
+  //     Plain entries rather than getters: the module is loaded eagerly at the
+  //     top of this file (it costs nothing), so there is nothing left to defer.
+  responsibilityFor,
+  ROLE_RESPONSIBILITIES,
+
   // --- logging
   logger,
 };

package/src/modules.js

@@ -28,6 +28,7 @@ const path = require('node:path');
 // until a module is moved into modules/ — so this is a no-op on the current tree.
 const loader = require('./module-loader/loader');
 const { resolveCoreRoot, resolveInstanceRoot } = require('./instance-config');
+const { responsibilitiesFor } = require('./role-responsibilities');
 
 // ADR 0108 §1: the neutral starter ships WITH the core package; the instance
 // pack is host content. Both resolvers return the repo root today, so this is
@@ -250,10 +251,20 @@ function enabledDisciplines(set = modules()) {
 
 // CLIENT-SAFE projection — module flags are just booleans, all safe to expose.
 // The hall/status front-ends read this to hide UI sections for off modules.
+//
+// `responsibilities` rides here (task 1003732) because this projection is already
+// injected into every served page as a global (serve-internal.injectBrandingGlobal),
+// and it already carries the discipline roster the statements are keyed by — so the
+// profile gets the owner's text with no new route, no fetch, and no second copy to
+// drift. Scoped to the disciplines this instance actually offers: a craft the
+// instance does not have must not appear in its UI, and a module-contributed craft
+// has no statement by design (src/role-responsibilities.js says why).
 function clientModules(set = modules()) {
+  const disciplines = enabledDisciplines(set);
   return {
     enabled: knownModules().reduce((o, k) => { o[k] = set[k] === true; return o; }, {}),
-    disciplines: enabledDisciplines(set),
+    disciplines,
+    responsibilities: responsibilitiesFor(disciplines),
   };
 }
 

package/src/role-responsibilities.js

@@ -0,0 +1,80 @@
+// src/role-responsibilities.js
+//
+// WHAT. The one source of each craft's written responsibility — the sentence that
+// says what a person holding that role is actually answerable for. Three consumers
+// read this file and nothing else: the hall profile shows it to the person, the
+// role pack under docs/packs/ teaches a session from it, and the grader references
+// it when it judges role-shaped work.
+//
+// WHY IT IS ONE FILE. Criterion wa6-written-responsibilities (goal 1000095) is
+// explicit that there is ONE source — "shown on the profile, injected into the
+// pack, referenced by grading" — and the reason is not tidiness. The promise made
+// to a builder on their profile and the text their session is actually held to
+// must be the same text; two copies that drift mean the project judged someone
+// against a standard it never showed them. The pack half is enforced rather than
+// promised: the packs carry a GENERATED block written by
+// scripts/gds/gen-role-responsibilities.js, and fitness.js fails CI when it drifts
+// from this file (the gen-diagrams / gen-session-index pattern, ADR 0062 §8).
+//
+// THE TEXT IS THE OWNER'S, VERBATIM. Fixed by the area owner on 2026-09-08 and
+// recorded in the criterion. Do not paraphrase, tighten, or "improve" these
+// sentences — a role's responsibility is the owner's to write, and the whole point
+// of a single source is that it says what they said. Per-project sub-specialities
+// (idea 1000733) build on this later and are deliberately not modelled here.
+//
+// KERNEL FILE. On the fitness.js KERNEL_FILES roster: three different modules read
+// it (hall-ui, grading) plus the core's own client projection, and modules never
+// import each other, so shared vocabulary has to sit in the kernel. It imports
+// nothing, which is what makes that placement free.
+'use strict';
+
+// discipline key (tasks.discipline / builders.preferred_disciplines) → the owner's
+// sentence. Keys mirror CORE_DISCIPLINES order (engineer | artist | ideator), the
+// migration 176 enum order. A module-contributed discipline (ui-design → 'ui') has
+// no statement here on purpose: a craft a module brings is that module's to
+// describe, and inventing one for it would be exactly the paraphrase this file
+// forbids. Consumers must therefore treat "no statement" as normal, not as an error.
+const ROLE_RESPONSIBILITIES = Object.freeze({
+  engineer: 'Running and optimizing the running of Claude nonstop, and ensuring Ideators and Artists can continue to interface with that system effectively.',
+  artist: 'No slop in the appearance and text of the project; the story, emotion and ideology of the project are communicated effectively; project purpose and gravitas are upheld.',
+  ideator: 'Make good ideas; be a philosopher / thought leader for the project; enable Engineers to scope and Artists to create with maximum efficiency — a baseline for creating scopes of work.',
+});
+
+// Provenance, carried with the text so every rendering can say where it came from
+// rather than looking like a platform opinion someone typed.
+const RESPONSIBILITIES_SOURCE = Object.freeze({
+  criterion: 'wa6-written-responsibilities',
+  goalId: '1000095',
+  authoredOn: '2026-09-08',
+  authoredBy: 'the area owner',
+});
+
+// The statement for one discipline, or null when the craft has none (a
+// module-contributed discipline, an unclassified task, a stray value from an older
+// row). Null is a legitimate answer every consumer must render as absence — never
+// as a blank quote or a placeholder sentence.
+function responsibilityFor(discipline) {
+  if (typeof discipline !== 'string') return null;
+  return ROLE_RESPONSIBILITIES[discipline.toLowerCase()] || null;
+}
+
+// The subset of statements an instance actually offers, so a client projection
+// never ships a craft the instance does not have. Takes the discipline roster the
+// caller already resolved (modules.enabledDisciplines()) rather than reaching for
+// the module registry itself — that would make this file import domain and cost it
+// its place on the kernel roster.
+function responsibilitiesFor(disciplines) {
+  const out = {};
+  for (const d of Array.isArray(disciplines) ? disciplines : []) {
+    const text = responsibilityFor(d);
+    if (text) out[d] = text;
+  }
+  return out;
+}
+
+module.exports = {
+  ROLE_RESPONSIBILITIES,
+  RESPONSIBILITIES_SOURCE,
+  responsibilityFor,
+  responsibilitiesFor,
+};

package/tests/edit_hints.mjs

@@ -25,7 +25,7 @@ test('each generator input maps to its generator; unrelated paths map to nothing
     ['modules/status-ui/public/index.html', 'copy-inventory.js'],
     ['src/bongos/auth.js', 'gen-repo-map.js'],
     ['modules/lifecycle/routes/claims.js', 'gen-api-docs.js'],
-    ['.claude/skills/dev/SKILL.md', 'gen-file-map.js'],
+    ['.claude/skills/status/SKILL.md', 'gen-file-map.js'],
     ['docs/session-logs/2026-09-03-x.md', 'gen-session-index.js'],
     ['docs/adr/0236-something.md', 'fitness.js'],
   ];