@codeworksh/harness 0.0.1-dev.20260907151726 → 0.0.1-dev.20260917115353

package/{index-CTm6Qzer.d.mts → index-5Ur9C_De.d.mts}

@@ -1,4 +1,4 @@
-import { g as Module, h as Driver, y as Registration } from "./sandbox-DnL9UPzZ.mjs";
+import { a as driver_d_exports, g as Module, h as Driver, y as Registration } from "./sandbox-DX9mliQs.mjs";
 import { Schema } from "effect";
 //#region src/sandboxes/daytona/index.d.ts
 declare const Options: Schema.Struct<{
@@ -72,4 +72,4 @@ declare const config: (value: CreateConfig) => {
 };
 //#endregion
 export { RuntimeConfig as a, sandbox as c, ResourcesConfig as i, CreateConfig as n, config as o, Options as r, make as s, ClientOptions as t };
-//# sourceMappingURL=index-CTm6Qzer.d.mts.map
+//# sourceMappingURL=index-5Ur9C_De.d.mts.map

package/{index-D5gDWEaM.d.mts → index-B72Qlv0L.d.mts}

@@ -1,4 +1,4 @@
-import { g as Module, h as Driver, y as Registration } from "./sandbox-DnL9UPzZ.mjs";
+import { a as driver_d_exports, g as Module, h as Driver, y as Registration } from "./sandbox-DX9mliQs.mjs";
 import { Schema } from "effect";
 //#region src/sandboxes/vercel/index.d.ts
 declare const Options: Schema.Struct<{
@@ -78,4 +78,4 @@ declare const config: (value: CreateConfig) => {
 };
 //#endregion
 export { Source as a, sandbox as c, RuntimeConfig as i, CreateConfig as n, config as o, Options as r, make as s, ClientOptions as t };
-//# sourceMappingURL=index-D5gDWEaM.d.mts.map
+//# sourceMappingURL=index-B72Qlv0L.d.mts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@codeworksh/harness",
-	"version": "0.0.1-dev.20260907151726",
+	"version": "0.0.1-dev.20260917115353",
 	"description": "AI agent harness — agent loop, tools, and code execution sandbox.",
 	"keywords": [
 		"agent",
@@ -68,14 +68,16 @@
 	},
 	"dependencies": {
 		"@codeworksh/aikit": "0.8.0",
-		"@effect/platform-node": "4.0.0-beta.107",
-		"@effect/sql-sqlite-node": "4.0.0-beta.107",
+		"@effect/platform-node": "4.0.0-rc.115",
+		"@effect/platform-node-shared": "4.0.0-rc.115",
+		"@effect/sql-sqlite-node": "4.0.0-rc.115",
 		"@platformatic/vfs": "^0.4.0",
-		"effect": "4.0.0-beta.107",
-		"just-bash": "^2.14.5",
+		"effect": "4.0.0-rc.115",
+		"just-bash": "^3.4.2",
+		"npm-package-arg": "^14.0.0",
 		"tslib": "^2.8.1",
-		"typebox": "^1.3.10",
-		"uuid": "^14.0.1",
+		"typebox": "^1.3.30",
+		"uuid": "^14.0.2",
 		"uuidv7": "^1.2.1"
 	},
 	"peerDependencies": {

package/{rolldown-runtime-D7D4PA-g.mjs → rolldown-runtime-8H4AJuhK.mjs}

@@ -1,3 +1,4 @@
+import "node:module";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {

package/{sandbox-DnL9UPzZ.d.mts → sandbox-DX9mliQs.d.mts}

@@ -1,134 +1,6 @@
 import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
-//#region src/sandbox/errors.d.ts
-declare const SandboxNotFoundError_base: Schema.Class<SandboxNotFoundError, Schema.TaggedStruct<"SandboxNotFoundError", {
-  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
-    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-  };
-}>, import("effect/Cause").YieldableError>;
-/**
- * Lifecycle errors are confined to the control plane. Once a mount succeeds,
- * consumers continue to see only FileSystemError and ShellError.
- */
-declare class SandboxNotFoundError extends SandboxNotFoundError_base {}
-declare const SandboxDriverNotRegisteredError_base: Schema.Class<SandboxDriverNotRegisteredError, Schema.TaggedStruct<"SandboxDriverNotRegisteredError", {
-  readonly driver: Schema.String;
-  readonly registered: Schema.optional<Schema.$Array<Schema.String>>;
-}>, import("effect/Cause").YieldableError>;
-declare class SandboxDriverNotRegisteredError extends SandboxDriverNotRegisteredError_base {}
-declare const SandboxDriverRegistrationError_base: Schema.Class<SandboxDriverRegistrationError, Schema.TaggedStruct<"SandboxDriverRegistrationError", {
-  readonly driver: Schema.String;
-  readonly reason: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-declare class SandboxDriverRegistrationError extends SandboxDriverRegistrationError_base {}
-declare const SandboxDriverLoadError_base: Schema.Class<SandboxDriverLoadError, Schema.TaggedStruct<"SandboxDriverLoadError", {
-  readonly specifier: Schema.String;
-  readonly phase: Schema.Literals<readonly ["resolve", "import", "module", "api-version", "options", "factory", "registration"]>;
-  readonly driver: Schema.optional<Schema.String>;
-  readonly reason: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-declare class SandboxDriverLoadError extends SandboxDriverLoadError_base {}
-declare const SandboxBusyError_base: Schema.Class<SandboxBusyError, Schema.TaggedStruct<"SandboxBusyError", {
-  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
-    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-  };
-  readonly refCount: Schema.Int;
-}>, import("effect/Cause").YieldableError>;
-declare class SandboxBusyError extends SandboxBusyError_base {}
-declare const SandboxMustBeStoppedError_base: Schema.Class<SandboxMustBeStoppedError, Schema.TaggedStruct<"SandboxMustBeStoppedError", {
-  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
-    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-  };
-  readonly status: Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>;
-}>, import("effect/Cause").YieldableError>;
-declare class SandboxMustBeStoppedError extends SandboxMustBeStoppedError_base {}
-declare const SandboxRemovedError_base: Schema.Class<SandboxRemovedError, Schema.TaggedStruct<"SandboxRemovedError", {
-  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
-    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-  };
-  readonly removedAt: Schema.optional<Schema.DateTimeUtc>;
-}>, import("effect/Cause").YieldableError>;
-declare class SandboxRemovedError extends SandboxRemovedError_base {}
-declare const SandboxUnavailError_base: Schema.Class<SandboxUnavailError, Schema.TaggedStruct<"SandboxUnavailError", {
-  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
-    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-  };
-  readonly reason: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-declare class SandboxUnavailError extends SandboxUnavailError_base {}
-declare const SandboxUnsupportedError_base: Schema.Class<SandboxUnsupportedError, Schema.TaggedStruct<"SandboxUnsupportedError", {
-  readonly id: Schema.optional<Schema.brand<Schema.String, "SandboxInstance.ID"> & {
-    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-  }>;
-  readonly driver: Schema.String;
-  readonly operation: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-declare class SandboxUnsupportedError extends SandboxUnsupportedError_base {}
-declare const SandboxTransitionConflictError_base: Schema.Class<SandboxTransitionConflictError, Schema.TaggedStruct<"SandboxTransitionConflictError", {
-  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
-    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
-  };
-  readonly expected: Schema.$Array<Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>>;
-  readonly actual: Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>;
-}>, import("effect/Cause").YieldableError>;
-declare class SandboxTransitionConflictError extends SandboxTransitionConflictError_base {}
-declare const SandboxProviderError_base: Schema.Class<SandboxProviderError, Schema.TaggedStruct<"SandboxProviderError", {
-  readonly driver: Schema.String;
-  readonly operation: Schema.String;
-  readonly sanitized: Schema.Struct<{
-    readonly name: Schema.String;
-    readonly message: Schema.String;
-    readonly code: Schema.optional<Schema.String>;
-  }>;
-}>, import("effect/Cause").YieldableError>;
-/**
- * A lifecycle failure safe to serialize, persist, or log.
- *
- * The raw SDK defect is deliberately absent from the schema. It is retained on
- * a non-enumerable symbol by {@link providerError}, so Effect's default
- * formatting and JSON serialization cannot expose credentials nested in it.
- */
-declare class SandboxProviderError extends SandboxProviderError_base {}
-declare const providerErrorCause: (error: SandboxProviderError) => unknown;
-declare const providerErrorIsNotFound: (error: SandboxProviderError) => boolean;
-type Redactor = (value: string) => string;
-/**
- * Conservative text redaction shared by every driver sanitizer.
- *
- * Disclaimer: This can really leak. Its never safe
- *
- * Configured secrets are removed exactly. Common authorization/header and URL
- * query shapes are masked as a second line of defence for values the caller did
- * not explicitly seed.
- *
- * Note: add support for diff regex as needed.
- */
-declare const makeRedactor: (secrets?: Iterable<string>) => Redactor;
-declare const sanitizeError: (cause: unknown, redact?: Redactor) => PersistedError;
-declare const providerError: (input: {
-  readonly driver: string;
-  readonly operation: string;
-  readonly cause: unknown;
-  readonly redact?: Redactor;
-  readonly sanitize?: (cause: unknown, redact: Redactor) => PersistedError;
-  readonly notFound?: boolean;
-}) => SandboxProviderError;
-type SandboxMountError = SandboxNotFoundError | SandboxDriverNotRegisteredError | SandboxUnavailError | SandboxRemovedError | SandboxProviderError;
-type SandboxCreateError = SandboxDriverNotRegisteredError | SandboxDriverRegistrationError | SandboxProviderError;
-type SandboxRegisterError = SandboxDriverNotRegisteredError | SandboxDriverRegistrationError | SandboxUnsupportedError | SandboxProviderError;
-type SandboxReadError = never;
-type SandboxRefreshError = SandboxNotFoundError | SandboxDriverNotRegisteredError | SandboxUnavailError | SandboxUnsupportedError | SandboxProviderError;
-type SandboxWakeError = SandboxRefreshError | SandboxRemovedError;
-type SandboxStopError = SandboxWakeError | SandboxBusyError | SandboxTransitionConflictError;
-type SandboxDestroyError = SandboxStopError | SandboxMustBeStoppedError;
 declare namespace filesystem_d_exports {
-  export { FileStat, FileSystemError, Interface, OperationUnsupportedError, Provider, RmOptions, filesystem_d_exports as SandboxFileSystem, Service$1 as Service, fromProvider, isNotFoundError, validateRmOptions, withCwd };
+  export { FileStat, FileSystemError, Interface, OperationUnsupportedError, Provider, RmOptions, filesystem_d_exports as SandboxFileSystem, Service$1 as Service, fromProvider, isNotFoundError, realpathScripts, validateRmOptions, withCwd };
 }
 declare const OperationUnsupportedError_base: Schema.Class<OperationUnsupportedError, Schema.TaggedStruct<"OperationUnsupportedError", {
   readonly operation: Schema.String;
@@ -184,6 +56,13 @@ interface RmOptions {
 }
 /** Whether a provider failure means the path itself is definitively absent. */
 declare const isNotFoundError: (cause: unknown) => boolean;
+/**
+ * Shell forms of `realpath` for backends that only expose a process API.
+ * `pwd -P` is the portable primitive: directories resolve directly, anything
+ * else resolves its parent and keeps the final name as given. Run as
+ * `sh -c <script> _ <path>`; try the first, fall back to the second.
+ */
+declare const realpathScripts: readonly ['cd -- "$1" && pwd -P', 'cd -- "$(dirname -- "$1")" && printf \'%s/%s\' "$(pwd -P)" "$(basename -- "$1")"'];
 /**
  * The backend-facing contract. Backends author plain promises and let them
  * reject; {@link fromProvider} turns rejections into typed failures.
@@ -203,6 +82,8 @@ interface Provider {
     recursive?: boolean;
   }) => Promise<void>;
   readonly rm: (path: string, options?: RmOptions) => Promise<void>;
+  /** Canonical absolute path with symlinks resolved; rejects when the path does not exist. */
+  readonly realpath: (path: string) => Promise<string>;
   /**
    * Metadata for the directory entry itself rather than a symlink's target.
    * Optional: a backend whose `stat` has mixed symlink semantics implements it
@@ -228,6 +109,8 @@ interface Interface {
     recursive?: boolean;
   }) => Effect.Effect<void, FileSystemError>;
   readonly rm: (path: string, options?: RmOptions) => Effect.Effect<void, FileSystemError | OperationUnsupportedError>;
+  /** Canonical absolute path with symlinks resolved; fails when the path does not exist. */
+  readonly realpath: (path: string) => Effect.Effect<string, FileSystemError>;
   readonly lstat?: (path: string) => Effect.Effect<FileStat, FileSystemError>;
 }
 declare const Service_base$1: Context.ServiceClass<Service$1, "@codeworksh/harness/sandbox/fs/filesystem/Service", Interface>;
@@ -285,7 +168,7 @@ interface ShellOptions {
 /**
  * A streamed chunk of command output, terminated by a single `exit` carrying the
  * exit code. (A backend-level mirror of the tool layer's event; kept here so
- * `sandbox/` does not depend on `tools/`.)
+ * `sandbox/` does not depend on `tool/`.)
  */
 type ExecChunk = {
   readonly _tag: "stdout";
@@ -342,8 +225,141 @@ declare const fromExec: (backend: Omit<ISandboxExe, "execArgv">) => ISandboxExe;
 declare const Shell_base: Context.ServiceClass<Shell$1, "@codeworksh/harness/sandbox/shell/shell", ISandboxExe>;
 /** Execution service — the live {@link ISandboxExe} for the active sandbox. */
 declare class Shell$1 extends Shell_base {}
-//#endregion
-//#region src/sandbox/io.d.ts
+declare namespace errors_d_exports {
+  export { Redactor, SandboxBusyError, SandboxCreateError, SandboxDestroyError, SandboxDriverLoadError, SandboxDriverLoadPhase, SandboxDriverNotRegisteredError, SandboxDriverRegistrationError, errors_d_exports as SandboxError, SandboxMountError, SandboxMustBeStoppedError, SandboxNotFoundError, SandboxProviderError, SandboxReadError, SandboxRefreshError, SandboxRegisterError, SandboxRemovedError, SandboxStopError, SandboxTransitionConflictError, SandboxUnavailError, SandboxUnsupportedError, SandboxWakeError, makeRedactor, providerError, providerErrorCause, providerErrorIsNotFound, sanitizeError };
+}
+declare const SandboxNotFoundError_base: Schema.Class<SandboxNotFoundError, Schema.TaggedStruct<"SandboxNotFoundError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Lifecycle errors are confined to the control plane. Once a mount succeeds,
+ * consumers continue to see only FileSystemError and ShellError.
+ */
+declare class SandboxNotFoundError extends SandboxNotFoundError_base {}
+declare const SandboxDriverNotRegisteredError_base: Schema.Class<SandboxDriverNotRegisteredError, Schema.TaggedStruct<"SandboxDriverNotRegisteredError", {
+  readonly driver: Schema.String;
+  readonly registered: Schema.optional<Schema.$Array<Schema.String>>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxDriverNotRegisteredError extends SandboxDriverNotRegisteredError_base {}
+declare const SandboxDriverRegistrationError_base: Schema.Class<SandboxDriverRegistrationError, Schema.TaggedStruct<"SandboxDriverRegistrationError", {
+  readonly driver: Schema.String;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxDriverRegistrationError extends SandboxDriverRegistrationError_base {}
+declare const SandboxDriverLoadPhase: Schema.Literals<readonly ["resolve", "import", "module", "api-version", "options", "factory", "registration"]>;
+type SandboxDriverLoadPhase = typeof SandboxDriverLoadPhase.Type;
+declare const SandboxDriverLoadError_base: Schema.Class<SandboxDriverLoadError, Schema.TaggedStruct<"SandboxDriverLoadError", {
+  readonly specifier: Schema.String;
+  readonly phase: Schema.Literals<readonly ["resolve", "import", "module", "api-version", "options", "factory", "registration"]>;
+  readonly driver: Schema.optional<Schema.String>;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxDriverLoadError extends SandboxDriverLoadError_base {}
+declare const SandboxBusyError_base: Schema.Class<SandboxBusyError, Schema.TaggedStruct<"SandboxBusyError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly refCount: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxBusyError extends SandboxBusyError_base {}
+declare const SandboxMustBeStoppedError_base: Schema.Class<SandboxMustBeStoppedError, Schema.TaggedStruct<"SandboxMustBeStoppedError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly status: Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxMustBeStoppedError extends SandboxMustBeStoppedError_base {}
+declare const SandboxRemovedError_base: Schema.Class<SandboxRemovedError, Schema.TaggedStruct<"SandboxRemovedError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly removedAt: Schema.optional<Schema.DateTimeUtc>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxRemovedError extends SandboxRemovedError_base {}
+declare const SandboxUnavailError_base: Schema.Class<SandboxUnavailError, Schema.TaggedStruct<"SandboxUnavailError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxUnavailError extends SandboxUnavailError_base {}
+declare const SandboxUnsupportedError_base: Schema.Class<SandboxUnsupportedError, Schema.TaggedStruct<"SandboxUnsupportedError", {
+  readonly id: Schema.optional<Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  }>;
+  readonly driver: Schema.String;
+  readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxUnsupportedError extends SandboxUnsupportedError_base {}
+declare const SandboxTransitionConflictError_base: Schema.Class<SandboxTransitionConflictError, Schema.TaggedStruct<"SandboxTransitionConflictError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly expected: Schema.$Array<Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>>;
+  readonly actual: Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxTransitionConflictError extends SandboxTransitionConflictError_base {}
+declare const SandboxProviderError_base: Schema.Class<SandboxProviderError, Schema.TaggedStruct<"SandboxProviderError", {
+  readonly driver: Schema.String;
+  readonly operation: Schema.String;
+  readonly sanitized: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly message: Schema.String;
+    readonly code: Schema.optional<Schema.String>;
+  }>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A lifecycle failure safe to serialize, persist, or log.
+ *
+ * The raw SDK defect is deliberately absent from the schema. It is retained on
+ * a non-enumerable symbol by {@link providerError}, so Effect's default
+ * formatting and JSON serialization cannot expose credentials nested in it.
+ */
+declare class SandboxProviderError extends SandboxProviderError_base {}
+declare const providerErrorCause: (error: SandboxProviderError) => unknown;
+declare const providerErrorIsNotFound: (error: SandboxProviderError) => boolean;
+type Redactor = (value: string) => string;
+/**
+ * Conservative text redaction shared by every driver sanitizer.
+ *
+ * Disclaimer: This can really leak. Its never safe
+ *
+ * Configured secrets are removed exactly. Common authorization/header and URL
+ * query shapes are masked as a second line of defence for values the caller did
+ * not explicitly seed.
+ *
+ * Note: add support for diff regex as needed.
+ */
+declare const makeRedactor: (secrets?: Iterable<string>) => Redactor;
+declare const sanitizeError: (cause: unknown, redact?: Redactor) => PersistedError;
+declare const providerError: (input: {
+  readonly driver: string;
+  readonly operation: string;
+  readonly cause: unknown;
+  readonly redact?: Redactor;
+  readonly sanitize?: (cause: unknown, redact: Redactor) => PersistedError;
+  readonly notFound?: boolean;
+}) => SandboxProviderError;
+type SandboxMountError = SandboxNotFoundError | SandboxDriverNotRegisteredError | SandboxUnavailError | SandboxRemovedError | SandboxProviderError;
+type SandboxCreateError = SandboxDriverNotRegisteredError | SandboxDriverRegistrationError | SandboxProviderError;
+type SandboxRegisterError = SandboxDriverNotRegisteredError | SandboxDriverRegistrationError | SandboxUnsupportedError | SandboxProviderError;
+type SandboxReadError = never;
+type SandboxRefreshError = SandboxNotFoundError | SandboxDriverNotRegisteredError | SandboxUnavailError | SandboxUnsupportedError | SandboxProviderError;
+type SandboxWakeError = SandboxRefreshError | SandboxRemovedError;
+type SandboxStopError = SandboxWakeError | SandboxBusyError | SandboxTransitionConflictError;
+type SandboxDestroyError = SandboxStopError | SandboxMustBeStoppedError;
+declare namespace io_d_exports$1 {
+  export { Current, FileSystem$1 as FileSystem, Identity, Layer$1 as Layer, Provides, io_d_exports$1 as SandboxIO, Shell, host, hostLayer, identityLayer, mount, remote, resolveMountCwd, virtual };
+}
 /**
  * `SandboxIO` is a **mount**: a filesystem, a shell, and the identity and
  * working directory they act on.
@@ -394,8 +410,79 @@ declare class Current extends Current_base {}
 type Provides = Current | Service$1 | Shell$1;
 /** A built mount. */
 type Layer$1<E = never, RIn = never> = Layer.Layer<Provides, E, RIn>;
-//#endregion
-//#region src/sandbox/driver.d.ts
+/**
+ * Resolve a mount's cwd without consulting ambient process state.
+ *
+ * The default is supplied by the namespace adapter:
+ * provider metadata remotely, `/` for a virtual filesystem, and `process.cwd()` for the host adapter.
+ * An explicit absolute cwd replaces it; a relative cwd is resolved inside it. The
+ * result is therefore always the one concrete absolute path `Current` requires.
+ *
+ * A non-absolute default throws rather than failing typed. It is the one
+ * defect-level guard in this module, and deliberately so:
+ * Adapters reading a value from a provider call this inside their own error channel,
+ * where the throw becomes their typed failure (see `EnvDaytona.mountCwd`).
+ */
+declare const resolveMountCwd: (defaultCwd: string, cwd?: string) => string;
+/**
+ * Bind a cwd-neutral transport to one mount.
+ *
+ * The transport underneath is shared between
+ * mounts and stays rooted at the namespace root, and everything directory-shaped
+ * happens here, once per mount. Two mounts of one namespace at different working
+ * directories therefore coexist without seeing or moving each other's.
+ *
+ * It consumes the same two tags it provides — the transport is supplied by the
+ * layer this is composed over, not by itself.
+ */
+declare const mount: (identity: Identity) => Layer.Layer<Provides, never, Service$1 | Shell$1>;
+/**
+ * Just the identity tag, with no filesystem or shell beneath it. For consumers
+ * assembled from stubs — a test that runs `Project` over a fake filesystem still
+ * needs to know which namespace it is in.
+ */
+declare const identityLayer: (identity: Identity) => Layer.Layer<Current, never, never>;
+/** The host identity alone. See {@link identityLayer}. */
+declare const hostLayer: (cwd?: string) => Layer.Layer<Current, never, never>;
+/**
+ * The host, rooted at `cwd`. Always `SandboxInstance.ID.local`: the working
+ * directory selects where relative paths resolve, it does not make a second host
+ * namespace — two mounts rooted at different directories still agree on absolute
+ * paths.
+ *
+ * The host adapter defaults to `process.cwd()`, matching the OS process it wraps.
+ * This is the one namespace where that coordinate is intrinsically valid; remote
+ * and virtual adapters must never inherit it.
+ */
+declare const host: (cwd?: string) => Identity;
+/**
+ * A VFS-backed namespace. The id is minted per call unless one is named, because
+ * building one of these builds a fresh VFS: N unnamed calls are N distinct
+ * namespaces, none of which outlives the process. A file-backed store is the
+ * exception — its file is the state, so whoever knows the file supplies the id
+ * it was registered under.
+ */
+declare const virtual: (input: {
+  readonly driver: string;
+  readonly id?: ID;
+  readonly defaultCwd?: string;
+  readonly cwd?: string;
+}) => Identity;
+/**
+ * A provider-hosted namespace. The id is always supplied: a remote resource's
+ * durable identity is minted and recorded by whoever provisioned it, never
+ * derived here from the provider's own locator.
+ */
+declare const remote: (input: {
+  readonly driver: string;
+  readonly id: ID;
+  /** Namespace-intrinsic default supplied or discovered by the driver. */
+  readonly defaultCwd: string;
+  readonly cwd?: string;
+}) => Identity;
+declare namespace driver_d_exports$1 {
+  export { AbsolutePath, ApiVersion, Capabilities, Definition, Driver, Module, ModuleDefinition, Name, Observed, Provisioned, Registered, Registration, RuntimeConfigBase, RuntimeInput, driver_d_exports$1 as SandboxDriver, Source, apiVersion, driver, erase, defineModule as module, withSource };
+}
 /** Version of the loadable sandbox-driver module ABI. */
 declare const apiVersion: 1;
 type ApiVersion = typeof apiVersion;
@@ -475,6 +562,7 @@ interface Registered {
   readonly stop?: (input: RuntimeInput<RuntimeConfigBase>) => Effect.Effect<Observed, SandboxProviderError>;
   readonly destroy?: (input: RuntimeInput<RuntimeConfigBase>) => Effect.Effect<void, SandboxProviderError>;
 }
+declare const erase: <CreateConfig, RuntimeConfig extends RuntimeConfigBase>(value: Driver<CreateConfig, RuntimeConfig>) => Registered;
 type Source = "core" | "builtin" | "package" | "file";
 interface Registration {
   readonly registered: Registered;
@@ -497,6 +585,8 @@ interface ModuleDefinition<Options> {
 declare const defineModule: <Options>(value: ModuleDefinition<Options>) => Module<Options>;
 /** Construct a driver and its registry contribution. */
 declare const driver: <CreateConfig, RuntimeConfig extends RuntimeConfigBase>(value: Driver<CreateConfig, RuntimeConfig>) => Driver<CreateConfig, RuntimeConfig> & Registration;
+/** Attach trusted origin metadata without changing the driver implementation. */
+declare const withSource: (registration: Registration, source: Source) => Registration;
 declare namespace instance_d_exports {
   export { ID, Info, Kind, Ownership, PersistedError, instance_d_exports as SandboxInstance, Status, Usage, fromColumn, fromField, isMountable, mountable, toColumn, toField };
 }
@@ -664,5 +754,5 @@ declare namespace shell_d_exports {
   export { ExecChunk, ExecResult, ISandboxExe, Shell$1 as Shell, ShellError, ShellOptions, fromExec, quote, quoteArgv };
 }
 //#endregion
-export { SandboxDriverNotRegisteredError as A, Layer$1 as C, SandboxCreateError as D, filesystem_d_exports as E, SandboxRegisterError as F, SandboxStopError as I, SandboxWakeError as L, SandboxMountError as M, SandboxReadError as N, SandboxDestroyError as O, SandboxRefreshError as P, Identity as S, FileSystemError as T, Name as _, driver_d_exports as a, RuntimeConfigBase as b, Status as c, AbsolutePath as d, ApiVersion as f, Module as g, Driver as h, io_d_exports as i, SandboxDriverRegistrationError as j, SandboxDriverLoadError as k, Usage as l, Definition as m, resource_d_exports as n, ID as o, Capabilities as p, error_d_exports as r, Info as s, shell_d_exports as t, instance_d_exports as u, Registered as v, Provides as w, Source as x, Registration as y };
-//# sourceMappingURL=sandbox-DnL9UPzZ.d.mts.map
+export { SandboxDriverLoadError as A, errors_d_exports as B, Current as C, io_d_exports$1 as D, Provides as E, SandboxReadError as F, FileSystemError as H, SandboxRefreshError as I, SandboxRegisterError as L, SandboxDriverRegistrationError as M, SandboxMountError as N, SandboxCreateError as O, SandboxNotFoundError as P, SandboxStopError as R, driver_d_exports$1 as S, Layer$1 as T, Service$1 as U, Shell$1 as V, filesystem_d_exports as W, Name as _, driver_d_exports as a, RuntimeConfigBase as b, Status as c, AbsolutePath as d, ApiVersion as f, Module as g, Driver as h, io_d_exports as i, SandboxDriverNotRegisteredError as j, SandboxDestroyError as k, Usage as l, Definition as m, resource_d_exports as n, ID as o, Capabilities as p, error_d_exports as r, Info as s, shell_d_exports as t, instance_d_exports as u, Registered as v, Identity as w, Source as x, Registration as y, SandboxWakeError as z };
+//# sourceMappingURL=sandbox-DX9mliQs.d.mts.map

package/{sandbox-QCmZ3UhD.mjs → sandbox-Dlz9cGeD.mjs}

@@ -1,5 +1,5 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { Context, DateTime, Effect, Option, Path, Schema, SchemaGetter } from "effect";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { Context, DateTime, Effect, Layer, Option, Path, Schema, SchemaGetter } from "effect";
 import { uuidv7 } from "uuidv7";
 import { Message } from "@codeworksh/aikit";
 import TypeBoxSchema from "typebox/schema";
@@ -40,7 +40,6 @@ const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
 * Cost greater than or equal with finite value
 */
 const NonNegativeCost = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
-Schema.String.pipe(Schema.brand("RelativePath"));
 /**
 * Absolute file path (e.g., `/home/user/projects/myapp/src/main.ts`).
 */
@@ -49,7 +48,7 @@ const AbsolutePath$1 = Schema.String.pipe(Schema.brand("AbsolutePath"));
 * Optional public JSON field that can hold explicit `undefined` on the type
 * side but encodes it as an omitted key, matching legacy `JSON.stringify`.
 */
-const optional = (schema) => Schema.optionalKey(schema).pipe(Schema.decodeTo(Schema.optional(schema), {
+const optional = (schema) => Schema.optionalKey(schema).pipe(Schema.decodeTo(Schema.optional(Schema.toType(schema)), {
 	decode: SchemaGetter.passthrough({ strict: false }),
 	encode: SchemaGetter.transformOptional(Option.filter((value) => value !== void 0))
 }));
@@ -219,6 +218,7 @@ var filesystem_exports = /* @__PURE__ */ __exportAll({
 	Service: () => Service$1,
 	fromProvider: () => fromProvider,
 	isNotFoundError: () => isNotFoundError,
+	realpathScripts: () => realpathScripts,
 	validateRmOptions: () => validateRmOptions,
 	withCwd: () => withCwd$1
 });
@@ -266,6 +266,13 @@ const isNotFoundError = (cause) => {
 	const code = cause?.code;
 	return code === "ENOENT" || code === "ENOTDIR";
 };
+/**
+* Shell forms of `realpath` for backends that only expose a process API.
+* `pwd -P` is the portable primitive: directories resolve directly, anything
+* else resolves its parent and keeps the final name as given. Run as
+* `sh -c <script> _ <path>`; try the first, fall back to the second.
+*/
+const realpathScripts = ["cd -- \"$1\" && pwd -P", "cd -- \"$(dirname -- \"$1\")\" && printf '%s/%s' \"$(pwd -P)\" \"$(basename -- \"$1\")\""];
 /** The runtime filesystem service — the live {@link Interface} for the active sandbox. */
 var Service$1 = class extends Context.Service()("@codeworksh/harness/sandbox/fs/filesystem/Service") {};
 /**
@@ -311,7 +318,8 @@ const fromProvider = (provider) => {
 		readdir: Effect.fn("SandboxFileSystem.readdir")((path) => attempt("readdir", path, () => provider.readdir(path))),
 		exists: Effect.fn("SandboxFileSystem.exists")((path) => attempt("exists", path, () => provider.exists(path))),
 		mkdir: Effect.fn("SandboxFileSystem.mkdir")((path, options) => attempt("mkdir", path, () => provider.mkdir(path, options))),
-		rm: Effect.fn("SandboxFileSystem.rm")((path, options) => validateRmOptions(options).pipe(Effect.andThen(attempt("rm", path, () => provider.rm(path, options)))))
+		rm: Effect.fn("SandboxFileSystem.rm")((path, options) => validateRmOptions(options).pipe(Effect.andThen(attempt("rm", path, () => provider.rm(path, options))))),
+		realpath: Effect.fn("SandboxFileSystem.realpath")((path) => attempt("realpath", path, () => provider.realpath(path)))
 	};
 };
 /**
@@ -333,6 +341,7 @@ const withCwd$1 = (fs, cwd) => {
 		exists: (path) => fs.exists(at(path)),
 		mkdir: (path, options) => fs.mkdir(at(path), options),
 		rm: (path, options) => fs.rm(at(path), options),
+		realpath: (path) => fs.realpath(at(path)),
 		...fs.lstat === void 0 ? {} : { lstat: (path) => fs.lstat(at(path)) }
 	};
 };
@@ -470,6 +479,34 @@ const resolveMountCwd = (defaultCwd, cwd) => {
 	if (cwd === void 0) return posix.resolve(defaultCwd);
 	return posix.isAbsolute(cwd) ? posix.resolve(cwd) : posix.resolve(defaultCwd, cwd);
 };
+/**
+* Bind a cwd-neutral transport to one mount.
+*
+* The transport underneath is shared between
+* mounts and stays rooted at the namespace root, and everything directory-shaped
+* happens here, once per mount. Two mounts of one namespace at different working
+* directories therefore coexist without seeing or moving each other's.
+*
+* It consumes the same two tags it provides — the transport is supplied by the
+* layer this is composed over, not by itself.
+*/
+const mount = (identity) => Layer.mergeAll(Layer.succeed(Current, identity), Layer.effect(Service$1, Effect.map(Service$1, (fs) => withCwd$1(fs, identity.cwd))), Layer.effect(Shell$1, Effect.map(Shell$1, (shell) => withCwd(shell, identity.cwd))));
+/**
+* The host, rooted at `cwd`. Always `SandboxInstance.ID.local`: the working
+* directory selects where relative paths resolve, it does not make a second host
+* namespace — two mounts rooted at different directories still agree on absolute
+* paths.
+*
+* The host adapter defaults to `process.cwd()`, matching the OS process it wraps.
+* This is the one namespace where that coordinate is intrinsically valid; remote
+* and virtual adapters must never inherit it.
+*/
+const host = (cwd) => ({
+	id: ID.local,
+	driver: "local",
+	kind: "local",
+	cwd: resolveMountCwd(process.cwd(), cwd)
+});
 /** Open driver identity. Adding a driver never extends a union in core. */
 const Name = Schema.String.check(Schema.isNonEmpty()).pipe(Schema.brand("SandboxDriver.Name"));
 /** A path whose coordinate system is the mounted namespace. */
@@ -513,6 +550,26 @@ const withSource = (registration, source) => ({
 });
 //#endregion
 //#region src/sandbox/errors.ts
+var errors_exports = /* @__PURE__ */ __exportAll({
+	SandboxBusyError: () => SandboxBusyError,
+	SandboxDriverLoadError: () => SandboxDriverLoadError,
+	SandboxDriverLoadPhase: () => SandboxDriverLoadPhase,
+	SandboxDriverNotRegisteredError: () => SandboxDriverNotRegisteredError,
+	SandboxDriverRegistrationError: () => SandboxDriverRegistrationError,
+	SandboxError: () => errors_exports,
+	SandboxMustBeStoppedError: () => SandboxMustBeStoppedError,
+	SandboxNotFoundError: () => SandboxNotFoundError,
+	SandboxProviderError: () => SandboxProviderError,
+	SandboxRemovedError: () => SandboxRemovedError,
+	SandboxTransitionConflictError: () => SandboxTransitionConflictError,
+	SandboxUnavailError: () => SandboxUnavailError,
+	SandboxUnsupportedError: () => SandboxUnsupportedError,
+	makeRedactor: () => makeRedactor,
+	providerError: () => providerError,
+	providerErrorCause: () => providerErrorCause,
+	providerErrorIsNotFound: () => providerErrorIsNotFound,
+	sanitizeError: () => sanitizeError
+});
 /**
 * Lifecycle errors are confined to the control plane. Once a mount succeeds,
 * consumers continue to see only FileSystemError and ShellError.
@@ -708,6 +765,6 @@ var shell_exports = /* @__PURE__ */ __exportAll({
 	quoteArgv: () => quoteArgv
 });
 //#endregion
-export { isMountable as $, FileSystem$1 as A, withCwd as B, Name as C, erase as D, driver as E, fromExec as F, withCwd$1 as G, filesystem_exports as H, perMount as I, Ownership as J, ID as K, quote as L, resolveMountCwd as M, Shell$1 as N, withSource as O, ShellError as P, instance_exports as Q, quoteArgv as R, AbsolutePath as S, defineModule as T, fromProvider as U, Service$1 as V, isNotFoundError as W, Status as X, PersistedError as Y, fromField as Z, SandboxUnsupportedError as _, io_exports as a, NonNegativeCost as at, providerErrorIsNotFound as b, SandboxDriverLoadError as c, isAikitToolCallTerminalPart as ct, SandboxMustBeStoppedError as d, validateAikitMessage as dt, toColumn as et, SandboxNotFoundError as f, validateAikitToolCallTerminalPart as ft, SandboxUnavailError as g, SandboxTransitionConflictError as h, error_exports as i, DateTimeUtcFromMillis as it, Shell as j, Current as k, SandboxDriverNotRegisteredError as l, optional as lt, SandboxRemovedError as m, withStatics as mt, Service as n, posix as nt, driver_exports as o, NonNegativeInt as ot, SandboxProviderError as p, validateAikitUserMessage as pt, Kind as q, resource_exports as r, AbsolutePath$1 as rt, SandboxBusyError as s, isAikitAssistantMessage as st, shell_exports as t, toField as tt, SandboxDriverRegistrationError as u, validateAikitAssistantMessage as ut, makeRedactor as v, RuntimeConfigBase as w, sanitizeError as x, providerError as y, resolveCwd as z };
+export { PersistedError as $, Current as A, quote as B, AbsolutePath as C, driver as D, defineModule as E, resolveMountCwd as F, filesystem_exports as G, resolveCwd as H, Shell$1 as I, realpathScripts as J, fromProvider as K, ShellError as L, Shell as M, host as N, erase as O, mount as P, Ownership as Q, fromExec as R, sanitizeError as S, RuntimeConfigBase as T, withCwd as U, quoteArgv as V, Service$1 as W, ID as X, withCwd$1 as Y, Kind as Z, SandboxUnsupportedError as _, validateAikitUserMessage as _t, io_exports as a, toField as at, providerError as b, SandboxDriverLoadError as c, DateTimeUtcFromMillis as ct, SandboxMustBeStoppedError as d, isAikitAssistantMessage as dt, Status as et, SandboxNotFoundError as f, isAikitToolCallTerminalPart as ft, SandboxUnavailError as g, validateAikitToolCallTerminalPart as gt, SandboxTransitionConflictError as h, validateAikitMessage as ht, error_exports as i, toColumn as it, FileSystem$1 as j, withSource as k, SandboxDriverNotRegisteredError as l, NonNegativeCost as lt, SandboxRemovedError as m, validateAikitAssistantMessage as mt, Service as n, instance_exports as nt, driver_exports as o, posix as ot, SandboxProviderError as p, optional as pt, isNotFoundError as q, resource_exports as r, isMountable as rt, SandboxBusyError as s, AbsolutePath$1 as st, shell_exports as t, fromField as tt, SandboxDriverRegistrationError as u, NonNegativeInt as ut, errors_exports as v, withStatics as vt, Name as w, providerErrorIsNotFound as x, makeRedactor as y, perMount as z };
 
-//# sourceMappingURL=sandbox-QCmZ3UhD.mjs.map
+//# sourceMappingURL=sandbox-Dlz9cGeD.mjs.map