@nylorun/runtime 0.15.1-beta → 0.16.0-beta

package/dist/harness/ws-client.js

@@ -0,0 +1,122 @@
+/**
+ * A harness's connection to core (F6.2): a WebSocket to the Harness API listener, with the
+ * harness credential (`Authorization: Bearer`, `NYLORUN_HARNESS_TOKEN`) and the API version
+ * header. Each connection runs one `createHarness`: it says `hello`, leases runs, and answers
+ * core's `workspace.*` requests (`serve`). When the connection is lost its runs stop (core gives
+ * their segments to the next advance, which resumes them by replay) and the client connects
+ * again after a jittered backoff of 0.5 to 10 s.
+ */
+import { createChannel } from "@nylorun/core/harness-api";
+import { createHarness } from "@nylorun/harness/api";
+import { WebSocket } from "ws";
+import { HARNESS_API_HEADER, HARNESS_MAX_PAYLOAD, wsPort } from "./ws-port.js";
+export function connectHarness(options) {
+    const { logger } = options;
+    const backoff = options.backoff ?? { minMs: 500, maxMs: 10_000 };
+    let stopped = false;
+    let connected = false;
+    let current;
+    let wake;
+    let markReady;
+    const ready = new Promise((resolve) => (markReady = resolve));
+    const open = async () => {
+        const token = typeof options.token === "string" ? options.token : await options.token();
+        return new Promise((resolve, reject) => {
+            const socket = new WebSocket(options.url, {
+                headers: { authorization: `Bearer ${token}`, [HARNESS_API_HEADER]: "1" },
+                maxPayload: HARNESS_MAX_PAYLOAD,
+                handshakeTimeout: 10_000,
+            });
+            socket.once("open", () => {
+                socket.removeAllListeners("error");
+                resolve(socket);
+            });
+            socket.once("unexpected-response", (_request, response) => {
+                socket.removeAllListeners("error");
+                socket.on("error", () => undefined);
+                reject(new Error(`The Harness API refused the connection: ${response.statusCode ?? 0}`));
+                response.resume();
+                socket.terminate();
+            });
+            socket.once("error", reject);
+        });
+    };
+    const pause = (ms) => new Promise((resolve) => {
+        const timer = setTimeout(done, ms);
+        timer.unref();
+        function done() {
+            clearTimeout(timer);
+            wake = undefined;
+            resolve();
+        }
+        wake = done;
+    });
+    const session = async () => {
+        const socket = await open();
+        if (stopped)
+            return void socket.close(1000, "harness stopped");
+        const channel = createChannel(wsPort(socket, options.liveness ?? {}), { validate: true });
+        if (options.serve)
+            channel.handle(options.serve);
+        const harness = createHarness({ ...options, channel, logger });
+        current = { channel, harness };
+        const lost = new Promise((resolve) => channel.onClose(resolve));
+        try {
+            await harness.start();
+            connected = true;
+            markReady();
+            logger.info("harness_connected", { url: options.url });
+            const reason = await lost;
+            logger.warn("harness_connection_lost", { reason });
+        }
+        finally {
+            connected = false;
+            // The connection is gone: its runs were aborted with it; let them wind down.
+            if (!stopped)
+                await harness.stop(5_000);
+            channel.close("reconnecting");
+            current = undefined;
+        }
+    };
+    const loop = (async () => {
+        let attempt = 0;
+        while (!stopped) {
+            const started = Date.now();
+            try {
+                await session();
+            }
+            catch (error) {
+                if (!stopped)
+                    logger.warn("harness_connect_failed", {
+                        url: options.url,
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+            }
+            if (stopped)
+                break;
+            // A connection that lasted resets the backoff.
+            if (Date.now() - started > backoff.maxMs)
+                attempt = 0;
+            const ceiling = Math.min(backoff.maxMs, backoff.minMs * 2 ** attempt);
+            attempt += 1;
+            await pause(backoff.minMs + Math.random() * Math.max(0, ceiling - backoff.minMs));
+        }
+    })();
+    return {
+        ready,
+        get connected() {
+            return connected;
+        },
+        channel: () => current?.channel,
+        async stop(waitMs = 10_000) {
+            stopped = true;
+            wake?.();
+            const live = current;
+            if (live) {
+                await live.harness.stop(waitMs);
+                live.channel.close("harness stopped");
+            }
+            await loop;
+        },
+    };
+}

package/dist/harness/ws-port.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The Harness API over a WebSocket (F6.2): one JSON text message per frame. Either end watches
+ * the connection: core pings every `pingMs` (30 s), the harness answers (`ws` does it), and an
+ * end that hears nothing from the other for `silenceMs` (90 s) drops the connection. A message
+ * that is not JSON closes it (1007); `createChannel({ validate: true })` checks the rest.
+ */
+import type { Port } from "@nylorun/core/harness-api";
+import { WebSocket } from "ws";
+/** The URL path of the Harness API, and the header naming its version. */
+export declare const HARNESS_API_PATH = "/nylorun/harness/v1";
+export declare const HARNESS_API_HEADER = "nylorun-harness-api";
+/** Largest frame either end accepts. */
+export declare const HARNESS_MAX_PAYLOAD: number;
+export declare const DEFAULT_PING_MS = 30000;
+export declare const DEFAULT_SILENCE_MS = 90000;
+export interface WsPortOptions {
+    /** Send pings (core's end). */
+    readonly ping?: boolean;
+    readonly pingMs?: number;
+    readonly silenceMs?: number;
+}
+export declare function wsPort(socket: WebSocket, options?: WsPortOptions): Port;

package/dist/harness/ws-port.js

@@ -0,0 +1,78 @@
+import { WebSocket } from "ws";
+/** The URL path of the Harness API, and the header naming its version. */
+export const HARNESS_API_PATH = "/nylorun/harness/v1";
+export const HARNESS_API_HEADER = "nylorun-harness-api";
+/** Largest frame either end accepts. */
+export const HARNESS_MAX_PAYLOAD = 64 * 1024 * 1024;
+export const DEFAULT_PING_MS = 30_000;
+export const DEFAULT_SILENCE_MS = 90_000;
+export function wsPort(socket, options = {}) {
+    const frames = [];
+    const closes = [];
+    const silenceMs = options.silenceMs ?? DEFAULT_SILENCE_MS;
+    let lastHeard = Date.now();
+    let closed = false;
+    let reason = "closed";
+    const heard = () => {
+        lastHeard = Date.now();
+    };
+    const watch = setInterval(() => {
+        if (Date.now() - lastHeard > silenceMs) {
+            reason = `nothing heard for ${Math.round(silenceMs / 1000)} s`;
+            socket.terminate();
+        }
+        else if (options.ping && socket.readyState === WebSocket.OPEN)
+            socket.ping();
+    }, Math.min(options.pingMs ?? DEFAULT_PING_MS, silenceMs));
+    watch.unref();
+    socket.on("ping", heard);
+    socket.on("pong", heard);
+    socket.on("message", (data, binary) => {
+        heard();
+        let frame;
+        try {
+            if (binary)
+                throw new Error("binary message");
+            frame = JSON.parse(data.toString());
+        }
+        catch {
+            reason = "a message that is not a JSON frame";
+            socket.close(1007, "Harness API frames are JSON text");
+            return;
+        }
+        for (const listener of frames)
+            listener(frame);
+    });
+    socket.on("error", (error) => {
+        reason = error.message;
+    });
+    socket.on("close", (code, why) => {
+        clearInterval(watch);
+        if (closed)
+            return;
+        closed = true;
+        const said = why.toString();
+        const message = said || (code === 1000 ? reason : `${reason} (${code})`);
+        for (const listener of closes)
+            listener(message);
+    });
+    return {
+        send(frame) {
+            if (socket.readyState === WebSocket.OPEN)
+                socket.send(JSON.stringify(frame));
+        },
+        onFrame(listener) {
+            frames.push(listener);
+        },
+        onClose(listener) {
+            closes.push(listener);
+        },
+        close(why = "closed") {
+            reason = why;
+            if (socket.readyState === WebSocket.CLOSED || socket.readyState === WebSocket.CLOSING)
+                return;
+            // A close reason is at most 123 bytes.
+            socket.close(1000, Buffer.from(why).subarray(0, 120).toString());
+        },
+    };
+}

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

@@ -0,0 +1,24 @@
+import { type MemoryPortsOptions } from "@nylorun/core/harness-api";
+import type { ModelRoute } from "../harness/calls.js";
+import type { McpPool } from "../mcp/pool.js";
+import type { SandboxManager } from "../sandbox/manager.js";
+import type { SandboxBackend } from "../sandbox/types.js";
+import type { TenantContext } from "../tenant/context.js";
+/** Where the Tenant's model calls go. */
+export declare function modelRouteOf(ctx: TenantContext): ModelRoute;
+export interface InProcessHarness {
+    /** Aborts its runs with `shutdown`, waits for them at most `waitMs`, and detaches. */
+    stop(waitMs?: number): Promise<void>;
+}
+export declare function startInProcessHarness(ctx: TenantContext, tools: {
+    mcp: McpPool;
+    sandbox: SandboxManager;
+}, 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.
+ */
+export declare function startLoopbackHarness(ctx: TenantContext, options?: {
+    sandboxBackends?: readonly SandboxBackend[];
+}): Promise<InProcessHarness>;

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

@@ -0,0 +1,119 @@
+/**
+ * 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).
+ *
+ * `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
+ * SandboxManager and no store, as `--service harness` runs one.
+ */
+import { randomBytes } from "node:crypto";
+import { memoryChannels } from "@nylorun/core/harness-api";
+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 { startHarnessListener } from "./ws-server.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" });
+    const harness = createHarness({
+        channel: channels.harness,
+        executors: harnessExecutors({
+            model: modelRouteOf(ctx),
+            toolGate: ctx.toolGate,
+            mcp: tools.mcp,
+            sandbox: () => tools.sandbox,
+        }),
+        logger: ctx.config.logger,
+        name: "in-process",
+    });
+    await harness.start();
+    return {
+        async stop(waitMs) {
+            await harness.stop(waitMs);
+            channels.harness.close("stopped");
+            detach();
+        },
+    };
+}
+/**
+ * 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.
+ */
+export async function startLoopbackHarness(ctx, options = {}) {
+    const token = randomBytes(32).toString("hex");
+    const listener = await startHarnessListener({
+        host: "127.0.0.1",
+        port: 0,
+        allowedHosts: [],
+        token,
+        attach: async () => (ctx.closed ? undefined : (channel, peer) => ctx.harness.attach(channel, peer)),
+        logger: ctx.config.logger,
+    });
+    const route = modelRouteOf(ctx);
+    const service = startHarnessService({
+        url: listener.url,
+        token,
+        paths: { sandboxes: ctx.config.paths.sandboxes, pluginData: ctx.config.paths.pluginData },
+        childEnv: ctx.config.childEnv,
+        modelGate: route.modelGate,
+        modelProvider: route.modelProvider,
+        useVaultModel: route.useVaultModel,
+        toolGate: ctx.toolGate,
+        ...(ctx.toolGate.openMcp
+            ? {}
+            : { authorize: (sessionId, request) => authorize(ctx, sessionId, request) }),
+        ...(options.sandboxBackends ? { sandboxBackends: options.sandboxBackends } : {}),
+        logger: quietLogger(ctx),
+        name: "loopback",
+        ephemeral: ctx.config.mode === "ephemeral",
+        backoff: { minMs: 50, maxMs: 500 },
+    });
+    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);
+            }),
+        ]);
+    }
+    catch (error) {
+        await service.stop(0);
+        await listener.close();
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    return {
+        async stop(waitMs) {
+            await service.stop(waitMs);
+            await listener.close();
+        },
+    };
+}
+/** The Tenant's logger, which never throws: a harness may log after the Tenant's log is gone. */
+function quietLogger(ctx) {
+    const quiet = (level) => (message, fields) => {
+        try {
+            ctx.config.logger[level](message, fields);
+        }
+        catch {
+            /* nowhere to log */
+        }
+    };
+    return { info: quiet("info"), warn: quiet("warn") };
+}

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

@@ -0,0 +1,44 @@
+/**
+ * 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 (Actions, flow work, delegation), or tells the harness to `execute`
+ * it. `recordOutcome` records what the harness's call returned. 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.
+ */
+import { type EffectIntent, type IntentAnswer, type OutcomeAnswer, type RecordedOutcome } from "@nylorun/core/harness-api";
+import { type Lease, type Session, type TenantContext } from "../tenant/context.js";
+import type { Tx } from "../store/types.js";
+/** What a run's journal writes are scoped by: the advance's lease and its signal. */
+export interface RecordScope {
+    readonly ctx: TenantContext;
+    readonly lease: Lease;
+    readonly signal: AbortSignal;
+}
+/** The hash a journal row's request was recorded with. */
+export declare function hashOf(row: {
+    request: unknown;
+    requestHash?: string;
+}): string;
+/** The completed outcomes of a segment, which a run replays without asking. */
+export declare function bulkOutcomes(t: Tx, session: Pick<Session, "id">, checkpoint: {
+    turnId: string;
+    segment: number;
+}): Promise<RecordedOutcome[]>;
+/**
+ * Journals one effect. `effect` is the engine's request; a model intent may come without its
+ * prompt, and then `requestHash` is the only record of it.
+ */
+export declare function recordIntent(scope: RecordScope, effect: EffectIntent, requestHash: string): Promise<IntentAnswer>;
+/**
+ * Records the outcome of a call the harness ran: `value`, with its transcript events, or the
+ * `error` that left it uncertain. Only a cancel discards an outcome in hand (§10.7): after any
+ * other abort (shutdown, deadline) it is recorded, so the next advance replays it.
+ */
+export declare function recordOutcome(scope: RecordScope, effectId: string, result: {
+    value: unknown;
+} | {
+    error: string;
+}): Promise<OutcomeAnswer>;

package/dist/harness-api/record.js

@@ -0,0 +1,250 @@
+/**
+ * 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 (Actions, flow work, delegation), or tells the harness to `execute`
+ * it. `recordOutcome` records what the harness's call returned. 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.
+ */
+import { HarnessApiError, effectRequestHash, } from "@nylorun/core/harness-api";
+import { isFlowEffect, isFlowToolEffect } from "../core/flow-host.js";
+import { sandboxCapabilityOf } from "../sandbox/capability.js";
+import { isSaveArtifactCall } from "../harness/calls.js";
+import { callSaveArtifact } from "../tenant/artifact-tool.js";
+import { isOwnershipLost } from "../store/ownership.js";
+import { manifestFor, mcpToolOf } from "../mcp/snapshot.js";
+import { ownedSession } from "../tenant/context.js";
+import { actionTarget, pinnedTool } from "../tenant/session.js";
+import { offerAction } from "../tenant/delivery.js";
+import { isRemoteMcpEffect, linkedOutcome, recoversMcpCalls, recoversModelCalls, resolveNewFlowEffect, } from "../tenant/effects.js";
+import { assistantMessage, contextCompacted, modelFailed, toolCompleted, toolIds, } from "../tenant/transcript.js";
+import { abortKind } from "../tenant/worker.js";
+const TURN_CANCELLED = () => new HarnessApiError("turn_cancelled", "Turn cancelled");
+/** The hash a journal row's request was recorded with. */
+export function hashOf(row) {
+    return row.requestHash ?? effectRequestHash(row.request);
+}
+/** The completed outcomes of a segment, which a run replays without asking. */
+export async function bulkOutcomes(t, session, checkpoint) {
+    const prefix = `${checkpoint.turnId}:${checkpoint.segment}:`;
+    const rows = await t.effectsForTurn(session.id, checkpoint.turnId, ["completed"]);
+    return rows
+        .filter((row) => row.request.effectId.startsWith(prefix) && row.outcome)
+        .map((row) => ({ effectId: row.request.effectId, requestHash: hashOf(row), outcome: row.outcome }));
+}
+/**
+ * Journals one effect. `effect` is the engine's request; a model intent may come without its
+ * prompt, and then `requestHash` is the only record of it.
+ */
+export async function recordIntent(scope, effect, requestHash) {
+    const { ctx, lease, signal } = scope;
+    const request = effect;
+    const answer = await ctx.store.tx(async (t) => {
+        const s = await ownedSession(t, lease, request.sessionId);
+        if (s.status === "cancelled" || s.activeTurnId !== request.turnId)
+            throw TURN_CANCELLED();
+        // An aborted advance starts no effect; the advance decides what the abort means.
+        signal.throwIfAborted();
+        const existing = await t.get("effects", request.effectId);
+        if (existing) {
+            if (hashOf(existing) !== requestHash)
+                throw new HarnessApiError("effect_drift", "Effect identity request drift");
+            if (existing.status === "completed")
+                return { status: "completed", outcome: existing.outcome };
+            // A call its previous owner left running at the gate: re-send it, same key and request,
+            // to join it or collect its outcome (P1.2 for model calls, F4.1 for remote MCP calls).
+            if (existing.status === "invoking" && request.kind === "model" && recoversModelCalls(ctx))
+                return { status: "execute", rejoin: true };
+            if (existing.status === "invoking" && recoversMcpCalls(ctx) && isRemoteMcpEffect(s, existing.request))
+                return { status: "execute", rejoin: true };
+            if (request.kind === "agent" && existing.status === "pending" && existing.agentSessionId) {
+                const agent = await t.get("sessions", existing.agentSessionId);
+                const outcome = await linkedOutcome(t, existing, agent);
+                if (outcome) {
+                    existing.status = "completed";
+                    existing.outcome = outcome;
+                    await t.put("effects", request.effectId, existing);
+                    return { status: "completed", outcome };
+                }
+            }
+            return {
+                status: existing.status === "uncertain" || existing.status === "invoking" ? "uncertain" : "pending",
+            };
+        }
+        if (request.kind === "agent" ||
+            request.kind === "fn" ||
+            request.kind === "verify" ||
+            isFlowToolEffect(request))
+            return "flow";
+        if (request.kind !== "model" && effectRequestHash(request) !== requestHash)
+            throw new HarnessApiError("invalid", "The request hash does not match the request");
+        if (request.kind === "delegation") {
+            // Lifecycle points of an agent used as a tool: journaled once, so replays never re-emit.
+            const outcome = { value: null };
+            await t.put("effects", request.effectId, { request, requestHash, status: "completed", outcome });
+            const settled = request.effectId.endsWith(":settled");
+            const callId = request.context?.callId;
+            await t.event(s.id, s.activeTurnId, settled ? "delegation.completed" : "delegation.started", {
+                agent: request.agent,
+                ...(typeof callId === "string" ? { callId } : {}),
+                ...request.input,
+            });
+            return { status: "completed", outcome };
+        }
+        const agentManifest = manifestFor(s.manifest, request.agent);
+        if (!agentManifest)
+            throw new Error(`Agent '${request.agent?.id ?? ""}' is not used as a tool`);
+        const executed = request.kind === "model" ||
+            (request.kind === "tool" &&
+                (mcpToolOf(s.mcpSnapshot, request) !== undefined ||
+                    sandboxCapabilityOf(agentManifest, request.capabilityId, request.toolName) !== undefined ||
+                    // `save_artifact` (F8.1) runs beside the sandbox tools.
+                    isSaveArtifactCall(agentManifest, request)));
+        await t.put("effects", request.effectId, {
+            request: storedRequest(request),
+            requestHash,
+            status: executed ? "invoking" : "pending",
+        });
+        // `save_artifact` writes the Tenant's artifacts: core runs it, reading the file through the
+        // workspace capability, wherever the sandbox is.
+        if (executed && request.kind === "tool" && isSaveArtifactCall(agentManifest, request))
+            return "save";
+        if (executed)
+            return { status: "execute" };
+        await offerActionFor(scope, t, s, agentManifest, request);
+        return { status: "pending" };
+    });
+    if (answer === "save")
+        return saveArtifact(scope, request);
+    if (answer !== "flow")
+        return answer;
+    if (!isFlowEffect(request))
+        return { status: "pending" };
+    return resolveNewFlowEffect(ctx, request, signal, lease);
+}
+/**
+ * Runs `save_artifact` (F8.1) for the run and records its outcome, as a harness would record a
+ * call it ran: the run gets the outcome as the intent's answer.
+ */
+async function saveArtifact(scope, request) {
+    let value;
+    try {
+        value = await callSaveArtifact(scope.ctx, request, scope.signal);
+    }
+    catch (error) {
+        if (isOwnershipLost(error))
+            throw error;
+        return recordOutcome(scope, request.effectId, {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    return recordOutcome(scope, request.effectId, { value });
+}
+/** A tool or hook Action for the agent's endpoint, in the intent's transaction. */
+async function offerActionFor(scope, t, s, agentManifest, request) {
+    const tool = request.kind === "tool" ? pinnedTool(agentManifest, request.capabilityId, request.toolName) : undefined;
+    const base = {
+        actionId: request.effectId,
+        sessionId: request.sessionId,
+        turnId: request.turnId,
+        agentId: request.agentId,
+        manifestHash: request.manifestHash,
+        implementationVersion: s.implementationVersion,
+        input: request.input,
+        context: request.context,
+        status: "pending",
+        generation: 0,
+        ...(request.agent ? { agent: request.agent } : {}),
+    };
+    const action = request.kind === "hook"
+        ? {
+            ...base,
+            kind: "hook",
+            hook: {
+                at: request.hook.at,
+                scope: request.hook.scope,
+                capabilityIds: [...request.hook.capabilityIds],
+            },
+        }
+        : {
+            ...base,
+            kind: "tool",
+            capabilityId: request.capabilityId,
+            toolName: request.toolName,
+            ...(tool?.inputSchema ? { inputSchema: tool.inputSchema } : {}),
+            ...(tool?.outputSchema ? { outputSchema: tool.outputSchema } : {}),
+        };
+    await t.put("actions", action.actionId, action);
+    await t.event(s.id, s.activeTurnId, "action.pending", {
+        actionId: action.actionId,
+        kind: action.kind,
+        ...actionTarget(action),
+        ...(action.kind === "tool" ? toolIds(request.context) : {}),
+        input: action.input,
+    });
+    await offerAction(t, scope.ctx, action);
+}
+/**
+ * Records the outcome of a call the harness ran: `value`, with its transcript events, or the
+ * `error` that left it uncertain. Only a cancel discards an outcome in hand (§10.7): after any
+ * other abort (shutdown, deadline) it is recorded, so the next advance replays it.
+ */
+export async function recordOutcome(scope, effectId, result) {
+    const { ctx, lease, signal } = scope;
+    if ("error" in result) {
+        await ctx.store.tx(async (t) => {
+            const s = await t.assertEpoch(lease.sessionId, lease.epoch);
+            const effect = await t.get("effects", effectId);
+            if (!effect)
+                return;
+            const { request } = effect;
+            effect.status = "uncertain";
+            effect.error = result.error;
+            await t.put("effects", effectId, effect);
+            if (s && s.status !== "cancelled" && s.activeTurnId === request.turnId)
+                await t.event(s.id, request.turnId, "effect.uncertain", { effectId, message: result.error });
+        });
+        return { status: "uncertain" };
+    }
+    const { value } = result;
+    return ctx.store.tx(async (t) => {
+        const s = await t.assertEpoch(lease.sessionId, lease.epoch);
+        const effect = await t.get("effects", effectId);
+        if (!effect)
+            throw new HarnessApiError("invalid", `Effect ${effectId} was never journaled`);
+        const { request } = effect;
+        if (s.status === "cancelled" || s.activeTurnId !== request.turnId || abortKind(signal) === "cancel")
+            throw TURN_CANCELLED();
+        effect.status = "completed";
+        effect.outcome = { value };
+        await t.put("effects", effectId, effect);
+        const model = request.kind === "model";
+        const failed = model ? modelFailed(request, value) : undefined;
+        // A summary call is never an assistant message; the last one publishes context.compacted.
+        const summarizing = model && Boolean(request.context.compaction);
+        const compacted = summarizing && !failed ? contextCompacted(request, value) : undefined;
+        const transcript = failed || summarizing
+            ? undefined
+            : model
+                ? assistantMessage(request, value)
+                : toolCompleted(request, value);
+        if (failed)
+            await t.event(s.id, request.turnId, "model.failed", failed);
+        if (compacted)
+            await t.event(s.id, request.turnId, "context.compacted", compacted);
+        if (transcript && model)
+            await t.event(s.id, request.turnId, "message.assistant", transcript);
+        else if (transcript)
+            await t.event(s.id, request.turnId, "tool.completed", transcript);
+        return { status: "completed", outcome: effect.outcome };
+    });
+}
+/** What a journal row keeps of a request: a model call without its prompt. */
+function storedRequest(request) {
+    if (request.kind !== "model" || request.input === undefined)
+        return request;
+    const { input: _, ...stored } = request;
+    return stored;
+}