@bubblebrain-ai/bubble 0.0.7 → 0.0.8

package/dist/agent.d.ts

@@ -2,12 +2,14 @@
  * Agent - The core decision loop.
  * It maintains message state, calls the LLM, executes tools, and auto-continues.
  */
+import { type ContextUsageSnapshot } from "./context/usage.js";
 import type { AgentEvent, ContentPart, PermissionMode, Message, Provider, ThinkingLevel, Todo, ToolResult, ToolRegistryEntry, ToolUpdate } from "./types.js";
 import { type TurnHooks } from "./orchestrator/hooks.js";
 import { BudgetLedger } from "./agent/budget-ledger.js";
 import { type AgentProfile, type SubagentRunResult } from "./agent/profiles.js";
 import { type SubagentThreadSnapshot } from "./agent/subagent-control.js";
 import type { SkillSummary } from "./skills/types.js";
+import type { FileStateTracker } from "./tools/file-state.js";
 export declare class AgentAbortError extends Error {
     constructor(message?: string);
 }
@@ -39,6 +41,7 @@ export interface AgentOptions {
     };
     skills?: SkillSummary[];
     memoryPrompt?: string;
+    fileStateTracker?: FileStateTracker;
 }
 export declare class Agent {
     messages: Message[];
@@ -65,6 +68,7 @@ export declare class Agent {
     private budgetSource;
     private skillSummaries;
     private memoryPrompt?;
+    private fileStateTracker?;
     private subagentThreads;
     private pendingSubagentUpdates;
     private lastInputTokens;
@@ -74,8 +78,10 @@ export declare class Agent {
     unlockDeferredTools(names: string[]): void;
     /** All deferred tools in this session (for tool_search to inspect). */
     listDeferredTools(): ToolRegistryEntry[];
+    getContextUsageSnapshot(): ContextUsageSnapshot;
     /** Whether a given tool is deferred and not yet unlocked. */
     isDeferredAndLocked(name: string): boolean;
+    private getActiveToolEntries;
     injectSystemReminder(content: string): void;
     injectModeReminder(): void;
     get model(): string;

package/dist/agent.js

@@ -6,6 +6,7 @@ import { compactMessages } from "./context/compact.js";
 import { randomUUID } from "node:crypto";
 import { compactMessagesWithLLM } from "./context/compact-llm.js";
 import { getContextBudget } from "./context/budget.js";
+import { buildContextUsageSnapshot } from "./context/usage.js";
 import { isContextOverflowError } from "./context/overflow.js";
 import { projectMessages } from "./context/projector.js";
 import { aggressivePruneMessages } from "./context/prune.js";
@@ -18,6 +19,7 @@ import { assignAgentNickname, builtinAgentProfiles, mergeUsage, selectToolsForAg
 import { snapshotSubagentThread, subagentResultFromThread } from "./agent/subagent-control.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { isOnlyProviderProtocolArtifacts, stripProviderProtocolArtifacts } from "./provider-artifacts.js";
+import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
 const MAX_CONSECUTIVE_OVERFLOW_RECOVERIES = 3;
 const RESIDENT_HISTORY_KEEP_RECENT_TURNS = 3;
 const RESIDENT_HISTORY_MESSAGE_LIMIT = 160;
@@ -56,6 +58,7 @@ export class Agent {
     budgetSource;
     skillSummaries;
     memoryPrompt;
+    fileStateTracker;
     subagentThreads = new Map();
     pendingSubagentUpdates = [];
     lastInputTokens = null;
@@ -80,6 +83,7 @@ export class Agent {
         this.budgetSource = options.budgetSource ?? { runId: this.sessionID ?? "agent" };
         this.skillSummaries = options.skills ?? [];
         this.memoryPrompt = options.memoryPrompt;
+        this.fileStateTracker = options.fileStateTracker;
         if (options.systemPrompt) {
             this.messages.push({ role: "system", content: options.systemPrompt });
         }
@@ -111,11 +115,26 @@ export class Agent {
     listDeferredTools() {
         return [...this.tools.values()].filter((t) => t.deferred);
     }
+    getContextUsageSnapshot() {
+        return buildContextUsageSnapshot({
+            providerId: this.providerId,
+            modelId: this.apiModel,
+            messages: this.messages,
+            toolEntries: this.getActiveToolEntries(),
+            deferredToolEntries: this.listDeferredTools(),
+            skills: this.skillSummaries,
+        });
+    }
     /** Whether a given tool is deferred and not yet unlocked. */
     isDeferredAndLocked(name) {
         const tool = this.tools.get(name);
         return !!tool?.deferred && !this.unlockedDeferred.has(name);
     }
+    getActiveToolEntries() {
+        return [...this.tools.values()]
+            .filter((tool) => !tool.deferred || this.unlockedDeferred.has(tool.name))
+            .filter((tool) => this._mode === "plan" || tool.name !== "exit_plan_mode");
+    }
     injectSystemReminder(content) {
         this.appendMessage({ role: "meta", kind: "system-reminder", content });
     }
@@ -320,6 +339,15 @@ export class Agent {
                             yield { type: "text_delta", content: chunk.content };
                             break;
                         case "reasoning_delta":
+                            debugReasoningStream({
+                                stage: "agent_receive",
+                                providerId: this._providerId,
+                                modelId: this.apiModel,
+                                turnStep: step,
+                                beforeLength: assistantMsg.reasoning?.length ?? 0,
+                                delta: summarizeDebugText(chunk.content),
+                                afterLength: (assistantMsg.reasoning?.length ?? 0) + chunk.content.length,
+                            });
                             assistantMsg.reasoning = (assistantMsg.reasoning || "") + chunk.content;
                             yield { type: "reasoning_delta", content: chunk.content };
                             break;
@@ -533,7 +561,7 @@ export class Agent {
                     },
                 });
                 flushGovernorReminders();
-                yield { type: "turn_end", usage: turnUsage };
+                yield { type: "turn_end", usage: turnUsage, willContinue: true };
                 // Auto-continue: if we have tool results, the LLM needs to respond to them.
                 // Emitting the turn boundary keeps UI renderers aligned with the persisted
                 // assistant/tool message sequence instead of merging the next answer into
@@ -549,8 +577,9 @@ export class Agent {
                 flushReminders: flushGovernorReminders,
             });
             flushGovernorReminders();
-            yield { type: "turn_end", usage: turnUsage };
-            if (hookState.forceContinuationReason) {
+            const willContinue = !!hookState.forceContinuationReason;
+            yield { type: "turn_end", usage: turnUsage, willContinue };
+            if (willContinue) {
                 delete hookState.forceContinuationReason;
                 continue;
             }
@@ -569,6 +598,7 @@ export class Agent {
             if (afterTokens < beforeTokens) {
                 this.lastInputTokens = null;
                 this.lastAnchorMessageCount = null;
+                this.fileStateTracker?.invalidateReadHistory();
                 return before - this.messages.length;
             }
         }
@@ -583,6 +613,7 @@ export class Agent {
             this.messages = llmResult.messages;
             this.lastInputTokens = null;
             this.lastAnchorMessageCount = null;
+            this.fileStateTracker?.invalidateReadHistory();
             return before - this.messages.length;
         }
         const fallback = compactMessages(this.messages, { keepRecentTurns });
@@ -590,6 +621,7 @@ export class Agent {
             this.messages = fallback.messages;
             this.lastInputTokens = null;
             this.lastAnchorMessageCount = null;
+            this.fileStateTracker?.invalidateReadHistory();
             return before - this.messages.length;
         }
         return 0;
@@ -1056,6 +1088,7 @@ export class Agent {
             this.messages = candidate;
             this.lastInputTokens = null;
             this.lastAnchorMessageCount = null;
+            this.fileStateTracker?.invalidateReadHistory();
         }
     }
     appendMessage(message) {

package/dist/context/budget.d.ts

@@ -19,3 +19,4 @@ export interface ContextBudgetOptions {
 export declare function estimateMessageTokens(message: Message): number;
 export declare function estimateContextTokens(messages: Message[]): number;
 export declare function getContextBudget(providerId: string, modelId: string, messages: Message[], options?: ContextBudgetOptions): ContextBudget;
+export declare function estimateTextTokens(text: string): number;

package/dist/context/budget.js

@@ -65,7 +65,7 @@ function shouldTriggerCompact(estimatedTokens, contextWindow) {
         : contextWindow * 0.75;
     return estimatedTokens >= threshold;
 }
-function estimateTextTokens(text) {
+export function estimateTextTokens(text) {
     if (!text) {
         return 0;
     }

package/dist/context/usage.d.ts

@@ -0,0 +1,34 @@
+import type { SkillSummary } from "../skills/types.js";
+import type { Message, ToolRegistryEntry } from "../types.js";
+export interface ContextUsageBucket {
+    label: string;
+    tokens: number;
+    detail?: string;
+}
+export interface ContextUsageSnapshot {
+    providerId: string;
+    modelId: string;
+    contextWindow?: number;
+    usedTokens: number;
+    freeTokens?: number;
+    buckets: {
+        systemPrompt: ContextUsageBucket;
+        tools: ContextUsageBucket;
+        skills: ContextUsageBucket;
+        deferredTools: ContextUsageBucket;
+        other: ContextUsageBucket;
+    };
+    toolCount: number;
+    deferredToolCount: number;
+    skillCount: number;
+    messageCount: number;
+}
+export declare function buildContextUsageSnapshot(input: {
+    providerId: string;
+    modelId: string;
+    messages: Message[];
+    toolEntries: ToolRegistryEntry[];
+    deferredToolEntries?: ToolRegistryEntry[];
+    skills: SkillSummary[];
+}): ContextUsageSnapshot;
+export declare function formatContextUsage(snapshot: ContextUsageSnapshot): string;

package/dist/context/usage.js

@@ -0,0 +1,213 @@
+import { getModelContextWindow } from "../model-catalog.js";
+import { formatSkillsPrompt } from "../skills/format.js";
+import { buildDeferredToolsReminder } from "../prompt/reminders.js";
+import { AUTOCOMPACT_BUFFER_TOKENS, estimateMessageTokens, estimateTextTokens, MIN_WINDOW_FOR_RESERVE, OUTPUT_RESERVE_TOKENS, } from "./budget.js";
+export function buildContextUsageSnapshot(input) {
+    const systemMessages = input.messages.filter((message) => message.role === "system");
+    const otherMessages = input.messages.filter((message) => message.role !== "system");
+    const deferredToolEntries = input.deferredToolEntries ?? [];
+    const systemContent = systemMessages.map((message) => message.content).join("\n\n");
+    const skillsPrompt = formatSkillsPrompt(input.skills);
+    const skillsInSystemPrompt = !!skillsPrompt && systemContent.includes(skillsPrompt);
+    const skillsTokens = skillsInSystemPrompt ? estimateTextTokens(skillsPrompt) : 0;
+    const systemPromptTokens = Math.max(0, estimateTextTokens(systemContent) - skillsTokens);
+    const toolsTokens = estimateToolEntriesTokens(input.toolEntries);
+    const deferredToolsTokens = estimateDeferredToolsReminderTokens(deferredToolEntries);
+    const rawOtherTokens = otherMessages.reduce((sum, message) => sum + estimateMessageTokens(message), 0);
+    const otherTokens = Math.max(0, rawOtherTokens - deferredToolsTokens);
+    const usedTokens = systemPromptTokens + toolsTokens + skillsTokens + deferredToolsTokens + otherTokens;
+    const contextWindow = getModelContextWindow(input.providerId, input.modelId);
+    return {
+        providerId: input.providerId,
+        modelId: input.modelId,
+        contextWindow,
+        usedTokens,
+        freeTokens: contextWindow === undefined ? undefined : Math.max(0, contextWindow - usedTokens),
+        buckets: {
+            systemPrompt: {
+                label: "System prompt",
+                tokens: systemPromptTokens,
+                detail: systemMessages.length > 0 ? `${systemMessages.length} system message${systemMessages.length === 1 ? "" : "s"}` : "none",
+            },
+            tools: {
+                label: "Tools",
+                tokens: toolsTokens,
+                detail: input.toolEntries.length > 0 ? `${input.toolEntries.length} active schema${input.toolEntries.length === 1 ? "" : "s"}` : "none",
+            },
+            skills: {
+                label: "Skills",
+                tokens: skillsTokens,
+                detail: skillsInSystemPrompt && input.skills.length > 0 ? `${input.skills.length} advertised skill${input.skills.length === 1 ? "" : "s"}` : "none in current prompt",
+            },
+            deferredTools: {
+                label: "Deferred/MCP",
+                tokens: deferredToolsTokens,
+                detail: deferredToolEntries.length > 0
+                    ? `${deferredToolEntries.length} deferred tool name${deferredToolEntries.length === 1 ? "" : "s"} in reminder`
+                    : "none",
+            },
+            other: {
+                label: "Other",
+                tokens: otherTokens,
+                detail: otherMessages.length > 0 ? `${otherMessages.length} conversation/meta/tool message${otherMessages.length === 1 ? "" : "s"}` : "none",
+            },
+        },
+        toolCount: input.toolEntries.length,
+        deferredToolCount: deferredToolEntries.length,
+        skillCount: skillsInSystemPrompt ? input.skills.length : 0,
+        messageCount: input.messages.length,
+    };
+}
+export function formatContextUsage(snapshot) {
+    const freeTokens = snapshot.freeTokens ?? 0;
+    const rows = [
+        { key: "system", marker: "█", color: ANSI_ORANGE, bucket: snapshot.buckets.systemPrompt },
+        { key: "tools", marker: "▓", color: ANSI_TEAL, bucket: snapshot.buckets.tools },
+        { key: "skills", marker: "▒", color: ANSI_PURPLE, bucket: snapshot.buckets.skills },
+        { key: "deferred", marker: "◆", color: ANSI_BLUE, bucket: snapshot.buckets.deferredTools },
+        { key: "other", marker: "▪", color: ANSI_GRAY, bucket: snapshot.buckets.other },
+    ];
+    const freeRow = {
+        key: "free",
+        marker: "░",
+        color: ANSI_DARK_GRAY,
+        bucket: {
+            label: "Free space",
+            tokens: freeTokens,
+            detail: snapshot.freeTokens === undefined ? "unknown window" : "available before context limit",
+        },
+    };
+    const barRows = snapshot.contextWindow === undefined ? rows : [...rows, freeRow];
+    const barTotal = snapshot.contextWindow ?? Math.max(1, snapshot.usedTokens);
+    const compactAt = snapshot.contextWindow === undefined
+        ? "unknown"
+        : formatTokens(compactionThreshold(snapshot.contextWindow));
+    const lines = [
+        colorize("• Context Usage", ANSI_BOLD),
+        `${colorize(snapshot.providerId || "unknown", ANSI_TEAL)}:${snapshot.modelId || "unknown"} · ${formatUsedWindow(snapshot)} · compaction at ${compactAt}`,
+        `Free space: ${snapshot.freeTokens === undefined ? "unknown" : colorize(`${formatTokens(snapshot.freeTokens)} (${formatPercent(snapshot.freeTokens, snapshot.contextWindow)})`, ANSI_DARK_GRAY)}`,
+        "",
+        buildSegmentedBar(barRows, barTotal),
+        "",
+        colorize("Estimated usage by category", ANSI_BOLD),
+        ...rows.map((row) => formatBucket(row.marker, row.bucket, snapshot.contextWindow)),
+        formatBucket(freeRow.marker, freeRow.bucket, snapshot.contextWindow),
+        "",
+        "Note: estimates include resident messages and active tool schemas; provider tokenization and hidden overhead can differ.",
+    ];
+    return lines.join("\n");
+}
+function estimateToolEntriesTokens(entries) {
+    return entries.reduce((sum, entry) => {
+        const payload = JSON.stringify({
+            name: entry.name,
+            description: entry.description,
+            parameters: entry.parameters,
+        });
+        return sum + estimateTextTokens(payload) + 8;
+    }, 0);
+}
+function estimateDeferredToolsReminderTokens(entries) {
+    if (entries.length === 0)
+        return 0;
+    return estimateTextTokens(buildDeferredToolsReminder(entries.map((entry) => entry.name)));
+}
+function buildSegmentedBar(rows, totalTokens) {
+    const width = 54;
+    if (rows.every((row) => row.bucket.tokens <= 0)) {
+        return "░".repeat(width);
+    }
+    const safeTotal = Math.max(1, totalTokens);
+    const rawSegments = rows.map((row) => {
+        const exact = (Math.max(0, row.bucket.tokens) / safeTotal) * width;
+        const minWidth = row.marker !== "░" && row.bucket.tokens > 0 ? 1 : 0;
+        return { ...row, exact, width: minWidth };
+    });
+    let assigned = rawSegments.reduce((sum, segment) => sum + segment.width, 0);
+    while (assigned < width && rawSegments.length > 0) {
+        const segment = rawSegments.reduce((best, item) => {
+            const itemDeficit = item.exact - item.width;
+            const bestDeficit = best.exact - best.width;
+            return itemDeficit > bestDeficit ? item : best;
+        }, rawSegments[0]);
+        segment.width += 1;
+        assigned += 1;
+    }
+    while (assigned > width) {
+        const segment = rawSegments
+            .filter((item) => item.width > 0)
+            .sort((a, b) => b.width - a.width)[0];
+        if (!segment)
+            break;
+        segment.width -= 1;
+        assigned -= 1;
+    }
+    return rawSegments.map((segment) => colorize(segment.marker.repeat(segment.width), segment.color)).join("");
+}
+function formatBucket(marker, bucket, contextWindow) {
+    const label = bucket.label.padEnd(13, " ");
+    const count = contextWindow === undefined && bucket.label === "Free space"
+        ? "unknown".padStart(14, " ")
+        : formatTokens(bucket.tokens).padStart(14, " ");
+    const percent = contextWindow === undefined ? "" : ` ${formatPercent(bucket.tokens, contextWindow).padStart(7, " ")}`;
+    const color = colorForLabel(bucket.label);
+    return `${colorize(marker, color)} ${colorize(label, color)} ${count}${percent}  ${bucket.detail ?? "unknown"}`;
+}
+function formatPercent(tokens, contextWindow) {
+    if (!contextWindow || contextWindow <= 0)
+        return "";
+    const percent = (tokens / contextWindow) * 100;
+    if (percent > 0 && percent < 0.1)
+        return "<0.1%";
+    return `${percent.toFixed(1)}%`;
+}
+function formatUsedWindow(snapshot) {
+    if (snapshot.contextWindow === undefined)
+        return `~${formatTokens(snapshot.usedTokens)} used`;
+    return `${formatTokenNumber(snapshot.usedTokens)}/${formatTokenNumber(snapshot.contextWindow)} tokens (${formatPercent(snapshot.usedTokens, snapshot.contextWindow)})`;
+}
+function compactionThreshold(contextWindow) {
+    if (contextWindow >= MIN_WINDOW_FOR_RESERVE) {
+        return Math.max(0, contextWindow - OUTPUT_RESERVE_TOKENS - AUTOCOMPACT_BUFFER_TOKENS);
+    }
+    return Math.floor(contextWindow * 0.75);
+}
+function formatTokens(count) {
+    return `${formatTokenNumber(count)} tokens`;
+}
+function formatTokenNumber(count) {
+    if (count < 1000)
+        return `${Math.round(count)}`;
+    if (count < 1_000_000)
+        return `${formatFixed(count / 1000)}K`;
+    return `${formatFixed(count / 1_000_000)}M`;
+}
+function formatFixed(value) {
+    return value >= 10 ? value.toFixed(0) : value.toFixed(1);
+}
+const ANSI_RESET = "\u001b[0m";
+const ANSI_BOLD = "\u001b[1m";
+const ANSI_ORANGE = "\u001b[38;5;208m";
+const ANSI_TEAL = "\u001b[38;5;73m";
+const ANSI_PURPLE = "\u001b[38;5;141m";
+const ANSI_BLUE = "\u001b[38;5;75m";
+const ANSI_GRAY = "\u001b[38;5;245m";
+const ANSI_DARK_GRAY = "\u001b[38;5;240m";
+function colorize(text, color) {
+    if (!text)
+        return text;
+    return `${color}${text}${ANSI_RESET}`;
+}
+function colorForLabel(label) {
+    if (label === "System prompt")
+        return ANSI_ORANGE;
+    if (label === "Tools")
+        return ANSI_TEAL;
+    if (label === "Skills")
+        return ANSI_PURPLE;
+    if (label === "Deferred/MCP")
+        return ANSI_BLUE;
+    if (label === "Free space")
+        return ANSI_DARK_GRAY;
+    return ANSI_GRAY;
+}

package/dist/diff-stats.d.ts

@@ -0,0 +1,5 @@
+export interface DiffChangeStats {
+    added: number;
+    removed: number;
+}
+export declare function countUnifiedDiffChanges(diff: string): DiffChangeStats;

package/dist/diff-stats.js

@@ -0,0 +1,21 @@
+export function countUnifiedDiffChanges(diff) {
+    let added = 0;
+    let removed = 0;
+    for (const line of diff.replace(/\r\n/g, "\n").split("\n")) {
+        if (isUnifiedDiffMetadataLine(line))
+            continue;
+        if (line.startsWith("+"))
+            added++;
+        else if (line.startsWith("-"))
+            removed++;
+    }
+    return { added, removed };
+}
+function isUnifiedDiffMetadataLine(line) {
+    return (line.startsWith("+++") ||
+        line.startsWith("---") ||
+        line.startsWith("@@") ||
+        line.startsWith("Index:") ||
+        line.startsWith("===") ||
+        line.startsWith("\\ No newline"));
+}

package/dist/main.js

@@ -14,6 +14,7 @@ import { SessionManager } from "./session.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { SkillRegistry } from "./skills/registry.js";
 import { createAllTools } from "./tools/index.js";
+import { FileStateTracker } from "./tools/file-state.js";
 import { PermissionAwareApprovalController } from "./approval/controller.js";
 import { BashAllowlist } from "./approval/session-cache.js";
 import { SettingsManager } from "./permissions/settings.js";
@@ -92,6 +93,7 @@ async function main() {
         unlock: (names) => agentRef?.unlockDeferredTools(names),
     };
     const lspService = getLspService(args.cwd, settingsManager.getMerged().lsp);
+    const fileStateTracker = new FileStateTracker(args.cwd);
     const tools = createAllTools(args.cwd, skillRegistry, {
         todoStore,
         planController,
@@ -99,6 +101,7 @@ async function main() {
         questionController: printMode ? undefined : questionController,
         toolSearchController,
         lspService,
+        fileStateTracker,
     });
     // Bring up MCP servers (if any). Failures are captured per-server and never
     // block the rest of startup; /mcp surfaces status at runtime.
@@ -246,6 +249,7 @@ async function main() {
         budgetLedger,
         skills: skillSummaries,
         memoryPrompt,
+        fileStateTracker,
     });
     agentRef = agent;
     if (sessionManager) {
@@ -330,8 +334,10 @@ async function main() {
             console.log();
             return;
         }
-        // Interactive mode: OpenTUI uses Bun native FFI, matching opencode's TUI stack.
-        const { runTui } = await import("./tui/run.js");
+        const tuiRuntime = process.env.BUBBLE_TUI === "opentui" ? "opentui" : "ink";
+        const { runTui } = tuiRuntime === "opentui"
+            ? await import("./tui/run.js")
+            : await import("./tui-ink/run.js");
         await runTui(agent, args, {
             sessionManager,
             createProvider,
@@ -366,7 +372,25 @@ async function readPipedStdin() {
         process.stdin.resume();
     });
 }
-main().catch((err) => {
+main()
+    .then(() => {
+    void exitAfterFlush(0);
+})
+    .catch((err) => {
     console.error(chalk.red(`Fatal error: ${err.message}`));
-    process.exit(1);
+    void exitAfterFlush(1);
 });
+async function exitAfterFlush(code) {
+    await Promise.all([
+        flushStream(process.stdout),
+        flushStream(process.stderr),
+    ]);
+    process.exit(code);
+}
+function flushStream(stream) {
+    if (stream.destroyed || stream.writableEnded)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        stream.write("", () => resolve());
+    });
+}

package/dist/mcp/transports.d.ts

@@ -14,6 +14,7 @@
  */
 import type { HttpServerConfig, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, McpTransport, SseServerConfig, StdioServerConfig } from "./types.js";
 type IncomingHandler = (msg: JsonRpcResponse | JsonRpcNotification | JsonRpcRequest) => void;
+export declare const MCP_HTTP_CLOSE_TIMEOUT_MS = 750;
 export declare class StdioTransport implements McpTransport {
     private readonly config;
     private child?;

package/dist/mcp/transports.js

@@ -13,6 +13,7 @@
  * JSON-RPC calls on the same pipe.
  */
 import { spawn } from "node:child_process";
+export const MCP_HTTP_CLOSE_TIMEOUT_MS = 750;
 // ---------------------------------------------------------------------------
 // Stdio
 // ---------------------------------------------------------------------------
@@ -233,15 +234,22 @@ export class HttpTransport {
         this.closed = true;
         // Best-effort session termination. Per spec, DELETE /mcp with the session id.
         if (this.sessionId) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), MCP_HTTP_CLOSE_TIMEOUT_MS);
+            timeout.unref?.();
             try {
                 await fetch(this.url, {
                     method: "DELETE",
                     headers: { "Mcp-Session-Id": this.sessionId, ...this.baseHeaders },
+                    signal: controller.signal,
                 });
             }
             catch {
                 // ignore
             }
+            finally {
+                clearTimeout(timeout);
+            }
         }
         this.closeHandler?.();
     }

package/dist/model-catalog.js

@@ -77,7 +77,7 @@ export const BUILTIN_MODELS = [
     { id: "gemma-2-9b-it", name: "gemma-2-9b-it", providerId: "groq", reasoningLevels: ["off"], contextWindow: 32768 },
     { id: "meta-llama/Llama-3.3-70B-Instruct-Turbo", name: "meta-llama/Llama-3.3-70B-Instruct-Turbo", providerId: "together", reasoningLevels: ["off"], contextWindow: 32768 },
     { id: "Qwen/Qwen2.5-72B-Instruct", name: "Qwen/Qwen2.5-72B-Instruct", providerId: "together", reasoningLevels: ["off"], contextWindow: 32768 },
-    { id: "accounts/fireworks/models/kimi-k2p6", name: "Kimi K2.6", providerId: "fireworks", reasoningLevels: ["off"], contextWindow: 256000 },
+    { id: "accounts/fireworks/models/kimi-k2p6", name: "Kimi-K2.6", providerId: "fireworks", reasoningLevels: ["off"], contextWindow: 256000 },
     { id: "llama3.1", name: "llama3.1", providerId: "local", reasoningLevels: ["off"], contextWindow: 32768 },
     { id: "qwen2.5", name: "qwen2.5", providerId: "local", reasoningLevels: ["off"], contextWindow: 32768 },
     { id: "deepseek-coder-v2", name: "deepseek-coder-v2", providerId: "local", reasoningLevels: ["off"], contextWindow: 32768 },

package/dist/orchestrator/default-hooks.js

@@ -3,7 +3,7 @@ import { classifyTaskSize } from "../agent/task-size.js";
 import { EvidenceTracker } from "../agent/evidence-tracker.js";
 import { ExecutionGovernor } from "../agent/execution-governor.js";
 import { arbitrateToolCall } from "../agent/tool-arbiter.js";
-import { buildEditRetryEscalationReminder, buildRedundantReadReminder, buildSmallTaskHint, buildTaskSummaryReminder, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
+import { buildEditRetryEscalationReminder, buildSmallTaskHint, buildTaskSummaryReminder, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
 import { reminderForTaskType } from "../prompt/task-reminders.js";
 import { formatCoverageSummary, resolveWorkflowPhase } from "./workflow.js";
 export function createDefaultHooks() {
@@ -101,23 +101,11 @@ export function createDefaultHooks() {
                     ctx.state.recentEditFailures = [];
                     ctx.state.editRetryReminderSent = false;
                 }
-                // Redundant-Read detection: same file path read twice within this turn.
-                // Soft single-shot reminder, governor handles cumulative read budgets.
-                if (ctx.toolCall.name === "read" && !ctx.result.isError) {
-                    const rawPath = ctx.toolCall.parsedArgs?.path ?? ctx.toolCall.parsedArgs?.file_path;
-                    const path = typeof rawPath === "string" ? rawPath : undefined;
-                    if (path) {
-                        const seen = ctx.state.recentReadPaths ?? (ctx.state.recentReadPaths = []);
-                        const flagged = ctx.state.redundantReadReminded ?? (ctx.state.redundantReadReminded = new Set());
-                        if (seen.includes(path) && !flagged.has(path)) {
-                            flagged.add(path);
-                            ctx.queueReminder(buildRedundantReadReminder(path));
-                        }
-                        seen.push(path);
-                        if (seen.length > 16)
-                            seen.shift();
-                    }
-                }
+                // Redundant-Read detection moved into the read tool itself: it now
+                // returns a FILE_UNCHANGED_STUB (or auto-advances to the next page)
+                // when the same args land on an unchanged file. Hook-level reminder
+                // is removed to avoid duplicate signals and to let the structural
+                // dedup do the work.
                 if (isCodeWriteResult(ctx.toolCall, ctx.result)) {
                     markCodeChanged(ctx.state);
                 }

package/dist/prompt/compose.js

@@ -40,6 +40,7 @@ function buildProviderPrompt(agentName, providerId, modelId, modelName) {
     const provider = providerId ?? "";
     const rawModel = modelId ?? modelName ?? "";
     const model = rawModel.includes(":") ? rawModel.split(":").slice(1).join(":") : rawModel;
+    const lowerModel = model.toLowerCase();
     if (provider === "anthropic" || model.startsWith("claude")) {
         return buildAnthropicProviderPrompt(agentName);
     }
@@ -52,7 +53,7 @@ function buildProviderPrompt(agentName, providerId, modelId, modelName) {
     if (provider === "deepseek" || model.startsWith("deepseek")) {
         return buildDeepSeekProviderPrompt(agentName);
     }
-    if (["moonshot-cn", "moonshot-intl", "kimi-for-coding"].includes(provider) || model.startsWith("kimi") || model.startsWith("k2.")) {
+    if (["moonshot-cn", "moonshot-intl", "kimi-for-coding"].includes(provider) || lowerModel.includes("kimi") || lowerModel.includes("k2.")) {
         return buildKimiProviderPrompt(agentName);
     }
     if (["zhipuai", "zhipuai-coding-plan", "zai", "zai-coding-plan"].includes(provider) || model.startsWith("glm")) {

package/dist/prompt/provider-prompts/kimi.js

@@ -2,5 +2,7 @@ export function buildKimiProviderPrompt(agentName) {
     return `You are ${agentName}, a terminal coding agent running on a Kimi/Moonshot model.
 
 Keep tool use disciplined: pursue one concrete hypothesis at a time, read results carefully, and converge after evidence is sufficient.
-Do not fan out into many parallel search directions unless the task truly requires it.`;
+Do not fan out into many parallel search directions unless the task truly requires it.
+
+Evidence-first project exploration: use observed filesystem evidence as the source of truth. Do not assume conventional project files or directories exist. Before reading or operating on a path, ensure it was observed, directly derived from an observed path, or explicitly provided by the user. If a path is missing, adapt to the observed structure instead of probing more conventional paths.`;
 }