@rivet-dev/agentos-core 0.2.22 → 0.4.0

package/dist/agentos-package.d.ts

@@ -7,17 +7,28 @@
  * projection. Package metadata lives in `<dir>/agentos-package.json`.
  *
  * This module is therefore only the client-facing package-dir surface plus the
- * `/opt/agentos` path constants used for agent-config wiring.
+ * `/opt/agentos` path constants used for package wiring.
  *
  * See `website/src/content/docs/docs/architecture/packages-and-command-resolution.mdx`.
  */
-import type { AgentosPackageManifest, PackageAgentDescriptor, PackageRef as ManifestPackageRef } from "@agentos-software/manifest";
+export interface PackageProvidesFileDescriptor {
+    source: string;
+    target: string;
+}
+export interface PackageProvidesDescriptor {
+    env?: Record<string, string>;
+    files?: PackageProvidesFileDescriptor[];
+}
+export interface AgentosPackageManifest {
+    name: string;
+    version: string;
+    provides?: PackageProvidesDescriptor;
+}
 /** Root of the agentOS package tree inside the VM. */
 export declare const OPT_AGENTOS_ROOT = "/opt/agentos";
 /** The symlink farm on `$PATH` (commands link here). */
 export declare const OPT_AGENTOS_BIN = "/opt/agentos/bin";
-export type AgentBlock = PackageAgentDescriptor;
-export type PackageRef = ManifestPackageRef;
+export type PackageRef = string;
 export type SoftwarePackageRef = {
     packagePath: string;
 };

package/dist/agentos-package.js

@@ -7,7 +7,7 @@
  * projection. Package metadata lives in `<dir>/agentos-package.json`.
  *
  * This module is therefore only the client-facing package-dir surface plus the
- * `/opt/agentos` path constants used for agent-config wiring.
+ * `/opt/agentos` path constants used for package wiring.
  *
  * See `website/src/content/docs/docs/architecture/packages-and-command-resolution.mdx`.
  */
@@ -60,23 +60,6 @@ function validateAgentosPackageManifest(value, source) {
         name: value.name,
         version: value.version,
     };
-    if (value.agent !== undefined) {
-        if (!isPlainObject(value.agent) ||
-            typeof value.agent.acpEntrypoint !== "string") {
-            throw new Error(`Invalid agentOS package manifest at ${source}: invalid agent.acpEntrypoint`);
-        }
-        manifest.agent = {
-            acpEntrypoint: value.agent.acpEntrypoint,
-            ...(isStringRecord(value.agent.env) ? { env: value.agent.env } : {}),
-            ...(Array.isArray(value.agent.launchArgs) &&
-                value.agent.launchArgs.every((arg) => typeof arg === "string")
-                ? { launchArgs: value.agent.launchArgs }
-                : {}),
-            ...(typeof value.agent.snapshot === "boolean"
-                ? { snapshot: value.agent.snapshot }
-                : {}),
-        };
-    }
     if (value.provides !== undefined) {
         manifest.provides = value.provides;
     }
@@ -85,7 +68,3 @@ function validateAgentosPackageManifest(value, source) {
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isStringRecord(value) {
-    return (isPlainObject(value) &&
-        Object.values(value).every((entry) => typeof entry === "string"));
-}

package/dist/cron/cron-manager.js

@@ -2,15 +2,6 @@ import { randomUUID } from "node:crypto";
 import { resolveSchedule, validateScheduleForRegistration, } from "./parse-schedule.js";
 function describeAction(action) {
     switch (action.type) {
-        case "session":
-            return {
-                type: "session",
-                agentType: action.agentType,
-                prompt: action.prompt,
-                ...(action.options === undefined
-                    ? {}
-                    : { options: structuredClone(action.options) }),
-            };
         case "exec":
             return {
                 type: "exec",
@@ -159,24 +150,6 @@ export class CronManager {
     }
     async runAction(action) {
         switch (action.type) {
-            case "session": {
-                const sessionId = `cron-${randomUUID()}`;
-                await this.vm.openSession({
-                    ...action.options,
-                    sessionId,
-                    agent: action.agentType,
-                });
-                try {
-                    await this.vm.prompt({
-                        sessionId,
-                        content: [{ type: "text", text: action.prompt }],
-                    });
-                }
-                finally {
-                    await this.vm.deleteSession({ sessionId });
-                }
-                break;
-            }
             case "exec": {
                 await this.vm.execArgv(action.command, action.args ?? []);
                 break;

package/dist/cron/types.d.ts

@@ -1,11 +1,4 @@
-import type { OpenSessionInput } from "../session-api.js";
-import type { AgentType } from "../types.js";
 export type CronAction = {
-    type: "session";
-    agentType: AgentType;
-    prompt: string;
-    options?: Omit<OpenSessionInput, "agent" | "sessionId">;
-} | {
     type: "exec";
     command: string;
     args?: string[];
@@ -18,11 +11,6 @@ export type CronAction = {
  * expose only their kind: the host closure is execution state, not job data.
  */
 export type CronActionInfo = {
-    type: "session";
-    agentType: AgentType;
-    prompt: string;
-    options?: Omit<OpenSessionInput, "agent" | "sessionId">;
-} | {
     type: "exec";
     command: string;
     args?: string[];

package/dist/default-software/coreutils.aospkg

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: package/dist/default-software/coreutils.aospkg
+size: 67400857 bytes
+sha256: e269c2e6a04b2d0027e66d0efb49a2937304decc7963dcb66f394cdd5dad4186

package/dist/default-software/default-software.json

@@ -0,0 +1,10 @@
+[
+	"coreutils",
+	"sed",
+	"grep",
+	"gawk",
+	"findutils",
+	"diffutils",
+	"tar",
+	"gzip"
+]

package/dist/default-software.d.ts

@@ -1,8 +1,9 @@
-import type { SoftwarePackageRef } from "@agentos-software/manifest";
+import type { SoftwarePackageRef } from "./agentos-package.js";
 /**
- * Default software for a bare `AgentOs.create()`: the `@agentos-software/common`
- * coreutils bundle, imported like any other package. The client makes NO
- * npm/node_modules assumptions (see root CLAUDE.md) — no dep scan, no
- * require.resolve. Opt out with `defaultSoftware: false`; add more via `software`.
+ * Default software for a bare `AgentOs.create()`. The build stages the list
+ * from `software/default-software.json` and its immutable `.aospkg` files into
+ * the Core package; runtime resolution never consults npm or scans
+ * node_modules. Opt out with `defaultSoftware: false`; add more trusted paths
+ * via `software`.
  */
 export declare function resolveDefaultSoftware(): SoftwarePackageRef[];

package/dist/default-software.js

@@ -1,10 +1,21 @@
-import common from "@agentos-software/common";
+import { readFileSync } from "node:fs";
 /**
- * Default software for a bare `AgentOs.create()`: the `@agentos-software/common`
- * coreutils bundle, imported like any other package. The client makes NO
- * npm/node_modules assumptions (see root CLAUDE.md) — no dep scan, no
- * require.resolve. Opt out with `defaultSoftware: false`; add more via `software`.
+ * Default software for a bare `AgentOs.create()`. The build stages the list
+ * from `software/default-software.json` and its immutable `.aospkg` files into
+ * the Core package; runtime resolution never consults npm or scans
+ * node_modules. Opt out with `defaultSoftware: false`; add more trusted paths
+ * via `software`.
  */
 export function resolveDefaultSoftware() {
-    return [common].flat();
+    // Published consumers execute this module from dist/, while Vitest executes
+    // the TypeScript source directly. The build stages the same immutable
+    // artifacts in dist/default-software for both cases.
+    const moduleDirectory = new URL(".", import.meta.url);
+    const artifactDirectory = moduleDirectory.pathname.endsWith("/src/")
+        ? new URL("../dist/default-software/", moduleDirectory)
+        : new URL("./default-software/", moduleDirectory);
+    const names = JSON.parse(readFileSync(new URL("default-software.json", artifactDirectory), "utf8"));
+    return names.map((name) => ({
+        packagePath: new URL(`${name}.aospkg`, artifactDirectory).pathname,
+    }));
 }

package/dist/generated/VmLimitsConfig.d.ts

@@ -1,4 +1,3 @@
-import type { AcpLimitsConfig } from "./AcpLimitsConfig.js";
 import type { HostFunctionLimitsConfig } from "./HostFunctionLimitsConfig.js";
 import type { HttpLimitsConfig } from "./HttpLimitsConfig.js";
 import type { JsRuntimeLimitsConfig } from "./JsRuntimeLimitsConfig.js";
@@ -12,7 +11,6 @@ export type VmLimitsConfig = {
     http?: HttpLimitsConfig;
     hostFunctions?: HostFunctionLimitsConfig;
     plugins?: PluginLimitsConfig;
-    acp?: AcpLimitsConfig;
     jsRuntime?: JsRuntimeLimitsConfig;
     python?: PythonLimitsConfig;
     wasm?: WasmLimitsConfig;

package/dist/host-dir-mount.d.ts

@@ -36,7 +36,7 @@ export declare function hostDirMount(path: string, hostPath: string, opts?: {
  * This is the explicit replacement for the removed `moduleAccessCwd` option:
  * the VM's module resolver reads the mounted tree through the kernel VFS, so the
  * caller supplies exactly the `node_modules` directory whose packages should be
- * resolvable in the guest (e.g. the agent SDK + its transitive deps).
+ * resolvable in the guest (e.g. a guest library and its transitive deps).
  *
  * @param hostNodeModulesDir Absolute host path to a `node_modules` directory.
  * @param opts.readOnly Defaults to `true`; the mount is read-only.

package/dist/host-dir-mount.js

@@ -31,7 +31,7 @@ export function hostDirMount(path, hostPath, opts) {
  * This is the explicit replacement for the removed `moduleAccessCwd` option:
  * the VM's module resolver reads the mounted tree through the kernel VFS, so the
  * caller supplies exactly the `node_modules` directory whose packages should be
- * resolvable in the guest (e.g. the agent SDK + its transitive deps).
+ * resolvable in the guest (e.g. a guest library and its transitive deps).
  *
  * @param hostNodeModulesDir Absolute host path to a `node_modules` directory.
  * @param opts.readOnly Defaults to `true`; the mount is read-only.

package/dist/language-execution.d.ts

@@ -1,4 +1,6 @@
-import type { JsonValue } from "./session-api.js";
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
 export type ExecutionSignal = "SIGHUP" | "SIGINT" | "SIGQUIT" | "SIGTERM" | "SIGKILL" | "SIGSTOP" | "SIGCONT" | "SIGUSR1" | "SIGUSR2";
 export interface LanguageExecutionOptions {
     contextId?: string;
@@ -168,8 +170,10 @@ export interface ProcessOutputEvent<TChunk = Uint8Array> {
 export interface OutputReplay<TChunk = Uint8Array> {
     pid: number;
     events: ProcessOutputEvent<TChunk>[];
-    nextCursor: string;
+    nextCursor: number | null;
     hasMore: boolean;
     truncated: boolean;
+    /** Sidecar-confirmed exit, or null while completion is not known. */
+    exitCode: number | null;
 }
 export {};

package/dist/options-schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod/v4";
-import type { AgentExitHandler, AgentOsOptions, AgentStderrHandler, LimitWarningHandler, NativeMountConfig } from "./agent-os.js";
+import type { AgentOsOptions, LimitWarningHandler, NativeMountConfig } from "./agent-os.js";
 import type { HostFunction, HostFunctionCollection, HostFunctionCollections } from "@rivet-dev/agentos-runtime-core/host-functions";
 export declare const permissionsSchema: z.ZodObject<{
     fs: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
@@ -106,6 +106,9 @@ export declare const permissionsSchema: z.ZodObject<{
     }, z.core.$strict>]>>;
 }, z.core.$strict>;
 export declare const agentOsLimitsSchema: z.ZodObject<{
+    agentosPackages: z.ZodOptional<z.ZodObject<{
+        maxMounts: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
     resources: z.ZodOptional<z.ZodObject<{
         cpuCount: z.ZodOptional<z.ZodNumber>;
         maxProcesses: z.ZodOptional<z.ZodNumber>;
@@ -148,26 +151,6 @@ export declare const agentOsLimitsSchema: z.ZodObject<{
         maxPersistedManifestBytes: z.ZodOptional<z.ZodNumber>;
         maxPersistedManifestFileBytes: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
-    acp: z.ZodOptional<z.ZodObject<{
-        maxReadLineBytes: z.ZodOptional<z.ZodNumber>;
-        stdoutBufferByteLimit: z.ZodOptional<z.ZodNumber>;
-        maxCompletedMessageBytes: z.ZodOptional<z.ZodNumber>;
-        maxTurnOutputBytes: z.ZodOptional<z.ZodNumber>;
-        maxPromptBytes: z.ZodOptional<z.ZodNumber>;
-        maxPromptBlocks: z.ZodOptional<z.ZodNumber>;
-        maxFallbackContinuationBytes: z.ZodOptional<z.ZodNumber>;
-        maxSessionHistoryBytes: z.ZodOptional<z.ZodNumber>;
-        maxSessionHistoryEvents: z.ZodOptional<z.ZodNumber>;
-        maxHistoryPageEntries: z.ZodOptional<z.ZodNumber>;
-        maxSessionListEntries: z.ZodOptional<z.ZodNumber>;
-        maxSessionsPerVm: z.ZodOptional<z.ZodNumber>;
-        maxPromptsPerSession: z.ZodOptional<z.ZodNumber>;
-        maxPromptsPerVm: z.ZodOptional<z.ZodNumber>;
-        maxPendingPermissionsPerSession: z.ZodOptional<z.ZodNumber>;
-        maxPendingPermissionsPerVm: z.ZodOptional<z.ZodNumber>;
-        maxPermissionOutcomesPerSession: z.ZodOptional<z.ZodNumber>;
-        maxPermissionOutcomesPerVm: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>;
     sqlite: z.ZodOptional<z.ZodObject<{
         maxResultBytes: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
@@ -311,18 +294,16 @@ export declare const agentOsOptionFieldSchemas: {
             members: z.ZodArray<z.ZodString>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
+    readonly environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     readonly software: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
     readonly defaultSoftware: z.ZodOptional<z.ZodBoolean>;
     readonly loopbackExemptPorts: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     readonly allowedNodeBuiltins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     readonly highResolutionTime: z.ZodOptional<z.ZodBoolean>;
-    readonly database: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"actor_uds">;
-        path: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
+    readonly database: z.ZodOptional<z.ZodObject<{
         type: z.ZodLiteral<"sqlite_file">;
         path: z.ZodString;
-    }, z.core.$strict>], "type">>;
+    }, z.core.$strict>>;
     readonly rootFilesystem: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodOptional<z.ZodLiteral<"overlay">>;
         mode: z.ZodOptional<z.ZodEnum<{
@@ -482,6 +463,9 @@ export declare const agentOsOptionFieldSchemas: {
         handle: z.ZodUnknown;
     }, z.core.$strict>]>>;
     readonly limits: z.ZodOptional<z.ZodObject<{
+        agentosPackages: z.ZodOptional<z.ZodObject<{
+            maxMounts: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
         resources: z.ZodOptional<z.ZodObject<{
             cpuCount: z.ZodOptional<z.ZodNumber>;
             maxProcesses: z.ZodOptional<z.ZodNumber>;
@@ -524,26 +508,6 @@ export declare const agentOsOptionFieldSchemas: {
             maxPersistedManifestBytes: z.ZodOptional<z.ZodNumber>;
             maxPersistedManifestFileBytes: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
-        acp: z.ZodOptional<z.ZodObject<{
-            maxReadLineBytes: z.ZodOptional<z.ZodNumber>;
-            stdoutBufferByteLimit: z.ZodOptional<z.ZodNumber>;
-            maxCompletedMessageBytes: z.ZodOptional<z.ZodNumber>;
-            maxTurnOutputBytes: z.ZodOptional<z.ZodNumber>;
-            maxPromptBytes: z.ZodOptional<z.ZodNumber>;
-            maxPromptBlocks: z.ZodOptional<z.ZodNumber>;
-            maxFallbackContinuationBytes: z.ZodOptional<z.ZodNumber>;
-            maxSessionHistoryBytes: z.ZodOptional<z.ZodNumber>;
-            maxSessionHistoryEvents: z.ZodOptional<z.ZodNumber>;
-            maxHistoryPageEntries: z.ZodOptional<z.ZodNumber>;
-            maxSessionListEntries: z.ZodOptional<z.ZodNumber>;
-            maxSessionsPerVm: z.ZodOptional<z.ZodNumber>;
-            maxPromptsPerSession: z.ZodOptional<z.ZodNumber>;
-            maxPromptsPerVm: z.ZodOptional<z.ZodNumber>;
-            maxPendingPermissionsPerSession: z.ZodOptional<z.ZodNumber>;
-            maxPendingPermissionsPerVm: z.ZodOptional<z.ZodNumber>;
-            maxPermissionOutcomesPerSession: z.ZodOptional<z.ZodNumber>;
-            maxPermissionOutcomesPerVm: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
         sqlite: z.ZodOptional<z.ZodObject<{
             maxResultBytes: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
@@ -585,8 +549,6 @@ export declare const agentOsOptionFieldSchemas: {
             pendingEventBytes: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
-    readonly onAgentStderr: z.ZodOptional<z.ZodCustom<AgentStderrHandler, AgentStderrHandler>>;
-    readonly onAgentExit: z.ZodOptional<z.ZodCustom<AgentExitHandler, AgentExitHandler>>;
     readonly onLimitWarning: z.ZodOptional<z.ZodCustom<LimitWarningHandler, LimitWarningHandler>>;
 };
 export declare const agentOsOptionsSchema: z.ZodType<AgentOsOptions>;

package/dist/options-schema.js

@@ -90,6 +90,10 @@ export const permissionsSchema = z
     .strict();
 export const agentOsLimitsSchema = z
     .object({
+    agentosPackages: z
+        .object({ maxMounts: positiveInteger.optional() })
+        .strict()
+        .optional(),
     resources: z
         .object({
         cpuCount: positiveInteger.optional(),
@@ -143,29 +147,6 @@ export const agentOsLimitsSchema = z
     })
         .strict()
         .optional(),
-    acp: z
-        .object({
-        maxReadLineBytes: positiveInteger.optional(),
-        stdoutBufferByteLimit: positiveInteger.optional(),
-        maxCompletedMessageBytes: positiveInteger.optional(),
-        maxTurnOutputBytes: positiveInteger.optional(),
-        maxPromptBytes: positiveInteger.optional(),
-        maxPromptBlocks: positiveInteger.optional(),
-        maxFallbackContinuationBytes: positiveInteger.optional(),
-        maxSessionHistoryBytes: positiveInteger.optional(),
-        maxSessionHistoryEvents: positiveInteger.optional(),
-        maxHistoryPageEntries: positiveInteger.optional(),
-        maxSessionListEntries: positiveInteger.optional(),
-        maxSessionsPerVm: positiveInteger.optional(),
-        maxPromptsPerSession: positiveInteger.optional(),
-        maxPromptsPerVm: positiveInteger.optional(),
-        maxPendingPermissionsPerSession: positiveInteger.optional(),
-        maxPendingPermissionsPerVm: positiveInteger.optional(),
-        maxPermissionOutcomesPerSession: positiveInteger.optional(),
-        maxPermissionOutcomesPerVm: positiveInteger.optional(),
-    })
-        .strict()
-        .optional(),
     sqlite: z
         .object({ maxResultBytes: positiveInteger.optional() })
         .strict()
@@ -346,26 +327,18 @@ export const hostFunctionsSchema = z.record(z.string(), hostFunctionCollectionSc
  */
 export const agentOsOptionFieldSchemas = {
     user: vmUserConfigSchema.optional(),
+    environment: z.record(z.string(), z.string()).optional(),
     software: z.array(z.unknown()).optional(),
     defaultSoftware: z.boolean().optional(),
     loopbackExemptPorts: z.array(z.number().int().min(0).max(65535)).optional(),
     allowedNodeBuiltins: stringArray.optional(),
     highResolutionTime: z.boolean().optional(),
     database: z
-        .discriminatedUnion("type", [
-        z
-            .object({
-            type: z.literal("actor_uds"),
-            path: z.string().min(1),
-        })
-            .strict(),
-        z
-            .object({
-            type: z.literal("sqlite_file"),
-            path: z.string().min(1),
-        })
-            .strict(),
-    ])
+        .object({
+        type: z.literal("sqlite_file"),
+        path: z.string().min(1),
+    })
+        .strict()
         .optional(),
     rootFilesystem: rootFilesystemConfigSchema.optional(),
     mounts: z.array(mountConfigSchema).optional(),
@@ -382,16 +355,6 @@ export const agentOsOptionFieldSchemas = {
     permissions: permissionsSchema.optional(),
     sidecar: sidecarConfigSchema.optional(),
     limits: agentOsLimitsSchema.optional(),
-    onAgentStderr: z
-        .custom((value) => typeof value === "function", {
-        message: "Expected function",
-    })
-        .optional(),
-    onAgentExit: z
-        .custom((value) => typeof value === "function", {
-        message: "Expected function",
-    })
-        .optional(),
     onLimitWarning: z
         .custom((value) => typeof value === "function", {
         message: "Expected function",

package/dist/output-replay.d.ts

@@ -0,0 +1,18 @@
+import type { OutputReplay, ProcessOutputEvent } from "./language-execution.js";
+export declare const REPLAY_PAGE_EVENT_LIMIT = 256;
+export declare const REPLAY_PAGE_BYTE_LIMIT: number;
+export interface ReplayReadOptions {
+    after?: number;
+    maxEvents?: number;
+    maxBytes?: number;
+}
+/** Zero is a wire-only omission sentinel, never an accepted public bound. */
+export declare function replayWirePageLimits(options: ReplayReadOptions): {
+    maxEvents: number;
+    maxBytes: number;
+};
+export declare function replayPageLimits(options: ReplayReadOptions): {
+    maxEvents: number;
+    maxBytes: number;
+};
+export declare function replayPage(pid: number, source: readonly ProcessOutputEvent[], options: ReplayReadOptions, truncatedBefore?: number, sourceHasMore?: boolean): OutputReplay;

package/dist/output-replay.js

@@ -0,0 +1,75 @@
+export const REPLAY_PAGE_EVENT_LIMIT = 256;
+export const REPLAY_PAGE_BYTE_LIMIT = 768 * 1024;
+const MAX_WIRE_PAGE_VALUE = 0xffff_ffff;
+/** Zero is a wire-only omission sentinel, never an accepted public bound. */
+export function replayWirePageLimits(options) {
+    replayPageLimits(options);
+    return { maxEvents: options.maxEvents ?? 0, maxBytes: options.maxBytes ?? 0 };
+}
+function limitError(field, requested, limit, message) {
+    return Object.assign(new Error(message ??
+        `process.readOutput ${field} requested ${requested}; supported range is 1..=${limit}`), {
+        code: "ERR_AGENTOS_RESOURCE_LIMIT",
+        operation: "process.output.read",
+        limitName: field === "maxBytes"
+            ? "output_replay_page_bytes"
+            : "output_replay_page_events",
+        configuredLimit: limit,
+        requested,
+        configurationPath: field,
+        unit: field === "maxBytes" ? "bytes" : "events",
+        scope: "vm",
+        retryable: message !== undefined,
+    });
+}
+export function replayPageLimits(options) {
+    if (options.after !== undefined &&
+        (!Number.isSafeInteger(options.after) || options.after < 0)) {
+        throw Object.assign(new Error("invalid_input: output cursor must be a non-negative safe integer"), { code: "invalid_input" });
+    }
+    const maxEvents = options.maxEvents ?? REPLAY_PAGE_EVENT_LIMIT;
+    const maxBytes = options.maxBytes ?? REPLAY_PAGE_BYTE_LIMIT;
+    for (const [field, value] of [
+        ["maxEvents", maxEvents],
+        ["maxBytes", maxBytes],
+    ]) {
+        if (!Number.isSafeInteger(value) ||
+            value < 1 ||
+            value > MAX_WIRE_PAGE_VALUE)
+            throw limitError(field, value, MAX_WIRE_PAGE_VALUE);
+    }
+    return { maxEvents, maxBytes };
+}
+export function replayPage(pid, source, options, truncatedBefore, sourceHasMore = false) {
+    const { maxEvents, maxBytes } = replayPageLimits(options);
+    const events = [];
+    let bytes = 0;
+    let hasMore = sourceHasMore;
+    let nextCursor = options.after ?? null;
+    let gap = truncatedBefore;
+    for (const event of source) {
+        if (options.after !== undefined && event.sequence <= options.after)
+            continue;
+        if (events.length === maxEvents ||
+            bytes + event.chunk.byteLength > maxBytes) {
+            if (events.length === 0)
+                throw limitError("maxBytes", event.chunk.byteLength, maxBytes, `process.output.read next retained event requires ${event.chunk.byteLength} bytes, exceeding maxBytes=${maxBytes}; raise maxBytes to at least ${event.chunk.byteLength}`);
+            hasMore = true;
+            break;
+        }
+        bytes += event.chunk.byteLength;
+        events.push({ ...event, chunk: event.chunk.slice() });
+        nextCursor = event.sequence;
+    }
+    if (!hasMore && gap !== undefined)
+        nextCursor = Math.max(nextCursor ?? -1, gap);
+    return {
+        pid,
+        exitCode: null,
+        events,
+        nextCursor,
+        hasMore,
+        truncated: gap !== undefined &&
+            gap >= (options.after === undefined ? 0 : options.after + 1),
+    };
+}

package/dist/packages.d.ts

@@ -17,12 +17,3 @@ export interface SoftwareRoot {
  * the `/opt/agentos` projection.
  */
 export declare function defineSoftware<T extends SoftwareEntry>(desc: T): T;
-/**
- * Resolve the agent-SDK snapshot bundle (an esbuild IIFE at
- * `<dir>/dist/sdk-snapshot.js`) for the first snapshot-enabled agent package in
- * the software set. Returns its source so it can be evaluated once into the
- * per-sidecar V8 startup snapshot (`jsRuntime.snapshotUserlandCode`) and reused
- * across sessions. Returns `undefined` when no agent opts in (`agent.snapshot`)
- * or the bundle is absent -- the runtime then keeps the per-session import path.
- */
-export declare function resolveAgentSnapshotBundle(software: SoftwareInput[]): string | undefined;

package/dist/packages.js

@@ -1,6 +1,3 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { tryReadAgentosPackageManifest } from "./agentos-package.js";
 // ── defineSoftware ───────────────────────────────────────────────────
 /**
  * Define a software descriptor. A type-safe identity function that validates the
@@ -10,39 +7,3 @@ import { tryReadAgentosPackageManifest } from "./agentos-package.js";
 export function defineSoftware(desc) {
     return desc;
 }
-/**
- * Resolve the agent-SDK snapshot bundle (an esbuild IIFE at
- * `<dir>/dist/sdk-snapshot.js`) for the first snapshot-enabled agent package in
- * the software set. Returns its source so it can be evaluated once into the
- * per-sidecar V8 startup snapshot (`jsRuntime.snapshotUserlandCode`) and reused
- * across sessions. Returns `undefined` when no agent opts in (`agent.snapshot`)
- * or the bundle is absent -- the runtime then keeps the per-session import path.
- */
-export function resolveAgentSnapshotBundle(software) {
-    const descriptors = software.flat();
-    for (const entry of descriptors) {
-        // Only transition package DIRS are readable host-side (their
-        // agentos-package.json is the toolchain-input manifest). Packed
-        // `.aospkg` refs carry the bundle inside the mount tar; the sidecar
-        // reads it from the packed vbare manifest's snapshotBundlePath.
-        const path = entry.packagePath;
-        if (path === undefined || !statIsDirectory(path))
-            continue;
-        const manifest = tryReadAgentosPackageManifest(path);
-        if (!manifest?.agent?.snapshot)
-            continue;
-        const bundlePath = join(path, "dist", "sdk-snapshot.js");
-        if (existsSync(bundlePath)) {
-            return readFileSync(bundlePath, "utf-8");
-        }
-    }
-    return undefined;
-}
-function statIsDirectory(path) {
-    try {
-        return statSync(path).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}

package/dist/process-forest.d.ts

@@ -0,0 +1,7 @@
+/** Internal topology stays separate from public, potentially overlapping display PIDs. */
+export interface ProcessForestRecord<T> {
+    info: T;
+    key: string;
+    parentKey: string | null;
+}
+export declare function buildProcessForest<T, R>(records: ProcessForestRecord<T>[], project: (info: T, children: R[]) => R): R[];