opencode-gateway 0.1.0 → 0.2.0

package/README.md

@@ -48,6 +48,7 @@ opencode serve
 ```toml
 [gateway]
 state_db = "/home/you/.local/share/opencode-gateway/state.db"
+# log_level = "warn"
 
 [cron]
 enabled = true
@@ -60,6 +61,17 @@ bot_token_env = "TELEGRAM_BOT_TOKEN"
 poll_timeout_seconds = 25
 allowed_chats = []
 allowed_users = []
+
+[[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"]
 ```
 
 When Telegram is enabled, export the bot token through the configured
@@ -68,3 +80,17 @@ environment variable, for example:
 ```bash
 export TELEGRAM_BOT_TOKEN="..."
 ```
+
+Gateway plugin logs are off by default. Set `gateway.log_level` to `error`,
+`warn`, `info`, or `debug` to emit that level and anything above it.
+
+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
+- relative paths are resolved from `opencode-gateway.toml`
+- memory is injected only into gateway-managed sessions

package/dist/binding/gateway.d.ts

@@ -60,8 +60,9 @@ export type BindingOutboundMessage = {
 export type BindingTransportHost = {
     sendMessage(message: BindingOutboundMessage): Promise<BindingHostAck>;
 };
+export type BindingLogLevel = "debug" | "info" | "warn" | "error";
 export type BindingLoggerHost = {
-    log(level: string, message: string): void;
+    log(level: BindingLogLevel, message: string): void;
 };
 export type GatewayContract = {
     gatewayStatus(): GatewayStatusSnapshot;

package/dist/binding/index.d.ts

@@ -1,7 +1,7 @@
 import type { BindingCronJobSpec, BindingInboundMessage, BindingPreparedExecution, GatewayContract } from "./gateway";
 import type { BindingOpencodeExecutionInput, OpencodeExecutionDriver } from "./opencode";
 export type { BindingExecutionObservation, BindingProgressiveDirective } from "./execution";
-export type { BindingCronJobSpec, BindingDeliveryTarget, BindingHostAck, BindingInboundAttachment, BindingInboundMessage, BindingLoggerHost, BindingOutboundMessage, BindingPreparedExecution, BindingPromptPart, BindingRuntimeReport, BindingTransportHost, GatewayContract, GatewayStatusSnapshot, } from "./gateway";
+export type { BindingCronJobSpec, BindingDeliveryTarget, BindingHostAck, BindingInboundAttachment, BindingInboundMessage, BindingLoggerHost, BindingLogLevel, BindingOutboundMessage, BindingPreparedExecution, BindingPromptPart, BindingRuntimeReport, BindingTransportHost, GatewayContract, GatewayStatusSnapshot, } from "./gateway";
 export type { BindingOpencodeCommand, BindingOpencodeCommandPart, BindingOpencodeCommandResult, BindingOpencodeDriverStep, BindingOpencodeExecutionInput, BindingOpencodeMessage, BindingOpencodeMessagePart, BindingOpencodePrompt, OpencodeExecutionDriver, } from "./opencode";
 export type GatewayBindingModule = GatewayContract & {
     prepareInboundExecution: (message: BindingInboundMessage) => BindingPreparedExecution;

package/dist/cli/doctor.js

@@ -1,18 +1,20 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { GATEWAY_CONFIG_FILE, OPENCODE_CONFIG_FILE } from "../config/paths";
+import { GATEWAY_CONFIG_FILE, OPENCODE_CONFIG_FILE, resolveGatewayWorkspacePath } from "../config/paths";
 import { parseOpencodeConfig } from "./opencode-config";
 import { pathExists, resolveCliConfigDir } from "./paths";
 export async function runDoctor(options, env) {
     const configDir = resolveCliConfigDir(options, env);
     const opencodeConfigPath = join(configDir, OPENCODE_CONFIG_FILE);
     const gatewayConfigPath = join(configDir, GATEWAY_CONFIG_FILE);
+    const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
     const opencodeStatus = await inspectOpencodeConfig(opencodeConfigPath);
     const gatewayOverride = env.OPENCODE_GATEWAY_CONFIG?.trim() || null;
     console.log("doctor report");
     console.log(`  config dir: ${configDir}`);
     console.log(`  opencode config: ${await describePath(opencodeConfigPath)}`);
     console.log(`  gateway config: ${await describePath(gatewayConfigPath)}`);
+    console.log(`  gateway workspace: ${await describePath(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"}`);

package/dist/cli/init.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { defaultGatewayStateDbPath, GATEWAY_CONFIG_FILE, OPENCODE_CONFIG_FILE, } from "../config/paths";
+import { defaultGatewayStateDbPath, GATEWAY_CONFIG_FILE, OPENCODE_CONFIG_FILE, resolveGatewayWorkspacePath, } from "../config/paths";
 import { createDefaultOpencodeConfig, ensureGatewayPlugin, parseOpencodeConfig, stringifyOpencodeConfig, } from "./opencode-config";
 import { pathExists, resolveCliConfigDir } from "./paths";
 import { buildGatewayConfigTemplate } from "./templates";
@@ -8,7 +8,9 @@ export async function runInit(options, env) {
     const configDir = resolveCliConfigDir(options, env);
     const opencodeConfigPath = join(configDir, OPENCODE_CONFIG_FILE);
     const gatewayConfigPath = join(configDir, GATEWAY_CONFIG_FILE);
+    const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
     await mkdir(configDir, { recursive: true });
+    await mkdir(workspaceDirPath, { recursive: true });
     let opencodeStatus = "already present";
     if (!(await pathExists(opencodeConfigPath))) {
         await writeFile(opencodeConfigPath, stringifyOpencodeConfig(createDefaultOpencodeConfig(options.managed)));
@@ -32,4 +34,5 @@ export async function runInit(options, env) {
     console.log(`config dir: ${configDir}`);
     console.log(`opencode config: ${opencodeConfigPath} (${opencodeStatus})`);
     console.log(`gateway config: ${gatewayConfigPath} (${gatewayStatus})`);
+    console.log(`gateway workspace: ${workspaceDirPath} (ready)`);
 }

package/dist/cli/paths.js

@@ -1,5 +1,5 @@
-import { access } from "node:fs/promises";
 import { constants } from "node:fs";
+import { access } from "node:fs/promises";
 import { resolve } from "node:path";
 import { resolveManagedOpencodeConfigDir, resolveOpencodeConfigDir } from "../config/paths";
 export function resolveCliConfigDir(options, env) {

package/dist/cli/templates.js

@@ -5,6 +5,7 @@ export function buildGatewayConfigTemplate(stateDbPath) {
         "",
         "[gateway]",
         `state_db = "${escapeTomlString(stateDbPath)}"`,
+        '# log_level = "warn"',
         "",
         "[cron]",
         "enabled = true",
@@ -19,6 +20,20 @@ export function buildGatewayConfigTemplate(stateDbPath) {
         "allowed_chats = []",
         "allowed_users = []",
         "",
+        "# Optional long-lived memory sources injected into gateway-managed sessions.",
+        "# Relative paths are resolved from this config file.",
+        "#",
+        "# [[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"]',
+        "",
     ].join("\n");
 }
 function escapeTomlString(value) {

package/dist/cli.js

@@ -62,9 +62,10 @@ import { join as join2 } from "node:path";
 
 // src/config/paths.ts
 import { homedir } from "node:os";
-import { join, resolve as resolve2 } from "node:path";
+import { dirname, join, resolve as resolve2 } from "node:path";
 var GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
 var OPENCODE_CONFIG_FILE = "opencode.json";
+var GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
 function resolveOpencodeConfigDir(env) {
   const explicit = env.OPENCODE_CONFIG_DIR;
   if (explicit && explicit.trim().length > 0) {
@@ -75,6 +76,9 @@ function resolveOpencodeConfigDir(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");
 }
@@ -153,8 +157,8 @@ function formatError(error) {
 }
 
 // src/cli/paths.ts
-import { access } from "node:fs/promises";
 import { constants } from "node:fs";
+import { access } from "node:fs/promises";
 import { resolve as resolve3 } from "node:path";
 function resolveCliConfigDir(options, env) {
   if (options.configDir !== null) {
@@ -179,12 +183,14 @@ async function runDoctor(options, env) {
   const configDir = resolveCliConfigDir(options, env);
   const opencodeConfigPath = join2(configDir, OPENCODE_CONFIG_FILE);
   const gatewayConfigPath = join2(configDir, GATEWAY_CONFIG_FILE);
+  const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
   const opencodeStatus = await inspectOpencodeConfig(opencodeConfigPath);
   const gatewayOverride = env.OPENCODE_GATEWAY_CONFIG?.trim() || null;
   console.log("doctor report");
   console.log(`  config dir: ${configDir}`);
   console.log(`  opencode config: ${await describePath(opencodeConfigPath)}`);
   console.log(`  gateway config: ${await describePath(gatewayConfigPath)}`);
+  console.log(`  gateway workspace: ${await describePath(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"}`);
@@ -231,7 +237,7 @@ async function inspectOpencodeConfig(path) {
 
 // src/cli/init.ts
 import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import { dirname, join as join3 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 
 // src/cli/templates.ts
 function buildGatewayConfigTemplate(stateDbPath) {
@@ -241,6 +247,7 @@ function buildGatewayConfigTemplate(stateDbPath) {
     "",
     "[gateway]",
     `state_db = "${escapeTomlString(stateDbPath)}"`,
+    '# log_level = "warn"',
     "",
     "[cron]",
     "enabled = true",
@@ -254,6 +261,20 @@ function buildGatewayConfigTemplate(stateDbPath) {
     "poll_timeout_seconds = 25",
     "allowed_chats = []",
     "allowed_users = []",
+    "",
+    "# Optional long-lived memory sources injected into gateway-managed sessions.",
+    "# Relative paths are resolved from this config file.",
+    "#",
+    "# [[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"]',
     ""
   ].join(`
 `);
@@ -267,7 +288,9 @@ async function runInit(options, env) {
   const configDir = resolveCliConfigDir(options, env);
   const opencodeConfigPath = join3(configDir, OPENCODE_CONFIG_FILE);
   const gatewayConfigPath = join3(configDir, GATEWAY_CONFIG_FILE);
+  const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
   await mkdir(configDir, { recursive: true });
+  await mkdir(workspaceDirPath, { recursive: true });
   let opencodeStatus = "already present";
   if (!await pathExists(opencodeConfigPath)) {
     await writeFile(opencodeConfigPath, stringifyOpencodeConfig(createDefaultOpencodeConfig(options.managed)));
@@ -283,13 +306,14 @@ async function runInit(options, env) {
   }
   let gatewayStatus = "already present";
   if (!await pathExists(gatewayConfigPath)) {
-    await mkdir(dirname(gatewayConfigPath), { recursive: true });
+    await mkdir(dirname2(gatewayConfigPath), { recursive: true });
     await writeFile(gatewayConfigPath, buildGatewayConfigTemplate(defaultGatewayStateDbPath(env)));
     gatewayStatus = "created";
   }
   console.log(`config dir: ${configDir}`);
   console.log(`opencode config: ${opencodeConfigPath} (${opencodeStatus})`);
   console.log(`gateway config: ${gatewayConfigPath} (${gatewayStatus})`);
+  console.log(`gateway workspace: ${workspaceDirPath} (ready)`);
 }
 
 // src/cli.ts

package/dist/config/gateway.d.ts

@@ -1,4 +1,6 @@
+import { type GatewayLogLevel } from "../host/logger";
 import { type CronConfig } from "./cron";
+import { type GatewayMemoryConfig } from "./memory";
 import { type TelegramConfig } from "./telegram";
 export type GatewayMailboxRouteConfig = {
     channel: string;
@@ -15,9 +17,12 @@ export type GatewayConfig = {
     configPath: string;
     stateDbPath: string;
     mediaRootPath: string;
+    workspaceDirPath: string;
+    logLevel: GatewayLogLevel;
     hasLegacyGatewayTimezone: boolean;
     legacyGatewayTimezone: string | null;
     mailbox: GatewayMailboxConfig;
+    memory: GatewayMemoryConfig;
     cron: CronConfig;
     telegram: TelegramConfig;
 };

package/dist/config/gateway.js

@@ -1,7 +1,9 @@
 import { existsSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
+import { parseGatewayLogLevel } from "../host/logger";
 import { parseCronConfig } from "./cron";
-import { defaultGatewayStateDbPath, resolveGatewayConfigPath } from "./paths";
+import { parseMemoryConfig } from "./memory";
+import { defaultGatewayStateDbPath, resolveGatewayConfigPath, resolveGatewayWorkspacePath } from "./paths";
 import { parseTelegramConfig } from "./telegram";
 export async function loadGatewayConfig(env = process.env) {
     const configPath = resolveGatewayConfigPath(env);
@@ -15,9 +17,12 @@ export async function loadGatewayConfig(env = process.env) {
         configPath,
         stateDbPath,
         mediaRootPath: resolveMediaRootPath(stateDbPath),
+        workspaceDirPath: resolveGatewayWorkspacePath(configPath),
+        logLevel: parseGatewayLogLevel(rawConfig?.gateway?.log_level, "gateway.log_level"),
         hasLegacyGatewayTimezone: rawConfig?.gateway?.timezone !== undefined,
         legacyGatewayTimezone: readLegacyGatewayTimezone(rawConfig?.gateway?.timezone),
         mailbox: parseMailboxConfig(rawConfig?.gateway?.mailbox),
+        memory: await parseMemoryConfig(rawConfig?.memory, configPath),
         cron: parseCronConfig(rawConfig?.cron),
         telegram: parseTelegramConfig(rawConfig?.channels?.telegram, env),
     };

package/dist/config/memory.d.ts

@@ -0,0 +1,18 @@
+export type GatewayMemoryConfig = {
+    entries: GatewayMemoryEntryConfig[];
+};
+export type GatewayMemoryEntryConfig = {
+    kind: "file";
+    path: string;
+    displayPath: string;
+    description: string;
+    injectContent: boolean;
+} | {
+    kind: "directory";
+    path: string;
+    displayPath: string;
+    description: string;
+    injectMarkdownContents: boolean;
+    globs: string[];
+};
+export declare function parseMemoryConfig(value: unknown, configPath: string): Promise<GatewayMemoryConfig>;

package/dist/config/memory.js

@@ -0,0 +1,105 @@
+import { stat } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+export async function parseMemoryConfig(value, configPath) {
+    const table = readMemoryTable(value);
+    const entries = await readMemoryEntries(table.entries, configPath);
+    return { entries };
+}
+function readMemoryTable(value) {
+    if (value === undefined) {
+        return {};
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("memory must be a table when present");
+    }
+    return value;
+}
+async function readMemoryEntries(value, configPath) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("memory.entries must be an array when present");
+    }
+    return await Promise.all(value.map((entry, index) => readMemoryEntry(entry, index, configPath)));
+}
+async function readMemoryEntry(value, index, configPath) {
+    const field = `memory.entries[${index}]`;
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${field} must be a table`);
+    }
+    const entry = value;
+    const displayPath = readRequiredString(entry.path, `${field}.path`);
+    const description = readRequiredString(entry.description, `${field}.description`);
+    const resolvedPath = resolve(dirname(configPath), displayPath);
+    const metadata = await statPath(resolvedPath, `${field}.path`);
+    if (metadata.isFile()) {
+        ensureDirectoryOnlyFieldIsAbsent(entry.inject_markdown_contents, `${field}.inject_markdown_contents`);
+        ensureDirectoryOnlyFieldIsAbsent(entry.globs, `${field}.globs`);
+        return {
+            kind: "file",
+            path: resolvedPath,
+            displayPath,
+            description,
+            injectContent: readBoolean(entry.inject_content, `${field}.inject_content`, false),
+        };
+    }
+    if (metadata.isDirectory()) {
+        ensureFileOnlyFieldIsAbsent(entry.inject_content, `${field}.inject_content`);
+        return {
+            kind: "directory",
+            path: resolvedPath,
+            displayPath,
+            description,
+            injectMarkdownContents: readBoolean(entry.inject_markdown_contents, `${field}.inject_markdown_contents`, false),
+            globs: readGlobList(entry.globs, `${field}.globs`),
+        };
+    }
+    throw new Error(`${field}.path must point to a regular file or directory`);
+}
+async function statPath(path, field) {
+    try {
+        return await stat(path);
+    }
+    catch (error) {
+        throw new Error(`${field} does not exist: ${path}`, { cause: error });
+    }
+}
+function ensureDirectoryOnlyFieldIsAbsent(value, field) {
+    if (value !== undefined) {
+        throw new Error(`${field} is only valid for directory entries`);
+    }
+}
+function ensureFileOnlyFieldIsAbsent(value, field) {
+    if (value !== undefined) {
+        throw new Error(`${field} is only valid for file entries`);
+    }
+}
+function readBoolean(value, field, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (typeof value !== "boolean") {
+        throw new Error(`${field} must be a boolean when present`);
+    }
+    return value;
+}
+function readGlobList(value, field) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${field} must be an array when present`);
+    }
+    return value.map((entry, index) => readRequiredString(entry, `${field}[${index}]`));
+}
+function readRequiredString(value, field) {
+    if (typeof value !== "string") {
+        throw new Error(`${field} must be a string`);
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${field} must not be empty`);
+    }
+    return trimmed;
+}

package/dist/config/paths.d.ts

@@ -1,9 +1,11 @@
 export declare const GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
 export declare const OPENCODE_CONFIG_FILE = "opencode.json";
+export declare const GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
 type EnvSource = Record<string, string | undefined>;
 export declare function resolveGatewayConfigPath(env: EnvSource): string;
 export declare function resolveOpencodeConfigDir(env: EnvSource): string;
 export declare function resolveManagedOpencodeConfigDir(env: EnvSource): string;
+export declare function resolveGatewayWorkspacePath(configPath: string): string;
 export declare function defaultGatewayStateDbPath(env: EnvSource): string;
 export declare function resolveConfigHome(env: EnvSource): string;
 export declare function resolveDataHome(env: EnvSource): string;

package/dist/config/paths.js

@@ -1,7 +1,8 @@
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 export const GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
 export const OPENCODE_CONFIG_FILE = "opencode.json";
+export const GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
 export function resolveGatewayConfigPath(env) {
     const explicit = env.OPENCODE_GATEWAY_CONFIG;
     if (explicit && explicit.trim().length > 0) {
@@ -19,6 +20,9 @@ export function resolveOpencodeConfigDir(env) {
 export function resolveManagedOpencodeConfigDir(env) {
     return join(resolveConfigHome(env), "opencode-gateway", "opencode");
 }
+export function resolveGatewayWorkspacePath(configPath) {
+    return join(dirname(configPath), GATEWAY_WORKSPACE_DIR);
+}
 export function defaultGatewayStateDbPath(env) {
     return join(resolveDataHome(env), "opencode-gateway", "state.db");
 }

package/dist/cron/runtime.d.ts

@@ -1,7 +1,7 @@
-import type { BindingLoggerHost, BindingRuntimeReport, GatewayContract } from "../binding";
+import type { BindingDeliveryTarget, BindingLoggerHost, BindingRuntimeReport, GatewayContract } from "../binding";
 import type { CronConfig } from "../config/cron";
 import type { GatewayExecutorLike } from "../runtime/executor";
-import type { CronJobRecord, SqliteStore } from "../store/sqlite";
+import type { CronJobRecord, CronRunRecord, SqliteStore } from "../store/sqlite";
 export type UpsertCronJobInput = {
     id: string;
     schedule: string;
@@ -11,6 +11,21 @@ export type UpsertCronJobInput = {
     deliveryTarget: string | null;
     deliveryTopic: string | null;
 };
+export type ScheduleOnceInput = {
+    id: string;
+    prompt: string;
+    delaySeconds: number | null;
+    runAtMs: number | null;
+    deliveryChannel: string | null;
+    deliveryTarget: string | null;
+    deliveryTopic: string | null;
+};
+export type ScheduleJobState = "scheduled" | "running" | "succeeded" | "failed" | "abandoned" | "canceled";
+export type ScheduleJobStatus = {
+    job: CronJobRecord;
+    state: ScheduleJobState;
+    runs: CronRunRecord[];
+};
 export declare class GatewayCronRuntime {
     private readonly executor;
     private readonly contract;
@@ -18,22 +33,26 @@ export declare class GatewayCronRuntime {
     private readonly logger;
     private readonly config;
     private readonly effectiveTimeZone;
+    private readonly resolveConversationKeyForTarget;
     private readonly runningJobIds;
     private running;
-    constructor(executor: GatewayExecutorLike, contract: GatewayContract, store: SqliteStore, logger: BindingLoggerHost, config: CronConfig, effectiveTimeZone: string);
+    constructor(executor: GatewayExecutorLike, contract: GatewayContract, store: SqliteStore, logger: BindingLoggerHost, config: CronConfig, effectiveTimeZone: string, resolveConversationKeyForTarget: (target: BindingDeliveryTarget) => string);
     isEnabled(): boolean;
     isRunning(): boolean;
     runningJobs(): number;
     timeZone(): string;
     start(): void;
-    listJobs(): CronJobRecord[];
+    listJobs(includeTerminal?: boolean): CronJobRecord[];
+    getJobStatus(id: string, limit?: number): ScheduleJobStatus;
     upsertJob(input: UpsertCronJobInput): CronJobRecord;
-    removeJob(id: string): boolean;
+    scheduleOnce(input: ScheduleOnceInput): CronJobRecord;
+    cancelJob(id: string): boolean;
     runNow(id: string): Promise<BindingRuntimeReport>;
     private runLoop;
     reconcileOnce(nowMs?: number): Promise<void>;
     tickOnce(nowMs?: number): Promise<void>;
     private executeJob;
+    private appendScheduleResultToTarget;
     private requireJob;
     private rebaseJobs;
     private readStoredEffectiveTimeZone;