@aragon-agent/cli 0.6.14 → 0.6.15

package/dist/compaction/digest.d.ts

@@ -1,62 +1,26 @@
-/**
- * The head of the history, rendered as a bounded plain-text transcript
- * (context-auto-compaction §3.6.3).
- *
- * ASCII ONLY: `src/compaction/**` is inside the glyph scanner's scope.
- *
- * PURE. Two reasons this is a digest rather than raw messages, and the second
- * one is the one that bites:
- *
- *  - Tool results are the bulk. Four 60 KB file reads are 240 KB of body that
- *    says almost nothing about what was decided.
- *  - THE SUMMARIZER MAY HAVE A SMALLER CONTEXT WINDOW THAN THE MODEL BEING
- *    COMPACTED. The whole point of using a cheap model is that it is cheap, and
- *    cheap models are exactly the ones with 32 k windows. Sending 180 k of
- *    history to summarize would fail with the same error we are recovering from
- *    (R-4).
- */
-import { type Message } from '@aragon-agent/core';
-/**
- * Is this `user` message a previous `<compacted_context>` block?
- *
- * Recognized on the OPENING TAG rather than a full parse: the block carries
- * attributes (`version`, `replaced`, `turns`, `anchor`, `generation`) that this
- * module has no business knowing about, and a stricter match would fail on the
- * first attribute anybody adds.
- */
-export declare function isPriorSummaryBlock(message: Message): boolean;
+/** Complete transcript input with bounded tool-only clipping and trusted sources. */
+import { type Message, type UserMessage } from '@aragon-agent/core';
+import { type CompactionMemory, type MemoryCoverage, type MemorySource } from './memory.js';
 export interface DigestInput {
-    /** The head — `messages[protectedPrefix..cutIndex)`. */
     head: readonly Message[];
-    /**
-     * The summarizer's own context window, or `undefined` when it is unknown.
-     *
-     * NOT the lead model's. This is the whole reason a digest exists rather than
-     * raw messages (R-4).
-     */
+    /** Retained original task is context only, never current acceptance evidence. */
+    anchor?: UserMessage;
     summarizerWindow?: number;
+    generation?: number;
+    startIndex?: number;
+    priorMemory?: CompactionMemory;
+    legacySummary?: string;
 }
 export interface DigestResult {
     text: string;
-    /** Entries the budget forced out. `> 0` means the marker is present. */
     omitted: number;
-    /** The budget actually used, after the window derivation. */
     budgetChars: number;
+    sourceMap: Map<string, MemorySource>;
+    coverage: MemoryCoverage;
 }
-/**
- * The character budget for one digest.
- *
- * `min(digestMaxChars, (summarizerWindow - summarizerReserveTokens) * CHARS_PER_TOKEN)`.
- * `CHARS_PER_TOKEN` comes from core (P2-3) rather than being re-spelled here: two
- * chars-per-token constants that must agree and nothing checking that they do is
- * how a digest budget and an occupancy estimate drift apart.
- */
+/** Text alone cannot identify a host summary; use verified identity at the caller. */
+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;
-/**
- * Render the head into a bounded transcript.
- *
- * OLDEST ENTRIES ARE DROPPED FIRST, except the pinned `PRIOR SUMMARY`, which is
- * evicted last of all. A single omission marker is prepended so the summary can
- * say that it is incomplete instead of pretending.
- */
+/** Build every head entry without mutating messages; rejects instead of omitting. */
 export declare function buildDigest(input: DigestInput): DigestResult;

package/dist/compaction/digest.js

@@ -1,164 +1,129 @@
-/**
- * The head of the history, rendered as a bounded plain-text transcript
- * (context-auto-compaction §3.6.3).
- *
- * ASCII ONLY: `src/compaction/**` is inside the glyph scanner's scope.
- *
- * PURE. Two reasons this is a digest rather than raw messages, and the second
- * one is the one that bites:
- *
- *  - Tool results are the bulk. Four 60 KB file reads are 240 KB of body that
- *    says almost nothing about what was decided.
- *  - THE SUMMARIZER MAY HAVE A SMALLER CONTEXT WINDOW THAN THE MODEL BEING
- *    COMPACTED. The whole point of using a cheap model is that it is cheap, and
- *    cheap models are exactly the ones with 32 k windows. Sending 180 k of
- *    history to summarize would fail with the same error we are recovering from
- *    (R-4).
- */
+/** Complete transcript input with bounded tool-only clipping and trusted sources. */
 import { CHARS_PER_TOKEN } from '@aragon-agent/core';
-import { BLOCK_TAG_CLOSE, BLOCK_TAG_OPEN, COMPACTION_LIMITS } from './limits.js';
-/** Prepended when the budget forced entries out, so the summary can say so. */
-const OMISSION_MARKER = (n) => `[... ${n} earlier ${n === 1 ? 'message' : 'messages'} omitted from this digest ...]`;
-function clip(text, max) {
-    if (text.length <= max)
-        return text;
-    return `${text.slice(0, max)}...`;
+import { COMPACTION_LIMITS as LIMITS } from './limits.js';
+import { isLegacyMemoryText, MemoryError, serializeMemory, } from './memory.js';
+/** Text alone cannot identify a host summary; use verified identity at the caller. */
+export function isPriorSummaryBlock(_message) {
+    return false;
 }
-/** Flatten `string | ContentPart[]` into text, naming images rather than dropping them. */
-function partsToText(content) {
-    if (typeof content === 'string')
-        return content;
-    if (!Array.isArray(content))
-        return '';
-    return content
-        .map((part) => (typeof part?.text === 'string' ? part.text : '[image]'))
-        .join('\n');
-}
-/**
- * Is this `user` message a previous `<compacted_context>` block?
- *
- * Recognized on the OPENING TAG rather than a full parse: the block carries
- * attributes (`version`, `replaced`, `turns`, `anchor`, `generation`) that this
- * module has no business knowing about, and a stricter match would fail on the
- * first attribute anybody adds.
- */
-export function isPriorSummaryBlock(message) {
-    if (message.role !== 'user')
-        return false;
-    const text = partsToText(message.content).trimStart();
-    return text.startsWith(BLOCK_TAG_OPEN);
+/** Derive the digest ceiling; known windows below reserve have no input room. */
+export function digestBudgetChars(summarizerWindow) {
+    if (summarizerWindow === undefined ||
+        !Number.isFinite(summarizerWindow) ||
+        summarizerWindow <= 0) {
+        return LIMITS.digestMaxChars;
+    }
+    return Math.min(LIMITS.digestMaxChars, Math.max(0, (summarizerWindow - LIMITS.summarizerReserveTokens) * CHARS_PER_TOKEN));
 }
-/** The block's body with its framing removed, for re-rendering as PRIOR SUMMARY. */
-function stripBlockTags(text) {
-    const trimmed = text.trim();
-    const open = trimmed.indexOf('>');
-    const close = trimmed.lastIndexOf(BLOCK_TAG_CLOSE);
-    if (open < 0)
-        return trimmed;
-    const body = close > open ? trimmed.slice(open + 1, close) : trimmed.slice(open + 1);
-    return body.trim();
+function contentText(content) {
+    if (typeof content === 'string')
+        return { text: content, visible: [content] };
+    return {
+        text: content
+            .map((part) => part.type === 'text' ? part.text : '[image unavailable to summarizer]')
+            .join('\n'),
+        visible: content.flatMap((part) => part.type === 'text' ? [part.text] : []),
+    };
 }
-function renderMessage(message) {
-    if (message.role === 'user') {
-        if (isPriorSummaryBlock(message)) {
-            // CARRIED WHOLE, up to `summaryMaxChars` (D-22 / P1-9).
-            //
-            // A `<compacted_context>` block IS a `user` message (D-5, deliberately),
-            // so a per-kind table that clipped it to `userChars` (2 000) would discard
-            // up to two thirds of the previous summary - which §5.4 permits to be
-            // 6 000 long - BEFORE summarizing it, and then report `summarized`. Every
-            // compaction after the first would decay the record silently.
-            const body = stripBlockTags(partsToText(message.content));
-            return [{ text: `PRIOR SUMMARY: ${clip(body, COMPACTION_LIMITS.summaryMaxChars)}`, pinned: true }];
-        }
-        return [
-            { text: `USER: ${clip(partsToText(message.content), COMPACTION_LIMITS.userChars)}`, pinned: false },
-        ];
-    }
-    if (message.role === 'tool_result') {
-        const status = message.isError ? 'error' : 'ok';
-        const body = clip(partsToText(message.content), COMPACTION_LIMITS.toolResultChars);
-        return [{ text: `RESULT[${status}] ${body}`, pinned: false }];
-    }
-    // Assistant: one entry per block, so a turn's text and its calls can be
-    // evicted independently.
-    const out = [];
+function renderAssistant(message, calls) {
+    const text = [];
+    const visible = [];
     for (const block of message.content) {
         if (block.type === 'text') {
-            if (block.text.trim().length === 0)
-                continue;
-            out.push({ text: `ASSISTANT: ${clip(block.text, COMPACTION_LIMITS.assistantChars)}`, pinned: false });
+            text.push(block.text);
+            visible.push(block.text);
         }
-        else if (block.type === 'tool_call') {
-            const args = clip(JSON.stringify(block.args ?? {}), COMPACTION_LIMITS.toolArgChars);
-            out.push({ text: `CALL ${block.toolName}(${args})`, pinned: false });
+        if (block.type === 'tool_call') {
+            const args = JSON.stringify(block.args);
+            text.push(`CALL ${block.toolName} toolCallId=${block.toolCallId}\n${args}`);
+            visible.push(args);
+            calls.set(block.toolCallId, block.toolName);
         }
-        // `thinking` blocks are DROPPED ENTIRELY (D-8): they are the model's private
-        // scratch, they are the single largest contributor at `thinkingLevel: high`,
-        // and nothing after the turn depends on them.
     }
-    return out;
+    return { text: text.join('\n'), visible };
 }
-/**
- * The character budget for one digest.
- *
- * `min(digestMaxChars, (summarizerWindow - summarizerReserveTokens) * CHARS_PER_TOKEN)`.
- * `CHARS_PER_TOKEN` comes from core (P2-3) rather than being re-spelled here: two
- * chars-per-token constants that must agree and nothing checking that they do is
- * how a digest budget and an occupancy estimate drift apart.
- */
-export function digestBudgetChars(summarizerWindow) {
-    const ceiling = COMPACTION_LIMITS.digestMaxChars;
-    if (!summarizerWindow || summarizerWindow <= 0)
-        return ceiling;
-    const usableTokens = summarizerWindow - COMPACTION_LIMITS.summarizerReserveTokens;
-    if (usableTokens <= 0)
-        return ceiling;
-    return Math.min(ceiling, usableTokens * CHARS_PER_TOKEN);
+function renderEntry(message, messageId, calls, result) {
+    const rendered = message.role === 'assistant'
+        ? renderAssistant(message, calls)
+        : contentText(message.content);
+    const source = { role: message.role, visibleText: rendered.visible };
+    let heading = `[${messageId}] ${message.role}`;
+    if (isLegacyMemoryText(message)) {
+        source.isLegacyReference = true;
+        heading += ' (legacy read-only reference, not current user acceptance)';
+    }
+    if (message.role === 'tool_result') {
+        source.toolCallId = message.toolCallId;
+        source.toolName = calls.get(message.toolCallId);
+        calls.delete(message.toolCallId);
+        source.isError = message.isError;
+        heading += ` tool=${source.toolName ?? 'unknown'} toolCallId=${message.toolCallId}`
+            + ` isError=${message.isError === true}`;
+        const edge = LIMITS.toolResultEdgeChars;
+        if (rendered.text.length > 2 * edge) {
+            const omittedChars = rendered.text.length - 2 * edge;
+            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}`
+                + ` omittedChars=${omittedChars}]\n${last}`;
+            result.coverage.clippedToolResults.push({ messageId, omittedChars });
+        }
+    }
+    result.sourceMap.set(messageId, source);
+    if (message.role !== 'user')
+        result.coverage.summarizedMessages += 1;
+    return `${heading}\n${rendered.text}`;
+}
+function clippedVisibleSections(parts, rendered, edge) {
+    const visible = [];
+    let from = 0;
+    for (const part of parts) {
+        const start = rendered.indexOf(part, from);
+        const end = start + part.length;
+        if (start < edge)
+            visible.push(part.slice(0, Math.max(0, edge - start)));
+        if (end > rendered.length - edge) {
+            visible.push(part.slice(Math.max(0, rendered.length - edge - start)));
+        }
+        from = end;
+    }
+    return visible.filter(Boolean);
 }
-/**
- * Render the head into a bounded transcript.
- *
- * OLDEST ENTRIES ARE DROPPED FIRST, except the pinned `PRIOR SUMMARY`, which is
- * evicted last of all. A single omission marker is prepended so the summary can
- * say that it is incomplete instead of pretending.
- */
+/** Build every head entry without mutating messages; rejects instead of omitting. */
 export function buildDigest(input) {
-    const budgetChars = digestBudgetChars(input.summarizerWindow);
-    const entries = input.head.flatMap(renderMessage);
-    const sep = '\n';
-    let total = entries.reduce((acc, e) => acc + e.text.length + sep.length, 0);
-    if (total <= budgetChars) {
-        return { text: entries.map((e) => e.text).join(sep), omitted: 0, budgetChars };
+    const generation = input.generation ?? 1;
+    const start = input.startIndex ?? 0;
+    if (!Number.isSafeInteger(generation) || generation < 1 ||
+        !Number.isSafeInteger(start) || start < 0) {
+        throw new MemoryError('invalid_memory_delta', '$.sourceIds');
     }
-    // Evict oldest-first among the unpinned. The marker itself costs characters,
-    // so it is charged up front against a worst-case width.
-    const kept = [...entries];
-    let omitted = 0;
-    let reserve = OMISSION_MARKER(entries.length).length + sep.length;
-    for (let i = 0; i < kept.length && total + reserve > budgetChars; i += 1) {
-        const entry = kept[i];
-        if (entry.pinned)
-            continue;
-        total -= entry.text.length + sep.length;
-        kept[i] = { text: '', pinned: false };
-        omitted += 1;
+    const result = {
+        text: '',
+        omitted: 0,
+        budgetChars: digestBudgetChars(input.summarizerWindow),
+        sourceMap: new Map(),
+        coverage: { summarizedMessages: 0, clippedToolResults: [] },
+    };
+    const parts = [];
+    if (input.anchor) {
+        parts.push('ORIGINAL TASK (read-only reference, not current evidence):\n'
+            + contentText(input.anchor.content).text);
     }
-    // Still over budget with only pinned entries left: clip the pinned text rather
-    // than dropping it, so the densest record survives in some form.
-    if (total + reserve > budgetChars) {
-        const room = Math.max(0, budgetChars - reserve);
-        const joined = kept.filter((e) => e.text.length > 0).map((e) => e.text).join(sep);
-        return {
-            text: `${OMISSION_MARKER(omitted)}${sep}${joined.slice(0, room)}`,
-            omitted,
-            budgetChars,
-        };
+    if (input.priorMemory) {
+        parts.push(`PRIOR MEMORY (read-only):\n${serializeMemory(input.priorMemory)}`);
     }
-    const body = kept.filter((e) => e.text.length > 0).map((e) => e.text).join(sep);
-    return {
-        text: omitted > 0 ? `${OMISSION_MARKER(omitted)}${sep}${body}` : body,
-        omitted,
-        budgetChars,
-    };
+    if (input.legacySummary && !input.priorMemory?.legacySummary) {
+        parts.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');
+    }
+    if (result.coverage.clippedToolResults.length > LIMITS.coverageClips) {
+        throw new MemoryError('protected_memory_too_large', '$.coverage');
+    }
+    return result;
 }

package/dist/compaction/limits.d.ts

@@ -1,165 +1,42 @@
-/**
- * COMPACTION_LIMITS — the single authority on every bound context compaction
- * enforces (context-auto-compaction §5.4).
- *
- * ASCII ONLY: `src/compaction/**` is inside the glyph scanner's scope
- * (`glyphs.test.ts::inScope`), so no literal in this tree may hold a non-ASCII
- * byte. That regex is a HARDCODED DIRECTORY LIST, which is why adding this tree
- * and adding `compaction` to that list are the SAME change (C-7) - a scanner
- * that silently stops scanning is worse than no scanner. `fast/limits.ts`
- * records the identical trap one feature earlier.
- *
- * TWO KINDS OF NUMBER, AND THEY ARE NOT INTERCHANGEABLE - the distinction
- * `TEAM_LIMITS`, `TODO_LIMITS` and `FAST_LIMITS` all state:
- *
- *  - The entries below are STRUCTURAL. They describe what a digest, a
- *    summarization call and a card can physically carry. A user has no business
- *    tuning them.
- *  - The six `compaction.*` keys in `config/schema.ts` are POLICY: when to fire,
- *    how much to keep, which model, what to do on failure. Those are clamped,
- *    persisted and user-facing.
- */
+/** Structural limits for v2 compaction. All character counts are UTF-16 units. */
 export declare const COMPACTION_LIMITS: {
-    /** Ceiling on the rendered digest, before the summarizer-window check. ~30k tokens. */
     readonly digestMaxChars: 120000;
-    /** Output + system prompt + framing, kept out of the digest's share of the window. */
     readonly summarizerReserveTokens: 8000;
-    readonly userChars: 2000;
-    readonly assistantChars: 2000;
-    readonly toolArgChars: 200;
-    readonly toolResultChars: 600;
-    /**
-     * Clip bound on the TAGGED text anchor.
-     *
-     * A CLIP, NOT A SHAPE SWITCH (D-21 / P1-9). v1 of the design kept the anchor
-     * verbatim-standalone past this length and merged it into the block below it,
-     * which made the anchor rule LENGTH-DEPENDENT and therefore non-idempotent: on
-     * the second compaction the "first user message" is a summary. A 4 000-character
-     * first message clipped with a visible marker keeps the rule "one leading
-     * anchor, always recognizable"; a 40 000-character first message is not a goal
-     * statement, and truncating it with a marker is the honest outcome.
-     */
-    readonly anchorChars: 4000;
-    /** What the summarizer prompt asks for, and what the splice clips to. */
-    readonly summaryMaxChars: 6000;
-    readonly summaryOutputTokens: 2048;
-    /**
-     * Wall-clock budget for ONE summarization call.
-     *
-     * Longer than the fast reviewer's 20 s because the input is ~30x larger and the
-     * output ~4x larger, and because the cost of a timeout here is a DEGRADED RUN
-     * rather than a missing critique.
-     *
-     * COUPLED TO THE ENGINE'S `COMPACTION_HARD_TIMEOUT_MS` (120 s). The worst legal
-     * host budget is two calls at this value back to back plus the digest render,
-     * so `2 * callTimeoutMs` must stay strictly under the engine's ceiling. Raising
-     * this without raising that makes the §3.7 ladder unreachable and turns every
-     * slow-but-correct summarization into `manager_timeout`.
-     */
+    readonly summaryMaxChars: 32000;
+    readonly summaryOutputTokens: 4096;
+    readonly memoryJsonChars: 32000;
+    readonly memoryEnvelopeChars: 1024;
+    readonly protectedMemoryChars: 48000;
+    readonly memoryItems: 200;
+    readonly protectedUserMessages: 200;
+    readonly memoryAdditions: 64;
+    readonly coverageClips: 200;
+    readonly jsonDepth: 32;
+    readonly instructionsChars: 4000;
+    readonly itemTextChars: 1200;
+    readonly sourceExcerptChars: 512;
+    readonly itemSources: 8;
+    readonly toolResultEdgeChars: 1500;
+    readonly operationTimeoutMs: 120000;
     readonly callTimeoutMs: 45000;
-    /** Turns between compactions. Never two in a row: a compaction that just ran
-     *  needs a real turn before its effect is measurable, because `lastUsage` is
-     *  still the pre-compaction number until the next `turn_end`. */
     readonly minTurnsBetween: 2;
-    /** Compactions STARTED per run, both triggers, hard. */
     readonly maxPerRun: 5;
-    /** A splice must project occupancy below `threshold - this`, or it bought two turns. */
     readonly minReclaimRatio: 0.15;
-    /** Consecutive no-progress PRESSURE compactions before the proactive trigger self-disables. */
     readonly stuckLimit: 2;
-    /**
-     * Clip bound on an oversized `tool_result` body inside the RETAINED tail.
-     *
-     * 2 000 rather than `toolResultChars`' 600, and the two are not the same
-     * question. That one bounds a message in the DIGEST, which the summarizer
-     * reads once and which exists to be lossy. This one bounds a message the model
-     * keeps WORKING FROM: it is the last two-to-four turns, and the run is about to
-     * continue on them. Relief only ever runs when the alternative is a request the
-     * provider cannot accept.
-     */
     readonly tailToolResultChars: 2000;
-    /**
-     * Room reserved for the `<compacted_context>` block in the tail-budget
-     * projection.
-     *
-     * THE BLOCK IS WRITTEN AFTER THE PROJECTION, which is why this exists at all:
-     * relief measures a spliced history whose summary body is already in it, but
-     * the `plan === null` path measures one where nothing has been written yet, and
-     * a budget with no allowance would let the block push the result back over.
-     */
     readonly blockAllowanceTokens: 2000;
-    /**
-     * Files kept for ONE `runId`, newest first.
-     *
-     * PER RUN, NOT PER DIRECTORY (RV-6). `<home>/compaction/` is shared by every
-     * `aragon` on the machine — `file-sink.ts:94-95` already treats concurrent
-     * processes as normal — so a global count-based prune would delete a live
-     * session's archives out from under it.
-     */
     readonly archiveMaxFiles: 20;
-    /**
-     * The cross-run sweep: 7 days.
-     *
-     * AGE RATHER THAN COUNT, for the reason above. Age can only ever delete files
-     * whose run finished a week ago; a count can delete the newest file another
-     * process wrote a second ago.
-     */
     readonly archiveMaxAgeMs: 604800000;
-    /**
-     * Per-file ceiling before dropped message bodies are clipped from the OLDEST
-     * end. The metadata and the summary are never clipped: a truncated archive
-     * that still says what happened beats none.
-     */
     readonly archiveMaxBytes: 8000000;
-    /** A child's `keepRecentTurns`, delivered through its config view. */
     readonly childKeepRecentTurns: 2;
-    /**
-     * A child's guard-2 ceiling, delivered through `Compactor`'s instance bound.
-     *
-     * HERE RATHER THAN AS A `compaction.*` KEY, and the placement is the whole
-     * argument: `maxPerRun` is STRUCTURAL (see this file's header), there is no
-     * config path to it by design, and a child needs a tighter one. Both numbers
-     * therefore stay in the one file that owns structural bounds.
-     */
     readonly childMaxPerRun: 2;
-    /** Rows the collapsed transcript card renders; Ctrl+O expands. */
     readonly cardTextRows: 6;
-    /**
-     * Below this many columns the status chip drops.
-     *
-     * 100, matching all four existing peers - `retry-view.ts`, `fast/limits.ts`,
-     * `team/limits.ts`, `todo/limits.ts` (P2-2). A status-bar degradation ladder
-     * that is nearly-but-not-quite uniform is a reading hazard bought for nothing.
-     * The guaranteed reporting surface is `/compact status`, which is what makes
-     * dropping the chip acceptable at all.
-     */
     readonly statusCompactCols: 100;
 };
-/**
- * Bumped whenever the wording of the `<compacted_context>` block or the
- * summarizer system prompt changes, so a behaviour report can be tied to a block
- * revision with one grep - exactly what `FAST_BLOCK_VERSION` and
- * `TEAM_BLOCK_VERSION` are for.
- */
-export declare const COMPACTION_BLOCK_VERSION = "v1-2026-08";
-/** Opening tag of the verbatim goal anchor (§3.6.5). */
+export declare const COMPACTION_BLOCK_VERSION = "v2-2026-10";
 export declare const ANCHOR_TAG_OPEN = "<original_task>";
 export declare const ANCHOR_TAG_CLOSE = "</original_task>";
-/** Opening tag of the spliced summary block. Recognized on the NEXT compaction. */
 export declare const BLOCK_TAG_OPEN = "<compacted_context";
 export declare const BLOCK_TAG_CLOSE = "</compacted_context>";
-/** Marker appended to an anchor clipped at `anchorChars`. ASCII (see the header). */
-export declare const ANCHOR_TRUNCATION_MARK = " [truncated]";
-/**
- * What tail relief writes where it removed text (hardening §3.3.2 rule 4).
- *
- * IN THE HISTORY THE MODEL READS, at the exact place the data went missing. A
- * model that sees this knows the output is partial and can re-run the tool; a
- * model handed a silently truncated file cannot tell the difference between "the
- * file ends here" and "the file was cut here".
- *
- * THE HOST OWNS IT, not core: `engine/compaction.ts` has no glyph vocabulary and
- * must not learn one, so `relieveTail` takes this as a callback. ASCII, per this
- * file's header.
- */
+/** Retained legacy helper for explicit callers; v2 compression never clips the tail. */
 export declare function tailClipMarker(removed: number): string;