@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/store/postgres/store.js

@@ -52,10 +52,12 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { and, count, desc, eq, getTableColumns, gte, gt, inArray, isNotNull, isNull, lt, lte, ne, or, sql, } from "drizzle-orm";
 import { appendEnvironmentEvent, appendEvent } from "../../record/index.js";
+import { readRuntimeLimits } from "../../tenant/runtime-limits.js";
 import { OwnershipLostError, PrincipalRoleConflict } from "../ownership.js";
 import { followControlSignals, pruneSignals, writeSignal } from "./control.js";
 import { database, driverError } from "./db.js";
 import { expectedSchemaVersion, readSchemaVersion } from "./migrate.js";
+import { hostTuning } from "../../tuning.js";
 import { createPostgresRecordReader } from "./record.js";
 import { postgresEnvironmentRecordWriter, postgresRecordWriter } from "./record-writer.js";
 import { artifacts, artifactVersions, artifactContent, definitionFiles, definitionFileUses, commands, definitions, effects, links, modelBudgets, modelUsage, principals, sandboxes, environmentEvents, environments, environmentManifests, sessionEvents, sessionLogHeads, sessions, toJson, toolCrossings, signingKeys, tenant, tenantSettings, vaultAudit, vaultCredentials, vaultIdempotency, vaults, sandboxSignals, wakes, } from "./schema.js";
@@ -63,8 +65,8 @@ export function createPostgresSessionStore(options) {
     return new PostgresSessionStore(options);
 }
 const OPEN_SESSION = ["running", "runnable"];
-/** Rows per statement when a folder version names many files. */
-const CONTENT_BATCH = 1000;
+/** Rows per statement when a folder version or a definition names many files (Host tuning). */
+const contentBatch = () => hostTuning().postgres.contentBatchRows;
 const DOCUMENTS = {
     definitions,
     sessions: sessions,
@@ -430,6 +432,7 @@ class PostgresTx {
             type,
             payload,
             ...(writer ? { writer } : {}),
+            maxEntryBytes: await this.maxEntryBytes(),
         });
         this.events.push(event);
         this.generations.push(generation);
@@ -770,16 +773,22 @@ class PostgresTx {
             time: this.now(),
             type,
             payload,
+            maxEntryBytes: await this.maxEntryBytes(),
         });
     }
+    /** The Tenant's Runtime limit `recordEntryBytes`, read in this transaction for each write. */
+    async maxEntryBytes() {
+        return (await readRuntimeLimits(this)).recordEntryBytes;
+    }
     async environmentEvents(environmentId, options = {}) {
         this.check();
-        const rows = await this.db
+        const query = this.db
             .select({ body: environmentEvents.body })
             .from(environmentEvents)
             .where(and(eq(environmentEvents.environmentId, environmentId), options.fromSeq === undefined ? undefined : gte(environmentEvents.seq, options.fromSeq), options.types === undefined ? undefined : inArray(environmentEvents.type, [...options.types]), options.since === undefined ? undefined : gte(environmentEvents.committedAt, options.since), options.until === undefined ? undefined : lt(environmentEvents.committedAt, options.until)))
             .orderBy(environmentEvents.seq)
-            .limit(options.limit ?? 1000);
+            .$dynamic();
+        const rows = await (options.limit === undefined ? query : query.limit(options.limit));
         return rows.map((row) => row.body);
     }
     async effectBodies(where) {
@@ -1181,6 +1190,11 @@ class PostgresTx {
             .where(and(eq(artifactVersions.artifactId, artifactId), eq(artifactVersions.version, version)));
         return row;
     }
+    async artifactVersionByWriteKey(writeKey) {
+        this.check();
+        const [row] = await this.db.select().from(artifactVersions).where(eq(artifactVersions.writeKey, writeKey));
+        return row;
+    }
     async artifactVersions(artifactId) {
         this.check();
         return this.db
@@ -1220,21 +1234,32 @@ class PostgresTx {
         this.check();
         await this.db.execute(sql `SELECT pg_advisory_xact_lock(hashtext('nylorun.artifacts'))`);
     }
-    async artifactBytes() {
+    /** The artifacts of Environment `environmentId`: its disk versions, and its sessions'. */
+    artifactsOfEnvironment(environmentId) {
+        return or(eq(artifacts.environmentId, environmentId), inArray(artifacts.sessionId, this.db.select({ id: sessions.id }).from(sessions).where(eq(sessions.environmentId, environmentId))));
+    }
+    async artifactBytes(scope) {
         this.check();
+        const within = scope === undefined ? undefined : this.artifactsOfEnvironment(scope.environmentId);
         const [files] = await this.db
             .select({
             bytes: sql `coalesce(sum(${artifactVersions.size}), 0)::bigint`.mapWith(Number),
         })
             .from(artifactVersions)
             .innerJoin(artifacts, eq(artifacts.id, artifactVersions.artifactId))
-            .where(eq(artifacts.kind, "file"));
+            .where(within === undefined ? eq(artifacts.kind, "file") : and(eq(artifacts.kind, "file"), within));
         // A folder's files are stored once per distinct hash, however many versions name them.
-        const distinct = this.db
-            .select({ size: sql `max(${artifactContent.size})`.as("size") })
-            .from(artifactContent)
-            .groupBy(artifactContent.sha256)
-            .as("distinct_content");
+        const distinct = (within === undefined
+            ? this.db
+                .select({ size: sql `max(${artifactContent.size})`.as("size") })
+                .from(artifactContent)
+                .groupBy(artifactContent.sha256)
+            : this.db
+                .select({ size: sql `max(${artifactContent.size})`.as("size") })
+                .from(artifactContent)
+                .innerJoin(artifacts, eq(artifacts.id, artifactContent.artifactId))
+                .where(within)
+                .groupBy(artifactContent.sha256)).as("distinct_content");
         const [content] = await this.db
             .select({ bytes: sql `coalesce(sum(${distinct.size}), 0)::bigint`.mapWith(Number) })
             .from(distinct);
@@ -1242,22 +1267,26 @@ class PostgresTx {
     }
     async insertArtifactContent(artifactId, version, files) {
         this.check();
-        for (let at = 0; at < files.length; at += CONTENT_BATCH)
+        for (let at = 0; at < files.length; at += contentBatch())
             await this.db
                 .insert(artifactContent)
                 .values(files
-                .slice(at, at + CONTENT_BATCH)
+                .slice(at, at + contentBatch())
                 .map((file) => ({ artifactId, version, sha256: file.sha256, size: file.size })))
                 .onConflictDoNothing();
     }
-    async referencedArtifactContent(shas) {
+    async referencedArtifactContent(shas, scope) {
         this.check();
         const found = new Set();
-        for (let at = 0; at < shas.length; at += CONTENT_BATCH) {
-            const rows = await this.db
-                .selectDistinct({ sha256: artifactContent.sha256 })
-                .from(artifactContent)
-                .where(inArray(artifactContent.sha256, shas.slice(at, at + CONTENT_BATCH)));
+        for (let at = 0; at < shas.length; at += contentBatch()) {
+            const batch = inArray(artifactContent.sha256, shas.slice(at, at + contentBatch()));
+            const rows = scope === undefined
+                ? await this.db.selectDistinct({ sha256: artifactContent.sha256 }).from(artifactContent).where(batch)
+                : await this.db
+                    .selectDistinct({ sha256: artifactContent.sha256 })
+                    .from(artifactContent)
+                    .innerJoin(artifacts, eq(artifacts.id, artifactContent.artifactId))
+                    .where(and(batch, this.artifactsOfEnvironment(scope.environmentId)));
             for (const row of rows)
                 found.add(row.sha256);
         }
@@ -1302,23 +1331,23 @@ class PostgresTx {
     }
     async heldDefinitionFiles(shas) {
         this.check();
-        const found = new Set();
-        for (let at = 0; at < shas.length; at += CONTENT_BATCH) {
+        const found = new Map();
+        for (let at = 0; at < shas.length; at += contentBatch()) {
             const rows = await this.db
-                .select({ sha256: definitionFiles.sha256 })
+                .select({ sha256: definitionFiles.sha256, size: definitionFiles.size })
                 .from(definitionFiles)
-                .where(inArray(definitionFiles.sha256, shas.slice(at, at + CONTENT_BATCH)));
+                .where(inArray(definitionFiles.sha256, shas.slice(at, at + contentBatch())));
             for (const row of rows)
-                found.add(row.sha256);
+                found.set(row.sha256, row.size);
         }
         return found;
     }
     async insertDefinitionFileUses(agentId, manifestHash, shas) {
         this.check();
-        for (let at = 0; at < shas.length; at += CONTENT_BATCH)
+        for (let at = 0; at < shas.length; at += contentBatch())
             await this.db
                 .insert(definitionFileUses)
-                .values(shas.slice(at, at + CONTENT_BATCH).map((sha256) => ({ agentId, manifestHash, sha256 })))
+                .values(shas.slice(at, at + contentBatch()).map((sha256) => ({ agentId, manifestHash, sha256 })))
                 .onConflictDoNothing();
     }
     // --- settings ------------------------------------------------------------

package/dist/store/types.d.ts

@@ -408,7 +408,7 @@ export type ControlSignal = {
     epoch: number;
 };
 export interface FollowSignalsOptions {
-    /** How often recent signals are read back. Default 5 s. */
+    /** How often recent signals are read back. Default `postgres.controlPollMs` (Host tuning, 5 s). */
     pollMs?: number;
     onError?: (error: unknown) => void;
 }
@@ -732,6 +732,8 @@ export interface Tx {
     /** One version, or every version oldest first. */
     artifactVersion(artifactId: string, version: number): Promise<ArtifactVersionRow | undefined>;
     artifactVersions(artifactId: string): Promise<ArtifactVersionRow[]>;
+    /** The version a harness write with this key stored (`artifact_versions.write_key`), if any. */
+    artifactVersionByWriteKey(writeKey: string): Promise<ArtifactVersionRow | undefined>;
     /** Deletes the artifact and its versions; returns the versions' blob keys (empty when none). */
     deleteArtifact(id: string): Promise<string[]>;
     /**
@@ -746,9 +748,12 @@ export interface Tx {
     lockArtifactQuota(): Promise<void>;
     /**
      * The bytes the artifacts store: every file version, plus each distinct content-addressed file
-     * of the folders once (F8.2).
+     * of the folders once (F8.2). With `environmentId`, only that Environment's artifacts: its disk
+     * versions and its sessions' artifacts.
      */
-    artifactBytes(): Promise<number>;
+    artifactBytes(scope?: {
+        environmentId: string;
+    }): Promise<number>;
     /**
      * The blob keys of every artifact version (a folder's: its manifests): of session artifacts
      * only, or of all of them.
@@ -759,8 +764,13 @@ export interface Tx {
         sha256: string;
         size: number;
     }[]): Promise<void>;
-    /** Those of `shas` some committed folder version references. */
-    referencedArtifactContent(shas: readonly string[]): Promise<Set<string>>;
+    /**
+     * Those of `shas` some committed folder version references; with `environmentId`, a version
+     * of one of that Environment's artifacts.
+     */
+    referencedArtifactContent(shas: readonly string[], scope?: {
+        environmentId: string;
+    }): Promise<Set<string>>;
     /**
      * The distinct content-addressed files folder versions reference: of one artifact, of session
      * artifacts only, or of all of them.
@@ -772,8 +782,8 @@ export interface Tx {
     definitionFile(sha256: string): Promise<DefinitionFileRow | undefined>;
     /** Records a stored definition file; false when the Tenant held it already. */
     insertDefinitionFile(row: DefinitionFileRow): Promise<boolean>;
-    /** Those of `shas` the Tenant holds. */
-    heldDefinitionFiles(shas: readonly string[]): Promise<Set<string>>;
+    /** Those of `shas` the Tenant holds, with each one's size in bytes. */
+    heldDefinitionFiles(shas: readonly string[]): Promise<Map<string, number>>;
     /** Records that version `manifestHash` of definition `agentId` names each of `shas`. */
     insertDefinitionFileUses(agentId: string, manifestHash: string, shas: readonly string[]): Promise<void>;
     getSetting(key: string): Promise<string | undefined>;

package/dist/streams/relay/core.d.ts

@@ -6,11 +6,11 @@ export interface StreamRelayOptions {
     streams: DurableStreams;
     /** Relay events: lag, errors, reconciliations. */
     log?: (message: string, fields?: Record<string, unknown>) => void;
-    /** Records per append (S2 allows 1000). */
+    /** Records per append (S2 allows 1000). Default `streams.relayBatchRecords` (Host tuning, 500). */
     maxBatchRecords?: number;
-    /** Bytes per append (S2 allows 1 MiB). */
+    /** Bytes per append (S2 allows 1 MiB). Default `streams.relayBatchBytes` (768 KiB). */
     maxBatchBytes?: number;
-    /** Sessions reconciled at once. */
+    /** Sessions reconciled at once. Default `streams.relayReconcileConcurrency` (8). */
     reconcileConcurrency?: number;
 }
 export interface StreamRelayStatus {

package/dist/streams/relay/core.js

@@ -23,17 +23,16 @@
  * The relay never writes the record and never deletes from S2.
  */
 import { sleep } from "../../retry.js";
+import { hostTuning } from "../../tuning.js";
 import { basinOf } from "../basin.js";
 import { sessionStream } from "../types.js";
-const RETRY_MIN_MS = 50;
-const RETRY_MAX_MS = 2000;
-const HEADS_PAGE = 500;
 export function createStreamRelay(options) {
     const { source, record, streams } = options;
     const log = options.log ?? (() => { });
-    const maxRecords = options.maxBatchRecords ?? 500;
-    const maxBytes = options.maxBatchBytes ?? 768 * 1024;
-    const concurrency = options.reconcileConcurrency ?? 8;
+    const tuning = hostTuning().streams;
+    const maxRecords = options.maxBatchRecords ?? tuning.relayBatchRecords;
+    const maxBytes = options.maxBatchBytes ?? tuning.relayBatchBytes;
+    const concurrency = options.reconcileConcurrency ?? tuning.relayReconcileConcurrency;
     /** Committed transactions not yet fully in S2, in commit order. */
     const txs = [];
     const sessions = new Map();
@@ -101,7 +100,7 @@ export function createStreamRelay(options) {
     }
     async function pump(queue) {
         queue.running = true;
-        let delay = RETRY_MIN_MS;
+        let delay = tuning.relayRetry.minMs;
         try {
             while (queue.rows.length > 0 && !stopped) {
                 // Duplicates (a replay overlapping a refill) and stale rows sort out here.
@@ -122,7 +121,7 @@ export function createStreamRelay(options) {
                         // S2 is behind the record: re-send the gap first.
                         await refill(queue, first.generation, result.tail, first.seq);
                     }
-                    delay = RETRY_MIN_MS;
+                    delay = tuning.relayRetry.minMs;
                     lastError = null;
                 }
                 catch (error) {
@@ -143,7 +142,7 @@ export function createStreamRelay(options) {
                     // The basin may be missing (S2 lost it, or it was never created).
                     await streams.ensureTenant(basin).catch(() => undefined);
                     await sleep(delay, stopping.signal);
-                    delay = Math.min(delay * 2, RETRY_MAX_MS);
+                    delay = Math.min(delay * 2, tuning.relayRetry.maxMs);
                 }
             }
         }
@@ -243,7 +242,7 @@ export function createStreamRelay(options) {
         for (;;) {
             if (!current())
                 return false;
-            const page = await record.heads(after, HEADS_PAGE);
+            const page = await record.heads(after, tuning.relayHeadsPage);
             if (page.length === 0)
                 break;
             let next = 0;

package/dist/tenant/advance.js

@@ -47,15 +47,16 @@ import { endAdvance } from "./scheduler.js";
 import { harnessOf } from "./context.js";
 import { HARNESS_ID } from "../sandbox/placement.js";
 import { recoversModelCalls } from "./effects.js";
+import { contextCompacted } from "./transcript.js";
 import { slimModelEffects } from "./slim.js";
 import { applyUpdates, leanState, transcriptShadow, withTranscript, } from "./history.js";
 import { command } from "./commands.js";
-import { exportOutputs } from "../artifacts/export.js";
 import { dropRunGrant, grantRun } from "./run-grants.js";
 import { startHeartbeat } from "../harness-api/renew.js";
 import { buildTurnStart, startSegment } from "../harness-api/start.js";
 import { touchEnvironment } from "./environments.js";
 import { endTurn, pauseTurn } from "./turn-timing.js";
+import { hostTuning } from "../tuning.js";
 import { AdvanceAbort, AdvanceDeadlineError, abortKind, } from "./worker.js";
 /**
  * A segment stopped by a `shutdown` or `ownership.lost` abort before it settled. Never
@@ -95,15 +96,6 @@ class HarnessUnavailable extends Error {
     }
 }
 const DONE = { status: "done" };
-/** How soon an advance whose segment no harness took is tried again. */
-const UNAVAILABLE_RETRY_MS = 1000;
-/**
- * How long a pod sandbox's segment waits for its engine (F7.2): a pod that is starting, or
- * resuming, takes longer than a harness that is already connected.
- */
-const POD_OFFER_WAIT_MS = 60_000;
-/** Shortest `busy` retry, so a lease about to lapse is not polled in a tight loop. */
-const MIN_RETRY_MS = 25;
 /**
  * Advance session `id` if it has a runnable checkpoint (`WorkerHandlers.advance`). Returns
  * `busy` when another advance holds a live lease, `done` otherwise.
@@ -115,7 +107,10 @@ export async function advance(ctx, id, signal) {
     if (taken.status === "busy")
         return {
             status: "busy",
-            retryAfterMs: Math.min(Math.max(Date.parse(taken.ownerExpiresAt) - Date.now(), MIN_RETRY_MS), ctx.ownerLeaseMs),
+            retryAfterMs: Math.min(
+            // The shortest `busy` retry (`tenant.busyRetryMinMs`), so a lease about to lapse is not
+            // polled in a tight loop.
+            Math.max(Date.parse(taken.ownerExpiresAt) - Date.now(), hostTuning().tenant.busyRetryMinMs), ctx.ownerLeaseMs),
         };
     if (taken.status === "idle")
         return DONE;
@@ -152,7 +147,7 @@ export async function advance(ctx, id, signal) {
                 sessionId: id,
                 epoch: lease.epoch,
             });
-            result = { status: "busy", retryAfterMs: UNAVAILABLE_RETRY_MS };
+            result = { status: "busy", retryAfterMs: hostTuning().tenant.unavailableRetryMs };
         }
         else if (error instanceof SegmentStopped && error.kind === "shutdown") {
             // Left for the next advance, which resumes from the checkpoint once this one releases.
@@ -302,7 +297,8 @@ async function runRemoteSegment(ctx, lease, started, controller, run, onTaken, p
             onTaken,
             // Only a connection of the session's harness takes its runs (R4.1).
             harness: harnessOf(segment.current),
-            ...(pod === undefined ? {} : { pod, waitMs: POD_OFFER_WAIT_MS }),
+            // A pod that is starting, or resuming, takes longer than a harness already connected.
+            ...(pod === undefined ? {} : { pod, waitMs: hostTuning().harnessApi.podOfferWaitMs }),
         });
         if (end.kind === "unavailable") {
             // A pod stopped, or not yet started: make sure it is asked to run.
@@ -313,9 +309,6 @@ async function runRemoteSegment(ctx, lease, started, controller, run, onTaken, p
         // Aborted before a harness took it: settled as an abort of the engine would be.
         if (end.kind === "aborted")
             throw signal.reason;
-        // The harness's own tools take names of this turn's tools (Harness API 3): the turn fails.
-        if (end.kind === "refused")
-            throw new Error(end.message);
         // Checked before the abort: whatever core's signal says, the run's effects are unaccounted for.
         if (end.kind === "released" && end.reason === "connection.lost")
             throw new RunLost();
@@ -333,7 +326,7 @@ async function runRemoteSegment(ctx, lease, started, controller, run, onTaken, p
             await settleFailure(ctx, lease, started, signal.reason);
         else {
             const recorded = result.status === "yielded" || result.status === "completed" || result.status === "paused";
-            cursor = await settleTurn(ctx, lease, started, result, recorded ? output.transcript ?? [] : [], signal, segment.cursor, 
+            cursor = await settle(ctx, lease, started, result, recorded ? output.transcript ?? [] : [], segment.cursor, 
             // The turn's end and its transcript are what the harness reported (R4.9).
             { source: { kind: "harness", id: harnessOf(started) }, evidence: "claimed", runId: output.runId });
         }
@@ -419,17 +412,6 @@ async function wakeWorkflowOf(ctx, t, agent, turnId, type, payload) {
             error: "Agent turn was cancelled",
         });
 }
-/**
- * `settle`, then, for a completed turn, the turn-end export of its sandbox outputs (F8.2): after
- * the turn has committed and while the advance still holds the lease. The harness hears back
- * after the export. The export never throws.
- */
-async function settleTurn(ctx, lease, s, result, updates, signal, cursor, writer) {
-    const kept = await settle(ctx, lease, s, result, updates, cursor, writer);
-    if (result.status === "completed")
-        await exportOutputs(ctx, lease.sessionId, s.activeTurnId, signal);
-    return kept;
-}
 /**
  * Record a segment result, then cancel failed siblings and wake a linked workflow. Returns the
  * cursor of the transcript it recorded (`cursor` when it recorded no edit), or undefined when
@@ -613,6 +595,10 @@ async function heldCalls(t, effectIds) {
         const request = row.request;
         const context = (request.context ?? {});
         const toolName = request.toolName ?? request.key ?? effectId;
+        // A person approves the tool by its identity (protocol 15): an MCP tool by server and tool.
+        const what = row.server !== undefined && row.tool !== undefined && row.toolKind === "mcp"
+            ? `${row.server} / ${row.tool}`
+            : (row.tool ?? toolName);
         const reason = row.hold?.reason ?? "The Tenant's tool policy asks a person about this call";
         held.push({
             invocationId: typeof context.invocationId === "string" ? context.invocationId : effectId,
@@ -620,9 +606,10 @@ async function heldCalls(t, effectIds) {
             interaction: {
                 id: effectId,
                 kind: "approval",
-                prompt: `Approve ${toolName}?`,
+                prompt: `Approve ${what}?`,
                 reason,
                 ...(row.server === undefined ? {} : { server: row.server }),
+                ...(row.tool === undefined ? {} : { tool: row.tool }),
                 input: request.input ?? null,
             },
             status: "interaction",
@@ -668,13 +655,16 @@ function leanCheckpoint(session, checkpoint) {
     return { ...checkpoint, state: leanOf(session, state) };
 }
 /**
- * Appends a segment's transcript edits; a snapshot moves `history.snapshot`. Returns the seq of
- * the last edit, if any.
+ * Appends a segment's transcript edits; a snapshot moves `history.snapshot`. An edit the harness
+ * marks as a compaction (`kind: "compaction"`, Q4) also writes `context.compacted`, from its facts
+ * and the summary calls it names. Returns the seq of the last edit, if any.
  */
 async function recordTranscript(t, id, turnId, s, updates, writer) {
     let last;
     for (const update of updates) {
         const event = await t.event(id, turnId, "transcript.updated", update, writer);
+        if ("compaction" in update)
+            await t.event(id, turnId, "context.compacted", await contextCompacted(t, id, turnId, update.compaction), writer);
         if (update.keep === 0)
             s.history = { from: s.history?.from ?? event.seq, snapshot: event.seq };
         last = event.seq;

package/dist/tenant/commands.js

@@ -28,7 +28,6 @@ import { checkEnvironmentTurn } from "./environments.js";
 import { turnManifestOf, variantStore } from "./session.js";
 import { slimModelEffects } from "./slim.js";
 import { resolveMessageParts } from "../artifacts/parts.js";
-import { currentModelInputs } from "../model/catalog.js";
 import { endTurn, resumeTurn, startTurn } from "./turn-timing.js";
 /** A command's identity for idempotency: everything but the request id. */
 const semantic = (value) => {
@@ -43,11 +42,6 @@ export async function command(ctx, id, input, scope,
 options = {}) {
     const { store } = ctx;
     const cascadeCancelIds = [];
-    // What the Tenant's model reads, for a message that names a file (protocol 12): read before
-    // the session's transaction. Undefined without a model in the vault: nothing is refused.
-    const inputs = input.type === "message" && "parts" in input && input.parts.some((part) => part.type === "file")
-        ? await currentModelInputs(ctx)
-        : undefined;
     const response = await store.tx(async (t) => {
         const s = await lockedSession(t, id, accessOf(scope));
         const command = input;
@@ -134,12 +128,14 @@ options = {}) {
             }
         }
         else {
-            // A session opened before protocol 11 (migration 0020) or 13 (migration 0024) keeps its
-            // history but takes no turn.
+            // A session opened before protocol 11 (migration 0020), 13 (migration 0024) or 15
+            // (migrations 0029, 0030) keeps its history but takes no turn.
             if (s.closedReason !== undefined)
                 fail(409, s.closedReason === "protocol_11"
                     ? "This session was opened before protocol 11: open a new session that names an Environment."
-                    : "This session was opened before protocol 13, on a manifest the Runtime no longer runs: register the agent again (manifest 7) and open a new session.", { code: "session_closed" });
+                    : s.closedReason === "protocol_15"
+                        ? "This session was opened before protocol 15, and its pinned manifest holds a runtime block: our harness now writes the model's instructions and defines its tools itself. Open a new session."
+                        : "This session was opened before protocol 13, on a manifest the Runtime no longer runs: register the agent again (manifest 7) and open a new session.", { code: "session_closed" });
             if (command.type === "message") {
                 if (!["idle", "completed", "failed", "cancelled"].includes(s.status))
                     fail(409, "Session has active or unresolved work");
@@ -156,15 +152,12 @@ options = {}) {
                     s.turnTrace = options.trace;
                 else
                     delete s.turnTrace;
-                // File parts name artifacts the caller may read; each is pinned to a version now. An
-                // agent's model must read each one (a workflow passes them on as data).
+                // File parts name artifacts the caller may read; each is pinned to a version now. Any
+                // file goes (protocol 15): the harness decides how the model sees it, and a workflow
+                // passes it on as data.
                 const parts = "parts" in command
-                    ? await resolveMessageParts(t, command.parts, id, accessOf(scope), isWorkflowManifest(s.manifest) ? undefined : inputs)
+                    ? await resolveMessageParts(t, command.parts, id, accessOf(scope))
                     : undefined;
-                if (parts && parts.refused.length > 0)
-                    fail(422, `The model does not read ${parts.refused
-                        .map((part) => `${part.name} (${part.reason})`)
-                        .join(", ")}.`, { code: "attachment_unsupported", details: { parts: parts.refused } });
                 // The files the session's messages named: `read_artifact` reads them again (protocol 12).
                 if (parts) {
                     const named = parts.pinned.flatMap((part) => (part.type === "file" ? [part.artifactId] : []));

package/dist/tenant/context.d.ts

@@ -19,8 +19,6 @@ import type { IssuerScope, SubjectScope, TenantEnvelope } from "@nylorun/core/co
 import type { DurableCheckpoint, FlowCheckpoint } from "@nylorun/harness/run";
 import type { AgentManifest, JsonValue, SandboxManifest } from "@nylorun/core/define";
 import type { OutboxRequest, SessionStore, Tx } from "../store/types.js";
-import type { FlowLimits } from "../core/limits.js";
-import type { ModelProvider } from "../core/provider.js";
 import type { ModelGate } from "../gates/model-gate.js";
 import type { ToolGate } from "../gates/tool-gate.js";
 import type { Keys } from "../keys/keys.js";
@@ -37,7 +35,6 @@ import type { StuckInvocation, Wake } from "../execution/types.js";
 import type { WorkState } from "./scheduler.js";
 import type { SigningKeys } from "./signing-keys.js";
 import type { BlobStore } from "../blob/index.js";
-import type { WorkspaceReader } from "../artifacts/workspace.js";
 import type { RunGrants } from "./run-grants.js";
 import type { TraceOptions } from "../traces/options.js";
 import type { TraceContext } from "../traces/ids.js";
@@ -49,8 +46,8 @@ export interface Session {
     manifest: any;
     manifestHash: string;
     /**
-     * The hash of the definition the session was opened from; `manifestHash` differs when the
-     * Runtime pinned its `runtime` block on it (R2b C11). Absent on older sessions.
+     * The hash of the definition the session was opened from (R2b C11); since protocol 15 it equals
+     * `manifestHash`. Absent on older sessions.
      */
     definitionHash?: string;
     /** Validated turn-manifest variants, keyed by hash (loops.md §4.2). */
@@ -115,8 +112,9 @@ export interface Session {
     sandbox?: SandboxManifest;
     /**
      * Why the session takes no new turn: `protocol_11` for a session opened before protocol 11
-     * (migration 0020), `protocol_13` for one opened before protocol 13 (migration 0024). Its
-     * history stays readable.
+     * (migration 0020), `protocol_13` for one opened before protocol 13 (migration 0024),
+     * `protocol_15` for an agent session that pinned a `runtime` block before protocol 15
+     * (migrations 0029, 0030). Its history stays readable.
      */
     closedReason?: string;
     /**
@@ -185,11 +183,15 @@ export interface TenantContext {
      * else the harness that serves workspaces (`harness-api/workspace.ts`).
      */
     readonly sandbox: WorkspacePort;
-    readonly flowLimits: FlowLimits;
-    readonly modelProvider: ModelProvider;
-    /** True when the model comes from the Tenant vault selection, served by `modelGate`. */
-    readonly useVaultModel: boolean;
-    /** Serves vault-backed model calls (blueprint §15): in this process, or the gates service. */
+    /**
+     * True when the Runtime's model is not the vault's (scripted, the fixture model, an embedder's
+     * provider): `modelGate` serves it, and no vault model need be configured.
+     */
+    readonly scriptedModel: boolean;
+    /**
+     * Serves every model call (blueprint §15, protocol 15): the vault's model in this process or
+     * the gates service, or a scripted model (`providerModelGate`).
+     */
     readonly modelGate: ModelGate;
     /**
      * Serves remote MCP servers and HTTP tools (blueprint §12, F4.1): in this process, or the
@@ -208,11 +210,6 @@ export interface TenantContext {
      * they mean, and a blob counts once a committed row names its key.
      */
     readonly blobs: BlobStore;
-    /**
-     * How core reads a session's sandbox workspace at turn end, to export its outputs (F8.2): over
-     * this process's `sandbox` today; over the Harness API's `workspace.read` from F6.2.
-     */
-    readonly workspaces: WorkspaceReader;
     /**
      * How the trace route (R7.5) makes spans: the resource and the content the installation exports
      * (R7.2). Absent: `service.name` `nylorun`, no content.

package/dist/tenant/definition-files.d.ts

@@ -1,5 +1,5 @@
 import { type DefinitionFileView } from "@nylorun/core/contracts";
-import type { BlobStore } from "../blob/index.js";
+import { type BlobStore } from "../blob/index.js";
 import type { Tx } from "../store/types.js";
 import type { TenantContext } from "./context.js";
 /** Where a definition file's bytes are in the Object store. */
@@ -8,7 +8,10 @@ export declare function definitionFileKey(sha256: string): string;
 export declare function hasDefinitionFile(ctx: TenantContext, file: string): Promise<boolean>;
 /**
  * Stores the bytes of definition file `file`: `201` when they are new, `200` when the Tenant
- * holds them already (the body is not read). Bytes that do not hash to `file` are a `400`.
+ * holds them already (the body is not read). Bytes that do not hash to `file` are a `400`; more
+ * than the Tenant's skill limit (`skills.config`) a `413`. The body streams to a staging key and is copied to
+ * the file's key only once its hash is checked, so no file is held in memory and bytes of
+ * another hash never replace a file at its key.
  */
 export declare function putDefinitionFile(ctx: TenantContext, file: string, request: {
     body: ReadableStream<Uint8Array> | null;
@@ -18,7 +21,25 @@ export declare function putDefinitionFile(ctx: TenantContext, file: string, requ
     status: 200 | 201;
     view: DefinitionFileView;
 }>;
-/** The definition files `document` names that the Tenant does not hold, in order. */
-export declare function missingDefinitionFiles(t: Tx, document: unknown): Promise<string[]>;
+/**
+ * Why `document` cannot be stored for the files it names: the files the Tenant does not hold
+ * (`missing`), else each skill whose files hold more than `limitBytes` together (`oversized`).
+ * A file a skill names at two paths counts twice: a sandbox holds both.
+ */
+export declare function definitionFileIssues(t: Tx, document: unknown, limitBytes: number): Promise<{
+    missing: string[];
+    oversized: {
+        name: string;
+        bytes: number;
+    }[];
+}>;
+/** A definition file's bytes as a stream, or undefined when the Object store does not have them. */
+export declare function openDefinitionFile(blobs: BlobStore, sha256: string, options?: {
+    range?: {
+        start: number;
+        end?: number;
+    };
+    signal?: AbortSignal;
+}): Promise<ReadableStream<Uint8Array> | undefined>;
 /** A definition file's bytes, or undefined when the Object store does not have them. */
 export declare function readDefinitionFile(blobs: BlobStore, sha256: string, signal?: AbortSignal): Promise<Uint8Array | undefined>;