session-orchestrator 3.16.0

package/scripts/lib/config/persona-gate-wave.mjs

@@ -0,0 +1,258 @@
+/**
+ * persona-gate-wave.mjs — Parser for the `persona-gate-wave:` Session Config block (#458).
+ *
+ * Mirrors `wave-reviewers.mjs` pattern: pure parser, no I/O, no side effects.
+ * Returns `null` when the block is absent; returns a normalised config object
+ * when present. Throws on malformed input (e.g. unparseable threshold).
+ *
+ * Fields:
+ *   enabled         — boolean              (default: false)
+ *   after           — 'quality' | 'impl-polish'  (default: 'quality')
+ *   threshold       — string spec parsed via parseThreshold (default: 'all')
+ *   personas        — string[] (each matches SAFE_PERSONA_NAME_RE)  (default: [])
+ *   dispatch-model  — model alias or full ID  (default: 'claude-opus-4-7')
+ *   mode            — 'off' | 'warn' | 'strict'  (default: 'off')
+ *
+ * Used by skills/wave-executor/wave-loop.md § 3b: Persona-Gate Hook to decide
+ * whether to fan out a persona-panel review after a wave completes.
+ */
+
+import { parseThreshold } from '../persona-panel/threshold.mjs';
+import { ALLOWED_MODEL_ALIASES, MODEL_ID_RE } from '../agent-frontmatter.mjs';
+import { matchBlockHeader } from './block-header.mjs';
+
+const ALLOWED_AFTER = new Set(['quality', 'impl-polish']);
+const ALLOWED_MODE = new Set(['off', 'warn', 'strict']);
+const SAFE_PERSONA_NAME_RE = /^[a-z0-9-]{1,64}$/;
+
+const DEFAULTS = Object.freeze({
+  enabled: false,
+  after: 'quality',
+  threshold: 'all',
+  threshold_parsed: null,  // cached ParsedThreshold result; populated by _normalizePersonaGateWave
+  personas: [],
+  'dispatch-model': 'claude-opus-4-7',
+  mode: 'off',
+});
+
+/**
+ * Parse the `persona-gate-wave:` YAML block from markdown content.
+ *
+ * Returns `null` when the block is absent. Returns a normalised config object
+ * (with defaults applied) when present. Throws on validation failure so the
+ * caller can surface the precise error to the operator.
+ *
+ * @param {string} content — full CLAUDE.md / AGENTS.md file content
+ * @returns {null | {enabled: boolean, after: string, threshold: string, threshold_parsed: {kind: string, m?: number, n?: number}, personas: string[], 'dispatch-model': string, mode: string}}
+ */
+export function _parsePersonaGateWave(content) {
+  const blockLines = _extractBlock(content, 'persona-gate-wave');
+  if (blockLines.length === 0) return null;
+
+  const parsed = _parseBlockLines(blockLines);
+  return _normalizePersonaGateWave(parsed);
+}
+
+/**
+ * Validate and normalise a parsed config object. Pure function — applies
+ * defaults and throws on any field that fails validation.
+ *
+ * @param {object} parsed — raw parsed object (possibly missing fields)
+ * @returns {{enabled: boolean, after: string, threshold: string, threshold_parsed: {kind: string, m?: number, n?: number}, personas: string[], 'dispatch-model': string, mode: string}}
+ */
+export function _normalizePersonaGateWave(parsed) {
+  const out = { ...DEFAULTS };
+
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(
+      `persona-gate-wave: expected an object (got ${Array.isArray(parsed) ? 'array' : typeof parsed})`,
+    );
+  }
+
+  // enabled
+  if (parsed.enabled !== undefined) {
+    if (typeof parsed.enabled !== 'boolean') {
+      throw new Error(
+        `persona-gate-wave.enabled must be a boolean (got ${JSON.stringify(parsed.enabled)})`,
+      );
+    }
+    out.enabled = parsed.enabled;
+  }
+
+  // after
+  if (parsed.after !== undefined) {
+    if (typeof parsed.after !== 'string' || !ALLOWED_AFTER.has(parsed.after)) {
+      throw new Error(
+        `persona-gate-wave.after must be one of ${[...ALLOWED_AFTER].map((a) => JSON.stringify(a)).join('|')} (got ${JSON.stringify(parsed.after)})`,
+      );
+    }
+    out.after = parsed.after;
+  }
+
+  // threshold — parsed via parseThreshold (throws InvalidThresholdError on failure)
+  if (parsed.threshold !== undefined) {
+    if (typeof parsed.threshold !== 'string') {
+      throw new Error(
+        `persona-gate-wave.threshold must be a string (got ${typeof parsed.threshold})`,
+      );
+    }
+    // parseThreshold throws InvalidThresholdError on bad spec; let it propagate
+    // Store the result as threshold_parsed so callers avoid re-parsing at dispatch time.
+    out.threshold_parsed = parseThreshold(parsed.threshold);
+    out.threshold = parsed.threshold;
+  } else {
+    // Populate threshold_parsed from the default threshold string so it is always non-null.
+    out.threshold_parsed = parseThreshold(DEFAULTS.threshold);
+  }
+
+  // personas — array of strings each matching SAFE_PERSONA_NAME_RE
+  if (parsed.personas !== undefined) {
+    if (!Array.isArray(parsed.personas)) {
+      throw new Error(
+        `persona-gate-wave.personas must be an array (got ${typeof parsed.personas})`,
+      );
+    }
+    for (const p of parsed.personas) {
+      if (typeof p !== 'string') {
+        throw new Error(
+          `persona-gate-wave.personas[] entries must be strings (got ${typeof p})`,
+        );
+      }
+      if (!SAFE_PERSONA_NAME_RE.test(p)) {
+        throw new Error(
+          `persona-gate-wave.personas[] entry ${JSON.stringify(p)} must match ${SAFE_PERSONA_NAME_RE} (lowercase, digits, hyphens, ≤64 chars)`,
+        );
+      }
+    }
+    out.personas = [...parsed.personas];
+  }
+
+  // dispatch-model — alias OR full model ID (reuses agent-frontmatter.mjs semantics)
+  if (parsed['dispatch-model'] !== undefined) {
+    const m = parsed['dispatch-model'];
+    if (typeof m !== 'string' || m === '') {
+      throw new Error(
+        `persona-gate-wave.dispatch-model must be a non-empty string (got ${JSON.stringify(m)})`,
+      );
+    }
+    if (!ALLOWED_MODEL_ALIASES.has(m) && !MODEL_ID_RE.test(m)) {
+      throw new Error(
+        `persona-gate-wave.dispatch-model must be one of ${[...ALLOWED_MODEL_ALIASES].map((a) => JSON.stringify(a)).join('|')} or a full model ID like "claude-opus-4-7" (got ${JSON.stringify(m)})`,
+      );
+    }
+    out['dispatch-model'] = m;
+  }
+
+  // mode
+  if (parsed.mode !== undefined) {
+    if (typeof parsed.mode !== 'string' || !ALLOWED_MODE.has(parsed.mode)) {
+      throw new Error(
+        `persona-gate-wave.mode must be one of ${[...ALLOWED_MODE].map((a) => JSON.stringify(a)).join('|')} (got ${JSON.stringify(parsed.mode)})`,
+      );
+    }
+    out.mode = parsed.mode;
+  }
+
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers — block extraction + line parsing
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract the indented block lines for a given top-level key from markdown
+ * content. Returns an empty array when the key is not present.
+ *
+ * @param {string} content
+ * @param {string} key — e.g. 'persona-gate-wave'
+ * @returns {string[]}
+ */
+function _extractBlock(content, key) {
+  const lines = content.split(/\r?\n/);
+  const blockLines = [];
+  let inBlock = false;
+
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\r$/, '');
+    if (!inBlock) {
+      if (matchBlockHeader(line, key)) {
+        inBlock = true;
+      }
+      continue;
+    }
+    // Stop at a non-empty line with no leading whitespace (next top-level key)
+    if (line.length > 0 && !/^\s/.test(line)) break;
+    blockLines.push(line);
+  }
+
+  return blockLines;
+}
+
+/**
+ * Parse the indented block lines into a raw object (defaults NOT applied here —
+ * normalisation happens in _normalizePersonaGateWave).
+ *
+ * Accepts:
+ *   - scalars: `enabled: true`, `mode: warn`, `after: quality`
+ *   - inline arrays: `personas: []`, `personas: [a, b, c]`
+ *   - quoted strings: `threshold: "5-of-6"` or `threshold: '5-of-6'`
+ *
+ * @param {string[]} blockLines
+ * @returns {object}
+ */
+function _parseBlockLines(blockLines) {
+  /** @type {Record<string, unknown>} */
+  const out = {};
+
+  for (const rawLine of blockLines) {
+    // Strip inline comments + trailing whitespace
+    const clean = rawLine.replace(/\s*#.*$/, '').replace(/\s+$/, '');
+    if (!clean.trim()) continue;
+
+    const kvMatch = clean.match(/^\s+([a-zA-Z][a-zA-Z0-9_-]*):\s*(.*)/);
+    if (!kvMatch) continue;
+
+    const k = kvMatch[1];
+    let v = kvMatch[2].trim();
+
+    // Strip surrounding quotes
+    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': {
+        const low = v.toLowerCase();
+        if (low === 'true') out.enabled = true;
+        else if (low === 'false') out.enabled = false;
+        else out.enabled = v; // let normaliser raise the precise error
+        break;
+      }
+      case 'after':
+      case 'mode':
+      case 'threshold':
+      case 'dispatch-model':
+        out[k] = v;
+        break;
+      case 'personas': {
+        // Inline array notation: [] or [a, b, c]
+        const stripped = v.replace(/^\s*\[/, '').replace(/\]\s*$/, '').trim();
+        if (stripped === '') {
+          out.personas = [];
+        } else {
+          out.personas = stripped
+            .split(',')
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+        }
+        break;
+      }
+      default:
+        // Unknown keys are silently ignored — additive-friendly. The
+        // normaliser does not check for unknown keys (mirrors wave-reviewers).
+        break;
+    }
+  }
+
+  return out;
+}

package/scripts/lib/config/reconcile.mjs

@@ -0,0 +1,205 @@
+import { matchBlockHeader } from './block-header.mjs';
+
+/**
+ * reconcile.mjs — Parser for the top-level `reconcile:` YAML block.
+ *
+ * Drives:
+ *   - FA3 (#696) advisory rule-proposal delivery at session-end Phase 3.6.8.
+ *   - FA4 (#697) this config foundation: `reconcile.enabled` gates the delivery.
+ *
+ * Returns:
+ *   {
+ *     enabled: boolean,
+ *     mode: 'warn' | 'off',
+ *     targets: string[],
+ *     'rule-expiry-days': number | null,
+ *     'confidence-floor': number,
+ *     'min-rule-days': number,
+ *     'min-insight-chars': number,
+ *   }
+ *
+ * Tolerant parser: malformed values silently fall back to defaults.
+ *
+ * Consumers: `scripts/lib/config.mjs`, `skills/session-end/SKILL.md` Phase 3.6.8.
+ */
+
+/**
+ * Parse the top-level `reconcile:` YAML block from markdown content.
+ *
+ * Defaults:
+ *   reconcile.enabled:           false   — opt-in (FA3 reads this to gate Phase 3.6.8)
+ *   reconcile.mode:              'warn'  — advisory only; rules NEVER auto-applied,
+ *                                          every write is operator-AUQ-gated (enum: off|warn)
+ *   reconcile.targets:           ['repo-local']
+ *                                         — where approved rules are written;
+ *                                           repo-local = `.claude/rules/` in v1
+ *   reconcile.rule-expiry-days:  null    — CRITICAL: must default to null so the
+ *                                          reconcile engine (`emitter.mjs`
+ *                                          `computeExpiresAt`) falls back to per-type
+ *                                          TTL (`deriveExpiresAt`, default 60d).
+ *                                          A non-null committed default would silently
+ *                                          force flat expiry and change FA2 behaviour.
+ *                                          Set to a positive integer to override.
+ *   reconcile.confidence-floor:  0.5    — float 0.0..1.0; min learning confidence
+ *                                          before a learning is eligible for rule proposal
+ *   reconcile.min-rule-days:     7       — positive integer; floor window (days) applied
+ *                                          to a proposed rule's `expires-at` so a near-dead
+ *                                          or already-elapsed natural expiry never produces
+ *                                          a born-dead rule (issue #741.1). Malformed,
+ *                                          absent, or non-positive values fall back to 7.
+ *   reconcile.min-insight-chars: 24      — integer >= 0; opt-in minimum insight length
+ *                                          gating the eligibility placeholder-insight check
+ *                                          (issue #741.2). Malformed, absent, or negative
+ *                                          values fall back to 24.
+ *
+ * YAML shape:
+ *   reconcile:
+ *     enabled: false
+ *     mode: warn
+ *     targets: [repo-local]
+ *     rule-expiry-days: null        # default null — falls back to per-type TTL
+ *     confidence-floor: 0.5
+ *     min-rule-days: 7
+ *     min-insight-chars: 24
+ *
+ * @param {string} content — full file contents
+ * @returns {{
+ *   enabled: boolean,
+ *   mode: string,
+ *   targets: string[],
+ *   'rule-expiry-days': number | null,
+ *   'confidence-floor': number,
+ *   'min-rule-days': number,
+ *   'min-insight-chars': number,
+ * }}
+ */
+export function _parseReconcile(content) {
+  const defaults = {
+    enabled: false,
+    mode: 'warn',
+    targets: ['repo-local'],
+    'rule-expiry-days': null,
+    'confidence-floor': 0.5,
+    'min-rule-days': 7,
+    'min-insight-chars': 24,
+  };
+
+  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, 'reconcile')) 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 mode = 'warn';
+  let targets = ['repo-local'];
+  let ruleExpiryDays = null;
+  let confidenceFloor = 0.5;
+  let minRuleDays = 7;
+  let minInsightChars = 24;
+
+  for (const rawLine of blockLines) {
+    // Strip inline comments and trailing whitespace
+    const clean = rawLine.replace(/\s*#.*$/, '').replace(/\s+$/, '');
+    if (!clean.trim()) continue;
+
+    // Parse YAML list value: targets: [repo-local] or targets: [a, b]
+    const listMatch = clean.match(/^\s+(targets):\s*\[([^\]]*)\]/);
+    if (listMatch) {
+      const items = listMatch[2]
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+      if (items.length > 0) targets = items;
+      continue;
+    }
+
+    const kvMatch = clean.match(/^\s+([a-zA-Z_-]+):\s*(.*)/);
+    if (!kvMatch) continue;
+
+    const k = kvMatch[1];
+    let v = kvMatch[2].trim();
+
+    // Strip surrounding quotes
+    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 'mode': {
+        const VALID_MODES = ['off', 'warn'];
+        if (VALID_MODES.includes(v)) mode = v;
+        // else: silently fall back to default 'warn'
+        break;
+      }
+
+      case 'rule-expiry-days': {
+        if (v === 'null' || v === '') {
+          ruleExpiryDays = null;
+        } else if (/^\d+$/.test(v)) {
+          const n = parseInt(v, 10);
+          if (n > 0) ruleExpiryDays = n;
+          // 0 or negative: silently ignore, keep null
+        }
+        break;
+      }
+
+      case 'confidence-floor': {
+        const f = parseFloat(v);
+        if (!isNaN(f) && f >= 0.0 && f <= 1.0) confidenceFloor = f;
+        break;
+      }
+
+      case 'min-rule-days': {
+        if (/^\d+$/.test(v)) {
+          const n = parseInt(v, 10);
+          if (n > 0) minRuleDays = n;
+          // 0 or negative: silently ignore, keep default 7
+        }
+        break;
+      }
+
+      case 'min-insight-chars': {
+        if (/^\d+$/.test(v)) {
+          const n = parseInt(v, 10);
+          if (n >= 0) minInsightChars = n;
+          // negative (unrepresentable by \d+ anyway) or malformed: keep default 24
+        }
+        break;
+      }
+
+      // targets inline-list with no brackets (e.g. targets: repo-local) — single value
+      case 'targets': {
+        if (v && !v.startsWith('[')) {
+          targets = [v];
+        }
+        break;
+      }
+    }
+  }
+
+  return {
+    enabled,
+    mode,
+    targets,
+    'rule-expiry-days': ruleExpiryDays,
+    'confidence-floor': confidenceFloor,
+    'min-rule-days': minRuleDays,
+    'min-insight-chars': minInsightChars,
+  };
+}

package/scripts/lib/config/section-extractor.mjs

@@ -0,0 +1,100 @@
+/**
+ * section-extractor.mjs — Extract and parse the ## Session Config KV block.
+ *
+ * Ported from config-yaml-parser.sh (v2). Used by parseSessionConfig in config.mjs.
+ */
+
+// ---------------------------------------------------------------------------
+// Section extraction (ported from config-yaml-parser.sh)
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract the raw ## Session Config block lines from markdown content.
+ * - CRLF-tolerant
+ * - Skips code fence lines (``` alone on a line)
+ * - Strips trailing whitespace from each line
+ * @param {string} content
+ * @returns {string[]} lines of the Session Config block
+ */
+export function _extractConfigSection(content) {
+  const lines = content.split(/\r?\n/);
+  const result = [];
+  let inSection = false;
+
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\r$/, '');
+
+    if (line === '## Session Config') {
+      inSection = true;
+      continue;
+    }
+
+    if (inSection) {
+      // Next ## header closes the section
+      if (/^## /.test(line)) break;
+      // Skip standalone code fences
+      if (line.trim() === '```') continue;
+      // Strip trailing whitespace and collect
+      result.push(line.replace(/\s+$/, ''));
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Parse the key-value pairs from extracted Session Config lines.
+ * Supports Format 1: `- **key:** value`
+ * Supports Format 2: plain `key: value`
+ * Last occurrence of a key wins.
+ * @param {string[]} lines
+ * @returns {Map<string, string>}
+ */
+export function _parseKV(lines) {
+  // We accumulate all matches, last-match wins per key
+  const allPairs = [];
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+
+    let key;
+    let value;
+
+    // Format 1: - **key:** value
+    const fmt1 = line.match(/^\s*-\s+\*\*([^*:]+):\*\*\s*(.*)/);
+    if (fmt1) {
+      key = fmt1[1].trim();
+      value = fmt1[2].trim();
+    } else {
+      // Format 2: key: value — supports both plain "key: value" and
+      // YAML list-item form "- key: value" (issue #497). Key starts with
+      // letter; rest is alphanum/hyphen/underscore.
+      const fmt2 = line.match(/^\s*(?:-\s+)?([a-zA-Z][a-zA-Z0-9_-]+):\s+(.*)/);
+      if (fmt2) {
+        key = fmt2[1].trim();
+        value = fmt2[2].trim();
+      } else {
+        continue;
+      }
+    }
+
+    if (!key) continue;
+
+    // Strip inline YAML comment (matches block-parser behaviour in _parseVaultSync etc.)
+    value = value.replace(/\s+#.*$/, '').trim();
+
+    // Strip surrounding double quotes from value
+    if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+      value = value.slice(1, -1);
+    }
+
+    allPairs.push([key, value]);
+  }
+
+  // Last match wins: build the map by iterating in order
+  const kv = new Map();
+  for (const [k, v] of allPairs) {
+    kv.set(k, v);
+  }
+  return kv;
+}

package/scripts/lib/config/skill-evolution.mjs

@@ -0,0 +1,112 @@
+import { matchBlockHeader } from './block-header.mjs';
+
+/**
+ * skill-evolution.mjs — Parser for the top-level `skill-evolution:` YAML block
+ * (Epic #643 Skill Self-Evolution Foundation / issue #646 C1-config).
+ *
+ * Returns `{ autonomy, "evidence-floor", judge, "judge-budget-tokens" }`.
+ * Tolerant parser: malformed values silently fall back to defaults.
+ *
+ * NOTE: `skill-evolution:` is a DISTINCT sibling block from the pre-existing
+ * `evolve:` block. Do not confuse them; this parser only touches the
+ * `skill-evolution:` header.
+ *
+ * Consumers:
+ *  - `scripts/lib/config.mjs` (wired in Wave 3, reads parsed object)
+ *  - Skills that implement the self-evolution autonomy gate
+ */
+
+const ALLOWED_AUTONOMY = ['off', 'advisory', 'autonomous-gated'];
+
+/**
+ * Parse the top-level `skill-evolution:` YAML block from markdown content.
+ * Independent of the `## Session Config` section boundary.
+ *
+ * Defaults:
+ *   autonomy:            'off'   (enum: off | advisory | autonomous-gated)
+ *   evidence-floor:      0.5    (float in [0.0, 1.0])
+ *   judge:               false  (boolean: on/true → true, else false)
+ *   judge-budget-tokens: 8000   (integer > 0 — L3 judge per-call input budget, #645)
+ *
+ * @param {string} content — full file contents
+ * @returns {{ autonomy: string, "evidence-floor": number, judge: boolean, "judge-budget-tokens": number }}
+ */
+export function _parseSkillEvolution(content) {
+  const defaults = {
+    autonomy: 'off',
+    'evidence-floor': 0.5,
+    judge: false,
+    'judge-budget-tokens': 8000,
+  };
+
+  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, 'skill-evolution')) inBlock = true;
+      continue;
+    }
+    if (line.length > 0 && !/^\s/.test(line)) break;
+    blockLines.push(line);
+  }
+
+  if (blockLines.length === 0) return defaults;
+
+  let autonomy = 'off';
+  let evidenceFloor = 0.5;
+  let judge = false;
+  let judgeBudgetTokens = 8000;
+
+  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);
+
+    switch (k) {
+      case 'autonomy': {
+        const lower = v.toLowerCase();
+        if (ALLOWED_AUTONOMY.includes(lower)) autonomy = lower;
+        // else: silently fall back to default 'off'
+        break;
+      }
+      case 'evidence-floor': {
+        if (/^\d+(\.\d+)?$/.test(v)) {
+          const f = parseFloat(v);
+          if (Number.isFinite(f) && f >= 0.0 && f <= 1.0) evidenceFloor = f;
+          // else: silently fall back to default 0.5
+        }
+        break;
+      }
+      case 'judge': {
+        const lower = v.toLowerCase();
+        judge = lower === 'on' || lower === 'true';
+        break;
+      }
+      case 'judge-budget-tokens': {
+        if (/^\d+$/.test(v)) {
+          const n = parseInt(v, 10);
+          if (Number.isInteger(n) && n > 0) judgeBudgetTokens = n;
+          // else: silently fall back to default 8000
+        }
+        break;
+      }
+    }
+  }
+
+  return {
+    autonomy,
+    'evidence-floor': evidenceFloor,
+    judge,
+    'judge-budget-tokens': judgeBudgetTokens,
+  };
+}