tinker-agent 2.5.0 → 2.7.0

package/CHANGELOG.md

@@ -5,6 +5,45 @@ All notable user-facing changes to Tinker are documented here. The project follo
 
 ## [Unreleased]
 
+## [2.7.0] - 2026-09-04
+
+### Added
+
+- Add `AskUser`, an interactive tool that lets the agent pause on a material
+  ambiguity and present two to six complete choices in the TUI before resuming
+  the same turn with the selected answer.
+- Add model-accessible `MemoryCreate`, `MemoryUpdate`, and `MemoryDelete` tools
+  for explicitly maintaining global memories shared across sessions and
+  workspaces.
+
+### Changed
+
+- Redesign the session resume picker as a compact table, making session metadata
+  easier to scan while preserving keyboard navigation and search.
+
+### Fixed
+
+- Give the long-history PTY resume fixture enough time on slower Linux CI
+  runners, avoiding a false timeout while the model is still producing the
+  expected response.
+
+## [2.6.0] - 2026-09-03
+
+### Added
+
+- Show the installed Tinker version at the end of the interactive prompt status
+  bar.
+
+### Changed
+
+- Raise the default maximum agent-loop iterations per turn from 512 to 65,536,
+  allowing longer autonomous tasks without requiring configuration changes.
+
+### Fixed
+
+- Preserve brace expressions in Grep glob filters, so patterns such as
+  `**/*.{ts,tsx}` are passed to ripgrep intact.
+
 ## [2.5.0] - 2026-09-03
 
 ### Added
@@ -307,7 +346,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.5.0...HEAD
+[Unreleased]: https://github.com/ishowshao/tinker/compare/v2.7.0...HEAD
+[2.7.0]: https://github.com/ishowshao/tinker/releases/tag/v2.7.0
+[2.6.0]: https://github.com/ishowshao/tinker/releases/tag/v2.6.0
 [2.5.0]: https://github.com/ishowshao/tinker/releases/tag/v2.5.0
 [2.4.0]: https://github.com/ishowshao/tinker/releases/tag/v2.4.0
 [2.3.0]: https://github.com/ishowshao/tinker/releases/tag/v2.3.0

package/README.md

@@ -1,8 +1,10 @@
 # Tinker
 
-**Tinker** is a personal coding agent — an interactive TUI (Terminal User Interface) and one-shot CLI tool that drives an LLM in an agent loop with file, search, shell, and MCP tools to read and modify a local workspace.
+**Tinker** is a personal coding-agent harness — an interactive TUI (Terminal User Interface) and one-shot CLI that drives an LLM in an agent loop with file, search, shell, and MCP tools to read and modify a local workspace.
 
-Built with [Bun](https://bun.sh) + TypeScript ESM, powered by [Ink](https://github.com/vadimdemedes/ink) (React for CLIs).
+**Tinker is designed for models that work over extremely long horizons — potentially as persistent agents that continue indefinitely, rather than as disposable chat sessions.** Its architecture treats the model's context window as a bounded working set, not as the source of truth. Immutable canonical history, durable sessions, protocol-safe recovery, deterministic context revisions, Recall-addressable cold state, and context-pressure management allow work to continue across compaction, process restarts, and context-window limits.
+
+This does not pretend that any model has infinite tokens or guarantee that it will recall every relevant fact. It means the harness is designed so that history remains durable and recoverable while the model repeatedly operates on a bounded, valid view of an ongoing session.
 
 ## Features
 
@@ -27,16 +29,36 @@ Built with [Bun](https://bun.sh) + TypeScript ESM, powered by [Ink](https://gith
 - **Turn cancellation**: Users can cancel an ongoing turn safely, with protocol-safe synthetic tool messages.
 - **Context metering**: Budget-aware context management with protocol validation before sending requests to the model.
 - **Deterministic context compaction**: Idle sessions can swap eligible historical tool output into Recall-addressable placeholders without calling the model.
-- **Infinite Context architecture**: Immutable canonical history, deterministic
-  context revisions, Recall-addressable cold state, and qualified prefix retirement
-  keep long-running sessions recoverable without pretending the model has infinite
-  tokens. See the [technical design](docs/infinite-context-technical-design.md).
+- **Infinite Context architecture**: Immutable canonical history, deterministic context revisions, Recall-addressable cold state, and qualified prefix retirement support sessions designed to continue indefinitely without pretending the model has infinite tokens. See the [technical design](docs/infinite-context-technical-design.md).
 - **Choice of models**: Uses an OpenAI-compatible Chat Completions transport with
   explicit model and context limits. Actual provider support must be established
   by a qualification matrix; transport compatibility alone is not a guarantee.
 
 ## Quick Start
 
+### Install with your existing agent
+
+If you already use a coding agent, you can ask it to read Tinker's documentation, install the package, and prepare a complete local configuration for you. Values it cannot safely determine can be left as clearly named placeholders; when setup is complete, the agent should tell you exactly which file to edit and what each placeholder expects.
+
+Copy and send this prompt to your existing agent:
+
+```text
+Open https://github.com/ishowshao/tinker and read Tinker's README and linked model-configuration documentation, then install and configure Tinker on this machine.
+
+Create a complete model profile configuration in an appropriate local file. Use clearly named placeholders for any required values that cannot be determined from the documentation or the current environment; do not invent API credentials, endpoint URLs, model names, or model limits. Configure Tinker to use that file, and verify the installation and configuration as far as possible without making a live model request.
+
+When finished, tell me:
+1. the exact path of the configuration file you created;
+2. every placeholder I still need to replace;
+3. what value each placeholder expects;
+4. any command I need to run after filling them in;
+5. the command to start Tinker.
+
+Do not ask me for the missing values during setup unless proceeding would be unsafe. Prefer creating a structurally complete configuration with placeholders so I can fill them in locally afterward.
+```
+
+### Install manually
+
 ```bash
 npm install --global tinker-agent
 
@@ -149,7 +171,7 @@ are required. Boolean environment values accept case-insensitive `true/false`,
 | `TINKER_STREAM` | Model | Env mode | No | Boolean | `true` | No | Use streaming transport for the selected model API. |
 | `TINKER_WEBFETCH_REFINE_MODEL` | Model | Env mode | No | Non-empty string | — | No | Optional WebFetch refiner model; currently must match TINKER_MODEL. |
 | `TINKER_WORKSPACE` | Workspace | All modes | No | Non-empty string | Process cwd | No | Workspace path. A leading ~ expands to the home directory; other relative paths resolve from the process cwd. |
-| `TINKER_MAX_ITERATIONS` | Workspace | All modes | No | Positive integer | `512` | No | Maximum agent-loop iterations per turn. |
+| `TINKER_MAX_ITERATIONS` | Workspace | All modes | No | Positive integer | `65536` | No | Maximum agent-loop iterations per turn. |
 | `EXA_API_KEY` | Tooling | All modes | No | Non-empty string | — | Yes | Enables WebSearch and the Exa WebFetch backend when set. |
 | `TINKER_MCP_TIMEOUT_MS` | Tooling | All modes | No | Positive integer | `60000` | No | MCP tool-call timeout in milliseconds. |
 | `TINKER_MCP_MAX_OBSERVATION_CHARS` | Tooling | All modes | No | Positive integer | `40000` | No | Maximum model-visible characters in one MCP result. |
@@ -513,6 +535,7 @@ Runtime data lives in ~/.tinker/ (sessions, bash tasks, assets), not in the repo
 - **Fast-fail**: Validate assumptions early and return clear errors close to the source. Structured failures allow the model to correct and retry.
 - **Model sees only text**: Tool execution results are rendered into readable text for the model. Raw result data with extra detail is kept for event logs and the TUI.
 - **Protocol safety**: All tool calls produce protocol-safe messages — even cancellations, fatal errors, or interruptions generate well-formed tool messages so the agent loop can continue.
+- **Long-horizon continuity**: Treat the context window as a replaceable working set over durable canonical history. Sessions should remain resumable and historically recoverable across compaction, interruption, and process restarts.
 - **Session durability**: Every turn, iteration, and tool call is committed to the SQLite ledger before the model is called, enabling reliable resume and history recall.
 
 ## Requirements

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tinker-agent",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "description": "A personal coding agent with an interactive TUI and one-shot CLI.",
   "license": "Apache-2.0",
   "type": "module",

package/src/agent/loop.ts

@@ -384,6 +384,28 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
       });
     }
 
+    if (toolCalls.some((call) => call.name === "AskUser") && toolCalls.length !== 1) {
+      const detail =
+        "AskUser must be the only tool call in an assistant response. Call it alone on the next iteration.";
+      const completions = toolCalls.map((call, index) => {
+        requireCallInIteration(call, iteration, index + 1);
+        return {
+          call,
+          kind: "synthetic" as const,
+          reason: "failed_active" as const,
+          detail,
+        };
+      });
+      input.ledger.commitToolCompletions(completions);
+      await input.runtimeSession.append({
+        type: "agent.iteration.finished",
+        ...iteration,
+        data: { outcome: "continue", toolCallCount: toolCalls.length },
+      });
+      input.runtimeSession.finishIterationForContinuation(iteration);
+      continue;
+    }
+
     for (let callIndex = 0; callIndex < toolCalls.length; callIndex += 1) {
       const call = requireToolCall(toolCalls, callIndex);
       requireCallInIteration(call, iteration, callIndex + 1);

package/src/agent/runtime-session.ts

@@ -80,6 +80,8 @@ import {
   type ContextStatusRawResult,
   type ContextSwapCandidatesRawResult,
   type ContextSwapRawResult,
+  type AskUserRequest,
+  type AskUserResponse,
   type ToolExecutor,
 } from "../tools/types";
 import type { TurnUndoResult } from "../tools/turn-undo-manager";
@@ -202,9 +204,20 @@ export type RuntimeSession = {
   subscribeBashGuard(listener: () => void): () => void;
   setYoloMode(enabled: boolean): void;
   resolveBashConfirmation(decision: "allow" | "deny"): Promise<void>;
+  askUser(): AskUserSnapshot;
+  subscribeAskUser(listener: () => void): () => void;
+  resolveAskUser(response: AskUserResolution): Promise<void>;
   dispose(reason: SessionDisposeReason): Promise<void>;
 };
 
+export type AskUserSnapshot = {
+  readonly pending?: AskUserRequest;
+};
+
+export type AskUserResolution =
+  | { readonly outcome: "selected"; readonly selectedIndex: number }
+  | { readonly outcome: "dismissed" };
+
 export type BashGuardSource = "default" | "environment" | "cli" | "session";
 
 export type BashGuardSnapshot = {
@@ -322,8 +335,12 @@ type CommonRuntimeSessionInput = {
   toolingConfig?: PublicToolingConfig;
   memorySearch?: ToolExecutor;
   memoryGet?: ToolExecutor;
+  memoryCreate?: ToolExecutor;
+  memoryUpdate?: ToolExecutor;
+  memoryDelete?: ToolExecutor;
   completedTurnHook?: CompletedTurnHook;
   enableTurnUndo?: boolean;
+  enableAskUser?: boolean;
   bashGuard?: {
     readonly mode: "guard" | "yolo";
     readonly source: Exclude<BashGuardSource, "session">;
@@ -490,6 +507,16 @@ class DefaultRuntimeSession implements RuntimeSession {
   private bashGuardSource: BashGuardSource;
   private bashGuardSnapshot: BashGuardSnapshot;
   private readonly bashGuardListeners = new Set<() => void>();
+  private askUserSnapshot: AskUserSnapshot = Object.freeze({});
+  private readonly askUserListeners = new Set<() => void>();
+  private pendingAskUser?: {
+    readonly request: AskUserRequest;
+    readonly startedAt: number;
+    readonly call: ToolCallIdentity;
+    readonly resolve: (response: AskUserResponse) => void;
+    readonly reject: (error: unknown) => void;
+    readonly removeAbortListener: () => void;
+  };
   private assistantTextDeltaSinkDisabled = false;
   private pendingBashConfirmation?: {
     readonly command: string;
@@ -695,6 +722,15 @@ class DefaultRuntimeSession implements RuntimeSession {
         ...(input.enableTurnUndo === true ? { enableTurnUndo: true } : {}),
         webFetchRefiner: input.webFetchRefiner,
         toolingConfig: input.toolingConfig,
+        ...(input.enableAskUser === true
+          ? {
+              askUser: (
+                call: ToolCallIdentity,
+                request: AskUserRequest,
+                signal: AbortSignal,
+              ) => session.requestUserAnswer(call, request, signal),
+            }
+          : {}),
         bashGuard: {
           surface: input.bashGuard?.surface ?? "one-shot",
           confirm: (call, request, signal) =>
@@ -704,6 +740,15 @@ class DefaultRuntimeSession implements RuntimeSession {
           ? {}
           : { 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
           ? {}
           : {
@@ -1204,6 +1249,119 @@ class DefaultRuntimeSession implements RuntimeSession {
     }
   }
 
+  askUser(): AskUserSnapshot {
+    return this.askUserSnapshot;
+  }
+
+  subscribeAskUser(listener: () => void): () => void {
+    this.askUserListeners.add(listener);
+    return () => this.askUserListeners.delete(listener);
+  }
+
+  async resolveAskUser(response: AskUserResolution): Promise<void> {
+    const pending = this.pendingAskUser;
+    if (pending === undefined) {
+      throw new Error("No AskUser question is pending.");
+    }
+    let result: AskUserResponse;
+    if (response.outcome === "selected") {
+      if (!Number.isSafeInteger(response.selectedIndex)) {
+        throw new Error("AskUser selectedIndex must be an integer.");
+      }
+      const option = pending.request.options[response.selectedIndex];
+      if (option === undefined) {
+        throw new Error("AskUser selectedIndex is out of range.");
+      }
+      result = { outcome: "selected", answer: option.description };
+    } else {
+      result = { outcome: "dismissed" };
+    }
+    this.pendingAskUser = undefined;
+    this.askUserSnapshot = Object.freeze({});
+    pending.removeAbortListener();
+    await this.append({
+      type: "tool.user_question.resolved",
+      ...pending.call,
+      data: {
+        ...result,
+        durationMs: Date.now() - pending.startedAt,
+      },
+    });
+    pending.resolve(result);
+    this.notifyAskUserListeners();
+  }
+
+  private async requestUserAnswer(
+    call: ToolCallIdentity,
+    request: AskUserRequest,
+    signal: AbortSignal,
+  ): Promise<AskUserResponse> {
+    if (this.pendingAskUser !== undefined) {
+      throw new Error("Another AskUser question is already pending.");
+    }
+    if (this.pendingBashConfirmation !== undefined) {
+      throw new Error("Cannot ask the user while a Bash confirmation is pending.");
+    }
+    if (signal.aborted) {
+      throw cancellationError(signal);
+    }
+    const startedAt = Date.now();
+    await this.append({
+      type: "tool.user_question.requested",
+      ...call,
+      data: request,
+    });
+    return new Promise<AskUserResponse>((resolve, reject) => {
+      const onAbort = () => {
+        const pending = this.pendingAskUser;
+        if (pending?.call.toolCallId !== call.toolCallId) {
+          return;
+        }
+        this.pendingAskUser = undefined;
+        this.askUserSnapshot = Object.freeze({});
+        void this.append({
+          type: "tool.user_question.resolved",
+          ...call,
+          data: {
+            outcome: "cancelled",
+            durationMs: Date.now() - startedAt,
+          },
+        }).finally(() => {
+          reject(cancellationError(signal));
+          this.notifyAskUserListeners();
+        });
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      const immutableRequest = Object.freeze({
+        question: request.question,
+        options: Object.freeze(
+          request.options.map((option) =>
+            Object.freeze({ description: option.description }),
+          ),
+        ),
+      });
+      this.pendingAskUser = {
+        request: immutableRequest,
+        startedAt,
+        call,
+        resolve,
+        reject,
+        removeAbortListener: () => signal.removeEventListener("abort", onAbort),
+      };
+      this.askUserSnapshot = Object.freeze({ pending: immutableRequest });
+      this.notifyAskUserListeners();
+      if (signal.aborted) {
+        onAbort();
+      }
+    });
+  }
+
+  private notifyAskUserListeners(): void {
+    for (const listener of this.askUserListeners) {
+      listener();
+    }
+  }
+
   async importImage(
     sourcePath: string,
     signal: AbortSignal,

package/src/cli/main.ts

@@ -51,6 +51,7 @@ type TuiRunner = {
     readonly publicConfig: ResolvedPublicConfig;
     readonly initialRunnerConfig: RunnerConfig;
     readonly env: NodeJS.ProcessEnv;
+    readonly version: string;
   }) => Promise<void>;
 };
 
@@ -187,6 +188,7 @@ export async function main(
           publicConfig,
           initialRunnerConfig: runnerConfig,
           env,
+          version: metadata.version,
         });
         return finish(0);
       } catch (error) {

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

@@ -135,7 +135,7 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     valueKind: "positive-integer",
     requiredIn: "never",
     appliesIn: "always",
-    defaultValue: 512,
+    defaultValue: 65_536,
     secret: false,
     section: "workspace",
     description: "Maximum agent-loop iterations per turn.",

package/src/cli/tui-runner.tsx

@@ -54,6 +54,7 @@ export type RunTuiOptions = {
   readonly publicConfig: ResolvedPublicConfig;
   readonly initialRunnerConfig: RunnerConfig;
   readonly env: NodeJS.ProcessEnv;
+  readonly version: string;
 };
 
 export async function runTui(options: RunTuiOptions): Promise<void> {
@@ -117,6 +118,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
         ),
         toolingConfig: options.publicConfig.tooling,
         enableTurnUndo: true,
+        enableAskUser: true,
         bashGuard: {
           mode: sessionConfig.bashGuardMode,
           source: sessionConfig.bashGuardSource,
@@ -133,6 +135,18 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
                 workspaceRoot,
                 sessionId,
               }),
+              memoryCreate: memoryCoordinator.createCreateToolExecutor({
+                workspaceRoot,
+                sessionId,
+              }),
+              memoryUpdate: memoryCoordinator.createUpdateToolExecutor({
+                workspaceRoot,
+                sessionId,
+              }),
+              memoryDelete: memoryCoordinator.createDeleteToolExecutor({
+                workspaceRoot,
+                sessionId,
+              }),
               completedTurnHook: memoryCoordinator,
             }),
       };
@@ -286,6 +300,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
     instance = render(
       <App
         sessionController={controller}
+        version={options.version}
         readGitBranch={readCurrentGitBranch}
         history={promptHistory}
         projectSlashCommands={projectSlashCommands}
@@ -321,7 +336,6 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
   } finally {
     instance?.unmount();
     restoreStdin();
-    memoryCoordinator?.dispose();
     if (controller !== undefined) {
       try {
         await controller.dispose(disposeReason);
@@ -335,6 +349,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
               );
       }
     }
+    memoryCoordinator?.dispose();
   }
 
   if (primaryError !== undefined) {

package/src/events/stdout-event-printer.ts

@@ -140,6 +140,16 @@ export class StdoutEventPrinter implements EventSink {
           `tool.confirmation.resolved toolCallId=${event.toolCallId} decision=${event.data.decision} durationMs=${event.data.durationMs}\n`,
         );
         break;
+      case "tool.user_question.requested":
+        this.stdout.write(
+          `tool.user_question.requested toolCallId=${event.toolCallId} question=${JSON.stringify(event.data.question)} options=${event.data.options.length}\n`,
+        );
+        break;
+      case "tool.user_question.resolved":
+        this.stdout.write(
+          `tool.user_question.resolved toolCallId=${event.toolCallId} outcome=${event.data.outcome} durationMs=${event.data.durationMs}\n`,
+        );
+        break;
       case "mcp.server.connected":
         this.stdout.write(
           `mcp.server.connected name=${event.data.serverName} tools=${event.data.toolCount}\n`,
@@ -235,7 +245,11 @@ function formatToolRawResult(call: ToolCall, raw: ToolRawResult): string[] {
     case "context_maintenance":
     case "memory_search":
     case "memory_get":
+    case "memory_create":
+    case "memory_update":
+    case "memory_delete":
     case "wait":
+    case "ask_user":
     case "mcp":
     case "generic":
       return [];

package/src/events/types.ts

@@ -351,6 +351,14 @@ export type AgentEventDataMap = {
     decision: "allow" | "deny" | "cancelled";
     durationMs: number;
   };
+  "tool.user_question.requested": {
+    question: string;
+    options: readonly { description: string }[];
+  };
+  "tool.user_question.resolved":
+    | { outcome: "selected"; answer: string; durationMs: number }
+    | { outcome: "dismissed"; durationMs: number }
+    | { outcome: "cancelled"; durationMs: number };
   "agent.iteration.finished": {
     outcome: "continue" | "completed";
     toolCallCount: number;
@@ -448,6 +456,7 @@ export type AgentEventInput =
       "tool.started" | "tool.raw_result" | "tool.finished" | "tool.observation"
     >
   | ToolEventInput<"tool.confirmation.requested" | "tool.confirmation.resolved">
+  | ToolEventInput<"tool.user_question.requested" | "tool.user_question.resolved">
   | ToolEventInput<
       "bash.task.backgrounded" | "bash.task.stopping" | "bash.task.finished"
     >;

package/src/memory/contracts.ts

@@ -2,6 +2,9 @@ import type { SessionId, TurnId } from "../ids/runtime-id";
 
 export const MEMORY_SEARCH_TOOL_NAME = "MemorySearch" as const;
 export const MEMORY_GET_TOOL_NAME = "MemoryGet" as const;
+export const MEMORY_CREATE_TOOL_NAME = "MemoryCreate" as const;
+export const MEMORY_UPDATE_TOOL_NAME = "MemoryUpdate" as const;
+export const MEMORY_DELETE_TOOL_NAME = "MemoryDelete" as const;
 export const MEMORY_SCHEMA_VERSION = 2 as const;
 export const MAX_MEMORY_TEXT_BYTES = 512;
 export const MAX_MEMORY_SUMMARY_BYTES = 4_096;
@@ -112,6 +115,35 @@ export type StoredMemoryRecord = StoredMemorySummary & {
   readonly sourceTurnId: string;
 };
 
+export type StoredMemoryMutationRecord = StoredMemoryRecord & {
+  readonly embedding: Float32Array;
+};
+
+export type MemoryUpdateStoreResult =
+  | {
+      readonly ok: true;
+      readonly memoryId: string;
+    }
+  | {
+      readonly ok: false;
+      readonly code: "memory_not_found";
+    }
+  | {
+      readonly ok: false;
+      readonly code: "memory_duplicate";
+      readonly conflictMemoryId: string;
+    };
+
+export type MemoryDeleteStoreResult =
+  | {
+      readonly ok: true;
+      readonly memoryId: string;
+    }
+  | {
+      readonly ok: false;
+      readonly code: "memory_not_found";
+    };
+
 export type MemoryExtractionRejectedCounts = {
   readonly duplicate: number;
   readonly secret: number;
@@ -175,10 +207,24 @@ export type MemoryGetDiagnostic = {
   readonly ms: number;
 };
 
+export type MemoryMutationDiagnostic = {
+  readonly at: string;
+  readonly kind: "create" | "update" | "delete";
+  readonly outcome: "ok" | "failed" | "skipped";
+  readonly reason: string | null;
+  readonly workspace: string;
+  readonly sessionId: string;
+  readonly turnId: string;
+  readonly toolCallId: string;
+  readonly memoryId: string | null;
+  readonly ms: number;
+};
+
 export type MemoryDiagnostic =
   | MemoryExtractionDiagnostic
   | MemorySearchDiagnostic
   | MemoryGetDiagnostic
+  | MemoryMutationDiagnostic
   | MemoryInitDiagnostic;
 
 export class MemoryError extends Error {