@nylorun/runtime 0.27.0-beta → 0.29.0-beta

package/dist/store/postgres/schema.js

@@ -54,7 +54,6 @@ export const tenant = nylorun.table("tenant", {
     /** Earlier generations whose basins are still to be deleted. */
     retiredGenerations: integer().array().notNull().default(sql `'{}'`),
 }, () => [check("tenant_singleton_check", sql `singleton`)]);
-export const definitions = documents("definitions");
 const xid8 = customType({ dataType: () => "xid8" });
 export const sessions = nylorun.table("sessions", {
     id: textC().primaryKey(),
@@ -69,14 +68,17 @@ export const sessions = nylorun.table("sessions", {
     ownerExpiresAt: timestamp({ withTimezone: true, mode: "date" }),
     /** The session owner (`ownerUserId`), not the lease column `owner`. */
     ownerUserId: field("->>'ownerUserId'"),
-    /** The Environment the session names (`environment`, protocol 11). */
+    /** The Agent's environment the session runs on: its Agent's id (protocol 16). */
     environmentId: field("->>'environmentId'"),
+    /** The agent manifest the session pinned a version of (protocol 16). */
+    manifestName: field("->'definition'->>'name'"),
 }, (t) => [
     index("sessions_created").on(t.createdAt.desc().nullsLast(), t.id.desc().nullsFirst()),
     index("sessions_status").on(t.status, t.ownerExpiresAt),
     index("sessions_agent").on(t.agentId),
     index("sessions_owner_user").on(t.ownerUserId),
     index("sessions_environment").on(t.environmentId),
+    index("sessions_manifest").on(t.manifestName),
 ]);
 export const commands = documents("commands");
 export const effects = nylorun.table("effects", {
@@ -108,13 +110,15 @@ export const principals = nylorun.table("principals", {
     createdAt: text().notNull(),
 });
 /**
- * An Environment (D55, protocol 11): its id, kind, labels, the recipe the app asked for and the
- * recipe its compute runs (`applied`, copied from `recipe` when a stopped pod is asked to run),
+ * An Agent (protocol 16; an Environment from protocol 11): the live instance of one version of an
+ * agent manifest, with its id, kind, labels, the recipe its environment runs (its manifest
+ * version's runtime section resolved, `recipe`, and what the current compute runs, `applied`),
  * the owner guard, and when it was last used. Kind `pod` adds the pod's lifecycle columns.
- * Sessions name it by id (the session body's `environmentId`). Not the `sandboxes` document
- * table, which holds the virtual backend's compute records, keyed by workspace key.
+ * Sessions name it by id (the session body's `agentId`, and `environmentId` for its environment).
+ * Not the `sandboxes` document table, which holds the virtual backend's compute records, keyed by
+ * workspace key.
  */
-export const environments = nylorun.table("environments", {
+export const agents = nylorun.table("agents", {
     id: textC().primaryKey(),
     kind: text({ enum: ["virtual", "pod", "none"] }).notNull(),
     /** `{ key: value }`, filtered through `nylorun.doc(labels)`. */
@@ -179,34 +183,150 @@ export const environments = nylorun.table("environments", {
      */
     diskSeed: jsonText(),
     /**
-     * The environment manifest it was made from and its version (D63): null for an Environment
-     * made from an inline manifest. Never changed after creation.
+     * The agent manifest it was made from and the version of it that it runs (track T3 moves it:
+     * `PUT /v1/agents/{id}`, and a save of the manifest for a tracking one).
      */
-    manifestName: textC(),
-    manifestVersion: integer(),
-    /** The hash of what it runs (`recipe`), from creation on. */
-    manifestHash: textC(),
-    /** The Environment it was forked from: `{ environment, disk }` (Q15). Never changed. */
+    manifestName: textC().notNull(),
+    manifestVersion: integer().notNull(),
+    /** How it names the manifest: `tracking` (`name`) or `pinned` (`name@n`). */
+    manifestRef: text({ enum: ["tracking", "pinned"] }).notNull(),
+    /** The hash of the manifest version it runs. */
+    manifestHash: textC().notNull(),
+    /** `on`, or `off` once paused (track T6); nothing sets `off` yet. */
+    desiredState: text({ enum: ["on", "off"] }).notNull().default("on"),
+    /** The Agent it was forked from: `{ agent, disk }` (Q15). Never changed. */
     forkedFrom: jsonText(),
+    /**
+     * The manifest version it is moving to while it is outdated (track T3, D73): it waits for its
+     * required secrets, or for its pod's next start. `manifestVersion` stays the one it runs.
+     */
+    targetVersion: integer(),
+    /** A version that failed to start (T3): a tracking Agent does not move to it again on its own. */
+    failedVersion: integer(),
+    /**
+     * While a pod starts on a new version (T3): `{ from, startedAt }`, what it ran before, which a
+     * failed start reverts to. Cleared when the new pod's harness joins.
+     */
+    startCheck: jsonText(),
+}, (t) => [
+    check("agents_kind_check", sql `${t.kind} IN ('virtual', 'pod', 'none')`),
+    index("agents_manifest").on(t.manifestName, t.manifestVersion),
+]);
+/**
+ * An Agent's triggers (track T4, D74): what its manifest's `runtime.triggers` declares is the
+ * manifest's; whether each one is on and when it fires next is the Agent's, here. A booked wake
+ * (D77) is a row of kind `wake` with id `wake:<sessionId>`. Postgres holds the truth: one
+ * durable timer per active trigger is armed from `nextFireAt`, and the sweep re-arms an overdue
+ * one, so the execution's timers can be rebuilt from these rows.
+ */
+export const agentTriggers = nylorun.table("agent_triggers", {
+    agentId: textC().notNull(),
+    triggerId: textC().notNull(),
+    kind: text({ enum: ["schedule", "at", "webhook", "wake"] }).notNull(),
+    status: text({ enum: ["active", "paused", "completed"] }).notNull(),
+    /** `manual`, or `new` for a trigger an upgrade added. */
+    pausedReason: text(),
+    /** Bumped when its timing changes, so a timer armed for an older time does nothing. */
+    generation: integer().notNull().default(0),
+    /** When it fires next (ISO), while active; a schedule's includes its jitter. */
+    nextFireAt: textC(),
+    lastFireAt: textC(),
+    /** A webhook trigger's endpoint id (`wh_…`), kept across upgrades. */
+    endpointId: textC(),
+    /**
+     * A webhook trigger's signing secret, sealed with the Tenant's vault key: only the keys service
+     * opens it, to verify a delivery (D75).
+     */
+    sealedSecret: jsonText(),
+    /** A booked wake's session, its note and the effect that booked it. */
+    sessionId: textC(),
+    note: text(),
+    effectId: text(),
+    createdAt: textC().notNull(),
+    updatedAt: textC().notNull(),
 }, (t) => [
-    check("environments_kind_check", sql `${t.kind} IN ('virtual', 'pod', 'none')`),
-    index("environments_manifest").on(t.manifestName, t.manifestVersion),
+    primaryKey({ name: "agent_triggers_pkey", columns: [t.agentId, t.triggerId] }),
+    index("agent_triggers_due").on(t.status, t.nextFireAt),
+    uniqueIndex("agent_triggers_endpoint").on(t.endpointId).where(sql `endpoint_id IS NOT NULL`),
 ]);
 /**
- * An environment manifest's versions (D63): a named, versioned definition of a kind of
- * Environment, saved like an agent. A version is written once and never changed; a save whose
- * body hashes the same as the latest writes nothing.
+ * An Agent's memories (track T5, D72): one row per Markdown file under `/memories`, its content
+ * inline (the Runtime limit `memoryBytes`, 100 KiB by default, bounds it). `version` counts the
+ * changes to this path; `description` is its frontmatter's, for the pinned index. A write locks the
+ * one row it changes, so writes to different memories never wait on each other.
+ */
+export const memories = nylorun.table("memories", {
+    agentId: textC().notNull(),
+    path: textC().notNull(),
+    content: text().notNull(),
+    contentSha256: text().notNull(),
+    bytes: integer().notNull(),
+    description: text(),
+    version: integer().notNull(),
+    updatedAt: textC().notNull(),
+}, (t) => [primaryKey({ name: "memories_pkey", columns: [t.agentId, t.path] })]);
+/**
+ * One row per change to an Agent's memories (D72): what changed it, the content it left (`null`
+ * for a delete), and who made it, with the session, turn and trigger run of a turn's write.
+ * Versions belong to the Agent, so they outlive a deleted memory; they go with the Agent. Ids
+ * increase with time (`newMemoryVersionId`), so they page newest first.
  */
-export const environmentManifests = nylorun.table("environment_manifests", {
+export const memoryVersions = nylorun.table("memory_versions", {
+    id: textC().primaryKey(),
+    agentId: textC().notNull(),
+    path: textC().notNull(),
+    /** A rename's old path. */
+    fromPath: textC(),
+    operation: text({ enum: ["create", "str_replace", "insert", "delete", "rename"] }).notNull(),
+    content: text(),
+    contentSha256: text(),
+    bytes: integer(),
+    actor: text().notNull(),
+    sessionId: textC(),
+    turnId: textC(),
+    triggerRunId: textC(),
+    createdAt: textC().notNull(),
+}, (t) => [index("memory_versions_agent").on(t.agentId, t.id), index("memory_versions_path").on(t.agentId, t.path, t.id)]);
+/**
+ * Each run of an Agent's triggers (D74): one per fire, delivery or run by hand, keyed by what
+ * caused it (`runKey`: `fire:<trigger>:<due ms>`, `webhook:<trigger>:<delivery id>`,
+ * `manual:<trigger>:<idempotency key>`), so a repeated cause makes no second run. Kept for the
+ * Runtime limit `triggerRunRetentionMs`.
+ */
+export const triggerRuns = nylorun.table("trigger_runs", {
+    id: textC().primaryKey(),
+    agentId: textC().notNull(),
+    triggerId: textC().notNull(),
+    kind: text({ enum: ["schedule", "at", "webhook", "wake"] }).notNull(),
+    runKey: textC().notNull(),
+    dueAt: textC().notNull(),
+    firedAt: textC().notNull(),
+    late: boolean().notNull().default(false),
+    status: text({ enum: ["started", "queued", "skipped", "failed"] }).notNull(),
+    reason: text(),
+    sessionId: textC(),
+    turnId: textC(),
+    queuedMessageId: textC(),
+}, (t) => [
+    uniqueIndex("trigger_runs_key").on(t.agentId, t.runKey),
+    index("trigger_runs_agent").on(t.agentId, t.id),
+    index("trigger_runs_fired").on(t.firedAt),
+]);
+/**
+ * An agent manifest's versions (protocol 16): a named, versioned document with a harness and a
+ * runtime section. A version is written once and never changed; a save whose body hashes the
+ * same as the latest writes nothing.
+ */
+export const agentManifests = nylorun.table("agent_manifests", {
     name: textC().notNull(),
     version: integer().notNull(),
-    /** The manifest (`EnvironmentManifest`) as saved. */
+    /** The manifest (`AgentManifestV8`) as saved. */
     body: jsonText().notNull(),
     hash: textC().notNull(),
     /** `{ actor }`: the subject the save acted for, else `application`. */
     savedBy: jsonText().notNull(),
     createdAt: textC().notNull(),
-}, (t) => [primaryKey({ name: "environment_manifests_pkey", columns: [t.name, t.version] })]);
+}, (t) => [primaryKey({ name: "agent_manifests_pkey", columns: [t.name, t.version] })]);
 /**
  * A vault (D56): the host model's (`id = 'host'`), or one Environment's, created and deleted with
  * it (`environment_id`, unique, deleted with the Environment's row). No other vault exists.
@@ -217,14 +337,14 @@ export const vaults = nylorun.table("vaults", {
     /** JSON text, or null. */
     metadataJson: text(),
     createdAt: textC().notNull(),
-    /** The Environment the vault belongs to; null only for the host vault. */
+    /** The Agent the vault belongs to; null only for the host vault. */
     environmentId: textC(),
 }, (t) => [
     uniqueIndex("vaults_environment").on(t.environmentId),
     foreignKey({
         name: "vaults_environment_id_fkey",
         columns: [t.environmentId],
-        foreignColumns: [environments.id],
+        foreignColumns: [agents.id],
     }).onDelete("cascade"),
     check("vaults_owner_check", sql `(${t.id} = 'host') = (${t.environmentId} IS NULL)`),
 ]);
@@ -305,7 +425,8 @@ export const signingKeys = nylorun.table("signing_keys", {
  * flagged `duplicate`; both were billed. Budgets read their spend from it. Token counts are 0
  * when the provider sent none. `startedAt`, `endedAt` and `firstTokenMs` are the gate's own
  * timing of the call (R7.1, migration 0022); null on rows written before, and `firstTokenMs`
- * when the provider streamed nothing.
+ * when the provider streamed nothing. The `cost*Usd` columns split `costUsd` by token kind, at the
+ * prices the adapter applied (migration 0037); null on rows written before.
  */
 export const modelUsage = nylorun.table("model_usage", {
     id: textC().primaryKey(),
@@ -316,7 +437,11 @@ export const modelUsage = nylorun.table("model_usage", {
     txid: xid8().notNull().default(sql `pg_current_xact_id()`),
     sessionId: textC().notNull(),
     turnId: textC().notNull(),
-    agentId: textC().notNull(),
+    /**
+     * The agent manifest the call's agent came from: the loop manifest's id, a version's name
+     * (protocol 16; the definition id before, under `agent_id`).
+     */
+    manifestName: textC().notNull(),
     provider: text(),
     model: text(),
     inputTokens: integer().notNull(),
@@ -335,27 +460,58 @@ export const modelUsage = nylorun.table("model_usage", {
     endedAt: text(),
     /** From `startedAt` to the provider's first stream event. */
     firstTokenMs: integer(),
+    /** What the uncached input cost. */
+    costInputUsd: doublePrecision(),
+    /** What the input read from the provider's cache cost. */
+    costCacheReadUsd: doublePrecision(),
+    /** What the input written to the provider's cache cost. */
+    costCacheWriteUsd: doublePrecision(),
+    /** What the output cost. */
+    costOutputUsd: doublePrecision(),
 }, (t) => [
     index("model_usage_session").on(t.sessionId, t.createdAt, t.id),
     index("model_usage_export").on(t.txid, t.id),
     index("model_usage_effect").on(t.effectKey),
-    index("model_usage_agent").on(t.agentId, t.createdAt),
+    index("model_usage_manifest").on(t.manifestName, t.createdAt),
     index("model_usage_turn").on(t.turnId),
     index("model_usage_created").on(t.createdAt),
 ]);
 /**
  * Model budgets (P1.3): hard caps the model gate checks before each call, at least one limit
- * set. One row per scope: `turn` and `tenant` use `*`, `agent` the agent id. `period` is the
+ * set. One row per scope: `turn` and `tenant` use `*`, `manifest` the agent manifest's name. `period` is the
  * UTC `day` or `month` the spend is counted over, or null for `turn`.
  */
 export const modelBudgets = nylorun.table("model_budgets", {
-    scope: text({ enum: ["tenant", "agent", "turn"] }).notNull(),
+    scope: text({ enum: ["tenant", "manifest", "turn"] }).notNull(),
     scopeId: textC().notNull(),
     period: text({ enum: ["day", "month"] }),
     limitUsd: doublePrecision(),
     limitTokens: bigint({ mode: "number" }),
     updatedAt: text().notNull(),
 }, (t) => [primaryKey({ name: "model_budgets_pkey", columns: [t.scope, t.scopeId] })]);
+/**
+ * Each session's queue (protocol 17, D76): messages that arrived while its turn ran or waited, in
+ * order (`seq`), until a turn takes them. A row holds the command as sent, the turn input its
+ * message gives the engine (file parts pinned when it was queued), and who sent it.
+ */
+export const sessionQueue = nylorun.table("session_queue", {
+    id: textC().primaryKey(),
+    sessionId: textC().notNull(),
+    seq: bigint({ mode: "number" }).notNull(),
+    /** The `message` command as sent (`command.message`'s payload when a turn takes it). */
+    command: jsonText().notNull(),
+    /** The engine's input for it: an agent's message input, or a workflow's input value. */
+    input: jsonText().notNull(),
+    /** The artifacts its file parts named, which the session may read again. */
+    fileArtifacts: jsonText().notNull(),
+    /** Who sent it (`EventWriter`). */
+    writer: jsonText().notNull(),
+    /** The W3C trace context it was sent with. */
+    trace: jsonText(),
+    /** What sent it when not a client (track T4): a trigger's run, or the session's own wake. */
+    cause: jsonText(),
+    createdAt: textC().notNull(),
+}, (t) => [uniqueIndex("session_queue_order").on(t.sessionId, t.seq)]);
 /**
  * The Tool Gate's keyed MCP calls (F4.1 G3): one row per call, written by the gates service
  * before it calls the server and given the answer after. A re-send whose row has an answer
@@ -390,7 +546,7 @@ export const artifacts = nylorun.table("artifacts", {
     labelsJson: text(),
     createdAt: textC().notNull(),
     updatedAt: text().notNull(),
-    /** The Environment whose disk versions this folder holds (R2d step 3); one per Environment. */
+    /** The Agent whose disk versions this folder holds (R2d step 3); one per Agent. */
     environmentId: textC(),
 }, (t) => [
     index("artifacts_session").on(t.sessionId, t.createdAt, t.id),
@@ -459,9 +615,9 @@ export const definitionFiles = nylorun.table("definition_files", {
     createdAt: textC().notNull(),
 });
 /**
- * Which definition version names which definition file: one row per agent id, manifest hash
- * and file, written when the definition is stored. A later sweep deletes the files no
- * definition uses.
+ * Which agent manifest version names which definition file: one row per owner
+ * (`agent-manifest:<name>`), manifest hash and file, written when the version is saved. A later
+ * sweep deletes the files no version uses.
  */
 export const definitionFileUses = nylorun.table("definition_file_uses", {
     agentId: textC().notNull(),
@@ -541,16 +697,16 @@ export const sandboxSignals = nylorun.table("sandbox_signals", {
 // ---------------------------------------------------------------------------
 // nylorun_streams: the record
 /**
- * Each Environment's lifecycle stream (`nylorun.environment-event/1`), numbered from 0 per
- * Environment id. Written only by the record module; not published to the stream relay.
+ * Each Agent's lifecycle stream (`nylorun.agent-event/1`), numbered from 0 per Agent id. Written
+ * only by the record module; not published to the stream relay.
  */
-export const environmentEvents = nylorunStreams.table("environment_events", {
-    environmentId: textC().notNull(),
+export const agentEvents = nylorunStreams.table("agent_events", {
+    agentId: textC().notNull(),
     seq: bigint({ mode: "number" }).notNull(),
     type: text().notNull(),
     body: jsonText().notNull(),
     committedAt: timestamp({ withTimezone: true, mode: "string" }).notNull().defaultNow(),
-}, (t) => [primaryKey({ name: "environment_events_pkey", columns: [t.environmentId, t.seq] })]);
+}, (t) => [primaryKey({ name: "agent_events_pkey", columns: [t.agentId, t.seq] })]);
 /** Each session's log head: the next seq and the basin generation its events go to. */
 export const sessionLogHeads = nylorunStreams.table("session_log_heads", {
     sessionId: textC().primaryKey(),