@nylorun/runtime 0.40.0-beta → 0.41.0-beta

package/dist/store/postgres/drizzle/0043_agent_triggers_origin.sql

@@ -0,0 +1,11 @@
+ALTER TABLE "nylorun"."agent_triggers" ADD COLUMN "origin" text DEFAULT 'manifest' NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."agent_triggers" ADD COLUMN "title" text;--> statement-breakpoint
+ALTER TABLE "nylorun"."agent_triggers" ADD COLUMN "definition" json;--> statement-breakpoint
+ALTER TABLE "nylorun"."agent_triggers" ADD COLUMN "created_session_id" text COLLATE "C";--> statement-breakpoint
+ALTER TABLE "nylorun"."agent_triggers" ADD COLUMN "created_turn_id" text COLLATE "C";--> statement-breakpoint
+ALTER TABLE "nylorun"."trigger_runs" ADD COLUMN "origin" text DEFAULT 'manifest' NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."trigger_runs" ADD COLUMN "title" text;--> statement-breakpoint
+ALTER TABLE "nylorun"."trigger_runs" ADD COLUMN "streamed_at" text COLLATE "C";--> statement-breakpoint
+CREATE INDEX "agent_triggers_created_session" ON "nylorun"."agent_triggers" USING btree ("agent_id","created_session_id") WHERE created_session_id IS NOT NULL;--> statement-breakpoint
+CREATE INDEX "trigger_runs_unstreamed" ON "nylorun"."trigger_runs" USING btree ("fired_at") WHERE streamed_at IS NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."agent_triggers" ADD CONSTRAINT "agent_triggers_origin_check" CHECK ("nylorun"."agent_triggers"."origin" IN ('manifest', 'agent', 'wake'));

package/dist/store/postgres/drizzle/0044_agent_triggers_origin_backfill.sql

@@ -0,0 +1,8 @@
+-- Custom SQL (a data change): the origin of the trigger rows and runs written before 0043 (D83). A
+-- booked wake's is `wake`; every other came from its manifest (`manifest`, the columns' default).
+-- Runs recorded before the Tenant runs stream are marked streamed, so the sweep does not append
+-- the history of the last 30 days to the new `runs` stream: it starts with the runs made from here
+-- on.
+UPDATE "nylorun"."agent_triggers" SET "origin" = 'wake' WHERE "kind" = 'wake';--> statement-breakpoint
+UPDATE "nylorun"."trigger_runs" SET "origin" = 'wake' WHERE "kind" = 'wake';--> statement-breakpoint
+UPDATE "nylorun"."trigger_runs" SET "streamed_at" = "fired_at" WHERE "streamed_at" IS NULL;

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

@@ -302,6 +302,20 @@
       "when": 1793509192153,
       "tag": "0042_worker_engine_image",
       "breakpoints": true
+    },
+    {
+      "idx": 43,
+      "version": "7",
+      "when": 1793548856412,
+      "tag": "0043_agent_triggers_origin",
+      "breakpoints": true
+    },
+    {
+      "idx": 44,
+      "version": "7",
+      "when": 1793548858191,
+      "tag": "0044_agent_triggers_origin_backfill",
+      "breakpoints": true
     }
   ]
 }

package/dist/store/postgres/schema.d.ts

@@ -1526,9 +1526,11 @@ export declare const agents: import("drizzle-orm/pg-core").PgTableWithColumns<{
 /**
  * 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.
+ * (D77) is a row of kind `wake` with id `wake:<sessionId>`. A trigger an agent made with the
+ * `triggers` tool (D83) is a row of origin `agent`, its definition (a `Trigger`, as a manifest
+ * entry holds it) and title on the row, with the session and turn that made it. 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 declare const agentTriggers: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "agent_triggers";
@@ -1769,6 +1771,97 @@ export declare const agentTriggers: import("drizzle-orm/pg-core").PgTableWithCol
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        origin: import("drizzle-orm/pg-core").PgColumn<{
+            name: "origin";
+            tableName: "agent_triggers";
+            dataType: "string";
+            columnType: "PgText";
+            data: "agent" | "manifest" | "wake";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["manifest", "agent", "wake"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        title: import("drizzle-orm/pg-core").PgColumn<{
+            name: "title";
+            tableName: "agent_triggers";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        definition: import("drizzle-orm/pg-core").PgColumn<{
+            name: "definition";
+            tableName: "agent_triggers";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
+        createdSessionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdSessionId";
+            tableName: "agent_triggers";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
+        createdTurnId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdTurnId";
+            tableName: "agent_triggers";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
         createdAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "createdAt";
             tableName: "agent_triggers";
@@ -2219,7 +2312,8 @@ export declare const memoryVersions: import("drizzle-orm/pg-core").PgTableWithCo
  * 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`.
+ * Runtime limit `triggerRunRetentionMs`. `streamedAt` is the Tenant runs stream's outbox (D83):
+ * set once the run is in the `runs` stream; the sweep appends a run still unset.
  */
 export declare const triggerRuns: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "trigger_runs";
@@ -2464,6 +2558,59 @@ export declare const triggerRuns: import("drizzle-orm/pg-core").PgTableWithColum
         }, {}, {
             pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
         }>;
+        origin: import("drizzle-orm/pg-core").PgColumn<{
+            name: "origin";
+            tableName: "trigger_runs";
+            dataType: "string";
+            columnType: "PgText";
+            data: "agent" | "manifest" | "wake";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["manifest", "agent", "wake"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        title: import("drizzle-orm/pg-core").PgColumn<{
+            name: "title";
+            tableName: "trigger_runs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        streamedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "streamedAt";
+            tableName: "trigger_runs";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
     };
     dialect: 'pg';
 }>;

package/dist/store/postgres/schema.js

@@ -217,9 +217,11 @@ export const agents = nylorun.table("agents", {
 /**
  * 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.
+ * (D77) is a row of kind `wake` with id `wake:<sessionId>`. A trigger an agent made with the
+ * `triggers` tool (D83) is a row of origin `agent`, its definition (a `Trigger`, as a manifest
+ * entry holds it) and title on the row, with the session and turn that made it. 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(),
@@ -244,10 +246,22 @@ export const agentTriggers = nylorun.table("agent_triggers", {
     sessionId: textC(),
     note: text(),
     effectId: text(),
+    /**
+     * Where its definition comes from (D83): `manifest` (the version's `runtime.triggers`),
+     * `agent` (`definition`, made with the `triggers` tool) or `wake` (a booked wake).
+     */
+    origin: text({ enum: ["manifest", "agent", "wake"] }).notNull().default("manifest"),
+    /** An agent-made trigger's title, its definition, and the session and turn that made it. */
+    title: text(),
+    definition: jsonText(),
+    createdSessionId: textC(),
+    createdTurnId: textC(),
     createdAt: textC().notNull(),
     updatedAt: textC().notNull(),
 }, (t) => [
+    check("agent_triggers_origin_check", sql `${t.origin} IN ('manifest', 'agent', 'wake')`),
     primaryKey({ name: "agent_triggers_pkey", columns: [t.agentId, t.triggerId] }),
+    index("agent_triggers_created_session").on(t.agentId, t.createdSessionId).where(sql `created_session_id IS NOT NULL`),
     index("agent_triggers_due").on(t.status, t.nextFireAt),
     uniqueIndex("agent_triggers_endpoint").on(t.endpointId).where(sql `endpoint_id IS NOT NULL`),
 ]);
@@ -293,7 +307,8 @@ export const memoryVersions = nylorun.table("memory_versions", {
  * 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`.
+ * Runtime limit `triggerRunRetentionMs`. `streamedAt` is the Tenant runs stream's outbox (D83):
+ * set once the run is in the `runs` stream; the sweep appends a run still unset.
  */
 export const triggerRuns = nylorun.table("trigger_runs", {
     id: textC().primaryKey(),
@@ -309,10 +324,16 @@ export const triggerRuns = nylorun.table("trigger_runs", {
     sessionId: textC(),
     turnId: textC(),
     queuedMessageId: textC(),
+    /** Its trigger's origin and title when it ran (D83), for the runs stream after the trigger is gone. */
+    origin: text({ enum: ["manifest", "agent", "wake"] }).notNull().default("manifest"),
+    title: text(),
+    /** When it was appended to the Tenant's `runs` stream (ISO), or null until then. */
+    streamedAt: 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),
+    index("trigger_runs_unstreamed").on(t.firedAt).where(sql `streamed_at IS NULL`),
 ]);
 /**
  * An agent manifest's versions (protocol 16): a named, versioned document with a harness and a

package/dist/store/postgres/store.js

@@ -1345,6 +1345,24 @@ class PostgresTx {
             .returning({ id: triggerRuns.id });
         return inserted.length === 1;
     }
+    async unstreamedTriggerRuns(options) {
+        this.check();
+        return this.db
+            .select()
+            .from(triggerRuns)
+            .where(and(isNull(triggerRuns.streamedAt), lt(triggerRuns.firedAt, options.firedBefore)))
+            .orderBy(triggerRuns.firedAt, triggerRuns.id)
+            .limit(options.limit);
+    }
+    async markTriggerRunsStreamed(ids, at) {
+        this.check();
+        if (ids.length === 0)
+            return;
+        await this.db
+            .update(triggerRuns)
+            .set({ streamedAt: at })
+            .where(and(inArray(triggerRuns.id, [...ids]), isNull(triggerRuns.streamedAt)));
+    }
     async triggerRunByKey(agentId, runKey) {
         this.check();
         const [row] = await this.db
@@ -1763,8 +1781,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"));
+            // A session's booked wake (T4) goes with it, and the triggers its agents made (D83).
+            await db.delete(agentTriggers).where(or(eq(agentTriggers.kind, "wake"), inArray(agentTriggers.origin, ["wake", "agent"])));
             await db.delete(toolCrossings);
             // A session's artifacts go with it (their versions by cascade).
             await db.delete(artifacts).where(isNotNull(artifacts.sessionId));

package/dist/store/types.d.ts

@@ -776,6 +776,16 @@ export interface Tx {
     }): Promise<TriggerRunRow[]>;
     /** Deletes runs fired before `before`; returns how many. */
     pruneTriggerRuns(before: string): Promise<number>;
+    /**
+     * Runs of every Agent not yet on the Tenant's runs stream (D83), fired before `firedBefore`,
+     * oldest first.
+     */
+    unstreamedTriggerRuns(options: {
+        firedBefore: string;
+        limit: number;
+    }): Promise<TriggerRunRow[]>;
+    /** Marks runs as on the runs stream, at `at`; one already marked keeps its time. */
+    markTriggerRunsStreamed(ids: readonly string[], at: string): Promise<void>;
     /** One memory; with `lock`, its path is locked until the transaction ends, whether or not a row has it. */
     memory(agentId: string, path: string, options?: {
         lock?: boolean;

package/dist/streams/types.d.ts

@@ -7,6 +7,7 @@
  * | Stream | Contents | Written by | Read by |
  * | --- | --- | --- | --- |
  * | `sessions/<sessionId>` | every event of the session, in sequence | the stream relay, from the record | history and session SSE |
+| `runs` | every run of the Tenant's triggers (D83), kept 7 days | `tenant/runs-stream.ts`, after the commit that made the run, and the sweep | `GET /v1/runs/stream` |
  *
  * S2 serves API listeners only (history, SSE, AG-UI, A2A): nothing inside the Runtime signals
  * through it or waits on it (D48). Signals between processes go over the control bus on
@@ -15,7 +16,9 @@
  * **Basin generations.** A session id is unique within its Tenant's basin generation. A
  * Tenant reset, the only path that frees ids, moves the Tenant to the next generation, so
  * a session created again with the same id starts in an empty basin at sequence 0; the old
- * basin is deleted afterwards. The cursor is `base64url("<sessionId>:<seq>")`.
+ * basin is deleted afterwards. The cursor is `base64url("<sessionId>:<seq>")`. The `runs`
+ * stream starts at 0 in each generation too; its cursor names the generation
+ * (`base64url("runs:<generation>:<seq>")`), so one from an older basin is refused.
  *
  * S2 is the supported implementation (`adapters/streams/s2.ts`, the only file
  * importing the S2 SDK); `streams/memory.ts` is the in-memory fake.
@@ -100,6 +103,14 @@ export interface DurableStreams {
     }): Promise<void>;
     /** Deletes one stream. Idempotent. */
     deleteStream(tenantId: string, stream: string): Promise<void>;
+    /**
+     * Creates `stream` if it does not exist, or sets its configuration, keeping its records for
+     * `retentionSecs` (the basin's default keeps them forever). Absent for in-process
+     * implementations, which keep what they hold until they close.
+     */
+    ensureStream?(tenantId: string, stream: string, options: {
+        retentionSecs: number;
+    }): Promise<void>;
     /**
      * Names of the Tenant's streams starting with `prefix`, in name order,
      * without streams being deleted. Empty when the Tenant has no basin.
@@ -114,5 +125,9 @@ export interface DurableStreams {
     probe?(signal: AbortSignal): Promise<void>;
 }
 export declare const SESSION_STREAM_PREFIX = "sessions/";
+/** The Tenant's runs stream (D83): every run of its triggers, beside the session streams. */
+export declare const RUNS_STREAM = "runs";
+/** How long the runs stream keeps a run: 7 days. */
+export declare const RUNS_STREAM_RETENTION_SECS: number;
 /** The stream of a session: `sessions/<sessionId>`. */
 export declare function sessionStream(sessionId: string): string;

package/dist/streams/types.js

@@ -7,6 +7,7 @@
  * | Stream | Contents | Written by | Read by |
  * | --- | --- | --- | --- |
  * | `sessions/<sessionId>` | every event of the session, in sequence | the stream relay, from the record | history and session SSE |
+| `runs` | every run of the Tenant's triggers (D83), kept 7 days | `tenant/runs-stream.ts`, after the commit that made the run, and the sweep | `GET /v1/runs/stream` |
  *
  * S2 serves API listeners only (history, SSE, AG-UI, A2A): nothing inside the Runtime signals
  * through it or waits on it (D48). Signals between processes go over the control bus on
@@ -15,7 +16,9 @@
  * **Basin generations.** A session id is unique within its Tenant's basin generation. A
  * Tenant reset, the only path that frees ids, moves the Tenant to the next generation, so
  * a session created again with the same id starts in an empty basin at sequence 0; the old
- * basin is deleted afterwards. The cursor is `base64url("<sessionId>:<seq>")`.
+ * basin is deleted afterwards. The cursor is `base64url("<sessionId>:<seq>")`. The `runs`
+ * stream starts at 0 in each generation too; its cursor names the generation
+ * (`base64url("runs:<generation>:<seq>")`), so one from an older basin is refused.
  *
  * S2 is the supported implementation (`adapters/streams/s2.ts`, the only file
  * importing the S2 SDK); `streams/memory.ts` is the in-memory fake.
@@ -44,6 +47,10 @@
 // ---------------------------------------------------------------------------
 // Stream names
 export const SESSION_STREAM_PREFIX = "sessions/";
+/** The Tenant's runs stream (D83): every run of its triggers, beside the session streams. */
+export const RUNS_STREAM = "runs";
+/** How long the runs stream keeps a run: 7 days. */
+export const RUNS_STREAM_RETENTION_SECS = 7 * 24 * 3600;
 /** The stream of a session: `sessions/<sessionId>`. */
 export function sessionStream(sessionId) {
     if (!sessionId)

package/dist/tenant/advance.js

@@ -621,6 +621,13 @@ async function heldCalls(t, effectIds) {
                 ...(row.server === undefined ? {} : { server: row.server }),
                 ...(row.tool === undefined ? {} : { tool: row.tool }),
                 input: request.input ?? null,
+                // What a client renders the approval from (D83): the tool's identity and the call's input.
+                metadata: {
+                    tool: row.tool ?? toolName,
+                    ...(row.toolKind === undefined ? {} : { kind: row.toolKind }),
+                    ...(row.server === undefined ? {} : { server: row.server }),
+                    input: request.input ?? null,
+                },
             },
             status: "interaction",
             toolName,

package/dist/tenant/agent-triggers.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The `triggers` tool (D83): an agent whose version declares `harness.engine.triggers` lists,
+ * creates and deletes its own triggers. The Runtime serves each call as a `runtime` effect
+ * (operation `triggers`), in the call's own transaction, keyed by the effect id, so a replayed turn
+ * changes nothing twice (`harness-api/record.ts`). The Tenant's tool policy decides it first (a
+ * rule of `kind: "runtime"`, `tool: "triggers"`), so an `ask` rule can hold a create for a person.
+ *
+ * A trigger an agent makes is a row of `agent_triggers` with origin `agent`: its definition (a
+ * `Trigger`, as a manifest entry holds it) and title on the row, with the session and turn that
+ * made it. It fires through `fireTimer` and `deliverRun` like a manifest's (`triggers.ts`), and an
+ * upgrade never touches it.
+ *
+ * - **Where it runs.** `session: "this"` runs it in the calling session (a follow-up); `"own"` in
+ *   a session named from the calling one, `<session>_t_<id>`, opened at its first run and kept.
+ * - **Scope.** A session lists and deletes the triggers made from it, and a trigger's own session
+ *   may list and delete it too. Creating with an id the session's trigger has replaces it; an id
+ *   another session's trigger, a manifest's or a wake holds is `tool.conflict`.
+ * - **Runs can't multiply.** A turn a trigger or a booked wake started may list and delete, never
+ *   create.
+ * - **Checks.** Every create runs the checks a manifest save runs (`triggerIssues`): cron and
+ *   zone, the minimum interval, `at` in the future, the prompt's length; and the count of the
+ *   Agent's agent-made triggers. Each against the limits in force: the manifest's
+ *   `runtime.limits.triggers` within the Tenant's (`triggerLimitsInForce`).
+ * - **Arming.** No I/O in the transaction: the call returns the rows to arm, which the record arms
+ *   after its commit; the sweep's reconcile arms any it missed.
+ */
+import { type TriggerToolOutput } from "@nylorun/core/contracts";
+import type { AgentTriggerRow, Tx } from "../store/types.js";
+import type { Session } from "./context.js";
+/** What a served call settles as, and the rows to arm once its transaction commits. */
+export interface ServedTriggers {
+    readonly outcome: {
+        kind: "completed";
+        output: TriggerToolOutput;
+    } | {
+        kind: "failed";
+        code: string;
+        message: string;
+    };
+    readonly arm: readonly AgentTriggerRow[];
+}
+/** The session an agent-made trigger runs in: the calling one, or its own, `<session>_t_<id>`. */
+export declare function triggerSessionOf(callingSessionId: string, id: string, session: "this" | "own"): string;
+/**
+ * Why session `s` cannot make `triggers` call `request` at all, before the Tenant's tool policy
+ * is asked (off means off, ADR-100): its version does not declare `engine.triggers`
+ * (`tool.unavailable`), or an agent used as a tool made it (`tool.forbidden`). Undefined when it can.
+ */
+export declare function triggersRefusal(t: Tx, s: Session, request: {
+    agent?: unknown;
+}): Promise<ServedTriggers["outcome"] | undefined>;
+/**
+ * Serves one `triggers` call of session `s`'s active turn in `t` (see the module comment). The
+ * call's `agent` is the agent used as a tool that made it, absent for the root agent.
+ */
+export declare function serveTriggersTool(t: Tx, s: Session, request: {
+    effectId: string;
+    input?: unknown;
+    agent?: unknown;
+}): Promise<ServedTriggers>;