@bubblebrain-ai/bubble 0.0.42 → 0.0.44

package/dist/agent/change-tracker.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Git-ground-truth change tracking for a single agent run.
+ *
+ * Tool-metadata bookkeeping (kind === "write" | "edit" | "patch") misses every
+ * other mutation channel: bash heredocs/sed -i, scripts, subagent worktree
+ * merges. Git sees them all. A baseline snapshot is taken at run start; the
+ * delta at completion time is the run's actual footprint.
+ *
+ * Everything here degrades to null outside a git repo or on any git error —
+ * callers fall back to metadata-based signals.
+ */
+export interface GitChangeBaseline {
+    /** Paths already dirty (or untracked) before the run started. */
+    dirtyAtStart: Set<string>;
+}
+export interface ModifiedExistingTest {
+    path: string;
+    deletedLines: number;
+}
+export interface RunChangeSummary {
+    /** Paths that became dirty during the run (not dirty at baseline). */
+    changedFiles: string[];
+    /**
+     * Pre-existing (tracked) test files that were modified during the run,
+     * with how many lines the working tree deletes from them vs HEAD. New test
+     * files created by the run are NOT listed — creating tests is not suspect.
+     */
+    modifiedExistingTests: ModifiedExistingTest[];
+}
+export declare function isTestFilePath(path: string): boolean;
+export declare function captureGitBaseline(cwd: string): Promise<GitChangeBaseline | null>;
+/**
+ * Diff the current working tree against the run-start baseline.
+ *
+ * Known honest limits: a file already dirty at baseline that the run edited
+ * further is not attributed to the run (indistinguishable without content
+ * snapshots), and deleted-line counts for such files would mix user and agent
+ * edits — so they are excluded entirely.
+ */
+export declare function detectRunChanges(cwd: string, baseline: GitChangeBaseline | null): Promise<RunChangeSummary | null>;

package/dist/agent/change-tracker.js

@@ -0,0 +1,89 @@
+/**
+ * Git-ground-truth change tracking for a single agent run.
+ *
+ * Tool-metadata bookkeeping (kind === "write" | "edit" | "patch") misses every
+ * other mutation channel: bash heredocs/sed -i, scripts, subagent worktree
+ * merges. Git sees them all. A baseline snapshot is taken at run start; the
+ * delta at completion time is the run's actual footprint.
+ *
+ * Everything here degrades to null outside a git repo or on any git error —
+ * callers fall back to metadata-based signals.
+ */
+import { execFile } from "node:child_process";
+const GIT_TIMEOUT_MS = 3_000;
+const TEST_PATH_PATTERN = /(^|\/)(tests?|__tests__|spec)(\/|$)|(\.|_|-)(test|tests|spec)\.[^/]+$|(^|\/)test_[^/]+$/i;
+export function isTestFilePath(path) {
+    return TEST_PATH_PATTERN.test(path);
+}
+function git(cwd, args) {
+    return new Promise((resolve) => {
+        execFile("git", args, { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: 8 * 1024 * 1024 }, (error, stdout) => {
+            resolve(error ? null : stdout);
+        });
+    });
+}
+/** `git status --porcelain -z` → set of paths with any dirty/untracked state. */
+async function dirtyPaths(cwd) {
+    const out = await git(cwd, ["status", "--porcelain", "-uall", "-z"]);
+    if (out === null)
+        return null;
+    const paths = new Set();
+    for (const entry of out.split("\0")) {
+        if (entry.length < 4)
+            continue;
+        // "XY path" (rename entries "XY new\0old" — the extra segment lacks the
+        // status prefix and is shorter than 4 chars only when degenerate; treat
+        // every segment with the status shape as an entry).
+        const path = entry.slice(3);
+        if (path)
+            paths.add(path);
+    }
+    return paths;
+}
+export async function captureGitBaseline(cwd) {
+    const dirty = await dirtyPaths(cwd);
+    if (dirty === null)
+        return null;
+    return { dirtyAtStart: dirty };
+}
+/**
+ * Diff the current working tree against the run-start baseline.
+ *
+ * Known honest limits: a file already dirty at baseline that the run edited
+ * further is not attributed to the run (indistinguishable without content
+ * snapshots), and deleted-line counts for such files would mix user and agent
+ * edits — so they are excluded entirely.
+ */
+export async function detectRunChanges(cwd, baseline) {
+    if (!baseline)
+        return null;
+    const dirtyNow = await dirtyPaths(cwd);
+    if (dirtyNow === null)
+        return null;
+    const changedFiles = [...dirtyNow].filter((path) => !baseline.dirtyAtStart.has(path)).sort();
+    if (changedFiles.length === 0) {
+        return { changedFiles, modifiedExistingTests: [] };
+    }
+    // Untracked paths are new files; only tracked files count as "existing".
+    const untrackedOut = await git(cwd, ["ls-files", "--others", "--exclude-standard", "-z"]);
+    const untracked = new Set((untrackedOut ?? "").split("\0").filter(Boolean));
+    const modifiedExistingTests = [];
+    const candidates = changedFiles.filter((path) => isTestFilePath(path) && !untracked.has(path));
+    if (candidates.length > 0) {
+        const numstat = await git(cwd, ["diff", "HEAD", "--numstat", "-z", "--", ...candidates]);
+        if (numstat !== null) {
+            // -z numstat entries: "added\tdeleted\tpath\0" (renames add a segment).
+            for (const entry of numstat.split("\0")) {
+                const parts = entry.split("\t");
+                if (parts.length < 3)
+                    continue;
+                const deleted = Number(parts[1]);
+                const path = parts[2];
+                if (!path || Number.isNaN(deleted))
+                    continue;
+                modifiedExistingTests.push({ path, deletedLines: deleted });
+            }
+        }
+    }
+    return { changedFiles, modifiedExistingTests };
+}

package/dist/agent/profiles.js

@@ -155,7 +155,7 @@ export function builtinAgentProfiles() {
                 "You are an implementer subagent working in your own isolated git worktree — the parent tree is never touched.",
                 "Your worktree forks from the last commit; changes the parent made after that commit are NOT present unless included in your briefing.",
                 "Make the smallest coherent edits that complete your assigned group. Stay strictly inside the file set you were given; if a needed change falls outside it, report that instead of editing.",
-                "Verify your changes narrowly (targeted tests or typecheck) when possible, and end with a concise summary of files changed and verification results — the parent reviews and applies your worktree.",
+                "Verify your changes when possible — run the affected module's existing tests, not only the cases you added — and end with a concise summary of files changed and verification results; the parent reviews and applies your worktree.",
             ].join("\n"),
         },
     ];

package/dist/agent.d.ts

@@ -261,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;
@@ -572,6 +573,10 @@ export class Agent {
                 // the redirected one.
                 hookState.exploredFiles?.clear();
                 hookState.largeTaskCheckpointDone = false;
+                // A steer is a new ask: the completion gate must be able to fire
+                // again for the follow-up's closing pass, or appended requirements
+                // never get a self-check (codeChanged stays — prior edits are real).
+                hookState.completionGateFired = false;
                 if (typeof input.content === "string" && input.content.trim()) {
                     hookState.taskType = classifyTask(input.content);
                 }
@@ -1002,6 +1007,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" });
@@ -1520,6 +1526,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 —
@@ -2551,23 +2558,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) {
@@ -2946,7 +2973,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/main.js

@@ -575,6 +575,26 @@ async function main() {
             // mode is byte-for-byte the previous behavior.
             const jsonOutput = args.outputFormat === "json";
             const collector = new PrintRunCollector();
+            // Harness-side change footprint (git ground truth) — printed by the
+            // harness so the run cannot omit or misstate what it touched.
+            const changeBaseline = jsonOutput
+                ? await (await import("./agent/change-tracker.js")).captureGitBaseline(args.cwd)
+                : null;
+            const collectChanges = async () => {
+                if (!changeBaseline)
+                    return undefined;
+                const { detectRunChanges } = await import("./agent/change-tracker.js");
+                const detected = await detectRunChanges(args.cwd, changeBaseline).catch(() => null);
+                if (!detected)
+                    return undefined;
+                return {
+                    changed_files: detected.changedFiles.length,
+                    modified_existing_tests: detected.modifiedExistingTests.map((t) => ({
+                        path: t.path,
+                        deleted_lines: t.deletedLines,
+                    })),
+                };
+            };
             const printSessionId = sessionManager
                 ? basename(sessionManager.getSessionFile())
                 : undefined;
@@ -617,6 +637,7 @@ async function main() {
                         summary: collector.summary(),
                         sessionId: printSessionId,
                         compaction: agent.getCompactionStats(),
+                        changes: await collectChanges(),
                     }) + "\n");
                 }
                 else {
@@ -633,6 +654,7 @@ async function main() {
                     summary: collector.summary(),
                     sessionId: printSessionId,
                     compaction: agent.getCompactionStats(),
+                    changes: await collectChanges(),
                 }) + "\n");
                 process.exitCode = 1;
             }

package/dist/orchestrator/default-hooks.js

@@ -6,6 +6,7 @@ import { DiscoveryBarrier } from "../agent/discovery-barrier.js";
 import { arbitrateToolCall } from "../agent/tool-arbiter.js";
 import { buildCompletionSelfCheckReminder, buildEditRetryEscalationReminder, buildSmallTaskHint, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
 import { largeImplementationTaskReminder, orchestrationRequestReminder, reminderForTaskType, userNamedModelReminder } from "../prompt/task-reminders.js";
+import { captureGitBaseline, detectRunChanges } from "../agent/change-tracker.js";
 import { formatCoverageSummary, resolveWorkflowPhase } from "./workflow.js";
 import { resolve as resolvePath } from "node:path";
 import { traceEvent } from "../debug-trace.js";
@@ -14,7 +15,13 @@ import { buildSubagentLifecycleReminder } from "../agent/subagent-lifecycle-remi
 export function createDefaultHooks() {
     return [
         {
-            beforeTurn(ctx) {
+            async beforeTurn(ctx) {
+                // Git ground truth for the completion gate: tool-metadata bookkeeping
+                // misses bash-written files and subagent worktree merges; a dirty-state
+                // baseline at run start makes the run's real footprint observable.
+                if (ctx.state.gitBaseline === undefined) {
+                    ctx.state.gitBaseline = await captureGitBaseline(ctx.cwd);
+                }
                 const taskType = classifyTask(ctx.input);
                 ctx.state.taskType = taskType;
                 ctx.state.governor = new ExecutionGovernor(taskType);
@@ -99,6 +106,7 @@ export function createDefaultHooks() {
         },
         {
             beforeToolCall(ctx) {
+                ctx.state.toolUsed = true;
                 const arbitration = arbitrateToolCall(ctx.toolCall);
                 const toolCall = { ...arbitration.toolCall, ...(arbitration.note ? { arbiterNote: arbitration.note } : {}) };
                 ctx.replaceToolCall(toolCall);
@@ -220,7 +228,7 @@ export function createDefaultHooks() {
                 }
                 // Verification reminders intentionally removed. See afterToolCall.
             },
-            afterTurn(ctx) {
+            async afterTurn(ctx) {
                 // Verification force-continuation removed. The model decides whether
                 // verification is meaningful for the task, per the system prompt.
                 //
@@ -232,21 +240,37 @@ export function createDefaultHooks() {
                 // "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.
+                // check would suggest. The parent's gate still covers their merged
+                // changes via the git baseline below.
                 if (ctx.agent.role === "subagent")
                     return;
+                // Change detection: tool metadata first (cheap), then git ground
+                // truth — which also catches bash-written files and subagent
+                // worktree merges. Gate only runs git when the run actually used
+                // tools, so external repo churn cannot hijack a pure Q&A turn.
+                let changes = null;
+                if (ctx.state.toolUsed && ctx.state.gitBaseline) {
+                    changes = await detectRunChanges(ctx.cwd, ctx.state.gitBaseline);
+                }
+                const changedSomething = !!ctx.state.codeChanged || (changes !== null && changes.changedFiles.length > 0);
+                if (!changedSomething)
+                    return;
                 ctx.state.completionGateFired = true;
                 ctx.state.forceContinuationReason = "completion_self_check";
-                ctx.queueReminder(buildCompletionSelfCheckReminder());
-                traceEvent("completion_gate_fired", { turnCount: ctx.state.turnCount });
+                ctx.queueReminder(buildCompletionSelfCheckReminder({
+                    modifiedExistingTests: changes?.modifiedExistingTests,
+                }));
+                traceEvent("completion_gate_fired", {
+                    turnCount: ctx.state.turnCount,
+                    changedFiles: changes?.changedFiles.length,
+                    modifiedExistingTests: changes?.modifiedExistingTests.length,
+                });
             },
         },
     ];

package/dist/orchestrator/hooks.d.ts

@@ -1,5 +1,6 @@
 import type { Agent } from "../agent.js";
 import type { ContentPart, ParsedToolCall, ToolRegistryEntry, ToolResult } from "../types.js";
+import type { GitChangeBaseline } from "../agent/change-tracker.js";
 import type { TaskType } from "../agent/task-classifier.js";
 import type { ExecutionGovernor } from "../agent/execution-governor.js";
 import type { EvidenceTracker } from "../agent/evidence-tracker.js";
@@ -18,6 +19,10 @@ export interface TurnHookState {
     codeChanged?: boolean;
     /** Completion self-check gate already fired this run (fires at most once). */
     completionGateFired?: boolean;
+    /** Git dirty-state snapshot at run start (null = not a git repo / git failed). */
+    gitBaseline?: GitChangeBaseline | null;
+    /** Any tool executed this run — guards git-change attribution for pure Q&A turns. */
+    toolUsed?: boolean;
     smallTaskHintSent?: boolean;
     recentEditFailures?: string[];
     editNoMatchReminderPaths?: string[];

package/dist/print-output.d.ts

@@ -42,6 +42,18 @@ export declare class PrintRunCollector {
     private addUsage;
     summary(): PrintRunSummary;
 }
+/**
+ * Harness-observed change footprint of the run (git ground truth). Printed
+ * by the harness, not the model — a run cannot omit or misstate what it
+ * touched ("no breaking changes" next to deleted test assertions).
+ */
+export interface PrintChangeSummary {
+    changed_files: number;
+    modified_existing_tests: Array<{
+        path: string;
+        deleted_lines: number;
+    }>;
+}
 /**
  * Per-path counts of context compactions during the run. Lets benchmark
  * harnesses correlate outcomes with "did the model ever lose sight of the
@@ -49,8 +61,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: {
@@ -58,10 +73,12 @@ export declare function formatPrintJson(input: {
     sessionId?: string;
     stopReason?: "end_turn" | "error" | "cancelled";
     compaction?: PrintCompactionStats;
+    changes?: PrintChangeSummary;
 }): string;
 export declare function formatPrintJsonError(input: {
     message: string;
     summary?: PrintRunSummary;
     sessionId?: string;
     compaction?: PrintCompactionStats;
+    changes?: PrintChangeSummary;
 }): string;

package/dist/print-output.js

@@ -84,6 +84,7 @@ export function formatPrintJson(input) {
         usage: input.summary.usage,
         usage_reported: input.summary.usage_reported,
         ...(input.compaction ? { compaction: input.compaction } : {}),
+        ...(input.changes ? { changes: input.changes } : {}),
     });
 }
 export function formatPrintJsonError(input) {
@@ -101,5 +102,6 @@ export function formatPrintJsonError(input) {
             }
             : {}),
         ...(input.compaction ? { compaction: input.compaction } : {}),
+        ...(input.changes ? { changes: input.changes } : {}),
     });
 }

package/dist/prompt/reminders.d.ts

@@ -23,7 +23,14 @@ 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 interface CompletionSelfCheckOptions {
+    /** Pre-existing test files this run modified, with deleted-line counts. */
+    modifiedExistingTests?: Array<{
+        path: string;
+        deletedLines: number;
+    }>;
+}
+export declare function buildCompletionSelfCheckReminder(options?: CompletionSelfCheckOptions): string;
 export declare function buildToolFreezeReminder(reason: string): string;
 export declare function buildWorkflowPhaseReminder(input: {
     phase: "investigate" | "correlate" | "conclude";

package/dist/prompt/reminders.js

@@ -116,15 +116,30 @@ You have enough context to act. Do not continue reading, searching, or delegatin
 Choose one of:
 1. Use edit/write to make the requested change.
 2. If no safe change can be made from the gathered context, explain the concrete blocker.
-3. If files were already changed, run the narrowest meaningful verification or finish with the result.
+3. If files were already changed, verify the change and run the affected module's existing tests, 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.
+export function buildCompletionSelfCheckReminder(options = {}) {
+    const sections = [];
+    const modifiedTests = options.modifiedExistingTests ?? [];
+    if (modifiedTests.length > 0) {
+        // Disclosure, not accusation: legitimate test updates (requirement
+        // changes, fixing a broken test, refactors) are normal engineering — the
+        // rule is that they must be declared, never silent. Confrontational
+        // wording risks a model rolling back a user-requested test update.
+        const listed = modifiedTests
+            .slice(0, 8)
+            .map((t) => `- ${t.path}${t.deletedLines > 0 ? ` (${t.deletedLines} line${t.deletedLines === 1 ? "" : "s"} removed)` : ""}`)
+            .join("\n");
+        sections.push(`This run modified pre-existing test files:
+${listed}${modifiedTests.length > 8 ? `\n- …and ${modifiedTests.length - 8} more` : ""}
+
+If a change you made caused an existing test to fail and you edited the test so the suite passes, restore the original behavior instead — weakening a test to make it pass is never acceptable. If the test changes are intentional (the request requires new expected behavior, or the test itself was wrong), keep them and state each modified test and the reason in your final summary.`);
+    }
+    sections.push(`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.
-`);
+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.`);
+    return wrapInSystemReminder(`\n${sections.join("\n\n")}\n`);
 }
 export function buildToolFreezeReminder(reason) {
     return wrapInSystemReminder(`

package/dist/prompt/task-reminders.js

@@ -24,7 +24,7 @@ Implementation workflow:
 - Do not stop at a proposal when the user asked for a change.
 - Inspect the relevant files first, then make the smallest coherent edit.
 - Keep unrelated files and behavior out of scope.
-- Run a narrow verification command or explain why it cannot be run.
+- Verify the change, then run the existing tests of the affected module — not only the cases you added — or explain why they cannot be run.
 `);
         case "code_review":
             return wrapInSystemReminder(`

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.42",
+  "version": "0.0.44",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {