tinker-agent 1.4.0 → 1.5.0

package/src/observation/observation-builder.ts

@@ -5,6 +5,7 @@ import type {
   GenericToolRawResult,
   GlobRawResult,
   GrepRawResult,
+  MemorySearchRawResult,
   McpToolRawResult,
   ReadFileRawResult,
   RecallRawResult,
@@ -33,6 +34,8 @@ export class ObservationBuilder {
         return { content: renderReadObservation(input.raw) };
       case "recall":
         return { content: renderRecallObservation(input.raw) };
+      case "memory_search":
+        return { content: renderMemorySearchObservation(input.raw) };
       case "skill":
         return { content: renderSkillObservation(input.raw) };
       case "write":
@@ -227,6 +230,23 @@ function renderRecallObservation(raw: RecallRawResult): string {
   return [header, ...hits].join("\n\n");
 }
 
+function renderMemorySearchObservation(raw: MemorySearchRawResult): string {
+  if (!raw.ok) {
+    return `MemorySearch unavailable: ${raw.error}`;
+  }
+  if (raw.matches.length === 0) {
+    return "MemorySearch found no stored memories.";
+  }
+  const header = `MemorySearch returned ${raw.matches.length} derived memories. They may be stale or wrong; verify current workspace facts.`;
+  return [
+    header,
+    ...raw.matches.map(
+      (match, index) =>
+        `${index + 1}. score=${match.score.toFixed(3)} created_at=${match.createdAt} workspace=${match.sourceWorkspace}\n   ${match.text}`,
+    ),
+  ].join("\n\n");
+}
+
 export function renderSkillObservation(raw: SkillRawResult): string {
   if (!raw.ok) {
     return `Skill failed for ${raw.name || "(unknown skill)"} (${raw.errorCode}): ${raw.error}`;

package/src/session/session-store.ts

@@ -144,6 +144,29 @@ export type SessionImageInputCompatibility = {
   readonly tokenEstimator?: InputTokenEstimatorCompatibility;
 };
 
+export type CompletedTurnMessageSnapshot =
+  | {
+      readonly ordinal: number;
+      readonly role: "user";
+      readonly content: string;
+    }
+  | {
+      readonly ordinal: number;
+      readonly role: "assistant";
+      readonly content: string | null;
+      readonly reasoningContent?: string | null;
+    }
+  | {
+      readonly ordinal: number;
+      readonly role: "tool";
+      readonly name: string;
+      readonly content: string;
+    };
+
+export type CompletedTurnSnapshot = {
+  readonly messages: readonly CompletedTurnMessageSnapshot[];
+};
+
 export type SessionCompatibilityContract = {
   modelName: string;
   profileName?: string;
@@ -2082,6 +2105,105 @@ export class SessionStore implements SessionLedgerCommitter {
     });
   }
 
+  readCompletedTurnSnapshot(turnId: TurnId): CompletedTurnSnapshot {
+    this.requireOpen();
+    const turnRow = this.database
+      .query("SELECT status FROM turns WHERE turn_id = ?")
+      .get(turnId);
+    const status = enumFromSql(
+      recordFromSql(turnRow, "completed turn").status,
+      ["open", "completed", "failed", "cancelled", "interrupted"] as const,
+      "turn status",
+    );
+    if (status !== "completed") {
+      throw new Error(`Turn ${turnId} is not completed.`);
+    }
+
+    const rows = this.database
+      .query(
+        `SELECT ordinal, role, content, reasoning_content,
+                reasoning_content_present, name
+         FROM messages
+         WHERE turn_id = ?
+         ORDER BY ordinal`,
+      )
+      .all(turnId);
+    if (rows.length === 0) {
+      throw new Error(`Completed turn ${turnId} has no messages.`);
+    }
+
+    let previousOrdinal = 0;
+    const messages = rows.map((value): CompletedTurnMessageSnapshot => {
+      const row = recordFromSql(value, "completed turn message");
+      const ordinal = numberFromSql(row.ordinal, "completed turn ordinal");
+      if (ordinal < 1 || ordinal <= previousOrdinal) {
+        throw new Error("Completed turn message ordinals are invalid.");
+      }
+      previousOrdinal = ordinal;
+      const role = enumFromSql(
+        row.role,
+        ["user", "assistant", "tool"] as const,
+        "completed turn message role",
+      );
+      if (role === "user") {
+        if (
+          row.reasoning_content !== null ||
+          numberFromSql(row.reasoning_content_present, "reasoning_content_present") !==
+            0 ||
+          row.name !== null
+        ) {
+          throw new Error("Completed user message fields are invalid.");
+        }
+        return Object.freeze({
+          ordinal,
+          role,
+          content: stringFromSql(row.content, "completed user content"),
+        });
+      }
+      if (role === "assistant") {
+        if (row.name !== null) {
+          throw new Error("Completed assistant message name must be null.");
+        }
+        const reasoningPresent = numberFromSql(
+          row.reasoning_content_present,
+          "reasoning_content_present",
+        );
+        if (reasoningPresent !== 0 && reasoningPresent !== 1) {
+          throw new Error("reasoning_content_present must be 0 or 1.");
+        }
+        if (reasoningPresent === 0 && row.reasoning_content !== null) {
+          throw new Error("Absent assistant reasoning content must be null.");
+        }
+        return Object.freeze({
+          ordinal,
+          role,
+          content: nullableTextFromSql(row.content, "completed assistant content"),
+          ...(reasoningPresent === 0
+            ? {}
+            : {
+                reasoningContent: nullableTextFromSql(
+                  row.reasoning_content,
+                  "completed assistant reasoning content",
+                ),
+              }),
+        });
+      }
+      if (
+        row.reasoning_content !== null ||
+        numberFromSql(row.reasoning_content_present, "reasoning_content_present") !== 0
+      ) {
+        throw new Error("Completed tool message reasoning fields are invalid.");
+      }
+      return Object.freeze({
+        ordinal,
+        role,
+        name: stringFromSql(row.name, "completed tool name"),
+        content: stringFromSql(row.content, "completed tool content"),
+      });
+    });
+    return Object.freeze({ messages: Object.freeze(messages) });
+  }
+
   loadProtocolView(): ProtocolContextView {
     this.requireOpen();
     const imageAttachments = loadMessageImageAttachments(this.database);
@@ -4725,6 +4847,7 @@ export function decodeStoredToolRawResult(value: unknown): ToolRawResult {
       "web_search",
       "web_fetch",
       "recall",
+      "memory_search",
       "skill",
       "mcp",
       "generic",

package/src/tools/registry.ts

@@ -133,6 +133,7 @@ export function createDefaultTooling(options: {
   skillCatalog?: SkillCatalogSnapshot;
   skillCoordinator?: SkillActivationCoordinator;
   toolingConfig?: PublicToolingConfig;
+  memorySearch?: ToolExecutor;
 }): DefaultTooling {
   const snapshots: FileSnapshotStore = new Map();
   const registry = new ToolRegistry();
@@ -170,6 +171,9 @@ export function createDefaultTooling(options: {
     }),
   );
   registry.register(createRecallToolExecutor({ historyReader: options.historyReader }));
+  if (options.memorySearch !== undefined) {
+    registry.register(options.memorySearch);
+  }
   if (options.skillCatalog !== undefined) {
     if (options.skillCatalog.skills.size === 0) {
       throw new Error("An empty Agent Skill catalog must not register tooling.");

package/src/tools/types.ts

@@ -245,6 +245,21 @@ export type RecallGetRawResult =
 
 export type RecallRawResult = RecallSearchRawResult | RecallGetRawResult;
 
+export type MemorySearchRawResult =
+  | {
+      ok: true;
+      matches: readonly {
+        text: string;
+        score: number;
+        sourceWorkspace: string;
+        createdAt: string;
+      }[];
+    }
+  | {
+      ok: false;
+      error: string;
+    };
+
 export type SkillRawResult =
   | {
       ok: true;
@@ -307,6 +322,7 @@ export type ToolRawResultByKind = {
   web_search: WebSearchRawResult;
   web_fetch: WebFetchRawResult;
   recall: RecallRawResult;
+  memory_search: MemorySearchRawResult;
   skill: SkillRawResult;
   mcp: McpToolRawResult;
   generic: GenericToolRawResult;

package/src/tui/app.tsx

@@ -1,6 +1,7 @@
 import { Box, Text, useApp, useInput } from "ink";
-import { useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
 import { TurnCancelledError } from "../agent/turn-cancellation";
+import { boundedMemoryError, type StoredMemorySummary } from "../memory/contracts";
 import {
   ContextManagerError,
   type ContextCompactionResult,
@@ -18,6 +19,7 @@ import { BackgroundTasks } from "./components/background-tasks";
 import { Header } from "./components/header";
 import { ModelPicker } from "./components/model-picker";
 import { FileViewer, FileViewerLoading } from "./components/file-viewer";
+import { MemoryBrowser } from "./components/memory-browser";
 import {
   PromptInput,
   type PromptMaintenanceAction,
@@ -59,6 +61,9 @@ export type AppProps = {
   ) => Promise<string | undefined>;
   writeClipboard?: (markdown: string) => Promise<void>;
   onQuit?: () => void;
+  initialNotice?: string;
+  listStoredMemories?: () => readonly StoredMemorySummary[];
+  memoryDisabledNotice?: string;
 };
 
 type ResumePickerState =
@@ -99,7 +104,7 @@ export function App(props: AppProps) {
   const [isSessionOperation, setIsSessionOperation] = useState(false);
   const [isCopying, setIsCopying] = useState(false);
   const [isCancelling, setIsCancelling] = useState(false);
-  const [notice, setNotice] = useState<string | undefined>(undefined);
+  const [notice, setNotice] = useState<string | undefined>(props.initialNotice);
   const [showStatus, setShowStatus] = useState(false);
   const [showSkills, setShowSkills] = useState(false);
   const [showMcp, setShowMcp] = useState(false);
@@ -111,6 +116,9 @@ export function App(props: AppProps) {
     ModelPickerState | undefined
   >(undefined);
   const [fileView, setFileView] = useState<FileViewState | undefined>(undefined);
+  const [memoryView, setMemoryView] = useState<
+    readonly StoredMemorySummary[] | undefined
+  >(undefined);
   const [viewError, setViewError] = useState<string | undefined>(undefined);
   const [gitBranch, setGitBranch] = useState<string | undefined>(undefined);
   const [gitBranchRefresh, setGitBranchRefresh] = useState(0);
@@ -132,6 +140,8 @@ export function App(props: AppProps) {
 
   const profileList = props.profiles ? [...props.profiles.profiles.values()] : [];
 
+  const runningElapsedMs = useElapsedMs(state.activeTurn?.startedAt);
+
   useEffect(() => {
     if (readGitBranch === undefined) {
       return;
@@ -276,6 +286,20 @@ export function App(props: AppProps) {
     setFileView(undefined);
   };
 
+  const openMemoryView = () => {
+    if (props.listStoredMemories === undefined) {
+      setNotice(props.memoryDisabledNotice ?? "memory disabled: not configured");
+      return;
+    }
+    try {
+      const snapshot = props.listStoredMemories();
+      setNotice(undefined);
+      setMemoryView(snapshot);
+    } catch (error) {
+      setNotice(`memory unavailable: ${boundedMemoryError(error)}`);
+    }
+  };
+
   const openFileView = (filePath: string) => {
     const requestId = fileViewRequest.current + 1;
     fileViewRequest.current = requestId;
@@ -454,6 +478,10 @@ export function App(props: AppProps) {
           openFileView(command.filePath);
           return true;
         }
+        if (command.type === "memory") {
+          openMemoryView();
+          return true;
+        }
         if (command.type === "copy") {
           copyLastResponse();
           return true;
@@ -583,6 +611,8 @@ export function App(props: AppProps) {
         <FileViewerLoading filePath={fileView.filePath} onCancel={closeFileView} />
       ) : fileView?.status === "ready" ? (
         <FileViewer file={fileView.file} onClose={closeFileView} />
+      ) : memoryView !== undefined ? (
+        <MemoryBrowser memories={memoryView} onClose={() => setMemoryView(undefined)} />
       ) : resumePicker?.status === "loading" ? (
         <ResumeSessionPickerLoading onCancel={closeResumePicker} />
       ) : resumePicker?.status === "ready" ? (
@@ -628,6 +658,7 @@ export function App(props: AppProps) {
             <Footer
               status={isCancelling ? "cancelling" : state.status}
               workedForMs={state.workedForMs}
+              elapsedMs={runningElapsedMs}
             />
           </Box>
           <Box marginTop={1} flexDirection="column">
@@ -670,6 +701,42 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+const ELAPSED_TICK_MS = 1_000;
+
+// The wall clock, quantized to whole ticks so a render pass reads one stable
+// value and re-renders at most once per second.
+function readElapsedClockMs(): number {
+  return Math.floor(Date.now() / ELAPSED_TICK_MS) * ELAPSED_TICK_MS;
+}
+
+// Counts up while a turn is active. The interval only exists while `startedAt`
+// is defined, so an idle TUI keeps no timer running.
+function useElapsedMs(startedAt: string | undefined): number | undefined {
+  const subscribe = useCallback(
+    (onClockTick: () => void) => {
+      if (startedAt === undefined) {
+        return () => undefined;
+      }
+
+      const timer = setInterval(onClockTick, ELAPSED_TICK_MS);
+      return () => clearInterval(timer);
+    },
+    [startedAt],
+  );
+  const nowMs = useSyncExternalStore(subscribe, readElapsedClockMs, readElapsedClockMs);
+
+  if (startedAt === undefined) {
+    return undefined;
+  }
+
+  const startedAtMs = Date.parse(startedAt);
+  if (!Number.isFinite(startedAtMs)) {
+    throw new Error(`Invalid turn start timestamp: ${startedAt}`);
+  }
+
+  return Math.max(0, nowMs - startedAtMs);
+}
+
 export function formatContextCompactionNotice(result: ContextCompactionResult): string {
   if (result.status === "unchanged") {
     if (result.outcome === "below_target") {

package/src/tui/clipboard.ts

@@ -1,5 +1,27 @@
 import clipboard from "clipboardy";
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
 
 export async function writeClipboardText(text: string): Promise<void> {
   await clipboard.write(text);
 }
+
+export function clipboardWriterForEnvironment(
+  env: NodeJS.ProcessEnv,
+): ((text: string) => Promise<void>) | undefined {
+  const filePath = env.TINKER_TEST_CLIPBOARD_FILE;
+  if (filePath === undefined || filePath === "") {
+    return undefined;
+  }
+  if (env.TINKER_TEST_FAKE_MODEL === undefined || env.TINKER_TEST_FAKE_MODEL === "") {
+    throw new Error("TINKER_TEST_CLIPBOARD_FILE requires TINKER_TEST_FAKE_MODEL.");
+  }
+  if (!path.isAbsolute(filePath)) {
+    throw new Error("TINKER_TEST_CLIPBOARD_FILE must be an absolute path.");
+  }
+  return (text) =>
+    writeFile(filePath, text, {
+      encoding: "utf8",
+      mode: 0o600,
+    });
+}

package/src/tui/components/footer.tsx

@@ -4,6 +4,7 @@ import { Text } from "ink";
 export type FooterProps = {
   status: "idle" | "running" | "cancelling" | "cancelled" | "done" | "failed";
   workedForMs?: number;
+  elapsedMs?: number;
 };
 
 export function Footer(props: FooterProps) {
@@ -14,7 +15,7 @@ export function Footer(props: FooterProps) {
 
     return (
       <StatusMessage variant="success">
-        Worked for {formatWorkedDuration(props.workedForMs)}
+        Worked for {formatDuration(props.workedForMs)}
       </StatusMessage>
     );
   }
@@ -24,7 +25,11 @@ export function Footer(props: FooterProps) {
   }
 
   if (props.status === "running") {
-    return <Text color="yellow">• Running</Text>;
+    if (props.elapsedMs === undefined) {
+      return <Text color="yellow">• Running</Text>;
+    }
+
+    return <Text color="yellow">{`• Running ${formatDuration(props.elapsedMs)}`}</Text>;
   }
 
   if (props.status === "cancelling") {
@@ -38,9 +43,9 @@ export function Footer(props: FooterProps) {
   return <StatusMessage variant="info">idle</StatusMessage>;
 }
 
-function formatWorkedDuration(durationMs: number): string {
+function formatDuration(durationMs: number): string {
   if (!Number.isFinite(durationMs) || durationMs < 0) {
-    throw new Error(`Invalid worked duration: ${durationMs}`);
+    throw new Error(`Invalid duration: ${durationMs}`);
   }
 
   const totalSeconds = Math.floor(durationMs / 1000);

package/src/tui/components/memory-browser.tsx

@@ -0,0 +1,151 @@
+import {
+  Box,
+  Text,
+  useBoxMetrics,
+  useInput,
+  useWindowSize,
+  type DOMElement,
+} from "ink";
+import { useRef, useState } from "react";
+import type { StoredMemorySummary } from "../../memory/contracts";
+
+const BROWSER_CHROME_ROWS = 3;
+
+export type MemoryBrowserProps = {
+  readonly memories: readonly StoredMemorySummary[];
+  readonly onClose: () => void;
+  readonly viewportRows?: number;
+  readonly viewportColumns?: number;
+};
+
+export function MemoryBrowser(props: MemoryBrowserProps) {
+  const windowSize = useWindowSize();
+  const rows = Math.max(4, props.viewportRows ?? windowSize.rows);
+  const columns = Math.max(20, props.viewportColumns ?? windowSize.columns);
+  const bodyRows = Math.max(1, rows - BROWSER_CHROME_ROWS);
+  const contentRef = useRef<DOMElement>(null);
+  const { height: measuredContentRows, hasMeasured } = useBoxMetrics(contentRef);
+  const totalLines = props.memories.length === 0 ? 0 : measuredContentRows;
+  const maxTopLine = Math.max(0, totalLines - bodyRows);
+  const [topLine, setTopLine] = useState(0);
+  const visibleTopLine = clamp(topLine, 0, maxTopLine);
+  const visibleEnd = Math.min(totalLines, visibleTopLine + bodyRows);
+
+  useInput((input, key) => {
+    if (key.escape) {
+      props.onClose();
+      return;
+    }
+    if (key.home) {
+      setTopLine(0);
+      return;
+    }
+    if (key.end) {
+      setTopLine(maxTopLine);
+      return;
+    }
+    if (key.pageUp || key.pageDown) {
+      const direction = key.pageUp ? -1 : 1;
+      setTopLine((current) => clamp(current + direction * bodyRows, 0, maxTopLine));
+      return;
+    }
+    const direction =
+      key.upArrow || (input === "k" && !key.ctrl && !key.meta)
+        ? -1
+        : key.downArrow || (input === "j" && !key.ctrl && !key.meta)
+          ? 1
+          : 0;
+    if (direction !== 0) {
+      setTopLine((current) => clamp(current + direction, 0, maxTopLine));
+    }
+  });
+
+  return (
+    <Box width={columns} height={rows} flexDirection="column" overflow="hidden">
+      <Text bold>Global memory</Text>
+      <Text dimColor wrap="truncate-end">
+        ↑/↓ or j/k · PgUp/PgDn · Home/End · Esc close
+      </Text>
+      <Box
+        height={bodyRows}
+        width={columns}
+        position="relative"
+        overflow="hidden"
+        flexDirection="column"
+      >
+        {props.memories.length === 0 ? (
+          <Text dimColor>No stored memories.</Text>
+        ) : (
+          <Box
+            ref={contentRef}
+            position="absolute"
+            top={-visibleTopLine}
+            width={columns}
+            flexDirection="column"
+          >
+            {props.memories.map((memory, index) => (
+              <Box
+                key={memory.memoryId}
+                flexDirection="column"
+                marginBottom={index === props.memories.length - 1 ? 0 : 1}
+              >
+                <Text dimColor wrap="truncate-middle">
+                  {formatMemoryCreatedAt(memory.createdAt)} · {memory.sourceWorkspace}
+                </Text>
+                <Text>{normalizeMemoryDisplayText(memory.text)}</Text>
+              </Box>
+            ))}
+          </Box>
+        )}
+      </Box>
+      <Text dimColor wrap="truncate-end">
+        {props.memories.length === 0
+          ? "0 memories"
+          : memoryBrowserStatus(
+              visibleTopLine,
+              visibleEnd,
+              hasMeasured ? totalLines : 0,
+              props.memories.length,
+            )}
+      </Text>
+    </Box>
+  );
+}
+
+export function normalizeMemoryDisplayText(text: string): string {
+  return (
+    text
+      .replaceAll(/\r\n?/g, "\n")
+      .replaceAll("\t", "    ")
+      // eslint-disable-next-line no-control-regex
+      .replaceAll(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, "\uFFFD")
+  );
+}
+
+export function formatMemoryCreatedAt(createdAt: string): string {
+  const date = new Date(createdAt);
+  const year = String(date.getFullYear()).padStart(4, "0");
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  return `${year}-${month}-${day} ${hours}:${minutes}`;
+}
+
+function memoryBrowserStatus(
+  topLine: number,
+  endLine: number,
+  totalLines: number,
+  memoryCount: number,
+): string {
+  if (totalLines === 0) {
+    return `0 lines · ${memoryCount} ${memoryCount === 1 ? "memory" : "memories"}`;
+  }
+  return `${topLine + 1}–${endLine} / ${totalLines} lines · ${memoryCount} ${
+    memoryCount === 1 ? "memory" : "memories"
+  }`;
+}
+
+function clamp(value: number, minimum: number, maximum: number): number {
+  return Math.min(Math.max(value, minimum), maximum);
+}

package/src/tui/event-store.ts

@@ -697,8 +697,8 @@ function toolCallSummary(input: { name: string; args: unknown }): string {
   if (input.name === "Grep") {
     return `Grep ${toolPattern(input.args) ?? ""}`.trim();
   }
-  if (input.name === "WebSearch") {
-    return `WebSearch ${toolQuery(input.args) ?? ""}`.trim();
+  if (input.name === "WebSearch" || input.name === "MemorySearch") {
+    return `${input.name} ${toolQuery(input.args) ?? ""}`.trim();
   }
   if (input.name === "WebFetch") {
     return `WebFetch ${toolUrl(input.args) ?? ""}`.trim();
@@ -779,6 +779,11 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
       return raw.mode === "search"
         ? `${base} -> ${raw.page.hits.length} historical match${raw.page.hits.length === 1 ? "" : "es"}`
         : `${base} -> ${raw.page.returnedBytes} historical bytes`;
+    case "memory_search":
+      if (!raw.ok) {
+        return base;
+      }
+      return `${base} -> ${raw.matches.length} derived memor${raw.matches.length === 1 ? "y" : "ies"}`;
     case "skill":
       if (!raw.ok) {
         return `${base} failed -> ${boundedToolError(raw.error)}`;
@@ -846,6 +851,7 @@ function toolRawResultBashDetail(raw: ToolRawResult): Pick<TimelineItem, "bash">
     case "web_search":
     case "web_fetch":
     case "recall":
+    case "memory_search":
     case "skill":
     case "mcp":
     case "generic":
@@ -880,6 +886,7 @@ function toolRawResultDiff(
     case "web_search":
     case "web_fetch":
     case "recall":
+    case "memory_search":
     case "skill":
     case "mcp":
     case "generic":

package/src/tui/slash-commands.ts

@@ -24,6 +24,11 @@ export const SLASH_COMMANDS: readonly BuiltInSlashCommand[] = [
     usage: "/mcp",
     description: "Show MCP servers and runtime tools",
   },
+  {
+    name: "memory",
+    usage: "/memory",
+    description: "Browse stored global memories",
+  },
   {
     name: "compact",
     usage: "/compact [retire]",
@@ -67,6 +72,7 @@ export type ParsedSlashCommand =
   | { type: "status" }
   | { type: "skills" }
   | { type: "mcp" }
+  | { type: "memory" }
   | { type: "compact" }
   | { type: "compact_retire" }
   | { type: "clear" }
@@ -114,6 +120,12 @@ export function parseSlashCommand(input: string): ParsedSlashCommand {
     }
     throw slashCommandUsageError("mcp");
   }
+  if (command === "/memory") {
+    if (tokens.length === 1) {
+      return { type: "memory" };
+    }
+    throw slashCommandUsageError("memory");
+  }
   if (command === "/compact") {
     if (tokens.length === 1) {
       return { type: "compact" };