@ijfw/memory-server 1.5.0 → 1.5.3

package/src/orchestrator/merge-block-aware.js

@@ -34,7 +34,7 @@
  *
  * RESERVED BLOCK NAMES
  *   Matches the shell script verbatim:
- *     MEMORY | ROUTING | AGENTS | BLACKBOARD | FRONTMATTER
+ *     MEMORY | ROUTING | AGENTS | BLACKBOARD | FRONTMATTER | DISCIPLINE
  *
  * ESM, Node ≥18, zero new prod deps.
  */
@@ -60,7 +60,7 @@ import { writeAtomic } from '../lib/atomic-io.js';
  * name yields `ERR_BAD_BLOCK` (the same exit-2 the shell script returns).
  */
 export const RESERVED_BLOCKS = Object.freeze([
-  'MEMORY', 'ROUTING', 'AGENTS', 'BLACKBOARD', 'FRONTMATTER',
+  'MEMORY', 'ROUTING', 'AGENTS', 'BLACKBOARD', 'FRONTMATTER', 'DISCIPLINE',
 ]);
 
 const RESERVED_BLOCK_SET = new Set(RESERVED_BLOCKS);
@@ -149,7 +149,7 @@ export function mergeBlocks(src, pairs) {
     if (typeof block !== 'string' || !RESERVED_BLOCK_SET.has(block)) {
       throw new MergeBlockAwareError(
         'ERR_BAD_BLOCK',
-        `mergeBlocks: block name reserved set: ${RESERVED_BLOCKS.join(' ')} (got ${JSON.stringify(block)})`,
+        `mergeBlocks: unknown block ${JSON.stringify(block)} -- reserved set: ${RESERVED_BLOCKS.join(' ')}`,
       );
     }
     const content = (pair.content === undefined || pair.content === null)
@@ -310,6 +310,18 @@ export function mergeFile(targetAbsPath, pairs, opts = {}) {
     seeded = true;
   }
 
+  const src = readFileSync(abs, 'utf8');
+  const next = mergeBlocks(src, pairs);
+
+  // No-op short-circuit: if content is unchanged and this is not a seed,
+  // skip backup rotation and the atomic write entirely. Idempotent calls
+  // will no longer accumulate identical-content backups.
+  if (!seeded && next === src) {
+    return {
+      ok: true, path: abs, bytes: Buffer.byteLength(next), seeded: false, noop: true,
+    };
+  }
+
   // Backup + retention (best-effort, defaults on). `opts.backups === false`
   // suppresses (used by some tests to keep tmp clean).
   let backup;
@@ -318,8 +330,6 @@ export function mergeFile(targetAbsPath, pairs, opts = {}) {
     if (rot.taken && rot.path) backup = rot.path;
   }
 
-  const src = readFileSync(abs, 'utf8');
-  const next = mergeBlocks(src, pairs);
   const res = writeAtomic(abs, next, { mode: 0o644, ensureDir: true });
   return {
     ok: true, path: res.path, bytes: res.bytes, backup, seeded,

package/src/orchestrator/post-done-runner.js

@@ -1,16 +1,27 @@
 /**
- * post-done-runner.js — v1.5.0-major S02: enforced post-DONE pipeline.
+ * post-done-runner.js — v1.5.0-major S02: post-DONE pipeline primitives.
  *
- * Runs after a subagent's DONE has been verified by runtime-loop.js. Wraps
- * reviewTask (v1.4.4 N3 two-stage review) and checkVerificationGate
- * (v1.4.4 N5) into a single callable the orchestrator-LLM invokes via MCP,
- * so the post-DONE contract isn't satisfied by markdown prose.
+ * WHAT IS LIVE: `runSelfCheck` is the only export on the production path. The
+ * live DONE-handler is the `subagent.post-done` state-SDK verb, which calls
+ * `runSelfCheck` directly (and fires debug-trident via debug-trident-trigger.js
+ * on a self-check failure). The verification gate itself is also enforced live
+ * — `state-sdk.js` calls `enforceVerificationGate` directly.
+ *
+ * WHAT IS NOT LIVE: `runPostDone` is a library/test surface — NOT the live
+ * DONE-handler. It is a convenience wrapper that bundles reviewTask (v1.4.4 N3
+ * two-stage review) + checkVerificationGate (v1.4.4 N5) for direct-import
+ * callers and the test path (`test-orchestrator-post-done-runner.js`). The
+ * production two-stage spec+quality review happens via agent dispatch
+ * (spec-reviewer + quality-reviewer agents), not through this wrapper. Its
+ * original S02 caller (`runtime-loop.js`) was never wired; that file is now
+ * removed. `runPostDone` is kept for its test surface and for any future
+ * caller that wants the two checks bundled — it does not carry production
+ * traffic today.
  *
  * v1.5.0 T13: the standalone `ijfw_subagent_post_done` MCP tool was retired and
  * absorbed into the single `ijfw_state` MCP tool as the `subagent.post-done`
  * verb (see STATE-SDK-CONTRACT §7). `runSelfCheck` is re-exported through
- * `state-sdk.js` for that verb; `runPostDone` is still exported here for the
- * direct-import test path (`test-orchestrator-post-done-runner.js`).
+ * `state-sdk.js` for that verb.
  *
  * Outcome shape (uniform regardless of branch taken):
  *   {
@@ -46,6 +57,13 @@ import { existsSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { reviewTask } from './review.js';
 import { checkVerificationGate, recordViolation } from './verification-gate.js';
+// debug-trident (T29) is wired on the LIVE path only: `subagent.post-done` in
+// state-sdk.js fires debug-trident fire-and-forget when its self-check gate
+// fails, via `maybeFireDebugTrident` in debug-trident-trigger.js. That is the
+// genuine production caller — codex+gemini are dispatched against the real
+// gate-failure evidence whenever IJFW_DEBUG_TRIDENT is enabled. runPostDone
+// deliberately does NOT invoke debug-trident (the earlier W2.C inline-
+// annotation hook was dead — computed but never returned — and was removed).
 
 /**
  * Extract paths claimed in the report. Naive but effective: looks for
@@ -123,7 +141,17 @@ export function runSelfCheck(reportText, projectRoot) {
 }
 
 /**
-/**
+ * runPostDone — library/test surface. NOT the live DONE-handler.
+ *
+ * The live subagent-completion path is the `subagent.post-done` state-SDK verb
+ * (which runs `runSelfCheck` + fires debug-trident on failure), plus the
+ * verification gate enforced directly in `state-sdk.js`; the production
+ * two-stage spec+quality review runs via agent dispatch (spec-reviewer +
+ * quality-reviewer agents). This wrapper bundles reviewTask (N3) +
+ * checkVerificationGate (N5) + runSelfCheck (S09) for direct-import callers
+ * and `test-orchestrator-post-done-runner.js`. It carries no production
+ * traffic — keep it honest: do not describe it as the live handler.
+ *
  * @param {object} params
  * @param {string} params.taskId
  * @param {string} [params.taskSpec]

package/src/orchestrator/state-sdk.js

@@ -11,13 +11,16 @@
  * straight off that contract.
  *
  * ───────────────────────────────────────────────────────────────────────────
- * SCOPE BOUNDARY — T2 builds the verb core; three later tasks wrap it:
+ * SCOPE BOUNDARY — T2 built the verb core; three later tasks wrapped it.
+ * All three (T3/T4/T5) are now REALIZED — this section is kept as the design
+ * record, but the seams below are live, not stubs:
  *
- *   T3 (lock hierarchy)   — wraps `_withLocks()`. Today it is a pass-through;
- *                           T3 swaps in `withFsLock` acquisition in the §3
- *                           canonical acquire-order. Handlers already declare
- *                           the ordered lock-target list they touch, so T3
- *                           only has to make `_withLocks` honor it.
+ *   T3 (lock hierarchy)   — `_withLocks()` is NOT a pass-through. It acquires
+ *                           real filesystem locks via `withFsLock`, ordering
+ *                           each verb's declared lock-target list through
+ *                           `canonicalLockOrder` (the §3 canonical acquire
+ *                           order) to prevent deadlock, then runs `fn` while
+ *                           the locks are held and releases on completion.
  *   T4 (intent/commit)    — wraps `_journalBegin()` / `_journalCommit()`.
  *                           Today they are no-ops; T4 makes them write the
  *                           write-ahead `intent-journal.jsonl` records and
@@ -34,12 +37,13 @@
  */
 
 import {
-  readFileSync, existsSync, mkdirSync, appendFileSync, unlinkSync, readdirSync,
+  readFileSync, existsSync, mkdirSync, appendFileSync, unlinkSync, readdirSync, realpathSync,
 } from 'node:fs';
-import { join, isAbsolute, dirname, basename } from 'node:path';
+import { join, isAbsolute, isAbsolute as pathIsAbsolute, relative as pathRelative, dirname, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { randomUUID, createHash } from 'node:crypto';
 import { gunzipSync } from 'node:zlib';
+import { execFileSync } from 'node:child_process';
 
 import { writeAtomic, readSafe } from '../lib/atomic-io.js';
 import { rotateJsonlIfNeeded } from '../lib/jsonl-rotation.js';
@@ -58,6 +62,17 @@ import {
   appendUnderHeldLock as appendEventUnderHeldLock,
   resolveEventLogPath,
 } from './state-events.js';
+// v1.5.1 cleanup C1: S08 incident-driven worktree safety guards. Previously
+// orphan (only importer was the unwired runtime-loop.js). Wired here as
+// preconditions of the LIVE `subagent.dispatch` verb — the genuinely-reachable
+// worktree-isolated spawn path (ijfw_state MCP tool → query → subagent.dispatch).
+// worktree-guards.js has no state-sdk dependency, so a static import is safe.
+import {
+  captureSpawnToplevel,
+  assertPathWithinToplevel,
+  assertNoCwdDrift,
+  assertNotProtectedRef,
+} from '../lib/worktree-guards.js';
 
 // ---------------------------------------------------------------------------
 // Gate-function indirection (T15 — Model 4 testability seam)
@@ -704,6 +719,88 @@ function requireStr(value, field) {
 
 function nowIso() { return new Date().toISOString(); }
 
+/**
+ * v1.5.1 cleanup C1 — S08 worktree-guard preconditions for `subagent.dispatch`.
+ *
+ * Runs the three incident-driven guards (worktree-guards.js) against the
+ * project root a worktree-isolated subagent is about to be dispatched into:
+ *   #3099 — assertPathWithinToplevel  (abs-path / symlink escape)
+ *   #3097 — assertNoCwdDrift          (cwd drifted off the toplevel)
+ *   #2924 — assertNotProtectedRef     (HEAD on main/master/develop/…)
+ *
+ * Semantics — `subagent.dispatch` is a brief-COMPOSITION verb (it produces a
+ * deterministic dispatch brief; the real spawn happens platform-side). The
+ * guards are therefore PRECONDITIONS surfaced on the result, not a hard abort
+ * of brief composition:
+ *   - Project root IS a git repo  → all 3 guards run. A failure is reported on
+ *     `guard.violations[]` and `guard.ok=false`. With IJFW_WORKTREE_GUARD_STRICT=1
+ *     a violation throws (aborts the dispatch before `_withLocks`).
+ *   - Project root is NOT a git repo (or guards can't run) → `guard.ok` stays
+ *     true with `guard.skipped` set; brief composition proceeds. This keeps the
+ *     verb usable from non-git temp dirs (tests, scratch projects).
+ *
+ * Only `'worktree'` isolation is guarded — `'shared'` dispatch spawns no
+ * separate worktree so containment/drift/protected-ref don't apply.
+ *
+ * @param {string} projectRoot   absolute path the subagent dispatches into
+ * @param {'shared'|'worktree'} isolation
+ * @returns {{ok:boolean, skipped?:string, violations:string[], branch?:string}}
+ * @throws {Error} only when IJFW_WORKTREE_GUARD_STRICT=1 and a guard fails
+ */
+function runWorktreeGuards(projectRoot, isolation) {
+  if (isolation !== 'worktree') {
+    return { ok: true, skipped: 'shared-isolation', violations: [] };
+  }
+  // Quiet git-repo pre-check — captureSpawnToplevel would otherwise let git's
+  // own "fatal: not a git repository" hit our stderr on non-git roots (common
+  // in tests / scratch projects). Suppress git stderr here, then run the real
+  // guards only when we know we're inside a work tree.
+  try {
+    const probe = execFileSync(
+      'git', ['rev-parse', '--is-inside-work-tree'],
+      { cwd: projectRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] },
+    ).trim();
+    if (probe !== 'true') {
+      return { ok: true, skipped: 'not-a-git-repo', violations: [] };
+    }
+  } catch {
+    // Not a git tree — nothing to contain. Brief composition still proceeds.
+    return { ok: true, skipped: 'not-a-git-repo', violations: [] };
+  }
+  let toplevel;
+  try {
+    toplevel = captureSpawnToplevel(projectRoot);
+  } catch {
+    return { ok: true, skipped: 'not-a-git-repo', violations: [] };
+  }
+  const violations = [];
+  let branch;
+  try {
+    assertPathWithinToplevel(projectRoot, toplevel);
+  } catch (e) {
+    violations.push(`path-escape: ${e.message}`);
+  }
+  try {
+    assertNoCwdDrift(toplevel, projectRoot);
+  } catch (e) {
+    violations.push(`cwd-drift: ${e.message}`);
+  }
+  try {
+    branch = assertNotProtectedRef(projectRoot);
+  } catch (e) {
+    violations.push(`protected-ref: ${e.message}`);
+  }
+  const ok = violations.length === 0;
+  if (!ok && process.env.IJFW_WORKTREE_GUARD_STRICT === '1') {
+    throw new Error(
+      `state-sdk: subagent.dispatch S08 worktree guard failed — ${violations.join('; ')}`,
+    );
+  }
+  return ok
+    ? { ok: true, violations: [], branch }
+    : { ok: false, violations };
+}
+
 // ---------------------------------------------------------------------------
 // VERB HANDLERS — one per contract §7 block. Signature: (payload, ctx, env).
 // `env` carries the per-invocation { verbId } so handlers can stamp records.
@@ -1000,6 +1097,13 @@ const handlers = {
     const isolation = payload?.isolation === 'shared' ? 'shared' : 'worktree';
     const role = typeof payload?.role === 'string' && payload.role.length > 0
       ? payload.role : null;
+    // v1.5.1 cleanup C1 — S08 worktree-guard preconditions. Runs the three
+    // incident-driven guards BEFORE the wave-state mutation when isolation is
+    // 'worktree'. This is the production caller worktree-guards.js was missing
+    // (its only prior importer was the unwired runtime-loop.js). With
+    // IJFW_WORKTREE_GUARD_STRICT=1 a guard violation throws here, aborting the
+    // dispatch before `_withLocks`; otherwise it is surfaced on the result.
+    const worktreeGuard = runWorktreeGuards(root, isolation);
     // Caller-supplied env passthrough (object: name → value). Coerce values to
     // strings (env vars are always strings) and drop nullish entries.
     const callerEnv = (payload?.env && typeof payload.env === 'object'
@@ -1055,8 +1159,46 @@ const handlers = {
       const envLines = Object.keys(inheritedEnv).sort()
         .map((k) => `  ${k}=${inheritedEnv[k]}`);
       const eventLogPath = resolveEventLogPath(root, waveId, subagentId);
-      const eventLogRel = eventLogPath.startsWith(root + '/')
-        ? eventLogPath.slice(root.length + 1) : eventLogPath;
+      // F5.6: the prior `startsWith(root + '/')` form (a) wired only on POSIX
+      // because the separator is `/`, breaking on Windows where the separator
+      // is `\`, and (b) silently leaked absolute paths into the dispatch brief
+      // on Windows because the startsWith check always returned false. Use
+      // path.relative + isAbsolute so the relative form is computed correctly
+      // cross-platform, and fall back to the absolute path only when the
+      // event log is genuinely outside the repo (rel '..' or different drive).
+      // F-LENS2-13: pre-canonicalize via realpathSync so a Windows 8.3 short-
+      // name (PROGRA~1) or a macOS /tmp -> /private/tmp symlink doesn't make
+      // the path.relative containment check spuriously claim "outside repo".
+      //
+      // Canonicalization MUST be atomic across both sides: realpathSync(root)
+      // can succeed (root exists) while realpathSync(eventLogPath) throws
+      // ENOENT (event log file is about to be created). Independent try/catches
+      // produce ASYMMETRIC results — on macOS /var/folders is a symlink to
+      // /private/var/folders, so canonicalRoot becomes the long form while
+      // canonicalEventLog stays short, path.relative returns a `..`-leading
+      // string, and the containment check spuriously rejects — leaking the
+      // absolute path into the dispatch brief. One try/catch keeps both sides
+      // either canonical or both un-canonical.
+      let canonicalRoot, canonicalEventLog;
+      try {
+        canonicalRoot = realpathSync(root);
+        canonicalEventLog = realpathSync(eventLogPath);
+      } catch {
+        canonicalRoot = root;
+        canonicalEventLog = eventLogPath;
+      }
+      const _rel = pathRelative(canonicalRoot, canonicalEventLog);
+      // F-LENS2-14: when the event log is genuinely outside the repo, the
+      // earlier behaviour leaked the FULL absolute path (often containing
+      // $HOME / $USERPROFILE) into the dispatch brief — which the subagent
+      // sees and may forward to an external LLM provider. Redact to a
+      // pseudo-path so the subagent knows the log exists by basename without
+      // leaking the absolute prefix. The orchestrator still has the real
+      // eventLogPath in its return value for its own I/O.
+      const _basename = (eventLogPath || '').split(/[\\/]/).pop() || 'events.jsonl';
+      const eventLogRel = (_rel === '' || _rel.startsWith('..') || pathIsAbsolute(_rel))
+        ? `<external>/${_basename}`
+        : _rel;
       const dispatchBrief = [
         `# Subagent dispatch — ${subagentId} (wave ${waveId})`,
         role ? `Role: ${role}` : null,
@@ -1078,6 +1220,11 @@ const handlers = {
         isolation,
         inheritedEnv,
         eventLogPath,
+        // v1.5.1 cleanup C1 — S08 guard outcome. `{ok:true}` when guards passed
+        // or were skipped (non-git root / shared isolation); `{ok:false,
+        // violations[]}` when a containment/drift/protected-ref hazard was
+        // detected (non-strict mode — the orchestrator should not spawn).
+        worktreeGuard,
       };
     }, env);
   },
@@ -1127,12 +1274,69 @@ const handlers = {
       process.stderr.write(`[state-sdk] WARN subagent.post-done gate execution-fail: ${e.message}\n`);
       return { ok: true, advisory: true, gate: 'post-done-self-check', reason: e.message };
     }
+    // v1.5.1 cleanup C1 — T20 truncation classification. When the caller hands
+    // us the subagent's `events` stream and/or intent `journal` on the payload,
+    // run `detectTruncation` so a truncated post-DONE is classified on the LIVE
+    // path (ijfw_state MCP tool → query → subagent.post-done). This is the
+    // production caller recovery/truncation.js was missing — its only prior
+    // importer was the unwired runtime-loop.js. Annotation-only: the classifier
+    // never throws and never alters the self-check verdict.
+    let truncation;
+    if (Array.isArray(payload?.events) || Array.isArray(payload?.journal)) {
+      try {
+        const { detectTruncation } = await import('../recovery/truncation.js');
+        const det = detectTruncation({
+          events: payload.events,
+          journal: payload.journal,
+          expectedTerminalVerb: payload.expectedTerminalVerb,
+        });
+        truncation = {
+          truncated: det.truncated,
+          reason: det.reason,
+        };
+      } catch (e) {
+        process.stderr.write(
+          `[state-sdk] WARN subagent.post-done truncation classify failed: ${e.message}\n`,
+        );
+      }
+    }
     if (selfCheck.verdict !== 'PASSED') {
       const reason = `self-check FAILED — ${selfCheck.files_missing.length} missing file(s), `
         + `${selfCheck.commits_missing.length} missing commit(s)`;
+      // v1.5.1: LIVE wiring of debug-trident (T29) onto the production
+      // gate-failure path. When the post-done self-check FAILS this is
+      // exactly the stalled-investigation moment the Trident debug loop
+      // exists for — dispatch codex+gemini to generate competing root-cause
+      // hypotheses against the gate-failure evidence. FIRE-AND-FORGET:
+      // `maybeFireDebugTrident` returns immediately, the campaign runs in a
+      // detached promise — the verb's return value + timing are UNCHANGED so
+      // STATE-SDK-CONTRACT §8 (subagent.post-done is a fast read verb) holds.
+      // Env-gated (IJFW_DEBUG_TRIDENT) + silent no-op on missing deps; never
+      // throws. Dynamic import avoids a static require cycle. Mirrors the
+      // A-Mem auto-linker fire-and-forget pattern in memory/fts5.js.
+      try {
+        import('./debug-trident-trigger.js')
+          .then(({ maybeFireDebugTrident }) => {
+            maybeFireDebugTrident({
+              projectRoot,
+              subagentId: _subagentId,
+              reason,
+              reportText,
+              selfCheck,
+            });
+          })
+          .catch((e) => {
+            try {
+              process.stderr.write(
+                `[state-sdk] WARN subagent.post-done debug-trident dispatch failed: ${e.message}\n`,
+              );
+            } catch { /* never throw */ }
+          });
+      } catch { /* fire-and-forget — never alters the verb verdict */ }
       if (!GATE_BYPASS) {
         return {
           ok: false, refused: true, gate: 'post-done-self-check', reason,
+          ...(truncation ? { truncation } : {}),
         };
       }
       // Bypass masks a would-be refusal — emit a loud WARN + advisory
@@ -1149,6 +1353,7 @@ const handlers = {
           claimedCommits: selfCheck.commits_claimed,
           verified: false,
         },
+        ...(truncation ? { truncation } : {}),
       };
     }
     return {
@@ -1158,6 +1363,7 @@ const handlers = {
         claimedCommits: selfCheck.commits_claimed,
         verified: selfCheck.verdict === 'PASSED',
       },
+      ...(truncation ? { truncation } : {}),
     };
   },
 

package/src/orchestrator/subagent-telemetry.js

@@ -27,6 +27,10 @@ import { query } from './state-sdk.js';
 import { pollEvents } from './state-events.js';
 // v1.5.0 N4.obs M1+M2: trace-id + hierarchical observation path.
 import { getTraceId, composePath } from '../observability/trace-id.js';
+// v1.5.1 W2.F: checkpoint-contract evaluator (N4.obs M3). Validates a final
+// status report carried by a checkpoint envelope against the v1.4.4 N2
+// four-section contract before the envelope is written.
+import { evaluateCheckpointContract } from '../observability/evaluator-checkpoint-contract.js';
 
 // ---------------------------------------------------------------------------
 // Frozen constants — Wave 11-A imports these directly
@@ -123,6 +127,21 @@ export async function recordCheckpoint(waveId, subId, checkpoint, projectRoot) {
     ...checkpoint,
   };
 
+  // v1.5.1 W2.F: contract-validate at emission time. When a checkpoint
+  // envelope carries the subagent's final status report (`checkpoint.report`),
+  // it MUST satisfy the v1.4.4 N2 four-section contract (Status/SHAs/Files/
+  // Tests). Schema drift now fails LOUD here at write — not silently at read.
+  // Progress-only checkpoints (no `report` field) skip this check unchanged.
+  if (typeof checkpoint.report === 'string') {
+    const evalResult = evaluateCheckpointContract(checkpoint.report);
+    if (!evalResult.valid) {
+      throw new Error(
+        `subagent-telemetry: checkpoint report for ${waveId}/${subId} `
+        + `violates checkpoint-contract — ${evalResult.reason}`,
+      );
+    }
+  }
+
   const serialised = JSON.stringify(envelope);
   if (serialised.length > MAX_CHECKPOINT_SIZE) {
     throw new Error(

package/src/orchestrator/wave-state.js

@@ -59,6 +59,27 @@ function loadPopulateBlackboardBlock() {
   return _populateBlackboardBlockPromise;
 }
 
+// Wave 5B wiring (post-cross-audit W1 fix): same lazy-Promise-singleton
+// pattern as populateBlackboardBlock above. populateDisciplineBlock is
+// idempotent (no-op short-circuit when content unchanged), so firing on
+// every wave checkpoint is free and guarantees the DISCIPLINE marker block
+// in AGENTS.md actually gets populated during a real workflow — closes the
+// "ships as dead code" wiring gap the cross-audit caught.
+let _populateDisciplineBlockPromise = null;
+function loadPopulateDisciplineBlock() {
+  if (_populateDisciplineBlockPromise === null) {
+    _populateDisciplineBlockPromise = (async () => {
+      try {
+        const mod = await import('./agents-md-blackboard.js');
+        return mod.populateDisciplineBlock ?? null;
+      } catch {
+        return null;
+      }
+    })();
+  }
+  return _populateDisciplineBlockPromise;
+}
+
 /**
  * Test-only helper: reset the populateBlackboardBlock promise singleton so a
  * test can simulate "first call after process start" semantics. Internal.
@@ -69,6 +90,14 @@ export function _resetPopulateBlackboardBlockSingleton() {
   _populateBlackboardBlockPromise = null;
 }
 
+/**
+ * Test-only helper: reset the populateDisciplineBlock promise singleton.
+ * @internal
+ */
+export function _resetPopulateDisciplineBlockSingleton() {
+  _populateDisciplineBlockPromise = null;
+}
+
 // ---------------------------------------------------------------------------
 // Internal YAML helpers — flat subset only (string/number/boolean/string[])
 // ---------------------------------------------------------------------------
@@ -560,5 +589,14 @@ export async function checkpointWave(waveId, projectRoot) {
     try { await populateBlackboardBlock(waveId, projectRoot); } catch { /* advisory */ }
   }
 
+  // Wave 5B wiring (cross-audit W1 fix): populate the DISCIPLINE block too.
+  // Same advisory-failure semantics as the BLACKBOARD call above. Auto-detects
+  // project type from .ijfw/memory/brief.md frontmatter or repo signals — no
+  // explicit projectType passed, the detector handles it.
+  const populateDisciplineBlock = await loadPopulateDisciplineBlock();
+  if (populateDisciplineBlock) {
+    try { await populateDisciplineBlock(projectRoot, undefined, { waveId }); } catch { /* advisory */ }
+  }
+
   return next;
 }

package/src/override-resolver.js

@@ -65,9 +65,11 @@ import {
  * projectRoot. Used by deployResolvedSkill to know which platforms to write
  * the merged body into.
  *
- * TODO(W2b/t11): replace this with an exported helper from
- * installer/src/install-helpers.js once that module exposes a canonical
- * platform-list getter. Until then this on-disk probe is the contract.
+ * DEFERRED (platform-list consolidation): could be replaced with an exported
+ * helper from installer/src/install-helpers.js once that module exposes a
+ * canonical platform-list getter. Until then this on-disk probe is the
+ * contract — and as an on-disk probe it correctly reflects what is actually
+ * deployed, so the consolidation is a nice-to-have, not a defect.
  *
  * @param {string} projectRoot
  * @returns {string[]} absolute paths to existing platform skill dirs