session-orchestrator 3.16.0

package/scripts/lib/common.mjs

@@ -0,0 +1,333 @@
+/**
+ * common.mjs — Shared I/O utilities for session-orchestrator scripts.
+ *
+ * Pure ESM, Node stdlib only. Replaces the generic helpers from common.sh.
+ *
+ * Part of v3.0.0 migration (Epic #124, issue #136).
+ * Shell-helper ports added for issue #218.
+ */
+
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { promises as fs, existsSync, statSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+
+// ---------------------------------------------------------------------------
+// Path helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns a unique temp path (does NOT create the file/directory).
+ * @param {string} prefix - non-empty string prepended to the filename
+ * @returns {string}
+ */
+export function makeTmpPath(prefix) {
+  if (typeof prefix !== 'string' || prefix.length === 0) {
+    throw new TypeError('makeTmpPath: prefix must be a non-empty string');
+  }
+  const rand = crypto.randomBytes(4).toString('hex');
+  return path.join(os.tmpdir(), `${prefix}-${Date.now()}-${rand}`);
+}
+
+/**
+ * Expand a leading `~` (home-directory shorthand) to the current user's home
+ * directory. Non-`~`-prefixed strings, non-strings, and the empty string pass
+ * through unchanged.
+ *
+ * Canonical shared implementation for vault-dir-consuming call-sites added
+ * under Epic #774 (docs Public-Split) — see `scripts/lib/vault-archive.mjs`
+ * and `scripts/export-hw-learnings.mjs`. Several pre-existing inline copies
+ * of this exact shape (e.g. `scripts/lib/vault-status/board-writer.mjs`,
+ * `narrative-mirror.mjs`, `scripts/lib/dispatcher/enumerate.mjs`) are
+ * intentionally NOT migrated to this shared helper here — that consolidation
+ * is a separate follow-up, not this fix's scope.
+ *
+ * @param {string} p
+ * @returns {string}
+ */
+export function expandTilde(p) {
+  if (typeof p !== 'string' || p.length === 0) return p;
+  if (p === '~') return os.homedir();
+  if (p.startsWith('~/')) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+
+// ---------------------------------------------------------------------------
+// Timestamp helpers
+// ---------------------------------------------------------------------------
+
+/** Returns the current time as an ISO 8601 UTC string. */
+export function utcTimestamp() {
+  return new Date().toISOString();
+}
+
+/** Returns the current Unix time in milliseconds. */
+export function epochMs() {
+  return Date.now();
+}
+
+// ---------------------------------------------------------------------------
+// JSON file helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Reads and parses a JSON file; throws on missing file or parse error.
+ * @param {string} filePath
+ * @returns {Promise<unknown>}
+ */
+export async function readJson(filePath) {
+  const raw = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(raw);
+}
+
+/**
+ * Serialises obj as pretty-printed JSON and writes it to filePath,
+ * creating any missing parent directories automatically.
+ * @param {string} filePath
+ * @param {unknown} obj
+ * @returns {Promise<void>}
+ */
+export async function writeJson(filePath, obj) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(obj, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Appends obj as a single JSONL line to filePath, creating missing parent
+ * directories automatically. Single appendFile call — atomic for lines under
+ * PIPE_BUF (4 KiB).
+ * @param {string} filePath
+ * @param {unknown} obj
+ * @returns {Promise<void>}
+ */
+export async function appendJsonl(filePath, obj) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.appendFile(filePath, JSON.stringify(obj) + '\n', 'utf8');
+}
+
+// ---------------------------------------------------------------------------
+// Shell-helper ports (issue #218) — equivalents of common.sh functions
+// ---------------------------------------------------------------------------
+
+/**
+ * Print an error message to stderr and exit with code 1.
+ * Equivalent to die() in common.sh.
+ * @param {string} message
+ * @returns {never}
+ */
+export function die(message) {
+  process.stderr.write(`ERROR: ${message}\n`);
+  process.exit(1);
+}
+
+/**
+ * Print a warning message to stderr (does not exit).
+ * Equivalent to warn() in common.sh.
+ * @param {string} message
+ */
+export function warn(message) {
+  process.stderr.write(`WARNING: ${message}\n`);
+}
+
+/**
+ * Verify that jq is available on PATH.
+ * Throws an Error if jq is not found (instead of exiting, so callers can decide).
+ * For scripts that want exit-on-failure behaviour, wrap with die():
+ *   try { requireJq(); } catch (e) { die(e.message); }
+ * Equivalent to require_jq() in common.sh.
+ * @returns {void}
+ * @throws {Error} when jq is not on PATH
+ */
+export function requireJq() {
+  try {
+    execSync('command -v jq', { stdio: 'ignore', shell: true });
+  } catch {
+    throw new Error('jq is required but not installed. Install via: brew install jq');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers for project/plugin root detection
+// ---------------------------------------------------------------------------
+
+/** Return true when `dir` exists as a directory. */
+function _isDirSync(dir) {
+  try { return statSync(dir).isDirectory(); } catch { return false; }
+}
+
+/** Return true when `file` exists (file or directory). */
+function _isFileSync(file) {
+  return existsSync(file);
+}
+
+/**
+ * Walk up the directory tree from `startDir` until a directory satisfying
+ * `predicate(dir)` is found. Returns the matching directory or null.
+ * @param {string} startDir
+ * @param {(dir: string) => boolean} predicate
+ * @returns {string|null}
+ */
+function _walkUpUntil(startDir, predicate) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    if (predicate(dir)) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break; // reached filesystem root
+    dir = parent;
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// findProjectRoot
+// ---------------------------------------------------------------------------
+
+/**
+ * Walk up from `startDir` (defaults to process.cwd()) looking for CLAUDE.md,
+ * .claude/, AGENTS.md, .codex/, or .pi/ markers. Returns the found project root, or
+ * `startDir` if nothing is found.
+ *
+ * Respects CLAUDE_PROJECT_DIR, CODEX_PROJECT_DIR, and PI_PROJECT_DIR environment variables as
+ * fast-paths (same semantics as common.sh find_project_root).
+ *
+ * Equivalent to find_project_root() in common.sh.
+ *
+ * @param {string} [startDir] - directory to start the walk from (default: process.cwd())
+ * @returns {string} Absolute path of the project root
+ */
+export function findProjectRoot(startDir) {
+  const base = startDir ? path.resolve(startDir) : process.cwd();
+
+  // Fast path: CLAUDE_PROJECT_DIR
+  const claudeDir = process.env.CLAUDE_PROJECT_DIR;
+  if (claudeDir) {
+    if (_isFileSync(path.join(claudeDir, 'CLAUDE.md')) || _isDirSync(path.join(claudeDir, '.claude'))) {
+      return claudeDir;
+    }
+  }
+
+  // Fast path: CODEX_PROJECT_DIR
+  const codexDir = process.env.CODEX_PROJECT_DIR;
+  if (codexDir) {
+    if (_isFileSync(path.join(codexDir, 'AGENTS.md')) || _isDirSync(path.join(codexDir, '.codex'))) {
+      return codexDir;
+    }
+  }
+
+  // Fast path: PI_PROJECT_DIR
+  const piDir = process.env.PI_PROJECT_DIR;
+  if (piDir) {
+    if (_isFileSync(path.join(piDir, 'AGENTS.md')) || _isDirSync(path.join(piDir, '.pi'))) {
+      return piDir;
+    }
+  }
+
+  const found = _walkUpUntil(base, (dir) =>
+    _isFileSync(path.join(dir, 'CLAUDE.md')) ||
+    _isDirSync(path.join(dir, '.claude')) ||
+    _isFileSync(path.join(dir, 'AGENTS.md')) ||
+    _isDirSync(path.join(dir, '.codex')) ||
+    _isDirSync(path.join(dir, '.pi')),
+  );
+
+  return found ?? base;
+}
+
+// ---------------------------------------------------------------------------
+// resolvePluginRoot
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the session-orchestrator plugin root directory.
+ *
+ * Resolution order (stops at first success):
+ *   1. CLAUDE_PLUGIN_ROOT env var
+ *   2. CODEX_PLUGIN_ROOT  env var
+ *   3. PI_PLUGIN_ROOT     env var
+ *   4. Walk up from import.meta.url of this file looking for plugin.json / skills/ / .codex-plugin/
+ *   5. Walk up from process.cwd() looking for the same markers
+ *
+ * Equivalent to resolve_plugin_root() in common.sh, but throws instead of calling die()
+ * so that callers in a non-process context (tests) can catch the error.
+ *
+ * @param {string} [callerUrl] - import.meta.url of the calling module (optional override for level-3 walk)
+ * @returns {string} Absolute path to the plugin root
+ * @throws {Error} when all resolution levels fail
+ */
+export function resolvePluginRoot(callerUrl) {
+  const isPluginDir = (dir) =>
+    _isFileSync(path.join(dir, 'plugin.json')) ||
+    _isDirSync(path.join(dir, 'skills')) ||
+    _isDirSync(path.join(dir, '.codex-plugin'));
+
+  // Level 1: CLAUDE_PLUGIN_ROOT
+  const claudeRoot = process.env.CLAUDE_PLUGIN_ROOT;
+  if (claudeRoot && _isDirSync(claudeRoot)) return claudeRoot;
+
+  // Level 2: CODEX_PLUGIN_ROOT
+  const codexRoot = process.env.CODEX_PLUGIN_ROOT;
+  if (codexRoot && _isDirSync(codexRoot)) return codexRoot;
+
+  // Level 3: PI_PLUGIN_ROOT
+  const piRoot = process.env.PI_PLUGIN_ROOT;
+  if (piRoot && _isDirSync(piRoot)) return piRoot;
+
+  // Level 4: walk up from caller / this file
+  const startFromFile = callerUrl
+    ? path.dirname(fileURLToPath(callerUrl))
+    : path.dirname(fileURLToPath(import.meta.url));
+  const byFile = _walkUpUntil(startFromFile, isPluginDir);
+  if (byFile) return byFile;
+
+  // Level 5: walk up from cwd
+  const byCwd = _walkUpUntil(process.cwd(), isPluginDir);
+  if (byCwd) return byCwd;
+
+  throw new Error(
+    'Could not locate plugin root. Set CLAUDE_PLUGIN_ROOT, CODEX_PLUGIN_ROOT, or PI_PLUGIN_ROOT to the plugin directory, ' +
+    'or ensure plugin.json / skills/ exists in an ancestor of the cwd.',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// resolveInstructionFile (issue #33)
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the canonical project-instruction file at the given repo root.
+ *
+ * `CLAUDE.md` (Claude Code / Cursor IDE) and `AGENTS.md` (Codex CLI) are
+ * transparent aliases. Precedence:
+ *
+ *   1. `<repoRoot>/CLAUDE.md` exists and is non-empty → kind: 'claude'
+ *   2. `<repoRoot>/AGENTS.md` exists and is non-empty → kind: 'agents'
+ *   3. otherwise → null (caller decides what to do)
+ *
+ * Never merge both. Never read both. Pick one.
+ *
+ * SSOT for the alias rule: `skills/_shared/instruction-file-resolution.md`.
+ *
+ * @param {string} [repoRoot] - absolute repo root (default: findProjectRoot())
+ * @returns {{ path: string, kind: 'claude' | 'agents' } | null}
+ */
+export function resolveInstructionFile(repoRoot) {
+  const root = repoRoot ?? findProjectRoot();
+  if (!root) return null;
+  const candidates = [
+    { file: 'CLAUDE.md', kind: 'claude' },
+    { file: 'AGENTS.md', kind: 'agents' },
+  ];
+  for (const c of candidates) {
+    const p = path.join(root, c.file);
+    if (existsSync(p)) {
+      try {
+        if (statSync(p).size > 0) return { path: p, kind: c.kind };
+      } catch {
+        // stat failure (race, permissions) — skip this candidate, try next
+      }
+    }
+  }
+  return null;
+}

package/scripts/lib/config/auto-dream.mjs

@@ -0,0 +1,77 @@
+import { matchBlockHeader } from './block-header.mjs';
+
+/**
+ * auto-dream.mjs — Parser for the top-level `auto-dream:` YAML block (issue #566).
+ *
+ * Returns `{ "min-confidence": float in [0.0, 1.0] }`.
+ * Tolerant parser: malformed values silently fall back to defaults.
+ *
+ * Consumer: `scripts/lib/memory-proposals/collector.mjs` reads the value via
+ * Session Config and applies the filter inside `collectProposals()` at
+ * session-end Phase 3.6.3 (collect-emit time). This is a SECOND confidence
+ * gate above the existing write-time `memory.proposals.confidence-floor`
+ * floor enforced by `scripts/memory-propose.mjs`.
+ *
+ * Structurally mirrors `scripts/lib/config/cold-start.mjs` (single-level
+ * nested block, top-level boundary detection). Float-range validation copied
+ * verbatim from `scripts/lib/config/vault-mirror-quality.mjs:69-73`.
+ */
+
+/**
+ * Parse the top-level `auto-dream:` YAML block from markdown content.
+ * Independent of the `## Session Config` section boundary.
+ *
+ * Defaults:
+ *   min-confidence: 0.5 (float in [0.0, 1.0])
+ *
+ * @param {string} content — full file contents
+ * @returns {{ "min-confidence": number }}
+ */
+export function _parseAutoDream(content) {
+  const defaults = {
+    'min-confidence': 0.5,
+  };
+
+  const lines = content.split(/\r?\n/);
+  let inBlock = false;
+  const blockLines = [];
+
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\r$/, '');
+    if (!inBlock) {
+      if (matchBlockHeader(line, 'auto-dream')) inBlock = true;
+      continue;
+    }
+    if (line.length > 0 && !/^\s/.test(line)) break;
+    blockLines.push(line);
+  }
+
+  if (blockLines.length === 0) return defaults;
+
+  let minConfidence = 0.5;
+
+  for (const rawLine of blockLines) {
+    const clean = rawLine.replace(/\s*#.*$/, '').replace(/\s+$/, '');
+    if (!clean.trim()) continue;
+
+    const kvMatch = clean.match(/^\s+([a-zA-Z_-]+):\s*(.*)/);
+    if (!kvMatch) continue;
+
+    const k = kvMatch[1];
+    let v = kvMatch[2].trim();
+    if (v.startsWith('"') && v.endsWith('"') && v.length >= 2) v = v.slice(1, -1);
+    else if (v.startsWith("'") && v.endsWith("'") && v.length >= 2) v = v.slice(1, -1);
+
+    if (k === 'min-confidence') {
+      // Float-range validation copied verbatim from vault-mirror-quality.mjs:69-73.
+      if (/^\d+(\.\d+)?$/.test(v)) {
+        const f = parseFloat(v);
+        if (Number.isFinite(f) && f >= 0.0 && f <= 1.0) minConfidence = f;
+      }
+    }
+  }
+
+  return {
+    'min-confidence': minConfidence,
+  };
+}

package/scripts/lib/config/block-header.mjs

@@ -0,0 +1,94 @@
+/**
+ * block-header.mjs — Shared bold-tolerant top-level block-header matcher (#830).
+ *
+ * Session Config blocks in CLAUDE.md / AGENTS.md may render as a bold-bullet
+ * `- **key:**` markdown form rather than a plain `key:` line. Parsers that used
+ * the strict `/^<key>:\s*$/` regex silently MISSED the bold form → the block was
+ * never entered → all defaults applied with no error surfaced anywhere. #823
+ * fixed only vault-integration.mjs; this module generalises the tolerance so
+ * every block parser matches the same set of header forms.
+ *
+ * ZERO IMPORTS by design: tests/lib/config/cycle-guard.test.mjs forbids any
+ * scripts/lib/config/*.mjs from importing ../config.mjs. This module keeps a
+ * clean leaf with no dependencies at all so every sub-parser can adopt it
+ * without any cycle risk.
+ *
+ * RAW-PARITY constraint (#830 / claude-md-drift-check): the checker imports these
+ * parsers directly and feeds RAW file content. Normalisation therefore lives
+ * INSIDE the helper each parser calls — never in a preprocessing step in
+ * config.mjs — so both the config.mjs path and the direct-import checker path
+ * see identical tolerance by construction.
+ *
+ * LOAD-BEARING semantics — the accepted / rejected form set is a contract:
+ *   MATCH (top-level block header for `key`), each with optional trailing ws:
+ *     key:            - key:            **key:**            - **key:**
+ *   NO MATCH (intentionally):
+ *     key: value      — a header carrying a value is not a block-opener
+ *     key:  # note    — inline comment on the header line (the documented
+ *                       custom-phases / eval gotcha stays broken-by-design)
+ *     '  key:'        — indented line (a sub-key of some other block)
+ *     other-key:      — a different key
+ *
+ * The two `**` markers are independent (`**key:` and `key:**` both match),
+ * mirroring the tolerant #823 vault-integration regex.
+ */
+
+/**
+ * Escape regex metacharacters in a literal key so a key like `a.b` or `a+b`
+ * is matched literally rather than as a pattern. Defensive: current keys are
+ * plain `[a-z-]` slugs (`-` is a literal outside a character class), but the
+ * dynamic callers (persona-gate-wave / wave-reviewers) pass a variable `key`.
+ *
+ * @param {string} s
+ * @returns {string}
+ */
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Build the single-line block-header regex for a key.
+ *
+ * Equivalent to: `^(?:-\s+)?(?:\*\*)?<key>:(?:\*\*)?\s*$`. Not multiline — it is
+ * tested against one already-split line.
+ *
+ * @param {string} key
+ * @returns {RegExp}
+ */
+function blockHeaderRe(key) {
+  return new RegExp('^(?:-\\s+)?(?:\\*\\*)?' + escapeRegExp(key) + ':(?:\\*\\*)?\\s*$');
+}
+
+/**
+ * True when `line` opens the top-level block for `key` — tolerant of the
+ * bold-bullet markdown rendering (`- **key:**`). Pure boolean, no side effects.
+ *
+ * @param {string} line — a single line (callers strip the trailing `\n`; a stray
+ *   trailing `\r` is tolerated by the `\s*$` tail)
+ * @param {string} key — the literal block key (e.g. 'eval', 'broken-window-budget')
+ * @returns {boolean}
+ */
+export function matchBlockHeader(line, key) {
+  if (typeof line !== 'string' || typeof key !== 'string' || key === '') return false;
+  return blockHeaderRe(key).test(line);
+}
+
+/**
+ * Multiline presence variant: true when ANY line of `content` opens the
+ * top-level block for `key`. For whole-file PRESENCE guards (e.g.
+ * dispatcher-autonomy-capture's `BLOCK_HEADER_RE`). Pure boolean.
+ *
+ * @param {string} content — full file contents
+ * @param {string} key
+ * @returns {boolean}
+ */
+export function hasBlockHeader(content, key) {
+  if (typeof content !== 'string' || content === '' || typeof key !== 'string' || key === '') {
+    return false;
+  }
+  const re = blockHeaderRe(key);
+  for (const rawLine of content.split(/\r?\n/)) {
+    if (re.test(rawLine)) return true;
+  }
+  return false;
+}

package/scripts/lib/config/broken-window.mjs

@@ -0,0 +1,114 @@
+import { matchBlockHeader } from './block-header.mjs';
+
+/**
+ * broken-window.mjs — Parser for the top-level `broken-window-budget:` YAML block
+ * (#730 Epic H / H5 — "Broken-Window Budget").
+ *
+ * Drives session-end Phase 2.6: a "shipped-but-broken" shipment (Full-Gate PASS
+ * with documented exceptions, overridden findings) mechanically files a
+ * hard-terminated closure issue + Override-Ratio tracking via events.jsonl.
+ *
+ * Returns `{ enabled, "due-days" }`.
+ * Tolerant parser: malformed values silently fall back to defaults, EXCEPT
+ * `due-days` — a malformed, non-positive, or non-integer value emits a stderr
+ * WARN before falling back (mirrors the handover-gate `max-open-questions`
+ * WARN discipline: a runtime-critical bound deserves a loud fallback).
+ *
+ * Consumer: `scripts/lib/config.mjs`, `skills/session-end/SKILL.md` Phase 2.6.
+ */
+
+// Upper bound for due-days (~10 years). Guards against Date#setUTCDate
+// overflowing into an Invalid Date downstream (#794 GAP-4).
+const MAX_DUE_DAYS = 3650;
+
+/**
+ * Parse the top-level `broken-window-budget:` YAML block from markdown content.
+ * Independent of the `## Session Config` section boundary.
+ *
+ * Defaults:
+ *   enabled:  false (opt-in — the whole Phase 2.6 is silent when disabled)
+ *   due-days: 7 (integer >= 1 and <= 3650 [~10 years]; the closure issue's hard
+ *             due-date = today + this). Malformed, non-integer, < 1, or > 3650
+ *             input falls back to 7 and emits a stderr WARN. The upper bound
+ *             guards against `Date#setUTCDate` overflowing into an Invalid Date
+ *             (RangeError on `.toISOString()` downstream in
+ *             `spiral-carryover.mjs` `computeDueDate` — #794 GAP-4).
+ *
+ * YAML shape:
+ *   broken-window-budget:
+ *     enabled: false
+ *     due-days: 7
+ *
+ * @param {string} content — full file contents
+ * @returns {{ enabled: boolean, "due-days": number }}
+ */
+export function _parseBrokenWindow(content) {
+  const defaults = {
+    enabled: false,
+    'due-days': 7,
+  };
+
+  const lines = String(content ?? '').split(/\r?\n/);
+  let inBlock = false;
+  const blockLines = [];
+
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\r$/, '');
+    if (!inBlock) {
+      if (matchBlockHeader(line, 'broken-window-budget')) inBlock = true;
+      continue;
+    }
+    // Stop at next column-0 non-empty line (sibling top-level key or H2 heading)
+    if (line.length > 0 && !/^\s/.test(line)) break;
+    blockLines.push(line);
+  }
+
+  if (blockLines.length === 0) return defaults;
+
+  let enabled = false;
+  let dueDays = 7;
+
+  for (const rawLine of blockLines) {
+    // Strip inline comments and trailing whitespace
+    const clean = rawLine.replace(/\s*#.*$/, '').replace(/\s+$/, '');
+    if (!clean.trim()) continue;
+
+    const kvMatch = clean.match(/^\s+([a-zA-Z_-]+):\s*(.*)/);
+    if (!kvMatch) continue;
+
+    const k = kvMatch[1];
+    let v = kvMatch[2].trim();
+    if (v.startsWith('"') && v.endsWith('"') && v.length >= 2) v = v.slice(1, -1);
+    else if (v.startsWith("'") && v.endsWith("'") && v.length >= 2) v = v.slice(1, -1);
+
+    switch (k) {
+      case 'enabled':
+        // Default is false → only flip to true on explicit "true"
+        enabled = v.toLowerCase() === 'true';
+        break;
+
+      case 'due-days': {
+        const parsed = /^\d+$/.test(v) ? parseInt(v, 10) : NaN;
+        if (Number.isInteger(parsed) && parsed >= 1 && parsed <= MAX_DUE_DAYS) {
+          // Positive integer within bounds (>= 1 — a 0-day due-date is
+          // nonsensical for a hard-terminated closure issue; <= MAX_DUE_DAYS —
+          // guards against Date overflow downstream, #794 GAP-4).
+          dueDays = parsed;
+        } else {
+          // Malformed (non-numeric, empty), non-integer, < 1, or > MAX_DUE_DAYS
+          // — emit a stderr WARN on this fallback path (handover-gate parity).
+          process.stderr.write(
+            `⚠ broken-window-budget.due-days: '${v}' invalid — falling back to 7\n`
+          );
+          dueDays = 7;
+        }
+        break;
+      }
+    }
+  }
+
+  return {
+    enabled,
+    'due-days': dueDays,
+  };
+}