@bubblebrain-ai/bubble 0.0.7 → 0.0.9

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, input.providerId) : 0;
+    const systemPromptTokens = Math.max(0, estimateTextTokens(systemContent, input.providerId) - skillsTokens);
+    const toolsTokens = estimateToolEntriesTokens(input.toolEntries, input.providerId);
+    const deferredToolsTokens = estimateDeferredToolsReminderTokens(deferredToolEntries, input.providerId);
+    const rawOtherTokens = otherMessages.reduce((sum, message) => sum + estimateMessageTokens(message, input.providerId), 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, providerId) {
+    return entries.reduce((sum, entry) => {
+        const payload = JSON.stringify({
+            name: entry.name,
+            description: entry.description,
+            parameters: entry.parameters,
+        });
+        return sum + estimateTextTokens(payload, providerId) + 8;
+    }, 0);
+}
+function estimateDeferredToolsReminderTokens(entries, providerId) {
+    if (entries.length === 0)
+        return 0;
+    return estimateTextTokens(buildDeferredToolsReminder(entries.map((entry) => entry.name)), providerId);
+}
+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";
@@ -55,6 +56,20 @@ async function main() {
         })
         : createUnavailableProvider(unavailableProviderMessage);
     const createProvider = (providerId, apiKey, baseURL) => createProviderInstance({ providerId, apiKey, baseURL, thinkingLevel: args.thinkingLevel });
+    const createProviderForRoute = async (route) => {
+        const providerId = route.providerId;
+        if (!providerId) {
+            throw new Error(`Subagent route for model "${route.model}" did not include a provider.`);
+        }
+        if (registry.supportsOAuth(providerId) && registry.getAuthStorage().has(providerId)) {
+            await registry.prepareProvider(providerId);
+        }
+        const target = registry.getConfigured().find((item) => item.id === providerId);
+        if (!target?.enabled || !target.apiKey) {
+            throw new Error(`Subagent route requires provider "${providerId}", but it is not configured or has no active credentials.`);
+        }
+        return createProvider(providerId, target.apiKey, target.baseURL);
+    };
     let agentRef;
     const todoStore = {
         getTodos: () => agentRef?.getTodos() ?? [],
@@ -92,6 +107,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 +115,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 +263,9 @@ async function main() {
         budgetLedger,
         skills: skillSummaries,
         memoryPrompt,
+        fileStateTracker,
+        agentCategories: userConfig.getAgentCategories(),
+        providerFactory: createProviderForRoute,
     });
     agentRef = agent;
     if (sessionManager) {
@@ -330,9 +350,9 @@ 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");
-        await runTui(agent, args, {
+        const tuiRuntime = process.env.BUBBLE_TUI === "opentui" ? "opentui" : "ink";
+        const themeConfig = userConfig.getTheme();
+        const commonOptions = {
             sessionManager,
             createProvider,
             registry,
@@ -344,12 +364,35 @@ async function main() {
             settingsManager,
             lspService,
             mcpManager,
-            theme: userConfig.getTheme(),
             flushMemory,
             runMemoryCompaction,
             runMemorySummary,
             runMemoryRefresh,
-        });
+        };
+        if (tuiRuntime === "opentui") {
+            const { runTui } = await import("./tui/run.js");
+            await runTui(agent, args, {
+                ...commonOptions,
+                theme: themeConfig.overrides,
+            });
+        }
+        else {
+            // Probe the terminal background BEFORE Ink takes over stdin. OSC 11
+            // needs raw mode, and once Ink owns stdin the reply never reaches us.
+            let detectedTheme = "dark";
+            if (themeConfig.mode === "auto") {
+                const { detectTerminalTheme } = await import("./tui-ink/detect-theme.js");
+                detectedTheme = await detectTerminalTheme();
+            }
+            const { runTui } = await import("./tui-ink/run.js");
+            await runTui(agent, args, {
+                ...commonOptions,
+                themeMode: themeConfig.mode,
+                themeOverrides: themeConfig.overrides,
+                detectedTheme,
+                onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
+            });
+        }
     }
     finally {
         await shutdownRuntime();
@@ -366,7 +409,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.d.ts

@@ -11,10 +11,19 @@ export interface BuiltinModelDefinition {
     providerId: string;
     reasoningLevels: ReasoningEffort[];
     contextWindow?: number;
+    /**
+     * Server-declared cap on per-tool-output tokens. When set, the agent must
+     * truncate each tool result to this token budget before adding it to history
+     * — otherwise the server's input window is exceeded by raw tool dumps.
+     * (For codex models this comes from the API's `truncation_policy.limit`.)
+     */
+    toolOutputTokenLimit?: number;
 }
 export declare const BUILTIN_PROVIDERS: BuiltinProviderDefinition[];
 export declare const BUILTIN_MODELS: BuiltinModelDefinition[];
 export declare function listBuiltinModels(providerId: string): BuiltinModelDefinition[];
+export declare function registerDynamicModelMetadata(model: BuiltinModelDefinition): void;
 export declare function getBuiltinModel(providerId: string, modelId: string): BuiltinModelDefinition | undefined;
 export declare function getBuiltinProvider(providerId: string): BuiltinProviderDefinition | undefined;
 export declare function getModelContextWindow(providerId: string, modelId: string): number | undefined;
+export declare function getToolOutputTokenLimit(providerId: string, modelId: string): number | undefined;

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 },
@@ -85,7 +85,20 @@ export const BUILTIN_MODELS = [
 export function listBuiltinModels(providerId) {
     return BUILTIN_MODELS.filter((model) => model.providerId === providerId);
 }
+// Runtime overlay populated from provider-side discovery (e.g. ChatGPT codex /models).
+// Looked up before the static catalog so newly-released models work without a code change.
+const dynamicOverlay = new Map();
+function overlayKey(providerId, modelId) {
+    return `${providerId}:${modelId}`;
+}
+export function registerDynamicModelMetadata(model) {
+    dynamicOverlay.set(overlayKey(model.providerId, model.id), model);
+}
 export function getBuiltinModel(providerId, modelId) {
+    const overlayHit = dynamicOverlay.get(overlayKey(providerId, modelId))
+        || (providerId === "openai" ? dynamicOverlay.get(overlayKey("openai-codex", modelId)) : undefined);
+    if (overlayHit)
+        return overlayHit;
     return BUILTIN_MODELS.find((model) => model.providerId === providerId && model.id === modelId)
         || (providerId === "openai"
             ? BUILTIN_MODELS.find((model) => model.providerId === "openai-codex" && model.id === modelId)
@@ -97,3 +110,6 @@ export function getBuiltinProvider(providerId) {
 export function getModelContextWindow(providerId, modelId) {
     return getBuiltinModel(providerId, modelId)?.contextWindow;
 }
+export function getToolOutputTokenLimit(providerId, modelId) {
+    return getBuiltinModel(providerId, modelId)?.toolOutputTokenLimit;
+}

package/dist/orchestrator/default-hooks.js

@@ -3,9 +3,10 @@ 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";
+import { buildSubagentLifecycleReminder } from "../agent/subagent-lifecycle-reminder.js";
 export function createDefaultHooks() {
     return [
         {
@@ -101,23 +102,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);
                 }
@@ -139,6 +128,12 @@ export function createDefaultHooks() {
                 }
             },
             beforeContinuation(ctx) {
+                if (hasSubagentLifecycleActivity(ctx.toolCalls, ctx.toolResults)) {
+                    const reminder = buildSubagentLifecycleReminder(ctx.agent.listSubAgents(), ctx.toolResults);
+                    if (reminder) {
+                        ctx.queueReminder(reminder);
+                    }
+                }
                 if (ctx.state.taskType === "security_investigation" && ctx.state.evidenceTracker?.isCoreCoverageComplete()) {
                     ctx.requestTextOnlyTurn("Core security investigation evidence has been collected. Summarize the findings instead of continuing with more tool calls.");
                     return;
@@ -161,6 +156,17 @@ function isCodeWriteResult(_toolCall, result) {
     }
     return result.metadata?.kind === "write" || result.metadata?.kind === "edit";
 }
+function hasSubagentLifecycleActivity(toolCalls, toolResults) {
+    return toolCalls.some((toolCall) => isSubagentLifecycleTool(toolCall.name))
+        || toolResults.some((result) => result.metadata?.kind === "subagent");
+}
+function isSubagentLifecycleTool(name) {
+    return name === "spawn_agent"
+        || name === "wait_agent"
+        || name === "send_input"
+        || name === "close_agent"
+        || name === "task";
+}
 function hashEditCall(toolCall) {
     // Cheap fingerprint that identifies "same edit/write call". JSON of the
     // sorted parsed args is good enough — we only need stable equality between

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/provider-openai-codex.d.ts

@@ -1,4 +1,14 @@
-import type { Provider, ThinkingLevel } from "./types.js";
+import type { Provider, ReasoningEffort, ThinkingLevel } from "./types.js";
+export interface CodexModelDescriptor {
+    id: string;
+    displayName?: string;
+    contextWindow?: number;
+    reasoningLevels?: ReasoningEffort[];
+    visibility?: string;
+    minimalClientVersion?: string;
+    /** Server-declared per-tool-output token cap (truncation_policy.limit when mode=tokens). */
+    toolOutputTokenLimit?: number;
+}
 export declare function isOpenAICodexBaseUrl(baseURL: string): boolean;
 export declare function getOpenAICodexFallbackModels(): string[];
 export declare function extractChatGptAccountId(accessToken: string): string | undefined;
@@ -11,4 +21,5 @@ export declare function createOpenAICodexProvider(options: {
 export declare function fetchOpenAICodexModels(options: {
     baseURL: string;
     accessToken: string;
-}): Promise<string[]>;
+}): Promise<CodexModelDescriptor[]>;
+export declare function sortCodexModelDescriptors(descriptors: CodexModelDescriptor[]): CodexModelDescriptor[];