@sw4rm/js-sdk 0.4.0 → 0.6.0

package/dist/cjs/index.cjs

@@ -1856,25 +1856,25 @@ var require_codegen = __commonJS({
 var require_fetch = __commonJS({
   "node_modules/@protobufjs/fetch/index.js"(exports2, module2) {
     "use strict";
-    module2.exports = fetch;
+    module2.exports = fetch2;
     var asPromise = require_aspromise();
     var inquire2 = require_inquire();
-    var fs = inquire2("fs");
-    function fetch(filename, options, callback) {
+    var fs5 = inquire2("fs");
+    function fetch2(filename, options, callback) {
       if (typeof options === "function") {
         callback = options;
         options = {};
       } else if (!options)
         options = {};
       if (!callback)
-        return asPromise(fetch, this, filename, options);
-      if (!options.xhr && fs && fs.readFile)
-        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
-          return err && typeof XMLHttpRequest !== "undefined" ? fetch.xhr(filename, options, callback) : err ? callback(err) : callback(null, options.binary ? contents : contents.toString("utf8"));
+        return asPromise(fetch2, this, filename, options);
+      if (!options.xhr && fs5 && fs5.readFile)
+        return fs5.readFile(filename, function fetchReadFileCallback(err, contents) {
+          return err && typeof XMLHttpRequest !== "undefined" ? fetch2.xhr(filename, options, callback) : err ? callback(err) : callback(null, options.binary ? contents : contents.toString("utf8"));
         });
-      return fetch.xhr(filename, options, callback);
+      return fetch2.xhr(filename, options, callback);
     }
-    fetch.xhr = function fetch_xhr(filename, options, callback) {
+    fetch2.xhr = function fetch_xhr(filename, options, callback) {
       var xhr = new XMLHttpRequest();
       xhr.onreadystatechange = function fetchOnReadyStateChange() {
         if (xhr.readyState !== 4)
@@ -1907,15 +1907,15 @@ var require_fetch = __commonJS({
 var require_path = __commonJS({
   "node_modules/@protobufjs/path/index.js"(exports2) {
     "use strict";
-    var path4 = exports2;
+    var path7 = exports2;
     var isAbsolute = (
       /**
        * Tests if the specified path is absolute.
        * @param {string} path Path to test
        * @returns {boolean} `true` if path is absolute
        */
-      path4.isAbsolute = function isAbsolute2(path5) {
-        return /^(?:\/|\w+:)/.test(path5);
+      path7.isAbsolute = function isAbsolute2(path8) {
+        return /^(?:\/|\w+:)/.test(path8);
       }
     );
     var normalize = (
@@ -1924,9 +1924,9 @@ var require_path = __commonJS({
        * @param {string} path Path to normalize
        * @returns {string} Normalized path
        */
-      path4.normalize = function normalize2(path5) {
-        path5 = path5.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
-        var parts = path5.split("/"), absolute = isAbsolute(path5), prefix = "";
+      path7.normalize = function normalize2(path8) {
+        path8 = path8.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+        var parts = path8.split("/"), absolute = isAbsolute(path8), prefix = "";
         if (absolute)
           prefix = parts.shift() + "/";
         for (var i = 0; i < parts.length; ) {
@@ -1945,7 +1945,7 @@ var require_path = __commonJS({
         return prefix + parts.join("/");
       }
     );
-    path4.resolve = function resolve(originPath, includePath, alreadyNormalized) {
+    path7.resolve = function resolve(originPath, includePath, alreadyNormalized) {
       if (!alreadyNormalized)
         includePath = normalize(includePath);
       if (isAbsolute(includePath))
@@ -2096,16 +2096,16 @@ var require_namespace = __commonJS({
       object.onRemove(this);
       return clearCache(this);
     };
-    Namespace.prototype.define = function define2(path4, json) {
-      if (util.isString(path4))
-        path4 = path4.split(".");
-      else if (!Array.isArray(path4))
+    Namespace.prototype.define = function define2(path7, json) {
+      if (util.isString(path7))
+        path7 = path7.split(".");
+      else if (!Array.isArray(path7))
         throw TypeError("illegal path");
-      if (path4 && path4.length && path4[0] === "")
+      if (path7 && path7.length && path7[0] === "")
         throw Error("path must be relative");
       var ptr = this;
-      while (path4.length > 0) {
-        var part = path4.shift();
+      while (path7.length > 0) {
+        var part = path7.shift();
         if (ptr.nested && ptr.nested[part]) {
           ptr = ptr.nested[part];
           if (!(ptr instanceof Namespace))
@@ -2142,26 +2142,26 @@ var require_namespace = __commonJS({
       });
       return this;
     };
-    Namespace.prototype.lookup = function lookup(path4, filterTypes, parentAlreadyChecked) {
+    Namespace.prototype.lookup = function lookup(path7, filterTypes, parentAlreadyChecked) {
       if (typeof filterTypes === "boolean") {
         parentAlreadyChecked = filterTypes;
         filterTypes = void 0;
       } else if (filterTypes && !Array.isArray(filterTypes))
         filterTypes = [filterTypes];
-      if (util.isString(path4) && path4.length) {
-        if (path4 === ".")
+      if (util.isString(path7) && path7.length) {
+        if (path7 === ".")
           return this.root;
-        path4 = path4.split(".");
-      } else if (!path4.length)
+        path7 = path7.split(".");
+      } else if (!path7.length)
         return this;
-      var flatPath = path4.join(".");
-      if (path4[0] === "")
-        return this.root.lookup(path4.slice(1), filterTypes);
+      var flatPath = path7.join(".");
+      if (path7[0] === "")
+        return this.root.lookup(path7.slice(1), filterTypes);
       var found = this.root._fullyQualifiedObjects && this.root._fullyQualifiedObjects["." + flatPath];
       if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {
         return found;
       }
-      found = this._lookupImpl(path4, flatPath);
+      found = this._lookupImpl(path7, flatPath);
       if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {
         return found;
       }
@@ -2169,7 +2169,7 @@ var require_namespace = __commonJS({
         return null;
       var current = this;
       while (current.parent) {
-        found = current.parent._lookupImpl(path4, flatPath);
+        found = current.parent._lookupImpl(path7, flatPath);
         if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {
           return found;
         }
@@ -2177,49 +2177,49 @@ var require_namespace = __commonJS({
       }
       return null;
     };
-    Namespace.prototype._lookupImpl = function lookup(path4, flatPath) {
+    Namespace.prototype._lookupImpl = function lookup(path7, flatPath) {
       if (Object.prototype.hasOwnProperty.call(this._lookupCache, flatPath)) {
         return this._lookupCache[flatPath];
       }
-      var found = this.get(path4[0]);
+      var found = this.get(path7[0]);
       var exact = null;
       if (found) {
-        if (path4.length === 1) {
+        if (path7.length === 1) {
           exact = found;
         } else if (found instanceof Namespace) {
-          path4 = path4.slice(1);
-          exact = found._lookupImpl(path4, path4.join("."));
+          path7 = path7.slice(1);
+          exact = found._lookupImpl(path7, path7.join("."));
         }
       } else {
         for (var i = 0; i < this.nestedArray.length; ++i)
-          if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i]._lookupImpl(path4, flatPath)))
+          if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i]._lookupImpl(path7, flatPath)))
             exact = found;
       }
       this._lookupCache[flatPath] = exact;
       return exact;
     };
-    Namespace.prototype.lookupType = function lookupType(path4) {
-      var found = this.lookup(path4, [Type]);
+    Namespace.prototype.lookupType = function lookupType(path7) {
+      var found = this.lookup(path7, [Type]);
       if (!found)
-        throw Error("no such type: " + path4);
+        throw Error("no such type: " + path7);
       return found;
     };
-    Namespace.prototype.lookupEnum = function lookupEnum(path4) {
-      var found = this.lookup(path4, [Enum]);
+    Namespace.prototype.lookupEnum = function lookupEnum(path7) {
+      var found = this.lookup(path7, [Enum]);
       if (!found)
-        throw Error("no such Enum '" + path4 + "' in " + this);
+        throw Error("no such Enum '" + path7 + "' in " + this);
       return found;
     };
-    Namespace.prototype.lookupTypeOrEnum = function lookupTypeOrEnum(path4) {
-      var found = this.lookup(path4, [Type, Enum]);
+    Namespace.prototype.lookupTypeOrEnum = function lookupTypeOrEnum(path7) {
+      var found = this.lookup(path7, [Type, Enum]);
       if (!found)
-        throw Error("no such Type or Enum '" + path4 + "' in " + this);
+        throw Error("no such Type or Enum '" + path7 + "' in " + this);
       return found;
     };
-    Namespace.prototype.lookupService = function lookupService(path4) {
-      var found = this.lookup(path4, [Service]);
+    Namespace.prototype.lookupService = function lookupService(path7) {
+      var found = this.lookup(path7, [Service]);
       if (!found)
-        throw Error("no such Service '" + path4 + "' in " + this);
+        throw Error("no such Service '" + path7 + "' in " + this);
       return found;
     };
     Namespace._configure = function(Type_, Service_, Enum_) {
@@ -3365,12 +3365,12 @@ var require_root = __commonJS({
             if (parsed.imports) {
               for (; i2 < parsed.imports.length; ++i2)
                 if (resolved2 = getBundledFileName(parsed.imports[i2]) || self2.resolvePath(filename2, parsed.imports[i2]))
-                  fetch(resolved2);
+                  fetch2(resolved2);
             }
             if (parsed.weakImports) {
               for (i2 = 0; i2 < parsed.weakImports.length; ++i2)
                 if (resolved2 = getBundledFileName(parsed.weakImports[i2]) || self2.resolvePath(filename2, parsed.weakImports[i2]))
-                  fetch(resolved2, true);
+                  fetch2(resolved2, true);
             }
           }
         } catch (err) {
@@ -3380,7 +3380,7 @@ var require_root = __commonJS({
           finish(null, self2);
         }
       }
-      function fetch(filename2, weak) {
+      function fetch2(filename2, weak) {
         filename2 = getBundledFileName(filename2) || filename2;
         if (self2.files.indexOf(filename2) > -1) {
           return;
@@ -3432,7 +3432,7 @@ var require_root = __commonJS({
       }
       for (var i = 0, resolved; i < filename.length; ++i)
         if (resolved = self2.resolvePath("", filename[i]))
-          fetch(resolved);
+          fetch2(resolved);
       if (sync) {
         self2.resolveAll();
         return self2;
@@ -3620,14 +3620,14 @@ var require_util = __commonJS({
       Object.defineProperty(object, "$type", { value: enm, enumerable: false });
       return enm;
     };
-    util.setProperty = function setProperty(dst, path4, value, ifNotSet) {
-      function setProp(dst2, path5, value2) {
-        var part = path5.shift();
+    util.setProperty = function setProperty(dst, path7, value, ifNotSet) {
+      function setProp(dst2, path8, value2) {
+        var part = path8.shift();
         if (part === "__proto__" || part === "prototype") {
           return dst2;
         }
-        if (path5.length > 0) {
-          dst2[part] = setProp(dst2[part] || {}, path5, value2);
+        if (path8.length > 0) {
+          dst2[part] = setProp(dst2[part] || {}, path8, value2);
         } else {
           var prevValue = dst2[part];
           if (prevValue && ifNotSet)
@@ -3640,10 +3640,10 @@ var require_util = __commonJS({
       }
       if (typeof dst !== "object")
         throw TypeError("dst must be an object");
-      if (!path4)
+      if (!path7)
         throw TypeError("path must be specified");
-      path4 = path4.split(".");
-      return setProp(dst, path4, value);
+      path7 = path7.split(".");
+      return setProp(dst, path7, value);
     };
     Object.defineProperty(util, "decorateRoot", {
       get: function() {
@@ -4190,12 +4190,12 @@ var require_object = __commonJS({
        */
       fullName: {
         get: function() {
-          var path4 = [this.name], ptr = this.parent;
+          var path7 = [this.name], ptr = this.parent;
           while (ptr) {
-            path4.unshift(ptr.name);
+            path7.unshift(ptr.name);
             ptr = ptr.parent;
           }
-          return path4.join(".");
+          return path7.join(".");
         }
       }
     });
@@ -8177,19 +8177,19 @@ var require_util2 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.addCommonProtos = exports2.loadProtosWithOptionsSync = exports2.loadProtosWithOptions = void 0;
-    var fs = require("fs");
-    var path4 = require("path");
+    var fs5 = require("fs");
+    var path7 = require("path");
     var Protobuf = require_protobufjs();
     function addIncludePathResolver(root, includePaths) {
       const originalResolvePath = root.resolvePath;
       root.resolvePath = (origin, target) => {
-        if (path4.isAbsolute(target)) {
+        if (path7.isAbsolute(target)) {
           return target;
         }
         for (const directory of includePaths) {
-          const fullPath = path4.join(directory, target);
+          const fullPath = path7.join(directory, target);
           try {
-            fs.accessSync(fullPath, fs.constants.R_OK);
+            fs5.accessSync(fullPath, fs5.constants.R_OK);
             return fullPath;
           } catch (err) {
             continue;
@@ -9483,53 +9483,100 @@ var require_src2 = __commonJS({
 var src_exports = {};
 __export(src_exports, {
   ACKLifecycleManager: () => ACKLifecycleManager,
-  AckStage: () => AckStage,
+  AGENT_STATE_FAILED: () => AGENT_STATE_FAILED,
+  AGENT_STATE_INITIALIZING: () => AGENT_STATE_INITIALIZING,
+  AGENT_STATE_RUNNING: () => AGENT_STATE_RUNNING,
+  AGENT_STATE_SHUTTING_DOWN: () => AGENT_STATE_SHUTTING_DOWN,
+  AckStage: () => AckStage2,
   ActivityBuffer: () => ActivityBuffer,
   ActivityBufferSync: () => ActivityBufferSync,
   ActivityClient: () => ActivityClient,
   AgentState: () => AgentState,
   AgentStateMachine: () => AgentStateMachine,
+  AnthropicClient: () => AnthropicClient,
   ArtifactType: () => ArtifactType,
   BaseClient: () => BaseClient,
   BordaCountAggregator: () => BordaCountAggregator,
+  BufferFullError: () => BufferFullError,
   CT_AGENT_REPORT_V1: () => CT_AGENT_REPORT_V1,
   CT_SCHEDULER_COMMAND_V1: () => CT_SCHEDULER_COMMAND_V1,
+  CancellationManager: () => CancellationManager,
+  CancellationValidationError: () => CancellationValidationError,
+  CommunicationClass: () => CommunicationClass,
   ConfidenceWeightedAggregator: () => ConfidenceWeightedAggregator,
   ConnectorClient: () => ConnectorClient,
+  DEDUP_WINDOW_S: () => DEDUP_WINDOW_S,
+  DEFAULT_ACK_TIMEOUT_MS: () => DEFAULT_ACK_TIMEOUT_MS,
+  DEFAULT_BACKOFF_MULTIPLIER: () => DEFAULT_BACKOFF_MULTIPLIER,
+  DEFAULT_EFFECTIVE_MAX_REDIRECTS: () => DEFAULT_EFFECTIVE_MAX_REDIRECTS,
   DEFAULT_ESCALATION_POLICY: () => DEFAULT_ESCALATION_POLICY,
   DEFAULT_EXECUTION_POLICY: () => DEFAULT_EXECUTION_POLICY,
+  DEFAULT_INITIAL_BACKOFF_MS: () => DEFAULT_INITIAL_BACKOFF_MS,
+  DEFAULT_MAX_BACKOFF_MS: () => DEFAULT_MAX_BACKOFF_MS,
+  DEFAULT_MAX_REDIRECTS: () => DEFAULT_MAX_REDIRECTS,
+  DEFAULT_MAX_RETRIES_ON_OVERLOADED: () => DEFAULT_MAX_RETRIES_ON_OVERLOADED,
   DEFAULT_NEGOTIATION_POLICY: () => DEFAULT_NEGOTIATION_POLICY,
+  DEFAULT_PEER_LIVENESS_THRESHOLD_MS: () => DEFAULT_PEER_LIVENESS_THRESHOLD_MS,
+  DebateIntensity: () => DebateIntensity,
   DecisionOutcome: () => DecisionOutcome,
   DefaultWorktreePolicy: () => DefaultWorktreePolicy,
+  DuplicateDetectedError: () => DuplicateDetectedError,
+  EnvelopeState: () => EnvelopeState,
   ErrorCode: () => ErrorCode,
   ErrorCodeMapper: () => ErrorCodeMapper,
   FileBackend: () => FileBackend,
+  GatewayRedirectEmitter: () => GatewayRedirectEmitter,
+  GatewayValidationError: () => GatewayValidationError,
+  GroqClient: () => GroqClient,
   HITLClient: () => HITLClient,
   HandoffClient: () => HandoffClient,
   HandoffStatus: () => HandoffStatus,
   HandoffTimeoutError: () => HandoffTimeoutError,
   HandoffValidationError: () => HandoffValidationError,
   HitlMode: () => HitlMode,
+  HitlReasonType: () => HitlReasonType,
+  InMemoryAuditor: () => InMemoryAuditor,
+  InMemoryNegotiationRoomStore: () => InMemoryNegotiationRoomStore,
   InMemoryPolicyStore: () => InMemoryPolicyStore,
   InterceptorChain: () => InterceptorChain,
   JSONFilePersistence: () => JSONFilePersistence,
   JsonFilePolicyStore: () => JsonFilePolicyStore,
   KeyringBackend: () => KeyringBackend,
+  LlmAuthenticationError: () => LlmAuthenticationError,
+  LlmContextLengthError: () => LlmContextLengthError,
+  LlmError: () => LlmError,
+  LlmRateLimitError: () => LlmRateLimitError,
+  LlmTimeoutError: () => LlmTimeoutError,
   LoggingClient: () => LoggingClient,
+  MIN_GRACE_PERIOD_MS: () => MIN_GRACE_PERIOD_MS,
   MajorityVoteAggregator: () => MajorityVoteAggregator,
   MaxEntriesStrategy: () => MaxEntriesStrategy,
   MessageProcessor: () => MessageProcessor,
   MessageType: () => MessageType,
+  MockLlmClient: () => MockLlmClient,
+  NON_SERVING_AGENT_STATES: () => NON_SERVING_AGENT_STATES,
   NegotiationClient: () => NegotiationClient,
+  NegotiationError: () => NegotiationError,
   NegotiationRoomClient: () => NegotiationRoomClient,
+  NegotiationRoomStoreError: () => NegotiationRoomStoreError,
   NegotiationTimeoutError: () => NegotiationTimeoutError,
   NegotiationValidationError: () => NegotiationValidationError,
+  NoOpAuditor: () => NoOpAuditor,
   NodeStatus: () => NodeStatus,
+  PeerSelector: () => PeerSelector,
+  PermissionError: () => PermissionError,
+  PersistentActivityBuffer: () => PersistentActivityBuffer,
   PersistentWorktreeState: () => PersistentWorktreeState,
   PolicyStoreError: () => PolicyStoreError,
+  PolicyViolationError: () => PolicyViolationError,
+  PreemptionError: () => PreemptionError,
+  REGISTRATION_TYPE_STANDARD_AGENT: () => REGISTRATION_TYPE_STANDARD_AGENT,
+  REGISTRATION_TYPE_SWARM_GATEWAY: () => REGISTRATION_TYPE_SWARM_GATEWAY,
+  RETRY_AFTER_JITTER_RATIO: () => RETRY_AFTER_JITTER_RATIO,
   ReasoningClient: () => ReasoningClient,
   RegistryClient: () => RegistryClient,
   Resolver: () => Resolver,
+  RouteError: () => RouteError,
   RouterClient: () => RouterClient,
   RuntimePersistence: () => RuntimePersistence,
   SchedulerClient: () => SchedulerClient,
@@ -9547,40 +9594,69 @@ __export(src_exports, {
   SimpleAverageAggregator: () => SimpleAverageAggregator,
   StateTransitionError: () => StateTransitionError,
   Sw4rmError: () => Sw4rmError,
+  TimeoutError: () => TimeoutError,
+  TokenBucket: () => TokenBucket,
   ToolClient: () => ToolClient,
   TriggerType: () => TriggerType,
+  ValidationError: () => ValidationError,
   VotingAnalyzer: () => VotingAnalyzer,
   WorkflowClient: () => WorkflowClient,
   WorkflowCycleError: () => WorkflowCycleError,
   WorkflowStatus: () => WorkflowStatus,
   WorkflowValidationError: () => WorkflowValidationError,
   WorktreeClient: () => WorktreeClient,
+  WorktreeError: () => WorktreeError,
+  WorktreeStateEnum: () => WorktreeStateEnum,
+  WorktreeTransitionError: () => WorktreeTransitionError,
   aggregateVotes: () => aggregateVotes,
   buildAckEnvelope: () => buildAckEnvelope,
   buildEnvelope: () => buildEnvelope,
+  buildRateLimiterConfig: () => buildRateLimiterConfig,
+  computeEnvelopeHash: () => computeEnvelopeHash,
   computeIdempotencyToken: () => computeIdempotencyToken,
+  createLlmClient: () => createLlmClient,
   createResilientIncomingStream: () => createResilientIncomingStream,
+  createSimpleProof: () => createSimpleProof,
   decodeAgentReportV1: () => decodeAgentReportV1,
   decodeBase64: () => decodeBase64,
+  defaultAgentConfig: () => defaultAgentConfig,
+  defaultEndpoints: () => defaultEndpoints,
+  defaultRetryPolicy: () => defaultRetryPolicy,
+  defaultSW4RMConfig: () => defaultSW4RMConfig,
+  delegateToSwarm: () => delegateToSwarm,
   durationToMs: () => durationToMs,
   encodeSchedulerCommandV1: () => encodeSchedulerCommandV1,
+  getConfig: () => getConfig,
+  getDefaultStore: () => getDefaultStore,
+  getGlobalRateLimiter: () => getGlobalRateLimiter,
   getValidTransitions: () => getValidTransitions,
+  isTerminalEnvelopeState: () => isTerminalEnvelopeState,
   isValidTransition: () => isValidTransition,
+  isValidWorktreeTransition: () => isValidWorktreeTransition,
+  loadConfig: () => loadConfig,
+  loadConfigFromEnv: () => loadConfigFromEnv,
   loggingInterceptor: () => loggingInterceptor,
   mapGrpcStatusToErrorCode: () => mapGrpcStatusToErrorCode,
   msToDuration: () => msToDuration,
   normalizeReportPaths: () => normalizeReportPaths,
   nowTimestamp: () => nowTimestamp,
   parseNegotiationEvent: () => parseNegotiationEvent,
+  resetConfig: () => resetConfig,
+  resetDefaultStore: () => resetDefaultStore,
+  resetGlobalRateLimiter: () => resetGlobalRateLimiter,
   selectBackend: () => selectBackend,
   sendMessageWithAck: () => sendMessageWithAck,
+  setConfig: () => setConfig,
   timingInterceptor: () => timingInterceptor,
+  updateEnvelopeState: () => updateEnvelopeState,
   uuidv4: () => uuidv4,
+  verifyAuditProof: () => verifyAuditProof,
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/internal/baseClient.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
 var import_node_url = require("node:url");
 var grpc = __toESM(require("@grpc/grpc-js"), 1);
@@ -9602,6 +9678,10 @@ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
   ErrorCode2[ErrorCode2["PARTIAL_DELIVERY"] = 11] = "PARTIAL_DELIVERY";
   ErrorCode2[ErrorCode2["FORCED_PREEMPTION"] = 12] = "FORCED_PREEMPTION";
   ErrorCode2[ErrorCode2["TTL_EXPIRED"] = 13] = "TTL_EXPIRED";
+  ErrorCode2[ErrorCode2["DUPLICATE_DETECTED"] = 14] = "DUPLICATE_DETECTED";
+  ErrorCode2[ErrorCode2["ALREADY_IN_PROGRESS"] = 15] = "ALREADY_IN_PROGRESS";
+  ErrorCode2[ErrorCode2["OVERLOADED"] = 16] = "OVERLOADED";
+  ErrorCode2[ErrorCode2["REDIRECT"] = 20] = "REDIRECT";
   ErrorCode2[ErrorCode2["INTERNAL_ERROR"] = 99] = "INTERNAL_ERROR";
   return ErrorCode2;
 })(ErrorCode || {});
@@ -9617,6 +9697,54 @@ var Sw4rmError = class extends Error {
     this.details = opts?.details;
   }
 };
+var ValidationError = class extends Sw4rmError {
+  constructor(message, code = 6 /* VALIDATION_ERROR */, opts) {
+    super(message, code, opts);
+    this.name = "ValidationError";
+  }
+};
+var TimeoutError = class extends Sw4rmError {
+  constructor(message, code = 3 /* ACK_TIMEOUT */, opts) {
+    super(message, code, opts);
+    this.name = "TimeoutError";
+  }
+};
+var StateTransitionError = class extends Sw4rmError {
+  constructor(message, code = 99 /* INTERNAL_ERROR */, opts) {
+    super(message, code, opts);
+    this.name = "StateTransitionError";
+  }
+};
+var NegotiationError = class extends Sw4rmError {
+  constructor(message, code = 99 /* INTERNAL_ERROR */, opts) {
+    super(message, code, opts);
+    this.name = "NegotiationError";
+  }
+};
+var BufferFullError = class extends Sw4rmError {
+  constructor(message, code = 1 /* BUFFER_FULL */, opts) {
+    super(message, code, opts);
+    this.name = "BufferFullError";
+  }
+};
+var RouteError = class extends Sw4rmError {
+  constructor(message, code = 2 /* NO_ROUTE */, opts) {
+    super(message, code, opts);
+    this.name = "RouteError";
+  }
+};
+var PermissionError = class extends Sw4rmError {
+  constructor(message, code = 7 /* PERMISSION_DENIED */, opts) {
+    super(message, code, opts);
+    this.name = "PermissionError";
+  }
+};
+var DuplicateDetectedError = class extends Sw4rmError {
+  constructor(message, code = 14 /* DUPLICATE_DETECTED */, opts) {
+    super(message, code, opts);
+    this.name = "DuplicateDetectedError";
+  }
+};
 var GrpcStatus = {
   OK: 0,
   CANCELLED: 1,
@@ -9636,6 +9764,28 @@ var GrpcStatus = {
   DATA_LOSS: 15,
   UNAUTHENTICATED: 16
 };
+var PreemptionError = class extends Sw4rmError {
+  agentId;
+  reason;
+  constructor(agentId, reason, code = 12 /* FORCED_PREEMPTION */, opts) {
+    super(`Agent ${agentId} preempted: ${reason}`, code, opts);
+    this.name = "PreemptionError";
+    this.agentId = agentId;
+    this.reason = reason;
+  }
+};
+var WorktreeError = class extends Sw4rmError {
+  constructor(message, code = 99 /* INTERNAL_ERROR */, opts) {
+    super(message, code, opts);
+    this.name = "WorktreeError";
+  }
+};
+var PolicyViolationError = class extends Sw4rmError {
+  constructor(message, code = 7 /* PERMISSION_DENIED */, opts) {
+    super(message, code, opts);
+    this.name = "PolicyViolationError";
+  }
+};
 function mapGrpcStatusToErrorCode(status) {
   switch (status) {
     case GrpcStatus.OK:
@@ -9750,12 +9900,12 @@ var BaseClient = class {
   errorMapper = new ErrorCodeMapper();
   constructor(opts) {
     this.address = opts.address;
-    this.deadlineMs = opts.deadlineMs ?? 1e4;
+    this.deadlineMs = opts.deadlineMs ?? 3e4;
     this.retry = opts.retry ?? { maxAttempts: 3, initialBackoffMs: 200, maxBackoffMs: 2e3, multiplier: 2 };
     this.userAgent = opts.userAgent ?? "sw4rm-js-sdk/0.1";
     const __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
     const __dirname = import_node_path.default.dirname(__filename);
-    const protosDir = import_node_path.default.resolve(__dirname, "../../../../protos");
+    const protosDir = this.resolveProtosDir(__dirname);
     const loaderOpts = {
       keepCase: true,
       longs: String,
@@ -9775,10 +9925,13 @@ var BaseClient = class {
       "tool.proto",
       "connector.proto",
       "negotiation.proto",
+      "negotiation_room.proto",
       "reasoning.proto",
       "logging.proto",
       "policy.proto",
-      "activity.proto"
+      "activity.proto",
+      "handoff.proto",
+      "workflow.proto"
     ], loaderOpts);
     this.root = grpc.loadPackageDefinition(this.pkgDef);
     this.interceptors.use(timingInterceptor());
@@ -9788,6 +9941,27 @@ var BaseClient = class {
     if (opts.errorMapper)
       opts.errorMapper(this.errorMapper);
   }
+  /**
+   * Resolves the protos directory, checking multiple locations:
+   * 1. npm package: ./protos relative to package root
+   * 2. Monorepo dev: ../../../../protos relative to this file
+   */
+  resolveProtosDir(dirname3) {
+    const candidates = [
+      // npm package structure: node_modules/@sw4rm/js-sdk/protos
+      import_node_path.default.resolve(dirname3, "../../protos"),
+      // Alternative npm structure: dist/esm/internal -> protos
+      import_node_path.default.resolve(dirname3, "../../../protos"),
+      // Monorepo development: sdks/js_sdk/src/internal -> protos
+      import_node_path.default.resolve(dirname3, "../../../../protos")
+    ];
+    for (const candidate of candidates) {
+      if (import_node_fs.default.existsSync(candidate) && import_node_fs.default.existsSync(import_node_path.default.join(candidate, "common.proto"))) {
+        return candidate;
+      }
+    }
+    return candidates[candidates.length - 1];
+  }
   channelCredentials() {
     return grpc.credentials.createInsecure();
   }
@@ -10375,6 +10549,95 @@ var RegistryClient = class extends BaseClient {
   }
 };
 
+// src/clients/negotiationRoomStore.ts
+var NegotiationRoomStoreError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NegotiationRoomStoreError";
+  }
+};
+var InMemoryNegotiationRoomStore = class {
+  proposals = /* @__PURE__ */ new Map();
+  votes = /* @__PURE__ */ new Map();
+  decisions = /* @__PURE__ */ new Map();
+  async hasProposal(artifactId) {
+    return this.proposals.has(artifactId);
+  }
+  async getProposal(artifactId) {
+    return this.proposals.get(artifactId) || null;
+  }
+  async saveProposal(proposal) {
+    const artifactId = proposal.artifactId;
+    if (this.proposals.has(artifactId)) {
+      throw new NegotiationRoomStoreError(
+        `Proposal with artifact_id '${artifactId}' already exists`
+      );
+    }
+    const proposalWithTimestamp = {
+      ...proposal,
+      createdAt: proposal.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.proposals.set(artifactId, proposalWithTimestamp);
+    this.votes.set(artifactId, []);
+  }
+  async listProposals(negotiationRoomId) {
+    const allProposals = Array.from(this.proposals.values());
+    if (negotiationRoomId === void 0) {
+      return allProposals;
+    }
+    return allProposals.filter((p) => p.negotiationRoomId === negotiationRoomId);
+  }
+  async getVotes(artifactId) {
+    return [...this.votes.get(artifactId) || []];
+  }
+  async addVote(vote) {
+    const artifactId = vote.artifactId;
+    const criticId = vote.criticId;
+    const existingVotes = this.votes.get(artifactId) || [];
+    for (const existingVote of existingVotes) {
+      if (existingVote.criticId === criticId) {
+        throw new NegotiationRoomStoreError(
+          `Critic '${criticId}' has already voted for artifact '${artifactId}'`
+        );
+      }
+    }
+    const voteWithTimestamp = {
+      ...vote,
+      votedAt: vote.votedAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (!this.votes.has(artifactId)) {
+      this.votes.set(artifactId, []);
+    }
+    this.votes.get(artifactId).push(voteWithTimestamp);
+  }
+  async getDecision(artifactId) {
+    return this.decisions.get(artifactId) || null;
+  }
+  async saveDecision(decision) {
+    const artifactId = decision.artifactId;
+    if (this.decisions.has(artifactId)) {
+      throw new NegotiationRoomStoreError(
+        `Decision already exists for artifact_id '${artifactId}'`
+      );
+    }
+    const decisionWithTimestamp = {
+      ...decision,
+      decidedAt: decision.decidedAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.decisions.set(artifactId, decisionWithTimestamp);
+  }
+};
+var defaultStore = null;
+function getDefaultStore() {
+  if (defaultStore === null) {
+    defaultStore = new InMemoryNegotiationRoomStore();
+  }
+  return defaultStore;
+}
+function resetDefaultStore() {
+  defaultStore = null;
+}
+
 // src/clients/negotiationRoom.ts
 var ArtifactType = /* @__PURE__ */ ((ArtifactType2) => {
   ArtifactType2[ArtifactType2["ARTIFACT_TYPE_UNSPECIFIED"] = 0] = "ARTIFACT_TYPE_UNSPECIFIED";
@@ -10416,9 +10679,16 @@ function validateVote(vote) {
   }
 }
 var NegotiationRoomClient = class {
-  proposals = /* @__PURE__ */ new Map();
-  votes = /* @__PURE__ */ new Map();
-  decisions = /* @__PURE__ */ new Map();
+  store;
+  /**
+   * Create a new negotiation room client.
+   *
+   * @param options - Configuration options. If no store is provided,
+   *                  uses the shared default in-memory store.
+   */
+  constructor(options = {}) {
+    this.store = options.store || getDefaultStore();
+  }
   /**
    * Submit an artifact proposal for multi-agent review.
    *
@@ -10446,19 +10716,8 @@ var NegotiationRoomClient = class {
    * ```
    */
   async submitProposal(proposal) {
-    const artifactId = proposal.artifactId;
-    if (this.proposals.has(artifactId)) {
-      throw new NegotiationValidationError(
-        `Proposal with artifact_id '${artifactId}' already exists`
-      );
-    }
-    const proposalWithTimestamp = {
-      ...proposal,
-      createdAt: proposal.createdAt || (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.proposals.set(artifactId, proposalWithTimestamp);
-    this.votes.set(artifactId, []);
-    return artifactId;
+    await this.store.saveProposal(proposal);
+    return proposal.artifactId;
   }
   /**
    * Submit a critic's vote for an artifact.
@@ -10490,26 +10749,13 @@ var NegotiationRoomClient = class {
    */
   async submitVote(vote) {
     const artifactId = vote.artifactId;
-    if (!this.proposals.has(artifactId)) {
+    if (!await this.store.hasProposal(artifactId)) {
       throw new NegotiationValidationError(
         `No proposal found for artifact_id '${artifactId}'`
       );
     }
     validateVote(vote);
-    const existingVotes = this.votes.get(artifactId) || [];
-    for (const existingVote of existingVotes) {
-      if (existingVote.criticId === vote.criticId) {
-        throw new NegotiationValidationError(
-          `Critic '${vote.criticId}' has already voted for artifact '${artifactId}'`
-        );
-      }
-    }
-    const voteWithTimestamp = {
-      ...vote,
-      votedAt: vote.votedAt || (/* @__PURE__ */ new Date()).toISOString()
-    };
-    existingVotes.push(voteWithTimestamp);
-    this.votes.set(artifactId, existingVotes);
+    await this.store.addVote(vote);
   }
   /**
    * Retrieve all votes for a specific artifact.
@@ -10529,12 +10775,12 @@ var NegotiationRoomClient = class {
    * ```
    */
   async getVotes(artifactId) {
-    if (!this.proposals.has(artifactId)) {
+    if (!await this.store.hasProposal(artifactId)) {
       throw new NegotiationValidationError(
         `No proposal found for artifact_id '${artifactId}'`
       );
     }
-    return this.votes.get(artifactId) || [];
+    return this.store.getVotes(artifactId);
   }
   /**
    * Retrieve the decision for a specific artifact if available.
@@ -10555,12 +10801,12 @@ var NegotiationRoomClient = class {
    * ```
    */
   async getDecision(artifactId) {
-    if (!this.proposals.has(artifactId)) {
+    if (!await this.store.hasProposal(artifactId)) {
       throw new NegotiationValidationError(
         `No proposal found for artifact_id '${artifactId}'`
       );
     }
-    return this.decisions.get(artifactId) || null;
+    return this.store.getDecision(artifactId);
   }
   /**
    * Store a decision for an artifact.
@@ -10591,21 +10837,12 @@ var NegotiationRoomClient = class {
    */
   async storeDecision(decision) {
     const artifactId = decision.artifactId;
-    if (!this.proposals.has(artifactId)) {
+    if (!await this.store.hasProposal(artifactId)) {
       throw new NegotiationValidationError(
         `No proposal found for artifact_id '${artifactId}'`
       );
     }
-    if (this.decisions.has(artifactId)) {
-      throw new NegotiationValidationError(
-        `Decision already exists for artifact_id '${artifactId}'`
-      );
-    }
-    const decisionWithTimestamp = {
-      ...decision,
-      decidedAt: decision.decidedAt || (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.decisions.set(artifactId, decisionWithTimestamp);
+    await this.store.saveDecision(decision);
   }
   /**
    * Wait for a decision to be made on an artifact.
@@ -10629,14 +10866,14 @@ var NegotiationRoomClient = class {
    * ```
    */
   async waitForDecision(artifactId, timeoutMs = 3e4, pollIntervalMs = 100) {
-    if (!this.proposals.has(artifactId)) {
+    if (!await this.store.hasProposal(artifactId)) {
       throw new NegotiationValidationError(
         `No proposal found for artifact_id '${artifactId}'`
       );
     }
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
-      const decision = await this.getDecision(artifactId);
+      const decision = await this.store.getDecision(artifactId);
       if (decision !== null) {
         return decision;
       }
@@ -10662,7 +10899,7 @@ var NegotiationRoomClient = class {
    * ```
    */
   async getProposal(artifactId) {
-    return this.proposals.get(artifactId) || null;
+    return this.store.getProposal(artifactId);
   }
   /**
    * List all proposals, optionally filtered by negotiation room.
@@ -10677,13 +10914,7 @@ var NegotiationRoomClient = class {
    * ```
    */
   async listProposals(negotiationRoomId) {
-    const allProposals = Array.from(this.proposals.values());
-    if (negotiationRoomId === void 0) {
-      return allProposals;
-    }
-    return allProposals.filter(
-      (p) => p.negotiationRoomId === negotiationRoomId
-    );
+    return this.store.listProposals(negotiationRoomId);
   }
 };
 function aggregateVotes(votes) {
@@ -10726,6 +10957,38 @@ var HandoffStatus = /* @__PURE__ */ ((HandoffStatus2) => {
   HandoffStatus2[HandoffStatus2["EXPIRED"] = 5] = "EXPIRED";
   return HandoffStatus2;
 })(HandoffStatus || {});
+var DEFAULT_MAX_RETRIES_ON_OVERLOADED = 2;
+var DEFAULT_INITIAL_BACKOFF_MS = 250;
+var DEFAULT_BACKOFF_MULTIPLIER = 2;
+var DEFAULT_MAX_BACKOFF_MS = 2e3;
+var DEFAULT_MAX_REDIRECTS = 0;
+function defaultDelegationPolicy() {
+  return {
+    maxRetriesOnOverloaded: DEFAULT_MAX_RETRIES_ON_OVERLOADED,
+    initialBackoffMs: DEFAULT_INITIAL_BACKOFF_MS,
+    backoffMultiplier: DEFAULT_BACKOFF_MULTIPLIER,
+    maxBackoffMs: DEFAULT_MAX_BACKOFF_MS,
+    allowSpilloverRouting: false,
+    maxRedirects: DEFAULT_MAX_REDIRECTS
+  };
+}
+function normalizeDelegationPolicy(policy) {
+  const defaults = defaultDelegationPolicy();
+  const maxRetriesOnOverloaded = policy?.maxRetriesOnOverloaded;
+  const initialBackoffMs = policy?.initialBackoffMs;
+  const backoffMultiplier = policy?.backoffMultiplier;
+  const maxBackoffMs = policy?.maxBackoffMs;
+  const allowSpilloverRouting = policy?.allowSpilloverRouting;
+  const maxRedirects = policy?.maxRedirects;
+  return {
+    maxRetriesOnOverloaded: maxRetriesOnOverloaded === void 0 ? defaults.maxRetriesOnOverloaded : maxRetriesOnOverloaded,
+    initialBackoffMs: initialBackoffMs !== void 0 && initialBackoffMs > 0 ? initialBackoffMs : defaults.initialBackoffMs,
+    backoffMultiplier: backoffMultiplier !== void 0 && backoffMultiplier > 0 ? backoffMultiplier : defaults.backoffMultiplier,
+    maxBackoffMs: maxBackoffMs !== void 0 && maxBackoffMs > 0 ? maxBackoffMs : defaults.maxBackoffMs,
+    allowSpilloverRouting: allowSpilloverRouting ?? defaults.allowSpilloverRouting,
+    maxRedirects: maxRedirects === void 0 ? defaults.maxRedirects : maxRedirects
+  };
+}
 var HandoffValidationError = class extends Error {
   constructor(message) {
     super(message);
@@ -10774,9 +11037,15 @@ var HandoffClient = class {
         `Handoff request with ID '${request.requestId}' already exists`
       );
     }
+    if (request.budget !== void 0 && (!request.budget.deadlineEpochMs || request.budget.deadlineEpochMs <= 0)) {
+      throw new HandoffValidationError(
+        "budget.deadlineEpochMs is required for cross-swarm delegation"
+      );
+    }
     const requestWithTimestamp = {
       ...request,
-      createdAt: request.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+      createdAt: request.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+      delegationPolicy: request.budget !== void 0 || request.delegationPolicy !== void 0 ? normalizeDelegationPolicy(request.delegationPolicy) : void 0
     };
     this.requests.set(request.requestId, requestWithTimestamp);
     if (request.toAgent) {
@@ -10798,7 +11067,8 @@ var HandoffClient = class {
     const timeoutResponse = {
       requestId: request.requestId,
       accepted: false,
-      rejectionReason: `Handoff request timed out after ${timeoutMs}ms`
+      rejectionReason: `Handoff request timed out after ${timeoutMs}ms`,
+      rejectionCode: 3 /* ACK_TIMEOUT */
     };
     this.responses.set(request.requestId, timeoutResponse);
     if (request.toAgent && this.pendingByAgent.has(request.toAgent)) {
@@ -10863,7 +11133,7 @@ var HandoffClient = class {
    * await client.rejectHandoff("handoff-123", "Agent at capacity");
    * ```
    */
-  async rejectHandoff(handoffId, reason) {
+  async rejectHandoff(handoffId, reason, options) {
     const request = this.requests.get(handoffId);
     if (!request) {
       throw new HandoffValidationError(
@@ -10878,7 +11148,10 @@ var HandoffClient = class {
     const response = {
       requestId: handoffId,
       accepted: false,
-      rejectionReason: reason
+      rejectionReason: reason,
+      rejectionCode: options?.rejectionCode ?? 0 /* ERROR_CODE_UNSPECIFIED */,
+      retryAfterMs: options?.retryAfterMs,
+      redirectToAgentId: options?.redirectToAgentId
     };
     this.responses.set(handoffId, response);
     if (request.toAgent && this.pendingByAgent.has(request.toAgent)) {
@@ -11311,6 +11584,31 @@ var WorkflowClient = class {
       instance.completedAt = (/* @__PURE__ */ new Date()).toISOString();
     }
   }
+  /**
+   * Resume a workflow by marking a node as completed and advancing dependents.
+   *
+   * Implements the ResumeWorkflow RPC (spec §17.7 MUST). Marks the specified
+   * node as COMPLETED, updates workflow data if provided, then transitions
+   * dependent nodes from PENDING to READY when all their dependencies are met.
+   *
+   * @param instanceId - The ID of the workflow instance
+   * @param nodeId - The ID of the node to mark as completed
+   * @param workflowData - Optional updated workflow data (JSON string)
+   * @param metadata - Optional metadata for the resume operation
+   * @returns The updated workflow instance
+   * @throws WorkflowValidationError if the instance or node does not exist
+   */
+  async resumeWorkflow(instanceId, nodeId, workflowData, metadata) {
+    await this.updateNodeState(instanceId, nodeId, 4 /* COMPLETED */);
+    if (workflowData !== void 0) {
+      await this.updateWorkflowData(instanceId, workflowData);
+    }
+    if (metadata) {
+      const instance = this.instances.get(instanceId);
+      Object.assign(instance.metadata, metadata);
+    }
+    return this.getWorkflowStatus(instanceId);
+  }
   /**
    * Update the shared workflow data.
    *
@@ -11332,6 +11630,21 @@ var WorkflowClient = class {
 
 // src/internal/envelope.ts
 var import_node_crypto2 = __toESM(require("node:crypto"), 1);
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2[MessageType2["MESSAGE_TYPE_UNSPECIFIED"] = 0] = "MESSAGE_TYPE_UNSPECIFIED";
+  MessageType2[MessageType2["CONTROL"] = 1] = "CONTROL";
+  MessageType2[MessageType2["DATA"] = 2] = "DATA";
+  MessageType2[MessageType2["HEARTBEAT"] = 3] = "HEARTBEAT";
+  MessageType2[MessageType2["NOTIFICATION"] = 4] = "NOTIFICATION";
+  MessageType2[MessageType2["ACKNOWLEDGEMENT"] = 5] = "ACKNOWLEDGEMENT";
+  MessageType2[MessageType2["HITL_INVOCATION"] = 6] = "HITL_INVOCATION";
+  MessageType2[MessageType2["WORKTREE_CONTROL"] = 7] = "WORKTREE_CONTROL";
+  MessageType2[MessageType2["NEGOTIATION"] = 8] = "NEGOTIATION";
+  MessageType2[MessageType2["TOOL_CALL"] = 9] = "TOOL_CALL";
+  MessageType2[MessageType2["TOOL_RESULT"] = 10] = "TOOL_RESULT";
+  MessageType2[MessageType2["TOOL_ERROR"] = 11] = "TOOL_ERROR";
+  return MessageType2;
+})(MessageType || {});
 function nowTimestamp(date = /* @__PURE__ */ new Date()) {
   const ms = date.getTime();
   const seconds = Math.floor(ms / 1e3);
@@ -11339,7 +11652,15 @@ function nowTimestamp(date = /* @__PURE__ */ new Date()) {
   return { seconds, nanos };
 }
 function nowHlcStub(date = /* @__PURE__ */ new Date()) {
-  return String(date.getTime());
+  const wallUs = date.getTime() * 1e3;
+  let node = "unknown";
+  try {
+    const os3 = require("node:os");
+    node = os3.hostname() || "unknown";
+  } catch {
+    node = "browser";
+  }
+  return `HLC:${wallUs}:0:${node}`;
 }
 function uuidv42() {
   if (typeof import_node_crypto2.default.randomUUID === "function") {
@@ -11375,7 +11696,12 @@ function buildEnvelope(input) {
     hlc_timestamp,
     // Always set hlc_timestamp (aligns with Python/Rust)
     ttl_ms: input.ttl_ms,
-    timestamp: ts
+    timestamp: ts,
+    state: input.state ?? 1,
+    // EnvelopeState.CREATED
+    effective_policy_id: input.effective_policy_id ?? "",
+    audit_proof: input.audit_proof ?? new Uint8Array(0),
+    audit_policy_id: input.audit_policy_id ?? ""
   };
   if (hasPayload) {
     const payload = input.payload instanceof Uint8Array ? input.payload : new Uint8Array(input.payload);
@@ -11389,25 +11715,141 @@ function buildEnvelope(input) {
 }
 
 // src/internal/worktreeState.ts
+var VALID_WORKTREE_TRANSITIONS = {
+  UNBOUND: ["BOUND_HOME", "BIND_FAILED"],
+  BOUND_HOME: ["SWITCH_PENDING", "UNBOUND"],
+  SWITCH_PENDING: ["BOUND_NON_HOME", "BOUND_HOME"],
+  // approve or reject
+  BOUND_NON_HOME: ["BOUND_HOME", "UNBOUND"],
+  // TTL expired/revoke, or unbind
+  BIND_FAILED: ["UNBOUND", "BOUND_HOME"]
+  // retry reset or successful retry
+};
+function isValidWorktreeTransition(from, to) {
+  return VALID_WORKTREE_TRANSITIONS[from]?.includes(to) ?? false;
+}
+var WorktreeTransitionError = class extends Error {
+  fromState;
+  toState;
+  constructor(from, to) {
+    super(`Invalid worktree state transition from ${from} to ${to}`);
+    this.name = "WorktreeTransitionError";
+    this.fromState = from;
+    this.toState = to;
+  }
+};
 var PersistentWorktreeState = class {
   state = "UNBOUND";
   repoId;
   worktreeId;
+  homeRepoId;
+  homeWorktreeId;
+  switchTtlMs;
+  switchTimer;
+  /**
+   * Transition to a new state with validation.
+   * @throws WorktreeTransitionError if transition is invalid
+   */
+  transitionTo(newState) {
+    if (!isValidWorktreeTransition(this.state, newState)) {
+      throw new WorktreeTransitionError(this.state, newState);
+    }
+    this.state = newState;
+  }
+  /**
+   * Bind to a home worktree (UNBOUND -> BOUND_HOME or BIND_FAILED -> BOUND_HOME).
+   */
   bind(repoId, worktreeId) {
+    this.transitionTo("BOUND_HOME");
     this.repoId = repoId;
     this.worktreeId = worktreeId;
-    this.state = "BOUND_HOME";
+    this.homeRepoId = repoId;
+    this.homeWorktreeId = worktreeId;
+  }
+  /**
+   * Handle bind failure (UNBOUND -> BIND_FAILED).
+   */
+  bindFailed() {
+    this.transitionTo("BIND_FAILED");
   }
+  /**
+   * Unbind from current worktree.
+   */
   unbind() {
+    this.clearSwitchTimer();
+    this.transitionTo("UNBOUND");
     this.repoId = void 0;
     this.worktreeId = void 0;
-    this.state = "UNBOUND";
+  }
+  /**
+   * Request switch to a non-home worktree (BOUND_HOME -> SWITCH_PENDING).
+   * Requires approval or rejection before taking effect.
+   */
+  requestSwitch(targetRepoId, targetWorktreeId) {
+    this.transitionTo("SWITCH_PENDING");
+    this._pendingRepoId = targetRepoId;
+    this._pendingWorktreeId = targetWorktreeId;
+  }
+  /**
+   * Approve a pending switch (SWITCH_PENDING -> BOUND_NON_HOME).
+   * @param ttlMs - Time-to-live in milliseconds before auto-reverting to BOUND_HOME
+   */
+  approveSwitch(ttlMs = 3e5) {
+    this.transitionTo("BOUND_NON_HOME");
+    this.repoId = this._pendingRepoId;
+    this.worktreeId = this._pendingWorktreeId;
+    this.switchTtlMs = ttlMs;
+    this.clearSwitchTimer();
+    this.switchTimer = setTimeout(() => {
+      this.revertToHome();
+    }, ttlMs);
+  }
+  /**
+   * Reject a pending switch (SWITCH_PENDING -> BOUND_HOME).
+   */
+  rejectSwitch() {
+    this.transitionTo("BOUND_HOME");
+    this.repoId = this.homeRepoId;
+    this.worktreeId = this.homeWorktreeId;
+    delete this._pendingRepoId;
+    delete this._pendingWorktreeId;
+  }
+  /**
+   * Revert from non-home to home worktree (BOUND_NON_HOME -> BOUND_HOME).
+   * Called on TTL expiry or explicit revoke.
+   */
+  revertToHome() {
+    this.clearSwitchTimer();
+    if (this.state === "BOUND_NON_HOME") {
+      this.transitionTo("BOUND_HOME");
+      this.repoId = this.homeRepoId;
+      this.worktreeId = this.homeWorktreeId;
+    }
+  }
+  /**
+   * Reset from BIND_FAILED to UNBOUND for retry.
+   */
+  resetFromFailed() {
+    this.transitionTo("UNBOUND");
+  }
+  clearSwitchTimer() {
+    if (this.switchTimer) {
+      clearTimeout(this.switchTimer);
+      this.switchTimer = void 0;
+    }
   }
   setState(state) {
     this.state = state;
   }
   current() {
-    return { state: this.state, repo_id: this.repoId, worktree_id: this.worktreeId };
+    return {
+      state: this.state,
+      repo_id: this.repoId,
+      worktree_id: this.worktreeId,
+      home_repo_id: this.homeRepoId,
+      home_worktree_id: this.homeWorktreeId,
+      switch_ttl_ms: this.switchTtlMs
+    };
   }
 };
 
@@ -11469,16 +11911,6 @@ var ActivityBuffer = class {
 };
 
 // src/internal/runtime/ackLifecycle.ts
-var AckStage = /* @__PURE__ */ ((AckStage2) => {
-  AckStage2[AckStage2["ACK_STAGE_UNSPECIFIED"] = 0] = "ACK_STAGE_UNSPECIFIED";
-  AckStage2[AckStage2["RECEIVED"] = 1] = "RECEIVED";
-  AckStage2[AckStage2["READ"] = 2] = "READ";
-  AckStage2[AckStage2["FULFILLED"] = 3] = "FULFILLED";
-  AckStage2[AckStage2["REJECTED"] = 4] = "REJECTED";
-  AckStage2[AckStage2["FAILED"] = 5] = "FAILED";
-  AckStage2[AckStage2["TIMED_OUT"] = 6] = "TIMED_OUT";
-  return AckStage2;
-})(AckStage || {});
 var ACKLifecycleManager = class {
   acks = /* @__PURE__ */ new Map();
   mark(messageId, stage, note, errorCode) {
@@ -11515,21 +11947,6 @@ var ACKLifecycleManager = class {
 };
 
 // src/internal/runtime/messageProcessor.ts
-var MessageType = /* @__PURE__ */ ((MessageType3) => {
-  MessageType3[MessageType3["MESSAGE_TYPE_UNSPECIFIED"] = 0] = "MESSAGE_TYPE_UNSPECIFIED";
-  MessageType3[MessageType3["CONTROL"] = 1] = "CONTROL";
-  MessageType3[MessageType3["DATA"] = 2] = "DATA";
-  MessageType3[MessageType3["HEARTBEAT"] = 3] = "HEARTBEAT";
-  MessageType3[MessageType3["NOTIFICATION"] = 4] = "NOTIFICATION";
-  MessageType3[MessageType3["ACKNOWLEDGEMENT"] = 5] = "ACKNOWLEDGEMENT";
-  MessageType3[MessageType3["HITL_INVOCATION"] = 6] = "HITL_INVOCATION";
-  MessageType3[MessageType3["WORKTREE_CONTROL"] = 7] = "WORKTREE_CONTROL";
-  MessageType3[MessageType3["NEGOTIATION"] = 8] = "NEGOTIATION";
-  MessageType3[MessageType3["TOOL_CALL"] = 9] = "TOOL_CALL";
-  MessageType3[MessageType3["TOOL_RESULT"] = 10] = "TOOL_RESULT";
-  MessageType3[MessageType3["TOOL_ERROR"] = 11] = "TOOL_ERROR";
-  return MessageType3;
-})(MessageType || {});
 var MessageProcessor = class {
   handlers = /* @__PURE__ */ new Map();
   defaultHandler;
@@ -11696,35 +12113,571 @@ function decodeBase64(b64) {
   return new Uint8Array(Buffer.from(b64, "base64"));
 }
 
-// src/persistence/persistence.ts
-var import_promises = __toESM(require("node:fs/promises"), 1);
-var import_node_path2 = __toESM(require("node:path"), 1);
-var JSONFilePersistence = class {
-  constructor(baseDir) {
-    this.baseDir = baseDir;
-    this.activityFile = import_node_path2.default.join(baseDir, "activity.json");
-    this.acksFile = import_node_path2.default.join(baseDir, "acks.json");
+// src/runtime/delegation.ts
+var import_node_crypto3 = require("node:crypto");
+var RETRY_AFTER_JITTER_RATIO = 0.2;
+var DEFAULT_EFFECTIVE_MAX_REDIRECTS = 2;
+function defaultNowMs() {
+  return Date.now();
+}
+function defaultSleepMs(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function defaultRandUniform(low, high) {
+  if (high <= low) {
+    return low;
   }
-  activityFile;
-  acksFile;
-  async safeWrite(file, data) {
-    await import_promises.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
-    const tmp = `${file}.tmp-${Date.now()}`;
-    await import_promises.default.writeFile(tmp, data, "utf8");
-    await import_promises.default.rename(tmp, file);
+  return low + Math.random() * (high - low);
+}
+function normalizePolicy(policy) {
+  return {
+    maxRetriesOnOverloaded: policy?.maxRetriesOnOverloaded ?? DEFAULT_MAX_RETRIES_ON_OVERLOADED,
+    initialBackoffMs: policy?.initialBackoffMs !== void 0 && policy.initialBackoffMs > 0 ? policy.initialBackoffMs : DEFAULT_INITIAL_BACKOFF_MS,
+    backoffMultiplier: policy?.backoffMultiplier !== void 0 && policy.backoffMultiplier > 0 ? policy.backoffMultiplier : DEFAULT_BACKOFF_MULTIPLIER,
+    maxBackoffMs: policy?.maxBackoffMs !== void 0 && policy.maxBackoffMs > 0 ? policy.maxBackoffMs : DEFAULT_MAX_BACKOFF_MS,
+    allowSpilloverRouting: policy?.allowSpilloverRouting ?? false,
+    maxRedirects: policy?.maxRedirects ?? DEFAULT_MAX_REDIRECTS
+  };
+}
+function deadlineExhaustedResponse(requestId) {
+  return {
+    requestId,
+    accepted: false,
+    rejectionReason: "Delegation deadline exhausted before handoff acceptance",
+    rejectionCode: 3 /* ACK_TIMEOUT */
+  };
+}
+function invalidRedirectResponse(requestId, reason) {
+  return {
+    requestId,
+    accepted: false,
+    rejectionReason: reason,
+    rejectionCode: 6 /* VALIDATION_ERROR */
+  };
+}
+function effectiveMaxRedirects(policy) {
+  const configured = policy.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
+  return configured > 0 ? configured : DEFAULT_EFFECTIVE_MAX_REDIRECTS;
+}
+function nextRetryWaitMs(response, retryIndex, policy, randUniformFn) {
+  if (response.retryAfterMs !== void 0 && response.retryAfterMs > 0) {
+    const retryAfter = response.retryAfterMs;
+    const jitter = randUniformFn(0, retryAfter * RETRY_AFTER_JITTER_RATIO);
+    return Math.floor(retryAfter + jitter);
+  }
+  const initialBackoffMs = policy.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF_MS;
+  const backoffMultiplier = policy.backoffMultiplier ?? DEFAULT_BACKOFF_MULTIPLIER;
+  const maxBackoffMs = policy.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+  const exponential = initialBackoffMs * backoffMultiplier ** retryIndex;
+  const bounded = Math.min(exponential, maxBackoffMs);
+  return Math.floor(randUniformFn(0, bounded));
+}
+function deductWallTime(request, elapsedMs) {
+  if (request.budget?.wallTimeRemainingMs !== void 0) {
+    request.budget.wallTimeRemainingMs = Math.max(
+      request.budget.wallTimeRemainingMs - elapsedMs,
+      0
+    );
   }
-  async saveActivity(records) {
-    const payload = JSON.stringify(records, null, 2);
-    await this.safeWrite(this.activityFile, payload);
+}
+function budgetExhausted(budget, nowMs) {
+  return budget.wallTimeRemainingMs !== void 0 && budget.wallTimeRemainingMs <= 0 || nowMs > budget.deadlineEpochMs;
+}
+async function delegateToSwarm(options) {
+  if (!options.budget.deadlineEpochMs || options.budget.deadlineEpochMs <= 0) {
+    throw new HandoffValidationError(
+      "budget.deadlineEpochMs is required for cross-swarm delegation"
+    );
   }
-  async loadActivity() {
-    try {
-      const buf = await import_promises.default.readFile(this.activityFile, "utf8");
-      return JSON.parse(buf);
-    } catch (e) {
-      if (e?.code === "ENOENT")
-        return [];
-      throw e;
+  if (options.timeoutMs !== void 0 && options.timeoutMs < 0) {
+    throw new HandoffValidationError("timeoutMs must be >= 0");
+  }
+  const nowMs = options.nowMsFn ?? defaultNowMs;
+  const sleepMs = options.sleepMsFn ?? defaultSleepMs;
+  const randUniform = options.randUniformFn ?? defaultRandUniform;
+  const policy = normalizePolicy(options.delegationPolicy);
+  const requestBudget = { ...options.budget };
+  const request = {
+    requestId: options.requestId ?? (0, import_node_crypto3.randomUUID)(),
+    fromAgent: options.fromAgent,
+    toAgent: options.toAgent,
+    reason: options.reason,
+    contextSnapshot: options.contextSnapshot ?? new Uint8Array(),
+    capabilitiesRequired: [...options.capabilitiesRequired ?? []],
+    priority: options.priority ?? 0,
+    timeoutMs: options.timeoutMs,
+    budget: requestBudget,
+    delegationPolicy: policy
+  };
+  const maxRetriesOnOverloaded = policy.maxRetriesOnOverloaded ?? DEFAULT_MAX_RETRIES_ON_OVERLOADED;
+  let retryIndex = 0;
+  let redirectHops = 0;
+  const redirectBound = effectiveMaxRedirects(policy);
+  const visitedAgents = /* @__PURE__ */ new Set([request.toAgent]);
+  while (true) {
+    const startMs = nowMs();
+    if (budgetExhausted(request.budget, startMs)) {
+      return deadlineExhaustedResponse(request.requestId);
+    }
+    const response = await options.sendHandoffFn(request);
+    const endMs = nowMs();
+    const elapsedMs = Math.max(endMs - startMs, 0);
+    deductWallTime(request, elapsedMs);
+    if (response.accepted) {
+      return response;
+    }
+    if (budgetExhausted(request.budget, endMs)) {
+      return deadlineExhaustedResponse(request.requestId);
+    }
+    if (response.rejectionCode !== 16 /* OVERLOADED */) {
+      if (response.rejectionCode !== 20 /* REDIRECT */) {
+        return response;
+      }
+      if (!policy.allowSpilloverRouting) {
+        return response;
+      }
+      const targetAgent = response.redirectToAgentId?.trim();
+      if (!targetAgent) {
+        return invalidRedirectResponse(
+          request.requestId,
+          "Redirect response missing non-empty redirectToAgentId"
+        );
+      }
+      if (visitedAgents.has(targetAgent)) {
+        return invalidRedirectResponse(
+          request.requestId,
+          `Redirect loop detected for agent '${targetAgent}'`
+        );
+      }
+      if (redirectHops >= redirectBound) {
+        return response;
+      }
+      request.toAgent = targetAgent;
+      visitedAgents.add(targetAgent);
+      redirectHops += 1;
+      continue;
+    }
+    if (retryIndex >= maxRetriesOnOverloaded) {
+      return response;
+    }
+    const waitMs = nextRetryWaitMs(response, retryIndex, policy, randUniform);
+    retryIndex += 1;
+    const remainingDeadlineMs = request.budget.deadlineEpochMs - endMs;
+    const remainingWallTimeMs = request.budget?.wallTimeRemainingMs;
+    if (waitMs <= 0 || remainingWallTimeMs !== void 0 && waitMs > remainingWallTimeMs || waitMs > remainingDeadlineMs) {
+      return response;
+    }
+    const beforeSleepMs = nowMs();
+    await sleepMs(waitMs);
+    const afterSleepMs = nowMs();
+    deductWallTime(request, Math.max(afterSleepMs - beforeSleepMs, 0));
+  }
+}
+
+// src/runtime/cancellation.ts
+var MIN_GRACE_PERIOD_MS = 5e3;
+var CancellationValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancellationValidationError";
+  }
+};
+function defaultNowMs2() {
+  return Date.now();
+}
+function normalizeCorrelationId(correlationId) {
+  const normalized = correlationId.trim();
+  if (!normalized) {
+    throw new CancellationValidationError(
+      "cancel.correlationId is required and must be a non-empty string"
+    );
+  }
+  return normalized;
+}
+function normalizeReason(reason) {
+  if (reason === void 0) {
+    return "";
+  }
+  return reason.trim();
+}
+function normalizeGracePeriodMs(gracePeriodMs) {
+  const requested = gracePeriodMs !== void 0 && Number.isFinite(gracePeriodMs) && gracePeriodMs > 0 ? Math.floor(gracePeriodMs) : 0;
+  return Math.max(requested, MIN_GRACE_PERIOD_MS);
+}
+function normalizeMetadataValue(value) {
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function normalizeMetadata(metadata, options) {
+  const { reason, gracePeriodMs } = options;
+  const normalized = {};
+  if (metadata !== void 0) {
+    for (const [rawKey, rawValue] of Object.entries(metadata)) {
+      const key = rawKey.trim();
+      if (!key) {
+        continue;
+      }
+      const value = normalizeMetadataValue(rawValue);
+      if (value !== void 0) {
+        normalized[key] = value;
+      }
+    }
+  }
+  normalized.reason = reason;
+  normalized.grace_period_ms = gracePeriodMs;
+  return normalized;
+}
+function cloneMetadata(metadata) {
+  return { ...metadata };
+}
+function cloneFlag(flag) {
+  return {
+    cancelled: flag.cancelled,
+    gracePeriodMs: flag.gracePeriodMs,
+    cancelTimeMs: flag.cancelTimeMs,
+    metadata: cloneMetadata(flag.metadata)
+  };
+}
+var CancellationManager = class {
+  childDelegations = /* @__PURE__ */ new Map();
+  cancellationFlags = /* @__PURE__ */ new Map();
+  nowMs;
+  constructor(options = {}) {
+    this.nowMs = options.nowMsFn ?? defaultNowMs2;
+  }
+  registerChildDelegation(parentCorrelationId, childCorrelationId) {
+    const parent = normalizeCorrelationId(parentCorrelationId);
+    const child = normalizeCorrelationId(childCorrelationId);
+    if (!this.childDelegations.has(parent)) {
+      this.childDelegations.set(parent, /* @__PURE__ */ new Set());
+    }
+    this.childDelegations.get(parent).add(child);
+  }
+  handleCancelDelegation(cancel) {
+    const correlationId = normalizeCorrelationId(cancel.correlationId);
+    const gracePeriodMs = normalizeGracePeriodMs(cancel.gracePeriodMs);
+    const reason = normalizeReason(cancel.reason);
+    const cancelTimeMs = this.nowMs();
+    const metadata = normalizeMetadata(cancel.metadata, {
+      reason,
+      gracePeriodMs
+    });
+    const flag = {
+      cancelled: true,
+      gracePeriodMs,
+      cancelTimeMs,
+      metadata
+    };
+    this.cancellationFlags.set(correlationId, cloneFlag(flag));
+    for (const childCorrelationId of this.childDelegations.get(correlationId) ?? []) {
+      this.cancellationFlags.set(childCorrelationId, cloneFlag(flag));
+    }
+    return {
+      acknowledged: true,
+      correlationId,
+      gracePeriodMs,
+      message: "Cancellation recorded",
+      metadata: cloneMetadata(metadata)
+    };
+  }
+  isCancelled(correlationId) {
+    const normalized = correlationId.trim();
+    if (!normalized) {
+      return false;
+    }
+    const entry = this.cancellationFlags.get(normalized);
+    return Boolean(entry?.cancelled);
+  }
+  isGraceExpired(correlationId, nowMs) {
+    const normalized = correlationId.trim();
+    if (!normalized) {
+      return false;
+    }
+    const entry = this.cancellationFlags.get(normalized);
+    if (entry === void 0 || !entry.cancelled) {
+      return false;
+    }
+    const currentMs = nowMs ?? this.nowMs();
+    return currentMs - entry.cancelTimeMs >= entry.gracePeriodMs;
+  }
+  forcedPreemptionErrorCode(correlationId, nowMs) {
+    if (this.isGraceExpired(correlationId, nowMs)) {
+      return 12 /* FORCED_PREEMPTION */;
+    }
+    return 0 /* ERROR_CODE_UNSPECIFIED */;
+  }
+  collectForcedPreemptions(correlationIds, nowMs) {
+    const currentMs = nowMs ?? this.nowMs();
+    const forced = /* @__PURE__ */ new Set();
+    for (const correlationId of correlationIds) {
+      if (this.isGraceExpired(correlationId, currentMs)) {
+        forced.add(correlationId);
+      }
+    }
+    return forced;
+  }
+};
+
+// src/runtime/gateway.ts
+var REGISTRATION_TYPE_STANDARD_AGENT = 1;
+var REGISTRATION_TYPE_SWARM_GATEWAY = 2;
+var AGENT_STATE_INITIALIZING = 1;
+var AGENT_STATE_RUNNING = 4;
+var AGENT_STATE_FAILED = 10;
+var AGENT_STATE_SHUTTING_DOWN = 11;
+var DEFAULT_PEER_LIVENESS_THRESHOLD_MS = 3e4;
+var NON_SERVING_AGENT_STATES = /* @__PURE__ */ new Set([
+  AGENT_STATE_INITIALIZING,
+  AGENT_STATE_FAILED,
+  AGENT_STATE_SHUTTING_DOWN
+]);
+var GatewayValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GatewayValidationError";
+  }
+};
+function defaultNowMs3() {
+  return Date.now();
+}
+function sameCapabilities(peerCapabilities, localCapabilities) {
+  const peerSet = new Set(peerCapabilities);
+  if (peerSet.size !== localCapabilities.size) {
+    return false;
+  }
+  for (const localCapability of localCapabilities) {
+    if (!peerSet.has(localCapability)) {
+      return false;
+    }
+  }
+  return true;
+}
+var PeerSelector = class {
+  localAgentId;
+  localCapabilities;
+  nowMs;
+  peerHealthFn;
+  livenessThresholdMs;
+  peers = [];
+  runtime = /* @__PURE__ */ new Map();
+  rrCursor = 0;
+  constructor(options) {
+    const threshold = options.livenessThresholdMs ?? DEFAULT_PEER_LIVENESS_THRESHOLD_MS;
+    if (threshold < 0) {
+      throw new GatewayValidationError("livenessThresholdMs must be >= 0");
+    }
+    this.localAgentId = options.localAgentId;
+    this.localCapabilities = new Set(options.localCapabilities ?? []);
+    this.nowMs = options.nowMsFn ?? defaultNowMs3;
+    this.peerHealthFn = options.peerHealthFn ?? (() => true);
+    this.livenessThresholdMs = threshold;
+  }
+  setPeers(peers) {
+    this.peers = [...peers];
+    const activeIds = new Set(this.peers.map((peer) => peer.agentId));
+    for (const agentId of [...this.runtime.keys()]) {
+      if (!activeIds.has(agentId)) {
+        this.runtime.delete(agentId);
+      }
+    }
+    const nowMs = this.nowMs();
+    for (const peer of this.peers) {
+      if (!this.runtime.has(peer.agentId)) {
+        this.runtime.set(peer.agentId, {
+          state: AGENT_STATE_RUNNING,
+          lastHeartbeatMs: nowMs,
+          cooldownUntilMs: 0
+        });
+      }
+    }
+  }
+  updatePeerRuntimeState(agentId, options = {}) {
+    const runtime = this.ensureRuntime(agentId);
+    if (options.state !== void 0) {
+      runtime.state = options.state;
+    }
+    if (options.lastHeartbeatMs !== void 0) {
+      runtime.lastHeartbeatMs = Math.max(Math.floor(options.lastHeartbeatMs), 0);
+    }
+    if (options.cooldownUntilMs !== void 0) {
+      runtime.cooldownUntilMs = Math.max(Math.floor(options.cooldownUntilMs), 0);
+    }
+    this.runtime.set(agentId, runtime);
+  }
+  touchPeerHeartbeat(agentId, options = {}) {
+    this.updatePeerRuntimeState(agentId, {
+      state: options.state,
+      lastHeartbeatMs: options.nowMs ?? this.nowMs()
+    });
+  }
+  recordPeerOverloaded(agentId, options = {}) {
+    const runtime = this.ensureRuntime(agentId);
+    const nowMs = this.nowMs();
+    const retryAfterMs = Math.max(Math.floor(options.retryAfterMs ?? 0), 0);
+    const localCooldownMs = Math.max(Math.floor(options.localCooldownMs ?? 0), 0);
+    const cooldownMs = Math.max(retryAfterMs, localCooldownMs);
+    runtime.cooldownUntilMs = Math.max(runtime.cooldownUntilMs, nowMs + cooldownMs);
+    this.runtime.set(agentId, runtime);
+  }
+  isEligible(peer) {
+    if (peer.registrationType !== REGISTRATION_TYPE_SWARM_GATEWAY) {
+      return false;
+    }
+    if (peer.agentId === this.localAgentId) {
+      return false;
+    }
+    return sameCapabilities(peer.capabilities, this.localCapabilities);
+  }
+  selectPeer() {
+    const healthy = this.peers.filter((peer) => this.isHealthy(peer));
+    if (healthy.length === 0) {
+      return "";
+    }
+    const idx = this.rrCursor % healthy.length;
+    this.rrCursor += 1;
+    return healthy[idx].agentId;
+  }
+  ensureRuntime(agentId) {
+    const existing = this.runtime.get(agentId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    return {
+      state: AGENT_STATE_RUNNING,
+      lastHeartbeatMs: this.nowMs(),
+      cooldownUntilMs: 0
+    };
+  }
+  isHealthy(peer) {
+    if (!this.isEligible(peer)) {
+      return false;
+    }
+    if (!this.peerHealthFn(peer)) {
+      return false;
+    }
+    const runtime = this.runtime.get(peer.agentId);
+    if (runtime === void 0) {
+      return false;
+    }
+    const nowMs = this.nowMs();
+    if (runtime.cooldownUntilMs > nowMs) {
+      return false;
+    }
+    if (nowMs - runtime.lastHeartbeatMs > this.livenessThresholdMs) {
+      return false;
+    }
+    if (NON_SERVING_AGENT_STATES.has(runtime.state)) {
+      return false;
+    }
+    return true;
+  }
+};
+var GatewayRedirectEmitter = class {
+  retryAfterMs;
+  peerSelector;
+  constructor(options) {
+    if ((options.retryAfterMs ?? 0) < 0) {
+      throw new GatewayValidationError("retryAfterMs must be >= 0");
+    }
+    this.retryAfterMs = options.retryAfterMs ?? 1e3;
+    this.peerSelector = new PeerSelector({
+      localAgentId: options.agentId,
+      localCapabilities: options.capabilities ?? [],
+      nowMsFn: options.nowMsFn,
+      peerHealthFn: options.peerHealthFn,
+      livenessThresholdMs: options.peerLivenessThresholdMs
+    });
+    this.peerSelector.setPeers(options.peerDescriptors ?? []);
+  }
+  setPeerDescriptors(peers) {
+    this.peerSelector.setPeers(peers);
+  }
+  updatePeerRuntimeState(agentId, options = {}) {
+    this.peerSelector.updatePeerRuntimeState(agentId, options);
+  }
+  touchPeerHeartbeat(agentId, options = {}) {
+    this.peerSelector.touchPeerHeartbeat(agentId, options);
+  }
+  recordPeerOverloaded(agentId, options = {}) {
+    this.peerSelector.recordPeerOverloaded(agentId, options);
+  }
+  emitOverloadedResponse(request) {
+    if (request.delegationPolicy?.allowSpilloverRouting) {
+      const redirectToAgentId = this.peerSelector.selectPeer();
+      if (redirectToAgentId) {
+        return {
+          requestId: request.requestId,
+          accepted: false,
+          rejectionReason: "Gateway at capacity; redirect to peer gateway",
+          rejectionCode: 20 /* REDIRECT */,
+          retryAfterMs: 0,
+          redirectToAgentId
+        };
+      }
+    }
+    return {
+      requestId: request.requestId,
+      accepted: false,
+      rejectionReason: "Gateway at capacity",
+      rejectionCode: 16 /* OVERLOADED */,
+      retryAfterMs: this.retryAfterMs
+    };
+  }
+};
+
+// src/persistence/persistence.ts
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var JSONFilePersistence = class {
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+    this.activityFile = import_node_path2.default.join(baseDir, "activity.json");
+    this.acksFile = import_node_path2.default.join(baseDir, "acks.json");
+  }
+  activityFile;
+  acksFile;
+  async safeWrite(file, data) {
+    await import_promises.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
+    const tmp = `${file}.tmp-${Date.now()}`;
+    await import_promises.default.writeFile(tmp, data, "utf8");
+    await import_promises.default.rename(tmp, file);
+  }
+  async saveActivity(records) {
+    const payload = JSON.stringify(records, null, 2);
+    await this.safeWrite(this.activityFile, payload);
+  }
+  async loadActivity() {
+    try {
+      const buf = await import_promises.default.readFile(this.activityFile, "utf8");
+      return JSON.parse(buf);
+    } catch (e) {
+      if (e?.code === "ENOENT")
+        return [];
+      throw e;
     }
   }
   async saveAcks(states) {
@@ -12649,7 +13602,7 @@ var AgentState = /* @__PURE__ */ ((AgentState2) => {
   AgentState2[AgentState2["RECOVERING"] = 12] = "RECOVERING";
   return AgentState2;
 })(AgentState || {});
-var StateTransitionError = class extends Error {
+var StateTransitionError2 = class extends Error {
   fromState;
   toState;
   constructor(fromState, toState) {
@@ -12662,8 +13615,8 @@ var StateTransitionError = class extends Error {
   }
 };
 var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
-  // INITIALIZING -> RUNNABLE
-  [1 /* INITIALIZING */, /* @__PURE__ */ new Set([2 /* RUNNABLE */])],
+  // INITIALIZING -> RUNNABLE, FAILED (init timeout per spec s8.2)
+  [1 /* INITIALIZING */, /* @__PURE__ */ new Set([2 /* RUNNABLE */, 10 /* FAILED */])],
   // RUNNABLE -> SCHEDULED
   [2 /* RUNNABLE */, /* @__PURE__ */ new Set([3 /* SCHEDULED */])],
   // SCHEDULED -> RUNNING
@@ -12687,8 +13640,8 @@ var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
     6 /* WAITING_RESOURCES */,
     /* @__PURE__ */ new Set([4 /* RUNNING */, 10 /* FAILED */])
   ],
-  // SUSPENDED -> RESUMED
-  [7 /* SUSPENDED */, /* @__PURE__ */ new Set([8 /* RESUMED */])],
+  // SUSPENDED -> RESUMED, FAILED (suspension timeout per spec s8.3)
+  [7 /* SUSPENDED */, /* @__PURE__ */ new Set([8 /* RESUMED */, 10 /* FAILED */])],
   // RESUMED -> RUNNING
   [8 /* RESUMED */, /* @__PURE__ */ new Set([4 /* RUNNING */])],
   // COMPLETED -> RUNNABLE
@@ -12697,10 +13650,10 @@ var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
   [10 /* FAILED */, /* @__PURE__ */ new Set([12 /* RECOVERING */])],
   // SHUTTING_DOWN -> FAILED (agent_shutdown_timeout)
   [11 /* SHUTTING_DOWN */, /* @__PURE__ */ new Set([10 /* FAILED */])],
-  // RECOVERING -> RUNNABLE, SHUTTING_DOWN (recovery abort)
+  // RECOVERING -> RUNNABLE, SHUTTING_DOWN (recovery abort), FAILED (recovery timeout per spec s8.3)
   [
     12 /* RECOVERING */,
-    /* @__PURE__ */ new Set([2 /* RUNNABLE */, 11 /* SHUTTING_DOWN */])
+    /* @__PURE__ */ new Set([2 /* RUNNABLE */, 11 /* SHUTTING_DOWN */, 10 /* FAILED */])
   ]
 ]);
 function isValidTransition(fromState, toState) {
@@ -12752,7 +13705,7 @@ var AgentStateMachine = class {
    */
   async initialize() {
     if (this.state !== 0 /* AGENT_STATE_UNSPECIFIED */) {
-      throw new StateTransitionError(this.state, 1 /* INITIALIZING */);
+      throw new StateTransitionError2(this.state, 1 /* INITIALIZING */);
     }
     await this.transitionTo(1 /* INITIALIZING */);
   }
@@ -12769,7 +13722,7 @@ var AgentStateMachine = class {
       return;
     }
     if (!isValidTransition(this.state, toState)) {
-      throw new StateTransitionError(this.state, toState);
+      throw new StateTransitionError2(this.state, toState);
     }
     await this.doTransition(toState, context);
   }
@@ -12925,15 +13878,16 @@ var AgentStateMachine = class {
 };
 
 // src/internal/idempotency.ts
-var import_node_crypto3 = __toESM(require("node:crypto"), 1);
+var import_node_crypto4 = __toESM(require("node:crypto"), 1);
 function computeIdempotencyToken(input) {
-  const h = import_node_crypto3.default.createHash("sha256");
+  const h = import_node_crypto4.default.createHash("sha256");
   h.update(input.producer_id);
   h.update("\n");
   h.update(input.operation);
   h.update("\n");
   h.update(Buffer.from(input.canonical_bytes));
-  return `v1:${h.digest("hex")}`;
+  const hash16 = h.digest("hex").slice(0, 16);
+  return `${input.producer_id}:${input.operation}:${hash16}`;
 }
 
 // src/runtime/persistenceAdapter.ts
@@ -13050,89 +14004,752 @@ function normalizeReportPaths(report) {
   return report;
 }
 
-// src/secrets/types.ts
-var SecretSource = /* @__PURE__ */ ((SecretSource2) => {
-  SecretSource2["CLI"] = "cli";
-  SecretSource2["ENV"] = "env";
-  SecretSource2["SCOPED"] = "scoped";
-  SecretSource2["GLOBAL"] = "global";
-  return SecretSource2;
-})(SecretSource || {});
-var Scope = class {
-  constructor(name = null) {
-    this.name = name;
-  }
-  get isGlobal() {
-    return this.name === null;
+// src/constants/index.ts
+var CommunicationClass = /* @__PURE__ */ ((CommunicationClass2) => {
+  CommunicationClass2[CommunicationClass2["COMM_CLASS_UNSPECIFIED"] = 0] = "COMM_CLASS_UNSPECIFIED";
+  CommunicationClass2[CommunicationClass2["PRIVILEGED"] = 1] = "PRIVILEGED";
+  CommunicationClass2[CommunicationClass2["STANDARD"] = 2] = "STANDARD";
+  CommunicationClass2[CommunicationClass2["BULK"] = 3] = "BULK";
+  return CommunicationClass2;
+})(CommunicationClass || {});
+var DebateIntensity = /* @__PURE__ */ ((DebateIntensity2) => {
+  DebateIntensity2[DebateIntensity2["DEBATE_INTENSITY_UNSPECIFIED"] = 0] = "DEBATE_INTENSITY_UNSPECIFIED";
+  DebateIntensity2[DebateIntensity2["LOWEST"] = 1] = "LOWEST";
+  DebateIntensity2[DebateIntensity2["LOW"] = 2] = "LOW";
+  DebateIntensity2[DebateIntensity2["MEDIUM"] = 3] = "MEDIUM";
+  DebateIntensity2[DebateIntensity2["HIGH"] = 4] = "HIGH";
+  DebateIntensity2[DebateIntensity2["HIGHEST"] = 5] = "HIGHEST";
+  return DebateIntensity2;
+})(DebateIntensity || {});
+var HitlReasonType = /* @__PURE__ */ ((HitlReasonType2) => {
+  HitlReasonType2[HitlReasonType2["HITL_REASON_UNSPECIFIED"] = 0] = "HITL_REASON_UNSPECIFIED";
+  HitlReasonType2[HitlReasonType2["CONFLICT"] = 1] = "CONFLICT";
+  HitlReasonType2[HitlReasonType2["SECURITY_APPROVAL"] = 2] = "SECURITY_APPROVAL";
+  HitlReasonType2[HitlReasonType2["TASK_ESCALATION"] = 3] = "TASK_ESCALATION";
+  HitlReasonType2[HitlReasonType2["MANUAL_OVERRIDE"] = 4] = "MANUAL_OVERRIDE";
+  HitlReasonType2[HitlReasonType2["WORKTREE_OVERRIDE"] = 5] = "WORKTREE_OVERRIDE";
+  HitlReasonType2[HitlReasonType2["DEBATE_DEADLOCK"] = 6] = "DEBATE_DEADLOCK";
+  HitlReasonType2[HitlReasonType2["TOOL_PRIVILEGE_ESCALATION"] = 7] = "TOOL_PRIVILEGE_ESCALATION";
+  HitlReasonType2[HitlReasonType2["CONNECTOR_APPROVAL"] = 8] = "CONNECTOR_APPROVAL";
+  return HitlReasonType2;
+})(HitlReasonType || {});
+var AckStage2 = /* @__PURE__ */ ((AckStage3) => {
+  AckStage3[AckStage3["ACK_STAGE_UNSPECIFIED"] = 0] = "ACK_STAGE_UNSPECIFIED";
+  AckStage3[AckStage3["RECEIVED"] = 1] = "RECEIVED";
+  AckStage3[AckStage3["READ"] = 2] = "READ";
+  AckStage3[AckStage3["FULFILLED"] = 3] = "FULFILLED";
+  AckStage3[AckStage3["REJECTED"] = 4] = "REJECTED";
+  AckStage3[AckStage3["FAILED"] = 5] = "FAILED";
+  AckStage3[AckStage3["TIMED_OUT"] = 6] = "TIMED_OUT";
+  return AckStage3;
+})(AckStage2 || {});
+var EnvelopeState = /* @__PURE__ */ ((EnvelopeState3) => {
+  EnvelopeState3[EnvelopeState3["ENVELOPE_STATE_UNSPECIFIED"] = 0] = "ENVELOPE_STATE_UNSPECIFIED";
+  EnvelopeState3[EnvelopeState3["SENT"] = 1] = "SENT";
+  EnvelopeState3[EnvelopeState3["RECEIVED"] = 2] = "RECEIVED";
+  EnvelopeState3[EnvelopeState3["READ"] = 3] = "READ";
+  EnvelopeState3[EnvelopeState3["FULFILLED"] = 4] = "FULFILLED";
+  EnvelopeState3[EnvelopeState3["REJECTED"] = 5] = "REJECTED";
+  EnvelopeState3[EnvelopeState3["FAILED"] = 6] = "FAILED";
+  EnvelopeState3[EnvelopeState3["TIMED_OUT"] = 7] = "TIMED_OUT";
+  return EnvelopeState3;
+})(EnvelopeState || {});
+var WorktreeStateEnum = /* @__PURE__ */ ((WorktreeStateEnum2) => {
+  WorktreeStateEnum2[WorktreeStateEnum2["WORKTREE_STATE_UNSPECIFIED"] = 0] = "WORKTREE_STATE_UNSPECIFIED";
+  WorktreeStateEnum2[WorktreeStateEnum2["UNBOUND"] = 1] = "UNBOUND";
+  WorktreeStateEnum2[WorktreeStateEnum2["BOUND_HOME"] = 2] = "BOUND_HOME";
+  WorktreeStateEnum2[WorktreeStateEnum2["SWITCH_PENDING"] = 3] = "SWITCH_PENDING";
+  WorktreeStateEnum2[WorktreeStateEnum2["BOUND_NON_HOME"] = 4] = "BOUND_NON_HOME";
+  WorktreeStateEnum2[WorktreeStateEnum2["BIND_FAILED"] = 5] = "BIND_FAILED";
+  return WorktreeStateEnum2;
+})(WorktreeStateEnum || {});
+var DEFAULT_ACK_TIMEOUT_MS = 1e4;
+var DEDUP_WINDOW_S = 3600;
+function isTerminalEnvelopeState(state) {
+  return state === 4 /* FULFILLED */ || state === 5 /* REJECTED */ || state === 6 /* FAILED */ || state === 7 /* TIMED_OUT */;
+}
+function updateEnvelopeState(envelope, newState) {
+  envelope.state = newState;
+  return envelope;
+}
+
+// src/audit.ts
+var import_node_crypto5 = __toESM(require("node:crypto"), 1);
+function uuidv43() {
+  if (typeof import_node_crypto5.default.randomUUID === "function") {
+    return import_node_crypto5.default.randomUUID();
   }
-  label() {
-    return this.name ?? "global";
+  const buf = import_node_crypto5.default.randomBytes(16);
+  buf[6] = buf[6] & 15 | 64;
+  buf[8] = buf[8] & 63 | 128;
+  const hex = [...buf].map((b) => b.toString(16).padStart(2, "0"));
+  return hex.slice(0, 4).join("") + "-" + hex.slice(4, 6).join("") + "-" + hex.slice(6, 8).join("") + "-" + hex.slice(8, 10).join("") + "-" + hex.slice(10, 16).join("");
+}
+function computeEnvelopeHash(envelope) {
+  const envelopeCopy = { ...envelope };
+  const payload = envelopeCopy.payload;
+  const audit_proof = envelopeCopy.audit_proof;
+  delete envelopeCopy.payload;
+  delete envelopeCopy.audit_proof;
+  const envelopeJson = JSON.stringify(envelopeCopy, Object.keys(envelopeCopy).sort());
+  const hasher = import_node_crypto5.default.createHash("sha256");
+  hasher.update(envelopeJson, "utf-8");
+  if (payload) {
+    if (payload instanceof Uint8Array) {
+      hasher.update(payload);
+    } else if (typeof payload === "string") {
+      hasher.update(payload, "utf-8");
+    }
+  }
+  if (audit_proof) {
+    if (audit_proof instanceof Uint8Array) {
+      hasher.update(audit_proof);
+    } else if (typeof audit_proof === "string") {
+      hasher.update(audit_proof, "utf-8");
+    }
+  }
+  return hasher.digest("hex");
+}
+function createSimpleProof(envelope, actor_id) {
+  const envelopeHash = computeEnvelopeHash(envelope);
+  const timestamp = nowHlcStub();
+  const proofInput = `${envelopeHash}:${actor_id}:${timestamp}`;
+  const proofHash = import_node_crypto5.default.createHash("sha256").update(proofInput, "utf-8").digest();
+  return {
+    proof_id: uuidv43(),
+    proof_type: "simple_hash",
+    proof_data: new Uint8Array(proofHash),
+    created_at: timestamp,
+    verified: false
+  };
+}
+function verifyAuditProof(envelope, proof) {
+  if (proof.proof_type === "noop") {
+    return true;
   }
-};
-var SecretKey = class {
-  constructor(key) {
-    this.key = key;
-    if (!key || key.split(".").some((p) => p.trim() === "")) {
-      throw new Error("secret key must be dotted identifiers without empty segments");
+  if (proof.proof_type === "simple_hash") {
+    if (proof.proof_data.length === 0) {
+      return false;
     }
-  }
-};
-var SecretValue = class _SecretValue {
-  constructor(value) {
-    this.value = value;
-    if (value.length > _SecretValue.MAX_LEN) {
-      throw new Error("secret value exceeds maximum allowed length (8KB)");
+    const envelopeHash = computeEnvelopeHash(envelope);
+    if (proof.proof_data.length !== 32) {
+      return false;
     }
+    return true;
   }
-  static MAX_LEN = 8 * 1024;
-};
-
-// src/secrets/errors.ts
-var SecretError = class extends Error {
-};
-var SecretNotFound = class extends SecretError {
-  constructor(scope, key) {
-    super(`secret not found: scope=${scope} key=${key}`);
-    this.scope = scope;
-    this.key = key;
-  }
-};
-var SecretBackendError = class extends SecretError {
-};
-var SecretPermissionError = class extends SecretError {
-};
-var SecretValidationError = class extends SecretError {
-};
-
-// src/secrets/backend.ts
-var Secrets = class {
-  constructor(backend) {
-    this.backend = backend;
+  return false;
+}
+var NoOpAuditor = class {
+  /**
+   * Create a minimal no-op proof.
+   *
+   * @param envelope - The envelope (ignored)
+   * @param action - The action (ignored)
+   * @returns A minimal no-op proof
+   */
+  createProof(envelope, action) {
+    return {
+      proof_id: uuidv43(),
+      proof_type: "noop",
+      proof_data: new Uint8Array(0),
+      created_at: nowHlcStub(),
+      verified: true
+    };
   }
-  set(scope, key, value) {
-    return this.backend.set(scope, key, value);
+  /**
+   * Always returns true for no-op proofs.
+   *
+   * @param proof - The proof (ignored)
+   * @returns Always true
+   */
+  verifyProof(proof) {
+    return true;
   }
-  get(scope, key) {
-    return this.backend.get(scope, key);
+  /**
+   * Create a minimal audit record without storing it.
+   *
+   * @param envelope - The envelope being audited
+   * @param action - The action being performed
+   * @param proof - Optional proof to attach
+   * @returns A minimal audit record
+   */
+  record(envelope, action, proof) {
+    return {
+      record_id: uuidv43(),
+      envelope_id: envelope.message_id ?? "unknown",
+      action,
+      actor_id: envelope.producer_id ?? "unknown",
+      timestamp: nowHlcStub(),
+      proof
+    };
   }
-  list(scope) {
-    return this.backend.list(scope);
+  /**
+   * Always returns empty array.
+   *
+   * @param envelope_id - The envelope ID (ignored)
+   * @returns Empty array
+   */
+  query(envelope_id) {
+    return [];
   }
 };
-
-// src/secrets/resolver.ts
-var Resolver = class {
-  constructor(backend, env = process.env) {
-    this.backend = backend;
-    this.env = env;
+var InMemoryAuditor = class {
+  _records;
+  /**
+   * Initialize with empty record storage.
+   */
+  constructor() {
+    this._records = /* @__PURE__ */ new Map();
   }
-  async resolve(key, scope, opts) {
-    const explicit = opts?.explicit ?? null;
-    const envVar = opts?.envVar ?? null;
-    if (explicit !== null)
-      return [explicit, "cli" /* CLI */];
-    if (envVar && this.env[envVar] && this.env[envVar] !== "")
-      return [this.env[envVar], "env" /* ENV */];
+  /**
+   * Create a simple hash-based proof.
+   *
+   * @param envelope - The envelope to create proof for
+   * @param action - The action being performed
+   * @returns A simple hash-based proof
+   */
+  createProof(envelope, action) {
+    return createSimpleProof(envelope, envelope.producer_id ?? "unknown");
+  }
+  /**
+   * Verify a proof using the verification module.
+   *
+   * @param proof - The proof to verify
+   * @returns True if proof is valid, false otherwise
+   */
+  verifyProof(proof) {
+    if (proof.proof_type === "noop") {
+      return true;
+    }
+    if (proof.proof_type === "simple_hash") {
+      return proof.proof_data.length > 0;
+    }
+    return false;
+  }
+  /**
+   * Create and store an audit record.
+   *
+   * @param envelope - The envelope being audited
+   * @param action - The action being performed
+   * @param proof - Optional proof to attach
+   * @returns The created audit record
+   */
+  record(envelope, action, proof) {
+    const record = {
+      record_id: uuidv43(),
+      envelope_id: envelope.message_id ?? "unknown",
+      action,
+      actor_id: envelope.producer_id ?? "unknown",
+      timestamp: nowHlcStub(),
+      proof
+    };
+    const envelope_id = record.envelope_id;
+    if (!this._records.has(envelope_id)) {
+      this._records.set(envelope_id, []);
+    }
+    this._records.get(envelope_id).push(record);
+    return record;
+  }
+  /**
+   * Query all audit records for a specific envelope.
+   *
+   * @param envelope_id - The message_id of the envelope to query
+   * @returns List of audit records for this envelope
+   */
+  query(envelope_id) {
+    return this._records.get(envelope_id) ?? [];
+  }
+  /**
+   * Get all audit records (useful for testing).
+   *
+   * @returns All audit records across all envelopes
+   */
+  getAllRecords() {
+    const allRecords = [];
+    for (const records of this._records.values()) {
+      allRecords.push(...records);
+    }
+    return allRecords;
+  }
+  /**
+   * Clear all stored records (useful for testing).
+   */
+  clear() {
+    this._records.clear();
+  }
+};
+
+// src/agentConfig.ts
+var fs2 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+function defaultEndpoints() {
+  return {
+    router: process.env.SW4RM_ROUTER_ADDR || "http://localhost:50051",
+    registry: process.env.SW4RM_REGISTRY_ADDR || "http://localhost:50052",
+    scheduler: process.env.SW4RM_SCHEDULER_ADDR || "http://localhost:50053",
+    hitl: process.env.SW4RM_HITL_ADDR || "http://localhost:50054",
+    worktree: process.env.SW4RM_WORKTREE_ADDR || "http://localhost:50055",
+    tool: process.env.SW4RM_TOOL_ADDR || "http://localhost:50056",
+    connector: process.env.SW4RM_CONNECTOR_ADDR || "http://localhost:50057",
+    negotiation: process.env.SW4RM_NEGOTIATION_ADDR || "http://localhost:50058",
+    reasoning: process.env.SW4RM_REASONING_ADDR || "http://localhost:50059",
+    logging: process.env.SW4RM_LOGGING_ADDR || "http://localhost:50060"
+  };
+}
+function defaultRetryPolicy() {
+  return {
+    maxAttempts: 3,
+    initialBackoffMs: 200,
+    maxBackoffMs: 2e3,
+    multiplier: 2
+  };
+}
+function defaultAgentConfig(agentId = "agent-1", name = "Agent") {
+  return {
+    agentId,
+    name,
+    description: void 0,
+    version: "0.1.0",
+    capabilities: [],
+    endpoints: defaultEndpoints(),
+    timeoutMs: 3e4,
+    streamKeepaliveMs: 6e4,
+    retry: defaultRetryPolicy(),
+    metadata: {},
+    communicationClass: 2,
+    // STANDARD
+    modalitiesSupported: ["application/json"],
+    reasoningConnectors: [],
+    publicKey: void 0
+  };
+}
+function loadConfigFromEnv() {
+  const config = defaultAgentConfig();
+  if (process.env.AGENT_ID) {
+    config.agentId = process.env.AGENT_ID;
+  }
+  if (process.env.AGENT_NAME) {
+    config.name = process.env.AGENT_NAME;
+  }
+  if (process.env.AGENT_DESCRIPTION) {
+    config.description = process.env.AGENT_DESCRIPTION;
+  }
+  if (process.env.AGENT_VERSION) {
+    config.version = process.env.AGENT_VERSION;
+  }
+  if (process.env.AGENT_CAPABILITIES) {
+    config.capabilities = process.env.AGENT_CAPABILITIES.split(",").map((s) => s.trim());
+  }
+  if (process.env.SW4RM_TIMEOUT_MS) {
+    const timeout = parseInt(process.env.SW4RM_TIMEOUT_MS, 10);
+    if (!isNaN(timeout)) {
+      config.timeoutMs = timeout;
+    }
+  }
+  if (process.env.SW4RM_STREAM_KEEPALIVE_MS) {
+    const keepalive = parseInt(process.env.SW4RM_STREAM_KEEPALIVE_MS, 10);
+    if (!isNaN(keepalive)) {
+      config.streamKeepaliveMs = keepalive;
+    }
+  }
+  if (process.env.SW4RM_RETRY_MAX_ATTEMPTS) {
+    const attempts = parseInt(process.env.SW4RM_RETRY_MAX_ATTEMPTS, 10);
+    if (!isNaN(attempts)) {
+      config.retry.maxAttempts = attempts;
+    }
+  }
+  if (process.env.SW4RM_COMMUNICATION_CLASS) {
+    const cls = parseInt(process.env.SW4RM_COMMUNICATION_CLASS, 10);
+    if (!isNaN(cls)) {
+      config.communicationClass = cls;
+    }
+  }
+  config.endpoints = defaultEndpoints();
+  return config;
+}
+function defaultSW4RMConfig() {
+  return {
+    routerAddr: process.env.SW4RM_ROUTER_ADDR || "http://localhost:50051",
+    registryAddr: process.env.SW4RM_REGISTRY_ADDR || "http://localhost:50052",
+    defaultTimeoutMs: parseInt(process.env.SW4RM_DEFAULT_TIMEOUT_MS || "30000", 10),
+    maxRetries: parseInt(process.env.SW4RM_MAX_RETRIES || "3", 10),
+    enableMetrics: parseBool(process.env.SW4RM_ENABLE_METRICS, true),
+    enableTracing: parseBool(process.env.SW4RM_ENABLE_TRACING, true),
+    logLevel: process.env.SW4RM_LOG_LEVEL || "INFO",
+    featureFlags: {}
+  };
+}
+function parseBool(value, defaultValue) {
+  if (value === void 0) {
+    return defaultValue;
+  }
+  return ["true", "1", "yes", "on"].includes(value.toLowerCase());
+}
+function loadConfig(configPath) {
+  let config = defaultSW4RMConfig();
+  if (configPath) {
+    if (!fs2.existsSync(configPath)) {
+      throw new Error(`Configuration file not found: ${configPath}`);
+    }
+    const ext = path4.extname(configPath).toLowerCase();
+    if (ext !== ".json") {
+      throw new Error(
+        `Unsupported configuration file format: ${ext}. Supported formats: .json`
+      );
+    }
+    const fileContent = fs2.readFileSync(configPath, "utf8");
+    const fileConfig = JSON.parse(fileContent);
+    config = { ...config, ...fileConfig };
+  }
+  const envConfig = loadFromEnv();
+  config = { ...config, ...envConfig };
+  return config;
+}
+function loadFromEnv() {
+  const envConfig = {};
+  if (process.env.SW4RM_ROUTER_ADDR) {
+    envConfig.routerAddr = process.env.SW4RM_ROUTER_ADDR;
+  }
+  if (process.env.SW4RM_REGISTRY_ADDR) {
+    envConfig.registryAddr = process.env.SW4RM_REGISTRY_ADDR;
+  }
+  if (process.env.SW4RM_DEFAULT_TIMEOUT_MS) {
+    const timeout = parseInt(process.env.SW4RM_DEFAULT_TIMEOUT_MS, 10);
+    if (!isNaN(timeout)) {
+      envConfig.defaultTimeoutMs = timeout;
+    }
+  }
+  if (process.env.SW4RM_MAX_RETRIES) {
+    const retries = parseInt(process.env.SW4RM_MAX_RETRIES, 10);
+    if (!isNaN(retries)) {
+      envConfig.maxRetries = retries;
+    }
+  }
+  if (process.env.SW4RM_ENABLE_METRICS !== void 0) {
+    envConfig.enableMetrics = parseBool(process.env.SW4RM_ENABLE_METRICS, true);
+  }
+  if (process.env.SW4RM_ENABLE_TRACING !== void 0) {
+    envConfig.enableTracing = parseBool(process.env.SW4RM_ENABLE_TRACING, true);
+  }
+  if (process.env.SW4RM_LOG_LEVEL) {
+    envConfig.logLevel = process.env.SW4RM_LOG_LEVEL.toUpperCase();
+  }
+  return envConfig;
+}
+var _globalConfig = null;
+function getConfig() {
+  if (_globalConfig === null) {
+    _globalConfig = loadConfig();
+  }
+  return _globalConfig;
+}
+function setConfig(config) {
+  _globalConfig = config;
+}
+function resetConfig() {
+  _globalConfig = null;
+}
+
+// src/persistentActivityBuffer.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path4 = require("node:path");
+var JSONFilePersistence2 = class {
+  constructor(filePath = "sw4rm_activity.json") {
+    this.filePath = filePath;
+  }
+  load() {
+    if (!(0, import_node_fs2.existsSync)(this.filePath)) {
+      return { records: {}, order: [] };
+    }
+    const raw = (0, import_node_fs2.readFileSync)(this.filePath, "utf-8");
+    const data = JSON.parse(raw);
+    return {
+      records: data.records ?? {},
+      order: data.order ?? []
+    };
+  }
+  save(records, order) {
+    const dir = (0, import_node_path4.dirname)(this.filePath);
+    if (dir && !(0, import_node_fs2.existsSync)(dir)) {
+      (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+    }
+    (0, import_node_fs2.writeFileSync)(this.filePath, JSON.stringify({ records, order, version: "1.0" }, null, 2));
+  }
+  clear() {
+    if ((0, import_node_fs2.existsSync)(this.filePath)) {
+      (0, import_node_fs2.writeFileSync)(this.filePath, JSON.stringify({ records: {}, order: [], version: "1.0" }));
+    }
+  }
+};
+var PersistentActivityBuffer = class {
+  byId = /* @__PURE__ */ new Map();
+  byIdempotencyToken = /* @__PURE__ */ new Map();
+  // token -> message_id
+  order = [];
+  maxItems;
+  persistence;
+  dedupWindowS;
+  dirty = false;
+  constructor(opts) {
+    this.maxItems = opts?.maxItems ?? 1e4;
+    this.persistence = opts?.persistence ?? new JSONFilePersistence2();
+    this.dedupWindowS = opts?.dedupWindowS ?? 3600;
+    this.loadFromPersistence();
+  }
+  loadFromPersistence() {
+    try {
+      const { records, order } = this.persistence.load();
+      this.byId = new Map(Object.entries(records));
+      this.order = order;
+      for (const [mid, rec] of this.byId) {
+        const token = rec.envelope?.idempotency_token;
+        if (token) {
+          this.byIdempotencyToken.set(token, mid);
+        }
+      }
+    } catch {
+      this.byId = /* @__PURE__ */ new Map();
+      this.byIdempotencyToken = /* @__PURE__ */ new Map();
+      this.order = [];
+    }
+  }
+  saveToPersistence() {
+    if (!this.dirty)
+      return;
+    try {
+      const records = {};
+      for (const [k, v] of this.byId) {
+        records[k] = v;
+      }
+      this.persistence.save(records, this.order);
+      this.dirty = false;
+    } catch {
+    }
+  }
+  checkCapacity() {
+    if (this.byId.size >= this.maxItems) {
+      throw new BufferFullError(
+        `Activity buffer is full (max ${this.maxItems} items). Reject per spec.`,
+        1 /* BUFFER_FULL */
+      );
+    }
+  }
+  cleanupExpiredDedupEntries() {
+    const nowMs = Date.now();
+    const windowMs = this.dedupWindowS * 1e3;
+    const expired = [];
+    for (const [token, mid] of this.byIdempotencyToken) {
+      const rec = this.byId.get(mid);
+      if (rec && nowMs - rec.ts_ms > windowMs) {
+        expired.push(token);
+      }
+    }
+    for (const token of expired) {
+      this.byIdempotencyToken.delete(token);
+    }
+  }
+  /**
+   * Record an incoming envelope. Throws BufferFullError if buffer is at capacity.
+   */
+  recordIncoming(envelope) {
+    this.checkCapacity();
+    const mid = String(envelope.message_id ?? "");
+    const rec = {
+      message_id: mid,
+      direction: "in",
+      envelope,
+      ts_ms: Date.now(),
+      ack_stage: 0 /* ACK_STAGE_UNSPECIFIED */,
+      error_code: 0 /* ERROR_CODE_UNSPECIFIED */,
+      ack_note: ""
+    };
+    this.byId.set(mid, rec);
+    this.order.push(mid);
+    const token = envelope.idempotency_token;
+    if (token) {
+      this.byIdempotencyToken.set(token, mid);
+    }
+    this.cleanupExpiredDedupEntries();
+    this.dirty = true;
+    return rec;
+  }
+  /**
+   * Record an outgoing envelope. Throws BufferFullError if buffer is at capacity.
+   */
+  recordOutgoing(envelope) {
+    this.checkCapacity();
+    const mid = String(envelope.message_id ?? "");
+    const rec = {
+      message_id: mid,
+      direction: "out",
+      envelope,
+      ts_ms: Date.now(),
+      ack_stage: 0 /* ACK_STAGE_UNSPECIFIED */,
+      error_code: 0 /* ERROR_CODE_UNSPECIFIED */,
+      ack_note: ""
+    };
+    this.byId.set(mid, rec);
+    this.order.push(mid);
+    const token = envelope.idempotency_token;
+    if (token) {
+      this.byIdempotencyToken.set(token, mid);
+    }
+    this.cleanupExpiredDedupEntries();
+    this.dirty = true;
+    return rec;
+  }
+  /**
+   * Process an ACK for a previously recorded message.
+   */
+  ack(ackMsg) {
+    const target = String(ackMsg.ack_for_message_id);
+    const rec = this.byId.get(target);
+    if (rec) {
+      rec.ack_stage = ackMsg.ack_stage ?? 0 /* ACK_STAGE_UNSPECIFIED */;
+      rec.error_code = ackMsg.error_code ?? 0 /* ERROR_CODE_UNSPECIFIED */;
+      rec.ack_note = ackMsg.note ?? "";
+      this.dirty = true;
+    }
+    return rec;
+  }
+  /** Get record by message ID. */
+  get(messageId) {
+    return this.byId.get(messageId);
+  }
+  /** Get record by idempotency token (for deduplication). */
+  getByIdempotencyToken(token) {
+    this.cleanupExpiredDedupEntries();
+    const mid = this.byIdempotencyToken.get(token);
+    if (mid)
+      return this.byId.get(mid);
+    return void 0;
+  }
+  /** Get all un-ACKed records. */
+  unacked() {
+    return [...this.byId.values()].filter(
+      (r) => r.ack_stage === 0 /* ACK_STAGE_UNSPECIFIED */ || r.ack_stage === 1 /* RECEIVED */ || r.ack_stage === 2 /* READ */
+    );
+  }
+  /** Get N most recent records. */
+  recent(n = 50) {
+    const ids = this.order.slice(-n);
+    return ids.map((id) => this.byId.get(id)).filter(Boolean);
+  }
+  /** Update envelope state for a message. */
+  updateState(messageId, newState) {
+    const rec = this.byId.get(messageId);
+    if (rec) {
+      rec.envelope.state = newState;
+      this.dirty = true;
+    }
+    return rec;
+  }
+  /** Return unacked outgoing messages for reconciliation. */
+  reconcile() {
+    return this.unacked().filter((r) => r.direction === "out");
+  }
+  /** Force save to persistence. */
+  flush() {
+    this.dirty = true;
+    this.saveToPersistence();
+  }
+  /** Clear all records. */
+  clear() {
+    this.byId.clear();
+    this.byIdempotencyToken.clear();
+    this.order = [];
+    this.persistence.clear();
+    this.dirty = false;
+  }
+  /** Get the count of records. */
+  get size() {
+    return this.byId.size;
+  }
+};
+
+// src/secrets/types.ts
+var SecretSource = /* @__PURE__ */ ((SecretSource2) => {
+  SecretSource2["CLI"] = "cli";
+  SecretSource2["ENV"] = "env";
+  SecretSource2["SCOPED"] = "scoped";
+  SecretSource2["GLOBAL"] = "global";
+  return SecretSource2;
+})(SecretSource || {});
+var Scope = class {
+  constructor(name = null) {
+    this.name = name;
+  }
+  get isGlobal() {
+    return this.name === null;
+  }
+  label() {
+    return this.name ?? "global";
+  }
+};
+var SecretKey = class {
+  constructor(key) {
+    this.key = key;
+    if (!key || key.split(".").some((p) => p.trim() === "")) {
+      throw new Error("secret key must be dotted identifiers without empty segments");
+    }
+  }
+};
+var SecretValue = class _SecretValue {
+  constructor(value) {
+    this.value = value;
+    if (value.length > _SecretValue.MAX_LEN) {
+      throw new Error("secret value exceeds maximum allowed length (8KB)");
+    }
+  }
+  static MAX_LEN = 8 * 1024;
+};
+
+// src/secrets/errors.ts
+var SecretError = class extends Error {
+};
+var SecretNotFound = class extends SecretError {
+  constructor(scope, key) {
+    super(`secret not found: scope=${scope} key=${key}`);
+    this.scope = scope;
+    this.key = key;
+  }
+};
+var SecretBackendError = class extends SecretError {
+};
+var SecretPermissionError = class extends SecretError {
+};
+var SecretValidationError = class extends SecretError {
+};
+
+// src/secrets/backend.ts
+var Secrets = class {
+  constructor(backend) {
+    this.backend = backend;
+  }
+  set(scope, key, value) {
+    return this.backend.set(scope, key, value);
+  }
+  get(scope, key) {
+    return this.backend.get(scope, key);
+  }
+  list(scope) {
+    return this.backend.list(scope);
+  }
+};
+
+// src/secrets/resolver.ts
+var Resolver = class {
+  constructor(backend, env = process.env) {
+    this.backend = backend;
+    this.env = env;
+  }
+  async resolve(key, scope, opts) {
+    const explicit = opts?.explicit ?? null;
+    const envVar = opts?.envVar ?? null;
+    if (explicit !== null)
+      return [explicit, "cli" /* CLI */];
+    if (envVar && this.env[envVar] && this.env[envVar] !== "")
+      return [this.env[envVar], "env" /* ENV */];
     try {
       const v = await this.backend.get(scope, key);
       return [v, scope.isGlobal ? "global" /* GLOBAL */ : "scoped" /* SCOPED */];
@@ -13147,28 +14764,28 @@ var Resolver = class {
 };
 
 // src/secrets/backends/file.ts
-var import_node_fs = require("node:fs");
-var import_node_path4 = require("node:path");
+var import_node_fs3 = require("node:fs");
+var import_node_path5 = require("node:path");
 function defaultPath() {
   const isWin = process.platform === "win32";
   if (isWin) {
-    const base2 = process.env.APPDATA || (0, import_node_path4.join)(process.env.USERPROFILE || "", "AppData", "Roaming");
-    return (0, import_node_path4.join)(base2, "sw4rm", "secrets.json");
+    const base2 = process.env.APPDATA || (0, import_node_path5.join)(process.env.USERPROFILE || "", "AppData", "Roaming");
+    return (0, import_node_path5.join)(base2, "sw4rm", "secrets.json");
   }
   const xdg = process.env.XDG_CONFIG_HOME;
-  const base = xdg && xdg.length > 0 ? xdg : (0, import_node_path4.join)(process.env.HOME || "", ".config");
-  return (0, import_node_path4.join)(base, "sw4rm", "secrets.json");
+  const base = xdg && xdg.length > 0 ? xdg : (0, import_node_path5.join)(process.env.HOME || "", ".config");
+  return (0, import_node_path5.join)(base, "sw4rm", "secrets.json");
 }
 var FileBackend = class {
   path;
-  constructor(path4) {
-    this.path = path4 ?? defaultPath();
-    (0, import_node_fs.mkdirSync)((0, import_node_path4.dirname)(this.path), { recursive: true });
+  constructor(path7) {
+    this.path = path7 ?? defaultPath();
+    (0, import_node_fs3.mkdirSync)((0, import_node_path5.dirname)(this.path), { recursive: true });
     try {
-      (0, import_node_fs.chmodSync)((0, import_node_path4.dirname)(this.path), 448);
+      (0, import_node_fs3.chmodSync)((0, import_node_path5.dirname)(this.path), 448);
     } catch {
     }
-    if (!(0, import_node_fs.existsSync)(this.path)) {
+    if (!(0, import_node_fs3.existsSync)(this.path)) {
       this.safeWrite({});
       this.enforceFilePerms();
     } else {
@@ -13178,17 +14795,17 @@ var FileBackend = class {
   enforceFilePerms() {
     if (process.platform !== "win32") {
       try {
-        (0, import_node_fs.chmodSync)(this.path, 384);
+        (0, import_node_fs3.chmodSync)(this.path, 384);
       } catch (e) {
         throw new SecretPermissionError(String(e));
       }
     }
   }
   safeWrite(obj) {
-    const tmp = (0, import_node_path4.join)((0, import_node_path4.dirname)(this.path), `.secrets.${Date.now()}.${Math.random().toString(16).slice(2)}`);
+    const tmp = (0, import_node_path5.join)((0, import_node_path5.dirname)(this.path), `.secrets.${Date.now()}.${Math.random().toString(16).slice(2)}`);
     try {
-      (0, import_node_fs.writeFileSync)(tmp, JSON.stringify(obj, null, 2), { encoding: "utf8", mode: 384 });
-      (0, import_node_fs.renameSync)(tmp, this.path);
+      (0, import_node_fs3.writeFileSync)(tmp, JSON.stringify(obj, null, 2), { encoding: "utf8", mode: 384 });
+      (0, import_node_fs3.renameSync)(tmp, this.path);
       this.enforceFilePerms();
     } catch (e) {
       throw new SecretBackendError(String(e));
@@ -13196,7 +14813,7 @@ var FileBackend = class {
   }
   load() {
     try {
-      const s = (0, import_node_fs.readFileSync)(this.path, { encoding: "utf8" });
+      const s = (0, import_node_fs3.readFileSync)(this.path, { encoding: "utf8" });
       return JSON.parse(s);
     } catch (e) {
       if (e.code === "ENOENT")
@@ -13292,58 +14909,940 @@ async function selectBackend(mode) {
   }
 }
 
+// src/llm/client.ts
+var LlmError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LlmError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LlmAuthenticationError = class extends LlmError {
+  constructor(message) {
+    super(message);
+    this.name = "LlmAuthenticationError";
+  }
+};
+var LlmRateLimitError = class extends LlmError {
+  constructor(message) {
+    super(message);
+    this.name = "LlmRateLimitError";
+  }
+};
+var LlmTimeoutError = class extends LlmError {
+  constructor(message) {
+    super(message);
+    this.name = "LlmTimeoutError";
+  }
+};
+var LlmContextLengthError = class extends LlmError {
+  constructor(message) {
+    super(message);
+    this.name = "LlmContextLengthError";
+  }
+};
+
+// src/llm/rateLimiter.ts
+function envBool(name, defaultVal) {
+  const raw = (process.env[name] ?? defaultVal).toLowerCase();
+  return !["0", "false", "no"].includes(raw);
+}
+function buildRateLimiterConfig(overrides) {
+  return {
+    tokensPerMinute: overrides?.tokensPerMinute ?? parseInt(process.env["LLM_RATE_LIMIT_TOKENS_PER_MIN"] ?? "250000", 10),
+    burstAllowance: overrides?.burstAllowance ?? 1,
+    minTokensPerRequest: overrides?.minTokensPerRequest ?? 100,
+    maxWaitSeconds: overrides?.maxWaitSeconds ?? 120,
+    enabled: overrides?.enabled ?? envBool("LLM_RATE_LIMIT_ENABLED", "1"),
+    adaptiveEnabled: overrides?.adaptiveEnabled ?? envBool("LLM_RATE_LIMIT_ADAPTIVE", "1"),
+    reductionFactor: overrides?.reductionFactor ?? parseFloat(process.env["LLM_RATE_LIMIT_REDUCTION_FACTOR"] ?? "0.7"),
+    recoveryFactor: overrides?.recoveryFactor ?? parseFloat(process.env["LLM_RATE_LIMIT_RECOVERY_FACTOR"] ?? "1.1"),
+    cooldownSeconds: overrides?.cooldownSeconds ?? parseFloat(process.env["LLM_RATE_LIMIT_COOLDOWN_SECONDS"] ?? "30"),
+    successesForRecovery: overrides?.successesForRecovery ?? parseInt(
+      process.env["LLM_RATE_LIMIT_RECOVERY_SUCCESS_THRESHOLD"] ?? "20",
+      10
+    )
+  };
+}
+var TokenBucket = class {
+  config;
+  baseTpm;
+  currentTpm;
+  minTpm;
+  tokens;
+  lastRefill;
+  lastRateLimitTime = null;
+  successesSinceLimit = 0;
+  constructor(config) {
+    this.config = buildRateLimiterConfig(config);
+    this.baseTpm = this.config.tokensPerMinute;
+    this.currentTpm = this.config.tokensPerMinute;
+    this.minTpm = Math.max(1e3, this.baseTpm * 0.25);
+    this.tokens = this.currentTpm;
+    this.lastRefill = performance.now();
+  }
+  // -- Internal helpers ----------------------------------------------------
+  refill() {
+    const now = performance.now();
+    const elapsedSeconds = (now - this.lastRefill) / 1e3;
+    const refill = elapsedSeconds * (this.currentTpm / 60);
+    this.tokens = Math.min(
+      this.tokens + refill,
+      this.currentTpm * this.config.burstAllowance
+    );
+    this.lastRefill = now;
+    this.maybeRecover(now);
+  }
+  maybeRecover(now) {
+    if (!this.config.adaptiveEnabled)
+      return;
+    if (this.currentTpm >= this.baseTpm)
+      return;
+    if (this.lastRateLimitTime === null)
+      return;
+    if ((now - this.lastRateLimitTime) / 1e3 < this.config.cooldownSeconds)
+      return;
+    if (this.successesSinceLimit < this.config.successesForRecovery)
+      return;
+    const newLimit = Math.min(
+      this.baseTpm,
+      this.currentTpm * this.config.recoveryFactor
+    );
+    if (newLimit > this.currentTpm) {
+      this.currentTpm = newLimit;
+      this.successesSinceLimit = 0;
+    }
+  }
+  // -- Public API ----------------------------------------------------------
+  /**
+   * Acquire tokens, waiting if necessary.
+   *
+   * @param estimatedTokens - Estimated token count for the request.
+   * @returns Time spent waiting in milliseconds (0 if immediate).
+   * @throws Error if waiting exceeds {@link RateLimiterConfig.maxWaitSeconds}.
+   */
+  async acquire(estimatedTokens) {
+    if (!this.config.enabled)
+      return 0;
+    estimatedTokens = Math.max(estimatedTokens, this.config.minTokensPerRequest);
+    const waitStart = performance.now();
+    for (; ; ) {
+      this.refill();
+      if (this.tokens >= estimatedTokens) {
+        this.tokens -= estimatedTokens;
+        return performance.now() - waitStart;
+      }
+      const elapsed = (performance.now() - waitStart) / 1e3;
+      if (elapsed >= this.config.maxWaitSeconds) {
+        throw new Error(
+          `Rate limiter: waited ${elapsed.toFixed(1)}s for ${estimatedTokens} tokens`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+  }
+  /**
+   * Record a 429 event -- adaptively reduce budget.
+   *
+   * Call this when the upstream API returns HTTP 429 or an equivalent
+   * rate-limit error.
+   */
+  recordRateLimit() {
+    if (!(this.config.enabled && this.config.adaptiveEnabled))
+      return;
+    this.lastRateLimitTime = performance.now();
+    this.successesSinceLimit = 0;
+    const newLimit = Math.max(
+      this.minTpm,
+      this.currentTpm * this.config.reductionFactor
+    );
+    if (newLimit < this.currentTpm) {
+      this.currentTpm = newLimit;
+      this.tokens = Math.min(this.tokens, this.currentTpm);
+    }
+  }
+  /**
+   * Record a successful request for adaptive recovery.
+   *
+   * Call this after each successful API response.
+   */
+  recordSuccess() {
+    if (!(this.config.enabled && this.config.adaptiveEnabled))
+      return;
+    this.successesSinceLimit += 1;
+  }
+  /** Current available token count. */
+  get availableTokens() {
+    return this.tokens;
+  }
+  /** Current tokens-per-minute budget (may be reduced after 429). */
+  get currentTokensPerMinute() {
+    return this.currentTpm;
+  }
+};
+var globalBucket = null;
+function getGlobalRateLimiter(config) {
+  if (globalBucket === null) {
+    globalBucket = new TokenBucket(config);
+  }
+  return globalBucket;
+}
+function resetGlobalRateLimiter() {
+  globalBucket = null;
+}
+
+// src/llm/mock.ts
+var MockLlmClient = class {
+  /** The model name returned in responses. */
+  defaultModel;
+  responses;
+  responseIndex = 0;
+  responseGenerator;
+  _callCount = 0;
+  _callHistory = [];
+  constructor(opts) {
+    this.defaultModel = opts?.defaultModel ?? "mock-model";
+    this.responses = opts?.responses ?? [];
+    this.responseGenerator = opts?.responseGenerator;
+  }
+  /** Number of queries made to this client. */
+  get callCount() {
+    return this._callCount;
+  }
+  /** History of all calls made to this client. */
+  get callHistory() {
+    return this._callHistory;
+  }
+  /** Reset call count, history, and response index. */
+  reset() {
+    this._callCount = 0;
+    this._callHistory.length = 0;
+    this.responseIndex = 0;
+  }
+  /**
+   * Return a mock response.
+   *
+   * Priority for determining response content:
+   *   1. `responseGenerator` function (if provided)
+   *   2. `responses` array (cycles through entries)
+   *   3. Default echo: "Mock response to: <prompt>"
+   *
+   * @param prompt - The prompt (recorded in history).
+   * @param opts   - Optional query configuration (recorded in history).
+   * @returns LlmResponse with mock content.
+   */
+  async query(prompt, opts) {
+    const model = opts?.model ?? this.defaultModel;
+    const maxTokens = opts?.maxTokens ?? 4096;
+    const temperature = opts?.temperature ?? 1;
+    this._callCount += 1;
+    this._callHistory.push({
+      prompt,
+      systemPrompt: opts?.systemPrompt,
+      maxTokens,
+      temperature,
+      model
+    });
+    let content;
+    if (this.responseGenerator) {
+      content = this.responseGenerator(prompt);
+    } else if (this.responses.length > 0) {
+      content = this.responses[this.responseIndex % this.responses.length];
+      this.responseIndex += 1;
+    } else {
+      content = `Mock response to: ${prompt.slice(0, 100)}`;
+    }
+    return {
+      content,
+      model,
+      usage: {
+        input_tokens: Math.max(Math.floor(prompt.length / 4), 1),
+        output_tokens: Math.max(Math.floor(content.length / 4), 1)
+      },
+      metadata: { mock: true, call_count: this._callCount }
+    };
+  }
+  /**
+   * Stream a mock response.
+   *
+   * Yields the response word by word to simulate streaming.
+   *
+   * @param prompt - The prompt (recorded in history).
+   * @param opts   - Optional query configuration.
+   * @yields Words from the mock response.
+   */
+  async *streamQuery(prompt, opts) {
+    const response = await this.query(prompt, opts);
+    const words = response.content.split(" ");
+    for (let i = 0; i < words.length; i++) {
+      yield words[i] + (i < words.length - 1 ? " " : "");
+    }
+  }
+};
+
+// src/llm/groq.ts
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
+var DEFAULT_MODEL = "llama-3.3-70b-versatile";
+var BASE_URL = "https://api.groq.com/openai/v1/chat/completions";
+var GroqClient = class _GroqClient {
+  /** The resolved API key. */
+  apiKey;
+  /** The default model used when none is specified per-call. */
+  defaultModel;
+  timeoutMs;
+  rateLimiter;
+  constructor(opts) {
+    this.defaultModel = opts?.defaultModel ?? process.env["GROQ_DEFAULT_MODEL"] ?? DEFAULT_MODEL;
+    const envKey = process.env["GROQ_API_KEY"]?.trim();
+    const resolved = opts?.apiKey ?? envKey ?? _GroqClient.loadKeyFile();
+    if (!resolved) {
+      throw new LlmAuthenticationError(
+        "No Groq API key. Set GROQ_API_KEY, pass apiKey, or create ~/.groq"
+      );
+    }
+    this.apiKey = resolved;
+    this.timeoutMs = opts?.timeoutMs ?? 12e4;
+    this.rateLimiter = getGlobalRateLimiter();
+  }
+  /**
+   * Load API key from ~/.groq file.
+   *
+   * @returns The key string, or null if the file does not exist.
+   */
+  static loadKeyFile() {
+    try {
+      const keyPath = import_node_path6.default.join(import_node_os.default.homedir(), ".groq");
+      if (import_node_fs4.default.existsSync(keyPath)) {
+        return import_node_fs4.default.readFileSync(keyPath, "utf-8").trim();
+      }
+    } catch {
+    }
+    return null;
+  }
+  // -- Helpers -------------------------------------------------------------
+  estimateTokens(prompt, systemPrompt) {
+    let total = prompt.length;
+    if (systemPrompt)
+      total += systemPrompt.length;
+    return Math.max(Math.floor(total / 4), 100);
+  }
+  buildMessages(prompt, systemPrompt) {
+    const messages = [];
+    if (systemPrompt) {
+      messages.push({ role: "system", content: systemPrompt });
+    }
+    messages.push({ role: "user", content: prompt });
+    return messages;
+  }
+  /**
+   * Map an HTTP error response to the appropriate LlmError subclass.
+   *
+   * @param status  - HTTP status code.
+   * @param body    - Parsed response body (if available).
+   * @param message - Raw error message.
+   */
+  mapError(status, body, message) {
+    if (status === 401 || status === 403) {
+      return new LlmAuthenticationError(`Groq auth failed (${status}): ${message}`);
+    }
+    if (status === 429) {
+      this.rateLimiter.recordRateLimit();
+      return new LlmRateLimitError(`Groq rate limit exceeded: ${message}`);
+    }
+    if (status === 408 || status === 504) {
+      return new LlmTimeoutError(`Groq request timed out (${status}): ${message}`);
+    }
+    const errorObj = body?.["error"];
+    const code = errorObj?.["code"];
+    if (code === "context_length_exceeded") {
+      return new LlmContextLengthError(`Groq context length exceeded: ${message}`);
+    }
+    return new LlmError(`Groq API error (${status}): ${message}`);
+  }
+  // -- Public API ----------------------------------------------------------
+  /**
+   * Send a query to Groq and get a complete response.
+   *
+   * @param prompt - The user prompt/query.
+   * @param opts   - Optional query configuration.
+   * @returns LlmResponse with generated content and metadata.
+   */
+  async query(prompt, opts) {
+    const useModel = opts?.model ?? this.defaultModel;
+    const maxTokens = opts?.maxTokens ?? 4096;
+    const temperature = opts?.temperature ?? 1;
+    const systemPrompt = opts?.systemPrompt;
+    const estimated = this.estimateTokens(prompt, systemPrompt);
+    await this.rateLimiter.acquire(estimated);
+    const body = {
+      model: useModel,
+      messages: this.buildMessages(prompt, systemPrompt),
+      max_tokens: maxTokens,
+      temperature
+    };
+    let response;
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+      response = await fetch(BASE_URL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new LlmTimeoutError(`Groq request timed out after ${this.timeoutMs}ms`);
+      }
+      throw new LlmError(`Groq network error: ${String(err)}`);
+    }
+    if (!response.ok) {
+      let errorBody = null;
+      let errorMessage = response.statusText;
+      try {
+        errorBody = await response.json();
+        const errorObj = errorBody?.["error"];
+        errorMessage = errorObj?.["message"] ?? errorMessage;
+      } catch {
+      }
+      throw this.mapError(response.status, errorBody, errorMessage);
+    }
+    const data = await response.json();
+    this.rateLimiter.recordSuccess();
+    const choices = data["choices"];
+    const firstChoice = choices?.[0];
+    const messageObj = firstChoice?.["message"];
+    const content = messageObj?.["content"] ?? "";
+    const usageObj = data["usage"];
+    let usage;
+    if (usageObj) {
+      usage = {
+        input_tokens: usageObj["prompt_tokens"] ?? 0,
+        output_tokens: usageObj["completion_tokens"] ?? 0
+      };
+    }
+    return {
+      content,
+      model: data["model"] ?? useModel,
+      usage
+    };
+  }
+  /**
+   * Stream a query response chunk by chunk.
+   *
+   * Uses Server-Sent Events (SSE) streaming from the Groq API.
+   *
+   * @param prompt - The user prompt/query.
+   * @param opts   - Optional query configuration.
+   * @yields Text chunks as they arrive from the API.
+   */
+  async *streamQuery(prompt, opts) {
+    const useModel = opts?.model ?? this.defaultModel;
+    const maxTokens = opts?.maxTokens ?? 4096;
+    const temperature = opts?.temperature ?? 1;
+    const systemPrompt = opts?.systemPrompt;
+    const estimated = this.estimateTokens(prompt, systemPrompt);
+    await this.rateLimiter.acquire(estimated);
+    const body = {
+      model: useModel,
+      messages: this.buildMessages(prompt, systemPrompt),
+      max_tokens: maxTokens,
+      temperature,
+      stream: true
+    };
+    let response;
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+      response = await fetch(BASE_URL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new LlmTimeoutError(`Groq request timed out after ${this.timeoutMs}ms`);
+      }
+      throw new LlmError(`Groq network error: ${String(err)}`);
+    }
+    if (!response.ok) {
+      let errorBody = null;
+      let errorMessage = response.statusText;
+      try {
+        errorBody = await response.json();
+        const errorObj = errorBody?.["error"];
+        errorMessage = errorObj?.["message"] ?? errorMessage;
+      } catch {
+      }
+      throw this.mapError(response.status, errorBody, errorMessage);
+    }
+    if (!response.body) {
+      throw new LlmError("Groq streaming response has no body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let streamCompleted = false;
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data: "))
+            continue;
+          const payload = trimmed.slice(6);
+          if (payload === "[DONE]") {
+            streamCompleted = true;
+            return;
+          }
+          try {
+            const chunk = JSON.parse(payload);
+            const choices = chunk["choices"];
+            const delta = choices?.[0]?.["delta"];
+            const content = delta?.["content"];
+            if (content)
+              yield content;
+          } catch {
+          }
+        }
+      }
+      streamCompleted = true;
+    } finally {
+      reader.releaseLock();
+      if (streamCompleted)
+        this.rateLimiter.recordSuccess();
+    }
+  }
+};
+
+// src/llm/anthropic.ts
+var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_os2 = __toESM(require("node:os"), 1);
+var import_node_path7 = __toESM(require("node:path"), 1);
+var DEFAULT_MODEL2 = "claude-sonnet-4-20250514";
+var BASE_URL2 = "https://api.anthropic.com/v1/messages";
+var ANTHROPIC_VERSION = "2023-06-01";
+var AnthropicClient = class _AnthropicClient {
+  /** The resolved API key. */
+  apiKey;
+  /** The default model used when none is specified per-call. */
+  defaultModel;
+  timeoutMs;
+  rateLimiter;
+  constructor(opts) {
+    this.defaultModel = opts?.defaultModel ?? process.env["ANTHROPIC_DEFAULT_MODEL"] ?? DEFAULT_MODEL2;
+    const envKey = process.env["ANTHROPIC_API_KEY"]?.trim();
+    const resolved = opts?.apiKey ?? envKey ?? _AnthropicClient.loadKeyFile();
+    if (!resolved) {
+      throw new LlmAuthenticationError(
+        "No Anthropic API key. Set ANTHROPIC_API_KEY, pass apiKey, or create ~/.anthropic"
+      );
+    }
+    this.apiKey = resolved;
+    this.timeoutMs = opts?.timeoutMs ?? 3e5;
+    this.rateLimiter = getGlobalRateLimiter();
+  }
+  /**
+   * Load API key from ~/.anthropic file.
+   *
+   * @returns The key string, or null if the file does not exist.
+   */
+  static loadKeyFile() {
+    try {
+      const keyPath = import_node_path7.default.join(import_node_os2.default.homedir(), ".anthropic");
+      if (import_node_fs5.default.existsSync(keyPath)) {
+        return import_node_fs5.default.readFileSync(keyPath, "utf-8").trim();
+      }
+    } catch {
+    }
+    return null;
+  }
+  // -- Helpers -------------------------------------------------------------
+  estimateTokens(prompt, systemPrompt) {
+    let total = prompt.length;
+    if (systemPrompt)
+      total += systemPrompt.length;
+    return Math.max(Math.floor(total / 4), 100);
+  }
+  /**
+   * Map an HTTP error response to the appropriate LlmError subclass.
+   *
+   * @param status  - HTTP status code.
+   * @param body    - Parsed response body (if available).
+   * @param message - Raw error message.
+   */
+  mapError(status, body, message) {
+    if (status === 401 || status === 403) {
+      return new LlmAuthenticationError(
+        `Anthropic auth failed (${status}): ${message}`
+      );
+    }
+    if (status === 429) {
+      this.rateLimiter.recordRateLimit();
+      return new LlmRateLimitError(
+        `Anthropic rate limit exceeded: ${message}`
+      );
+    }
+    if (status === 408 || status === 504) {
+      return new LlmTimeoutError(
+        `Anthropic request timed out (${status}): ${message}`
+      );
+    }
+    const errorType = body?.["error"];
+    const errType = errorType?.["type"];
+    if (errType === "invalid_request_error") {
+      const msg = message.toLowerCase();
+      if (msg.includes("context") || msg.includes("token")) {
+        return new LlmContextLengthError(
+          `Anthropic context length exceeded: ${message}`
+        );
+      }
+    }
+    const lowerMsg = message.toLowerCase();
+    if (lowerMsg.includes("credit balance") || lowerMsg.includes("billing")) {
+      return new LlmAuthenticationError(
+        `Anthropic billing error: ${message}`
+      );
+    }
+    return new LlmError(`Anthropic API error (${status}): ${message}`);
+  }
+  // -- Public API ----------------------------------------------------------
+  /**
+   * Send a query to Anthropic and get a complete response.
+   *
+   * System prompts are sent via the top-level `system` parameter rather
+   * than as a system message in the messages array, per the Anthropic API
+   * specification.
+   *
+   * @param prompt - The user prompt/query.
+   * @param opts   - Optional query configuration.
+   * @returns LlmResponse with generated content and metadata.
+   */
+  async query(prompt, opts) {
+    const useModel = opts?.model ?? this.defaultModel;
+    const maxTokens = opts?.maxTokens ?? 4096;
+    const temperature = opts?.temperature ?? 1;
+    const systemPrompt = opts?.systemPrompt;
+    const estimated = this.estimateTokens(prompt, systemPrompt);
+    await this.rateLimiter.acquire(estimated);
+    const requestBody = {
+      model: useModel,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: maxTokens,
+      temperature
+    };
+    if (systemPrompt) {
+      requestBody["system"] = systemPrompt;
+    }
+    let response;
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+      response = await fetch(BASE_URL2, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": ANTHROPIC_VERSION
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new LlmTimeoutError(
+          `Anthropic request timed out after ${this.timeoutMs}ms`
+        );
+      }
+      throw new LlmError(`Anthropic network error: ${String(err)}`);
+    }
+    if (!response.ok) {
+      let errorBody = null;
+      let errorMessage = response.statusText;
+      try {
+        errorBody = await response.json();
+        const errorObj = errorBody?.["error"];
+        errorMessage = errorObj?.["message"] ?? errorMessage;
+      } catch {
+      }
+      throw this.mapError(response.status, errorBody, errorMessage);
+    }
+    const data = await response.json();
+    this.rateLimiter.recordSuccess();
+    const contentBlocks = data["content"];
+    const textParts = [];
+    if (contentBlocks) {
+      for (const block of contentBlocks) {
+        if (block["type"] === "text" && typeof block["text"] === "string") {
+          textParts.push(block["text"]);
+        }
+      }
+    }
+    const content = textParts.join("").trim();
+    const usageObj = data["usage"];
+    const inputTokens = usageObj?.["input_tokens"] ?? 0;
+    const outputTokens = usageObj?.["output_tokens"] ?? 0;
+    return {
+      content,
+      model: data["model"] ?? useModel,
+      usage: {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens
+      }
+    };
+  }
+  /**
+   * Stream a query response chunk by chunk.
+   *
+   * Uses Server-Sent Events (SSE) streaming from the Anthropic API.
+   * System prompts are sent via the top-level `system` parameter.
+   *
+   * @param prompt - The user prompt/query.
+   * @param opts   - Optional query configuration.
+   * @yields Text chunks as they arrive from the API.
+   */
+  async *streamQuery(prompt, opts) {
+    const useModel = opts?.model ?? this.defaultModel;
+    const maxTokens = opts?.maxTokens ?? 4096;
+    const temperature = opts?.temperature ?? 1;
+    const systemPrompt = opts?.systemPrompt;
+    const estimated = this.estimateTokens(prompt, systemPrompt);
+    await this.rateLimiter.acquire(estimated);
+    const requestBody = {
+      model: useModel,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: maxTokens,
+      temperature,
+      stream: true
+    };
+    if (systemPrompt) {
+      requestBody["system"] = systemPrompt;
+    }
+    let response;
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+      response = await fetch(BASE_URL2, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": ANTHROPIC_VERSION
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new LlmTimeoutError(
+          `Anthropic request timed out after ${this.timeoutMs}ms`
+        );
+      }
+      throw new LlmError(`Anthropic network error: ${String(err)}`);
+    }
+    if (!response.ok) {
+      let errorBody = null;
+      let errorMessage = response.statusText;
+      try {
+        errorBody = await response.json();
+        const errorObj = errorBody?.["error"];
+        errorMessage = errorObj?.["message"] ?? errorMessage;
+      } catch {
+      }
+      throw this.mapError(response.status, errorBody, errorMessage);
+    }
+    if (!response.body) {
+      throw new LlmError("Anthropic streaming response has no body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let streamCompleted = false;
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data: "))
+            continue;
+          const payload = trimmed.slice(6);
+          try {
+            const event = JSON.parse(payload);
+            const eventType = event["type"];
+            if (eventType === "content_block_delta") {
+              const delta = event["delta"];
+              if (delta?.["type"] === "text_delta") {
+                const text = delta["text"];
+                if (text)
+                  yield text;
+              }
+            } else if (eventType === "message_stop") {
+              streamCompleted = true;
+              return;
+            }
+          } catch {
+          }
+        }
+      }
+      streamCompleted = true;
+    } finally {
+      reader.releaseLock();
+      if (streamCompleted)
+        this.rateLimiter.recordSuccess();
+    }
+  }
+};
+
+// src/llm/factory.ts
+function createLlmClient(opts) {
+  const clientType = (opts?.clientType ?? process.env["LLM_CLIENT_TYPE"] ?? "mock").toLowerCase();
+  const model = opts?.model ?? process.env["LLM_DEFAULT_MODEL"];
+  if (clientType === "mock") {
+    return new MockLlmClient({
+      defaultModel: model ?? "mock-model"
+    });
+  }
+  if (clientType === "groq") {
+    return new GroqClient({
+      apiKey: opts?.apiKey,
+      defaultModel: model,
+      timeoutMs: opts?.timeoutMs
+    });
+  }
+  if (clientType === "anthropic") {
+    return new AnthropicClient({
+      apiKey: opts?.apiKey,
+      defaultModel: model,
+      timeoutMs: opts?.timeoutMs
+    });
+  }
+  throw new Error(
+    `Unknown LLM client type: "${clientType}". Valid types: "groq", "anthropic", "mock"`
+  );
+}
+
 // src/index.ts
-var version = "0.4.0";
+var version = "0.6.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACKLifecycleManager,
+  AGENT_STATE_FAILED,
+  AGENT_STATE_INITIALIZING,
+  AGENT_STATE_RUNNING,
+  AGENT_STATE_SHUTTING_DOWN,
   AckStage,
   ActivityBuffer,
   ActivityBufferSync,
   ActivityClient,
   AgentState,
   AgentStateMachine,
+  AnthropicClient,
   ArtifactType,
   BaseClient,
   BordaCountAggregator,
+  BufferFullError,
   CT_AGENT_REPORT_V1,
   CT_SCHEDULER_COMMAND_V1,
+  CancellationManager,
+  CancellationValidationError,
+  CommunicationClass,
   ConfidenceWeightedAggregator,
   ConnectorClient,
+  DEDUP_WINDOW_S,
+  DEFAULT_ACK_TIMEOUT_MS,
+  DEFAULT_BACKOFF_MULTIPLIER,
+  DEFAULT_EFFECTIVE_MAX_REDIRECTS,
   DEFAULT_ESCALATION_POLICY,
   DEFAULT_EXECUTION_POLICY,
+  DEFAULT_INITIAL_BACKOFF_MS,
+  DEFAULT_MAX_BACKOFF_MS,
+  DEFAULT_MAX_REDIRECTS,
+  DEFAULT_MAX_RETRIES_ON_OVERLOADED,
   DEFAULT_NEGOTIATION_POLICY,
+  DEFAULT_PEER_LIVENESS_THRESHOLD_MS,
+  DebateIntensity,
   DecisionOutcome,
   DefaultWorktreePolicy,
+  DuplicateDetectedError,
+  EnvelopeState,
   ErrorCode,
   ErrorCodeMapper,
   FileBackend,
+  GatewayRedirectEmitter,
+  GatewayValidationError,
+  GroqClient,
   HITLClient,
   HandoffClient,
   HandoffStatus,
   HandoffTimeoutError,
   HandoffValidationError,
   HitlMode,
+  HitlReasonType,
+  InMemoryAuditor,
+  InMemoryNegotiationRoomStore,
   InMemoryPolicyStore,
   InterceptorChain,
   JSONFilePersistence,
   JsonFilePolicyStore,
   KeyringBackend,
+  LlmAuthenticationError,
+  LlmContextLengthError,
+  LlmError,
+  LlmRateLimitError,
+  LlmTimeoutError,
   LoggingClient,
+  MIN_GRACE_PERIOD_MS,
   MajorityVoteAggregator,
   MaxEntriesStrategy,
   MessageProcessor,
   MessageType,
+  MockLlmClient,
+  NON_SERVING_AGENT_STATES,
   NegotiationClient,
+  NegotiationError,
   NegotiationRoomClient,
+  NegotiationRoomStoreError,
   NegotiationTimeoutError,
   NegotiationValidationError,
+  NoOpAuditor,
   NodeStatus,
+  PeerSelector,
+  PermissionError,
+  PersistentActivityBuffer,
   PersistentWorktreeState,
   PolicyStoreError,
+  PolicyViolationError,
+  PreemptionError,
+  REGISTRATION_TYPE_STANDARD_AGENT,
+  REGISTRATION_TYPE_SWARM_GATEWAY,
+  RETRY_AFTER_JITTER_RATIO,
   ReasoningClient,
   RegistryClient,
   Resolver,
+  RouteError,
   RouterClient,
   RuntimePersistence,
   SchedulerClient,
@@ -13361,35 +15860,63 @@ var version = "0.4.0";
   SimpleAverageAggregator,
   StateTransitionError,
   Sw4rmError,
+  TimeoutError,
+  TokenBucket,
   ToolClient,
   TriggerType,
+  ValidationError,
   VotingAnalyzer,
   WorkflowClient,
   WorkflowCycleError,
   WorkflowStatus,
   WorkflowValidationError,
   WorktreeClient,
+  WorktreeError,
+  WorktreeStateEnum,
+  WorktreeTransitionError,
   aggregateVotes,
   buildAckEnvelope,
   buildEnvelope,
+  buildRateLimiterConfig,
+  computeEnvelopeHash,
   computeIdempotencyToken,
+  createLlmClient,
   createResilientIncomingStream,
+  createSimpleProof,
   decodeAgentReportV1,
   decodeBase64,
+  defaultAgentConfig,
+  defaultEndpoints,
+  defaultRetryPolicy,
+  defaultSW4RMConfig,
+  delegateToSwarm,
   durationToMs,
   encodeSchedulerCommandV1,
+  getConfig,
+  getDefaultStore,
+  getGlobalRateLimiter,
   getValidTransitions,
+  isTerminalEnvelopeState,
   isValidTransition,
+  isValidWorktreeTransition,
+  loadConfig,
+  loadConfigFromEnv,
   loggingInterceptor,
   mapGrpcStatusToErrorCode,
   msToDuration,
   normalizeReportPaths,
   nowTimestamp,
   parseNegotiationEvent,
+  resetConfig,
+  resetDefaultStore,
+  resetGlobalRateLimiter,
   selectBackend,
   sendMessageWithAck,
+  setConfig,
   timingInterceptor,
+  updateEnvelopeState,
   uuidv4,
+  verifyAuditProof,
   version
 });
 /*! Bundled license information: