@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/harness-api/artifacts.js

@@ -0,0 +1,478 @@
+/**
+ * The artifact seam of the Harness API (protocol 15): a harness reads and writes the artifacts
+ * of the run it holds, and nothing else. Our engine's `read_artifact` and `save_artifact` run in
+ * the harness over it; any harness may use it.
+ *
+ * - **Scope.** The run's session (`run.grant.sessionId`), never a parameter: agents used as tools
+ *   share it. A read follows the read rule (`sessionMayRead`): the session's own artifacts and the
+ *   Tenant-wide ones its messages named. Anything else, missing or not, is the same `not_found`.
+ *   A write makes an artifact of the session, or a new version of one of its own file artifacts.
+ * - **Chunks.** No answer or chunk carries more than the run's `limits.chunkBytes`: a read is
+ *   clamped to it, a chunk past it is `limit_exceeded`.
+ * - **Uploads stream.** `begin` starts the upload (`uploadArtifact`) with a body that takes each
+ *   chunk as it comes: a chunk is answered once the store took it, so nothing is held whole, and
+ *   the version commits in Postgres on `commit` as any upload does. The key of `begin` makes the
+ *   write idempotent within the session (`writeKeyOf`, `artifact_versions.write_key`), and its
+ *   `effectId` a tool call of the run's turn, whose call id `artifact.created` carries: core reads
+ *   it from the journal, so the harness only names the call.
+ * - **Ends.** `abort`, the run's end and core's abort of the advance stop an upload: nothing
+ *   commits.
+ * - **Folders.** `begin` with `kind: "folder"` writes a folder version of the session instead
+ *   (`artifacts/folder-upload.ts`): file by file, each checked against its hash, committed with
+ *   dedupe, and not added when it equals the folder's latest version.
+ */
+import { randomUUID } from "node:crypto";
+import { HarnessApiError } from "@nylorun/core/harness-api";
+import { limitExceededMessage, normalizeContentType } from "@nylorun/core/contracts";
+import { isArtifactId } from "@nylorun/core/compatibility";
+import { BlobRangeError } from "../blob/index.js";
+import { sessionMayRead } from "../artifacts/files.js";
+import { artifactQuota, artifactUsage, environmentOfSession } from "../artifacts/quota.js";
+import { artifactRoom, checkArtifactName, uploadArtifact, writeKeyOf, } from "../artifacts/service.js";
+import { FolderUpload } from "../artifacts/folder-upload.js";
+import { contentEpoch } from "../artifacts/folders.js";
+import { HttpError } from "../tenant/http.js";
+import { toolIds } from "../tenant/transcript.js";
+import { abortKind } from "../tenant/worker.js";
+import { Pipe } from "../artifacts/pipe.js";
+const notOurs = (artifactId) => new HarnessApiError("not_found", `Artifact ${artifactId} is not an artifact of this session.`);
+export function createArtifactSeam(ctx) {
+    const uploads = new Map();
+    const folders = new Map();
+    const folderOf = (scope, uploadId) => folders.get(scope.runId)?.get(uploadId);
+    const forgetFolder = (runId, uploadId) => {
+        const open = folders.get(runId);
+        open?.delete(uploadId);
+        if (open?.size === 0)
+            folders.delete(runId);
+    };
+    /** Opens a folder version of the session (`kind: "folder"`). */
+    const beginFolder = async (scope, params) => {
+        stopped(scope.runSignal);
+        const { sessionId } = scope;
+        harnessError(() => checkArtifactName(params.name));
+        const writeKey = writeKeyOf(sessionId, params.key);
+        const begun = await ctx.store.tx(async (t) => {
+            // A key written before answers its version: a harness repeating a write stores nothing.
+            const known = await t.artifactVersionByWriteKey(writeKey);
+            if (known) {
+                const row = await t.artifact(known.artifactId);
+                if (row)
+                    return { written: metaOf(row, known) };
+            }
+            const session = await t.get("sessions", sessionId);
+            if (!session)
+                throw new HarnessApiError("run_not_held", `Session ${sessionId} is gone`);
+            let prior;
+            if (params.artifactId !== undefined) {
+                prior = isArtifactId(params.artifactId) ? await t.artifact(params.artifactId) : undefined;
+                if (!prior || prior.kind !== "folder" || prior.sessionId !== sessionId)
+                    throw notOurs(params.artifactId);
+            }
+            else if (params.sameName)
+                prior = (await t.listArtifacts({ sessionId }))
+                    .filter((row) => row.kind === "folder" && row.name === params.name)
+                    .sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0))[0];
+            const latest = prior ? await t.artifactVersion(prior.id, prior.latestVersion) : undefined;
+            return {
+                upload: new FolderUpload(ctx, {
+                    sessionId,
+                    turnId: scope.turnId,
+                    name: params.name,
+                    ...(prior ? { prior: { row: prior, ...(latest ? { latest } : {}) } } : {}),
+                    quota: await artifactQuota(t, await environmentOfSession(t, sessionId)),
+                    epoch: await contentEpoch(t),
+                    writeKey,
+                    limits: scope.limits,
+                }),
+            };
+        });
+        if ("written" in begun)
+            return { status: "written", artifact: begun.written, created: false };
+        const upload = begun.upload;
+        const open = folders.get(scope.runId) ?? new Map();
+        folders.set(scope.runId, open);
+        open.set(upload.id, upload);
+        const end = () => {
+            forgetFolder(scope.runId, upload.id);
+            void upload.abort("the run stopped");
+        };
+        if (scope.runSignal.aborted)
+            end();
+        else
+            scope.runSignal.addEventListener("abort", end, { once: true });
+        return {
+            status: "open",
+            uploadId: upload.id,
+            maxBytes: upload.maxBytes,
+            maxFileBytes: upload.maxFileBytes,
+            maxEntries: upload.maxEntries,
+            received: 0,
+        };
+    };
+    /** One request of an open folder upload; a refusal ends the upload. */
+    const inFolder = async (scope, upload, step) => {
+        try {
+            return await step();
+        }
+        catch (error) {
+            forgetFolder(scope.runId, upload.id);
+            await upload.abort("a request of it was refused");
+            throw toHarnessError(error);
+        }
+    };
+    const folderAnswer = (upload, received) => ({
+        status: "open",
+        uploadId: upload.id,
+        maxBytes: upload.maxBytes,
+        maxFileBytes: upload.maxFileBytes,
+        maxEntries: upload.maxEntries,
+        received,
+    });
+    const stop = (upload, reason) => {
+        if (!upload.controller.signal.aborted)
+            upload.controller.abort(new Error(reason));
+        upload.pipe.fail(new HarnessApiError("invalid", `The upload ended: ${reason}`));
+    };
+    const forget = (runId, uploadId) => {
+        const open = uploads.get(runId);
+        open?.delete(uploadId);
+        if (open?.size === 0)
+            uploads.delete(runId);
+    };
+    const uploadOf = (scope, uploadId) => {
+        const upload = uploads.get(scope.runId)?.get(uploadId);
+        if (!upload)
+            throw new HarnessApiError("invalid", `No upload ${uploadId} is open for this run`);
+        return upload;
+    };
+    const begin = async (scope, params, signal) => {
+        stopped(scope.runSignal);
+        const { sessionId, limits } = scope;
+        const contentType = params.contentType === undefined ? undefined : normalizeContentType(params.contentType);
+        if (params.contentType !== undefined && contentType === undefined)
+            throw new HarnessApiError("invalid", `${params.contentType} is not a media type`);
+        if (params.artifactId === undefined)
+            harnessError(() => checkArtifactName(params.name));
+        const writeKey = writeKeyOf(sessionId, params.key);
+        const begun = await ctx.store.tx(async (t) => {
+            // A key written before answers its version: a harness repeating a write stores nothing.
+            const known = await t.artifactVersionByWriteKey(writeKey);
+            if (known) {
+                const row = await t.artifact(known.artifactId);
+                if (row)
+                    return { written: metaOf(row, known) };
+            }
+            const session = await t.get("sessions", sessionId);
+            if (!session)
+                throw new HarnessApiError("run_not_held", `Session ${sessionId} is gone`);
+            if (params.artifactId !== undefined) {
+                const prior = isArtifactId(params.artifactId) ? await t.artifact(params.artifactId) : undefined;
+                // A new version only of a file artifact of this session.
+                if (!prior || prior.kind !== "file" || prior.sessionId !== sessionId)
+                    throw notOurs(params.artifactId);
+            }
+            let callId;
+            if (params.effectId !== undefined) {
+                const row = await t.get("effects", params.effectId);
+                const request = row?.request;
+                if (!request ||
+                    request.kind !== "tool" ||
+                    request.sessionId !== sessionId ||
+                    request.turnId !== scope.turnId)
+                    throw new HarnessApiError("invalid", `Effect ${params.effectId} is not a tool call of this run's turn`);
+                const ids = toolIds(request.context);
+                if ("callId" in ids)
+                    callId = ids.callId;
+            }
+            const quota = await artifactQuota(t, await environmentOfSession(t, sessionId));
+            return {
+                owner: session.ownerUserId,
+                callId,
+                room: artifactRoom(quota, await artifactUsage(t, quota)),
+            };
+        });
+        if (begun.written)
+            return { status: "written", artifact: begun.written, created: false };
+        const refusal = begun.room.refusal(params.size);
+        if (refusal)
+            throw new HarnessApiError("limit_exceeded", `${refusal.message} (limitBytes ${refusal.limitBytes})`);
+        const input = {
+            ...(params.artifactId === undefined ? { name: params.name } : { artifactId: params.artifactId }),
+            ...(contentType === undefined ? {} : { contentType }),
+            sessionId,
+            source: "engine",
+            turnId: scope.turnId,
+            ...(begun.callId === undefined ? {} : { callId: begun.callId }),
+            writeKey,
+        };
+        // Our engine saves into its own session only: the session's owner reaches it.
+        const access = { owner: begun.owner };
+        if (params.base64 !== undefined) {
+            const bytes = chunkOf(params.base64, limits);
+            const over = begun.room.refusal(bytes.byteLength);
+            if (over)
+                throw new HarnessApiError("limit_exceeded", `${over.message} (limitBytes ${over.limitBytes})`);
+            const saved = await harnessErrorOf(uploadArtifact(ctx, { ...input, declaredBytes: bytes.byteLength }, bytes, access, signal));
+            return written(saved);
+        }
+        const controller = new AbortController();
+        const pipe = new Pipe();
+        const upload = {
+            id: randomUUID(),
+            maxBytes: begun.room.maxBytes,
+            received: 0,
+            pipe,
+            controller,
+            done: uploadArtifact(ctx, { ...input, ...(params.size === undefined ? {} : { declaredBytes: params.size }) }, pipe, access, controller.signal),
+        };
+        // A failed upload fails the chunk waiting on it, and the next request; no rejection is lost.
+        upload.done.catch((error) => pipe.fail(error));
+        const open = uploads.get(scope.runId) ?? new Map();
+        uploads.set(scope.runId, open);
+        open.set(upload.id, upload);
+        // Core's abort of the advance (a cancel, a lost lease) stops the run's uploads.
+        if (scope.runSignal.aborted)
+            stop(upload, "the run stopped");
+        else
+            scope.runSignal.addEventListener("abort", () => stop(upload, "the run stopped"), { once: true });
+        return { status: "open", uploadId: upload.id, maxBytes: upload.maxBytes, received: 0 };
+    };
+    const chunk = async (scope, params) => {
+        const upload = uploadOf(scope, params.uploadId);
+        const open = () => ({ status: "open", uploadId: upload.id, maxBytes: upload.maxBytes, received: upload.received });
+        const bytes = chunkOf(params.base64, scope.limits);
+        // A repeat of the last chunk (its answer was lost) is acknowledged, not taken again.
+        if (upload.last &&
+            params.offset === upload.last.offset &&
+            bytes.byteLength === upload.last.length &&
+            params.offset + bytes.byteLength === upload.received)
+            return open();
+        if (params.offset !== upload.received)
+            throw new HarnessApiError("invalid", `The chunk starts at ${params.offset}; the upload has ${upload.received} bytes, so the next chunk starts there`);
+        if (upload.received + bytes.byteLength > upload.maxBytes) {
+            const message = `The upload passes the ${upload.maxBytes} bytes it may hold (limitBytes ${upload.maxBytes})`;
+            stop(upload, message);
+            forget(scope.runId, upload.id);
+            await upload.done.catch(() => undefined);
+            throw new HarnessApiError("limit_exceeded", message);
+        }
+        // Taken now, so a repeat sent while this one is written is acknowledged too.
+        upload.received += bytes.byteLength;
+        upload.last = { offset: params.offset, length: bytes.byteLength };
+        try {
+            await upload.pipe.push(bytes);
+        }
+        catch (error) {
+            forget(scope.runId, upload.id);
+            // The upload's own refusal (a limit, the session gone) says more than the pipe's.
+            throw toHarnessError(await upload.done.then(() => error, (failure) => failure));
+        }
+        return open();
+    };
+    const commit = async (scope, params) => {
+        const upload = uploadOf(scope, params.uploadId);
+        stopped(scope.runSignal);
+        upload.pipe.close();
+        try {
+            return written(await upload.done);
+        }
+        catch (error) {
+            throw toHarnessError(error);
+        }
+        finally {
+            forget(scope.runId, upload.id);
+        }
+    };
+    return {
+        async read(scope, params, signal) {
+            const { artifactId } = params;
+            const found = await ctx.store.tx(async (t) => {
+                if (!isArtifactId(artifactId))
+                    return undefined;
+                const artifact = await t.artifact(artifactId);
+                if (!artifact)
+                    return undefined;
+                const session = await t.get("sessions", scope.sessionId);
+                if (!sessionMayRead(session, artifact))
+                    return undefined;
+                return { artifact, version: await t.artifactVersion(artifact.id, params.version ?? artifact.latestVersion) };
+            });
+            if (!found)
+                throw notOurs(artifactId);
+            const { artifact, version } = found;
+            if (!version)
+                throw new HarnessApiError("not_found", `Artifact ${artifactId} has no version ${params.version}.`);
+            const meta = metaOf(artifact, version);
+            const offset = params.offset ?? 0;
+            // A folder's bytes are its files: the seam answers its metadata only.
+            if (artifact.kind !== "file")
+                return { artifact: meta, offset, base64: "", eof: true };
+            if (offset > version.size)
+                throw new HarnessApiError("invalid", `Offset ${offset} is past the end of ${artifact.name}, which is ${version.size} bytes.`);
+            const { chunkBytes } = scope.limits;
+            const end = Math.min(offset + Math.min(params.length ?? chunkBytes, chunkBytes), version.size);
+            if (end === offset)
+                return { artifact: meta, offset, base64: "", eof: offset === version.size };
+            let bytes;
+            try {
+                const got = await ctx.blobs.get(version.blobKey, { range: { start: offset, end: end - 1 }, signal });
+                if (!got)
+                    throw new HarnessApiError("unavailable", `The bytes of ${artifact.name} are missing from the Object store`);
+                bytes = new Uint8Array(await new Response(got.body).arrayBuffer());
+            }
+            catch (error) {
+                if (!(error instanceof BlobRangeError))
+                    throw error;
+                bytes = new Uint8Array();
+            }
+            return {
+                artifact: meta,
+                offset,
+                base64: Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64"),
+                eof: offset + bytes.byteLength >= version.size,
+            };
+        },
+        async write(scope, params, signal) {
+            switch (params.op) {
+                case "begin":
+                    return "kind" in params ? beginFolder(scope, params) : begin(scope, params, signal);
+                case "file": {
+                    const folder = folderOf(scope, params.uploadId);
+                    if (!folder)
+                        throw new HarnessApiError("invalid", `No folder upload ${params.uploadId} is open for this run`);
+                    return folderAnswer(folder, await inFolder(scope, folder, () => folder.file(params, signal)));
+                }
+                case "chunk": {
+                    const folder = folderOf(scope, params.uploadId);
+                    if (folder)
+                        return folderAnswer(folder, await inFolder(scope, folder, () => folder.chunk(params)));
+                    return chunk(scope, params);
+                }
+                case "commit": {
+                    const folder = folderOf(scope, params.uploadId);
+                    if (!folder)
+                        return commit(scope, params);
+                    stopped(scope.runSignal);
+                    const done = await inFolder(scope, folder, () => folder.commit(signal));
+                    forgetFolder(scope.runId, folder.id);
+                    return done.kind === "refused"
+                        ? { status: "refused", reason: done.reason, message: done.message, limit: done.limit }
+                        : {
+                            status: "written",
+                            artifact: metaOf(done.row, done.version),
+                            created: done.created,
+                            ...(done.unchanged ? { unchanged: true } : {}),
+                        };
+                }
+                case "abort": {
+                    const folder = folderOf(scope, params.uploadId);
+                    if (folder) {
+                        forgetFolder(scope.runId, folder.id);
+                        await folder.abort("the harness aborted it");
+                        return { status: "aborted" };
+                    }
+                    const upload = uploads.get(scope.runId)?.get(params.uploadId);
+                    if (upload) {
+                        stop(upload, "the harness aborted it");
+                        forget(scope.runId, upload.id);
+                        await upload.done.catch(() => undefined);
+                    }
+                    return { status: "aborted" };
+                }
+            }
+        },
+        endRun(runId) {
+            const openFolders = folders.get(runId);
+            folders.delete(runId);
+            for (const folder of openFolders?.values() ?? [])
+                void folder.abort("the run ended");
+            const open = uploads.get(runId);
+            if (!open)
+                return;
+            uploads.delete(runId);
+            for (const upload of open.values())
+                stop(upload, "the run ended");
+        },
+    };
+}
+/** What the seam shows of an artifact's version. */
+function metaOf(artifact, version) {
+    return {
+        artifactId: artifact.id,
+        kind: artifact.kind,
+        name: artifact.name,
+        version: version.version,
+        contentType: version.contentType,
+        size: version.size,
+        sha256: version.sha256,
+        tenantWide: artifact.sessionId === null,
+    };
+}
+function written(saved) {
+    return {
+        status: "written",
+        artifact: {
+            artifactId: saved.artifact.artifactId,
+            kind: saved.artifact.kind,
+            name: saved.artifact.name,
+            version: saved.version.version,
+            contentType: saved.version.contentType,
+            size: saved.version.size,
+            sha256: saved.version.sha256,
+            tenantWide: saved.artifact.sessionId === undefined,
+        },
+        created: saved.created,
+    };
+}
+/** One chunk's bytes, at most the run's `chunkBytes`. */
+function chunkOf(base64, limits) {
+    const bytes = Buffer.from(base64, "base64");
+    if (bytes.byteLength > limits.chunkBytes)
+        throw new HarnessApiError("limit_exceeded", limitExceededMessage("The chunk", bytes.byteLength, "chunkBytes", limits.chunkBytes));
+    return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+/** A stopped run starts no write. */
+function stopped(signal) {
+    const kind = abortKind(signal);
+    if (kind === undefined)
+        return;
+    if (kind === "cancel")
+        throw new HarnessApiError("turn_cancelled", "Turn cancelled");
+    if (kind === "ownership.lost")
+        throw new HarnessApiError("ownership_lost", "The session's lease was lost");
+    throw new HarnessApiError("unavailable", "The run is stopping");
+}
+/**
+ * An upload's refusal as the harness hears it: missing or not the session's is `not_found`, past a
+ * limit `limit_exceeded`, any other refusal `invalid`. Anything else is the Runtime's own error.
+ */
+function toHarnessError(error) {
+    if (error instanceof HarnessApiError || !(error instanceof HttpError))
+        return error;
+    if (error.status === 404)
+        return new HarnessApiError("not_found", error.message);
+    if (error.status === 413) {
+        const limit = error.rejection.details?.limitBytes;
+        return new HarnessApiError("limit_exceeded", typeof limit === "number" ? `${error.message} (limitBytes ${limit})` : error.message);
+    }
+    if (error.status === 400 || error.status === 409)
+        return new HarnessApiError("invalid", error.message);
+    return error;
+}
+function harnessError(call) {
+    try {
+        return call();
+    }
+    catch (error) {
+        throw toHarnessError(error);
+    }
+}
+async function harnessErrorOf(promise) {
+    try {
+        return await promise;
+    }
+    catch (error) {
+        throw toHarnessError(error);
+    }
+}

package/dist/harness-api/in-process.d.ts

@@ -16,8 +16,8 @@ export declare function startInProcessHarness(ctx: TenantContext, tools: {
 }, options?: MemoryPortsOptions): Promise<InProcessHarness>;
 /**
  * A harness service over a loopback WebSocket (tests): what `--service harness` runs, in this
- * process. Its workspaces live under the Tenant's `sandboxes` directory. Remote MCP servers go
- * through the Tenant's Tool Gate when it opens them, else they are authorized in this process.
+ * process. Its workspaces live under the Tenant's `sandboxes` directory, and its MCP servers
+ * open through the Tenant's Tool Gate.
  */
 export declare function startLoopbackHarness(ctx: TenantContext, options?: {
     sandboxBackends?: readonly SandboxBackend[];

package/dist/harness-api/in-process.js

@@ -1,8 +1,10 @@
 /**
  * The Tenant's own harness (D37): `@nylorun/harness/api` in this process, attached to the
  * Tenant's Harness API server over a memory channel, with the Tenant's model gate, MCP pool
- * and SandboxManager as its executors. `json` sends every frame through JSON and validates it,
- * as a socket will (tests).
+ * and SandboxManager as its executors. It uses the same seams and gates as a remote one
+ * (protocol 15): every model call goes through the Model Gate, every MCP server opens through
+ * the Tool Gate, and skill bytes come over `definition.file`. `json` sends every frame through
+ * JSON and validates it, as a socket will (tests).
  *
  * `startLoopbackHarness` (tests, `harness: "ws"`) runs a harness service in this process instead:
  * over a WebSocket to a Harness API listener on 127.0.0.1, with its own MCP pool and
@@ -10,31 +12,37 @@
  */
 import { randomBytes } from "node:crypto";
 import { DEFAULT_HARNESS, memoryChannels } from "@nylorun/core/harness-api";
+import { sandboxToolLimitsOf } from "@nylorun/harness";
 import { createHarness } from "@nylorun/harness/api";
 import { harnessExecutors } from "../harness/executors.js";
-import { startHarnessService } from "../harness/service.js";
-import { authorize } from "../tenant/effects.js";
+import { engineOptionsOf, startHarnessService } from "../harness/service.js";
 import { startHarnessListener } from "./ws-server.js";
+import { hostTuning } from "../tuning.js";
 /** Where the Tenant's model calls go. */
 export function modelRouteOf(ctx) {
     return {
         tenantId: ctx.config.tenantId,
         modelGate: ctx.modelGate,
-        modelProvider: ctx.modelProvider,
-        useVaultModel: ctx.useVaultModel,
     };
 }
 export async function startInProcessHarness(ctx, tools, options = {}) {
     const channels = memoryChannels(options);
     const detach = ctx.harness.attach(channels.core, { name: "in-process" });
+    // Our engine's settings from the Host tuning (`engine`), and one configuration of the sandbox
+    // tools: what our engine's schemas name, and what runs them.
+    const engine = engineOptionsOf(hostTuning().engine);
+    const sandboxTools = sandboxToolLimitsOf(engine.sandboxTools);
     const harness = createHarness({
+        ...engine,
         channel: channels.harness,
         executors: harnessExecutors({
             model: modelRouteOf(ctx),
             toolGate: ctx.toolGate,
             mcp: tools.mcp,
             sandbox: () => tools.sandbox,
+            sandboxTools,
         }),
+        sandboxTools,
         logger: ctx.config.logger,
         // Our harness: its hello names our harness id (R4.1).
         name: DEFAULT_HARNESS,
@@ -50,8 +58,8 @@ export async function startInProcessHarness(ctx, tools, options = {}) {
 }
 /**
  * A harness service over a loopback WebSocket (tests): what `--service harness` runs, in this
- * process. Its workspaces live under the Tenant's `sandboxes` directory. Remote MCP servers go
- * through the Tenant's Tool Gate when it opens them, else they are authorized in this process.
+ * process. Its workspaces live under the Tenant's `sandboxes` directory, and its MCP servers
+ * open through the Tenant's Tool Gate.
  */
 export async function startLoopbackHarness(ctx, options = {}) {
     const token = randomBytes(32).toString("hex");
@@ -69,24 +77,18 @@ export async function startLoopbackHarness(ctx, options = {}) {
         token,
         paths: { sandboxes: ctx.config.paths.sandboxes },
         modelGate: route.modelGate,
-        modelProvider: route.modelProvider,
-        useVaultModel: route.useVaultModel,
         toolGate: ctx.toolGate,
-        ...(ctx.toolGate.openMcp
-            ? {}
-            : { authorize: (sessionId, request) => authorize(ctx, sessionId, request) }),
-        ...(ctx.config.delivery ? { delivery: ctx.config.delivery } : {}),
         ...(options.sandboxBackends ? { sandboxBackends: options.sandboxBackends } : {}),
         logger: quietLogger(ctx),
         ephemeral: ctx.config.mode === "ephemeral",
-        backoff: { minMs: 50, maxMs: 500 },
+        backoff: hostTuning().harnessApi.loopbackBackoff,
     });
     let timer;
     try {
         await Promise.race([
             service.client.ready,
             new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error("The loopback harness did not connect")), 10_000);
+                timer = setTimeout(() => reject(new Error("The loopback harness did not connect")), hostTuning().harnessApi.loopbackConnectTimeoutMs);
             }),
         ]);
     }

package/dist/harness-api/record.d.ts

@@ -1,13 +1,16 @@
 /**
  * The Record seam of the Harness API: core's journal for the effects of a run. `recordIntent`
  * journals an effect before anything runs it, and either answers it from the journal, hands it
- * to core's own executors (flow work, delegation, `save_artifact`, `read_artifact`,
- * `tool_search` and the skill tools), tells the harness to `execute` it (model calls; MCP, HTTP
- * and sandbox tools, a deferred MCP tool's `tool_call` among them, whose effect names the tool;
- * a flow's HTTP stages and HTTP verifiers), or fails a tool the Runtime cannot run (one that
- * would run the developer's code, R2 M6). `recordOutcome` records what the harness's call returned, an
- * agent's MCP or HTTP tool result first shaped to fit (R2b C11). Both run under the advance's
- * lease: every write is epoch-checked (`ownedSession`), and a lost epoch writes nothing.
+ * to core's own executors (flow work, delegation), tells the harness to `execute` it (model calls;
+ * a flow's HTTP stages and HTTP verifiers; an agent's tool call whose target the session has,
+ * protocol 15: an `mcp` tool it discovered and the turn leaves enabled, by `{server, tool}`; an
+ * `http` tool it declares; a `sandbox` operation when it has a sandbox; a `harness` tool), or
+ * fails a tool call it cannot run (no target, as an author's code tool has, R2 M6, or one the
+ * session lacks). A tool call is routed by its target, never by its name. `recordOutcome`
+ * records what the harness's call returned, as the harness reported it: one record entry, refused
+ * past the Runtime limit `recordEntryBytes` (`limit_exceeded`), since the harness shapes tool
+ * results, not core. Both run under the advance's lease: every write is epoch-checked
+ * (`ownedSession`), and a lost epoch writes nothing.
  *
  * Rows store the request's hash (`requestHash`) and, for a model call, the request without its
  * prompt: drift is a hash compare. Rows written before carry their full request, hashed on read.
@@ -27,8 +30,6 @@ export interface RecordScope {
     readonly ctx: TenantContext;
     readonly lease: Lease;
     readonly signal: AbortSignal;
-    /** The tools the run's harness declared it runs itself (`hello` `features.tools`, R4.2), by name. */
-    readonly nativeTools?: ReadonlySet<string>;
     /**
      * Who reported what this scope records (R4.9): the run's harness, so the events derived from
      * its intents and outcomes are its claim. Absent, core recorded what it saw itself.