@bubblebrain-ai/bubble 0.0.6 → 0.0.8

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.
@@ -125,9 +128,8 @@ async function main() {
         const { registry: slashRegistry } = await import("./slash-commands/index.js");
         slashRegistry.addDynamicSource(() => mcpManager.getPromptCommands());
     }
-    // Signal-based shutdown for Ctrl-C / kill. For /quit the command handler
-    // shuts MCP down directly — process.once("exit", ...)
-    // runs synchronously and can't await async work, so relying on it is a trap.
+    // Signal-based shutdown for Ctrl-C / kill. Normal /quit cleanup happens after
+    // the TUI renderer has been destroyed, avoiding native teardown races.
     const shutdownMcp = async () => {
         try {
             await mcpManager.shutdown();
@@ -247,6 +249,7 @@ async function main() {
         budgetLedger,
         skills: skillSummaries,
         memoryPrompt,
+        fileStateTracker,
     });
     agentRef = agent;
     if (sessionManager) {
@@ -261,6 +264,18 @@ async function main() {
         // Codex-style memory runs at startup over historical rollouts. Exit should
         // not perform an ad-hoc extraction of the just-finished session.
     };
+    const shutdownRuntime = async () => {
+        const results = await Promise.allSettled([
+            flushMemory(),
+            shutdownMcp(),
+            lspService.shutdown(),
+        ]);
+        for (const result of results) {
+            if (result.status === "rejected") {
+                // Shutdown is best-effort; never turn exit into a fatal error.
+            }
+        }
+    };
     const runMemoryCompaction = async () => formatMemoryStartupResult(await runMemoryStartupPipeline({
         cwd: args.cwd,
         complete: (messages, completeOptions) => agent.complete(messages, completeOptions),
@@ -296,49 +311,55 @@ async function main() {
             console.log(chalk.dim(`Resumed session: ${sessionManager.getSessionFile()}`));
         }
     }
-    // Print mode: single prompt, then exit
-    if (args.print || args.prompt) {
-        const prompt = args.prompt || (await readPipedStdin()) || "";
-        if (!prompt) {
-            console.error(chalk.red("Error: No prompt provided."));
-            process.exit(1);
-        }
-        for await (const event of agent.run(prompt, args.cwd)) {
-            if (event.type === "text_delta") {
-                process.stdout.write(event.content);
-            }
-            else if (event.type === "tool_start") {
-                console.log(chalk.cyan(`\n[Tool: ${event.name}]`));
+    try {
+        // Print mode: single prompt, then exit
+        if (args.print || args.prompt) {
+            const prompt = args.prompt || (await readPipedStdin()) || "";
+            if (!prompt) {
+                console.error(chalk.red("Error: No prompt provided."));
+                process.exit(1);
             }
-            else if (event.type === "tool_end") {
-                const color = event.result.isError ? chalk.red : chalk.dim;
-                console.log(color(`[Result: ${event.result.content.slice(0, 200)}${event.result.content.length > 200 ? "..." : ""}]`));
+            for await (const event of agent.run(prompt, args.cwd)) {
+                if (event.type === "text_delta") {
+                    process.stdout.write(event.content);
+                }
+                else if (event.type === "tool_start") {
+                    console.log(chalk.cyan(`\n[Tool: ${event.name}]`));
+                }
+                else if (event.type === "tool_end") {
+                    const color = event.result.isError ? chalk.red : chalk.dim;
+                    console.log(color(`[Result: ${event.result.content.slice(0, 200)}${event.result.content.length > 200 ? "..." : ""}]`));
+                }
             }
+            console.log();
+            return;
         }
-        console.log();
-        return;
+        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,
+            registry,
+            skillRegistry,
+            planHandlerRef,
+            approvalHandlerRef,
+            questionController,
+            bashAllowlist,
+            settingsManager,
+            lspService,
+            mcpManager,
+            theme: userConfig.getTheme(),
+            flushMemory,
+            runMemoryCompaction,
+            runMemorySummary,
+            runMemoryRefresh,
+        });
+    }
+    finally {
+        await shutdownRuntime();
     }
-    // Interactive mode: OpenTUI uses Bun native FFI, matching opencode's TUI stack.
-    const { runTui } = await import("./tui/run.js");
-    await runTui(agent, args, {
-        sessionManager,
-        createProvider,
-        registry,
-        skillRegistry,
-        planHandlerRef,
-        approvalHandlerRef,
-        questionController,
-        bashAllowlist,
-        settingsManager,
-        lspService,
-        mcpManager,
-        theme: userConfig.getTheme(),
-        flushMemory,
-        runMemoryCompaction,
-        runMemorySummary,
-        runMemoryRefresh,
-    });
-    await flushMemory();
 }
 async function readPipedStdin() {
     if (process.stdin.isTTY)
@@ -351,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() {
@@ -36,18 +36,15 @@ export function createDefaultHooks() {
             },
             beforeModelCall(ctx) {
                 ctx.agent.compactResidentHistory();
-                if (ctx.state.governor) {
-                    ctx.toolEntries = ctx.state.governor.filterToolDefinitions(ctx.toolEntries);
-                }
                 if (ctx.state.taskType === "security_investigation" && ctx.state.evidenceTracker && ctx.state.governor) {
                     const coverage = ctx.state.evidenceTracker.snapshot();
                     const phase = resolveWorkflowPhase({
                         coreCoverageComplete: ctx.state.evidenceTracker.isCoreCoverageComplete(),
-                        searchFrozen: ctx.state.governor.snapshot().searchFrozen,
+                        searchFrozen: false,
                     });
                     ctx.state.workflowPhase = phase;
                     const summary = formatCoverageSummary(coverage);
-                    const key = `${phase}:${ctx.state.evidenceTracker.key()}:${ctx.state.governor.snapshot().searchFrozen ? "1" : "0"}`;
+                    const key = `${phase}:${ctx.state.evidenceTracker.key()}:0`;
                     if (ctx.state.workflowKey !== key) {
                         ctx.state.workflowKey = key;
                         ctx.queueReminder(buildWorkflowPhaseReminder({
@@ -66,10 +63,7 @@ export function createDefaultHooks() {
             beforeToolCall(ctx) {
                 const arbitration = arbitrateToolCall(ctx.toolCall);
                 ctx.replaceToolCall({ ...arbitration.toolCall, ...(arbitration.note ? { arbiterNote: arbitration.note } : {}) });
-                const decision = ctx.state.governor?.beforeToolCall(ctx.toolCall);
-                if (decision?.blockedResult) {
-                    ctx.blockToolCall(decision.blockedResult);
-                }
+                ctx.state.governor?.beforeToolCall(ctx.toolCall);
             },
             afterToolCall(ctx) {
                 if (ctx.toolCall.arbiterNote) {
@@ -107,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);
                 }
@@ -149,12 +131,6 @@ export function createDefaultHooks() {
                     ctx.requestTextOnlyTurn("Core security investigation evidence has been collected. Summarize the findings instead of continuing with more tool calls.");
                     return;
                 }
-                const allSearchResultsWereLowSignal = ctx.toolCalls.length > 0
-                    && ctx.toolCalls.every((toolCall) => ["glob", "grep", "bash", "web_search", "web_fetch"].includes(toolCall.name))
-                    && ctx.toolResults.every((result) => result.status === "no_match" || result.status === "blocked");
-                if (ctx.state.governor?.snapshot().searchFrozen && allSearchResultsWereLowSignal) {
-                    ctx.requestTextOnlyTurn("Search continuation has become low-yield. Summarize the strongest evidence already collected instead of continuing broad exploration.");
-                }
                 // Verification reminders intentionally removed. See afterToolCall.
             },
             afterTurn() {

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.`;
 }

package/dist/prompt/reminders.d.ts

@@ -41,7 +41,8 @@ export declare function buildTaskSummaryReminder(): string;
 export declare function buildEditRetryEscalationReminder(reason: string): string;
 /**
  * Fired the FIRST time the model re-reads a file it already read in this turn.
- * Soft — does not freeze the tool. Just prevents a 3rd / 4th re-read.
+ * Soft — does not freeze the tool. The model may still re-read when context was
+ * pruned, the requested range changed, or a later mutation needs verification.
  */
 export declare function buildRedundantReadReminder(path: string): string;
 /**

package/dist/prompt/reminders.js

@@ -200,12 +200,13 @@ Stop retrying the same call. Pick one of:
 }
 /**
  * Fired the FIRST time the model re-reads a file it already read in this turn.
- * Soft — does not freeze the tool. Just prevents a 3rd / 4th re-read.
+ * Soft — does not freeze the tool. The model may still re-read when context was
+ * pruned, the requested range changed, or a later mutation needs verification.
  */
 export function buildRedundantReadReminder(path) {
     return wrapInSystemReminder(`
-You already read ${path} earlier in this turn. Use the content already in context rather than re-reading.
-Only re-read this path if a subsequent tool call (edit/write/bash) modified it since.
+You already read ${path} earlier in this turn. If that content is still available and nothing changed, rely on it rather than re-reading.
+It is okay to re-read when you need to recover pruned context, inspect a different range, or verify a later edit/write/bash change.
 `);
 }
 /**

package/dist/provider-registry.js

@@ -4,7 +4,7 @@
  * Supports OpenAI-compatible providers with dynamic or static model lists.
  * Reads provider configuration from models.json first, then falls back to config.json.
  */
-import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, getBuiltinProvider, listBuiltinModels, } from "./model-catalog.js";
+import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, getBuiltinModel, getBuiltinProvider, listBuiltinModels, } from "./model-catalog.js";
 import { ModelConfig } from "./model-config.js";
 import { AuthStorage } from "./oauth/index.js";
 import { fetchOpenAICodexModels } from "./provider-openai-codex.js";
@@ -232,8 +232,8 @@ export function decodeModel(value) {
 }
 /** Strip provider prefix for concise display. */
 export function displayModel(model) {
-    const { modelId } = decodeModel(model);
-    return modelId;
+    const { providerId, modelId } = decodeModel(model);
+    return providerId ? getBuiltinModel(providerId, modelId)?.name ?? modelId : modelId;
 }
 /** Normalize user input to provider:model format when possible. */
 export function normalizeModel(model, defaultProvider = "openai") {

package/dist/provider-transform.d.ts

@@ -3,7 +3,9 @@ export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingL
 export interface ProviderRequestConfig {
     effectiveThinkingLevel: ThinkingLevel;
     reasoningEffort?: ThinkingLevel;
-    reasoningContentEcho?: "tool_calls" | "all";
+    reasoningContentEcho?: "tool_calls" | "all" | "none";
+    parallelToolCalls?: boolean;
+    maxTokens?: number;
     extraBody?: Record<string, unknown>;
     omitTemperature?: boolean;
 }