tinker-agent 2.10.0 → 2.12.0

package/CHANGELOG.md

@@ -5,6 +5,50 @@ All notable user-facing changes to Tinker are documented here. The project follo
 
 ## [Unreleased]
 
+## [2.12.0] - 2026-09-11
+
+### Changed
+
+- Replace the vector memory system with plain-text Markdown records. Session
+  transcripts are appended to `memory/records/<sessionId>.md` in the global
+  Tinker home, and `MemoryCreate` saves explicit Markdown notes. `MemorySearch`
+  searches all memory files with literal, case-insensitive keywords and
+  paginated, grouped passages; the `MemoryGet`, `MemoryUpdate`, and
+  `MemoryDelete` tools and the `memory` model-profile configuration are
+  removed. Old memory configuration is ignored, and the existing memory
+  database and diagnostic files are moved to `memory-legacy/` on first use,
+  preserved but no longer searched. Memory now works in both the TUI and the
+  one-shot CLI without any model profile or embedding service.
+- Simplify `MemoryCreate` to a Markdown note with the `text` heading and an
+  optional `summary` body, recording creation time and source workspace.
+
+## [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 +481,9 @@ 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.12.0...HEAD
+[2.12.0]: https://github.com/ishowshao/tinker/releases/tag/v2.12.0
+[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:
@@ -52,7 +65,7 @@ creation; running tasks cannot be resized through these tools.
 
 Both Recall tools accept an optional `sessionId` (a canonical session UUID).
 Omitting it keeps the current-session behavior. In the TUI or one-shot CLI, the
-agent can use a session ID you supply or a Memory result's `sourceSessionId`:
+agent can use a session ID you supply or find in a memory record's filename/header:
 
 ```ts
 RecallSearch({ sessionId: sourceSessionId, query: "distinctive-anchor" })
@@ -367,70 +380,6 @@ Image-capable profile example:
 }
 ```
 
-The top-level `memory` object is optional. When present, every field below is required. It enables completed-turn extraction and `MemorySearch` only in the TUI; one-shot runs do not load memory.
-
-| Field | Required | Type / constraint | Secret | Description |
-| --- | --- | --- | --- | --- |
-| `profile` | Yes | Non-empty string | No | Existing model profile used for completed-turn atomic-memory extraction. |
-| `embedding` | Yes | Object | Yes | Single embedding profile for the global memory database. |
-
-`memory.embedding` fields:
-
-| Field | Required | Type / constraint | Secret | Description |
-| --- | --- | --- | --- | --- |
-| `name` | Yes | Non-empty string | No | Stable identity for the embedding space. |
-| `kind` | Yes | Literal `"openai-compatible"` | No | Embedding transport kind. |
-| `model` | Yes | Non-empty string | No | Embedding provider model name. |
-| `apiBase` | Yes | Non-empty string | No | OpenAI-compatible API base URL. |
-| `apiKey` | Yes | Non-empty string | Yes | Embedding provider credential. |
-| `dimensions` | Yes | Positive integer | No | Fixed vector dimensions for the global memory database. |
-
-Enabling memory sends completed-turn text (not image bytes) to `memory.profile`, and sends extracted candidates plus search queries to the embedding endpoint. Derived memories are stored in `~/.tinker/memory/memory.sqlite`; newly inserted memory text is appended to the private development log `~/.tinker/memory/extracted-memories.log`.
-
-Atomic-memory profile example:
-
-```json
-{
-  "default": "text",
-  "profiles": {
-    "text": {
-      "model": "example-text-model",
-      "api": "chat-completions",
-      "apiBase": "https://api.example.com/v1",
-      "apiKey": "your-model-api-key",
-      "contextWindowTokens": 128000,
-      "maxSupportedOutputTokens": 8192,
-      "reasoning": {
-        "supportedEfforts": [
-          "low",
-          "medium",
-          "high"
-        ],
-        "defaultEffort": "medium"
-      },
-      "includeReasoningContent": false,
-      "stream": true,
-      "inputModalities": [
-        "text"
-      ],
-      "toolResultModalities": [
-        "text"
-      ]
-    }
-  },
-  "memory": {
-    "profile": "text",
-    "embedding": {
-      "name": "example-embedding-space",
-      "kind": "openai-compatible",
-      "model": "example-embedding-model",
-      "apiBase": "https://embeddings.example.com/v1",
-      "apiKey": "your-embedding-api-key",
-      "dimensions": 1024
-    }
-  }
-}
-```
 <!-- END GENERATED: MODEL PROFILE FIELDS -->
 
 Set `api` to `"responses"` to use the standard Responses API. Keep `apiBase`
@@ -550,6 +499,34 @@ one-shot `tinker run` command. See the
 [project command loader](src/tui/project-slash-commands.ts) for configuration
 validation and loading behavior.
 
+### Text memory
+
+Memory works without a model profile or embedding service in both the TUI and
+one-shot CLI. Session transcripts are appended to
+`<home>/.tinker/memory/records/<sessionId>.md`. `MemoryCreate` saves explicit notes
+to `memory/notes/<id>.md`, using `text` as the heading and optional `summary` as
+the body, with creation time and source workspace.
+
+`MemorySearch` searches Markdown under `<home>/.tinker/memory/` using literal,
+case-insensitive keywords. Supply `keywords` (any keyword may match), optionally
+`context` (default 3), `limit` (default 20 matching lines), and `offset` (default 0).
+Each line counts once, even if several keywords match. Keywords cannot span lines.
+Passages are grouped by file with line numbers; `>` marks matching lines and `…`
+separates passages. Long lines retain up to 500 code points around the earliest
+match. Use `Read` with `offset` and `limit` to expand a passage, or `nextOffset` to
+continue searching. There are no regex, glob, output-mode, or multiline parameters.
+Results follow file-path order; changes between calls can affect pagination.
+There are no MemoryGet, MemoryUpdate, or
+MemoryDelete tools. Resume appends to the same record; cloning copies historical
+content; deleting a session leaves its memory record in place. `/memory` browses
+previews of records and notes.
+
+Old `models.json` memory configuration is ignored. Existing database and memory
+diagnostic files are moved to `<home>/.tinker/memory-legacy/<id>/` on first use;
+they are preserved but not searched or converted. Older session-local
+`observations.md` files move to records when those sessions are resumed.
+See [the memory design](docs/global-memory/global-memory-design.md).
+
 ### Global Runtime Data
 
 Tinker keeps private runtime state in a global home directory instead of inside
@@ -557,8 +534,8 @@ your projects. Each workspace maps to
 `~/.tinker/projects/<workspace-slug-hash>/` — the slug comes from the workspace
 directory name and the hash from its canonical absolute path, so one project
 always resolves to one storage directory even when reached through symlinks.
-That directory holds per-session SQLite databases, event logs, and observation
-logs (`sessions/<id>/`), background Bash task logs (`bash/`), imported image
+That directory holds per-session SQLite databases and event logs
+(`sessions/<id>/`), background Bash task logs (`bash/`), imported image
 assets (`assets/images/`), and prompt history (`prompt-history.jsonl`).
 Workspaces stay clean: no `.tinker/` directory is created inside them.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tinker-agent",
-  "version": "2.10.0",
+  "version": "2.12.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 {
@@ -11,7 +15,7 @@ import type { ContextSurfaceComponent } from "../context/context-surface";
 import type { ToolCompletionInput } from "../context/protocol-frame";
 import type { EventSink } from "../events/event-sink";
 import type { AgentEventInput, AgentEventType } from "../events/types";
-import type { RuntimeIdFactory, SessionId, TurnId } from "../ids/runtime-id";
+import type { RuntimeIdFactory, SessionId } from "../ids/runtime-id";
 import type { ImportedImageAsset } from "../image/image-asset-store";
 import type { ImageAssetRef, UserMessage } from "../image/image-types";
 import type { ProjectInstructionManifest } from "../instructions/project-instructions";
@@ -24,11 +28,7 @@ import type {
 } from "../model/model-context-profile";
 import type { ReasoningEffortSnapshot } from "../model/reasoning-effort";
 import type { ObservationBuilder } from "../observation/observation-builder";
-import type {
-  CompletedTurnSnapshot,
-  SessionRecoveryResult,
-  SessionStore,
-} from "../session/session-store";
+import type { SessionRecoveryResult, SessionStore } from "../session/session-store";
 import type { SkillCatalogSnapshot } from "../skills/skill-loader";
 import type { createDefaultTooling } from "../tools/registry";
 import type { TurnUndoResult } from "../tools/turn-undo-manager";
@@ -118,6 +118,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>;
@@ -201,25 +207,6 @@ export type SkillsUpdateSummary = {
   readonly addedOverrideCount: number;
 };
 
-export type CompletedTurnHookInput = {
-  readonly workspaceRoot: string;
-  readonly sessionId: SessionId;
-  readonly turnId: TurnId;
-  readonly snapshot: CompletedTurnSnapshot;
-};
-
-export type CompletedTurnHookFailure = {
-  readonly workspaceRoot: string;
-  readonly sessionId: SessionId;
-  readonly turnId: TurnId;
-  readonly reason: "completed_turn_snapshot_failed" | "completed_turn_enqueue_failed";
-};
-
-export type CompletedTurnHook = {
-  enqueue(input: CompletedTurnHookInput): void;
-  recordFailure(input: CompletedTurnHookFailure): void;
-};
-
 export type CommonRuntimeSessionInput = {
   workspaceRoot: string;
   homeRoot?: string;
@@ -244,13 +231,10 @@ export type CommonRuntimeSessionInput = {
   webFetchRefiner?: Refiner;
   toolingConfig?: PublicToolingConfig;
   memorySearch?: ToolExecutor;
-  memoryGet?: ToolExecutor;
   memoryCreate?: ToolExecutor;
-  memoryUpdate?: ToolExecutor;
-  memoryDelete?: ToolExecutor;
-  completedTurnHook?: CompletedTurnHook;
   enableTurnUndo?: boolean;
   enableAskUser?: boolean;
+  enableProviderRetryPrompt?: boolean;
   bashGuard?: {
     readonly mode: "guard" | "yolo";
     readonly source: Exclude<BashGuardSource, "session">;