@aragon-agent/cli 0.6.39 → 0.6.40

package/dist/commands/subagent-command.js

@@ -0,0 +1,242 @@
+/**
+ * `/subagent` — force the next turn to fan out into a parallel team
+ * (subagent-fanout 3.5 / 5.2).
+ *
+ * ASCII ONLY: `src/commands/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * WHAT THIS COMMAND IS AND IS NOT (D-8 / D-9 / D-10). It does not dispatch: it
+ * parses the user's intent, refuses honestly when forcing cannot work, prints
+ * ONE line saying what will happen next, and submits a normal user turn. The
+ * lead then calls `task` on the one dispatch path that already exists, so Esc,
+ * the watchdog pause, the report, spend accounting and the concurrency lock all
+ * keep working without a second implementation. The consequence the user must
+ * be told about is that forcing is INSTRUCTION-LEVEL: the notice says "the next
+ * turn dispatches them", never "N subagents started".
+ *
+ * THE GUARD ORDER IS A CONTRACT (R-P1-10 / R-P1-11): status -> capability ->
+ * parse. A `--no-team` session typing `/subagent -n x` is told the session has
+ * no team capability, because a syntax hint would send them to fix the one thing
+ * that is not wrong.
+ */
+import { buildForcedDirective, parseSubagentArgs } from '../team/forced-dispatch.js';
+import { subagentModelSummary } from '../ui/overlays/model-profile-state.js';
+/**
+ * The default count when the user names none (D-11).
+ *
+ * FOUR, not `maxSubagents`: `<team_mode>` tells the model two to four is usually
+ * enough, so "force one dispatch" must not silently become the most expensive
+ * call the session can make. The status line advertises the real ceiling so the
+ * user who wants the widest fan-out knows which flag to add.
+ */
+const DEFAULT_FORCED_COUNT = 4;
+/** `off (--no-team)` / `off` / `on`: the three states the status line tells apart. */
+function teamState(ctx) {
+    if (!ctx.controller.isTeamRegistered())
+        return 'off (--no-team)';
+    return ctx.controller.isTeamEnabled() ? 'on' : 'off';
+}
+/** The subagent model line, phrased by the same authority `/team status` uses. */
+function modelLine(ctx) {
+    const config = ctx.controller.getConfig();
+    const team = ctx.controller.getTeamConfig();
+    const fast = config.fast;
+    return subagentModelSummary({
+        mode: team.model,
+        modelProfileId: team.modelProfileId,
+        mainConnection: `${config.provider}:${config.model}`,
+        fastConnection: fast.enabled && fast.model
+            ? `${fast.provider || config.provider}:${fast.model}` : null,
+        profiles: config.modelProfiles,
+        hasKey: (id) => ctx.controller.hasApiKey(id),
+    });
+}
+/**
+ * The no-argument answer: five lines, honest in every session state.
+ *
+ * IT RUNS BEFORE EVERY GUARD (R-P1-11). "How wide can I go?" is a question, not
+ * a request, and a question deserves an answer even in a `--no-team` session -
+ * which is exactly where the user is most likely to ask it.
+ */
+function reportStatus(ctx) {
+    const team = ctx.controller.getTeamConfig();
+    const max = team.maxSubagents;
+    // The bracket's bounds are the LIVE width, never a literal: at capacity 2 this
+    // line has to read `<2-2>`, or the status line teaches a flag that arrives
+    // narrowed every time.
+    const low = Math.min(2, max);
+    const lines = [
+        `Forced fan-out: /subagent [-n <${low}-${max}>] [--parts a,b,c] [--read-only] <brief>`,
+        `Capacity: ${max} per dispatch, ${team.maxConcurrent} at once `
+            + '(team.maxSubagents / team.maxConcurrent)',
+        `Subagent model: ${modelLine(ctx)}`,
+        `Supervisor: ${team.overseer ? 'on' : 'off'}. Team mode: ${teamState(ctx)}.`,
+    ];
+    // Disclosed, never refused (R-P2-6): plan mode may remove `task` from this
+    // turn's tool array, and a user who is told so will not read the silence as a
+    // broken command.
+    if (ctx.controller.getAgentMode() === 'plan') {
+        lines.push('Plan mode is on: the task tool may be unavailable this turn.');
+    }
+    ctx.notify('info', lines.join('\n'));
+}
+/**
+ * Guard 5's sentence. The provider is named because "no API key" alone leaves
+ * the user guessing which of their configured providers is the empty one.
+ */
+function reportMissingKey(ctx, team) {
+    const config = ctx.controller.getConfig();
+    const resolution = ctx.controller.subagentModelResolution();
+    const provider = resolution.effective === 'main'
+        ? config.provider : resolution.ref.providerId;
+    const note = team.model === 'fast' && !ctx.controller.hasApiKey(undefined, 'fast')
+        ? ' Fast tier has no key either; children will fail and the report will say so.'
+        : '';
+    ctx.notify('warn', `No API key for ${provider}. Set one with /settings or an environment variable.${note}`);
+}
+/** The five capability refusals, in the fixed order 3.5.3 records. */
+function refused(ctx, team) {
+    if (!ctx.controller.isTeamRegistered()) {
+        ctx.notify('warn', 'Team mode is off for this session (started with --no-team). '
+            + 'Restart without --no-team to use /subagent.');
+        return true;
+    }
+    if (!ctx.controller.isTeamEnabled()) {
+        ctx.notify('warn', 'Team mode is off. Run /team on, then /subagent again.');
+        return true;
+    }
+    // The team lock and the lead's turn are separate refusals for one reason: both
+    // would collide with `task`'s own BUSY_REFUSAL, and the user would see a failed
+    // tool card instead of a sentence explaining why nothing ran.
+    if (ctx.controller.isTeamBusy()) {
+        ctx.notify('warn', 'A team dispatch is already running. '
+            + 'Wait for its report, or press Esc to stop it.');
+        return true;
+    }
+    if (ctx.controller.isRunning()) {
+        ctx.notify('warn', 'A turn is in progress. Press Esc to stop it, then run /subagent again.');
+        return true;
+    }
+    if (!ctx.controller.hasApiKey()) {
+        reportMissingKey(ctx, team);
+        return true;
+    }
+    return false;
+}
+/** The four parse failures, each with the one sentence that fixes it. */
+function reportParseError(ctx, parsed) {
+    if (parsed.error === 'count') {
+        ctx.notify('warn', '/subagent: -n needs a number of 1 or more, e.g. -n 4.');
+        return;
+    }
+    if (parsed.error === 'conflict') {
+        ctx.notify('warn', '/subagent: use -n or --parts, not both.');
+        return;
+    }
+    if (parsed.error === 'flag') {
+        ctx.notify('warn', `/subagent: unknown option "${parsed.token ?? ''}". Try /subagent for usage.`);
+        return;
+    }
+    ctx.notify('warn', '/subagent <brief> - describe the work; add -n <count> to fix the fan-out.');
+}
+/**
+ * Narrow the parsed intent against the LIVE width.
+ *
+ * TWO CEILINGS, IN THIS ORDER (R-P1-3): the structural `forcedPartsMax` bounds
+ * what one argument may carry (the parser already applied it), and the policy
+ * `maxSubagents` bounds what this session may dispatch - which only this layer
+ * can apply, because only it can read the live config.
+ */
+function planForced(args, team) {
+    const max = team.maxSubagents;
+    if (args.parts.length > 0) {
+        // A PARTS LIST STARTS WITH A CHILD PER SURVIVING PART, and `requested` is the
+        // number the user TYPED - not the structural 8 the parser already applied.
+        // Quoting the post-truncation count made the old notice tell a user who asked
+        // for eleven parts that they had asked for eight (R-4: the notice and the
+        // directive must both name the user's number).
+        const parts = args.parts.slice(0, max);
+        return {
+            brief: args.brief,
+            parts,
+            partsAdmitted: args.parts.length,
+            partsRequested: args.partsRequested,
+            requested: args.partsRequested,
+            count: parts.length,
+            readOnly: args.readOnly,
+        };
+    }
+    const requested = args.count ?? Math.min(DEFAULT_FORCED_COUNT, max);
+    return {
+        brief: args.brief,
+        parts: [],
+        partsAdmitted: 0,
+        partsRequested: 0,
+        requested,
+        count: Math.max(1, Math.min(requested, max)),
+        readOnly: args.readOnly,
+    };
+}
+/** The one line that says what the NEXT turn will do - a plan, not a result. */
+function planNotice(planned, team) {
+    const noun = planned.count === 1 ? 'subagent' : 'subagents';
+    const head = `Forcing a fan-out of ${planned.count} ${noun}`;
+    const followUp = `${head} (max ${team.maxSubagents}) - the next turn dispatches them. `
+        + 'Esc stops the turn.';
+    // TWO CEILINGS, TWO SENTENCES. `forcedPartsMax` bounds what one argument may
+    // carry and `team.maxSubagents` bounds what may be dispatched; naming the wrong
+    // one sends the user to change a number that is not the reason.
+    if (planned.parts.length > 0) {
+        if (planned.parts.length < planned.partsAdmitted) {
+            return `${head} (asked for ${planned.partsRequested} parts; `
+                + `team.maxSubagents is ${team.maxSubagents}).`;
+        }
+        if (planned.partsAdmitted < planned.partsRequested) {
+            return `${head} (asked for ${planned.partsRequested} parts, `
+                + `the first ${planned.parts.length} are used).`;
+        }
+        return followUp;
+    }
+    if (planned.requested > planned.count) {
+        return `${head} (asked for ${planned.requested}; `
+            + `team.maxSubagents is ${team.maxSubagents}).`;
+    }
+    return followUp;
+}
+/** The command body; `registerSubagentCommand` is the only registration site. */
+export function runSubagentCommand(ctx) {
+    if (ctx.args.trim().length === 0) {
+        reportStatus(ctx);
+        return;
+    }
+    const team = ctx.controller.getTeamConfig();
+    if (refused(ctx, team))
+        return;
+    const parsed = parseSubagentArgs(ctx.args);
+    if (!parsed.ok) {
+        reportParseError(ctx, parsed);
+        return;
+    }
+    const planned = planForced(parsed.args, team);
+    const directive = buildForcedDirective({
+        brief: planned.brief,
+        count: planned.count,
+        readOnly: planned.readOnly,
+        parts: planned.parts,
+        maxSubagents: team.maxSubagents,
+        clamped: planned.requested > planned.count,
+        requested: planned.requested,
+        planMode: ctx.controller.getAgentMode() === 'plan',
+    });
+    ctx.notify('info', planNotice(planned, team));
+    // `userInitiated: false`: a directive the user did not type belongs in neither
+    // the prompt history nor the hint-fade counter (todo-plan-followthrough C-12).
+    ctx.submit(directive, { userInitiated: false });
+}
+/** Registered from `builtins.ts` with one line, next to every other subsystem. */
+export function registerSubagentCommand(registry) {
+    registry.register({
+        name: 'subagent',
+        description: 'Force the next turn to fan out into a parallel team',
+        run: (ctx) => { runSubagentCommand(ctx); },
+    });
+}

package/dist/compaction/command.js

@@ -16,6 +16,7 @@ import { parseThresholdInput } from '../config/schema.js';
 import { formatCost, formatTokens } from '../agent/usage.js';
 import { computeCost } from '../agent/usage.js';
 import { COMPACTION_LIMITS } from './limits.js';
+import { compactionReasonLine } from './reason-text.js';
 import { findArchive, listArchives } from './archive.js';
 /**
  * `/compact status` — THE GUARANTEED REPORTING SURFACE (§6.5 / AC-17).
@@ -46,7 +47,7 @@ export function formatCompactionStatus(ctx) {
         return lines.join('\n');
     }
     const state = snapshot.selfDisabled
-        ? `self-disabled (${snapshot.selfDisabledReason ?? 'no progress'})`
+        ? `self-disabled (${compactionReasonLine(snapshot.selfDisabledReason ?? 'no progress')})`
         : controller.isCompactionEnabled()
             ? snapshot.live
                 ? 'on'
@@ -61,7 +62,13 @@ export function formatCompactionStatus(ctx) {
         `[${p.source === 'usage' ? 'measured' : 'estimated'}]`);
     lines.push(`  Automatic trigger: occupancy >= ${(config.threshold * 100).toFixed(2)}%; ` +
         `manual: /compact (${Math.ceil(p.contextWindow * config.threshold)} tokens)`);
+    // TWO LINES, BECAUSE THE TAIL GUARANTEE IS NOW CONDITIONAL (never-fires B).
+    // `keepRecentTurns` stays the promise; the second line is what happens when a run
+    // has too few user turns for that promise to be satisfiable, and saying it here
+    // is what makes the card's `kept M of N` readable rather than surprising.
     lines.push(`  Keeps: the original task + ${config.keepRecentTurns} recent turns, verbatim`);
+    lines.push(`  Relaxes to: the last ${COMPACTION_LIMITS.minRetainedMessages} messages ` +
+        'when a run has too few user turns for that');
     lines.push(`  Summarizer: ${snapshot.model || '(none)'}` +
         (config.useFastTier ? ' (fast tier preferred)' : ' (fast tier not used)'));
     lines.push('  On summarize failure: ' + (config.onFailure === 'truncate'
@@ -79,8 +86,14 @@ export function formatCompactionStatus(ctx) {
     if (declined > 0) {
         sessionNotes.push(`${declined} ${declined === 1 ? 'checkpoint' : 'checkpoints'} declined`);
     }
-    lines.push(`  This session: ${snapshot.compactions} ` +
-        `${snapshot.compactions === 1 ? 'compaction' : 'compactions'}` +
+    // ATTEMPTS, THEN APPLIED (never-fires C). `compactions` counts every card the
+    // user saw, which now includes the ones that declined, so reporting it alone
+    // would overstate how much the feature actually achieved.
+    const attempts = snapshot.applied === undefined
+        ? `${snapshot.compactions} ${snapshot.compactions === 1 ? 'compaction' : 'compactions'}`
+        : `${snapshot.compactions} ${snapshot.compactions === 1 ? 'attempt' : 'attempts'}` +
+            ` (${snapshot.applied} applied)`;
+    lines.push(`  This session: ${attempts}` +
         (sessionNotes.length > 0 ? ` (${sessionNotes.join(', ')})` : '') +
         `, ${formatTokens(snapshot.tokensReclaimed)} tokens reclaimed`);
     const cost = snapshot.pricingUnknown

package/dist/compaction/compactor.d.ts

@@ -93,6 +93,7 @@ export declare class Compactor implements ContextManager {
     private compactionsThisRun;
     private lastCompactionTurn;
     private compactions;
+    private appliedCompactions;
     private declined;
     private tokensReclaimed;
     private sessionUsage;
@@ -132,8 +133,31 @@ export declare class Compactor implements ContextManager {
     private callOnce;
     private checkCandidate;
     private isCurrent;
+    /**
+     * Open the card for THIS attempt (C).
+     *
+     * CALLED FROM `compact()`'S ENTRY, so the two pre-model rejections are visible
+     * too. The old position - inside `callOnce` - made an attempt that never called
+     * a model indistinguishable from a checkpoint that never fired, which is exactly
+     * how this feature spent 96 attempts without a single user-visible symptom.
+     *
+     * `state.index !== undefined` keeps it idempotent: `callOnce` no longer calls it,
+     * but the guard stays so a future re-announce cannot open a second card for one
+     * attempt.
+     */
     private announce;
+    /** Publish the current phase, for the live card only. */
+    private phase;
     private keep;
+    /**
+     * The relaxation disclosure, as record fields.
+     *
+     * ONE PLACE BUILDS IT, so the card, the reducer and the diagnostic log cannot
+     * describe one relaxed cut three different ways. Absent entirely when the first
+     * planning pass found a cut, which is what keeps a normal compaction's record
+     * byte-identical to the round before this change.
+     */
+    private relaxedFields;
     private finishRecord;
     /** Commit only the engine/host verdict; candidates have no authority before this point. */
     settleOperation(verdict: {
@@ -152,6 +176,7 @@ export declare class Compactor implements ContextManager {
     sessionTotals(): {
         selfDisabledReason?: string | undefined;
         compactions: number;
+        applied: number;
         declined: number;
         tokensReclaimed: number;
         usage: TokenUsage;

package/dist/compaction/compactor.js

@@ -13,6 +13,7 @@ import { prepareMemoryInput } from './memory-input.js';
 import { mergeMemory, parseMemoryDelta } from './memory.js';
 import { validateMemoryDelta } from './memory-validation.js';
 import { renderMemoryMarkdown } from './memory-render.js';
+import { compactionReasonLine } from './reason-text.js';
 import { createCompactionIdentity, verifyCompactionIdentity, } from './memory-identity.js';
 export class Compactor {
     deps;
@@ -20,6 +21,7 @@ export class Compactor {
     compactionsThisRun = 0;
     lastCompactionTurn = -Infinity;
     compactions = 0;
+    appliedCompactions = 0;
     declined = 0;
     tokensReclaimed = 0;
     sessionUsage = { inputTokens: 0, outputTokens: 0 };
@@ -110,16 +112,24 @@ export class Compactor {
             return { action: 'keep', reason: 'already_running' };
         const manual = this.pendingManual;
         this.pendingManual = null;
+        const keepRecentTurns = this.deps.getConfig().compaction.keepRecentTurns;
         const state = {
             operation: new CompactionOperation(++this.serial, ctx.signal, COMPACTION_LIMITS.operationTimeoutMs),
             epoch: this.historyEpoch, settings: this.settingsKey(),
             trigger: manual ? 'manual' : ctx.trigger, pressure: this.meter().current(),
             threshold: this.deps.getConfig().compaction.threshold,
             started: Date.now(), messages: [...ctx.messages], model: '',
+            keepRelaxed: false, keepRecentTurns,
         };
         this.active = state;
         this.compactionsThisRun += 1;
         this.lastCompactionTurn = ctx.turnIndex;
+        // THE CARD OPENS HERE, NOT AT THE FIRST PAID CALL (C). `announce` used to be
+        // invoked from `callOnce`, so the two rejections that account for 96 of 96
+        // attempts in the field - no safe cut, digest too long - happened BEFORE it
+        // and produced no card at all. Every attempt is now visible, and every one is
+        // settled by `finishRecord` below or by the wiring's own settle.
+        this.announce(state);
         try {
             if (state.operation.signal.aborted)
                 throw new Error('aborted');
@@ -134,23 +144,38 @@ export class Compactor {
         if (this.identity && !verifyCompactionIdentity(state.messages, this.identity)) {
             return this.keep(state, 'invalid_prior_memory');
         }
+        // B: `retainMessages` IS THE SECOND PASS, AND IT IS OPT-IN (see the core
+        // argument at `PlanCompactionOptions.retainMessages`). Without it a long
+        // autonomous run - one user prompt and three hundred tool calls - has no
+        // legal cut at all, because every candidate leaves fewer than
+        // `keepRecentTurns` USER messages behind it. 107 of 119 long sessions on the
+        // reporting machine were in exactly that state.
         const plan = planCompaction(state.messages, {
             keepRecentTurns: config.keepRecentTurns,
             protectedPrefix: countProtectedPrefix(state.messages, this.identity),
+            retainMessages: COMPACTION_LIMITS.minRetainedMessages,
         });
         if (!plan)
             return this.keep(state, 'nothing_to_drop');
+        state.keepRelaxed = plan.keepRelaxed === true;
+        state.retainedTurns = plan.retainedTurns;
+        state.retainedMessages = state.messages.length - plan.cutIndex;
+        this.phase(state, 'digesting');
         const input = prepareMemoryInput({ messages: state.messages, cutIndex: plan.cutIndex,
             ...(this.identity ? { identity: this.identity } : {}) });
         const selected = this.selectInput(input, instructions);
+        state.elided = selected.digest.omitted;
         this.checkMinimumCandidate(input, selected.digest, state, ctx.systemPrompt);
+        this.phase(state, 'summarizing');
         const memory = await this.summarize(state, input, selected, instructions);
         if (!this.isCurrent(state, ctx))
             return this.keep(state, 'stale_history');
+        this.phase(state, 'validating');
         const block = buildCompactedBlock({ memory, replaced: input.cutIndex,
             turns: input.tail.filter((m) => m.role === 'user').length,
             anchor: input.anchorShape, generation: memory.generation, truncated: false });
         const candidate = [input.anchor, block, ...input.tail];
+        this.phase(state, 'applying');
         this.checkCandidate(candidate, state, ctx.systemPrompt);
         state.candidate = candidate;
         state.generation = memory.generation;
@@ -168,7 +193,14 @@ export class Compactor {
             return { choice, digest: this.digestFor(input, choice, instructions) };
         }
         catch (error) {
-            if (!choice.fromFastTier || !errorText(error).includes('digest_budget_exceeded'))
+            // BOTH CODES MEAN "THIS SUMMARIZER IS TOO SMALL FOR THIS HEAD", and both are
+            // worth one retry on the main model. `digest_budget_exceeded` no longer
+            // comes from the digest LENGTH (A1 elides instead of throwing) - it now
+            // comes only from the request-vs-window projection below - so the two names
+            // differ by which ceiling was hit, not by which is fatal.
+            const windowBound = /digest_budget_exceeded|summarizer_window_exceeded/
+                .test(errorText(error));
+            if (!choice.fromFastTier || !windowBound)
                 throw error;
             const main = this.mainChoice();
             return { choice: main, digest: this.digestFor(input, main, instructions) };
@@ -204,7 +236,12 @@ export class Compactor {
             ...(instructions ? { instructions } : {}) });
         if (estimatePromptTokens(request.messages, request.systemPrompt) +
             COMPACTION_LIMITS.summaryOutputTokens + CONTEXT_SAFETY_MARGIN_TOKENS >= window) {
-            throw new Error('digest_budget_exceeded');
+            // A DIFFERENT GATE FROM THE DIGEST'S LENGTH BUDGET, and it keeps a different
+            // reason code on purpose (A1). This one is the REAL ceiling - the actual
+            // request does not fit the summarizer's window - so it must still refuse.
+            // Giving it the length budget's name would send `selectInput`'s retry ladder
+            // and every log reader after the wrong cause.
+            throw new Error('summarizer_window_exceeded');
         }
         return digest;
     }
@@ -246,7 +283,10 @@ export class Compactor {
         const apiKey = this.deps.getApiKey(choice.ref.providerId, choice.role);
         if (!apiKey)
             throw new Error('no_api_key');
-        this.announce(state, choice);
+        // THE RECORD NAMES THE MODEL THAT ACTUALLY RAN, which may be the main model
+        // after a fast-tier retry - `announce` can only name the one it EXPECTED.
+        if (state.index !== undefined)
+            state.model = choice.ref.modelId;
         const outcome = await state.operation.run(() => runSummarizeCall({
             ...input, ref: choice.ref, apiKey, signal: state.operation.signal, now: Date.now(),
             complete: (providerId, request) => this.deps.complete(providerId, request),
@@ -273,13 +313,35 @@ export class Compactor {
             state.settings === this.settingsKey() && !ctx.signal.aborted &&
             !state.operation.signal.aborted;
     }
-    announce(state, choice) {
-        state.model = choice.ref.modelId;
+    /**
+     * Open the card for THIS attempt (C).
+     *
+     * CALLED FROM `compact()`'S ENTRY, so the two pre-model rejections are visible
+     * too. The old position - inside `callOnce` - made an attempt that never called
+     * a model indistinguishable from a checkpoint that never fired, which is exactly
+     * how this feature spent 96 attempts without a single user-visible symptom.
+     *
+     * `state.index !== undefined` keeps it idempotent: `callOnce` no longer calls it,
+     * but the guard stays so a future re-announce cannot open a second card for one
+     * attempt.
+     */
+    announce(state) {
         if (state.index !== undefined)
             return;
+        // THE MODEL IS NAMED BEFORE IT IS USED, and `''` when none resolves - the card
+        // renders that as "compacting context #N" with no dangling separator, and the
+        // attempt then declines at `selectInput` with `no_summarizer_model`.
+        state.model = this.resolveSummarizer()?.ref.modelId ?? '';
         state.index = ++this.compactions;
         this.deps.emit({ type: 'compaction_start', index: state.index,
             trigger: state.trigger, model: state.model });
+        this.phase(state, 'planning');
+    }
+    /** Publish the current phase, for the live card only. */
+    phase(state, phase) {
+        if (state.index === undefined)
+            return;
+        this.deps.emit({ type: 'phase', index: state.index, phase });
     }
     keep(state, reason) {
         state.reason = reason;
@@ -287,21 +349,50 @@ export class Compactor {
         if (this.active !== state)
             return outcome;
         this.finishRecord(state, outcome);
-        if (state.trigger === 'manual')
+        // NO DUPLICATE NOTICE FOR A DECLINE THE CARD ALREADY REPORTS (C).
+        // `setEnabled`/`command.ts` used to pair every failed `/compact` with a
+        // `History preserved: <code>.` toast while the transcript said nothing; now the
+        // card is the surface, and two surfaces saying one thing is the failure mode
+        // `fast` and `team` both avoid. The notice survives ONLY for the one path that
+        // still has no card (an attempt that never announced).
+        if (state.trigger === 'manual' && state.index === undefined) {
             this.deps.notify('warn', `History preserved: ${reason}.`);
+        }
         if (this.deps.getConfig().compaction.onFailure === 'truncate' && !this.legacyFailureNotified) {
             this.legacyFailureNotified = true;
             this.deps.notify('info', 'Legacy truncate configuration: preserving history on failure.');
         }
         return outcome;
     }
+    /**
+     * The relaxation disclosure, as record fields.
+     *
+     * ONE PLACE BUILDS IT, so the card, the reducer and the diagnostic log cannot
+     * describe one relaxed cut three different ways. Absent entirely when the first
+     * planning pass found a cut, which is what keeps a normal compaction's record
+     * byte-identical to the round before this change.
+     */
+    relaxedFields(state) {
+        if (!state.keepRelaxed)
+            return {};
+        return {
+            keepRelaxed: true,
+            keepRecentTurnsUsed: state.keepRecentTurns,
+            ...(state.retainedTurns === undefined ? {} : { retainedTurns: state.retainedTurns }),
+            ...(state.retainedMessages === undefined
+                ? {}
+                : { retainedMessages: state.retainedMessages }),
+        };
+    }
     finishRecord(state, outcome, summary) {
         if (this.active !== state)
             return;
-        if (state.index === undefined) {
+        // A DECLINE IS COUNTED EVEN WHEN IT HAS A CARD, so `/compact status` and the
+        // card agree about how many attempts did nothing.
+        if (outcome.action === 'keep')
             this.declined += 1;
+        if (state.index === undefined)
             return;
-        }
         const p = state.pressure;
         const record = {
             index: state.index, trigger: state.trigger,
@@ -312,6 +403,8 @@ export class Compactor {
             tokensBefore: p.occupied, tokensAfter: 0, model: state.model,
             durationMs: Date.now() - state.started, ...(summary ? { summary } : {}),
             memoryVersion: 2,
+            ...this.relaxedFields(state),
+            ...(state.elided ? { elidedMessages: state.elided } : {}),
             decision: { occupied: p.occupied, contextWindow: p.contextWindow,
                 threshold: state.threshold,
                 source: p.source, deltaTokens: p.deltaTokens },
@@ -327,6 +420,7 @@ export class Compactor {
         if (verdict.applied && state.candidate) {
             this.identity = createCompactionIdentity(state.candidate);
             this.generation = state.generation ?? this.generation;
+            this.appliedCompactions += 1;
             this.recordApplied(verdict.tokensBefore ?? state.pressure.occupied, verdict.tokensAfter);
             this.meter().onHistorySpliced();
             const projected = (verdict.tokensAfter + (state.pressure.estimateOffset ?? 0)) /
@@ -359,7 +453,13 @@ export class Compactor {
             return;
         this.selfDisabled = true;
         this.selfDisabledReason = reason;
-        this.deps.notify('warn', `Auto-compaction paused: ${reason}. History preserved. Use /compact.`);
+        // THE LOG LINE IS BACK ON PURPOSE (C / analysis 3.3.1 (c)). Commit 4b61a2f8a
+        // replaced `log.warn('compaction_self_disabled')` with a toast, and a toast
+        // scrolls away - so the one state that stops auto-compaction for the rest of a
+        // run had NO durable trace at all. Diagnosing the next report without this line
+        // means reading a session file and a config file by hand.
+        this.log.warn('compaction_self_disabled', { reason, trigger });
+        this.deps.notify('warn', `Auto-compaction paused: ${compactionReasonLine(reason)}. History preserved. Use /compact.`);
     }
     measure(_probe) { return this.meter().current(); }
     lastMeasured() { return this.meter().lastPublished(); }
@@ -367,7 +467,8 @@ export class Compactor {
         this.tokensReclaimed += Math.max(0, tokensBefore - tokensAfter);
     }
     sessionTotals() {
-        return { compactions: this.compactions, declined: this.declined,
+        return { compactions: this.compactions, applied: this.appliedCompactions,
+            declined: this.declined,
             tokensReclaimed: this.tokensReclaimed, usage: this.sessionUsage, costUsd: this.costUsd,
             pricingUnknown: this.pricingUnknown, inFlight: this.active !== null,
             selfDisabled: this.selfDisabled, generation: this.generation,

package/dist/compaction/digest.d.ts

@@ -22,5 +22,28 @@ export interface DigestResult {
 export declare function isPriorSummaryBlock(_message: Message): boolean;
 /** Derive the digest ceiling; known windows below reserve have no input room. */
 export declare function digestBudgetChars(summarizerWindow?: number): number;
-/** Build every head entry without mutating messages; rejects instead of omitting. */
+/**
+ * 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 declare function buildDigest(input: DigestInput): DigestResult;