brass-runtime 1.13.6 → 1.13.7

package/dist/{chunk-DB57UZBE.cjs → chunk-XDINDYNA.cjs}

@@ -11,7 +11,7 @@
 
 
 
-var _chunkKT4IKCIUcjs = require('./chunk-KT4IKCIU.cjs');
+var _chunk2P4PD6D7cjs = require('./chunk-2P4PD6D7.cjs');
 
 // src/agent/core/state.ts
 var initialAgentState = (goal) => ({
@@ -1350,22 +1350,22 @@ var decideNextAction = (state) => {
   const latest = state.observations.at(-1);
   if (_optionalChain([latest, 'optionalAccess', _109 => _109.type]) === "agent.error") {
     if (shouldRequestRepairAfterPatchError(state)) {
-      return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, repairAction(state, "previous patch failed to apply"));
+      return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, repairAction(state, "previous patch failed to apply"));
     }
-    return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, { type: "agent.finish", summary: buildErrorSummary(state) });
+    return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { type: "agent.finish", summary: buildErrorSummary(state) });
   }
   if (!hasObservation(state, "fs.fileRead")) {
-    return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, { type: "fs.readFile", path: "package.json" });
+    return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { type: "fs.readFile", path: "package.json" });
   }
   const probeAction = nextProjectProbeAction(state);
   if (probeAction) {
-    return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, probeAction);
+    return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, probeAction);
   }
   const suppliedPatch = _optionalChain([state, 'access', _110 => _110.goal, 'access', _111 => _111.initialPatch, 'optionalAccess', _112 => _112.trim, 'call', _113 => _113()]);
   if (suppliedPatch) {
     const action = initialPatchFlowAction(state, suppliedPatch);
-    if (action) return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, action);
-    return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, {
+    if (action) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, action);
+    return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, {
       type: "agent.finish",
       summary: buildCompletionSummary(state, suppliedPatch)
     });
@@ -1373,10 +1373,10 @@ var decideNextAction = (state) => {
   const pendingLlmPatch = latestLlmPatchCandidate(state);
   if (pendingLlmPatch) {
     if (isWritableMode(state.goal.mode)) {
-      return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, { type: "patch.apply", patch: pendingLlmPatch.patch });
+      return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { type: "patch.apply", patch: pendingLlmPatch.patch });
     }
     if (state.goal.mode === "propose") {
-      return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, { type: "patch.propose", patch: pendingLlmPatch.patch });
+      return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { type: "patch.propose", patch: pendingLlmPatch.patch });
     }
   }
   const planResponse = state.observations.find(
@@ -1384,10 +1384,10 @@ var decideNextAction = (state) => {
   );
   if (!planResponse) {
     const validationAction = nextValidationActionBeforePlanning(state);
-    if (validationAction) return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, validationAction);
+    if (validationAction) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, validationAction);
     const contextAction = nextContextDiscoveryAction(state);
-    if (contextAction) return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, contextAction);
-    return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, {
+    if (contextAction) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, contextAction);
+    return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, {
       type: "llm.complete",
       purpose: "plan",
       prompt: buildPlanningPrompt(state)
@@ -1396,39 +1396,39 @@ var decideNextAction = (state) => {
   if (isWritableMode(state.goal.mode)) {
     if (shouldContinueRollbackStack(state)) {
       const rollbackAction = automaticRollbackAction(state, "continuing rollback of generated patch stack");
-      if (rollbackAction) return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, rollbackAction);
+      if (rollbackAction) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, rollbackAction);
     }
     if (_optionalChain([latestWorkspaceChange, 'call', _114 => _114(state), 'optionalAccess', _115 => _115.type]) === "patch.rolledBack") {
       const summary = rollbackSafetySummary(state);
       if (summary.runValidationAfterRollback) {
         const validationAction = nextValidationActionAfterLatestWorkspaceChange(state);
-        if (validationAction) return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, validationAction);
+        if (validationAction) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, validationAction);
       }
     }
     if (_optionalChain([latestWorkspaceChange, 'call', _116 => _116(state), 'optionalAccess', _117 => _117.type]) === "patch.applied") {
       const validationAction = nextValidationActionAfterPatch(state);
-      if (validationAction) return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, validationAction);
+      if (validationAction) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, validationAction);
       if (shouldRequestRepairAfterValidation(state)) {
-        return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, repairAction(state, "validation failed after applying the generated patch"));
+        return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, repairAction(state, "validation failed after applying the generated patch"));
       }
       if (shouldAutoRollbackAfterFinalValidationFailure(state)) {
         const rollbackAction = automaticRollbackAction(state, "validation failed after generated patches and no repair attempts remain");
-        if (rollbackAction) return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, rollbackAction);
+        if (rollbackAction) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, rollbackAction);
       }
     }
   }
   const patch = latestExtractedPatch(state);
-  return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, {
+  return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, {
     type: "agent.finish",
     summary: buildCompletionSummary(state, patch)
   });
 };
 
 // src/agent/core/events.ts
-var nowMillis = () => _chunkKT4IKCIUcjs.async.call(void 0, (_env, cb) => {
+var nowMillis = () => _chunk2P4PD6D7cjs.async.call(void 0, (_env, cb) => {
   cb({ _tag: "Success", value: Date.now() });
 });
-var emitAgentEvent = (event) => _chunkKT4IKCIUcjs.async.call(void 0, (env, cb) => {
+var emitAgentEvent = (event) => _chunk2P4PD6D7cjs.async.call(void 0, (env, cb) => {
   try {
     _optionalChain([env, 'access', _118 => _118.events, 'optionalAccess', _119 => _119.emit, 'call', _120 => _120(event)]);
   } catch (e5) {
@@ -1436,8 +1436,8 @@ var emitAgentEvent = (event) => _chunkKT4IKCIUcjs.async.call(void 0, (env, cb) =
   cb({ _tag: "Success", value: void 0 });
 });
 var emitAgentEvents = (events) => events.reduce(
-  (acc, event) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, acc, () => emitAgentEvent(event)),
-  _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, void 0)
+  (acc, event) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, acc, () => emitAgentEvent(event)),
+  _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, void 0)
 );
 var summarizeAgentAction = (action) => {
   switch (action.type) {
@@ -1549,7 +1549,7 @@ var observationEventFor = (state, observation, at) => {
 var runStatusFor = (phase) => phase === "done" ? "done" : "failed";
 
 // src/agent/tools/env.ts
-var service = (key) => _chunkKT4IKCIUcjs.asyncSync.call(void 0, (env) => env[key]);
+var service = (key) => _chunk2P4PD6D7cjs.asyncSync.call(void 0, (env) => env[key]);
 
 // src/agent/tools/path.ts
 var isAbsoluteLike = (path) => path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path);
@@ -1575,48 +1575,48 @@ var normalizeWorkspaceRelativePath = (inputPath) => {
 var resolveWorkspacePath = (cwd, inputPath) => {
   const normalized = normalizeWorkspaceRelativePath(inputPath);
   if (!normalized) {
-    return _chunkKT4IKCIUcjs.asyncFail.call(void 0, { _tag: "PathOutsideWorkspace", path: inputPath, cwd });
+    return _chunk2P4PD6D7cjs.asyncFail.call(void 0, { _tag: "PathOutsideWorkspace", path: inputPath, cwd });
   }
-  return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, `${trimTrailingSlash(cwd)}/${normalized}`);
+  return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, `${trimTrailingSlash(cwd)}/${normalized}`);
 };
 
 // src/agent/tools/actionToEffect.ts
 var actionToEffect = (action, state) => {
   switch (action.type) {
     case "fs.readFile":
-      return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         resolveWorkspacePath(state.goal.cwd, action.path),
-        (path) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+        (path) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
           service("fs"),
-          (fs) => _chunkKT4IKCIUcjs.asyncMap.call(void 0, 
+          (fs) => _chunk2P4PD6D7cjs.asyncMap.call(void 0, 
             fs.readFile(path),
             (content) => ({ type: "fs.fileRead", path: action.path, content })
           )
         )
       );
     case "fs.exists":
-      return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         resolveWorkspacePath(state.goal.cwd, action.path),
-        (path) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+        (path) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
           service("fs"),
-          (fs) => _chunkKT4IKCIUcjs.asyncMap.call(void 0, 
+          (fs) => _chunk2P4PD6D7cjs.asyncMap.call(void 0, 
             fs.exists(path),
             (exists) => ({ type: "fs.exists", path: action.path, exists })
           )
         )
       );
     case "fs.searchText":
-      return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         service("fs"),
-        (fs) => _chunkKT4IKCIUcjs.asyncMap.call(void 0, 
+        (fs) => _chunk2P4PD6D7cjs.asyncMap.call(void 0, 
           fs.searchText(state.goal.cwd, action.query, { globs: action.globs }),
           (matches) => ({ type: "fs.searchResult", query: action.query, matches })
         )
       );
     case "shell.exec":
-      return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         service("shell"),
-        (shell) => _chunkKT4IKCIUcjs.asyncMap.call(void 0, 
+        (shell) => _chunk2P4PD6D7cjs.asyncMap.call(void 0, 
           shell.exec(action.command, { cwd: _nullishCoalesce(action.cwd, () => ( state.goal.cwd)) }),
           (result) => ({
             type: "shell.result",
@@ -1628,19 +1628,19 @@ var actionToEffect = (action, state) => {
         )
       );
     case "llm.complete":
-      return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         service("llm"),
-        (llm) => _chunkKT4IKCIUcjs.asyncMap.call(void 0, 
+        (llm) => _chunk2P4PD6D7cjs.asyncMap.call(void 0, 
           llm.complete({ purpose: action.purpose, prompt: action.prompt }),
           (response) => ({ type: "llm.response", purpose: action.purpose, content: response.content })
         )
       );
     case "patch.propose":
-      return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, { type: "patch.proposed", patch: action.patch });
+      return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { type: "patch.proposed", patch: action.patch });
     case "patch.apply":
-      return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         service("patch"),
-        (patch) => _chunkKT4IKCIUcjs.asyncMap.call(void 0, 
+        (patch) => _chunk2P4PD6D7cjs.asyncMap.call(void 0, 
           patch.apply(state.goal.cwd, action.patch),
           (result) => ({
             type: "patch.applied",
@@ -1650,9 +1650,9 @@ var actionToEffect = (action, state) => {
         )
       );
     case "patch.rollback":
-      return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         service("patch"),
-        (patch) => _chunkKT4IKCIUcjs.asyncMap.call(void 0, 
+        (patch) => _chunk2P4PD6D7cjs.asyncMap.call(void 0, 
           patch.rollback(state.goal.cwd, action.patch),
           (result) => ({
             type: "patch.rolledBack",
@@ -1664,33 +1664,33 @@ var actionToEffect = (action, state) => {
         )
       );
     case "agent.finish":
-      return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, { type: "agent.done", summary: action.summary });
+      return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { type: "agent.done", summary: action.summary });
     case "agent.fail":
-      return _chunkKT4IKCIUcjs.asyncFail.call(void 0, { _tag: "AgentLoopError", message: action.reason });
+      return _chunk2P4PD6D7cjs.asyncFail.call(void 0, { _tag: "AgentLoopError", message: action.reason });
   }
 };
 
 // src/agent/tools/retry.ts
 var retry = (make, options) => {
-  const loop = (remaining) => _chunkKT4IKCIUcjs.asyncFold.call(void 0, 
+  const loop = (remaining) => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
     make(),
     (error) => {
       if (remaining > 0 && options.while(error)) return loop(remaining - 1);
-      return _chunkKT4IKCIUcjs.asyncFail.call(void 0, error);
+      return _chunk2P4PD6D7cjs.asyncFail.call(void 0, error);
     },
-    (value) => _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, value)
+    (value) => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, value)
   );
   return loop(options.times);
 };
 
 // src/agent/tools/timeout.ts
-var sleep = (ms) => _chunkKT4IKCIUcjs.async.call(void 0, (_env, cb) => {
+var sleep = (ms) => _chunk2P4PD6D7cjs.async.call(void 0, (_env, cb) => {
   const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), ms);
   return () => clearTimeout(id);
 });
-var timeout = (effect, ms, scope) => _chunkKT4IKCIUcjs.race.call(void 0, 
+var timeout = (effect, ms, scope) => _chunk2P4PD6D7cjs.race.call(void 0, 
   effect,
-  _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, sleep(ms), () => _chunkKT4IKCIUcjs.asyncFail.call(void 0, { _tag: "ToolTimeout", timeoutMs: ms })),
+  _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, sleep(ms), () => _chunk2P4PD6D7cjs.asyncFail.call(void 0, { _tag: "ToolTimeout", timeoutMs: ms })),
   scope
 );
 
@@ -1724,7 +1724,7 @@ var configuredPolicyFor = (action, overrides) => {
     retries: _optionalChain([override, 'optionalAccess', _123 => _123.retries]) !== void 0 ? Math.max(0, Math.floor(override.retries)) : base.retries
   };
 };
-var runAuthorizedAction = (action, state, scope) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, _chunkKT4IKCIUcjs.asyncSync.call(void 0, (env) => env.toolPolicies), (toolPolicies) => {
+var runAuthorizedAction = (action, state, scope) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, _chunk2P4PD6D7cjs.asyncSync.call(void 0, (env) => env.toolPolicies), (toolPolicies) => {
   const policy = configuredPolicyFor(action, toolPolicies);
   return retry(() => timeout(actionToEffect(action, state), policy.timeoutMs, scope), {
     times: policy.retries,
@@ -1736,7 +1736,7 @@ var rejected = (action, reason) => ({
   action,
   reason
 });
-var emitApprovalResolved = (action, state, approved, reason) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+var emitApprovalResolved = (action, state, approved, reason) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
   nowMillis(),
   (at) => emitAgentEvent({
     type: "agent.approval.resolved",
@@ -1750,9 +1750,9 @@ var emitApprovalResolved = (action, state, approved, reason) => _chunkKT4IKCIUcj
 );
 var requestApproval = (action, state, decision) => {
   const defaultAnswer = _nullishCoalesce(decision.defaultAnswer, () => ( "reject"));
-  return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+  return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
     nowMillis(),
-    (at) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+    (at) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
       emitAgentEvent({
         type: "agent.approval.requested",
         action,
@@ -1763,15 +1763,15 @@ var requestApproval = (action, state, decision) => {
         defaultAnswer,
         at
       }),
-      () => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, service("approvals"), (approvals) => {
+      () => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, service("approvals"), (approvals) => {
         if (!approvals) {
           const reason = "No approval service configured.";
-          return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+          return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
             emitApprovalResolved(action, state, false, reason),
-            () => _chunkKT4IKCIUcjs.asyncFail.call(void 0, rejected(action, reason))
+            () => _chunk2P4PD6D7cjs.asyncFail.call(void 0, rejected(action, reason))
           );
         }
-        return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+        return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
           approvals.request({
             action,
             state,
@@ -1781,15 +1781,15 @@ var requestApproval = (action, state, decision) => {
           }),
           (response) => {
             if (response.type === "approved") {
-              return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+              return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
                 emitApprovalResolved(action, state, true, void 0),
-                () => _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, void 0)
+                () => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, void 0)
               );
             }
             const reason = _nullishCoalesce(response.reason, () => ( "Approval rejected."));
-            return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+            return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
               emitApprovalResolved(action, state, false, reason),
-              () => _chunkKT4IKCIUcjs.asyncFail.call(void 0, rejected(action, reason))
+              () => _chunk2P4PD6D7cjs.asyncFail.call(void 0, rejected(action, reason))
             );
           }
         );
@@ -1797,18 +1797,18 @@ var requestApproval = (action, state, decision) => {
     )
   );
 };
-var invokeAction = (action, state, scope) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+var invokeAction = (action, state, scope) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
   service("permissions"),
-  (permissions) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, permissions.check(action, state), (decision) => {
+  (permissions) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, permissions.check(action, state), (decision) => {
     if (decision.type === "deny") {
-      return _chunkKT4IKCIUcjs.asyncFail.call(void 0, {
+      return _chunk2P4PD6D7cjs.asyncFail.call(void 0, {
         _tag: "PermissionDenied",
         action,
         reason: decision.reason
       });
     }
     if (decision.type === "ask") {
-      return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         requestApproval(action, state, decision),
         () => runAuthorizedAction(action, state, scope)
       );
@@ -1818,9 +1818,9 @@ var invokeAction = (action, state, scope) => _chunkKT4IKCIUcjs.asyncFlatMap.call
 );
 
 // src/agent/core/runAgent.ts
-var executeAction = (action, state, scope) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+var executeAction = (action, state, scope) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
   nowMillis(),
-  (startedAt) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+  (startedAt) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
     emitAgentEvent({
       type: "agent.action.started",
       action,
@@ -1828,9 +1828,9 @@ var executeAction = (action, state, scope) => _chunkKT4IKCIUcjs.asyncFlatMap.cal
       phase: state.phase,
       at: startedAt
     }),
-    () => _chunkKT4IKCIUcjs.asyncFold.call(void 0, 
+    () => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
       invokeAction(action, state, scope),
-      (error) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, nowMillis(), (endedAt) => {
+      (error) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, nowMillis(), (endedAt) => {
         const specific = errorEventFor(action, state, error, endedAt);
         const events = [
           ...specific ? [specific] : [],
@@ -1844,14 +1844,14 @@ var executeAction = (action, state, scope) => _chunkKT4IKCIUcjs.asyncFlatMap.cal
             at: endedAt
           }
         ];
-        return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+        return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
           emitAgentEvents(events),
-          () => _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, { type: "agent.error", error })
+          () => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { type: "agent.error", error })
         );
       }),
-      (observation) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      (observation) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         nowMillis(),
-        (endedAt) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+        (endedAt) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
           emitAgentEvent({
             type: "agent.action.completed",
             action,
@@ -1861,13 +1861,13 @@ var executeAction = (action, state, scope) => _chunkKT4IKCIUcjs.asyncFlatMap.cal
             durationMs: endedAt - startedAt,
             at: endedAt
           }),
-          () => _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, observation)
+          () => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, observation)
         )
       )
     )
   )
 );
-var recordObservation = (next, observation) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, nowMillis(), (at) => {
+var recordObservation = (next, observation) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, nowMillis(), (at) => {
   const specific = observationEventFor(next, observation, at);
   const events = [
     {
@@ -1883,9 +1883,9 @@ var recordObservation = (next, observation) => _chunkKT4IKCIUcjs.asyncFlatMap.ca
 });
 var runLoop = (state, scope, runStartedAt) => {
   if (isTerminal(state)) {
-    return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+    return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
       nowMillis(),
-      (at) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      (at) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         emitAgentEvent({
           type: "agent.run.completed",
           goal: state.goal,
@@ -1895,26 +1895,26 @@ var runLoop = (state, scope, runStartedAt) => {
           durationMs: at - runStartedAt,
           at
         }),
-        () => _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, state)
+        () => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, state)
       )
     );
   }
-  return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+  return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
     decideNextAction(state),
-    (action) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, executeAction(action, state, scope), (observation) => {
+    (action) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, executeAction(action, state, scope), (observation) => {
       const next = reduceAgentState(state, observation);
-      return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         recordObservation(next, observation),
         () => runLoop(next, scope, runStartedAt)
       );
     })
   );
 };
-var runAgent = (runtime, goal) => _chunkKT4IKCIUcjs.withScopeAsync.call(void 0, 
+var runAgent = (runtime, goal) => _chunk2P4PD6D7cjs.withScopeAsync.call(void 0, 
   runtime,
-  (scope) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+  (scope) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
     nowMillis(),
-    (startedAt) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+    (startedAt) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
       emitAgentEvent({ type: "agent.run.started", goal, at: startedAt }),
       () => runLoop(initialAgentState(goal), scope, startedAt)
     )
@@ -2064,45 +2064,45 @@ var makeConfiguredPermissions = (config = {}) => ({
     switch (state.goal.mode) {
       case "read-only": {
         if (action.type === "fs.readFile" || action.type === "fs.exists" || action.type === "fs.searchText" || action.type === "llm.complete" || action.type === "agent.finish" || action.type === "agent.fail") {
-          return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, allow());
+          return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, allow());
         }
-        return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, deny(`Action ${action.type} is not allowed in read-only mode`));
+        return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, deny(`Action ${action.type} is not allowed in read-only mode`));
       }
       case "propose": {
         if (action.type === "shell.exec") {
           const decision = shellDecisionFromConfig(action.command, config.shell);
-          return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, 
+          return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, 
             _nullishCoalesce(decision, () => ( deny(`Command not whitelisted: ${action.command.join(" ")}`)))
           );
         }
         if (action.type === "patch.apply" || action.type === "patch.rollback") {
-          return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, deny(`${action.type} is not allowed in propose mode; use write mode or --apply.`));
+          return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, deny(`${action.type} is not allowed in propose mode; use write mode or --apply.`));
         }
-        return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, allow());
+        return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, allow());
       }
       case "write": {
         if (action.type === "shell.exec") {
           const decision = shellDecisionFromConfig(action.command, config.shell);
-          return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, 
+          return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, 
             _nullishCoalesce(decision, () => ( deny(`Command not whitelisted: ${action.command.join(" ")}`)))
           );
         }
         if (action.type === "patch.apply" || action.type === "patch.rollback") {
-          return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, patchApplyDecisionFromConfig(action, config.patchApply));
+          return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, patchApplyDecisionFromConfig(action, config.patchApply));
         }
-        return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, allow());
+        return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, allow());
       }
       case "autonomous": {
         if (action.type === "patch.apply" || action.type === "patch.rollback") {
-          return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, patchApplyDecisionFromConfig(action, config.patchApply));
+          return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, patchApplyDecisionFromConfig(action, config.patchApply));
         }
         if (action.type === "shell.exec") {
           const decision = shellDecisionFromConfig(action.command, config.shell);
-          return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, 
+          return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, 
             _nullishCoalesce(decision, () => ( ask(`Run non-whitelisted command: ${describeCommand(action)}`, "high", "reject")))
           );
         }
-        return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, allow());
+        return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, allow());
       }
     }
   }
@@ -2111,10 +2111,10 @@ var defaultPermissions = makeConfiguredPermissions();
 
 // src/agent/tools/approvals.ts
 var autoApproveApprovals = {
-  request: () => _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, { type: "approved" })
+  request: () => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { type: "approved" })
 };
 var makeAutoDenyApprovals = (reason = "Approval denied by non-interactive policy.") => ({
-  request: () => _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, { type: "rejected", reason })
+  request: () => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { type: "rejected", reason })
 });
 
 // src/agent/node/nodeShell.ts
@@ -2124,12 +2124,12 @@ var chunkToString = (chunk) => {
   return typeof maybeToString === "function" ? maybeToString.call(chunk, "utf8") : String(chunk);
 };
 var NodeShell = {
-  exec: (command, options) => _chunkKT4IKCIUcjs.async.call(void 0, (_env, cb) => {
+  exec: (command, options) => _chunk2P4PD6D7cjs.async.call(void 0, (_env, cb) => {
     const [bin, ...args] = command;
     if (!bin) {
       cb(
-        _chunkKT4IKCIUcjs.Exit.failCause(
-          _chunkKT4IKCIUcjs.Cause.fail({
+        _chunk2P4PD6D7cjs.Exit.failCause(
+          _chunk2P4PD6D7cjs.Cause.fail({
             _tag: "ShellError",
             operation: "exec",
             command,
@@ -2160,8 +2160,8 @@ var NodeShell = {
         if (done) return;
         done = true;
         cb(
-          _chunkKT4IKCIUcjs.Exit.failCause(
-            _chunkKT4IKCIUcjs.Cause.fail({
+          _chunk2P4PD6D7cjs.Exit.failCause(
+            _chunk2P4PD6D7cjs.Cause.fail({
               _tag: "ShellError",
               operation: "exec",
               command,
@@ -2174,7 +2174,7 @@ var NodeShell = {
         if (done) return;
         done = true;
         cb(
-          _chunkKT4IKCIUcjs.Exit.succeed({
+          _chunk2P4PD6D7cjs.Exit.succeed({
             exitCode: _nullishCoalesce(code, () => ( 1)),
             stdout,
             stderr
@@ -2190,8 +2190,8 @@ var NodeShell = {
       if (done) return;
       done = true;
       cb(
-        _chunkKT4IKCIUcjs.Exit.failCause(
-          _chunkKT4IKCIUcjs.Cause.fail({
+        _chunk2P4PD6D7cjs.Exit.failCause(
+          _chunk2P4PD6D7cjs.Cause.fail({
             _tag: "ShellError",
             operation: "exec",
             command,
@@ -2215,15 +2215,15 @@ var parseRipgrep = (stdout) => stdout.split("\n").filter(Boolean).map((line) =>
   return { path, line: Number(lineNo), text: rest.join(":") };
 });
 var makeNodeFileSystem = (shell) => ({
-  readFile: (path) => _chunkKT4IKCIUcjs.fromPromiseAbortable.call(void 0, 
-    _chunkKT4IKCIUcjs.async.call(void 0, signal) => {
+  readFile: (path) => _chunk2P4PD6D7cjs.fromPromiseAbortable.call(void 0, 
+    _chunk2P4PD6D7cjs.async.call(void 0, signal) => {
       const { readFile } = await dynamicImport2("node:fs/promises");
       return readFile(path, { encoding: "utf8", signal });
     },
     (cause) => ({ _tag: "FsError", operation: "readFile", cause })
   ),
-  exists: (path) => _chunkKT4IKCIUcjs.fromPromiseAbortable.call(void 0, 
-    _chunkKT4IKCIUcjs.async.call(void 0, signal) => {
+  exists: (path) => _chunk2P4PD6D7cjs.fromPromiseAbortable.call(void 0, 
+    _chunk2P4PD6D7cjs.async.call(void 0, signal) => {
       if (signal.aborted) return false;
       const { stat } = await dynamicImport2("node:fs/promises");
       if (signal.aborted) return false;
@@ -2236,7 +2236,7 @@ var makeNodeFileSystem = (shell) => ({
     },
     (cause) => ({ _tag: "FsError", operation: "exists", cause })
   ),
-  searchText: (cwd, query, options) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+  searchText: (cwd, query, options) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
     shell.exec(
       [
         "rg",
@@ -2256,27 +2256,27 @@ var makeNodeFileSystem = (shell) => ({
     ),
     (result) => {
       if (result.exitCode > 1) {
-        return _chunkKT4IKCIUcjs.asyncFail.call(void 0, {
+        return _chunk2P4PD6D7cjs.asyncFail.call(void 0, {
           _tag: "FsError",
           operation: "searchText",
           cause: result.stderr
         });
       }
-      return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, parseRipgrep(result.stdout));
+      return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, parseRipgrep(result.stdout));
     }
   )
 });
 
 // src/agent/node/nodePatchService.ts
 var validatePatchTargets = (cwd, paths) => paths.reduce(
-  (acc, path) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+  (acc, path) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
     acc,
-    (validated) => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+    (validated) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
       resolveWorkspacePath(cwd, path),
-      () => _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, [...validated, path])
+      () => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [...validated, path])
     )
   ),
-  _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, [])
+  _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [])
 );
 var patchFailure = (operation, cause, patch) => ({
   _tag: "PatchError",
@@ -2292,7 +2292,7 @@ var makeNodePatchService = (shell) => {
 `;
     const operation = reverse ? "rollback" : "apply";
     if (!patch || !changedFiles.length) {
-      return _chunkKT4IKCIUcjs.asyncFail.call(void 0, 
+      return _chunk2P4PD6D7cjs.asyncFail.call(void 0, 
         patchFailure("extract", "No unified diff with workspace-scoped paths was found.", rawPatch)
       );
     }
@@ -2313,13 +2313,13 @@ var makeNodePatchService = (shell) => {
       "--whitespace=nowarn",
       "-"
     ];
-    return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+    return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
       validatePatchTargets(cwd, changedFiles),
-      () => _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+      () => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
         shell.exec(checkArgs, { cwd, stdin }),
         (checkResult) => {
           if (checkResult.exitCode !== 0) {
-            return _chunkKT4IKCIUcjs.asyncFail.call(void 0, 
+            return _chunk2P4PD6D7cjs.asyncFail.call(void 0, 
               patchFailure(
                 `${operation}.check`,
                 checkResult.stderr || checkResult.stdout || `git apply --check exited with ${checkResult.exitCode}`,
@@ -2327,11 +2327,11 @@ var makeNodePatchService = (shell) => {
               )
             );
           }
-          return _chunkKT4IKCIUcjs.asyncFlatMap.call(void 0, 
+          return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
             shell.exec(applyArgs, { cwd, stdin }),
             (applyResult) => {
               if (applyResult.exitCode !== 0) {
-                return _chunkKT4IKCIUcjs.asyncFail.call(void 0, 
+                return _chunk2P4PD6D7cjs.asyncFail.call(void 0, 
                   patchFailure(
                     operation,
                     applyResult.stderr || applyResult.stdout || `git apply exited with ${applyResult.exitCode}`,
@@ -2339,7 +2339,7 @@ var makeNodePatchService = (shell) => {
                   )
                 );
               }
-              return _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, { changedFiles });
+              return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { changedFiles });
             }
           );
         }
@@ -2554,7 +2554,7 @@ var validateAgentConfig = (config, sourcePath) => {
   }
   return config;
 };
-var isFile = _chunkKT4IKCIUcjs.async.call(void 0, path) => {
+var isFile = _chunk2P4PD6D7cjs.async.call(void 0, path) => {
   const { stat } = await dynamicImport3("node:fs/promises");
   try {
     return (await stat(path)).isFile();
@@ -2562,7 +2562,7 @@ var isFile = _chunkKT4IKCIUcjs.async.call(void 0, path) => {
     return false;
   }
 };
-var findConfigPath = _chunkKT4IKCIUcjs.async.call(void 0, cwd) => {
+var findConfigPath = _chunk2P4PD6D7cjs.async.call(void 0, cwd) => {
   const nodePath = await dynamicImport3("node:path");
   let current = nodePath.resolve(cwd);
   while (true) {
@@ -2575,7 +2575,7 @@ var findConfigPath = _chunkKT4IKCIUcjs.async.call(void 0, cwd) => {
     current = parent;
   }
 };
-var readConfigFile = _chunkKT4IKCIUcjs.async.call(void 0, path) => {
+var readConfigFile = _chunk2P4PD6D7cjs.async.call(void 0, path) => {
   const { readFile } = await dynamicImport3("node:fs/promises");
   const raw = String(await readFile(path, "utf8")).replace(/^\uFEFF/, "");
   try {
@@ -2587,7 +2587,7 @@ var readConfigFile = _chunkKT4IKCIUcjs.async.call(void 0, path) => {
     throw error;
   }
 };
-var loadNodeAgentConfig = _chunkKT4IKCIUcjs.async.call(void 0, options) => {
+var loadNodeAgentConfig = _chunk2P4PD6D7cjs.async.call(void 0, options) => {
   if (options.noConfig) return { config: {} };
   const nodePath = await dynamicImport3("node:path");
   if (options.configPath) {
@@ -2603,8 +2603,8 @@ var loadNodeAgentConfig = _chunkKT4IKCIUcjs.async.call(void 0, options) => {
 // src/agent/llm/openAICompatible.ts
 var extractText = (json) => _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([json, 'optionalAccess', _150 => _150.choices, 'optionalAccess', _151 => _151[0], 'optionalAccess', _152 => _152.message, 'optionalAccess', _153 => _153.content]), () => ( _optionalChain([json, 'optionalAccess', _154 => _154.output_text]))), () => ( _optionalChain([json, 'optionalAccess', _155 => _155.content, 'optionalAccess', _156 => _156[0], 'optionalAccess', _157 => _157.text]))), () => ( JSON.stringify(json)));
 var makeOpenAICompatibleLLM = (config) => ({
-  complete: (request) => _chunkKT4IKCIUcjs.fromPromiseAbortable.call(void 0, 
-    _chunkKT4IKCIUcjs.async.call(void 0, signal) => {
+  complete: (request) => _chunk2P4PD6D7cjs.fromPromiseAbortable.call(void 0, 
+    _chunk2P4PD6D7cjs.async.call(void 0, signal) => {
       const res = await fetch(config.endpoint, {
         method: "POST",
         signal,
@@ -2685,7 +2685,7 @@ var extractGoogleText = (json) => {
   }
   return JSON.stringify(json);
 };
-var responseErrorMessage = _chunkKT4IKCIUcjs.async.call(void 0, res) => {
+var responseErrorMessage = _chunk2P4PD6D7cjs.async.call(void 0, res) => {
   const raw = await res.text();
   try {
     const json = JSON.parse(raw);
@@ -2695,8 +2695,8 @@ var responseErrorMessage = _chunkKT4IKCIUcjs.async.call(void 0, res) => {
   }
 };
 var makeGoogleGenerativeAILLM = (config) => ({
-  complete: (request) => _chunkKT4IKCIUcjs.fromPromiseAbortable.call(void 0, 
-    _chunkKT4IKCIUcjs.async.call(void 0, signal) => {
+  complete: (request) => _chunk2P4PD6D7cjs.fromPromiseAbortable.call(void 0, 
+    _chunk2P4PD6D7cjs.async.call(void 0, signal) => {
       const res = await fetch(makeGenerateContentEndpoint(config), {
         method: "POST",
         signal,
@@ -2726,7 +2726,7 @@ var defaultContent = (request) => [
   "You can also set BRASS_FAKE_LLM_RESPONSE to provide a deterministic offline response, including a fenced ```diff block."
 ].join("\n");
 var makeFakeLLM = (options = {}) => ({
-  complete: (request) => _chunkKT4IKCIUcjs.asyncSucceed.call(void 0, {
+  complete: (request) => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, {
     content: typeof options.content === "function" ? options.content(request) : _nullishCoalesce(options.content, () => ( defaultContent(request)))
   })
 });