@pugi/cli 0.1.0-alpha.3 → 0.1.0-alpha.6

package/dist/core/context/compaction.js

@@ -0,0 +1,602 @@
+/**
+ * Six-tier context compaction engine for the Pugi CLI agent loop.
+ *
+ * Spec: `docs/research/pugi-cli-corpus/patterns/context-compaction.md`,
+ * sprint slot: ADR-0056 §α5.5.
+ *
+ * Tiers and triggers (selectTier rules):
+ *
+ *   pressure      | tier
+ *   --------------+----------------------------------------------------
+ *   <  0.5        | microcompact (only if redundant tool outputs)
+ *   0.5  .. 0.7   | cached_microcompact
+ *   0.7  .. 0.85  | reactive_summary
+ *   0.85 .. 0.95  | full_compaction
+ *   >  0.95       | reset (with checkpoint)
+ *
+ * Tier behaviours (per pattern card §3):
+ *
+ *   1. microcompact         — sync; strip redundant token deltas,
+ *                             collapse repeated status lines, dedupe
+ *                             identical tool argument echoes; keep
+ *                             tool RESULTS verbatim; target 10-20%
+ *   2. cached_microcompact  — sync; replace inline tool output with
+ *                             { artifactRef, size } when an artifact
+ *                             with matching sha256 already exists;
+ *                             target 30-50% on repetitive sessions
+ *   3. reactive_summary     — async-shaped; summarize the last N=10
+ *                             turns into a structured turn-summary
+ *                             artifact; replace those turns with a
+ *                             single turn_summary event
+ *   4. session_memory       — async-shaped; distill long-running build
+ *                             state into .pugi/session.db (or jsonl
+ *                             fallback if SQLite not yet present)
+ *   5. full_compaction      — sync, slow; rebuild from event log +
+ *                             artifacts + session_memory + PUGI.md;
+ *                             keep open decisions, FSM state, active
+ *                             tool calls, last 3 turns verbatim
+ *   6. reset                — manual or >0.95; save full state to
+ *                             .pugi/checkpoints/<name>/ and start
+ *                             fresh with only PUGI.md + session_memory
+ *
+ * The compaction NEVER touches static blocks. Invariants enforce that
+ * (static-hash-unchanged) plus secrets-never-summarize and
+ * open-decisions-preserved. Caller is expected to run `checkInvariants`
+ * before committing the result.
+ *
+ * All tier functions are pure with respect to the in-memory transcript;
+ * disk writes (artifacts, checkpoints, session_memory) go through the
+ * caller-supplied `ArtifactWriter` so tests can stub them.
+ */
+import { createHash } from 'node:crypto';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+const REACTIVE_SUMMARY_TURNS_DEFAULT = 10;
+const FULL_COMPACTION_KEEP_TURNS = 3;
+const PATTERN_BUDGET_NO_OP_THRESHOLD = 0.5;
+const PATTERN_BUDGET_CACHED_THRESHOLD = 0.7;
+const PATTERN_BUDGET_REACTIVE_THRESHOLD = 0.85;
+const PATTERN_BUDGET_FULL_THRESHOLD = 0.95;
+/**
+ * Decide which tier should run for the given pressure. Pure function.
+ * The engine loop calls this every tool turn and dispatches to
+ * `runCompaction` with the returned tier.
+ */
+export function selectTier(input) {
+    const pressure = input.contextBudgetMax > 0
+        ? input.contextBudgetUsed / input.contextBudgetMax
+        : 0;
+    if (pressure > PATTERN_BUDGET_FULL_THRESHOLD)
+        return 'reset';
+    if (pressure > PATTERN_BUDGET_REACTIVE_THRESHOLD)
+        return 'full_compaction';
+    if (pressure > PATTERN_BUDGET_CACHED_THRESHOLD)
+        return 'reactive_summary';
+    if (pressure > PATTERN_BUDGET_NO_OP_THRESHOLD)
+        return 'cached_microcompact';
+    // Sub-50% pressure: only microcompact if there's actually duplication
+    // to reclaim. The caller may treat the resulting `skipped: true`
+    // result as a no-op.
+    return 'microcompact';
+}
+/**
+ * Run the requested compaction tier. The engine should `checkInvariants`
+ * on the returned `CompactionResult` before committing the new
+ * transcript; on violation, the engine discards the result and proceeds
+ * with the pre-compaction state.
+ */
+export async function runCompaction(input, tier) {
+    switch (tier) {
+        case 'microcompact':
+            return tierMicrocompact(input);
+        case 'cached_microcompact':
+            return tierCachedMicrocompact(input);
+        case 'reactive_summary':
+            return tierReactiveSummary(input);
+        case 'session_memory':
+            return tierSessionMemory(input);
+        case 'full_compaction':
+            return tierFullCompaction(input);
+        case 'reset':
+            return tierReset(input);
+        default: {
+            const exhaustive = tier;
+            throw new Error(`unknown compaction tier: ${String(exhaustive)}`);
+        }
+    }
+}
+// ---------------------------------------------------------------------
+// Tier 1: microcompact
+// ---------------------------------------------------------------------
+function tierMicrocompact(input) {
+    const beforeBytes = transcriptBytes(input.transcript);
+    const newTranscript = [];
+    let lastStatusLine = '';
+    const seenToolEchoes = new Set();
+    for (const turn of input.transcript) {
+        // Tool RESULTS are kept verbatim (pattern card §3 tier 1 explicit).
+        if (turn.kind === 'tool_result') {
+            newTranscript.push(turn);
+            continue;
+        }
+        // Tool CALL echoes: dedupe by serialized content. Same args sent
+        // twice is bookkeeping noise (e.g. a retry); keep first.
+        if (turn.kind === 'tool_call') {
+            const key = `${turn.role}::${turn.content}`;
+            if (seenToolEchoes.has(key))
+                continue;
+            seenToolEchoes.add(key);
+            newTranscript.push(turn);
+            continue;
+        }
+        // Status lines: collapse exact repeats (typical of streamed progress
+        // dots / "thinking..." stubs). We only collapse the immediate
+        // previous status; non-adjacent repeats survive.
+        const collapsed = collapseRepeatedStatusLines(turn.content);
+        if (turn.role === 'assistant' && collapsed === lastStatusLine && isStatusLike(collapsed)) {
+            continue;
+        }
+        lastStatusLine = collapsed;
+        newTranscript.push({ ...turn, content: collapsed });
+    }
+    const afterBytes = transcriptBytes(newTranscript);
+    const reclaimed = Math.max(0, beforeBytes - afterBytes);
+    return {
+        tier: 'microcompact',
+        bytesReclaimed: reclaimed,
+        artifactsCreated: [],
+        newContextSize: afterBytes,
+        decisionsPreserved: extractFourMarkers(input.transcript),
+        newTranscript,
+        summaryText: '',
+        skipped: reclaimed === 0,
+        skipReason: reclaimed === 0 ? 'no redundant lines detected' : '',
+    };
+}
+// ---------------------------------------------------------------------
+// Tier 2: cached_microcompact
+// ---------------------------------------------------------------------
+function tierCachedMicrocompact(input) {
+    const beforeBytes = transcriptBytes(input.transcript);
+    // Build a map from (tool, arguments) -> existing artifact ref. A repeat
+    // call with identical arguments is replaced with the inline ref.
+    const existingByKey = new Map();
+    const outputBytesByKey = new Map();
+    for (const out of input.toolOutputs) {
+        const key = `${out.tool}::${out.arguments}`;
+        if (out.existingArtifactRef) {
+            existingByKey.set(key, out.existingArtifactRef);
+        }
+        outputBytesByKey.set(key, out.bytes);
+    }
+    // Also fold large repeated outputs into artifact refs on the fly. If
+    // the same tool+args combo appears twice in the recent transcript and
+    // the output is >2 KB, hash and inline-replace.
+    const seenLargeOutputs = new Map();
+    const newTranscript = [];
+    const artifactsCreated = [];
+    for (const turn of input.transcript) {
+        if (turn.kind !== 'tool_result') {
+            newTranscript.push(turn);
+            continue;
+        }
+        // Try parse the tool result as { tool, arguments, output } for keying.
+        const parsed = tryParseToolResult(turn.content);
+        if (!parsed) {
+            newTranscript.push(turn);
+            continue;
+        }
+        const key = `${parsed.tool}::${parsed.arguments}`;
+        const sizeBytes = Buffer.byteLength(parsed.output, 'utf8');
+        // Already have an artifact ref for this exact call? Inline it.
+        const existing = existingByKey.get(key);
+        if (existing && sizeBytes > 256) {
+            newTranscript.push({
+                ...turn,
+                content: JSON.stringify({
+                    tool: parsed.tool,
+                    arguments: parsed.arguments,
+                    artifactRef: existing,
+                    size: sizeBytes,
+                }),
+            });
+            continue;
+        }
+        // Otherwise, large + repeated: hash, write, replace. Only act on
+        // the SECOND-and-later occurrence so the first response stays inline
+        // for the operator.
+        if (sizeBytes > 2 * 1024) {
+            const prev = seenLargeOutputs.get(key);
+            if (prev) {
+                // Replace this occurrence with the ref. We do NOT write a new
+                // artifact here unless the workspace root is supplied; tests
+                // that omit it will see size shrinkage without a disk artifact.
+                const ref = input.workspaceRoot
+                    ? maybeWriteArtifact(input, parsed.output, 'cached_microcompact', artifactsCreated)
+                    : { sha: prev.sha };
+                newTranscript.push({
+                    ...turn,
+                    content: JSON.stringify({
+                        tool: parsed.tool,
+                        arguments: parsed.arguments,
+                        artifactRef: ref.sha,
+                        size: sizeBytes,
+                    }),
+                });
+                continue;
+            }
+            // First sighting: keep inline, remember sha for next time.
+            const sha = `sha256:${sha256(parsed.output)}`;
+            seenLargeOutputs.set(key, { sha, bytes: sizeBytes });
+        }
+        newTranscript.push(turn);
+    }
+    const afterBytes = transcriptBytes(newTranscript);
+    const reclaimed = Math.max(0, beforeBytes - afterBytes);
+    return {
+        tier: 'cached_microcompact',
+        bytesReclaimed: reclaimed,
+        artifactsCreated,
+        newContextSize: afterBytes,
+        decisionsPreserved: extractFourMarkers(input.transcript),
+        newTranscript,
+        summaryText: '',
+        skipped: reclaimed === 0 && artifactsCreated.length === 0,
+        skipReason: reclaimed === 0 && artifactsCreated.length === 0
+            ? 'no repeated tool outputs eligible for ref-replacement'
+            : '',
+    };
+}
+// ---------------------------------------------------------------------
+// Tier 3: reactive_summary
+// ---------------------------------------------------------------------
+function tierReactiveSummary(input) {
+    const N = REACTIVE_SUMMARY_TURNS_DEFAULT;
+    if (input.transcript.length <= N) {
+        return skipResult('reactive_summary', input, `transcript has ${input.transcript.length} turns, threshold is ${N}`);
+    }
+    const beforeBytes = transcriptBytes(input.transcript);
+    const head = input.transcript.slice(0, input.transcript.length - N);
+    const tail = input.transcript.slice(input.transcript.length - N);
+    const summary = summarizeTurns(tail);
+    const summaryText = JSON.stringify(summary, null, 2);
+    // The summary turn carries the structured ref as its content. Engine
+    // consumers MAY hydrate the artifact ref into a full read when needed.
+    const summaryTurn = {
+        role: 'assistant',
+        content: summaryText,
+        kind: 'turn_summary',
+    };
+    const newTranscript = [...head, summaryTurn];
+    const afterBytes = transcriptBytes(newTranscript);
+    const reclaimed = Math.max(0, beforeBytes - afterBytes);
+    const artifactsCreated = [];
+    if (input.workspaceRoot) {
+        const ref = writeArtifact(input.workspaceRoot, summaryText, 'reactive_summary');
+        artifactsCreated.push(ref);
+    }
+    return {
+        tier: 'reactive_summary',
+        bytesReclaimed: reclaimed,
+        artifactsCreated,
+        newContextSize: afterBytes,
+        // The head turns are kept verbatim in newTranscript, so any
+        // DECISION/OPEN/BLOCKED/REJECTED lines in the head are physically
+        // preserved. But `summary.decisions` only scans the tail (and only
+        // captures DECISION/OPEN/REJECTED, never BLOCKED) — so the
+        // invariant cross-check, which walks before.transcript looking for
+        // every marker line, would fire on every head decision and every
+        // BLOCKED line. Use extractFourMarkers across the whole input to
+        // report the union; the lines are actually preserved (head verbatim,
+        // tail in summary), so reporting them is honest.
+        decisionsPreserved: extractFourMarkers(input.transcript),
+        newTranscript,
+        summaryText,
+        skipped: false,
+        skipReason: '',
+    };
+}
+// ---------------------------------------------------------------------
+// Tier 4: session_memory
+// ---------------------------------------------------------------------
+function tierSessionMemory(input) {
+    const beforeBytes = transcriptBytes(input.transcript);
+    // Distill into a session-memory record. The shape matches the spec:
+    // open task graph state, completed nodes, blocked nodes, key
+    // decisions, rejected approaches.
+    const memory = {
+        sessionId: input.sessionId,
+        timestamp: new Date().toISOString(),
+        openTasks: extractMarked(input.transcript, /^\s*OPEN:\s*(.+)$/),
+        completed: extractMarked(input.transcript, /^\s*DONE:\s*(.+)$/),
+        blocked: extractMarked(input.transcript, /^\s*BLOCKED:\s*(.+)$/),
+        decisions: extractMarked(input.transcript, /^\s*DECISION:\s*(.+)$/),
+        rejected: extractMarked(input.transcript, /^\s*REJECTED:\s*(.+)$/),
+    };
+    const summaryText = JSON.stringify(memory, null, 2);
+    const artifactsCreated = [];
+    if (input.workspaceRoot) {
+        // SQLite migration arrives in α6.4 (per spec). Until then we append
+        // a JSONL line to .pugi/session-memory.jsonl, which the next session
+        // bootstraps into context.
+        const path = resolve(input.workspaceRoot, '.pugi', 'session-memory.jsonl');
+        try {
+            mkdirSync(resolve(input.workspaceRoot, '.pugi'), { recursive: true });
+            writeFileSync(path, `${JSON.stringify(memory)}\n`, { flag: 'a', mode: 0o600 });
+        }
+        catch {
+            // best effort — fall through with no artifact record
+        }
+        const ref = writeArtifact(input.workspaceRoot, summaryText, 'session_memory');
+        artifactsCreated.push(ref);
+    }
+    // Session memory does not modify the active transcript on its own —
+    // it's a side-channel that survives across reactive_summary cycles.
+    return {
+        tier: 'session_memory',
+        bytesReclaimed: 0,
+        artifactsCreated,
+        newContextSize: beforeBytes,
+        // The structured `memory.decisions` field above strips the marker
+        // prefix for the session-memory.jsonl record. The invariant check
+        // compares full lines (with `DECISION:` prefix) against
+        // `before.transcript`, so we must surface the full-line shape here.
+        // Using `memory.decisions` directly would fail the invariant on
+        // every run.
+        decisionsPreserved: extractFourMarkers(input.transcript),
+        newTranscript: input.transcript,
+        summaryText,
+        skipped: false,
+        skipReason: '',
+    };
+}
+// ---------------------------------------------------------------------
+// Tier 5: full_compaction
+// ---------------------------------------------------------------------
+function tierFullCompaction(input) {
+    const beforeBytes = transcriptBytes(input.transcript);
+    if (input.transcript.length <= FULL_COMPACTION_KEEP_TURNS) {
+        return skipResult('full_compaction', input, `transcript only ${input.transcript.length} turns, keep window is ${FULL_COMPACTION_KEEP_TURNS}`);
+    }
+    const keep = input.transcript.slice(-FULL_COMPACTION_KEEP_TURNS);
+    const distilled = summarizeTurns(input.transcript.slice(0, -FULL_COMPACTION_KEEP_TURNS));
+    const summaryText = JSON.stringify(distilled, null, 2);
+    const summaryTurn = {
+        role: 'assistant',
+        content: summaryText,
+        kind: 'turn_summary',
+    };
+    const newTranscript = [summaryTurn, ...keep];
+    const afterBytes = transcriptBytes(newTranscript);
+    const reclaimed = Math.max(0, beforeBytes - afterBytes);
+    const artifactsCreated = [];
+    if (input.workspaceRoot) {
+        const ref = writeArtifact(input.workspaceRoot, summaryText, 'full_compaction');
+        artifactsCreated.push(ref);
+    }
+    return {
+        tier: 'full_compaction',
+        bytesReclaimed: reclaimed,
+        artifactsCreated,
+        newContextSize: afterBytes,
+        // `distilled.decisions` only carries DECISION/OPEN/REJECTED. The
+        // invariant compares against all four markers in the pre-compaction
+        // transcript, so we union with extractFourMarkers to include any
+        // BLOCKED lines that lived in the head and would otherwise trip
+        // open-decisions-preserved. The keep window also has decisions; both
+        // are scanned because the invariant walks the FULL before.transcript.
+        decisionsPreserved: extractFourMarkers(input.transcript),
+        newTranscript,
+        summaryText,
+        skipped: false,
+        skipReason: '',
+    };
+}
+// ---------------------------------------------------------------------
+// Tier 6: reset
+// ---------------------------------------------------------------------
+function tierReset(input) {
+    const beforeBytes = transcriptBytes(input.transcript);
+    const distilled = summarizeTurns(input.transcript);
+    const summaryText = JSON.stringify({ ...distilled, reason: 'context budget >95%, full reset triggered' }, null, 2);
+    const artifactsCreated = [];
+    if (input.workspaceRoot) {
+        // Checkpoint dump for replay; named after the session + timestamp.
+        const checkpointName = `${input.sessionId}-${Date.now()}`;
+        const checkpointDir = resolve(input.workspaceRoot, '.pugi', 'checkpoints', checkpointName);
+        try {
+            mkdirSync(checkpointDir, { recursive: true });
+            writeFileSync(resolve(checkpointDir, 'transcript.json'), JSON.stringify(input.transcript, null, 2), { mode: 0o600 });
+            writeFileSync(resolve(checkpointDir, 'summary.json'), summaryText, { mode: 0o600 });
+        }
+        catch {
+            // best effort — the caller still gets the in-memory result
+        }
+        const ref = writeArtifact(input.workspaceRoot, summaryText, 'reset');
+        artifactsCreated.push(ref);
+    }
+    // Post-reset transcript is a single seed message describing the reset.
+    const seed = {
+        role: 'assistant',
+        content: summaryText,
+        kind: 'turn_summary',
+    };
+    return {
+        tier: 'reset',
+        bytesReclaimed: Math.max(0, beforeBytes - Buffer.byteLength(seed.content, 'utf8')),
+        artifactsCreated,
+        newContextSize: Buffer.byteLength(seed.content, 'utf8'),
+        // Same rationale as full_compaction: use the four-marker helper so
+        // BLOCKED lines are preserved alongside DECISION/OPEN/REJECTED.
+        decisionsPreserved: extractFourMarkers(input.transcript),
+        newTranscript: [seed],
+        summaryText,
+        skipped: false,
+        skipReason: '',
+    };
+}
+// ---------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------
+function transcriptBytes(transcript) {
+    return transcript.reduce((sum, t) => sum + Buffer.byteLength(t.content, 'utf8'), 0);
+}
+function isStatusLike(line) {
+    // Treat short, lowercase, no-period lines as status. Real prose
+    // usually has punctuation or capital letters.
+    if (line.length === 0 || line.length > 80)
+        return false;
+    if (/[.!?]\s*$/.test(line))
+        return false;
+    return true;
+}
+function collapseRepeatedStatusLines(content) {
+    // Within a single turn, collapse any two adjacent identical lines
+    // into one. Streaming "thinking..." style status emits these.
+    const lines = content.split('\n');
+    if (lines.length < 2)
+        return content;
+    const out = [];
+    let prev = '';
+    for (const line of lines) {
+        if (line === prev && isStatusLike(line))
+            continue;
+        out.push(line);
+        prev = line;
+    }
+    return out.join('\n');
+}
+function tryParseToolResult(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (parsed &&
+            typeof parsed === 'object' &&
+            typeof parsed.tool === 'string' &&
+            typeof parsed.output === 'string') {
+            const p = parsed;
+            return {
+                tool: String(p.tool),
+                arguments: String(p.arguments ?? ''),
+                output: String(p.output),
+            };
+        }
+    }
+    catch {
+        // not JSON — skip
+    }
+    return null;
+}
+function summarizeTurns(turns) {
+    const decisions = [];
+    const blockers = [];
+    const filesTouched = new Set();
+    let goal = '';
+    let nextStep = '';
+    for (const turn of turns) {
+        if (turn.role === 'user' && !goal) {
+            goal = firstSentence(turn.content);
+        }
+        for (const line of turn.content.split('\n')) {
+            const t = line.trim();
+            if (/^DECISION:/.test(t) || /^OPEN:/.test(t) || /^REJECTED:/.test(t))
+                decisions.push(t);
+            if (/^BLOCKED:/.test(t))
+                blockers.push(t);
+            // Crude file capture: paths look like a/b/c.ts or apps/x/src/y.ts.
+            const pathMatches = line.match(/\b[a-z0-9_-]+(?:\/[A-Za-z0-9._-]+){1,}\.[a-z]{1,5}\b/g);
+            if (pathMatches)
+                for (const p of pathMatches)
+                    filesTouched.add(p);
+            // Last imperative line of the assistant becomes next_step.
+            if (turn.role === 'assistant' && /^(?:next|todo|run|build|test|ship|deploy)\b/i.test(t)) {
+                nextStep = t;
+            }
+        }
+    }
+    return {
+        goal: goal || '(no explicit user goal in window)',
+        decisions,
+        blockers,
+        files_touched: [...filesTouched].sort(),
+        next_step: nextStep || '(no explicit next step recorded)',
+    };
+}
+/**
+ * Extract every DECISION/OPEN/BLOCKED/REJECTED line from the transcript,
+ * preserving the marker prefix (`DECISION: ...`). This is the shape
+ * `checkInvariants` expects in `decisionsPreserved`: it walks the
+ * pre-compaction transcript collecting the same shape and compares
+ * line-for-line. Any tier that drops the prefix (or omits a marker
+ * type) will trip `open-decisions-preserved` on every run.
+ *
+ * Used by all six tiers when they populate `decisionsPreserved`. The
+ * structured-memory variant (`extractMarked`, suffix-only) is for the
+ * separate session-memory record format and is not invariant-relevant.
+ */
+function extractFourMarkers(turns) {
+    const out = [];
+    for (const turn of turns) {
+        for (const line of turn.content.split('\n')) {
+            const t = line.trim();
+            if (/^(?:DECISION|OPEN|BLOCKED|REJECTED):/.test(t))
+                out.push(t);
+        }
+    }
+    return out;
+}
+function extractMarked(turns, rx) {
+    const out = [];
+    for (const turn of turns) {
+        for (const line of turn.content.split('\n')) {
+            const m = rx.exec(line);
+            if (m && m[1])
+                out.push(m[1].trim());
+        }
+    }
+    return out;
+}
+function firstSentence(content) {
+    const trimmed = content.trim();
+    const m = /^[^.!?\n]{1,200}/.exec(trimmed);
+    return m ? m[0].trim() : trimmed.slice(0, 200);
+}
+function sha256(input) {
+    return createHash('sha256').update(input, 'utf8').digest('hex');
+}
+function writeArtifact(workspaceRoot, content, producedBy) {
+    const sha = sha256(content);
+    const dir = resolve(workspaceRoot, '.pugi', 'artifacts');
+    mkdirSync(dir, { recursive: true });
+    const path = resolve(dir, `${sha}.json`);
+    writeFileSync(path, content, { mode: 0o600 });
+    return {
+        sha256: `sha256:${sha}`,
+        path,
+        size: Buffer.byteLength(content, 'utf8'),
+        producedBy,
+    };
+}
+function maybeWriteArtifact(input, content, producedBy, collector) {
+    if (input.workspaceRoot) {
+        const ref = writeArtifact(input.workspaceRoot, content, producedBy);
+        collector.push(ref);
+        return { sha: ref.sha256 };
+    }
+    // Test/no-disk fallback: return the in-memory sha without persisting.
+    return { sha: `sha256:${sha256(content)}` };
+}
+function skipResult(tier, input, reason) {
+    const bytes = transcriptBytes(input.transcript);
+    return {
+        tier,
+        bytesReclaimed: 0,
+        artifactsCreated: [],
+        newContextSize: bytes,
+        decisionsPreserved: extractFourMarkers(input.transcript),
+        newTranscript: input.transcript,
+        summaryText: '',
+        skipped: true,
+        skipReason: reason,
+    };
+}
+//# sourceMappingURL=compaction.js.map