@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/store/postgres/store.js

@@ -51,22 +51,23 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { and, count, desc, eq, getTableColumns, gte, gt, inArray, isNotNull, isNull, lt, lte, ne, or, sql, } from "drizzle-orm";
-import { appendEnvironmentEvent, appendEvent } from "../../record/index.js";
+import { appendAgentEvent, appendEvent } from "../../record/index.js";
+import { readRuntimeLimits } from "../../tenant/runtime-limits.js";
 import { OwnershipLostError, PrincipalRoleConflict } from "../ownership.js";
 import { followControlSignals, pruneSignals, writeSignal } from "./control.js";
 import { database, driverError } from "./db.js";
 import { expectedSchemaVersion, readSchemaVersion } from "./migrate.js";
+import { hostTuning } from "../../tuning.js";
 import { createPostgresRecordReader } from "./record.js";
-import { postgresEnvironmentRecordWriter, postgresRecordWriter } from "./record-writer.js";
-import { artifacts, artifactVersions, artifactContent, definitionFiles, definitionFileUses, commands, definitions, effects, links, modelBudgets, modelUsage, principals, sandboxes, environmentEvents, environments, environmentManifests, sessionEvents, sessionLogHeads, sessions, toJson, toolCrossings, signingKeys, tenant, tenantSettings, vaultAudit, vaultCredentials, vaultIdempotency, vaults, sandboxSignals, wakes, } from "./schema.js";
+import { postgresAgentRecordWriter, postgresRecordWriter } from "./record-writer.js";
+import { artifacts, artifactVersions, artifactContent, definitionFiles, definitionFileUses, commands, effects, links, modelBudgets, modelUsage, principals, sandboxes, agentEvents, agents, agentManifests, sessionEvents, sessionLogHeads, sessions, sessionQueue, agentTriggers, triggerRuns, memories, memoryVersions, toJson, toolCrossings, signingKeys, tenant, tenantSettings, vaultAudit, vaultCredentials, vaultIdempotency, vaults, sandboxSignals, wakes, } from "./schema.js";
 export function createPostgresSessionStore(options) {
     return new PostgresSessionStore(options);
 }
 const OPEN_SESSION = ["running", "runnable"];
-/** Rows per statement when a folder version names many files. */
-const CONTENT_BATCH = 1000;
+/** Rows per statement when a folder version or a definition names many files (Host tuning). */
+const contentBatch = () => hostTuning().postgres.contentBatchRows;
 const DOCUMENTS = {
-    definitions,
     sessions: sessions,
     commands,
     effects: effects,
@@ -255,10 +256,15 @@ function environmentOf(row) {
         updatedAt: row.updatedAt,
         ...(row.diskOp ? { diskOp: row.diskOp } : {}),
         ...(row.diskSeed ? { diskSeed: row.diskSeed } : {}),
-        ...(row.manifestName !== null ? { manifestName: row.manifestName } : {}),
-        ...(row.manifestVersion !== null ? { manifestVersion: row.manifestVersion } : {}),
-        ...(row.manifestHash !== null ? { manifestHash: row.manifestHash } : {}),
+        manifestName: row.manifestName,
+        manifestVersion: row.manifestVersion,
+        manifestRef: row.manifestRef,
+        manifestHash: row.manifestHash,
+        desiredState: row.desiredState,
         ...(row.forkedFrom ? { forkedFrom: row.forkedFrom } : {}),
+        ...(row.targetVersion !== null ? { targetVersion: row.targetVersion } : {}),
+        ...(row.failedVersion !== null ? { failedVersion: row.failedVersion } : {}),
+        ...(row.startCheck ? { startCheck: row.startCheck } : {}),
         ...(row.k8sName !== null && row.desired !== null && row.observed !== null
             ? {
                 pod: {
@@ -281,7 +287,7 @@ function environmentOf(row) {
             : {}),
     };
 }
-function environmentManifestOf(row) {
+function agentManifestOf(row) {
     return {
         name: row.name,
         version: row.version,
@@ -320,7 +326,7 @@ const SIGNING_KEY_STAMP = {
 };
 /** The audit columns a row has (`ord` only orders them). */
 const { ord: _ord, ...AUDIT } = getTableColumns(vaultAudit);
-const SESSION_TABLES = [sessions, commands, effects, links, wakes];
+const SESSION_TABLES = [sessions, commands, effects, links, wakes, sessionQueue];
 /**
  * The outbox's tables, by the kind of request each holds. Their delivery columns (`id`,
  * `created_at`, `attempts`, `retry_at`, `parked_at`) are the same.
@@ -430,6 +436,7 @@ class PostgresTx {
             type,
             payload,
             ...(writer ? { writer } : {}),
+            maxEntryBytes: await this.maxEntryBytes(),
         });
         this.events.push(event);
         this.generations.push(generation);
@@ -626,44 +633,40 @@ class PostgresTx {
         const rows = await this.db.select({ body: table.body }).from(table).orderBy(table.id);
         return rows.map((row) => row.body);
     }
-    async listDefinitions() {
-        this.check();
-        return this.bodies(definitions);
-    }
     async listSandboxes() {
         this.check();
         return this.bodies(sandboxes);
     }
-    // --- Environments ----------------------------------------------------------
+    // --- Agents ----------------------------------------------------------------
     async environment(id, options = {}) {
         this.check();
-        const query = this.db.select().from(environments).where(eq(environments.id, id));
+        const query = this.db.select().from(agents).where(eq(agents.id, id));
         const [row] = options.lock ? await query.for("update") : await query;
         return row && environmentOf(row);
     }
     async createEnvironment(row, limit) {
         this.check();
         // Every create takes this lock, so two never both see room for one more.
-        await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext('nylorun.environments'))`);
+        await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext('nylorun.agents'))`);
         const [found] = await this.db
-            .select({ id: environments.id })
-            .from(environments)
-            .where(eq(environments.id, row.id));
+            .select({ id: agents.id })
+            .from(agents)
+            .where(eq(agents.id, row.id));
         if (found)
             return "exists";
-        const [counted] = await this.db.select({ n: count() }).from(environments);
+        const [counted] = await this.db.select({ n: count() }).from(agents);
         if ((counted?.n ?? 0) >= limit)
             return "limit";
-        const { pod, ownerUserId, diskOp, diskSeed, manifestName, manifestVersion, manifestHash, forkedFrom, ...environment } = row;
-        await this.db.insert(environments).values({
+        const { pod, ownerUserId, diskOp, diskSeed, forkedFrom, targetVersion, failedVersion, startCheck, ...environment } = row;
+        await this.db.insert(agents).values({
             ...environment,
             ownerUserId: ownerUserId ?? null,
             diskOp: diskOp ?? null,
             diskSeed: diskSeed ?? null,
-            manifestName: manifestName ?? null,
-            manifestVersion: manifestVersion ?? null,
-            manifestHash: manifestHash ?? null,
             forkedFrom: forkedFrom ?? null,
+            targetVersion: targetVersion ?? null,
+            failedVersion: failedVersion ?? null,
+            startCheck: startCheck ?? null,
             ...(pod ? podColumns(pod) : {}),
         });
         return "created";
@@ -672,88 +675,88 @@ class PostgresTx {
         this.check();
         const columns = Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined));
         await this.db
-            .update(environments)
+            .update(agents)
             .set({ ...columns, updatedAt })
-            .where(eq(environments.id, id));
+            .where(eq(agents.id, id));
     }
     async updateEnvironmentPod(id, patch, updatedAt) {
         this.check();
         await this.db
-            .update(environments)
+            .update(agents)
             .set({ ...podColumns(patch), updatedAt })
-            .where(eq(environments.id, id));
+            .where(eq(agents.id, id));
     }
     async deleteEnvironment(id) {
         this.check();
         // Its vault and credentials go with it (ON DELETE CASCADE).
-        await this.db.delete(environments).where(eq(environments.id, id));
+        await this.db.delete(agents).where(eq(agents.id, id));
     }
     async listEnvironments(filter = {}) {
         this.check();
         const labels = filter.labels;
         const rows = await this.db
             .select()
-            .from(environments)
+            .from(agents)
             .where(labels === undefined || Object.keys(labels).length === 0
             ? undefined
-            : sql `nylorun.doc(${environments.labels}) @> ${toJson(labels)}::jsonb`)
-            .orderBy(environments.id);
+            : sql `nylorun.doc(${agents.labels}) @> ${toJson(labels)}::jsonb`)
+            .orderBy(agents.id);
         return rows.map(environmentOf);
     }
-    // --- Environment manifests (D63) -----------------------------------------------
-    async lockEnvironmentManifest(name) {
+    // --- Agent manifests (protocol 16) ---------------------------------------------
+    async lockAgentManifest(name) {
         this.check();
-        await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext(${`nylorun.environment_manifests:${name}`}))`);
+        await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext(${`nylorun.agent_manifests:${name}`}))`);
     }
-    async environmentManifest(name, version) {
+    async agentManifest(name, version) {
         this.check();
         const [row] = await this.db
             .select()
-            .from(environmentManifests)
+            .from(agentManifests)
             .where(version === undefined
-            ? eq(environmentManifests.name, name)
-            : and(eq(environmentManifests.name, name), eq(environmentManifests.version, version)))
-            .orderBy(desc(environmentManifests.version))
+            ? eq(agentManifests.name, name)
+            : and(eq(agentManifests.name, name), eq(agentManifests.version, version)))
+            .orderBy(desc(agentManifests.version))
             .limit(1);
-        return row && environmentManifestOf(row);
+        return row && agentManifestOf(row);
     }
-    async insertEnvironmentManifest(row) {
+    async insertAgentManifest(row) {
         this.check();
-        await this.db.insert(environmentManifests).values(row);
+        await this.db.insert(agentManifests).values(row);
     }
-    async listEnvironmentManifests() {
+    async listAgentManifests() {
         this.check();
         const rows = await this.db
-            .selectDistinctOn([environmentManifests.name])
-            .from(environmentManifests)
-            .orderBy(environmentManifests.name, desc(environmentManifests.version));
-        return rows.map(environmentManifestOf);
+            .selectDistinctOn([agentManifests.name])
+            .from(agentManifests)
+            .orderBy(agentManifests.name, desc(agentManifests.version));
+        return rows.map(agentManifestOf);
     }
-    async environmentManifestVersions(name) {
+    async agentManifestVersions(name) {
         this.check();
         const rows = await this.db
             .select()
-            .from(environmentManifests)
-            .where(eq(environmentManifests.name, name))
-            .orderBy(desc(environmentManifests.version));
-        return rows.map(environmentManifestOf);
+            .from(agentManifests)
+            .where(eq(agentManifests.name, name))
+            .orderBy(desc(agentManifests.version));
+        return rows.map(agentManifestOf);
     }
-    async deleteEnvironmentManifest(name) {
+    async deleteAgentManifest(name) {
         this.check();
         const deleted = await this.db
-            .delete(environmentManifests)
-            .where(eq(environmentManifests.name, name))
-            .returning({ version: environmentManifests.version });
+            .delete(agentManifests)
+            .where(eq(agentManifests.name, name))
+            .returning({ version: agentManifests.version });
         return deleted.length;
     }
-    async environmentsOfManifest(name) {
+    async agentsOfManifest(name) {
         this.check();
         const rows = await this.db
-            .select({ version: environments.manifestVersion, n: count() })
-            .from(environments)
-            .where(eq(environments.manifestName, name))
-            .groupBy(environments.manifestVersion);
-        return new Map(rows.filter((row) => row.version !== null).map((row) => [row.version, row.n]));
+            .select({ version: agents.manifestVersion, n: count() })
+            .from(agents)
+            .where(eq(agents.manifestName, name))
+            .groupBy(agents.manifestVersion);
+        return new Map(rows.map((row) => [row.version, row.n]));
     }
     async sessionsOnEnvironment(environmentId) {
         this.check();
@@ -762,24 +765,30 @@ class PostgresTx {
             .orderBy(sessions.id);
         return rows.map((row) => storedSession(row));
     }
-    async environmentEvent(environmentId, type, payload) {
+    async agentEvent(agentId, type, payload) {
         this.check();
-        return appendEnvironmentEvent(postgresEnvironmentRecordWriter(this.db), {
+        return appendAgentEvent(postgresAgentRecordWriter(this.db), {
             tenantId: this.tenantId,
-            environmentId,
+            agentId,
             time: this.now(),
             type,
             payload,
+            maxEntryBytes: await this.maxEntryBytes(),
         });
     }
-    async environmentEvents(environmentId, options = {}) {
+    /** The Tenant's Runtime limit `recordEntryBytes`, read in this transaction for each write. */
+    async maxEntryBytes() {
+        return (await readRuntimeLimits(this)).recordEntryBytes;
+    }
+    async agentEvents(agentId, options = {}) {
         this.check();
-        const rows = await this.db
-            .select({ body: environmentEvents.body })
-            .from(environmentEvents)
-            .where(and(eq(environmentEvents.environmentId, environmentId), options.fromSeq === undefined ? undefined : gte(environmentEvents.seq, options.fromSeq), options.types === undefined ? undefined : inArray(environmentEvents.type, [...options.types]), options.since === undefined ? undefined : gte(environmentEvents.committedAt, options.since), options.until === undefined ? undefined : lt(environmentEvents.committedAt, options.until)))
-            .orderBy(environmentEvents.seq)
-            .limit(options.limit ?? 1000);
+        const query = this.db
+            .select({ body: agentEvents.body })
+            .from(agentEvents)
+            .where(and(eq(agentEvents.agentId, agentId), options.fromSeq === undefined ? undefined : gte(agentEvents.seq, options.fromSeq), options.types === undefined ? undefined : inArray(agentEvents.type, [...options.types]), options.since === undefined ? undefined : gte(agentEvents.committedAt, options.since), options.until === undefined ? undefined : lt(agentEvents.committedAt, options.until)))
+            .orderBy(agentEvents.seq)
+            .$dynamic();
+        const rows = await (options.limit === undefined ? query : query.limit(options.limit));
         return rows.map((row) => row.body);
     }
     async effectBodies(where) {
@@ -827,13 +836,13 @@ class PostgresTx {
           WHERE ${sessions.status} IN ('running', 'runnable'))::int AS running,
         (SELECT count(*) FROM ${effects} WHERE ${effects.status} = 'uncertain')::int AS uncertain,
         (SELECT count(*) FROM ${sandboxes})::int AS sandboxes,
-        (SELECT count(*) FROM ${definitions})::int AS definitions`);
+        (SELECT count(*) FROM ${agentManifests})::int AS manifests`);
         return {
             sessions: row.sessions,
             runningSessions: row.running,
             uncertainEffects: row.uncertain,
             sandboxes: row.sandboxes,
-            definitions: row.definitions,
+            agentManifests: row.manifests,
         };
     }
     // --- control bus (D21) ---------------------------------------------------
@@ -1080,7 +1089,7 @@ class PostgresTx {
             costUsd: sql `coalesce(sum(${modelUsage.costUsd}), 0)::double precision`.mapWith(Number),
         })
             .from(modelUsage)
-            .where(and(query.scope === "agent" ? eq(modelUsage.agentId, query.id ?? "") : undefined, query.scope === "turn" ? eq(modelUsage.turnId, query.id ?? "") : undefined, query.since !== undefined ? gte(modelUsage.createdAt, query.since) : undefined));
+            .where(and(query.scope === "manifest" ? eq(modelUsage.manifestName, query.id ?? "") : undefined, query.scope === "turn" ? eq(modelUsage.turnId, query.id ?? "") : undefined, query.since !== undefined ? gte(modelUsage.createdAt, query.since) : undefined));
         return row;
     }
     async listModelBudgets() {
@@ -1096,6 +1105,249 @@ class PostgresTx {
         if (rows.length > 0)
             await this.db.insert(modelBudgets).values([...rows]);
     }
+    // --- session queues (protocol 17) -------------------------------------------
+    async enqueueMessage(row) {
+        this.check();
+        const [last] = await this.db
+            .select({ seq: sql `max(${sessionQueue.seq})` })
+            .from(sessionQueue)
+            .where(eq(sessionQueue.sessionId, row.sessionId));
+        const seq = Number(last?.seq ?? 0) + 1;
+        await this.db.insert(sessionQueue).values({ ...row, seq });
+        return seq;
+    }
+    async queuedMessages(sessionId) {
+        this.check();
+        return this.db
+            .select()
+            .from(sessionQueue)
+            .where(eq(sessionQueue.sessionId, sessionId))
+            .orderBy(sessionQueue.seq);
+    }
+    async countQueuedMessages(sessionId) {
+        this.check();
+        const [row] = await this.db
+            .select({ n: count() })
+            .from(sessionQueue)
+            .where(eq(sessionQueue.sessionId, sessionId));
+        return Number(row?.n ?? 0);
+    }
+    async deleteQueuedMessages(ids) {
+        this.check();
+        if (ids.length > 0)
+            await this.db.delete(sessionQueue).where(inArray(sessionQueue.id, [...ids]));
+    }
+    // --- triggers (track T4) ----------------------------------------------------
+    async agentTriggers(agentId) {
+        this.check();
+        return this.db
+            .select()
+            .from(agentTriggers)
+            .where(eq(agentTriggers.agentId, agentId))
+            .orderBy(agentTriggers.triggerId);
+    }
+    async agentTrigger(agentId, triggerId, options = {}) {
+        this.check();
+        const query = this.db
+            .select()
+            .from(agentTriggers)
+            .where(and(eq(agentTriggers.agentId, agentId), eq(agentTriggers.triggerId, triggerId)));
+        const [row] = options.lock ? await query.for("update") : await query;
+        return row;
+    }
+    async putAgentTrigger(row) {
+        this.check();
+        const { agentId: _a, triggerId: _t, createdAt: _c, ...set } = row;
+        await this.db
+            .insert(agentTriggers)
+            .values(row)
+            .onConflictDoUpdate({ target: [agentTriggers.agentId, agentTriggers.triggerId], set });
+    }
+    async deleteAgentTrigger(agentId, triggerId) {
+        this.check();
+        await this.db
+            .delete(agentTriggers)
+            .where(and(eq(agentTriggers.agentId, agentId), eq(agentTriggers.triggerId, triggerId)));
+    }
+    async deleteAgentTriggers(agentId) {
+        this.check();
+        await this.db.delete(agentTriggers).where(eq(agentTriggers.agentId, agentId));
+        await this.db.delete(triggerRuns).where(eq(triggerRuns.agentId, agentId));
+    }
+    async activeTriggers(options) {
+        this.check();
+        const conditions = [eq(agentTriggers.status, "active"), isNotNull(agentTriggers.nextFireAt)];
+        if (options.dueBefore !== undefined)
+            conditions.push(lte(agentTriggers.nextFireAt, options.dueBefore));
+        if (options.changedSince !== undefined)
+            conditions.push(gte(agentTriggers.updatedAt, options.changedSince));
+        if (options.after)
+            conditions.push(or(gt(agentTriggers.agentId, options.after.agentId), and(eq(agentTriggers.agentId, options.after.agentId), gt(agentTriggers.triggerId, options.after.triggerId))));
+        return this.db
+            .select()
+            .from(agentTriggers)
+            .where(and(...conditions))
+            .orderBy(agentTriggers.agentId, agentTriggers.triggerId)
+            .limit(options.limit);
+    }
+    async agentTriggerByEndpoint(endpointId) {
+        this.check();
+        const [row] = await this.db.select().from(agentTriggers).where(eq(agentTriggers.endpointId, endpointId));
+        return row;
+    }
+    async nextWakeAt(agentId) {
+        this.check();
+        const [row] = await this.db
+            .select({ at: sql `min(${agentTriggers.nextFireAt})` })
+            .from(agentTriggers)
+            .where(and(eq(agentTriggers.agentId, agentId), eq(agentTriggers.status, "active")));
+        return row?.at ?? null;
+    }
+    async insertTriggerRun(row) {
+        this.check();
+        const inserted = await this.db
+            .insert(triggerRuns)
+            .values(row)
+            .onConflictDoNothing()
+            .returning({ id: triggerRuns.id });
+        return inserted.length === 1;
+    }
+    async triggerRunByKey(agentId, runKey) {
+        this.check();
+        const [row] = await this.db
+            .select()
+            .from(triggerRuns)
+            .where(and(eq(triggerRuns.agentId, agentId), eq(triggerRuns.runKey, runKey)));
+        return row;
+    }
+    async updateTriggerRun(id, patch) {
+        this.check();
+        await this.db.update(triggerRuns).set(patch).where(eq(triggerRuns.id, id));
+    }
+    async countTriggerRuns(agentId, since, statuses) {
+        this.check();
+        const [row] = await this.db
+            .select({ n: count() })
+            .from(triggerRuns)
+            .where(and(eq(triggerRuns.agentId, agentId), gte(triggerRuns.firedAt, since), inArray(triggerRuns.status, [...statuses])));
+        return Number(row?.n ?? 0);
+    }
+    async listTriggerRuns(agentId, options) {
+        this.check();
+        const conditions = [eq(triggerRuns.agentId, agentId)];
+        if (options.triggerId !== undefined)
+            conditions.push(eq(triggerRuns.triggerId, options.triggerId));
+        if (options.before !== undefined)
+            conditions.push(lt(triggerRuns.id, options.before));
+        return this.db
+            .select()
+            .from(triggerRuns)
+            .where(and(...conditions))
+            .orderBy(desc(triggerRuns.id))
+            .limit(options.limit);
+    }
+    async pruneTriggerRuns(before) {
+        this.check();
+        const deleted = await this.db
+            .delete(triggerRuns)
+            .where(lt(triggerRuns.firedAt, before))
+            .returning({ id: triggerRuns.id });
+        return deleted.length;
+    }
+    // --- memory (track T5) ------------------------------------------------------
+    async memory(agentId, path, options = {}) {
+        this.check();
+        // The path's own lock, held whether or not a row has it, so two writes creating it queue.
+        if (options.lock)
+            await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext(${`nylorun.memories:${agentId}:${path}`}))`);
+        const query = this.db
+            .select()
+            .from(memories)
+            .where(and(eq(memories.agentId, agentId), eq(memories.path, path)));
+        const [row] = options.lock ? await query.for("update") : await query;
+        return row;
+    }
+    async memories(agentId, options) {
+        this.check();
+        const conditions = [eq(memories.agentId, agentId)];
+        // `starts_with`, not LIKE: a path may hold `%` or `_`.
+        if (options.folder !== undefined)
+            conditions.push(sql `starts_with(${memories.path}, ${`${options.folder}/`})`);
+        if (options.after !== undefined)
+            conditions.push(gt(memories.path, options.after));
+        const ordered = this.db
+            .select()
+            .from(memories)
+            .where(and(...conditions))
+            .orderBy(memories.path);
+        const limited = options.limit === undefined ? ordered : ordered.limit(options.limit);
+        return options.lock ? limited.for("update") : limited;
+    }
+    async countMemories(agentId) {
+        this.check();
+        const [row] = await this.db.select({ n: count() }).from(memories).where(eq(memories.agentId, agentId));
+        return Number(row?.n ?? 0);
+    }
+    async recentMemories(agentId, limit) {
+        this.check();
+        return this.db
+            .select({ path: memories.path, description: memories.description, bytes: memories.bytes })
+            .from(memories)
+            .where(eq(memories.agentId, agentId))
+            .orderBy(desc(memories.updatedAt), memories.path)
+            .limit(limit);
+    }
+    async putMemory(row) {
+        this.check();
+        const { agentId: _a, path: _p, ...set } = row;
+        await this.db
+            .insert(memories)
+            .values(row)
+            .onConflictDoUpdate({ target: [memories.agentId, memories.path], set });
+    }
+    async deleteMemory(agentId, path) {
+        this.check();
+        await this.db.delete(memories).where(and(eq(memories.agentId, agentId), eq(memories.path, path)));
+    }
+    async insertMemoryVersion(row) {
+        this.check();
+        await this.db.insert(memoryVersions).values(row);
+    }
+    async memoryVersions(agentId, options) {
+        this.check();
+        const conditions = [eq(memoryVersions.agentId, agentId)];
+        if (options.path !== undefined)
+            conditions.push(eq(memoryVersions.path, options.path));
+        if (options.before !== undefined)
+            conditions.push(lt(memoryVersions.id, options.before));
+        return this.db
+            .select()
+            .from(memoryVersions)
+            .where(and(...conditions))
+            .orderBy(desc(memoryVersions.id))
+            .limit(options.limit);
+    }
+    async memoryVersion(agentId, id) {
+        this.check();
+        const [row] = await this.db
+            .select()
+            .from(memoryVersions)
+            .where(and(eq(memoryVersions.agentId, agentId), eq(memoryVersions.id, id)));
+        return row;
+    }
+    async copyMemories(from, to, now) {
+        this.check();
+        const copied = await this.db.execute(sql `
+      INSERT INTO ${memories} (agent_id, path, content, content_sha256, bytes, description, version, updated_at)
+      SELECT ${to}, path, content, content_sha256, bytes, description, 1, ${now}
+      FROM ${memories} WHERE agent_id = ${from}`);
+        return Number(copied.count ?? 0);
+    }
+    async deleteAgentMemories(agentId) {
+        this.check();
+        await this.db.delete(memories).where(eq(memories.agentId, agentId));
+        await this.db.delete(memoryVersions).where(eq(memoryVersions.agentId, agentId));
+    }
     // --- tool crossings --------------------------------------------------------
     async toolCrossing(key) {
         this.check();
@@ -1181,6 +1433,11 @@ class PostgresTx {
             .where(and(eq(artifactVersions.artifactId, artifactId), eq(artifactVersions.version, version)));
         return row;
     }
+    async artifactVersionByWriteKey(writeKey) {
+        this.check();
+        const [row] = await this.db.select().from(artifactVersions).where(eq(artifactVersions.writeKey, writeKey));
+        return row;
+    }
     async artifactVersions(artifactId) {
         this.check();
         return this.db
@@ -1220,21 +1477,32 @@ class PostgresTx {
         this.check();
         await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext('nylorun.artifacts'))`);
     }
-    async artifactBytes() {
+    /** The artifacts of Environment `environmentId`: its disk versions, and its sessions'. */
+    artifactsOfEnvironment(environmentId) {
+        return or(eq(artifacts.environmentId, environmentId), inArray(artifacts.sessionId, this.db.select({ id: sessions.id }).from(sessions).where(eq(sessions.environmentId, environmentId))));
+    }
+    async artifactBytes(scope) {
         this.check();
+        const within = scope === undefined ? undefined : this.artifactsOfEnvironment(scope.environmentId);
         const [files] = await this.db
             .select({
             bytes: sql `coalesce(sum(${artifactVersions.size}), 0)::bigint`.mapWith(Number),
         })
             .from(artifactVersions)
             .innerJoin(artifacts, eq(artifacts.id, artifactVersions.artifactId))
-            .where(eq(artifacts.kind, "file"));
+            .where(within === undefined ? eq(artifacts.kind, "file") : and(eq(artifacts.kind, "file"), within));
         // A folder's files are stored once per distinct hash, however many versions name them.
-        const distinct = this.db
-            .select({ size: sql `max(${artifactContent.size})`.as("size") })
-            .from(artifactContent)
-            .groupBy(artifactContent.sha256)
-            .as("distinct_content");
+        const distinct = (within === undefined
+            ? this.db
+                .select({ size: sql `max(${artifactContent.size})`.as("size") })
+                .from(artifactContent)
+                .groupBy(artifactContent.sha256)
+            : this.db
+                .select({ size: sql `max(${artifactContent.size})`.as("size") })
+                .from(artifactContent)
+                .innerJoin(artifacts, eq(artifacts.id, artifactContent.artifactId))
+                .where(within)
+                .groupBy(artifactContent.sha256)).as("distinct_content");
         const [content] = await this.db
             .select({ bytes: sql `coalesce(sum(${distinct.size}), 0)::bigint`.mapWith(Number) })
             .from(distinct);
@@ -1242,22 +1510,26 @@ class PostgresTx {
     }
     async insertArtifactContent(artifactId, version, files) {
         this.check();
-        for (let at = 0; at < files.length; at += CONTENT_BATCH)
+        for (let at = 0; at < files.length; at += contentBatch())
             await this.db
                 .insert(artifactContent)
                 .values(files
-                .slice(at, at + CONTENT_BATCH)
+                .slice(at, at + contentBatch())
                 .map((file) => ({ artifactId, version, sha256: file.sha256, size: file.size })))
                 .onConflictDoNothing();
     }
-    async referencedArtifactContent(shas) {
+    async referencedArtifactContent(shas, scope) {
         this.check();
         const found = new Set();
-        for (let at = 0; at < shas.length; at += CONTENT_BATCH) {
-            const rows = await this.db
-                .selectDistinct({ sha256: artifactContent.sha256 })
-                .from(artifactContent)
-                .where(inArray(artifactContent.sha256, shas.slice(at, at + CONTENT_BATCH)));
+        for (let at = 0; at < shas.length; at += contentBatch()) {
+            const batch = inArray(artifactContent.sha256, shas.slice(at, at + contentBatch()));
+            const rows = scope === undefined
+                ? await this.db.selectDistinct({ sha256: artifactContent.sha256 }).from(artifactContent).where(batch)
+                : await this.db
+                    .selectDistinct({ sha256: artifactContent.sha256 })
+                    .from(artifactContent)
+                    .innerJoin(artifacts, eq(artifacts.id, artifactContent.artifactId))
+                    .where(and(batch, this.artifactsOfEnvironment(scope.environmentId)));
             for (const row of rows)
                 found.add(row.sha256);
         }
@@ -1302,23 +1574,23 @@ class PostgresTx {
     }
     async heldDefinitionFiles(shas) {
         this.check();
-        const found = new Set();
-        for (let at = 0; at < shas.length; at += CONTENT_BATCH) {
+        const found = new Map();
+        for (let at = 0; at < shas.length; at += contentBatch()) {
             const rows = await this.db
-                .select({ sha256: definitionFiles.sha256 })
+                .select({ sha256: definitionFiles.sha256, size: definitionFiles.size })
                 .from(definitionFiles)
-                .where(inArray(definitionFiles.sha256, shas.slice(at, at + CONTENT_BATCH)));
+                .where(inArray(definitionFiles.sha256, shas.slice(at, at + contentBatch())));
             for (const row of rows)
-                found.add(row.sha256);
+                found.set(row.sha256, row.size);
         }
         return found;
     }
     async insertDefinitionFileUses(agentId, manifestHash, shas) {
         this.check();
-        for (let at = 0; at < shas.length; at += CONTENT_BATCH)
+        for (let at = 0; at < shas.length; at += contentBatch())
             await this.db
                 .insert(definitionFileUses)
-                .values(shas.slice(at, at + CONTENT_BATCH).map((sha256) => ({ agentId, manifestHash, sha256 })))
+                .values(shas.slice(at, at + contentBatch()).map((sha256) => ({ agentId, manifestHash, sha256 })))
                 .onConflictDoNothing();
     }
     // --- settings ------------------------------------------------------------
@@ -1344,6 +1616,8 @@ class PostgresTx {
         if (scope === "sessions" || scope === "all") {
             for (const table of SESSION_TABLES)
                 await db.delete(table);
+            // A session's booked wake (T4) goes with it.
+            await db.delete(agentTriggers).where(eq(agentTriggers.kind, "wake"));
             await db.delete(toolCrossings);
             // A session's artifacts go with it (their versions by cascade).
             await db.delete(artifacts).where(isNotNull(artifacts.sessionId));
@@ -1356,15 +1630,20 @@ class PostgresTx {
                 basinGeneration: sql `${tenant.basinGeneration} + 1`,
             });
         }
-        if (scope === "environments" || scope === "all") {
+        if (scope === "agents" || scope === "all") {
             await db.delete(sandboxes);
             // Their vaults and credentials go with them (ON DELETE CASCADE).
-            await db.delete(environments);
-            await db.delete(environmentEvents);
+            await db.delete(agents);
+            await db.delete(agentEvents);
+            await db.delete(agentTriggers);
+            await db.delete(triggerRuns);
+            // Memories belong to the Agents (D72).
+            await db.delete(memories);
+            await db.delete(memoryVersions);
             await db.delete(sandboxSignals);
         }
         if (scope === "all") {
-            await db.delete(definitions);
+            await db.delete(agentManifests);
             // The files stay, as their bytes do; only what used them goes.
             await db.delete(definitionFileUses);
             await db.delete(modelUsage);