@bubblebrain-ai/bubble 0.0.46 → 0.0.47

package/dist/context/compact-llm.js

@@ -6,7 +6,9 @@
  * message. Falls back to the heuristic `compactMessages` if the LLM call
  * fails.
  */
-import { buildCompactionSummaryMessage, clonePinnedUserMessage, compactMessages as compactMessagesHeuristic, findFirstRealUserIndex, isCompactionSummaryMessage, isRealUserMessage, splitLeadingContext, } from "./compact.js";
+import { buildCompactionSummaryMessage, clonePinnedUserMessage, collectCompactionFileOps, compactMessages as compactMessagesHeuristic, findFirstRealUserIndex, isCompactionSummaryMessage, isRealUserMessage, messageText, splitLeadingContext, } from "./compact.js";
+import { sanitizeInternalReminderBlocks } from "../agent/internal-reminder-sanitizer.js";
+import { appendFileBlocks, stripFileBlocks } from "./compaction-files.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
@@ -65,13 +67,16 @@ export async function compactMessagesWithLLM(messages, options) {
     // pin the heuristic and llm-compactor paths already had).
     const pinnedIndex = findFirstRealUserIndex(oldMessages);
     const pinnedMessage = pinnedIndex >= 0 ? oldMessages[pinnedIndex] : undefined;
+    // File blocks are stripped from prior summaries before summarization: the
+    // deterministic merge below owns the file lists end to end.
     const summarizable = [
         ...priorSummaries.map((m) => ({
             role: "user",
-            content: `[Prior compaction summary]\n${typeof m.content === "string" ? m.content : ""}`,
+            content: `[Prior compaction summary]\n${stripFileBlocks(messageText(m))}`,
         })),
         ...oldMessages.filter((_, index) => index !== pinnedIndex),
     ];
+    const fileOps = collectCompactionFileOps(oldMessages, priorSummaries);
     let summary;
     try {
         summary = await generateSummary(summarizable, options);
@@ -79,16 +84,20 @@ export async function compactMessagesWithLLM(messages, options) {
     catch {
         return compactMessagesHeuristic(messages, { keepRecentTurns, maxSummaryItems: options.maxSummaryItems });
     }
-    if (!summary.trim()) {
+    // Models quote their input, and the transcript can contain projected
+    // reminder blocks; this summary is persisted, so scrub markup first.
+    summary = sanitizeInternalReminderBlocks(summary).trim();
+    if (!summary) {
         return compactMessagesHeuristic(messages, { keepRecentTurns, maxSummaryItems: options.maxSummaryItems });
     }
+    const summaryWithFiles = appendFileBlocks(summary, fileOps);
     return {
         compacted: true,
-        summary,
+        summary: summaryWithFiles,
         messages: [
             ...leading,
             ...(pinnedMessage ? [clonePinnedUserMessage(pinnedMessage)] : []),
-            buildCompactionSummaryMessage(summary),
+            buildCompactionSummaryMessage(summaryWithFiles),
             ...keptMessages,
         ],
         droppedEntries: oldMessages.length,

package/dist/context/compact.d.ts

@@ -1,5 +1,6 @@
 import type { Message } from "../types.js";
 import type { SessionLogEntry } from "../session-types.js";
+import { type CompactionFileOps } from "./compaction-files.js";
 /**
  * Compaction must never summarize away what the user actually asked for:
  * requirements that appear late in a long instruction ("commit when done",
@@ -10,6 +11,7 @@ import type { SessionLogEntry } from "../session-types.js";
 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):";
+export declare function messageText(message: Message): string;
 /**
  * Identity check for compaction summaries across every form they can take:
  * the first-class meta form, the legacy raw-system form, and the projected
@@ -68,6 +70,13 @@ export type SessionCompactionPlan = {
     keptEntries: SessionLogEntry[];
 };
 export declare function planSessionCompaction(entries: SessionLogEntry[], options?: CompactOptions): SessionCompactionPlan;
+/**
+ * Cumulative file ops for a compaction: the blocks prior summaries carried,
+ * unioned with the ops found in the messages being evicted now. Every
+ * compaction path — LLM, heuristic, sub-turn, session-entry — must thread
+ * this through, or the "cumulative" record resets on that path.
+ */
+export declare function collectCompactionFileOps(evicted: Message[], priorSummaries: Message[]): CompactionFileOps;
 /**
  * Assemble the post-compaction entry list from a plan and a (possibly
  * LLM-generated) summary string. The summary entry is keyed off the full

package/dist/context/compact.js

@@ -1,4 +1,5 @@
-import { isInternalBlockContent } from "../agent/internal-reminder-sanitizer.js";
+import { isInternalBlockContent, sanitizeInternalReminderBlocks } from "../agent/internal-reminder-sanitizer.js";
+import { appendFileBlocks, extractFileOps, mergeFileOps, parseFileBlocks, stripFileBlocks, } from "./compaction-files.js";
 /**
  * Compaction must never summarize away what the user actually asked for:
  * requirements that appear late in a long instruction ("commit when done",
@@ -23,7 +24,7 @@ const PROJECTED_SUMMARY_PREFIXES = [
     `<bubble_internal_context kind="runtime-system">\n${COMPACTION_SUMMARY_PREFIX}`,
     `<bubble_internal_context kind="runtime-system">\n${SUBTURN_SUMMARY_PREFIX}`,
 ];
-function messageText(message) {
+export function messageText(message) {
     if (typeof message.content === "string")
         return message.content;
     if (Array.isArray(message.content)) {
@@ -139,6 +140,15 @@ export function planSessionCompaction(entries, options = {}) {
         keptEntries: activeEntries.slice(keepStartIndex),
     };
 }
+/**
+ * Cumulative file ops for a compaction: the blocks prior summaries carried,
+ * unioned with the ops found in the messages being evicted now. Every
+ * compaction path — LLM, heuristic, sub-turn, session-entry — must thread
+ * this through, or the "cumulative" record resets on that path.
+ */
+export function collectCompactionFileOps(evicted, priorSummaries) {
+    return mergeFileOps(...priorSummaries.map((message) => parseFileBlocks(messageText(message))), extractFileOps(evicted));
+}
 /**
  * Assemble the post-compaction entry list from a plan and a (possibly
  * LLM-generated) summary string. The summary entry is keyed off the full
@@ -148,7 +158,9 @@ export function buildCompactedEntries(entries, plan, summary) {
     const summaryEntry = {
         id: nextSummaryId(entries),
         type: "summary",
-        summary,
+        // Sink-level backstop: whatever producer built this string (LLM or
+        // heuristic), internal markup never lands in the session file.
+        summary: sanitizeInternalReminderBlocks(summary),
         timestamp: Date.now(),
     };
     return [...plan.metadataEntries, summaryEntry, ...plan.keptEntries];
@@ -167,10 +179,12 @@ export function compactSessionEntries(entries, options = {}) {
     if (!summary) {
         return { compacted: false };
     }
+    const oldMessages = entriesToMessages(plan.oldEntries);
+    const summaryWithFiles = appendFileBlocks(summary, collectCompactionFileOps(oldMessages.filter((message) => !isCompactionSummaryMessage(message)), oldMessages.filter(isCompactionSummaryMessage)));
     return {
         compacted: true,
-        summary,
-        entries: buildCompactedEntries(entries, plan, summary),
+        summary: summaryWithFiles,
+        entries: buildCompactedEntries(entries, plan, summaryWithFiles),
         droppedEntries: plan.oldEntries.length,
     };
 }
@@ -182,6 +196,7 @@ export function compactMessages(messages, options = {}) {
     // 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 priorSummaries = body.filter(isCompactionSummaryMessage);
     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
@@ -211,15 +226,16 @@ export function compactMessages(messages, options = {}) {
     if (!summary) {
         return { compacted: false };
     }
+    const summaryWithFiles = appendFileBlocks(summary, collectCompactionFileOps(oldMessages, priorSummaries));
     const compactedMessages = [
         ...leading.map((message) => cloneMessage(message)),
         ...(pinnedMessage ? [clonePinnedUserMessage(pinnedMessage)] : []),
-        buildCompactionSummaryMessage(summary),
+        buildCompactionSummaryMessage(summaryWithFiles),
         ...keptMessages.map((message) => cloneMessage(message)),
     ];
     return {
         compacted: true,
-        summary,
+        summary: summaryWithFiles,
         messages: compactedMessages,
         droppedEntries: summaryInput.length,
     };
@@ -271,6 +287,9 @@ export function compactCurrentTurnToolGroups(messages, options = {}) {
     if (!freshSummary)
         return { compacted: false };
     const summary = mergeSubturnSummaryLines(priorSubturnSummaries, freshSummary, maxSummaryItems);
+    // Evicted groups' file ops would otherwise vanish before any multi-turn
+    // compactor runs; blocks on the sub-turn summary get merged upward later.
+    const summaryWithFiles = appendFileBlocks(summary, collectCompactionFileOps(evictable.flatMap((g) => [g.assistant, ...g.toolResults]), priorSubturnSummaries));
     const survivingGroups = groups.filter((g) => !evictable.includes(g));
     const flatSurvivors = [];
     for (const g of survivingGroups) {
@@ -284,7 +303,7 @@ export function compactCurrentTurnToolGroups(messages, options = {}) {
         {
             role: "meta",
             kind: "subturn-compaction-summary",
-            content: `${SUBTURN_SUMMARY_PREFIX}\n${summary}`,
+            content: `${SUBTURN_SUMMARY_PREFIX}\n${summaryWithFiles}`,
         },
         ...flatSurvivors,
     ];
@@ -313,7 +332,9 @@ function mergeSubturnSummaryLines(priorSummaries, freshSummary, maxItems) {
         merged.push(line);
     };
     for (const prior of priorSummaries) {
-        for (const line of messageText(prior).split("\n")) {
+        // File blocks are merged structurally by collectCompactionFileOps, not as
+        // prose lines — strip them so paths don't leak into the line dedupe.
+        for (const line of stripFileBlocks(messageText(prior)).split("\n")) {
             if (line.startsWith(SUBTURN_SUMMARY_PREFIX) || line.startsWith("<bubble_internal_"))
                 continue;
             push(line);
@@ -397,7 +418,12 @@ function buildMessageSummary(messages, maxSummaryItems) {
     if (messages.length === 0) {
         return "";
     }
-    const userMessages = messages.filter((message) => message.role === "user");
+    // Internal blocks (goal kicks, task wakes, projected reminders) must not
+    // become the Goal/Progress lines: 140-char truncation would turn them into
+    // markup FRAGMENTS, which defeat the anchored display filters downstream.
+    const userMessages = messages.filter((message) => message.role === "user"
+        && typeof message.content === "string"
+        && !isInternalBlockContent(message.content));
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     const toolCalls = collectToolCalls(messages);
     const relevantFiles = collectRelevantFiles(toolCalls);

package/dist/context/compaction-files.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Cumulative file-operation tracking across compactions.
+ *
+ * The LLM summary handles semantics (progress, decisions, next steps); which
+ * files were touched is an enumerable fact the model reliably drops after a
+ * couple of rolling summaries. So it never goes through the model: at each
+ * compaction, deterministic code extracts file ops from the evicted messages,
+ * unions them with the lists the previous summary carried, and appends the
+ * result as structured blocks after the summary text.
+ *
+ * Robustness rules (each earned by a review finding):
+ * - appendFileBlocks sanitizes its input first, so a summary can never carry
+ *   two generations of blocks — or model-echoed tags — at once.
+ * - Only tool calls with a successful result count: a rejected or failed edit
+ *   must not report the file as modified.
+ * - Lists are capped; modified entries are the ones worth keeping complete.
+ * - Serialization is sorted and deduped so identical sets are identical bytes.
+ */
+import type { Message } from "../types.js";
+export interface CompactionFileOps {
+    read: string[];
+    modified: string[];
+}
+/**
+ * File ops mentioned by tool calls in the given (about-to-be-evicted)
+ * messages. A call only counts when its tool result is present and not an
+ * error — a rejected edit or failed read must not enter the record.
+ */
+export declare function extractFileOps(messages: Message[]): CompactionFileOps;
+/** Parse every block a previous compaction summary carried (empty when absent). */
+export declare function parseFileBlocks(text: string): CompactionFileOps;
+/**
+ * Remove all blocks AND stray tags, e.g. before feeding a prior summary back
+ * to the model. Whitespace is only reflowed when something was removed.
+ */
+export declare function stripFileBlocks(text: string): string;
+/** Union, deduped and sorted; a file that was ever modified never lists as read-only. */
+export declare function mergeFileOps(...ops: CompactionFileOps[]): CompactionFileOps;
+/**
+ * Append the blocks to a summary text. Sanitizes the summary first so the
+ * output always contains exactly one generation of blocks, even when the
+ * model echoed tags into its own prose. No-op when both lists are empty.
+ */
+export declare function appendFileBlocks(summary: string, ops: CompactionFileOps): string;

package/dist/context/compaction-files.js

@@ -0,0 +1,148 @@
+/**
+ * Cumulative file-operation tracking across compactions.
+ *
+ * The LLM summary handles semantics (progress, decisions, next steps); which
+ * files were touched is an enumerable fact the model reliably drops after a
+ * couple of rolling summaries. So it never goes through the model: at each
+ * compaction, deterministic code extracts file ops from the evicted messages,
+ * unions them with the lists the previous summary carried, and appends the
+ * result as structured blocks after the summary text.
+ *
+ * Robustness rules (each earned by a review finding):
+ * - appendFileBlocks sanitizes its input first, so a summary can never carry
+ *   two generations of blocks — or model-echoed tags — at once.
+ * - Only tool calls with a successful result count: a rejected or failed edit
+ *   must not report the file as modified.
+ * - Lists are capped; modified entries are the ones worth keeping complete.
+ * - Serialization is sorted and deduped so identical sets are identical bytes.
+ */
+const READ_TOOLS = new Set(["read"]);
+const MODIFY_TOOLS = new Set(["edit", "write"]);
+/** Cap per list. Modified is the higher-value list; both stay bounded. */
+const MAX_FILES_PER_LIST = 200;
+const MORE_MARKER = /^\(\+\d+ more\)$/;
+const READ_BLOCKS = /<read-files>[\s\S]*?<\/read-files>/g;
+const MODIFIED_BLOCKS = /<modified-files>[\s\S]*?<\/modified-files>/g;
+/** Stray (unpaired / model-echoed) tags left after full blocks are removed. */
+const STRAY_TAGS = /<\/?(?:read|modified)-files>/g;
+/**
+ * File ops mentioned by tool calls in the given (about-to-be-evicted)
+ * messages. A call only counts when its tool result is present and not an
+ * error — a rejected edit or failed read must not enter the record.
+ */
+export function extractFileOps(messages) {
+    const succeeded = new Set();
+    for (const message of messages) {
+        if (message.role === "tool" && !message.isError)
+            succeeded.add(message.toolCallId);
+    }
+    const read = new Set();
+    const modified = new Set();
+    for (const message of messages) {
+        if (message.role !== "assistant" || !message.toolCalls)
+            continue;
+        for (const toolCall of message.toolCalls) {
+            if (!succeeded.has(toolCall.id))
+                continue;
+            const target = READ_TOOLS.has(toolCall.name)
+                ? read
+                : MODIFY_TOOLS.has(toolCall.name)
+                    ? modified
+                    : undefined;
+            if (!target)
+                continue;
+            const path = pathFromArguments(toolCall.arguments);
+            if (path)
+                target.add(path);
+        }
+    }
+    return { read: [...read], modified: [...modified] };
+}
+/** Parse every block a previous compaction summary carried (empty when absent). */
+export function parseFileBlocks(text) {
+    return {
+        read: parseBlocks(text, READ_BLOCKS, "<read-files>", "</read-files>"),
+        modified: parseBlocks(text, MODIFIED_BLOCKS, "<modified-files>", "</modified-files>"),
+    };
+}
+/**
+ * Remove all blocks AND stray tags, e.g. before feeding a prior summary back
+ * to the model. Whitespace is only reflowed when something was removed.
+ */
+export function stripFileBlocks(text) {
+    const without = text.replace(READ_BLOCKS, "").replace(MODIFIED_BLOCKS, "").replace(STRAY_TAGS, "");
+    if (without === text)
+        return text;
+    return without.replace(/\n{3,}/g, "\n\n").trim();
+}
+/** Union, deduped and sorted; a file that was ever modified never lists as read-only. */
+export function mergeFileOps(...ops) {
+    const read = new Set();
+    const modified = new Set();
+    for (const op of ops) {
+        for (const path of op.modified)
+            modified.add(normalizePath(path));
+        for (const path of op.read)
+            read.add(normalizePath(path));
+    }
+    for (const path of modified)
+        read.delete(path);
+    return { read: [...read].sort(), modified: [...modified].sort() };
+}
+/**
+ * Append the blocks to a summary text. Sanitizes the summary first so the
+ * output always contains exactly one generation of blocks, even when the
+ * model echoed tags into its own prose. No-op when both lists are empty.
+ */
+export function appendFileBlocks(summary, ops) {
+    const clean = stripFileBlocks(summary);
+    const blocks = [];
+    if (ops.read.length > 0)
+        blocks.push(`<read-files>\n${capped(ops.read)}\n</read-files>`);
+    if (ops.modified.length > 0)
+        blocks.push(`<modified-files>\n${capped(ops.modified)}\n</modified-files>`);
+    if (blocks.length === 0)
+        return clean;
+    return `${clean.trimEnd()}\n\n${blocks.join("\n")}`;
+}
+function capped(paths) {
+    if (paths.length <= MAX_FILES_PER_LIST)
+        return paths.join("\n");
+    const kept = paths.slice(0, MAX_FILES_PER_LIST);
+    return `${kept.join("\n")}\n(+${paths.length - MAX_FILES_PER_LIST} more)`;
+}
+function parseBlocks(text, pattern, open, close) {
+    const out = new Set();
+    for (const match of text.match(pattern) ?? []) {
+        const inner = match.slice(open.length, match.length - close.length);
+        for (const line of inner.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed && !MORE_MARKER.test(trimmed))
+                out.add(trimmed);
+        }
+    }
+    return [...out];
+}
+/**
+ * Best-effort normalization so "./src/a.ts" and "src/a.ts" dedupe. Relative vs
+ * absolute spellings of the same file can still coexist — resolving that needs
+ * a cwd this layer doesn't have; models are consistent enough within a session
+ * that the union stays useful.
+ */
+function normalizePath(path) {
+    let out = path.trim().replace(/\/{2,}/g, "/");
+    while (out.startsWith("./"))
+        out = out.slice(2);
+    return out;
+}
+function pathFromArguments(rawArguments) {
+    if (!rawArguments)
+        return undefined;
+    try {
+        const parsed = JSON.parse(rawArguments);
+        return typeof parsed.path === "string" && parsed.path.trim() ? parsed.path.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/context/llm-compactor.js

@@ -9,8 +9,10 @@
 //
 // Failure modes are explicit: returns { compacted: false, reason } so the
 // caller can fall back to algorithmic compaction without an exception.
+import { sanitizeInternalReminderBlocks } from "../agent/internal-reminder-sanitizer.js";
 import { estimateContextTokens } from "./budget.js";
-import { buildCompactionSummaryMessage, clonePinnedUserMessage, findFirstRealUserIndex, isCompactionSummaryMessage, isRealUserMessage, splitLeadingContext, } from "./compact.js";
+import { appendFileBlocks, stripFileBlocks } from "./compaction-files.js";
+import { collectCompactionFileOps, messageText, 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:
@@ -81,15 +83,21 @@ export async function compactWithLLM(messages, options) {
     const keptGroups = groups.slice(groups.length - keptGroupCount);
     // 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.
+    // pinned first instruction is excluded — it survives verbatim. File blocks
+    // are stripped from prior summaries here: the deterministic merge below owns
+    // the file lists, and feeding them to the model only invites a lossy echo.
     const toSummarize = [
         ...priorSummaries.map((m) => ({
             role: "user",
-            content: `[Prior compaction summary]\n${typeof m.content === "string" ? m.content : ""}`,
+            content: `[Prior compaction summary]\n${stripFileBlocks(messageText(m))}`,
         })),
         ...summarizablePriorTurns,
         ...evictedGroups.flatMap((g) => [g.assistant, ...g.toolResults]),
     ];
+    // Cumulative file tracking (deterministic, never via the model): union the
+    // lists the prior summaries carried with the ops in what we're evicting now.
+    // Tool results ride along so failed/rejected calls don't count as touches.
+    const fileOps = collectCompactionFileOps([...summarizablePriorTurns, ...evictedGroups.flatMap((g) => [g.assistant, ...g.toolResults])], priorSummaries);
     if (toSummarize.length === 0) {
         return { compacted: false, reason: "nothing to evict" };
     }
@@ -113,6 +121,14 @@ export async function compactWithLLM(messages, options) {
     if (!summaryText || summaryText.trim().length === 0) {
         return { compacted: false, reason: "compactor returned empty summary" };
     }
+    // The summarizer's input transcript can contain projected reminder blocks
+    // (resident history holds them after pruned-mode projection), and models
+    // quote their input. This summary is persisted via onCompactionApplied, so
+    // scrub markup before it can reach the session file.
+    summaryText = sanitizeInternalReminderBlocks(summaryText).trim();
+    if (!summaryText) {
+        return { compacted: false, reason: "compactor returned only internal markup" };
+    }
     // New history shape (prefix-cache-friendly: preserved system+meta stay at the
     // absolute prefix unchanged; summary is injected after as a user-role envelope
     // so it can't pollute the cacheable system-prompt prefix):
@@ -130,13 +146,16 @@ export async function compactWithLLM(messages, options) {
     const compacted = [
         ...leading.map(cloneMessage),
         ...(pinnedFirstUser ? [clonePinnedUserMessage(pinnedFirstUser)] : []),
-        buildCompactionSummaryMessage(`${LLM_SUMMARY_PREFIX}\n${summaryText.trim()}`),
+        buildCompactionSummaryMessage(appendFileBlocks(`${LLM_SUMMARY_PREFIX}\n${summaryText}`, fileOps)),
         cloneMessage(lastUser),
         ...flatKept,
     ];
     return {
         compacted: true,
-        summary: summaryText,
+        // Same payload the resident message carries (minus the envelope prefix —
+        // session replay adds its own "Previous conversation summary:" header), so
+        // the persisted checkpoint matches the in-memory state, file blocks included.
+        summary: appendFileBlocks(summaryText, fileOps),
         messages: compacted,
     };
 }

package/dist/feishu/agent-host/run-driver.js

@@ -135,6 +135,9 @@ export class RunDriver {
                     recordMemoryCitations(session.cwd, message.content);
                 }
             },
+            onCompactionApplied: (summary) => {
+                session.manager.applyLLMCompaction(summary);
+            },
             onToolResult: (toolName, result) => {
                 if (toolName !== "skill" || result.isError)
                     return;

package/dist/feishu/serve.js

@@ -91,15 +91,19 @@ export async function serveFeishu(opts = {}) {
     if (mcpLoaded.servers.length > 0) {
         await mcpManager.start();
     }
-    const createProvider = (providerId, apiKey, baseURL, promptCacheKey) => createProviderInstance({
-        providerId,
-        apiKey,
-        baseURL,
-        promptCacheKey,
-        protocol: providerRegistry.getConfigured().find((provider) => provider.id === providerId)?.protocol,
-        openAICodexAuth: providerRegistry.createOpenAICodexAuthAdapter(providerId),
-        grokAuth: providerRegistry.createGrokAuthAdapter(providerId),
-    });
+    const createProvider = (providerId, apiKey, baseURL, promptCacheKey) => {
+        const profile = providerRegistry.getConfigured().find((provider) => provider.id === providerId);
+        return createProviderInstance({
+            providerId,
+            apiKey,
+            baseURL,
+            promptCacheKey,
+            protocol: profile?.protocol,
+            headers: profile?.headers,
+            openAICodexAuth: providerRegistry.createOpenAICodexAuthAdapter(providerId),
+            grokAuth: providerRegistry.createGrokAuthAdapter(providerId),
+        });
+    };
     const createProviderForRoute = async (route, promptCacheKey) => {
         const target = providerRegistry.getConfigured().find((p) => p.id === route.providerId);
         if (!target?.apiKey) {

package/dist/goal/tools.js

@@ -8,8 +8,8 @@
  * goal turn's prompt, so a get_goal call could only return what the model was
  * just told.
  */
-const UPDATE_GOAL_DESCRIPTION = `Update the active thread goal's status. Use this tool only to mark the goal achieved or genuinely blocked; it returns an error if there is no active goal.
-Set status to "complete" only when the objective has actually been achieved and no required work remains — never merely because the budget is nearly exhausted or you are stopping.
+const UPDATE_GOAL_DESCRIPTION = `Errors unless the user has set an active goal via /goal — do NOT call this to wrap up an ordinary turn; most sessions have no goal.
+Update the active thread goal's status. Set status to "complete" only when the objective has actually been achieved and no required work remains — never merely because the budget is nearly exhausted or you are stopping.
 Set status to "blocked" only when the same blocking condition has repeated for at least three consecutive goal turns (counting the original turn and automatic continuations) and you cannot make meaningful progress without user input or an external-state change. Do not use "blocked" because work is hard, slow, uncertain, or incomplete.
 You cannot pause, resume, or set a budget through this tool; those are controlled by the user.`;
 export function createGoalTools(store) {
@@ -29,7 +29,16 @@ export function createGoalTools(store) {
             additionalProperties: false,
         },
         effect: "unknown",
-        promptSnippet: "Mark the goal complete (objective achieved) or blocked (true impasse).",
+        // Goalless sessions must not see this tool AT ALL: a completion-marker
+        // in the function list gets spuriously called at turn end even by strong
+        // models at high effort (observed with gpt-5.6-sol) — wording does not
+        // beat the trained close-out-the-task prior. The enabled() gate removes
+        // it from the provider's tool list until a goal is active (re-evaluated
+        // every model call, so /goal mid-session takes effect immediately), and
+        // there is deliberately no promptSnippet since the static system prompt
+        // cannot track goal state. Goal turns inject full usage guidance
+        // separately (goal/prompts.ts), so the legitimate path loses nothing.
+        enabled: () => store.isActive(),
         async execute(args) {
             const goal = store.snapshot();
             if (!goal)

package/dist/main.js

@@ -94,20 +94,25 @@ async function main() {
             thinkingLevel: args.thinkingLevel,
             promptCacheKey: sessionPromptCacheKey,
             protocol: defaultProvider.protocol,
+            headers: defaultProvider.headers,
             openAICodexAuth: registry.createOpenAICodexAuthAdapter(defaultProvider.id),
             grokAuth: registry.createGrokAuthAdapter(defaultProvider.id),
         })
         : createUnavailableProvider(unavailableProviderMessage);
-    const createProvider = (providerId, apiKey, baseURL) => createProviderInstance({
-        providerId,
-        apiKey,
-        baseURL,
-        thinkingLevel: args.thinkingLevel,
-        promptCacheKey: sessionPromptCacheKey,
-        protocol: registry.getConfigured().find((provider) => provider.id === providerId)?.protocol,
-        openAICodexAuth: registry.createOpenAICodexAuthAdapter(providerId),
-        grokAuth: registry.createGrokAuthAdapter(providerId),
-    });
+    const createProvider = (providerId, apiKey, baseURL) => {
+        const profile = registry.getConfigured().find((provider) => provider.id === providerId);
+        return createProviderInstance({
+            providerId,
+            apiKey,
+            baseURL,
+            thinkingLevel: args.thinkingLevel,
+            promptCacheKey: sessionPromptCacheKey,
+            protocol: profile?.protocol,
+            headers: profile?.headers,
+            openAICodexAuth: registry.createOpenAICodexAuthAdapter(providerId),
+            grokAuth: registry.createGrokAuthAdapter(providerId),
+        });
+    };
     const createProviderForRoute = async (route) => {
         const providerId = route.providerId;
         if (!providerId) {
@@ -196,18 +201,13 @@ async function main() {
     for (const d of mcpLoaded.diagnostics) {
         console.error(chalk.yellow(`[mcp:${d.scope}] ${d.path}: ${d.message}`));
     }
-    const mcpManager = new McpManager({ servers: mcpLoaded.servers });
+    // Silent diagnostics: connect failures are captured per-server and shown by
+    // /mcp on demand. Printing them at startup (or mid-session, where stderr
+    // writes corrupt the Ink display) only duplicates that surface.
+    const mcpManager = new McpManager({ servers: mcpLoaded.servers, onDiagnostic: () => { } });
     let externalRuntime;
     if (mcpLoaded.servers.length > 0) {
         await mcpManager.start();
-        // Only surface failures at startup. Successful connections would push the
-        // welcome screen above the visible area on small terminals. /mcp shows the
-        // full status.
-        for (const state of mcpManager.getStates()) {
-            if (state.status.kind === "failed") {
-                console.error(chalk.yellow(`[mcp] ${state.name}: failed — ${state.status.error}`));
-            }
-        }
         tools.push(...mcpManager.getToolEntries());
     }
     // Expose MCP prompts as slash commands. Queried live at each lookup so
@@ -420,6 +420,11 @@ async function main() {
                 recordMemoryCitations(args.cwd, message.content);
             }
         },
+        // Auto-compaction summaries are meta messages (dropped above); persist the
+        // compacted state as a session summary entry so it survives resume.
+        onCompactionApplied: (summary) => {
+            sessionManager?.applyLLMCompaction(summary);
+        },
         onToolResult: (toolName, result) => {
             if (!sessionManager)
                 return;