@nylorun/runtime 0.23.0-beta → 0.24.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 { 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, 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, 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,19 @@ 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 EnvironmentSnapshot = named("EnvironmentSnapshot", EnvironmentSnapshotSchema);
+export const RestoreEnvironmentRequest = named("RestoreEnvironmentRequest", RestoreEnvironmentRequestSchema);
+export const EnvironmentRestore = named("EnvironmentRestore", EnvironmentRestoreSchema);
+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 +49,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 +70,21 @@ 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 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 +98,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.js

@@ -40,7 +40,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

@@ -146,6 +146,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 +221,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 +260,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 +367,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,14 @@ 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 { 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 +44,11 @@ function build() {
     });
     sessionRoutes(api);
     fileRoutes(api);
-    sandboxRoutes(api);
+    environmentRoutes(api);
     artifactRoutes(api);
     tenantRoutes(api);
     keyRoutes(api);
-    vaultRoutes(api);
+    coverageRoutes(api);
     mcpRoutes(api);
     accessRoutes(api);
     meRoutes(api);

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/environments.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Environments (`/v1/environments/**`, protocol 11, D55, D56): create, find or change one by id,
+ * read it, list them by label, read its lifecycle stream, stop, reset and delete it, and write
+ * its vault's secrets. Ids may hold `/`, sent percent-encoded as one path segment
+ * (`users%2Falice%2Fweb`). A token caller reaches only the ids its Environment grants match,
+ * and changes them only with `environments:write`. Secret values are write-only: no route reads
+ * one back.
+ */
+import type { OpenAPIHono } from "@hono/zod-openapi";
+import type { TenantEnv } from "../app.js";
+export declare function environmentRoutes(api: OpenAPIHono<TenantEnv>): void;