pi-ui-extend 1.0.41 → 1.0.45

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

@@ -128,6 +128,16 @@ function validateExactBlock(value: unknown): asserts value is CompressionBlock {
       throw new DcpJournalError(`DCP journal block b${value.id} has invalid ${key}`);
     }
   }
+  if (value.commitMetrics !== undefined) {
+    const m = value.commitMetrics;
+    if (!isRecord(m) || typeof m.operationId !== "string" || !m.operationId ||
+      !["manual", "auto", "consolidation"].includes(m.kind as string) ||
+      !finiteNonNegativeInteger(m.beforeTokens) || !finiteNonNegativeInteger(m.afterTokens) ||
+      !finiteNonNegativeInteger(m.netGainTokens) || m.netGainTokens <= 0 ||
+      m.beforeTokens - m.afterTokens !== m.netGainTokens) {
+      throw new DcpJournalError(`DCP journal block b${value.id} has invalid commit metrics`);
+    }
+  }
   for (const key of ["sourceMembers", "mutationMembers"] as const) {
     const members = value[key];
     if (!Array.isArray(members) || members.length === 0) {
@@ -438,13 +448,125 @@ function journalBranch(ctx: ExtensionContext): unknown[] {
   }
 }
 
+function indexBranchParents(entries: readonly unknown[], requireFullChain: boolean): Map<string, string | null> | undefined {
+  const parents = new Map<string, string | null>();
+  let previousId: string | null = null;
+  for (const entry of entries) {
+    if (!isRecord(entry) || typeof entry.id !== "string" || !entry.id
+      || parents.has(entry.id)) return undefined;
+    let parentId: string | null = null;
+    if (entry.parentId !== null) {
+      if (typeof entry.parentId !== "string" || !entry.parentId) return undefined;
+      parentId = entry.parentId;
+    }
+    if (requireFullChain && parentId !== previousId) return undefined;
+    parents.set(entry.id, parentId);
+    previousId = entry.id;
+  }
+  return parents;
+}
+
+/**
+ * getBranch() on Pix's lazy manager is a JSONL presentation tail: it may omit
+ * older ancestors AND interleave abandoned branches. Do not "simplify" this
+ * into a positional prefix/suffix comparison or an ID-membership test.
+ *
+ * Walk parentId from the captured current leaf. Only the full read may supply
+ * ancestors missing from the tail; overlapping IDs must have identical parents
+ * (SDK entry identities/parent links are immutable). Both the old leaf and the
+ * read tip must lie on that walk. A side-branch tip merely present in the tail
+ * is not evidence. Missing links/cycles/conflicts deny the retry.
+ *
+ * This proves permission to re-read, NOT a publishable merged snapshot. Never
+ * return the tail/union as history or hydrate synchronously to validate it.
+ * Contract + counterexample: specs/dcp-statistics.md#lazy-tail-retry-invariant.
+ */
+function readSnapshotFollowsCurrentBranch(
+  entries: readonly unknown[],
+  currentEntries: readonly unknown[],
+  previousLeafId: string,
+  currentLeafId: string,
+): boolean {
+  const readParents = indexBranchParents(entries, true);
+  const currentParents = indexBranchParents(currentEntries, false);
+  if (!readParents?.has(previousLeafId) || !currentParents?.has(currentLeafId)) return false;
+
+  const readTipId = (entries.at(-1) as { id: string }).id;
+  const visited = new Set<string>();
+  let cursor: string | null = currentLeafId;
+  let reachedPrevious = false;
+  let reachedReadTip = false;
+  while (cursor !== null) {
+    if (visited.has(cursor)) return false;
+    visited.add(cursor);
+    const currentParent = currentParents.get(cursor);
+    const readParent = readParents.get(cursor);
+    if (currentParent !== undefined && readParent !== undefined && currentParent !== readParent) return false;
+    // An absent old ancestor may be supplied by the full read, but a missing
+    // new descendant cannot be guessed. Null is a root, not a missing value.
+    const parent = currentParent !== undefined ? currentParent : readParent;
+    if (parent === undefined) return false;
+    reachedPrevious ||= cursor === previousLeafId;
+    reachedReadTip ||= cursor === readTipId;
+    cursor = parent;
+  }
+  return reachedPrevious && reachedReadTip;
+}
+
 export async function readDcpJournalBranch(ctx: ExtensionContext): Promise<unknown[]> {
   const manager = ctx.sessionManager as any;
-  if (typeof manager.readFullBranchEntries === "function") {
-    const entries = await manager.readFullBranchEntries();
-    return Array.isArray(entries) ? entries : [];
+  const sessionId = manager.getSessionId?.();
+  const hasLeafIdentity = typeof manager.getLeafId === "function";
+  const readFullBranch = typeof manager.readFullBranchEntries === "function"
+    ? () => manager.readFullBranchEntries()
+    : undefined;
+
+  // Lazy full-history reads yield to the event loop. A normal append on the
+  // same active branch (for example, tool results arriving while a reloaded
+  // runtime is replaying its journal) advances the leaf without changing the
+  // branch owner. Retry that transient race so startup does not permanently
+  // block DCP. A real branch move/fork, owner replacement, or a branch that
+  // keeps moving still fails closed.
+  const maxAttempts = readFullBranch ? 3 : 1;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const leafId = manager.getLeafId?.();
+    const entries = readFullBranch ? await readFullBranch() : manager.getBranch();
+    if (ctx.sessionManager !== manager || manager.getSessionId?.() !== sessionId) {
+      throw new DcpJournalError("DCP branch changed during history read; rebuild context");
+    }
+    if (!Array.isArray(entries)) throw new DcpJournalError("DCP full branch is unavailable");
+    // A presentation cursor is not a complete SDK branch, even if it contains
+    // recent users or journal deltas. Never silently initialize from that tail.
+    if (entries[0]?.parentId != null) throw new DcpJournalError("DCP received an incomplete branch (presentation tail)");
+
+    const currentLeafId = manager.getLeafId?.();
+    if (currentLeafId === leafId) {
+      if (hasLeafIdentity) {
+        const readLeafId = entries.at(-1)?.id;
+        if ((leafId == null && entries.length > 0) || (leafId != null && readLeafId !== leafId)) {
+          throw new DcpJournalError("DCP branch changed during history read; rebuild context");
+        }
+      }
+      return entries;
+    }
+
+    let sameBranchAdvance = false;
+    if (leafId && currentLeafId) {
+      try {
+        const currentEntries = manager.getBranch();
+        sameBranchAdvance = Array.isArray(currentEntries)
+          && manager.getLeafId?.() === currentLeafId
+          && readSnapshotFollowsCurrentBranch(entries, currentEntries, leafId, currentLeafId);
+      } catch {
+        sameBranchAdvance = false;
+      }
+    }
+    if (!sameBranchAdvance || attempt === maxAttempts - 1) {
+      throw new DcpJournalError("DCP branch changed during history read; rebuild context");
+    }
   }
-  return journalBranch(ctx);
+
+  throw new DcpJournalError("DCP branch changed during history read; rebuild context");
 }
 
 function restoreLeafAfterAppendFailure(ctx: ExtensionContext, previousLeafId: string | null | undefined): void {

package/external/pi-tools-suite/src/dcp/progress-controller.ts

@@ -15,7 +15,8 @@ export type DcpBlockedReason =
   | "summarizer-unavailable"
   | "non-positive-gain"
   | "missing-source"
-  | "budget-exhausted";
+  | "budget-exhausted"
+  | "auto-compress-failed";
 
 export interface DcpBlockedReasonInput {
   pressured: boolean;

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

@@ -9,23 +9,21 @@
  * Appended to the existing system prompt when DCP is enabled (automatic mode).
  */
 export const SYSTEM_PROMPT = `
-You operate in a context-constrained environment. Keep live context high-signal; use \`compress\` only when it materially helps.
-
-\`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\` boundary IDs and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
-
-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.
-
-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.
-
-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.
-
-Do not compress active work, still-needed raw context, or material whose exact code/error/output will be needed for immediate edits or references.
-
-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.
-
-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. Do not infer, invent, or add facts that are not present in the selected messages. Drop incidental transcript detail, duplicate outputs, full logs, long code/JSON/diffs, and prose not needed later; include short literals only when required.
+Keep live context high-signal. \`compress\` is the only DCP context tool; use it
+only when a closed stale slice materially reduces context pressure. Low context
+usage alone does not require compression. Good boundaries include completed
+implementation, verification, investigation, config/docs, or understood logs.
+Use \`messages\` for one large stale message and batch independent safe work.
+
+Do not compress active work or raw code/errors/output needed next. If unfinished
+work is compressed, preserve the active objective and next step. A summary must
+preserve user intent/constraints, decisions, relevant files/symbols, actionable
+errors, verification state, and next steps. Do not infer, invent, or add facts;
+drop duplicate transcript detail, full logs, and long code/JSON/diffs.
+
+\`mNNN\`/\`bN\` IDs and \`<dcp-system-reminder>\` tags are injected metadata;
+never quote or output them. Critical/high-pressure reminders take priority;
+routine reminders may be skipped when no safe useful slice exists.
 `.trim()
 
 /**
@@ -37,105 +35,52 @@ Summaries must preserve only what is needed to continue: user intent and constra
  *     ranges: Array<{
  *       startId: string        // mNNN or bN
  *       endId:   string        // mNNN or bN
- *       summary: string        // continuation-focused technical summary
+ *       summary?: string       // optional parent-authored summary
  *     }>
  *   }
  */
-export const COMPRESS_RANGE_DESCRIPTION = `Collapse one or more ranges of the conversation into detailed summaries.
-
-CONTEXT-PRESSURE HOUSEKEEPING
-Use compression when it will materially improve the live context window. Low context usage by itself does not require compression, even when a small closed slice exists. When context usage is meaningfully high, or a DCP reminder supplies concrete high-yield candidates, closed implementation, verification, config/doc edit, answered exploration, dead-end debugging, or finished test/log inspection can become summary-only before another large exploratory batch.
-
-PASSING LOGS AND LARGE OUTPUTS
-Passing check/test/lint/tsc logs are summary-only after you know the result. Preserve command, pass/fail, key failures if any, and follow-up status; drop full passing output. Treat large shell/read/repo/web outputs as disposable evidence once important facts are extracted.
-
-DCP REMINDERS
-If a \`<dcp-system-reminder>\` is present in context, treat it as a signal to evaluate compression. Critical or high-context reminders should be handled promptly. Routine reminders should lead to compression only when a safe, closed, useful-to-summarize range exists; otherwise continue the next atomic step and re-check later.
-
-COMMITTED IS NOT NECESSARILY RECOVERED
-The tool rejects non-positive full-projection gain, including wrappers and preserved content. An unsuccessful call does not satisfy the reminder. Inspect \`netGain\`, \`pressureRelieved\`, and \`remainingRecoveryTokens\` in its result: a partial positive commit may still leave context pressure. Use freshly visible IDs for subsequent work; do not retry an unchanged rejected summary or discard required facts just to meet a token goal.
-
-THE SUMMARY
-Your summary must be COMPLETE FOR CONTINUATION, not a transcript rewrite. Preserve only information that will plausibly matter later: user intent, accepted constraints, decisions, files/symbols changed or inspected, exact errors that are still actionable, verification status, and next steps.
-
-Do not infer, invent, or add facts that are not present in the selected range. If the source is uncertain or incomplete, preserve that uncertainty instead of filling gaps.
-
-If active unfinished work exists, start with \`Active objective\` and \`Next step\`.
-
-Default to a compact structured summary (roughly 4-10 bullets for a normal completed work slice). Grow beyond that only when the compressed range contains multiple independent decisions, unresolved blockers, or precise state that is genuinely required to continue.
-
-Do not copy long raw code, JSON, diffs, logs, or tool output into summaries. Prefer semantic descriptions such as “updated foo.json so scene_assets_1.zai-svg has maxConcurrentRuns set to 5.” Include exact snippets only when the literal text is required for safe continuation, and keep them short and single-line.
-
-SUMMARY ARGUMENT SAFETY
-The summary is passed as a JSON string argument to the compress tool. Avoid raw double-quoted JSON fragments, multiline object literals, and diff hunks because they can make tool-call arguments malformed. If a literal field name matters, prefer plain prose or quote-light code spans such as \`maxConcurrentRuns: 5\` instead of raw \`"maxConcurrentRuns": 5\` blocks.
-
-USER INTENT FIDELITY
-When the compressed range includes user messages, preserve the user's intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
-Directly quote user messages when they are short enough to include safely. Direct quotes are preferred when they best preserve exact meaning.
-
-Be LEAN. Strip away full logs, repeated search/read output, duplicate summaries, incidental failed attempts, and line-by-line edit history. What remains should be pure signal with enough detail to resume work confidently.
-
-TWO COMPRESSION MODES
-You may use either or both modes in one call:
-
-- \`ranges\`: collapse contiguous conversation spans using \`startId\`, \`endId\`, and \`summary\`.
-- \`messages\`: collapse individual raw messages using \`messageId\`, optional \`topic\`, and \`summary\`.
-
-Use \`messages\` for a single large stale message when surrounding messages should remain raw. \`messages\` accepts only raw \`mNNN\` IDs, not \`bN\` compressed block IDs.
-
-PROTECTED PROMPT CONTENT
-If selected user text contains \`<protect>...</protect>\` content, preserve that protected content verbatim in your summary. The tool may append protected text automatically, but you should still account for it semantically.
-
-COMPRESSED BLOCK PLACEHOLDERS
-When rolling up compressed blocks, summarize their continuation-relevant meaning instead of copying the full old summaries. Every block carries a protected-fragment ledger, and those fragments are preserved separately. A block missing that ledger is invalid and must not be rolled up.
-
-Only when the full previous summary is genuinely needed verbatim, use this exact placeholder format:
-
-- \`(bN)\`
-
-Compressed block sections in context are clearly marked with a header:
-
-- \`[Compressed conversation section]\`
-
-Compressed block IDs always use the \`bN\` form (never \`mNNN\`) and are represented as hidden DCP metadata.
-
-Rules:
-
-- Placeholders are optional, not required for every covered modern block. Each explicit placeholder expands the full old summary and may eliminate the intended savings. Include an intentionally preserved block at most once.
-- Do not invent placeholders for blocks outside the selected range.
-- Treat \`(bN)\` placeholders as RESERVED TOKENS. Do not emit \`(bN)\` text anywhere except intentional placeholders.
-- If you need to mention a block in prose, use plain text like \`compressed bN\` (not as a placeholder).
-- Preflight check before finalizing: each placeholder must refer to a known selected block whose full text you deliberately need to preserve. Otherwise write a concise factual summary in your own words.
-
-These placeholders are semantic references. They will be replaced with the full stored compressed block content when the tool processes your output.
-
-FLOW PRESERVATION WITH PLACEHOLDERS
-When you use compressed block placeholders, write the surrounding summary text so it still reads correctly AFTER placeholder expansion.
-
-- Treat each placeholder as a stand-in for a full conversation segment, not as a short label.
-- Ensure transitions before and after each placeholder preserve chronology and causality.
-- Do not write text that depends on the placeholder staying literal (for example, "as noted in \`(b2)\`").
-- Your final meaning must be coherent once each placeholder is replaced with its full compressed block content.
-
-BOUNDARY IDS
-You specify boundaries by ID using the injected metadata IDs present in the conversation context:
-
-- \`mNNN\` IDs identify raw messages (3 digits, zero-padded, e.g. \`m001\`, \`m042\`)
-- \`bN\` IDs identify previously compressed blocks
-
-Raw message IDs are provided in hidden DCP control metadata attached to stable user/tool-result carriers. IDs may be sparse; determine range order from where their carriers appear in context, not from the numeric suffix.
-Some message-compression candidate hints include a low/medium/high priority; prefer high-priority stale message IDs for message-mode compression when a full range would be too broad.
-Each carrier's metadata labels that carrier and any immediately preceding assistant message(s).
-Treat these reference lines as boundary metadata only, not as tool result content.
-
-Rules:
-
-- Use only injected IDs in current context; \`startId\` must precede \`endId\`. Do not invent IDs.
-- For \`ranges\`, never split a tool group: include the calling assistant and all its tool results, including parallel calls.
-- If \`compress\` fails with \`Unknown message ID\`, treat those IDs as stale; retry at most once using only the error's listed current raw IDs or eligible \`bN\` blocks, or skip if no closed range is safe.
-
-BATCHING
-When multiple independent ranges or individual messages are ready, include all of them in one \`compress\` call. Range entries must not overlap. Message entries should each summarize exactly one raw message.`
+export const COMPRESS_RANGE_DESCRIPTION = `Replace closed stale context with continuation-focused summaries.
+
+WHEN: compress only when it materially improves live context or a DCP reminder
+identifies useful stale work. Do not compress active/still-needed material. Passing
+test/lint/build logs may become command + outcome + actionable failures; discard
+raw logs/read/search output after their facts are captured.
+
+SUMMARY: make it COMPLETE FOR CONTINUATION, not a transcript rewrite. Preserve
+user intent/constraints, decisions, files/symbols changed or inspected, exact
+errors that are still actionable, verification state, unresolved blockers, and
+next steps. If work remains unfinished include \`Active objective\` and \`Next
+step\`. Do not infer, invent, or add facts. Preserve uncertainty. Do not copy long
+raw code, JSON, diffs, logs, or tool output; use short literals only when needed.
+Normally omit \`summary\`: DCP generates it. An explicit \`summary\` overrides
+generation when parent-authored continuation wording is genuinely required.
+
+MODES:
+- \`ranges\`: contiguous \`startId..endId\` spans.
+- \`messages\`: one raw \`mNNN\` body when neighbours should remain raw. Use
+  \`messages\` for a single large stale message; it does not accept \`bN\`.
+Batch independent non-overlapping selections in one call.
+
+BOUNDARIES: use only injected IDs currently visible on stable user/tool-result
+carriers. \`mNNN\` is raw, \`bN\` is an active compressed block; IDs may be sparse
+and order is the conversation order, not the number. Carrier metadata labels the
+carrier plus immediately preceding assistant message(s): \`a\`=assistant,
+\`u\`=user, \`t\`=tool result, \`x\`=bash result, \`b\`=block alias. Do not invent IDs. For
+\`ranges\`, never split a tool group: include the calling assistant and all its
+tool results, including parallel calls. On \`Unknown message ID\`, retry at most
+once using the current IDs reported by the tool.
+
+PROTECTION/ROLLUP: preserve \`<protect>...</protect>\` text verbatim. When a
+selected range contains compressed blocks, summarize their continuation-relevant
+meaning; their protected-fragment ledgers survive separately. Placeholders are
+optional: use \`(bN)\` only when the full selected prior summary is genuinely
+required verbatim, at most once, and never invent a placeholder. Otherwise refer
+to it in prose as \`compressed bN\`.
+
+RESULT: the tool rejects non-positive full-projection gain. An unsuccessful call
+does not satisfy a reminder. Inspect \`netGain\`, \`pressureRelieved\`, and
+\`remainingRecoveryTokens\`; a positive partial commit can still leave pressure.
+Do not discard required facts merely to hit a token target.`
 
 /**
  * Injected into messages when context usage exceeds maxContextPercent.
@@ -143,29 +88,11 @@ When multiple independent ranges or individual messages are ready, include all o
  */
 export const CONTEXT_LIMIT_NUDGE_STRONG = `<dcp-system-reminder>
 CRITICAL WARNING: MAX CONTEXT LIMIT REACHED
-
-You are at or beyond the configured max context threshold. This is an emergency context-recovery moment.
-
-You MUST use the \`compress\` tool now. Do not continue normal exploration until compression is handled.
-
-If you are in the middle of a critical atomic operation, finish that atomic step first, then compress immediately.
-If any closed slice exists (finished implementation, verification, config/doc edit, answered exploration, dead end, or test/log inspection), compress it before replying or starting another task. Passing logs should become command + pass/fail + follow-up status only.
-Recently completed todo/task/subtask items are preferred boundaries when they form a high-yield closed slice.
-
-RANGE STRATEGY (MANDATORY)
-Prioritize one large, closed, high-yield compression range first.
-This overrides the normal preference for many small compressions.
-Only split into multiple compressions if one large range would reduce summary quality or make boundary selection unsafe.
-
-RANGE SELECTION
-Start from older, resolved history and capture as much stale context as safely possible in one pass.
-Avoid the newest active working slice unless it is clearly closed.
-Use injected boundary IDs for compression (\`mNNN\` for messages, \`bN\` for compressed blocks), and ensure \`startId\` appears before \`endId\`.
-For a single large stale message, use the \`messages\` array with its injected \`mNNN\` ID.
-
-SUMMARY REQUIREMENTS
-Your summary must cover all essential details from the selected range so work can continue without reopening raw messages, but it should not restate raw code, JSON, logs, or diffs unless a short literal is required.
-If the compressed range includes user messages, preserve user intent exactly. Prefer direct quotes for short user messages to avoid semantic drift.
+You MUST use the \`compress\` tool now, after any critical atomic step. Prefer one
+large, older, closed high-yield range; split only for safety/summary quality. Keep
+the newest active slice raw. Preserve user intent exactly and all state needed to
+continue, but not full logs/code/diffs. Use current injected IDs; use \`messages\`
+for one isolated large stale message.
 </dcp-system-reminder>`
 
 /**
@@ -174,20 +101,11 @@ If the compressed range includes user messages, preserve user intent exactly. Pr
  */
 export const CONTEXT_LIMIT_NUDGE_SOFT = `<dcp-system-reminder>
 ACTION REQUIRED: Context usage is high.
-
-Before doing more exploration, look for a high-yield closed range that no longer needs to stay raw. Compress it now if one is safe and useful.
-
-This is context-pressure guidance, not a request to compress tiny or still-needed slices. If completed research, implementation, verification, config/doc edit, CI-log inspection, or dead-end debugging is large enough to reduce signal, call the \`compress\` tool before continuing normal work.
-Recently completed todo/task/subtask items are preferred candidates when they form a non-trivial closed slice; do not compress merely because a tiny todo was completed.
-High-priority stale shell/read/repo/web outputs should be compressed once no exact raw text is needed. Passing logs should not remain raw after they are understood.
-
-RANGE SELECTION
-Prefer older, resolved history. Avoid the newest active working slice unless it is clearly done.
-Use injected boundary IDs (\`mNNN\` for messages, \`bN\` for compressed blocks) and ensure \`startId\` appears before \`endId\`.
-For a single large stale message, use message-mode compression via the \`messages\` array.
-
-If multiple independent high-yield ranges are ready, batch them in a single \`compress\` call.
-If nothing is cleanly closed and worth summarizing yet, continue with the next atomic step and re-check later.
+Before more exploration, compress a high-yield older closed slice if one is safe
+and useful. Keep active/tiny slices raw; understood logs/search/read output are
+good candidates. Batch independent ranges; use message-mode compression for one
+large stale message. If nothing is cleanly closed, continue with the next atomic
+step and re-check later.
 </dcp-system-reminder>`
 
 /**
@@ -196,18 +114,10 @@ If nothing is cleanly closed and worth summarizing yet, continue with the next a
  */
 export const TURN_NUDGE = `<dcp-system-reminder>
 CONTEXT CHECK: Evaluate whether compression would materially improve the live context.
-
-If a range is cleanly closed, non-trivial, and unlikely to be needed verbatim again, use the \`compress\` tool. If direction has shifted, consider whether earlier ranges are now less relevant.
-
-If a todo/task/subtask was just completed, treat that completed work as a preferred compression boundary when it is large enough and no longer needed raw; completion alone is not a reason to compress while context is still low.
-
-Do not compress just because a small slice closed while context is still low. Prefer compression before another large batch of searches, reads, CI log fetches, or tests when a high-yield stale slice exists.
-High-priority stale shell/read/repo/web outputs and understood passing logs should be compressed once no exact raw text is needed.
-
-Prefer small, closed-range compressions over one broad compression.
-Use message-mode compression for isolated large stale messages.
-The goal is to filter meaningful noise and distill key information so context accumulation stays under control.
-Keep active context uncompressed.
+Compress only a non-trivial closed stale slice that no longer needs verbatim text,
+especially before another large tool batch. Do not compress just because a small
+slice closed. Prefer closed ranges; use message-mode compression for an isolated
+large stale message. Keep active context uncompressed.
 </dcp-system-reminder>`
 
 /**
@@ -215,15 +125,10 @@ Keep active context uncompressed.
  */
 export const ITERATION_NUDGE = `<dcp-system-reminder>
 CONTEXT CHECK: You've been iterating for a while after the last user message.
-
-Pause before the next large non-atomic tool batch. If there is a closed portion that is unlikely to be referenced immediately and is worth summarizing (for example, finished research before implementation, completed config edit, completed CI-log triage, a verified fix, or a dead-end investigation), use the \`compress\` tool on it.
-
-If a todo/task/subtask was just completed, prefer that completed work as the compression boundary when it is non-trivial and safe to summarize; do not compress merely because the todo status changed.
-
-Avoid accumulating large tool outputs while a high-yield completed slice remains raw. If only small or still-needed ranges are closed, continue the next atomic step and re-check later.
-
-Prefer multiple short, closed ranges over one large range when several independent slices are ready.
-Use message-mode compression for isolated large stale messages.
+Before another large tool batch, compress completed non-trivial work that no longer
+needs raw detail. Prefer closed ranges; use message-mode compression for an
+isolated large stale message. If only small or still-needed ranges are closed,
+continue the next atomic step and re-check later.
 </dcp-system-reminder>`
 
 /**
@@ -233,25 +138,11 @@ Use message-mode compression for isolated large stale messages.
  */
 export const MANUAL_MODE_SYSTEM_PROMPT = `
 You are operating in DCP manual mode for context management.
-
-\`mNNN\`/\`bN\` DCP boundary IDs and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
-
-In manual mode you do NOT proactively compress conversation content. Compression is a deliberate, user-directed action.
-
-WHEN TO COMPRESS
-- Only when the user explicitly asks you to compress
-- Only when a \`<dcp-system-reminder>\` nudge instructs you to (context-limit emergency)
-- Never as background housekeeping or on your own initiative
-
-WHEN YOU DO COMPRESS
-Apply the same quality standards as always:
-
-- Summaries must be complete for continuation, not transcript-sized; keep only file paths, decisions, findings, exact constraints, unresolved blockers, and verification state that may matter later
-- Avoid raw JSON/code/diff/log blocks in summary strings; describe changes in prose or use very short quote-light code spans when literals are necessary
-- Preserve user intent precisely; prefer direct quotes for short user messages
-- Use only boundary IDs present in context (\`mNNN\` for messages, \`bN\` for compressed blocks)
-- Batch independent ranges in a single \`compress\` call when possible
-- Use message-mode compression for isolated large stale messages when directed by a context-limit nudge
-
-Do not compress active, still-needed context. Only compress ranges that are genuinely closed and whose raw form is no longer required.
+Do NOT proactively compress. Use \`compress\` only when the user explicitly asks
+or a \`<dcp-system-reminder>\` requires context-limit recovery. Preserve user
+intent precisely and enough decisions/files/errors/verification/next state to
+continue; omit long raw code/JSON/diffs/logs. Use only visible \`mNNN\`/\`bN\`
+IDs, batch independent safe ranges, and use message-mode for one large stale
+message. Do not compress active, still-needed context. Injected DCP IDs/reminder
+tags are metadata; never output them.
 `.trim()