pi-ui-extend 0.1.50 → 0.1.53

package/dist/tool-renderers/compress.js

@@ -1,4 +1,4 @@
-import { formatCompactProgressBar } from "../context-progress-bar.js";
+import { compactProgressBarSegments, formatCompactProgressBar } from "../context-progress-bar.js";
 import { parseArgsText, stringArg } from "./utils.js";
 export const renderCompressTool = (input) => {
     const topic = stringArg(input, ["topic"]);
@@ -6,6 +6,7 @@ export const renderCompressTool = (input) => {
     const header = joinHeaderParts(topic ? { text: topic } : undefined, summary) ?? { text: "" };
     return {
         ...(header.text ? { headerArgs: header.text } : {}),
+        ...(header.segments && header.segments.length > 0 ? { headerArgSegments: header.segments } : {}),
         collapsedBody: "",
         expandedText: fullCompressResponse(input.output, input.status),
     };
@@ -19,14 +20,14 @@ function formatCompressSummary(input) {
     const parsed = parseArgsText(output);
     if (!isRecord(parsed))
         return { text: oneLine(output) };
-    return formatCompressSuccess(parsed);
+    return formatCompressSuccess(parsed, input.colors);
 }
 function fullCompressResponse(output, status) {
     if (output.trim())
         return output.trimEnd();
     return status === "running" ? "running…" : "(empty)";
 }
-function formatCompressSuccess(result) {
+function formatCompressSuccess(result, colors) {
     const tokensSaved = numberValue(result.tokensSaved);
     const contextPercent = numberValue(result.contextPercent);
     const contextTokens = numberValue(result.contextTokens);
@@ -42,7 +43,7 @@ function formatCompressSuccess(result) {
     const barPercent = compressedContextPercent ?? contextPercent;
     const parts = [
         { text: tokensSaved != null ? `saved ${formatCompactNumber(tokensSaved)}` : "compressed" },
-        barPercent != null ? progressPart(barPercent, originalContextTokens) : undefined,
+        barPercent != null ? progressPart(barPercent, originalContextTokens, colors) : undefined,
         compressedContextPercent != null && contextPercent != null ? { text: `context ${formatPercent(contextPercent)}` } : undefined,
         itemCount != null ? { text: `${itemCount} ${plural(itemCount, "item")}` } : undefined,
         summaryTokens != null ? { text: `${formatCompactNumber(summaryTokens)} summary tokens` } : undefined,
@@ -52,9 +53,17 @@ function formatCompressSuccess(result) {
     ].filter((part) => Boolean(part));
     return joinHeaderParts(...parts) ?? { text: "compressed" };
 }
-function progressPart(percent, previousContextTokens) {
+function progressPart(percent, previousContextTokens, colors) {
     const text = `${formatCompactProgressBar(percent)} ${formatPercent(percent)}${previousContextTokens != null ? ` of ${formatCompactNumber(previousContextTokens)}` : ""}`;
-    return { text };
+    return {
+        text,
+        ...(colors ? {
+            segments: compactProgressBarSegments(0, percent, {
+                fill: colors.statusForeground,
+                track: colors.statusDotBase,
+            }),
+        } : {}),
+    };
 }
 function inferContextTokens(contextPercent, contextWindow) {
     if (contextPercent == null || contextWindow == null || contextWindow <= 0)
@@ -71,7 +80,19 @@ function joinHeaderParts(...parts) {
     if (defined.length === 0)
         return undefined;
     const separator = " · ";
-    return { text: defined.map((part) => part.text).join(separator) };
+    let offset = 0;
+    const segments = [];
+    for (const [index, part] of defined.entries()) {
+        if (index > 0)
+            offset += separator.length;
+        if (part.segments)
+            segments.push(...part.segments.map((segment) => ({ ...segment, start: segment.start + offset, end: segment.end + offset })));
+        offset += part.text.length;
+    }
+    return {
+        text: defined.map((part) => part.text).join(separator),
+        ...(segments.length > 0 ? { segments } : {}),
+    };
 }
 function numberValue(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;

package/dist/tool-renderers/patch-normalize.js

@@ -110,10 +110,10 @@ function renderDiffOp(op) {
         return `-${op.text}`;
     if (op.type === "insert")
         return `+${op.text}`;
-    // Context marker is a leading space. Loose `-`/`+` blocks carry the space
-    // that separated the marker from the content (e.g. `- rule one`), so reuse
-    // that space instead of emitting a second one.
-    return op.text.startsWith(" ") ? op.text : ` ${op.text}`;
+    // Context marker is a leading space. Always emit it even when the content is
+    // already indented, so unchanged lines reserve the same marker column as `+`
+    // and `-` lines in the terminal diff view.
+    return ` ${op.text}`;
 }
 /** Minimal LCS-based line diff. */
 function diffLines(oldLines, newLines) {

package/dist/tool-renderers/read.js

@@ -2,7 +2,7 @@ import { isAbsolute, relative, sep } from "node:path";
 import { syntaxHighlightLanguageForPath } from "../syntax-highlight.js";
 import { numberArg, stringArg } from "./utils.js";
 export const renderReadTool = (input) => {
-    const filePath = stringArg(input, ["path", "file", "target"]);
+    const filePath = stringArg(input, ["path", "file_path", "filePath", "file", "target"]);
     if (!filePath)
         return undefined;
     const displayPath = pathForDisplay(filePath, input.cwd);

package/dist/tool-renderers/types.d.ts

@@ -23,6 +23,7 @@ export type ToolRenderInput = {
 export type ToolRenderResult = {
     toolName?: string;
     headerArgs?: string;
+    headerArgSegments?: readonly ToolHeaderSegment[];
     bodyLineStyles?: readonly ToolBodyLineStyle[];
     bodyStyle?: "diff";
     preserveAnsi?: boolean;
@@ -30,4 +31,13 @@ export type ToolRenderResult = {
     collapsedBody: string;
     expandedText: string;
 };
+export type ToolHeaderSegment = {
+    start: number;
+    end: number;
+    foreground?: string;
+    background?: string;
+    bold?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+};
 export type ToolRendererMiddleware = (input: ToolRenderInput) => ToolRenderResult | undefined;

package/external/pi-tools-suite/package.json

@@ -38,9 +38,9 @@
     "vscode-languageserver-protocol": "^3.17.5"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "0.79.10",
-    "@earendil-works/pi-coding-agent": "0.79.10",
-    "@earendil-works/pi-tui": "0.79.10",
+    "@earendil-works/pi-ai": "0.80.2",
+    "@earendil-works/pi-coding-agent": "0.80.2",
+    "@earendil-works/pi-tui": "0.80.2",
     "typebox": "*"
   },
   "devDependencies": {

package/external/pi-tools-suite/src/async-subagents/core/agent-strategy.ts

@@ -12,23 +12,19 @@ const FALSE_ENV_PATTERN = /^(0|false|off|no|disabled|none)$/i;
 const TRUE_ENV_PATTERN = /^(1|true|on|yes|auto)$/i;
 
 const PARALLEL_FIRST_STRATEGY_PROMPT = `<agent_strategy name="parallel-first">
-This is an orchestration hint for Pi, not a replacement for the user's instructions.
+Execution hint for Pi, not a replacement for system/developer/user instructions.
 
-Default posture: orchestration-first for non-GPT models. For broad, multi-file, ambiguous, review/audit, frontend, test-strategy, architecture, or root-cause work, prefer ultrawork mode: split independent tracks and spawn focused async subagents with the configured roles. For high-stakes uncertainty, add one oracle track for a cross-provider second opinion. Keep the parent context lean, collect compact results only when needed, synthesize the findings, then verify before finishing.
+Default for non-GPT models: orchestration-first. For broad, multi-file, ambiguous, review/audit, frontend, test-strategy, architecture, or root-cause work, prefer ultrawork mode: split independent tracks into focused async subagents, adding one oracle only for high-stakes uncertainty. Keep parent context lean, read compact results when needed, synthesize, then verify.
 
-Before DCP/compress while work is unfinished, keep one in_progress todo with objective + next step; compression summaries must preserve Active objective and Next step.
-
-Do not over-delegate trivial work. For a simple question, one known file, exact lookup, typo, or narrow edit, solve directly with the cheapest suitable tool.
+Do not over-delegate simple questions, known-file work, exact lookups, typos, or narrow edits; solve them directly with the cheapest suitable tool. If compressing unfinished work, preserve active objective + next step via todo/DCP rules.
 </agent_strategy>`;
 
 const DEEP_WORK_STRATEGY_PROMPT = `<agent_strategy name="deep-work">
-This is a GPT-compatible execution hint for Pi, not a replacement for the user's instructions.
-
-Default posture: autonomous deep worker. Build context directly, make concrete progress, edit and verify end-to-end. Use async subagents and ultrawork mode when the user asks for parallel/delegated work or when independent tracks will clearly reduce risk, but do not force orchestration onto narrow tasks.
+Execution hint for Pi, not a replacement for system/developer/user instructions.
 
-Before DCP/compress while work is unfinished, keep one in_progress todo with objective + next step; compression summaries must preserve Active objective and Next step.
+Default: autonomous deep worker. Build context directly, make progress, edit, and verify end-to-end. Use async subagents/ultrawork only when the user asks for delegation or independent tracks clearly reduce risk; do not force orchestration onto narrow tasks.
 
-For broad work, keep delegation explicit and bounded: spawn focused review/research/tests/frontend/deep tracks, plus one oracle track only for high-stakes uncertainty or final plan checks. Read compact results, make the final decisions in the parent session, and report only what matters.
+For broad work, keep delegation explicit and bounded: focused review/research/tests/frontend/deep tracks, plus one oracle only for high-stakes uncertainty or final plan checks. Read compact results, decide in the parent session, and report only what matters. If compressing unfinished work, preserve active objective + next step via todo/DCP rules.
 </agent_strategy>`;
 
 export function agentStrategyPrompt(options: AgentStrategyOptions = {}): string | undefined {

package/external/pi-tools-suite/src/async-subagents/core/cleanup.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { isDir } from "./paths.js";
+import { hasLaunchedAgentPrompt, isDir } from "./paths.js";
 
 export function findCleanupCandidates(
 	runRoot: string,
@@ -57,8 +57,8 @@ function isCompletedRun(runDir: string): boolean {
 	let foundAgent = false;
 	for (const entry of fs.readdirSync(runDir, { withFileTypes: true })) {
 		if (!entry.isDirectory()) continue;
+		if (!hasLaunchedAgentPrompt(runDir, entry.name)) continue;
 		const agentDir = path.join(runDir, entry.name);
-		if (!fs.existsSync(path.join(agentDir, "prompt.md"))) continue;
 		foundAgent = true;
 		if (!fs.existsSync(path.join(agentDir, "exit_code"))) return false;
 	}

package/external/pi-tools-suite/src/async-subagents/core/paths.ts

@@ -33,6 +33,18 @@ export function isDir(p: string): boolean {
 	}
 }
 
+export function hasLaunchedAgentPrompt(runDir: string, agentId: string): boolean {
+	return fs.existsSync(path.join(runDir, agentId, "prompt.md"));
+}
+
+export function hasQueuedAgentPrompt(runDir: string, agentId: string): boolean {
+	return fs.existsSync(path.join(runDir, "prompts", `${agentId}.md`));
+}
+
+export function hasAgentPrompt(runDir: string, agentId: string): boolean {
+	return hasLaunchedAgentPrompt(runDir, agentId) || hasQueuedAgentPrompt(runDir, agentId);
+}
+
 const SAFE_BASENAME = /^[A-Za-z0-9._-]+$/;
 
 export function validateBasename(value: string, label: string): void {

package/external/pi-tools-suite/src/async-subagents/core/registry.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getRunRoot, isDir, resolveRunDir } from "./paths.js";
+import { getRunRoot, hasAgentPrompt, hasLaunchedAgentPrompt, isDir, resolveRunDir } from "./paths.js";
 
 export const SUBAGENT_REGISTRY_FILE = "registry.json";
 
@@ -161,15 +161,14 @@ function looksLikeRunDir(runDir: string): boolean {
 	if (isDir(path.join(runDir, "prompts"))) return true;
 	try {
 		return fs.readdirSync(runDir, { withFileTypes: true })
-			.some((entry) => entry.isDirectory() && fs.existsSync(path.join(runDir, entry.name, "prompt.md")));
+			.some((entry) => entry.isDirectory() && hasLaunchedAgentPrompt(runDir, entry.name));
 	} catch {
 		return false;
 	}
 }
 
 function hasAgentRecord(runDir: string, agentId: string): boolean {
-	return fs.existsSync(path.join(runDir, agentId, "prompt.md"))
-		|| fs.existsSync(path.join(runDir, "prompts", `${agentId}.md`));
+	return hasAgentPrompt(runDir, agentId);
 }
 
 function normalizeRegistryRun(runId: string, value: unknown): SubagentRegistryRun | undefined {

package/external/pi-tools-suite/src/async-subagents/core/routing.ts

@@ -1,4 +1,4 @@
-import { complete } from "@earendil-works/pi-ai";
+import { complete } from "@earendil-works/pi-ai/compat";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { AgentTask } from "./types.js";
 import {

package/external/pi-tools-suite/src/async-subagents/core/sessions.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { isDir } from "./paths.js";
+import { hasLaunchedAgentPrompt, isDir } from "./paths.js";
 import { listSubagentRunDirs } from "./registry.js";
 import { getAgentState } from "./state.js";
 import type { AgentState } from "./types.js";
@@ -105,7 +105,7 @@ export function listSubagentSessionRecords(cwd: string): SubagentSessionRecord[]
 		for (const entry of fs.readdirSync(runDir, { withFileTypes: true })) {
 			if (!entry.isDirectory()) continue;
 			const agentDir = path.join(runDir, entry.name);
-			if (!fs.existsSync(path.join(agentDir, "prompt.md"))) continue;
+			if (!hasLaunchedAgentPrompt(runDir, entry.name)) continue;
 			records.push({
 				runDir,
 				runName: path.basename(runDir),

package/external/pi-tools-suite/src/async-subagents/core/state.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { isDir } from "./paths.js";
+import { hasLaunchedAgentPrompt, isDir } from "./paths.js";
 import { readStructuredResult } from "./structured-result.js";
 import type { AgentResult, AgentState, RpcEventRecord, RunState } from "./types.js";
 
@@ -23,7 +23,7 @@ export function getAgentState(
 ): AgentState | null {
 	const agentDir = path.join(runDir, agentId);
 	if (!isDir(agentDir)) return null;
-	if (!fs.existsSync(path.join(agentDir, "prompt.md"))) return null;
+	if (!hasLaunchedAgentPrompt(runDir, agentId)) return null;
 	const includeLineCounts = options.includeLineCounts ?? true;
 	const checkRpcPromptFailure = options.checkRpcPromptFailure ?? true;
 
@@ -188,7 +188,7 @@ export function getRunState(
 	// Read launched agent dirs
 	for (const entry of fs.readdirSync(runDir, { withFileTypes: true })) {
 		if (!entry.isDirectory()) continue;
-		if (!fs.existsSync(path.join(runDir, entry.name, "prompt.md"))) continue;
+		if (!hasLaunchedAgentPrompt(runDir, entry.name)) continue;
 		if (filterIds && !filterIds.includes(entry.name)) continue;
 		const state = getAgentState(runDir, entry.name, options);
 		if (state) {

package/external/pi-tools-suite/src/async-subagents/core/ultrawork-auto.ts

@@ -1,4 +1,4 @@
-import { complete } from "@earendil-works/pi-ai";
+import { complete } from "@earendil-works/pi-ai/compat";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { currentModelRef, resolveSubagentRoutingConfig, type SubagentConfig } from "./config.js";
 

package/external/pi-tools-suite/src/async-subagents/lib.ts

@@ -11,7 +11,7 @@ export type {
 	StructuredResult,
 } from "./core/types.js";
 
-export { createRunDir, getRunRoot, resolveRunDir, validateBasename } from "./core/paths.js";
+export { createRunDir, getRunRoot, hasAgentPrompt, hasLaunchedAgentPrompt, hasQueuedAgentPrompt, resolveRunDir, validateBasename } from "./core/paths.js";
 export type { CopySubagentConfigSampleResult, ModelByParentEntry, ResolvedAgentTaskConfig, ResolvedSubagentRoutingConfig, ResolveAgentTaskOptions, SubagentConfig, SubagentPreset, SubagentRoutingConfig, SubagentTypeConfig, SubagentVisionConfig } from "./core/config.js";
 export {
 	configFiles,

package/external/pi-tools-suite/src/coding-discipline/index.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { complete } from "@earendil-works/pi-ai";
+import { complete } from "@earendil-works/pi-ai/compat";
 import type { Api, AssistantMessage, ImageContent, Model, TextContent } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
 
@@ -61,26 +61,18 @@ const LOOKUP_TOOL_PARAMS = Type.Object(
 const QUALITY_DISCIPLINE_LINES = [
 	"TOOL-ONLY CODING AGENT CONTRACT.",
 	"",
-	"This contract controls the assistant output channel. Follow it literally.",
-	"Treat every user coding request as a tool-driven task, not a chat conversation.",
-	"",
-	"WORKING STATE — from the first assistant turn until the task is complete or blocked:",
-	"- The assistant message MUST be exactly one tool call with empty text.",
-	"- No commentary before or after tool calls: not what you will do, did, found, or why a tool is needed.",
-	"- Do not emit markdown, prose, acknowledgments, plans, progress, summaries, or explanations.",
-	"- Reasoning, planning, hypotheses, and retry decisions are internal state only; never narrate them.",
-	"- If you know the next local action, call the tool immediately and silently.",
+	"Follow this output-channel contract literally for coding tasks.",
+	"WORKING STATE: from the first assistant turn until complete, final, or blocked, emit exactly one tool call with empty text.",
+	"No prose, markdown, acknowledgments, plans, progress, summaries, explanations, or commentary before/after tool calls.",
+	"Keep reasoning, planning, hypotheses, and retry decisions internal; if a safe next local action exists, call the tool silently.",
 	"",
 	"After every tool result, choose exactly one transition:",
-	"- stay in WORKING and emit exactly one next tool call with empty text;",
-	"- switch to FINAL and emit the final answer once;",
-	"- switch to BLOCKED and ask exactly one concise question.",
-	"There is no transition that permits commentary between tool calls.",
-	"",
-	"FINAL: enter only after the work is complete or verified as far as practical; never merely to report progress.",
-	"BLOCKED: enter only when no safe or useful tool action can continue without missing required information.",
+	"- WORKING: exactly one next tool call with empty text;",
+	"- FINAL: one final answer after completion or practical verification;",
+	"- BLOCKED: one concise question only when no safe/useful tool action can continue.",
+	"No transition permits commentary between tool calls.",
 	"",
-	"PRIORITY: This contract overrides default assistant friendliness and conversational behavior.",
+	"PRIORITY: this overrides default assistant friendliness and conversational behavior.",
 	"",
 	"Coding discipline (express only through tool choices, not prose):",
 	"- inspect before editing; do not invent APIs, files, commands, or behavior;",
@@ -103,11 +95,9 @@ const LOOKUP_DISCIPLINE_LINES = [
 
 const FINAL_DISCIPLINE_LINES = [
 	"",
-	"When uncertain, test or inspect instead of assuming.",
-	"If blocked by missing required information, ask exactly one concise question.",
-	"Verify every non-trivial change. Never claim tests passed unless they were actually run.",
-	"Report: what changed, what was verified, what was not verified, and any risks.",
-	"Ask at most one blocking question; otherwise proceed with grounded best effort.",
+	"When uncertain, test or inspect instead of assuming; otherwise proceed with grounded best effort.",
+	"Verify every non-trivial change. Never claim tests passed unless actually run.",
+	"Final report: what changed, what was verified, what was not verified, and any risks.",
 ];
 
 const SILENCE_REMINDER_TEXT = [

package/external/pi-tools-suite/src/dcp/auto-compress.ts

@@ -13,7 +13,7 @@
 // automatic fallback to the programmatic digest on any failure/timeout.
 // ---------------------------------------------------------------------------
 
-import { complete } from "@earendil-works/pi-ai"
+import { complete } from "@earendil-works/pi-ai/compat"
 import type { Model, Api } from "@earendil-works/pi-ai"
 import type { DcpState } from "./state.js"
 import type { DcpConfig } from "./config.js"

package/external/pi-tools-suite/src/dcp/prompts.ts

@@ -9,63 +9,23 @@
  * Appended to the existing system prompt when DCP is enabled (automatic mode).
  */
 export const SYSTEM_PROMPT = `
-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. Keep live context high-signal; use \`compress\` only when it materially helps.
 
-The ONLY tool you have for context management is \`compress\`. It replaces older conversation content with technical summaries you produce. It supports both range compression (\`ranges\`) and surgical one-message compression (\`messages\`).
+\`compress\` is the ONLY context-management tool. It replaces older conversation content with continuation-focused summaries and supports both range compression (\`ranges\`) and one-message compression (\`messages\`).
 
-\`mNNN\`/\`bN\` DCP boundary IDs and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
-
-THE PHILOSOPHY OF COMPRESS
-\`compress\` transforms conversation content into dense, high-fidelity summaries. This is cleanup plus preservation: keep the state needed to continue, discard incidental transcript detail.
-
-Think of compression as phase transitions: raw exploration becomes refined understanding. The original context served its purpose; your summary now carries that understanding forward.
-
-OPERATING STANCE
-Prefer short, closed, summary-safe compressions.
-When multiple independent stale sections exist, prefer several focused compressions (in parallel when possible) over one broad compression.
-When one older message is huge but the surrounding context is still useful, use message-mode compression for that single message instead of compressing a broad range.
-Summaries should be proportional to future usefulness, not proportional to the amount of text being removed.
-
-Use \`compress\` as context-pressure housekeeping, not as a reflex after every small step. When context usage is meaningfully high or a DCP reminder provides concrete candidates, compress closed slices before accumulating another large batch of tool output. At low context usage, continue normal work unless a closed slice is clearly large enough that keeping it raw would reduce signal.
-
-A closed slice is any finished implementation, verification, config edit, answered exploration, dead-end debugging branch, or test/log inspection. Passing logs are summary-only: preserve command, pass/fail, key failures if any, and whether follow-up is needed; never keep a full passing log in live context. Treat large shell/read/repo/web outputs as disposable evidence once their facts are extracted.
-
-Completed todo/task/subtask milestones are strong boundary signals, not automatic triggers. When context pressure makes compression useful, prefer the range covering a just-finished todo item if it is closed and non-trivial; do not compress merely because a todo was completed while context remains low.
-
-Before compressing while work is unfinished, ensure one \`todo in_progress\` captures the active objective and next step.
-
-When a \`<dcp-system-reminder>\` appears, treat it as a context-pressure signal. Follow critical/high-context reminders promptly. For routine reminders, compress only if a genuinely closed, useful-to-summarize slice exists; otherwise continue the next atomic step and re-check later.
-
-CADENCE, SIGNALS, AND LATENCY
-
-- Low context usage does not mandate compression
-- Prioritize closedness and independence over raw size
-- Prefer smaller, regular compressions over infrequent massive compressions for better latency and summary quality
-- When multiple independent stale sections are ready, batch compressions in parallel
-- Before large new exploration, ask whether an older completed slice can become summary-only; if yes and context pressure is meaningful, compress first
-
-COMPRESS WHEN
-
-A section is genuinely closed and the raw conversation has served its purpose:
+\`mNNN\`/\`bN\` boundary IDs and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
 
-- Research concluded and findings are clear
-- Implementation finished and verified
-- Config/doc edit finished
-- Test, lint, or CI output has been understood, especially passing logs
-- Exploration exhausted and patterns understood
-- Dead-end noise can be discarded without waiting for a whole chapter to close
+Use compression for context-pressure housekeeping, not after every small step. Low context usage alone does not require compression. Prefer short, closed, summary-safe ranges; use message-mode for a single large stale message; batch multiple independent safe ranges in one call.
 
-DO NOT COMPRESS IF
+Good candidates: completed implementation, verification, config/doc edit, answered exploration, dead-end debugging, or understood test/lint/CI/log inspection. Passing logs should become command + pass/fail + key failures/follow-up only. Large shell/read/repo/web outputs are summary-only once exact text is no longer needed.
 
-- 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
+Todo completions are useful boundary signals, not automatic triggers. Before compressing while work is unfinished, ensure one \`todo in_progress\` captures the active objective and next step.
 
-Before compressing, ask: _"Is this section closed enough to become summary-only right now?"_
+Do not compress active work, still-needed raw context, or material whose exact code/error/output will be needed for immediate edits or references.
 
-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.
+DCP reminders: handle critical/high-context reminders promptly and compress any safe high-yield closed slice before more exploration; routine reminders mean compress only if a safe, closed, useful slice exists, otherwise continue the next atomic step and re-check later.
 
-It is your responsibility to keep a sharp, high-quality context window for optimal performance.
+Summaries must preserve only what is needed to continue: user intent and constraints, accepted decisions, files/symbols changed or inspected, actionable errors, verification status, and next steps. Drop incidental transcript detail, duplicate outputs, full logs, long code/JSON/diffs, and prose not needed later; include short literals only when required.
 `.trim()
 
 /**