tinker-agent 2.10.0 → 2.11.0

package/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable user-facing changes to Tinker are documented here. The project follo
 
 ## [Unreleased]
 
+## [2.11.0] - 2026-09-08
+
+### Added
+
+- Offer directories in the TUI `@` file-mention popup. Ancestor directories of
+  workspace files now appear alongside files, ranked after matching files, and
+  selecting a directory inserts its path directly instead of attempting an
+  image import.
+- Offer a retry selection in the TUI after provider retries are exhausted, so a
+  failed model request can be retried without re-entering the prompt.
+
+### Changed
+
+- Cache ESLint results for `check:fast` and split the fast test tier into
+  twelve independent shards, shortening local iteration while keeping the
+  serial full test run as the final gate.
+
+### Fixed
+
+- Align `Grep` context-line precedence and remove an unsupported regex hint
+  from its documentation.
+- Warm up the fake ripgrep binary in tests to absorb the macOS first-execution
+  validation delay.
+- Cancel pending image file opens without leaking file handles.
+- Emphasize TUI timeline labels and add spacing between messages.
+- Finalize scoped SQLite queries before closing the session database.
+
 ## [2.10.0] - 2026-09-06
 
 ### Added
@@ -437,7 +464,8 @@ All notable user-facing changes to Tinker are documented here. The project follo
 - First formal npm release under the `tinker-agent` package name with the `tinker`
   executable.
 
-[Unreleased]: https://github.com/ishowshao/tinker/compare/v2.10.0...HEAD
+[Unreleased]: https://github.com/ishowshao/tinker/compare/v2.11.0...HEAD
+[2.11.0]: https://github.com/ishowshao/tinker/releases/tag/v2.11.0
 [2.10.0]: https://github.com/ishowshao/tinker/releases/tag/v2.10.0
 [2.9.0]: https://github.com/ishowshao/tinker/releases/tag/v2.9.0
 [2.8.0]: https://github.com/ishowshao/tinker/releases/tag/v2.8.0

package/README.md

@@ -34,6 +34,19 @@ This does not pretend that any model has infinite tokens or guarantee that it wi
   explicit model and context limits. Actual provider support must be established
   by a qualification matrix; transport compatibility alone is not a guarantee.
 
+### Provider retry selection
+
+When automatic retries for a provider request are exhausted, the TUI offers
+**Retry again** or **End this turn**. Retrying reuses the same request within the
+same turn and iteration, with a fresh automatic retry allowance. Ending the turn
+(or pressing Esc in the selection) records the original failure. The selection
+adds no conversation message and applies only to the current running process.
+Retryable failures include HTTP 429/500/502/503/504, structured `server_error`
+and `rate_limit_exceeded` errors inside provider streams or failed Responses,
+and transient connection failures, including socket resets during streaming.
+Tool failures and non-retryable errors keep their existing behavior. One-shot
+and remote service runs do not wait for this TUI selection.
+
 ### PTY screen size
 
 `Bash` accepts optional `cols` and `rows` for the initial PTY screen size:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tinker-agent",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "description": "A personal coding agent with an interactive TUI and one-shot CLI.",
   "license": "Apache-2.0",
   "type": "module",
@@ -66,14 +66,15 @@
     "docs:check": "bun scripts/render-public-contract-docs.ts --check",
     "tinker": "bun src/cli/index.ts",
     "check": "bun run check:source-lines && bun run typecheck && bun run format:check && bun run lint && bun run docs:check && bun run test && bun run bench:smoke",
-    "check:fast": "bun run check:source-lines && bun run typecheck && bun run format:check && bun run lint && bun run test:fast",
+    "check:fast": "bun run check:source-lines && bun run typecheck && bun run format:check && bun run lint:fast && bun run test:fast",
     "check:source-lines": "bun scripts/check-source-lines.ts",
     "format": "biome format --write .",
     "format:check": "biome format .",
     "lint": "eslint \"bin/**/*.js\" \"src/**/*.{ts,tsx}\" \"scripts/**/*.ts\" \"packages/**/*.ts\" --max-warnings=0",
+    "lint:fast": "bun run lint --cache --cache-strategy content --cache-location .cache/eslint-fast/",
     "lint:fix": "eslint \"bin/**/*.js\" \"src/**/*.{ts,tsx}\" \"scripts/**/*.ts\" \"packages/**/*.ts\" --fix",
     "test": "FORCE_COLOR=0 bun test",
-    "test:fast": "FORCE_COLOR=0 bun test --path-ignore-patterns='**/*pty*.test.ts' --path-ignore-patterns='**/native-host-integration.test.ts'",
+    "test:fast": "bun scripts/run-test-shards.ts --path-ignore-patterns='**/*pty*.test.ts' --path-ignore-patterns='**/native-host-integration.test.ts'",
     "test:e2e": "FORCE_COLOR=0 bun test src/__tests__/cli-pty src/__tests__/pty-tui-harness packages/tinker-chrome/__tests__/native-host-integration",
     "typecheck": "tsc --noEmit"
   },

package/src/agent/loop.ts

@@ -1,3 +1,5 @@
+import type { ModelRequestFailedData } from "../events/types";
+import type { ProviderRetryDecision } from "./runtime-provider-retry";
 import {
   materializeModelRequest,
   type MaterializedModelRequest,
@@ -74,6 +76,11 @@ export type RunAgentInput = {
     usage: ContextUsageSnapshot;
   };
   transientRetryDelaysMs?: readonly number[];
+  requestProviderRetry?: (
+    iteration: IterationIdentity,
+    failure: ModelRequestFailedData,
+    signal: AbortSignal,
+  ) => Promise<ProviderRetryDecision>;
 };
 
 export class FatalAgentTurnError extends Error {
@@ -196,12 +203,13 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
       return failedResult(error, iteration);
     }
 
+    let maxAttempts = MODEL_REQUEST_MAX_ATTEMPTS;
     await input.runtimeSession.append({
       type: "model.request.started",
       ...iteration,
       data: {
         attemptNumber: 1,
-        maxAttempts: MODEL_REQUEST_MAX_ATTEMPTS,
+        maxAttempts,
       },
     });
 
@@ -240,7 +248,7 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
           ...iteration,
           data: {
             attemptNumber,
-            maxAttempts: MODEL_REQUEST_MAX_ATTEMPTS,
+            maxAttempts,
           },
         });
       }
@@ -289,19 +297,47 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
           transientRetries,
           transientRetryDelaysMs,
         });
+        const failure = modelRequestFailureData({
+          error,
+          request,
+          attemptNumber,
+          maxAttempts,
+          retryDisposition: decision.disposition,
+          ...(decision.disposition === "scheduled" && decision.delayMs > 0
+            ? { retryDelayMs: decision.delayMs }
+            : {}),
+        });
         await input.runtimeSession.append({
           type: "model.request.failed",
           ...iteration,
-          data: modelRequestFailureData({
-            error,
-            request,
-            attemptNumber,
-            retryDisposition: decision.disposition,
-            ...(decision.disposition === "scheduled" && decision.delayMs > 0
-              ? { retryDelayMs: decision.delayMs }
-              : {}),
-          }),
+          data: failure,
         });
+        if (decision.disposition === "exhausted" && input.requestProviderRetry) {
+          let retry: ProviderRetryDecision;
+          try {
+            retry = await input.requestProviderRetry(iteration, failure, input.signal);
+          } catch (retryError) {
+            if (input.signal.aborted) {
+              return cancelledResult(
+                cancellation(input.signal, iteration, "model_request"),
+                iteration,
+              );
+            }
+            throw retryError;
+          }
+          if (input.signal.aborted) {
+            return cancelledResult(
+              cancellation(input.signal, iteration, "model_request"),
+              iteration,
+            );
+          }
+          if (retry === "retry") {
+            reasoningOnlyRetries = 0;
+            transientRetries = 0;
+            maxAttempts = attemptNumber + MODEL_REQUEST_MAX_ATTEMPTS;
+            continue;
+          }
+        }
 
         if (decision.disposition === "scheduled") {
           if (decision.kind === "reasoning_only") {
@@ -349,7 +385,7 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
       ...iteration,
       data: {
         attemptNumber: successfulAttempt,
-        maxAttempts: MODEL_REQUEST_MAX_ATTEMPTS,
+        maxAttempts,
         output: modelOutput,
       },
     });
@@ -823,6 +859,7 @@ function modelRequestFailureData(input: {
   error: unknown;
   request: PreparedModelRequest;
   attemptNumber: number;
+  maxAttempts: number;
   retryDisposition: "scheduled" | "not_retryable" | "exhausted";
   retryDelayMs?: number;
 }) {
@@ -830,7 +867,7 @@ function modelRequestFailureData(input: {
     input.error instanceof ProviderResponseError ? input.error : undefined;
   return {
     attemptNumber: input.attemptNumber,
-    maxAttempts: MODEL_REQUEST_MAX_ATTEMPTS,
+    maxAttempts: input.maxAttempts,
     code: providerError?.code ?? ("provider_request_error" as const),
     retryDisposition: input.retryDisposition,
     ...(input.retryDelayMs === undefined ? {} : { retryDelayMs: input.retryDelayMs }),

package/src/agent/runtime-provider-retry.ts

@@ -0,0 +1,115 @@
+import type { AgentEventInput, ModelRequestFailedData } from "../events/types";
+import type { IterationIdentity } from "./types";
+import { cancellationError } from "./turn-cancellation";
+
+export type ProviderRetryDecision = "retry" | "stop";
+export type ProviderRetryRequest = {
+  readonly requestId: string;
+  readonly failure: ModelRequestFailedData;
+};
+export type ProviderRetrySnapshot = { readonly pending?: ProviderRetryRequest };
+export const EMPTY_PROVIDER_RETRY: ProviderRetrySnapshot = Object.freeze({});
+
+type PendingRetry = {
+  request: ProviderRetryRequest;
+  iteration: IterationIdentity;
+  startedAt: number;
+  signal: AbortSignal;
+  resolve: (decision: ProviderRetryDecision) => void;
+  reject: (error: unknown) => void;
+  removeAbortListener: () => void;
+};
+
+/** Process-local interaction; the original turn and model request remain open. */
+export class RuntimeProviderRetry {
+  private snapshot: ProviderRetrySnapshot = EMPTY_PROVIDER_RETRY;
+  private pending?: PendingRetry;
+  private readonly listeners = new Set<() => void>();
+
+  constructor(private readonly append: (event: AgentEventInput) => Promise<void>) {}
+
+  read(): ProviderRetrySnapshot {
+    return this.snapshot;
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  async request(
+    iteration: IterationIdentity,
+    failure: ModelRequestFailedData,
+    signal: AbortSignal,
+  ): Promise<ProviderRetryDecision> {
+    if (this.pending !== undefined) throw new Error("Provider retry already pending.");
+    if (signal.aborted) throw cancellationError(signal);
+    await this.append({ type: "model.retry.requested", ...iteration, data: failure });
+    return new Promise((resolve, reject) => {
+      const request = Object.freeze({
+        requestId: `${iteration.iterationId}:${failure.attemptNumber}`,
+        failure: Object.freeze({ ...failure }),
+      });
+      const pending: PendingRetry = {
+        request,
+        iteration,
+        startedAt: Date.now(),
+        signal,
+        resolve,
+        reject,
+        removeAbortListener: () => signal.removeEventListener("abort", onAbort),
+      };
+      const onAbort = () => {
+        // settle rejects the waiting loop too; do not leave a detached rejection.
+        void this.settle(pending, "cancelled").catch(() => undefined);
+      };
+      this.pending = pending;
+      this.snapshot = Object.freeze({ pending: request });
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted) onAbort();
+      else this.notify();
+    });
+  }
+
+  async resolve(requestId: string, decision: ProviderRetryDecision): Promise<void> {
+    const pending = this.pending;
+    if (pending === undefined || pending.request.requestId !== requestId) {
+      throw new Error("Provider retry question is no longer pending.");
+    }
+    if (decision !== "retry" && decision !== "stop") {
+      throw new Error("Invalid provider retry decision.");
+    }
+    await this.settle(pending, decision);
+  }
+
+  private async settle(
+    pending: PendingRetry,
+    decision: ProviderRetryDecision | "cancelled",
+  ): Promise<void> {
+    if (this.pending !== pending) return;
+    this.pending = undefined;
+    this.snapshot = EMPTY_PROVIDER_RETRY;
+    pending.removeAbortListener();
+    this.notify();
+    try {
+      await this.append({
+        type: "model.retry.resolved",
+        ...pending.iteration,
+        data: {
+          attemptNumber: pending.request.failure.attemptNumber,
+          decision,
+          durationMs: Date.now() - pending.startedAt,
+        },
+      });
+      if (decision === "cancelled") pending.reject(cancellationError(pending.signal));
+      else pending.resolve(decision);
+    } catch (error) {
+      pending.reject(error);
+      throw error;
+    }
+  }
+
+  private notify(): void {
+    for (const listener of this.listeners) listener();
+  }
+}

package/src/agent/runtime-session-contracts.ts

@@ -1,3 +1,7 @@
+import type {
+  ProviderRetryDecision,
+  ProviderRetrySnapshot,
+} from "./runtime-provider-retry";
 import type { PublicToolingConfig } from "../cli/public-config-contract";
 import type { ContextAutomationPolicy } from "../context/context-automation-policy";
 import type {
@@ -118,6 +122,12 @@ export type RuntimeSession = {
   subscribeBashGuard(listener: () => void): () => void;
   setYoloMode(enabled: boolean): void;
   resolveBashConfirmation(decision: "allow" | "deny"): Promise<void>;
+  providerRetry(): ProviderRetrySnapshot;
+  subscribeProviderRetry(listener: () => void): () => void;
+  resolveProviderRetry(
+    requestId: string,
+    decision: ProviderRetryDecision,
+  ): Promise<void>;
   askUser(): AskUserSnapshot;
   subscribeAskUser(listener: () => void): () => void;
   resolveAskUser(response: AskUserResolution): Promise<void>;
@@ -251,6 +261,7 @@ export type CommonRuntimeSessionInput = {
   completedTurnHook?: CompletedTurnHook;
   enableTurnUndo?: boolean;
   enableAskUser?: boolean;
+  enableProviderRetryPrompt?: boolean;
   bashGuard?: {
     readonly mode: "guard" | "yolo";
     readonly source: Exclude<BashGuardSource, "session">;

package/src/agent/runtime-session.ts

@@ -1,3 +1,7 @@
+import {
+  RuntimeProviderRetry,
+  type ProviderRetryDecision,
+} from "./runtime-provider-retry";
 import path from "node:path";
 import { assertContextMaintenanceCapabilities } from "./runtime-context-capabilities";
 import { CompiledContextError } from "../context/compiled-context-validator";
@@ -221,6 +225,7 @@ class DefaultRuntimeSession implements RuntimeSession {
 
   private readonly skillCatalog: SkillCatalogSnapshot;
   private readonly interactions: RuntimeInteractions;
+  private readonly providerRetryInteraction: RuntimeProviderRetry;
   private readonly scheduler: RuntimePromptScheduler;
   private readonly contextMaintenance: RuntimeContextMaintenance;
   private readonly runtimeSkills: RuntimeSkills;
@@ -234,6 +239,9 @@ class DefaultRuntimeSession implements RuntimeSession {
     private readonly store: SessionStore,
     private readonly assetStore: ImageAssetStore,
   ) {
+    this.providerRetryInteraction = new RuntimeProviderRetry((event) =>
+      this.append(event),
+    );
     this.sessionId = input.selection.sessionId;
     this.resumed = input.selection.mode === "resume";
     this.scheduler = new RuntimePromptScheduler(
@@ -694,6 +702,21 @@ class DefaultRuntimeSession implements RuntimeSession {
     return this.interactions.resolveBashConfirmation(decision);
   }
 
+  providerRetry() {
+    return this.providerRetryInteraction.read();
+  }
+
+  subscribeProviderRetry(listener: () => void): () => void {
+    return this.providerRetryInteraction.subscribe(listener);
+  }
+
+  resolveProviderRetry(
+    requestId: string,
+    decision: ProviderRetryDecision,
+  ): Promise<void> {
+    return this.providerRetryInteraction.resolve(requestId, decision);
+  }
+
   askUser(): AskUserSnapshot {
     return this.interactions.askUser();
   }
@@ -1184,6 +1207,12 @@ class DefaultRuntimeSession implements RuntimeSession {
           signal,
           assetStore: this.assetStore,
           initialRequest,
+          ...(this.input.enableProviderRetryPrompt === true
+            ? {
+                requestProviderRetry: (iteration, failure, signal) =>
+                  this.providerRetryInteraction.request(iteration, failure, signal),
+              }
+            : {}),
         });
       } catch (error) {
         if (error instanceof RuntimeEventAppendError) {

package/src/cli/tui-runner.tsx

@@ -119,6 +119,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
         toolingConfig: options.publicConfig.tooling,
         enableTurnUndo: true,
         enableAskUser: true,
+        enableProviderRetryPrompt: true,
         bashGuard: {
           mode: sessionConfig.bashGuardMode,
           source: sessionConfig.bashGuardSource,

package/src/events/types.ts

@@ -337,6 +337,12 @@ export type AgentEventDataMap = {
   "agent.iteration.started": { iterationNumber: number };
   "model.request.started": ModelRequestAttemptData;
   "model.request.failed": ModelRequestFailedData;
+  "model.retry.requested": ModelRequestFailedData;
+  "model.retry.resolved": {
+    attemptNumber: number;
+    decision: "retry" | "stop" | "cancelled";
+    durationMs: number;
+  };
   "model.request.finished": ModelRequestAttemptData & {
     output: ModelRequestOutput;
   };
@@ -457,6 +463,8 @@ export type AgentEventInput =
       | "agent.iteration.started"
       | "model.request.started"
       | "model.request.failed"
+      | "model.retry.requested"
+      | "model.retry.resolved"
       | "model.request.finished"
       | "context.usage.updated"
       | "context.shadow.planned"

package/src/image/abortable-file-open.ts

@@ -0,0 +1,54 @@
+import type { FileHandle } from "node:fs/promises";
+
+// An OS permission prompt can leave open() pending without accepting a signal.
+// Cancellation releases the caller; ownership of a late handle stays here.
+export function abortableFileOpen(
+  openFile: () => Promise<FileHandle>,
+  signal?: AbortSignal,
+  onWarning?: (message: string) => void,
+): Promise<FileHandle> {
+  signal?.throwIfAborted();
+  if (signal === undefined) return openFile();
+
+  return new Promise<FileHandle>((resolve, reject) => {
+    let cancelled = false;
+    const onAbort = () => {
+      cancelled = true;
+      signal.removeEventListener("abort", onAbort);
+      reject(asError(signal.reason));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    // Also handle a synchronous failure from the opener without leaking a listener.
+    Promise.resolve()
+      .then(() => {
+        signal.throwIfAborted();
+        return openFile();
+      })
+      .then(async (handle) => {
+        signal.removeEventListener("abort", onAbort);
+        if (cancelled) {
+          try {
+            await handle.close();
+          } catch (error) {
+            onWarning?.(
+              `Failed to close cancelled image file: ${error instanceof Error ? error.message : String(error)}.`,
+            );
+          }
+        } else {
+          resolve(handle);
+        }
+      })
+      .catch((error: unknown) => {
+        signal.removeEventListener("abort", onAbort);
+        if (cancelled) {
+          // Late open failures must not become unhandled rejections.
+          return;
+        }
+        reject(asError(error));
+      });
+  });
+}
+
+function asError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(String(error), { cause: error });
+}

package/src/image/image-asset-store.ts

@@ -13,6 +13,7 @@ import {
 import path from "node:path";
 import { createUuidV7 } from "../ids/uuid-v7";
 import { IMAGE_INPUT_POLICY } from "./image-input-policy";
+import { abortableFileOpen } from "./abortable-file-open";
 import { probeImageBytes } from "./image-probe";
 import {
   normalizeOriginalImageName,
@@ -116,9 +117,14 @@ export class ImageAssetStore {
       assertContained(this.workspaceRoot, canonicalSource, "Image source realpath");
     }
 
-    const handle = await open(canonicalSource, constants.O_RDONLY | noFollowFlag());
+    const handle = await abortableFileOpen(
+      () => open(canonicalSource, constants.O_RDONLY | noFollowFlag()),
+      options.signal,
+      this.onWarning,
+    );
     let bytes: Buffer;
     try {
+      throwIfAborted(options.signal);
       const handleStat = await handle.stat();
       if (
         !handleStat.isFile() ||

package/src/model/fake-model-client.ts

@@ -25,7 +25,7 @@ import type {
   PreparedModelRequest,
   PreparedPromptSegment,
 } from "./model-client";
-import { validateModelModalities } from "./model-client";
+import { ProviderResponseError, validateModelModalities } from "./model-client";
 import { sha256, stableJsonStringify } from "./model-request-preflight";
 import { estimatePromptSegments } from "./token-estimator";
 
@@ -212,6 +212,25 @@ export class FakeModelClient implements ModelClient {
       );
     }
 
+    if (this.mode === "pty-provider-retry") {
+      if (lastUserMessage(input.messages) === "PTY_RETRY_NEXT") {
+        return textOutput(prepared, "PTY_RETRY_NEXT_DONE");
+      }
+      if (this.steps <= 4) {
+        options.onTextDelta?.(
+          `## Attempt ${this.steps}\nPartial response\n\n## Unfinished\nDRAFT_ONLY`,
+        );
+        throw new ProviderResponseError(
+          "reasoning_only_assistant",
+          "PTY_PROVIDER_FAILURE",
+          {
+            provider: prepared.provider,
+            model: prepared.model,
+          },
+        );
+      }
+      return textOutput(prepared, "PTY_RETRY_DONE");
+    }
     if (this.mode === "write-notes") {
       return this.writeNotes(input, prepared, options);
     }

package/src/model/openai-model-utils.ts

@@ -358,12 +358,56 @@ function providerErrorCode(error: unknown): ProviderResponseErrorCode {
   if (status === 500 || status === 502 || status === 503 || status === 504) {
     return "provider_unavailable";
   }
-  if (status === undefined && error instanceof OpenAI.APIConnectionError) {
+  // Explicit HTTP failures take precedence over payload or transport hints.
+  if (status !== undefined) return "provider_request_error";
+  const code = errorField(error, "code");
+  if (code === "server_error") return "provider_unavailable";
+  if (code === "rate_limit_exceeded") return "provider_rate_limited";
+  if (error instanceof OpenAI.APIConnectionError || isTransportFailure(error)) {
     return "provider_unavailable";
   }
   return "provider_request_error";
 }
 
+const TRANSIENT_TRANSPORT_CODES = new Set([
+  "ECONNRESET",
+  "EPIPE",
+  "ETIMEDOUT",
+  "ERR_STREAM_PREMATURE_CLOSE",
+  "UND_ERR_SOCKET",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT",
+]);
+
+function isTransportFailure(error: unknown): boolean {
+  const seen = new Set<unknown>();
+  // Fetch may wrap a socket error in TypeError.cause after headers arrive.
+  for (let depth = 0; error !== undefined && depth < 8; depth += 1) {
+    if (seen.has(error)) return false;
+    seen.add(error);
+    if (
+      errorField(error, "name") === "AbortError" ||
+      error instanceof OpenAI.APIUserAbortError ||
+      providerErrorStatus(error) !== undefined
+    ) {
+      return false;
+    }
+    const code = errorField(error, "code");
+    if (code !== undefined) {
+      return typeof code === "string" && TRANSIENT_TRANSPORT_CODES.has(code);
+    }
+    error = errorField(error, "cause");
+  }
+  return false;
+}
+
+function errorField(error: unknown, key: string): unknown {
+  return typeof error === "object" && error !== null
+    ? (error as Record<string, unknown>)[key]
+    : undefined;
+}
+
 function providerErrorStatus(error: unknown): number | undefined {
   if (typeof error !== "object" || error === null || !("status" in error)) {
     return undefined;

package/src/model/openai-responses-mapping.ts

@@ -28,6 +28,7 @@ import {
   type ProviderResponseDiagnostics,
 } from "./model-client";
 import { imageAssetUrlMarker } from "./openai-image-mapping";
+import { sanitizedProviderError } from "./openai-model-utils";
 
 export type OpenAIResponsesMappingOptions = {
   materializedImages?: ReadonlyMap<ImageAssetId, string>;
@@ -160,6 +161,16 @@ export function fromOpenAIResponse(
 ): ModelRequestOutput {
   const root = requireRecord(response, "response", options);
   const status = requireString(root.status, "status", options);
+  if (status === "failed") {
+    const error = requireRecord(root.error, "error", options);
+    const code = requireString(error.code, "error.code", options);
+    const message = requireString(error.message, "error.message", options);
+    throw sanitizedProviderError(
+      Object.assign(new Error(message), { code }),
+      options.provider,
+      options.model,
+    );
+  }
   if (status !== "completed" && status !== "incomplete") {
     throw providerResponseError(
       options,

package/src/model/openai-responses-stream.ts

@@ -2,6 +2,7 @@ import {
   ProviderResponseError,
   type ProviderResponseDiagnostics,
 } from "./model-client";
+import { sanitizedProviderError } from "./openai-model-utils";
 
 export class OpenAIResponsesStreamAccumulator {
   private eventCount = 0;
@@ -20,6 +21,19 @@ export class OpenAIResponsesStreamAccumulator {
     const type = requireString(record.type, `${path}.type`, this.options);
     this.eventCount += 1;
 
+    if (type === "error") {
+      const message = requireString(record.message, `${path}.message`, this.options);
+      const code =
+        record.code === null
+          ? null
+          : requireString(record.code, `${path}.code`, this.options);
+      throw sanitizedProviderError(
+        Object.assign(new Error(message), { code }),
+        this.options.provider,
+        this.options.model,
+      );
+    }
+
     if (type === "response.output_text.delta") {
       return requireString(record.delta, `${path}.delta`, this.options);
     }

package/src/session/scoped-query-database.ts

@@ -0,0 +1,27 @@
+import { Database, type SQLQueryBindings } from "bun:sqlite";
+
+/**
+ * Own every query statement until a short-lived connection closes. Bun only
+ * caches its first 20 queries; later statements otherwise survive close() until
+ * GC, leaving a zombie SQLite connection behind. Do not use this for resident
+ * stores: retaining every query is intentionally bounded by the operation.
+ */
+export class ScopedQueryDatabase extends Database {
+  private readonly queries = new Set<{ finalize(): void }>();
+
+  override query<Result, Params extends SQLQueryBindings | SQLQueryBindings[]>(
+    sql: string,
+  ) {
+    const statement = super.query<Result, Params>(sql);
+    this.queries.add(statement);
+    return statement;
+  }
+
+  override close(): void {
+    for (const statement of this.queries) statement.finalize();
+    this.queries.clear();
+    // Also finalizes Bun's transaction statements and rejects any other live
+    // resources instead of silently deferring the underlying connection close.
+    super.close(true);
+  }
+}

package/src/session/session-history-access.ts

@@ -1,4 +1,5 @@
-import { Database } from "bun:sqlite";
+import type { Database } from "bun:sqlite";
+import { ScopedQueryDatabase } from "./scoped-query-database";
 import { lstat, readdir, realpath } from "node:fs/promises";
 import path from "node:path";
 import { throwIfTurnCancelled } from "../agent/turn-cancellation";
@@ -67,7 +68,7 @@ export function createSessionHistoryAccess(input: {
         throwIfTurnCancelled(signal);
         await validateHistoryFiles(location.databasePath, sessionId);
         throwIfTurnCancelled(signal);
-        const database = new Database(location.databasePath, {
+        const database = new ScopedQueryDatabase(location.databasePath, {
           readonly: true,
           strict: true,
           safeIntegers: true,
@@ -100,7 +101,7 @@ export function createSessionHistoryAccess(input: {
           throwIfTurnCancelled(signal);
           return result;
         } finally {
-          database.close(true);
+          database.close();
         }
       } catch (error) {
         throwIfTurnCancelled(signal);

package/src/session/session-store.ts

@@ -1,4 +1,5 @@
 import { Database } from "bun:sqlite";
+import { ScopedQueryDatabase } from "./scoped-query-database";
 import { randomUUID } from "node:crypto";
 import { chmod, mkdir, open, readdir, rename, rmdir } from "node:fs/promises";
 import path from "node:path";
@@ -1327,7 +1328,7 @@ export class SessionStore implements SessionLedgerCommitter {
       await chmod(stagingDatabasePath, 0o600);
       input.faultInjector?.("after_snapshot");
 
-      stagingDatabase = openWritableDatabase(stagingDatabasePath);
+      stagingDatabase = openWritableDatabase(stagingDatabasePath, ScopedQueryDatabase);
       verifySessionSchema(stagingDatabase, this.sessionId);
       dropSessionCloneTriggers(stagingDatabase);
       input.faultInjector?.("after_trigger_drop");
@@ -1542,8 +1543,11 @@ export async function resolveSessionDatabasePath(
   );
 }
 
-function openWritableDatabase(databasePath: string): Database {
-  const database = new Database(databasePath, {
+function openWritableDatabase(
+  databasePath: string,
+  DatabaseType: typeof Database = Database,
+): Database {
+  const database = new DatabaseType(databasePath, {
     create: false,
     readwrite: true,
     strict: true,

package/src/tools/grep.ts

@@ -72,7 +72,7 @@ export function createGrepToolExecutor(options: GrepToolOptions): ToolExecutor {
           path: {
             type: "string",
             description:
-              "Optional workspace-relative or absolute file or directory to search in. Defaults to the current workspace-local cwd. For directories, ripgrep runs in that directory with . as its search path; explicitly selecting an excluded directory allows searching inside it. Files are passed as absolute paths: explicit files bypass ignore/glob/type filtering, and explicit symlink files are followed. Explicit binary files may yield matches but are not guaranteed to be searched completely.",
+              "Optional workspace-relative or absolute file or directory to search in. Defaults to the current workspace-local cwd. For directories, ripgrep runs in that directory with . as its search path; explicitly selecting an excluded directory allows searching inside it. Files are passed as absolute paths: explicit files bypass ignore/glob/type filtering, and explicit symlink files are followed. Explicit binary files may yield matches but are not guaranteed to be searched completely, and reported line numbers may be inaccurate.",
           },
           glob: {
             type: "string",
@@ -202,7 +202,7 @@ export function createGrepToolExecutor(options: GrepToolOptions): ToolExecutor {
           absoluteSearchPath,
           mode,
           truncated: rg.truncated ? true : undefined,
-          error: rg.error ?? "ripgrep failed.",
+          error: omitUnsupportedRegexHint(rg.error ?? "ripgrep failed."),
         });
       }
 
@@ -368,11 +368,19 @@ export function buildRipgrepArgs(
 function resolveGrepContext(input: GrepArgs) {
   const both = input.context ?? input.contextAlias;
   return {
-    before: both ?? input.before ?? 0,
-    after: both ?? input.after ?? 0,
+    before: input.before ?? both ?? 0,
+    after: input.after ?? both ?? 0,
   };
 }
 
+function omitUnsupportedRegexHint(error: string): string {
+  // Grep does not expose rg's PCRE2 flag; preserve the diagnostic itself.
+  return error.replace(
+    /\n+Consider enabling PCRE2 with the --pcre2 flag, which can handle backreferences\s+and look-around\.\s*$/,
+    "",
+  );
+}
+
 type ParsedGrepArgs =
   | { ok: true; value: GrepArgs }
   | { ok: false; error: string; pattern?: string; mode?: GrepOutputMode };

package/src/tui/app.tsx

@@ -1,3 +1,4 @@
+import { EMPTY_PROVIDER_RETRY } from "../agent/runtime-provider-retry";
 import { Box, Static, Text, useApp, useInput, useStdout, useWindowSize } from "ink";
 import {
   useCallback,
@@ -143,6 +144,12 @@ export function App(props: AppProps) {
     () => binding.bashGuard(),
     () => binding.bashGuard(),
   );
+  const providerRetry = useSyncExternalStore(
+    (listener) => binding.subscribeProviderRetry?.(listener) ?? (() => undefined),
+    () => binding.providerRetry?.() ?? EMPTY_PROVIDER_RETRY,
+    () => EMPTY_PROVIDER_RETRY,
+  );
+  const pendingProviderRetry = providerRetry.pending;
   const askUser = useSyncExternalStore(
     (listener) => binding.subscribeAskUser(listener),
     () => binding.askUser(),
@@ -282,7 +289,12 @@ export function App(props: AppProps) {
       setIsCancelling(true);
       setNotice("Cancelling current turn...");
     },
-    { isActive: executionRunning && askUser.pending === undefined },
+    {
+      isActive:
+        executionRunning &&
+        askUser.pending === undefined &&
+        pendingProviderRetry === undefined,
+    },
   );
 
   const closeResumePicker = () => {
@@ -912,7 +924,8 @@ export function App(props: AppProps) {
                 status={
                   isCancelling
                     ? "cancelling"
-                    : askUser.pending !== undefined
+                    : askUser.pending !== undefined ||
+                        pendingProviderRetry !== undefined
                       ? "waiting_for_answer"
                       : executionRunning
                         ? "running"
@@ -924,7 +937,35 @@ export function App(props: AppProps) {
               />
             </Box>
             <Box marginTop={1} flexDirection="column" flexShrink={0}>
-              {askUser.pending !== undefined ? (
+              {pendingProviderRetry !== undefined ? (
+                <AskUser
+                  key={pendingProviderRetry.requestId}
+                  title="Provider request failed"
+                  question={`Automatic retries exhausted. ${pendingProviderRetry.failure.error.slice(0, 500)}`}
+                  options={[
+                    { description: "Retry again" },
+                    { description: "End this turn" },
+                  ]}
+                  dismissLabel="end this turn"
+                  onSelect={(index) => {
+                    void binding
+                      .resolveProviderRetry?.(
+                        pendingProviderRetry.requestId,
+                        index === 0 ? "retry" : "stop",
+                      )
+                      .catch((error: unknown) =>
+                        setNotice(`Retry selection failed: ${errorMessage(error)}`),
+                      );
+                  }}
+                  onDismiss={() => {
+                    void binding
+                      .resolveProviderRetry?.(pendingProviderRetry.requestId, "stop")
+                      .catch((error: unknown) =>
+                        setNotice(`Retry selection failed: ${errorMessage(error)}`),
+                      );
+                  }}
+                />
+              ) : askUser.pending !== undefined ? (
                 <AskUser
                   question={askUser.pending.question}
                   options={askUser.pending.options}
@@ -977,6 +1018,7 @@ export function App(props: AppProps) {
                     isCopying ||
                     isCancelling ||
                     askUser.pending !== undefined ||
+                    pendingProviderRetry !== undefined ||
                     bashGuard.pending !== undefined
                   }
                   history={props.history}

package/src/tui/components/ask-user.tsx

@@ -1,8 +1,10 @@
 import { Box, Text, useInput } from "ink";
-import { useState } from "react";
+import { useRef, useState } from "react";
 
 export type AskUserProps = {
   question: string;
+  title?: string;
+  dismissLabel?: string;
   options: readonly { readonly description: string }[];
   onSelect(selectedIndex: number): void;
   onDismiss(): void;
@@ -10,6 +12,12 @@ export type AskUserProps = {
 
 export function AskUser(props: AskUserProps) {
   const [selectedIndex, setSelectedIndex] = useState(0);
+  const selection = useRef(0);
+  const moveSelection = (offset: number) => {
+    selection.current =
+      (selection.current + offset + props.options.length) % props.options.length;
+    setSelectedIndex(selection.current);
+  };
 
   useInput((input, key) => {
     if (key.escape) {
@@ -17,17 +25,15 @@ export function AskUser(props: AskUserProps) {
       return;
     }
     if (key.upArrow) {
-      setSelectedIndex((current) =>
-        current === 0 ? props.options.length - 1 : current - 1,
-      );
+      moveSelection(-1);
       return;
     }
     if (key.downArrow) {
-      setSelectedIndex((current) => (current + 1) % props.options.length);
+      moveSelection(1);
       return;
     }
     if (key.return) {
-      props.onSelect(selectedIndex);
+      props.onSelect(selection.current);
       return;
     }
     if (/^[1-6]$/.test(input)) {
@@ -41,7 +47,7 @@ export function AskUser(props: AskUserProps) {
   return (
     <Box flexDirection="column" borderStyle="round" borderColor="cyan" paddingX={1}>
       <Text color="cyan" bold>
-        Tinker asks
+        {props.title ?? "Tinker asks"}
       </Text>
       <Text>{props.question}</Text>
       <Box flexDirection="column" marginTop={1}>
@@ -54,7 +60,8 @@ export function AskUser(props: AskUserProps) {
         ))}
       </Box>
       <Text dimColor>
-        ↑/↓ select · 1-{props.options.length} choose · Enter confirm · Esc skip
+        ↑/↓ select · 1-{props.options.length} choose · Enter confirm · Esc{" "}
+        {props.dismissLabel ?? "skip"}
       </Text>
     </Box>
   );

package/src/tui/components/prompt-input.tsx

@@ -41,7 +41,11 @@ import {
   type PromptDraft,
 } from "../prompt-draft";
 import { matchSlashCommands, type SlashCommand } from "../slash-commands";
-import { listWorkspaceFiles, type WorkspaceFileLister } from "../workspace-file-search";
+import {
+  listWorkspaceFiles,
+  listWorkspaceFilesAndDirectories,
+  type WorkspaceFileLister,
+} from "../workspace-file-search";
 
 export type PromptSubmission = {
   readonly draft: PromptDraft;
@@ -183,7 +187,10 @@ export function PromptInput(props: PromptInputProps) {
     () =>
       fileQuery === undefined || fileCatalog.status !== "ready"
         ? []
-        : rankWorkspaceFiles(fileCatalog.files, fileQuery),
+        : rankWorkspaceFiles(
+            listWorkspaceFilesAndDirectories(fileCatalog.files),
+            fileQuery,
+          ),
     [fileCatalog, fileQuery],
   );
   const suggestions =
@@ -223,13 +230,14 @@ export function PromptInput(props: PromptInputProps) {
     });
   };
 
-  const selectFile = (filePath: string) => {
+  const selectFile = (match: FileMentionMatch) => {
+    const filePath = match.path;
     const mention = findFileMention(state.draft.editor);
     if (mention === undefined || locked) {
       return;
     }
     const importImage = props.importImage;
-    if (importImage === undefined) {
+    if (importImage === undefined || match.kind === "directory") {
       insertFilePath(filePath);
       return;
     }
@@ -616,7 +624,7 @@ export function PromptInput(props: PromptInputProps) {
       const selectedCommand = suggestions[selectedIndex];
       if (key.return) {
         if (filePopupActive && selectedFile !== undefined) {
-          selectFile(selectedFile.path);
+          selectFile(selectedFile);
         } else if (selectedCommand !== undefined) {
           submitDraft(createPromptDraft(`/${selectedCommand.name}`));
         } else {
@@ -629,7 +637,7 @@ export function PromptInput(props: PromptInputProps) {
           if (selectedFile === undefined) {
             setState((current) => ({ ...current, suggestionsDismissed: true }));
           } else {
-            selectFile(selectedFile.path);
+            selectFile(selectedFile);
           }
         } else if (selectedCommand !== undefined) {
           setState(createPromptInputState(`/${selectedCommand.name} `));

package/src/tui/components/timeline.tsx

@@ -26,16 +26,16 @@ export function TimelineRow(props: { item: TimelineItem }) {
   if (item.label !== undefined) {
     if (item.label === "assistant") {
       return (
-        <Fragment>
-          <Text color="gray">- {item.label}</Text>
+        <Box flexDirection="column" marginTop={1}>
+          <TimelineLabel label={item.label} />
           <AssistantMarkdown text={item.text} />
-        </Fragment>
+        </Box>
       );
     }
 
     return (
-      <Fragment>
-        <Text color="gray">- {item.label}</Text>
+      <Box flexDirection="column" marginY={1}>
+        <TimelineLabel label={item.label} />
         {item.userPrompt === undefined ? (
           <Text color={colorForStatus(item.status)}>{formatTimelineItem(item)}</Text>
         ) : (
@@ -44,7 +44,7 @@ export function TimelineRow(props: { item: TimelineItem }) {
         {renderItemBash(item)}
         {renderItemDiff(item)}
         {renderItemPlan(item)}
-      </Fragment>
+      </Box>
     );
   }
 
@@ -60,10 +60,18 @@ export function TimelineRow(props: { item: TimelineItem }) {
 
 export function AssistantStreamSectionRow(props: { item: AssistantStreamSectionItem }) {
   return (
-    <Fragment>
-      {props.item.showAssistantLabel ? <Text color="gray">- assistant</Text> : null}
+    <Box flexDirection="column" marginTop={props.item.showAssistantLabel ? 1 : 0}>
+      {props.item.showAssistantLabel ? <TimelineLabel label="assistant" /> : null}
       <AssistantMarkdown text={props.item.markdown} />
-    </Fragment>
+    </Box>
+  );
+}
+
+function TimelineLabel(props: { label: string }) {
+  return (
+    <Text color="cyan" bold>
+      - {props.label}
+    </Text>
   );
 }
 

package/src/tui/event-store.ts

@@ -205,6 +205,16 @@ export function reduceTuiProjection(
           status: "running",
         })),
       );
+    case "model.retry.requested":
+      return updateActiveTurn(state, event, policy, (turn) =>
+        updateTurnItem(turn, modelRequestRef(event.iterationId), (item) => ({
+          ...item,
+          text: `model iteration ${event.iterationNumber} · waiting for retry selection`,
+          status: "running",
+        })),
+      );
+    case "model.retry.resolved":
+      return state;
     case "model.request.finished":
       return updateActiveTurn(state, event, policy, (turn) =>
         updateTurnItem(turn, modelRequestRef(event.iterationId), (item) => ({

package/src/tui/file-mention.ts

@@ -12,6 +12,7 @@ export type FileMentionMatch = {
   path: string;
   indices: readonly number[];
   score: number;
+  kind: "file" | "directory";
 };
 
 export function findFileMention(editor: LineEditorState): FileMention | undefined {
@@ -76,8 +77,13 @@ export function rankWorkspaceFiles(
 ): FileMentionMatch[] {
   if (query === "") {
     return files
-      .map((filePath) => ({ path: filePath, indices: [], score: 0 }))
-      .sort((left, right) => compareShallowPaths(left.path, right.path))
+      .map((filePath) => ({
+        path: filePath,
+        indices: [],
+        score: 0,
+        kind: fileMentionKind(filePath),
+      }))
+      .sort((left, right) => compareShallowPaths(left, right))
       .slice(0, limit);
   }
 
@@ -104,6 +110,7 @@ function fuzzyMatchPath(filePath: string, query: string): FileMentionMatch | und
       path: filePath,
       indices: basenameMatch.indices,
       score: basenameMatch.score + 200,
+      kind: fileMentionKind(filePath),
     };
   }
 
@@ -115,6 +122,7 @@ function fuzzyMatchPath(filePath: string, query: string): FileMentionMatch | und
     path: filePath,
     indices: fullPathMatch.indices,
     score: fullPathMatch.score,
+    kind: fileMentionKind(filePath),
   };
 }
 
@@ -167,6 +175,11 @@ function compareFileMatches(left: FileMentionMatch, right: FileMentionMatch): nu
     return right.score - left.score;
   }
 
+  const kindDifference = left.kind === right.kind ? 0 : left.kind === "file" ? -1 : 1;
+  if (kindDifference !== 0) {
+    return kindDifference;
+  }
+
   const depthDifference = pathDepth(left.path) - pathDepth(right.path);
   if (depthDifference !== 0) {
     return depthDifference;
@@ -178,9 +191,16 @@ function compareFileMatches(left: FileMentionMatch, right: FileMentionMatch): nu
     : lengthDifference;
 }
 
-function compareShallowPaths(left: string, right: string): number {
-  const depthDifference = pathDepth(left) - pathDepth(right);
-  return depthDifference === 0 ? comparePathText(left, right) : depthDifference;
+function compareShallowPaths(left: FileMentionMatch, right: FileMentionMatch): number {
+  const kindDifference = left.kind === right.kind ? 0 : left.kind === "file" ? -1 : 1;
+  if (kindDifference !== 0) {
+    return kindDifference;
+  }
+
+  const depthDifference = pathDepth(left.path) - pathDepth(right.path);
+  return depthDifference === 0
+    ? comparePathText(left.path, right.path)
+    : depthDifference;
 }
 
 function comparePathText(left: string, right: string): number {
@@ -196,6 +216,10 @@ function comparePathText(left: string, right: string): number {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
+function fileMentionKind(filePath: string): FileMentionMatch["kind"] {
+  return filePath.endsWith("/") || filePath.endsWith("\\") ? "directory" : "file";
+}
+
 function pathDepth(filePath: string): number {
   return [...filePath].filter((char) => char === "/" || char === "\\").length;
 }

package/src/tui/tui-projection-store.ts

@@ -205,12 +205,15 @@ export class TuiProjectionStore implements EventSink, AssistantTextDeltaSink {
       return false;
     }
     this.assistantStreamAttempt = undefined;
-    if (event.data.retryDisposition !== "scheduled" || attempt.sectionCount === 0) {
+    if (attempt.sectionCount === 0) {
       return false;
     }
     this.appendCommitted({
       id: `assistant-stream-retry-${attempt.iterationId}-${attempt.attemptNumber}`,
-      text: "assistant response interrupted · retrying",
+      text:
+        event.data.retryDisposition === "scheduled"
+          ? "assistant response interrupted · retrying"
+          : "assistant response interrupted",
       status: "info",
     });
     return true;

package/src/tui/tui-session-controller.ts

@@ -54,6 +54,9 @@ export type TuiSessionBinding = {
   subscribeBashGuard(listener: () => void): () => void;
   setYoloMode(enabled: boolean): void;
   resolveBashConfirmation(decision: "allow" | "deny"): Promise<void>;
+  providerRetry?: RuntimeSession["providerRetry"];
+  subscribeProviderRetry?: RuntimeSession["subscribeProviderRetry"];
+  resolveProviderRetry?: RuntimeSession["resolveProviderRetry"];
   askUser(): AskUserSnapshot;
   subscribeAskUser(listener: () => void): () => void;
   resolveAskUser(response: AskUserResolution): Promise<void>;
@@ -267,6 +270,11 @@ export function managedTuiBinding(input: {
     setYoloMode: (enabled) => input.runtimeSession.setYoloMode(enabled),
     resolveBashConfirmation: (decision) =>
       input.runtimeSession.resolveBashConfirmation(decision),
+    providerRetry: () => input.runtimeSession.providerRetry(),
+    subscribeProviderRetry: (listener) =>
+      input.runtimeSession.subscribeProviderRetry(listener),
+    resolveProviderRetry: (requestId, decision) =>
+      input.runtimeSession.resolveProviderRetry(requestId, decision),
     askUser: () => input.runtimeSession.askUser(),
     subscribeAskUser: (listener) => input.runtimeSession.subscribeAskUser(listener),
     resolveAskUser: (response) => input.runtimeSession.resolveAskUser(response),

package/src/tui/workspace-file-search.ts

@@ -93,6 +93,27 @@ export function createWorkspaceFileLister(
 
 export const listWorkspaceFiles = createWorkspaceFileLister();
 
+export function deriveWorkspaceDirectories(files: readonly string[]): string[] {
+  const directories = new Set<string>();
+
+  for (const filePath of files) {
+    for (let index = 0; index < filePath.length; index += 1) {
+      const char = filePath[index];
+      if ((char === "/" || char === "\\") && index > 0) {
+        directories.add(filePath.slice(0, index + 1));
+      }
+    }
+  }
+
+  return [...directories];
+}
+
+export function listWorkspaceFilesAndDirectories(
+  files: readonly string[],
+): readonly string[] {
+  return [...files, ...deriveWorkspaceDirectories(files)];
+}
+
 function splitPaths(stdout: string): string[] {
   return stdout
     .split("\n")