@ijfw/memory-server 1.5.1 → 1.5.4

package/src/orchestrator/discipline-selector.js

@@ -0,0 +1,259 @@
+/**
+ * discipline-selector.js — pure functions to pick and load a project-discipline
+ * template body for the DISCIPLINE AGENTS.md marker block.
+ *
+ * Two exports:
+ *
+ *   selectDisciplineTemplate(projectType)
+ *     Synchronous. Returns the template body string (utf-8) for the given
+ *     project type, or an empty string for `unknown` / `mixed`. Throws a
+ *     TypeError when projectType is null or undefined. Resolves template
+ *     paths relative to this module, using the same fileURLToPath + dirname
+ *     pattern as merge-block-aware.js.
+ *
+ *   detectProjectTypeFromRepo(repoRoot)
+ *     Synchronous, deterministic. Inspects the repo root directory to infer
+ *     project type. Priority order:
+ *       (a) .ijfw/memory/brief.md frontmatter `type` key — highest fidelity,
+ *           set explicitly by the user or brainstorm-LOCK hook.
+ *       (b) Well-known file/dir signals — cheap existsSync probes, no glob.
+ *     Returns one of: 'code' | 'narrative' | 'business' | 'design' |
+ *                     'research' | 'unknown'
+ *
+ * No deps beyond node:fs and node:path (Node >=18, ESM).
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { validateSafeRepoPath } from '../brain/path-guard.js';
+
+// ---------------------------------------------------------------------------
+// Module-relative template root
+// ---------------------------------------------------------------------------
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Root of the ijfw-agents-md templates directory, resolved relative to this
+ * module. Same anchor pattern used by merge-block-aware.js for DEFAULT_TEMPLATE.
+ */
+const TEMPLATES_DIR = join(
+  __dirname,
+  '..', '..', '..', 'claude', 'skills', 'ijfw-agents-md', 'templates',
+);
+
+// ---------------------------------------------------------------------------
+// Valid project types
+// ---------------------------------------------------------------------------
+
+/** All recognized project type codes (non-empty body returned for these). */
+const TYPED_CODES = new Set(['code', 'narrative', 'business', 'design', 'research']);
+
+/** Project types that legitimately produce an empty template body. */
+const EMPTY_BODY_CODES = new Set(['unknown', 'mixed']);
+
+// ---------------------------------------------------------------------------
+// selectDisciplineTemplate
+// ---------------------------------------------------------------------------
+
+/**
+ * Return the template body string for `projectType`.
+ *
+ * @param {string} projectType  one of: code | narrative | business | design |
+ *                              research | unknown | mixed
+ * @param {object} [opts]
+ * @param {string} [opts.templatesDir]  Override the templates directory. Used
+ *                                      by tests to exercise the missing-file
+ *                                      Error path against a directory that
+ *                                      contains no `discipline-*.md` files
+ *                                      (W3 D1 / L2-04 follow-up). Default:
+ *                                      shipped TEMPLATES_DIR.
+ * @returns {string}  template body (utf-8). For unknown/mixed (and any
+ *                    unrecognized string), returns an HTML-comment hint
+ *                    body documenting how the user activates a domain.
+ * @throws {TypeError}  when projectType is null, undefined, or non-string.
+ * @throws {Error}      when the template file is absent for a typed project.
+ */
+export function selectDisciplineTemplate(projectType, opts = {}) {
+  if (projectType === null || projectType === undefined) {
+    throw new TypeError(
+      'selectDisciplineTemplate: projectType must be a string (got null/undefined)',
+    );
+  }
+  if (typeof projectType !== 'string') {
+    throw new TypeError(
+      `selectDisciplineTemplate: projectType must be a string (got ${typeof projectType})`,
+    );
+  }
+
+  const type = String(projectType).trim().toLowerCase();
+
+  // Helpful hint body for "no domain rules to apply" cases. Replaces what
+  // was previously an empty marker block (Wave 5B finding L3-03 + L3-04):
+  // a labelled-but-empty DISCIPLINE region left users unsure what to do.
+  // The hint is an HTML comment so it stays invisible in rendered markdown
+  // but visible to anyone reading the raw AGENTS.md, and documents the
+  // correction path inline.
+  const emptyBodyHint = (label) =>
+    `<!-- IJFW: project type is "${label}" -- domain-specific discipline rules not yet activated.\n`
+    + `To activate, set frontmatter \`type: code\` (or narrative | business | design | research)\n`
+    + `in .ijfw/memory/brief.md and re-run the brainstorm-LOCK or plan-LOCK in the IJFW workflow. -->`;
+
+  if (EMPTY_BODY_CODES.has(type)) {
+    return emptyBodyHint(type);
+  }
+
+  if (!TYPED_CODES.has(type)) {
+    // Unrecognized type string -- treat as 'unknown' for the hint label so
+    // the message stays sensible, rather than echoing whatever garbage came
+    // in. The graceful-degradation policy is preserved: no throw.
+    return emptyBodyHint('unknown');
+  }
+
+  const templatesDir = (opts && typeof opts.templatesDir === 'string')
+    ? opts.templatesDir
+    : TEMPLATES_DIR;
+  const templatePath = join(templatesDir, `discipline-${type}.md`);
+  if (!existsSync(templatePath)) {
+    throw new Error(
+      `selectDisciplineTemplate: template file missing for type "${type}" at ${templatePath}`,
+    );
+  }
+
+  return readFileSync(templatePath, 'utf8');
+}
+
+// ---------------------------------------------------------------------------
+// detectProjectTypeFromRepo -- frontmatter + file-signal fallback
+// ---------------------------------------------------------------------------
+
+/**
+ * Inline frontmatter parser -- minimal, zero deps.
+ * Reads only the `type` key from the first YAML fence (--- ... ---).
+ *
+ * Mirrors parseFrontmatter in mcp-server/src/memory/reader.js.
+ *
+ * @param {string} raw  file contents
+ * @returns {string|null}  value of `type` key, or null if absent
+ */
+function extractTypeFromFrontmatter(raw) {
+  const stripped = String(raw).replace(/^/, '').replace(/^\s+/, '');
+  const m = stripped.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return null;
+  for (const line of m[1].split('\n')) {
+    const kv = line.match(/^type:\s*(.+)/i);
+    if (kv) return kv[1].trim().toLowerCase();
+  }
+  return null;
+}
+
+/**
+ * Return true if `name` is a direct child of `repoRoot` that is a directory
+ * AND contains at least one `.md` file. Avoids false-positive on plain files
+ * named `chapters` or `manuscript`.
+ *
+ * @param {string} repoRoot
+ * @param {string} name  directory name to check
+ * @returns {boolean}
+ */
+function isDirWithMd(repoRoot, name) {
+  const p = join(repoRoot, name);
+  try {
+    if (!statSync(p).isDirectory()) return false;
+    return readdirSync(p).some((n) => n.endsWith('.md'));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Detect the project type from a repository root.
+ *
+ * Priority:
+ *   (a) .ijfw/memory/brief.md frontmatter `type` key -- set by brainstorm-LOCK.
+ *   (b) Well-known file/dir signals via existsSync (no glob, cheap).
+ *
+ * Signal table (first match wins within each tier):
+ *   code:      package.json | tsconfig.json | Cargo.toml | go.mod |
+ *              *.csproj | pyproject.toml | setup.py | Gemfile
+ *   narrative: chapters/ dir | manuscript/ dir
+ *   business:  pitch-deck* | business-plan* | *.numbers
+ *   design:    figma-* | *.sketch | design-system/ dir
+ *   research:  research/ dir | notebooks/ dir | *.ipynb
+ *   unknown:   fallback
+ *
+ * @param {string} repoRoot  absolute path to repository root
+ * @returns {'code'|'narrative'|'business'|'design'|'research'|'unknown'}
+ */
+export function detectProjectTypeFromRepo(repoRoot) {
+  if (!repoRoot || typeof repoRoot !== 'string') {
+    return 'unknown';
+  }
+
+  // (a) Brief.md frontmatter -- highest fidelity
+  const briefPath = join(repoRoot, '.ijfw', 'memory', 'brief.md');
+  if (existsSync(briefPath)) {
+    try {
+      const guard = validateSafeRepoPath(repoRoot, briefPath);
+      if (guard.ok) {
+        const briefStat = statSync(briefPath);
+        if (briefStat.size <= 256 * 1024) {
+          const raw = readFileSync(briefPath, 'utf8');
+          const type = extractTypeFromFrontmatter(raw);
+          if (type && (TYPED_CODES.has(type) || EMPTY_BODY_CODES.has(type))) {
+            return /** @type {any} */ (type);
+          }
+        }
+        // brief.md too large -- fall through to file signals
+      }
+      // symlink outside repo (guard.ok === false) -- skip frontmatter
+    } catch {
+      // Brief read failure is non-fatal -- fall through to file signals.
+    }
+  }
+
+  // (b) File-signal fallback -- read root entries once, then use cached list.
+  // Priority: earlier tier wins. e.g., pyproject.toml beats notebooks/ when both present (code projects may contain notebooks).
+  let _entries = null;
+  try { _entries = readdirSync(repoRoot); } catch { _entries = []; }
+  function has(predicate) { return _entries.some(predicate); }
+
+  // --- code signals ---
+  const CODE_FILES = [
+    'package.json', 'tsconfig.json', 'Cargo.toml', 'go.mod',
+    'pyproject.toml', 'setup.py', 'Gemfile',
+  ];
+  for (const f of CODE_FILES) {
+    if (_entries.includes(f)) return 'code';
+  }
+  // *.csproj -- project-named file; scan cached root entries.
+  if (has((n) => n.endsWith('.csproj'))) return 'code';
+
+  // --- narrative signals --- (must be a directory containing at least one .md)
+  if (isDirWithMd(repoRoot, 'chapters') || isDirWithMd(repoRoot, 'manuscript')) return 'narrative';
+
+  // --- business signals ---
+  if (
+    has((n) => n.startsWith('pitch-deck')) ||
+    has((n) => n.startsWith('business-plan')) ||
+    has((n) => n.endsWith('.numbers'))
+  ) return 'business';
+
+  // --- design signals ---
+  if (
+    has((n) => n.startsWith('figma-')) ||
+    has((n) => n.endsWith('.sketch')) ||
+    _entries.includes('design-system')
+  ) return 'design';
+
+  // --- research signals ---
+  if (
+    _entries.includes('research') ||
+    _entries.includes('notebooks') ||
+    has((n) => n.endsWith('.ipynb'))
+  ) return 'research';
+
+  return 'unknown';
+}

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/state-sdk.js

@@ -37,9 +37,9 @@
  */
 
 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';
@@ -1159,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,

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/recovery/code-fixer.js

@@ -470,7 +470,7 @@ async function applyEdit(filePath, fix) {
     // Exactly-one occurrence guarantee — same rule the Edit tool uses.
     const occurrences = before.split(fix.old_string).length - 1;
     if (occurrences > 1 && !fix.replace_all) {
-      return { ok: false, evidence: `old_string occurs ${occurrences}×; ambiguous`, before };
+      return { ok: false, evidence: `old_string occurs ${occurrences}x; ambiguous`, before };
     }
     after = fix.replace_all
       ? before.split(fix.old_string).join(fix.new_string)