brass-runtime 1.16.0 → 1.16.1

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## 1.14.0 - First Public Release Candidate
+
+- Added mature core runtime features: structured concurrency, `Cause`,
+  interruptibility, `FiberRef`, Layer 2.0, Schedule 2.0, TestRuntime, streams,
+  and runtime observability.
+- Added HTTP client/server surface with schema validation, lifecycle
+  middleware, adaptive limiter, retry, compression, health/readiness, and
+  observability hooks.
+- Added `brass-runtime/perf` with runtime A/B, soak profiling, HTTP memory lab,
+  benchmark budgets, and local perf history/baseline storage.
+- Added DX helpers: `runPromise`, `runExit`, `makeRuntime`, `defineService`,
+  `getService`, `provide`, `formatLayerError`, `formatConfigError`, and
+  `HttpServer`.
+- Added first-release recipes under `docs/recipes/` and release validation via
+  `npm run release:check`.

package/README.md

@@ -1,6 +1,7 @@
 # brass-runtime
 
-A ZIO-inspired effect runtime for TypeScript with structured concurrency, pull-based streams, and a production-grade HTTP client.
+A ZIO-inspired effect runtime for TypeScript with structured concurrency,
+runtime diagnostics, pull-based streams, and a production-grade HTTP client.
 
 Built without `Promise`/`async`/`await` as the primary semantic primitive. Effects are values — lazy, composable, and cancelable by default.
 
@@ -12,19 +13,27 @@ npm i brass-runtime
 
 ## What it does
 
-**Core runtime** — algebraic effects, fibers, scopes, scheduler, layers, semaphores, circuit breakers, metrics, tracing.
+**Runtime** — algebraic effects, fibers, scopes, scheduler, interruptibility
+regions, fiber-local refs, typed layers, semaphores, circuit breakers, rich
+`Cause<E>` failures, metrics, tracing, and an opt-in flight recorder.
 
-**Streams** — pull-based with backpressure, bounded buffers, queues, hubs, pipelines, fusion optimization.
+**Streams** — pull-based streams with backpressure, bounded buffers, hubs,
+pipelines, fusion optimization, and a small fluent DX facade.
 
-**HTTP client** — lazy/cancelable requests with a full middleware pipeline: adaptive concurrency, compression, batching, connection pre-warming, caching, deduplication, priority scheduling, and retry with backoff.
+**HTTP** — lazy/cancelable client and server primitives with typed routing,
+schema validation, health/readiness probes, adaptive concurrency, compression,
+batching, prewarm, cache, dedup, priority, retry, and observability.
 
-**Schema validation** — dependency-free runtime schemas for JSON, config, and protocol boundaries, with typed inference and path-rich validation issues.
+**Production signals** — dependency-free schemas, Prometheus/OTLP exporters,
+structured logs, W3C trace propagation, sampling, redaction, bounded exporters,
+and explicit flush/shutdown.
 
-**Observability export** — Prometheus metrics, OTLP metrics/traces/logs, structured logging, W3C trace-context propagation, request adapters, sampling, redaction, bounded exporters, and production flush/shutdown controls.
+**Performance profiler** — runtime primitives, HTTP layer comparison, memory
+retention reports, observability overhead, CLI/JSON output, and actionable
+recommendations.
 
-**WASM engine** — optional Rust/WASM-backed state machines for strict scheduling and bounded queues.
-
-**Brass Agent** — experimental CLI coding agent with workspace inspection, LLM integration, and VS Code extension.
+**Optional engine and tools** — Rust/WASM-backed state machines plus the
+experimental Brass Agent CLI/VS Code workflow.
 
 ---
 
@@ -43,12 +52,86 @@ npm i brass-runtime
 ### Run an effect
 
 ```ts
-import { Runtime, succeed } from "brass-runtime";
+import { runPromise, succeed } from "brass-runtime";
+
+const value = await runPromise(succeed(42));
+```
+
+Use `makeRuntime` when you want explicit runtime options, and `runExit` when
+you want the full `Exit`/`Cause` instead of a rejected promise.
+
+### Inspect failure causes
+
+```ts
+import { Cause, formatCause } from "brass-runtime";
+
+const cause = Cause.then(
+  Cause.fail("database unavailable"),
+  Cause.both(Cause.interrupt(), Cause.die(new Error("release failed"))),
+);
+
+console.log(formatCause(cause));
+```
+
+`Cause<E>` preserves typed failures, defects, interruptions, and sequential or
+parallel composition (`Then` / `Both`) so diagnostics can explain what happened
+without flattening every failure into a single thrown value.
+
+### Mask interruption
+
+```ts
+import { async, flatMap, succeed, uninterruptibleMask } from "brass-runtime";
+
+const effect = uninterruptibleMask((restore) =>
+  flatMap(succeed("acquired"), (resource) =>
+    restore(async((_env, cb) => {
+      setTimeout(() => cb({ _tag: "Success", value: `used:${resource}` }), 10);
+    })),
+  ),
+);
+```
+
+Use `uninterruptible(effect)` for critical regions and
+`uninterruptibleMask((restore) => ...)` when only part of the region should be
+interruptible again. Pending interruption is deferred until the protected region
+exits; restored sub-effects remain cancelable.
+
+### Fiber-local context
+
+```ts
+import { Runtime, makeFiberRef } from "brass-runtime";
 
+const requestId = makeFiberRef("anonymous");
 const runtime = Runtime.make({});
-const value = await runtime.toPromise(succeed(42));
+
+const result = await runtime.toPromise(
+  requestId.locally("req-123", requestId.get()),
+);
+```
+
+`FiberRef` values are local to the running fiber, inherited by child fibers at
+fork time, isolated from child mutations, and restored after `locally` regions
+even when the region fails or is interrupted.
+
+### Explain runtime behavior
+
+```ts
+import { Runtime, async, makeRuntimeRecorder } from "brass-runtime";
+
+const recorder = makeRuntimeRecorder({ maxEvents: 5000 });
+const runtime = new Runtime({ env: {}, hooks: recorder.hooks });
+
+await runtime.toPromise(async((_env, cb) => {
+  setTimeout(() => cb({ _tag: "Success", value: "ok" }), 10);
+}));
+
+console.log(recorder.explain());
 ```
 
+The flight recorder is opt-in and keeps a bounded ring buffer of runtime events:
+fiber start/end/suspend/resume, scopes, supervisor events, logs, spans, and
+trace context when available.
+
 ### Recommended HTTP client
 
 ```ts
@@ -75,8 +158,10 @@ console.log(http.compression?.stats());
 `makeDefaultHttpClient` is the batteries-included entrypoint: timeout,
 deduplication, priority scheduling, retry, adaptive concurrency, safe-method
 response cache, decompression, stats, `cancelAll`, and JSON/text helpers. Use
+`preset: "production"` when you want that production-ready shape explicitly,
 `preset: "balanced"` to skip the default cache, or `preset: "minimal"` for a
-cheap wire client with the same helper API.
+cheap wire client with the same helper API. `preset: "default"` remains the
+same full preset for compatibility.
 
 The HTTP stack is meant to replace the usual `fetch` wrapper plus Zod/Valibot
 glue: schemas are dependency-free, responses and request bodies are validated in
@@ -84,6 +169,70 @@ the same effect, config validation fails at construction time, and the client
 still owns cancellation, retries, compression, observability, and adaptive
 limits as one pipeline.
 
+Custom Promise clients such as Axios can be injected without making the
+consumer manage `AbortSignal` or `Async` plumbing:
+
+```ts
+import {
+  defineHttpPolicyPresets,
+  formatHttpError,
+  isRetryableHttpError,
+  makeDefaultHttpClient,
+  promiseHttpTransport,
+} from "brass-runtime/http";
+
+const transport = promiseHttpTransport()
+  .requestConfig(({ request, url }) => ({
+    url: url.toString(),
+    method: request.method,
+    headers: request.headers,
+    data: request.body,
+    responseType: "json",
+  }))
+  .send((config) => axiosInstance.request(config))
+  .json();
+
+const axiosHttp = makeDefaultHttpClient({
+  baseUrl: "https://api.example.com",
+  transport,
+});
+
+try {
+  await axiosHttp.getJson("/users/1").unsafeRunPromise();
+} catch (error) {
+  if (isRetryableHttpError(error)) {
+    console.warn("transient upstream failure");
+  }
+  console.error(formatHttpError(error));
+}
+```
+
+Brass injects the runtime `AbortSignal` into object configs before `send` and
+normalizes external failures with `toHttpError`, including Axios-like
+`response.status`, aborts, and common timeout codes.
+
+Repeated execution intent can be named once with policy presets:
+
+```ts
+const policies = defineHttpPolicyPresets({
+  readModel: {
+    lane: "read-model",
+    poolKey: "users-api",
+    priority: 2,
+    retry: { maxRetries: 2, baseDelayMs: 50 },
+  },
+});
+
+const http = makeDefaultHttpClient({
+  baseUrl: "https://api.example.com",
+  policyPresets: policies,
+});
+
+await http.getJson("/users/1", {
+  policy: { preset: "readModel", dedupKey: "users:1" },
+}).unsafeRunPromise();
+```
+
 The default adaptive limiter uses the `aggressive` preset: warmup sample floor,
 P5 baseline, error-rate signal, priority-aware queueing, jittered probes,
 proportional headroom, capped decreases, and TTL-evicted per-key state.
@@ -122,6 +271,45 @@ The same validation machinery checks runtime, HTTP, and observability configs
 at construction time, so invalid values fail with field paths like
 `$.otlp.pipeline.batchSize` instead of surfacing later as ambiguous behavior.
 
+### HTTP server
+
+```ts
+import { asyncSucceed, asyncSync, runPromise, useResource } from "brass-runtime";
+import { HttpServer, s } from "brass-runtime/http";
+
+const User = s.object({
+  id: s.nonEmptyString(),
+  name: s.nonEmptyString(),
+});
+
+const router = HttpServer.router([
+  HttpServer.route("GET", "/users/:id", {
+    params: s.object({ id: s.nonEmptyString() }),
+    response: User,
+  }, (ctx) =>
+    asyncSucceed(HttpServer.json({
+      id: ctx.params.id,
+      name: "Ada",
+    })),
+  ),
+  HttpServer.healthRoute(),
+  HttpServer.readinessRoute(),
+]);
+
+await runPromise(
+  useResource(
+    router.listen({ port: 3000 }),
+    (server) => asyncSync(() => {
+      console.log(server.url());
+    }),
+  ),
+);
+```
+
+Routes infer `:params` from the path, optional schemas validate
+params/query/body/response, middleware is effect-based, and the Node listener is
+available as a managed resource for graceful shutdown.
+
 ### Discoverable HTTP builder
 
 ```ts
@@ -131,7 +319,7 @@ declare const token: string;
 
 const http = httpClientBuilder()
   .baseUrl("https://api.example.com")
-  .balanced()
+  .production()
   .balancedLimiter({ maxLimit: 128 })
   .header("authorization", `Bearer ${token}`)
   .cache({ ttlSeconds: 30, maxEntries: 512 })
@@ -270,6 +458,62 @@ HTTP client observability automatically reads adaptive limiter diagnostics when
 the wrapped client owns a limiter, exposing gauges for current limit, queue
 depth, utilization, error rate, request/completion rate, rejection rate, and
 state count.
+It also reads `req.policy` automatically: logs and span attributes include
+`preset`, `lane`, `poolKey`, `dedupKey`, `priority`, and retry overrides when present.
+Metric labels stay conservative by default; opt into stable labels with
+`withHttpObservability({ policy: { labelKeys: ["preset", "lane", "poolKey"] } })`.
+
+### Performance profiler
+
+```bash
+npm run perf
+npm run perf:json
+npm run benchmark:perf
+npm run perf:runtime:ab
+npm run perf:runtime:soak
+npm run perf:runtime:budget
+npm run perf:http:memory
+npm run perf:history
+```
+
+```ts
+import { runBrassPerformanceProfile } from "brass-runtime/perf";
+
+const report = await runBrassPerformanceProfile({
+  http: {
+    calls: 20_000,
+    concurrency: 512,
+    delayMs: 2,
+    forceGc: true,
+    variants: ["default-json", "default-json-observed"],
+  },
+});
+
+console.log(report.recommendations);
+```
+
+The profiler compares runtime primitives, runtime A/B variants, runtime-only
+soak behavior, `node:http`, Brass wire/default HTTP clients, HTTP long-run
+memory, observability overhead, history/baseline regressions, and memory deltas. Use
+[`docs/performance-profiler.md`](docs/performance-profiler.md) for focused
+commands and `node --expose-gc` runs.
+
+Perf runs can be persisted and compared locally:
+
+```bash
+npm run perf -- --profile runtime-ab --record-history --save-baseline runtime-main
+npm run perf -- --profile runtime-ab --compare-baseline runtime-main --fail-on-baseline-regression
+```
+
+### First-release recipes
+
+Copyable happy paths live in [`docs/recipes`](docs/recipes/README.md):
+
+- runtime execution
+- typed layers
+- HTTP server
+- testing
+- performance baselines
 
 ### Structured concurrency
 
@@ -289,12 +533,13 @@ await runtime.toPromise(
 ### Streams
 
 ```ts
-import { Runtime, collectStream, fromArray, mapP, via } from "brass-runtime";
+import { Runtime, Stream } from "brass-runtime";
 
 const runtime = Runtime.make({});
-const numbers = fromArray([1, 2, 3, 4, 5]);
-const doubled = via(numbers, mapP((n: number) => n * 2));
-const result = await runtime.toPromise(collectStream(doubled));
+const result = await Stream
+  .from([1, 2, 3, 4, 5])
+  .map((n) => n * 2)
+  .collect(runtime);
 // [2, 4, 6, 8, 10]
 ```
 
@@ -310,6 +555,7 @@ const result = await runtime.toPromise(collectStream(doubled));
 | `brass-runtime/http/testing` | Dependency-free mock clients, mock fetch, response factories, and effect runner helpers |
 | `brass-runtime/schema` | Dependency-free runtime schema DSL with type inference |
 | `brass-runtime/observability` | Prometheus/OTLP exporters, logs, spans, trace propagation, request adapters |
+| `brass-runtime/perf` | Runtime, HTTP, observability, memory, and baseline performance profiler |
 | `brass-runtime/agent` | Brass Agent core (experimental) |
 
 CLI: `brass-agent`
@@ -346,6 +592,8 @@ All layers emit lifecycle events, track stats, and support cancellation.
 The recommended `makeDefaultHttpClient` factory wires the default preset
 for you and accepts extra middleware, so observability can be attached with
 `middleware: [withHttpObservability(obs)]` without coupling HTTP to exporters.
+Per-request `policy` travels through that stack and is visible to observability
+without being forwarded to the host transport.
 
 ---
 
@@ -388,7 +636,14 @@ Docs: [Install](./docs/agent-install-and-configure.md) · [CLI](./docs/agent-cli
 npm test              # vitest suite
 npm run test:types    # TypeScript type checking
 npm run test:coverage # coverage with baseline gate
+npm run release:check # full release gate: types, tests, build, CJS, perf budgets
 npm run benchmark     # runtime, HTTP lifecycle, and 100k local HTTP concurrency
+npm run benchmark:runtime        # Runtime Performance Track
+npm run benchmark:runtime:budget # Runtime Performance Track regression budget
+npm run perf:runtime:ab          # Runtime A/B Performance Lab
+npm run perf:runtime:soak        # Runtime-only soak profile
+npm run perf:runtime:budget      # Runtime profiler budget
+npm run perf:http:memory         # HTTP long-run memory lab
 npm run benchmark -- http-concurrent # HTTP compare mode variants
 node --expose-gc --import tsx src/benchmarks/runner.ts http-concurrent # HTTP memory/limiter diagnostics
 npm run benchmark:adaptive
@@ -426,10 +681,16 @@ Property-based tests use `fast-check` with 100+ iterations per property. Each HT
 
 - [x] Sync effect values via `ZIO<R, E, A>` aliases
 - [x] Algebraic async: `Async<R, E, A>`
+- [x] Rich `Cause<E>` failure trees with pretty printing
+- [x] Interruptibility regions with `uninterruptible` / `uninterruptibleMask`
+- [x] Fiber-local refs with fork inheritance and scoped restoration
+- [x] TS TestRuntime with deterministic scheduler and virtual clock
+- [x] Schedule 2.0 with drivers, runtime-clock budgets, observability, and HTTP integration
 - [x] Cooperative scheduler (observable, testable)
 - [x] Fibers with interruption & finalizers
 - [x] Structured scopes & resource safety
-- [x] Layers, semaphores, circuit breakers
+- [x] Runtime flight recorder for bounded execution traces
+- [x] Layer 2.0 typed contexts, semaphores, circuit breakers
 - [x] Metrics, tracing, runtime hooks
 - [x] Worker pools
 - [x] WASM engine (optional)
@@ -437,6 +698,7 @@ Property-based tests use `fast-check` with 100+ iterations per property. Each HT
 ### Streams
 
 - [x] Pull-based streams with backpressure
+- [x] Fluent `Stream` / `Pipeline` DX facade
 - [x] Bounded buffers, queues, hubs
 - [x] Pipelines with fusion optimization
 - [x] Stream merge, zip, broadcast
@@ -445,6 +707,9 @@ Property-based tests use `fast-check` with 100+ iterations per property. Each HT
 ### HTTP
 
 - [x] Lazy, cancelable HTTP client
+- [x] Effect-based Node HTTP server listener with resource lifecycle
+- [x] Declarative typed routing with params/query/body/response schemas
+- [x] Health/readiness routes backed by runtime health reports
 - [x] Schema-validated JSON helpers
 - [x] Discoverable builder API
 - [x] Test helper subpath

package/dist/agent/cli/main.cjs

@@ -17,18 +17,18 @@
 
 
 
-var _chunkN6VHMOWBcjs = require('../../chunk-N6VHMOWB.cjs');
-require('../../chunk-NYL4D7SK.cjs');
-require('../../chunk-TVN5I4U6.cjs');
+var _chunk4ROBZFL6cjs = require('../../chunk-4ROBZFL6.cjs');
+require('../../chunk-SA6HUJVI.cjs');
+require('../../chunk-JF5WGYJJ.cjs');
 
 
-var _chunkWQ5QNU5Rcjs = require('../../chunk-WQ5QNU5R.cjs');
+var _chunkGLE2WY7Zcjs = require('../../chunk-GLE2WY7Z.cjs');
 
 
 
 
-var _chunkDJQ7OMMBcjs = require('../../chunk-DJQ7OMMB.cjs');
-require('../../chunk-SPUEME2B.cjs');
+var _chunkMVGUEJ5Zcjs = require('../../chunk-MVGUEJ5Z.cjs');
+require('../../chunk-CZIVE6NT.cjs');
 require('../../chunk-OBGZSXTJ.cjs');
 
 // src/agent/cli/approvals.ts
@@ -45,7 +45,7 @@ var answerToResponse = (answer, request) => {
   return { type: "rejected", reason: `Unrecognized approval answer: ${answer}` };
 };
 var makeCliApprovalService = (options = {}) => ({
-  request: (request) => _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (_env, cb) => {
+  request: (request) => _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_env, cb) => {
     let closed = false;
     let rl;
     dynamicImport("node:readline/promises").then(({ createInterface }) => {
@@ -57,7 +57,7 @@ var makeCliApprovalService = (options = {}) => ({
       _optionalChain([output, 'optionalAccess', _ => _.write, 'optionalCall', _2 => _2(`
 Approval required (${request.risk})
 `)]);
-      _optionalChain([output, 'optionalAccess', _3 => _3.write, 'optionalCall', _4 => _4(`Action: ${_chunkN6VHMOWBcjs.summarizeAgentAction.call(void 0, request.action)}
+      _optionalChain([output, 'optionalAccess', _3 => _3.write, 'optionalCall', _4 => _4(`Action: ${_chunk4ROBZFL6cjs.summarizeAgentAction.call(void 0, request.action)}
 `)]);
       _optionalChain([output, 'optionalAccess', _5 => _5.write, 'optionalCall', _6 => _6(`Reason: ${request.reason}
 `)]);
@@ -66,14 +66,14 @@ Approval required (${request.risk})
       if (answer === void 0 || closed) return;
       closed = true;
       _optionalChain([rl, 'optionalAccess', _7 => _7.close, 'optionalCall', _8 => _8()]);
-      cb(_chunkDJQ7OMMBcjs.Exit.succeed(answerToResponse(answer, request)));
+      cb(_chunkMVGUEJ5Zcjs.Exit.succeed(answerToResponse(answer, request)));
     }).catch((cause) => {
       if (closed) return;
       closed = true;
       _optionalChain([rl, 'optionalAccess', _9 => _9.close, 'optionalCall', _10 => _10()]);
       cb(
-        _chunkDJQ7OMMBcjs.Exit.failCause(
-          _chunkDJQ7OMMBcjs.Cause.fail({
+        _chunkMVGUEJ5Zcjs.Exit.failCause(
+          _chunkMVGUEJ5Zcjs.Cause.fail({
             _tag: "AgentLoopError",
             message: `Approval prompt failed: ${String(cause)}`
           })
@@ -1104,7 +1104,7 @@ var parseCliArgs = (argv) => {
     }
     if (arg === "--preset" || arg.startsWith("--preset=")) {
       const [value, nextIndex] = readFlagValue(argv, index, "--preset");
-      if (!_chunkN6VHMOWBcjs.isAgentPreset.call(void 0, value)) {
+      if (!_chunk4ROBZFL6cjs.isAgentPreset.call(void 0, value)) {
         throw new Error("--preset requires one of: fix-tests, inspect, typecheck, lint");
       }
       preset = value;
@@ -1280,7 +1280,7 @@ var parseBatchGoal = (value, path) => {
   if (cwd !== void 0 && typeof cwd !== "string") throw new Error(`${path}.cwd must be a string.`);
   if (patchFile !== void 0 && typeof patchFile !== "string") throw new Error(`${path}.patchFile must be a string.`);
   if (saveRunDir !== void 0 && typeof saveRunDir !== "string") throw new Error(`${path}.saveRunDir must be a string.`);
-  if (preset !== void 0 && (typeof preset !== "string" || !_chunkN6VHMOWBcjs.isAgentPreset.call(void 0, preset))) {
+  if (preset !== void 0 && (typeof preset !== "string" || !_chunk4ROBZFL6cjs.isAgentPreset.call(void 0, preset))) {
     throw new Error(`${path}.preset must be one of: fix-tests, inspect, typecheck, lint.`);
   }
   if (mode !== void 0 && (typeof mode !== "string" || !isAgentMode(mode))) {
@@ -1324,7 +1324,7 @@ var readBatchFile = async (cwd, batchFile) => {
 var resolveBatchGoalText = (item, fallbackPatchFile) => {
   if (typeof item === "string") return item;
   if (item.goal) return item.goal;
-  if (item.preset) return _chunkN6VHMOWBcjs.goalForAgentPreset.call(void 0, item.preset);
+  if (item.preset) return _chunk4ROBZFL6cjs.goalForAgentPreset.call(void 0, item.preset);
   if (_nullishCoalesce(item.patchFile, () => ( fallbackPatchFile))) return "apply supplied patch";
   return "";
 };
@@ -1351,7 +1351,7 @@ var resolveBatchRuns = (items, parsed, config) => items.map((item, index) => {
   };
 });
 var resolveParsedConfig = async (parsed) => {
-  const workspaceDiscovery = _chunkN6VHMOWBcjs.discoverNodeWorkspaceRoot.call(void 0, parsed.cwd, {
+  const workspaceDiscovery = _chunk4ROBZFL6cjs.discoverNodeWorkspaceRoot.call(void 0, parsed.cwd, {
     enabled: parsed.discoverWorkspace
   });
   const cwdResolved = workspaceDiscovery.cwd;
@@ -1359,7 +1359,7 @@ var resolveParsedConfig = async (parsed) => {
     ...parsed,
     cwd: cwdResolved
   };
-  const loaded = await _chunkN6VHMOWBcjs.loadNodeAgentConfig.call(void 0, {
+  const loaded = await _chunk4ROBZFL6cjs.loadNodeAgentConfig.call(void 0, {
     cwd: cwdResolved,
     configPath: parsed.configPath,
     noConfig: parsed.noConfig
@@ -1375,7 +1375,7 @@ var resolveParsedConfig = async (parsed) => {
   const batchRuns = resolveBatchRuns(batchItems, parsedAtWorkspace, loaded.config);
   return {
     ...parsedAtWorkspace,
-    goalText: parsed.goalText || (parsed.preset ? _chunkN6VHMOWBcjs.goalForAgentPreset.call(void 0, parsed.preset) : parsed.patchFile ? "apply supplied patch" : parsed.goalText),
+    goalText: parsed.goalText || (parsed.preset ? _chunk4ROBZFL6cjs.goalForAgentPreset.call(void 0, parsed.preset) : parsed.patchFile ? "apply supplied patch" : parsed.goalText),
     mode: parsed.modeSpecified ? parsed.mode : parsed.preset === "inspect" ? "read-only" : _nullishCoalesce(loaded.config.mode, () => ( parsed.mode)),
     approval: parsed.approvalSpecified ? parsed.approval : _nullishCoalesce(loaded.config.approval, () => ( parsed.approval)),
     config: loaded.config,
@@ -1499,7 +1499,7 @@ var envByName = (name) => name ? process.env[name] : void 0;
 var makeGoogleLLMFromEnv = (config) => {
   const apiKey = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(envByName(_optionalChain([config, 'optionalAccess', _39 => _39.apiKeyEnv])), () => ( process.env.BRASS_GOOGLE_API_KEY)), () => ( process.env.GOOGLE_API_KEY)), () => ( process.env.GEMINI_API_KEY));
   if (!apiKey) return void 0;
-  return _chunkN6VHMOWBcjs.makeGoogleGenerativeAILLM.call(void 0, {
+  return _chunk4ROBZFL6cjs.makeGoogleGenerativeAILLM.call(void 0, {
     apiKey,
     model: _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(process.env.BRASS_GOOGLE_MODEL, () => ( process.env.BRASS_LLM_MODEL)), () => ( _optionalChain([config, 'optionalAccess', _40 => _40.model]))), () => ( "gemini-2.5-flash")),
     apiVersion: _nullishCoalesce(_nullishCoalesce(process.env.BRASS_GOOGLE_API_VERSION, () => ( _optionalChain([config, 'optionalAccess', _41 => _41.apiVersion]))), () => ( "v1beta")),
@@ -1517,12 +1517,12 @@ var makeOpenAICompatibleLLMFromEnv = (config) => {
   const apiKey = _nullishCoalesce(envByName(_optionalChain([config, 'optionalAccess', _50 => _50.apiKeyEnv])), () => ( process.env.BRASS_LLM_API_KEY));
   const model = _nullishCoalesce(_nullishCoalesce(process.env.BRASS_LLM_MODEL, () => ( _optionalChain([config, 'optionalAccess', _51 => _51.model]))), () => ( "gpt-4.1"));
   if (!endpoint || !apiKey) return void 0;
-  return _chunkN6VHMOWBcjs.makeOpenAICompatibleLLM.call(void 0, { endpoint, apiKey, model });
+  return _chunk4ROBZFL6cjs.makeOpenAICompatibleLLM.call(void 0, { endpoint, apiKey, model });
 };
 var makeLLMFromEnv = (config) => {
   const provider = _optionalChain([(_nullishCoalesce(process.env.BRASS_LLM_PROVIDER, () => ( _optionalChain([config, 'optionalAccess', _52 => _52.provider])))), 'optionalAccess', _53 => _53.trim, 'call', _54 => _54(), 'access', _55 => _55.toLowerCase, 'call', _56 => _56()]);
   const fakeResponse = _nullishCoalesce(process.env.BRASS_FAKE_LLM_RESPONSE, () => ( _optionalChain([config, 'optionalAccess', _57 => _57.fakeResponse])));
-  if (provider === "fake") return _chunkN6VHMOWBcjs.makeFakeLLM.call(void 0, { content: fakeResponse });
+  if (provider === "fake") return _chunk4ROBZFL6cjs.makeFakeLLM.call(void 0, { content: fakeResponse });
   if (provider === "google" || provider === "gemini") {
     const google = makeGoogleLLMFromEnv(config);
     if (!google) {
@@ -1544,7 +1544,7 @@ var makeLLMFromEnv = (config) => {
   if (provider) {
     throw new Error(`Unsupported LLM provider: ${provider}`);
   }
-  return _nullishCoalesce(_nullishCoalesce(makeGoogleLLMFromEnv(config), () => ( makeOpenAICompatibleLLMFromEnv(config))), () => ( _chunkN6VHMOWBcjs.makeFakeLLM.call(void 0, { content: fakeResponse })));
+  return _nullishCoalesce(_nullishCoalesce(makeGoogleLLMFromEnv(config), () => ( makeOpenAICompatibleLLMFromEnv(config))), () => ( _chunk4ROBZFL6cjs.makeFakeLLM.call(void 0, { content: fakeResponse })));
 };
 var parseApprovalModeFromEnv = () => {
   const raw = _optionalChain([process, 'access', _58 => _58.env, 'access', _59 => _59.BRASS_AGENT_APPROVAL, 'optionalAccess', _60 => _60.trim, 'call', _61 => _61(), 'access', _62 => _62.toLowerCase, 'call', _63 => _63()]);
@@ -1567,9 +1567,9 @@ var makeApprovalServiceFromCli = (parsed) => {
   const mode = resolveApprovalMode(parsed);
   switch (mode) {
     case "approve":
-      return _chunkN6VHMOWBcjs.autoApproveApprovals;
+      return _chunk4ROBZFL6cjs.autoApproveApprovals;
     case "deny":
-      return _chunkN6VHMOWBcjs.makeAutoDenyApprovals.call(void 0, "Approval rejected because the CLI is running without interactive input. Use --yes to auto-approve.");
+      return _chunk4ROBZFL6cjs.makeAutoDenyApprovals.call(void 0, "Approval rejected because the CLI is running without interactive input. Use --yes to auto-approve.");
     case "interactive":
       return makeCliApprovalService();
   }
@@ -1701,32 +1701,32 @@ var createHumanEventSink = (configPath) => ({
         console.log("");
         break;
       case "agent.action.started":
-        console.log(`\u2192 ${_chunkN6VHMOWBcjs.summarizeAgentAction.call(void 0, event.action)}`);
+        console.log(`\u2192 ${_chunk4ROBZFL6cjs.summarizeAgentAction.call(void 0, event.action)}`);
         break;
       case "agent.action.completed": {
-        const status = _chunkN6VHMOWBcjs.observationStatus.call(void 0, event.observation);
-        console.log(`${statusIcon2(status)} ${_chunkN6VHMOWBcjs.summarizeAgentObservation.call(void 0, event.observation)} ${formatDuration(event.durationMs)}`);
+        const status = _chunk4ROBZFL6cjs.observationStatus.call(void 0, event.observation);
+        console.log(`${statusIcon2(status)} ${_chunk4ROBZFL6cjs.summarizeAgentObservation.call(void 0, event.observation)} ${formatDuration(event.durationMs)}`);
         break;
       }
       case "agent.action.failed":
         if (event.error._tag !== "ToolTimeout" && event.error._tag !== "PermissionDenied" && event.error._tag !== "ApprovalRejected") {
-          console.log(`\u2717 ${_chunkN6VHMOWBcjs.summarizeAgentAction.call(void 0, event.action)} failed with ${event.error._tag} ${formatDuration(event.durationMs)}`);
+          console.log(`\u2717 ${_chunk4ROBZFL6cjs.summarizeAgentAction.call(void 0, event.action)} failed with ${event.error._tag} ${formatDuration(event.durationMs)}`);
         }
         break;
       case "agent.tool.timeout":
-        console.log(`! ${_chunkN6VHMOWBcjs.summarizeAgentAction.call(void 0, event.action)} timed out after ${event.timeoutMs}ms`);
+        console.log(`! ${_chunk4ROBZFL6cjs.summarizeAgentAction.call(void 0, event.action)} timed out after ${event.timeoutMs}ms`);
         break;
       case "agent.permission.denied":
-        console.log(`\u2717 ${_chunkN6VHMOWBcjs.summarizeAgentAction.call(void 0, event.action)} denied: ${event.reason}`);
+        console.log(`\u2717 ${_chunk4ROBZFL6cjs.summarizeAgentAction.call(void 0, event.action)} denied: ${event.reason}`);
         break;
       case "agent.approval.requested":
-        console.log(`? approval required for ${_chunkN6VHMOWBcjs.summarizeAgentAction.call(void 0, event.action)} (${event.risk})`);
+        console.log(`? approval required for ${_chunk4ROBZFL6cjs.summarizeAgentAction.call(void 0, event.action)} (${event.risk})`);
         break;
       case "agent.approval.resolved":
         if (event.approved) {
-          console.log(`\u2713 approval granted for ${_chunkN6VHMOWBcjs.summarizeAgentAction.call(void 0, event.action)}`);
+          console.log(`\u2713 approval granted for ${_chunk4ROBZFL6cjs.summarizeAgentAction.call(void 0, event.action)}`);
         } else {
-          console.log(`\u2717 approval rejected for ${_chunkN6VHMOWBcjs.summarizeAgentAction.call(void 0, event.action)}${event.reason ? `: ${event.reason}` : ""}`);
+          console.log(`\u2717 approval rejected for ${_chunk4ROBZFL6cjs.summarizeAgentAction.call(void 0, event.action)}${event.reason ? `: ${event.reason}` : ""}`);
         }
         break;
       case "agent.patch.applied":
@@ -1831,13 +1831,13 @@ var printHumanFinalSummary = (state) => {
 };
 var makeEventsSink = (parsed, compactOptions) => parsed.output === "human" ? createHumanEventSink(parsed.resolvedConfigPath) : parsed.output === "events-json" ? createJsonEventSink(compactOptions) : parsed.output === "protocol-json" ? createProtocolEventSink(compactOptions) : void 0;
 var makeAgentEnv = (parsed, events) => {
-  const shell = _chunkN6VHMOWBcjs.NodeShell;
+  const shell = _chunk4ROBZFL6cjs.NodeShell;
   return {
     shell,
-    fs: _chunkN6VHMOWBcjs.makeNodeFileSystem.call(void 0, shell),
-    patch: _chunkN6VHMOWBcjs.makeNodePatchService.call(void 0, shell),
+    fs: _chunk4ROBZFL6cjs.makeNodeFileSystem.call(void 0, shell),
+    patch: _chunk4ROBZFL6cjs.makeNodePatchService.call(void 0, shell),
     llm: makeLLMFromEnv(parsed.config.llm),
-    permissions: _chunkN6VHMOWBcjs.makeConfiguredPermissions.call(void 0, parsed.config.permissions),
+    permissions: _chunk4ROBZFL6cjs.makeConfiguredPermissions.call(void 0, parsed.config.permissions),
     approvals: makeApprovalServiceFromCli(parsed),
     ...events ? { events } : {},
     ...parsed.config.tools ? { toolPolicies: parsed.config.tools } : {}
@@ -1854,10 +1854,10 @@ var singleRunFromParsed = (parsed) => ({
 });
 var runCliAgent = async (parsed, run, compactOptions, events) => {
   const env = makeAgentEnv(parsed, events);
-  const runtime = new (0, _chunkWQ5QNU5Rcjs.Runtime)({ env });
+  const runtime = new (0, _chunkGLE2WY7Zcjs.Runtime)({ env });
   const initialPatch = run.patchFile ? await readPatchFile(run.cwd, run.patchFile) : void 0;
   const state = await runtime.toPromise(
-    _chunkN6VHMOWBcjs.runAgent.call(void 0, runtime, {
+    _chunk4ROBZFL6cjs.runAgent.call(void 0, runtime, {
       id: `agent-${Date.now()}-${run.index + 1}`,
       cwd: run.cwd,
       text: run.goalText,