mixdog 0.9.44 → 0.9.46

package/src/runtime/agent/orchestrator/session/compact/summary.mjs

@@ -124,22 +124,22 @@ function estimateCompactionPromptTokens(input, perMessageChars) {
 }
 
 function previousSummaryBodyForCompactionPrompt(previousSummary) {
-    const text = String(previousSummary || '').trim();
-    if (!text) return '';
+    const text = String(previousSummary || '');
+    if (!text.trim()) return '';
     return stripNestedSummaryHeaderLines(text);
 }
 
 function priorSummaryNeedsNormalization(text) {
-    const body = String(text || '').trim();
-    if (!body) return false;
+    const body = String(text || '');
+    if (!body.trim()) return false;
     if (!/^##\s+/m.test(body)) return true;
     if (!summaryIsSchemaValid(body)) return true;
     return summaryHasUnrecognizedHeadings(body);
 }
 
 function normalizePriorSummaryForCompactionPrompt(fullBody) {
-    const text = String(fullBody || '').trim();
-    if (!text) return '';
+    const text = String(fullBody || '');
+    if (!text.trim()) return '';
     if (!priorSummaryNeedsNormalization(text)) return text;
     return repairSemanticSummary(text, { head: [], tail: [] });
 }
@@ -154,9 +154,9 @@ function fitPreviousSummaryForCompactionPrompt(input, perMessageChars, targetTok
         previousSummaryBodyForCompactionPrompt(input.previousSummary),
     );
     const withSummary = (summaryText) => {
-        const trimmed = String(summaryText || '').trim();
-        if (!trimmed) return { ...input, previousSummary: null };
-        return { ...input, previousSummary: trimmed };
+        const value = String(summaryText || '');
+        if (!value.trim()) return { ...input, previousSummary: null };
+        return { ...input, previousSummary: value };
     };
 
     if (estimateCompactionPromptTokens(withSummary(fullBody), perMessageChars) <= targetTokens) {
@@ -412,23 +412,162 @@ export const RECALL_TAIL_SHORT_TRUNCATION_MARKER = '[truncated]';
 
 const PRIOR_COMPACTED_CONTEXT_OPEN = '<prior-compacted-context>';
 const PRIOR_COMPACTED_CONTEXT_CLOSE = '</prior-compacted-context>';
+// Matches ONLY a structural wrapper BOUNDARY line — a line whose sole content is
+// the open or close tag (optionally surrounded by whitespace). It deliberately
+// does NOT match an inline occurrence embedded in real content (e.g. a user note
+// like "keep <prior-compacted-context> literal here"), so flattening the wrapper
+// can never splice words together or corrupt marker-like text. The production
+// wrapper is always emitted on its own line, so boundary-line stripping removes
+// every real wrapper while leaving inline literals verbatim.
+const PRIOR_COMPACTED_CONTEXT_BOUNDARY_RE = /^[ \t]*<\/?prior-compacted-context>[ \t]*$/;
+
+// Strip the STRUCTURAL <prior-compacted-context> / </prior-compacted-context>
+// boundary lines from prior text so re-wrapping never nests, while preserving
+// any inline marker-like text inside real content exactly as written. Returns
+// the bare inner content with the blank lines the removed boundary lines leave
+// behind collapsed.
+export function stripPriorCompactedContextWrappers(text) {
+    const raw = String(text ?? '');
+    if (!raw) return '';
+    // Keep every non-structural byte, including leading/trailing and repeated
+    // newlines.  Removing only the structural line itself (not trim/collapse)
+    // preserves the layout of all remaining content.
+    return raw
+        .split('\n')
+        .filter((line) => !PRIOR_COMPACTED_CONTEXT_BOUNDARY_RE.test(line))
+        .join('\n');
+}
 
-function formatPriorCompactedContextBlock(priorText) {
-    const prior = String(priorText || '').trim();
-    if (!prior) return '';
-    return `${PRIOR_COMPACTED_CONTEXT_OPEN}\n${prior}\n${PRIOR_COMPACTED_CONTEXT_CLOSE}`;
+// Remove only STRUCTURALLY IDENTICAL blank-line-separated blocks (byte-for-byte
+// repeats) so a prior context re-fed across many compaction cycles keeps every
+// distinct requirement/fact and cannot grow without bound. The dedupe is
+// content-preserving: the key is the block's EXACT text — internal whitespace is
+// never collapsed and meaningful block content is never trimmed — so distinct
+// strings such as `printf 'a  b'` and `printf 'a b'` are BOTH kept verbatim.
+// Only an exact repeat of a previously emitted block is dropped; blank
+// separators (whitespace-only splits) are skipped, never real content.
+function dedupePriorCompactedBlocks(text) {
+    const raw = String(text ?? '');
+    if (!raw.trim()) return '';
+    const seen = new Set();
+    const parts = raw.split(/(\n{2,})/);
+    const out = [];
+    let separator = '';
+    for (let i = 0; i < parts.length; i += 1) {
+        const part = parts[i];
+        if (i % 2 === 1) {
+            separator += part;
+            continue;
+        }
+        // Whitespace-only parts are layout, not a duplicate candidate.
+        if (!part.trim()) {
+            out.push(separator, part);
+            separator = '';
+            continue;
+        }
+        if (seen.has(part)) {
+            // Drop only the exact repeated structural block and its preceding
+            // separator; all retained text and whitespace stay byte-for-byte.
+            separator = '';
+            continue;
+        }
+        out.push(separator, part);
+        separator = '';
+        seen.add(part);
+    }
+    out.push(separator);
+    return out.join('');
+}
+
+// Canonicalize prior compacted context to AT MOST ONE wrapper: flatten any
+// nested/duplicated wrappers accumulated by earlier cycles, dedupe repeated
+// blocks, then wrap the surviving content exactly once. Repeated compaction can
+// therefore never nest or duplicate the prior context, each distinct
+// requirement/fact is preserved exactly once, and repeated-cycle token size
+// stays bounded.
+//
+// Optimization-safe empty-prior interpretation: when there is NO prior content
+// (empty / blank / boundary-tag-only input) this returns '' so the generated
+// summary carries ZERO wrappers instead of an empty
+// <prior-compacted-context></prior-compacted-context> pair. The production
+// summary body joins only non-empty parts (makeRecall*SummaryMessageParts), so
+// an empty wrapper cannot be carried and would only waste tokens. "Exactly one
+// wrapper" is thus realized as: exactly one when prior content exists, none when
+// it does not — and never more than one, never nested.
+export function formatPriorCompactedContextBlock(priorText) {
+    const flattened = dedupePriorCompactedBlocks(stripPriorCompactedContextWrappers(priorText));
+    if (!flattened) return '';
+    return `${PRIOR_COMPACTED_CONTEXT_OPEN}\n${flattened}\n${PRIOR_COMPACTED_CONTEXT_CLOSE}`;
 }
 
 export function stripNestedSummaryHeaderLines(text) {
-    const lines = String(text ?? '').split('\n');
+    const raw = String(text ?? '');
+    // A generated recall summary has a canonical, provenance-bearing shape:
+    //   header + "\n\n" + OPEN + "\n" + prior + "\n" + CLOSE + "\n\n" + recall
+    // Extracting it as lines loses ownership of a run of newlines: in
+    // `X\n` + join + live `X`, generic block dedupe cannot know that one
+    // newline belongs to X and must survive dropping the duplicate live X.
+    // Peel only the emitted wrapper/header/join bytes and retain the inner
+    // prior slice verbatim. The live recall is dropped only when it is the
+    // same payload the wrapper already carries.
+    const openMatch = /^[ \t]*<prior-compacted-context>[ \t]*\n/m.exec(raw);
+    if (openMatch) {
+        const closeRe = /\n[ \t]*<\/prior-compacted-context>[ \t]*(?=\n|$)/g;
+        closeRe.lastIndex = openMatch.index + openMatch[0].length;
+        const closeMatch = closeRe.exec(raw);
+        if (closeMatch) {
+            const prior = raw.slice(openMatch.index + openMatch[0].length, closeMatch.index);
+            const remainder = raw.slice(closeMatch.index + closeMatch[0].length);
+            // The only bytes between generated wrapper and live recall are
+            // this part-join's two newlines. Do not consume any other newline:
+            // those belong to either prior or live content.
+            const live = remainder.startsWith('\n\n') ? remainder.slice(2) : remainder;
+            if (!live || prior.trim() === live) return prior;
+            if (!prior) return live;
+            return `${prior}\n\n${live}`;
+        }
+    }
+
+    const lines = raw.split('\n');
     const out = [];
+    let followsStructuralHeader = false;
     for (const line of lines) {
-        if (line.startsWith(SUMMARY_PREFIX)) continue;
-        if (/^messages=\d+\s+(?:sha256=|compact_type=)/.test(line.trim())) continue;
-        if (/^compact_type=/.test(line.trim())) continue;
+        if (line.startsWith(SUMMARY_PREFIX)) {
+            followsStructuralHeader = true;
+            continue;
+        }
+        if (/^messages=\d+\s+(?:sha256=|compact_type=)/.test(line.trim())) {
+            followsStructuralHeader = true;
+            continue;
+        }
+        if (/^compact_type=/.test(line.trim())) {
+            followsStructuralHeader = true;
+            continue;
+        }
+        // Summary parts are joined with "\n\n".  The first empty line after
+        // stripped summary metadata is that join's structural separator, not
+        // prior content; retaining it makes every refeed gain a newline when
+        // formatPriorCompactedContextBlock wraps the result again.
+        if (followsStructuralHeader && line === '') {
+            followsStructuralHeader = false;
+            continue;
+        }
+        followsStructuralHeader = false;
+        // A prior summary re-fed as <previous-summary>/prior may still carry
+        // the canonical <prior-compacted-context> wrapper from an earlier
+        // cycle; drop those tag-only lines so the caller re-wraps exactly once
+        // (or treats the body as bare prior) instead of nesting.
+        if (/^<prior-compacted-context>$/.test(line.trim())) {
+            // The immediately preceding blank is the header→wrapper join from
+            // a generated summary. Remove only that wrapper-owned separator;
+            // blank lines inside the wrapper body remain untouched.
+            if (out.length > 0 && out[out.length - 1] === '') out.pop();
+            continue;
+        }
+        if (/^<\/prior-compacted-context>$/.test(line.trim())) continue;
         out.push(line);
     }
-    return out.join('\n').trim();
+    return out.join('\n');
 }
 
 function makeRecallFastTrackSummaryMessageParts(oldHistory, recallPart, priorPart, recallMeta = {}) {
@@ -444,7 +583,7 @@ function makeRecallFastTrackSummaryMessageParts(oldHistory, recallPart, priorPar
 
 export function fitRecallFastTrackSummaryMessage(oldHistory, recallText, remainingTokens, recallMeta = {}, priorPart = '') {
     const recall = String(recallText || '').trim();
-    const prior = String(priorPart || '').trim();
+    const prior = String(priorPart || '');
 
     let fittedPrior = prior;
     if (prior) {
@@ -594,7 +733,7 @@ function makeRecallRootsSummaryMessageParts(oldHistory, rootsPart, priorPart, re
 // blocks can only shrink (never grow) the serialized size, the minimal-drop
 // threshold is found via binary search on the drop count.
 export function fitRecallRootsMessage(oldHistory, recallText, remainingTokens, recallMeta = {}, priorPart = '') {
-    const prior = String(priorPart || '').trim();
+    const prior = String(priorPart || '');
 
     let fittedPrior = prior;
     if (prior) {

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -253,6 +253,7 @@ function contextMessageContribution(message) {
         role,
         tokens,
         reminderBuckets: null,
+        systemWorkflowTokens: 0,
         toolCallCount: 0,
         toolCallTokens: 0,
         toolResultCount: role === 'tool' ? 1 : 0,
@@ -270,6 +271,13 @@ function contextMessageContribution(message) {
         buckets.otherTokens = Math.max(0, contribution.tokens - sectionTokens);
         contribution.reminderBuckets = buckets;
     }
+    if (role === 'system') {
+        for (const section of splitMarkdownSections(text)) {
+            if (reminderSectionBucket(section) === 'workflow') {
+                contribution.systemWorkflowTokens += estimateTokens(section);
+            }
+        }
+    }
     if (fingerprint.role === 'assistant' && Array.isArray(message?.toolCalls) && message.toolCalls.length) {
         contribution.toolCallCount = message.toolCalls.length;
         try { contribution.toolCallTokens = estimateTokens(JSON.stringify(message.toolCalls)); }
@@ -317,7 +325,8 @@ function applyContextMessageContribution(state, contribution, direction) {
     state.rows[role].tokens += direction * tokens;
     if (role === 'system') {
         state.semantic.system.count += direction;
-        state.semantic.system.tokens += direction * tokens;
+        state.semantic.system.tokens += direction * (tokens - contribution.systemWorkflowTokens);
+        state.semantic.workflow.tokens += direction * contribution.systemWorkflowTokens;
     } else if (role === 'user') {
         if (contribution.reminderBuckets) {
             state.semantic.reminders.count += direction;
@@ -358,8 +367,11 @@ function contextSummaryResult(state, count) {
 
 export const DEFAULT_COMPACTION_BUFFER_TOKENS = 0;
 export const DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
-export const MAIN_COMPACTION_TRIGGER_RATIO = 0.95;
+// Main/user recall-fasttrack compacts at 95% by default. Lower triggers remain
+// opt-in through the mainBuffer* configuration and MIXDOG_MAIN_COMPACT_BUFFER_*.
+export const DEFAULT_MAIN_COMPACTION_BUFFER_RATIO = 0.05;
 export const MAX_COMPACTION_BUFFER_RATIO = 0.25;
+const MAX_BUFFER_INPUT_RATIO = 0.999_999;
 export const DEFAULT_COMPACTION_KEEP_TOKENS = 8_000;
 const LEGACY_DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
 
@@ -384,11 +396,11 @@ export function normalizeCompactionBufferRatio(value, fallback = DEFAULT_COMPACT
 export function resolveBufferRatioCandidate(percentInputs = [], ratioInputs = []) {
     for (const raw of percentInputs) {
         const n = Number(raw);
-        if (Number.isFinite(n) && n > 0) return Math.min(1, n / 100);
+        if (Number.isFinite(n) && n > 0) return Math.min(MAX_BUFFER_INPUT_RATIO, n / 100);
     }
     for (const raw of ratioInputs) {
         const n = Number(raw);
-        if (Number.isFinite(n) && n > 0) return n > 1 ? n / 100 : n;
+        if (Number.isFinite(n) && n > 0) return Math.min(MAX_BUFFER_INPUT_RATIO, n > 1 ? n / 100 : n);
     }
     return null;
 }
@@ -401,6 +413,42 @@ export function resolveCompactBufferRatio(cfg = {}) {
     return normalizeCompactionBufferRatio(resolved, DEFAULT_COMPACTION_BUFFER_RATIO);
 }
 
+// Main/user settings are deliberately separate from the semantic-agent buffer:
+// `buffer*` and MIXDOG_AGENT_COMPACT_BUFFER_* remain agent-only controls.
+// Source precedence is config before environment; within each source the fixed
+// unit precedence is tokens, percent, then ratio. Invalid/zero values are
+// ignored, and percent/ratio inputs are capped below 100%/1.0.
+function positiveTokenCandidate(values = []) {
+    for (const value of values) {
+        const tokens = positiveTokenInt(value);
+        if (tokens) return tokens;
+    }
+    return null;
+}
+
+function resolveMainBufferSetting(cfg = {}) {
+    const configTokens = positiveTokenCandidate([cfg.mainBufferTokens, cfg.mainBuffer]);
+    if (configTokens) return { tokens: configTokens };
+    const configRatio = resolveBufferRatioCandidate(
+        [cfg.mainBufferPercent, cfg.mainBufferPct],
+        [cfg.mainBufferRatio, cfg.mainBufferFraction],
+    );
+    if (configRatio !== null) return { ratio: configRatio };
+
+    const envTokens = positiveTokenCandidate([process.env.MIXDOG_MAIN_COMPACT_BUFFER_TOKENS]);
+    if (envTokens) return { tokens: envTokens };
+    const envRatio = resolveBufferRatioCandidate(
+        [process.env.MIXDOG_MAIN_COMPACT_BUFFER_PERCENT],
+        [process.env.MIXDOG_MAIN_COMPACT_BUFFER_RATIO],
+    );
+    return envRatio === null ? null : { ratio: envRatio };
+}
+
+export function resolveMainCompactBufferRatio(cfg = {}) {
+    const setting = resolveMainBufferSetting(cfg);
+    return setting?.ratio ?? DEFAULT_MAIN_COMPACTION_BUFFER_RATIO;
+}
+
 export function compactionBufferTokensForBoundary(boundaryTokens, opts = {}) {
     const boundary = Math.max(0, Math.floor(Number(boundaryTokens) || 0));
     const explicit = Math.max(0, Math.floor(Number(opts.explicitTokens) || 0));
@@ -483,6 +531,18 @@ export function resolveCompactBufferTokens(boundaryTokens, cfg = {}, opts = {})
     });
 }
 
+export function resolveMainCompactBufferTokens(boundaryTokens, cfg = {}, opts = {}) {
+    const boundary = positiveTokenInt(boundaryTokens);
+    const setting = resolveMainBufferSetting(cfg);
+    const configured = setting?.tokens || 0;
+    if (!boundary) return configured || positiveTokenInt(opts.defaultTokens) || DEFAULT_COMPACTION_BUFFER_TOKENS;
+    return compactionBufferTokensForBoundary(boundary, {
+        explicitTokens: configured,
+        ratio: setting?.ratio ?? DEFAULT_MAIN_COMPACTION_BUFFER_RATIO,
+        maxRatio: opts.maxRatio ?? MAX_COMPACTION_BUFFER_RATIO,
+    });
+}
+
 export function resolveCompactTriggerTokens(sessionOrConfig = {}, boundaryTokens = 0) {
     return resolveSessionCompactPolicy(sessionOrConfig, boundaryTokens).triggerTokens;
 }
@@ -495,8 +555,8 @@ export function resolveCompactTriggerTokens(sessionOrConfig = {}, boundaryTokens
 //     (trigger = limit) for every session type;
 //   - agent-owned semantic sessions otherwise keep the default early-trigger
 //     buffer (config-driven, default 10% -> compact at 90% of the boundary);
-//   - main/user recall-fasttrack sessions keep 5% headroom and compact at 95%
-//     of the effective boundary.
+//   - main/user recall-fasttrack sessions use their independently configurable
+//     buffer (default 25% -> compact at 75% of the effective boundary).
 // Returns the sanitized explicit limit (null when absent/legacy full-window)
 // plus triggerTokens / bufferTokens / bufferRatio for the given boundary.
 export function resolveSessionCompactPolicy(sessionOrConfig = {}, boundaryTokens = 0) {
@@ -507,7 +567,9 @@ export function resolveSessionCompactPolicy(sessionOrConfig = {}, boundaryTokens
             autoCompactTokenLimit: null,
             triggerTokens: null,
             bufferTokens: 0,
-            bufferRatio: resolveCompactBufferRatio(cfg),
+            bufferRatio: isAgentOwner(sessionOrConfig)
+                ? resolveCompactBufferRatio(cfg)
+                : resolveMainCompactBufferRatio(cfg),
         };
     }
     const rawLimit = positiveTokenInt(sessionOrConfig?.autoCompactTokenLimit ?? cfg?.autoCompactTokenLimit);
@@ -518,7 +580,7 @@ export function resolveSessionCompactPolicy(sessionOrConfig = {}, boundaryTokens
     } else if (isAgentOwner(sessionOrConfig)) {
         triggerTokens = Math.max(1, boundary - resolveCompactBufferTokens(boundary, cfg));
     } else {
-        triggerTokens = Math.max(1, Math.floor(boundary * MAIN_COMPACTION_TRIGGER_RATIO));
+        triggerTokens = Math.max(1, boundary - resolveMainCompactBufferTokens(boundary, cfg));
     }
     const bufferTokens = Math.max(0, boundary - triggerTokens);
     const bufferRatio = bufferTokens / boundary;
@@ -617,8 +679,19 @@ const toolSchemaTokenMemo = new WeakMap();
 const requestReserveTokenMemo = new WeakMap();
 
 function serializeToolSchemas(tools) {
-    try { return JSON.stringify(Array.isArray(tools) ? tools : []); }
-    catch { return (Array.isArray(tools) ? tools : []).map(t => String(t?.name ?? '')).join(''); }
+    const list = Array.isArray(tools) ? tools : [];
+    try {
+        return JSON.stringify(list.map(tool => {
+            const wireTool = {
+                name: tool?.name,
+                description: tool?.description,
+                input_schema: tool?.inputSchema ?? tool?.input_schema ?? tool?.parameters ?? tool?.schema,
+            };
+            if (tool?.deferLoading === true || tool?.defer_loading === true) wireTool.defer_loading = true;
+            return wireTool;
+        }));
+    }
+    catch { return list.map(t => String(t?.name ?? '')).join(''); }
 }
 
 export function toolSchemaSignature(tools) {

package/src/runtime/agent/orchestrator/session/loop/compact-policy.mjs

@@ -81,6 +81,32 @@ function resolveCompactKeepTokens(cfg = {}) {
         || envTokenInt('MIXDOG_AGENT_COMPACT_KEEP_TOKENS')
         || DEFAULT_COMPACTION_KEEP_TOKENS;
 }
+
+function compactTriggerMarginTokens(boundaryTokens) {
+    const boundary = positiveTokenInt(boundaryTokens);
+    if (!boundary) return 1;
+    return Math.max(1, Math.min(1_024, Math.floor(boundary * 0.01)));
+}
+
+function legacyCompactTargetBudget(boundaryTokens, targetTokens, reserveTokens) {
+    const boundary = positiveTokenInt(boundaryTokens);
+    if (!boundary) return null;
+    return Math.max(1, Math.min(boundary, targetTokens + reserveTokens));
+}
+
+function compactTargetBudgetForTrigger(boundaryTokens, targetTokens, reserveTokens, triggerTokens, singleShot = false, force = false) {
+    const legacyTarget = legacyCompactTargetBudget(boundaryTokens, targetTokens, reserveTokens);
+    const trigger = positiveTokenInt(triggerTokens);
+    // Degenerate reserve/window combinations cannot leave any post-compact
+    // headroom. Keep the legacy target and let the caller compact once only,
+    // rather than inventing a zero/negative margin that would immediately loop.
+    if (singleShot || !trigger) return legacyTarget;
+    const boundedTarget = Math.max(1, Math.min(legacyTarget, trigger - 1));
+    // Forced/manual compaction must retain a viable legacy budget when the
+    // strict no-repeat clamp would consume all non-reserve working space.
+    return force && boundedTarget <= reserveTokens ? legacyTarget : boundedTarget;
+}
+
 export function resolveWorkerCompactPolicy(sessionRef, tools) {
     if (!sessionRef) return null;
     const cfg = sessionRef.compaction || {};
@@ -95,19 +121,37 @@ export function resolveWorkerCompactPolicy(sessionRef, tools) {
     if (!boundaryTokens) return null;
     const compactBoundaryTokens = Math.max(1, Math.floor(boundaryTokens * COMPACT_SAFETY_PERCENT));
     // Shared session-compaction policy (context-utils): agent semantic keeps the
-    // default early-trigger buffer (90%); main/user keep 5% headroom (95%);
+    // default early-trigger buffer (90%); main/user use their independently
+    // configurable 25% default headroom (75%);
     // a truly-explicit sub-boundary limit wins. explicitAutoCompactTokenLimit
     // is the sanitized (null when legacy full-window) value so telemetry never
     // re-persists a boundary-collapsing limit.
     const policy = resolveSessionCompactPolicy(sessionRef, compactBoundaryTokens);
     const explicitAutoCompactTokenLimit = policy.autoCompactTokenLimit;
-    const bufferTokens = policy.bufferTokens;
-    const bufferRatio = policy.bufferRatio;
-    const triggerTokens = policy.triggerTokens;
     const configuredReserve = positiveTokenInt(cfg.reservedTokens)
         || envTokenInt('MIXDOG_AGENT_COMPACT_RESERVED_TOKENS')
         || 0;
     const requestReserve = estimateRequestReserveTokens(tools);
+    const reserveTokens = requestReserve + configuredReserve;
+    const compactTargetTokens = resolveCompactTargetTokens(compactBoundaryTokens, cfg) || compactBoundaryTokens;
+    const legacyTargetBudget = legacyCompactTargetBudget(compactBoundaryTokens, compactTargetTokens, reserveTokens);
+    // Reserve is included in every next-send pressure calculation, so its
+    // relationship to the actual trigger (not the raw boundary) determines
+    // whether a post-compact transcript can ever fall below the trigger.
+    const singleShot = reserveTokens >= policy.triggerTokens;
+    // Main/user recall-fasttrack must not compact into its next trigger. Keep a
+    // 1%-of-boundary (up to 1,024-token) gap above the effective post-compact
+    // target. Explicit sub-boundary limits and agent semantic triggers retain
+    // their established precedence/behavior.
+    const minMainTrigger = Math.min(
+        compactBoundaryTokens,
+        (legacyTargetBudget || 0) + compactTriggerMarginTokens(compactBoundaryTokens),
+    );
+    const triggerTokens = !singleShot && !isAgentOwner(sessionRef) && !explicitAutoCompactTokenLimit
+        ? Math.max(policy.triggerTokens, minMainTrigger)
+        : policy.triggerTokens;
+    const bufferTokens = Math.max(0, compactBoundaryTokens - triggerTokens);
+    const bufferRatio = bufferTokens / compactBoundaryTokens;
     const keepTokens = resolveCompactKeepTokens(cfg);
     const compactType = resolveCompactTypeSetting(sessionRef, cfg);
     return {
@@ -119,6 +163,8 @@ export function resolveWorkerCompactPolicy(sessionRef, tools) {
         triggerTokens,
         bufferTokens,
         bufferRatio,
+        compactTargetTokens,
+        singleShot,
         contextWindow,
         rawContextWindow: positiveTokenInt(sessionRef.rawContextWindow ?? cfg.rawContextWindow) || contextWindow,
         effectiveContextWindowPercent: Number.isFinite(Number(sessionRef.effectiveContextWindowPercent ?? cfg.effectiveContextWindowPercent))
@@ -131,7 +177,7 @@ export function resolveWorkerCompactPolicy(sessionRef, tools) {
         tailTurns: positiveTokenInt(cfg.tailTurns) || envTokenInt('MIXDOG_AGENT_COMPACT_TAIL_TURNS') || 2,
         keepTokens,
         preserveRecentTokens: positiveTokenInt(cfg.preserveRecentTokens) || envTokenInt('MIXDOG_AGENT_COMPACT_PRESERVE_RECENT_TOKENS') || keepTokens,
-        reserveTokens: requestReserve + configuredReserve,
+        reserveTokens,
         requestReserveTokens: requestReserve,
         configuredReserveTokens: configuredReserve,
         toolSchemaSignature: toolSchemaSignature(tools),
@@ -257,8 +303,20 @@ export function compactTargetBudget(policy) {
     const boundary = positiveTokenInt(policy?.boundaryTokens);
     if (!boundary) return null;
     const reserve = Math.max(0, Number(policy?.reserveTokens) || 0);
-    const targetEffective = resolveCompactTargetTokens(boundary, policy) || boundary;
-    return Math.max(1, Math.min(boundary, targetEffective + reserve));
+    const targetEffective = positiveTokenInt(policy?.compactTargetTokens)
+        || resolveCompactTargetTokens(boundary, policy)
+        || boundary;
+    const trigger = positiveTokenInt(policy?.triggerTokens);
+    const singleShot = policy?.singleShot === true
+        || (trigger > 0 && reserve >= trigger);
+    return compactTargetBudgetForTrigger(
+        boundary,
+        targetEffective,
+        reserve,
+        trigger,
+        singleShot,
+        policy?.force === true,
+    );
 }
 export function shouldCompactForSession(messageTokensEst, policy, {
     forceReactive = false,
@@ -267,7 +325,14 @@ export function shouldCompactForSession(messageTokensEst, policy, {
     pressureTokens,
 } = {}) {
     if (!policy?.auto || !policy.boundaryTokens) return false;
+    // send-with-recovery permits exactly one context-overflow retry per send
+    // (`contextOverflowRetryUsed`), so this can consume at most one additional
+    // reactive compact after a one-shot attempt; a second overflow is surfaced.
     if (forceReactive) return true;
+    // A reserve at/above the trigger (or a one-token boundary)
+    // can never satisfy target < trigger. Permit one legacy compact attempt,
+    // then suppress automatic repeats until an operator intervenes.
+    if (policy.singleShot === true && sessionRef?.compaction?.singleShotConsumed === true) return false;
     if (messageTokensEst === null) return true;
     const pressure = Number.isFinite(Number(pressureTokens))
         ? Number(pressureTokens)
@@ -339,6 +404,9 @@ export function rememberCompactTelemetry(sessionRef, policy, meta = {}) {
             ? Math.max(0, Math.round(Number(meta.durationMs)))
             : null,
         compactCount: (prev.compactCount || 0) + (changed ? 1 : 0),
+        singleShotConsumed: policy.singleShot === true && meta.stage === 'compacting'
+            ? true
+            : prev.singleShotConsumed === true,
     };
     if (changed) {
         const changedAt = Date.now();