@nylorun/runtime 0.17.0-beta → 0.19.1-beta

package/dist/tenant/session.d.ts

@@ -1,5 +1,11 @@
-import type { Action } from "@nylorun/core/contracts";
-import type { AgentManifest, JsonValue } from "@nylorun/core/define";
+/**
+ * Pure helpers over the session document: turn-manifest pins and variants, and state rebasing.
+ * No store access and no I/O. (The tools of an MCP snapshot
+ * live in `mcp/snapshot.ts`.)
+ *
+ * Later waves: stable; the async store conversion (Wave 1 / A) does not change these.
+ */
+import type { AgentManifest } from "@nylorun/core/define";
 import { type TurnManifestStore } from "../core/turn-manifest.js";
 import type { Session } from "./context.js";
 export { manifestFor, sessionToolsOf } from "../mcp/snapshot.js";
@@ -7,43 +13,4 @@ export { manifestFor, sessionToolsOf } from "../mcp/snapshot.js";
 export declare function variantStore(session: Session): TurnManifestStore;
 /** Manifest this turn's checkpoint is pinned to (session pin or a stored variant). */
 export declare function turnManifestOf(session: Session): AgentManifest;
-/** Wrap a linked agent turn so the Loop learns the turn's manifest (SD-I4 pin stays on session). */
-export declare function linkedAgentOutput(session: Session, output: JsonValue | undefined): JsonValue;
 export declare function rebaseSessionState(session: Session, turnHash: string): void;
-export declare function pinnedTool(manifest: AgentManifest, capabilityId?: string, toolName?: string): import("@nylorun/core/define").ToolManifest | undefined;
-/** What an action runs, for events: a tool name, or a hook point and its capabilities. */
-export declare function actionTarget(action: Action): {
-    hook: {
-        at: "after" | "before";
-        scope: "step" | "turn";
-        capabilityIds: string[];
-    };
-    agent?: {
-        id: string;
-        path: string;
-        delegationId?: string | undefined;
-    } | undefined;
-} | {
-    toolName: string;
-    agent?: {
-        id: string;
-        path: string;
-        delegationId?: string | undefined;
-    } | undefined;
-} | {
-    path: string;
-    key: string;
-    agent?: {
-        id: string;
-        path: string;
-        delegationId?: string | undefined;
-    } | {
-        id: string;
-        path: string;
-        delegationId?: string | undefined;
-    } | {
-        id: string;
-        path: string;
-        delegationId?: string | undefined;
-    } | undefined;
-};

package/dist/tenant/session.js

@@ -1,12 +1,3 @@
-/**
- * Pure helpers over the session document: turn-manifest pins and variants, state rebasing,
- * and the event target of an Action. No store access and no I/O. (The tools of an MCP snapshot
- * live in `mcp/snapshot.ts`.)
- *
- * Later waves: stable; the async store conversion (Wave 1 / A) does not change these.
- */
-import { agentTurnValue } from "@nylorun/harness/run";
-import { isWorkflowManifest } from "../core/flow-host.js";
 import { allowedManifestHashes, rebaseTurnState, } from "../core/turn-manifest.js";
 export { manifestFor, sessionToolsOf } from "../mcp/snapshot.js";
 /** Turn-manifest store backed by the session's `variants` map (no schema change). */
@@ -27,12 +18,6 @@ export function turnManifestOf(session) {
         return session.manifest;
     return session.variants?.[hash] ?? session.manifest;
 }
-/** Wrap a linked agent turn so the Loop learns the turn's manifest (SD-I4 pin stays on session). */
-export function linkedAgentOutput(session, output) {
-    if (isWorkflowManifest(session.manifest))
-        return output ?? null;
-    return agentTurnValue(output ?? null, turnManifestOf(session));
-}
 export function rebaseSessionState(session, turnHash) {
     const allowed = allowedManifestHashes({
         pinnedHash: session.manifestHash,
@@ -46,25 +31,3 @@ export function rebaseSessionState(session, turnHash) {
     if (next !== session.state)
         session.state = next;
 }
-export function pinnedTool(manifest, capabilityId, toolName) {
-    const capability = manifest.capabilities.find((item) => item.id === capabilityId);
-    return capability?.tools?.find((tool) => tool.name === toolName);
-}
-/** What an action runs, for events: a tool name, or a hook point and its capabilities. */
-export function actionTarget(action) {
-    if (action.kind === "hook")
-        return {
-            hook: action.hook,
-            ...(action.agent ? { agent: action.agent } : {}),
-        };
-    if (action.kind === "tool" && "toolName" in action)
-        return {
-            toolName: action.toolName,
-            ...(action.agent ? { agent: action.agent } : {}),
-        };
-    return {
-        path: action.path,
-        key: action.key,
-        ...(action.agent ? { agent: action.agent } : {}),
-    };
-}

package/dist/tenant/sessions.js

@@ -3,8 +3,9 @@
  * re-attach vaults), the session list and the session view. Reads use the store's typed
  * queries; `PUT /v1/sessions/:id` runs in one transaction with the vault attachment checks.
  */
-import { DefinitionDocumentSchema, } from "@nylorun/core/contracts";
+import { DefinitionDocumentSchema, definitionFilesOf, } from "@nylorun/core/contracts";
 import { hashManifest } from "@nylorun/core/compatibility";
+import { codeToolRefusal } from "@nylorun/core/define";
 import { aggregateWaits, isWorkflowManifest } from "../core/flow-host.js";
 import { canonical } from "../store/canonical.js";
 import { validateSandboxAttach } from "../core/sandbox-routes.js";
@@ -16,6 +17,7 @@ import { checkPlacement, requirePods } from "../sandbox/placement.js";
 import { attachSandbox, recordAttachment } from "./sandboxes.js";
 import { sandboxLookup, } from "./context.js";
 import { fail } from "./http.js";
+import { missingDefinitionFiles } from "./definition-files.js";
 /** A session's creation identity: everything but the request id and vault attachments. */
 const sessionIdentity = (value) => {
     const { requestId: _requestId, vaultIds: _vaultIds, credentialSelections: _selections, ...body } = value ?? {};
@@ -54,6 +56,10 @@ export async function putDefinition(ctx, agentId, body) {
     if (body.manifest.id !== agentId)
         fail(400, "Agent id mismatch");
     DefinitionDocumentSchema.parse(body.manifest);
+    // The Runtime runs no code of yours during a session (track R2): no tool may need it.
+    const code = codeToolRefusal(body.manifest);
+    if (code)
+        fail(400, code);
     const declared = declaredSandboxes(body.manifest);
     if (declared.length > 0)
         fail(400, `${declared.join(", ")} declares a sandbox. Agents no longer declare one: remove .sandbox() and open the session with it, createSession({ sandbox: { image, network: { allow }, resources } }), or set the Tenant's default sandbox. See MIGRATION.md.`);
@@ -61,7 +67,14 @@ export async function putDefinition(ctx, agentId, body) {
         ...body,
         manifestHash: hashManifest(body.manifest),
     };
-    await ctx.store.tx((t) => t.put("definitions", agentId, definition));
+    const files = [...definitionFilesOf(body.manifest)];
+    await ctx.store.tx(async (t) => {
+        const missing = await missingDefinitionFiles(t, body.manifest);
+        if (missing.length > 0)
+            fail(400, `The definition names ${missing.length} file(s) the Runtime does not hold; upload each with PUT /v1/files/<sha256> first: ${missing.join(", ")}`, { code: "definition_files_missing", details: { missing } });
+        await t.put("definitions", agentId, definition);
+        await t.insertDefinitionFileUses(agentId, definition.manifestHash, files);
+    });
     return {
         agentId,
         manifestHash: definition.manifestHash,
@@ -156,7 +169,6 @@ export async function putSession(ctx, id, body, access, options = {}) {
             creation: body,
             vaultIds,
             credentialSelections,
-            pluginRoots: definition.pluginRoots ?? {},
             ...(sandbox.sandboxOwnerId !== undefined
                 ? { sandboxOwnerId: sandbox.sandboxOwnerId }
                 : {}),
@@ -221,7 +233,7 @@ async function sessionSandbox(t, body, definition, options) {
     return pin(definition, resolved.spec, resolved.source);
 }
 async function pin(definition, spec, source) {
-    // A workflow's manifest stays as registered: Action endpoints match workflow actions by its hash.
+    // A workflow's manifest stays as registered: its agents inherit the sandbox when they start.
     if (isWorkflowManifest(definition.manifest))
         return { spec, source };
     const sandboxed = withSandboxCapability(definition.manifest, spec);
@@ -249,9 +261,6 @@ export async function sessionView(t, s) {
         if (aggregated.length > 0)
             waits = aggregated;
     }
-    const actions = await t.actionsForSession(s.id, {
-        statuses: ["pending", "delivering", "uncertain"],
-    });
     const uncertain = await t.effectsForSession(s.id, {
         statuses: ["uncertain"],
     });
@@ -273,7 +282,6 @@ export async function sessionView(t, s) {
         mcpDiagnostics: s.mcpDiagnostics ?? [],
         waits,
         error: s.error,
-        actions,
         uncertainEffects: uncertain.map((e) => ({
             effectId: e.request.effectId,
             turnId: e.request.turnId,

package/dist/tenant/signing-keys.d.ts

@@ -1,6 +1,6 @@
 /**
- * Tenant signing keys for the tokens the Runtime signs itself (delivery tokens, capability
- * links, run and host tokens). Each key is an ES256 pair: the public JWK is stored
+ * Tenant signing keys for the tokens the Runtime signs itself (capability links, run and host
+ * tokens). Each key is an ES256 pair: the public JWK is stored
  * as is, the PKCS#8 private key is sealed with the vault KEK (AAD bound to the Tenant and key
  * id), like a credential.
  *
@@ -44,7 +44,7 @@ export declare class SigningKeys {
     /**
      * Rotates: previous → revoked, current → previous, standby → current, new standby. Refused
      * with 409 while the previous key may still verify live tokens (retired less than the
-     * longest token lifetime, `maxTtlSeconds` or a delivery token's, plus a minute ago), unless
+     * longest token lifetime, `maxTtlSeconds` or `TOKEN_TTL_MAX_SECONDS`, plus a minute ago), unless
      * `force`.
      */
     rotate(t: Tx, kek: Buffer, maxTtlSeconds: number, force: boolean): Promise<SigningKeyRow[]>;

package/dist/tenant/signing-keys.js

@@ -1,6 +1,6 @@
 /**
- * Tenant signing keys for the tokens the Runtime signs itself (delivery tokens, capability
- * links, run and host tokens). Each key is an ES256 pair: the public JWK is stored
+ * Tenant signing keys for the tokens the Runtime signs itself (capability links, run and host
+ * tokens). Each key is an ES256 pair: the public JWK is stored
  * as is, the PKCS#8 private key is sealed with the vault KEK (AAD bound to the Tenant and key
  * id), like a credential.
  *
@@ -15,7 +15,7 @@
  */
 import { exportJWK, exportPKCS8, generateKeyPair, importJWK, importPKCS8, } from "jose";
 import { newSigningKeyId, SIGNING_KEY_ID_PATTERN, } from "@nylorun/core/compatibility";
-import { DELIVERY_TOKEN_MAX_TTL_SECONDS } from "@nylorun/core/contracts";
+import { TOKEN_TTL_MAX_SECONDS } from "@nylorun/core/contracts";
 import { decryptSecret, encryptSecret } from "../vault/crypto.js";
 import { fail } from "./http.js";
 const ALG = "ES256";
@@ -107,7 +107,7 @@ export class SigningKeys {
     /**
      * Rotates: previous → revoked, current → previous, standby → current, new standby. Refused
      * with 409 while the previous key may still verify live tokens (retired less than the
-     * longest token lifetime, `maxTtlSeconds` or a delivery token's, plus a minute ago), unless
+     * longest token lifetime, `maxTtlSeconds` or `TOKEN_TTL_MAX_SECONDS`, plus a minute ago), unless
      * `force`.
      */
     async rotate(t, kek, maxTtlSeconds, force) {
@@ -118,7 +118,7 @@ export class SigningKeys {
         const [previous] = await t.signingKeys(["previous"]);
         if (previous && !force) {
             const retired = Date.parse(previous.retiredAt ?? previous.createdAt);
-            const longest = Math.max(maxTtlSeconds, DELIVERY_TOKEN_MAX_TTL_SECONDS);
+            const longest = Math.max(maxTtlSeconds, TOKEN_TTL_MAX_SECONDS);
             const until = retired + longest * 1000 + ROTATION_GRACE_MS;
             if (until > now.getTime())
                 fail(409, "The previous key may still verify live tokens", {

package/dist/tenant/skill-tool.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The skill tools (track R2 M4): `load_skill` and `read_skill_resource`, which the build gives
+ * the first capability with skills. The Runtime runs them itself, like `save_artifact`, from the
+ * definition files uploaded with the agent: no developer process is involved.
+ *
+ * - `load_skill`: the skill's instructions (its `SKILL.md` after the frontmatter), the paths of
+ *   its other files, and, when the session has a sandbox, where they are in it
+ *   (`/skills/<name>/`, read-only).
+ * - `read_skill_resource`: one text file of the skill. A binary file is refused: the model reads
+ *   it in the sandbox, when there is one.
+ *
+ * Expected problems are failed outcomes the model sees; only infrastructure errors throw.
+ */
+import type { SandboxToolOutcome } from "@nylorun/core/contracts";
+import { type AgentManifest } from "@nylorun/core/define";
+import type { HostEffect } from "@nylorun/harness/run";
+import type { TenantContext } from "./context.js";
+/** True when `request` calls a skill tool the Runtime serves for `manifest`'s agent. */
+export declare function isSkillToolCall(manifest: AgentManifest | undefined, request: HostEffect): boolean;
+export declare function callSkillTool(ctx: TenantContext, manifest: AgentManifest, request: HostEffect, signal: AbortSignal): Promise<SandboxToolOutcome>;

package/dist/tenant/skill-tool.js

@@ -0,0 +1,72 @@
+import { LOAD_SKILL_TOOL, SANDBOX_CAPABILITY_ID, SKILL_ENTRY, SKILLS_MOUNT, isSkillTool, skillInstructions, } from "@nylorun/core/define";
+import { sandboxCapabilityOf } from "../sandbox/capability.js";
+import { readDefinitionFile } from "./definition-files.js";
+const failed = (code, message) => ({ kind: "failed", code, message });
+/** True when `request` calls a skill tool the Runtime serves for `manifest`'s agent. */
+export function isSkillToolCall(manifest, request) {
+    return (request.kind === "tool" &&
+        isSkillTool(manifest?.capabilities.find((capability) => capability.id === request.capabilityId), request.toolName));
+}
+/** Every skill of the agent, by name. */
+function skillsOf(manifest) {
+    const skills = new Map();
+    for (const capability of manifest.capabilities)
+        for (const skill of Object.values(capability.skills ?? {}))
+            skills.set(skill.name, skill);
+    return skills;
+}
+/** UTF-8 text, or undefined for bytes that are not (a NUL byte, or invalid UTF-8). */
+function textOf(bytes) {
+    if (bytes.includes(0))
+        return undefined;
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function callSkillTool(ctx, manifest, request, signal) {
+    const input = (request.input ?? {});
+    const skills = skillsOf(manifest);
+    const name = typeof input.name === "string" ? input.name : "";
+    const skill = skills.get(name);
+    if (!skill)
+        return request.toolName === LOAD_SKILL_TOOL
+            ? { kind: "completed", output: { unknown: name, available: [...skills.keys()].sort() } }
+            : failed("skill.unknown", `There is no skill '${name}'.`);
+    const sandboxed = sandboxCapabilityOf(manifest, SANDBOX_CAPABILITY_ID, "bash") !== undefined;
+    const directory = `${SKILLS_MOUNT}/${skill.name}/`;
+    const read = async (path) => {
+        const bytes = await readDefinitionFile(ctx.blobs, skill.files[path], signal);
+        if (!bytes)
+            throw new Error(`The bytes of ${skill.files[path]} (${skill.name}/${path}) are missing from the Object store`);
+        return bytes;
+    };
+    if (request.toolName === LOAD_SKILL_TOOL) {
+        const text = textOf(await read(SKILL_ENTRY));
+        if (text === undefined)
+            return failed("skill.binary_resource", `${SKILL_ENTRY} of '${skill.name}' is not text.`);
+        const resources = Object.keys(skill.files)
+            .filter((path) => path !== SKILL_ENTRY)
+            .sort();
+        return {
+            kind: "completed",
+            output: {
+                name: skill.name,
+                content: skillInstructions(text),
+                ...(resources.length === 0 ? {} : { resources }),
+                ...(sandboxed ? { sandboxPath: directory } : {}),
+            },
+        };
+    }
+    const path = typeof input.path === "string" ? input.path : "";
+    if (skill.files[path] === undefined)
+        return failed("skill.unknown_resource", `Skill '${skill.name}' has no resource '${path}'.`);
+    const content = textOf(await read(path));
+    if (content === undefined)
+        return failed("skill.binary_resource", sandboxed
+            ? `${path} is not a text file. It is in the sandbox at ${directory}${path}; use it there.`
+            : `${path} is not a text file; only text files can be read without a sandbox.`);
+    return { kind: "completed", output: { name: skill.name, path, content } };
+}

package/dist/tenant/slim.d.ts

@@ -3,6 +3,6 @@ import type { Tx } from "../store/types.js";
  * Slim the completed model effects of a turn that ended (Model Calls §9): drop the prompt
  * and the answer, which the transcript already holds, and keep the identity and status.
  * Replay only ever reads the effects of a running segment. Tool, flow and uncertain rows
- * are never touched: completed actions return their receipts, and status lists uncertain work.
+ * are never touched: status lists uncertain work.
  */
 export declare function slimModelEffects(t: Tx, sessionId: string, turnId: string | null): Promise<void>;

package/dist/tenant/slim.js

@@ -2,7 +2,7 @@
  * Slim the completed model effects of a turn that ended (Model Calls §9): drop the prompt
  * and the answer, which the transcript already holds, and keep the identity and status.
  * Replay only ever reads the effects of a running segment. Tool, flow and uncertain rows
- * are never touched: completed actions return their receipts, and status lists uncertain work.
+ * are never touched: status lists uncertain work.
  */
 export async function slimModelEffects(t, sessionId, turnId) {
     if (!turnId)

package/dist/tenant/status.js

@@ -56,16 +56,13 @@ export async function buildTenantStatus(ctx) {
         ctx.stuckInvocations ? executionStatus(ctx.stuckInvocations) : undefined,
         ctx.streamsStatus?.(),
     ]);
-    const definitionIds = new Set(definitions
-        .map((d) => d.manifest?.id)
-        .filter((id) => typeof id === "string"));
-    const endpointIds = new Set((await ctx.store.tx((t) => t.listEndpoints())).map((e) => e.agentId));
-    const agentIds = new Set([...definitionIds, ...endpointIds]);
-    const agents = [...agentIds].sort().map((agentId) => ({
-        agentId,
-        registered: definitionIds.has(agentId),
-        endpoint: endpointIds.has(agentId),
-    }));
+    const agents = [
+        ...new Set(definitions
+            .map((d) => d.manifest?.id)
+            .filter((id) => typeof id === "string")),
+    ]
+        .sort()
+        .map((agentId) => ({ agentId }));
     return {
         tenant: ctx.envelope,
         path: ctx.config.paths.root,
@@ -73,7 +70,6 @@ export async function buildTenantStatus(ctx) {
             store: health.schemaVersion > 0,
             scheduler: !ctx.closing,
             model: ctx.modelConfigured || modelView.configured,
-            endpoints: true,
             schema: health.ok,
         },
         model: modelView,
@@ -81,7 +77,6 @@ export async function buildTenantStatus(ctx) {
         counts: {
             sessions: counts.sessions,
             runningSessions: counts.runningSessions,
-            pendingActions: counts.pendingActions,
             uncertainEffects: counts.uncertainEffects,
         },
         sandbox: {

package/dist/tenant/store-pg.d.ts

@@ -1,3 +1,18 @@
+/**
+ * Opens the Host's Tenant on its Postgres database (tenancy.md §4–§5, plan P9).
+ *
+ * The database holds one Tenant (`store/postgres/tenant.ts`): opening migrates it, creates
+ * the Tenant on first start (from the Host's configuration: id, name, Studio and derived
+ * principals), and opens the Tenant Runtime on its Session Store. What stays on the Host root
+ * is the Tenant directory `tenant/`: the vault key (`vault-kek`), `logs/`, and the private
+ * `home/` and `sandboxes/`.
+ *
+ * - A failure in the Tenant (an old layout, a database newer than this Runtime, a failed
+ *   migration, an unreadable Tenant row, vault ciphertext without its key) rejects with that
+ *   `TenantOpenError`; the Host reports it and fails readiness.
+ * - A failure outside the Tenant (Postgres unreachable, its sweep not armed in Restate) is
+ *   `TenantUnavailableError`; the Tenant module retries.
+ */
 import type { PostgresClient } from "../store/postgres/connect.js";
 import type { Migration } from "../store/postgres/migrate.js";
 import { type TenantCreation } from "../store/postgres/tenant.js";

package/dist/tenant/store-pg.js

@@ -4,8 +4,8 @@
  * The database holds one Tenant (`store/postgres/tenant.ts`): opening migrates it, creates
  * the Tenant on first start (from the Host's configuration: id, name, Studio and derived
  * principals), and opens the Tenant Runtime on its Session Store. What stays on the Host root
- * is the Tenant directory `tenant/`: the vault key (`vault-kek`), `plugin-data/`, `logs/`,
- * and the private `home/`, `tmp/` and `sandboxes/`.
+ * is the Tenant directory `tenant/`: the vault key (`vault-kek`), `logs/`, and the private
+ * `home/` and `sandboxes/`.
  *
  * - A failure in the Tenant (an old layout, a database newer than this Runtime, a failed
  *   migration, an unreadable Tenant row, vault ciphertext without its key) rejects with that
@@ -13,6 +13,7 @@
  * - A failure outside the Tenant (Postgres unreachable, its sweep not armed in Restate) is
  *   `TenantUnavailableError`; the Tenant module retries.
  */
+import { createPostgresReadStore } from "../store/postgres/reads.js";
 import { mkdirSync } from "node:fs";
 import { openTenantDatabase, } from "../store/postgres/tenant.js";
 import { TenantOpenError } from "./cause.js";
@@ -54,13 +55,16 @@ export function createPostgresTenantOpener(options) {
                 from: opened.migrated.from,
                 to: opened.migrated.to,
             });
+        let reads;
         try {
+            reads = createPostgresReadStore(options.sql, tenantId);
             const config = options.configFor(tenantId);
             const paths = tenantPaths(options.hostRoot);
             mkdirSync(paths.root, { recursive: true, mode: 0o700 });
-            return await options.openRuntime({ ...config, tenantId }, { store, envelope });
+            return await options.openRuntime({ ...config, tenantId }, { store, envelope, reads });
         }
         catch (error) {
+            await reads?.close().catch(() => undefined);
             await store.close().catch(() => undefined);
             if (error instanceof TenantOpenError) {
                 // The Tenant's own failure (`kek-missing`): report which Tenant it is.

package/dist/tenant/streams.d.ts

@@ -16,9 +16,8 @@
  *   and `streamsStatus` reports the basin's state.
  * - **Readers.** History and session SSE read the session's stream
  *   (`tenant/session-streams.ts`). This module runs one `tenant/control` reader per Tenant per
- *   process, on the current basin, which calls `ctx.abortLocal` for each `session.cancel`,
- *   passes an Action's outcome to a run held here for each `action.resolved` (F6.2), and
- *   checks the session streams for each `sessions.reset`.
+ *   process, on the current basin, which calls `ctx.abortLocal` for each `session.cancel`
+ *   and checks the session streams for each `sessions.reset`.
  *
  * The caller passes the streams: the Host's S2 streams, or `MemoryStreams` for tests and a
  * local development Host (not durable).
@@ -78,12 +77,6 @@ export declare function wireStreams(ctx: TenantContext, options: WireStreamsOpti
  * effect), so failures are logged, never thrown.
  */
 export declare function signalSessionCancel(ctx: TenantContext, sessionId: string, turnId: string | null): void;
-/**
- * Appends `action.resolved` for an Action whose outcome just committed, so a run held for it
- * by a harness of another process goes on (F6.2). Call it from `t.afterCommit`. A lost signal
- * costs the hold's time only: the segment then ends as waiting and resumes by replay.
- */
-export declare function signalActionOutcome(ctx: TenantContext, sessionId: string, actionId: string): void;
 /**
  * After a reset deleted the Tenant's sessions and moved it to a new basin generation: tells
  * every process with the Tenant open (`sessions.reset` on the old basin's control stream),
@@ -91,7 +84,7 @@ export declare function signalActionOutcome(ctx: TenantContext, sessionId: strin
  * are logged; the periodic check and the next open finish the job.
  */
 export declare function tenantReset(ctx: TenantContext): Promise<void>;
-/** Tenant status of the streams seam (for `GET /v1/tenant` and the Admin API). */
+/** Tenant status of the streams seam (for `GET /v1/tenant`). */
 export interface StreamsStatus {
     /** The streams' service answered a probe (`probeStreams`) within the timeout. */
     reachable: boolean;

package/dist/tenant/streams.js

@@ -1,5 +1,5 @@
 import { basinOf } from "../streams/basin.js";
-import { signalActionResolved, signalCancel, signalSessionsReset } from "../streams/control.js";
+import { signalCancel, signalSessionsReset } from "../streams/control.js";
 import { createStreamRelay, } from "../streams/relay/core.js";
 import { CONTROL_STREAM, } from "../streams/types.js";
 import { checkSessionStreams, currentBasin, sleep, } from "./session-streams.js";
@@ -59,10 +59,6 @@ export async function wireStreams(ctx, options) {
         const signal = body;
         if (signal?.type === "session.cancel" && typeof signal.sessionId === "string")
             ctx.abortLocal(signal.sessionId, typeof signal.turnId === "string" ? signal.turnId : undefined);
-        else if (signal?.type === "action.resolved" &&
-            typeof signal.sessionId === "string" &&
-            typeof signal.actionId === "string")
-            void resolveHeld(ctx, signal.sessionId, signal.actionId).catch(report("held run resolution failed"));
         else if (signal?.type === "sessions.reset")
             void checkSessionStreams(ctx).catch(report("session stream check failed"));
     }, report("control stream read failed; retrying"));
@@ -171,25 +167,6 @@ export function signalSessionCancel(ctx, sessionId, turnId) {
         message: messageOf(error),
     }));
 }
-/**
- * Appends `action.resolved` for an Action whose outcome just committed, so a run held for it
- * by a harness of another process goes on (F6.2). Call it from `t.afterCommit`. A lost signal
- * costs the hold's time only: the segment then ends as waiting and resumes by replay.
- */
-export function signalActionOutcome(ctx, sessionId, actionId) {
-    const streams = ctx.sessionStreams.wiring?.streams;
-    if (!streams)
-        return;
-    void signalActionResolved(streams, currentBasin(ctx), sessionId, actionId).catch((error) => ctx.config.logger.warn("action resolved signal failed", { sessionId, message: messageOf(error) }));
-}
-/** Passes an Action's recorded outcome to the run of `sessionId` held here, if any. */
-async function resolveHeld(ctx, sessionId, actionId) {
-    if (!ctx.harness.holds(sessionId))
-        return;
-    const effect = await ctx.store.tx((t) => t.get("effects", actionId));
-    if (effect?.status === "completed" && effect.outcome)
-        ctx.harness.resolved(sessionId, actionId, effect.outcome);
-}
 /**
  * After a reset deleted the Tenant's sessions and moved it to a new basin generation: tells
  * every process with the Tenant open (`sessions.reset` on the old basin's control stream),

package/dist/tenant/sweep.js

@@ -14,9 +14,6 @@
  *    workspace capability (`harness-api/workspace.ts`: here, or in the harness that serves
  *    workspaces). Idle MCP connections of the in-process harness are closed.
  * 4. **Hooks.** Callbacks registered with `ctx.onSweep`.
- * 5. **Deliveries.** Deliveries to Action endpoints whose deadline passed without an answer are
- *    lost (`delivery.ts` `loseAction`), and pending Actions of agents with an endpoint are sent
- *    again, in case a send was lost between a commit and the execution.
  *
  * Every step runs one transaction per session it changes (a linked agent and its workflow
  * share one, child first), so the sweep follows the lock order in `store/types.ts`. A failing
@@ -24,14 +21,12 @@
  * reports it.
  */
 import { pendingAgentEffects, reconcilePendingAgentEffect, } from "../core/flow-host.js";
-import { sweepDeliveries } from "./delivery.js";
 const BATCH = 100;
 export async function sweep(ctx) {
     if (ctx.closing || ctx.closed)
         return;
     const now = new Date();
     const steps = [
-        ["deliveries", () => sweepDeliveries(ctx, now)],
         ["linked", () => reconcileLinkedAgents(ctx)],
         ["orphans", () => wakeOrphanedSessions(ctx, now)],
         [

package/dist/tenant/transcript.d.ts

@@ -4,7 +4,7 @@
  * Payload schemas: `@nylorun/core/contracts` (`parseTranscriptEvent`).
  */
 import type { HostEffect } from "@nylorun/harness/run";
-/** The model's tool call id and the harness invocation, for tool effects and tool actions. */
+/** The model's tool call id and the harness invocation, for tool effects. */
 export declare function toolIds(context: unknown): {
     callId: string;
     invocationId: string;
@@ -75,7 +75,7 @@ export declare function modelFailed(request: HostEffect, value: unknown): {
     message: string;
     retryable: boolean;
 } | undefined;
-/** `tool.completed` for an MCP or sandbox tool: its output, or the tool error it reported. */
+/** `tool.completed` for a tool the Runtime ran: its output, or the tool error it reported. */
 export declare function toolCompleted(request: HostEffect, value: unknown): {
     agent: import("@nylorun/core/define").AgentRef;
     error: {

package/dist/tenant/transcript.js

@@ -1,5 +1,5 @@
 import { isModelFailureOutcome } from "@nylorun/core/define";
-/** The model's tool call id and the harness invocation, for tool effects and tool actions. */
+/** The model's tool call id and the harness invocation, for tool effects. */
 export function toolIds(context) {
     const c = context;
     return typeof c?.callId === "string" && typeof c.invocationId === "string"
@@ -91,7 +91,7 @@ export function modelFailed(request, value) {
         ...agentOf(request),
     };
 }
-/** `tool.completed` for an MCP or sandbox tool: its output, or the tool error it reported. */
+/** `tool.completed` for a tool the Runtime ran: its output, or the tool error it reported. */
 export function toolCompleted(request, value) {
     const ids = toolIds(request.context);
     if (!("callId" in ids))