@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/store/postgres/tenant.js

@@ -4,7 +4,7 @@ import { TenantEnvelopeSchema, } from "@nylorun/core/contracts";
 import { openError, TenantOpenError } from "../../tenant/cause.js";
 import { database, driverError } from "./db.js";
 import { applyMigrations, assertCurrentLayout, isStatementError, lockMigrations, shippedMigrations, } from "./migrate.js";
-import { definitions, principals, sessions, signingKeys, TENANT_SCHEMA, tenant, vaultAudit, vaults, } from "./schema.js";
+import { principals, sessions, signingKeys, TENANT_SCHEMA, tenant, vaultAudit, vaults, } from "./schema.js";
 import { createPostgresSessionStore } from "./store.js";
 /** The migration that deletes the vault's `oauth` credentials, each with an audit row. */
 const OAUTH_REMOVED_MIGRATION = "0016_mcp_oauth_removed";
@@ -114,7 +114,6 @@ async function ensureTenant(tx, create, migrated, now) {
         const [data] = await tx.execute(sql `
       SELECT EXISTS (SELECT 1 FROM ${principals})
         OR EXISTS (SELECT 1 FROM ${sessions})
-        OR EXISTS (SELECT 1 FROM ${definitions})
         OR EXISTS (SELECT 1 FROM ${vaults})
         OR EXISTS (SELECT 1 FROM ${signingKeys}) AS held`);
         if (data?.held)

package/dist/store/types.d.ts

@@ -63,11 +63,11 @@
 import type { KeyRole } from "@nylorun/core/compatibility";
 import type { RecordReader } from "../streams/relay/types.js";
 import type { SandboxSignal, Wake } from "../execution/types.js";
-import type { EventPayload, EventType, EventWriter, LiveEvent, EnvironmentEvent, EnvironmentEventPayload, EnvironmentEventType, EnvironmentKind, EnvironmentManifest, EnvironmentRecipe, PodDesired, PodObserved, SessionEventOf } from "@nylorun/core/contracts";
+import type { EventPayload, EventType, EventWriter, LiveEvent, AgentEvent, AgentEventPayload, AgentEventType, AgentManifestV8, EnvironmentKind, EnvironmentRecipe, PodDesired, PodObserved, SessionEventOf } from "@nylorun/core/contracts";
 import type { HostEffect } from "@nylorun/harness/run";
-import type { ArtifactRow, ArtifactVersionRow, DefinitionFileRow, ModelBudgetRow, ModelUsageRow, ModelUsageWrite, PrincipalRow, ToolCrossingRow, SigningKeyRow, VaultAuditRow, VaultCredentialRow, VaultIdempotencyRow, VaultRow } from "./postgres/schema.js";
+import type { ArtifactRow, ArtifactVersionRow, DefinitionFileRow, ModelBudgetRow, ModelUsageRow, ModelUsageWrite, PrincipalRow, ToolCrossingRow, QueuedMessageRow, AgentTriggerRow, TriggerRunRow, MemoryRow, MemoryVersionRow, SigningKeyRow, VaultAuditRow, VaultCredentialRow, VaultIdempotencyRow, VaultRow } from "./postgres/schema.js";
 /** Tables holding JSON documents keyed by `id`. */
-export type DocTable = "definitions" | "sessions" | "commands" | "effects" | "sandboxes" | "links";
+export type DocTable = "sessions" | "commands" | "effects" | "sandboxes" | "links";
 export declare const DOC_TABLES: readonly DocTable[];
 /** Session lifecycle (architecture §10.2). */
 export type SessionStatus = "idle" | "runnable" | "running" | "waiting" | "paused" | "uncertain" | "completed" | "failed" | "cancelled";
@@ -117,17 +117,15 @@ export interface LinkDoc {
     effectId: string;
     turnId: string;
 }
-/** A definition document. Indexed: `manifest.id`. */
-export interface DefinitionDoc {
-    manifest: {
-        id: string;
-    };
-}
 /** A sandbox record, keyed by sandbox key. */
 export interface SandboxDoc {
     key: string;
 }
-/** An Environment (`environments`, D55): what `PUT /v1/environments/{id}` created. */
+/**
+ * An Agent's row (`agents`; an Environment's before protocol 16): what `PUT /v1/agents/{id}`
+ * created. The Runtime's own code calls the part it runs on (its kind, recipe, pod, disk and
+ * vault) the Agent's environment, keyed by the Agent's id.
+ */
 export interface Environment {
     id: string;
     kind: EnvironmentKind;
@@ -138,7 +136,7 @@ export interface Environment {
     applied: EnvironmentRecipe;
     version: number;
     appliedVersion: number;
-    /** The owner guard: only this owner's sessions may name it. */
+    /** The owner guard (`owner` on the API): only this owner's sessions may run on it. */
     ownerUserId?: string;
     /** ISO time it was last used (`lifecycle.deleteAfter` counts from it). */
     lastUsedAt: string;
@@ -153,16 +151,39 @@ export interface Environment {
      * Q17): the setup runs once the version is written (`written`), and the seed stays until it is done.
      */
     diskSeed?: DiskSeed;
-    /** The environment manifest it was made from and its version (D63); absent for an inline one. */
-    manifestName?: string;
-    manifestVersion?: number;
-    /** The hash of what it runs (`recipe`), recorded at creation (protocol 14). */
-    manifestHash?: string;
-    /** The Environment it was forked from and the disk version it started from (Q15). */
+    /** The agent manifest it was made from and the version it resolved then, which it runs. */
+    manifestName: string;
+    manifestVersion: number;
+    /** How it names the manifest: `tracking` (`name`) or `pinned` (`name@n`). */
+    manifestRef: "tracking" | "pinned";
+    /** The hash of that manifest version. */
+    manifestHash: string;
+    /** `on`, or `off` once paused (track T6). */
+    desiredState: "on" | "off";
+    /** The Agent it was forked from and the disk version it started from (Q15). */
     forkedFrom?: {
-        environment: string;
+        agent: string;
         disk: number | null;
     };
+    /**
+     * The manifest version it moves to while it is outdated (track T3, D73): it waits for its
+     * required secrets or its pod's next start. Absent when it runs the version it should.
+     */
+    targetVersion?: number;
+    /** A version that failed to start (T3): a tracking Agent does not move to it again on its own. */
+    failedVersion?: number;
+    /** While a pod starts on a new version (T3): what it ran before, which a failed start reverts to. */
+    startCheck?: AgentStartCheck;
+}
+/** What a pod Agent ran before it started on a new version (track T3), and since when it starts. */
+export interface AgentStartCheck {
+    from: {
+        manifestVersion: number;
+        manifestHash: string;
+        applied: EnvironmentRecipe;
+        imageDigest?: string;
+    };
+    startedAt: string;
 }
 /** A pending seed of an Environment's disk (`disk_seed`). */
 export interface DiskSeed {
@@ -173,11 +194,11 @@ export interface DiskSeed {
     /** The version is written; with `setup`, the seed waits for the setup to be done. */
     written?: true;
 }
-/** One version of an environment manifest (`environment_manifests`, D63). */
-export interface EnvironmentManifestRow {
+/** One version of an agent manifest (`agent_manifests`, protocol 16). */
+export interface AgentManifestRow {
     name: string;
     version: number;
-    body: EnvironmentManifest;
+    body: AgentManifestV8;
     hash: string;
     savedBy: {
         actor: string;
@@ -260,11 +281,11 @@ export type CommitListener = (commit: Commit) => void;
  * `bytea` columns, never inside a JSON body), the vault's audit and idempotency records, the
  * Tenant's signing keys, a model call in the usage ledger and a model budget.
  */
-export type { ArtifactRow, ArtifactVersionRow, DefinitionFileRow, ModelBudgetRow, ModelUsageRow, ModelUsageWrite, ToolCrossingRow, PrincipalRow, SigningKeyRow, VaultAuditRow, VaultCredentialRow, VaultIdempotencyRow, VaultRow, };
+export type { ArtifactRow, ArtifactVersionRow, DefinitionFileRow, ModelBudgetRow, ModelUsageRow, ModelUsageWrite, ToolCrossingRow, QueuedMessageRow, AgentTriggerRow, TriggerRunRow, MemoryRow, MemoryVersionRow, PrincipalRow, SigningKeyRow, VaultAuditRow, VaultCredentialRow, VaultIdempotencyRow, VaultRow, };
 /** Which rows of the usage ledger a total covers. */
 export interface ModelUsageQuery {
-    scope: "tenant" | "agent" | "turn";
-    /** The agent or turn id; ignored for `tenant`. */
+    scope: "tenant" | "manifest" | "turn";
+    /** The agent manifest's name or the turn id; ignored for `tenant`. */
     id?: string;
     /** Only rows created at or after this ISO time. */
     since?: string;
@@ -289,9 +310,9 @@ export interface StoreCounts {
     /** Effects `uncertain`. */
     uncertainEffects: number;
     sandboxes: number;
-    definitions: number;
+    agentManifests: number;
 }
-export type ResetScope = "sessions" | "environments" | "all";
+export type ResetScope = "sessions" | "agents" | "all";
 /** Result of `takeOwnership`. */
 export type TakeOwnership = {
     status: "owned";
@@ -408,7 +429,7 @@ export type ControlSignal = {
     epoch: number;
 };
 export interface FollowSignalsOptions {
-    /** How often recent signals are read back. Default 5 s. */
+    /** How often recent signals are read back. Default `postgres.controlPollMs` (Host tuning, 5 s). */
     pollMs?: number;
     onError?: (error: unknown) => void;
 }
@@ -541,9 +562,8 @@ export interface Tx {
         agentId?: string;
         ownerUserId?: string;
     }): Promise<StoredSession<T>[]>;
-    listDefinitions<T extends DefinitionDoc = DefinitionDoc>(): Promise<T[]>;
     listSandboxes<T extends SandboxDoc = SandboxDoc>(): Promise<T[]>;
-    /** Environment `id`; with `lock`, its row is locked until the transaction ends. */
+    /** Agent `id`'s row; with `lock`, it is locked until the transaction ends. */
     environment(id: string, options?: {
         lock?: boolean;
     }): Promise<Environment | undefined>;
@@ -554,8 +574,8 @@ export interface Tx {
     createEnvironment(row: Environment, limit: number): Promise<"created" | "exists" | "limit">;
     /**
      * Changes an Environment's columns other than its pod's (the caller holds the row's lock):
-     * labels, recipe and version, the applied recipe and its version, the owner guard (`null`
-     * clears it), and when it was last used.
+     * labels, recipe and version, the applied recipe and its version, the manifest version it runs
+     * and how it names it (track T3), the owner guard (`null` clears it), and when it was last used.
      */
     updateEnvironment(id: string, patch: {
         labels?: Record<string, string>;
@@ -563,6 +583,12 @@ export interface Tx {
         version?: number;
         applied?: EnvironmentRecipe;
         appliedVersion?: number;
+        manifestVersion?: number;
+        manifestHash?: string;
+        manifestRef?: "tracking" | "pinned";
+        targetVersion?: number | null;
+        failedVersion?: number | null;
+        startCheck?: AgentStartCheck | null;
         ownerUserId?: string | null;
         lastUsedAt?: string;
         diskOp?: DiskOperation | null;
@@ -576,32 +602,32 @@ export interface Tx {
     listEnvironments(filter?: {
         labels?: Record<string, string>;
     }): Promise<Environment[]>;
-    /** Sessions that name Environment `environmentId` (`Session.environmentId`), by id. */
+    /** Sessions on Agent `environmentId` (`Session.environmentId`), by id. */
     sessionsOnEnvironment<T extends SessionDoc = SessionDoc>(environmentId: string): Promise<StoredSession<T>[]>;
     /**
-     * Appends an event to the Environment's lifecycle stream through the record module. The
-     * caller holds the Environment row's lock (or created the row in this transaction).
+     * Appends an event to the Agent's lifecycle stream through the record module. The caller holds
+     * the Agent row's lock (or created the row in this transaction).
      */
-    environmentEvent<T extends EnvironmentEventType>(environmentId: string, type: T, payload: EnvironmentEventPayload<T>): Promise<EnvironmentEvent>;
+    agentEvent<T extends AgentEventType>(agentId: string, type: T, payload: AgentEventPayload<T>): Promise<AgentEvent>;
     /**
-     * The Environment's stream, from `fromSeq` on, at most `limit` events: only `types` when given,
-     * and only events recorded at or after `since` and before `until` (ISO times) when given.
+     * The Agent's stream, from `fromSeq` on, at most `limit` events: only `types` when given, and
+     * only events recorded at or after `since` and before `until` (ISO times) when given.
      */
-    environmentEvents(environmentId: string, options?: EnvironmentEventsQuery): Promise<EnvironmentEvent[]>;
+    agentEvents(agentId: string, options?: AgentEventsQuery): Promise<AgentEvent[]>;
     /** Holds manifest `name`'s save lock until the transaction ends, so saves of one name are serial. */
-    lockEnvironmentManifest(name: string): Promise<void>;
+    lockAgentManifest(name: string): Promise<void>;
     /** Version `version` of manifest `name`, or its latest when `version` is omitted. */
-    environmentManifest(name: string, version?: number): Promise<EnvironmentManifestRow | undefined>;
+    agentManifest(name: string, version?: number): Promise<AgentManifestRow | undefined>;
     /** Writes a new version (the caller holds the name's lock and chose the next number). */
-    insertEnvironmentManifest(row: EnvironmentManifestRow): Promise<void>;
+    insertAgentManifest(row: AgentManifestRow): Promise<void>;
     /** Each manifest's latest version, by name. */
-    listEnvironmentManifests(): Promise<EnvironmentManifestRow[]>;
+    listAgentManifests(): Promise<AgentManifestRow[]>;
     /** Every version of manifest `name`, newest first. */
-    environmentManifestVersions(name: string): Promise<EnvironmentManifestRow[]>;
+    agentManifestVersions(name: string): Promise<AgentManifestRow[]>;
     /** Deletes every version of manifest `name`; how many there were. */
-    deleteEnvironmentManifest(name: string): Promise<number>;
-    /** How many Environments were made from each version of manifest `name` (deleting ones too). */
-    environmentsOfManifest(name: string): Promise<Map<number, number>>;
+    deleteAgentManifest(name: string): Promise<number>;
+    /** How many Agents were made from each version of manifest `name` (deleting ones too). */
+    agentsOfManifest(name: string): Promise<Map<number, number>>;
     /** `invoking` effects of one session; takeover turns them `uncertain`. */
     invokingEffects<T extends EffectDoc = EffectDoc>(sessionId: string): Promise<T[]>;
     effectsForSession<T extends EffectDoc = EffectDoc>(sessionId: string, filter?: SessionEffectFilter): Promise<T[]>;
@@ -609,6 +635,86 @@ export interface Tx {
     effectsWithStatus<T extends EffectDoc = EffectDoc>(statuses: readonly (EffectStatus | (string & {}))[], filter?: {
         kinds?: readonly EffectKind[];
     }): Promise<T[]>;
+    /** Adds a message at the end of its session's queue; returns its position in the queue's order. */
+    enqueueMessage(row: Omit<QueuedMessageRow, "seq">): Promise<number>;
+    /** A session's queued messages, first to go first. */
+    queuedMessages(sessionId: string): Promise<QueuedMessageRow[]>;
+    countQueuedMessages(sessionId: string): Promise<number>;
+    /** Removes queued messages a turn took. */
+    deleteQueuedMessages(ids: readonly string[]): Promise<void>;
+    agentTriggers(agentId: string): Promise<AgentTriggerRow[]>;
+    /** One trigger's state; with `lock`, its row is locked until the transaction ends. */
+    agentTrigger(agentId: string, triggerId: string, options?: {
+        lock?: boolean;
+    }): Promise<AgentTriggerRow | undefined>;
+    /** Inserts or replaces a trigger's state (its `createdAt` is kept). */
+    putAgentTrigger(row: AgentTriggerRow): Promise<void>;
+    deleteAgentTrigger(agentId: string, triggerId: string): Promise<void>;
+    /** Deletes an Agent's triggers and runs. */
+    deleteAgentTriggers(agentId: string): Promise<void>;
+    /**
+     * Active triggers with a next fire time (due by `dueBefore`, changed since `changedSince`, when
+     * given), by Agent and trigger id.
+     */
+    activeTriggers(options: {
+        dueBefore?: string;
+        changedSince?: string;
+        after?: {
+            agentId: string;
+            triggerId: string;
+        };
+        limit: number;
+    }): Promise<AgentTriggerRow[]>;
+    /** The webhook trigger whose endpoint id is `endpointId`. */
+    agentTriggerByEndpoint(endpointId: string): Promise<AgentTriggerRow | undefined>;
+    /** The earliest next fire time of an Agent's active triggers, or `null`. */
+    nextWakeAt(agentId: string): Promise<string | null>;
+    /** Records a run; false when one with the same `runKey` exists for the Agent. */
+    insertTriggerRun(row: TriggerRunRow): Promise<boolean>;
+    triggerRunByKey(agentId: string, runKey: string): Promise<TriggerRunRow | undefined>;
+    updateTriggerRun(id: string, patch: Partial<Omit<TriggerRunRow, "id">>): Promise<void>;
+    /** An Agent's runs fired at or after `since` with one of `statuses`. */
+    countTriggerRuns(agentId: string, since: string, statuses: readonly TriggerRunRow["status"][]): Promise<number>;
+    /** An Agent's runs, newest first, before run id `before`. */
+    listTriggerRuns(agentId: string, options: {
+        triggerId?: string;
+        before?: string;
+        limit: number;
+    }): Promise<TriggerRunRow[]>;
+    /** Deletes runs fired before `before`; returns how many. */
+    pruneTriggerRuns(before: string): Promise<number>;
+    /** One memory; with `lock`, its path is locked until the transaction ends, whether or not a row has it. */
+    memory(agentId: string, path: string, options?: {
+        lock?: boolean;
+    }): Promise<MemoryRow | undefined>;
+    /**
+     * An Agent's memories by path: those inside `folder` (a normalised folder path, `/memories` for
+     * all), after path `after`; with `lock`, their rows are locked until the transaction ends.
+     */
+    memories(agentId: string, options: {
+        folder?: string;
+        after?: string;
+        limit?: number;
+        lock?: boolean;
+    }): Promise<MemoryRow[]>;
+    countMemories(agentId: string): Promise<number>;
+    /** An Agent's newest memories first (by `updatedAt`, then path): what the pinned index lists. */
+    recentMemories(agentId: string, limit: number): Promise<Pick<MemoryRow, "path" | "description" | "bytes">[]>;
+    /** Inserts or replaces a memory. */
+    putMemory(row: MemoryRow): Promise<void>;
+    deleteMemory(agentId: string, path: string): Promise<void>;
+    insertMemoryVersion(row: MemoryVersionRow): Promise<void>;
+    /** An Agent's memory versions, newest first, before version id `before`; `path` keeps one path's. */
+    memoryVersions(agentId: string, options: {
+        path?: string;
+        before?: string;
+        limit: number;
+    }): Promise<MemoryVersionRow[]>;
+    memoryVersion(agentId: string, id: string): Promise<MemoryVersionRow | undefined>;
+    /** Copies Agent `from`'s memories to new Agent `to`, each at version 1, with no history (a fork). */
+    copyMemories(from: string, to: string, now: string): Promise<number>;
+    /** Deletes an Agent's memories and their versions. */
+    deleteAgentMemories(agentId: string): Promise<void>;
     /** Links of one workflow session joined to their existing agent sessions, ordered by agent session id. */
     linkedSessions<S extends SessionDoc = SessionDoc>(workflowSessionId: string): Promise<LinkedSession<S>[]>;
     counts(): Promise<StoreCounts>;
@@ -732,6 +838,8 @@ export interface Tx {
     /** One version, or every version oldest first. */
     artifactVersion(artifactId: string, version: number): Promise<ArtifactVersionRow | undefined>;
     artifactVersions(artifactId: string): Promise<ArtifactVersionRow[]>;
+    /** The version a harness write with this key stored (`artifact_versions.write_key`), if any. */
+    artifactVersionByWriteKey(writeKey: string): Promise<ArtifactVersionRow | undefined>;
     /** Deletes the artifact and its versions; returns the versions' blob keys (empty when none). */
     deleteArtifact(id: string): Promise<string[]>;
     /**
@@ -746,9 +854,12 @@ export interface Tx {
     lockArtifactQuota(): Promise<void>;
     /**
      * The bytes the artifacts store: every file version, plus each distinct content-addressed file
-     * of the folders once (F8.2).
+     * of the folders once (F8.2). With `environmentId`, only that Environment's artifacts: its disk
+     * versions and its sessions' artifacts.
      */
-    artifactBytes(): Promise<number>;
+    artifactBytes(scope?: {
+        environmentId: string;
+    }): Promise<number>;
     /**
      * The blob keys of every artifact version (a folder's: its manifests): of session artifacts
      * only, or of all of them.
@@ -759,8 +870,13 @@ export interface Tx {
         sha256: string;
         size: number;
     }[]): Promise<void>;
-    /** Those of `shas` some committed folder version references. */
-    referencedArtifactContent(shas: readonly string[]): Promise<Set<string>>;
+    /**
+     * Those of `shas` some committed folder version references; with `environmentId`, a version
+     * of one of that Environment's artifacts.
+     */
+    referencedArtifactContent(shas: readonly string[], scope?: {
+        environmentId: string;
+    }): Promise<Set<string>>;
     /**
      * The distinct content-addressed files folder versions reference: of one artifact, of session
      * artifacts only, or of all of them.
@@ -772,8 +888,8 @@ export interface Tx {
     definitionFile(sha256: string): Promise<DefinitionFileRow | undefined>;
     /** Records a stored definition file; false when the Tenant held it already. */
     insertDefinitionFile(row: DefinitionFileRow): Promise<boolean>;
-    /** Those of `shas` the Tenant holds. */
-    heldDefinitionFiles(shas: readonly string[]): Promise<Set<string>>;
+    /** Those of `shas` the Tenant holds, with each one's size in bytes. */
+    heldDefinitionFiles(shas: readonly string[]): Promise<Map<string, number>>;
     /** Records that version `manifestHash` of definition `agentId` names each of `shas`. */
     insertDefinitionFileUses(agentId: string, manifestHash: string, shas: readonly string[]): Promise<void>;
     getSetting(key: string): Promise<string | undefined>;
@@ -784,16 +900,15 @@ export interface Tx {
      *   Tenant's record rows and log heads. The Tenant moves to the next basin
      *   generation and the current one is retired, so session ids it frees start again in an
      *   empty basin;
-     * - `environments`: sandbox records, Environments with their vaults, and their lifecycle
-     *   streams;
-     * - `all`: both, plus definitions (and which definition files they use),
+     * - `agents`: sandbox records, Agents with their vaults, and their lifecycle streams;
+     * - `all`: both, plus agent manifests (and which definition files they use),
      *   the model usage ledger, the model budgets and Tenant-wide artifacts. The host vault, principals, signing keys,
      *   settings, audit and vault idempotency rows stay.
      */
     reset(scope: ResetScope): Promise<void>;
 }
-/** Which of an Environment's events to read (`Tx.environmentEvents`). */
-export interface EnvironmentEventsQuery {
+/** Which of an Agent's events to read (`Tx.agentEvents`). */
+export interface AgentEventsQuery {
     readonly fromSeq?: number;
     readonly limit?: number;
     readonly types?: readonly string[];

package/dist/store/types.js

@@ -1,5 +1,4 @@
 export const DOC_TABLES = [
-    "definitions",
     "sessions",
     "commands",
     "effects",

package/dist/streams/relay/core.d.ts

@@ -6,11 +6,11 @@ export interface StreamRelayOptions {
     streams: DurableStreams;
     /** Relay events: lag, errors, reconciliations. */
     log?: (message: string, fields?: Record<string, unknown>) => void;
-    /** Records per append (S2 allows 1000). */
+    /** Records per append (S2 allows 1000). Default `streams.relayBatchRecords` (Host tuning, 500). */
     maxBatchRecords?: number;
-    /** Bytes per append (S2 allows 1 MiB). */
+    /** Bytes per append (S2 allows 1 MiB). Default `streams.relayBatchBytes` (768 KiB). */
     maxBatchBytes?: number;
-    /** Sessions reconciled at once. */
+    /** Sessions reconciled at once. Default `streams.relayReconcileConcurrency` (8). */
     reconcileConcurrency?: number;
 }
 export interface StreamRelayStatus {

package/dist/streams/relay/core.js

@@ -23,17 +23,16 @@
  * The relay never writes the record and never deletes from S2.
  */
 import { sleep } from "../../retry.js";
+import { hostTuning } from "../../tuning.js";
 import { basinOf } from "../basin.js";
 import { sessionStream } from "../types.js";
-const RETRY_MIN_MS = 50;
-const RETRY_MAX_MS = 2000;
-const HEADS_PAGE = 500;
 export function createStreamRelay(options) {
     const { source, record, streams } = options;
     const log = options.log ?? (() => { });
-    const maxRecords = options.maxBatchRecords ?? 500;
-    const maxBytes = options.maxBatchBytes ?? 768 * 1024;
-    const concurrency = options.reconcileConcurrency ?? 8;
+    const tuning = hostTuning().streams;
+    const maxRecords = options.maxBatchRecords ?? tuning.relayBatchRecords;
+    const maxBytes = options.maxBatchBytes ?? tuning.relayBatchBytes;
+    const concurrency = options.reconcileConcurrency ?? tuning.relayReconcileConcurrency;
     /** Committed transactions not yet fully in S2, in commit order. */
     const txs = [];
     const sessions = new Map();
@@ -101,7 +100,7 @@ export function createStreamRelay(options) {
     }
     async function pump(queue) {
         queue.running = true;
-        let delay = RETRY_MIN_MS;
+        let delay = tuning.relayRetry.minMs;
         try {
             while (queue.rows.length > 0 && !stopped) {
                 // Duplicates (a replay overlapping a refill) and stale rows sort out here.
@@ -122,7 +121,7 @@ export function createStreamRelay(options) {
                         // S2 is behind the record: re-send the gap first.
                         await refill(queue, first.generation, result.tail, first.seq);
                     }
-                    delay = RETRY_MIN_MS;
+                    delay = tuning.relayRetry.minMs;
                     lastError = null;
                 }
                 catch (error) {
@@ -143,7 +142,7 @@ export function createStreamRelay(options) {
                     // The basin may be missing (S2 lost it, or it was never created).
                     await streams.ensureTenant(basin).catch(() => undefined);
                     await sleep(delay, stopping.signal);
-                    delay = Math.min(delay * 2, RETRY_MAX_MS);
+                    delay = Math.min(delay * 2, tuning.relayRetry.maxMs);
                 }
             }
         }
@@ -243,7 +242,7 @@ export function createStreamRelay(options) {
         for (;;) {
             if (!current())
                 return false;
-            const page = await record.heads(after, HEADS_PAGE);
+            const page = await record.heads(after, tuning.relayHeadsPage);
             if (page.length === 0)
                 break;
             let next = 0;