tinker-agent 2.10.0 → 2.12.0

package/src/agent/runtime-session.ts

@@ -1,3 +1,8 @@
+import { prepareSessionMemory, sessionMemoryPath } from "../memory/memory-files";
+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";
@@ -21,7 +26,7 @@ import type { EventSink } from "../events/event-sink";
 import { JsonlEventLog } from "../events/jsonl-event-log";
 import { ObservationTextLog } from "../events/observation-text-log";
 import type { AgentEvent, AgentEventInput } from "../events/types";
-import { runtimeIdFactory, type SessionId, type TurnId } from "../ids/runtime-id";
+import { runtimeIdFactory, type SessionId } from "../ids/runtime-id";
 import { ImageAssetStore, type ImportedImageAsset } from "../image/image-asset-store";
 import { IMAGE_INPUT_POLICY } from "../image/image-input-policy";
 import {
@@ -48,7 +53,6 @@ import { SessionError } from "../session/session-errors";
 import {
   createSessionCompatibilityContract,
   SessionStore,
-  type CompletedTurnSnapshot,
   type SessionRecoveryResult,
   type StoredSkillActivation,
 } from "../session/session-store";
@@ -79,8 +83,6 @@ import {
   type AskUserResolution,
   type AskUserSnapshot,
   type BashGuardSnapshot,
-  type CompletedTurnHook,
-  type CompletedTurnHookFailure,
   type CreateNewRuntimeSessionInput,
   type CreateRuntimeSessionInput,
   type ExecuteTurnInput,
@@ -119,9 +121,6 @@ export {
   type AskUserSnapshot,
   type BashGuardSnapshot,
   type BashGuardSource,
-  type CompletedTurnHook,
-  type CompletedTurnHookFailure,
-  type CompletedTurnHookInput,
   type ContextSurfaceRefreshSummary,
   type CreateRuntimeSessionInput,
   type ExecuteTurnInput,
@@ -221,6 +220,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 +234,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(
@@ -339,6 +342,16 @@ class DefaultRuntimeSession implements RuntimeSession {
     }
     let session: DefaultRuntimeSession;
     try {
+      if (
+        input.persistence !== false &&
+        input.persistence?.observationLogPath === undefined
+      ) {
+        await prepareSessionMemory(
+          store.sessionDirectory,
+          input.selection.sessionId,
+          input.homeRoot,
+        );
+      }
       session = new DefaultRuntimeSession(
         input,
         dependencies,
@@ -466,16 +479,9 @@ class DefaultRuntimeSession implements RuntimeSession {
         ...(input.memorySearch === undefined
           ? {}
           : { memorySearch: input.memorySearch }),
-        ...(input.memoryGet === undefined ? {} : { memoryGet: input.memoryGet }),
         ...(input.memoryCreate === undefined
           ? {}
           : { memoryCreate: input.memoryCreate }),
-        ...(input.memoryUpdate === undefined
-          ? {}
-          : { memoryUpdate: input.memoryUpdate }),
-        ...(input.memoryDelete === undefined
-          ? {}
-          : { memoryDelete: input.memoryDelete }),
         ...(session.skillCatalog.skills.size === 0
           ? {}
           : {
@@ -694,6 +700,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 +1205,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) {
@@ -1215,9 +1242,6 @@ class DefaultRuntimeSession implements RuntimeSession {
       pendingLedgerTurn.finish(result);
       settled = true;
       this.requireTooling().turnUndoManager?.completeTurn(turn);
-      if (result.status === "completed") {
-        this.notifyCompletedTurn(turn);
-      }
       await this.runtimeSkills.settleClosedTurnSkills();
       if (result.status === "completed") {
         await this.contextMaintenance.evaluateClosedTurnContextPressure();
@@ -1241,55 +1265,6 @@ class DefaultRuntimeSession implements RuntimeSession {
     }
   }
 
-  private notifyCompletedTurn(turn: TurnIdentity): void {
-    const hook = this.input.completedTurnHook;
-    if (hook === undefined) {
-      return;
-    }
-    let snapshot: CompletedTurnSnapshot;
-    try {
-      snapshot = this.store.readCompletedTurnSnapshot(turn.turnId);
-    } catch {
-      this.recordCompletedTurnHookFailure(
-        hook,
-        turn.turnId,
-        "completed_turn_snapshot_failed",
-      );
-      return;
-    }
-    try {
-      hook.enqueue({
-        workspaceRoot: this.input.workspaceRoot,
-        sessionId: this.sessionId,
-        turnId: turn.turnId,
-        snapshot,
-      });
-    } catch {
-      this.recordCompletedTurnHookFailure(
-        hook,
-        turn.turnId,
-        "completed_turn_enqueue_failed",
-      );
-    }
-  }
-
-  private recordCompletedTurnHookFailure(
-    hook: CompletedTurnHook,
-    turnId: TurnId,
-    reason: CompletedTurnHookFailure["reason"],
-  ): void {
-    try {
-      hook.recordFailure({
-        workspaceRoot: this.input.workspaceRoot,
-        sessionId: this.sessionId,
-        turnId,
-        reason,
-      });
-    } catch {
-      // Optional completed-turn integrations never fault a committed turn.
-    }
-  }
-
   private async appendTerminalEvent(
     turn: TurnIdentity,
     result: RunAgentResult,
@@ -1715,7 +1690,7 @@ function createEventSink(
       ),
       new ObservationTextLog(
         input.persistence?.observationLogPath ??
-          path.join(sessionDirectory, "observations.md"),
+          sessionMemoryPath(input.selection.sessionId, input.homeRoot),
       ),
     );
   }

package/src/cli/config.ts

@@ -17,7 +17,6 @@ import {
   type ModelProfiles,
   unknownProfileError,
 } from "./model-profiles";
-import type { MemoryEmbeddingConfig } from "../memory/contracts";
 import type { ReasoningEffortConfig } from "../model/reasoning-effort";
 import {
   parsePublicEnvironment,
@@ -54,12 +53,6 @@ export type RunnerConfigSelection = {
 
 type RunnerConfigTemplate = Omit<RunnerConfig, "sessionId">;
 
-export type ResolvedMemoryConfig = {
-  readonly profile: ModelProfile;
-  readonly contextBudget: ModelContextBudget;
-  readonly embedding: MemoryEmbeddingConfig;
-};
-
 export type ResolvedPublicConfig =
   | {
       readonly mode: "env";
@@ -71,7 +64,6 @@ export type ResolvedPublicConfig =
       readonly tooling: PublicToolingConfig;
       readonly profiles: ModelProfiles;
       readonly templates: ReadonlyMap<string, RunnerConfigTemplate>;
-      readonly memory?: ResolvedMemoryConfig;
       readonly persistDefaultProfile: (profileName: string) => Promise<void>;
     };
 
@@ -101,16 +93,11 @@ export function createResolvedPublicConfig(
         runnerConfigTemplateFromProfile(environment, profile),
       ]),
     );
-    const memory =
-      profiles.memory === undefined
-        ? undefined
-        : resolveMemoryConfig(profiles, profiles.memory.profile);
     return Object.freeze({
       mode: "profile",
       tooling: environment.tooling,
       profiles,
       templates,
-      ...(memory === undefined ? {} : { memory }),
       persistDefaultProfile: (profileName: string) =>
         persistDefaultProfile(profileName, environment.modelsPath),
     });
@@ -126,22 +113,6 @@ export function createResolvedPublicConfig(
   });
 }
 
-function resolveMemoryConfig(
-  profiles: ModelProfiles,
-  profileName: string,
-): ResolvedMemoryConfig {
-  const profile = profiles.profiles.get(profileName);
-  if (profile === undefined || profiles.memory === undefined) {
-    throw unknownProfileError(profileName, profiles);
-  }
-  const contextProfile = profileToContextProfile(profile);
-  return Object.freeze({
-    profile,
-    contextBudget: deriveModelContextBudget(contextProfile),
-    embedding: profiles.memory.embedding,
-  });
-}
-
 export function deriveRunnerConfig(
   snapshot: ResolvedPublicConfig,
   selection: RunnerConfigSelection,

package/src/cli/model-profiles.ts

@@ -5,13 +5,10 @@ import {
 } from "../model/model-context-profile";
 import { parseModelApi, type ModelApi } from "../model/model-api";
 import {
-  MEMORY_CONFIG_FIELDS,
-  MEMORY_EMBEDDING_FIELDS,
   MODEL_PROFILE_FIELDS,
   MODEL_PROFILES_DOCUMENT_FIELDS,
   MODEL_REASONING_FIELDS,
 } from "./public-config-contract";
-import type { MemoryEmbeddingConfig } from "../memory/contracts";
 import type { ReasoningEffortConfig } from "../model/reasoning-effort";
 import type { ModelInputModality, ToolResultModality } from "../model/model-client";
 
@@ -34,12 +31,6 @@ export type { ModelInputModality, ToolResultModality } from "../model/model-clie
 export type ModelProfiles = {
   readonly defaultProfile: string;
   readonly profiles: ReadonlyMap<string, ModelProfile>;
-  readonly memory?: MemoryConfig;
-};
-
-export type MemoryConfig = {
-  readonly profile: string;
-  readonly embedding: MemoryEmbeddingConfig;
 };
 
 export async function loadModelProfiles(configPath: string): Promise<ModelProfiles> {
@@ -146,14 +137,9 @@ export function parseModelProfiles(raw: string, sourcePath: string): ModelProfil
     profiles.set(profileName, parseProfile(profileName, profileValue, sourcePath));
   }
 
-  const memory =
-    json.memory === undefined
-      ? undefined
-      : parseMemoryConfig(json.memory, profiles, sourcePath);
   return Object.freeze({
     defaultProfile,
     profiles,
-    ...(memory === undefined ? {} : { memory }),
   });
 }
 
@@ -370,56 +356,6 @@ function parseReasoning(value: unknown, where: string): ReasoningEffortConfig {
   });
 }
 
-function parseMemoryConfig(
-  value: unknown,
-  profiles: ReadonlyMap<string, ModelProfile>,
-  sourcePath: string,
-): MemoryConfig {
-  const where = `Model profiles ${sourcePath}: "memory"`;
-  if (!isRecord(value)) {
-    throw new Error(`${where} must be an object.`);
-  }
-  assertKnownKeys(
-    value,
-    MEMORY_CONFIG_FIELDS.map((field) => field.name),
-    where,
-  );
-  const profile = requireString(value.profile, `${where}.profile`);
-  if (!profiles.has(profile)) {
-    throw unknownProfileNamesError(profile, [...profiles.keys()]);
-  }
-  const embedding = parseMemoryEmbedding(value.embedding, `${where}.embedding`);
-  return Object.freeze({ profile, embedding });
-}
-
-function parseMemoryEmbedding(value: unknown, where: string): MemoryEmbeddingConfig {
-  if (!isRecord(value)) {
-    throw new Error(`${where} must be an object.`);
-  }
-  assertKnownKeys(
-    value,
-    MEMORY_EMBEDDING_FIELDS.map((field) => field.name),
-    where,
-  );
-  const name = requireString(value.name, `${where}.name`);
-  if (value.kind !== "openai-compatible") {
-    throw new Error(`${where}.kind must be "openai-compatible".`);
-  }
-  const model = requireString(value.model, `${where}.model`);
-  const apiBase = requireString(value.apiBase, `${where}.apiBase`);
-  requireHttpUrl(apiBase, `${where}.apiBase`);
-  const apiKey = requireString(value.apiKey, `${where}.apiKey`);
-  const dimensions = requirePositiveInteger(value.dimensions, `${where}.dimensions`);
-  return Object.freeze({
-    name,
-    kind: "openai-compatible",
-    model,
-    apiBase,
-    apiKey,
-    dimensions,
-  });
-}
-
 function parseInputModalities(
   value: unknown,
   name: string,
@@ -538,22 +474,6 @@ function requirePositiveInteger(value: unknown, name: string): number {
   return value;
 }
 
-function requireHttpUrl(value: string, name: string): void {
-  let parsed: URL;
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw new Error(`${name} must be a valid HTTP(S) URL.`);
-  }
-  if (
-    (parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
-    parsed.username !== "" ||
-    parsed.password !== ""
-  ) {
-    throw new Error(`${name} must be a valid HTTP(S) URL.`);
-  }
-}
-
 function parseBoolean(value: unknown, name: string): boolean {
   if (typeof value === "boolean") {
     return value;

package/src/cli/public-config-contract.ts

@@ -379,91 +379,10 @@ export const MODEL_REASONING_FIELDS = Object.freeze([
   }),
 ]);
 
-export type MemoryConfigField = {
-  readonly name: "profile" | "embedding";
-  readonly valueKind: "non-empty-string" | "embedding-profile";
-  readonly required: true;
-  readonly secret: boolean;
-  readonly description: string;
-};
-
-export const MEMORY_CONFIG_FIELDS = Object.freeze([
-  Object.freeze({
-    name: "profile",
-    valueKind: "non-empty-string",
-    required: true,
-    secret: false,
-    description:
-      "Existing model profile used for completed-turn atomic-memory extraction.",
-  }),
-  Object.freeze({
-    name: "embedding",
-    valueKind: "embedding-profile",
-    required: true,
-    secret: true,
-    description: "Single embedding profile for the global memory database.",
-  }),
-] satisfies readonly MemoryConfigField[]);
-
-export type MemoryEmbeddingField = {
-  readonly name: "name" | "kind" | "model" | "apiBase" | "apiKey" | "dimensions";
-  readonly valueKind: "non-empty-string" | "positive-integer" | "literal-string";
-  readonly required: true;
-  readonly secret: boolean;
-  readonly literalValue?: "openai-compatible";
-  readonly description: string;
-};
-
-export const MEMORY_EMBEDDING_FIELDS = Object.freeze([
-  Object.freeze({
-    name: "name",
-    valueKind: "non-empty-string",
-    required: true,
-    secret: false,
-    description: "Stable identity for the embedding space.",
-  }),
-  Object.freeze({
-    name: "kind",
-    valueKind: "literal-string",
-    required: true,
-    secret: false,
-    literalValue: "openai-compatible",
-    description: "Embedding transport kind.",
-  }),
-  Object.freeze({
-    name: "model",
-    valueKind: "non-empty-string",
-    required: true,
-    secret: false,
-    description: "Embedding provider model name.",
-  }),
-  Object.freeze({
-    name: "apiBase",
-    valueKind: "non-empty-string",
-    required: true,
-    secret: false,
-    description: "OpenAI-compatible API base URL.",
-  }),
-  Object.freeze({
-    name: "apiKey",
-    valueKind: "non-empty-string",
-    required: true,
-    secret: true,
-    description: "Embedding provider credential.",
-  }),
-  Object.freeze({
-    name: "dimensions",
-    valueKind: "positive-integer",
-    required: true,
-    secret: false,
-    description: "Fixed vector dimensions for the global memory database.",
-  }),
-] satisfies readonly MemoryEmbeddingField[]);
-
 export const MODEL_PROFILES_DOCUMENT_FIELDS = Object.freeze([
   Object.freeze({ name: "default", valueKind: "non-empty-string" as const }),
   Object.freeze({ name: "profiles", valueKind: "profiles-map" as const }),
-  Object.freeze({ name: "memory", valueKind: "memory-config" as const }),
+  Object.freeze({ name: "memory", valueKind: "ignored-legacy-config" as const }),
 ]);
 
 export type PublicToolingConfig = {

package/src/cli/tui-runner.tsx

@@ -46,7 +46,7 @@ import { loadSkillCatalog } from "../skills/skill-loader";
 import { loadProjectSlashCommands } from "../tui/project-slash-commands";
 import { createWorkspaceFileLister } from "../tui/workspace-file-search";
 import { clipboardWriterForEnvironment } from "../tui/clipboard";
-import { initializeTuiMemory } from "./tui-memory";
+import { listMemoryFiles } from "../memory/memory-files";
 import { prepareShikiHighlighter } from "../tui/shiki-highlighter";
 import { createReasoningEffortController } from "../model/reasoning-effort";
 
@@ -63,13 +63,6 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
     options.publicConfig.mode === "profile" ? options.publicConfig.profiles : undefined;
   const config = options.initialRunnerConfig;
   const workspaceRoot = await realpath(config.workspaceRoot);
-  const memory = await initializeTuiMemory({
-    config:
-      options.publicConfig.mode === "profile" ? options.publicConfig.memory : undefined,
-    env: options.env,
-  });
-  const memoryCoordinator = memory.coordinator;
-  const memoryNotice = memory.notice;
   let controller: DefaultTuiSessionController | undefined;
   let instance: ReturnType<typeof render> | undefined;
   let disposeReason: SessionDisposeReason = { type: "tui_exit" };
@@ -119,36 +112,12 @@ 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,
           surface: "tui" as const,
         },
-        ...(memoryCoordinator === undefined
-          ? {}
-          : {
-              memorySearch: memoryCoordinator.createSearchToolExecutor({
-                workspaceRoot,
-                sessionId,
-              }),
-              memoryGet: memoryCoordinator.createGetToolExecutor({
-                workspaceRoot,
-                sessionId,
-              }),
-              memoryCreate: memoryCoordinator.createCreateToolExecutor({
-                workspaceRoot,
-                sessionId,
-              }),
-              memoryUpdate: memoryCoordinator.createUpdateToolExecutor({
-                workspaceRoot,
-                sessionId,
-              }),
-              memoryDelete: memoryCoordinator.createDeleteToolExecutor({
-                workspaceRoot,
-                sessionId,
-              }),
-              completedTurnHook: memoryCoordinator,
-            }),
       };
       if (mode === "resume") {
         return createRuntimeSession({
@@ -319,13 +288,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
         onQuit={() => {
           quitRequested = true;
         }}
-        initialNotice={memoryNotice}
-        memoryDisabledNotice={memoryNotice}
-        listStoredMemories={
-          memoryCoordinator === undefined
-            ? undefined
-            : () => memoryCoordinator.listStoredMemories()
-        }
+        listStoredMemories={() => listMemoryFiles()}
       />,
       { incrementalRendering: true },
     );
@@ -349,7 +312,6 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
               );
       }
     }
-    memoryCoordinator?.dispose();
   }
 
   if (primaryError !== undefined) {

package/src/events/observation-text-log.ts

@@ -197,6 +197,13 @@ function toolCallSummary(call: ToolCall): string {
       .join("\n");
   }
 
+  if (call.name === "MemorySearch" && Array.isArray(args.keywords)) {
+    return [
+      `Call ID: ${call.toolCallId}`,
+      `Keywords: ${JSON.stringify(args.keywords)}`,
+    ].join("\n");
+  }
+
   const filePath = stringProperty(args, "file_path");
   const pattern = stringProperty(args, "pattern");
   return [

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() ||