@aragon-agent/cli 0.6.39 → 0.6.40

package/dist/compaction/digest.js

@@ -42,7 +42,7 @@ function renderAssistant(message, calls) {
     }
     return { text: text.join('\n'), visible };
 }
-function renderEntry(message, messageId, calls, result) {
+function renderEntry(message, messageId, calls) {
     const rendered = message.role === 'assistant'
         ? renderAssistant(message, calls)
         : contentText(message.content);
@@ -52,6 +52,12 @@ function renderEntry(message, messageId, calls, result) {
         source.isLegacyReference = true;
         heading += ' (legacy read-only reference, not current user acceptance)';
     }
+    const entry = {
+        id: messageId,
+        text: `${heading}\n${rendered.text}`,
+        source,
+        summarized: message.role !== 'user',
+    };
     if (message.role === 'tool_result') {
         source.toolCallId = message.toolCallId;
         source.toolName = calls.get(message.toolCallId);
@@ -65,15 +71,12 @@ function renderEntry(message, messageId, calls, result) {
             const first = rendered.text.slice(0, edge);
             const last = rendered.text.slice(-edge);
             source.visibleText = clippedVisibleSections(rendered.visible, rendered.text, edge);
-            rendered.text = `${first}\n[clipped originalChars=${rendered.text.length}`
+            entry.text = `${heading}\n${first}\n[clipped originalChars=${rendered.text.length}`
                 + ` omittedChars=${omittedChars}]\n${last}`;
-            result.coverage.clippedToolResults.push({ messageId, omittedChars });
+            entry.clip = { messageId, omittedChars };
         }
     }
-    result.sourceMap.set(messageId, source);
-    if (message.role !== 'user')
-        result.coverage.summarizedMessages += 1;
-    return `${heading}\n${rendered.text}`;
+    return entry;
 }
 function clippedVisibleSections(parts, rendered, edge) {
     const visible = [];
@@ -90,7 +93,86 @@ function clippedVisibleSections(parts, rendered, edge) {
     }
     return visible.filter(Boolean);
 }
-/** Build every head entry without mutating messages; rejects instead of omitting. */
+/**
+ * The elision marker, in the text the summarizer reads.
+ *
+ * IT CARRIES THE ID RANGE AND SAYS "NOT QUOTABLE", because the model's output is
+ * validated against the source map: a model that cannot tell which messages it did
+ * not see will cite one, and the delta is then rejected as `invalid_memory_delta`.
+ * Naming the range turns a mystery failure into a readable instruction.
+ */
+function elisionMarker(firstId, lastId, count) {
+    return `[elided ${count} messages, ids ${firstId}..${lastId} - not quotable]`;
+}
+/**
+ * Decide the split: the FIRST and LAST entries verbatim, the middle elided.
+ *
+ * THIS IS THE SHAPE THE USER ASKED FOR ("keep the front and the back, compress
+ * the middle"), and it is also the only shape that keeps the digest useful: the
+ * front carries the task as it unfolded and the back carries what the run was
+ * doing when the budget ran out, which is what the next turn needs.
+ *
+ * FOUR RULES, AND EACH ONE FIXES A CASE THE OBVIOUS VERSION GETS WRONG:
+ *
+ *  1. The first entry is kept unless it ALONE overruns the whole budget - a
+ *     pathological single 130 k message must not evict everything else, and the
+ *     user's own instruction is protected by the anchor anyway (never elided).
+ *  2. The front stops at half the budget, so the back always gets a share. A
+ *     front that greedily filled the budget would leave the most recent history
+ *     out of the digest, which is the exact opposite of what the tail is for.
+ *  3. The LAST entry gets a floor of one, even when rule 2 spent the budget. The
+ *     budget is a soft target here: the hard gate is the summarizer's window
+ *     projection in `compactor.ts`, and exceeding a soft target by one entry is
+ *     strictly better than handing the model a digest that predates the turn it is
+ *     about to continue from.
+ *  4. At least ONE entry always survives, even at a zero budget, which is what
+ *     makes `digestBudgetChars(7000) === 0` produce a quotable digest instead of
+ *     an empty one that `validateMemoryDelta` accepts as an empty delta.
+ */
+function planElision(lengths, available) {
+    const total = lengths.length;
+    if (total === 0)
+        return { front: 0, back: 0 };
+    const usable = Math.max(0, available);
+    const half = Math.floor(usable / 2);
+    let front = lengths[0] > usable ? 0 : 1;
+    let frontChars = front === 1 ? lengths[0] : 0;
+    while (front < total && frontChars + lengths[front] <= half) {
+        frontChars += lengths[front];
+        front += 1;
+    }
+    let back = total - front > 0 ? 1 : 0;
+    let backChars = back === 1 ? lengths[total - 1] : 0;
+    while (back < total - front && backChars + lengths[total - 1 - back] <= usable - frontChars) {
+        backChars += lengths[total - 1 - back];
+        back += 1;
+    }
+    return { front, back };
+}
+/**
+ * Build every head entry without mutating messages.
+ *
+ * NEVER REJECTS FOR LENGTH (context-compaction-never-fires A1). It used to throw
+ * `digest_budget_exceeded` whenever the rendered head exceeded the budget, which is
+ * the gate that turned 96 of 96 compaction attempts on the reporting machine into
+ * no-ops - the digests were simply too big, and every caller (including the
+ * preflight in `memory-input.ts`, which discards the text and only wanted the two
+ * counts) inherited the rejection.
+ *
+ * WHAT IS ELIDED AND WHAT IS NOT. The anchor, the prior memory and the legacy
+ * summary are never elided: the first is the user's own instruction and the other
+ * two are the memory this compaction is extending. Only `head` entries are
+ * candidates, and an elided entry is dropped WHOLE - never half-rendered, which
+ * would produce a quoted fragment with a source id that does not correspond to
+ * anything the model actually read.
+ *
+ * AN ELIDED ENTRY IS NOT QUOTABLE, BUT IT IS STILL COUNTED. It does not enter
+ * `sourceMap` (so a delta citing it fails validation rather than inventing
+ * evidence) and it DOES count towards `coverage.summarizedMessages`, because that
+ * counter is what tells `validateMemoryDelta` that this head contained something
+ * summarizable at all - an all-elided digest that counted zero would let an empty
+ * delta through and record a "successful" compaction with an empty memory.
+ */
 export function buildDigest(input) {
     const generation = input.generation ?? 1;
     const start = input.startIndex ?? 0;
@@ -98,30 +180,70 @@ export function buildDigest(input) {
         !Number.isSafeInteger(start) || start < 0) {
         throw new MemoryError('invalid_memory_delta', '$.sourceIds');
     }
+    const budgetChars = digestBudgetChars(input.summarizerWindow);
     const result = {
         text: '',
         omitted: 0,
-        budgetChars: digestBudgetChars(input.summarizerWindow),
+        budgetChars,
         sourceMap: new Map(),
         coverage: { summarizedMessages: 0, clippedToolResults: [] },
     };
-    const parts = [];
+    const prefix = [];
     if (input.anchor) {
-        parts.push('ORIGINAL TASK (read-only reference, not current evidence):\n'
+        prefix.push('ORIGINAL TASK (read-only reference, not current evidence):\n'
             + contentText(input.anchor.content).text);
     }
     if (input.priorMemory) {
-        parts.push(`PRIOR MEMORY (read-only):\n${serializeMemory(input.priorMemory)}`);
+        prefix.push(`PRIOR MEMORY (read-only):\n${serializeMemory(input.priorMemory)}`);
     }
     if (input.legacySummary && !input.priorMemory?.legacySummary) {
-        parts.push(`LEGACY SUMMARY (read-only, incomplete provenance):\n${input.legacySummary}`);
+        prefix.push(`LEGACY SUMMARY (read-only, incomplete provenance):\n${input.legacySummary}`);
     }
     const calls = new Map();
-    input.head.forEach((message, index) => parts.push(renderEntry(message, `g${generation}:m${start + index}`, calls, result)));
-    result.text = parts.join('\n\n');
-    if (result.text.length > result.budgetChars) {
-        throw new MemoryError('digest_budget_exceeded', '$.digest');
+    const entries = input.head.map((message, index) => renderEntry(message, `g${generation}:m${start + index}`, calls));
+    const prefixChars = prefix.join('\n\n').length;
+    const budget = Math.max(budgetChars, LIMITS.digestMinChars);
+    const available = budget - prefixChars;
+    const fits = entries.reduce((sum, entry) => sum + entry.text.length, 0) <= available;
+    const kept = fits
+        ? { front: entries.length, back: 0 }
+        : planElision(entries.map((entry) => entry.text.length), available);
+    const elidedFrom = kept.front;
+    const elidedTo = entries.length - kept.back;
+    if (elidedTo > elidedFrom) {
+        // The elided middle still names its tool calls, so a retained `tool_result`
+        // whose `tool_call` was dropped keeps `tool=<name>` instead of `unknown`.
+        for (const message of input.head.slice(elidedFrom, elidedTo)) {
+            if (message.role !== 'assistant')
+                continue;
+            for (const block of message.content) {
+                if (block.type === 'tool_call')
+                    calls.set(block.toolCallId, block.toolName);
+            }
+        }
+    }
+    for (let index = 0; index < entries.length; index += 1) {
+        if (index >= elidedFrom && index < elidedTo) {
+            // ELIDED: not quotable, but still counted (see the function's header).
+            if (entries[index].summarized)
+                result.coverage.summarizedMessages += 1;
+            continue;
+        }
+        const entry = entries[index];
+        result.sourceMap.set(entry.id, entry.source);
+        if (entry.summarized)
+            result.coverage.summarizedMessages += 1;
+        if (entry.clip)
+            result.coverage.clippedToolResults.push(entry.clip);
     }
+    result.omitted = Math.max(0, elidedTo - elidedFrom);
+    const parts = [...prefix];
+    parts.push(...entries.slice(0, kept.front).map((entry) => entry.text));
+    if (result.omitted > 0) {
+        parts.push(elisionMarker(entries[elidedFrom].id, entries[elidedTo - 1].id, result.omitted));
+    }
+    parts.push(...entries.slice(elidedTo).map((entry) => entry.text));
+    result.text = parts.join('\n\n');
     if (result.coverage.clippedToolResults.length > LIMITS.coverageClips) {
         throw new MemoryError('protected_memory_too_large', '$.coverage');
     }

package/dist/compaction/limits.d.ts

@@ -1,6 +1,27 @@
 /** Structural limits for v2 compaction. All character counts are UTF-16 units. */
 export declare const COMPACTION_LIMITS: {
     readonly digestMaxChars: 120000;
+    /**
+     * The smallest digest worth sending when the budget collapses (never-fires A1).
+     *
+     * `digestBudgetChars(7000)` is 0 - a summarizer whose window is smaller than the
+     * reserve has no input room - and before this change a 0 budget simply threw.
+     * Eliding is only safe while SOMETHING survives: a digest with no messages and no
+     * source map forces the model to invent a delta (`invalid_memory_delta`) or to
+     * return none, so the floor is spent on the first entry, the last entry and the
+     * elision marker.
+     */
+    readonly digestMinChars: 2000;
+    /**
+     * The tail budget the SECOND planning pass may fall back to (never-fires B).
+     *
+     * A MEANINGFUL TAIL, NOT A TOKEN-LEVEL FLOOR. `planCompaction` walks down from
+     * the LARGEST safe cut, so the cut it relaxes to leaves exactly this many
+     * messages behind; too small a number would satisfy the planner while breaking
+     * the thing the user asked for (the recent instructions stay verbatim). Tens of
+     * messages is one or two agentic turns' worth of tool calls.
+     */
+    readonly minRetainedMessages: 40;
     readonly summarizerReserveTokens: 8000;
     readonly summaryMaxChars: 32000;
     readonly summaryOutputTokens: 4096;

package/dist/compaction/limits.js

@@ -1,6 +1,27 @@
 /** Structural limits for v2 compaction. All character counts are UTF-16 units. */
 export const COMPACTION_LIMITS = {
     digestMaxChars: 120_000,
+    /**
+     * The smallest digest worth sending when the budget collapses (never-fires A1).
+     *
+     * `digestBudgetChars(7000)` is 0 - a summarizer whose window is smaller than the
+     * reserve has no input room - and before this change a 0 budget simply threw.
+     * Eliding is only safe while SOMETHING survives: a digest with no messages and no
+     * source map forces the model to invent a delta (`invalid_memory_delta`) or to
+     * return none, so the floor is spent on the first entry, the last entry and the
+     * elision marker.
+     */
+    digestMinChars: 2_000,
+    /**
+     * The tail budget the SECOND planning pass may fall back to (never-fires B).
+     *
+     * A MEANINGFUL TAIL, NOT A TOKEN-LEVEL FLOOR. `planCompaction` walks down from
+     * the LARGEST safe cut, so the cut it relaxes to leaves exactly this many
+     * messages behind; too small a number would satisfy the planner while breaking
+     * the thing the user asked for (the recent instructions stay verbatim). Tens of
+     * messages is one or two agentic turns' worth of tool calls.
+     */
+    minRetainedMessages: 40,
     summarizerReserveTokens: 8_000,
     summaryMaxChars: 32_000,
     summaryOutputTokens: 4_096,

package/dist/compaction/reason-text.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Human wording for compaction outcomes (context-compaction-never-fires C).
+ *
+ * ASCII ONLY: `src/compaction/**` is inside the glyph scanner's scope
+ * (`glyphs.test.ts::inScope`), so every glyph the card draws comes from
+ * `pickGlyphs` and nothing here may carry a non-ASCII byte.
+ *
+ * WHY THIS MODULE EXISTS AT ALL. The card used to print the raw rejection code
+ * (`context not compacted #4: digest_budget_exceeded: $.digest`), which names the
+ * internal gate and tells the user nothing they can act on. A decline is a
+ * QUESTION ("why, and what do I do now"), so each code gets one phrase and - for
+ * the ones a user can act on - one remedy.
+ *
+ * IT IS ALSO THE SELF-DISABLE NOTICE'S SOURCE. The one line that says
+ * auto-compaction has paused reads the same phrase, so the card and the toast
+ * cannot describe one failure two ways.
+ */
+import type { CompactionPhase } from './types.js';
+/** One phrase plus, where it helps, the thing the user can do about it. */
+export interface ReasonText {
+    /** What happened, in one clause. Never contains the raw code. */
+    text: string;
+    /** The remedy, or `undefined` when there is nothing to offer. */
+    action?: string;
+}
+/**
+ * A phrase for a rejection code, falling back to the code itself.
+ *
+ * THE FALLBACK IS THE RAW CODE, deliberately: a new gate nobody wrote wording for
+ * must still say SOMETHING specific on the card, and an invented sentence would
+ * be worse than a code the next reviewer can grep.
+ */
+export declare function describeCompactionReason(reason: string): ReasonText;
+/** The card's one-line reason, with the remedy appended when there is one. */
+export declare function compactionReasonLine(reason: string): string;
+export declare function compactionPhaseLabel(phase: CompactionPhase): string;

package/dist/compaction/reason-text.js

@@ -0,0 +1,78 @@
+const REASONS = {
+    nothing_to_drop: {
+        text: 'no safe cut - this run has too few user turns to keep',
+        action: 'keep talking, or lower /compact keep',
+    },
+    digest_budget_exceeded: {
+        text: 'the summary input was too large for one call',
+        action: 'retry - the middle is elided now',
+    },
+    summarizer_window_exceeded: {
+        text: 'the summary request does not fit the summarizer window',
+        action: 'pick a summarizer with a larger window',
+    },
+    protected_memory_too_large: {
+        text: 'the task memory does not fit its protection budget',
+        action: 'start a fresh conversation',
+    },
+    invalid_memory_delta: {
+        text: 'the summarizer returned an unusable memory delta',
+        action: 'retry',
+    },
+    empty_memory_delta: {
+        text: 'the summarizer returned an empty memory delta',
+        action: 'retry',
+    },
+    no_token_reclaim: {
+        text: 'the summary would not have reclaimed any tokens',
+    },
+    timeout: { text: 'the summarizer timed out', action: 'retry' },
+    no_summarizer_model: {
+        text: 'no summarizer model resolves',
+        action: 'set a model or add a provider key',
+    },
+    no_api_key: { text: 'the summarizer provider has no API key' },
+    already_running: { text: 'another compaction is already running' },
+    invalid_prior_memory: {
+        text: 'the existing task memory does not match this history',
+        action: 'start a fresh conversation',
+    },
+    invalid_history: { text: 'this history cannot be split safely' },
+    protected_multimodal_tail: {
+        text: 'an image in the middle of this history would have to be dropped',
+    },
+    insufficient_reclaim: {
+        text: 'the splice freed too little to stay below the threshold',
+    },
+    disabled: { text: 'auto-compaction is off for this session', action: '/compact on' },
+    cancelled: { text: 'cancelled' },
+    aborted: { text: 'cancelled' },
+    stale_history: { text: 'the history changed while the summary was running' },
+    adoption_failed: { text: 'the compacted history could not be adopted' },
+};
+/**
+ * A phrase for a rejection code, falling back to the code itself.
+ *
+ * THE FALLBACK IS THE RAW CODE, deliberately: a new gate nobody wrote wording for
+ * must still say SOMETHING specific on the card, and an invented sentence would
+ * be worse than a code the next reviewer can grep.
+ */
+export function describeCompactionReason(reason) {
+    const code = reason.split(':', 1)[0].trim();
+    return REASONS[code] ?? { text: reason };
+}
+/** The card's one-line reason, with the remedy appended when there is one. */
+export function compactionReasonLine(reason) {
+    const { text, action } = describeCompactionReason(reason);
+    return action ? `${text} (${action})` : text;
+}
+const PHASES = {
+    planning: 'planning the cut',
+    digesting: 'building the digest',
+    summarizing: 'summarizing',
+    validating: 'validating the summary',
+    applying: 'applying',
+};
+export function compactionPhaseLabel(phase) {
+    return PHASES[phase];
+}

package/dist/compaction/types.d.ts

@@ -55,6 +55,23 @@ export type CompactionMode = 'summarized' | 'truncated' | 'relieved' | 'none';
  * thing a CLI-local type is for.
  */
 export type CompactionUiTrigger = 'pressure' | 'overflow' | 'manual';
+/**
+ * Where one attempt currently is, so "compacting context" can also say WHAT it is
+ * doing for the forty-five seconds it is on screen.
+ *
+ * IT EXISTS BECAUSE THE GATES WERE INVISIBLE (context-compaction-never-fires
+ * RC-3). Planning and digesting both run BEFORE any model call, and both used to
+ * be able to reject while the only surface said `Context 95%` and nothing else.
+ * A phase is the CLI's answer to "is this stuck, or merely slow", and it is
+ * CLI-LOCAL for the reason the whole stream is: the engine has no phases, only a
+ * splice.
+ *
+ * THERE IS NO `settled` MEMBER, deliberately: the settle is already the
+ * `compaction_end` record. A phase restating it would give the card two ways to
+ * learn one fact, and the extra phase would race the record whenever the engine's
+ * verdict comes back first.
+ */
+export type CompactionPhase = 'planning' | 'digesting' | 'summarizing' | 'validating' | 'applying';
 /** Whether a figure was measured by the provider or estimated by us. */
 export type PressureSource = 'usage' | 'estimate';
 /** The exact occupancy evidence at the compaction checkpoint. */
@@ -183,6 +200,36 @@ export interface CompactionRecord {
     usage?: TokenUsage;
     /** Set when an overflow attempt halved `keepRecentTurns` for itself (D-24). */
     keepRecentTurnsUsed?: number;
+    /**
+     * Set when `planCompaction` had to relax `keepRecentTurns` to find a cut
+     * (context-compaction-never-fires B).
+     *
+     * DISCLOSED ON THE CARD, never silent: the relaxation trades "the last N turns
+     * are verbatim" for "compaction happens at all", and a user who is not told
+     * which side they got cannot tell a lossless compaction from a lossy one.
+     * `retainedTurns` and `retainedMessages` are what actually survived, so the card
+     * can state all three numbers instead of implying one.
+     */
+    keepRelaxed?: boolean;
+    retainedTurns?: number;
+    /**
+     * How many MESSAGES the relaxed cut left verbatim.
+     *
+     * `retainedTurns` COUNTS USER TURNS, and in the sessions this fix exists for - one
+     * prompt followed by a hundred tool calls - that number is zero even though forty
+     * messages survived word for word. A card reading "kept 0 recent turns" at that
+     * moment says the opposite of what happened, so both numbers are recorded.
+     */
+    retainedMessages?: number;
+    /**
+     * Messages left OUT of the digest text and therefore not quotable by the
+     * summarizer (context-compaction-never-fires A1).
+     *
+     * The elision is LOUD in three places: the digest text itself carries an
+     * `[elided ...]` marker, this field puts the count on the card, and the elided
+     * ids never enter the source map, so a delta citing one is rejected.
+     */
+    elidedMessages?: number;
     /**
      * Present ONLY when tail relief fired (hardening §3.3.4 / W2).
      *
@@ -221,14 +268,24 @@ export interface CompactionSnapshot {
     /** The summarizer's model id, or `''`. */
     model: string;
     /**
-     * How many compactions ANNOUNCED themselves (quiet-noop §6.2 / D-5).
+     * How many compactions ANNOUNCED themselves, i.e. how many cards the user saw.
      *
-     * COMPACTIONS THAT RAN, NOT CHECKPOINTS THAT FIRED. A `pressure` compaction
-     * that declines before calling a model or changing the history never advances
-     * this, which is what keeps the card's `#N` contiguous. `declined` below is
-     * the other half of the same total.
+     * IT COUNTS ATTEMPTS, NOT SPLICES (context-compaction-never-fires C). Before
+     * this change only attempts that committed to work announced, so this was
+     * "compactions that ran"; now every attempt opens a card - including the ones
+     * that decline at the planner or the digest - because a silent decline is
+     * indistinguishable from a dead feature, which is the bug this feature shipped
+     * with. `applied` below is the other half, and `/compact status` prints both.
      */
     compactions: number;
+    /**
+     * How many of those attempts actually replaced the history.
+     *
+     * OPTIONAL SO EVERY EXISTING CONSTRUCTION SITE STAYS UNTOUCHED. Absent means
+     * "not reported", which `/compact status` renders exactly as the pre-change
+     * wording did.
+     */
+    applied?: number;
     /**
      * How many `pressure` checkpoints declined BEFORE committing to any work
      * (quiet-noop D-9 / P1-2).
@@ -260,19 +317,26 @@ export interface CompactionSnapshot {
 /**
  * THE COMPACTION EVENT STREAM.
  *
- * `compaction_start` and `compaction_end` are emitted ONLY for compactions that
- * COMMITTED TO WORK (quiet-noop §3.1): a `pressure` compaction that declines
- * before calling a model or changing the history emits NEITHER, and is
- * deliberately indistinguishable from a turn at which `shouldCompact` returned
- * false. `manual` and `overflow` always emit both.
+ * EVERY ATTEMPT ANNOUNCES ITSELF (context-compaction-never-fires C, which
+ * REVERSES quiet-noop §3.1). A `pressure` compaction used to reach
+ * `compaction_start` only after it committed to paid work, so an attempt that
+ * declined at the planner (`nothing_to_drop`) or at the digest budget produced
+ * no card at all - and a user sitting at 95 % with a dead auto-compaction had no
+ * way to learn that the feature was trying and failing 96 times. The card is now
+ * opened at the entry of `compact()` and ALWAYS settled, so `#N` counts attempts
+ * and the transcript carries one line per attempt, applied or not.
+ *
+ * WHY THE OLD DESIGN WAS DEFENSIBLE AND IS STILL WRONG. Its stated worry was a
+ * red `context not compacted` card every two turns flooding the transcript. The
+ * guards bound that to `stuckLimit` declines per run (`limits.ts`), and after
+ * them the auto path self-disables and says so once - so the flood never
+ * happens, while the silence happened every time.
  *
  * The pair is still BALANCED: every `compaction_start` is followed by exactly
  * one `compaction_end` (a `finally` in the engine guarantees the verdict, and
  * `settlePending` synthesizes a skeleton record when the compactor's own has not
- * arrived). Consumers that count PAIRS are unaffected; consumers that counted
- * ATTEMPTS must read `/compact status` or the JSONL diagnostic log instead -
- * CORE's own `compaction_start` / `compaction_end` pair still fires for every
- * attempt, declined or not, and that is the stream the log subscribes to.
+ * arrived). `phase` events land BETWEEN them, in order, and only for the live
+ * card.
  */
 export type CompactionEvent = {
     type: 'compaction_start';
@@ -282,6 +346,10 @@ export type CompactionEvent = {
 } | {
     type: 'compaction_end';
     record: CompactionRecord;
+} | {
+    type: 'phase';
+    index: number;
+    phase: CompactionPhase;
 } | ({
     type: 'usage';
     usage: TokenUsage;

package/dist/compaction/wiring.d.ts

@@ -27,14 +27,19 @@ import type { CompactionIdentity } from './memory-identity.js';
  * `/compact off`, `/compact threshold 0.8` and a settings-screen save take effect
  * mid-session without touching the `Agent`.
  *
- * DECLINED COMPACTIONS PRODUCE NO CLI EVENTS (quiet-noop §3.6). A `pressure`
- * compaction that changed nothing, called nothing and spent nothing never emits
- * `compaction_start`, so `onCompactorEvent` never opens a card and `settlePending`
- * finds neither a held record nor a skeleton to synthesize. CORE still emits its
- * own pair for every attempt, which is why `settlePending` still runs - it just
- * refreshes the snapshot and returns. `onCompactorEvent`'s `if (!this.open)`
- * guard is now unreachable for declines and stays for the abort race it was
- * written for.
+ * DECLINED COMPACTIONS ARE VISIBLE (context-compaction-never-fires C, which
+ * REVERSES quiet-noop §3.6). A `pressure` compaction that changes nothing used to
+ * emit no `compaction_start`, so `onCompactorEvent` never opened a card and the
+ * only trace of an attempt was a counter in `/compact status`. The compactor now
+ * announces at the entry of `compact()` and always settles, so this class holds a
+ * record for every attempt and `settlePending` emits it - declined attempts
+ * included, with the reason on the card.
+ *
+ * WHAT THE OLD RULE PROTECTED IS STILL PROTECTED, by a different mechanism: the
+ * transcript cannot flood, because `maxPerRun` (5) and `stuckLimit` (2) bound the
+ * attempts and the auto path self-disables and says so once. `onCompactorEvent`'s
+ * `if (!this.open)` guard is still load-bearing: it is what stops a late record
+ * from re-opening a card the engine's verdict already closed.
  */
 import type { ModelRole } from '../config/model-profiles.js';
 import { type AgentEvent, type ContextManager, type Message, type ModelInfo, type ModelRef, type ProviderRegistry, type ProviderRegistryOptions, type TokenUsage } from '@aragon-agent/core';

package/dist/compaction/wiring.js

@@ -368,6 +368,7 @@ export class CompactionWiring {
             live: this.enabled && summarizer !== null,
             model: summarizer?.ref.modelId ?? '',
             compactions: totals.compactions,
+            applied: totals.applied,
             // OMITTED WHEN ZERO (quiet-noop D-9), so a healthy session's snapshot is
             // shaped exactly as it was before this feature and `/compact status` has
             // nothing extra to render.

package/dist/config/load.js

@@ -7,7 +7,7 @@
  */
 import process from 'node:process';
 import { JOB_WAIT_MARGIN_MS } from '../proc/limits.js';
-import { DEFAULT_CONFIG, DEFAULT_SCROLL_MODE, IDLE_TIMEOUT_MARGIN_MS, clampAskRounds, clampDensity, clampHumanTimeout, clampCompactionConfig, clampLogConfig, clampFastConfig, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampBashConfig, clampJobsConfig, clampPromptsConfig, clampTaskSummaryConfig, clampUpdateConfig, clampTheme, clampThinkingLevel, clampContextWindow, clampMaxTokens, clampMaxRenderInterval, clampScrollMode, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAutoToken, isSkillsToolPolicyMode, legacyTeamCeilingPatch, parseThresholdInput, } from './schema.js';
+import { DEFAULT_CONFIG, DEFAULT_SCROLL_MODE, IDLE_TIMEOUT_MARGIN_MS, clampDensity, clampHumanTimeout, clampCompactionConfig, clampLogConfig, clampFastConfig, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampBashConfig, clampJobsConfig, clampPromptsConfig, clampTaskSummaryConfig, clampUpdateConfig, clampTheme, clampThinkingLevel, clampContextWindow, clampMaxTokens, clampMaxRenderInterval, clampScrollMode, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAutoToken, isSkillsToolPolicyMode, legacyTeamCeilingPatch, legacyTeamFanoutPatch, LEGACY_TEAM_FANOUT_DEFAULTS, parseThresholdInput, } from './schema.js';
 import { loadDotenv, readEnvConfig, readEnvDisabledSkills } from './env.js';
 import { readConfigFile, updatePersistedConfig } from './store.js';
 import { projectModelProfiles, resolveModelProfileState, resolveModelRoleKey, } from './model-profile-resolution.js';
@@ -517,6 +517,49 @@ function migrateLegacyTeamCeilings(raw) {
         keys: Object.keys(patch).join(','),
     });
 }
+/**
+ * Rewrite the cli<=0.6.x persisted fan-out defaults (5 / 3) to the new ones
+ * (8 / 8) and persist the change (subagent-fanout D-3 / D-4).
+ *
+ * ONE-SHOT and IDEMPOTENT, and the FILE LAYER ONLY, for the reasons
+ * `migrateLegacyTeamCeilings` records one block above: env (`ARAGON_TEAM_MAX`)
+ * and `--team-max` are THIS launch's intent and are never rewritten, the raw
+ * file object is patched IN PLACE so the `file` layer resolved below already
+ * reads 8/8, and a failed write leaves the marker absent so the next launch
+ * retries the whole migration.
+ *
+ * WHY A MARKER AND NOT JUST THE NUMBERS: `fanoutMigrated` is what keeps a user
+ * who deliberately returns to 5/3 from being migrated again on every launch
+ * (`legacyTeamFanoutPatch` returns `null` once it is set). The price of
+ * exact-equality is that one deliberate 5/3 is widened once; the marker bounds
+ * that to at most once.
+ */
+function migrateLegacyTeamFanout(raw) {
+    const patch = legacyTeamFanoutPatch(raw?.team);
+    if (patch === null)
+        return;
+    // READ THE STARTING POINT BEFORE THE IN-PLACE PATCH, and never hardcode
+    // `5/3`: rule 4 of the matcher accepts an ABSENT `maxConcurrent`, in which
+    // case the honest starting point is "unset" - a log line the user cannot find
+    // on disk is worse than no log line.
+    const from = `${LEGACY_TEAM_FANOUT_DEFAULTS.maxSubagents}/${raw?.team?.maxConcurrent ?? 'unset'}`;
+    // THE FULL SECTION, not the bare patch: the write port types `team` as a
+    // whole `TeamConfig`, and the section the file already carries plus the three
+    // keys IS the section we want on disk.
+    const migratedTeam = { ...raw.team, ...patch };
+    Object.assign(raw.team, patch);
+    try {
+        updatePersistedConfig({ team: migratedTeam });
+    }
+    catch {
+        // Unwritable config dir: in-memory values are already migrated; retry next
+        // launch (idempotent, because the marker never made it to disk).
+    }
+    getLogger().warn('config', 'team_fanout_migrated', {
+        from,
+        to: `${patch.maxSubagents}/${patch.maxConcurrent}`,
+    });
+}
 /**
  * Resolve the effective config by merging all layers, then derive the runtime
  * (non-persisted) fields and enforce the timeout invariant.
@@ -527,6 +570,12 @@ export function loadConfig(flags = {}, options = {}) {
     loadDotenv(cwd);
     const read = readConfigFile();
     migrateLegacyTeamCeilings(read.config);
+    // THE NEXT LINE, not a shared pass: the two migrations are independent, and
+    // keeping them as two statements keeps each one's "returns null when nothing
+    // matches" contract visible. Both run BEFORE `projectModelProfiles` for the
+    // same reason - the `file` layer resolved below must already read the migrated
+    // numbers, and neither migration needs a second projection path.
+    migrateLegacyTeamFanout(read.config);
     const projection = projectModelProfiles(read.config ?? {});
     const file = projection.file;
     const env = readEnvConfig();
@@ -570,7 +619,6 @@ export function loadConfig(flags = {}, options = {}) {
     // a config file that turned plan mode on.
     const startInPlanMode = pick(flags.plan, env.partial.planModeDefault, file.planModeDefault) ??
         DEFAULT_CONFIG.planModeDefault;
-    const planModeMaxAskRounds = clampAskRounds(file.planModeMaxAskRounds, DEFAULT_CONFIG.planModeMaxAskRounds);
     const planModeHumanTimeoutMs = clampHumanTimeout(file.planModeHumanTimeoutMs, DEFAULT_CONFIG.planModeHumanTimeoutMs);
     const toolTimeoutMs = coercePositiveInt(pick(flags.toolTimeout, file.toolTimeoutMs), DEFAULT_CONFIG.toolTimeoutMs);
     // THE `jobs` SECTION IS RESOLVED HERE, ABOVE THE TIMEOUT BLOCK, and the
@@ -706,7 +754,6 @@ export function loadConfig(flags = {}, options = {}) {
         // From `<home>/state.json`, not the config file — see `ui-state.ts`.
         submitCount: readSubmitCount(),
         startInPlanMode,
-        planModeMaxAskRounds,
         planModeHumanTimeoutMs,
         skills,
         skillsRuntime: {