@nylorun/runtime 0.23.0-beta → 0.25.0-beta

package/dist/api/components.js

@@ -5,7 +5,7 @@
  * global registry.
  */
 import { z } from "zod";
-import { SessionListItemSchema, ModelCallSchema, SessionPageSchema, SessionManifestViewSchema, HistoryPageSchema, SessionUsageTotalsSchema, ModelCallsPageSchema, ModelCallExportPageSchema, SandboxPageSchema, JwksSchema, SigningKeyListSchema, SigningKeyViewSchema, RotateSigningKeysRequestSchema, RevokeSigningKeyRequestSchema, MeResponseSchema, TenantStatusSchema, ResetTenantRequestSchema, ResetTenantResponseSchema, SeedTenantConfigRequestSchema, SeedTenantConfigResponseSchema, HostModelCatalogSchema, TenantSandboxViewSchema, ModelUsageTotalsSchema, ModelBudgetsSchema, PutModelBudgetsRequestSchema, PutTenantSandboxRequestSchema, ListProvidersResponseSchema, HostModelViewSchema, PutHostModelRequestSchema, SelectHostModelRequestSchema, CreateVaultRequestSchema, VaultInfoSchema, ListVaultsResponseSchema, CreateCredentialRequestSchema, CredentialInfoSchema, ListCredentialsResponseSchema, RotateCredentialRequestSchema, McpPreviewRequestSchema, McpPreviewSchema, DeletedResponseSchema, ListAgentsResponseSchema, ListPublicAgentsResponseSchema, ListSessionsResponseSchema, LiveEventSchema, PutAgentRequestSchema, PutAgentResponseSchema, PutSessionRequestSchema, SessionItemsResponseSchema, SessionViewSchema, StreamClosedFrameSchema, AcceptedResponseSchema, SandboxToolOutcomeSchema, PutSandboxRequestSchema, SandboxViewSchema, ListSandboxesResponseSchema, DeleteSandboxResponseSchema, ListSandboxEventsResponseSchema, ArtifactViewSchema, ArtifactVersionViewSchema, ListArtifactsResponseSchema, UploadArtifactResponseSchema, DefinitionFileViewSchema, DeleteArtifactResponseSchema, CreateArtifactLinkRequestSchema, ArtifactLinkSchema, PutTenantArtifactsRequestSchema, TenantArtifactsViewSchema, ArtifactTreeSchema, ArtifactDiffSchema, SessionCommandSchema, ListOperatorKeysResponseSchema, PutOperatorKeyResponseSchema, DeleteOperatorKeyResponseSchema, OperatorKeySchema, ProtocolRejectedResponseSchema, RejectedResponseSchema, EVENT_SCHEMAS, EVENT_TYPES, } from "@nylorun/core/contracts";
+import { EnvironmentManifestSchema, EnvironmentSecretSlotsSchema, DeleteEnvironmentManifestResponseSchema, EnvironmentManifestPlanSchema, EnvironmentManifestVersionsSchema, EnvironmentManifestViewSchema, ListEnvironmentManifestsResponseSchema, PutEnvironmentManifestRequestSchema, PutEnvironmentSecretValueRequestSchema, SaveEnvironmentManifestResponseSchema, SessionListItemSchema, ModelCallSchema, SessionPageSchema, SessionManifestViewSchema, HistoryPageSchema, SessionUsageTotalsSchema, ModelCallsPageSchema, ModelCallExportPageSchema, EnvironmentPageSchema, ToolCallSchema, ToolCallsPageSchema, TurnTraceSchema, JwksSchema, SigningKeyListSchema, SigningKeyViewSchema, RotateSigningKeysRequestSchema, RevokeSigningKeyRequestSchema, MeResponseSchema, TenantStatusSchema, ResetTenantRequestSchema, ResetTenantResponseSchema, SeedTenantConfigRequestSchema, SeedTenantConfigResponseSchema, HostModelCatalogSchema, TenantSandboxViewSchema, ModelUsageTotalsSchema, ModelBudgetsSchema, PutModelBudgetsRequestSchema, ToolPolicySchema, PutToolPolicyRequestSchema, PutModelInputsRequestSchema, ModelInputsViewSchema, PutTenantEnvironmentsRequestSchema, ListProvidersResponseSchema, HostModelViewSchema, PutHostModelRequestSchema, SelectHostModelRequestSchema, PutEnvironmentSecretRequestSchema, EnvironmentSecretViewSchema, ListEnvironmentSecretsResponseSchema, McpPreviewRequestSchema, McpPreviewSchema, CredentialCoverageRequestSchema, CredentialCoverageSchema, DeletedResponseSchema, ListAgentsResponseSchema, ListPublicAgentsResponseSchema, ListSessionsResponseSchema, LiveEventSchema, PutAgentRequestSchema, PutAgentResponseSchema, PutSessionRequestSchema, SessionItemsResponseSchema, SessionViewSchema, StreamClosedFrameSchema, AcceptedResponseSchema, SandboxToolOutcomeSchema, PutEnvironmentRequestSchema, EnvironmentViewSchema, EnvironmentSnapshotSchema, RestoreEnvironmentRequestSchema, ForkEnvironmentRequestSchema, EnvironmentForkPlanSchema, ForkEnvironmentResponseSchema, EnvironmentRestoreSchema, EnvironmentVersionsSchema, ListEnvironmentsResponseSchema, DeleteEnvironmentResponseSchema, ListEnvironmentEventsResponseSchema, ArtifactViewSchema, ArtifactListItemSchema, ArtifactPageSchema, ArtifactVersionViewSchema, ListArtifactsResponseSchema, UploadArtifactResponseSchema, DefinitionFileViewSchema, DeleteArtifactResponseSchema, CreateArtifactLinkRequestSchema, ArtifactLinkSchema, PutTenantArtifactsRequestSchema, TenantArtifactsViewSchema, ArtifactTreeSchema, ArtifactDiffSchema, SessionCommandSchema, ListOperatorKeysResponseSchema, PutOperatorKeyResponseSchema, DeleteOperatorKeyResponseSchema, OperatorKeySchema, ProtocolRejectedResponseSchema, RejectedResponseSchema, EVENT_SCHEMAS, EVENT_TYPES, } from "@nylorun/core/contracts";
 function named(id, schema) {
     return schema.meta({ id });
 }
@@ -16,13 +16,32 @@ export const ListOperatorKeysResponse = named("ListOperatorKeysResponse", ListOp
 export const PutOperatorKeyResponse = named("PutOperatorKeyResponse", PutOperatorKeyResponseSchema);
 export const DeleteOperatorKeyResponse = named("DeleteOperatorKeyResponse", DeleteOperatorKeyResponseSchema);
 export const SandboxToolOutcome = named("SandboxToolOutcome", SandboxToolOutcomeSchema);
-export const PutSandboxRequest = named("PutSandboxRequest", PutSandboxRequestSchema);
-export const SandboxView = named("SandboxView", SandboxViewSchema);
-export const ListSandboxesResponse = named("ListSandboxesResponse", ListSandboxesResponseSchema);
-export const DeleteSandboxResponse = named("DeleteSandboxResponse", DeleteSandboxResponseSchema);
-export const ListSandboxEventsResponse = named("ListSandboxEventsResponse", ListSandboxEventsResponseSchema);
+export const PutEnvironmentRequest = named("PutEnvironmentRequest", PutEnvironmentRequestSchema);
+export const EnvironmentView = named("EnvironmentView", EnvironmentViewSchema);
+export const EnvironmentSecretSlots = named("EnvironmentSecretSlots", EnvironmentSecretSlotsSchema);
+export const EnvironmentManifest = named("EnvironmentManifest", EnvironmentManifestSchema);
+export const PutEnvironmentManifestRequest = named("PutEnvironmentManifestRequest", PutEnvironmentManifestRequestSchema);
+export const EnvironmentManifestView = named("EnvironmentManifestView", EnvironmentManifestViewSchema);
+export const EnvironmentManifestPlan = named("EnvironmentManifestPlan", EnvironmentManifestPlanSchema);
+export const SaveEnvironmentManifestResponse = named("SaveEnvironmentManifestResponse", SaveEnvironmentManifestResponseSchema);
+export const ListEnvironmentManifestsResponse = named("ListEnvironmentManifestsResponse", ListEnvironmentManifestsResponseSchema);
+export const EnvironmentManifestVersions = named("EnvironmentManifestVersions", EnvironmentManifestVersionsSchema);
+export const DeleteEnvironmentManifestResponse = named("DeleteEnvironmentManifestResponse", DeleteEnvironmentManifestResponseSchema);
+export const PutEnvironmentSecretValueRequest = named("PutEnvironmentSecretValueRequest", PutEnvironmentSecretValueRequestSchema);
+export const EnvironmentSnapshot = named("EnvironmentSnapshot", EnvironmentSnapshotSchema);
+export const RestoreEnvironmentRequest = named("RestoreEnvironmentRequest", RestoreEnvironmentRequestSchema);
+export const EnvironmentRestore = named("EnvironmentRestore", EnvironmentRestoreSchema);
+export const ForkEnvironmentRequest = named("ForkEnvironmentRequest", ForkEnvironmentRequestSchema);
+export const EnvironmentForkPlan = named("EnvironmentForkPlan", EnvironmentForkPlanSchema);
+export const ForkEnvironmentResponse = named("ForkEnvironmentResponse", ForkEnvironmentResponseSchema);
+export const EnvironmentVersions = named("EnvironmentVersions", EnvironmentVersionsSchema);
+export const ListEnvironmentsResponse = named("ListEnvironmentsResponse", ListEnvironmentsResponseSchema);
+export const DeleteEnvironmentResponse = named("DeleteEnvironmentResponse", DeleteEnvironmentResponseSchema);
+export const ListEnvironmentEventsResponse = named("ListEnvironmentEventsResponse", ListEnvironmentEventsResponseSchema);
 export const ArtifactVersionView = named("ArtifactVersionView", ArtifactVersionViewSchema);
 export const ArtifactView = named("ArtifactView", ArtifactViewSchema);
+export const ArtifactListItem = named("ArtifactListItem", ArtifactListItemSchema);
+export const ArtifactPage = named("ArtifactPage", ArtifactPageSchema.extend({ artifacts: z.array(ArtifactListItem) }));
 export const ListArtifactsResponse = named("ListArtifactsResponse", ListArtifactsResponseSchema);
 export const UploadArtifactResponse = named("UploadArtifactResponse", UploadArtifactResponseSchema);
 export const DefinitionFileView = named("DefinitionFileView", DefinitionFileViewSchema);
@@ -43,7 +62,7 @@ export const ListSessionsResponse = named("ListSessionsResponse", ListSessionsRe
 export const PutSessionRequest = named("PutSessionRequest", PutSessionRequestSchema);
 export const SessionView = named("SessionView", SessionViewSchema);
 export const LiveEvent = named("LiveEvent", LiveEventSchema);
-/** `sandbox.state` → `SandboxStateEvent`. */
+/** `environment.state` → `EnvironmentStateEvent`. */
 export function eventComponentName(type) {
     return `${type
         .split(/[._]/)
@@ -64,21 +83,23 @@ export const TenantSandboxView = named("TenantSandboxView", TenantSandboxViewSch
 export const ModelUsageTotals = named("ModelUsageTotals", ModelUsageTotalsSchema);
 export const ModelBudgets = named("ModelBudgets", ModelBudgetsSchema);
 export const PutModelBudgetsRequest = named("PutModelBudgetsRequest", PutModelBudgetsRequestSchema);
-export const PutTenantSandboxRequest = named("PutTenantSandboxRequest", PutTenantSandboxRequestSchema);
+export const ToolPolicy = named("ToolPolicy", ToolPolicySchema);
+export const PutToolPolicyRequest = named("PutToolPolicyRequest", PutToolPolicyRequestSchema);
+export const PutModelInputsRequest = named("PutModelInputsRequest", PutModelInputsRequestSchema);
+export const ModelInputsView = named("ModelInputsView", ModelInputsViewSchema);
+export const PutTenantEnvironmentsRequest = named("PutTenantEnvironmentsRequest", PutTenantEnvironmentsRequestSchema);
 export const ListProvidersResponse = named("ListProvidersResponse", ListProvidersResponseSchema);
 export const HostModelView = named("HostModelView", HostModelViewSchema);
 export const PutHostModelRequest = named("PutHostModelRequest", PutHostModelRequestSchema);
 export const SelectHostModelRequest = named("SelectHostModelRequest", SelectHostModelRequestSchema);
-export const CreateVaultRequest = named("CreateVaultRequest", CreateVaultRequestSchema);
-export const VaultInfo = named("VaultInfo", VaultInfoSchema);
-export const ListVaultsResponse = named("ListVaultsResponse", ListVaultsResponseSchema);
-export const CreateCredentialRequest = named("CreateCredentialRequest", CreateCredentialRequestSchema);
-export const CredentialInfo = named("CredentialInfo", CredentialInfoSchema);
-export const ListCredentialsResponse = named("ListCredentialsResponse", ListCredentialsResponseSchema);
-export const RotateCredentialRequest = named("RotateCredentialRequest", RotateCredentialRequestSchema);
+export const PutEnvironmentSecretRequest = named("PutEnvironmentSecretRequest", PutEnvironmentSecretRequestSchema);
+export const EnvironmentSecretView = named("EnvironmentSecretView", EnvironmentSecretViewSchema);
+export const ListEnvironmentSecretsResponse = named("ListEnvironmentSecretsResponse", ListEnvironmentSecretsResponseSchema);
 export const DeletedResponse = named("DeletedResponse", DeletedResponseSchema);
 export const McpPreviewRequest = named("McpPreviewRequest", McpPreviewRequestSchema);
 export const McpPreview = named("McpPreview", McpPreviewSchema);
+export const CredentialCoverageRequest = named("CredentialCoverageRequest", CredentialCoverageRequestSchema);
+export const CredentialCoverage = named("CredentialCoverage", CredentialCoverageSchema);
 export const Jwks = named("Jwks", JwksSchema);
 export const SigningKeyList = named("SigningKeyList", SigningKeyListSchema);
 export const SigningKeyView = named("SigningKeyView", SigningKeyViewSchema);
@@ -92,5 +113,8 @@ export const HistoryPage = named("HistoryPage", HistoryPageSchema.extend({ items
 export const SessionUsageTotals = named("SessionUsageTotals", SessionUsageTotalsSchema);
 export const ModelCallsPage = named("ModelCallsPage", ModelCallsPageSchema.extend({ calls: z.array(ModelCall) }));
 export const ModelCallExportPage = named("ModelCallExportPage", ModelCallExportPageSchema.extend({ calls: z.array(ModelCall) }));
-export const SandboxPage = named("SandboxPage", SandboxPageSchema.extend({ sandboxes: z.array(SandboxView) }));
+export const EnvironmentPage = named("EnvironmentPage", EnvironmentPageSchema.extend({ environments: z.array(EnvironmentView) }));
+export const ToolCall = named("ToolCall", ToolCallSchema);
+export const ToolCallsPage = named("ToolCallsPage", ToolCallsPageSchema.extend({ calls: z.array(ToolCall) }));
+export const TurnTrace = named("TurnTrace", TurnTraceSchema);
 export const MeResponse = named("MeResponse", MeResponseSchema);

package/dist/api/gate/keys.d.ts

@@ -1,7 +1,8 @@
 /**
  * The `keys` service's route on the gateway's listener (F4.2, `contract.ts`): one operation of
  * `Keys` per request, run with the vault key of the gateway's Tenant. Errors keep their status,
- * code and details. Logs the operation and its outcome, never an argument or a result.
+ * code and details. Logs the operation, its outcome and an internal failure's cause, never an
+ * argument or a result.
  */
 import type { Env, Hono, MiddlewareHandler } from "hono";
 import type { Logger } from "../../tenant/types.js";

package/dist/api/gate/keys.js

@@ -29,6 +29,13 @@ export function mountKeysRoutes(app, options) {
         }
         catch (error) {
             answer = { error: errorOf(error) };
+            // The caller sees only "The keys service failed": the cause is logged, never the args.
+            if (answer.error.status === 500)
+                options.logger.error("keys_request_failed", {
+                    operation,
+                    error: error?.message ?? String(error),
+                    stack: error?.stack,
+                });
         }
         options.logger.info("keys_request", {
             operation,
@@ -40,7 +47,13 @@ export function mountKeysRoutes(app, options) {
 }
 function errorOf(error) {
     if (error instanceof VaultError)
-        return { kind: "vault", status: error.status, message: error.message };
+        return {
+            kind: "vault",
+            status: error.status,
+            message: error.message,
+            ...(error.rejection.code === undefined ? {} : { code: error.rejection.code }),
+            ...(error.rejection.details === undefined ? {} : { details: error.rejection.details }),
+        };
     if (error instanceof HttpError)
         return {
             kind: "http",

package/dist/api/gate/routes.d.ts

@@ -3,6 +3,7 @@ import type { ModelCallHandler } from "../../gates/handler.js";
 import { type InflightCalls } from "../../gates/inflight.js";
 import type { McpHandler } from "../../gates/mcp-handler.js";
 import type { ToolCalls } from "../../gates/tool-calls.js";
+import type { JournalCheck } from "../../gates/journal.js";
 import type { HttpOutcome, HttpToolCall } from "../../gates/http-tool.js";
 import type { Keys } from "../../keys/keys.js";
 import type { Logger } from "../../tenant/types.js";
@@ -34,6 +35,11 @@ export interface GatesAppOptions {
     };
     /** Keyed MCP and HTTP tool calls, which outlive their client and run once (F4.1 G3). */
     readonly toolCalls?: ToolCalls;
+    /**
+     * The journal check (R5.6): a run's tool call must be keyed, and journaled as sent. Without
+     * it the gate sends what it is asked to.
+     */
+    readonly journal?: JournalCheck;
     /** The keys service's operations (F4.2). Without it the keys route answers 404. */
     readonly keys?: () => Promise<Keys>;
     /** Logs the keys service's requests and refused credentials. */

package/dist/api/gate/routes.js

@@ -20,6 +20,7 @@
 import { createHash } from "node:crypto";
 import { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
+import { HTTPException } from "hono/http-exception";
 import { isTenantId } from "@nylorun/core/compatibility";
 import { MAX_MODEL_CALL_BYTES, MODEL_CALLS_PATH, ModelCallBodySchema, TENANT_HEADER, } from "../../gates/contract.js";
 import { InflightConflict, InflightStale } from "../../gates/inflight.js";
@@ -38,6 +39,18 @@ export function createGatesApp(options) {
     const app = new Hono();
     const maxSize = options.maxBodyBytes ?? MAX_MODEL_CALL_BYTES;
     const logger = options.logger ?? { info() { }, warn() { }, error() { } };
+    // Hono's default, but logged through the logger: never the body, which may hold secrets.
+    app.onError((error, c) => {
+        if (error instanceof HTTPException)
+            return error.getResponse();
+        logger.error("request_failed", {
+            method: c.req.method,
+            route: c.req.routePath,
+            error: error.message,
+            stack: error.stack,
+        });
+        return c.text("Internal Server Error", 500);
+    });
     app.get("/health", (c) => c.json({ status: "ok" }));
     app.get("/ready", async (c) => (await options.ready()) ? c.json({ ready: true }) : c.json({ ready: false }, 503));
     const bearerOf = (c) => /^Bearer (.+)$/.exec(c.req.header("authorization") ?? "")?.[1];
@@ -146,6 +159,24 @@ export function createGatesApp(options) {
         const claims = c.get("run");
         return claims ? { sessionId: claims.sessionId, epoch: claims.epoch } : undefined;
     };
+    /**
+     * Under a run token, the 400 or 409 for a tool call the effect journal does not hold, running,
+     * as sent (R5.6); else the call's span context from its row (R7.4), none under core's credential.
+     */
+    const unjournaled = async (c, tenantId, key, call) => {
+        const claims = c.get("run");
+        if (!claims || !options.journal)
+            return {};
+        if (!key)
+            return {
+                refused: c.json(gateError("key_required", "A run's tool call needs its effect id as its Idempotency-Key"), 400),
+            };
+        const answer = await options.journal.check(tenantId, claims, key, call);
+        if (answer.refused === undefined)
+            return answer.traceparent ? { traceparent: answer.traceparent } : {};
+        logger.warn("gate_call_unjournaled", { route: c.req.path, session: claims.sessionId, effect: key, reason: answer.refused });
+        return { refused: c.json(gateError("effect_not_journaled", answer.refused), 409) };
+    };
     /** 409 for a keyed re-send the in-flight map refused, or undefined. */
     const refusedJoin = (c, error) => {
         if (error instanceof InflightStale)
@@ -203,12 +234,21 @@ export function createGatesApp(options) {
             const body = { ...request.body, server: server.server };
             const signal = c.req.raw.signal;
             const key = c.req.header("idempotency-key");
+            const journaled = await unjournaled(c, request.tenantId, key, {
+                kind: "mcp",
+                server: body.server,
+                name: body.name,
+                arguments: body.arguments,
+            });
+            if (journaled.refused)
+                return journaled.refused;
+            const traced = journaled.traceparent ? { traceparent: journaled.traceparent } : {};
             try {
                 // Keyed: the call runs under its own signal, once, and outlives this request (G3). The
                 // hash covers the session, so a re-send joins only its own session's call.
                 const answer = key && toolCalls
-                    ? await untilAborted(toolCalls.run(request.tenantId, key, createHash("sha256").update(canonical(body)).digest("hex"), (own) => mcp.call(request.tenantId, body, own), ownerOf(c)), signal)
-                    : await mcp.call(request.tenantId, body, signal);
+                    ? await untilAborted(toolCalls.run(request.tenantId, key, createHash("sha256").update(canonical(body)).digest("hex"), (own) => mcp.call(request.tenantId, { ...body, key, ...traced }, own), ownerOf(c)), signal)
+                    : await mcp.call(request.tenantId, { ...body, ...traced }, signal);
                 if (signal.aborted)
                     return new Response(null, { status: 499 });
                 return c.json(answer);
@@ -233,13 +273,19 @@ export function createGatesApp(options) {
             if (!tool.ok)
                 return tool.response;
             // A run token's turn is the call's: it names the request's `Nylorun-Turn-Id`.
-            const call = {
+            let call = {
                 ...request.body,
                 tool: tool.ref,
                 turnId: c.get("run")?.turnId ?? request.body.turnId,
             };
             const signal = c.req.raw.signal;
             const key = c.req.header("idempotency-key");
+            const journaled = await unjournaled(c, request.tenantId, key, { kind: "http", tool: call.tool, input: call.input });
+            if (journaled.refused)
+                return journaled.refused;
+            // The span context from the call's journal row (R7.4), never from the body.
+            if (journaled.traceparent)
+                call = { ...call, traceparent: journaled.traceparent };
             try {
                 // Keyed: runs once under its own signal and outlives this request, as an MCP call.
                 const answer = key && toolCalls
@@ -334,6 +380,9 @@ export function createGatesApp(options) {
 }
 /** `promise`, or a rejection as soon as `signal` aborts (the call itself keeps running). */
 function untilAborted(promise, signal) {
+    // Nobody may wait for it (the caller went away first); its rejection, a cancel or the gate's
+    // shutdown, is not an unhandled one.
+    promise.catch(() => { });
     if (signal.aborted)
         return Promise.reject(signal.reason);
     return new Promise((resolve, reject) => {

package/dist/api/http/app.js

@@ -12,14 +12,15 @@ import { declaredRoute, pathSegments, routeNotFound } from "./define.js";
 import { jsonResponse, rejectionOf } from "./respond.js";
 import { accessRoutes } from "./routes/access.js";
 import { meRoutes } from "./routes/me.js";
-import { sandboxRoutes } from "./routes/sandboxes.js";
+import { environmentRoutes } from "./routes/environments.js";
+import { environmentManifestRoutes } from "./routes/environment-manifests.js";
 import { artifactRoutes } from "./routes/artifacts.js";
 import { readRoutes } from "./routes/reads.js";
 import { sessionRoutes } from "./routes/sessions.js";
 import { fileRoutes } from "./routes/files.js";
 import { keyRoutes } from "./routes/keys.js";
 import { tenantRoutes } from "./routes/tenant.js";
-import { vaultRoutes } from "./routes/vaults.js";
+import { coverageRoutes } from "./routes/coverage.js";
 import { mcpRoutes } from "./routes/mcp.js";
 let app;
 /** The Tenant API, built on first use. */
@@ -44,11 +45,12 @@ function build() {
     });
     sessionRoutes(api);
     fileRoutes(api);
-    sandboxRoutes(api);
+    environmentRoutes(api);
+    environmentManifestRoutes(api);
     artifactRoutes(api);
     tenantRoutes(api);
     keyRoutes(api);
-    vaultRoutes(api);
+    coverageRoutes(api);
     mcpRoutes(api);
     accessRoutes(api);
     meRoutes(api);
@@ -56,13 +58,22 @@ function build() {
     a2aRoutes(api);
     api.notFound(routeNotFound);
     api.onError((error, c) => {
-        const { outgoing } = c.env;
+        const { outgoing, tenant } = c.env;
+        const rejection = rejectionOf(error);
+        // The client sees only `internal_error`: the operator's log has the cause. The route's
+        // pattern, not its path, and never the body, which may hold secrets.
+        if (rejection.status === 500)
+            tenant.config.logger.error("request_failed", {
+                method: c.req.method,
+                route: c.req.routePath,
+                error: error.message,
+                stack: error.stack,
+            });
         // Once a response has started, the rejection can only end it.
         if (outgoing.headersSent) {
             outgoing.end();
             return RESPONSE_ALREADY_SENT;
         }
-        const rejection = rejectionOf(error);
         return jsonResponse(rejection.status, rejection.body, rejection.headers);
     });
     readRoutes(api);

package/dist/api/http/body.d.ts

@@ -1,4 +1,4 @@
-/** The body as text. */
-export declare function readText(request: Request): Promise<string>;
+/** The body as text; past `maxBytes`, `413 Request too large`. */
+export declare function readText(request: Request, maxBytes?: number): Promise<string>;
 /** The body as JSON, before any schema. */
-export declare function readJson(request: Request): Promise<unknown>;
+export declare function readJson(request: Request, maxBytes?: number): Promise<unknown>;

package/dist/api/http/body.js

@@ -1,12 +1,12 @@
 /**
  * Request bodies of Tenant routes, read as the router they replace read them
- * (`tenant/http.ts`): at most 1 MiB, UTF-8, and a missing or malformed JSON body is
- * `400 Invalid JSON`.
+ * (`tenant/http.ts`): at most 1 MiB unless a route allows more (an endpoint that takes files
+ * inline), UTF-8, and a missing or malformed JSON body is `400 Invalid JSON`.
  */
 import { fail } from "../../tenant/http.js";
 const MAX_BODY_BYTES = 1024 * 1024;
-/** The body as text. */
-export async function readText(request) {
+/** The body as text; past `maxBytes`, `413 Request too large`. */
+export async function readText(request, maxBytes = MAX_BODY_BYTES) {
     if (request.body === null)
         return "";
     const chunks = [];
@@ -17,7 +17,7 @@ export async function readText(request) {
         if (done)
             break;
         bytes += value.byteLength;
-        if (bytes > MAX_BODY_BYTES) {
+        if (bytes > maxBytes) {
             await reader.cancel();
             fail(413, "Request too large");
         }
@@ -26,8 +26,8 @@ export async function readText(request) {
     return Buffer.concat(chunks).toString("utf8");
 }
 /** The body as JSON, before any schema. */
-export async function readJson(request) {
-    const text = await readText(request);
+export async function readJson(request, maxBytes = MAX_BODY_BYTES) {
+    const text = await readText(request, maxBytes);
     try {
         return JSON.parse(text);
     }

package/dist/api/http/define.d.ts

@@ -12,6 +12,7 @@
 import type { IncomingMessage } from "node:http";
 import type { OpenAPIHono, RouteConfig } from "@hono/zod-openapi";
 import type { Context, Handler } from "hono";
+import { z } from "zod";
 import type { SubjectScope } from "@nylorun/core/contracts";
 import { type KeyAccess } from "../../tenant/auth.js";
 import type { AuthScope } from "../../tenant/context.js";
@@ -56,4 +57,9 @@ export declare function routeNotFound(c: Context<TenantEnv>): Promise<Response>;
 export declare function keyAccess(access: RouteAccess): KeyAccess;
 /** The declared route `method path` is, if any. `{param}` segments match any one segment. */
 export declare function declaredRoute(method: string, segments: readonly string[]): RouteAccess | undefined;
+/** W3C trace context a request may send (R7.4): the turn it starts joins the caller's trace. */
+export declare const TraceHeaders: z.ZodObject<{
+    traceparent: z.ZodOptional<z.ZodString>;
+    tracestate: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare function tenantRoute(api: OpenAPIHono<TenantEnv>, access: RouteAccess, route: RouteConfig, handler: Handler<TenantEnv>): void;

package/dist/api/http/define.js

@@ -71,6 +71,14 @@ function authenticated(access) {
         await next();
     };
 }
+/** W3C trace context a request may send (R7.4): the turn it starts joins the caller's trace. */
+export const TraceHeaders = z.object({
+    traceparent: z
+        .string()
+        .optional()
+        .meta({ description: "W3C trace context: the turn this request starts joins the caller's trace (feature `traces`). A malformed value is ignored" }),
+    tracestate: z.string().optional().meta({ description: "W3C trace context, kept with `traceparent`" }),
+});
 export function tenantRoute(api, access, route, handler) {
     const takes = (credential) => access.credentials.includes(credential);
     const schemes = [...new Set(access.credentials.map((credential) => SCHEMES[credential]))];
@@ -97,7 +105,11 @@ export function tenantRoute(api, access, route, handler) {
             ...schemes.map((scheme) => ({ [scheme]: [] })),
             ...(access.anonymous ? [{}] : []),
         ],
-        request: { ...route.request, headers },
+        // A route's own headers (`traceparent`, R7.4) beside the common ones.
+        request: {
+            ...route.request,
+            headers: route.request?.headers instanceof z.ZodObject ? headers.extend(route.request.headers.shape) : headers,
+        },
         responses: {
             400: rejected("Invalid headers, path, body or cursor"),
             401: rejected(takes("token")

package/dist/api/http/respond.js

@@ -30,7 +30,7 @@ export function rejectionOf(error) {
             error?.message === "Invalid cursor"
             ? 400
             : 500;
-    const rejection = error instanceof HttpError ? error.rejection : {};
+    const rejection = error instanceof HttpError || error instanceof VaultError ? error.rejection : {};
     return {
         status,
         body: {

package/dist/api/http/routes/artifacts.js

@@ -14,8 +14,8 @@
  */
 import { posix } from "node:path";
 import { z } from "zod";
-import { ArtifactLabelsSchema, CreateArtifactLinkRequestSchema, PutTenantArtifactsRequestSchema, } from "@nylorun/core/contracts";
-import { ArtifactDiff, ArtifactTree, ArtifactLink, ArtifactView, CreateArtifactLinkRequest, DeleteArtifactResponse, ListArtifactsResponse, PutTenantArtifactsRequest, TenantArtifactsView, UploadArtifactResponse, } from "../../components.js";
+import { ArtifactLabelsSchema, ArtifactKindSchema, CreateArtifactLinkRequestSchema, PutTenantArtifactsRequestSchema, } from "@nylorun/core/contracts";
+import { ArtifactDiff, ArtifactTree, ArtifactLink, ArtifactView, ArtifactPage, CreateArtifactLinkRequest, DeleteArtifactResponse, ListArtifactsResponse, PutTenantArtifactsRequest, TenantArtifactsView, UploadArtifactResponse, } from "../../components.js";
 import { BlobRangeError } from "../../../blob/index.js";
 import { effectiveArtifactLimits, readArtifactsConfig, writeArtifactsConfig, } from "../../../artifacts/config.js";
 import { contentKey, diffManifests, entryAt, readManifest } from "../../../artifacts/folders.js";
@@ -24,10 +24,12 @@ import { zipStream, zipTooLarge } from "../../../artifacts/zip.js";
 import { normalizeContentType } from "../../../artifacts/media-types.js";
 import { artifactContent, deleteArtifact, folderContent, getArtifact, listArtifacts, readableArtifact, uploadArtifact, versionOf, } from "../../../artifacts/service.js";
 import { accessOf } from "../../../tenant/auth.js";
+import { readAccess, readStoreOf } from "../../../reads/access.js";
 import { fail } from "../../../tenant/http.js";
 import { readJson } from "../body.js";
 import { tenantRoute } from "../define.js";
 import { jsonResponse } from "../respond.js";
+import { pageQuery, parseQuery } from "./reads.js";
 /** Reading and writing artifacts: whoever may use sessions, a person only in their own. */
 const OWN = {
     credentials: ["application", "subject", "token"],
@@ -78,6 +80,15 @@ const labelQuery = z
     .union([z.string(), z.array(z.string())])
     .optional()
     .meta({ description: "`key=value`; repeat it for several labels" });
+const artifactPageQuery = pageQuery
+    .extend({
+    sessionId: z.string().optional().meta({
+        description: "Only artifacts belonging to this session; excludes Tenant-owned artifacts",
+    }),
+    kind: ArtifactKindSchema.optional(),
+    label: labelQuery,
+})
+    .strict();
 /** `label=k=v`, repeated. */
 function labelsOf(values) {
     if (values === undefined || values.length === 0)
@@ -216,7 +227,9 @@ function zipResponse(ctx, artifact, version, manifest, request) {
     const refused = zipTooLarge(manifest.entries.length, version.size);
     if (refused)
         fail(400, refused);
-    const iterator = zipStream(manifest.entries.map((entry) => ({
+    const iterator = zipStream(
+    // A v2 manifest's links and empty directories are not files: the zip holds the files.
+    manifest.entries.filter((entry) => entry.type === undefined).map((entry) => ({
         name: entry.path,
         open: async () => {
             const got = await ctx.blobs.get(contentKey(entry.sha256), { signal: request.signal });
@@ -311,13 +324,24 @@ export function artifactRoutes(api) {
         path: "/v1/artifacts",
         tags: ["Artifacts"],
         summary: "List artifacts",
-        description: "Oldest first: of one session, or of every session the caller reaches (an application key: every artifact).",
+        description: "Without limit, the existing metadata list, oldest first. Explicit limit (1–200) opts into metadata pages ordered by creation time and artifact ID descending, with an opaque nextCursor bound to the Tenant and filters. " +
+            "sessionId selects only that session's artifacts, excluding Tenant-owned artifacts. Paged reads support kind and repeated label=key=value equality filters. " +
+            "An application key as itself sees all artifacts, including Tenant-owned; a caller acting for a person sees only their sessions' artifacts of allowed agents. Authorization is checked on every page. " +
+            "Newer inserts appear on a fresh traversal, not in pages already passed.",
         request: {
-            query: z.object({ sessionId: z.string().optional().meta({ description: "Only this session's" }) }),
+            query: artifactPageQuery,
+        },
+        responses: {
+            200: json(z.union([ListArtifactsResponse, ArtifactPage]), "The artifacts; explicit limit opts into pagination"),
         },
-        responses: { 200: json(ListArtifactsResponse, "The artifacts") },
     }, async (c) => {
         const sessionId = c.req.query("sessionId");
+        if (c.req.query("limit") !== undefined) {
+            const { limit, cursor, kind } = parseQuery(artifactPageQuery, c.req.query());
+            if (limit === undefined)
+                return fail(400, "Pagination requires limit");
+            return jsonResponse(200, await readStoreOf(c.env.tenant).artifacts({ sessionId, kind, labels: labelsOf(c.req.queries("label")) ?? {} }, { limit, cursor }, readAccess(c.get("scope"))));
+        }
         return jsonResponse(200, await listArtifacts(c.env.tenant, sessionId === undefined ? {} : { sessionId }, accessOf(c.get("scope"))));
     });
     tenantRoute(api, OWN, {
@@ -456,9 +480,12 @@ export function artifactRoutes(api) {
         path: "/v1/artifacts/{artifactId}",
         tags: ["Artifacts"],
         summary: "Delete an artifact",
-        description: "Deletes every version and its bytes; its links stop working. A session's artifact gets `artifact.deleted` in its history.",
+        description: "Deletes every version and its bytes; its links stop working. A session's artifact gets `artifact.deleted` in its history. An Environment's disk versions are deleted through `/v1/environments/{environmentId}/versions/{version}` (`409` here).",
         request: { params: artifactId },
-        responses: { 200: json(DeleteArtifactResponse, "Deleted") },
+        responses: {
+            200: json(DeleteArtifactResponse, "Deleted"),
+            409: { description: "The artifact holds an Environment's disk versions" },
+        },
     }, async (c) => jsonResponse(200, await deleteArtifact(c.env.tenant, c.req.param("artifactId"), accessOf(c.get("scope")))));
     tenantRoute(api, LINK, {
         method: "get",

package/dist/api/http/routes/coverage.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `POST /v1/tenant/credential-coverage` (the Management API): what a session of a saved agent
+ * would send for each URL it names, in a given Environment. A dry run of each call's credential
+ * choice (`VaultService.coverage`); no secret is read. An Environment's secrets themselves are
+ * written on the Runtime API (`/v1/environments/{id}/secrets`, `routes/environments.ts`).
+ */
+import type { OpenAPIHono } from "@hono/zod-openapi";
+import type { TenantEnv } from "../app.js";
+export declare function coverageRoutes(api: OpenAPIHono<TenantEnv>): void;

package/dist/api/http/routes/coverage.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { CredentialCoverageRequestSchema } from "@nylorun/core/contracts";
+import { CredentialCoverage, CredentialCoverageRequest, Rejected } from "../../components.js";
+import { readJson } from "../body.js";
+import { tenantRoute } from "../define.js";
+import { jsonResponse } from "../respond.js";
+import { fail } from "../../../tenant/http.js";
+/** A Management API route: a management key. */
+const MANAGEMENT = { credentials: ["management"], scopes: "never" };
+const json = (schema, description) => ({
+    description,
+    content: { "application/json": { schema } },
+});
+export function coverageRoutes(api) {
+    tenantRoute(api, MANAGEMENT, {
+        method: "post",
+        path: "/v1/tenant/credential-coverage",
+        tags: ["Environments"],
+        summary: "Check an agent's credentials against an Environment",
+        description: "For each remote MCP server and each HTTP tool with a `credential` that the saved agent `agentId` declares (its own, its agents used as tools' and a flow's), the credential a session that names `environmentId` would send: the Environment's secret bound to the URL (`covered`), or none (`missing`). No secret is read and no server is called.",
+        request: {
+            body: { required: true, content: { "application/json": { schema: CredentialCoverageRequest } } },
+        },
+        responses: {
+            200: json(CredentialCoverage, "One entry per declared URL"),
+            404: json(Rejected, "No such agent, or no such Environment"),
+        },
+    }, async (c) => {
+        const request = CredentialCoverageRequestSchema.parse(await readJson(c.req.raw));
+        const tenant = c.env.tenant;
+        const definition = (await tenant.store.tx((t) => t.get("definitions", request.agentId))) ?? fail(404, "Definition not found");
+        return jsonResponse(200, await tenant.vault.coverage(definition.manifest, request));
+    });
+}

package/dist/api/http/routes/environment-manifests.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Environment manifests (`/v1/environment-manifests/**`, protocol 14, D63): save, read, list and
+ * delete the named, versioned definitions Environments are made from. A save never changes an
+ * Environment. Reading needs what reading an Environment needs; saving and deleting need
+ * `environments:write`, from any client (Q12).
+ */
+import type { OpenAPIHono } from "@hono/zod-openapi";
+import type { TenantEnv } from "../app.js";
+export declare function environmentManifestRoutes(api: OpenAPIHono<TenantEnv>): void;