@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/harness-api/server.js

@@ -16,6 +16,9 @@
  * workspace request it is serving acts for; a `sandbox.state` claim's record becomes the
  * workspace's row in the `sandboxes` table.
  *
+ * Protocol 15: a harness reads and writes its run's session's artifacts over the artifact seam
+ * (`artifact.read`, `artifact.write`, `./artifacts.ts`); a run's open uploads end with it.
+ *
  * F7.2: a pod sandbox's engine connects as that sandbox's *host* (`HarnessPeer.host`, from its
  * host token): it leases only runs whose session is attached to its sandbox (`RunOffer.pod`),
  * serves only that sandbox's workspace (`workspace(..., { pod })`), and claims events only for
@@ -25,20 +28,24 @@
  * `connection.lost`.
  */
 import { randomUUID } from "node:crypto";
-import { DEFAULT_HARNESS, HARNESS_API_VERSION, HARNESS_CLAIMS, MAX_HARNESS_STATE_BYTES, isHarnessId, HarnessApiError, } from "@nylorun/core/harness-api";
-import { definitionFilesOf } from "@nylorun/core/contracts";
-import { TOOL_CALL_TOOL, TOOL_SEARCH_TOOL, delegatesOf, } from "@nylorun/core/define";
+import { DEFAULT_HARNESS, HARNESS_API_VERSION, HARNESS_CLAIMS, isHarnessId, HarnessApiError, } from "@nylorun/core/harness-api";
+import { definitionFilesOf, limitExceededMessage } from "@nylorun/core/contracts";
 import { isOwnershipLost } from "../store/ownership.js";
 import { harnessOf, ownedSession } from "../tenant/context.js";
-import { mcpDiscovered, pinDeferral, sessionToolsOf, } from "../mcp/snapshot.js";
-import { contextWindowOf } from "../model/catalog.js";
+import { fitSnapshot, isSnapshot, mcpDiscovered, mcpFactsOf, } from "../mcp/snapshot.js";
 import { turnManifestOf } from "../tenant/session.js";
+import { readRuntimeLimits } from "../tenant/runtime-limits.js";
 import { sandboxWorkspaceKey, workspacePrefix } from "../sandbox/records.js";
 import { abortKind } from "../tenant/worker.js";
-import { readDefinitionFile } from "../tenant/definition-files.js";
+import { BlobRangeError } from "../blob/index.js";
+import { openDefinitionFile, readDefinitionFile } from "../tenant/definition-files.js";
 import { recordIntent, recordOutcome } from "./record.js";
+import { createArtifactSeam } from "./artifacts.js";
+import { RecordEntryTooLargeError } from "../record/index.js";
 import { redactTokens } from "./redact.js";
 import { beat, renewEveryMs, tokenOf } from "./renew.js";
+import { hostTuning } from "../tuning.js";
+import { passStartCheck } from "../tenant/agent-versions.js";
 /** No attached harness serves workspaces (or, with `pod`, that pod sandbox's). */
 export class NoWorkspaceHarness extends Error {
     pod;
@@ -60,11 +67,12 @@ const OUTPUTS = [
     "checkpoint",
 ];
 export function createHarnessApiServer(ctx, options = {}) {
-    const offerWaitMs = options.offerWaitMs ?? 10_000;
+    const offerWaitMs = options.offerWaitMs ?? hostTuning().harnessApi.offerWaitMs;
     const connections = new Set();
     const waiting = [];
     const queued = [];
     const runs = new Map();
+    const artifacts = createArtifactSeam(ctx);
     let closed = false;
     /**
      * A harness may take a run of its own harness id (R4.1): a pod sandbox's host its sandbox's
@@ -81,15 +89,6 @@ export function createHarnessApiServer(ctx, options = {}) {
                 continue;
             }
             queued.splice(i, 1);
-            const clash = nativeToolClashes(waiting[at].connection.tools, run.offer.start);
-            if (clash.length > 0) {
-                // The harness keeps waiting for a run its tools fit; this turn fails (Harness API 3).
-                run.end({
-                    kind: "refused",
-                    message: `Harness '${waiting[at].connection.harness}' runs tools named like tools of this turn's agents: ${clash.join(", ")}. A tool the harness runs itself needs a name no other tool of the session has.`,
-                });
-                continue;
-            }
             const lease = waiting.splice(at, 1)[0];
             run.connection = lease.connection;
             // The run token the advance holds now (F5): the gate calls of this run present it.
@@ -111,11 +110,18 @@ export function createHarnessApiServer(ctx, options = {}) {
         evidence: "claimed",
         ...(runId === undefined ? {} : { runId }),
     });
+    /** What the artifact seam serves a run: its session and turn, its limits, its signal. */
+    const artifactScope = (run) => ({
+        runId: run.grant.runId,
+        sessionId: run.grant.sessionId,
+        turnId: run.grant.turnId,
+        limits: run.offer.start.limits,
+        runSignal: run.offer.controller.signal,
+    });
     const scope = (run) => ({
         ctx,
         lease: run.offer.lease,
         signal: run.offer.controller.signal,
-        ...(run.connection?.tools ? { nativeTools: run.connection.tools } : {}),
         ...(run.connection ? { writer: writerOf(run.connection, run.grant.runId) } : {}),
     });
     const serve = (connection) => async (method, params, signal) => {
@@ -127,8 +133,6 @@ export function createHarnessApiServer(ctx, options = {}) {
                 throw new HarnessApiError("invalid", `unsupported Harness API version ${api}: this Runtime speaks ${HARNESS_API_VERSION}`);
             connection.harness = await harnessIdOf(connection, name);
             connection.workspace = features.workspace !== undefined;
-            if (features.tools?.length)
-                connection.tools = new Set(features.tools.map((tool) => tool.name));
             return {
                 api: HARNESS_API_VERSION,
                 tenantId: ctx.config.tenantId,
@@ -181,7 +185,11 @@ export function createHarnessApiServer(ctx, options = {}) {
             case "session.mcp":
                 return recordMcp(run, p);
             case "definition.file":
-                return definitionFile(run, p.sha256, signal);
+                return definitionFile(run, p, signal);
+            case "artifact.read":
+                return artifacts.read(artifactScope(run), p, signal);
+            case "artifact.write":
+                return artifacts.write(artifactScope(run), p, signal);
             default:
                 throw new HarnessApiError("invalid", `Unknown request ${method}`);
         }
@@ -204,6 +212,9 @@ export function createHarnessApiServer(ctx, options = {}) {
             const expected = environment?.applied.harness ?? DEFAULT_HARNESS;
             if (expected !== name)
                 throw new HarnessApiError("invalid", `Environment ${connection.host.sandboxId} runs the ${expected} harness, and this pod says ${name}`);
+            // Its pod started on the version it switched to, setup done (track T3): the start check passed.
+            if (environment?.startCheck)
+                await passStartCheck(ctx, connection.host.sandboxId, connection.host.epoch);
         }
         return name;
     };
@@ -211,7 +222,8 @@ export function createHarnessApiServer(ctx, options = {}) {
      * A `sandbox.*` event the harness claims: for a run it holds (the run's session, or the
      * session owning its sandbox), or a session one of its workspace requests acts for. A
      * `sandbox.state` record becomes the workspace's `sandboxes` row. Claims are best effort, as
-     * the events of core's own SandboxManager are: a session gone since is skipped.
+     * the events of core's own SandboxManager are: a session gone since is skipped. One past the
+     * Tenant's `recordEntryBytes` is refused (`limit_exceeded`).
      */
     const claim = async (connection, event) => {
         if (!HARNESS_CLAIMS.includes(event.type))
@@ -240,6 +252,9 @@ export function createHarnessApiServer(ctx, options = {}) {
             });
         }
         catch (error) {
+            // Past the record entry limit is the harness's to hear (`limit_exceeded`), not a lost claim.
+            if (error instanceof RecordEntryTooLargeError)
+                throw error;
             ctx.config.logger.warn("harness event claim not recorded", {
                 sessionId: event.sessionId,
                 type: event.type,
@@ -250,22 +265,23 @@ export function createHarnessApiServer(ctx, options = {}) {
     };
     /**
      * What a harness found readying the run's MCP servers: the first snapshot recorded for the
-     * session wins, with `mcp.discovered` in its log; diagnostics replace those of the same server.
-     * Answers the session's snapshot and the tools the engine advertises.
+     * session wins, pinned as it is within the Tenant's Runtime limit `mcpSnapshotBytes` (a server
+     * past it is left out, with a diagnostic: `fitSnapshot`), with `mcp.discovered` in its log;
+     * diagnostics replace those of the same server. Answers the session's facts as the run's turn
+     * sees them (protocol 15).
      */
     const recordMcp = async (run, params) => {
         const snapshot = params.snapshot;
         if (snapshot !== undefined && !isSnapshot(snapshot))
             throw new HarnessApiError("invalid", "The MCP snapshot is malformed");
-        // Which MCP tools the model reaches through tool_search, decided once for the session from
-        // the Tenant's model's context window (R2b C10, Q21).
-        const contextWindow = snapshot ? contextWindowOf(await ctx.vault.getHostModel()) : 0;
         return ctx.store.tx(async (t) => {
             const { lease } = run.offer;
             const current = await ownedSession(t, lease, lease.sessionId);
-            const diagnostics = params.diagnostics;
+            let diagnostics = params.diagnostics;
             if (snapshot && !current.mcpSnapshot) {
-                current.mcpSnapshot = pinDeferral(snapshot, current.manifest, contextWindow);
+                const fitted = fitSnapshot(snapshot, diagnostics, (await readRuntimeLimits(t)).mcpSnapshotBytes);
+                diagnostics = fitted.diagnostics;
+                current.mcpSnapshot = fitted.snapshot;
                 current.mcpDiagnostics = diagnostics;
                 await t.put("sessions", current.id, current);
                 await t.event(current.id, run.grant.turnId, "mcp.discovered", mcpDiscovered(current.mcpSnapshot, diagnostics, current.manifest), run.connection ? writerOf(run.connection, run.grant.runId) : undefined);
@@ -282,27 +298,48 @@ export function createHarnessApiServer(ctx, options = {}) {
                 current.mcpDiagnostics = prior;
                 await t.put("sessions", current.id, current);
             }
-            return {
-                ...(current.mcpSnapshot ? { snapshot: current.mcpSnapshot } : {}),
-                // The turn's manifest: a variant may have disabled tools or required their approval.
-                sessionTools: [...(sessionToolsOf(current.mcpSnapshot, turnManifestOf(current)) ?? [])],
-            };
+            // The turn's manifest: a variant may have disabled tools.
+            return current.mcpSnapshot ? { mcp: mcpFactsOf(current.mcpSnapshot, turnManifestOf(current)) } : {};
         });
     };
-    /** A definition file the run's definition names (its skills', for its sandbox), base64. */
-    const definitionFile = async (run, sha256, signal) => {
+    /**
+     * A definition file the run's definition names (its skills', for its sandbox), base64: whole,
+     * or the range `offset` and `length` name (none past the end), at most the run's
+     * `limits.chunkBytes`, which is also the length when the harness names none.
+     */
+    const definitionFile = async (run, { sha256, offset, length }, signal) => {
         if (!definitionFilesOf(run.offer.start.routing.rootManifest).has(sha256))
             throw new HarnessApiError("invalid", `The run's definition names no file ${sha256}`);
-        const bytes = await readDefinitionFile(ctx.blobs, sha256, signal);
-        if (!bytes)
-            throw new HarnessApiError("unavailable", `The Object store has no bytes for ${sha256}`);
-        return { base64: Buffer.from(bytes).toString("base64") };
+        const missing = () => new HarnessApiError("unavailable", `The Object store has no bytes for ${sha256}`);
+        if (offset === undefined && length === undefined) {
+            const bytes = await readDefinitionFile(ctx.blobs, sha256, signal);
+            if (!bytes)
+                throw missing();
+            return { base64: Buffer.from(bytes).toString("base64") };
+        }
+        const { chunkBytes } = run.offer.start.limits;
+        if (length !== undefined && length > chunkBytes)
+            throw new HarnessApiError("limit_exceeded", limitExceededMessage("The range asked for", length, "chunkBytes", chunkBytes));
+        const start = offset ?? 0;
+        const end = start + (length ?? chunkBytes) - 1;
+        let body;
+        try {
+            body = await openDefinitionFile(ctx.blobs, sha256, { range: { start, end }, signal });
+        }
+        catch (error) {
+            if (error instanceof BlobRangeError)
+                return { base64: "" };
+            throw error;
+        }
+        if (!body)
+            throw missing();
+        return { base64: Buffer.from(await new Response(body).arrayBuffer()).toString("base64") };
     };
     /**
      * A custom harness's output (R4.2): its state is its own, stored as sent and never read, so it
-     * must be JSON and at most `MAX_HARNESS_STATE_BYTES`; a larger one fails the turn, as an engine
-     * that threw would. It cannot pause for approvals in v2 (Q14): approvals read our engine's plan
-     * until R5 makes them core holds.
+     * must be JSON and at most the run's `limits.harnessStateBytes`; a larger one fails the turn
+     * (`limit_exceeded`), as an engine that threw would. It cannot pause for approvals in v2 (Q14):
+     * approvals read our engine's plan until R5 makes them core holds.
      */
     const checkCustomOutput = (run, method, params) => {
         if (method === "turn.paused")
@@ -310,14 +347,16 @@ export function createHarnessApiServer(ctx, options = {}) {
         if (params.state === undefined || run.outputs.has(method))
             return;
         const bytes = Buffer.byteLength(JSON.stringify(params.state) ?? "");
-        if (bytes <= MAX_HARNESS_STATE_BYTES)
+        const { harnessStateBytes } = run.offer.start.limits;
+        if (bytes <= harnessStateBytes)
             return;
+        const message = limitExceededMessage("The harness's state", bytes, "harnessStateBytes", harnessStateBytes);
         output(run, "turn.failed", {
             runId: run.grant.runId,
             status: "failed",
-            thrown: { code: "invalid", message: `The harness's state is ${bytes} bytes, over ${MAX_HARNESS_STATE_BYTES}` },
+            thrown: { code: "limit_exceeded", message },
         }).catch(() => undefined);
-        throw new HarnessApiError("invalid", `state over 256 KiB (${bytes} bytes): the turn failed`);
+        throw new HarnessApiError("limit_exceeded", `${message} The turn failed.`);
     };
     const output = (run, method, params) => {
         const known = run.outputs.get(method);
@@ -455,6 +494,8 @@ export function createHarnessApiServer(ctx, options = {}) {
                             return;
                         run.ended = true;
                         clearTimeout(timer);
+                        // An upload the run left open commits nothing.
+                        artifacts.endRun(run.grant.runId);
                         controller.signal.removeEventListener("abort", onAbort);
                         // An output's run stays held until core answers it, so a repeat gets the same answer.
                         if (end.kind === "output") {
@@ -501,31 +542,3 @@ export function createHarnessApiServer(ctx, options = {}) {
         },
     };
 }
-function isSnapshot(value) {
-    const snapshot = value;
-    return (typeof snapshot === "object" &&
-        snapshot !== null &&
-        snapshot.snapshotSchemaVersion === 1 &&
-        typeof snapshot.manifestHash === "string" &&
-        Array.isArray(snapshot.mcpTools));
-}
-/**
- * The tools a harness runs itself (`features.tools`) whose names the turn already uses: a tool of
- * the turn's agents (their own and the Runtime's `runtime` tools), a session tool, `tool_search` or
- * `tool_call` (session tools a later step may get). Tools are known by name alone, so a native
- * tool must not take one (Harness API 3); `hello` already refuses a name with `__`, which names an
- * MCP server's tools. A flow turn runs no native tools.
- */
-export function nativeToolClashes(tools, start) {
-    if (!tools?.size || start.engine !== "agent")
-        return [];
-    const manifest = start.manifest;
-    const taken = new Set([TOOL_SEARCH_TOOL, TOOL_CALL_TOOL]);
-    for (const agent of [manifest, ...delegatesOf(manifest).map((delegate) => delegate.manifest)])
-        for (const tool of [...(agent.tools ?? []), ...(agent.runtime?.tools ?? [])])
-            taken.add(tool.name);
-    for (const tool of (start.sessionTools ?? []))
-        if (typeof tool?.name === "string")
-            taken.add(tool.name);
-    return [...tools].filter((name) => taken.has(name)).sort();
-}

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

@@ -1,4 +1,5 @@
-import type { RecordedOutcome, TurnStart } from "@nylorun/core/harness-api";
+import type { ModelDescriptor, RecordedOutcome, RuntimeLimits, TurnAgent, TurnMemory, TurnStart } from "@nylorun/core/harness-api";
+import { type SandboxManifest } from "@nylorun/core/define";
 import type { SandboxPodState } from "../store/types.js";
 import { type Lease, type Session, type TenantContext } from "../tenant/context.js";
 import { type TraceContext } from "../traces/ids.js";
@@ -6,29 +7,47 @@ import { type TraceContext } from "../traces/ids.js";
 export interface SegmentStart {
     readonly current: Session;
     readonly fixtureModel: boolean;
+    /** The Tenant's Runtime limits as the segment starts: what `turn.start.limits` hands the harness. */
+    readonly limits: RuntimeLimits;
     /** The transcript the engine resumes from (agents with state; empty otherwise). */
     readonly transcript: unknown[];
     /** The record position of `transcript` (`foldTranscriptWithCursor`). */
     readonly cursor: number;
     readonly outcomes: RecordedOutcome[];
-    /** The session's sandbox workspace: the session, and the Environment whose workspace it is. */
+    /** The session's sandbox workspace: the session, and the Agent whose workspace it is. */
     readonly sandbox: {
         readonly ownerId: string;
         readonly environmentId?: string;
         /** Variables every sandbox command gets (R2c): secret names set to the sentinel, plain values. */
         readonly environment?: Readonly<Record<string, string>>;
+        /** The sandbox spec the session pinned when it opened; absent without a sandbox. */
+        readonly spec?: SandboxManifest;
     };
     /**
-     * The Environment is a pod (F7.2): its engine runs the segment. Its lifecycle state, and
-     * whether its new volume is still being seeded from a disk version (R2d step 3).
+     * The Agent the session runs on, as `TurnStart.agent` states it (Harness API 5): its id and
+     * kind, and its sandbox's workspace when the session has a sandbox.
+     */
+    readonly agent?: TurnAgent;
+    /**
+     * The Agent is a pod (F7.2): its engine runs the segment. Its lifecycle state, and whether its
+     * new volume is still being seeded from a disk version (R2d step 3).
      */
     readonly pod?: {
         readonly id: string;
         readonly pod: SandboxPodState;
         readonly seeding?: boolean;
+        /** It starts on a new version (track T3) and has not joined yet: a failed start goes back. */
+        readonly starting?: boolean;
     };
     /** The turn's span context (R7.4): what `TurnStart.trace` hands the harness. */
     readonly trace?: TraceContext;
+    /**
+     * The model the turn's calls use (protocol 15), as the segment starts: what `TurnStart.model`
+     * hands an agent's harness. Absent for a flow, and when the Tenant has no model.
+     */
+    readonly model?: ModelDescriptor;
+    /** The Agent's memory (track T5): its access, instructions and the index the harness pins. */
+    readonly memory?: TurnMemory;
 }
 /** The segment's starting transaction and fold. */
 export declare function startSegment(ctx: TenantContext, lease: Lease, 
@@ -38,7 +57,10 @@ options?: {
 }): Promise<SegmentStart>;
 /** The run's `turn.start`. */
 export declare function buildTurnStart(ctx: TenantContext, segment: SegmentStart): TurnStart;
-/** The engine's yield budget for a segment. */
+/**
+ * The engine's yield budget for a segment: the Tenant's `rollover`, else the Host tuning's
+ * (`harnessApi.rolloverSteps`, `rolloverMs`), well inside the advance deadline.
+ */
 export declare function yieldAfterOf(ctx: TenantContext): {
     steps: number;
     ms: number;

package/dist/harness-api/start.js

@@ -1,17 +1,31 @@
+/**
+ * What a segment starts from (§10.5): in one transaction the session's state is rebased onto
+ * the turn's manifest, a transcript still on the row is recorded, and the segment's completed
+ * outcomes are read; then the transcript is folded from the record (P0.3). `buildTurnStart`
+ * turns that into the run's `turn.start`: the checkpoint goes without its transcript, which the
+ * harness holds at the fold's cursor or reads once.
+ */
+import { harnessLimitsOf } from "@nylorun/core/contracts";
+import { SANDBOX_WORKSPACE } from "@nylorun/core/define";
 import { isWorkflowManifest } from "../core/flow-host.js";
 import { sandboxWorkspaceOf } from "../sandbox/share.js";
 import { ownedTx } from "../store/ownership.js";
 import { harnessOf } from "../tenant/context.js";
+import { repinTurn } from "../tenant/agent-versions.js";
 import { HARNESS_ID } from "../sandbox/placement.js";
 import { checkParity, foldTranscriptWithCursor, leanState, transcriptOf, transcriptUpdates, withTranscript, } from "../tenant/history.js";
 import { usesFixtureModel } from "../tenant/model-setting.js";
-import { sessionToolsOf, turnManifestOf } from "../tenant/session.js";
+import { currentModelDescriptor } from "../model/descriptor.js";
+import { readRuntimeLimits } from "../tenant/runtime-limits.js";
+import { flowLimitsOf } from "../core/limits.js";
+import { turnManifestOf } from "../tenant/session.js";
+import { mcpFactsOf } from "../mcp/snapshot.js";
 import { bulkOutcomes } from "./record.js";
+import { renderMemoryIndex } from "../memory/service.js";
+import { memorySettingsOf } from "../memory/tool.js";
 import { traceKey } from "../traces/key.js";
+import { hostTuning } from "../tuning.js";
 import { traceparentOf, turnSpanOf, turnTraceIdOf, } from "../traces/ids.js";
-/** Segment rollover defaults (Model Calls §10), well inside the advance deadline. */
-const ROLLOVER_STEPS = 50;
-const ROLLOVER_MS = 20 * 60_000;
 /** The segment's starting transaction and fold. */
 export async function startSegment(ctx, lease, 
 /** For a harness: also the segment's outcomes and the sandbox's owner. */
@@ -19,34 +33,58 @@ options = {}) {
     const id = lease.sessionId;
     // Read before the transaction: the first read of the Tenant may create the key.
     const key = options.harness ? await traceKey(ctx.store) : undefined;
-    const started = await ownedTx(ctx.store, id, lease.epoch, async (t, current) => {
+    const opened = await ownedTx(ctx.store, id, lease.epoch, async (t, current) => {
+        // A turn's first segment runs the version its Agent runs now (T3, D73).
+        if (options.harness && (await repinTurn(t, current)))
+            await t.put("sessions", id, current);
         // A transcript left on our engine's state by an older Runtime is recorded once; another
         // harness's state is its own (R4.2).
+        const limits = await readRuntimeLimits(t);
         if (!isWorkflowManifest(current.manifest) && current.checkpoint && harnessOf(current) === HARNESS_ID) {
-            await adoptStoredTranscript(t, current);
+            await adoptStoredTranscript(t, current, limits.recordEntryBytes);
             const cp = current.checkpoint;
             current.checkpoint = { ...cp, state: current.state };
             await t.put("sessions", id, current);
         }
         const fixtureModel = await usesFixtureModel(t);
         if (!options.harness)
-            return { current, fixtureModel, outcomes: [], sandbox: { ownerId: id } };
+            return { current, fixtureModel, limits, outcomes: [], sandbox: { ownerId: id } };
         const workspace = sandboxWorkspaceOf(current);
         const resource = workspace.environmentId === undefined ? undefined : await t.environment(workspace.environmentId);
         const environment = await ctx.vault.environmentVariables(t, current.environmentId);
-        const sandbox = Object.keys(environment).length > 0 ? { ...workspace, environment } : workspace;
+        const sandbox = {
+            ...workspace,
+            ...(Object.keys(environment).length > 0 ? { environment } : {}),
+            ...(current.sandbox === undefined ? {} : { spec: current.sandbox }),
+        };
         const turnId = current.activeTurnId;
+        const memory = isWorkflowManifest(current.manifest) ? undefined : await turnMemoryOf(t, current, limits);
         return {
             current,
             fixtureModel,
+            limits,
+            ...(memory ? { memory } : {}),
             outcomes: current.checkpoint ? await bulkOutcomes(t, current, current.checkpoint) : [],
             sandbox,
+            ...(resource ? { agent: agentOf(resource, current.sandbox, await selfWakeOf(t, current)) } : {}),
             ...(key && turnId ? { trace: turnContextOf(key, ctx.store.tenantId, current, turnId) } : {}),
             ...(resource?.pod
-                ? { pod: { id: resource.id, pod: resource.pod, ...(resource.diskSeed ? { seeding: true } : {}) } }
+                ? {
+                    pod: {
+                        id: resource.id,
+                        pod: resource.pod,
+                        ...(resource.diskSeed ? { seeding: true } : {}),
+                        ...(resource.startCheck ? { starting: true } : {}),
+                    },
+                }
                 : {}),
         };
     });
+    // The model an agent's harness decides files by, read outside the session's transaction.
+    const model = options.harness && !isWorkflowManifest(opened.current.manifest)
+        ? await currentModelDescriptor(ctx)
+        : undefined;
+    const started = model ? { ...opened, model } : opened;
     // One history (P0.3): the engine resumes from the transcript folded from the record.
     const { current } = started;
     const cp = current.checkpoint;
@@ -76,24 +114,66 @@ export function buildTurnStart(ctx, segment) {
         checkpoint: !flow && cp.state && harnessOf(current) === HARNESS_ID
             ? { ...cp, state: withTranscript(cp.state, []) }
             : cp,
-        // The turn's manifest: a variant may have disabled MCP tools or required their approval.
-        ...(flow ? {} : { sessionTools: sessionToolsOf(current.mcpSnapshot, turnManifestOf(current)) ?? [] }),
+        // The session's MCP discovery as the turn's manifest sees it: a variant may disable tools.
+        ...(!flow && current.mcpSnapshot ? { mcp: mcpFactsOf(current.mcpSnapshot, turnManifestOf(current)) } : {}),
         outcomes: segment.outcomes,
         transcript: { cursor: segment.cursor },
         options: {
             ...(flow
-                ? { flowLimits: ctx.flowLimits }
+                ? { flowLimits: flowLimitsOf(segment.limits) }
                 : { yieldAfter: yieldAfterOf(ctx) }),
             fixtureModel: segment.fixtureModel,
         },
         routing: {
             rootManifest: current.manifest,
-            ...(current.mcpSnapshot ? { mcpSnapshot: current.mcpSnapshot } : {}),
             sandbox: segment.sandbox,
         },
         ...(segment.trace ? { trace: segment.trace } : {}),
+        limits: harnessLimitsOf(segment.limits),
+        ...(segment.model && !flow ? { model: segment.model } : {}),
+        ...(segment.agent && !flow ? { agent: segment.agent } : {}),
+        // The agent manifest version the session pinned, and its harness's own settings (protocol 16).
+        ...(current.definition === undefined ? {} : { definition: current.definition }),
+        ...(current.loop === undefined || flow ? {} : { loop: current.loop }),
+        ...(segment.memory && !flow ? { memory: segment.memory } : {}),
+    };
+}
+/**
+ * The Agent's memory as the segment starts (track T5, D72), when the version the session runs sets
+ * `harness.memory`: its access (the same in every turn), the agent's instructions, and the index of
+ * its memories, newest first, within the Tenant's index limits.
+ */
+async function turnMemoryOf(t, s, limits) {
+    const settings = await memorySettingsOf(t, s);
+    if (!settings)
+        return undefined;
+    const { index, truncated } = await renderMemoryIndex(t, s.agentId, limits);
+    return {
+        access: settings.access ?? "read_write",
+        ...(settings.instructions === undefined ? {} : { instructions: settings.instructions }),
+        index,
+        truncated,
     };
 }
+/**
+ * The facts of the Agent a session runs on (Harness API 5): its id and kind, and, with the
+ * session's sandbox, the workspace its commands start in. The harness words them.
+ */
+function agentOf(resource, spec, selfWake) {
+    return {
+        id: resource.id,
+        kind: resource.kind,
+        ...(spec === undefined ? {} : { sandbox: { workspace: SANDBOX_WORKSPACE } }),
+        ...(selfWake ? { selfWake: true } : {}),
+    };
+}
+/** Whether the manifest version the session runs sets `runtime.selfWake` (track T4, D77). */
+async function selfWakeOf(t, s) {
+    if (!s.definition)
+        return false;
+    const version = await t.agentManifest(s.definition.name, s.definition.version);
+    return version?.body.runtime?.selfWake === true;
+}
 /**
  * The context of turn `turnId`'s span (R7.4): its trace (the caller's when its message carried a
  * `traceparent`) and its span, as the trace projector derives them, with the caller's
@@ -106,18 +186,21 @@ function turnContextOf(key, tenantId, s, turnId) {
         ...(s.turnTrace?.tracestate ? { tracestate: s.turnTrace.tracestate } : {}),
     };
 }
-/** The engine's yield budget for a segment. */
+/**
+ * The engine's yield budget for a segment: the Tenant's `rollover`, else the Host tuning's
+ * (`harnessApi.rolloverSteps`, `rolloverMs`), well inside the advance deadline.
+ */
 export function yieldAfterOf(ctx) {
     return {
-        steps: ctx.config.rollover?.steps ?? ROLLOVER_STEPS,
-        ms: ctx.config.rollover?.ms ?? ROLLOVER_MS,
+        steps: ctx.config.rollover?.steps ?? hostTuning().harnessApi.rolloverSteps,
+        ms: ctx.config.rollover?.ms ?? hostTuning().harnessApi.rolloverMs,
     };
 }
 /**
  * A session written before transcripts were recorded keeps its transcript on its row: record
  * it once (the turn's starting transcript, then the turn so far), and store the row lean.
  */
-async function adoptStoredTranscript(t, s) {
+async function adoptStoredTranscript(t, s, recordEntryBytes) {
     if (s.history)
         return;
     const now = transcriptOf(s.state);
@@ -131,9 +214,9 @@ async function adoptStoredTranscript(t, s) {
             first ??= event.seq;
         }
     };
-    await write(null, transcriptUpdates([], start));
+    await write(null, transcriptUpdates([], start, recordEntryBytes));
     if (s.activeTurnId)
-        await write(s.activeTurnId, transcriptUpdates(start, now));
+        await write(s.activeTurnId, transcriptUpdates(start, now, recordEntryBytes));
     s.history = { from: first ?? 0, snapshot: first ?? 0 };
     s.state = leanState(s.state);
     s.turnStartState = leanState(s.turnStartState);

package/dist/harness-api/tool-journal.d.ts

@@ -5,12 +5,13 @@
  * Delivery (R5.3, R5.4). A tool call is sent at least once, and every send carries its effect
  * id as the key. After a crash, a shutdown or a lost gate hop, a row still `invoking` is sent
  * again: an MCP or HTTP tool call (it crosses the Tool Gate, which hands the tool the key) up to
- * `MAX_TOOL_ATTEMPTS` sends, then it fails to the model as `tool.interrupted`. A sandbox or
+ * the Tenant's Runtime limit `toolAttempts` sends, then it fails to the model as
+ * `tool.interrupted`. A sandbox or
  * core-served call has no key to dedupe on, so a crash fails it to the model at once, and
  * nothing runs it again (Q2). No tool call leaves its session `uncertain`.
  *
- * The row body keeps the journal's facts: `toolKind`, `server`, `attempts`, `startedAt` and
- * `settledAt`. A row written before R5 has none of them.
+ * The row body keeps the journal's facts: `toolKind`, `server`, `tool` (the identity, protocol
+ * 15), `attempts`, `startedAt` and `settledAt`. A row written before R5 has none of them.
  *
  * Spans (R7.1). `tool.completed` also carries the call's effect id, the Tool Gate's own start
  * and end of its last send (`gate`, from its `tool_crossings` row: MCP and HTTP calls through
@@ -23,8 +24,6 @@ import type { HostEffect } from "@nylorun/harness/run";
 import type { Session } from "../tenant/context.js";
 import { type GateTimes, type ToolCallFacts, type ToolCallKind, type ToolCallStatus, type ToolPolicyFact } from "../tenant/transcript.js";
 import type { EffectDoc, Tx } from "../store/types.js";
-/** How many times a tool call is sent before it fails to the model as `tool.interrupted`. */
-export declare const MAX_TOOL_ATTEMPTS = 3;
 /** A tool row's journal facts (R5), kept in its body. */
 export interface ToolRowFacts {
     /** Why the Tool Gate held the call for approval, and since when (R5 step 2). */
@@ -40,6 +39,8 @@ export interface ToolRowFacts {
     };
     toolKind?: ToolCallKind;
     server?: string;
+    /** The tool's identity: an MCP tool's name on `server`, an HTTP tool's declared name. */
+    tool?: string;
     /** The skill the call ran, and the plugin that brought its skill or MCP server. */
     skill?: string;
     plugin?: PluginLabel;
@@ -62,18 +63,22 @@ export type ToolRow = EffectDoc & ToolRowFacts & {
 };
 /** Where a tool call runs, and what it traces to (Q7, Q11). */
 export interface ToolCallPlace {
-    toolKind: ToolCallKind;
+    /** Its target's kind; absent for a call that names none (an author's code tool). */
+    toolKind?: ToolCallKind;
     /** Its MCP server or, for an agent's HTTP tool, its URL's host. */
     server?: string;
+    /** Its identity: an MCP tool's own name on the server, an HTTP tool's declared name. */
+    tool?: string;
     skill?: string;
     plugin?: PluginLabel;
 }
 /**
- * Where a tool call runs, and what it traces to: an MCP call names its server and the plugin
- * that brought it; a skill tool, or a sandbox tool whose input names `/skills/<name>@<hash>/`, names the
- * skill and its plugin. A tool the turn's harness declared (`nativeTools`) runs in the harness.
+ * Where a tool call runs, and what it traces to (protocol 15): its target's kind; an MCP call
+ * names its identity (server and tool) and the plugin that brought the server, an HTTP call its
+ * declared name and its URL's host. The skill the effect names (`skill`: a skill tool's, or a
+ * sandbox call in a skill's folder) is kept when the agent has it, with the plugin that brought it.
  */
-export declare function toolKindOf(s: Pick<Session, "manifest" | "mcpSnapshot">, agentManifest: AgentManifest | undefined, request: HostEffect, nativeTools?: ReadonlySet<string>): ToolCallPlace;
+export declare function toolKindOf(s: Pick<Session, "manifest">, agentManifest: AgentManifest | undefined, request: HostEffect): ToolCallPlace;
 /** The facts a new tool row starts with: its first send, now. */
 export declare function firstSend(kind: ToolCallPlace, now?: Date): ToolRowFacts;
 /** A failed outcome the Runtime gives a call a crash interrupted: it may have run. */