@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/store/postgres/control.js

@@ -11,8 +11,8 @@
  *   exists exactly when what it announces committed.
  * - **Follow.** `followControlSignals` holds one connection of its own that LISTENs (a pooled
  *   connection cannot). Each notification reads back the signals of the last
- *   `WINDOW_SECONDS` and delivers those this follower has not delivered yet. So does a poll
- *   every `pollMs`, and every LISTEN after a reconnect: Postgres does not queue notifications
+ *   `postgres.controlWindowSeconds` (Host tuning) and delivers those this follower has not delivered yet. So does a poll
+ *   every `pollMs` (`postgres.controlPollMs`), and every LISTEN after a reconnect: Postgres does not queue notifications
  *   for a session that is not connected, and the rows are what catches up. Ids are never read
  *   as a cursor: they are allocated at insert and commit out of order, so a later id can be
  *   visible first.
@@ -23,14 +23,10 @@
  */
 import { gte, lt, sql } from "drizzle-orm";
 import { createPostgresListenClient } from "./connect.js";
+import { hostTuning } from "../../tuning.js";
 import { controlSignals } from "./schema.js";
 /** The channel every signal is notified on. */
 export const CONTROL_CHANNEL = "nylorun_control";
-/** How far back a read-back looks. Longer than the poll, so a missed notification is caught. */
-const WINDOW_SECONDS = 120;
-const POLL_MS = 5000;
-const RETRY_MIN_MS = 100;
-const RETRY_MAX_MS = 5000;
 const SIGNAL = {
     id: controlSignals.id,
     kind: controlSignals.kind,
@@ -69,7 +65,11 @@ export async function pruneSignals(db, before) {
  * start is fixed; the first LISTEN may still be retrying, and the poll covers it meanwhile.
  */
 export async function followControlSignals(source, db, onSignal, options = {}) {
-    const pollMs = options.pollMs ?? POLL_MS;
+    const tuning = hostTuning().postgres;
+    const pollMs = options.pollMs ?? tuning.controlPollMs;
+    // How far back a read-back looks: longer than the poll, so a missed notification is caught.
+    const windowSeconds = tuning.controlWindowSeconds;
+    const { minMs: retryMinMs, maxMs: retryMaxMs } = tuning.controlRetry;
     const onError = options.onError ?? (() => { });
     // Drizzle leaves timestamps to its column types, so a raw read of one is text.
     const [start] = await db.execute(sql `SELECT clock_timestamp()::text AS now`);
@@ -78,7 +78,7 @@ export async function followControlSignals(source, db, onSignal, options = {}) {
     const delivered = new Map();
     let stopped = false;
     let retry;
-    let delay = RETRY_MIN_MS;
+    let delay = retryMinMs;
     let draining;
     let again = false;
     const client = createPostgresListenClient(source, {
@@ -98,14 +98,14 @@ export async function followControlSignals(source, db, onSignal, options = {}) {
             void listen();
         }, delay);
         retry.unref();
-        delay = Math.min(delay * 2, RETRY_MAX_MS);
+        delay = Math.min(delay * 2, retryMaxMs);
     }
     async function listen() {
         if (stopped)
             return;
         try {
             await client.unsafe(`LISTEN ${CONTROL_CHANNEL}`);
-            delay = RETRY_MIN_MS;
+            delay = retryMinMs;
             drain();
         }
         catch (error) {
@@ -129,7 +129,7 @@ export async function followControlSignals(source, db, onSignal, options = {}) {
                     const rows = await db
                         .select(SIGNAL)
                         .from(controlSignals)
-                        .where(gte(controlSignals.createdAt, sql `greatest(${since}::timestamptz, clock_timestamp() - make_interval(secs => ${WINDOW_SECONDS}))`))
+                        .where(gte(controlSignals.createdAt, sql `greatest(${since}::timestamptz, clock_timestamp() - make_interval(secs => ${windowSeconds}))`))
                         .orderBy(controlSignals.id);
                     for (const row of rows)
                         deliver(row);
@@ -160,7 +160,7 @@ export async function followControlSignals(source, db, onSignal, options = {}) {
     }
     /** A row a read-back can still return is younger than the window: keep twice that. */
     function forgetOld() {
-        const before = Date.now() - 2 * WINDOW_SECONDS * 1000;
+        const before = Date.now() - 2 * windowSeconds * 1000;
         for (const [id, at] of delivered)
             if (at < before)
                 delivered.delete(id);

package/dist/store/postgres/drizzle/0028_artifact_write_keys.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "nylorun"."artifact_versions" ADD COLUMN "write_key" text COLLATE "C";--> statement-breakpoint
+CREATE UNIQUE INDEX "artifact_versions_write_key" ON "nylorun"."artifact_versions" USING btree ("write_key") WHERE write_key IS NOT NULL;

package/dist/store/postgres/drizzle/0029_protocol_15.sql

@@ -0,0 +1,11 @@
+-- Protocol 15: the harness boundary. `read_artifact` and `save_artifact` are our harness's own
+-- tools, no longer the Runtime's: the manifest schema refuses a pinned `runtime` block that holds
+-- them. A fresh start for the sessions that pinned one (every agent session since protocol 12):
+-- each is closed (`session_closed`) and its history stays readable. Workflow sessions pin no
+-- `runtime` block and carry over.
+UPDATE "nylorun"."sessions" SET "body" = ("body"::jsonb || '{"closedReason":"protocol_15"}'::jsonb)::json
+WHERE nylorun.doc("body") ->> 'closedReason' IS NULL
+  AND jsonb_path_exists(
+    nylorun.doc("body") -> 'manifest' -> 'runtime' -> 'tools',
+    '$[*] ? (@.name == "read_artifact" || @.name == "save_artifact")'
+  );

package/dist/store/postgres/drizzle/0030_protocol_15_runtime_block.sql

@@ -0,0 +1,11 @@
+-- Protocol 15: the harness writes the model's instructions and defines the sandbox and skill
+-- tools, so the manifest schema refuses a pinned `runtime` block, and a session pins its
+-- definition as registered. A fresh start for the agent sessions that still pinned one (opened
+-- by a build of protocol 15 before this change, on the root agent or an agent it uses as a tool):
+-- each is closed (`session_closed`) and its history stays readable. The others carry over.
+UPDATE "nylorun"."sessions" SET "body" = ("body"::jsonb || '{"closedReason":"protocol_15"}'::jsonb)::json
+WHERE nylorun.doc("body") ->> 'closedReason' IS NULL
+  AND (
+    jsonb_path_exists(nylorun.doc("body") -> 'manifest', 'lax $.runtime')
+    OR jsonb_path_exists(nylorun.doc("body") -> 'manifest', 'lax $.tools[*].agent.runtime')
+  );

package/dist/store/postgres/drizzle/0031_protocol_15_mcp_snapshot.sql

@@ -0,0 +1,8 @@
+-- Protocol 15: the harness names a session's MCP tools and decides which to defer, so the
+-- session pins what its servers listed, raw (`snapshotSchemaVersion` 2), and every MCP call names
+-- its tool by `{server, tool}`. A session that pinned the former snapshot (model-facing names,
+-- deferral decided by core) cannot run its next turn: each still open is closed
+-- (`session_closed`) and its history stays readable. The others carry over.
+UPDATE "nylorun"."sessions" SET "body" = ("body"::jsonb || '{"closedReason":"protocol_15"}'::jsonb)::json
+WHERE nylorun.doc("body") ->> 'closedReason' IS NULL
+  AND nylorun.doc("body") -> 'mcpSnapshot' ->> 'snapshotSchemaVersion' = '1';

package/dist/store/postgres/drizzle/0032_agents.sql

@@ -0,0 +1,54 @@
+-- Protocol 16: Agents from one manifest (track T2), a fresh start. Agent definitions and
+-- environment manifests cannot become agent manifests (v8) on their own: a definition has no
+-- runtime section, and an Environment held sessions of many agents. So both go, and so do the
+-- Environments with their pods, disks and vaults, as protocol 11 dropped sandboxes and vaults.
+-- Every open session is closed (`protocol_16`): its history stays readable. `environments` is
+-- renamed `agents` (made from a saved agent manifest only) and its lifecycle stream
+-- `agent_events`; model budget scope `agent` is `manifest`, keyed by the manifest's name, so a
+-- budget keeps its meaning, and the usage ledger names the manifest.
+UPDATE "nylorun"."sessions" SET "body" = ("body"::jsonb || '{"closedReason":"protocol_16"}'::jsonb)::json
+WHERE nylorun.doc("body") ->> 'closedReason' IS NULL;--> statement-breakpoint
+DELETE FROM "nylorun"."vaults" WHERE "id" <> 'host';--> statement-breakpoint
+DELETE FROM "nylorun"."vault_idempotency" WHERE "id" NOT LIKE 'host-model%';--> statement-breakpoint
+DELETE FROM "nylorun"."sandboxes";--> statement-breakpoint
+DELETE FROM "nylorun"."sandbox_signals";--> statement-breakpoint
+DELETE FROM "nylorun"."artifacts" WHERE "environment_id" IS NOT NULL;--> statement-breakpoint
+DELETE FROM "nylorun"."environments";--> statement-breakpoint
+DELETE FROM "nylorun"."definition_file_uses";--> statement-breakpoint
+DROP TABLE "nylorun"."definitions";--> statement-breakpoint
+DROP TABLE "nylorun"."environment_manifests";--> statement-breakpoint
+DROP TABLE "nylorun_streams"."environment_events";--> statement-breakpoint
+CREATE TABLE "nylorun_streams"."agent_events" (
+	"agent_id" text COLLATE "C" NOT NULL,
+	"seq" bigint NOT NULL,
+	"type" text NOT NULL,
+	"body" json NOT NULL,
+	"committed_at" timestamp with time zone DEFAULT now() NOT NULL,
+	CONSTRAINT "agent_events_pkey" PRIMARY KEY("agent_id","seq")
+);
+--> statement-breakpoint
+CREATE TABLE "nylorun"."agent_manifests" (
+	"name" text COLLATE "C" NOT NULL,
+	"version" integer NOT NULL,
+	"body" json NOT NULL,
+	"hash" text COLLATE "C" NOT NULL,
+	"saved_by" json NOT NULL,
+	"created_at" text COLLATE "C" NOT NULL,
+	CONSTRAINT "agent_manifests_pkey" PRIMARY KEY("name","version")
+);
+--> statement-breakpoint
+ALTER TABLE "nylorun"."environments" RENAME TO "agents";--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" RENAME CONSTRAINT "environments_pkey" TO "agents_pkey";--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" DROP CONSTRAINT "environments_kind_check";--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ADD CONSTRAINT "agents_kind_check" CHECK ("nylorun"."agents"."kind" IN ('virtual', 'pod', 'none'));--> statement-breakpoint
+ALTER INDEX "nylorun"."environments_manifest" RENAME TO "agents_manifest";--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ALTER COLUMN "manifest_name" SET NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ALTER COLUMN "manifest_version" SET NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ALTER COLUMN "manifest_hash" SET NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ADD COLUMN "manifest_ref" text NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ADD COLUMN "desired_state" text DEFAULT 'on' NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."model_usage" RENAME COLUMN "agent_id" TO "manifest_name";--> statement-breakpoint
+ALTER INDEX "nylorun"."model_usage_agent" RENAME TO "model_usage_manifest";--> statement-breakpoint
+UPDATE "nylorun"."model_budgets" SET "scope" = 'manifest' WHERE "scope" = 'agent';--> statement-breakpoint
+ALTER TABLE "nylorun"."sessions" ADD COLUMN "manifest_name" text GENERATED ALWAYS AS (nylorun.doc(body)->'definition'->>'name') STORED;--> statement-breakpoint
+CREATE INDEX "sessions_manifest" ON "nylorun"."sessions" USING btree ("manifest_name");

package/dist/store/postgres/drizzle/0033_agent_versions.sql

@@ -0,0 +1,7 @@
+-- Track T3, Agents that evolve (D73): an Agent moves between versions of its manifest. While it
+-- is outdated it names the version it moves to (`target_version`); a version that failed to start
+-- is kept so a tracking Agent does not move to it again (`failed_version`); and while a pod starts
+-- on a new version, what it ran before (`start_check`), which a failed start reverts to.
+ALTER TABLE "nylorun"."agents" ADD COLUMN "target_version" integer;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ADD COLUMN "failed_version" integer;--> statement-breakpoint
+ALTER TABLE "nylorun"."agents" ADD COLUMN "start_check" json;

package/dist/store/postgres/drizzle/0034_protocol_17_session_queue.sql

@@ -0,0 +1,13 @@
+CREATE TABLE "nylorun"."session_queue" (
+	"id" text COLLATE "C" PRIMARY KEY NOT NULL,
+	"session_id" text COLLATE "C" NOT NULL,
+	"seq" bigint NOT NULL,
+	"command" json NOT NULL,
+	"input" json NOT NULL,
+	"file_artifacts" json NOT NULL,
+	"writer" json NOT NULL,
+	"trace" json,
+	"created_at" text COLLATE "C" NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX "session_queue_order" ON "nylorun"."session_queue" USING btree ("session_id","seq");

package/dist/store/postgres/drizzle/0035_t4_triggers.sql

@@ -0,0 +1,41 @@
+CREATE TABLE "nylorun"."agent_triggers" (
+	"agent_id" text COLLATE "C" NOT NULL,
+	"trigger_id" text COLLATE "C" NOT NULL,
+	"kind" text NOT NULL,
+	"status" text NOT NULL,
+	"paused_reason" text,
+	"generation" integer DEFAULT 0 NOT NULL,
+	"next_fire_at" text COLLATE "C",
+	"last_fire_at" text COLLATE "C",
+	"endpoint_id" text COLLATE "C",
+	"sealed_secret" json,
+	"session_id" text COLLATE "C",
+	"note" text,
+	"effect_id" text,
+	"created_at" text COLLATE "C" NOT NULL,
+	"updated_at" text COLLATE "C" NOT NULL,
+	CONSTRAINT "agent_triggers_pkey" PRIMARY KEY("agent_id","trigger_id")
+);
+--> statement-breakpoint
+CREATE TABLE "nylorun"."trigger_runs" (
+	"id" text COLLATE "C" PRIMARY KEY NOT NULL,
+	"agent_id" text COLLATE "C" NOT NULL,
+	"trigger_id" text COLLATE "C" NOT NULL,
+	"kind" text NOT NULL,
+	"run_key" text COLLATE "C" NOT NULL,
+	"due_at" text COLLATE "C" NOT NULL,
+	"fired_at" text COLLATE "C" NOT NULL,
+	"late" boolean DEFAULT false NOT NULL,
+	"status" text NOT NULL,
+	"reason" text,
+	"session_id" text COLLATE "C",
+	"turn_id" text COLLATE "C",
+	"queued_message_id" text COLLATE "C"
+);
+--> statement-breakpoint
+ALTER TABLE "nylorun"."session_queue" ADD COLUMN "cause" json;--> statement-breakpoint
+CREATE INDEX "agent_triggers_due" ON "nylorun"."agent_triggers" USING btree ("status","next_fire_at");--> statement-breakpoint
+CREATE UNIQUE INDEX "agent_triggers_endpoint" ON "nylorun"."agent_triggers" USING btree ("endpoint_id") WHERE endpoint_id IS NOT NULL;--> statement-breakpoint
+CREATE UNIQUE INDEX "trigger_runs_key" ON "nylorun"."trigger_runs" USING btree ("agent_id","run_key");--> statement-breakpoint
+CREATE INDEX "trigger_runs_agent" ON "nylorun"."trigger_runs" USING btree ("agent_id","id");--> statement-breakpoint
+CREATE INDEX "trigger_runs_fired" ON "nylorun"."trigger_runs" USING btree ("fired_at");

package/dist/store/postgres/drizzle/0036_t5_memories.sql

@@ -0,0 +1,30 @@
+CREATE TABLE "nylorun"."memories" (
+	"agent_id" text COLLATE "C" NOT NULL,
+	"path" text COLLATE "C" NOT NULL,
+	"content" text NOT NULL,
+	"content_sha256" text NOT NULL,
+	"bytes" integer NOT NULL,
+	"description" text,
+	"version" integer NOT NULL,
+	"updated_at" text COLLATE "C" NOT NULL,
+	CONSTRAINT "memories_pkey" PRIMARY KEY("agent_id","path")
+);
+--> statement-breakpoint
+CREATE TABLE "nylorun"."memory_versions" (
+	"id" text COLLATE "C" PRIMARY KEY NOT NULL,
+	"agent_id" text COLLATE "C" NOT NULL,
+	"path" text COLLATE "C" NOT NULL,
+	"from_path" text COLLATE "C",
+	"operation" text NOT NULL,
+	"content" text,
+	"content_sha256" text,
+	"bytes" integer,
+	"actor" text NOT NULL,
+	"session_id" text COLLATE "C",
+	"turn_id" text COLLATE "C",
+	"trigger_run_id" text COLLATE "C",
+	"created_at" text COLLATE "C" NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX "memory_versions_agent" ON "nylorun"."memory_versions" USING btree ("agent_id","id");--> statement-breakpoint
+CREATE INDEX "memory_versions_path" ON "nylorun"."memory_versions" USING btree ("agent_id","path","id");

package/dist/store/postgres/drizzle/meta/_journal.json

@@ -197,6 +197,69 @@
       "when": 1791997067694,
       "tag": "0027_environment_image_digest",
       "breakpoints": true
+    },
+    {
+      "idx": 28,
+      "version": "7",
+      "when": 1792084466204,
+      "tag": "0028_artifact_write_keys",
+      "breakpoints": true
+    },
+    {
+      "idx": 29,
+      "version": "7",
+      "when": 1792086180701,
+      "tag": "0029_protocol_15",
+      "breakpoints": true
+    },
+    {
+      "idx": 30,
+      "version": "7",
+      "when": 1792091020175,
+      "tag": "0030_protocol_15_runtime_block",
+      "breakpoints": true
+    },
+    {
+      "idx": 31,
+      "version": "7",
+      "when": 1792094620175,
+      "tag": "0031_protocol_15_mcp_snapshot",
+      "breakpoints": true
+    },
+    {
+      "idx": 32,
+      "version": "7",
+      "when": 1792098220175,
+      "tag": "0032_agents",
+      "breakpoints": true
+    },
+    {
+      "idx": 33,
+      "version": "7",
+      "when": 1792161078177,
+      "tag": "0033_agent_versions",
+      "breakpoints": true
+    },
+    {
+      "idx": 34,
+      "version": "7",
+      "when": 1792163689759,
+      "tag": "0034_protocol_17_session_queue",
+      "breakpoints": true
+    },
+    {
+      "idx": 35,
+      "version": "7",
+      "when": 1792164194039,
+      "tag": "0035_t4_triggers",
+      "breakpoints": true
+    },
+    {
+      "idx": 36,
+      "version": "7",
+      "when": 1792172016681,
+      "tag": "0036_t5_memories",
+      "breakpoints": true
     }
   ]
 }

package/dist/store/postgres/reads.js

@@ -4,12 +4,14 @@ import { and, asc, desc, eq, exists, gt, inArray, isNull, lt, ne, or, sql, } fro
 import { isArtifactId } from "@nylorun/core/compatibility";
 import { readCursor } from "../../reads/cursor.js";
 import { fail } from "../../tenant/http.js";
+import { limitsInForce, readTenantLimits } from "../../tenant/limits.js";
 import { artifactView } from "../../artifacts/service.js";
 import { sandboxWorkspaceKey } from "../../sandbox/records.js";
 import { database, driverError } from "./db.js";
 import { createPostgresReadClient } from "./connect.js";
+import { hostTuning } from "../../tuning.js";
 import { toolCallDuration, toolCallStatus } from "../../harness-api/tool-status.js";
-import { effects, artifacts, modelUsage, environments, sandboxes, sessions, sessionEvents, } from "./schema.js";
+import { effects, artifacts, modelUsage, sandboxes, sessions, sessionEvents, tenantSettings, } from "./schema.js";
 const sessionFields = {
     id: sessions.id,
     agentId: sessions.agentId,
@@ -17,11 +19,18 @@ const sessionFields = {
     status: sessions.status,
     activeTurnId: sql `${sessions.body}->>'activeTurnId'`,
     lastTurnId: sql `${sessions.body}->>'lastTurnId'`,
-    environmentId: sessions.environmentId,
     createdAt: sessions.createdAt,
 };
+/** Rows whose Agent id an Agent grant (`*`, an id, or a `p/*` prefix) reaches; none reach nothing. */
+function grantsWhere(column, grants) {
+    if (grants.includes("*"))
+        return sql `true`;
+    if (grants.length === 0)
+        return sql `false`;
+    return or(...grants.map((grant) => grant.endsWith("/*") ? sql `starts_with(${column}, ${grant.slice(0, -1)})` : eq(column, grant)));
+}
 function accessWhere(access) {
-    return and(access.owner === undefined ? undefined : eq(sessions.ownerUserId, access.owner), access.agents === undefined ? undefined : inArray(sessions.agentId, [...access.agents]));
+    return and(access.owner === undefined ? undefined : eq(sessions.ownerUserId, access.owner), access.agents === undefined ? undefined : grantsWhere(sessions.agentId, access.agents));
 }
 function publicCall(row) {
     return {
@@ -29,7 +38,7 @@ function publicCall(row) {
         effectId: row.effectKey,
         sessionId: row.sessionId,
         turnId: row.turnId,
-        agentId: row.agentId,
+        manifestName: row.manifestName,
         provider: row.provider,
         model: row.model,
         at: row.createdAt,
@@ -64,6 +73,7 @@ function publicToolCall(body) {
         toolName: request.toolName ?? null,
         kind: body.toolKind ?? null,
         server: body.server ?? null,
+        tool: body.tool ?? null,
         skill: body.skill ?? null,
         plugin: body.plugin ?? null,
         status,
@@ -118,7 +128,7 @@ export function createPostgresReadStore(source, tenantId) {
         return row.id;
     }
     return {
-        close: () => pool.end({ timeout: 2 }),
+        close: () => pool.end({ timeout: hostTuning().postgres.readCloseTimeoutSeconds }),
         artifacts: (filters, page, access) => read(async (tx) => {
             if (filters.sessionId !== undefined)
                 await requireSession(tx, filters.sessionId, access);
@@ -163,9 +173,7 @@ export function createPostgresReadStore(source, tenantId) {
             const rows = await tx
                 .select(fields)
                 .from(sessions)
-                .where(and(accessWhere(access), position, filters.agentId === undefined ? undefined : eq(sessions.agentId, filters.agentId), filters.status === undefined ? undefined : eq(sessions.status, filters.status), filters.environmentId === undefined
-                ? undefined
-                : eq(sessions.environmentId, filters.environmentId), filters.ownerUserId === undefined
+                .where(and(accessWhere(access), position, filters.agentId === undefined ? undefined : eq(sessions.agentId, filters.agentId), filters.status === undefined ? undefined : eq(sessions.status, filters.status), filters.manifest === undefined ? undefined : eq(sessions.manifestName, filters.manifest), filters.ownerUserId === undefined
                 ? undefined
                 : eq(sessions.ownerUserId, filters.ownerUserId)))
                 .orderBy(sql `${sessions.createdAt} desc nulls last`, desc(sessions.id))
@@ -186,8 +194,8 @@ export function createPostgresReadStore(source, tenantId) {
                 .select({
                 sessionId: sessions.id,
                 agentId: sessions.agentId,
+                definition: sql `${sessions.body}->'definition'`,
                 manifestHash: sql `${sessions.body}->>'manifestHash'`,
-                implementationVersion: sql `${sessions.body}->>'implementationVersion'`,
                 manifest: sql `${sessions.body}->'manifest'`,
             })
                 .from(sessions)
@@ -301,78 +309,5 @@ export function createPostgresReadStore(source, tenantId) {
                 asOf: new Date().toISOString(),
             };
         }),
-        environments: (labels, page, access, grants) => read(async (tx) => {
-            const cursor = readCursor(tenantId, "environments", labels);
-            const key = keyOf(cursor.decode(page.cursor), 1);
-            const allowed = grants === undefined
-                ? undefined
-                : or(...grants.map((grant) => grant.endsWith("/*")
-                    ? sql `starts_with(${environments.id}, ${grant.slice(0, -1)})`
-                    : eq(environments.id, grant)));
-            const rows = await tx
-                .select()
-                .from(environments)
-                .where(and(grants?.length === 0 ? sql `false` : allowed, key ? gt(environments.id, key[0]) : undefined, or(isNull(environments.desired), ne(environments.desired, "deleted")), ...Object.entries(labels).map(([k, v]) => sql `${environments.labels}::jsonb->>${k} = ${v}`)))
-                .orderBy(asc(environments.id))
-                .limit(page.limit + 1);
-            const items = [];
-            for (const row of rows.slice(0, page.limit)) {
-                const [related] = await tx
-                    .select({
-                    items: sql `coalesce(json_agg(json_build_object('id', ${sessions.id}, 'activeTurnId', ${sessions.body}->>'activeTurnId') order by ${sessions.id}), '[]'::json)`,
-                })
-                    .from(sessions)
-                    .where(and(eq(sessions.environmentId, row.id), accessWhere(access)));
-                const [compute] = await tx
-                    .select({ body: sandboxes.body })
-                    .from(sandboxes)
-                    .where(eq(sandboxes.id, sandboxWorkspaceKey(tenantId, row.id)))
-                    .limit(1);
-                const isPod = row.kind === "pod";
-                items.push({
-                    id: row.id,
-                    kind: row.kind,
-                    labels: row.labels,
-                    manifest: row.recipe,
-                    ...(row.manifestName === null ? {} : { manifestName: row.manifestName }),
-                    ...(row.manifestVersion === null ? {} : { manifestVersion: row.manifestVersion }),
-                    ...(row.manifestHash === null ? {} : { manifestHash: row.manifestHash }),
-                    ...(row.forkedFrom ? { forkedFrom: row.forkedFrom } : {}),
-                    version: row.version,
-                    appliedVersion: row.appliedVersion,
-                    ownerUserId: row.ownerUserId,
-                    state: isPod
-                        ? row.observed === "running"
-                            ? "running"
-                            : row.observed === "creating"
-                                ? "creating"
-                                : "stopped"
-                        : row.kind === "none"
-                            ? "ready"
-                            : (compute?.body?.state ?? "ready"),
-                    ...(isPod
-                        ? {
-                            pod: {
-                                desired: row.desired,
-                                observed: row.observed,
-                                volumeGeneration: row.volumeGen,
-                                hostEpoch: row.hostEpoch,
-                                ...(row.reason ? { reason: row.reason } : {}),
-                                ...(row.imageDigest ? { imageDigest: row.imageDigest } : {}),
-                            },
-                        }
-                        : {}),
-                    lastUsedAt: new Date(row.lastUsedAt).toISOString(),
-                    sessions: related.items,
-                    createdAt: row.createdAt,
-                    updatedAt: row.updatedAt,
-                });
-            }
-            const last = items.at(-1);
-            return {
-                environments: items,
-                nextCursor: rows.length > page.limit && last ? cursor.encode([last.id]) : null,
-            };
-        }),
     };
 }

package/dist/store/postgres/record-writer.d.ts

@@ -1,9 +1,9 @@
-import type { RecordWriter, EnvironmentRecordWriter } from "../../record/index.js";
+import type { RecordWriter, AgentRecordWriter } from "../../record/index.js";
 import type { Transaction } from "./db.js";
 /**
- * The Environment stream writer of transaction `db` (`record/environment.ts`): the only inserts
- * into `environment_events`. The caller holds the Environment row's lock, which orders its events.
+ * The Agent stream writer of transaction `db` (`record/agent.ts`): the only inserts into
+ * `agent_events`. The caller holds the Agent row's lock, which orders its events.
  */
-export declare function postgresEnvironmentRecordWriter(db: Transaction): EnvironmentRecordWriter;
+export declare function postgresAgentRecordWriter(db: Transaction): AgentRecordWriter;
 /** The record writer of transaction `db`. */
 export declare function postgresRecordWriter(db: Transaction): RecordWriter;

package/dist/store/postgres/record-writer.js

@@ -5,22 +5,22 @@
  * run in the store's transaction under the caller's session row lock.
  */
 import { eq, sql } from "drizzle-orm";
-import { environmentEvents, sessionEvents, sessionLogHeads, tenant } from "./schema.js";
+import { agentEvents, sessionEvents, sessionLogHeads, tenant } from "./schema.js";
 /**
- * The Environment stream writer of transaction `db` (`record/environment.ts`): the only inserts
- * into `environment_events`. The caller holds the Environment row's lock, which orders its events.
+ * The Agent stream writer of transaction `db` (`record/agent.ts`): the only inserts into
+ * `agent_events`. The caller holds the Agent row's lock, which orders its events.
  */
-export function postgresEnvironmentRecordWriter(db) {
+export function postgresAgentRecordWriter(db) {
     return {
-        async nextSeq(environmentId) {
+        async nextSeq(agentId) {
             const [row] = await db
-                .select({ next: sql `coalesce(max(${environmentEvents.seq}) + 1, 0)`.mapWith(Number) })
-                .from(environmentEvents)
-                .where(eq(environmentEvents.environmentId, environmentId));
+                .select({ next: sql `coalesce(max(${agentEvents.seq}) + 1, 0)`.mapWith(Number) })
+                .from(agentEvents)
+                .where(eq(agentEvents.agentId, agentId));
             return row?.next ?? 0;
         },
         async insert(row) {
-            await db.insert(environmentEvents).values(row);
+            await db.insert(agentEvents).values(row);
         },
     };
 }