@nylorun/runtime 0.51.2-beta → 0.53.0-beta

package/dist/sandbox/computer.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Computers in core (ADR-149, ADR-150): a pod Agent on an Agent Substrate cluster whose sandboxes
+ * service renders computers (`NYLORUN_SANDBOX_GATEWAY_URL` set). Its engine runs no loop: its
+ * sessions' runs go to the harness container, and its commands and files go through the sandbox
+ * gateway with a ticket core signs here (`computer-ticket.key`, Ed25519; ADR-148).
+ *
+ * - `computerAccess` wakes the computer when it isn't running (as a turn start does), waits until
+ *   the sandboxes service says it is ready (its wake-up probe answered), records its first contact
+ *   (`agent.running` or `agent.relaunched`, the pod's UID for the lost check), and answers where it
+ *   is and a ticket. Core's own uses (the sandbox route, disk versions, artifacts) open it so.
+ * - `openComputer` is what a harness gets with `computer.open`: the same, once a seed being copied
+ *   onto a new volume is written (R2d step 3), with the disk's setup run through the computer when
+ *   its marker isn't the recipe's (R2d step 2; `prepareComputerDisk`), and a version's start check
+ *   passed (T3).
+ */
+import { type KeyObject } from "node:crypto";
+import type { TenantContext } from "../tenant/context.js";
+import { type ComputerAccess } from "../adapters/sandbox/computer.js";
+import { SandboxManager } from "./manager.js";
+import type { SandboxHandle } from "./types.js";
+/** How a Tenant reaches its computers. */
+export interface TenantComputers {
+    /** The sandbox gateway's base URL (`http://sandbox-gateway:4400`). */
+    readonly gatewayUrl: string;
+    /** The ticket key's private half. */
+    readonly ticketKey: KeyObject;
+    /** How long a ticket holds (10 minutes). */
+    readonly ttlMs: number;
+}
+export declare const TICKET_TTL_MS: number;
+/** Reads `NYLORUN_COMPUTER_TICKET_KEY_FILE`'s key (PKCS #8 PEM, Ed25519). */
+export declare function loadTicketKey(path: string): KeyObject;
+/** A computer ticket for sandbox `subject`, signed with `key`: a compact JWS (EdDSA). */
+export declare function signTicket(key: KeyObject, subject: string, expiresAt: number): string;
+/** Whether pod Environments of this Tenant are computers. */
+export declare function computersOf(ctx: Pick<TenantContext, "pods">): TenantComputers | undefined;
+/**
+ * Wakes computer `id` if needed, waits until it is ready, and answers where it is with a ticket.
+ * Refused for a lost, deleted or failed one.
+ */
+export declare function computerAccess(ctx: TenantContext, id: string, signal?: AbortSignal): Promise<ComputerAccess>;
+/**
+ * What `computer.open` answers a harness: access to computer `id`, once a seed is written, its
+ * setup ran, and a version's start check passed. Concurrent opens of one computer share one.
+ */
+export declare function openComputer(ctx: TenantContext, id: string, signal?: AbortSignal): Promise<ComputerAccess>;
+/** The disk's setup, run through the computer when its marker isn't the recipe's (R2d step 2). */
+export declare function prepareComputerDisk(ctx: TenantContext, id: string, handle: SandboxHandle, signal?: AbortSignal): Promise<void>;
+/**
+ * A SandboxManager per computer, for core's own uses: its backend opens the computer with
+ * `computerAccess` (no setup run: the harness's `computer.open` does that before a turn's tools).
+ */
+export declare function computerManagers(ctx: () => TenantContext, emit: ConstructorParameters<typeof SandboxManager>[0]["emit"]): (environmentId: string) => SandboxManager;

package/dist/sandbox/computer.js

@@ -0,0 +1,271 @@
+/**
+ * Computers in core (ADR-149, ADR-150): a pod Agent on an Agent Substrate cluster whose sandboxes
+ * service renders computers (`NYLORUN_SANDBOX_GATEWAY_URL` set). Its engine runs no loop: its
+ * sessions' runs go to the harness container, and its commands and files go through the sandbox
+ * gateway with a ticket core signs here (`computer-ticket.key`, Ed25519; ADR-148).
+ *
+ * - `computerAccess` wakes the computer when it isn't running (as a turn start does), waits until
+ *   the sandboxes service says it is ready (its wake-up probe answered), records its first contact
+ *   (`agent.running` or `agent.relaunched`, the pod's UID for the lost check), and answers where it
+ *   is and a ticket. Core's own uses (the sandbox route, disk versions, artifacts) open it so.
+ * - `openComputer` is what a harness gets with `computer.open`: the same, once a seed being copied
+ *   onto a new volume is written (R2d step 3), with the disk's setup run through the computer when
+ *   its marker isn't the recipe's (R2d step 2; `prepareComputerDisk`), and a version's start check
+ *   passed (T3).
+ */
+import { createPrivateKey, randomUUID, sign } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { posix } from "node:path";
+import { fail, failRetryLater } from "../tenant/http.js";
+import { wakePod } from "../tenant/agents.js";
+import { passStartCheck } from "../tenant/agent-versions.js";
+import { computerBackend } from "../adapters/sandbox/computer.js";
+import { SandboxManager } from "./manager.js";
+import { memorySandboxRecords } from "./records.js";
+import { recordSetup, setupFile, setupPlanOf } from "./setup.js";
+import { hostTuning } from "../tuning.js";
+export const TICKET_TTL_MS = 10 * 60_000;
+/** Reads `NYLORUN_COMPUTER_TICKET_KEY_FILE`'s key (PKCS #8 PEM, Ed25519). */
+export function loadTicketKey(path) {
+    const key = createPrivateKey(readFileSync(path, "utf8"));
+    if (key.asymmetricKeyType !== "ed25519")
+        throw new Error(`${path} is not an Ed25519 key`);
+    return key;
+}
+/** A computer ticket for sandbox `subject`, signed with `key`: a compact JWS (EdDSA). */
+export function signTicket(key, subject, expiresAt) {
+    const header = Buffer.from(JSON.stringify({ alg: "EdDSA", typ: "JWT" })).toString("base64url");
+    const body = Buffer.from(JSON.stringify({ aud: "nylorun-computer", sub: subject, exp: Math.floor(expiresAt / 1000) })).toString("base64url");
+    const signature = sign(null, Buffer.from(`${header}.${body}`), key).toString("base64url");
+    return `${header}.${body}.${signature}`;
+}
+/** Whether pod Environments of this Tenant are computers. */
+export function computersOf(ctx) {
+    return ctx.pods?.computer;
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Wakes computer `id` if needed, waits until it is ready, and answers where it is with a ticket.
+ * Refused for a lost, deleted or failed one.
+ */
+export async function computerAccess(ctx, id, signal) {
+    const computers = computersOf(ctx);
+    const pods = ctx.pods;
+    if (!computers || !pods)
+        return fail(409, `Agent ${id} is not a computer on this Runtime.`, { code: "agent_unavailable" });
+    await wakePod(ctx, id);
+    const deadline = Date.now() + hostTuning().pods.readyDeadlineMs;
+    for (;;) {
+        if (signal?.aborted)
+            throw signal.reason ?? new Error("Cancelled");
+        const environment = await ctx.store.tx((t) => t.environment(id));
+        const pod = environment?.pod;
+        if (!environment || !pod || pod.desired === "deleted")
+            return fail(404, `Agent ${id} does not exist.`, { code: "not_found" });
+        if (pod.observed === "lost")
+            return fail(409, `Agent ${id}'s computer was lost (${pod.reason ?? "its volume is gone"}). Reset it.`, { code: "agent_lost" });
+        if (pod.observed === "failed")
+            return fail(409, `Agent ${id}'s computer failed: ${pod.reason ?? "it did not start"}.`, { code: "agent_unavailable" });
+        const status = await pods.client.status(pod.k8sName, { wait: "ready", timeoutMs: 20_000 }).catch(() => undefined);
+        if (status?.ready && status.podUID) {
+            await firstContact(ctx, id, status.podUID);
+            const expiresAt = Date.now() + computers.ttlMs;
+            return {
+                url: `${computers.gatewayUrl}/${pod.k8sName}`,
+                ticket: signTicket(computers.ticketKey, pod.k8sName, expiresAt),
+                expiresAt,
+            };
+        }
+        if (Date.now() > deadline)
+            failRetryLater(`Agent ${id}'s computer was not ready within ${hostTuning().pods.readyDeadlineMs / 1000} s.`, "agent_unavailable");
+        // The reconcile moves the row along (creating → running); the next look waits on the service.
+        await ctx.sandboxSignal(id, { kind: "reconcile" }).catch(() => undefined);
+        await sleep(500);
+    }
+}
+/** Records the computer's first answer since it started: its UID, and `agent.running` or `agent.relaunched`. */
+async function firstContact(ctx, id, podUid) {
+    await ctx.store.tx(async (t) => {
+        const environment = await t.environment(id, { lock: true });
+        const pod = environment?.pod;
+        if (!pod || pod.podUid === podUid || pod.desired !== "running")
+            return;
+        const now = new Date().toISOString();
+        const epoch = pod.hostEpoch + 1;
+        await t.updateEnvironmentPod(id, { podUid, hostEpoch: epoch, observed: "running", reason: null }, now);
+        if (pod.podUid !== undefined)
+            await t.agentEvent(id, "agent.relaunched", { hostEpoch: epoch });
+        else
+            await t.agentEvent(id, "agent.running", { hostEpoch: epoch });
+    });
+}
+const opening = new Map();
+/**
+ * What `computer.open` answers a harness: access to computer `id`, once a seed is written, its
+ * setup ran, and a version's start check passed. Concurrent opens of one computer share one.
+ */
+export function openComputer(ctx, id, signal) {
+    const key = `${ctx.config.tenantId}\0${id}`;
+    let pending = opening.get(key);
+    if (!pending) {
+        pending = openOnce(ctx, id, signal).finally(() => opening.delete(key));
+        opening.set(key, pending);
+    }
+    return pending;
+}
+async function openOnce(ctx, id, signal) {
+    let access = await computerAccess(ctx, id, signal);
+    // A new volume being seeded from a disk version (R2d step 3): wait until core has written it.
+    const deadline = Date.now() + hostTuning().pods.readyDeadlineMs;
+    for (;;) {
+        const environment = await ctx.store.tx((t) => t.environment(id));
+        if (!environment?.diskSeed || environment.diskSeed.written)
+            break;
+        const { runPendingSeed } = await import("../artifacts/disk.js");
+        void runPendingSeed(ctx, id);
+        if (Date.now() > deadline)
+            failRetryLater(`Agent ${id}'s disk is still being copied.`, "agent_busy");
+        await sleep(hostTuning().pods.enginePollMs);
+    }
+    const backend = computerBackend({ open: async () => (access = await computerAccess(ctx, id, signal)) });
+    const handle = await backend.open({ key: id, cpus: 1, memoryMiB: 1024, network: { preset: "none", hosts: [], suffixes: [] } });
+    await prepareComputerDisk(ctx, id, handle, signal);
+    const environment = await ctx.store.tx((t) => t.environment(id));
+    if (environment?.startCheck && environment.pod)
+        await passStartCheck(ctx, id, environment.pod.hostEpoch);
+    return access;
+}
+const MARKER = "/harness/setup.json";
+const VOLUME = "/harness/volume-id";
+/** The disk's setup, run through the computer when its marker isn't the recipe's (R2d step 2). */
+export async function prepareComputerDisk(ctx, id, handle, signal) {
+    const state = await ctx.store.tx(async (t) => {
+        const environment = await t.environment(id);
+        if (!environment?.pod)
+            return undefined;
+        return {
+            epoch: environment.pod.hostEpoch,
+            setup: await setupPlanOf(ctx, t, environment),
+            seeded: environment.diskSeed !== undefined,
+            afterSeed: environment.diskSeed?.setup === true,
+        };
+    });
+    if (!state)
+        return;
+    let volumeId = (await handle.readFile(VOLUME))?.trim();
+    if (!volumeId) {
+        volumeId = randomUUID();
+        await handle.writeFile(VOLUME, `${volumeId}\n`);
+    }
+    const markerOf = (setup) => ({
+        volumeId: volumeId,
+        recipeVersion: setup?.recipeVersion ?? 0,
+        ...(setup?.setupHash === undefined ? {} : { setupHash: setup.setupHash }),
+        status: "ok",
+    });
+    const setup = state.setup;
+    if (state.seeded && !state.afterSeed) {
+        // The disk version holds what setup made: mark it done.
+        await handle.writeFile(MARKER, `${JSON.stringify(markerOf(setup))}\n`);
+        return;
+    }
+    if (!setup) {
+        if (state.afterSeed)
+            await recordSetup(ctx, id, state.epoch, { status: "ok" });
+        return;
+    }
+    const raw = await handle.readFile(MARKER);
+    if (raw) {
+        try {
+            const done = JSON.parse(raw);
+            const same = done.setupHash === undefined || done.setupHash === setup.setupHash;
+            if (done.volumeId === volumeId && done.status === "ok" && same)
+                return;
+        }
+        catch {
+            // a broken marker: run it again
+        }
+    }
+    ctx.config.logger.info("environment setup started", { environmentId: id, recipeVersion: setup.recipeVersion });
+    const report = await runSetup(ctx, id, handle, setup, signal ?? new AbortController().signal);
+    if (report.status === "ok")
+        await handle.writeFile(MARKER, `${JSON.stringify(markerOf(setup))}\n`);
+    await recordSetup(ctx, id, state.epoch, report);
+    if (report.status === "failed")
+        fail(409, `Agent ${id}'s setup failed${report.index === undefined ? "" : ` at command ${report.index + 1}`}: ${(report.output ?? "").slice(-500)}`, {
+            code: "agent_unavailable",
+        });
+}
+async function bytesOf(body) {
+    return new Uint8Array(await new Response(body).arrayBuffer());
+}
+async function ensureDir(handle, path, signal) {
+    await handle.exec({ command: `mkdir -p '${path.replace(/'/g, "'\\''")}'`, cwd: "/", timeoutMs: 30_000 }, signal);
+}
+function under(base, relative) {
+    const joined = posix.normalize(posix.join(base, relative));
+    if (joined !== base && !joined.startsWith(`${base.replace(/\/$/, "")}/`))
+        throw new Error(`${relative} would leave ${base}`);
+    return joined;
+}
+async function runSetup(ctx, id, handle, setup, signal) {
+    for (const file of setup.files) {
+        try {
+            const first = await setupFile(ctx, id, file.index, undefined);
+            if (!first)
+                throw new Error(`input file ${file.index + 1} is gone`);
+            if (first.kind === "file") {
+                await ensureDir(handle, posix.dirname(file.path), signal);
+                await handle.writeFile(file.path, await bytesOf(first.body));
+                continue;
+            }
+            for (const entry of first.entries) {
+                const one = await setupFile(ctx, id, file.index, entry.path);
+                if (!one || one.kind !== "file")
+                    throw new Error(`input file ${file.index + 1}, ${entry.path}, is gone`);
+                const target = under(file.path, entry.path);
+                await ensureDir(handle, posix.dirname(target), signal);
+                await handle.writeFile(target, await bytesOf(one.body));
+            }
+        }
+        catch (error) {
+            return { status: "failed", output: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    for (const [index, command] of setup.commands.entries()) {
+        await ensureDir(handle, command.cwd, signal).catch(() => undefined);
+        try {
+            const result = await handle.exec({ command: command.command, cwd: command.cwd, timeoutMs: command.timeoutMs, env: setup.environment }, signal);
+            if (result.exitCode !== 0) {
+                const output = `${result.stdout}${result.stderr ? `\n${result.stderr}` : ""}${result.timedOut ? "\n[timed out]" : ""}`;
+                return { status: "failed", index, exitCode: result.exitCode, output: output.slice(-hostTuning().harness.setupReportTailChars) };
+            }
+        }
+        catch (error) {
+            return { status: "failed", index, output: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    return { status: "ok" };
+}
+/**
+ * A SandboxManager per computer, for core's own uses: its backend opens the computer with
+ * `computerAccess` (no setup run: the harness's `computer.open` does that before a turn's tools).
+ */
+export function computerManagers(ctx, emit) {
+    const managers = new Map();
+    return (environmentId) => {
+        let manager = managers.get(environmentId);
+        if (!manager) {
+            manager = new SandboxManager({
+                scope: ctx().config.tenantId,
+                records: memorySandboxRecords(),
+                backends: [computerBackend({ open: (signal) => computerAccess(ctx(), environmentId, signal) })],
+                preference: "auto",
+                ephemeral: false,
+                emit,
+            });
+            managers.set(environmentId, manager);
+        }
+        return manager;
+    };
+}

package/dist/sandbox/placement.d.ts

@@ -5,7 +5,8 @@
  * Runtime's harness: in process, or the harness container) and `sandbox` (the engine in a pod).
  * Default: both. `"*": { hosts: [] }` refuses every harness the map does not name (R4.1).
  *
- * A session on a pod Environment runs on `sandbox`; every other session (a virtual or `none`
+ * A session on a pod Environment runs on `sandbox` (on `harness-container` when pod Agents are
+ * computers, ADR-149); every other session (a virtual or `none`
  * Environment, or none) on `harness-container` (D52). A host the Tenant does not allow is
  * `409 placement_refused`. A pod Environment needs sandbox pods: without a cluster (`nylorun
  * sandbox enable`), or with the sandboxes service not ready, it is `409 agent_unavailable`.
@@ -21,7 +22,9 @@ export declare function placementOf(config: TenantSandboxConfig, harnessId?: str
 /** How to enable sandbox pods, for the messages that need them. */
 export declare const ENABLE_PODS = "run `nylorun local sandbox enable --context <name>` to give this Tenant a cluster";
 /** Refuses a session whose harness, on the host its Environment needs, the Tenant does not allow. */
-export declare function checkPlacement(config: TenantSandboxConfig, kind: EnvironmentKind | undefined, harness?: string): void;
+export declare function checkPlacement(config: TenantSandboxConfig, kind: EnvironmentKind | undefined, harness?: string, 
+/** Pod Agents are computers (ADR-149): their harness runs in the harness container. */
+computers?: boolean): void;
 /** Whether the sandboxes service is up, the answer reused for `pods.readyCacheMs` (Host tuning). */
 export declare function podsReady(pods: TenantPods): Promise<boolean>;
 /** Refuses a pod Environment without sandbox pods, or with the sandboxes service down. */

package/dist/sandbox/placement.js

@@ -5,7 +5,8 @@
  * Runtime's harness: in process, or the harness container) and `sandbox` (the engine in a pod).
  * Default: both. `"*": { hosts: [] }` refuses every harness the map does not name (R4.1).
  *
- * A session on a pod Environment runs on `sandbox`; every other session (a virtual or `none`
+ * A session on a pod Environment runs on `sandbox` (on `harness-container` when pod Agents are
+ * computers, ADR-149); every other session (a virtual or `none`
  * Environment, or none) on `harness-container` (D52). A host the Tenant does not allow is
  * `409 placement_refused`. A pod Environment needs sandbox pods: without a cluster (`nylorun
  * sandbox enable`), or with the sandboxes service not ready, it is `409 agent_unavailable`.
@@ -24,8 +25,10 @@ export function placementOf(config, harnessId = HARNESS_ID) {
 /** How to enable sandbox pods, for the messages that need them. */
 export const ENABLE_PODS = "run `nylorun local sandbox enable --context <name>` to give this Tenant a cluster";
 /** Refuses a session whose harness, on the host its Environment needs, the Tenant does not allow. */
-export function checkPlacement(config, kind, harness = HARNESS_ID) {
-    const host = kind === "pod" ? "sandbox" : "harness-container";
+export function checkPlacement(config, kind, harness = HARNESS_ID, 
+/** Pod Agents are computers (ADR-149): their harness runs in the harness container. */
+computers = false) {
+    const host = kind === "pod" && !computers ? "sandbox" : "harness-container";
     const allowed = placementOf(config, harness);
     if (allowed.includes(host))
         return;

package/dist/sandbox/pods/reconcile.js

@@ -131,6 +131,7 @@ export async function reconcileSandbox(ctx, sandboxId, trigger) {
             harness: row.applied.harness,
             ...(joinToken ? { joinToken } : {}),
             keys,
+            ...(pods.computer ? { computer: true } : {}),
         });
         try {
             await pods.client.put(row.pod.k8sName, spec);

package/dist/sandbox/pods/spec.d.ts

@@ -45,5 +45,10 @@ export interface PodSpecInput {
     readonly joinToken?: string;
     /** The keyed hosts (`keys.ts`), for Agent Substrate's egress. */
     readonly keys?: PodSpec["keys"];
+    /**
+     * The pod is a computer (ADR-149): our engine runs there in computer mode whatever harness the
+     * Agent runs, since every harness runs outside it.
+     */
+    readonly computer?: boolean;
 }
 export declare function podSpecOf(input: PodSpecInput): PodSpec;

package/dist/sandbox/pods/spec.js

@@ -40,7 +40,7 @@ export function podSpecOf(input) {
     const lifecycle = podLifecycleConfig(config);
     // Pinned by digest once a pod ran it (Q14).
     const image = pod.imageDigest ?? spec.image;
-    const ours = (input.harness ?? DEFAULT_HARNESS) === DEFAULT_HARNESS;
+    const ours = input.computer === true || (input.harness ?? DEFAULT_HARNESS) === DEFAULT_HARNESS;
     // Our engine, built into an image the Tenant lists, while it is this Runtime's (ADR-99).
     const builtin = ours &&
         runsBuiltinEngine({

package/dist/sandbox/records.d.ts

@@ -27,3 +27,5 @@ export declare function storeSandboxRecords(store: SessionStore): SandboxRecords
  * change. Writes are serialized; a file that cannot be read starts empty.
  */
 export declare function fileSandboxRecords(path: string): SandboxRecords;
+/** Records kept in memory: a computer's compute is core's pod row, not a `sandboxes` row. */
+export declare function memorySandboxRecords(): SandboxRecords;

package/dist/sandbox/records.js

@@ -77,3 +77,14 @@ export function fileSandboxRecords(path) {
         count: async () => records.size,
     };
 }
+/** Records kept in memory: a computer's compute is core's pod row, not a `sandboxes` row. */
+export function memorySandboxRecords() {
+    const rows = new Map();
+    return {
+        get: async (key) => rows.get(key),
+        put: async (record) => void rows.set(record.key, record),
+        delete: async (key) => void rows.delete(key),
+        list: async () => [...rows.values()],
+        count: async () => rows.size,
+    };
+}

package/dist/sandbox/types.d.ts

@@ -3,8 +3,11 @@
  * and import a substrate SDK; everything else in the Runtime talks to this interface.
  */
 import type { SandboxNetworkPreset } from "@nylorun/core/define";
-/** `virtual` (just-bash, in process); `local` (the pod sandbox the engine runs in, F7.2). */
-export type SandboxBackendName = "virtual" | "local";
+/**
+ * `virtual` (just-bash, in process); `local` (the pod sandbox the engine runs in, F7.2);
+ * `computer` (an Agent Substrate computer, reached through the sandbox gateway, ADR-149).
+ */
+export type SandboxBackendName = "virtual" | "local" | "computer";
 /** What separates a sandbox from its host: the Runtime process, or a container boundary. */
 export type SandboxIsolation = "process" | "container";
 export interface SandboxProbe {

package/dist/store/postgres/drizzle/0049_agent_triggers_api.sql

@@ -0,0 +1,3 @@
+ALTER TABLE "nylorun"."agent_triggers" DROP CONSTRAINT "agent_triggers_origin_check";--> statement-breakpoint
+ALTER TABLE "nylorun"."agent_triggers" ADD COLUMN "principal" text;--> statement-breakpoint
+ALTER TABLE "nylorun"."agent_triggers" ADD CONSTRAINT "agent_triggers_origin_check" CHECK ("nylorun"."agent_triggers"."origin" IN ('manifest', 'agent', 'api', 'wake'));

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

@@ -344,6 +344,13 @@
       "when": 1794635246579,
       "tag": "0048_sandbox_pod_drained_at",
       "breakpoints": true
+    },
+    {
+      "idx": 49,
+      "version": "7",
+      "when": 1794674884188,
+      "tag": "0049_agent_triggers_api",
+      "breakpoints": true
     }
   ]
 }

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

@@ -1793,14 +1793,31 @@ export declare const agentTriggers: import("drizzle-orm/pg-core").PgTableWithCol
             tableName: "agent_triggers";
             dataType: "string";
             columnType: "PgText";
-            data: "agent" | "manifest" | "wake";
+            data: "agent" | "api" | "manifest" | "wake";
             driverParam: string;
             notNull: true;
             hasDefault: true;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: ["manifest", "agent", "wake"];
+            enumValues: ["manifest", "agent", "api", "wake"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        principal: import("drizzle-orm/pg-core").PgColumn<{
+            name: "principal";
+            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;
@@ -2580,14 +2597,14 @@ export declare const triggerRuns: import("drizzle-orm/pg-core").PgTableWithColum
             tableName: "trigger_runs";
             dataType: "string";
             columnType: "PgText";
-            data: "agent" | "manifest" | "wake";
+            data: "agent" | "api" | "manifest" | "wake";
             driverParam: string;
             notNull: true;
             hasDefault: true;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: ["manifest", "agent", "wake"];
+            enumValues: ["manifest", "agent", "api", "wake"];
             baseColumn: never;
             identity: undefined;
             generated: undefined;

package/dist/store/postgres/schema.js

@@ -249,11 +249,14 @@ export const agentTriggers = nylorun.table("agent_triggers", {
     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).
+     * Where its definition comes from (D83, D88): `manifest` (the version's `runtime.triggers`),
+     * `agent` (`definition`, made with the `triggers` tool), `api` (`definition`, put by a client
+     * over the API) 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. */
+    origin: text({ enum: ["manifest", "agent", "api", "wake"] }).notNull().default("manifest"),
+    /** Who put an `api` trigger (D88): the caller's principal. */
+    principal: text(),
+    /** An agent-made or put trigger's title, its definition, and the session and turn that made it. */
     title: text(),
     definition: jsonText(),
     createdSessionId: textC(),
@@ -261,7 +264,7 @@ export const agentTriggers = nylorun.table("agent_triggers", {
     createdAt: textC().notNull(),
     updatedAt: textC().notNull(),
 }, (t) => [
-    check("agent_triggers_origin_check", sql `${t.origin} IN ('manifest', 'agent', 'wake')`),
+    check("agent_triggers_origin_check", sql `${t.origin} IN ('manifest', 'agent', 'api', '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),
@@ -326,8 +329,8 @@ 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"),
+    /** Its trigger's origin and title when it ran (D83, D88), for the runs stream after the trigger is gone. */
+    origin: text({ enum: ["manifest", "agent", "api", "wake"] }).notNull().default("manifest"),
     title: text(),
     /** When it was appended to the Tenant's `runs` stream (ISO), or null until then. */
     streamedAt: textC(),

package/dist/tenant/advance.js

@@ -285,14 +285,17 @@ async function runRemoteSegment(ctx, lease, started, controller, run, onTaken, p
         const unusable = podUnusable(ctx, segment);
         if (unusable)
             throw new Error(unusable);
+        // A computer's run goes to the harness container (ADR-149); `computer.open` waits for its
+        // seed, runs its setup and passes its start check.
+        const computer = ctx.pods?.computer !== undefined;
         // A new volume being seeded from a disk version takes no turn until it holds it (R2d step 3).
-        if (segment.pod?.seeding)
+        if (!computer && segment.pod?.seeding)
             throw new HarnessUnavailable();
         // A pod starting on a new version takes no turn until its harness joins (track T3): a start
         // that fails goes back to the version it ran, and the turn's first segment re-pins to it.
-        if (segment.pod?.starting)
+        if (!computer && segment.pod?.starting)
             throw new HarnessUnavailable();
-        const pod = segment.pod?.id;
+        const pod = computer ? undefined : segment.pod?.id;
         if (started.environmentId !== undefined)
             placed.environment = started.environmentId;
         end = await ctx.harness.offer({

package/dist/tenant/agent-triggers.js

@@ -115,7 +115,7 @@ export async function serveTriggersTool(t, s, request) {
         if (!row || !reaches(row, s.id))
             return failed("tool.not-found", `This session has no trigger ${input.id}: list shows the ones it has.`);
         await t.deleteAgentTrigger(s.agentId, input.id);
-        await t.agentEvent(s.agentId, "agent.trigger_deleted", { triggerId: input.id, sessionId: s.id });
+        await t.agentEvent(s.agentId, "agent.trigger_deleted", { triggerId: input.id, origin: "agent", sessionId: s.id });
         return completed({ id: input.id, deleted: true });
     }
     // create: never from a turn a trigger or a booked wake started. Under the `nylorun-triggers`
@@ -153,7 +153,8 @@ export async function serveTriggersTool(t, s, request) {
     const agent = await liveEnvironment(t, s.agentId);
     const inForce = triggerLimitsInForce(runtime, agent?.applied?.limits);
     if (!existing) {
-        const made = (await t.agentTriggers(s.agentId)).filter((row) => originOf(row) === "agent").length;
+        // One count for every trigger not from the definition: the tool's and the API's (D88).
+        const made = (await t.agentTriggers(s.agentId)).filter((row) => originOf(row) === "agent" || originOf(row) === "api").length;
         if (made >= inForce.count)
             return failed("tool.limit", `This Agent has ${made} triggers, the most it can have. Delete one to add another.`);
     }
@@ -176,6 +177,7 @@ export async function serveTriggersTool(t, s, request) {
         note: null,
         effectId: request.effectId,
         origin: "agent",
+        principal: null,
         title: input.title ?? null,
         definition,
         createdSessionId: s.id,
@@ -187,6 +189,7 @@ export async function serveTriggersTool(t, s, request) {
     await t.agentEvent(s.agentId, existing ? "agent.trigger_updated" : "agent.trigger_created", {
         triggerId: input.id,
         kind: definition.schedule === undefined ? "at" : "schedule",
+        origin: "agent",
         sessionId: s.id,
         session,
         ...(row.title === null ? {} : { title: row.title }),

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

@@ -0,0 +1,33 @@
+/**
+ * Triggers a client puts on one Agent (D88): `PUT /v1/agents/{agentId}/triggers/{triggerId}` with
+ * a `Trigger`, exactly as a definition's `runtime.triggers` entry holds it, and an optional title.
+ *
+ * - **Origin `api`.** The row keeps its own definition, like an agent-made trigger (D83), and the
+ *   principal that put it. Upgrades and moves never touch it (`mergeAgentTriggers` merges
+ *   `manifest` rows only); `DELETE` removes it; pause, resume, run and a webhook's secret work as
+ *   for any trigger; it fires through `fireTimer` and `deliverRun` like every other.
+ * - **Create or replace.** A new id makes it active with its next time. The same id replaces it:
+ *   `generation` goes up and the next time is worked out again, so the timer armed for the old
+ *   time does nothing. A paused one stays paused; an `at` that ran is active again at its new time.
+ * - **The same body again changes nothing** and records no event, so a client may put its desired
+ *   state as often as it likes.
+ * - **Conflicts.** An id the definition declares, or a row of another origin holds, is
+ *   `409 trigger_conflict`: the API never replaces a trigger it didn't put.
+ * - **Checks and limits.** Those a definition save runs (`triggerIssues`), against the limits in
+ *   force; `count` covers the Agent's `agent` and `api` triggers together (`422 trigger_limit`).
+ * - **Events.** `agent.trigger_created` or `agent.trigger_updated` (with `changed`) on the Agent.
+ *
+ * One transaction with the Agent locked; the timer is armed after the commit.
+ */
+import { type Trigger, type TriggerPut, type TriggerView } from "@nylorun/core/contracts";
+import type { TenantContext } from "./context.js";
+/** The `Trigger` part of a put body, with only the fields it has. */
+export declare function definitionOfPut(body: TriggerPut): Trigger;
+/** The definition fields that differ between `before` and `after`, and `title` when it changed. */
+export declare function changedFields(before: Trigger, after: Trigger, titleBefore: string | null, titleAfter: string | null): string[];
+/**
+ * `PUT /v1/agents/{agentId}/triggers/{triggerId}` (D88): creates or replaces the Agent's `api`
+ * trigger `triggerId` and answers it as the list shows it. `principal` is who put it; `origin` is
+ * the URL origin the request reached, for a webhook's URL.
+ */
+export declare function putTrigger(ctx: TenantContext, agentId: string, triggerId: string, body: TriggerPut, principal: string | undefined, origin?: string): Promise<TriggerView>;