@bubblebrain-ai/bubble 0.0.4 → 0.0.6

package/dist/context/budget.js

@@ -6,6 +6,7 @@ export const MIN_WINDOW_FOR_RESERVE = 40_000;
 export function estimateMessageTokens(message) {
     switch (message.role) {
         case "system":
+        case "meta":
         case "tool":
             return estimateTextTokens(message.content);
         case "assistant":

package/dist/context/compact-llm.js

@@ -44,9 +44,9 @@ content, write "None".
    - The single most natural next action, if obvious.`;
 export async function compactMessagesWithLLM(messages, options) {
     const keepRecentTurns = options.keepRecentTurns ?? 2;
-    const systemMessages = messages.filter((m) => m.role === "system");
-    const nonSystemMessages = messages.filter((m) => m.role !== "system");
-    const turnStartIndexes = nonSystemMessages
+    const preservedContextMessages = messages.filter((m) => m.role === "system" || m.role === "meta");
+    const conversationalMessages = messages.filter((m) => m.role !== "system" && m.role !== "meta");
+    const turnStartIndexes = conversationalMessages
         .map((m, i) => (m.role === "user" ? i : -1))
         .filter((i) => i >= 0);
     if (turnStartIndexes.length <= keepRecentTurns) {
@@ -56,8 +56,8 @@ export async function compactMessagesWithLLM(messages, options) {
     if (keepStartIndex <= 0) {
         return { compacted: false };
     }
-    const oldMessages = nonSystemMessages.slice(0, keepStartIndex);
-    const keptMessages = nonSystemMessages.slice(keepStartIndex);
+    const oldMessages = conversationalMessages.slice(0, keepStartIndex);
+    const keptMessages = conversationalMessages.slice(keepStartIndex);
     let summary;
     try {
         summary = await generateSummary(oldMessages, options);
@@ -72,7 +72,7 @@ export async function compactMessagesWithLLM(messages, options) {
         compacted: true,
         summary,
         messages: [
-            ...systemMessages,
+            ...preservedContextMessages,
             { role: "system", content: `Previous conversation summary:\n${summary}` },
             ...keptMessages,
         ],
@@ -112,6 +112,7 @@ function serializeTranscript(messages) {
                 lines.push(`[tool] ${truncate(message.content, 800)}`);
                 break;
             case "system":
+            case "meta":
                 break;
         }
     }

package/dist/context/compact.js

@@ -43,9 +43,9 @@ export function compactSessionEntries(entries, options = {}) {
 export function compactMessages(messages, options = {}) {
     const keepRecentTurns = options.keepRecentTurns ?? 2;
     const maxSummaryItems = options.maxSummaryItems ?? 4;
-    const systemMessages = messages.filter((message) => message.role === "system");
-    const nonSystemMessages = messages.filter((message) => message.role !== "system");
-    const turnStartIndexes = nonSystemMessages
+    const preservedContextMessages = messages.filter((message) => message.role === "system" || message.role === "meta");
+    const conversationalMessages = messages.filter((message) => message.role !== "system" && message.role !== "meta");
+    const turnStartIndexes = conversationalMessages
         .map((message, index) => (message.role === "user" ? index : -1))
         .filter((index) => index >= 0);
     if (turnStartIndexes.length <= keepRecentTurns) {
@@ -55,14 +55,14 @@ export function compactMessages(messages, options = {}) {
     if (keepStartIndex <= 0) {
         return { compacted: false };
     }
-    const oldMessages = nonSystemMessages.slice(0, keepStartIndex);
-    const keptMessages = nonSystemMessages.slice(keepStartIndex);
+    const oldMessages = conversationalMessages.slice(0, keepStartIndex);
+    const keptMessages = conversationalMessages.slice(keepStartIndex);
     const summary = buildMessageSummary(oldMessages, maxSummaryItems);
     if (!summary) {
         return { compacted: false };
     }
     const compactedMessages = [
-        ...systemMessages.map((message) => cloneMessage(message)),
+        ...preservedContextMessages.map((message) => cloneMessage(message)),
         {
             role: "system",
             content: `Previous conversation summary:\n${summary}`,

package/dist/context/projector.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from "../types.js";
+import type { Message, ProviderMessage } from "../types.js";
 export interface ProjectionOptions {
     mode?: "full" | "pruned" | "budgeted";
     providerId?: string;
@@ -6,7 +6,7 @@ export interface ProjectionOptions {
     usageAnchorTokens?: number;
     anchorMessageCount?: number;
 }
-export declare function projectMessages(messages: Message[], options?: ProjectionOptions): Message[];
+export declare function projectMessages(messages: Message[], options?: ProjectionOptions): ProviderMessage[];
 /**
  * Ensures every assistant `tool_calls` is followed (in order) by tool messages
  * responding to each tool_call_id, with no foreign messages interleaved.
@@ -23,4 +23,4 @@ export declare function projectMessages(messages: Message[], options?: Projectio
  * synthesize placeholder tool messages for any tool_call_id with no captured
  * result. Other messages keep their original order.
  */
-export declare function repairToolCallChains(messages: Message[]): Message[];
+export declare function repairToolCallChains(messages: ProviderMessage[]): ProviderMessage[];

package/dist/context/projector.js

@@ -3,29 +3,33 @@ import { compactMessages } from "./compact.js";
 import { pruneMessages } from "./prune.js";
 export function projectMessages(messages, options = {}) {
     const mode = options.mode ?? "full";
-    const projected = [];
-    let systemBuffer = [];
-    const flushSystemBuffer = () => {
-        if (systemBuffer.length === 0)
-            return;
-        projected.push({
-            role: "system",
-            content: systemBuffer.join("\n\n"),
-        });
-        systemBuffer = [];
-    };
+    const projectedBody = [];
+    const systemContext = [];
     for (const message of messages) {
         if (message.role === "system") {
-            systemBuffer.push(message.content);
+            systemContext.push(message.content);
+            continue;
+        }
+        if (message.role === "meta") {
+            if (message.includeInLlm !== false) {
+                systemContext.push(formatMetaMessage(message));
+            }
             continue;
         }
-        flushSystemBuffer();
         if (message.role === "assistant" && isEmptyAssistantMessage(message)) {
             continue;
         }
-        projected.push(cloneMessage(message));
+        projectedBody.push(cloneMessage(message));
     }
-    flushSystemBuffer();
+    const projected = [
+        ...(systemContext.length > 0
+            ? [{
+                    role: "system",
+                    content: systemContext.join("\n\n"),
+                }]
+            : []),
+        ...projectedBody,
+    ];
     const repaired = repairToolCallChains(projected);
     if (mode === "pruned") {
         return pruneMessages(repaired);
@@ -48,12 +52,13 @@ export function projectMessages(messages, options = {}) {
         if (!compacted.compacted || !compacted.messages) {
             return pruned;
         }
-        const afterFirstPass = getContextBudget(options.providerId, options.modelId, compacted.messages);
+        const compactedMessages = compacted.messages;
+        const afterFirstPass = getContextBudget(options.providerId, options.modelId, compactedMessages);
         if (!afterFirstPass.shouldCompact) {
-            return repairToolCallChains(compacted.messages);
+            return repairToolCallChains(compactedMessages);
         }
         const tighter = compactMessages(pruned, { keepRecentTurns: 1 });
-        const finalMessages = tighter.compacted && tighter.messages ? tighter.messages : compacted.messages;
+        const finalMessages = (tighter.compacted && tighter.messages ? tighter.messages : compactedMessages);
         return repairToolCallChains(finalMessages);
     }
     return repaired;
@@ -130,6 +135,15 @@ function isEmptyAssistantMessage(message) {
     const hasToolCalls = !!message.toolCalls && message.toolCalls.length > 0;
     return !hasContent && !hasReasoning && !hasToolCalls;
 }
+function formatMetaMessage(message) {
+    switch (message.kind) {
+        case "system-reminder":
+            return `Runtime reminder:\n${message.content}`;
+        case "runtime-context":
+        default:
+            return `Runtime context:\n${message.content}`;
+    }
+}
 function cloneMessage(message) {
     if (message.role === "assistant") {
         return {

package/dist/context/prune.d.ts

@@ -1,9 +1,9 @@
 import type { Message } from "../types.js";
-export declare function pruneMessages(messages: Message[]): Message[];
+export declare function pruneMessages<T extends Message>(messages: T[]): T[];
 /**
  * Aggressive variant of pruneMessages: drops the content of every prunable
  * tool output except the latest unresolved tool turn that the model still
  * needs to reason over. Used as a last-resort microcompact pass when a
  * standard prune hasn't reclaimed enough budget.
  */
-export declare function aggressivePruneMessages(messages: Message[]): Message[];
+export declare function aggressivePruneMessages<T extends Message>(messages: T[]): T[];

package/dist/context/prune.js

@@ -96,10 +96,7 @@ export function aggressivePruneMessages(messages) {
 function collectProtectedToolCallIds(messages) {
     for (let index = messages.length - 1; index >= 0; index--) {
         const message = messages[index];
-        if (message.role === "tool" || message.role === "system") {
-            continue;
-        }
-        if (message.role === "user" && message.isMeta) {
+        if (message.role === "tool" || message.role === "system" || message.role === "meta") {
             continue;
         }
         if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {

package/dist/main.js

@@ -4,6 +4,7 @@
  */
 import chalk from "chalk";
 import { Agent } from "./agent.js";
+import { BudgetLedger } from "./agent/budget-ledger.js";
 import { parseArgs, printHelp } from "./cli.js";
 import { UserConfig } from "./config.js";
 import { createProviderInstance, createUnavailableProvider } from "./provider.js";
@@ -185,6 +186,8 @@ async function main() {
         : (sessionThinkingLevel ?? args.thinkingLevel ?? configuredThinkingLevel ?? "off");
     const restoredTodos = sessionManager?.getTodos() ?? [];
     const initialMode = args.mode ?? "default";
+    const skillSummaries = skillRegistry.summaries();
+    const memoryPrompt = buildMemoryPrompt(args.cwd);
     const systemPrompt = buildSystemPrompt({
         agentName: "Bubble",
         configuredProvider: activeProviderId || "none",
@@ -194,9 +197,10 @@ async function main() {
         mode: initialMode,
         workingDir: args.cwd,
         tools: tools.map((tool) => tool.name),
-        skills: skillRegistry.summaries(),
-        memoryPrompt: buildMemoryPrompt(args.cwd),
+        skills: skillSummaries,
+        memoryPrompt,
     });
+    const budgetLedger = new BudgetLedger();
     const agent = new Agent({
         provider: activeProvider
             ? createProvider(activeProviderId, activeProvider.apiKey, activeProvider.baseURL)
@@ -215,9 +219,9 @@ async function main() {
                 return;
             if (message.role === "system")
                 return;
-            // <system-reminder> injections are runtime/ephemeral; don't persist them —
+            // Runtime meta messages are ephemeral; don't persist them —
             // they will be re-injected as needed on resume based on the current mode.
-            if (message.role === "user" && message.isMeta)
+            if (message.role === "meta")
                 return;
             sessionManager.appendMessage(message);
             if (message.role === "assistant") {
@@ -240,6 +244,9 @@ async function main() {
         onModeUpdate: (mode) => {
             sessionManager?.appendMarker("mode_switch", mode);
         },
+        budgetLedger,
+        skills: skillSummaries,
+        memoryPrompt,
     });
     agentRef = agent;
     if (sessionManager) {
@@ -281,7 +288,7 @@ async function main() {
         const history = sessionManager.getMessages();
         if (history.length > 0) {
             agent.messages = [{ role: "system", content: systemPrompt }, ...history];
-            // Reassigning agent.messages drops any <system-reminder> we injected during
+            // Reassigning agent.messages drops any runtime meta reminder injected during
             // construction. Re-inject if the agent is starting in plan mode.
             if (agent.mode === "plan") {
                 agent.injectModeReminder();

package/dist/mcp/manager.js

@@ -164,6 +164,7 @@ function buildToolEntry(serverName, tool, getClient) {
         description,
         parameters,
         readOnly: false, // Conservative default; user can allow-list.
+        effect: "unknown",
         deferred: true, // Load schema on demand via tool_search to keep context small.
         async execute(args) {
             const client = getClient();

package/dist/orchestrator/default-hooks.js

@@ -1,8 +1,9 @@
 import { classifyTask } from "../agent/task-classifier.js";
+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 { buildTaskSummaryReminder, buildVerificationReminder, buildWorkflowPhaseReminder } from "../prompt/reminders.js";
+import { buildEditRetryEscalationReminder, buildRedundantReadReminder, buildSmallTaskHint, buildTaskSummaryReminder, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
 import { reminderForTaskType } from "../prompt/task-reminders.js";
 import { formatCoverageSummary, resolveWorkflowPhase } from "./workflow.js";
 export function createDefaultHooks() {
@@ -16,6 +17,13 @@ export function createDefaultHooks() {
                 if (taskReminder) {
                     ctx.queueReminder(taskReminder);
                 }
+                // Small-task hint: counterweight to the default protocol's exploration
+                // bias, only fires once per run on focused one-shot requests like
+                // "写个 HTML 介绍元旦". Don't issue for the same input twice.
+                if (!ctx.state.smallTaskHintSent && classifyTaskSize(ctx.input) === "small") {
+                    ctx.state.smallTaskHintSent = true;
+                    ctx.queueReminder(buildSmallTaskHint());
+                }
                 if (taskType === "security_investigation") {
                     ctx.state.evidenceTracker = new EvidenceTracker();
                     ctx.state.workflowPhase = "investigate";
@@ -75,12 +83,58 @@ export function createDefaultHooks() {
                 }
                 ctx.state.evidenceTracker?.observe(ctx.toolCall, ctx.result);
                 ctx.state.governor?.afterToolResult(ctx.toolCall, ctx.result);
-                if (isCodeWriteResult(ctx.toolCall, ctx.result)) {
-                    ctx.state.codeChanged = true;
+                // Edit/write retry-escalation: if the same tool with the same args
+                // failed twice in a row, models — especially thinking-heavy ones —
+                // can spiral on "identical content" / "not found" errors. Nudge them
+                // to change strategy.
+                if ((ctx.toolCall.name === "edit" || ctx.toolCall.name === "write") && ctx.result.isError) {
+                    const hash = hashEditCall(ctx.toolCall);
+                    const history = ctx.state.recentEditFailures ?? (ctx.state.recentEditFailures = []);
+                    history.push(hash);
+                    // Keep last 4 entries.
+                    if (history.length > 4)
+                        history.shift();
+                    const len = history.length;
+                    if (len >= 2 && history[len - 1] === history[len - 2] && !ctx.state.editRetryReminderSent) {
+                        ctx.state.editRetryReminderSent = true;
+                        const summary = ctx.result.content.split("\n")[0] || "";
+                        ctx.queueReminder(buildEditRetryEscalationReminder(`Last failure: ${ctx.toolCall.name} on the same target with identical arguments. ${summary}`));
+                    }
                 }
-                else if (ctx.state.codeChanged && isVerificationResult(ctx.toolCall, ctx.result)) {
-                    ctx.state.verificationCompleted = true;
+                else if ((ctx.toolCall.name === "edit" || ctx.toolCall.name === "write") && !ctx.result.isError) {
+                    // Successful mutation resets the dedup state so a later, unrelated
+                    // failure won't fire the reminder spuriously.
+                    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();
+                    }
                 }
+                if (isCodeWriteResult(ctx.toolCall, ctx.result)) {
+                    markCodeChanged(ctx.state);
+                }
+                // Removed: active verification tracking. The previous design nagged the
+                // model every turn until it ran a recognised verification command, and
+                // narrowly accepted only test/lint commands — which meant ad-hoc python
+                // checks did not count, the nag never cleared, and reasoning models
+                // (DeepSeek v4-pro with hex-blindness) spiraled trying to "prove" the
+                // edit was correct. CC's approach is the opposite: verify when there
+                // is something real to verify, say so explicitly when there isn't, and
+                // trust the model to judge. We follow that.
                 if (ctx.toolCall.name === "task") {
                     ctx.queueReminder(buildTaskSummaryReminder());
                 }
@@ -101,48 +155,44 @@ export function createDefaultHooks() {
                 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.");
                 }
-                const changedThisTurn = ctx.toolResults.some((result) => result.metadata?.kind === "write" || result.metadata?.kind === "edit");
-                if (changedThisTurn && !ctx.state.verificationCompleted && !ctx.state.verificationReminderQueued) {
-                    ctx.state.verificationReminderQueued = true;
-                    ctx.queueReminder(buildVerificationReminder("The previous turn changed files and no verification evidence has been observed yet."));
-                }
+                // Verification reminders intentionally removed. See afterToolCall.
             },
-            afterTurn(ctx) {
-                if (ctx.state.codeChanged && !ctx.state.verificationCompleted && !ctx.state.finalVerificationReminderSent) {
-                    ctx.state.finalVerificationReminderSent = true;
-                    ctx.state.forceContinuationReason = "Files were changed but no verification evidence was observed before the final answer.";
-                    ctx.queueReminder(buildVerificationReminder(ctx.state.forceContinuationReason));
-                }
+            afterTurn() {
+                // Verification force-continuation removed. The model decides whether
+                // verification is meaningful for the task, per the system prompt.
             },
         },
     ];
 }
+function markCodeChanged(state) {
+    state.codeChanged = true;
+}
 function isCodeWriteResult(_toolCall, result) {
     if (result.isError || result.status === "blocked" || result.status === "command_error") {
         return false;
     }
     return result.metadata?.kind === "write" || result.metadata?.kind === "edit";
 }
-function isVerificationResult(toolCall, result) {
-    if (result.isError || result.status === "blocked" || result.status === "command_error") {
-        return false;
+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
+    // identical calls, not cryptographic strength.
+    try {
+        return `${toolCall.name}:${stableStringify(toolCall.parsedArgs)}`;
     }
-    if (toolCall.name === "lsp") {
-        return true;
+    catch {
+        return `${toolCall.name}:${toolCall.arguments}`;
     }
-    if (toolCall.name !== "bash") {
-        return false;
-    }
-    const command = typeof result.metadata?.command === "string"
-        ? result.metadata.command
-        : typeof toolCall.parsedArgs.command === "string"
-            ? toolCall.parsedArgs.command
-            : "";
-    return isVerificationCommand(command);
 }
-function isVerificationCommand(command) {
-    const normalized = command.trim().toLowerCase();
-    return /\b(npm|pnpm|yarn|bun)\s+(test|run\s+(test|build|typecheck|lint|check|tsc)|exec\s+tsc)\b/.test(normalized)
-        || /\b(npx|pnpm\s+exec|bunx)\s+(vitest|tsc|eslint|playwright)\b/.test(normalized)
-        || /\b(vitest|tsc|pytest|ruff|cargo\s+test|go\s+test|swift\s+test)\b/.test(normalized);
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+        return `{${entries.join(",")}}`;
+    }
+    return JSON.stringify(value ?? null);
 }

package/dist/orchestrator/hooks.d.ts

@@ -14,9 +14,11 @@ export interface TurnHookState {
     forceTextOnlyReason?: string;
     forceContinuationReason?: string;
     codeChanged?: boolean;
-    verificationCompleted?: boolean;
-    verificationReminderQueued?: boolean;
-    finalVerificationReminderSent?: boolean;
+    smallTaskHintSent?: boolean;
+    recentEditFailures?: string[];
+    editRetryReminderSent?: boolean;
+    recentReadPaths?: string[];
+    redundantReadReminded?: Set<string>;
     taskBudget?: {
         total: number;
         spent: number;

package/dist/prompt/compose.d.ts

@@ -8,5 +8,6 @@ export interface ComposeSystemPromptOptions extends EnvironmentPromptOptions {
     mode?: PermissionMode;
     skills?: SkillSummary[];
     memoryPrompt?: string;
+    agentProfilePrompt?: string;
 }
 export declare function composeSystemPrompt(options?: ComposeSystemPromptOptions): string;

package/dist/prompt/compose.js

@@ -27,7 +27,14 @@ export function composeSystemPrompt(options = {}) {
         guidelines: buildGuidelines(options.tools ?? defaultToolNames, options.guidelines ?? []),
     });
     const skillsPrompt = buildSkillsPrompt(options.skills ?? []);
-    return [providerPrompt, environmentPrompt, runtimePrompt, options.memoryPrompt, skillsPrompt].filter(Boolean).join("\n\n");
+    return [
+        providerPrompt,
+        environmentPrompt,
+        runtimePrompt,
+        options.agentProfilePrompt,
+        options.memoryPrompt,
+        skillsPrompt,
+    ].filter(Boolean).join("\n\n");
 }
 function buildProviderPrompt(agentName, providerId, modelId, modelName) {
     const provider = providerId ?? "";
@@ -72,6 +79,9 @@ function buildGuidelines(tools, extraGuidelines) {
     if (tools.includes("question")) {
         add("When the user is explicitly discussing, brainstorming, or shaping an approach instead of asking for immediate execution, use the question tool for targeted clarification or preference choices when it would materially improve the discussion; do not use it for generic permission-to-proceed questions");
     }
+    if (tools.includes("todo_write")) {
+        add("Use todo_write to plan any task that needs three or more concrete steps before you start. Mark each item completed as soon as it is done; do not batch updates");
+    }
     for (const item of extraGuidelines) {
         add(item);
     }

package/dist/prompt/environment.js

@@ -9,11 +9,32 @@ export const defaultToolSnippets = {
     lsp: "Use the language server for code navigation, symbols, call hierarchy, and type-aware lookup",
     web_search: "Search the public web for current information",
     web_fetch: "Fetch and extract the contents of a specific webpage",
-    task: "Delegate a bounded investigative subtask to a read-only sub-agent",
+    spawn_agent: "Start a child subagent thread and return its agent id plus nickname",
+    wait_agent: "Wait for one or more spawned subagents to finish",
+    send_input: "Send follow-up input to an existing subagent thread",
+    close_agent: "Close or cancel a spawned subagent thread",
     question: "Ask the user structured questions when clarification or preference choices would materially improve the work",
     skill: "Load a named skill with specialized instructions and bundled resources",
+    todo_write: "Plan and track multi-step work. Mark each task completed as soon as it is done — do not batch.",
 };
-export const defaultToolNames = ["read", "glob", "bash", "edit", "write", "grep", "lsp", "web_search", "web_fetch", "task", "question", "skill"];
+export const defaultToolNames = [
+    "read",
+    "glob",
+    "bash",
+    "edit",
+    "write",
+    "grep",
+    "lsp",
+    "web_search",
+    "web_fetch",
+    "spawn_agent",
+    "wait_agent",
+    "send_input",
+    "close_agent",
+    "question",
+    "skill",
+    "todo_write",
+];
 export function buildEnvironmentPrompt(options = {}) {
     const configuredProvider = options.configuredProvider ?? "unknown";
     const configuredModel = options.configuredModel ?? "unknown";

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

@@ -3,6 +3,5 @@ export function buildDeepSeekProviderPrompt(agentName) {
 
 Prefer short plans followed by concrete tool use. Avoid broad speculation.
 After each tool result, update your understanding before choosing the next action.
-Do not repeat equivalent searches unless the previous result changed the search space.
-When provider/API behavior is involved, inspect serialization and request-shape code before changing generic agent logic.`;
+Do not repeat equivalent searches unless the previous result changed the search space.`;
 }

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

@@ -2,6 +2,5 @@ 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.
-For tool-call or reasoning-mode issues, inspect message history serialization before changing unrelated agent behavior.`;
+Do not fan out into many parallel search directions unless the task truly requires it.`;
 }

package/dist/prompt/reminders.d.ts

@@ -1,6 +1,6 @@
 /**
  * System reminders - short, runtime-variable instructions injected into the
- * message stream as <system-reminder>-wrapped user messages with isMeta=true.
+ * message stream as hidden meta messages.
  *
  * Rationale: the static system prompt is stable and cacheable. Mode transitions
  * and other ephemeral state are signaled via reminders so we do not invalidate
@@ -30,4 +30,23 @@ export declare function buildWorkflowPhaseReminder(input: {
     pending: string[];
 }): string;
 export declare function buildTaskSummaryReminder(): string;
-export declare function buildVerificationReminder(reason: string): string;
+/**
+ * Fired when the same edit/write tool call (identical tool name + args) has
+ * just failed for the second time in a row. Models — especially thinking-heavy
+ * ones — can otherwise spiral on `No changes made: identical content` or
+ * `oldText not found` because their internal reasoning convinces them they
+ * are typing the change correctly even though the JSON args arrive identical.
+ * This nudge forces a strategy change.
+ */
+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.
+ */
+export declare function buildRedundantReadReminder(path: string): string;
+/**
+ * Injected once at task start when the user's input looks like a small,
+ * focused task (e.g. "write an HTML page about X"). Counterweight to the
+ * default protocol which biases toward thorough exploration.
+ */
+export declare function buildSmallTaskHint(): string;