Claudinite maintenance (#793)

* Claudinite maintenance: converge vendored mount, wiring, and migration notes

* Baselining: fix gcec pack manifest to match pack-schema.mjs

check_the_world flagged the gcec local pack's manifest for three
schema-conformance blockers: no ruleRoutingGuidance (required field),
"rules" (not a manifest field — renamed to worldRules, since all three
gcec rules audit static repo state), and "run_daily" (dead legacy field,
unused anywhere in the engine).

No pending agentic migration note this cycle (2026-07-19-pack-independence
landed before the prior stamp, so it was already handled in an earlier
cycle; this repo's gcec pack composes no barrier from the shared engine
either way, so it would have been a no-op).

Advances claudinite.updated to reflect this cycle's judgment pass.

Refs #794

* Baselining: mark dispatch issue reference (#794)

Ties this maintenance cycle's judgment pass (gcec pack manifest fix, stamp advance in 66139bb) to its dispatch issue, satisfying this repo's task-lifecycle check.

---------

Co-authored-by: claudinite[bot] <claudinite@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: 3 people

.claudinite-checks.json

@@ -32,8 +32,8 @@
     "delivery": "auto-merge"
   },
   "claudinite": {
-    "updated": "2026-07-29T03:46:43.872Z",
-    "ref": "3dea09ab5a3bcea11eee969cbe6340db725af1ac"
+    "updated": "2026-07-30T03:45:18.000Z",
+    "ref": "29e843cd69f355e2cf41aea3b91197aa5e5030da"
   },
   "badges": {
     "readme": "auto"

.claudinite/local/packs/gcec/pack.mjs

@@ -16,10 +16,13 @@ import npmTestGlobCoverage from './npm-test-glob-coverage.mjs';
 // here, not from the canon skills tree.
 export default {
   id: 'gcec',
+  ruleRoutingGuidance: {
+    belongs: "this project's standing rules — owner commands, testing invariants, codebase gotchas, extractor-pipeline rules, architecture rules of the road, capture policy",
+    excludes: 'general software-engineering practices and portable procedures — those live in the vendored Claudinite canon, not here',
+  },
   detect: null,
   marker: null,
   prose: 'RULES.md',
-  rules: [testOfflineListSync, customSourcesFlat, npmTestGlobCoverage],
+  worldRules: [testOfflineListSync, customSourcesFlat, npmTestGlobCoverage],
   skills: ['snapshot-approval', 'merge-and-ci', 'testing-guide'],
-  run_daily: [],
 };

.claudinite/shared/engine/checks/check_the_world.mjs

@@ -18,7 +18,7 @@ import { writeFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { buildContext } from './helpers/repo-context.mjs';
 import { discoverPacks, resolveDeclaredPacks } from '../pack_loader/pack-registry.mjs';
-import { runActivePackRules, contributedRules } from './run-active-pack-rules.mjs';
+import { runActivePackRules, packRules } from './run-active-pack-rules.mjs';
 import { reportFindings } from './report-findings.mjs';
 
 const configError = (what, fix) => ({
@@ -33,12 +33,7 @@ const root = value('--root') || process.cwd();
 
 if (has('--list')) {
   const { packs } = await discoverPacks({ localRoot: root });
-  const rules = [
-    ...packs.flatMap((p) => p.rules ?? []),
-    ...packs.flatMap((p) => p.skillChecks ?? []),
-    ...packs.flatMap((p) => contributedRules(p, packs)),
-  ];
-  for (const r of rules.sort((a, b) => a.id.localeCompare(b.id))) {
+  for (const r of packRules(packs)) {
     console.log(`${r.id}\t${r.severity}\t${r.description}\t${r.doc}`);
   }
   process.exit(0);

.claudinite/shared/engine/checks/helpers/repo-context.mjs

@@ -92,7 +92,35 @@ function vendoredSet(root, files) {
 // README — { readme: 'auto' | 'off' }. Materialized explicitly into every member
 // (the wiring converge writes it) rather than inferred from absence, so the knob
 // sits visibly in the file anyone would open to change it.
-export const CONFIG_KEYS = ['packs', 'rules', 'accept', 'sharedConstants', 'packConfig', 'maintenance', 'claudinite', 'taskScheduler', 'badges'];
+// `dormant` is the project's own declaration that it is out of the RECURRING work —
+// see isDormant below for exactly how much that covers.
+export const CONFIG_KEYS = ['packs', 'rules', 'accept', 'sharedConstants', 'packConfig', 'maintenance', 'claudinite', 'taskScheduler', 'badges', 'dormant'];
+
+// Does this project declare itself DORMANT? A project goes dormant when it is
+// finished, parked, or simply not being worked on: it should stop paying the
+// upkeep of a project that IS being worked on.
+//
+// What dormancy means, exactly — it is narrow on purpose:
+//   - NO RECURRING WORK. The vendored scheduler stops before it evaluates
+//     anything (engine/scheduler/run.mjs), so no task is due, no dispatch issue
+//     is filed, no agent session is started, and no maintenance PR is opened.
+//     Nothing scheduled runs "for nothing" on a repo nobody is working on.
+//   - NO FLEET CEREMONY. Whatever looks at this repo from the OUTSIDE reads the
+//     same declaration and leaves it alone rather than reporting it as unhealthy —
+//     a repo TOLD to stop keeping up must not then be nagged for not keeping up.
+//     Which is why this predicate is exported for a raw declaration too (below).
+//   - EVERYTHING ELSE STAYS ON. Claudinite is not switched off: the session
+//     hooks, the checks engine, the mounted skills and pack prose all work
+//     exactly as before the moment someone opens a session on the repo. Dormancy
+//     is about unattended upkeep, never about what an interactive session may do.
+//
+// The predicate reads BOTH shapes deliberately: a raw parsed .claudinite-checks.json
+// and the normalized config loadConfig returns. A cross-repo reader fetches another
+// repo's declaration over the API with no engine loaded against that tree, and it
+// must decide dormancy by the same test that repo's own scheduler used — a second
+// notion of dormancy would nag exactly the repos that had already opted out. One
+// definition, both sides.
+export const isDormant = (config) => config?.dormant === true;
 
 // The keys a `schedule` object may carry, and the canonical weekday vocabulary
 // (mirrored from engine/scheduler/slots.mjs WEEKDAYS — kept as a literal here so
@@ -128,7 +156,7 @@ export const PACK_ENTRY_KEYS = ['id', 'config', 'answers', 'rules', 'accept', 'v
 // read this one shape regardless of which form the file used.
 export function loadConfig(root) {
   const path = join(root, '.claudinite-checks.json');
-  const empty = { packs: [], packEntries: [], rules: {}, accept: [], sharedConstants: [], packConfig: {}, taskScheduler: null, claudinite: null, maintenance: null, badges: null, errors: [] };
+  const empty = { packs: [], packEntries: [], rules: {}, accept: [], sharedConstants: [], packConfig: {}, taskScheduler: null, claudinite: null, maintenance: null, badges: null, dormant: false, errors: [] };
   if (!existsSync(path)) return empty;
 
   let raw;
@@ -267,6 +295,17 @@ export function loadConfig(root) {
     }
   }
 
+  // --- dormant: a plain boolean, validated as one. A string "true", a `{ since }`
+  // object or a reason left in its place would all read as dormant to a truthiness
+  // test and as active to this one, and the difference is a whole repo's scheduled
+  // work — so the wrong TYPE is a settings error, not a value to coerce.
+  if (raw.dormant !== undefined && typeof raw.dormant !== 'boolean') {
+    errors.push({
+      what: `"dormant" must be true or false, got ${JSON.stringify(raw.dormant)}`,
+      fix: 'set "dormant": true to stop this project\'s recurring work, or remove the key',
+    });
+  }
+
   return {
     packs,
     packEntries,
@@ -288,6 +327,10 @@ export function loadConfig(root) {
     claudinite: raw.claudinite ?? null,
     maintenance: raw.maintenance ?? null,
     badges: raw.badges ?? null,
+    // Normalized to a boolean rather than passed through: everything downstream
+    // asks "is this project dormant", and a tri-state (true / false / absent) would
+    // invite each caller to answer the absent case for itself. Absent is active.
+    dormant: isDormant(raw),
     errors,
   };
 }

.claudinite/shared/engine/checks/run-active-pack-rules.mjs

@@ -18,6 +18,20 @@ export function contributedRules(pack, fromPacks, onError = null) {
   catch (e) { onError?.(e); return []; }
 }
 
+// The full rule catalog the given packs carry, id-sorted: a pack's own rules,
+// the checks its bundled skills own, and the rules built from contributions
+// addressed to it. The ONE place the three sources are summed — `--list`
+// prints it and the catalog's own tally guard counts it, so neither can
+// disagree with the runner about what rules exist, and a fourth source added
+// later lands in both for free.
+export function packRules(packs) {
+  return [
+    ...packs.flatMap((p) => p.rules ?? []),
+    ...packs.flatMap((p) => p.skillChecks ?? []),
+    ...packs.flatMap((p) => contributedRules(p, packs)),
+  ].sort((a, b) => a.id.localeCompare(b.id));
+}
+
 // Every finding from the active packs' rules that `includeRule` admits. A rule
 // turned `off` in settings is skipped. `onContributeError(pack, err)` is invoked
 // when a pack's contributedRules seam throws (the caller decides whether that

.claudinite/shared/engine/hooks/session-end-command.mjs

@@ -11,10 +11,21 @@
 // conformance checks); a step that writes anything per-session would fire once per
 // TURN there. SessionEnd fires once, when the session ends.
 //
-// BEST EFFORT, and that is enough. A container reclaimed by timeout never fires
-// this hook at all, so nothing may depend on it having run: every firing strictly
+// BEST EFFORT AS A HOOK, and that is enough there: a container reclaimed by timeout
+// never fires it, so nothing may depend on it having run — every firing strictly
 // enriches the record, every miss leaves exactly the prior behaviour.
 //
+// AND EXPLICITLY INVOCABLE, which is what makes unattended sessions countable at
+// all. An UNATTENDED session — the scheduler's executor, running a dispatch in a
+// cloud container nobody is sitting in front of — ends when its container is
+// reclaimed, so the hook is exactly the firing that does not happen, and every one
+// of those sessions used to leave no record anywhere. So the executor runs this
+// runner itself as its last step (engine/scheduler/executor.md), naming the dispatch
+// issue in `CLAUDINITE_SESSION_ISSUE`. Steps must therefore tolerate being run
+// mid-session: the transcript is complete only up to the invocation, and the later
+// hook firing (when it happens at all) is a second event over the same session,
+// which the capture step's session-keyed delta already makes safe.
+//
 // FAIL-SOFT, absolutely. A session must never fail to end because of this hook, so
 // every error — a step that throws, a step that hangs, a broken pack registry — is
 // swallowed, recorded via hooklog, and exited 0. The per-step bound is a hard kill;
@@ -71,6 +82,12 @@ async function main() {
         // to re-derive it. Named for the engine, not for any one step's CLI flags.
         ...(input.session_id ? { CLAUDINITE_SESSION_ID: String(input.session_id) } : {}),
         ...(input.transcript_path ? { CLAUDINITE_TRANSCRIPT: String(input.transcript_path) } : {}),
+        // The issue this session was ABOUT, when its launcher knew one. A hook
+        // firing never does — nothing tells a SessionEnd hook what the session was
+        // for — so this is only ever set by an explicit invocation (the executor
+        // naming its dispatch). Passed through verbatim: core states the fact, and
+        // a step decides what, if anything, to do with it.
+        ...(process.env.CLAUDINITE_SESSION_ISSUE ? { CLAUDINITE_SESSION_ISSUE: process.env.CLAUDINITE_SESSION_ISSUE } : {}),
       },
     });
     const tail = (run.stdout || run.stderr || '').trim().split('\n').pop() || '';

.claudinite/shared/engine/pack_loader/inject-pack-prose.mjs

@@ -25,20 +25,42 @@ try {
   // system rather than an explicit @import.
   const packs = await loadPacks({ localRoot: projectRoot });
 
+  // Nothing active means this repo runs no Claudinite: no prose, and no routing
+  // table either. The hook stays silent rather than pushing a catalog of the
+  // corpus into a session that declared none of it.
+  const active = packs.filter((pack) => isActive(pack, { packs: declared }));
+  if (!active.length) process.exit(0);
+
   const sections = [];
-  for (const pack of packs) {
-    if (!pack.prose || !isActive(pack, { packs: declared })) continue;
+  for (const pack of active) {
+    if (!pack.prose) continue;
     // Resolve prose off the pack's OWN directory (canon or local_packs), not a
     // single shared root — so a local pack's RULES.md is found where it lives.
     const prosePath = join(pack.dir, pack.prose);
     if (!existsSync(prosePath)) continue;
     sections.push(`<!-- pack:${pack.id} -->\n${readFileSync(prosePath, 'utf8').trim()}`);
   }
 
-  if (sections.length) {
-    process.stdout.write(
-      `# Claudinite — active-pack guidance\n\nThe baseline plus the packs this project declares. Deeper per-pack reference (e.g. a pack's release doc) is linked from its prose and read on demand.\n\n${sections.join('\n\n---\n\n')}\n`
-    );
+  // The routing table: every pack's own statement of its boundary, so a session
+  // holding a piece of content (a doc, a rule, a skill) routes it to the pack
+  // that owns it instead of defaulting into the baseline. Emitted for every pack
+  // DISCOVERED, not only the active ones — a consumer holds just the packs it
+  // vendored, so the discovered set is already the set it can route into, and in
+  // the canon every pack is a legitimate destination whether or not this repo
+  // declares it. Rows are short by contract (the manifest spec caps each side at
+  // 20 words — pack-schema.mjs), so the whole table stays a cheap session cost.
+  const routed = packs.filter((p) => p.ruleRoutingGuidance?.belongs && p.ruleRoutingGuidance?.excludes);
+  const routingTable = routed.length
+    ? `# Claudinite — where content goes (pack routing)\n\nEach pack states what it owns and what it does not. When a rule, doc, skill or check could live in more than one, this table decides it — and "no pack fits" means a new pack or the project's own \`local_packs/\`, never the baseline by default.\n\n| Pack | Belongs | Does not belong |\n|---|---|---|\n${routed
+        .map((p) => `| \`${p.id}\`${p.local ? ' (local)' : ''} | ${p.ruleRoutingGuidance.belongs} | ${p.ruleRoutingGuidance.excludes} |`)
+        .join('\n')}\n`
+    : '';
+
+  if (sections.length || routingTable) {
+    const guidance = sections.length
+      ? `# Claudinite — active-pack guidance\n\nThe baseline plus the packs this project declares. Deeper per-pack reference (e.g. a pack's release doc) is linked from its prose and read on demand.\n\n${sections.join('\n\n---\n\n')}\n`
+      : '';
+    process.stdout.write([guidance, routingTable].filter(Boolean).join('\n---\n\n'));
   }
 } catch {
   // fail soft — a broken loader must never block a session

.claudinite/shared/engine/pack_loader/pack-registry.mjs

@@ -1,6 +1,7 @@
 import { readdirSync, existsSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { validateManifest, normalizeManifest } from './pack-schema.mjs';
 
 // This module lives at <canon>/engine/pack_loader/; the packs it scans at <canon>/packs/.
 const canonRoot = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
@@ -140,13 +141,34 @@ async function scanPackDir(dir, { local, subdir }, errors) {
     // import needed (the pack owns the interview HYGIENE check; the engine owns
     // the manifest-shape validation).
     for (const e of packQuestions(mod).errors) errors.push({ ...e, dir: packDir });
-    const pack = { ...mod, dir: packDir, local };
+    // The rest of the manifest against the spec (pack-schema.mjs). REPORTED, not
+    // fatal: a pack whose declaration is incomplete still loads and still runs
+    // its checks — silently disabling a repo's own rules is a worse failure than
+    // the one being reported, and the blocking config error is what gets it fixed.
+    for (const e of validateManifest(mod, { label: `the pack in ${rel}`, skillDirs: skillDirNames(packDir) })) {
+      errors.push({ ...e, dir: packDir });
+    }
+    const pack = { ...normalizeManifest(mod), dir: packDir, local };
     pack.skillChecks = await scanSkillChecks(packDir, errors);
     out.push(pack);
   }
   return out;
 }
 
+// The skill directory names a pack bundles — the tree side of the manifest's
+// `skills` declaration, which the spec holds to it in both directions. Absent or
+// unreadable skills/ reads as none: scanSkillChecks reports the unreadable case,
+// and the spec must not turn one broken directory into a wall of phantom findings.
+function skillDirNames(packDir) {
+  const skillsRoot = join(packDir, 'skills');
+  if (!existsSync(skillsRoot)) return [];
+  try {
+    return readdirSync(skillsRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  } catch {
+    return [];
+  }
+}
+
 // A pack's skill-owned checks: any <pack>/skills/<skill>/checks.mjs (default
 // export = an array of rules). Isolated per import; run gated by the owning
 // pack being active, exactly like the pack's own rules — a skill is pack