sinapse-ai 1.19.1 → 1.20.0

package/.sinapse-ai/core/synapse/context/context-tracker.js

@@ -6,10 +6,13 @@
  * per bracket for the SynapseEngine orchestrator.
  *
  * Reads model context window from core-config.yaml → models.registry.
+ * Also exposes shouldCompact() — a dual-trigger (percent + absolute)
+ * compaction signal, independent of the bracket ladder above.
  *
  * @module core/synapse/context/context-tracker
- * @version 1.1.0
+ * @version 1.2.0
  * @created Story SYN-3 - Context Bracket Tracker
+ * @updated Story onda2-p4 - dual-trigger compaction signal (audit AF-20260702 item 2.12)
  */
 
 const fs = require('fs');
@@ -24,25 +27,44 @@ const path = require('path');
  * - DEPLETED: 25-40% remaining (reinforcement injection)
  * - CRITICAL: 0-25% remaining (warning + handoff prep)
  *
+ * Token budgets recalibrated by Story onda1-s2 (audit AF-20260702 item 1.6)
+ * to the REAL floors of the context-diet regime, measured 2026-07-02 with
+ * the real formatter against the real .synapse/constitution (96 rules):
+ *
+ * - Turn 1 (prompt_count=0 → always FRESH at ~100%): the FULL Constitution
+ *   is PROTECTED and measures 7,226 chars ≈ 1,807 tokens (section alone);
+ *   whole <synapse-rules> block ≈ 7,324 chars ≈ 1,831 tokens. FRESH=2000
+ *   covers this floor with headroom for CONTEXT rules / AGENT section.
+ *   (The old FRESH=800 was structurally unreachable — 2.3x over, silent.)
+ * - Turns 2+ (constitution emitted as reminder ≤ 1,000 chars ≈ ≤ 250
+ *   tokens): the PROTECTED floor drops to ~200-300 tokens. MODERATE /
+ *   DEPLETED / CRITICAL can only occur on turns 2+ (bracket is derived
+ *   from prompt_count), so they are sized for reminder + AGENT rules
+ *   (+ memory hints at DEPLETED+, + handoff warning at CRITICAL).
+ *
+ * Overflow is now SIGNALED (never silent) — see formatter.enforceTokenBudget()
+ * and the [BUDGET OVERFLOW] output marker + metrics.budget in engine.js.
+ *
  * @type {Object.<string, {min: number, max: number, tokenBudget: number}>}
  */
 const BRACKETS = {
-  FRESH:    { min: 60, max: 100, tokenBudget: 800 },
-  MODERATE: { min: 40, max: 60,  tokenBudget: 1500 },
-  DEPLETED: { min: 25, max: 40,  tokenBudget: 2000 },
-  CRITICAL: { min: 0,  max: 25,  tokenBudget: 2500 },
+  FRESH:    { min: 60, max: 100, tokenBudget: 2000 },
+  MODERATE: { min: 40, max: 60,  tokenBudget: 800 },
+  DEPLETED: { min: 25, max: 40,  tokenBudget: 1000 },
+  CRITICAL: { min: 0,  max: 25,  tokenBudget: 1200 },
 };
 
 /**
  * Token budget constants per bracket (shorthand access).
+ * Values mirror BRACKETS — see the measurement basis documented above.
  *
  * @type {Object.<string, number>}
  */
 const TOKEN_BUDGETS = {
-  FRESH: 800,
-  MODERATE: 1500,
-  DEPLETED: 2000,
-  CRITICAL: 2500,
+  FRESH: 2000,
+  MODERATE: 800,
+  DEPLETED: 1000,
+  CRITICAL: 1200,
 };
 
 /**
@@ -53,8 +75,21 @@ const TOKEN_BUDGETS = {
 const XML_SAFETY_MULTIPLIER = 1.2;
 
 /**
- * Default configuration values.
- * maxContext is the fallback when core-config.yaml is unavailable.
+ * Default configuration values — the FALLBACK only.
+ *
+ * The EFFECTIVE maxContext is derived from
+ * `models.registry[models.active].contextWindow` in core-config.yaml via
+ * getModelConfig() below (reused as-is by estimateContextPercent() and
+ * shouldCompact() — one read path, no duplication/cycle). These DEFAULTS
+ * apply only when the config file, the `models` section, or the active
+ * registry entry is missing/invalid.
+ *
+ * As of Story onda2-p4 (audit AF-20260702 item 2.12), that fallback path is
+ * still what REAL `npx sinapse-ai install` outputs hit: the shipped
+ * core-config.yaml template has no `models` section, so installed projects
+ * fall back to 200000 even when the user's actual model has a 1M window.
+ * Adding that section to the install template is a separate, deliberate
+ * decision (P8/DEC-01) — intentionally not part of this story.
  */
 const DEFAULTS = Object.freeze({
   avgTokensPerPrompt: 1500,
@@ -206,6 +241,75 @@ function estimateContextPercent(promptCount, options = {}) {
   return Math.max(0, Math.min(100, percent));
 }
 
+/**
+ * Absolute ceiling (tokens) of live conversation history before compaction
+ * is recommended — independent of window size.
+ *
+ * Story onda2-p4 (audit AF-20260702 item 2.12): a pure percentage trigger
+ * does not scale to 1M-token windows — 60% of a 1M window is 600,000
+ * tokens of live history, far past the point where instruction coherence
+ * degrades ("context amnesia", see .claude/rules/token-economy.md §1,
+ * measured/calibrated for the 200K window). This constant is the midpoint
+ * of the 150-180K range the audit recommended as the interim absolute cap
+ * while the 1M-window trigger itself remains pending real measurement.
+ *
+ * @type {number}
+ */
+const COMPACTION_ABSOLUTE_CEILING = 165000;
+
+/**
+ * Percentage of the active context window used before compaction is
+ * recommended — mirrors token-economy.md §1 ("Auto-compact: 60%").
+ *
+ * @type {number}
+ */
+const COMPACTION_PERCENT_TRIGGER = 0.6;
+
+/**
+ * Determine whether compaction is recommended right now.
+ *
+ * DUAL trigger (Story onda2-p4 / audit item 2.12): fires at whichever
+ * comes first — COMPACTION_PERCENT_TRIGGER (60%) of the active context
+ * window, or the absolute COMPACTION_ABSOLUTE_CEILING (~165K tokens of
+ * live history). Reads maxContext/avgTokensPerPrompt from getModelConfig()
+ * — the SAME registry-aware source estimateContextPercent() uses, no
+ * duplicate read path — overridable via options for testing.
+ *
+ * Equivalence at today's real windows: real installs fall back to the 200K
+ * DEFAULTS (see DEFAULTS above), where 60% of 200K is 120,000 tokens —
+ * always smaller than the 165K ceiling. The percent trigger always wins
+ * there, so behavior is IDENTICAL to the pre-existing 60%-of-window rule
+ * (zero regression). Above ~275K (COMPACTION_ABSOLUTE_CEILING /
+ * COMPACTION_PERCENT_TRIGGER) — e.g. the 1M registry entries — the
+ * absolute ceiling wins and compaction is recommended far earlier than a
+ * naive 60%-of-window rule would allow.
+ *
+ * @param {number} promptCount - Number of prompts in the current session
+ * @param {Object} [options={}] - Configuration options (override config values, mirrors estimateContextPercent)
+ * @param {number} [options.avgTokensPerPrompt] - Average tokens per prompt
+ * @param {number} [options.maxContext] - Maximum context window size in tokens
+ * @returns {boolean} True when compaction is recommended now
+ */
+function shouldCompact(promptCount, options = {}) {
+  const modelConfig = getModelConfig();
+  const {
+    avgTokensPerPrompt = modelConfig.avgTokensPerPrompt,
+    maxContext = modelConfig.maxContext,
+  } = options;
+
+  if (typeof promptCount !== 'number' || isNaN(promptCount) || promptCount < 0) {
+    return false;
+  }
+
+  if (maxContext <= 0) {
+    return true;
+  }
+
+  const usedTokens = promptCount * avgTokensPerPrompt * XML_SAFETY_MULTIPLIER;
+  const triggerTokens = Math.min(maxContext * COMPACTION_PERCENT_TRIGGER, COMPACTION_ABSOLUTE_CEILING);
+  return usedTokens >= triggerTokens;
+}
+
 /**
  * Get the maximum token budget for injection at the given bracket.
  *
@@ -280,6 +384,7 @@ function resetModelConfigCache(basePath = null) {
 module.exports = {
   calculateBracket,
   estimateContextPercent,
+  shouldCompact,
   getTokenBudget,
   getActiveLayers,
   needsHandoffWarning,
@@ -290,5 +395,7 @@ module.exports = {
   TOKEN_BUDGETS,
   DEFAULTS,
   XML_SAFETY_MULTIPLIER,
+  COMPACTION_ABSOLUTE_CEILING,
+  COMPACTION_PERCENT_TRIGGER,
 };
 

package/.sinapse-ai/core/synapse/engine.js

@@ -25,6 +25,7 @@ const {
 const { buildLayerContext } = require('./context/context-builder');
 
 const { formatSynapseRules } = require('./output/formatter');
+const { estimateTokens } = require('./utils/tokens');
 const { MemoryBridge } = require('./memory/memory-bridge');
 
 // ---------------------------------------------------------------------------
@@ -383,9 +384,6 @@ class SynapseEngine {
     metrics.totalEnd = process.hrtime.bigint();
     const summary = metrics.getSummary();
 
-    // Persist hook metrics (fire-and-forget)
-    this._persistHookMetrics(summary, bracket, mergedConfig);
-
     // 4. Format output
     const xml = formatSynapseRules(
       results,
@@ -398,6 +396,21 @@ class SynapseEngine {
       needsHandoffWarning(bracket),
     );
 
+    // Story onda1-s2: honest budget accounting — measure the EMITTED block
+    // against the bracket budget and expose it in metrics (never silent;
+    // the formatter also renders a [BUDGET OVERFLOW] marker in the output).
+    const emittedTokens = estimateTokens(xml);
+    summary.budget = {
+      bracket,
+      tokenBudget: typeof tokenBudget === 'number' && tokenBudget > 0 ? tokenBudget : null,
+      emittedTokens,
+      overBudget: typeof tokenBudget === 'number' && tokenBudget > 0 && emittedTokens > tokenBudget,
+    };
+
+    // Persist hook metrics (fire-and-forget) — after budget accounting so
+    // the persisted system log carries the overflow signal
+    this._persistHookMetrics(summary, bracket, mergedConfig);
+
     return { xml, metrics: summary, bracket };
   }
 
@@ -427,6 +440,8 @@ class SynapseEngine {
         layersSkipped: summary.layers_skipped,
         layersErrored: summary.layers_errored,
         totalRules: summary.total_rules,
+        // Story onda1-s2: budget overflow signal persisted in the system log
+        budget: summary.budget || null,
         perLayer: {},
         timestamp: new Date().toISOString(),
       };

package/.sinapse-ai/core/synapse/layers/l0-constitution.js

@@ -1,24 +1,95 @@
 /**
  * L0 Constitution Layer Processor
  *
- * Injects the 6 Constitutional articles as NON-NEGOTIABLE rules.
+ * Injects the Constitutional articles as NON-NEGOTIABLE rules.
  * ALWAYS_ON — processes regardless of session state.
  * Rules are loaded from the .synapse/constitution domain file.
  *
+ * Context diet (Story onda1-s2 — audit AF-20260702 item 1.1 CRITICAL):
+ * - FIRST prompt of a session (prompt_count === 0 at injection time — the
+ *   session-manager increments prompt_count AFTER the engine runs, see
+ *   hook-runtime.js → updateSession): emits the FULL constitution block,
+ *   exactly as before.
+ * - Prompts 2+ (prompt_count >= 1): emits a short reminder (formatted
+ *   [CONSTITUTION] section <= REMINDER_MAX_CHARS) containing the article
+ *   titles table + a MANDATORY pointer to the granular source
+ *   `.synapse/constitution` (the CLAUDE.md 11-article table is NOT a
+ *   substitute for the granular rules — adversarial-review ressalva).
+ * - New session (prompt_count resets to 0) → full block again.
+ * - FAIL-SAFE: if prompt_count is unreadable (missing session, corrupted
+ *   value, non-integer, negative) OR the reminder cannot be built (no
+ *   article titles detected), the FULL block is emitted. A read error must
+ *   never degrade to LESS enforcement.
+ *
+ * Measured with the real formatter against the real .synapse/constitution
+ * (2026-07-02): full section = 7,226 chars ≈ 1,807 tokens (96 rules);
+ * reminder section ≈ 700 chars ≈ ~175 tokens (~90% reduction per turn 2+).
+ *
  * @module core/synapse/layers/l0-constitution
- * @version 1.0.0
+ * @version 1.1.0
  * @created Story SYN-4 - Layer Processors L0-L3
+ * @updated Story onda1-s2 - Context diet (full block only on 1st prompt)
  */
 
 const path = require('path');
 const { loadDomainFile } = require('../domain/domain-loader');
 const LayerProcessor = require('./layer-processor');
 
+/**
+ * Max size (chars) of the FORMATTED [CONSTITUTION] reminder section
+ * (header + indented rules), per AC2 of Story onda1-s2.
+ * @type {number}
+ */
+const REMINDER_MAX_CHARS = 1000;
+
+/**
+ * Mirror of the section header rendered by output/formatter.js
+ * formatConstitution(). Used only to size-guard the reminder against
+ * REMINDER_MAX_CHARS with the exact final layout.
+ * @type {string}
+ */
+const SECTION_HEADER = '[CONSTITUTION] (NON-NEGOTIABLE)';
+
+/**
+ * Article title lines in the constitution domain file end with their
+ * severity marker, e.g. "CLI First (NON-NEGOTIABLE)". Granular rules
+ * instead START with "MUST:", "MUST NOT:", "SHOULD:", "EXCEPTION:".
+ */
+const ARTICLE_TITLE_RE = /\((NON-NEGOTIABLE|MUST|SHOULD)\)$/;
+const GRANULAR_PREFIX_RE = /^(MUST|SHOULD|EXCEPTION)\b/;
+
+/** Canonical pointer to the granular source (MANDATORY in the reminder). */
+const GRANULAR_SOURCE = '.synapse/constitution';
+
+/**
+ * Convert a positive integer to a roman numeral (article numbering).
+ *
+ * @param {number} num - Positive integer (1-3999)
+ * @returns {string} Roman numeral
+ */
+function toRoman(num) {
+  const table = [
+    [1000, 'M'], [900, 'CM'], [500, 'D'], [400, 'CD'],
+    [100, 'C'], [90, 'XC'], [50, 'L'], [40, 'XL'],
+    [10, 'X'], [9, 'IX'], [5, 'V'], [4, 'IV'], [1, 'I'],
+  ];
+  let n = num;
+  let out = '';
+  for (const [value, symbol] of table) {
+    while (n >= value) {
+      out += symbol;
+      n -= value;
+    }
+  }
+  return out;
+}
+
 /**
  * L0 Constitution Processor
  *
  * Loads constitution domain file and validates nonNegotiable flag in manifest.
- * Returns all constitutional rules as an array of strings.
+ * Returns all constitutional rules (1st prompt) or a compact reminder with a
+ * pointer to the granular source (prompts 2+) as an array of strings.
  *
  * @extends LayerProcessor
  */
@@ -30,18 +101,19 @@ class L0ConstitutionProcessor extends LayerProcessor {
   /**
    * Load constitution rules from domain file.
    *
-   * ALWAYS_ON: processes regardless of session state.
+   * ALWAYS_ON: processes regardless of session state (the layer always
+   * emits — only the SHAPE changes between full block and reminder).
    * Validates that the constitution domain has nonNegotiable: true in manifest.
    *
    * @param {object} context
    * @param {string} context.prompt - Current prompt text
-   * @param {object} context.session - Session state
+   * @param {object} context.session - Session state (SYN-2 schema; prompt_count used here)
    * @param {object} context.config - Config with synapsePath and manifest
    * @param {object[]} context.previousLayers - Results from previous layers
    * @returns {{ rules: string[], metadata: object } | null}
    */
   process(context) {
-    const { config } = context;
+    const { config, session } = context;
     const { synapsePath, manifest } = config;
 
     // Find constitution domain in manifest
@@ -66,16 +138,125 @@ class L0ConstitutionProcessor extends LayerProcessor {
     // Validate nonNegotiable flag
     const nonNegotiable = domain ? domain.nonNegotiable === true : false;
 
+    // Context diet (Story onda1-s2): full block on the 1st prompt of the
+    // session; compact reminder on prompts 2+. FAIL-SAFE: any unreadable
+    // prompt_count → full block (never degrade enforcement on read errors).
+    const { promptCount, reliable } = this._resolvePromptCount(session);
+    let emittedRules = rules;
+    let constitutionMode = 'full';
+
+    if (reliable && promptCount >= 1) {
+      const reminder = this._buildReminderRules(rules);
+      if (reminder) {
+        emittedRules = reminder;
+        constitutionMode = 'reminder';
+      }
+      // reminder === null → keep the full block (fail-safe)
+    }
+
     return {
-      rules,
+      rules: emittedRules,
       metadata: {
         layer: 0,
         source: 'constitution',
         nonNegotiable,
+        constitutionMode,
+        totalRules: rules.length,
       },
     };
   }
+
+  /**
+   * Resolve prompt_count from the session with strict validation.
+   *
+   * prompt_count semantics (session-manager.js): the counter is incremented
+   * AFTER each processed prompt, so at injection time the FIRST prompt of a
+   * session sees prompt_count === 0.
+   *
+   * FAIL-SAFE contract: any value that is not a non-negative integer is
+   * treated as UNRELIABLE and the caller emits the FULL block. This covers
+   * missing session file / corrupted JSON (hook-runtime already falls back
+   * to { prompt_count: 0 }), missing field, NaN, floats and negatives.
+   *
+   * @param {object|null|undefined} session - Session state
+   * @returns {{ promptCount: number, reliable: boolean }}
+   * @private
+   */
+  _resolvePromptCount(session) {
+    if (!session || typeof session !== 'object') {
+      return { promptCount: 0, reliable: false };
+    }
+    const raw = session.prompt_count;
+    if (typeof raw !== 'number' || !Number.isInteger(raw) || raw < 0) {
+      return { promptCount: 0, reliable: false };
+    }
+    return { promptCount: raw, reliable: true };
+  }
+
+  /**
+   * Build the compact reminder emitted on prompts 2+.
+   *
+   * Content: lead line + article titles table (derived DYNAMICALLY from the
+   * loaded rules — no hardcoded article list, so regenerating the
+   * constitution keeps the reminder in sync) + mandatory pointer to the
+   * granular source (.synapse/constitution).
+   *
+   * Size guard: the FORMATTED section (header + 2-space indented lines,
+   * mirroring output/formatter.js formatConstitution) must fit in
+   * REMINDER_MAX_CHARS. Falls back to progressively more compact layouts;
+   * the pointer line is NEVER dropped.
+   *
+   * @param {string[]} rules - Full granular rule list
+   * @returns {string[]|null} Reminder rules, or null when no article titles
+   *   could be detected (caller falls back to the full block — fail-safe)
+   * @private
+   */
+  _buildReminderRules(rules) {
+    const titles = rules.filter(rule =>
+      typeof rule === 'string'
+      && ARTICLE_TITLE_RE.test(rule.trim())
+      && !GRANULAR_PREFIX_RE.test(rule.trim()),
+    ).map(rule => rule.trim());
+
+    // Fail-safe: cannot summarize → caller emits the full block
+    if (titles.length === 0) {
+      return null;
+    }
+
+    const lead = 'Constitution ativa — TODOS os artigos abaixo seguem em vigor neste turno:';
+    const pointer = `Fonte completa: as ${rules.length} regras granulares estão em ${GRANULAR_SOURCE} — `
+      + 'este lembrete NÃO substitui a fonte granular; consulte-a na dúvida.';
+
+    // Layout 1: one numbered title per line
+    let candidate = [lead, ...titles.map((t, i) => `${toRoman(i + 1)}. ${t}`), pointer];
+    if (this._formattedSectionLength(candidate) <= REMINDER_MAX_CHARS) {
+      return candidate;
+    }
+
+    // Layout 2: all titles on a single separated line
+    candidate = [lead, titles.join(' · '), pointer];
+    if (this._formattedSectionLength(candidate) <= REMINDER_MAX_CHARS) {
+      return candidate;
+    }
+
+    // Layout 3: hard-truncate the titles line to fit (pointer always kept)
+    const fixedLength = this._formattedSectionLength([lead, '', pointer]);
+    const room = Math.max(0, REMINDER_MAX_CHARS - fixedLength - 1); // -1 for the ellipsis
+    const titlesLine = titles.join(' · ').slice(0, room) + '…';
+    return [lead, titlesLine, pointer];
+  }
+
+  /**
+   * Exact length of the [CONSTITUTION] section as the formatter renders it
+   * (header line + each rule prefixed with two spaces, newline separated).
+   *
+   * @param {string[]} lines - Candidate reminder lines
+   * @returns {number} Rendered section length in chars
+   * @private
+   */
+  _formattedSectionLength(lines) {
+    return [SECTION_HEADER, ...lines.map(l => `  ${l}`)].join('\n').length;
+  }
 }
 
 module.exports = L0ConstitutionProcessor;
-

package/.sinapse-ai/core/synapse/output/formatter.js

@@ -378,44 +378,65 @@ function formatSummary(results, _metrics) {
 // Token Budget Enforcement
 // ---------------------------------------------------------------------------
 
+/** Sections that are never removed by budget truncation. */
+const PROTECTED_SECTIONS = new Set(['CONTEXT_BRACKET', 'CONSTITUTION', 'AGENT']);
+
+/** Truncation priority: removed first when over budget. */
+const TRUNCATION_ORDER = [
+  'SUMMARY',
+  'KEYWORD',
+  'MEMORY_HINTS',
+  'SQUAD',
+  'STAR_COMMANDS',
+  'DEVMODE',
+  'TASK',
+  'WORKFLOW',
+];
+
 /**
  * Enforce a token budget by removing sections from the end.
  *
  * Truncation order (last removed first): SUMMARY, KEYWORD, SQUAD,
  * STAR_COMMANDS, TASK, WORKFLOW. CONSTITUTION and AGENT are never removed.
  *
+ * Story onda1-s2 (audit AF-20260702 item 1.6): the result is now a
+ * STRUCTURED object — overflow is signaled, never silent. When the
+ * PROTECTED sections alone exceed the budget, `overBudget` is true and
+ * formatSynapseRules() renders a visible [BUDGET OVERFLOW] warning; the
+ * engine also persists the signal in hook metrics.
+ *
  * @param {string[]} sections - Ordered section strings
  * @param {string[]} sectionIds - Corresponding section identifiers
  * @param {number} tokenBudget - Max tokens allowed
- * @returns {string[]} Filtered sections within budget
+ * @returns {{
+ *   sections: string[],
+ *   sectionIds: string[],
+ *   totalTokens: number,
+ *   tokenBudget: number,
+ *   overBudget: boolean,
+ *   removed: string[]
+ * }} Filtered sections + structured budget signal
  */
 function enforceTokenBudget(sections, sectionIds, tokenBudget) {
-  if (!tokenBudget || tokenBudget <= 0) {
-    return sections;
-  }
-
-  // Sections that should never be removed
-  const PROTECTED = new Set(['CONTEXT_BRACKET', 'CONSTITUTION', 'AGENT']);
-
-  // Truncation priority: remove from end first
-  const TRUNCATION_ORDER = [
-    'SUMMARY',
-    'KEYWORD',
-    'MEMORY_HINTS',
-    'SQUAD',
-    'STAR_COMMANDS',
-    'DEVMODE',
-    'TASK',
-    'WORKFLOW',
-  ];
-
   const result = [...sections];
   const ids = [...sectionIds];
+  const removed = [];
+
+  if (!tokenBudget || tokenBudget <= 0) {
+    return {
+      sections: result,
+      sectionIds: ids,
+      totalTokens: estimateTokens(result.join('\n\n')),
+      tokenBudget: 0,
+      overBudget: false,
+      removed,
+    };
+  }
 
   let totalTokens = estimateTokens(result.join('\n\n'));
 
   if (totalTokens <= tokenBudget) {
-    return result;
+    return { sections: result, sectionIds: ids, totalTokens, tokenBudget, overBudget: false, removed };
   }
 
   // Remove sections in truncation order
@@ -425,14 +446,22 @@ function enforceTokenBudget(sections, sectionIds, tokenBudget) {
     }
 
     const idx = ids.indexOf(sectionToRemove);
-    if (idx !== -1 && !PROTECTED.has(sectionToRemove)) {
+    if (idx !== -1 && !PROTECTED_SECTIONS.has(sectionToRemove)) {
       result.splice(idx, 1);
       ids.splice(idx, 1);
+      removed.push(sectionToRemove);
       totalTokens = estimateTokens(result.join('\n\n'));
     }
   }
 
-  return result;
+  return {
+    sections: result,
+    sectionIds: ids,
+    totalTokens,
+    tokenBudget,
+    overBudget: totalTokens > tokenBudget,
+    removed,
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -544,8 +573,19 @@ function formatSynapseRules(results, bracket, contextPercent, session, devmode,
     sectionIds.push('SUMMARY');
   }
 
-  // Token budget enforcement
-  const finalSections = enforceTokenBudget(sections, sectionIds, tokenBudget);
+  // Token budget enforcement (structured — Story onda1-s2)
+  const budgetResult = enforceTokenBudget(sections, sectionIds, tokenBudget);
+  const finalSections = [...budgetResult.sections];
+
+  // Budget overflow signal: when the PROTECTED sections alone exceed the
+  // bracket budget, say so IN the output — never silently over-deliver.
+  if (budgetResult.overBudget) {
+    finalSections.push(
+      '[BUDGET OVERFLOW]\n'
+      + `  WARN: emitted ~${budgetResult.totalTokens} tokens > budget ${budgetResult.tokenBudget} (${bracket}). `
+      + 'Protected sections (Constitution/Agent) alone exceed this bracket\'s token budget.',
+    );
+  }
 
   // Wrap in <synapse-rules> tags
   const body = finalSections.join('\n\n');

package/.sinapse-ai/core-config.yaml

@@ -398,11 +398,18 @@ boundary:
 # Consumed by .sinapse-ai/core/synapse/context/context-tracker.js (getModelConfig).
 # active selects which registry entry drives estimateContextPercent.
 models:
-  active: claude-opus-4-8
+  active: claude-fable-5
   registry:
+    claude-fable-5:
+      contextWindow: 1000000
+      avgTokensPerPrompt: 2000
     claude-opus-4-8:
       contextWindow: 1000000
       avgTokensPerPrompt: 2000
+    claude-sonnet-5:
+      # conservative default — verify against official docs before relying on 1M
+      contextWindow: 200000
+      avgTokensPerPrompt: 1500
     claude-sonnet-4-6:
       contextWindow: 1000000
       avgTokensPerPrompt: 1500