@rivet-dev/agentos-core 0.2.4 → 0.2.5-rc.1

package/dist/agentos-package.d.ts

@@ -0,0 +1,29 @@
+/**
+ * agentOS package model (Linux-exact, Homebrew-modeled) — client-facing surface.
+ *
+ * A package is a self-contained directory produced by `@rivet-dev/agentos-toolchain
+ * pack`. The HOST no longer projects it: the client forwards only the package
+ * directory over the wire and the secure-exec sidecar owns the `/opt/agentos`
+ * 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.
+ *
+ * See `website/src/content/docs/docs/architecture/packages-and-command-resolution.mdx`.
+ */
+import type { AgentosPackageManifest, PackageAgentDescriptor, PackageRef as ManifestPackageRef } from "@agentos-software/manifest";
+/** 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 interface SoftwarePackageRef {
+    packageDir: string;
+}
+/** @deprecated Package software is now represented by its package directory. */
+export type PackageDescriptor = PackageRef;
+/** Discriminate the dir-only package reference. */
+export declare function isPackageDescriptor(value: unknown): value is PackageDescriptor;
+export declare function readAgentosPackageManifest(dir: string): AgentosPackageManifest;
+export declare function tryReadAgentosPackageManifest(dir: string): AgentosPackageManifest | undefined;

package/dist/agentos-package.js

@@ -0,0 +1,82 @@
+/**
+ * agentOS package model (Linux-exact, Homebrew-modeled) — client-facing surface.
+ *
+ * A package is a self-contained directory produced by `@rivet-dev/agentos-toolchain
+ * pack`. The HOST no longer projects it: the client forwards only the package
+ * directory over the wire and the secure-exec sidecar owns the `/opt/agentos`
+ * 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.
+ *
+ * See `website/src/content/docs/docs/architecture/packages-and-command-resolution.mdx`.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+/** Root of the agentOS package tree inside the VM. */
+export const OPT_AGENTOS_ROOT = "/opt/agentos";
+/** The symlink farm on `$PATH` (commands link here). */
+export const OPT_AGENTOS_BIN = "/opt/agentos/bin";
+/** Discriminate the dir-only package reference. */
+export function isPackageDescriptor(value) {
+    return typeof value === "string";
+}
+export function readAgentosPackageManifest(dir) {
+    const manifestPath = join(dir, "agentos-package.json");
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+    }
+    catch (error) {
+        const wrapped = new Error(`Failed to read agentOS package manifest at ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+        wrapped.code = error.code;
+        throw wrapped;
+    }
+    return validateAgentosPackageManifest(parsed, manifestPath);
+}
+export function tryReadAgentosPackageManifest(dir) {
+    try {
+        return readAgentosPackageManifest(dir);
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function validateAgentosPackageManifest(value, source) {
+    if (!isPlainObject(value) || typeof value.name !== "string") {
+        throw new Error(`Invalid agentOS package manifest at ${source}: missing name`);
+    }
+    const manifest = { name: value.name };
+    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;
+    }
+    return manifest;
+}
+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/agents.d.ts

@@ -1,8 +1,18 @@
 export interface AgentConfig {
-    /** npm package name for the ACP adapter (spawned inside the VM) */
-    acpAdapter: string;
-    /** npm package name for the underlying agent */
-    agentPackage: string;
+    /**
+     * npm package name for the ACP adapter (spawned inside the VM). Optional: an
+     * `/opt/agentos` agent package sets `adapterEntrypoint` instead.
+     */
+    acpAdapter?: string;
+    /** npm package name for the underlying agent (optional for `/opt/agentos` packages). */
+    agentPackage?: string;
+    /**
+     * Pre-resolved guest command path/name for the ACP adapter (e.g.
+     * `/opt/agentos/bin/<acpEntrypoint>`). When set, it is used directly as the
+     * adapter entrypoint and the npm-package resolution (`acpAdapter` →
+     * `/root/node_modules/...`) is bypassed. Set by `/opt/agentos` agent packages.
+     */
+    adapterEntrypoint?: string;
     /**
      * Absolute host path to the software package directory that registered this
      * agent config. Package-provided agent adapters should resolve their nested
@@ -19,6 +29,12 @@ export interface AgentConfig {
      */
     defaultEnv?: Record<string, string>;
 }
+/**
+ * @deprecated npm-era legacy. Agents are `/opt/agentos` packages resolved from
+ * `@agentos-software/*` dependency manifests (see `default-software.ts`); this
+ * table is no longer consulted by agent resolution and exists only for the
+ * exported `AgentType` union and legacy registry-listing metadata.
+ */
 export declare const AGENT_CONFIGS: {
     pi: {
         acpAdapter: string;

package/dist/agents.js

@@ -1,4 +1,10 @@
 // Agent configurations for ACP-compatible coding agents
+/**
+ * @deprecated npm-era legacy. Agents are `/opt/agentos` packages resolved from
+ * `@agentos-software/*` dependency manifests (see `default-software.ts`); this
+ * table is no longer consulted by agent resolution and exists only for the
+ * exported `AgentType` union and legacy registry-listing metadata.
+ */
 export const AGENT_CONFIGS = {
     pi: {
         acpAdapter: "@agentos-software/pi",

package/dist/base-filesystem.d.ts

@@ -1,5 +1,4 @@
-import { type FilesystemEntry } from "./filesystem-snapshot.js";
-import { type VirtualFileSystem } from "./runtime-compat.js";
+import type { FilesystemEntry } from "./filesystem-snapshot.js";
 export interface BaseFilesystemEnvironment {
     env: Record<string, string>;
     prompt: string;
@@ -18,17 +17,5 @@ export interface BaseFilesystemSnapshot {
         entries: BaseFilesystemEntry[];
     };
 }
-export declare function createBaseLowerFilesystem(): Promise<VirtualFileSystem>;
-export declare function createBootstrapAwareFilesystem(filesystem: VirtualFileSystem, existingRoot: VirtualFileSystem, options?: {
-    readOnlyAfterBootstrap?: boolean;
-}): {
-    filesystem: VirtualFileSystem;
-    finishKernelBootstrap: () => void;
-};
-export declare function getBaseFilesystemSnapshot(): BaseFilesystemSnapshot;
+/** The default VM environment (a fresh, mutable copy per call). */
 export declare function getBaseEnvironment(): Record<string, string>;
-export declare function getBaseFilesystemEntries(): BaseFilesystemEntry[];
-export declare function createBaseRootFilesystem(): Promise<{
-    filesystem: VirtualFileSystem;
-    finishKernelBootstrap: () => void;
-}>;

package/dist/base-filesystem.js

@@ -1,173 +1,25 @@
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import * as posixPath from "node:path/posix";
-import { createFilesystemFromEntries, } from "./filesystem-snapshot.js";
-import { createOverlayBackend } from "./overlay-filesystem.js";
-import { KernelError } from "./runtime-compat.js";
-const require = createRequire(import.meta.url);
-const SNAPSHOT_PATH = require.resolve("@secure-exec/core/fixtures/base-filesystem.json");
-const SUPPRESSED_KERNEL_BOOTSTRAP_DIRS = new Set([
-    "/boot",
-    "/usr/games",
-    "/usr/include",
-    "/usr/libexec",
-    "/usr/man",
-]);
-const SUPPRESSED_KERNEL_BOOTSTRAP_FILES = new Set(["/usr/bin/env"]);
-let snapshotCache = null;
-function loadSnapshot() {
-    if (snapshotCache) {
-        return snapshotCache;
-    }
-    snapshotCache = JSON.parse(readFileSync(SNAPSHOT_PATH, "utf-8"));
-    return snapshotCache;
-}
-function normalizePath(path) {
-    const normalized = posixPath.normalize(path);
-    return normalized === "." ? "/" : normalized;
-}
-export async function createBaseLowerFilesystem() {
-    return createFilesystemFromEntries(getBaseFilesystemEntries());
-}
-export function createBootstrapAwareFilesystem(filesystem, existingRoot, options) {
-    let bootstrapActive = true;
-    let writesLocked = false;
-    function throwReadOnly() {
-        throw new KernelError("EROFS", "read-only file system");
-    }
-    async function rootHasPath(path) {
-        try {
-            return await existingRoot.exists(path);
-        }
-        catch {
-            return false;
-        }
-    }
-    const wrapped = {
-        ...filesystem,
-        async createDir(path) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            const normalized = normalizePath(path);
-            if (bootstrapActive &&
-                SUPPRESSED_KERNEL_BOOTSTRAP_DIRS.has(normalized) &&
-                !(await rootHasPath(normalized))) {
-                return;
-            }
-            return filesystem.createDir(path);
-        },
-        async mkdir(path, options) {
-            if (writesLocked) {
-                if (options?.recursive && (await rootHasPath(path))) {
-                    return;
-                }
-                throwReadOnly();
-            }
-            const normalized = normalizePath(path);
-            if (bootstrapActive &&
-                options?.recursive &&
-                SUPPRESSED_KERNEL_BOOTSTRAP_DIRS.has(normalized) &&
-                !(await rootHasPath(normalized))) {
-                return;
-            }
-            return filesystem.mkdir(path, options);
-        },
-        async writeFile(path, content) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            const normalized = normalizePath(path);
-            if (bootstrapActive &&
-                SUPPRESSED_KERNEL_BOOTSTRAP_FILES.has(normalized)) {
-                return;
-            }
-            return filesystem.writeFile(path, content);
-        },
-        async removeFile(path) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.removeFile(path);
-        },
-        async removeDir(path) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.removeDir(path);
-        },
-        async rename(oldPath, newPath) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.rename(oldPath, newPath);
-        },
-        async symlink(target, linkPath) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.symlink(target, linkPath);
-        },
-        async link(oldPath, newPath) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.link(oldPath, newPath);
-        },
-        async chmod(path, mode) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.chmod(path, mode);
-        },
-        async chown(path, uid, gid) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.chown(path, uid, gid);
-        },
-        async utimes(path, atime, mtime) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.utimes(path, atime, mtime);
-        },
-        async truncate(path, length) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.truncate(path, length);
-        },
-        async pwrite(path, offset, data) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.pwrite(path, offset, data);
-        },
-    };
-    return {
-        filesystem: wrapped,
-        finishKernelBootstrap() {
-            bootstrapActive = false;
-            writesLocked = options?.readOnlyAfterBootstrap ?? false;
-        },
-    };
-}
-export function getBaseFilesystemSnapshot() {
-    return loadSnapshot();
-}
+/**
+ * The base VM environment, baked in as a constant (verbatim from the single
+ * `base-filesystem.json` the sidecar embeds). The host no longer reads that JSON
+ * — the sidecar owns the base filesystem, and there is exactly one committed copy
+ * of it (`secure-exec/crates/vfs/assets/base-filesystem.json`). Regenerate both
+ * this constant and that file together with the build-tools snapshot script.
+ */
+const BASE_ENVIRONMENT = Object.freeze({
+    CHARSET: "UTF-8",
+    HOME: "/home/agentos",
+    HOSTNAME: "secure-exec",
+    LANG: "C.UTF-8",
+    LC_COLLATE: "C",
+    LOGNAME: "agentos",
+    PAGER: "less",
+    PATH: "/usr/local/sbin:/usr/local/bin:/opt/agentos/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+    MANPATH: "/opt/agentos/share/man:/usr/local/share/man:/usr/share/man",
+    SHELL: "/bin/sh",
+    USER: "agentos",
+    PS1: "\\h:\\w\\$ ",
+});
+/** The default VM environment (a fresh, mutable copy per call). */
 export function getBaseEnvironment() {
-    const snapshot = loadSnapshot();
-    return {
-        ...snapshot.environment.env,
-        PS1: snapshot.environment.prompt,
-    };
-}
-export function getBaseFilesystemEntries() {
-    return loadSnapshot().filesystem.entries;
-}
-export async function createBaseRootFilesystem() {
-    const lower = await createBaseLowerFilesystem();
-    const overlay = createOverlayBackend({ lower });
-    return createBootstrapAwareFilesystem(overlay, lower);
+    return { ...BASE_ENVIRONMENT };
 }

package/dist/default-software.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Default software + on-demand agents — FULLY DYNAMIC, no hardcoded lists.
+ *
+ * This package's own `@agentos-software/*` runtime dependencies (from
+ * `dependencies`, never `devDependencies`) are the entire universe:
+ *
+ * - `resolveDefaultSoftware()` — the set a bare `AgentOs.create()` projects:
+ *   every NON-agent dependency's registry-built descriptor (`{ packageDir }`,
+ *   or an ARRAY for meta-packages like `@agentos-software/common`). Agent
+ *   packages are deliberately NOT projected by default — each carries a full
+ *   node closure (and pi a V8 snapshot bundle), so they enter a VM only when a
+ *   session actually needs them.
+ * - `resolveDependencyAgents()` — the agent packages, keyed by their manifest
+ *   `name` (the `createSession(id)` id). `createSession` links the matching
+ *   package into the running VM on first use (`linkSoftware`), which registers
+ *   its entrypoint/env from the package's own `agentos-package.json`.
+ *
+ * Adding a default command set or an available agent = adding a dependency.
+ * Resolution THROWS with build instructions instead of silently skipping: a
+ * missing artifact means either `pnpm install` was not run or, with the
+ * file-linked deps, the sibling secure-exec registry was not built.
+ */
+/** A registry package descriptor: a package dir, or `{ packageDir }`. */
+type SoftwareDescriptor = string | {
+    packageDir: string;
+};
+/**
+ * The default (non-agent) software set: every `@agentos-software/*`
+ * dependency's descriptor(s) whose packed manifest has no `agent` entry.
+ * Library deps (e.g. `@agentos-software/manifest`) export no descriptor and
+ * are skipped. Opt out with `AgentOs.create({ defaultSoftware: false })`.
+ */
+export declare function resolveDefaultSoftware(): Promise<SoftwareDescriptor[]>;
+export interface DependencyAgent {
+    /** The dependency package name (e.g. `@agentos-software/pi`). */
+    dependency: string;
+    /** The packed runtime dir to `linkSoftware`. */
+    packageDir: string;
+    /** The agent's ACP entrypoint command name. */
+    acpEntrypoint: string;
+}
+/**
+ * Agent packages among the dependencies, keyed by manifest `name` (the
+ * `createSession(id)` id). Sync (no module import — the packed manifest is
+ * read straight from `<dep>/dist/package/`). Unbuilt agent deps THROW.
+ */
+export declare function resolveDependencyAgents(): Map<string, DependencyAgent>;
+export {};

package/dist/default-software.js

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const requireFromHere = createRequire(import.meta.url);
+const BUILD_INSTRUCTIONS = "With file-linked deps, build the registry in the sibling secure-exec " +
+    "checkout: `just registry-build` (see its registry/README.md).";
+function dependencyNames() {
+    const manifest = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8"));
+    return Object.keys(manifest.dependencies ?? {})
+        .filter((name) => name.startsWith("@agentos-software/"))
+        .sort();
+}
+function descriptorDir(ref) {
+    return typeof ref === "string" ? ref : ref.packageDir;
+}
+function readPackedManifest(dir) {
+    const path = join(dir, "agentos-package.json");
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function assertBuilt(name, dir) {
+    if (!existsSync(join(dir, "package.json"))) {
+        throw new Error(`software package ${name} is not BUILT (missing ${dir}). ${BUILD_INSTRUCTIONS}`);
+    }
+}
+/**
+ * The default (non-agent) software set: every `@agentos-software/*`
+ * dependency's descriptor(s) whose packed manifest has no `agent` entry.
+ * Library deps (e.g. `@agentos-software/manifest`) export no descriptor and
+ * are skipped. Opt out with `AgentOs.create({ defaultSoftware: false })`.
+ */
+export async function resolveDefaultSoftware() {
+    const software = [];
+    for (const name of dependencyNames()) {
+        let mod;
+        try {
+            mod = (await import(name));
+        }
+        catch (error) {
+            throw new Error(`software package ${name} could not be imported — run \`pnpm install\` ` +
+                `(it is a dependency of this package): ${String(error)}`);
+        }
+        if (mod.default === undefined)
+            continue; // library dep, not software
+        for (const descriptor of [mod.default].flat()) {
+            const dir = descriptorDir(descriptor);
+            assertBuilt(name, dir);
+            if (readPackedManifest(dir)?.agent)
+                continue; // agents load lazily
+            software.push(descriptor);
+        }
+    }
+    return software;
+}
+/**
+ * Agent packages among the dependencies, keyed by manifest `name` (the
+ * `createSession(id)` id). Sync (no module import — the packed manifest is
+ * read straight from `<dep>/dist/package/`). Unbuilt agent deps THROW.
+ */
+export function resolveDependencyAgents() {
+    const agents = new Map();
+    for (const name of dependencyNames()) {
+        let entry;
+        try {
+            entry = requireFromHere.resolve(name); // -> <pkg>/dist/index.js
+        }
+        catch {
+            continue; // not installed — surfaced by resolveDefaultSoftware/import paths
+        }
+        const dir = join(dirname(entry), "package");
+        const manifest = readPackedManifest(dir);
+        if (!manifest?.agent)
+            continue;
+        if (!manifest.name || !manifest.agent.acpEntrypoint) {
+            throw new Error(`agent package ${name} has an invalid packed manifest (${dir}/agentos-package.json) — rebuild it (\`just registry-build\`)`);
+        }
+        assertBuilt(name, dir);
+        agents.set(manifest.name, {
+            dependency: name,
+            packageDir: dir,
+            acpEntrypoint: manifest.agent.acpEntrypoint,
+        });
+    }
+    return agents;
+}

package/dist/index.d.ts

@@ -6,6 +6,8 @@ export { hostTool, MAX_TOOL_DESCRIPTION_LENGTH, toolKit, validateToolkits, } fro
 export { agentOsLimitsSchema, agentOsOptionFieldSchemas, agentOsOptionsSchema, hostToolSchema, mountConfigSchema, nativeMountConfigSchema, parseAgentOsOptions, permissionsSchema, rootFilesystemConfigSchema, sharedSidecarConfigSchema, sidecarConfigSchema, toolKitSchema, } from "./options-schema.js";
 export { createInMemoryLayerStore, createSnapshotExport, } from "./layers.js";
 export { defineSoftware } from "./packages.js";
+export { isPackageDescriptor, OPT_AGENTOS_BIN, OPT_AGENTOS_ROOT, tryReadAgentosPackageManifest, } from "./agentos-package.js";
 export { isAcpTimeoutErrorData, isUnknownSessionErrorData, } from "./json-rpc.js";
 export { createInMemoryFileSystem, KernelError } from "./runtime-compat.js";
+export type { ExecOptions, ExecResult, ManagedProcess, ProcessInfo, ShellHandle, VirtualDirEntry, VirtualStat, } from "./runtime.js";
 export type * from "./types.js";

package/dist/index.js

@@ -7,5 +7,6 @@ export { hostTool, MAX_TOOL_DESCRIPTION_LENGTH, toolKit, validateToolkits, } fro
 export { agentOsLimitsSchema, agentOsOptionFieldSchemas, agentOsOptionsSchema, hostToolSchema, mountConfigSchema, nativeMountConfigSchema, parseAgentOsOptions, permissionsSchema, rootFilesystemConfigSchema, sharedSidecarConfigSchema, sidecarConfigSchema, toolKitSchema, } from "./options-schema.js";
 export { createInMemoryLayerStore, createSnapshotExport, } from "./layers.js";
 export { defineSoftware } from "./packages.js";
+export { isPackageDescriptor, OPT_AGENTOS_BIN, OPT_AGENTOS_ROOT, tryReadAgentosPackageManifest, } from "./agentos-package.js";
 export { isAcpTimeoutErrorData, isUnknownSessionErrorData, } from "./json-rpc.js";
 export { createInMemoryFileSystem, KernelError } from "./runtime-compat.js";

package/dist/layers.d.ts

@@ -1,4 +1,4 @@
-import { type BaseFilesystemSnapshot } from "./base-filesystem.js";
+import type { BaseFilesystemSnapshot } from "./base-filesystem.js";
 import { type FilesystemEntry } from "./filesystem-snapshot.js";
 import type { VirtualFileSystem } from "./runtime-compat.js";
 export type OverlayFilesystemMode = "ephemeral" | "read-only";
@@ -49,4 +49,3 @@ export interface LayerStore {
 }
 export declare function createSnapshotExport(entries: FilesystemEntry[]): RootSnapshotExport;
 export declare function createInMemoryLayerStore(): LayerStore;
-export declare function createDefaultRootLowerInput(): SnapshotImportSource;

package/dist/layers.js

@@ -1,5 +1,4 @@
 import { randomUUID } from "node:crypto";
-import { getBaseFilesystemSnapshot, } from "./base-filesystem.js";
 import { createFilesystemFromEntries, snapshotVirtualFilesystem, } from "./filesystem-snapshot.js";
 import { createOverlayBackend } from "./overlay-filesystem.js";
 function cloneSnapshotHandle(storeId, layerId) {
@@ -193,9 +192,3 @@ export function createInMemoryLayerStore() {
     };
     return store;
 }
-export function createDefaultRootLowerInput() {
-    return {
-        kind: "base-filesystem-artifact",
-        source: getBaseFilesystemSnapshot(),
-    };
-}

package/dist/options-schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod/v4";
-import type { AgentOsOptions, AgentStderrHandler, LimitWarningHandler, NativeMountConfig } from "./agent-os.js";
+import type { AgentExitHandler, AgentOsOptions, AgentStderrHandler, LimitWarningHandler, NativeMountConfig } from "./agent-os.js";
 import type { HostTool, ToolKit } from "./host-tools.js";
 export declare const permissionsSchema: z.ZodObject<{
     fs: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
@@ -224,6 +224,7 @@ export declare const agentOsOptionFieldSchemas: {
     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 rootFilesystem: z.ZodOptional<z.ZodObject<{
         type: z.ZodOptional<z.ZodLiteral<"overlay">>;
         mode: z.ZodOptional<z.ZodEnum<{
@@ -432,6 +433,7 @@ export declare const agentOsOptionFieldSchemas: {
         }, 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

@@ -236,6 +236,7 @@ export const agentOsOptionFieldSchemas = {
     defaultSoftware: z.boolean().optional(),
     loopbackExemptPorts: z.array(z.number().int().min(0).max(65535)).optional(),
     allowedNodeBuiltins: stringArray.optional(),
+    highResolutionTime: z.boolean().optional(),
     rootFilesystem: rootFilesystemConfigSchema.optional(),
     mounts: z.array(mountConfigSchema).optional(),
     moduleAccessCwd: z.string().optional(),
@@ -250,6 +251,7 @@ export const agentOsOptionFieldSchemas = {
     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" }).optional(),
 };
 export const agentOsOptionsSchema = z