@nylorun/runtime 0.27.0-beta → 0.29.0-beta

package/dist/store/postgres/store.js

@@ -51,7 +51,7 @@
 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";
@@ -59,8 +59,8 @@ 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);
 }
@@ -68,7 +68,6 @@ const OPEN_SESSION = ["running", "runnable"];
 /** 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,
@@ -257,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: {
@@ -283,7 +287,7 @@ function environmentOf(row) {
             : {}),
     };
 }
-function environmentManifestOf(row) {
+function agentManifestOf(row) {
     return {
         name: row.name,
         version: row.version,
@@ -322,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.
@@ -629,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";
@@ -675,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();
@@ -765,11 +765,11 @@ 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,
@@ -780,13 +780,13 @@ class PostgresTx {
     async maxEntryBytes() {
         return (await readRuntimeLimits(this)).recordEntryBytes;
     }
-    async environmentEvents(environmentId, options = {}) {
+    async agentEvents(agentId, options = {}) {
         this.check();
         const query = 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)
+            .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);
@@ -836,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) ---------------------------------------------------
@@ -1089,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() {
@@ -1105,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();
@@ -1373,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));
@@ -1385,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);

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)