exoagent 0.0.13 → 0.0.14

package/dist/exoeval/allowed.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Whitelists for exoeval — shared between the evaluator and the eslint rule.
+ * Single source of truth: if exoeval adds a node type, the lint rule allows
+ * it automatically.
+ */
+export declare const allowedExpressions: readonly ["ArrayExpression", "ArrowFunctionExpression", "AwaitExpression", "BinaryExpression", "CallExpression", "ConditionalExpression", "Identifier", "Literal", "LogicalExpression", "MemberExpression", "NewExpression", "ObjectExpression", "TemplateLiteral", "UnaryExpression", "ChainExpression"];
+export declare const allowedStatements: readonly ["BlockStatement", "EmptyStatement", "VariableDeclaration", "ExpressionStatement", "ReturnStatement", "IfStatement"];
+/** Allowed at module top-level (exoImport). */
+export declare const allowedModuleDeclarations: readonly ["ExportDefaultDeclaration"];

package/dist/exoeval/builtins.d.ts

@@ -1,6 +1,8 @@
 import { ExpressionContext } from './expr';
-export declare class ExoArray<T = unknown> {
+import { IExoArray, IExoBoolean, IExoDate, IExoNumber, IExoString } from './lib';
+export declare class ExoArray<T = unknown> implements IExoArray<T> {
     constructor(...args: Parameters<typeof Array>);
+    [index: number]: T;
     get length(): number;
     get map(): <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[];
     get filter(): {
@@ -33,6 +35,7 @@ export declare class ExoArray<T = unknown> {
         (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): boolean;
     };
     get flatMap(): <U, This = undefined>(callback: (this: This, value: any, index: number, array: any[]) => U | readonly U[], thisArg?: This | undefined) => U[];
+    get forEach(): (callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any) => void;
     get toSorted(): (compareFn?: ((a: any, b: any) => number) | undefined) => any[];
     get at(): (index: number) => any;
     get slice(): (start?: number, end?: number) => any[];
@@ -54,10 +57,11 @@ export declare class ExoArray<T = unknown> {
         (start: number, deleteCount?: number): any[];
     };
     get with(): (index: number, value: any) => any[];
+    get toString(): () => string;
     static from(arrayLike: ArrayLike<unknown>): unknown[];
     static isArray(value: unknown): value is any[];
 }
-export declare class ExoString {
+export declare class ExoString implements IExoString {
     constructor(...args: Parameters<typeof String>);
     get length(): number;
     get at(): (index: number) => string | undefined;
@@ -100,8 +104,9 @@ export declare class ExoString {
     get trim(): () => string;
     get trimEnd(): () => string;
     get trimStart(): () => string;
+    get toString(): () => string;
 }
-export declare class ExoDate {
+export declare class ExoDate implements IExoDate {
     constructor();
     constructor(value: string | number | Date);
     constructor(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number);
@@ -130,6 +135,7 @@ export declare class ExoDate {
         (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
     };
     get valueOf(): () => number;
+    get toString(): () => string;
     static now(): number;
     static parse(dateString: string): number;
 }
@@ -141,9 +147,10 @@ export declare class ExoObject {
         [k: string]: unknown;
     };
 }
-export declare class ExoBoolean {
+export declare class ExoBoolean implements IExoBoolean {
     constructor(...args: Parameters<typeof Boolean>);
     get valueOf(): () => boolean;
+    get toString(): () => string;
 }
 export declare class ExoJSON {
     static parse(text: string): any;
@@ -163,8 +170,16 @@ export declare class ExoMath {
     static sign(x: number): number;
     static trunc(x: number): number;
 }
-export declare class ExoNumber {
+export declare class ExoPromise {
+    static all(values: unknown[]): Promise<unknown[]>;
+    static allSettled(values: unknown[]): Promise<PromiseSettledResult<unknown>[]>;
+    static race(values: unknown[]): Promise<unknown>;
+    static resolve(value: unknown): Promise<unknown>;
+    static reject(reason: unknown): Promise<never>;
+}
+export declare class ExoNumber implements IExoNumber {
     constructor(...args: Parameters<typeof Number>);
+    get toString(): (radix?: number) => string;
     static parseInt(s: string, radix?: number): number;
     static parseFloat(s: string): number;
     static isNaN(value: unknown): boolean;

package/dist/exoeval/evaluator.d.ts

@@ -38,10 +38,17 @@ export declare class Evaluator<Expr> {
     assertAllowedProperty(key: string | number, node: acorn.Node): void;
     defineProperty(obj: object, key: string | number, value: unknown, node: acorn.Node): void;
     getExoProperty(obj: Expr, key: string | number, node: acorn.Node, optional: boolean): EvalResult<Expr>;
+    /**
+     * Convert a value to string for interpolation/concatenation.
+     * Calls .toString() via getExoProperty if available.
+     */
+    toString(obj: Expr, node: acorn.Node): EvalResult<Expr, string>;
     getBuiltinPrototype(value: unknown): unknown;
     ObjectExpression(node: acorn.ObjectExpression): EvalResult<Expr>;
     AwaitExpression(node: acorn.AwaitExpression): EvalResult<Expr>;
-    evalStatements(statements: (acorn.Statement | acorn.ModuleDeclaration)[]): EvalResult<Expr>;
+    evalStatements(statements: (acorn.Statement | acorn.ModuleDeclaration)[], { module }?: {
+        module?: boolean | undefined;
+    }): EvalResult<Expr>;
     evalFunctionCall(node: acorn.Function, args: Expr[]): EvalResult<Expr>;
     ArrowFunctionExpression(node: acorn.ArrowFunctionExpression): EvalResult<Expr>;
     UnaryExpression(node: acorn.UnaryExpression): EvalResult<Expr>;
@@ -54,6 +61,8 @@ export declare class Evaluator<Expr> {
     $(node: acorn.Expression): EvalResult<Expr, unknown>;
     makeReturn(value: Expr, node: acorn.Node): EvalResult<Expr>;
     Statement(node: acorn.Statement): EvalResult<Expr>;
-    Program(node: acorn.Program): Expr | Promise<Expr>;
+    Program(node: acorn.Program, { module }?: {
+        module?: boolean | undefined;
+    }): Expr | Promise<Expr>;
 }
 export {};

package/dist/exoeval/index.d.ts

@@ -3,4 +3,14 @@ export { asToolFn } from './tool';
 export type { ToolFunction } from './tool';
 export declare function exoEval(code: string): unknown;
 export declare function exoEval<T>(code: string, ctx: ExpressionContext<T>): T;
+export declare function exoImport(code: string): {
+    [key: string]: unknown;
+} | Promise<{
+    [key: string]: unknown;
+}>;
+export declare function exoImport<T>(code: string, ctx: ExpressionContext<T>): {
+    [key: string]: unknown;
+} | Promise<{
+    [key: string]: unknown;
+}>;
 export declare function exoFn<T extends (...args: any[]) => unknown>(fn: T): T;

package/dist/exoeval/lib/index.d.ts

@@ -0,0 +1 @@
+export type { IExoArray, IExoBoolean, IExoDate, IExoJSON, IExoMath, IExoNumber, IExoObject, IExoPromise, IExoString } from './types';

package/dist/exoeval/tool.d.ts

@@ -23,6 +23,11 @@ export declare const registerToolField: (obj: unknown, key: string) => void;
  * Fields:  adds field name to toolFieldsSymbol Set on instance.
  *          If value is a function with schemas, wraps with asTool.
  * Classes: returns replacement class with constructor validation + toolSymbol.
+ *
+ * NOTE: @tool() on a class means `new MyClass(...)` is callable by sandboxed code
+ * that has a reference to it. This is intended for builtins (e.g. `new Date`, `new Map`)
+ * where construction is part of the API. For capability classes where you want to expose
+ * only methods (not construction), don't decorate the class — just decorate the methods.
  */
 export declare function tool<Schemas extends StandardSchemaV1[]>(...argSchemas: Schemas): {
     <This, Value extends (this: This, ...args: SchemasToParams<Schemas>) => any>(target: Value, context: ClassMethodDecoratorContext<This, Value>): Value;

package/dist/index.mjs

@@ -45,10 +45,10 @@ var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _isArray_dec, _from_dec, _with_dec, _toSpliced_dec, _toReversed_dec, _values_dec, _keys_dec, _entries_dec, _flat_dec, _includes_dec, _lastIndexOf_dec, _indexOf_dec, _concat_dec, _join_dec, _slice_dec, _at_dec, _toSorted_dec, _flatMap_dec, _every_dec, _some_dec, _findLastIndex_dec, _findLast_dec, _findIndex_dec, _find_dec, _reduceRight_dec, _reduce_dec, _filter_dec, _map_dec, _length_dec, _ExoArray_decorators, _init, _trimStart_dec, _trimEnd_dec, _trim_dec, _toUpperCase_dec, _toLowerCase_dec, _substring_dec, _startsWith_dec, _split_dec, _slice_dec2, _replaceAll_dec, _replace_dec, _repeat_dec, _padStart_dec, _padEnd_dec, _lastIndexOf_dec2, _indexOf_dec2, _includes_dec2, _endsWith_dec, _concat_dec2, _codePointAt_dec, _charCodeAt_dec, _charAt_dec, _at_dec2, _length_dec2, _ExoString_decorators, _init2, _parse_dec, _now_dec, _valueOf_dec, _toLocaleString_dec, _toLocaleTimeString_dec, _toLocaleDateString_dec, _toISOString_dec, _getMilliseconds_dec, _getSeconds_dec, _getMinutes_dec, _getHours_dec, _getDate_dec, _getMonth_dec, _getFullYear_dec, _getTime_dec, _ExoDate_decorators, _init3, _fromEntries_dec, _entries_dec2, _values_dec2, _keys_dec2, _init4, _valueOf_dec2, _ExoBoolean_decorators, _init5, _stringify_dec, _parse_dec2, _init6, _trunc_dec, _sign_dec, _random_dec, _log_dec, _pow_dec, _sqrt_dec, _abs_dec, _ceil_dec, _floor_dec, _round_dec, _max_dec, _min_dec, _init7, _isInteger_dec, _isFinite_dec, _isNaN_dec, _parseFloat_dec, _parseInt_dec, _ExoNumber_decorators, _init8;
+var _isArray_dec, _from_dec, _toString_dec, _with_dec, _toSpliced_dec, _toReversed_dec, _values_dec, _keys_dec, _entries_dec, _flat_dec, _includes_dec, _lastIndexOf_dec, _indexOf_dec, _concat_dec, _join_dec, _slice_dec, _at_dec, _toSorted_dec, _forEach_dec, _flatMap_dec, _every_dec, _some_dec, _findLastIndex_dec, _findLast_dec, _findIndex_dec, _find_dec, _reduceRight_dec, _reduce_dec, _filter_dec, _map_dec, _length_dec, _ExoArray_decorators, _init, _toString_dec2, _trimStart_dec, _trimEnd_dec, _trim_dec, _toUpperCase_dec, _toLowerCase_dec, _substring_dec, _startsWith_dec, _split_dec, _slice_dec2, _replaceAll_dec, _replace_dec, _repeat_dec, _padStart_dec, _padEnd_dec, _lastIndexOf_dec2, _indexOf_dec2, _includes_dec2, _endsWith_dec, _concat_dec2, _codePointAt_dec, _charCodeAt_dec, _charAt_dec, _at_dec2, _length_dec2, _ExoString_decorators, _init2, _parse_dec, _now_dec, _toString_dec3, _valueOf_dec, _toLocaleString_dec, _toLocaleTimeString_dec, _toLocaleDateString_dec, _toISOString_dec, _getMilliseconds_dec, _getSeconds_dec, _getMinutes_dec, _getHours_dec, _getDate_dec, _getMonth_dec, _getFullYear_dec, _getTime_dec, _ExoDate_decorators, _init3, _fromEntries_dec, _entries_dec2, _values_dec2, _keys_dec2, _init4, _toString_dec4, _valueOf_dec2, _ExoBoolean_decorators, _init5, _stringify_dec, _parse_dec2, _init6, _trunc_dec, _sign_dec, _random_dec, _log_dec, _pow_dec, _sqrt_dec, _abs_dec, _ceil_dec, _floor_dec, _round_dec, _max_dec, _min_dec, _init7, _reject_dec, _resolve_dec, _race_dec, _allSettled_dec, _all_dec, _init8, _isInteger_dec, _isFinite_dec, _isNaN_dec, _parseFloat_dec, _parseInt_dec, _toString_dec5, _ExoNumber_decorators, _init9;
 import z, { z as z$1 } from "zod";
 import sjson from "secure-json-parse";
-import { t as toolFieldsSymbol, a as tool, e as expr, f as fn, i as isExprFunction, b as isToolableFunction, g as getTool, c as isToolableConstructor, d as asToolFn } from "./tool-DGs9ZxVn.js";
+import { t as toolFieldsSymbol, a as tool, e as expr, f as fn, i as isExprFunction, b as isToolableFunction, g as getTool, c as isToolableConstructor, d as asToolFn } from "./tool-5wSlXWJ2.js";
 import * as z4 from "zod/v4";
 import { ZodFirstPartyTypeKind } from "zod/v3";
 import camelCase from "camelcase";
@@ -5791,7 +5791,7 @@ class Invariant {
     }
   }
 }
-_ExoArray_decorators = [tool()], _length_dec = [tool()], _map_dec = [tool(fn.returns(z.any()))], _filter_dec = [tool(fn.returns(z.any()))], _reduce_dec = [tool(fn.returns(z.any()), z.any().optional())], _reduceRight_dec = [tool(fn.returns(z.any()), z.any().optional())], _find_dec = [tool(fn.returns(z.any()))], _findIndex_dec = [tool(fn.returns(z.any()))], _findLast_dec = [tool(fn.returns(z.any()))], _findLastIndex_dec = [tool(fn.returns(z.any()))], _some_dec = [tool(fn.returns(z.any()))], _every_dec = [tool(fn.returns(z.any()))], _flatMap_dec = [tool(fn.returns(z.any()))], _toSorted_dec = [tool(fn.returns(z.any()).optional())], _at_dec = [tool(z.number())], _slice_dec = [tool(z.number().optional(), z.number().optional())], _join_dec = [tool(z.string().optional())], _concat_dec = [tool(z.array(z.any()))], _indexOf_dec = [tool(z.any(), z.number().optional())], _lastIndexOf_dec = [tool(z.any(), z.number().optional())], _includes_dec = [tool(z.any())], _flat_dec = [tool(z.number().optional())], _entries_dec = [tool()], _keys_dec = [tool()], _values_dec = [tool()], _toReversed_dec = [tool()], _toSpliced_dec = [tool(z.number(), z.number().optional(), z.any().optional())], _with_dec = [tool(z.number(), z.any())], _from_dec = [tool(z.array(z.any()))], _isArray_dec = [tool(z.any())];
+_ExoArray_decorators = [tool()], _length_dec = [tool()], _map_dec = [tool(fn.returns(z.any()))], _filter_dec = [tool(fn.returns(z.any()))], _reduce_dec = [tool(fn.returns(z.any()), z.any().optional())], _reduceRight_dec = [tool(fn.returns(z.any()), z.any().optional())], _find_dec = [tool(fn.returns(z.any()))], _findIndex_dec = [tool(fn.returns(z.any()))], _findLast_dec = [tool(fn.returns(z.any()))], _findLastIndex_dec = [tool(fn.returns(z.any()))], _some_dec = [tool(fn.returns(z.any()))], _every_dec = [tool(fn.returns(z.any()))], _flatMap_dec = [tool(fn.returns(z.any()))], _forEach_dec = [tool(fn.returns(z.void()))], _toSorted_dec = [tool(fn.returns(z.any()).optional())], _at_dec = [tool(z.number())], _slice_dec = [tool(z.number().optional(), z.number().optional())], _join_dec = [tool(z.string().optional())], _concat_dec = [tool(z.array(z.any()))], _indexOf_dec = [tool(z.any(), z.number().optional())], _lastIndexOf_dec = [tool(z.any(), z.number().optional())], _includes_dec = [tool(z.any())], _flat_dec = [tool(z.number().optional())], _entries_dec = [tool()], _keys_dec = [tool()], _values_dec = [tool()], _toReversed_dec = [tool()], _toSpliced_dec = [tool(z.number(), z.number().optional(), z.any().optional())], _with_dec = [tool(z.number(), z.any())], _toString_dec = [tool()], _from_dec = [tool(z.array(z.any()))], _isArray_dec = [tool(z.any())];
 class ExoArray {
   constructor(...args) {
     __runInitializers(_init, 5, this);
@@ -5836,6 +5836,9 @@ class ExoArray {
   get flatMap() {
     return Array.prototype.flatMap;
   }
+  get forEach() {
+    return Array.prototype.forEach;
+  }
   get toSorted() {
     return Array.prototype.toSorted;
   }
@@ -5881,6 +5884,9 @@ class ExoArray {
   get with() {
     return Array.prototype.with;
   }
+  get toString() {
+    return Array.prototype.toString;
+  }
   static from(arrayLike) {
     return Array.from(arrayLike);
   }
@@ -5903,6 +5909,7 @@ __decorateElement(_init, 2, "findLastIndex", _findLastIndex_dec, ExoArray);
 __decorateElement(_init, 2, "some", _some_dec, ExoArray);
 __decorateElement(_init, 2, "every", _every_dec, ExoArray);
 __decorateElement(_init, 2, "flatMap", _flatMap_dec, ExoArray);
+__decorateElement(_init, 2, "forEach", _forEach_dec, ExoArray);
 __decorateElement(_init, 2, "toSorted", _toSorted_dec, ExoArray);
 __decorateElement(_init, 2, "at", _at_dec, ExoArray);
 __decorateElement(_init, 2, "slice", _slice_dec, ExoArray);
@@ -5918,10 +5925,11 @@ __decorateElement(_init, 2, "values", _values_dec, ExoArray);
 __decorateElement(_init, 2, "toReversed", _toReversed_dec, ExoArray);
 __decorateElement(_init, 2, "toSpliced", _toSpliced_dec, ExoArray);
 __decorateElement(_init, 2, "with", _with_dec, ExoArray);
+__decorateElement(_init, 2, "toString", _toString_dec, ExoArray);
 ExoArray = __decorateElement(_init, 0, "ExoArray", _ExoArray_decorators, ExoArray);
 __runInitializers(_init, 3, ExoArray);
 __runInitializers(_init, 1, ExoArray);
-_ExoString_decorators = [tool(z.union([z.string(), z.number(), z.instanceof(Date), z.boolean(), z.null(), z.undefined(), z.bigint()]))], _length_dec2 = [tool()], _at_dec2 = [tool(z.number())], _charAt_dec = [tool(z.number())], _charCodeAt_dec = [tool(z.number())], _codePointAt_dec = [tool(z.number())], _concat_dec2 = [tool(z.string())], _endsWith_dec = [tool(z.string(), z.number().optional())], _includes_dec2 = [tool(z.string(), z.number().optional())], _indexOf_dec2 = [tool(z.string(), z.number().optional())], _lastIndexOf_dec2 = [tool(z.string(), z.number().optional())], _padEnd_dec = [tool(z.number(), z.string().optional())], _padStart_dec = [tool(z.number(), z.string().optional())], _repeat_dec = [tool(z.number())], _replace_dec = [tool(z.string(), z.string())], _replaceAll_dec = [tool(z.string(), z.string())], _slice_dec2 = [tool(z.number().optional(), z.number().optional())], _split_dec = [tool(z.string(), z.number().optional())], _startsWith_dec = [tool(z.string(), z.number().optional())], _substring_dec = [tool(z.number().optional(), z.number().optional())], _toLowerCase_dec = [tool()], _toUpperCase_dec = [tool()], _trim_dec = [tool()], _trimEnd_dec = [tool()], _trimStart_dec = [tool()];
+_ExoString_decorators = [tool(z.union([z.string(), z.number(), z.instanceof(Date), z.boolean(), z.null(), z.undefined(), z.bigint()]))], _length_dec2 = [tool()], _at_dec2 = [tool(z.number())], _charAt_dec = [tool(z.number())], _charCodeAt_dec = [tool(z.number())], _codePointAt_dec = [tool(z.number())], _concat_dec2 = [tool(z.string())], _endsWith_dec = [tool(z.string(), z.number().optional())], _includes_dec2 = [tool(z.string(), z.number().optional())], _indexOf_dec2 = [tool(z.string(), z.number().optional())], _lastIndexOf_dec2 = [tool(z.string(), z.number().optional())], _padEnd_dec = [tool(z.number(), z.string().optional())], _padStart_dec = [tool(z.number(), z.string().optional())], _repeat_dec = [tool(z.number())], _replace_dec = [tool(z.string(), z.string())], _replaceAll_dec = [tool(z.string(), z.string())], _slice_dec2 = [tool(z.number().optional(), z.number().optional())], _split_dec = [tool(z.string(), z.number().optional())], _startsWith_dec = [tool(z.string(), z.number().optional())], _substring_dec = [tool(z.number().optional(), z.number().optional())], _toLowerCase_dec = [tool()], _toUpperCase_dec = [tool()], _trim_dec = [tool()], _trimEnd_dec = [tool()], _trimStart_dec = [tool()], _toString_dec2 = [tool()];
 class ExoString {
   constructor(...args) {
     __runInitializers(_init2, 5, this);
@@ -6002,6 +6010,9 @@ class ExoString {
   get trimStart() {
     return String.prototype.trimStart;
   }
+  get toString() {
+    return String.prototype.toString;
+  }
 }
 _init2 = __decoratorStart(null);
 __decorateElement(_init2, 2, "length", _length_dec2, ExoString);
@@ -6028,9 +6039,10 @@ __decorateElement(_init2, 2, "toUpperCase", _toUpperCase_dec, ExoString);
 __decorateElement(_init2, 2, "trim", _trim_dec, ExoString);
 __decorateElement(_init2, 2, "trimEnd", _trimEnd_dec, ExoString);
 __decorateElement(_init2, 2, "trimStart", _trimStart_dec, ExoString);
+__decorateElement(_init2, 2, "toString", _toString_dec2, ExoString);
 ExoString = __decorateElement(_init2, 0, "ExoString", _ExoString_decorators, ExoString);
 __runInitializers(_init2, 1, ExoString);
-_ExoDate_decorators = [tool(z.union([z.string(), z.number(), z.instanceof(Date)]).optional())], _getTime_dec = [tool()], _getFullYear_dec = [tool()], _getMonth_dec = [tool()], _getDate_dec = [tool()], _getHours_dec = [tool()], _getMinutes_dec = [tool()], _getSeconds_dec = [tool()], _getMilliseconds_dec = [tool()], _toISOString_dec = [tool()], _toLocaleDateString_dec = [tool(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())], _toLocaleTimeString_dec = [tool(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())], _toLocaleString_dec = [tool(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())], _valueOf_dec = [tool()], _now_dec = [tool()], _parse_dec = [tool(z.string())];
+_ExoDate_decorators = [tool(z.union([z.string(), z.number(), z.instanceof(Date)]).optional())], _getTime_dec = [tool()], _getFullYear_dec = [tool()], _getMonth_dec = [tool()], _getDate_dec = [tool()], _getHours_dec = [tool()], _getMinutes_dec = [tool()], _getSeconds_dec = [tool()], _getMilliseconds_dec = [tool()], _toISOString_dec = [tool()], _toLocaleDateString_dec = [tool(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())], _toLocaleTimeString_dec = [tool(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())], _toLocaleString_dec = [tool(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())], _valueOf_dec = [tool()], _toString_dec3 = [tool()], _now_dec = [tool()], _parse_dec = [tool(z.string())];
 class ExoDate {
   constructor(...args) {
     __runInitializers(_init3, 5, this);
@@ -6075,6 +6087,9 @@ class ExoDate {
   get valueOf() {
     return Date.prototype.valueOf;
   }
+  get toString() {
+    return Date.prototype.toString;
+  }
   static now() {
     return Date.now();
   }
@@ -6098,6 +6113,7 @@ __decorateElement(_init3, 2, "toLocaleDateString", _toLocaleDateString_dec, ExoD
 __decorateElement(_init3, 2, "toLocaleTimeString", _toLocaleTimeString_dec, ExoDate);
 __decorateElement(_init3, 2, "toLocaleString", _toLocaleString_dec, ExoDate);
 __decorateElement(_init3, 2, "valueOf", _valueOf_dec, ExoDate);
+__decorateElement(_init3, 2, "toString", _toString_dec3, ExoDate);
 ExoDate = __decorateElement(_init3, 0, "ExoDate", _ExoDate_decorators, ExoDate);
 __runInitializers(_init3, 3, ExoDate);
 __runInitializers(_init3, 1, ExoDate);
@@ -6107,20 +6123,23 @@ _keys_dec2 = [expr()], _values_dec2 = [expr()], _entries_dec2 = [expr()], _fromE
 class ExoObject {
   static keys(ctx, obj) {
     const seq = ctx.sequence(obj);
-    if (!isPlainObject(seq))
+    if (!isPlainObject(seq)) {
       throw new TypeError("Object.keys requires an object");
+    }
     return ctx.distribute(Object.keys(seq).map((k) => ctx.of(k)));
   }
   static values(ctx, obj) {
     const seq = ctx.sequence(obj);
-    if (!isPlainObject(seq))
+    if (!isPlainObject(seq)) {
       throw new TypeError("Object.values requires an object");
+    }
     return ctx.distribute(Object.values(seq));
   }
   static entries(ctx, obj) {
     const seq = ctx.sequence(obj);
-    if (!isPlainObject(seq))
+    if (!isPlainObject(seq)) {
       throw new TypeError("Object.entries requires an object");
+    }
     return ctx.distribute(
       Object.entries(seq).map(([k, v]) => ctx.distribute([ctx.of(k), v]))
     );
@@ -6136,7 +6155,7 @@ __decorateElement(_init4, 9, "entries", _entries_dec2, ExoObject);
 __decorateElement(_init4, 9, "fromEntries", _fromEntries_dec, ExoObject);
 __decoratorMetadata(_init4, ExoObject);
 __runInitializers(_init4, 3, ExoObject);
-_ExoBoolean_decorators = [tool(z.any())], _valueOf_dec2 = [tool()];
+_ExoBoolean_decorators = [tool(z.any())], _valueOf_dec2 = [tool()], _toString_dec4 = [tool()];
 class ExoBoolean {
   constructor(...args) {
     __runInitializers(_init5, 5, this);
@@ -6145,9 +6164,13 @@ class ExoBoolean {
   get valueOf() {
     return Boolean.prototype.valueOf;
   }
+  get toString() {
+    return Boolean.prototype.toString;
+  }
 }
 _init5 = __decoratorStart(null);
 __decorateElement(_init5, 2, "valueOf", _valueOf_dec2, ExoBoolean);
+__decorateElement(_init5, 2, "toString", _toString_dec4, ExoBoolean);
 ExoBoolean = __decorateElement(_init5, 0, "ExoBoolean", _ExoBoolean_decorators, ExoBoolean);
 __runInitializers(_init5, 1, ExoBoolean);
 _parse_dec2 = [tool(z.string())], _stringify_dec = [tool(z.any(), z.union([z.null(), z.undefined()]), z.number().optional())];
@@ -6218,11 +6241,41 @@ __decorateElement(_init7, 9, "sign", _sign_dec, ExoMath);
 __decorateElement(_init7, 9, "trunc", _trunc_dec, ExoMath);
 __decoratorMetadata(_init7, ExoMath);
 __runInitializers(_init7, 3, ExoMath);
-_ExoNumber_decorators = [tool(z.union([z.string(), z.number(), z.bigint()]))], _parseInt_dec = [tool(z.string(), z.number().optional())], _parseFloat_dec = [tool(z.string())], _isNaN_dec = [tool(z.any())], _isFinite_dec = [tool(z.any())], _isInteger_dec = [tool(z.any())];
+_all_dec = [tool(z.array(z.any()))], _allSettled_dec = [tool(z.array(z.any()))], _race_dec = [tool(z.array(z.any()))], _resolve_dec = [tool(z.any())], _reject_dec = [tool(z.any())];
+class ExoPromise {
+  static all(values) {
+    return Promise.all(values);
+  }
+  static allSettled(values) {
+    return Promise.allSettled(values);
+  }
+  static race(values) {
+    return Promise.race(values);
+  }
+  static resolve(value) {
+    return Promise.resolve(value);
+  }
+  static reject(reason) {
+    return Promise.reject(reason);
+  }
+}
+_init8 = __decoratorStart(null);
+__decorateElement(_init8, 9, "all", _all_dec, ExoPromise);
+__decorateElement(_init8, 9, "allSettled", _allSettled_dec, ExoPromise);
+__decorateElement(_init8, 9, "race", _race_dec, ExoPromise);
+__decorateElement(_init8, 9, "resolve", _resolve_dec, ExoPromise);
+__decorateElement(_init8, 9, "reject", _reject_dec, ExoPromise);
+__decoratorMetadata(_init8, ExoPromise);
+__runInitializers(_init8, 3, ExoPromise);
+_ExoNumber_decorators = [tool(z.union([z.string(), z.number(), z.bigint()]))], _toString_dec5 = [tool(z.number().optional())], _parseInt_dec = [tool(z.string(), z.number().optional())], _parseFloat_dec = [tool(z.string())], _isNaN_dec = [tool(z.any())], _isFinite_dec = [tool(z.any())], _isInteger_dec = [tool(z.any())];
 class ExoNumber {
   constructor(...args) {
+    __runInitializers(_init9, 5, this);
     return new Number(...args);
   }
+  get toString() {
+    return Number.prototype.toString;
+  }
   static parseInt(s, radix) {
     return Number.parseInt(s, radix);
   }
@@ -6239,15 +6292,33 @@ class ExoNumber {
     return Number.isInteger(value);
   }
 }
-_init8 = __decoratorStart(null);
-__decorateElement(_init8, 9, "parseInt", _parseInt_dec, ExoNumber);
-__decorateElement(_init8, 9, "parseFloat", _parseFloat_dec, ExoNumber);
-__decorateElement(_init8, 9, "isNaN", _isNaN_dec, ExoNumber);
-__decorateElement(_init8, 9, "isFinite", _isFinite_dec, ExoNumber);
-__decorateElement(_init8, 9, "isInteger", _isInteger_dec, ExoNumber);
-ExoNumber = __decorateElement(_init8, 0, "ExoNumber", _ExoNumber_decorators, ExoNumber);
-__runInitializers(_init8, 3, ExoNumber);
-__runInitializers(_init8, 1, ExoNumber);
+_init9 = __decoratorStart(null);
+__decorateElement(_init9, 9, "parseInt", _parseInt_dec, ExoNumber);
+__decorateElement(_init9, 9, "parseFloat", _parseFloat_dec, ExoNumber);
+__decorateElement(_init9, 9, "isNaN", _isNaN_dec, ExoNumber);
+__decorateElement(_init9, 9, "isFinite", _isFinite_dec, ExoNumber);
+__decorateElement(_init9, 9, "isInteger", _isInteger_dec, ExoNumber);
+__decorateElement(_init9, 2, "toString", _toString_dec5, ExoNumber);
+ExoNumber = __decorateElement(_init9, 0, "ExoNumber", _ExoNumber_decorators, ExoNumber);
+__runInitializers(_init9, 3, ExoNumber);
+__runInitializers(_init9, 1, ExoNumber);
+const allowedExpressions = [
+  "ArrayExpression",
+  "ArrowFunctionExpression",
+  "AwaitExpression",
+  "BinaryExpression",
+  "CallExpression",
+  "ConditionalExpression",
+  "Identifier",
+  "Literal",
+  "LogicalExpression",
+  "MemberExpression",
+  "NewExpression",
+  "ObjectExpression",
+  "TemplateLiteral",
+  "UnaryExpression",
+  "ChainExpression"
+];
 class Scope2 {
   constructor(parent) {
     this.parent = parent;
@@ -6441,17 +6512,45 @@ class Evaluator {
     const tool2 = getTool(objRaw, objForLookup, key);
     return this.ctx.of(tool2);
   }
+  /**
+   * Convert a value to string for interpolation/concatenation.
+   * Calls .toString() via getExoProperty if available.
+   */
+  *toString(obj, node) {
+    const raw = yield obj;
+    if (raw === null) {
+      return "null";
+    }
+    if (raw === void 0) {
+      return "undefined";
+    }
+    const toStringFn = yield* this.getExoProperty(obj, "toString", node, true);
+    const toStringRaw = yield toStringFn;
+    if (typeof toStringRaw === "function") {
+      const result = this.ctx.call(this.ctx.of(toStringFn), []);
+      const resultRaw = yield result;
+      if (typeof resultRaw === "string") {
+        return resultRaw;
+      }
+    }
+    return "[object]";
+  }
   getBuiltinPrototype(value) {
-    if (typeof value === "string")
+    if (typeof value === "string") {
       return this.builtinPrototypes.String;
-    if (typeof value === "number")
+    }
+    if (typeof value === "number") {
       return this.builtinPrototypes.Number;
-    if (typeof value === "boolean")
+    }
+    if (typeof value === "boolean") {
       return this.builtinPrototypes.Boolean;
-    if (Array.isArray(value))
+    }
+    if (Array.isArray(value)) {
       return this.builtinPrototypes.Array;
-    if (value instanceof Date)
+    }
+    if (value instanceof Date) {
       return this.builtinPrototypes.Date;
+    }
     return null;
   }
   *ObjectExpression(node) {
@@ -6477,16 +6576,27 @@ class Evaluator {
     this.inv.eval(this.ctx.isExpr(result), "internal error: result is not an expression", node, result);
     return result;
   }
-  *evalStatements(statements) {
+  *evalStatements(statements, { module = false } = {}) {
     let result = this.ctx.of(void 0);
+    const exports$1 = {};
     for (const statement of statements) {
-      this.inv.parse(
-        statement.type !== "ImportDeclaration" && statement.type !== "ExportAllDeclaration" && statement.type !== "ExportNamedDeclaration" && statement.type !== "ExportDefaultDeclaration",
-        "statement is not a statement",
-        statement
-      );
+      if (statement.type === "ImportDeclaration") {
+        this.inv.parse(false, "imports are not allowed", statement);
+      }
+      if (statement.type === "ExportAllDeclaration" || statement.type === "ExportNamedDeclaration") {
+        this.inv.parse(false, "only export default is allowed", statement);
+      }
+      if (statement.type === "ExportDefaultDeclaration") {
+        this.inv.parse(module, "export is not allowed in script mode", statement);
+        const exported = yield* this.Expression(statement.declaration);
+        this.defineProperty(exports$1, "default", exported, statement);
+        continue;
+      }
       result = yield* this.Statement(statement);
     }
+    if (module) {
+      return this.ctx.distribute(exports$1);
+    }
     return result;
   }
   *evalFunctionCall(node, args) {
@@ -6562,8 +6672,10 @@ class Evaluator {
   }
   *BinaryExpression(node) {
     this.inv.parse(node.left.type !== "PrivateIdentifier", "private identifiers are not allowed", node);
-    const left = yield* this.$(node.left);
-    const right = yield* this.$(node.right);
+    const leftExpr = yield* this.Expression(node.left);
+    const rightExpr = yield* this.Expression(node.right);
+    const left = yield leftExpr;
+    const right = yield rightExpr;
     switch (node.operator) {
       case "===":
         return this.ctx.of(left === right);
@@ -6574,6 +6686,14 @@ class Evaluator {
       case "!=":
         return this.ctx.of(left != right);
     }
+    if (node.operator === "+") {
+      if (typeof left === "number" && typeof right === "number") {
+        return this.ctx.of(left + right);
+      }
+      const leftStr = yield* this.toString(leftExpr, node.left);
+      const rightStr = yield* this.toString(rightExpr, node.right);
+      return this.ctx.of(leftStr + rightStr);
+    }
     this.inv.eval((typeof left === "number" || typeof left === "string") && (typeof right === "number" || typeof right === "string"), "left and right are not numbers or strings", node, { left, right });
     switch (node.operator) {
       case "<":
@@ -6582,8 +6702,6 @@ class Evaluator {
         return this.ctx.of(left > right);
       case "<=":
         return this.ctx.of(left <= right);
-      case "+":
-        return this.ctx.of(left + right);
     }
     this.inv.eval(typeof left === "number" && typeof right === "number", "left and right are not numbers", node, { left, right });
     switch (node.operator) {
@@ -6636,9 +6754,9 @@ class Evaluator {
       result.push(quasi.value.cooked);
       const expr2 = node.expressions[i];
       if (expr2) {
-        const val = yield* this.$(expr2);
-        this.inv.eval(typeof val === "string" || typeof val === "number" || typeof val === "boolean", "template expressions must evaluate to a string, number, or boolean", expr2, val);
-        result.push(val);
+        const exprValue = yield* this.Expression(expr2);
+        const str = yield* this.toString(exprValue, expr2);
+        result.push(str);
       }
     }
     return this.ctx.of(result.join(""));
@@ -6660,8 +6778,7 @@ class Evaluator {
     return this.ctx.of(instance);
   }
   *Expression(node) {
-    const supportedExpressions = ["ArrayExpression", "ArrowFunctionExpression", "AwaitExpression", "BinaryExpression", "CallExpression", "ConditionalExpression", "Function", "Identifier", "Literal", "LogicalExpression", "MemberExpression", "NewExpression", "ObjectExpression", "TemplateLiteral", "UnaryExpression", "ChainExpression"];
-    this.inv.parse(supportedExpressions.includes(node.type), `unsupported expression type: ${node.type}`, node);
+    this.inv.parse(allowedExpressions.includes(node.type), `unsupported expression type: ${node.type}`, node);
     return yield* this[node.type](node);
   }
   *$(node) {
@@ -6705,8 +6822,8 @@ class Evaluator {
     }
     this.inv.parse(false, "unsupported statement type", node);
   }
-  Program(node) {
-    const iter = this.ctx.doGen(this.evalStatements(node.body));
+  Program(node, { module = false } = {}) {
+    const iter = this.ctx.doGen(this.evalStatements(node.body, { module }));
     let step = iter.next();
     if (step.done) {
       return step.value;
@@ -6731,7 +6848,8 @@ const builtins = {
   Boolean: ExoBoolean,
   JSON: ExoJSON,
   Math: ExoMath,
-  Number: ExoNumber
+  Number: ExoNumber,
+  Promise: ExoPromise
 };
 function exoEval(code, ctx = new IdentityContext()) {
   const ast = parse3(code, { ecmaVersion: 2022 });
@@ -6739,7 +6857,9 @@ function exoEval(code, ctx = new IdentityContext()) {
   const evaluator = new Evaluator(ast, code, ctx, rootScope, {
     Array: ExoArray.prototype,
     String: ExoString.prototype,
-    Date: ExoDate.prototype
+    Date: ExoDate.prototype,
+    Number: ExoNumber.prototype,
+    Boolean: ExoBoolean.prototype
   });
   for (const [name, value] of Object.entries(builtins)) {
     rootScope.set(
@@ -8141,21 +8261,20 @@ async function* generateToolTypes(tools, name) {
   for (const [toolName, tool2] of toolEntries) {
     const inputSchema = getJsonSchema(tool2.inputSchema);
     const outputSchema = tool2.outputSchema ? getJsonSchema(tool2.outputSchema) : null;
+    const compileOpts = {
+      format: false,
+      bannerComment: " ",
+      cwd: "/"
+    };
     const inputJsonType = await compile(
       inputSchema,
       `${camelCase(toolName, { pascalCase: true })}Input`,
-      {
-        format: false,
-        bannerComment: " "
-      }
+      compileOpts
     );
     const outputJsonType = outputSchema ? await compile(
       outputSchema,
       `${camelCase(toolName, { pascalCase: true })}Output`,
-      {
-        format: false,
-        bannerComment: " "
-      }
+      compileOpts
     ) : null;
     const inputTypeBody = extractTypeBody(inputJsonType);
     const outputTypeBody = outputJsonType ? extractTypeBody(outputJsonType) : "object";

package/dist/runtime/daemon.d.ts

@@ -0,0 +1,37 @@
+import { Secrets } from './providers/secrets';
+import { StorageCap } from './providers/storage';
+/**
+ * exoagentd — runtime daemon.
+ *
+ * Owns shared infrastructure (storage, secrets) and manages
+ * agent processes via dtach (terminal session manager).
+ */
+export interface DaemonConfig {
+    repoDir: string;
+    dataDir?: string;
+}
+export declare class Daemon {
+    readonly repoDir: string;
+    readonly dataDir: string;
+    readonly storage: StorageCap;
+    readonly secrets: Secrets;
+    private constructor();
+    static start(config: DaemonConfig): Promise<Daemon>;
+    /** Validate agentId — alphanumeric, hyphens, underscores only */
+    private validateAgentId;
+    /** Spawn an agent in a dtach session */
+    spawn(agentId: string): Promise<string>;
+    /** Attach to an agent — replaces current process with dtach */
+    attach(agentId: string): void;
+    /** List running agents (by socket files) */
+    list(): string[];
+    /** Kill an agent — terminates the dtach process tree */
+    kill(agentId: string): void;
+    /** Run an exo with daemon caps */
+    runExo(name: string, exoArgs?: string[]): Promise<unknown>;
+    /** Eval arbitrary code with daemon caps (like an inline exo) */
+    evalCode(code: string): Promise<unknown>;
+    /** Get a ReviewCap for the default clone (if exists) */
+    private getReviewCap;
+    stop(): Promise<void>;
+}

package/dist/runtime/dts.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Generate a .d.ts declaration string from a TypeScript source file.
+ *
+ * Uses the TypeScript compiler API to emit declarations. Resolves imports
+ * so the output includes full type information.
+ *
+ * @param filePath - Absolute path to the .ts source file
+ * @returns The generated .d.ts content
+ */
+export declare function generateDts(filePath: string): string;
+/**
+ * Generate a .d.ts for a class, extracting only its public method signatures.
+ *
+ * This produces a minimal type declaration suitable for codemode — just the
+ * methods the LLM can call, without internal implementation details.
+ *
+ * @param filePath - Absolute path to the .ts source file
+ * @param className - Name of the class to extract
+ * @returns A declaration string like `{ method(args): ReturnType; ... }`
+ */
+export declare function generateCapDts(filePath: string, className: string): string;

package/dist/runtime/eslint-exo-rule.d.ts

@@ -0,0 +1,3 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/runtime/exo.d.ts

@@ -0,0 +1,33 @@
+/**
+ * An Exo is a sandboxed program. It declares its caps by destructuring
+ * the first argument of its default export.
+ *
+ * ```javascript
+ * export default async ({ sandbox, review, storage }) => {
+ *   await sandbox.exec({ command: 'echo hello' })
+ * }
+ * ```
+ *
+ * Only the destructured caps are available — exoeval enforces this at
+ * the interpreter level. Every exo gets the full cap set; the destructure
+ * is the audit trail for what it actually uses.
+ */
+/**
+ * An exo module's default export signature.
+ * Caps are received as a single object, destructured by the exo.
+ */
+export type ExoFn = (caps: Record<string, object>) => void | Promise<void>;
+/**
+ * Metadata for an exo — loaded from its module.
+ */
+export interface ExoDef {
+    readonly name: string;
+    readonly run: ExoFn;
+}
+/**
+ * Loads an exo from source code via exoImport (the sandboxed interpreter).
+ * The source must `export default` a function that takes a caps object.
+ *
+ * Source should already be plain JS (run through esbuild if TypeScript).
+ */
+export declare function loadExo(name: string, code: string): Promise<ExoDef>;

package/dist/runtime/providers/args.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Args cap — provides CLI arguments to exos.
+ */
+export declare class ArgsCap {
+    private map;
+    constructor(args: string[]);
+    get({ key }: {
+        key: string;
+    }): Promise<string | undefined>;
+    has({ key }: {
+        key: string;
+    }): Promise<boolean>;
+}

package/dist/runtime/providers/pi.d.ts

@@ -0,0 +1,68 @@
+import { Model } from '@mariozechner/pi-ai';
+import { ExtensionFactory, AgentSession, SessionManager, SettingsManager } from '@mariozechner/pi-coding-agent';
+import { Secrets } from './secrets';
+import { StorageCap } from './storage';
+import { ReviewCap } from './review';
+import { SandboxCap } from './sandbox';
+export interface PiCapConfig {
+    sandbox: SandboxCap;
+    /** Arbitrary capability objects to expose via codemode */
+    caps?: Record<string, object>;
+    /** Additional system prompt text */
+    systemPrompt?: string;
+    /** Pre-generated .d.ts for caps (required when caps are provided) */
+    capsDts: string;
+    /** @internal */ model?: Model<any>;
+    /** @internal */ extensionFactories?: ExtensionFactory[];
+    /** @internal */ settingsManager?: SettingsManager;
+    /** @internal */ sessionManager?: SessionManager;
+}
+export declare class PiCap {
+    private config;
+    private session;
+    private modelFallbackMessage?;
+    constructor(config: PiCapConfig);
+    private sandboxBashOps;
+    /** Read a file via sandbox exec, returns base64-decoded content */
+    private sandboxRead;
+    /** Write a file via sandbox exec, content passed via stdin */
+    private sandboxWrite;
+    /** Check file access via sandbox exec */
+    private sandboxAccess;
+    private scopedReadOps;
+    private scopedWriteOps;
+    private scopedEditOps;
+    private buildCodemodeTool;
+    private ensureSession;
+    /** Send a prompt and return the final text response (background mode) */
+    prompt(message: string): Promise<string>;
+    /** Access the underlying session (for interactive TUI attach) */
+    get currentSession(): AgentSession | null;
+    /** Initialize session without prompting (for interactive mode) */
+    init(): Promise<AgentSession>;
+    /** Run pi's interactive TUI (handles /login, /model, etc.) */
+    runInteractive(options?: {
+        initialMessage?: string;
+    }): Promise<void>;
+    /** Dispose the session */
+    dispose(): void;
+}
+export interface SpawnAgentConfig {
+    id: string;
+    repoDir: string;
+    dataDir: string;
+    storage: StorageCap;
+    secrets: Secrets;
+}
+export interface Agent {
+    readonly id: string;
+    readonly pi: PiCap;
+    readonly review: ReviewCap | undefined;
+    readonly cloneDir: string;
+}
+/**
+ * Spawn a coding agent — wires sandbox + review + pi together.
+ * Creates a local clone, sets up sandbox and review caps, and returns
+ * a fully configured Agent.
+ */
+export declare function spawnAgent(config: SpawnAgentConfig): Promise<Agent>;

package/dist/runtime/providers/review.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Review provider — GitHub PR-based code review.
+ *
+ * Pushes branches to GitHub, opens PRs, fetches reviews.
+ * Git push assumes the host has SSH/credentials configured.
+ * Only GitHub API operations use the token (from secrets DB).
+ */
+/** Review result — uses GitHub API shapes directly (no wrapper types) */
+export interface ReviewResult {
+    approved: boolean;
+    body: string;
+    /** Inline review comments (GitHub PullRequestReviewComment objects) */
+    comments: any[];
+    /** PR-level issue comments (GitHub IssueComment objects) */
+    issueComments: any[];
+    pr: number;
+    url: string;
+}
+export interface ReviewCapConfig {
+    /** Path to the agent's local clone */
+    cloneDir: string;
+    /** Nix git store path */
+    git: string;
+    /** GitHub API token (pre-attenuated from secrets) */
+    token: string;
+    /** GitHub owner/repo (e.g. "user/repo") */
+    repo: string;
+    /** Base branch for PRs. Default: "main" */
+    baseBranch?: string;
+    /** Poll interval in ms. Default: 5000 */
+    pollInterval?: number;
+    /** Agent name for branch prefixing. Default: "default" */
+    agentName?: string;
+}
+export declare class ReviewCap {
+    private config;
+    constructor(config: ReviewCapConfig);
+    /** GitHub API token (pre-attenuated, single source of truth) */
+    private get token();
+    /** Prefix branch name with agent namespace. */
+    private qualifyBranch;
+    /**
+     * Push a branch to GitHub and open/update a PR.
+     * Returns immediately with the PR URL.
+     * Remote branch will be auto-prefixed with `exoagent-<agent>/`.
+     */
+    openPR({ branch, title, body }: {
+        branch: string;
+        title: string;
+        body?: string;
+    }): Promise<{
+        pr: number;
+        url: string;
+        sha: string;
+    }>;
+    /**
+     * Get the latest review on a PR. Returns immediately (non-blocking).
+     * Returns the most recent non-pending review with its comments.
+     */
+    getReviews({ pr }: {
+        pr: number;
+    }): Promise<ReviewResult>;
+    /**
+     * Reply to a specific review comment on a PR.
+     */
+    replyToComment({ pr, commentId, body }: {
+        pr: number;
+        commentId: number;
+        body: string;
+    }): Promise<{
+        id: number;
+    }>;
+    /**
+     * Post a general comment on a PR (issue-level comment).
+     */
+    commentOnPR({ pr, body }: {
+        pr: number;
+        body: string;
+    }): Promise<{
+        id: number;
+    }>;
+}

package/dist/runtime/providers/sandbox.d.ts

@@ -0,0 +1,54 @@
+import { StorageCap } from './storage';
+/**
+ * Sandbox provider — bwrap-based execution environment with network
+ * isolation (internet yes, LAN/loopback blocked via pasta + nft).
+ *
+ * - exec: runs commands inside bwrap (PID-isolated, net-filtered, fs-scoped)
+ * - read/write/edit: host-side file ops, path-validated to workspace
+ */
+/** Nix store paths for essential binaries */
+export interface NixPaths {
+    bash: string;
+    coreutils: string;
+    bwrap: string;
+    pasta: string;
+    nft: string;
+    nix: string;
+    cacert: string;
+    git: string;
+    gnugrep: string;
+    dtach: string;
+}
+/** Read nix paths from EXOAGENT_NIX env var (JSON) set by flake.nix devShell */
+export declare function nixPathsFromEnv(): NixPaths;
+interface SandboxConfig {
+    nix: NixPaths;
+    storage: StorageCap;
+    sessionId: string;
+    workspace: string;
+}
+export declare class SandboxCap {
+    private config;
+    private rootDir;
+    private scriptWritten;
+    constructor(config: SandboxConfig);
+    private getRoot;
+    /** Compute the transitive closure of nix store paths needed in the sandbox */
+    private nixClosure;
+    /** Validate a path is safe to interpolate into a shell script (no special chars) */
+    private static assertSafePath;
+    /** Write the wrapper script once, reuse for every exec */
+    private ensureScript;
+    exec({ command, timeout, signal, stdin }: {
+        command: string;
+        timeout?: number;
+        signal?: AbortSignal;
+        stdin?: string;
+    }): Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+    get workspace(): string;
+}
+export {};

package/dist/runtime/providers/secrets.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Daemon-only secrets store. Never exposed to exos.
+ * Each provider gets its own set of named secrets (e.g. API keys).
+ */
+export declare class Secrets {
+    private readonly root;
+    private readonly db;
+    private constructor();
+    /**
+     * Create a Secrets store backed by a SQLite DB in the given directory.
+     * Initializes the directory (mode 0700) and DB schema on first call.
+     */
+    static create(root: string): Secrets;
+    get(provider: string, name: string): string | null;
+    set(provider: string, name: string, value: string): void;
+    delete(provider: string, name: string): void;
+    close(): void;
+}

package/dist/runtime/providers/storage.d.ts

@@ -0,0 +1,16 @@
+export declare class StorageCap {
+    private readonly root;
+    private readonly provider;
+    private readonly db;
+    private constructor();
+    /**
+     * Create a StorageCap backed by a SQLite DB in the given directory.
+     * Initializes the directory and DB schema on first call.
+     */
+    static create(root: string, provider?: string): StorageCap;
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    close(): void;
+    dir(name: string): Promise<string>;
+}

package/dist/runtime/secrets-ui.d.ts

@@ -0,0 +1,19 @@
+import { Secrets } from './providers/secrets';
+/**
+ * Secret declaration — providers declare what secrets they need.
+ */
+export interface SecretDecl {
+    name: string;
+    required: boolean;
+    description: string;
+}
+export interface ProviderSecrets {
+    provider: string;
+    secrets: SecretDecl[];
+}
+/** Known providers and their secrets */
+export declare const PROVIDER_SECRETS: ProviderSecrets[];
+/**
+ * Interactive TUI for managing secrets.
+ */
+export declare function runSecretsUI(db: Secrets): Promise<void>;

package/dist/runtime/start-agent.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/runtime/start.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/sql.mjs

@@ -51,7 +51,7 @@ var _desc_dec, _asc_dec, ___dec, ___dec2, ___dec3, ___dec4, ___dec5, _NOT_LIKE_d
 import { sql as sql$1, Kysely } from "kysely";
 import invariant from "tiny-invariant";
 import z from "zod";
-import { a as tool, r as registerToolField, f as fn } from "./tool-DGs9ZxVn.js";
+import { a as tool, r as registerToolField, f as fn } from "./tool-5wSlXWJ2.js";
 const sql = sql$1;
 const buildSql = (parts, separator = sql$1` `) => {
   return sql$1.join(parts.filter((x) => x != null), separator);

package/dist/{tool-DGs9ZxVn.js → tool-5wSlXWJ2.js}

@@ -70,8 +70,9 @@ const makeFnSchema = (retSchema, allowOptional = false) => {
       version: 1,
       vendor: "exoeval",
       validate: (value) => {
-        if (value === void 0 && allowOptional)
+        if (value === void 0 && allowOptional) {
           return { value: void 0 };
+        }
         if (typeof value !== "function") {
           return { issues: [{ message: "Expected a function" }] };
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "exoagent",
   "type": "module",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "The OS kernel to safely unleash your agents",
   "author": "Ryan Rasti <https://github.com/ryanrasti>",
   "license": "MIT",
@@ -48,6 +48,7 @@
     "release": "bumpp",
     "start": "tsx src/index.ts",
     "test": "vitest --run",
+    "test:ci": "vitest --run --exclude '**/*.local.test.ts'",
     "typecheck": "tsc",
     "check:examples": "npm --prefix ./examples run check",
     "check": "npm ci && npm run lint && npm run typecheck && npm run build && npm run test && npm run check:examples"
@@ -56,6 +57,9 @@
     "ai": "^6.0.0"
   },
   "dependencies": {
+    "@mariozechner/pi-coding-agent": "^0.58.4",
+    "@sinclair/typebox": "^0.34.48",
+    "better-sqlite3": "^12.8.0",
     "camelcase": "^9.0.0",
     "json-schema": "^0.4.0",
     "json-schema-to-typescript": "^15.0.0",
@@ -71,6 +75,7 @@
     "@antfu/utils": "9.3.0",
     "@electric-sql/pglite": "^0.3.15",
     "@standard-schema/spec": "^1.1.0",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "25.0.1",
     "acorn": "^8.16.0",
     "bumpp": "10.3.2",