opencode-gateway 0.2.9 → 0.3.0

package/README.md

@@ -28,10 +28,22 @@ Check what it resolved:
 npx opencode-gateway doctor
 ```
 
-Then start OpenCode normally:
+Recommended:
+
+```bash
+opencode-gateway serve
+```
+
+This wraps `opencode serve` and warms the gateway plugin worker immediately, so
+Telegram polling and scheduled jobs do not stay idle until the first
+project-scoped request.
+
+If you still prefer the raw OpenCode command, warm the gateway explicitly after
+startup:
 
 ```bash
 opencode serve
+opencode-gateway warm
 ```
 
 If you want a separate managed config tree instead of editing your existing
@@ -39,9 +51,7 @@ OpenCode config:
 
 ```bash
 npx opencode-gateway init --managed
-export OPENCODE_CONFIG="$HOME/.config/opencode-gateway/opencode/opencode.json"
-export OPENCODE_CONFIG_DIR="$HOME/.config/opencode-gateway/opencode"
-opencode serve
+opencode-gateway serve --managed
 ```
 
 ## Example gateway config
@@ -88,8 +98,12 @@ inject_content = true
 [[memory.entries]]
 path = "memory/notes"
 description = "Domain notes and operating docs"
-inject_markdown_contents = true
-globs = ["**/*.rs", "notes/**/*.txt"]
+search_only = true
+
+[[memory.entries]]
+path = "memory/snippets"
+description = "Selected files are auto-injected; the rest stay searchable on demand"
+globs = ["**/*.md", "notes/**/*.txt"]
 ```
 
 When Telegram is enabled, export the bot token through the configured
@@ -112,13 +126,16 @@ Mailbox rules:
 Memory rules:
 
 - all entries inject their configured path and description
-- file contents are injected only when `inject_content = true`
-- directory entries default to description-only
-- `inject_markdown_contents = true` recursively injects `*.md` and `*.markdown`
-- `globs` are relative to the configured directory and may match other UTF-8
-  text files
+- file contents are auto-injected only when `inject_content = true`
+- `search_only = true` keeps an entry available to `memory_search` and `memory_get`
+  without auto-injecting its content
+- directory entries default to description-only plus on-demand search
+- directory `globs` are relative to the configured directory and define which
+  files are auto-injected; other UTF-8 text files remain searchable on demand
 - relative paths are resolved from `opencode-gateway-workspace`
 - absolute paths are still allowed
 - missing files and directories are created automatically on load
 - the default template includes `USER.md` as persistent user-profile memory
 - memory is injected only into gateway-managed sessions
+- `memory_search` returns matching snippets and paths; `memory_get` reads a
+  specific configured memory file by path and optional line window

package/dist/cli/args.d.ts

@@ -1,7 +1,7 @@
 export type CliCommand = {
     kind: "help";
 } | {
-    kind: "init" | "doctor";
+    kind: "init" | "doctor" | "serve" | "warm";
     managed: boolean;
     configDir: string | null;
 };

package/dist/cli/opencode-server.d.ts

@@ -0,0 +1,19 @@
+type CliOptions = {
+    managed: boolean;
+    configDir: string | null;
+};
+export type ResolvedServeTarget = {
+    configDir: string;
+    gatewayConfigPath: string;
+    workspaceDirPath: string;
+    opencodeConfigPath: string;
+    serverOrigin: string;
+    env: Record<string, string>;
+};
+export declare function resolveServeTarget(options: CliOptions, env: Record<string, string | undefined>): Promise<ResolvedServeTarget>;
+export declare function warmGatewayProject(target: ResolvedServeTarget, options?: {
+    deadlineMs?: number;
+    intervalMs?: number;
+}): Promise<void>;
+export declare function resolveServerOriginFromDocument(document: Record<string, unknown>): string;
+export {};

package/dist/cli/serve.d.ts

@@ -0,0 +1,6 @@
+type ServeOptions = {
+    managed: boolean;
+    configDir: string | null;
+};
+export declare function runServe(options: ServeOptions, env: Record<string, string | undefined>): Promise<void>;
+export {};

package/dist/cli/warm.d.ts

@@ -0,0 +1,6 @@
+type WarmOptions = {
+    managed: boolean;
+    configDir: string | null;
+};
+export declare function runWarm(options: WarmOptions, env: Record<string, string | undefined>): Promise<void>;
+export {};

package/dist/cli.js

@@ -7,7 +7,7 @@ function parseCliCommand(argv) {
   if (!command || command === "help" || command === "--help" || command === "-h") {
     return { kind: "help" };
   }
-  if (command !== "init" && command !== "doctor") {
+  if (command !== "init" && command !== "doctor" && command !== "serve" && command !== "warm") {
     throw new Error(`unknown command: ${command}`);
   }
   let managed = false;
@@ -48,6 +48,8 @@ function formatCliHelp() {
     "Commands:",
     "  opencode-gateway init [--managed] [--config-dir <path>]",
     "  opencode-gateway doctor [--managed] [--config-dir <path>]",
+    "  opencode-gateway warm [--managed] [--config-dir <path>]",
+    "  opencode-gateway serve [--managed] [--config-dir <path>]",
     "",
     "Defaults:",
     "  init/doctor use OPENCODE_CONFIG_DIR when set, otherwise ~/.config/opencode",
@@ -57,42 +59,7 @@ function formatCliHelp() {
 }
 
 // src/cli/doctor.ts
-import { readFile } from "node:fs/promises";
-import { join as join3 } from "node:path";
-
-// src/config/paths.ts
-import { homedir } from "node:os";
-import { dirname, join, resolve as resolve2 } from "node:path";
-var GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
-var OPENCODE_CONFIG_FILE = "opencode.json";
-var OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
-var OPENCODE_CONFIG_FILE_CANDIDATES = [OPENCODE_CONFIG_FILE_JSONC, OPENCODE_CONFIG_FILE];
-var GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
-function resolveOpencodeConfigDir(env) {
-  const explicit = env.OPENCODE_CONFIG_DIR;
-  if (explicit && explicit.trim().length > 0) {
-    return resolve2(explicit);
-  }
-  return defaultOpencodeConfigDir(env);
-}
-function resolveManagedOpencodeConfigDir(env) {
-  return join(resolveConfigHome(env), "opencode-gateway", "opencode");
-}
-function resolveGatewayWorkspacePath(configPath) {
-  return join(dirname(configPath), GATEWAY_WORKSPACE_DIR);
-}
-function defaultGatewayStateDbPath(env) {
-  return join(resolveDataHome(env), "opencode-gateway", "state.db");
-}
-function resolveConfigHome(env) {
-  return env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
-}
-function resolveDataHome(env) {
-  return env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
-}
-function defaultOpencodeConfigDir(env) {
-  return join(resolveConfigHome(env), "opencode");
-}
+import { readFile as readFile2 } from "node:fs/promises";
 
 // src/cli/opencode-config.ts
 var OPENCODE_SCHEMA_URL = "https://opencode.ai/config.json";
@@ -290,6 +257,47 @@ function isGatewayPluginReference(entry) {
 // src/cli/opencode-config-file.ts
 import { join as join2 } from "node:path";
 
+// src/config/paths.ts
+import { homedir } from "node:os";
+import { dirname, join, resolve as resolve2 } from "node:path";
+var GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
+var OPENCODE_CONFIG_FILE = "opencode.json";
+var OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
+var OPENCODE_CONFIG_FILE_CANDIDATES = [OPENCODE_CONFIG_FILE_JSONC, OPENCODE_CONFIG_FILE];
+var GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
+function resolveGatewayConfigPath(env) {
+  const explicit = env.OPENCODE_GATEWAY_CONFIG;
+  if (explicit && explicit.trim().length > 0) {
+    return resolve2(explicit);
+  }
+  return join(resolveOpencodeConfigDir(env), GATEWAY_CONFIG_FILE);
+}
+function resolveOpencodeConfigDir(env) {
+  const explicit = env.OPENCODE_CONFIG_DIR;
+  if (explicit && explicit.trim().length > 0) {
+    return resolve2(explicit);
+  }
+  return defaultOpencodeConfigDir(env);
+}
+function resolveManagedOpencodeConfigDir(env) {
+  return join(resolveConfigHome(env), "opencode-gateway", "opencode");
+}
+function resolveGatewayWorkspacePath(configPath) {
+  return join(dirname(configPath), GATEWAY_WORKSPACE_DIR);
+}
+function defaultGatewayStateDbPath(env) {
+  return join(resolveDataHome(env), "opencode-gateway", "state.db");
+}
+function resolveConfigHome(env) {
+  return env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+}
+function resolveDataHome(env) {
+  return env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+}
+function defaultOpencodeConfigDir(env) {
+  return join(resolveConfigHome(env), "opencode");
+}
+
 // src/cli/paths.ts
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
@@ -329,19 +337,106 @@ async function resolveOpencodeConfigFile(configDir) {
   };
 }
 
+// src/cli/opencode-server.ts
+import { readFile } from "node:fs/promises";
+var DEFAULT_SERVER_ORIGIN = "http://127.0.0.1:4096";
+var WARM_REQUEST_TIMEOUT_MS = 2000;
+async function resolveServeTarget(options, env) {
+  const configDir = resolveCliConfigDir(options, env);
+  const gatewayConfigPath = resolveGatewayConfigPath({
+    ...env,
+    OPENCODE_CONFIG_DIR: configDir
+  });
+  const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
+  const opencodeConfig = await resolveOpencodeConfigFile(configDir);
+  const serverOrigin = opencodeConfig.exists ? await resolveServerOrigin(opencodeConfig.path) : DEFAULT_SERVER_ORIGIN;
+  return {
+    configDir,
+    gatewayConfigPath,
+    workspaceDirPath,
+    opencodeConfigPath: opencodeConfig.path,
+    serverOrigin,
+    env: {
+      OPENCODE_CONFIG_DIR: configDir,
+      OPENCODE_CONFIG: opencodeConfig.path
+    }
+  };
+}
+async function warmGatewayProject(target, options) {
+  const deadlineMs = options?.deadlineMs ?? 30000;
+  const intervalMs = options?.intervalMs ?? 250;
+  const warmUrl = new URL("/experimental/tool/ids", target.serverOrigin);
+  warmUrl.searchParams.set("directory", target.workspaceDirPath);
+  const deadline = Date.now() + deadlineMs;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(warmUrl, {
+        signal: AbortSignal.timeout(WARM_REQUEST_TIMEOUT_MS)
+      });
+      if (response.ok) {
+        const payload = await response.json();
+        if (isGatewayToolList(payload)) {
+          return;
+        }
+      }
+    } catch {}
+    await delay(intervalMs);
+  }
+  throw new Error(`failed to warm the gateway plugin at ${target.serverOrigin} for ${target.workspaceDirPath}`);
+}
+function resolveServerOriginFromDocument(document) {
+  const server = document.server;
+  if (server === null || typeof server !== "object" || Array.isArray(server)) {
+    return DEFAULT_SERVER_ORIGIN;
+  }
+  const hostname = readNonEmptyString(server.hostname);
+  const port = readPort(server.port);
+  if (hostname === null || port === null) {
+    return DEFAULT_SERVER_ORIGIN;
+  }
+  return `http://${hostname}:${port}`;
+}
+async function resolveServerOrigin(configPath) {
+  const source = await readFile(configPath, "utf8");
+  const document = parseOpencodeConfig(source, configPath);
+  return resolveServerOriginFromDocument(document);
+}
+function readNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function readPort(value) {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    return null;
+  }
+  return value >= 1 && value <= 65535 ? value : null;
+}
+function isGatewayToolList(value) {
+  return Array.isArray(value) && value.includes("gateway_status");
+}
+function delay(durationMs) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, durationMs);
+  });
+}
+
 // src/cli/doctor.ts
 async function runDoctor(options, env) {
   const configDir = resolveCliConfigDir(options, env);
-  const gatewayConfigPath = join3(configDir, GATEWAY_CONFIG_FILE);
-  const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
   const opencodeConfig = await resolveOpencodeConfigFile(configDir);
   const opencodeStatus = await inspectOpencodeConfig(opencodeConfig.path);
   const gatewayOverride = env.OPENCODE_GATEWAY_CONFIG?.trim() || null;
+  const serveTarget = await resolveServeTarget(options, env);
   console.log("doctor report");
   console.log(`  config dir: ${configDir}`);
   console.log(`  opencode config: ${await describePath(opencodeConfig.path)}`);
-  console.log(`  gateway config: ${await describePath(gatewayConfigPath)}`);
-  console.log(`  gateway workspace: ${await describePath(workspaceDirPath)}`);
+  console.log(`  gateway config: ${await describePath(serveTarget.gatewayConfigPath)}`);
+  console.log(`  gateway workspace: ${await describePath(serveTarget.workspaceDirPath)}`);
+  console.log(`  warm server: ${serveTarget.serverOrigin}`);
+  console.log(`  warm directory: ${serveTarget.workspaceDirPath}`);
   console.log(`  gateway config override: ${gatewayOverride ?? "not set"}`);
   console.log(`  plugin configured: ${opencodeStatus.pluginConfigured}`);
   console.log(`  TELEGRAM_BOT_TOKEN: ${env.TELEGRAM_BOT_TOKEN?.trim() ? "set" : "missing"}`);
@@ -360,7 +455,7 @@ async function inspectOpencodeConfig(path) {
     };
   }
   try {
-    const parsed = parseOpencodeConfig(await readFile(path, "utf8"), path);
+    const parsed = parseOpencodeConfig(await readFile2(path, "utf8"), path);
     return {
       pluginConfigured: inspectGatewayPlugin(parsed),
       error: null
@@ -374,8 +469,8 @@ async function inspectOpencodeConfig(path) {
 }
 
 // src/cli/init.ts
-import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { mkdir, readFile as readFile3, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
 
 // src/cli/templates.ts
 function buildGatewayConfigTemplate(stateDbPath) {
@@ -423,10 +518,19 @@ function buildGatewayConfigTemplate(stateDbPath) {
     "inject_content = true",
     "#",
     "# [[memory.entries]]",
+    '# path = "memory/project.md"',
+    '# description = "Project conventions and long-lived context"',
+    "# inject_content = true",
+    "#",
+    "# [[memory.entries]]",
     '# path = "memory/notes"',
-    '# description = "Domain notes and operating docs"',
-    "# inject_markdown_contents = true",
-    '# globs = ["**/*.rs", "notes/**/*.txt"]',
+    '# description = "Domain notes and operating docs. Use memory_search and memory_get to inspect this directory on demand."',
+    "# search_only = true",
+    "#",
+    "# [[memory.entries]]",
+    '# path = "memory/snippets"',
+    '# description = "Selected files are auto-injected; the rest stay searchable on demand."',
+    '# globs = ["**/*.md", "notes/**/*.txt"]',
     ""
   ].join(`
 `);
@@ -438,7 +542,7 @@ function escapeTomlString(value) {
 // src/cli/init.ts
 async function runInit(options, env) {
   const configDir = resolveCliConfigDir(options, env);
-  const gatewayConfigPath = join4(configDir, GATEWAY_CONFIG_FILE);
+  const gatewayConfigPath = join3(configDir, GATEWAY_CONFIG_FILE);
   const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
   const opencodeConfig = await resolveOpencodeConfigFile(configDir);
   const opencodeConfigPath = opencodeConfig.path;
@@ -449,7 +553,7 @@ async function runInit(options, env) {
     await writeFile(opencodeConfigPath, stringifyOpencodeConfig(createDefaultOpencodeConfig(options.managed)));
     opencodeStatus = "created";
   } else {
-    const source = await readFile2(opencodeConfigPath, "utf8");
+    const source = await readFile3(opencodeConfigPath, "utf8");
     const parsed = parseOpencodeConfig(source, opencodeConfigPath);
     const next = ensureGatewayPlugin(parsed);
     if (next.changed) {
@@ -467,6 +571,54 @@ async function runInit(options, env) {
   console.log(`opencode config: ${opencodeConfigPath} (${opencodeStatus})`);
   console.log(`gateway config: ${gatewayConfigPath} (${gatewayStatus})`);
   console.log(`gateway workspace: ${workspaceDirPath} (ready)`);
+  console.log("next step: start OpenCode with `opencode-gateway serve`");
+  console.log("fallback: if you still run `opencode serve`, run `opencode-gateway warm` after startup");
+}
+
+// src/cli/serve.ts
+import { spawn } from "node:child_process";
+import { mkdir as mkdir2 } from "node:fs/promises";
+async function runServe(options, env) {
+  const target = await resolveServeTarget(options, env);
+  await mkdir2(target.workspaceDirPath, { recursive: true });
+  const child = spawn("opencode", ["serve"], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ...target.env
+    }
+  });
+  warmGatewayProject(target).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`warning: ${message}`);
+    console.warn("warning: the gateway plugin may stay idle until the first project-scoped request");
+  });
+  const exitCode = await waitForChild(child);
+  if (exitCode !== 0) {
+    process.exitCode = exitCode;
+  }
+}
+function waitForChild(child) {
+  return new Promise((resolve4, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (signal !== null) {
+        resolve4(1);
+        return;
+      }
+      resolve4(code ?? 0);
+    });
+  });
+}
+
+// src/cli/warm.ts
+import { mkdir as mkdir3 } from "node:fs/promises";
+async function runWarm(options, env) {
+  const target = await resolveServeTarget(options, env);
+  await mkdir3(target.workspaceDirPath, { recursive: true });
+  await warmGatewayProject(target);
+  console.log(`gateway plugin warmed: ${target.serverOrigin}`);
+  console.log(`warm directory: ${target.workspaceDirPath}`);
 }
 
 // src/cli.ts
@@ -482,6 +634,12 @@ async function main() {
     case "init":
       await runInit(command, process.env);
       return;
+    case "serve":
+      await runServe(command, process.env);
+      return;
+    case "warm":
+      await runWarm(command, process.env);
+      return;
   }
 }
 main().catch((error) => {

package/dist/config/memory.d.ts

@@ -7,12 +7,13 @@ export type GatewayMemoryEntryConfig = {
     displayPath: string;
     description: string;
     injectContent: boolean;
+    searchOnly: boolean;
 } | {
     kind: "directory";
     path: string;
     displayPath: string;
     description: string;
-    injectMarkdownContents: boolean;
     globs: string[];
+    searchOnly: boolean;
 };
 export declare function parseMemoryConfig(value: unknown, workspaceDirPath: string): Promise<GatewayMemoryConfig>;

package/dist/gateway.d.ts

@@ -2,6 +2,7 @@ import type { PluginInput } from "@opencode-ai/plugin";
 import type { GatewayBindingModule, GatewayContract } from "./binding";
 import { GatewayCronRuntime } from "./cron/runtime";
 import { ChannelFileSender } from "./host/file-sender";
+import { GatewayMemoryRuntime } from "./memory/runtime";
 import { GatewayExecutor } from "./runtime/executor";
 import { GatewaySessionContext } from "./session/context";
 import { ChannelSessionSwitcher } from "./session/switcher";
@@ -29,7 +30,8 @@ export declare class GatewayPluginRuntime {
     readonly channelSessions: ChannelSessionSwitcher;
     readonly sessionContext: GatewaySessionContext;
     readonly systemPrompts: GatewaySystemPromptBuilder;
-    constructor(contract: GatewayContract, executor: GatewayExecutor, cron: GatewayCronRuntime, telegram: GatewayTelegramRuntime, files: ChannelFileSender, channelSessions: ChannelSessionSwitcher, sessionContext: GatewaySessionContext, systemPrompts: GatewaySystemPromptBuilder);
+    readonly memory: GatewayMemoryRuntime;
+    constructor(contract: GatewayContract, executor: GatewayExecutor, cron: GatewayCronRuntime, telegram: GatewayTelegramRuntime, files: ChannelFileSender, channelSessions: ChannelSessionSwitcher, sessionContext: GatewaySessionContext, systemPrompts: GatewaySystemPromptBuilder, memory: GatewayMemoryRuntime);
     status(): GatewayPluginStatus;
 }
 export declare function createGatewayRuntime(module: GatewayBindingModule, input: PluginInput): Promise<GatewayPluginRuntime>;

package/dist/index.js

@@ -16151,30 +16151,42 @@ async function readMemoryEntry(value, index, workspaceDirPath) {
     throw new Error(`${field} must be a table`);
   }
   const entry = value;
+  if (entry.inject_markdown_contents !== undefined) {
+    throw new Error(`${field}.inject_markdown_contents has been removed; use globs for directory injection or search_only for on-demand access`);
+  }
   const displayPath = readRequiredString(entry.path, `${field}.path`);
   const description = readRequiredString(entry.description, `${field}.description`);
   const resolvedPath = resolve(workspaceDirPath, displayPath);
   const metadata = await ensurePathMetadata(resolvedPath, displayPath, entry, `${field}.path`);
+  const searchOnly = readBoolean2(entry.search_only, `${field}.search_only`, false);
   if (metadata.isFile()) {
-    ensureDirectoryOnlyFieldIsAbsent(entry.inject_markdown_contents, `${field}.inject_markdown_contents`);
     ensureDirectoryOnlyFieldIsAbsent(entry.globs, `${field}.globs`);
+    const injectContent = readBoolean2(entry.inject_content, `${field}.inject_content`, false);
+    if (searchOnly && injectContent) {
+      throw new Error(`${field} cannot enable both inject_content and search_only`);
+    }
     return {
       kind: "file",
       path: resolvedPath,
       displayPath,
       description,
-      injectContent: readBoolean2(entry.inject_content, `${field}.inject_content`, false)
+      injectContent,
+      searchOnly
     };
   }
   if (metadata.isDirectory()) {
     ensureFileOnlyFieldIsAbsent(entry.inject_content, `${field}.inject_content`);
+    const globs = readGlobList(entry.globs, `${field}.globs`);
+    if (searchOnly && globs.length > 0) {
+      throw new Error(`${field} cannot enable both globs and search_only`);
+    }
     return {
       kind: "directory",
       path: resolvedPath,
       displayPath,
       description,
-      injectMarkdownContents: readBoolean2(entry.inject_markdown_contents, `${field}.inject_markdown_contents`, false),
-      globs: readGlobList(entry.globs, `${field}.globs`)
+      globs,
+      searchOnly
     };
   }
   throw new Error(`${field}.path must point to a regular file or directory`);
@@ -16198,7 +16210,7 @@ function inferMissingEntryKind(displayPath, entry) {
   if (entry.inject_content !== undefined) {
     return "file";
   }
-  if (entry.inject_markdown_contents !== undefined || entry.globs !== undefined) {
+  if (entry.globs !== undefined) {
     return "directory";
   }
   const trimmedPath = displayPath.trim();
@@ -17614,87 +17626,58 @@ class GatewayMailboxRouter {
   }
 }
 
-// src/memory/prompt.ts
+// src/memory/files.ts
 var import_fast_glob = __toESM(require_out4(), 1);
 import { readFile as readFile3 } from "node:fs/promises";
 import { extname as extname3, relative } from "node:path";
-var MARKDOWN_GLOBS = ["**/*.md", "**/*.markdown"];
+var ALL_FILES_GLOB = "**/*";
 var UTF8_TEXT_DECODER = new TextDecoder("utf-8", { fatal: true });
-
-class GatewayMemoryPromptProvider {
-  config;
-  logger;
-  constructor(config, logger) {
-    this.config = config;
-    this.logger = logger;
-  }
-  async buildPrompt() {
-    if (this.config.entries.length === 0) {
-      return null;
-    }
-    const sections = await Promise.all(this.config.entries.map((entry) => this.buildEntrySection(entry)));
-    return ["Gateway memory:", ...sections].join(`
-
-`);
-  }
-  async buildEntrySection(entry) {
-    const lines = [`Configured path: ${entry.displayPath}`, `Description: ${entry.description}`];
-    const injectedFiles = await collectInjectedFiles(entry, this.logger);
-    for (const file of injectedFiles) {
-      lines.push("");
-      lines.push(`File: ${file.displayPath}`);
-      lines.push(codeFence(file.infoString, file.text));
-    }
-    return lines.join(`
-`);
-  }
-}
-async function collectInjectedFiles(entry, logger) {
+async function collectInjectedMemoryFiles(entry, logger) {
   if (entry.kind === "file") {
-    if (!entry.injectContent) {
+    if (entry.searchOnly || !entry.injectContent) {
       return [];
     }
-    const text = await readTextFile(entry.path, logger);
+    const text = await readMemoryTextFile(entry.path, logger);
     if (text === null) {
       return [];
     }
     return [
       {
+        path: entry.path,
         displayPath: entry.displayPath,
+        description: entry.description,
         infoString: inferFenceInfoString(entry.path),
         text
       }
     ];
   }
-  const filePaths = new Set;
-  if (entry.injectMarkdownContents) {
-    for (const pattern of MARKDOWN_GLOBS) {
-      addMatchingFiles(filePaths, entry.path, pattern);
-    }
-  }
-  for (const pattern of entry.globs) {
-    addMatchingFiles(filePaths, entry.path, pattern);
+  if (entry.searchOnly || entry.globs.length === 0) {
+    return [];
   }
-  const injectedFiles = [];
-  for (const filePath of [...filePaths].sort((left, right) => left.localeCompare(right))) {
-    const text = await readTextFile(filePath, logger);
-    if (text === null) {
+  return await readDirectoryFiles(entry, entry.globs, logger);
+}
+async function collectSearchableMemoryFiles(config, logger) {
+  const files = [];
+  for (const entry of config.entries) {
+    if (entry.kind === "file") {
+      const text = await readMemoryTextFile(entry.path, logger);
+      if (text === null) {
+        continue;
+      }
+      files.push({
+        path: entry.path,
+        displayPath: entry.displayPath,
+        description: entry.description,
+        infoString: inferFenceInfoString(entry.path),
+        text
+      });
       continue;
     }
-    injectedFiles.push({
-      displayPath: relativeDisplayPath(entry.path, entry.displayPath, filePath),
-      infoString: inferFenceInfoString(filePath),
-      text
-    });
+    files.push(...await readDirectoryFiles(entry, [ALL_FILES_GLOB], logger));
   }
-  return injectedFiles;
+  return files;
 }
-function addMatchingFiles(result, cwd, pattern) {
-  for (const match of import_fast_glob.globSync(pattern, { cwd, absolute: true, onlyFiles: true })) {
-    result.add(match);
-  }
-}
-async function readTextFile(path, logger) {
+async function readMemoryTextFile(path, logger) {
   let bytes;
   try {
     bytes = await readFile3(path);
@@ -17715,6 +17698,37 @@ async function readTextFile(path, logger) {
   }
   return text;
 }
+function codeFence(infoString, text) {
+  const language = infoString.length === 0 ? "" : infoString;
+  return [`\`\`\`${language}`, text, "```"].join(`
+`);
+}
+function addMatchingFiles(result, cwd, pattern) {
+  for (const match of import_fast_glob.globSync(pattern, { cwd, absolute: true, onlyFiles: true, followSymbolicLinks: false })) {
+    result.add(match);
+  }
+}
+async function readDirectoryFiles(entry, patterns, logger) {
+  const filePaths = new Set;
+  for (const pattern of patterns) {
+    addMatchingFiles(filePaths, entry.path, pattern);
+  }
+  const files = [];
+  for (const filePath of [...filePaths].sort((left, right) => left.localeCompare(right))) {
+    const text = await readMemoryTextFile(filePath, logger);
+    if (text === null) {
+      continue;
+    }
+    files.push({
+      path: filePath,
+      displayPath: relativeDisplayPath(entry.path, entry.displayPath, filePath),
+      description: entry.description,
+      infoString: inferFenceInfoString(filePath),
+      text
+    });
+  }
+  return files;
+}
 function relativeDisplayPath(rootPath, rootDisplayPath, filePath) {
   const suffix = relative(rootPath, filePath);
   if (suffix.length === 0) {
@@ -17729,11 +17743,6 @@ function inferFenceInfoString(path) {
   }
   return extension2;
 }
-function codeFence(infoString, text) {
-  const language = infoString.length === 0 ? "" : infoString;
-  return [`\`\`\`${language}`, text, "```"].join(`
-`);
-}
 function formatError2(error) {
   if (error instanceof Error && error.message.trim().length > 0) {
     return error.message;
@@ -17741,6 +17750,218 @@ function formatError2(error) {
   return String(error);
 }
 
+// src/memory/prompt.ts
+class GatewayMemoryPromptProvider {
+  config;
+  logger;
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  async buildPrompt() {
+    if (this.config.entries.length === 0) {
+      return null;
+    }
+    const sections = await Promise.all(this.config.entries.map((entry) => this.buildEntrySection(entry)));
+    return ["Gateway memory:", ...sections].join(`
+
+`);
+  }
+  async buildEntrySection(entry) {
+    const lines = [
+      `Configured path: ${entry.displayPath}`,
+      `Description: ${entry.description}`,
+      `Access: ${describeMemoryAccess(entry)}`
+    ];
+    const injectedFiles = await collectInjectedMemoryFiles(entry, this.logger);
+    if (entry.kind === "directory" && entry.globs.length > 0 && !entry.searchOnly) {
+      lines.push(`Auto-injected globs: ${entry.globs.join(", ")}`);
+    }
+    for (const file of injectedFiles) {
+      lines.push("");
+      lines.push(`File: ${file.displayPath}`);
+      lines.push(codeFence(file.infoString, file.text));
+    }
+    return lines.join(`
+`);
+  }
+}
+function describeMemoryAccess(entry) {
+  if (entry.kind === "file") {
+    if (entry.injectContent && !entry.searchOnly) {
+      return "auto-injected; use memory_search or memory_get for targeted follow-up";
+    }
+    return "search-only; use memory_search or memory_get when this file is relevant";
+  }
+  if (entry.searchOnly) {
+    return "search-only; all UTF-8 text files under this directory are available via memory_search or memory_get";
+  }
+  if (entry.globs.length > 0) {
+    return "globs are auto-injected; all UTF-8 text files under this directory remain available via memory_search or memory_get";
+  }
+  return "search-only by default; use memory_search or memory_get when this directory is relevant";
+}
+
+// src/memory/runtime.ts
+import { dirname as dirname3 } from "node:path";
+import { FileFinder } from "@ff-labs/fff-node";
+var DEFAULT_SEARCH_LIMIT = 5;
+var MAX_SEARCH_LIMIT = 20;
+var DEFAULT_GET_MAX_LINES = 200;
+var MAX_GET_MAX_LINES = 500;
+var SEARCH_CONTEXT_RADIUS = 1;
+var SEARCH_SCAN_TIMEOUT_MS = 5000;
+
+class GatewayMemoryRuntime {
+  config;
+  logger;
+  finderCache = new Map;
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  hasEntries() {
+    return this.config.entries.length > 0;
+  }
+  async search(query, limit = DEFAULT_SEARCH_LIMIT) {
+    const normalizedQuery = normalizeRequiredString(query, "query");
+    const normalizedLimit = normalizePositiveInteger(limit, "limit", MAX_SEARCH_LIMIT);
+    const searchableFiles = await collectSearchableMemoryFiles(this.config, this.logger);
+    const searchableFilesByPath = new Map(searchableFiles.map((file) => [file.path, file]));
+    const results = [];
+    for (const entry of this.config.entries) {
+      const finder = await this.getFinder(searchRootForEntry(entry));
+      const grep = finder.grep(normalizedQuery, {
+        mode: "plain",
+        beforeContext: SEARCH_CONTEXT_RADIUS,
+        afterContext: SEARCH_CONTEXT_RADIUS
+      });
+      if (!grep.ok) {
+        throw new Error(`memory search failed for ${entry.displayPath}: ${grep.error}`);
+      }
+      for (const match of grep.value.items) {
+        if (entry.kind === "file" && match.path !== entry.path) {
+          continue;
+        }
+        const searchableFile = searchableFilesByPath.get(match.path);
+        if (searchableFile === undefined) {
+          continue;
+        }
+        const window2 = readSnippetWindow(searchableFile.text, match.lineNumber, SEARCH_CONTEXT_RADIUS);
+        results.push({
+          path: displayPathForMatch(entry, match.relativePath),
+          description: entry.description,
+          lineStart: window2.lineStart,
+          lineEnd: window2.lineEnd,
+          snippet: window2.text,
+          infoString: searchableFile.infoString
+        });
+        if (results.length >= normalizedLimit) {
+          return results;
+        }
+      }
+    }
+    return results;
+  }
+  async get(path, startLine = 1, maxLines = DEFAULT_GET_MAX_LINES) {
+    const normalizedPath = normalizeRequiredString(path, "path");
+    const normalizedStartLine = normalizePositiveInteger(startLine, "start_line");
+    const normalizedMaxLines = normalizePositiveInteger(maxLines, "max_lines", MAX_GET_MAX_LINES);
+    const files = await collectSearchableMemoryFiles(this.config, this.logger);
+    const matches = files.filter((file2) => file2.displayPath === normalizedPath);
+    if (matches.length === 0) {
+      throw new Error(`memory path was not found: ${normalizedPath}`);
+    }
+    if (matches.length > 1) {
+      throw new Error(`memory path is ambiguous: ${normalizedPath}`);
+    }
+    const file = matches[0];
+    const lines = splitLines(file.text);
+    if (normalizedStartLine > lines.length) {
+      throw new Error(`start_line ${normalizedStartLine} exceeds the file length of ${lines.length} line(s) for ${normalizedPath}`);
+    }
+    const startIndex = normalizedStartLine - 1;
+    const window2 = lines.slice(startIndex, startIndex + normalizedMaxLines);
+    return {
+      path: file.displayPath,
+      description: file.description,
+      lineStart: normalizedStartLine,
+      lineEnd: startIndex + window2.length,
+      text: window2.join(`
+`),
+      infoString: file.infoString
+    };
+  }
+  async getFinder(rootPath) {
+    const cached = this.finderCache.get(rootPath);
+    if (cached !== undefined && !cached.isDestroyed) {
+      return cached;
+    }
+    const created = FileFinder.create({
+      basePath: rootPath,
+      aiMode: true
+    });
+    if (!created.ok) {
+      throw new Error(`could not initialize memory search index for ${rootPath}: ${created.error}`);
+    }
+    const finder = created.value;
+    const ready = await finder.waitForScan(SEARCH_SCAN_TIMEOUT_MS);
+    if (!ready.ok) {
+      finder.destroy();
+      throw new Error(`memory search index failed while waiting for scan: ${ready.error}`);
+    }
+    if (!ready.value) {
+      this.logger.log("warn", `memory search scan is still warming after ${SEARCH_SCAN_TIMEOUT_MS}ms: ${rootPath}`);
+    }
+    this.finderCache.set(rootPath, finder);
+    return finder;
+  }
+}
+function searchRootForEntry(entry) {
+  return entry.kind === "file" ? dirname3(entry.path) : entry.path;
+}
+function displayPathForMatch(entry, relativePath) {
+  if (entry.kind === "file") {
+    return entry.displayPath;
+  }
+  const normalizedRelativePath = relativePath.replaceAll("\\", "/");
+  return normalizedRelativePath.length === 0 ? entry.displayPath : `${entry.displayPath}/${normalizedRelativePath}`;
+}
+function splitLines(text) {
+  return text.split(/\r?\n/);
+}
+function readSnippetWindow(text, lineNumber, contextRadius) {
+  const lines = splitLines(text);
+  const matchIndex = Math.min(Math.max(lineNumber - 1, 0), Math.max(lines.length - 1, 0));
+  const startIndex = Math.max(0, matchIndex - contextRadius);
+  const endIndex = Math.min(lines.length - 1, matchIndex + contextRadius);
+  return {
+    lineStart: startIndex + 1,
+    lineEnd: endIndex + 1,
+    text: lines.slice(startIndex, endIndex + 1).join(`
+`)
+  };
+}
+function normalizePositiveInteger(value, field, maxValue) {
+  if (!Number.isSafeInteger(value)) {
+    throw new Error(`${field} must be an integer`);
+  }
+  if (value <= 0) {
+    throw new Error(`${field} must be greater than 0`);
+  }
+  if (maxValue !== undefined && value > maxValue) {
+    throw new Error(`${field} must be less than or equal to ${maxValue}`);
+  }
+  return value;
+}
+function normalizeRequiredString(value, field) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`${field} must not be empty`);
+  }
+  return trimmed;
+}
+
 // src/opencode/adapter.ts
 import { basename as basename2 } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -17754,7 +17975,9 @@ function delay(durationMs) {
 
 // src/opencode/adapter.ts
 var SESSION_IDLE_POLL_MS = 250;
-var PROMPT_RESPONSE_TIMEOUT_MS = 90000;
+var PROMPT_RESPONSE_PROGRESS_TIMEOUT_MS = 90000;
+var PROMPT_RESPONSE_MAX_TIMEOUT_MS = 10 * 60000;
+var PROMPT_RESPONSE_SETTLE_MS = 1000;
 
 class OpencodeSdkAdapter {
   client;
@@ -17900,8 +18123,12 @@ class OpencodeSdkAdapter {
     };
   }
   async awaitPromptResponse(command) {
-    const deadline = Date.now() + PROMPT_RESPONSE_TIMEOUT_MS;
+    const startedAtMs = Date.now();
+    const maxDeadline = startedAtMs + PROMPT_RESPONSE_MAX_TIMEOUT_MS;
+    let progressDeadline = startedAtMs + PROMPT_RESPONSE_PROGRESS_TIMEOUT_MS;
     let stableCandidateKey = null;
+    let stableCandidateSinceMs = null;
+    let progressKey = null;
     for (;; ) {
       const messages = await this.client.session.messages({
         path: { id: command.sessionId },
@@ -17912,22 +18139,32 @@ class OpencodeSdkAdapter {
         responseStyle: "data",
         throwOnError: true
       });
-      const response = selectAssistantResponse(unwrapData(messages), command.messageId);
+      const assistantChildren = listAssistantResponses(unwrapData(messages), command.messageId);
+      const nextProgressKey = createAssistantProgressKey(assistantChildren);
+      const now = Date.now();
+      if (progressKey !== nextProgressKey) {
+        progressKey = nextProgressKey;
+        progressDeadline = now + PROMPT_RESPONSE_PROGRESS_TIMEOUT_MS;
+      }
+      const response = selectAssistantResponse(assistantChildren);
       if (response !== null) {
         const candidateKey = createAssistantCandidateKey(response);
         if (stableCandidateKey === candidateKey) {
-          return {
-            kind: "awaitPromptResponse",
-            sessionId: command.sessionId,
-            messageId: response.info.id,
-            parts: response.parts.flatMap(toBindingMessagePart)
-          };
+          if (stableCandidateSinceMs !== null && now - stableCandidateSinceMs >= PROMPT_RESPONSE_SETTLE_MS) {
+            return toAwaitPromptResponseResult(command.sessionId, response);
+          }
+        } else {
+          stableCandidateKey = candidateKey;
+          stableCandidateSinceMs = now;
         }
-        stableCandidateKey = candidateKey;
       } else {
         stableCandidateKey = null;
+        stableCandidateSinceMs = null;
       }
-      if (Date.now() >= deadline) {
+      if (now >= progressDeadline || now >= maxDeadline) {
+        if (response !== null) {
+          return toAwaitPromptResponseResult(command.sessionId, response);
+        }
         throw new Error(`assistant message for prompt ${command.messageId} is unavailable after prompt completion`);
       }
       await delay(SESSION_IDLE_POLL_MS);
@@ -17988,8 +18225,10 @@ function toSessionPromptPart(part) {
       };
   }
 }
-function selectAssistantResponse(messages, userMessageId) {
-  const assistantChildren = messages.filter(isAssistantChildMessage(userMessageId));
+function listAssistantResponses(messages, userMessageId) {
+  return messages.filter(isAssistantChildMessage(userMessageId));
+}
+function selectAssistantResponse(assistantChildren) {
   for (let index = assistantChildren.length - 1;index >= 0; index -= 1) {
     const candidate = assistantChildren[index];
     if (hasVisibleText(candidate)) {
@@ -18004,6 +18243,9 @@ function selectAssistantResponse(messages, userMessageId) {
   }
   return null;
 }
+function createAssistantProgressKey(messages) {
+  return JSON.stringify(messages.map(createAssistantCandidateKey));
+}
 function createAssistantCandidateKey(message) {
   return JSON.stringify({
     messageId: message.info.id,
@@ -18020,6 +18262,14 @@ function createAssistantCandidateKey(message) {
 function isAssistantChildMessage(userMessageId) {
   return (message) => message.info?.role === "assistant" && message.info.parentID === userMessageId;
 }
+function toAwaitPromptResponseResult(sessionId, message) {
+  return {
+    kind: "awaitPromptResponse",
+    sessionId,
+    messageId: message.info.id,
+    parts: message.parts.flatMap(toBindingMessagePart)
+  };
+}
 function toBindingMessagePart(part) {
   if (typeof part.id !== "string" || typeof part.messageID !== "string" || part.type.length === 0) {
     return [];
@@ -22463,7 +22713,7 @@ function buildGatewayContextPrompt(targets) {
 
 // src/store/sqlite.ts
 import { mkdir as mkdir2 } from "node:fs/promises";
-import { dirname as dirname3 } from "node:path";
+import { dirname as dirname4 } from "node:path";
 
 // src/store/migrations.ts
 var LATEST_SCHEMA_VERSION = 7;
@@ -23377,7 +23627,7 @@ function readBooleanField(value, field, fallback) {
   return raw;
 }
 async function openSqliteStore(path) {
-  await mkdir2(dirname3(path), { recursive: true });
+  await mkdir2(dirname4(path), { recursive: true });
   const { openRuntimeSqliteDatabase: openRuntimeSqliteDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));
   const db2 = await openRuntimeSqliteDatabase2(path);
   migrateGatewayDatabase(db2);
@@ -24107,7 +24357,8 @@ class GatewayPluginRuntime {
   channelSessions;
   sessionContext;
   systemPrompts;
-  constructor(contract, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts) {
+  memory;
+  constructor(contract, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts, memory) {
     this.contract = contract;
     this.executor = executor;
     this.cron = cron;
@@ -24116,6 +24367,7 @@ class GatewayPluginRuntime {
     this.channelSessions = channelSessions;
     this.sessionContext = sessionContext;
     this.systemPrompts = systemPrompts;
+    this.memory = memory;
   }
   status() {
     const rustStatus = this.contract.gatewayStatus();
@@ -24146,6 +24398,7 @@ async function createGatewayRuntime(module, input) {
     const effectiveCronTimeZone = resolveEffectiveCronTimeZone(module, config);
     const store = await openSqliteStore(config.stateDbPath);
     const sessionContext = new GatewaySessionContext(store);
+    const memory = new GatewayMemoryRuntime(config.memory, logger);
     const memoryPrompts = new GatewayMemoryPromptProvider(config.memory, logger);
     const systemPrompts = new GatewaySystemPromptBuilder(sessionContext, memoryPrompts);
     const telegramClient = config.telegram.enabled ? new TelegramBotClient(config.telegram.botToken) : null;
@@ -24170,7 +24423,7 @@ async function createGatewayRuntime(module, input) {
     cron.start();
     mailbox.start();
     telegram.start();
-    return new GatewayPluginRuntime(module, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts);
+    return new GatewayPluginRuntime(module, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts, memory);
   });
 }
 function resolveEffectiveCronTimeZone(module, config) {
@@ -36732,6 +36985,63 @@ function formatGatewayStatus(status) {
 `);
 }
 
+// src/tools/memory-get.ts
+function createMemoryGetTool(runtime) {
+  return tool({
+    description: "Read a configured gateway memory file by path. Use the path returned by memory_search or a configured file path.",
+    args: {
+      path: tool.schema.string().min(1),
+      start_line: tool.schema.number().optional(),
+      max_lines: tool.schema.number().optional()
+    },
+    async execute(args) {
+      return formatMemoryGetResult(await runtime.get(args.path, args.start_line, args.max_lines));
+    }
+  });
+}
+function formatMemoryGetResult(result) {
+  return [
+    `path=${result.path}`,
+    `description=${result.description}`,
+    `line_start=${result.lineStart}`,
+    `line_end=${result.lineEnd}`,
+    "content:",
+    codeFence(result.infoString, result.text)
+  ].join(`
+`);
+}
+
+// src/tools/memory-search.ts
+function createMemorySearchTool(runtime) {
+  return tool({
+    description: "Search configured gateway memory files and directories. Returns matching snippets and paths that can be read in more detail with memory_get.",
+    args: {
+      query: tool.schema.string().min(1),
+      limit: tool.schema.number().optional()
+    },
+    async execute(args) {
+      const results = await runtime.search(args.query, args.limit);
+      if (results.length === 0) {
+        return "no memory matches";
+      }
+      return results.map((result, index) => formatMemorySearchResult(result, index + 1)).join(`
+
+`);
+    }
+  });
+}
+function formatMemorySearchResult(result, ordinal) {
+  return [
+    `result[${ordinal}].path=${result.path}`,
+    `result[${ordinal}].description=${result.description}`,
+    `result[${ordinal}].line_start=${result.lineStart}`,
+    `result[${ordinal}].line_end=${result.lineEnd}`,
+    `result[${ordinal}].snippet:`,
+    codeFence(result.infoString, result.snippet)
+  ].join(`
+`);
+}
+
 // src/tools/schedule-cancel.ts
 function createScheduleCancelTool(runtime) {
   return tool({
@@ -36972,6 +37282,10 @@ var OpencodeGatewayPlugin = async (input) => {
     schedule_once: createScheduleOnceTool(runtime.cron, runtime.sessionContext),
     schedule_status: createScheduleStatusTool(runtime.cron)
   };
+  if (runtime.memory.hasEntries()) {
+    tools.memory_search = createMemorySearchTool(runtime.memory);
+    tools.memory_get = createMemoryGetTool(runtime.memory);
+  }
   if (runtime.files.hasEnabledChannel()) {
     tools.channel_send_file = createChannelSendFileTool(runtime.files, runtime.sessionContext);
   }

package/dist/memory/files.d.ts

@@ -0,0 +1,13 @@
+import type { BindingLoggerHost } from "../binding";
+import type { GatewayMemoryConfig, GatewayMemoryEntryConfig } from "../config/memory";
+export type SearchableMemoryFile = {
+    path: string;
+    displayPath: string;
+    description: string;
+    infoString: string;
+    text: string;
+};
+export declare function collectInjectedMemoryFiles(entry: GatewayMemoryEntryConfig, logger: Pick<BindingLoggerHost, "log">): Promise<SearchableMemoryFile[]>;
+export declare function collectSearchableMemoryFiles(config: GatewayMemoryConfig, logger: Pick<BindingLoggerHost, "log">): Promise<SearchableMemoryFile[]>;
+export declare function readMemoryTextFile(path: string, logger: Pick<BindingLoggerHost, "log">): Promise<string | null>;
+export declare function codeFence(infoString: string, text: string): string;

package/dist/memory/runtime.d.ts

@@ -0,0 +1,28 @@
+import type { BindingLoggerHost } from "../binding";
+import type { GatewayMemoryConfig } from "../config/memory";
+export type MemorySearchResult = {
+    path: string;
+    description: string;
+    lineStart: number;
+    lineEnd: number;
+    snippet: string;
+    infoString: string;
+};
+export type MemoryGetResult = {
+    path: string;
+    description: string;
+    lineStart: number;
+    lineEnd: number;
+    text: string;
+    infoString: string;
+};
+export declare class GatewayMemoryRuntime {
+    private readonly config;
+    private readonly logger;
+    private readonly finderCache;
+    constructor(config: GatewayMemoryConfig, logger: Pick<BindingLoggerHost, "log">);
+    hasEntries(): boolean;
+    search(query: string, limit?: number): Promise<MemorySearchResult[]>;
+    get(path: string, startLine?: number, maxLines?: number): Promise<MemoryGetResult>;
+    private getFinder;
+}

package/dist/tools/memory-get.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import type { GatewayMemoryRuntime } from "../memory/runtime";
+export declare function createMemoryGetTool(runtime: GatewayMemoryRuntime): ToolDefinition;

package/dist/tools/memory-search.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import type { GatewayMemoryRuntime } from "../memory/runtime";
+export declare function createMemorySearchTool(runtime: GatewayMemoryRuntime): ToolDefinition;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gateway",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "description": "Gateway plugin for OpenCode",
   "license": "MIT",
   "type": "module",
@@ -52,6 +52,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@ff-labs/fff-node": "^0.4.2",
     "@opencode-ai/plugin": "~1.3.0",
     "@opencode-ai/sdk": "~1.3.0",
     "better-sqlite3": "^12.8.0",