From 42c7fffd2267b5f8122b55c8372d5fc2c372f644 Mon Sep 17 00:00:00 2001 From: ranxianglei Date: Sat, 13 Jun 2026 22:18:28 +0800 Subject: [PATCH 1/4] =?UTF-8?q?feat:=20smart=20compression=20prompts=20?= =?UTF-8?q?=E2=80=94=20tiered=20context=20usage=20guidance=20and=20compres?= =?UTF-8?q?sion=20priority?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Rewrite system prompt: conservative compression when context is ample, aggressive only when high. Added compression priority guidance (what to compress first vs carefully) and recovery breadcrumb generation. - Replace unconditional 'use compress proactively' with tiered guidance: ample (<40%): focus on task, minimal compression moderate (40-55%): compress completed sections high (>55%): compress aggressively but selectively --- .../REQ.md | 25 ++++++++ .../WORKLOG.md | 26 ++++++++ lib/messages/inject/inject.ts | 31 +++++++--- lib/messages/inject/utils.ts | 16 ++++- lib/prompts/system.ts | 59 +++++++++++++------ 5 files changed, 130 insertions(+), 27 deletions(-) create mode 100644 devlog/2026-06-13_smart-compression-prompts/REQ.md create mode 100644 devlog/2026-06-13_smart-compression-prompts/WORKLOG.md diff --git a/devlog/2026-06-13_smart-compression-prompts/REQ.md b/devlog/2026-06-13_smart-compression-prompts/REQ.md new file mode 100644 index 0000000..b52dce8 --- /dev/null +++ b/devlog/2026-06-13_smart-compression-prompts/REQ.md @@ -0,0 +1,25 @@ +# REQ: Smart Compression Prompts + +## Background + +ACP 默认配置的 45%/55% 阈值只控制 nudge 何时触发，但系统提示词和 context usage 注入文本在无条件鼓励压缩。具体问题： + +1. **Context usage 文本**：每轮注入 "use the compress tool proactively to manage context quality"——不管上下文是 10% 还是 55%，导致模型在低使用率时也频繁压缩 +2. **系统提示词**："Evaluate conversation signal-to-noise REGULARLY" 过度鼓励压缩，没有上下文充裕度感知 +3. **缺少压缩优先级指导**：模型不知道什么该先压缩、什么该谨慎压缩 +4. **缺少恢复线索指导**：压缩后不生成可恢复的线索 + +## Acceptance Criteria + +1. Context usage 注入文本根据使用率分层（充裕/适中/紧张），充裕时提示"少压缩或基本不压缩" +2. 系统提示词包含压缩优先级指导： + - 优先压缩：bash 大量输出、无用日志、冗余工具结果、探索死胡同 + - 谨慎压缩：临时密钥、文件路径、关键方法签名、用户偏好、错误信息 +3. 系统提示词要求压缩重要内容前确认已在外部存储（文件、issue、devlog 等） +4. 系统提示词要求压缩后生成恢复线索（如自言自语式总结） + +## Proposed Approach + +- 修改 `lib/prompts/system.ts`：重写压缩哲学 +- 修改 `lib/messages/inject/inject.ts` + `lib/messages/inject/utils.ts`：分层 context usage 文本 +- 纯提示词变更，无逻辑/类型变化 diff --git a/devlog/2026-06-13_smart-compression-prompts/WORKLOG.md b/devlog/2026-06-13_smart-compression-prompts/WORKLOG.md new file mode 100644 index 0000000..49efa6a --- /dev/null +++ b/devlog/2026-06-13_smart-compression-prompts/WORKLOG.md @@ -0,0 +1,26 @@ +# WORKLOG: Smart Compression Prompts + +## Changes + +### 1. `lib/prompts/system.ts` — Rewrote compression philosophy +- Removed "Manage context continuously" → Changed to "primary goal is completing the task" +- Added CONTEXT PRESSURE LEVELS (Ample <40%, Moderate 40-55%, High >55%) +- Added WHAT TO COMPRESS FIRST (bash output, dead-end exploration, redundant tool results) +- Added WHAT TO COMPRESS CAREFULLY (secrets/keys, file paths, function signatures, errors, user preferences) +- Added BEFORE COMPRESSING IMPORTANT CONTENT (verify persisted externally) +- Added AFTER COMPRESSING (generate recovery breadcrumbs with file paths, signatures, rationale) + +### 2. `lib/messages/inject/inject.ts` L182-213 — Tiered context usage injection +- Old: Always "use the compress tool proactively to manage context quality" regardless of usage +- New: Three tiers based on actual usage percentage: + - <40%: "Context is ample — focus on your task. Only compress obvious waste." + - 40-55%: "Context is moderate — compress completed sections and high-token waste." + - >55%: "Context is high — compress aggressively but selectively." + +### 3. `lib/messages/inject/utils.ts` L360-380 — Same tiered logic +- Applied identical three-tier guidance to the `buildContextUsageInfo()` function used in anchored nudges + +## Verification +- TypeScript: clean +- Build: success (301.02 KB) +- Tests: 386/386 pass diff --git a/lib/messages/inject/inject.ts b/lib/messages/inject/inject.ts index 19b8a27..54211fd 100644 --- a/lib/messages/inject/inject.ts +++ b/lib/messages/inject/inject.ts @@ -179,19 +179,36 @@ export const injectCompressNudges = ( } } +function buildContextUsageTag(currentTokens?: number, modelContextLimit?: number): string { + if (currentTokens === undefined || modelContextLimit === undefined || modelContextLimit === 0) { + return "" + } + + const pct = (currentTokens / modelContextLimit) * 100 + const percentage = pct.toFixed(1) + const formatK = (n: number) => (n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n)) + const base = `Context usage: ${formatK(currentTokens)} / ${formatK(modelContextLimit)} tokens (${percentage}%). ACP threshold: 55%.` + + let guidance: string + if (pct < 40) { + guidance = " Context is ample — focus on your task. Only compress obvious waste (large terminal outputs, duplicated content)." + } else if (pct < 55) { + guidance = " Context is moderate — compress completed sections and high-token waste. Preserve key details." + } else { + guidance = " Context is high — compress aggressively but selectively. Preserve only what is essential." + } + + return `\n\n${base}${guidance}` +} + function injectContextUsage( target: WithParts | null, currentTokens?: number, modelContextLimit?: number, ): void { if (!target) return - if (currentTokens === undefined || modelContextLimit === undefined || modelContextLimit === 0) { - return - } - - const percentage = ((currentTokens / modelContextLimit) * 100).toFixed(1) - const formatK = (n: number) => (n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n)) - const usageTag = `\n\nContext usage: ${formatK(currentTokens)} / ${formatK(modelContextLimit)} tokens (${percentage}%). ACP (Active Context Pruning) threshold: 55%. You ARE the ACP agent — use the compress tool proactively to manage context quality.` + const usageTag = buildContextUsageTag(currentTokens, modelContextLimit) + if (!usageTag) return for (const part of target.parts) { if (part.type === "text") { diff --git a/lib/messages/inject/utils.ts b/lib/messages/inject/utils.ts index ffecc60..8bac304 100644 --- a/lib/messages/inject/utils.ts +++ b/lib/messages/inject/utils.ts @@ -361,9 +361,21 @@ function buildContextUsageInfo(currentTokens?: number, modelContextLimit?: numbe if (currentTokens === undefined || modelContextLimit === undefined || modelContextLimit === 0) { return "" } - const percentage = ((currentTokens / modelContextLimit) * 100).toFixed(1) + const pct = (currentTokens / modelContextLimit) * 100 + const percentage = pct.toFixed(1) const formatK = (n: number) => (n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n)) - return `\n\nContext usage: ${formatK(currentTokens)} / ${formatK(modelContextLimit)} tokens (${percentage}%). ACP (Active Context Pruning) threshold: 55%. You ARE the ACP agent — use the compress tool proactively to manage context quality.` + const base = `Context usage: ${formatK(currentTokens)} / ${formatK(modelContextLimit)} tokens (${percentage}%). ACP threshold: 55%.` + + let guidance: string + if (pct < 40) { + guidance = " Context is ample — focus on your task. Only compress obvious waste (large terminal outputs, duplicated content)." + } else if (pct < 55) { + guidance = " Context is moderate — compress completed sections and high-token waste. Preserve key details." + } else { + guidance = " Context is high — compress aggressively but selectively. Preserve only what is essential." + } + + return `\n\n${base}${guidance}` } export function applyAnchoredNudges( diff --git a/lib/prompts/system.ts b/lib/prompts/system.ts index 2308b17..42d4028 100644 --- a/lib/prompts/system.ts +++ b/lib/prompts/system.ts @@ -1,33 +1,56 @@ export const SYSTEM = ` -You operate in a context-constrained environment. Manage context continuously to avoid buildup and preserve retrieval quality. Efficient context management is paramount for your agentic performance. + +You operate in a context-constrained environment. Context management helps preserve retrieval quality, but your primary goal is completing the task at hand. Do not let context management distract from the actual work. The tools you have for context management are \`compress\` and \`decompress\`. \`compress\` replaces older conversation content with technical summaries you produce. \`decompress\` restores previously compressed content when you need exact details. \`\` and \`\` tags are environment-injected metadata. Do not output them. -THE PHILOSOPHY OF COMPRESS -\`compress\` transforms conversation content into dense, high-fidelity summaries. This is not cleanup - it is crystallization. Your summary becomes the authoritative record of what transpired. +COMPRESSION PHILOSOPHY + +Compression replaces raw conversation content with dense summaries. When used correctly, it keeps your context sharp and focused. When used carelessly, it destroys information you need. + +The key principle: compress based on context pressure, not habit. When context is ample, compress rarely or not at all. When context is tight, compress aggressively but selectively. + +CONTEXT PRESSURE LEVELS + +- Ample (below 40% usage): Do NOT compress unless there is obvious waste (huge terminal dumps, duplicated content). Focus entirely on your task. +- Moderate (40-55% usage): Compress completed sections proactively. Prioritize high-token waste over minor cleanup. +- High (above 55% usage): Compress aggressively. Every compression should free meaningful tokens. Preserve only what is essential for the current task. + +WHAT TO COMPRESS FIRST (high value, low risk) -Think of compression as phase transitions: raw exploration becomes refined understanding. The original context served its purpose; your summary now carries that understanding forward. +- Verbose terminal/bash command output (build logs, test output, directory listings) +- Exploration that led nowhere (failed approaches, dead-end searches) +- Redundant tool results (reading the same file multiple times, repeated status checks) +- Intermediate steps of completed multi-step tasks +- Large file contents that have already been used and are no longer needed -COMPRESS WHEN +WHAT TO COMPRESS CAREFULLY (high risk - verify before compressing) -A section is genuinely closed and the raw conversation has served its purpose: +- Temporary secrets/keys/tokens needed later: Do NOT compress unless recorded elsewhere +- File paths and directory structures: Keep in summary - losing these wastes tokens rediscovering them +- Key function/method signatures and APIs: Summarize with exact names and signatures +- Critical error messages and stack traces: Keep the error type and key detail in summary +- User preferences and requirements: These must survive compression intact +- Architectural decisions and rationale: Summarize the decision, not just the conclusion -- Research concluded and findings are clear -- Implementation finished and verified -- Exploration exhausted and patterns understood -- Dead-end noise can be discarded without waiting for a whole chapter to close +BEFORE COMPRESSING IMPORTANT CONTENT -DO NOT COMPRESS IF +Verify the information is persisted in one of: +- A file you have written or edited +- An issue, PR, or devlog entry +- The compression summary itself (include the critical bits explicitly) -- Raw context is still relevant and needed for edits or precise references -- The target content is still actively in progress -- You may need exact code, error messages, or file contents in the immediate next steps +If it is not persisted anywhere, either persist it first or include it explicitly in your compression summary. -Before compressing, ask: _"Is this section closed enough to become summary-only right now?"_ +AFTER COMPRESSING -Evaluate conversation signal-to-noise REGULARLY. Use \`compress\` deliberately with quality-first summaries. Prioritize stale content intelligently to maintain a high-signal context window that supports your agency. +Generate recovery breadcrumbs in your summary so future-you can reconstruct the context: +- Reference specific files by path +- Include key variable names, function signatures, or configuration values +- Note what was decided and why, not just what was done +- Example: "Implemented auth check in src/middleware.ts using validateToken() from auth.ts - user table is users not user" -It is of your responsibility to keep a sharp, high-quality context window for optimal performance. -` +Use \`compress\` deliberately with quality-first summaries. Prioritize stale content intelligently to maintain a high-signal context window. +` \ No newline at end of file From a1b932b9db208815055fe909101c1bc6a2cda5d5 Mon Sep 17 00:00:00 2001 From: ranxianglei Date: Sat, 13 Jun 2026 22:23:43 +0800 Subject: [PATCH 2/4] fix: use config thresholds for tiered context usage guidance - Remove hardcoded 40%/55% from system prompt, use qualitative descriptions - Extract shared buildContextUsageGuidance() that reads minContextLimit/maxContextLimit from config - Both inject.ts and utils.ts now use config-driven thresholds for tiering - ACP threshold shown in usage text now reflects actual maxContextLimit config value --- lib/messages/inject/inject.ts | 28 ++++--------------------- lib/messages/inject/utils.ts | 39 ++++++++++++++++++++++++++++++----- lib/prompts/system.ts | 8 +++---- 3 files changed, 42 insertions(+), 33 deletions(-) diff --git a/lib/messages/inject/inject.ts b/lib/messages/inject/inject.ts index 54211fd..939ba31 100644 --- a/lib/messages/inject/inject.ts +++ b/lib/messages/inject/inject.ts @@ -23,6 +23,7 @@ import { import { addAnchor, applyAnchoredNudges, + buildContextUsageGuidance, countMessagesAfterIndex, findLastNonIgnoredMessage, getIterationNudgeThreshold, @@ -163,7 +164,7 @@ export const injectCompressNudges = ( applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage) - injectContextUsage(suffixMessage, currentTokens, modelContextLimit) + injectContextUsage(suffixMessage, config, currentTokens, modelContextLimit) if (config.compress.mode !== "message") { const blockGuidance = buildCompressedBlockGuidance(state, config.gc, { currentTokens, modelContextLimit }) @@ -179,35 +180,14 @@ export const injectCompressNudges = ( } } -function buildContextUsageTag(currentTokens?: number, modelContextLimit?: number): string { - if (currentTokens === undefined || modelContextLimit === undefined || modelContextLimit === 0) { - return "" - } - - const pct = (currentTokens / modelContextLimit) * 100 - const percentage = pct.toFixed(1) - const formatK = (n: number) => (n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n)) - const base = `Context usage: ${formatK(currentTokens)} / ${formatK(modelContextLimit)} tokens (${percentage}%). ACP threshold: 55%.` - - let guidance: string - if (pct < 40) { - guidance = " Context is ample — focus on your task. Only compress obvious waste (large terminal outputs, duplicated content)." - } else if (pct < 55) { - guidance = " Context is moderate — compress completed sections and high-token waste. Preserve key details." - } else { - guidance = " Context is high — compress aggressively but selectively. Preserve only what is essential." - } - - return `\n\n${base}${guidance}` -} - function injectContextUsage( target: WithParts | null, + config: PluginConfig, currentTokens?: number, modelContextLimit?: number, ): void { if (!target) return - const usageTag = buildContextUsageTag(currentTokens, modelContextLimit) + const usageTag = buildContextUsageGuidance(config, currentTokens, modelContextLimit) if (!usageTag) return for (const part of target.parts) { diff --git a/lib/messages/inject/utils.ts b/lib/messages/inject/utils.ts index 8bac304..7c30bd1 100644 --- a/lib/messages/inject/utils.ts +++ b/lib/messages/inject/utils.ts @@ -357,19 +357,48 @@ function applyMessageModeAnchoredNudge( } } -function buildContextUsageInfo(currentTokens?: number, modelContextLimit?: number): string { +/** + * Resolve a config threshold (number | "NN%") to a percentage value. + */ +function resolveThresholdPercent( + threshold: number | `${number}%` | undefined, + modelContextLimit: number | undefined, +): number | undefined { + if (threshold === undefined) return undefined + if (typeof threshold === "number") { + if (!modelContextLimit) return undefined + return (threshold / modelContextLimit) * 100 + } + const parsed = parseFloat(threshold) + return isNaN(parsed) ? undefined : parsed +} + +/** + * Build tiered context usage guidance based on actual config thresholds. + * Shared by inject.ts (suffix message) and utils.ts (anchored nudges). + */ +export function buildContextUsageGuidance( + config: PluginConfig, + currentTokens?: number, + modelContextLimit?: number, +): string { if (currentTokens === undefined || modelContextLimit === undefined || modelContextLimit === 0) { return "" } + const pct = (currentTokens / modelContextLimit) * 100 const percentage = pct.toFixed(1) const formatK = (n: number) => (n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n)) - const base = `Context usage: ${formatK(currentTokens)} / ${formatK(modelContextLimit)} tokens (${percentage}%). ACP threshold: 55%.` + + const minPct = resolveThresholdPercent(config.compress.minContextLimit, modelContextLimit) ?? 45 + const maxPct = resolveThresholdPercent(config.compress.maxContextLimit, modelContextLimit) ?? 55 + + const base = `Context usage: ${formatK(currentTokens)} / ${formatK(modelContextLimit)} tokens (${percentage}%). ACP threshold: ${maxPct.toFixed(0)}%.` let guidance: string - if (pct < 40) { + if (pct < minPct) { guidance = " Context is ample — focus on your task. Only compress obvious waste (large terminal outputs, duplicated content)." - } else if (pct < 55) { + } else if (pct < maxPct) { guidance = " Context is moderate — compress completed sections and high-token waste. Preserve key details." } else { guidance = " Context is high — compress aggressively but selectively. Preserve only what is essential." @@ -388,7 +417,7 @@ export function applyAnchoredNudges( modelContextLimit?: number, suffixMessage?: WithParts | null, ): void { - const contextUsageInfo = buildContextUsageInfo(currentTokens, modelContextLimit) + const contextUsageInfo = buildContextUsageGuidance(config, currentTokens, modelContextLimit) const contextLimitNudgeWithUsage = prompts.contextLimitNudge + contextUsageInfo const turnNudgeAnchors = collectTurnNudgeAnchors(state, config, messages) diff --git a/lib/prompts/system.ts b/lib/prompts/system.ts index 42d4028..2b6c8ef 100644 --- a/lib/prompts/system.ts +++ b/lib/prompts/system.ts @@ -10,13 +10,13 @@ COMPRESSION PHILOSOPHY Compression replaces raw conversation content with dense summaries. When used correctly, it keeps your context sharp and focused. When used carelessly, it destroys information you need. -The key principle: compress based on context pressure, not habit. When context is ample, compress rarely or not at all. When context is tight, compress aggressively but selectively. +The key principle: compress based on context pressure, not habit. When context is ample, compress rarely or not at all. When context is tight, compress aggressively but selectively. The runtime context usage indicator tells you the current pressure level. CONTEXT PRESSURE LEVELS -- Ample (below 40% usage): Do NOT compress unless there is obvious waste (huge terminal dumps, duplicated content). Focus entirely on your task. -- Moderate (40-55% usage): Compress completed sections proactively. Prioritize high-token waste over minor cleanup. -- High (above 55% usage): Compress aggressively. Every compression should free meaningful tokens. Preserve only what is essential for the current task. +- Ample: Context is well below the threshold. Do NOT compress unless there is obvious waste (huge terminal dumps, duplicated content). Focus entirely on your task. +- Moderate: Context is approaching the threshold. Compress completed sections proactively. Prioritize high-token waste over minor cleanup. +- High: Context has exceeded the threshold. Compress aggressively. Every compression should free meaningful tokens. Preserve only what is essential for the current task. WHAT TO COMPRESS FIRST (high value, low risk) From 8ec54962292345ae6c2e72e9d4398887c03828a0 Mon Sep 17 00:00:00 2001 From: ranxianglei Date: Sat, 13 Jun 2026 22:26:44 +0800 Subject: [PATCH 3/4] feat: mention decompress in AFTER COMPRESSING guidance --- lib/prompts/system.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/lib/prompts/system.ts b/lib/prompts/system.ts index 2b6c8ef..af1a31a 100644 --- a/lib/prompts/system.ts +++ b/lib/prompts/system.ts @@ -52,5 +52,7 @@ Generate recovery breadcrumbs in your summary so future-you can reconstruct the - Note what was decided and why, not just what was done - Example: "Implemented auth check in src/middleware.ts using validateToken() from auth.ts - user table is users not user" -Use \`compress\` deliberately with quality-first summaries. Prioritize stale content intelligently to maintain a high-signal context window. +If you later realize you need the original details from a compressed block, use \`decompress\` to restore them. You can decompress, read the content, then re-compress if needed. + +Use \`compress\` and \`decompress\` deliberately with quality-first summaries. Prioritize stale content intelligently to maintain a high-signal context window. ` \ No newline at end of file From 7a18ec246ef0160a2d89ac8c483b63432041dd9b Mon Sep 17 00:00:00 2001 From: ranxianglei Date: Sat, 13 Jun 2026 22:39:13 +0800 Subject: [PATCH 4/4] =?UTF-8?q?fix:=20address=20review=20findings=20?= =?UTF-8?q?=E2=80=94=20trailing=20newline=20and=20WORKLOG=20accuracy?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../WORKLOG.md | 18 ++++++++++-------- lib/prompts/system.ts | 2 +- 2 files changed, 11 insertions(+), 9 deletions(-) diff --git a/devlog/2026-06-13_smart-compression-prompts/WORKLOG.md b/devlog/2026-06-13_smart-compression-prompts/WORKLOG.md index 49efa6a..0ac869c 100644 --- a/devlog/2026-06-13_smart-compression-prompts/WORKLOG.md +++ b/devlog/2026-06-13_smart-compression-prompts/WORKLOG.md @@ -4,21 +4,23 @@ ### 1. `lib/prompts/system.ts` — Rewrote compression philosophy - Removed "Manage context continuously" → Changed to "primary goal is completing the task" -- Added CONTEXT PRESSURE LEVELS (Ample <40%, Moderate 40-55%, High >55%) +- Added CONTEXT PRESSURE LEVELS (qualitative: Ample/Moderate/High — no hardcoded percentages) - Added WHAT TO COMPRESS FIRST (bash output, dead-end exploration, redundant tool results) - Added WHAT TO COMPRESS CAREFULLY (secrets/keys, file paths, function signatures, errors, user preferences) - Added BEFORE COMPRESSING IMPORTANT CONTENT (verify persisted externally) -- Added AFTER COMPRESSING (generate recovery breadcrumbs with file paths, signatures, rationale) +- Added AFTER COMPRESSING (generate recovery breadcrumbs + mention decompress for recovery) ### 2. `lib/messages/inject/inject.ts` L182-213 — Tiered context usage injection - Old: Always "use the compress tool proactively to manage context quality" regardless of usage -- New: Three tiers based on actual usage percentage: - - <40%: "Context is ample — focus on your task. Only compress obvious waste." - - 40-55%: "Context is moderate — compress completed sections and high-token waste." - - >55%: "Context is high — compress aggressively but selectively." +- New: Shared `buildContextUsageGuidance()` from utils.ts, config-driven thresholds + - Below minContextLimit (default 45%): "Context is ample — focus on your task" + - Between min/max (45-55%): "Context is moderate — compress completed sections" + - Above maxContextLimit (55%): "Context is high — compress aggressively but selectively" -### 3. `lib/messages/inject/utils.ts` L360-380 — Same tiered logic -- Applied identical three-tier guidance to the `buildContextUsageInfo()` function used in anchored nudges +### 3. `lib/messages/inject/utils.ts` L360-410 — Shared tiered logic +- Exported `buildContextUsageGuidance()` replaces old private `buildContextUsageInfo()` +- Added `resolveThresholdPercent()` helper to parse `number | "NN%"` config values +- Both inject.ts and utils.ts now call the same shared function ## Verification - TypeScript: clean diff --git a/lib/prompts/system.ts b/lib/prompts/system.ts index af1a31a..385d942 100644 --- a/lib/prompts/system.ts +++ b/lib/prompts/system.ts @@ -55,4 +55,4 @@ Generate recovery breadcrumbs in your summary so future-you can reconstruct the If you later realize you need the original details from a compressed block, use \`decompress\` to restore them. You can decompress, read the content, then re-compress if needed. Use \`compress\` and \`decompress\` deliberately with quality-first summaries. Prioritize stale content intelligently to maintain a high-signal context window. -` \ No newline at end of file +`