@tangle-network/agent-runtime 0.103.1 → 0.105.0

package/dist/{chunk-AAN2MB2X.js → chunk-HNP72PNU.js}

@@ -5,10 +5,10 @@ import {
   definePersona,
   runPersonified,
   worktreeFanout
-} from "./chunk-3LJF5XSE.js";
+} from "./chunk-WRTOVNN4.js";
 import {
   createExecutorRegistry
-} from "./chunk-EAQ5YRRY.js";
+} from "./chunk-XBG2W2VW.js";
 import {
   runAnalystLoop
 } from "./chunk-FD2MBMOH.js";
@@ -17,9 +17,6 @@ import {
 } from "./chunk-YEJR7IXO.js";
 
 // src/loop-runner.ts
-import {
-  selfImprove
-} from "@tangle-network/agent-eval/contract";
 var DELEGATED_LOOP_MODES = ["code", "review", "research", "audit", "self-improve"];
 function isDelegatedLoopMode(value) {
   return typeof value === "string" && DELEGATED_LOOP_MODES.includes(value);
@@ -106,9 +103,6 @@ function researchLoopRunner(o) {
     return { accepted, vetoed, rounds };
   };
 }
-function selfImproveLoopRunner(options) {
-  return async () => selfImprove(options);
-}
 function auditLoopRunner(options) {
   return async () => runAnalystLoop(options);
 }
@@ -191,9 +185,8 @@ export {
   runDelegatedLoop,
   worktreeLoopRunner,
   researchLoopRunner,
-  selfImproveLoopRunner,
   auditLoopRunner,
   runLoopRunnerCli,
   parseLoopRunnerArgv
 };
-//# sourceMappingURL=chunk-AAN2MB2X.js.map
+//# sourceMappingURL=chunk-HNP72PNU.js.map

package/dist/chunk-HNP72PNU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/loop-runner.ts","../src/loop-runner-bin.ts"],"sourcesContent":["/**\n *\n * `runDelegatedLoop` — the configured delegated loop-runner.\n *\n * One typed entrypoint a worker agent (or a scheduled routine) calls to run a\n * disciplined loop in a chosen MODE, over agent-runtime's hardened engines:\n *\n *   code         → build-in-a-loop on the GENERIC recursive path (worktreeLoopRunner: author one\n *                  `AgentProfile` per harness → worktree-CLI leaves → `patchDelivered` gate)\n *   review       → caller-registered runner — a `code` runner with an approval gate over candidates\n *   research     → research-in-a-loop with valid-only KB growth (createKbGate)\n *   audit        → analyze trace/run data → findings (runAnalystLoop, caller-wired)\n *   self-improve → caller-registered `improve(profile, options)` run\n *\n * It is intentionally a thin façade: the value is that EVERY product reuses the\n * one hardened engine instead of forking delegation logic. The dispatcher owns\n * mode routing, timing, fail-loud on an unregistered mode, and a uniform result\n * shape; each mode's engine is a pre-configured runner in the registry (build it\n * with the factories below, or inject your own / a stub).\n *\n * @experimental\n */\n\nimport { runAnalystLoop } from './analyst-loop'\nimport type { RunAnalystLoopOpts, RunAnalystLoopResult } from './analyst-loop/types'\nimport { ConfigError } from './errors'\nimport { type CreateKbGateOptions, createKbGate, type FactCandidate } from './mcp/kb-gate'\nimport {\n  type AuthoredHarness,\n  type Budget,\n  createExecutorRegistry,\n  definePersona,\n  runPersonified,\n  type WinnerStrategy,\n  type WorktreeFanoutOptions,\n  type WorktreePatchArtifact,\n  worktreeFanout,\n} from './runtime'\n\n/** All valid delegated-loop mode names — used for validation and CLI surfaces. @experimental */\nexport const DELEGATED_LOOP_MODES = ['code', 'review', 'research', 'audit', 'self-improve'] as const\n\n/** @experimental */\nexport type DelegatedLoopMode = (typeof DELEGATED_LOOP_MODES)[number]\n\n/** Type guard — returns true when `value` is a valid `DelegatedLoopMode` string. @experimental */\nexport function isDelegatedLoopMode(value: unknown): value is DelegatedLoopMode {\n  return typeof value === 'string' && (DELEGATED_LOOP_MODES as readonly string[]).includes(value)\n}\n\n/** @experimental A pre-configured loop for one mode. Returns the mode's raw\n *  output; the dispatcher wraps it in a {@link DelegatedLoopResult}. */\nexport type DelegatedLoopRunner<T = unknown> = (signal: AbortSignal) => Promise<T>\n\n/** @experimental Mode → configured runner. Partial: only register the modes a\n *  given product/routine actually uses. */\nexport type DelegatedLoopRegistry = Partial<Record<DelegatedLoopMode, DelegatedLoopRunner>>\n\n/** @experimental Uniform result — never throws from a registered runner; a\n *  thrown engine becomes `{ ok: false, error }` so a routine can record + move on. */\nexport interface DelegatedLoopResult<T = unknown> {\n  mode: DelegatedLoopMode\n  ok: boolean\n  output?: T\n  error?: string\n  durationMs: number\n}\n\n/** @experimental */\nexport interface RunDelegatedLoopOptions {\n  signal?: AbortSignal\n  /** Clock override for deterministic tests. */\n  now?: () => number\n}\n\n/**\n *\n * Dispatch a configured loop by mode. Fails loud (throws `ConfigError`) when no\n * runner is registered for the mode — a routine pointed at an unwired mode is a\n * config bug, not a silent no-op. A runner that throws is captured as\n * `{ ok: false }` so unattended runs record the failure rather than crash.\n *\n * @experimental\n */\nexport async function runDelegatedLoop<T = unknown>(\n  mode: DelegatedLoopMode,\n  registry: DelegatedLoopRegistry,\n  options: RunDelegatedLoopOptions = {},\n): Promise<DelegatedLoopResult<T>> {\n  const runner = registry[mode] as DelegatedLoopRunner<T> | undefined\n  if (!runner) {\n    throw new ConfigError(\n      `runDelegatedLoop: no runner registered for mode '${mode}' (registered: ${\n        Object.keys(registry).join(', ') || 'none'\n      })`,\n    )\n  }\n  const now = options.now ?? Date.now\n  const signal = options.signal ?? new AbortController().signal\n  const start = now()\n  try {\n    const output = await runner(signal)\n    return { mode, ok: true, output, durationMs: now() - start }\n  } catch (err) {\n    return {\n      mode,\n      ok: false,\n      error: err instanceof Error ? err.message : String(err),\n      durationMs: now() - start,\n    }\n  }\n}\n\n/** @experimental Options for the local-repo `code` runner over the GENERIC recursive path. */\nexport interface WorktreeLoopRunnerOptions {\n  /** Absolute path to the local git checkout each worktree is cut from. */\n  repoRoot: string\n  /** The instruction handed to every authored harness (composed under each profile's systemPrompt). */\n  taskPrompt: string\n  /** The supervisor-authored harness profiles — one fanout item (one worktree-CLI leaf) each. */\n  harnesses: ReadonlyArray<AuthoredHarness>\n  /** Conserved budget pool bounding the fanout (equal-k holds by construction). */\n  budget: Budget\n  /** Shell command run in each worktree to derive the tests-PASS signal. */\n  testCmd?: string\n  /** Shell command run in each worktree to derive the typecheck-PASS signal. */\n  typecheckCmd?: string\n  /** Which verification signals the deliverable REQUIRES present-and-passing (default none). */\n  require?: ReadonlyArray<'tests' | 'typecheck'>\n  /** Diff-size cap (lines). */\n  maxDiffLines?: number\n  /** Literal path prefixes the patch must not touch (the secret-floor is always on regardless). */\n  forbiddenPaths?: string[]\n  /** Winner-selection strategy among gated candidates. Default `highest-score`. */\n  winnerStrategy?: WinnerStrategy\n  /** Test seams forwarded to the worktree-CLI leaves so the runner drives offline. */\n  runGit?: WorktreeFanoutOptions['runGit']\n  runHarness?: WorktreeFanoutOptions['runHarness']\n  runCommand?: WorktreeFanoutOptions['runCommand']\n}\n\n/**\n *\n * `code` mode on the GENERIC recursive path: author one `AgentProfile` per harness, run them as a\n * `worktreeFanout` (N `createWorktreeCliExecutor` leaves, each `gateOnDeliverable`) through\n * `runPersonified` on the keystone Supervisor. The sandbox-session counterpart that drives the in-box\n * harness over a `SandboxClient` is `detachedSessionDelegate` (`./mcp/delegates`); here there is no\n * `runAgentRounds` driver, no role-coupled delegate — the harness list is the fanout, the gate is\n * `patchDelivered`,\n * the winner is the shared valid-only selector (NOT `defaultSelectWinner`, whose non-valid fallback\n * would surface an ungated patch). Equal-k holds by the conserved budget pool. Returns the winning\n * patch artifact, or throws when no candidate is delivered (fail loud, never a vacuous done).\n *\n * @experimental\n */\nexport function worktreeLoopRunner(\n  options: WorktreeLoopRunnerOptions,\n): DelegatedLoopRunner<WorktreePatchArtifact> {\n  const shape = worktreeFanout<string>({\n    repoRoot: options.repoRoot,\n    taskPrompt: options.taskPrompt,\n    harnesses: options.harnesses,\n    ...(options.testCmd !== undefined ? { testCmd: options.testCmd } : {}),\n    ...(options.typecheckCmd !== undefined ? { typecheckCmd: options.typecheckCmd } : {}),\n    ...(options.require !== undefined ? { require: options.require } : {}),\n    ...(options.maxDiffLines !== undefined ? { maxDiffLines: options.maxDiffLines } : {}),\n    ...(options.forbiddenPaths !== undefined ? { forbiddenPaths: options.forbiddenPaths } : {}),\n    ...(options.winnerStrategy !== undefined ? { winnerStrategy: options.winnerStrategy } : {}),\n    ...(options.runGit ? { runGit: options.runGit } : {}),\n    ...(options.runHarness ? { runHarness: options.runHarness } : {}),\n    ...(options.runCommand ? { runCommand: options.runCommand } : {}),\n  })\n  // The persona's only role here is to carry the fanout shape onto the Supervisor; each item's\n  // executor is BYO (the gated worktree-CLI leaf), so the registry only needs to pass BYO through.\n  const persona = definePersona<WorktreePatchArtifact>({\n    name: 'worktree-coder',\n    root: { profile: { name: 'worktree-coder' }, harness: null },\n    directive: 'deliver a minimal validated patch on a fresh worktree',\n    context: { role: 'coder' },\n    executors: { registry: createExecutorRegistry() },\n  })\n  return async (signal) => {\n    const result = await runPersonified<string, WorktreePatchArtifact>({\n      persona,\n      shape,\n      task: options.taskPrompt,\n      budget: options.budget,\n      signal,\n    })\n    if (result.kind !== 'winner' || result.out.kind !== 'done') {\n      const blockers =\n        result.kind === 'winner' && result.out.kind === 'blocked'\n          ? result.out.blockers.join('; ')\n          : `supervisor settled ${result.kind}`\n      throw new Error(`worktreeLoopRunner: no delivered patch (${blockers})`)\n    }\n    return result.out.deliverable\n  }\n}\n\n/** @experimental A fact rejected at the KB gate — surfaced, never dropped. */\nexport interface VetoedFact {\n  candidate: FactCandidate\n  vetoedBy?: string\n  reason?: string\n}\n\n/** @experimental */\nexport interface ResearchLoopResult {\n  /** Facts that passed the fail-closed gate — safe to write to the KB. */\n  accepted: FactCandidate[]\n  /** Facts the gate vetoed in the final round — escalate, do not silently drop. */\n  vetoed: VetoedFact[]\n  /** Research rounds actually run. */\n  rounds: number\n}\n\n/** @experimental Options for the default `research` runner. */\nexport interface ResearchLoopRunnerOptions {\n  /**\n   * The research engine (the consumer's web/doc searcher + extractor). Called\n   * each round with the prior round's vetoes so it can re-research the gaps.\n   * Returns fact candidates carrying their grounding (`verbatimPassage` +\n   * `sourceText`).\n   */\n  research: (round: number, vetoed: VetoedFact[]) => Promise<FactCandidate[]>\n  /** Gate config (extra judges, self-artifact kinds, …). The floor is always on. */\n  gate?: CreateKbGateOptions\n  /** Max research rounds (correct-on-veto remediation). Default 1. */\n  maxRounds?: number\n}\n\n/**\n * `research` mode — research-in-a-loop with valid-only KB growth.\n *\n * Each round: research → gate every candidate (fail-closed; passage MUST be in\n * the source) → accept the clean ones → re-research the vetoed ones next round,\n * up to `maxRounds`. Vetoed facts in the final round are RETURNED (escalate,\n * never silently dropped) so the caller audits vs retries.\n *\n * @experimental\n */\nexport function researchLoopRunner(\n  o: ResearchLoopRunnerOptions,\n): DelegatedLoopRunner<ResearchLoopResult> {\n  const gate = createKbGate(o.gate)\n  const maxRounds = Math.max(1, Math.trunc(o.maxRounds ?? 1))\n  return async (signal) => {\n    const accepted: FactCandidate[] = []\n    let vetoed: VetoedFact[] = []\n    let rounds = 0\n    for (let round = 0; round < maxRounds; round += 1) {\n      if (signal.aborted) break\n      rounds += 1\n      const candidates = await o.research(round, vetoed)\n      if (candidates.length === 0) break\n      vetoed = []\n      for (const c of candidates) {\n        const v = await gate(c)\n        if (v.accepted) accepted.push(c)\n        else vetoed.push({ candidate: c, vetoedBy: v.vetoedBy, reason: v.reason })\n      }\n      if (vetoed.length === 0) break\n    }\n    return { accepted, vetoed, rounds }\n  }\n}\n\n/**\n * `audit` mode — analyst loop over captured trace/run data.\n *\n * @experimental\n */\nexport function auditLoopRunner<TProposal = unknown, TEdit = unknown>(\n  options: RunAnalystLoopOpts,\n): DelegatedLoopRunner<RunAnalystLoopResult<TProposal, TEdit>> {\n  return async () => runAnalystLoop<TProposal, TEdit>(options)\n}\n","#!/usr/bin/env node\n/**\n *\n * `agent-runtime-loop` — the schedulable entrypoint for the configured\n * delegated loop-runner. A cron job / routine / Makefile target invokes:\n *\n *   agent-runtime-loop --mode research --config ./loops.config.js\n *\n * The config module wires the registry (with full access to env / creds —\n * which is why the deps live there, not in this generic bin). It must default-\n * export a `DelegatedLoopRegistry`, or a `() => DelegatedLoopRegistry | Promise<…>`.\n * The bin runs the selected mode, prints the `DelegatedLoopResult` as JSON, and\n * exits 0 on `ok`, 1 on a recorded failure, 2 on a usage/config error.\n *\n * @experimental\n */\n\nimport {\n  DELEGATED_LOOP_MODES,\n  type DelegatedLoopMode,\n  type DelegatedLoopRegistry,\n  type DelegatedLoopResult,\n  isDelegatedLoopMode,\n  runDelegatedLoop,\n} from './loop-runner'\n\n/** @experimental Parsed CLI invocation. */\nexport interface LoopRunnerCliArgs {\n  mode: string\n  /** Loads the registry — the bin wires this from `--config`; tests inject a stub. */\n  loadRegistry: () => Promise<DelegatedLoopRegistry> | DelegatedLoopRegistry\n  now?: () => number\n}\n\n/** @experimental */\nexport interface LoopRunnerCliResult {\n  exitCode: number\n  result?: DelegatedLoopResult\n  error?: string\n}\n\n/**\n *\n * Pure CLI core (no process / argv / IO) so it's unit-testable: validate the\n * mode, load the registry, dispatch, map to an exit code (0 ok / 1 failed /\n * 2 usage). Exported for embedding in custom runners + tests.\n *\n * @experimental\n */\nexport async function runLoopRunnerCli(args: LoopRunnerCliArgs): Promise<LoopRunnerCliResult> {\n  if (!isDelegatedLoopMode(args.mode)) {\n    return {\n      exitCode: 2,\n      error: `unknown mode '${args.mode}' (expected one of: ${DELEGATED_LOOP_MODES.join(', ')})`,\n    }\n  }\n  let registry: DelegatedLoopRegistry\n  try {\n    registry = await args.loadRegistry()\n  } catch (err) {\n    return { exitCode: 2, error: `failed to load registry: ${errMsg(err)}` }\n  }\n  if (!registry[args.mode]) {\n    return {\n      exitCode: 2,\n      error: `config registers no runner for mode '${args.mode}' (registered: ${\n        Object.keys(registry).join(', ') || 'none'\n      })`,\n    }\n  }\n  // runDelegatedLoop throws only on a missing runner (guarded above); a failing\n  // engine is captured as { ok: false } → exit 1, not a crash.\n  const result = await runDelegatedLoop(args.mode as DelegatedLoopMode, registry, {\n    ...(args.now ? { now: args.now } : {}),\n  })\n  return { exitCode: result.ok ? 0 : 1, result }\n}\n\n/** Parse `--mode X --config Y` from an argv tail (`process.argv.slice(2)`). */\nexport function parseLoopRunnerArgv(argv: string[]): { mode?: string; config?: string } {\n  const out: { mode?: string; config?: string } = {}\n  for (let i = 0; i < argv.length; i += 1) {\n    const a = argv[i]\n    if (a === '--mode') out.mode = argv[++i]\n    else if (a === '--config') out.config = argv[++i]\n    else if (a?.startsWith('--mode=')) out.mode = a.slice('--mode='.length)\n    else if (a?.startsWith('--config=')) out.config = a.slice('--config='.length)\n  }\n  return out\n}\n\n/** Normalize a config module's default export → a registry. */\nfunction resolveRegistry(mod: unknown): DelegatedLoopRegistry {\n  const def = (mod as { default?: unknown })?.default ?? mod\n  const value = typeof def === 'function' ? (def as () => unknown)() : def\n  return value as DelegatedLoopRegistry\n}\n\nfunction errMsg(err: unknown): string {\n  return err instanceof Error ? err.message : String(err)\n}\n\n/** The argv → IO → exit shell. Kept thin; logic lives in `runLoopRunnerCli`. */\nasync function main(): Promise<void> {\n  const { mode, config } = parseLoopRunnerArgv(process.argv.slice(2))\n  if (!mode || !config) {\n    process.stderr.write(\n      'usage: agent-runtime-loop --mode <mode> --config <module>\\n' +\n        `  modes: ${DELEGATED_LOOP_MODES.join(' | ')}\\n` +\n        '  config: a JS/TS module default-exporting a DelegatedLoopRegistry (or a factory)\\n',\n    )\n    process.exit(2)\n  }\n  const { pathToFileURL } = await import('node:url')\n  const { resolve } = await import('node:path')\n  const cli = await runLoopRunnerCli({\n    mode,\n    loadRegistry: async () => resolveRegistry(await import(pathToFileURL(resolve(config)).href)),\n  })\n  process.stdout.write(`${JSON.stringify(cli.result ?? { error: cli.error }, null, 2)}\\n`)\n  if (cli.error) process.stderr.write(`${cli.error}\\n`)\n  process.exit(cli.exitCode)\n}\n\n// Run only when executed as the bin — never when imported for the testable\n// core, and never when bundled into a runtime that has no `process.argv`\n// (e.g. Cloudflare Workers, where `process` is a shim without `argv`). Reading\n// `process.argv[1]` directly would throw at module load there; `process.argv?.`\n// keeps the guard a no-op instead of crashing the Worker on startup.\nconst invokedScript = typeof process !== 'undefined' ? process.argv?.[1] : undefined\nif (invokedScript && /loop-runner-bin\\.(js|ts|mjs)$/.test(invokedScript)) {\n  void main()\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-M6MD6JBS.js → chunk-KRBFHMV6.js}

@@ -2,6 +2,433 @@ import {
   zeroTokenUsage
 } from "./chunk-3MDZX7YU.js";
 
+// src/runtime/tangle-sandbox-exact-process-provider.ts
+import { isDeepStrictEqual } from "util";
+var exactProcessProviderMarker = "agent-runtime.exact-process-provider";
+var exactProcessEgressMarker = "agent-runtime.exact-process-egress";
+function createTangleSandboxExactProcessProvider(client, options = {}) {
+  const name = options.name ?? "tangle-sandbox-exact-process";
+  if (!name.trim()) throw new Error("Tangle Sandbox exact-process provider name must not be empty");
+  const exactProcess = {
+    async create(input) {
+      throwIfAborted(input.signal);
+      assertNoProviderOptions(input.providerOptions);
+      const egressPolicy = sandboxEgressPolicy(input.egress);
+      const metadata = exactMetadata(input.metadata, name, egressPolicy);
+      const sandbox = await client.create(
+        {
+          image: requiredText(input.image, "exact-process image"),
+          agent: false,
+          bare: false,
+          publicEdge: false,
+          ephemeral: true,
+          egressPolicy,
+          resources: sandboxResources(input),
+          maxLifetimeSeconds: sandboxLifetimeSeconds(input.maxLifetimeMs),
+          metadata,
+          idempotencyKey: requiredText(input.idempotencyKey, "exact-process idempotency key")
+        },
+        {
+          ...input.provisionTimeoutMs === void 0 ? {} : { timeoutMs: positiveInteger(input.provisionTimeoutMs, "provision timeout") },
+          ...input.signal === void 0 ? {} : { signal: input.signal }
+        }
+      );
+      try {
+        throwIfAborted(input.signal);
+        assertExactSandboxMetadata(sandbox, metadata);
+        await assertExactSandboxEgress(sandbox, egressPolicy);
+      } catch (error) {
+        await discardInvalidSandbox(sandbox, error);
+      }
+      return sandboxAsExactProcessEnvironment(sandbox, name);
+    },
+    async get(id) {
+      const sandbox = await client.get(id);
+      if (!sandbox || !isExactSandbox(sandbox, name)) return null;
+      await assertExactSandboxEgress(sandbox, egressFromMetadata(sandbox.metadata));
+      return sandboxAsExactProcessEnvironment(sandbox, name);
+    },
+    async list(query) {
+      assertNoProviderOptions(query?.providerOptions);
+      const sandboxes = await client.list();
+      return Promise.all(
+        sandboxes.filter((sandbox) => isExactSandbox(sandbox, name)).filter((sandbox) => metadataMatches(sandbox.metadata, query?.metadata)).map(async (sandbox) => {
+          await assertExactSandboxEgress(sandbox, egressFromMetadata(sandbox.metadata));
+          return sandboxAsExactProcessEnvironment(sandbox, name);
+        })
+      );
+    }
+  };
+  return {
+    name,
+    exactProcess,
+    capabilities: exactProcessOnlyCapabilities,
+    async create() {
+      throw new Error(`agent environment provider "${name}" supports exactProcess.create() only`);
+    }
+  };
+}
+function sandboxAsExactProcessEnvironment(sandbox, provider) {
+  return {
+    id: requiredText(sandbox.id, "Sandbox id"),
+    provider,
+    ...sandbox.metadata ? { metadata: sandbox.metadata } : {},
+    process: {
+      async list() {
+        return (await sandbox.process.list()).map((status) => exactProcessStatus(status));
+      },
+      async get(pid) {
+        const process = await sandbox.process.get(pid);
+        return process ? sandboxProcessAsExactProcess(process) : null;
+      },
+      async spawn(input, options) {
+        const process = await afterAbortCheck(
+          options?.signal,
+          () => sandbox.process.spawnExact(input.executable, [...input.args], {
+            cwd: input.cwd,
+            env: { ...input.env },
+            inheritEnv: false,
+            ...input.stdin === void 0 ? {} : { stdin: input.stdin },
+            timeoutMs: input.timeoutMs
+          })
+        );
+        return sandboxProcessAsExactProcess(process);
+      }
+    },
+    async writeFile(path, bytes, options) {
+      if (sandbox.fs.supportsWriteMode !== true) {
+        throw new Error("Tangle Sandbox does not declare exact file-mode support");
+      }
+      await afterAbortCheck(
+        options.signal,
+        () => sandbox.fs.write(path, Buffer.from(bytes).toString("base64"), {
+          encoding: "base64",
+          mode: fileMode(options.mode)
+        })
+      );
+    },
+    async readFile(path, options) {
+      const maxBytes = nonnegativeInteger(options.maxBytes, "exact-process file read maximum");
+      const initialSize = nonnegativeInteger(
+        (await afterAbortCheck(options.signal, () => sandbox.fs.stat(path))).size,
+        `Tangle Sandbox file size for "${path}"`
+      );
+      if (initialSize > maxBytes) {
+        throw new Error(
+          `Tangle Sandbox file "${path}" exceeds the ${maxBytes}-byte exact read maximum`
+        );
+      }
+      const result = await afterAbortCheck(
+        options.signal,
+        () => sandbox.fs.readBatch([path], { encoding: "base64" })
+      );
+      const failure = result.errors.find((entry) => entry.path === path);
+      if (failure) {
+        throw new Error(`Tangle Sandbox failed to read "${path}": ${failure.error}`);
+      }
+      const files = result.files.filter((entry) => entry.path === path);
+      if (files.length !== 1) {
+        throw new Error(`Tangle Sandbox returned ${files.length} files for exact read "${path}"`);
+      }
+      const file = files[0];
+      if (file.encoding !== "base64") {
+        throw new Error(`Tangle Sandbox returned non-binary content for exact read "${path}"`);
+      }
+      const size = nonnegativeInteger(file.size, `Tangle Sandbox file size for "${path}"`);
+      if (size !== initialSize) {
+        throw new Error(`Tangle Sandbox file "${path}" changed during exact read`);
+      }
+      if (size > maxBytes) {
+        throw new Error(
+          `Tangle Sandbox file "${path}" exceeds the ${maxBytes}-byte exact read maximum`
+        );
+      }
+      const bytes = Buffer.from(file.content, "base64");
+      if (bytes.byteLength !== size || bytes.toString("base64") !== file.content) {
+        throw new Error(
+          `Tangle Sandbox returned an invalid binary payload for exact read "${path}"`
+        );
+      }
+      return Uint8Array.from(bytes);
+    },
+    async destroy() {
+      await sandbox.delete();
+    }
+  };
+}
+function sandboxProcessAsExactProcess(process) {
+  const pid = positiveInteger(process.pid, "Tangle Sandbox process pid");
+  return {
+    pid,
+    async status() {
+      return exactProcessStatus(await process.status(), pid);
+    },
+    async wait() {
+      const waitExitCode = await process.wait();
+      if (!Number.isSafeInteger(waitExitCode)) {
+        throw new Error("Tangle Sandbox process wait returned an invalid exit code");
+      }
+      const status = exactProcessStatus(await process.status(), pid);
+      if (status.running || !status.termination) {
+        throw new Error("Tangle Sandbox process wait returned before terminal status");
+      }
+      if (status.termination.kind === "exit" && status.termination.exitCode !== waitExitCode) {
+        throw new Error("Tangle Sandbox process wait and status disagree on exit code");
+      }
+      return status.termination;
+    },
+    async kill() {
+      await process.kill("SIGKILL", { tree: true });
+    },
+    async *stdout() {
+      yield* process.stdout();
+    },
+    async *stderr() {
+      yield* process.stderr();
+    }
+  };
+}
+function exactProcessStatus(status, expectedPid) {
+  const pid = positiveInteger(status.pid, "Tangle Sandbox process pid");
+  if (expectedPid !== void 0 && pid !== expectedPid) {
+    throw new Error("Tangle Sandbox process status changed process identity");
+  }
+  if (typeof status.running !== "boolean") {
+    throw new Error("Tangle Sandbox process status is missing running state");
+  }
+  if (!Number.isSafeInteger(status.exitCode)) {
+    throw new Error("Tangle Sandbox process status is missing an integer exit code");
+  }
+  const exitSignal = optionalText(status.exitSignal, "Tangle Sandbox process exit signal");
+  if (status.running) {
+    if (status.exitCode !== -1) {
+      throw new Error("Tangle Sandbox running process must report exit code -1");
+    }
+    if (exitSignal) {
+      throw new Error("Tangle Sandbox running process must not report an exit signal");
+    }
+    return {
+      pid,
+      running: true,
+      exitCode: -1
+    };
+  }
+  const termination = exitSignal ? { kind: "signal", signal: exitSignal } : status.exitCode >= 0 ? { kind: "exit", exitCode: status.exitCode } : void 0;
+  if (!termination) {
+    throw new Error("Tangle Sandbox stopped process has no terminal reason");
+  }
+  return {
+    pid,
+    running: false,
+    exitCode: status.exitCode,
+    ...exitSignal ? { exitSignal } : {},
+    termination
+  };
+}
+function exactMetadata(metadata, provider, egressPolicy) {
+  for (const marker of [exactProcessProviderMarker, exactProcessEgressMarker]) {
+    if (Object.hasOwn(metadata, marker)) {
+      throw new Error(`exact-process metadata must not set "${marker}"`);
+    }
+  }
+  return {
+    ...metadata,
+    [exactProcessProviderMarker]: provider,
+    [exactProcessEgressMarker]: serializeEgressPolicy(egressPolicy)
+  };
+}
+function isExactSandbox(sandbox, provider) {
+  return sandbox.metadata?.[exactProcessProviderMarker] === provider;
+}
+function metadataMatches(metadata, expected) {
+  return expected === void 0 || Object.entries(expected).every(([key, value]) => isDeepStrictEqual(metadata?.[key], value));
+}
+function assertExactSandboxMetadata(sandbox, expected) {
+  if (!metadataMatches(sandbox.metadata, expected)) {
+    throw new Error("Tangle Sandbox did not persist exact-process metadata");
+  }
+}
+function egressFromMetadata(metadata) {
+  const encoded = metadata?.[exactProcessEgressMarker];
+  if (typeof encoded !== "string") {
+    throw new Error("Tangle Sandbox exact-process environment is missing egress metadata");
+  }
+  try {
+    const parsed = JSON.parse(encoded);
+    if (!parsed || typeof parsed !== "object") throw new Error("expected egress object");
+    const policy = parsed;
+    if (policy.mode === "blocked" && policy.allowDomains === void 0) return { mode: "blocked" };
+    if (policy.mode === "strict" && policy.includeImplicitDomains === false && Array.isArray(policy.allowDomains) && policy.allowDomains.every((domain) => typeof domain === "string")) {
+      const allowDomains = sortedDomains(policy.allowDomains);
+      if (new Set(allowDomains).size === allowDomains.length) {
+        return { mode: "strict", allowDomains, includeImplicitDomains: false };
+      }
+    }
+  } catch {
+    throw new Error("Tangle Sandbox exact-process environment has invalid egress metadata");
+  }
+  throw new Error("Tangle Sandbox exact-process environment has invalid egress metadata");
+}
+async function assertExactSandboxEgress(sandbox, expected) {
+  const actual = (await sandbox.egress.get()).policy;
+  if (actual.mode !== expected.mode) {
+    throw new Error(
+      `Tangle Sandbox egress mismatch: expected ${expected.mode}, received ${actual.mode}`
+    );
+  }
+  if (expected.mode === "blocked") {
+    const allowDomains = actual.allowDomains;
+    if (actual.mode === "blocked" && (allowDomains === void 0 || Array.isArray(allowDomains) && allowDomains.length === 0)) {
+      return;
+    }
+    throw new Error("Tangle Sandbox blocked egress retained an allowlist");
+  }
+  if (actual.mode !== "strict") {
+    throw new Error("Tangle Sandbox did not return strict egress policy");
+  }
+  const expectedDomains = sortedDomains(expected.allowDomains);
+  const actualDomains = sortedDomains(actual.allowDomains ?? []);
+  if (!isDeepStrictEqual(actualDomains, expectedDomains)) {
+    throw new Error("Tangle Sandbox strict egress differs from the exact allowlist");
+  }
+  if (actual.includeImplicitDomains !== false) {
+    throw new Error("Tangle Sandbox strict egress retained implicit domains");
+  }
+}
+function sandboxEgressPolicy(input) {
+  if (input.mode === "blocked") return { mode: "blocked" };
+  const allowDomains = input.allowDomains.map(
+    (domain) => requiredText(domain, "strict egress domain")
+  );
+  if (new Set(allowDomains).size !== allowDomains.length) {
+    throw new Error("strict egress domains must not contain duplicates");
+  }
+  return { mode: "strict", allowDomains, includeImplicitDomains: false };
+}
+function serializeEgressPolicy(policy) {
+  return JSON.stringify(
+    policy.mode === "blocked" ? { mode: "blocked" } : {
+      mode: "strict",
+      allowDomains: sortedDomains(policy.allowDomains),
+      includeImplicitDomains: false
+    }
+  );
+}
+function sandboxResources(input) {
+  const cpuCores = positiveNumber(input.resources.cpu, "exact-process cpu");
+  const memoryMB = positiveInteger(input.resources.memoryMb, "exact-process memory");
+  const diskMb = positiveInteger(input.resources.diskMb, "exact-process disk");
+  if (diskMb % 1024 !== 0) {
+    throw new Error("Tangle Sandbox exact-process disk must be a whole GiB");
+  }
+  return { cpuCores, memoryMB, diskGB: diskMb / 1024 };
+}
+function sandboxLifetimeSeconds(maxLifetimeMs) {
+  const milliseconds = positiveInteger(maxLifetimeMs, "exact-process maximum lifetime");
+  if (milliseconds % 1e3 !== 0) {
+    throw new Error(
+      "Tangle Sandbox exact-process maximum lifetime must be a whole number of seconds"
+    );
+  }
+  return milliseconds / 1e3;
+}
+function fileMode(value) {
+  const mode = nonnegativeInteger(value, "exact-process file mode");
+  if (mode > 4095) throw new Error("exact-process file mode exceeds POSIX mode bits");
+  return mode;
+}
+function assertNoProviderOptions(providerOptions) {
+  if (providerOptions && Object.keys(providerOptions).length > 0) {
+    throw new Error("Tangle Sandbox exact-process provider does not accept providerOptions");
+  }
+}
+function exactProcessOnlyCapabilities() {
+  return {
+    profile: {
+      namedProfiles: false,
+      systemPrompt: false,
+      instructions: false,
+      tools: false,
+      permissions: false,
+      mcp: false,
+      subagents: false,
+      resources: {
+        files: false,
+        instructions: false,
+        tools: false,
+        skills: false,
+        agents: false,
+        commands: false
+      },
+      hooks: false,
+      modes: false,
+      runtimeUpdate: false,
+      validation: false
+    },
+    streaming: { live: false, replay: false, detach: false, turnIdempotency: false },
+    sessions: { continue: false, list: false, messages: false },
+    workspace: {
+      read: false,
+      write: false,
+      exec: false,
+      git: false,
+      upload: false,
+      download: false
+    },
+    branching: { checkpoint: false, fork: false },
+    placement: false,
+    usage: false,
+    confidential: false,
+    exactProcess: { egress: ["blocked", "strict"] }
+  };
+}
+async function discardInvalidSandbox(sandbox, cause) {
+  try {
+    await sandbox.delete();
+  } catch (destroyError) {
+    throw new AggregateError(
+      [cause, destroyError],
+      "Tangle Sandbox exact-process creation failed and cleanup failed"
+    );
+  }
+  throw cause;
+}
+function sortedDomains(domains) {
+  return [...domains].sort((left, right) => left.localeCompare(right));
+}
+function requiredText(value, label) {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`${label} must be a non-empty string`);
+  return value;
+}
+function optionalText(value, label) {
+  if (value === void 0) return void 0;
+  return requiredText(value, label);
+}
+function positiveNumber(value, label) {
+  if (!Number.isFinite(value) || value <= 0) throw new Error(`${label} must be positive`);
+  return value;
+}
+function positiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new Error(`${label} must be a positive integer`);
+  return value;
+}
+function nonnegativeInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new Error(`${label} must be a non-negative integer`);
+  return value;
+}
+function throwIfAborted(signal) {
+  signal?.throwIfAborted();
+}
+async function afterAbortCheck(signal, operation) {
+  throwIfAborted(signal);
+  const result = await operation();
+  throwIfAborted(signal);
+  return result;
+}
+
 // src/runtime/environment-provider.ts
 var ValidationError = class extends Error {
   constructor(message, options) {
@@ -791,10 +1218,11 @@ function hasExec(box) {
 }
 
 export {
+  createTangleSandboxExactProcessProvider,
   createAgentEnvironmentProviderRegistry,
   resolveAgentEnvironmentProvider,
   providerAsSandboxClient,
   sandboxClientAsProvider,
   providerAsExecutor
 };
-//# sourceMappingURL=chunk-M6MD6JBS.js.map
+//# sourceMappingURL=chunk-KRBFHMV6.js.map