@bubblebrain-ai/bubble 0.0.41 → 0.0.43

package/dist/agent.d.ts

@@ -227,6 +227,7 @@ export declare class Agent {
     private getActiveToolEntries;
     injectSystemReminder(content: string): void;
     injectModeReminder(): void;
+    get role(): "parent" | "subagent";
     get model(): string;
     set model(value: string);
     get providerId(): string;
@@ -260,8 +261,10 @@ export declare class Agent {
     /** Snapshot of how often each compaction path rewrote history this run. */
     getCompactionStats(): {
         resident: number;
+        subturn: number;
         llm: number;
         overflow: number;
+        fired: number;
         droppedMessages: number;
     };
     /**

package/dist/agent.js

@@ -2,7 +2,7 @@
  * Agent - The core decision loop.
  * It maintains message state, calls the LLM, executes tools, and auto-continues.
  */
-import { compactMessages } from "./context/compact.js";
+import { compactCurrentTurnToolGroups, compactMessages, isRealUserMessage } from "./context/compact.js";
 import { randomUUID } from "node:crypto";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -175,9 +175,10 @@ export class Agent {
     // How often each compaction path actually rewrote history this run.
     // Surfaced via getCompactionStats() for print-mode telemetry: without it,
     // "did the model ever stop seeing the original instruction?" is
-    // unanswerable from the outside (only counts real compactions, not
-    // byte-saving projection rewrites).
-    compactionStats = { resident: 0, llm: 0, overflow: 0, droppedMessages: 0 };
+    // unanswerable from the outside. `fired` counts successful compaction
+    // computations including ones whose rewrite was later rejected — a
+    // fired-but-never-written gap is the churn signal.
+    compactionStats = { resident: 0, subturn: 0, llm: 0, overflow: 0, fired: 0, droppedMessages: 0 };
     constructor(options) {
         this.provider = options.provider;
         this.sessionID = options.sessionID;
@@ -428,6 +429,9 @@ export class Agent {
         }
         this.injectSystemReminder(reminder);
     }
+    get role() {
+        return this.agentRole;
+    }
     get model() {
         return this._model;
     }
@@ -999,6 +1003,7 @@ export class Agent {
                     const droppedMessages = await this.recoverFromOverflow(consecutiveOverflowRecoveries);
                     consecutiveOverflowRecoveries += 1;
                     this.compactionStats.overflow += 1;
+                    this.compactionStats.fired += 1;
                     this.compactionStats.droppedMessages += droppedMessages;
                     traceEvent("compaction_fired", { path: "overflow", droppedMessages });
                     yield emit({ type: "context_recovered", droppedMessages, reason: "overflow" });
@@ -1517,6 +1522,7 @@ export class Agent {
             this.lastAnchorMessageCount = null;
             this.fileStateTracker?.invalidateReadHistory();
             this.compactionStats.llm += 1;
+            this.compactionStats.fired += 1;
             traceEvent("compaction_fired", { path: "llm" });
         }
         // If LLM compaction failed for any reason, leave this.messages alone —
@@ -2548,23 +2554,43 @@ export class Agent {
         if (shouldAggressivelyPrune) {
             candidate = aggressivePruneMessages(candidate);
         }
+        let compactedPath;
         if (shouldCompact) {
             const compacted = compactMessages(candidate, { keepRecentTurns });
             if (compacted.compacted && compacted.messages) {
                 candidate = compacted.messages;
-                this.compactionStats.resident += 1;
+                compactedPath = "resident";
                 traceEvent("compaction_fired", { path: "resident", droppedEntries: compacted.droppedEntries });
             }
+            else {
+                // Single-instruction runs (one real user turn) never satisfy the
+                // turn-level compactor; fold old tool groups within the turn instead.
+                const subturn = compactCurrentTurnToolGroups(candidate, { keepRecentGroups: 3 });
+                if (subturn.compacted && subturn.messages) {
+                    candidate = subturn.messages;
+                    compactedPath = "subturn";
+                    traceEvent("compaction_fired", { path: "subturn", droppedEntries: subturn.droppedEntries });
+                }
+            }
+            if (compactedPath)
+                this.compactionStats.fired += 1;
         }
         const afterChars = estimateResidentChars(candidate);
         const afterToolChars = estimateToolPayloadChars(candidate);
-        if (afterChars < beforeChars
-            || afterToolChars < beforeToolChars
-            || candidate.length < before.length) {
+        // Chars-not-increasing is a NECESSARY condition: the old OR gate let a
+        // fewer-but-bigger candidate (summary stacking) rewrite history.
+        if (afterChars <= beforeChars
+            && (afterChars < beforeChars
+                || afterToolChars < beforeToolChars
+                || candidate.length < before.length)) {
             this.messages = candidate;
             this.lastInputTokens = null;
             this.lastAnchorMessageCount = null;
             this.fileStateTracker?.invalidateReadHistory();
+            if (compactedPath === "resident")
+                this.compactionStats.resident += 1;
+            if (compactedPath === "subturn")
+                this.compactionStats.subturn += 1;
         }
     }
     appendMessage(message) {
@@ -2943,7 +2969,10 @@ function estimateToolPayloadChars(messages) {
     }, 0);
 }
 function countUserTurns(messages) {
-    return messages.reduce((count, message) => count + (message.role === "user" ? 1 : 0), 0);
+    // Real user turns only: projected reminders and summary envelopes are
+    // user-ROLE but not user TURNS — counting them used to shrink the keep
+    // window and fire compaction almost every turn.
+    return messages.reduce((count, message) => count + (isRealUserMessage(message) ? 1 : 0), 0);
 }
 function getCurrentHeapUsed() {
     try {

package/dist/context/compact-llm.js

@@ -6,7 +6,7 @@
  * message. Falls back to the heuristic `compactMessages` if the LLM call
  * fails.
  */
-import { compactMessages as compactMessagesHeuristic } from "./compact.js";
+import { buildCompactionSummaryMessage, clonePinnedUserMessage, compactMessages as compactMessagesHeuristic, findFirstRealUserIndex, isCompactionSummaryMessage, isRealUserMessage, splitLeadingContext, } from "./compact.js";
 export const COMPACT_SYSTEM_PROMPT = `You are a conversation summarizer. Your job is to produce a structured
 summary of an earlier portion of a software-engineering assistant's
 conversation so that the assistant can continue working without the full
@@ -44,10 +44,13 @@ content, write "None".
    - The single most natural next action, if obvious.`;
 export async function compactMessagesWithLLM(messages, options) {
     const keepRecentTurns = options.keepRecentTurns ?? 2;
-    const preservedContextMessages = messages.filter((m) => m.role === "system" || m.role === "meta");
-    const conversationalMessages = messages.filter((m) => m.role !== "system" && m.role !== "meta");
-    const turnStartIndexes = conversationalMessages
-        .map((m, i) => (m.role === "user" ? i : -1))
+    const { leading, body } = splitLeadingContext(messages);
+    // Replace semantics: prior summaries (any form) are folded into the new
+    // summary as INPUT (the LLM merges them semantically) and removed.
+    const priorSummaries = body.filter(isCompactionSummaryMessage);
+    const bodyMessages = body.filter((m) => !isCompactionSummaryMessage(m));
+    const turnStartIndexes = bodyMessages
+        .map((m, i) => (isRealUserMessage(m) ? i : -1))
         .filter((i) => i >= 0);
     if (turnStartIndexes.length <= keepRecentTurns) {
         return { compacted: false };
@@ -56,11 +59,22 @@ export async function compactMessagesWithLLM(messages, options) {
     if (keepStartIndex <= 0) {
         return { compacted: false };
     }
-    const oldMessages = conversationalMessages.slice(0, keepStartIndex);
-    const keptMessages = conversationalMessages.slice(keepStartIndex);
+    const oldMessages = bodyMessages.slice(0, keepStartIndex);
+    const keptMessages = bodyMessages.slice(keepStartIndex);
+    // Pin the original instruction verbatim (P0.5: this path used to lack the
+    // pin the heuristic and llm-compactor paths already had).
+    const pinnedIndex = findFirstRealUserIndex(oldMessages);
+    const pinnedMessage = pinnedIndex >= 0 ? oldMessages[pinnedIndex] : undefined;
+    const summarizable = [
+        ...priorSummaries.map((m) => ({
+            role: "user",
+            content: `[Prior compaction summary]\n${typeof m.content === "string" ? m.content : ""}`,
+        })),
+        ...oldMessages.filter((_, index) => index !== pinnedIndex),
+    ];
     let summary;
     try {
-        summary = await generateSummary(oldMessages, options);
+        summary = await generateSummary(summarizable, options);
     }
     catch {
         return compactMessagesHeuristic(messages, { keepRecentTurns, maxSummaryItems: options.maxSummaryItems });
@@ -72,8 +86,9 @@ export async function compactMessagesWithLLM(messages, options) {
         compacted: true,
         summary,
         messages: [
-            ...preservedContextMessages,
-            { role: "system", content: `Previous conversation summary:\n${summary}` },
+            ...leading,
+            ...(pinnedMessage ? [clonePinnedUserMessage(pinnedMessage)] : []),
+            buildCompactionSummaryMessage(summary),
             ...keptMessages,
         ],
         droppedEntries: oldMessages.length,

package/dist/context/compact.d.ts

@@ -4,17 +4,41 @@ import type { SessionLogEntry } from "../session-types.js";
  * Compaction must never summarize away what the user actually asked for:
  * requirements that appear late in a long instruction ("commit when done",
  * "write the report in French") would otherwise vanish once the heuristic
- * summary truncates the goal line. Messages larger than this cap are exempt
- * from pinning (e.g. a pasted megabyte of logs as the opening message) —
- * summarization is the lesser evil there.
+ * summary truncates the goal line. Messages larger than this cap are pinned
+ * in truncated form (e.g. a pasted megabyte of logs as the opening message).
  */
 export declare const PINNED_INSTRUCTION_MAX_CHARS = 8192;
+export declare const COMPACTION_SUMMARY_PREFIX = "Previous conversation summary:";
+export declare const SUBTURN_SUMMARY_PREFIX = "Earlier in this turn (compacted to free context):";
 /**
- * Index of the first message the user actually wrote: user-role, not an
- * internal reminder/context block re-rolled into user role by the projector,
- * and small enough to keep verbatim.
+ * Identity check for compaction summaries across every form they can take:
+ * the first-class meta form, the legacy raw-system form, and the projected
+ * user-role internal-block forms (the resident path rewrites projections back
+ * into history, so role/position are not conserved).
  */
+export declare function isCompactionSummaryMessage(message: Message): boolean;
+/** A message the user actually typed (not a projected reminder, not a summary). */
+export declare function isRealUserMessage(message: Message): boolean;
+/**
+ * Split history into the leading system/meta context prefix (system prompt,
+ * startup reminders) and the conversational body. Positional, mirroring the
+ * projector's leading-prefix semantics: mid-history system/meta messages
+ * belong to the body and are foldable — preserving them by role forever is
+ * how stale reminders and relocated summaries used to pile up at the head.
+ */
+export declare function splitLeadingContext(messages: Message[]): {
+    leading: Message[];
+    body: Message[];
+};
+/** Index of the first message the user actually wrote. */
 export declare function findFirstRealUserIndex(messages: Message[]): number;
+/**
+ * Clone a message for pinning; oversized content is truncated rather than
+ * losing the pin entirely (P0.5: a truncated original beats a 140-char
+ * summary line).
+ */
+export declare function clonePinnedUserMessage(message: Message): Message;
+export declare function buildCompactionSummaryMessage(summary: string): Message;
 export interface CompactOptions {
     keepRecentTurns?: number;
     maxSummaryItems?: number;

package/dist/context/compact.js

@@ -3,12 +3,27 @@ import { isInternalBlockContent } from "../agent/internal-reminder-sanitizer.js"
  * Compaction must never summarize away what the user actually asked for:
  * requirements that appear late in a long instruction ("commit when done",
  * "write the report in French") would otherwise vanish once the heuristic
- * summary truncates the goal line. Messages larger than this cap are exempt
- * from pinning (e.g. a pasted megabyte of logs as the opening message) —
- * summarization is the lesser evil there.
+ * summary truncates the goal line. Messages larger than this cap are pinned
+ * in truncated form (e.g. a pasted megabyte of logs as the opening message).
  */
 export const PINNED_INSTRUCTION_MAX_CHARS = 8192;
-function userMessageText(message) {
+export const COMPACTION_SUMMARY_PREFIX = "Previous conversation summary:";
+export const SUBTURN_SUMMARY_PREFIX = "Earlier in this turn (compacted to free context):";
+// llm-compactor.ts's LLM_SUMMARY_PREFIX must start with this literal — a unit
+// test locks the two together (importing it here would create a module cycle).
+const LLM_ENVELOPE_PREFIX = "Another language model previously worked on this task";
+// Projected forms: the projector wraps meta messages into user-role internal
+// blocks, and the resident-history path writes that projected form back, so a
+// summary emitted as meta can come back around as one of these.
+const PROJECTED_SUMMARY_PREFIXES = [
+    `<bubble_internal_context kind="compaction-summary">`,
+    `<bubble_internal_context kind="subturn-compaction-summary">`,
+    // Legacy: summaries emitted as raw system messages by ≤0.0.42 got projected
+    // into runtime-system blocks.
+    `<bubble_internal_context kind="runtime-system">\n${COMPACTION_SUMMARY_PREFIX}`,
+    `<bubble_internal_context kind="runtime-system">\n${SUBTURN_SUMMARY_PREFIX}`,
+];
+function messageText(message) {
     if (typeof message.content === "string")
         return message.content;
     if (Array.isArray(message.content)) {
@@ -20,24 +35,86 @@ function userMessageText(message) {
     return "";
 }
 /**
- * Index of the first message the user actually wrote: user-role, not an
- * internal reminder/context block re-rolled into user role by the projector,
- * and small enough to keep verbatim.
+ * Identity check for compaction summaries across every form they can take:
+ * the first-class meta form, the legacy raw-system form, and the projected
+ * user-role internal-block forms (the resident path rewrites projections back
+ * into history, so role/position are not conserved).
  */
+export function isCompactionSummaryMessage(message) {
+    if (message.role === "meta") {
+        return message.kind === "compaction-summary" || message.kind === "subturn-compaction-summary";
+    }
+    const text = messageText(message);
+    if (message.role === "system") {
+        return text.startsWith(COMPACTION_SUMMARY_PREFIX) || text.startsWith(SUBTURN_SUMMARY_PREFIX);
+    }
+    if (message.role === "user") {
+        const trimmed = text.trimStart();
+        if (trimmed.startsWith(LLM_ENVELOPE_PREFIX))
+            return true;
+        return PROJECTED_SUMMARY_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
+    }
+    return false;
+}
+/** A message the user actually typed (not a projected reminder, not a summary). */
+export function isRealUserMessage(message) {
+    if (message.role !== "user")
+        return false;
+    const text = messageText(message);
+    if (!text.trim() || isInternalBlockContent(text))
+        return false;
+    if (text.trimStart().startsWith(LLM_ENVELOPE_PREFIX))
+        return false;
+    return true;
+}
+/**
+ * Split history into the leading system/meta context prefix (system prompt,
+ * startup reminders) and the conversational body. Positional, mirroring the
+ * projector's leading-prefix semantics: mid-history system/meta messages
+ * belong to the body and are foldable — preserving them by role forever is
+ * how stale reminders and relocated summaries used to pile up at the head.
+ */
+export function splitLeadingContext(messages) {
+    let split = 0;
+    while (split < messages.length) {
+        const message = messages[split];
+        if ((message.role === "system" || message.role === "meta") && !isCompactionSummaryMessage(message)) {
+            split += 1;
+            continue;
+        }
+        break;
+    }
+    return { leading: messages.slice(0, split), body: messages.slice(split) };
+}
+/** Index of the first message the user actually wrote. */
 export function findFirstRealUserIndex(messages) {
     for (let index = 0; index < messages.length; index++) {
-        const message = messages[index];
-        if (message.role !== "user")
-            continue;
-        const text = userMessageText(message);
-        if (!text.trim() || isInternalBlockContent(text))
-            continue;
-        if (text.length > PINNED_INSTRUCTION_MAX_CHARS)
-            return -1;
-        return index;
+        if (isRealUserMessage(messages[index]))
+            return index;
     }
     return -1;
 }
+/**
+ * Clone a message for pinning; oversized content is truncated rather than
+ * losing the pin entirely (P0.5: a truncated original beats a 140-char
+ * summary line).
+ */
+export function clonePinnedUserMessage(message) {
+    const text = messageText(message);
+    if (text.length <= PINNED_INSTRUCTION_MAX_CHARS)
+        return cloneMessage(message);
+    return {
+        role: "user",
+        content: `${text.slice(0, PINNED_INSTRUCTION_MAX_CHARS)}\n[...original message truncated for context management...]`,
+    };
+}
+export function buildCompactionSummaryMessage(summary) {
+    return {
+        role: "meta",
+        kind: "compaction-summary",
+        content: `${COMPACTION_SUMMARY_PREFIX}\n${summary}`,
+    };
+}
 export function planSessionCompaction(entries, options = {}) {
     const keepRecentTurns = options.keepRecentTurns ?? 2;
     const metadataEntries = entries.filter((entry) => entry.type === "metadata");
@@ -100,10 +177,17 @@ export function compactSessionEntries(entries, options = {}) {
 export function compactMessages(messages, options = {}) {
     const keepRecentTurns = options.keepRecentTurns ?? 2;
     const maxSummaryItems = options.maxSummaryItems ?? 4;
-    const preservedContextMessages = messages.filter((message) => message.role === "system" || message.role === "meta");
-    const conversationalMessages = messages.filter((message) => message.role !== "system" && message.role !== "meta");
-    const turnStartIndexes = conversationalMessages
-        .map((message, index) => (message.role === "user" ? index : -1))
+    // Replace semantics: prior summaries (any form, any position) die here —
+    // at most one summary exists after every compaction. Their content is
+    // template-grade (goal truncated to 140 chars, constant next-steps line);
+    // the pinned original instruction is the durable record, not old summaries.
+    const { leading, body } = splitLeadingContext(messages);
+    const bodyMessages = body.filter((message) => !isCompactionSummaryMessage(message));
+    // Turn boundaries anchor on REAL user messages only. Projected reminders
+    // and summary envelopes used to inflate the turn count, shrinking the keep
+    // window to nothing and firing compaction almost every turn.
+    const turnStartIndexes = bodyMessages
+        .map((message, index) => (isRealUserMessage(message) ? index : -1))
         .filter((index) => index >= 0);
     if (turnStartIndexes.length <= keepRecentTurns) {
         return { compacted: false };
@@ -112,26 +196,25 @@ export function compactMessages(messages, options = {}) {
     if (keepStartIndex <= 0) {
         return { compacted: false };
     }
-    const oldMessages = conversationalMessages.slice(0, keepStartIndex);
-    const keptMessages = conversationalMessages.slice(keepStartIndex);
+    const oldMessages = bodyMessages.slice(0, keepStartIndex);
+    const keptMessages = bodyMessages.slice(keepStartIndex);
     // Pin the original instruction: it stays verbatim above the summary instead
     // of being crushed into the summary's 140-char goal line.
     const pinnedIndex = findFirstRealUserIndex(oldMessages);
     const pinnedMessage = pinnedIndex >= 0 ? oldMessages[pinnedIndex] : undefined;
-    const summaryInput = pinnedIndex >= 0
-        ? oldMessages.filter((_, index) => index !== pinnedIndex)
-        : oldMessages;
+    // Summary fodder: real conversational content only — no pinned original,
+    // no projected reminder blocks (they used to pollute Goal/Progress lines).
+    const summaryInput = oldMessages.filter((message, index) => index !== pinnedIndex
+        && message.role !== "meta"
+        && !(message.role === "user" && !isRealUserMessage(message)));
     const summary = buildMessageSummary(summaryInput, maxSummaryItems);
     if (!summary) {
         return { compacted: false };
     }
     const compactedMessages = [
-        ...preservedContextMessages.map((message) => cloneMessage(message)),
-        ...(pinnedMessage ? [cloneMessage(pinnedMessage)] : []),
-        {
-            role: "system",
-            content: `Previous conversation summary:\n${summary}`,
-        },
+        ...leading.map((message) => cloneMessage(message)),
+        ...(pinnedMessage ? [clonePinnedUserMessage(pinnedMessage)] : []),
+        buildCompactionSummaryMessage(summary),
         ...keptMessages.map((message) => cloneMessage(message)),
     ];
     return {
@@ -144,11 +227,12 @@ export function compactMessages(messages, options = {}) {
 export function compactCurrentTurnToolGroups(messages, options = {}) {
     const keepRecentGroups = options.keepRecentGroups ?? 2;
     const maxSummaryItems = options.maxSummaryItems ?? 8;
-    const preserved = messages.filter((m) => m.role === "system" || m.role === "meta");
-    const body = messages.filter((m) => m.role !== "system" && m.role !== "meta");
+    const { leading, body } = splitLeadingContext(messages);
+    // Anchor the "current turn" on the last REAL user message — a projected
+    // reminder must not shrink the turn to a sliver.
     let lastUserIndex = -1;
     for (let i = body.length - 1; i >= 0; i--) {
-        if (body[i].role === "user") {
+        if (isRealUserMessage(body[i])) {
             lastUserIndex = i;
             break;
         }
@@ -156,7 +240,11 @@ export function compactCurrentTurnToolGroups(messages, options = {}) {
     if (lastUserIndex < 0)
         return { compacted: false };
     const preTurn = body.slice(0, lastUserIndex + 1);
-    const turnBody = body.slice(lastUserIndex + 1);
+    const rawTurnBody = body.slice(lastUserIndex + 1);
+    // Replace semantics within the turn: fold prior sub-turn summaries' lines
+    // into the new one instead of stacking marker messages.
+    const priorSubturnSummaries = rawTurnBody.filter((m) => m.role === "meta" ? m.kind === "subturn-compaction-summary" : isCompactionSummaryMessage(m) && messageText(m).includes(SUBTURN_SUMMARY_PREFIX.slice(0, 20)));
+    const turnBody = rawTurnBody.filter((m) => !priorSubturnSummaries.includes(m));
     const groups = [];
     let current = null;
     for (const msg of turnBody) {
@@ -179,9 +267,10 @@ export function compactCurrentTurnToolGroups(messages, options = {}) {
         .filter((g) => g.assistant.role === "assistant" && (g.assistant.toolCalls?.length ?? 0) > 0);
     if (evictable.length === 0)
         return { compacted: false };
-    const summary = buildToolGroupsSummary(evictable, maxSummaryItems);
-    if (!summary)
+    const freshSummary = buildToolGroupsSummary(evictable, maxSummaryItems);
+    if (!freshSummary)
         return { compacted: false };
+    const summary = mergeSubturnSummaryLines(priorSubturnSummaries, freshSummary, maxSummaryItems);
     const survivingGroups = groups.filter((g) => !evictable.includes(g));
     const flatSurvivors = [];
     for (const g of survivingGroups) {
@@ -190,11 +279,12 @@ export function compactCurrentTurnToolGroups(messages, options = {}) {
             flatSurvivors.push(cloneMessage(t));
     }
     const compactedMessages = [
-        ...preserved.map(cloneMessage),
+        ...leading.map(cloneMessage),
         ...preTurn.map(cloneMessage),
         {
-            role: "system",
-            content: `Earlier in this turn (compacted to free context):\n${summary}`,
+            role: "meta",
+            kind: "subturn-compaction-summary",
+            content: `${SUBTURN_SUMMARY_PREFIX}\n${summary}`,
         },
         ...flatSurvivors,
     ];
@@ -205,6 +295,35 @@ export function compactCurrentTurnToolGroups(messages, options = {}) {
         droppedEntries: evictable.length,
     };
 }
+/**
+ * Merge prior sub-turn summary lines with the fresh one: line-level dedupe,
+ * prior lines first (chronological), capped. Structured merge of tool-name /
+ * file lists — not freetext concatenation.
+ */
+function mergeSubturnSummaryLines(priorSummaries, freshSummary, maxItems) {
+    if (priorSummaries.length === 0)
+        return freshSummary;
+    const seen = new Set();
+    const merged = [];
+    const push = (line) => {
+        const normalized = line.trim();
+        if (!normalized || seen.has(normalized))
+            return;
+        seen.add(normalized);
+        merged.push(line);
+    };
+    for (const prior of priorSummaries) {
+        for (const line of messageText(prior).split("\n")) {
+            if (line.startsWith(SUBTURN_SUMMARY_PREFIX) || line.startsWith("<bubble_internal_"))
+                continue;
+            push(line);
+        }
+    }
+    for (const line of freshSummary.split("\n"))
+        push(line);
+    const cap = Math.max(maxItems * 4, 24);
+    return merged.slice(-cap).join("\n");
+}
 function buildToolGroupsSummary(groups, maxItems) {
     const toolCounts = new Map();
     const fileSet = new Set();

package/dist/context/llm-compactor.js

@@ -10,7 +10,7 @@
 // Failure modes are explicit: returns { compacted: false, reason } so the
 // caller can fall back to algorithmic compaction without an exception.
 import { estimateContextTokens } from "./budget.js";
-import { findFirstRealUserIndex } from "./compact.js";
+import { buildCompactionSummaryMessage, clonePinnedUserMessage, findFirstRealUserIndex, isCompactionSummaryMessage, isRealUserMessage, splitLeadingContext, } from "./compact.js";
 export const LLM_COMPACTION_PROMPT = `You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.
 
 Include:
@@ -25,11 +25,17 @@ export async function compactWithLLM(messages, options) {
     const { provider, modelId, abortSignal } = options;
     const maxInputTokens = options.maxInputTokens ?? 100_000;
     const keepRecentGroups = options.keepRecentGroups ?? 2;
-    const preserved = messages.filter((m) => m.role === "system" || m.role === "meta");
-    const body = messages.filter((m) => m.role !== "system" && m.role !== "meta");
+    // Positional leading prefix, not role-global filtering: filtering by role
+    // used to relocate mid-history system messages (including prior summaries)
+    // to the head, where the projector then fused them into the system prompt.
+    const { leading, body: rawBody } = splitLeadingContext(messages);
+    // Replace semantics: prior summaries become summarization INPUT (semantic
+    // rolling — the compactor model merges them), never preserved copies.
+    const priorSummaries = rawBody.filter(isCompactionSummaryMessage);
+    const body = rawBody.filter((m) => !isCompactionSummaryMessage(m));
     let lastUserIndex = -1;
     for (let i = body.length - 1; i >= 0; i--) {
-        if (body[i].role === "user") {
+        if (isRealUserMessage(body[i])) {
             lastUserIndex = i;
             break;
         }
@@ -73,10 +79,14 @@ export async function compactWithLLM(messages, options) {
     const keptGroupCount = Math.min(keepRecentGroups, groups.length);
     const evictedGroups = groups.slice(0, groups.length - keptGroupCount);
     const keptGroups = groups.slice(groups.length - keptGroupCount);
-    // What we'll send to the model to summarize: prior turns + the older groups
-    // in the current turn (everything we're about to evict). The pinned first
-    // instruction is excluded — it survives verbatim, not as summary fodder.
+    // What we'll send to the model to summarize: prior summaries (semantic
+    // rolling), prior turns, and the older groups in the current turn. The
+    // pinned first instruction is excluded — it survives verbatim.
     const toSummarize = [
+        ...priorSummaries.map((m) => ({
+            role: "user",
+            content: `[Prior compaction summary]\n${typeof m.content === "string" ? m.content : ""}`,
+        })),
         ...summarizablePriorTurns,
         ...evictedGroups.flatMap((g) => [g.assistant, ...g.toolResults]),
     ];
@@ -118,12 +128,9 @@ export async function compactWithLLM(messages, options) {
             flatKept.push(cloneMessage(t));
     }
     const compacted = [
-        ...preserved.map(cloneMessage),
-        ...(pinnedFirstUser ? [cloneMessage(pinnedFirstUser)] : []),
-        {
-            role: "user",
-            content: `${LLM_SUMMARY_PREFIX}\n${summaryText.trim()}`,
-        },
+        ...leading.map(cloneMessage),
+        ...(pinnedFirstUser ? [clonePinnedUserMessage(pinnedFirstUser)] : []),
+        buildCompactionSummaryMessage(`${LLM_SUMMARY_PREFIX}\n${summaryText.trim()}`),
         cloneMessage(lastUser),
         ...flatKept,
     ];

package/dist/context/projector.js

@@ -85,7 +85,13 @@ export function projectMessages(messages, options = {}) {
             if (!after.shouldCompact)
                 break;
         }
-        return repairToolCallChains(working);
+        // Compaction passes emit summaries as meta messages (first-class identity);
+        // the provider payload must stay provider-safe, so render them here the
+        // same way body meta messages are rendered above.
+        const providerSafe = working.map((message) => message.role === "meta"
+            ? { role: "user", content: formatMetaMessage(message) }
+            : message);
+        return repairToolCallChains(providerSafe);
     }
     return repaired;
 }

package/dist/orchestrator/default-hooks.js

@@ -4,7 +4,7 @@ import { EvidenceTracker } from "../agent/evidence-tracker.js";
 import { ExecutionGovernor } from "../agent/execution-governor.js";
 import { DiscoveryBarrier } from "../agent/discovery-barrier.js";
 import { arbitrateToolCall } from "../agent/tool-arbiter.js";
-import { buildEditRetryEscalationReminder, buildSmallTaskHint, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
+import { buildCompletionSelfCheckReminder, buildEditRetryEscalationReminder, buildSmallTaskHint, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
 import { largeImplementationTaskReminder, orchestrationRequestReminder, reminderForTaskType, userNamedModelReminder } from "../prompt/task-reminders.js";
 import { formatCoverageSummary, resolveWorkflowPhase } from "./workflow.js";
 import { resolve as resolvePath } from "node:path";
@@ -220,9 +220,33 @@ export function createDefaultHooks() {
                 }
                 // Verification reminders intentionally removed. See afterToolCall.
             },
-            afterTurn() {
+            afterTurn(ctx) {
                 // Verification force-continuation removed. The model decides whether
                 // verification is meaningful for the task, per the system prompt.
+                //
+                // Completion self-check gate: when a run that changed code is about
+                // to end (this hook only runs on final, no-tool-call turns), remind
+                // the model ONCE to re-read the original request before finishing.
+                // Unlike the removed verification gate it never repeats — the model
+                // is explicitly told a confirming final answer ends the run — so the
+                // "prove it" spiral that killed the old design cannot start.
+                if (ctx.state.completionGateFired)
+                    return;
+                if (!ctx.state.codeChanged)
+                    return;
+                // Tools are frozen: the model could not act on anything the check
+                // surfaces, so another turn is pure token burn.
+                if (ctx.state.forceTextOnlyReason)
+                    return;
+                // Subagents hand off to a parent that does its own closing pass, and
+                // worktree profiles explicitly forbid the very actions a completion
+                // check would suggest.
+                if (ctx.agent.role === "subagent")
+                    return;
+                ctx.state.completionGateFired = true;
+                ctx.state.forceContinuationReason = "completion_self_check";
+                ctx.queueReminder(buildCompletionSelfCheckReminder());
+                traceEvent("completion_gate_fired", { turnCount: ctx.state.turnCount });
             },
         },
     ];

package/dist/orchestrator/hooks.d.ts

@@ -16,6 +16,8 @@ export interface TurnHookState {
     forceTextOnlyReason?: string;
     forceContinuationReason?: string;
     codeChanged?: boolean;
+    /** Completion self-check gate already fired this run (fires at most once). */
+    completionGateFired?: boolean;
     smallTaskHintSent?: boolean;
     recentEditFailures?: string[];
     editNoMatchReminderPaths?: string[];

package/dist/print-output.d.ts

@@ -49,8 +49,11 @@ export declare class PrintRunCollector {
  */
 export interface PrintCompactionStats {
     resident: number;
+    subturn: number;
     llm: number;
     overflow: number;
+    /** Successful compaction computations incl. rejected rewrites (churn signal). */
+    fired: number;
     droppedMessages: number;
 }
 export declare function formatPrintJson(input: {

package/dist/prompt/reminders.d.ts

@@ -23,6 +23,7 @@ export declare function buildInvestigationReminder(): string;
 export declare function buildLoopWarningReminder(reason: string): string;
 export declare function buildSearchFreezeReminder(reason: string): string;
 export declare function buildExplorationFreezeReminder(reason: string): string;
+export declare function buildCompletionSelfCheckReminder(): string;
 export declare function buildToolFreezeReminder(reason: string): string;
 export declare function buildWorkflowPhaseReminder(input: {
     phase: "investigate" | "correlate" | "conclude";

package/dist/prompt/reminders.js

@@ -119,6 +119,13 @@ Choose one of:
 3. If files were already changed, run the narrowest meaningful verification or finish with the result.
 `);
 }
+export function buildCompletionSelfCheckReminder() {
+    return wrapInSystemReminder(`
+You appear to be finishing. Before giving your final answer, re-read the user's original request in this conversation and check whether any explicit requirement in it remains unfulfilled — including requirements about how the work should be delivered or reported, not only whether the implementation works.
+
+If something is missing, complete it now. If everything is done, give your final answer directly — do not repeat this check or re-verify work you have already verified.
+`);
+}
 export function buildToolFreezeReminder(reason) {
     return wrapInSystemReminder(`
 CRITICAL - MAXIMUM STEPS REACHED

package/dist/prompt/runtime.js

@@ -11,6 +11,7 @@ const defaultGuidelines = [
     "Prefer structured tools (glob, grep, read) over bash for search and inspection. Do not repeat a near-identical search or re-read the same file unless new evidence changes the question.",
     "If a tool fails, diagnose the error before switching tactics. Do not retry the identical call with identical arguments. After two equivalent failures, switch approach — re-read the file, use a different tool, rewrite the whole file with write, or ask the user.",
     "Before reporting a task complete, verify it works when verification is meaningful and cheap — run the existing test, execute the script, check the output. If no test exists, the change is purely declarative (static HTML/markdown/config), or running the code is not practical, state that explicitly rather than inventing a verification step. Do not write throwaway validation scripts to prove correctness; if there is no real check to run, report the change and stop.",
+    "Before declaring a task complete, re-read the user's original request and verify that every explicit requirement in it — about both the result and the process — has been fulfilled, not only that the implementation works.",
 ];
 export function buildRuntimePrompt(options = {}) {
     const guidelines = dedupe(defaultGuidelines, options.guidelines ?? []);

package/dist/tui-ink/display-history.js

@@ -157,7 +157,13 @@ const TURN_SUMMARY_PREFIX = /^Earlier in this turn \(compacted to free context\)
 export function latestCompactionSummary(agentMessages) {
     for (let index = agentMessages.length - 1; index >= 0; index--) {
         const message = agentMessages[index];
-        if (!message || message.role !== "system" || typeof message.content !== "string")
+        if (!message || typeof message.content !== "string")
+            continue;
+        // Summaries are meta messages since 0.0.43; raw system form is legacy.
+        const isSummaryCarrier = message.role === "system"
+            || (message.role === "meta"
+                && (message.kind === "compaction-summary" || message.kind === "subturn-compaction-summary"));
+        if (!isSummaryCarrier)
             continue;
         const previousMatch = message.content.match(PREVIOUS_SUMMARY_PREFIX);
         if (previousMatch?.[1]?.trim())

package/dist/types.d.ts

@@ -64,7 +64,7 @@ export interface SystemMessage {
     role: "system";
     content: string;
 }
-export type MetaMessageKind = "system-reminder" | "runtime-context";
+export type MetaMessageKind = "system-reminder" | "runtime-context" | "compaction-summary" | "subturn-compaction-summary";
 export interface MetaMessage {
     role: "meta";
     kind: MetaMessageKind;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {