@bubblebrain-ai/bubble 0.0.18 → 0.0.20

package/dist/provider-anthropic.js

@@ -1,6 +1,10 @@
 import { getAvailableThinkingLevels, normalizeThinkingLevel } from "./provider-transform.js";
+import { isProviderTransportError, normalizeProviderNetworkError, providerFetch } from "./network/provider-transport.js";
+import { computeRetryDelayMs, getProviderMaxRetries, isRetryableHttpStatus, ProviderStreamInterruptedError, retryAfterMsFromResponse, sleepBeforeRetry, } from "./network/retry.js";
 const ANTHROPIC_VERSION = "2023-06-01";
 const DEFAULT_MAX_TOKENS = 8192;
+const ANTHROPIC_OPUS_LONG_OUTPUT_MAX_TOKENS = 128000;
+const ANTHROPIC_LONG_OUTPUT_MAX_TOKENS = 64000;
 const ANTHROPIC_PROMPT_CACHE_CONTROL = { type: "ephemeral" };
 const MINIMAX_PROMPT_CACHE_MODELS = new Set([
     "minimax-m2.7",
@@ -22,14 +26,14 @@ export function createAnthropicMessagesProvider(options) {
             thinkingLevel: chatOptions.thinkingLevel,
             stream: true,
         });
-        const response = await fetchAnthropicResponseWithRetry(options, {
+        const events = streamAnthropicEventsWithRetry(options, {
             url: resolveAnthropicMessagesUrl(options.baseURL),
             stream: true,
             method: "POST",
             body: JSON.stringify(body),
             signal: chatOptions.abortSignal,
         });
-        yield* translateAnthropicStream(readSseEvents(response));
+        yield* translateAnthropicStream(events);
         yield { type: "done" };
     }
     async function complete(messages, chatOptions) {
@@ -65,24 +69,37 @@ export function buildAnthropicRequest(options, messages, chatOptions) {
             cache_control: ANTHROPIC_PROMPT_CACHE_CONTROL,
         };
     }
+    const effectiveThinkingLevel = normalizeThinkingLevel(chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off", getAvailableThinkingLevels(options.providerId || "", chatOptions.model));
     const body = {
         model: chatOptions.model,
-        max_tokens: DEFAULT_MAX_TOKENS,
+        max_tokens: resolveAnthropicMaxTokens(options, chatOptions.model),
         system: buildAnthropicSystem(system, enablePromptCache),
         messages: anthropicMessages,
         tools: tools && tools.length > 0 ? tools : undefined,
         tool_choice: tools && tools.length > 0 ? { type: chatOptions.toolChoice ?? "auto" } : undefined,
         stream: chatOptions.stream || undefined,
     };
-    if (typeof chatOptions.temperature === "number") {
+    if (typeof chatOptions.temperature === "number"
+        && shouldSendTemperature(options, chatOptions.model, effectiveThinkingLevel)) {
         body.temperature = chatOptions.temperature;
     }
-    const effectiveThinkingLevel = normalizeThinkingLevel(chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off", getAvailableThinkingLevels(options.providerId || "", chatOptions.model));
     if (effectiveThinkingLevel !== "off") {
         body.thinking = { type: "adaptive" };
     }
     return body;
 }
+export function resolveAnthropicMaxTokens(options, model) {
+    if (!isOfficialAnthropicBaseUrl(options.baseURL)) {
+        return DEFAULT_MAX_TOKENS;
+    }
+    if (isFableModelWith128kOutput(model) || isOpusModelWith128kOutput(model)) {
+        return ANTHROPIC_OPUS_LONG_OUTPUT_MAX_TOKENS;
+    }
+    if (isSonnetOrHaikuModelWith64kOutput(model)) {
+        return ANTHROPIC_LONG_OUTPUT_MAX_TOKENS;
+    }
+    return DEFAULT_MAX_TOKENS;
+}
 function buildAnthropicSystem(system, enablePromptCache) {
     if (!system)
         return undefined;
@@ -352,27 +369,71 @@ export async function* readSseEvents(response) {
         reader.releaseLock();
     }
 }
+async function* streamAnthropicEventsWithRetry(options, request) {
+    const maxRetries = getProviderMaxRetries();
+    for (let attempt = 0;; attempt++) {
+        // Connection-level failures and retryable HTTP statuses are retried
+        // inside fetchAnthropicResponseWithRetry; an error thrown from it has
+        // already exhausted its budget, so it propagates without another loop.
+        const response = await fetchAnthropicResponseWithRetry(options, request);
+        let sawSseEvent = false;
+        try {
+            for await (const event of readSseEvents(response)) {
+                sawSseEvent = true;
+                yield event;
+            }
+            return;
+        }
+        catch (error) {
+            const normalized = normalizeAnthropicTransportError(error, request.url);
+            if (sawSseEvent) {
+                // Partial content already surfaced — only the agent loop can discard
+                // the half-built assistant message and safely re-issue the request.
+                if (!request.signal?.aborted && isProviderTransportError(error)) {
+                    throw new ProviderStreamInterruptedError(normalized.message, { cause: normalized });
+                }
+                throw normalized;
+            }
+            if (request.signal?.aborted || attempt >= maxRetries || !isProviderTransportError(error)) {
+                throw normalized;
+            }
+            await sleepBeforeRetry(computeRetryDelayMs(attempt + 1), request.signal);
+        }
+    }
+}
 async function fetchAnthropicResponseWithRetry(options, request) {
-    const maxAttempts = shouldRetryMiniMaxAnthropic(options) ? 2 : 1;
-    let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        const response = await fetch(request.url, {
-            method: request.method,
-            headers: buildAnthropicHeaders(options, request.stream),
-            body: request.body,
-            signal: request.signal,
-        });
+    const maxRetries = getProviderMaxRetries();
+    for (let attempt = 0;; attempt++) {
+        let response;
+        try {
+            response = await providerFetch(request.url, {
+                method: request.method,
+                headers: buildAnthropicHeaders(options, request.stream),
+                body: request.body,
+                signal: request.signal,
+                keepalive: false,
+            }, {
+                providerName: "Anthropic",
+                verboseEnvVar: "BUBBLE_ANTHROPIC_FETCH_VERBOSE",
+            });
+        }
+        catch (error) {
+            // No response received, so the request is safe to re-issue.
+            if (request.signal?.aborted || attempt >= maxRetries || !isProviderTransportError(error)) {
+                throw normalizeAnthropicTransportError(error, request.url);
+            }
+            await sleepBeforeRetry(computeRetryDelayMs(attempt + 1), request.signal);
+            continue;
+        }
         if (response.ok)
             return response;
         const detail = await readAnthropicErrorDetail(response);
         const error = new Error(`Anthropic Messages API error ${response.status}: ${detail || response.statusText}`);
-        lastError = error;
-        if (attempt >= maxAttempts || !isRetryableMiniMaxAnthropicError(response.status, detail)) {
+        if (request.signal?.aborted || attempt >= maxRetries || !isRetryableAnthropicHttpError(response.status, detail)) {
             throw error;
         }
-        await sleepBeforeRetry(getAnthropicRetryDelayMs(), request.signal);
+        await sleepBeforeRetry(computeRetryDelayMs(attempt + 1, { retryAfterMs: retryAfterMsFromResponse(response) }), request.signal);
     }
-    throw lastError ?? new Error("Anthropic Messages API request failed");
 }
 function resolveAnthropicMessagesUrl(baseURL) {
     const normalized = baseURL.trim().replace(/\/+$/, "");
@@ -403,42 +464,18 @@ async function readAnthropicErrorDetail(response) {
         return response.statusText;
     }
 }
-function shouldRetryMiniMaxAnthropic(options) {
-    const providerId = (options.providerId || "").toLowerCase();
-    const baseURL = options.baseURL.toLowerCase();
-    return providerId.startsWith("minimax") || baseURL.includes("api.minimaxi.com") || baseURL.includes("api.minimax.io");
-}
-function isRetryableMiniMaxAnthropicError(status, detail) {
-    return status === 500
-        || status === 502
-        || status === 503
-        || status === 504
-        || detail.includes("714 (1000)");
-}
-function getAnthropicRetryDelayMs() {
-    if (process.env.NODE_ENV === "test")
-        return 0;
-    return 800 + Math.floor(Math.random() * 700);
-}
-function sleepBeforeRetry(ms, signal) {
-    if (signal?.aborted) {
-        return Promise.reject(toAbortError(signal));
-    }
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(resolve, ms);
-        signal?.addEventListener("abort", () => {
-            clearTimeout(timeout);
-            reject(toAbortError(signal));
-        }, { once: true });
+function normalizeAnthropicTransportError(error, url) {
+    if (!isProviderTransportError(error)) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    return normalizeProviderNetworkError(error, {
+        providerName: "Anthropic",
+        input: url,
     });
 }
-function toAbortError(signal) {
-    const reason = signal?.reason;
-    if (reason instanceof Error)
-        return reason;
-    const error = new Error("Anthropic request retry aborted.");
-    error.name = "AbortError";
-    return error;
+function isRetryableAnthropicHttpError(status, detail) {
+    // "714 (1000)" is a transient MiniMax backend error surfaced as a 500.
+    return isRetryableHttpStatus(status) || detail.includes("714 (1000)");
 }
 function parseSseEvent(raw) {
     const dataLines = [];
@@ -573,6 +610,44 @@ function shouldEchoThinking(providerId) {
 function shouldSendBearerAuth(options) {
     return !isOfficialAnthropicBaseUrl(options.baseURL) || options.providerId?.startsWith("minimax") === true;
 }
+function shouldSendTemperature(options, model, thinkingLevel) {
+    if (!isOfficialAnthropicBaseUrl(options.baseURL))
+        return true;
+    if (thinkingLevel !== "off")
+        return false;
+    return !isOpusModelWithoutSamplingControls(model);
+}
+function isOpusModelWith128kOutput(model) {
+    return isClaudeFamilyVersionAtLeast(model, "opus", 4, 6);
+}
+function isFableModelWith128kOutput(model) {
+    return model.toLowerCase().startsWith("claude-fable-5");
+}
+function isSonnetOrHaikuModelWith64kOutput(model) {
+    const normalized = model.toLowerCase();
+    return normalized.startsWith("claude-sonnet-4-6")
+        || normalized.startsWith("claude-haiku-4-5");
+}
+function isOpusModelWithoutSamplingControls(model) {
+    return isClaudeFamilyVersionAtLeast(model, "opus", 4, 7);
+}
+function isClaudeFamilyVersionAtLeast(model, family, minMajor, minMinor) {
+    const normalized = model.toLowerCase();
+    if (!normalized.startsWith(`claude-${family}-`))
+        return false;
+    const [, , majorSegment, minorSegment] = normalized.split("-");
+    const major = Number(majorSegment);
+    if (!Number.isFinite(major))
+        return false;
+    if (major > minMajor)
+        return true;
+    if (major < minMajor)
+        return false;
+    if (!minorSegment || minorSegment.length > 2)
+        return false;
+    const minor = Number(minorSegment);
+    return Number.isFinite(minor) && minor >= minMinor;
+}
 function isMiniMaxAnthropicEndpoint(options) {
     const providerId = (options.providerId ?? "").toLowerCase();
     if (providerId !== "minimax" && providerId !== "minimax-anthropic")

package/dist/provider-openai-codex.js

@@ -2,11 +2,10 @@ import { createHash } from "node:crypto";
 import { listBuiltinModels } from "./model-catalog.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
 import { chatGptFetch } from "./network/chatgpt-transport.js";
+import { computeRetryDelayMs, getProviderMaxRetries, isRetryableHttpStatus, ProviderStreamInterruptedError, sleepBeforeRetry, } from "./network/retry.js";
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const OPENAI_BETA_RESPONSES = "responses=experimental";
 const TOKEN_REFRESH_GRACE_MS = 5 * 60 * 1000;
-const CODEX_TRANSPORT_MAX_RETRIES = 2;
-const CODEX_TRANSPORT_RETRY_BASE_DELAY_MS = 250;
 // OpenAI gates new codex models server-side by client_version (each model carries a
 // `minimal_client_version`). Track a recent real Codex CLI release; override via env
 // when OpenAI lifts the gate again before we cut a new release.
@@ -221,6 +220,13 @@ export function createOpenAICodexProvider(options) {
                 return;
             }
             catch (error) {
+                if (sawParsedSseEvent
+                    && !chatOptions.abortSignal?.aborted
+                    && isTransientCodexTransportError(error)) {
+                    // Partial content already surfaced — the agent loop discards the
+                    // half-built assistant message and re-issues the whole request.
+                    throw new ProviderStreamInterruptedError(error instanceof Error ? error.message : String(error), { cause: error });
+                }
                 if (!shouldRetryCodexTransportError({
                     error,
                     attempt,
@@ -229,7 +235,7 @@ export function createOpenAICodexProvider(options) {
                 })) {
                     throw error;
                 }
-                await sleepBeforeCodexRetry(codexRetryDelayMs(attempt), chatOptions.abortSignal);
+                await sleepBeforeRetry(computeRetryDelayMs(attempt + 1), chatOptions.abortSignal);
             }
         }
     }
@@ -439,9 +445,17 @@ function shouldRetryCodexTransportError(input) {
         return false;
     if (input.sawParsedSseEvent)
         return false;
-    if (input.attempt >= CODEX_TRANSPORT_MAX_RETRIES)
+    if (input.attempt >= getProviderMaxRetries())
+        return false;
+    return isTransientCodexTransportError(input.error) || isRetryableCodexHttpError(input.error);
+}
+function isRetryableCodexHttpError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const match = error.message.match(/^(\d{3}) status code/);
+    if (!match)
         return false;
-    return isTransientCodexTransportError(input.error);
+    return isRetryableHttpStatus(Number(match[1]));
 }
 function isTransientCodexTransportError(error) {
     const text = errorMessageChain(error).join("\n");
@@ -487,30 +501,6 @@ function errorMessageChain(error) {
     }
     return messages;
 }
-function codexRetryDelayMs(attempt) {
-    return CODEX_TRANSPORT_RETRY_BASE_DELAY_MS * Math.pow(3, attempt);
-}
-function sleepBeforeCodexRetry(ms, signal) {
-    if (signal?.aborted)
-        return Promise.reject(toAbortError(signal));
-    return new Promise((resolve, reject) => {
-        const onAbort = () => {
-            clearTimeout(timeout);
-            signal?.removeEventListener("abort", onAbort);
-            reject(toAbortError(signal));
-        };
-        const timeout = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
-}
-function toAbortError(signal) {
-    if (signal?.reason instanceof Error)
-        return signal.reason;
-    return new DOMException(typeof signal?.reason === "string" ? signal.reason : "Aborted", "AbortError");
-}
 function buildBaseHeaders(accessToken, accountId, sessionId, extraHeaders) {
     const headers = new Headers(extraHeaders);
     headers.set("Authorization", `Bearer ${accessToken}`);

package/dist/session-log.js

@@ -1,4 +1,4 @@
-import { sanitizeAssistantProviderMetadata, sanitizeInternalReminderBlocks } from "./agent/internal-reminder-sanitizer.js";
+import { sanitizeAssistantProviderMetadata, sanitizeInternalReasoningText, sanitizeInternalReminderBlocks, } from "./agent/internal-reminder-sanitizer.js";
 export class SessionLog {
     entries = [];
     load(lines) {
@@ -130,7 +130,7 @@ export class SessionLog {
                         role: "assistant",
                         content: sanitizeInternalReminderBlocks(entry.message.content),
                         reasoning: entry.message.reasoning !== undefined
-                            ? sanitizeInternalReminderBlocks(entry.message.reasoning)
+                            ? sanitizeInternalReasoningText(entry.message.reasoning)
                             : undefined,
                         providerMetadata: sanitizeAssistantProviderMetadata(cloneProviderMetadata(entry.message.providerMetadata)),
                     });
@@ -197,7 +197,7 @@ function normalizeMessageToEntries(message, id, timestamp) {
                     role: "assistant",
                     content: sanitizeInternalReminderBlocks(message.content),
                     reasoning: message.reasoning !== undefined
-                        ? sanitizeInternalReminderBlocks(message.reasoning)
+                        ? sanitizeInternalReasoningText(message.reasoning)
                         : undefined,
                     model: message.model,
                     providerId: message.providerId,

package/dist/slash-commands/commands.js

@@ -6,6 +6,7 @@ import { parseRule } from "../permissions/rule.js";
 import { encodeModel, decodeModel, displayModel, BUILTIN_PROVIDERS, isUserVisibleProvider } from "../provider-registry.js";
 import { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "../provider-transform.js";
 import { buildSystemPrompt } from "../system-prompt.js";
+import { HOOK_EVENT_NAMES, isHookEventName } from "../hooks/index.js";
 import { isThinkingLevel } from "../variant/thinking-level.js";
 import { collectUsageStatsBundle, formatStatsText } from "../stats/usage.js";
 import { buildMemoryPrompt, getMemoryStatus, isMemoryDisabled, resetMemory, searchMemory, } from "../memory/index.js";
@@ -49,6 +50,45 @@ function handlePermissionsMutation(sub, tokens, ctx) {
         return `Rule not found in ${scope} ${list}: ${rule}`;
     return `Removed from ${scope} ${list}: ${rule}`;
 }
+async function handleHooksCommand(args, ctx) {
+    const hooks = ctx.hookController;
+    if (!hooks)
+        return "Hooks controller is not attached to this session.";
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    const sub = tokens[0] ?? "status";
+    if (sub === "status" || sub === "list" || sub === "") {
+        return hooks.status();
+    }
+    if (sub === "reload") {
+        hooks.reload();
+        return `Reloaded hooks.\n\n${hooks.status()}`;
+    }
+    if (sub === "trust" && tokens[1] === "project") {
+        return hooks.trustProject();
+    }
+    if (sub === "untrust" && tokens[1] === "project") {
+        return hooks.untrustProject();
+    }
+    if (sub === "test") {
+        const event = tokens[1];
+        if (!isHookEventName(event)) {
+            return `Usage: /hooks test <event> [target]\nEvents: ${HOOK_EVENT_NAMES.join(", ")}`;
+        }
+        return hooks.test(event, tokens.slice(2).join(" ") || undefined);
+    }
+    if (sub === "explain") {
+        const event = tokens[1];
+        if (!isHookEventName(event)) {
+            return `Usage: /hooks explain <event>\nEvents: ${HOOK_EVENT_NAMES.join(", ")}`;
+        }
+        return hooks.explain(event);
+    }
+    if (sub === "logs") {
+        const limit = Number(tokens[1] ?? 20);
+        return hooks.logs(Number.isFinite(limit) ? limit : 20);
+    }
+    return "Usage: /hooks [status|reload|trust project|untrust project|test <event> [target]|explain <event>|logs [limit]]";
+}
 function persistSelectedModel(model, ctx) {
     const userConfig = new UserConfig();
     userConfig.setDefaultModel(model);
@@ -667,6 +707,13 @@ const builtinSlashCommandEntries = [
             return lines.join("\n");
         },
     },
+    {
+        name: "hooks",
+        description: "Inspect and manage lifecycle hooks. Usage: /hooks [status|trust project|test <event>]",
+        async handler(args, ctx) {
+            return handleHooksCommand(args, ctx);
+        },
+    },
     {
         name: "lsp",
         description: "Inspect or restart language servers. Usage: /lsp [status|diagnostics|restart]",
@@ -788,8 +835,33 @@ const builtinSlashCommandEntries = [
             if (!ctx.sessionManager) {
                 return "Compaction requires session persistence. Start an interactive session first.";
             }
+            const preHook = await ctx.hookController?.runEvent({
+                eventName: "PreCompact",
+                cwd: ctx.cwd,
+                sessionId: ctx.sessionManager.getSessionFile(),
+                agentRole: "driver",
+                target: "manual",
+                payload: {
+                    kind: "manual",
+                    messageCount: ctx.agent.messages.length,
+                },
+            });
+            if (preHook?.decision === "deny") {
+                return preHook.reason ?? `Compaction blocked by hook ${preHook.sourceHookId ?? "<unknown>"}.`;
+            }
             const result = ctx.sessionManager.compact();
             if (!result.compacted) {
+                await ctx.hookController?.runEvent({
+                    eventName: "PostCompact",
+                    cwd: ctx.cwd,
+                    sessionId: ctx.sessionManager.getSessionFile(),
+                    agentRole: "driver",
+                    target: "manual",
+                    payload: {
+                        kind: "manual",
+                        compacted: false,
+                    },
+                });
                 return "Session is already compact enough.";
             }
             const systemMessage = ctx.agent.messages.find((message) => message.role === "system");
@@ -799,6 +871,18 @@ const builtinSlashCommandEntries = [
             ];
             ctx.agent.resetContextUsageAnchor();
             const dropped = result.droppedEntries ?? 0;
+            await ctx.hookController?.runEvent({
+                eventName: "PostCompact",
+                cwd: ctx.cwd,
+                sessionId: ctx.sessionManager.getSessionFile(),
+                agentRole: "driver",
+                target: "manual",
+                payload: {
+                    kind: "manual",
+                    compacted: true,
+                    droppedEntries: dropped,
+                },
+            });
             return `✓ Compaction complete · ${dropped} log entr${dropped === 1 ? "y" : "ies"} summarized`;
         },
     },

package/dist/slash-commands/types.d.ts

@@ -9,6 +9,7 @@ import type { McpManager } from "../mcp/manager.js";
 import type { LspService } from "../lsp/index.js";
 import type { MemoryScope } from "../memory/index.js";
 import type { ThemeMode } from "../config.js";
+import type { ExternalHookController } from "../hooks/controller.js";
 export type SidebarMode = "auto" | "expanded" | "collapsed";
 export interface SidebarCommandState {
     mode: SidebarMode;
@@ -28,6 +29,7 @@ export interface SlashCommandContext {
     skillRegistry: SkillRegistry;
     bashAllowlist?: BashAllowlist;
     settingsManager?: SettingsManager;
+    hookController?: ExternalHookController;
     mcpManager?: McpManager;
     lspService?: LspService;
     flushMemory?: () => Promise<void>;

package/dist/tools/edit-apply.js

@@ -1,3 +1,4 @@
+import { isSensitivePath } from "./sensitive-paths.js";
 export class EditApplyError extends Error {
     status;
     constructor(message, status = "no_match") {
@@ -6,6 +7,9 @@ export class EditApplyError extends Error {
         this.name = "EditApplyError";
     }
 }
+const CANDIDATE_EXCERPT_CONTEXT_LINES = 3;
+const CANDIDATE_EXCERPT_MAX_LINES = 8;
+const CANDIDATE_EXCERPT_MAX_CHARS = 1200;
 function detectLineEnding(content) {
     const crlf = content.indexOf("\r\n");
     const lf = content.indexOf("\n");
@@ -234,19 +238,75 @@ function findBestLineHint(content, oldText) {
         return undefined;
     const contentLines = nonBlankLines(splitLines(content));
     let best;
+    let tieCount = 0;
     for (let i = 0; i < contentLines.length; i++) {
         let score = 0;
         for (let j = 0; j < oldLines.length && i + j < contentLines.length; j++) {
             if (contentLines[i + j].normalized === oldLines[j])
                 score++;
         }
-        if (!best || score > best.score)
+        if (!best || score > best.score) {
             best = { index: i, score };
+            tieCount = 1;
+        }
+        else if (score === best.score) {
+            tieCount++;
+        }
     }
     if (!best || best.score === 0)
         return undefined;
     const startLine = contentLines[best.index].lineIndex + 1;
-    return `Closest line-based candidate starts near line ${startLine} and matched ${best.score}/${oldLines.length} non-blank lines.`;
+    return {
+        startLine,
+        score: best.score,
+        total: oldLines.length,
+        lineIndex: contentLines[best.index].lineIndex,
+        tieCount,
+    };
+}
+function isHighConfidenceLineHint(hint) {
+    return hint.score >= 2 && hint.score / hint.total >= 0.5 && hint.tieCount === 1;
+}
+function formatLineHint(hint) {
+    if (hint.tieCount > 1) {
+        return `Closest ambiguous line-based candidate starts near line ${hint.startLine} and matched ${hint.score}/${hint.total} non-blank lines, but ${hint.tieCount} candidates tied. Current bytes were not included because the candidate may be unrelated.`;
+    }
+    if (!isHighConfidenceLineHint(hint)) {
+        return `Closest low-confidence line-based candidate starts near line ${hint.startLine} and matched ${hint.score}/${hint.total} non-blank lines. Current bytes were not included because the candidate may be unrelated.`;
+    }
+    return `Closest line-based candidate starts near line ${hint.startLine} and matched ${hint.score}/${hint.total} non-blank lines.`;
+}
+function formatFence(content) {
+    let fence = "```";
+    while (content.includes(fence))
+        fence += "`";
+    return `${fence}\n${content}\n${fence}`;
+}
+function truncateExcerpt(excerpt) {
+    if (excerpt.length <= CANDIDATE_EXCERPT_MAX_CHARS)
+        return excerpt;
+    const marker = "\n...[truncated current candidate excerpt]";
+    return excerpt.slice(0, Math.max(0, CANDIDATE_EXCERPT_MAX_CHARS - marker.length)) + marker;
+}
+function formatCandidateExcerpt(content, hint) {
+    const lines = splitLines(content);
+    const startLineIndex = Math.max(0, hint.lineIndex - CANDIDATE_EXCERPT_CONTEXT_LINES);
+    const requestedEnd = Math.min(lines.length, hint.lineIndex + CANDIDATE_EXCERPT_CONTEXT_LINES + 1);
+    const endLineIndex = Math.min(requestedEnd, startLineIndex + CANDIDATE_EXCERPT_MAX_LINES);
+    const excerpt = truncateExcerpt(lines.slice(startLineIndex, endLineIndex).map((line) => line.text).join("\n"));
+    return [
+        `Current candidate excerpt (high confidence, current file lines ${startLineIndex + 1}-${endLineIndex}, not guaranteed target):`,
+        formatFence(excerpt),
+    ].join("\n");
+}
+function formatBestLineHint(content, hint, options) {
+    const lineHint = formatLineHint(hint);
+    if (!isHighConfidenceLineHint(hint))
+        return lineHint;
+    if (options?.path && isSensitivePath(options.path)) {
+        return `${lineHint}\nCurrent bytes were not included because this path is blocked by the sensitive-path read policy.`;
+    }
+    return `${lineHint}\n\n${formatCandidateExcerpt(content, hint)}`;
 }
 function matchEdit(content, edit, index, total, options) {
     if (edit.oldText.length === 0) {
@@ -350,7 +410,7 @@ function matchEdit(content, edit, index, total, options) {
         }
     }
     const hint = findBestLineHint(content, oldText);
-    const hintSuffix = hint ? `\n${hint}` : "";
+    const hintSuffix = hint ? `\n${formatBestLineHint(content, hint, options)}` : "";
     const recovery = [
         "",
         "How to recover:",

package/dist/tools/edit.js

@@ -65,12 +65,12 @@ export function createEditTool(cwd, approval, lsp, fileState) {
         name: "edit",
         effect: "write_direct",
         requiresApproval: true,
-        description: "Edit a single file using targeted text replacements. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
+        description: "Edit a single file using targeted text replacements. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes overlap or one replacement is nested inside another, merge them into one edit. Do not include large unchanged regions just to connect distant changes.",
         promptSnippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
         promptGuidelines: [
-            "Use edit for precise changes; edits[].oldText should be copied from a recent read and must identify a unique target.",
-            "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls.",
-            "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
+            "Use edit for precise changes; each edits[].oldText must be copied verbatim from a fresh read of the current exact target block and must identify a unique target. Do not reconstruct oldText from memory, stale reads, or similar code elsewhere.",
+            "When changing multiple small, clearly disjoint locations copied from the same fresh read, you may use one edit call with multiple entries in edits[]. Use separate smaller edit calls after re-reading when anchors are uncertain, stale, or likely to drift.",
+            "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits; merge only truly overlapping targets.",
             "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
         ],
         parameters: {

package/dist/tui/display-history.d.ts

@@ -2,7 +2,6 @@ import type { ToolResultMetadata, TokenUsage } from "../types.js";
 export interface CompactionMeta {
     turns: number;
     messages: number;
-    tokensSaved: number;
     summarySections: Array<{
         label: string;
         content: string;
@@ -10,11 +9,12 @@ export interface CompactionMeta {
     contextWindow?: number;
     compactedAt: number;
 }
+export type UserInputStatus = "queued" | "pending_steer";
 export interface DisplayMessage {
     role: "user" | "assistant" | "error";
     content: string;
     clientId?: string;
-    queued?: boolean;
+    inputStatus?: UserInputStatus;
     reasoning?: string;
     toolCalls?: DisplayToolCall[];
     parts?: DisplayMessagePart[];
@@ -53,11 +53,12 @@ export interface DisplayToolCall {
     startedAt?: number;
     completedAt?: number;
 }
+export declare function userInputStatusBadgeLabel(status?: UserInputStatus): string | undefined;
+export declare function setUserInputStatus(message: DisplayMessage, inputStatus?: UserInputStatus): DisplayMessage;
 export declare function appendTextPart(parts: DisplayMessagePart[], content: string): void;
 export declare function appendToolPart(parts: DisplayMessagePart[], toolCall: DisplayToolCall): void;
 export declare function snapshotDisplayParts(parts: DisplayMessagePart[]): DisplayMessagePart[];
 export declare function contentFromParts(parts: DisplayMessagePart[]): string;
 export declare function toolCallsFromParts(parts: DisplayMessagePart[]): DisplayToolCall[];
 export declare function compactDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];
-export declare function truncateText(value: string, maxChars: number): string;
 export declare function formatCompactNumber(n: number): string;