@sw4rm/js-sdk 0.3.0 → 0.5.0

package/dist/cjs/index.cjs

@@ -1859,7 +1859,7 @@ var require_fetch = __commonJS({
     module2.exports = fetch;
     var asPromise = require_aspromise();
     var inquire2 = require_inquire();
-    var fs = inquire2("fs");
+    var fs3 = inquire2("fs");
     function fetch(filename, options, callback) {
       if (typeof options === "function") {
         callback = options;
@@ -1868,8 +1868,8 @@ var require_fetch = __commonJS({
         options = {};
       if (!callback)
         return asPromise(fetch, this, filename, options);
-      if (!options.xhr && fs && fs.readFile)
-        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
+      if (!options.xhr && fs3 && fs3.readFile)
+        return fs3.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 fetch.xhr(filename, options, callback);
@@ -1907,15 +1907,15 @@ var require_fetch = __commonJS({
 var require_path = __commonJS({
   "node_modules/@protobufjs/path/index.js"(exports2) {
     "use strict";
-    var path3 = exports2;
+    var path5 = exports2;
     var isAbsolute = (
       /**
        * Tests if the specified path is absolute.
        * @param {string} path Path to test
        * @returns {boolean} `true` if path is absolute
        */
-      path3.isAbsolute = function isAbsolute2(path4) {
-        return /^(?:\/|\w+:)/.test(path4);
+      path5.isAbsolute = function isAbsolute2(path6) {
+        return /^(?:\/|\w+:)/.test(path6);
       }
     );
     var normalize = (
@@ -1924,9 +1924,9 @@ var require_path = __commonJS({
        * @param {string} path Path to normalize
        * @returns {string} Normalized path
        */
-      path3.normalize = function normalize2(path4) {
-        path4 = path4.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
-        var parts = path4.split("/"), absolute = isAbsolute(path4), prefix = "";
+      path5.normalize = function normalize2(path6) {
+        path6 = path6.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+        var parts = path6.split("/"), absolute = isAbsolute(path6), 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("/");
       }
     );
-    path3.resolve = function resolve(originPath, includePath, alreadyNormalized) {
+    path5.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(path3, json) {
-      if (util.isString(path3))
-        path3 = path3.split(".");
-      else if (!Array.isArray(path3))
+    Namespace.prototype.define = function define2(path5, json) {
+      if (util.isString(path5))
+        path5 = path5.split(".");
+      else if (!Array.isArray(path5))
         throw TypeError("illegal path");
-      if (path3 && path3.length && path3[0] === "")
+      if (path5 && path5.length && path5[0] === "")
         throw Error("path must be relative");
       var ptr = this;
-      while (path3.length > 0) {
-        var part = path3.shift();
+      while (path5.length > 0) {
+        var part = path5.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(path3, filterTypes, parentAlreadyChecked) {
+    Namespace.prototype.lookup = function lookup(path5, filterTypes, parentAlreadyChecked) {
       if (typeof filterTypes === "boolean") {
         parentAlreadyChecked = filterTypes;
         filterTypes = void 0;
       } else if (filterTypes && !Array.isArray(filterTypes))
         filterTypes = [filterTypes];
-      if (util.isString(path3) && path3.length) {
-        if (path3 === ".")
+      if (util.isString(path5) && path5.length) {
+        if (path5 === ".")
           return this.root;
-        path3 = path3.split(".");
-      } else if (!path3.length)
+        path5 = path5.split(".");
+      } else if (!path5.length)
         return this;
-      var flatPath = path3.join(".");
-      if (path3[0] === "")
-        return this.root.lookup(path3.slice(1), filterTypes);
+      var flatPath = path5.join(".");
+      if (path5[0] === "")
+        return this.root.lookup(path5.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(path3, flatPath);
+      found = this._lookupImpl(path5, 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(path3, flatPath);
+        found = current.parent._lookupImpl(path5, 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(path3, flatPath) {
+    Namespace.prototype._lookupImpl = function lookup(path5, flatPath) {
       if (Object.prototype.hasOwnProperty.call(this._lookupCache, flatPath)) {
         return this._lookupCache[flatPath];
       }
-      var found = this.get(path3[0]);
+      var found = this.get(path5[0]);
       var exact = null;
       if (found) {
-        if (path3.length === 1) {
+        if (path5.length === 1) {
           exact = found;
         } else if (found instanceof Namespace) {
-          path3 = path3.slice(1);
-          exact = found._lookupImpl(path3, path3.join("."));
+          path5 = path5.slice(1);
+          exact = found._lookupImpl(path5, path5.join("."));
         }
       } else {
         for (var i = 0; i < this.nestedArray.length; ++i)
-          if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i]._lookupImpl(path3, flatPath)))
+          if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i]._lookupImpl(path5, flatPath)))
             exact = found;
       }
       this._lookupCache[flatPath] = exact;
       return exact;
     };
-    Namespace.prototype.lookupType = function lookupType(path3) {
-      var found = this.lookup(path3, [Type]);
+    Namespace.prototype.lookupType = function lookupType(path5) {
+      var found = this.lookup(path5, [Type]);
       if (!found)
-        throw Error("no such type: " + path3);
+        throw Error("no such type: " + path5);
       return found;
     };
-    Namespace.prototype.lookupEnum = function lookupEnum(path3) {
-      var found = this.lookup(path3, [Enum]);
+    Namespace.prototype.lookupEnum = function lookupEnum(path5) {
+      var found = this.lookup(path5, [Enum]);
       if (!found)
-        throw Error("no such Enum '" + path3 + "' in " + this);
+        throw Error("no such Enum '" + path5 + "' in " + this);
       return found;
     };
-    Namespace.prototype.lookupTypeOrEnum = function lookupTypeOrEnum(path3) {
-      var found = this.lookup(path3, [Type, Enum]);
+    Namespace.prototype.lookupTypeOrEnum = function lookupTypeOrEnum(path5) {
+      var found = this.lookup(path5, [Type, Enum]);
       if (!found)
-        throw Error("no such Type or Enum '" + path3 + "' in " + this);
+        throw Error("no such Type or Enum '" + path5 + "' in " + this);
       return found;
     };
-    Namespace.prototype.lookupService = function lookupService(path3) {
-      var found = this.lookup(path3, [Service]);
+    Namespace.prototype.lookupService = function lookupService(path5) {
+      var found = this.lookup(path5, [Service]);
       if (!found)
-        throw Error("no such Service '" + path3 + "' in " + this);
+        throw Error("no such Service '" + path5 + "' in " + this);
       return found;
     };
     Namespace._configure = function(Type_, Service_, Enum_) {
@@ -3620,14 +3620,14 @@ var require_util = __commonJS({
       Object.defineProperty(object, "$type", { value: enm, enumerable: false });
       return enm;
     };
-    util.setProperty = function setProperty(dst, path3, value, ifNotSet) {
-      function setProp(dst2, path4, value2) {
-        var part = path4.shift();
+    util.setProperty = function setProperty(dst, path5, value, ifNotSet) {
+      function setProp(dst2, path6, value2) {
+        var part = path6.shift();
         if (part === "__proto__" || part === "prototype") {
           return dst2;
         }
-        if (path4.length > 0) {
-          dst2[part] = setProp(dst2[part] || {}, path4, value2);
+        if (path6.length > 0) {
+          dst2[part] = setProp(dst2[part] || {}, path6, 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 (!path3)
+      if (!path5)
         throw TypeError("path must be specified");
-      path3 = path3.split(".");
-      return setProp(dst, path3, value);
+      path5 = path5.split(".");
+      return setProp(dst, path5, value);
     };
     Object.defineProperty(util, "decorateRoot", {
       get: function() {
@@ -4190,12 +4190,12 @@ var require_object = __commonJS({
        */
       fullName: {
         get: function() {
-          var path3 = [this.name], ptr = this.parent;
+          var path5 = [this.name], ptr = this.parent;
           while (ptr) {
-            path3.unshift(ptr.name);
+            path5.unshift(ptr.name);
             ptr = ptr.parent;
           }
-          return path3.join(".");
+          return path5.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 path3 = require("path");
+    var fs3 = require("fs");
+    var path5 = require("path");
     var Protobuf = require_protobufjs();
     function addIncludePathResolver(root, includePaths) {
       const originalResolvePath = root.resolvePath;
       root.resolvePath = (origin, target) => {
-        if (path3.isAbsolute(target)) {
+        if (path5.isAbsolute(target)) {
           return target;
         }
         for (const directory of includePaths) {
-          const fullPath = path3.join(directory, target);
+          const fullPath = path5.join(directory, target);
           try {
-            fs.accessSync(fullPath, fs.constants.R_OK);
+            fs3.accessSync(fullPath, fs3.constants.R_OK);
             return fullPath;
           } catch (err) {
             continue;
@@ -9483,31 +9483,71 @@ var require_src2 = __commonJS({
 var src_exports = {};
 __export(src_exports, {
   ACKLifecycleManager: () => ACKLifecycleManager,
-  AckStage: () => AckStage,
+  AckStage: () => AckStage2,
   ActivityBuffer: () => ActivityBuffer,
   ActivityBufferSync: () => ActivityBufferSync,
   ActivityClient: () => ActivityClient,
+  AgentState: () => AgentState,
+  AgentStateMachine: () => AgentStateMachine,
+  ArtifactType: () => ArtifactType,
   BaseClient: () => BaseClient,
+  BordaCountAggregator: () => BordaCountAggregator,
+  BufferFullError: () => BufferFullError,
   CT_AGENT_REPORT_V1: () => CT_AGENT_REPORT_V1,
   CT_SCHEDULER_COMMAND_V1: () => CT_SCHEDULER_COMMAND_V1,
+  CommunicationClass: () => CommunicationClass,
+  ConfidenceWeightedAggregator: () => ConfidenceWeightedAggregator,
   ConnectorClient: () => ConnectorClient,
+  DEDUP_WINDOW_S: () => DEDUP_WINDOW_S,
+  DEFAULT_ACK_TIMEOUT_MS: () => DEFAULT_ACK_TIMEOUT_MS,
+  DEFAULT_ESCALATION_POLICY: () => DEFAULT_ESCALATION_POLICY,
+  DEFAULT_EXECUTION_POLICY: () => DEFAULT_EXECUTION_POLICY,
+  DEFAULT_NEGOTIATION_POLICY: () => DEFAULT_NEGOTIATION_POLICY,
+  DebateIntensity: () => DebateIntensity,
+  DecisionOutcome: () => DecisionOutcome,
   DefaultWorktreePolicy: () => DefaultWorktreePolicy,
+  DuplicateDetectedError: () => DuplicateDetectedError,
+  EnvelopeState: () => EnvelopeState,
   ErrorCode: () => ErrorCode,
   ErrorCodeMapper: () => ErrorCodeMapper,
   FileBackend: () => FileBackend,
   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,
   LoggingClient: () => LoggingClient,
+  MajorityVoteAggregator: () => MajorityVoteAggregator,
   MaxEntriesStrategy: () => MaxEntriesStrategy,
   MessageProcessor: () => MessageProcessor,
   MessageType: () => MessageType,
   NegotiationClient: () => NegotiationClient,
+  NegotiationError: () => NegotiationError,
+  NegotiationRoomClient: () => NegotiationRoomClient,
+  NegotiationRoomStoreError: () => NegotiationRoomStoreError,
+  NegotiationTimeoutError: () => NegotiationTimeoutError,
+  NegotiationValidationError: () => NegotiationValidationError,
+  NoOpAuditor: () => NoOpAuditor,
+  NodeStatus: () => NodeStatus,
+  PermissionError: () => PermissionError,
+  PersistentActivityBuffer: () => PersistentActivityBuffer,
   PersistentWorktreeState: () => PersistentWorktreeState,
+  PolicyStoreError: () => PolicyStoreError,
+  PolicyViolationError: () => PolicyViolationError,
+  PreemptionError: () => PreemptionError,
   ReasoningClient: () => ReasoningClient,
   RegistryClient: () => RegistryClient,
   Resolver: () => Resolver,
+  RouteError: () => RouteError,
   RouterClient: () => RouterClient,
   RuntimePersistence: () => RuntimePersistence,
   SchedulerClient: () => SchedulerClient,
@@ -9522,32 +9562,66 @@ __export(src_exports, {
   SecretValidationError: () => SecretValidationError,
   SecretValue: () => SecretValue,
   Secrets: () => Secrets,
+  SimpleAverageAggregator: () => SimpleAverageAggregator,
+  StateTransitionError: () => StateTransitionError,
   Sw4rmError: () => Sw4rmError,
+  TimeoutError: () => TimeoutError,
   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,
+  computeEnvelopeHash: () => computeEnvelopeHash,
   computeIdempotencyToken: () => computeIdempotencyToken,
   createResilientIncomingStream: () => createResilientIncomingStream,
+  createSimpleProof: () => createSimpleProof,
   decodeAgentReportV1: () => decodeAgentReportV1,
   decodeBase64: () => decodeBase64,
+  defaultAgentConfig: () => defaultAgentConfig,
+  defaultEndpoints: () => defaultEndpoints,
+  defaultRetryPolicy: () => defaultRetryPolicy,
+  defaultSW4RMConfig: () => defaultSW4RMConfig,
   durationToMs: () => durationToMs,
   encodeSchedulerCommandV1: () => encodeSchedulerCommandV1,
+  getConfig: () => getConfig,
+  getDefaultStore: () => getDefaultStore,
+  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,
   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);
@@ -9569,6 +9643,8 @@ 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["INTERNAL_ERROR"] = 99] = "INTERNAL_ERROR";
   return ErrorCode2;
 })(ErrorCode || {});
@@ -9584,6 +9660,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,
@@ -9603,6 +9727,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:
@@ -9672,7 +9818,7 @@ var InterceptorChain = class {
 };
 function timingInterceptor() {
   return {
-    onRequest(ctx) {
+    onRequest(_ctx) {
     },
     onResponse(ctx, status) {
       if (typeof console !== "undefined" && console.debug) {
@@ -9717,12 +9863,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,
@@ -9742,10 +9888,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());
@@ -9755,6 +9904,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();
   }
@@ -10342,214 +10512,1370 @@ var RegistryClient = class extends BaseClient {
   }
 };
 
-// src/internal/envelope.ts
-var import_node_crypto2 = __toESM(require("node:crypto"), 1);
-function nowTimestamp(date = /* @__PURE__ */ new Date()) {
-  const ms = date.getTime();
-  const seconds = Math.floor(ms / 1e3);
-  const nanos = ms % 1e3 * 1e6;
-  return { seconds, nanos };
-}
-function nowHlcStub(date = /* @__PURE__ */ new Date()) {
-  return String(date.getTime());
-}
-function uuidv42() {
-  if (typeof import_node_crypto2.default.randomUUID === "function") {
-    return import_node_crypto2.default.randomUUID();
+// src/clients/negotiationRoomStore.ts
+var NegotiationRoomStoreError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NegotiationRoomStoreError";
   }
-  const buf = import_node_crypto2.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 buildEnvelope(input) {
-  const hasPayload = input.payload !== void 0;
-  const content_type = input.content_type ?? "application/json";
-  const message_id = uuidv42();
-  const correlation_id = input.correlation_id ?? uuidv42();
-  const sequence_number = input.sequence_number ?? 1;
-  const retry_count = input.retry_count ?? 0;
-  const ts = nowTimestamp(input.timestamp ?? /* @__PURE__ */ new Date());
-  const hlc_timestamp = input.hlc_timestamp ?? nowHlcStub(input.timestamp);
-  const built = {
-    message_id,
-    idempotency_token: input.idempotency_token,
-    producer_id: input.producer_id,
-    correlation_id,
-    sequence_number,
-    retry_count,
-    message_type: input.message_type,
-    content_type,
-    // Always set content_type (aligns with Python/Rust)
-    repo_id: input.repo_id,
-    worktree_id: input.worktree_id,
-    hlc_timestamp,
-    // Always set hlc_timestamp (aligns with Python/Rust)
-    ttl_ms: input.ttl_ms,
-    timestamp: ts
-  };
-  if (hasPayload) {
-    const payload = input.payload instanceof Uint8Array ? input.payload : new Uint8Array(input.payload);
-    built.payload = payload;
-    built.content_length = payload.byteLength;
-    if (!input.content_type) {
-      built.content_type = "application/octet-stream";
+};
+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, []);
   }
-  return built;
-}
-
-// src/internal/worktreeState.ts
-var PersistentWorktreeState = class {
-  state = "UNBOUND";
-  repoId;
-  worktreeId;
-  bind(repoId, worktreeId) {
-    this.repoId = repoId;
-    this.worktreeId = worktreeId;
-    this.state = "BOUND_HOME";
+  async listProposals(negotiationRoomId) {
+    const allProposals = Array.from(this.proposals.values());
+    if (negotiationRoomId === void 0) {
+      return allProposals;
+    }
+    return allProposals.filter((p) => p.negotiationRoomId === negotiationRoomId);
   }
-  unbind() {
-    this.repoId = void 0;
-    this.worktreeId = void 0;
-    this.state = "UNBOUND";
+  async getVotes(artifactId) {
+    return [...this.votes.get(artifactId) || []];
   }
-  setState(state) {
-    this.state = state;
+  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);
   }
-  current() {
-    return { state: this.state, repo_id: this.repoId, worktree_id: this.worktreeId };
+  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/internal/runtime/activityBuffer.ts
-var MaxEntriesStrategy = class {
-  prune(records, maxEntries) {
-    if (records.length <= maxEntries)
-      return records;
-    const overflow = records.length - maxEntries;
-    return records.slice(overflow);
+// src/clients/negotiationRoom.ts
+var ArtifactType = /* @__PURE__ */ ((ArtifactType2) => {
+  ArtifactType2[ArtifactType2["ARTIFACT_TYPE_UNSPECIFIED"] = 0] = "ARTIFACT_TYPE_UNSPECIFIED";
+  ArtifactType2[ArtifactType2["REQUIREMENTS"] = 1] = "REQUIREMENTS";
+  ArtifactType2[ArtifactType2["PLAN"] = 2] = "PLAN";
+  ArtifactType2[ArtifactType2["CODE"] = 3] = "CODE";
+  ArtifactType2[ArtifactType2["DEPLOYMENT"] = 4] = "DEPLOYMENT";
+  return ArtifactType2;
+})(ArtifactType || {});
+var DecisionOutcome = /* @__PURE__ */ ((DecisionOutcome2) => {
+  DecisionOutcome2[DecisionOutcome2["DECISION_OUTCOME_UNSPECIFIED"] = 0] = "DECISION_OUTCOME_UNSPECIFIED";
+  DecisionOutcome2[DecisionOutcome2["APPROVED"] = 1] = "APPROVED";
+  DecisionOutcome2[DecisionOutcome2["REVISION_REQUESTED"] = 2] = "REVISION_REQUESTED";
+  DecisionOutcome2[DecisionOutcome2["ESCALATED_TO_HITL"] = 3] = "ESCALATED_TO_HITL";
+  return DecisionOutcome2;
+})(DecisionOutcome || {});
+var NegotiationTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NegotiationTimeoutError";
   }
 };
-var ActivityBuffer = class {
-  records = /* @__PURE__ */ new Map();
-  maxEntries;
-  strategy;
-  constructor(opts) {
-    this.maxEntries = opts?.maxEntries ?? 1e3;
-    this.strategy = opts?.strategy ?? new MaxEntriesStrategy();
+var NegotiationValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NegotiationValidationError";
   }
-  upsert(rec) {
-    this.records.set(rec.task_id, rec);
-    this.prune();
+};
+function validateVote(vote) {
+  if (vote.score < 0 || vote.score > 10) {
+    throw new NegotiationValidationError(
+      `score must be in range [0, 10], got ${vote.score}`
+    );
   }
-  remove(taskId) {
-    this.records.delete(taskId);
+  if (vote.confidence < 0 || vote.confidence > 1) {
+    throw new NegotiationValidationError(
+      `confidence must be in range [0, 1], got ${vote.confidence}`
+    );
   }
-  list() {
-    return [...this.records.values()].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+var NegotiationRoomClient = class {
+  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.
+   *
+   * Stores the proposal and initializes empty vote tracking for the artifact.
+   * This method is typically called by producer agents.
+   *
+   * @param proposal - The negotiation proposal containing artifact details
+   * @returns The artifact_id of the submitted proposal
+   * @throws NegotiationValidationError if a proposal with the same artifact_id already exists
+   *
+   * @example
+   * ```typescript
+   * const client = new NegotiationRoomClient();
+   * const proposal: NegotiationProposal = {
+   *   artifactType: ArtifactType.CODE,
+   *   artifactId: "code-123",
+   *   producerId: "agent-producer",
+   *   artifact: new TextEncoder().encode("def hello(): pass"),
+   *   artifactContentType: "text/x-python",
+   *   requestedCritics: ["critic-1", "critic-2"],
+   *   negotiationRoomId: "room-1"
+   * };
+   * const artifactId = await client.submitProposal(proposal);
+   * console.log(artifactId); // "code-123"
+   * ```
+   */
+  async submitProposal(proposal) {
+    await this.store.saveProposal(proposal);
+    return proposal.artifactId;
+  }
+  /**
+   * Submit a critic's vote for an artifact.
+   *
+   * Adds the vote to the collection for the specified artifact.
+   * This method is typically called by critic agents after evaluating
+   * an artifact.
+   *
+   * @param vote - The negotiation vote containing the critic's evaluation
+   * @throws NegotiationValidationError if no proposal exists for the vote's artifact_id
+   * @throws NegotiationValidationError if the critic has already voted for this artifact
+   * @throws NegotiationValidationError if score or confidence are out of range
+   *
+   * @example
+   * ```typescript
+   * const vote: NegotiationVote = {
+   *   artifactId: "code-123",
+   *   criticId: "critic-1",
+   *   score: 8.5,
+   *   confidence: 0.9,
+   *   passed: true,
+   *   strengths: ["Good structure"],
+   *   weaknesses: ["Needs tests"],
+   *   recommendations: ["Add unit tests"],
+   *   negotiationRoomId: "room-1"
+   * };
+   * await client.submitVote(vote);
+   * ```
+   */
+  async submitVote(vote) {
+    const artifactId = vote.artifactId;
+    if (!await this.store.hasProposal(artifactId)) {
+      throw new NegotiationValidationError(
+        `No proposal found for artifact_id '${artifactId}'`
+      );
+    }
+    validateVote(vote);
+    await this.store.addVote(vote);
   }
-  recent(limit = 50) {
-    const arr = this.list();
-    return arr.slice(Math.max(0, arr.length - limit));
+  /**
+   * Retrieve all votes for a specific artifact.
+   *
+   * Returns all critic votes that have been submitted for the artifact.
+   * This method is typically called by coordinator agents to aggregate
+   * votes and make decisions.
+   *
+   * @param artifactId - The identifier of the artifact
+   * @returns List of all votes for the artifact (empty array if no votes yet)
+   * @throws NegotiationValidationError if no proposal exists for the artifact_id
+   *
+   * @example
+   * ```typescript
+   * const votes = await client.getVotes("code-123");
+   * console.log(votes.length); // 1
+   * ```
+   */
+  async getVotes(artifactId) {
+    if (!await this.store.hasProposal(artifactId)) {
+      throw new NegotiationValidationError(
+        `No proposal found for artifact_id '${artifactId}'`
+      );
+    }
+    return this.store.getVotes(artifactId);
   }
-  reconcile(knownTaskIds) {
-    for (const id of this.records.keys()) {
-      if (!knownTaskIds.has(id))
-        this.records.delete(id);
+  /**
+   * Retrieve the decision for a specific artifact if available.
+   *
+   * Returns the final decision if one has been made, or null if the
+   * artifact is still under review.
+   *
+   * @param artifactId - The identifier of the artifact
+   * @returns The negotiation decision if available, null otherwise
+   * @throws NegotiationValidationError if no proposal exists for the artifact_id
+   *
+   * @example
+   * ```typescript
+   * const decision = await client.getDecision("code-123");
+   * if (decision === null) {
+   *   console.log("Decision pending");
+   * }
+   * ```
+   */
+  async getDecision(artifactId) {
+    if (!await this.store.hasProposal(artifactId)) {
+      throw new NegotiationValidationError(
+        `No proposal found for artifact_id '${artifactId}'`
+      );
     }
+    return this.store.getDecision(artifactId);
   }
-  prune() {
-    const arr = this.list();
-    const pruned = this.strategy.prune(arr, this.maxEntries);
-    if (pruned.length === arr.length)
-      return;
-    this.records.clear();
-    for (const r of pruned)
-      this.records.set(r.task_id, r);
+  /**
+   * Store a decision for an artifact.
+   *
+   * This is an internal method used by coordinators to record the
+   * final decision after evaluating votes. Once a decision is stored,
+   * it becomes available via getDecision() and waitForDecision().
+   *
+   * @param decision - The negotiation decision to store
+   * @throws NegotiationValidationError if no proposal exists for the decision's artifact_id
+   * @throws NegotiationValidationError if a decision already exists for this artifact
+   *
+   * @example
+   * ```typescript
+   * const votes = await client.getVotes("code-123");
+   * const aggregated = aggregateVotes(votes);
+   * const decision: NegotiationDecision = {
+   *   artifactId: "code-123",
+   *   outcome: DecisionOutcome.APPROVED,
+   *   votes: votes,
+   *   aggregatedScore: aggregated,
+   *   policyVersion: "1.0",
+   *   reason: "Met all criteria",
+   *   negotiationRoomId: "room-1"
+   * };
+   * await client.storeDecision(decision);
+   * ```
+   */
+  async storeDecision(decision) {
+    const artifactId = decision.artifactId;
+    if (!await this.store.hasProposal(artifactId)) {
+      throw new NegotiationValidationError(
+        `No proposal found for artifact_id '${artifactId}'`
+      );
+    }
+    await this.store.saveDecision(decision);
   }
-  toJSON() {
-    return this.list();
+  /**
+   * Wait for a decision to be made on an artifact.
+   *
+   * Polls for a decision until one is available or the timeout is reached.
+   * This method is useful for producer agents waiting for the outcome
+   * of their artifact review.
+   *
+   * @param artifactId - The identifier of the artifact
+   * @param timeoutMs - Maximum time to wait in milliseconds (default: 30000)
+   * @param pollIntervalMs - Time between polling attempts in milliseconds (default: 100)
+   * @returns The negotiation decision once available
+   * @throws NegotiationValidationError if no proposal exists for the artifact_id
+   * @throws NegotiationTimeoutError if no decision is made within the timeout period
+   *
+   * @example
+   * ```typescript
+   * // In a separate thread/process, a coordinator makes a decision
+   * const decision = await client.waitForDecision("code-123", 10000);
+   * console.log(decision.outcome); // DecisionOutcome.APPROVED
+   * ```
+   */
+  async waitForDecision(artifactId, timeoutMs = 3e4, pollIntervalMs = 100) {
+    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.store.getDecision(artifactId);
+      if (decision !== null) {
+        return decision;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new NegotiationTimeoutError(
+      `No decision made for artifact '${artifactId}' within ${timeoutMs} milliseconds`
+    );
   }
-  fromJSON(records) {
-    this.records.clear();
-    for (const r of records)
-      this.records.set(r.task_id, r);
-    this.prune();
+  /**
+   * Retrieve the original proposal for an artifact.
+   *
+   * Useful for critics that need to review the original artifact
+   * before submitting a vote.
+   *
+   * @param artifactId - The identifier of the artifact
+   * @returns The negotiation proposal if it exists, null otherwise
+   *
+   * @example
+   * ```typescript
+   * const proposal = await client.getProposal("code-123");
+   * console.log(proposal?.artifactType); // ArtifactType.CODE
+   * ```
+   */
+  async getProposal(artifactId) {
+    return this.store.getProposal(artifactId);
+  }
+  /**
+   * List all proposals, optionally filtered by negotiation room.
+   *
+   * @param negotiationRoomId - If provided, only return proposals for this room
+   * @returns List of proposals matching the filter criteria
+   *
+   * @example
+   * ```typescript
+   * const proposals = await client.listProposals("room-1");
+   * console.log(proposals.length); // 1
+   * ```
+   */
+  async listProposals(negotiationRoomId) {
+    return this.store.listProposals(negotiationRoomId);
   }
 };
-
-// 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) {
-    const st = {
-      messageId,
-      stage,
-      lastUpdateIso: (/* @__PURE__ */ new Date()).toISOString(),
-      note,
-      errorCode
-    };
-    this.acks.set(messageId, st);
-  }
-  get(messageId) {
-    return this.acks.get(messageId);
-  }
-  recent(limit = 100) {
-    const arr = [...this.acks.values()].sort((a, b) => a.lastUpdateIso.localeCompare(b.lastUpdateIso));
-    return arr.slice(Math.max(0, arr.length - limit));
+function aggregateVotes(votes) {
+  if (votes.length === 0) {
+    throw new NegotiationValidationError(
+      "Cannot aggregate empty list of votes"
+    );
   }
-  reconcileLateAck(messageId, stage) {
-    const curr = this.acks.get(messageId);
-    if (!curr || curr.stage === stage)
-      return;
-    this.mark(messageId, stage, "late_ack_reconciled");
+  const scores = votes.map((v) => v.score);
+  const confidences = votes.map((v) => v.confidence);
+  const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
+  const minScore = Math.min(...scores);
+  const maxScore = Math.max(...scores);
+  const variance = scores.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) / scores.length;
+  const stdDev = Math.sqrt(variance);
+  const totalConfidence = confidences.reduce((a, b) => a + b, 0);
+  let weightedMean;
+  if (totalConfidence > 0) {
+    weightedMean = scores.reduce((sum, s, i) => sum + s * confidences[i], 0) / totalConfidence;
+  } else {
+    weightedMean = mean;
   }
-  toJSON() {
-    return [...this.acks.values()].sort((a, b) => a.lastUpdateIso.localeCompare(b.lastUpdateIso));
+  return {
+    mean,
+    minScore,
+    maxScore,
+    stdDev,
+    weightedMean,
+    voteCount: votes.length
+  };
+}
+
+// src/clients/handoff.ts
+var HandoffStatus = /* @__PURE__ */ ((HandoffStatus2) => {
+  HandoffStatus2[HandoffStatus2["HANDOFF_STATUS_UNSPECIFIED"] = 0] = "HANDOFF_STATUS_UNSPECIFIED";
+  HandoffStatus2[HandoffStatus2["PENDING"] = 1] = "PENDING";
+  HandoffStatus2[HandoffStatus2["ACCEPTED"] = 2] = "ACCEPTED";
+  HandoffStatus2[HandoffStatus2["REJECTED"] = 3] = "REJECTED";
+  HandoffStatus2[HandoffStatus2["COMPLETED"] = 4] = "COMPLETED";
+  HandoffStatus2[HandoffStatus2["EXPIRED"] = 5] = "EXPIRED";
+  return HandoffStatus2;
+})(HandoffStatus || {});
+var HandoffValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HandoffValidationError";
   }
-  fromJSON(states) {
-    this.acks.clear();
-    for (const s of states)
-      this.acks.set(s.messageId, s);
+};
+var HandoffTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HandoffTimeoutError";
   }
 };
-
-// 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;
-  ack;
-  constructor(ack) {
-    this.ack = ack;
+var HandoffClient = class {
+  requests = /* @__PURE__ */ new Map();
+  responses = /* @__PURE__ */ new Map();
+  pendingByAgent = /* @__PURE__ */ new Map();
+  /**
+   * Request a handoff to another agent.
+   *
+   * Initiates a handoff request that the target agent can accept or reject.
+   * The request is stored and made available to the target agent via
+   * getPendingHandoffs().
+   *
+   * @param request - The handoff request containing context and requirements
+   * @returns The response once the handoff is accepted, rejected, or times out
+   * @throws HandoffValidationError if a request with the same ID already exists
+   *
+   * @example
+   * ```typescript
+   * const client = new HandoffClient();
+   * const request: HandoffRequest = {
+   *   requestId: "handoff-123",
+   *   fromAgent: "agent-a",
+   *   toAgent: "agent-b",
+   *   reason: "Capability mismatch",
+   *   contextSnapshot: new TextEncoder().encode('{"state": "in_progress"}'),
+   *   capabilitiesRequired: ["code_review"],
+   *   priority: 5
+   * };
+   * const response = await client.requestHandoff(request);
+   * ```
+   */
+  async requestHandoff(request) {
+    if (this.requests.has(request.requestId)) {
+      throw new HandoffValidationError(
+        `Handoff request with ID '${request.requestId}' already exists`
+      );
+    }
+    const requestWithTimestamp = {
+      ...request,
+      createdAt: request.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.requests.set(request.requestId, requestWithTimestamp);
+    if (request.toAgent) {
+      if (!this.pendingByAgent.has(request.toAgent)) {
+        this.pendingByAgent.set(request.toAgent, /* @__PURE__ */ new Set());
+      }
+      this.pendingByAgent.get(request.toAgent).add(request.requestId);
+    }
+    const timeoutMs = request.timeoutMs || 3e4;
+    const startTime = Date.now();
+    const pollIntervalMs = 100;
+    while (Date.now() - startTime < timeoutMs) {
+      const response = this.responses.get(request.requestId);
+      if (response) {
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    const timeoutResponse = {
+      requestId: request.requestId,
+      accepted: false,
+      rejectionReason: `Handoff request timed out after ${timeoutMs}ms`
+    };
+    this.responses.set(request.requestId, timeoutResponse);
+    if (request.toAgent && this.pendingByAgent.has(request.toAgent)) {
+      this.pendingByAgent.get(request.toAgent).delete(request.requestId);
+    }
+    return timeoutResponse;
   }
-  registerHandler(type, handler) {
+  /**
+   * Accept a pending handoff request.
+   *
+   * Called by the target agent to accept a handoff. After acceptance,
+   * the agent should process the context snapshot and continue the work.
+   *
+   * @param handoffId - The ID of the handoff request to accept
+   * @throws HandoffValidationError if no request exists with the given ID
+   * @throws HandoffValidationError if the request has already been responded to
+   *
+   * @example
+   * ```typescript
+   * // Get pending handoffs for this agent
+   * const pending = await client.getPendingHandoffs("agent-b");
+   * if (pending.length > 0) {
+   *   await client.acceptHandoff(pending[0].requestId);
+   * }
+   * ```
+   */
+  async acceptHandoff(handoffId) {
+    const request = this.requests.get(handoffId);
+    if (!request) {
+      throw new HandoffValidationError(
+        `No handoff request found with ID '${handoffId}'`
+      );
+    }
+    if (this.responses.has(handoffId)) {
+      throw new HandoffValidationError(
+        `Handoff request '${handoffId}' has already been responded to`
+      );
+    }
+    const response = {
+      requestId: handoffId,
+      accepted: true,
+      acceptingAgent: request.toAgent
+    };
+    this.responses.set(handoffId, response);
+    if (request.toAgent && this.pendingByAgent.has(request.toAgent)) {
+      this.pendingByAgent.get(request.toAgent).delete(handoffId);
+    }
+  }
+  /**
+   * Reject a pending handoff request.
+   *
+   * Called by the target agent to reject a handoff. A reason should be
+   * provided to help the originating agent determine next steps.
+   *
+   * @param handoffId - The ID of the handoff request to reject
+   * @param reason - Human-readable reason for the rejection
+   * @throws HandoffValidationError if no request exists with the given ID
+   * @throws HandoffValidationError if the request has already been responded to
+   *
+   * @example
+   * ```typescript
+   * await client.rejectHandoff("handoff-123", "Agent at capacity");
+   * ```
+   */
+  async rejectHandoff(handoffId, reason) {
+    const request = this.requests.get(handoffId);
+    if (!request) {
+      throw new HandoffValidationError(
+        `No handoff request found with ID '${handoffId}'`
+      );
+    }
+    if (this.responses.has(handoffId)) {
+      throw new HandoffValidationError(
+        `Handoff request '${handoffId}' has already been responded to`
+      );
+    }
+    const response = {
+      requestId: handoffId,
+      accepted: false,
+      rejectionReason: reason
+    };
+    this.responses.set(handoffId, response);
+    if (request.toAgent && this.pendingByAgent.has(request.toAgent)) {
+      this.pendingByAgent.get(request.toAgent).delete(handoffId);
+    }
+  }
+  /**
+   * Get all pending handoff requests for an agent.
+   *
+   * Returns handoff requests that have been addressed to the specified
+   * agent and have not yet been accepted or rejected.
+   *
+   * @param agentId - The ID of the agent to get pending handoffs for
+   * @returns List of pending handoff requests for the agent
+   *
+   * @example
+   * ```typescript
+   * const pending = await client.getPendingHandoffs("agent-b");
+   * console.log(`${pending.length} pending handoffs`);
+   * for (const request of pending) {
+   *   console.log(`From ${request.fromAgent}: ${request.reason}`);
+   * }
+   * ```
+   */
+  async getPendingHandoffs(agentId) {
+    const pendingIds = this.pendingByAgent.get(agentId);
+    if (!pendingIds) {
+      return [];
+    }
+    const pending = [];
+    for (const requestId of pendingIds) {
+      const request = this.requests.get(requestId);
+      if (request && !this.responses.has(requestId)) {
+        pending.push(request);
+      }
+    }
+    return pending;
+  }
+  /**
+   * Get the response for a handoff request.
+   *
+   * Returns the response if the handoff has been accepted, rejected, or
+   * timed out. Returns null if the handoff is still pending.
+   *
+   * @param handoffId - The ID of the handoff request
+   * @returns The handoff response if available, null otherwise
+   */
+  async getHandoffResponse(handoffId) {
+    return this.responses.get(handoffId) || null;
+  }
+  /**
+   * Get the original handoff request.
+   *
+   * @param handoffId - The ID of the handoff request
+   * @returns The handoff request if it exists, null otherwise
+   */
+  async getHandoffRequest(handoffId) {
+    return this.requests.get(handoffId) || null;
+  }
+};
+
+// src/clients/workflow.ts
+var NodeStatus = /* @__PURE__ */ ((NodeStatus2) => {
+  NodeStatus2[NodeStatus2["NODE_STATUS_UNSPECIFIED"] = 0] = "NODE_STATUS_UNSPECIFIED";
+  NodeStatus2[NodeStatus2["PENDING"] = 1] = "PENDING";
+  NodeStatus2[NodeStatus2["READY"] = 2] = "READY";
+  NodeStatus2[NodeStatus2["RUNNING"] = 3] = "RUNNING";
+  NodeStatus2[NodeStatus2["COMPLETED"] = 4] = "COMPLETED";
+  NodeStatus2[NodeStatus2["FAILED"] = 5] = "FAILED";
+  NodeStatus2[NodeStatus2["SKIPPED"] = 6] = "SKIPPED";
+  return NodeStatus2;
+})(NodeStatus || {});
+var TriggerType = /* @__PURE__ */ ((TriggerType2) => {
+  TriggerType2[TriggerType2["TRIGGER_TYPE_UNSPECIFIED"] = 0] = "TRIGGER_TYPE_UNSPECIFIED";
+  TriggerType2[TriggerType2["EVENT"] = 1] = "EVENT";
+  TriggerType2[TriggerType2["SCHEDULE"] = 2] = "SCHEDULE";
+  TriggerType2[TriggerType2["MANUAL"] = 3] = "MANUAL";
+  TriggerType2[TriggerType2["DEPENDENCY"] = 4] = "DEPENDENCY";
+  return TriggerType2;
+})(TriggerType || {});
+var WorkflowStatus = /* @__PURE__ */ ((WorkflowStatus2) => {
+  WorkflowStatus2[WorkflowStatus2["WORKFLOW_STATUS_UNSPECIFIED"] = 0] = "WORKFLOW_STATUS_UNSPECIFIED";
+  WorkflowStatus2[WorkflowStatus2["CREATED"] = 1] = "CREATED";
+  WorkflowStatus2[WorkflowStatus2["RUNNING"] = 2] = "RUNNING";
+  WorkflowStatus2[WorkflowStatus2["COMPLETED"] = 3] = "COMPLETED";
+  WorkflowStatus2[WorkflowStatus2["FAILED"] = 4] = "FAILED";
+  WorkflowStatus2[WorkflowStatus2["CANCELLED"] = 5] = "CANCELLED";
+  WorkflowStatus2[WorkflowStatus2["PAUSED"] = 6] = "PAUSED";
+  return WorkflowStatus2;
+})(WorkflowStatus || {});
+var WorkflowValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorkflowValidationError";
+  }
+};
+var WorkflowCycleError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorkflowCycleError";
+  }
+};
+function validateWorkflowDefinition(definition) {
+  const nodeIds = new Set(Object.keys(definition.nodes));
+  for (const [nodeId, node] of Object.entries(definition.nodes)) {
+    for (const dep of node.dependencies) {
+      if (!nodeIds.has(dep)) {
+        throw new WorkflowValidationError(
+          `Node '${nodeId}' has dependency '${dep}' which does not exist`
+        );
+      }
+      if (dep === nodeId) {
+        throw new WorkflowCycleError(
+          `Node '${nodeId}' has a self-dependency`
+        );
+      }
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function hasCycle(nodeId) {
+    if (recursionStack.has(nodeId)) {
+      return true;
+    }
+    if (visited.has(nodeId)) {
+      return false;
+    }
+    visited.add(nodeId);
+    recursionStack.add(nodeId);
+    const node = definition.nodes[nodeId];
+    for (const dep of node.dependencies) {
+      if (hasCycle(dep)) {
+        return true;
+      }
+    }
+    recursionStack.delete(nodeId);
+    return false;
+  }
+  for (const nodeId of nodeIds) {
+    if (hasCycle(nodeId)) {
+      throw new WorkflowCycleError(
+        `Workflow contains a cycle involving node '${nodeId}'`
+      );
+    }
+  }
+}
+function generateInstanceId() {
+  return `wf-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+var WorkflowClient = class {
+  definitions = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  instancesByWorkflow = /* @__PURE__ */ new Map();
+  /**
+   * Create a new workflow from a definition.
+   *
+   * Validates the workflow definition and stores it for later execution.
+   *
+   * @param definition - The workflow definition to create
+   * @returns The workflow_id of the created workflow
+   * @throws WorkflowValidationError if the definition is invalid
+   * @throws WorkflowCycleError if the workflow contains a cycle
+   *
+   * @example
+   * ```typescript
+   * const client = new WorkflowClient();
+   * const definition: WorkflowDefinition = {
+   *   workflowId: "review-workflow",
+   *   nodes: {
+   *     "produce": {
+   *       nodeId: "produce",
+   *       agentId: "producer-agent",
+   *       dependencies: [],
+   *       triggerType: TriggerType.MANUAL,
+   *       inputMapping: {},
+   *       outputMapping: { "artifact": "produced_artifact" },
+   *       metadata: {}
+   *     },
+   *     "review": {
+   *       nodeId: "review",
+   *       agentId: "critic-agent",
+   *       dependencies: ["produce"],
+   *       triggerType: TriggerType.DEPENDENCY,
+   *       inputMapping: { "artifact": "produced_artifact" },
+   *       outputMapping: { "result": "review_result" },
+   *       metadata: {}
+   *     }
+   *   },
+   *   metadata: {}
+   * };
+   * const workflowId = await client.createWorkflow(definition);
+   * ```
+   */
+  async createWorkflow(definition) {
+    validateWorkflowDefinition(definition);
+    if (this.definitions.has(definition.workflowId)) {
+      throw new WorkflowValidationError(
+        `Workflow with ID '${definition.workflowId}' already exists`
+      );
+    }
+    const definitionWithTimestamp = {
+      ...definition,
+      createdAt: definition.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.definitions.set(definition.workflowId, definitionWithTimestamp);
+    this.instancesByWorkflow.set(definition.workflowId, /* @__PURE__ */ new Set());
+    return definition.workflowId;
+  }
+  /**
+   * Start a new instance of a workflow.
+   *
+   * Creates a new workflow instance and initializes all nodes to their
+   * starting states based on dependencies.
+   *
+   * @param workflowId - The ID of the workflow to start
+   * @param initialData - Optional initial workflow data (JSON string)
+   * @param metadata - Optional runtime metadata
+   * @returns The created workflow instance
+   * @throws WorkflowValidationError if the workflow does not exist
+   *
+   * @example
+   * ```typescript
+   * const instance = await client.startWorkflow("review-workflow");
+   * console.log(instance.status); // WorkflowStatus.RUNNING
+   * ```
+   */
+  async startWorkflow(workflowId, initialData, metadata) {
+    const definition = this.definitions.get(workflowId);
+    if (!definition) {
+      throw new WorkflowValidationError(
+        `Workflow with ID '${workflowId}' does not exist`
+      );
+    }
+    const instanceId = generateInstanceId();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const nodeStates = {};
+    for (const [nodeId, node] of Object.entries(definition.nodes)) {
+      const status = node.dependencies.length === 0 ? 2 /* READY */ : 1 /* PENDING */;
+      nodeStates[nodeId] = {
+        nodeId,
+        status
+      };
+    }
+    const instance = {
+      instanceId,
+      workflowId,
+      status: 2 /* RUNNING */,
+      nodeStates,
+      workflowData: initialData || "{}",
+      startedAt: now,
+      metadata: metadata || {}
+    };
+    this.instances.set(instanceId, instance);
+    this.instancesByWorkflow.get(workflowId).add(instanceId);
+    return instance;
+  }
+  /**
+   * Get the current status of a workflow instance.
+   *
+   * @param instanceId - The ID of the workflow instance
+   * @returns The workflow instance with current state
+   * @throws WorkflowValidationError if the instance does not exist
+   *
+   * @example
+   * ```typescript
+   * const instance = await client.getWorkflowStatus("wf-123-abc");
+   * console.log(instance.status);
+   * for (const [nodeId, state] of Object.entries(instance.nodeStates)) {
+   *   console.log(`${nodeId}: ${NodeStatus[state.status]}`);
+   * }
+   * ```
+   */
+  async getWorkflowStatus(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      throw new WorkflowValidationError(
+        `Workflow instance with ID '${instanceId}' does not exist`
+      );
+    }
+    return instance;
+  }
+  /**
+   * Cancel a running workflow instance.
+   *
+   * Marks the workflow as cancelled and stops any pending nodes.
+   *
+   * @param instanceId - The ID of the workflow instance to cancel
+   * @throws WorkflowValidationError if the instance does not exist
+   * @throws WorkflowValidationError if the workflow is not in a cancellable state
+   *
+   * @example
+   * ```typescript
+   * await client.cancelWorkflow("wf-123-abc");
+   * const instance = await client.getWorkflowStatus("wf-123-abc");
+   * console.log(instance.status); // WorkflowStatus.CANCELLED
+   * ```
+   */
+  async cancelWorkflow(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      throw new WorkflowValidationError(
+        `Workflow instance with ID '${instanceId}' does not exist`
+      );
+    }
+    if (instance.status === 3 /* COMPLETED */ || instance.status === 4 /* FAILED */ || instance.status === 5 /* CANCELLED */) {
+      throw new WorkflowValidationError(
+        `Workflow instance '${instanceId}' is already in terminal state '${WorkflowStatus[instance.status]}'`
+      );
+    }
+    instance.status = 5 /* CANCELLED */;
+    instance.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    for (const nodeState of Object.values(instance.nodeStates)) {
+      if (nodeState.status === 1 /* PENDING */ || nodeState.status === 2 /* READY */) {
+        nodeState.status = 6 /* SKIPPED */;
+      }
+    }
+    this.instances.set(instanceId, instance);
+  }
+  /**
+   * Get the workflow definition.
+   *
+   * @param workflowId - The ID of the workflow
+   * @returns The workflow definition if it exists, null otherwise
+   */
+  async getWorkflowDefinition(workflowId) {
+    return this.definitions.get(workflowId) || null;
+  }
+  /**
+   * List all instances of a workflow.
+   *
+   * @param workflowId - The ID of the workflow
+   * @returns List of all instances for the workflow
+   */
+  async listWorkflowInstances(workflowId) {
+    const instanceIds = this.instancesByWorkflow.get(workflowId);
+    if (!instanceIds) {
+      return [];
+    }
+    const instances = [];
+    for (const instanceId of instanceIds) {
+      const instance = this.instances.get(instanceId);
+      if (instance) {
+        instances.push(instance);
+      }
+    }
+    return instances;
+  }
+  /**
+   * Update the state of a node in a workflow instance.
+   *
+   * This is an internal method used by node executors to report progress.
+   *
+   * @param instanceId - The ID of the workflow instance
+   * @param nodeId - The ID of the node to update
+   * @param status - The new status of the node
+   * @param output - Optional output data from the node
+   * @param error - Optional error message if the node failed
+   * @throws WorkflowValidationError if the instance or node does not exist
+   */
+  async updateNodeState(instanceId, nodeId, status, output, error) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      throw new WorkflowValidationError(
+        `Workflow instance with ID '${instanceId}' does not exist`
+      );
+    }
+    const nodeState = instance.nodeStates[nodeId];
+    if (!nodeState) {
+      throw new WorkflowValidationError(
+        `Node '${nodeId}' does not exist in workflow instance '${instanceId}'`
+      );
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    nodeState.status = status;
+    if (status === 3 /* RUNNING */ && !nodeState.startedAt) {
+      nodeState.startedAt = now;
+    }
+    if (status === 4 /* COMPLETED */ || status === 5 /* FAILED */ || status === 6 /* SKIPPED */) {
+      nodeState.completedAt = now;
+    }
+    if (output !== void 0) {
+      nodeState.output = output;
+    }
+    if (error !== void 0) {
+      nodeState.error = error;
+    }
+    if (status === 4 /* COMPLETED */) {
+      const definition = this.definitions.get(instance.workflowId);
+      if (definition) {
+        this.updateDependentNodes(instance, definition, nodeId);
+      }
+    }
+    this.checkWorkflowCompletion(instance);
+    this.instances.set(instanceId, instance);
+  }
+  /**
+   * Update the status of nodes that depend on a completed node.
+   */
+  updateDependentNodes(instance, definition, completedNodeId) {
+    for (const [nodeId, node] of Object.entries(definition.nodes)) {
+      if (node.dependencies.includes(completedNodeId)) {
+        const nodeState = instance.nodeStates[nodeId];
+        if (nodeState.status === 1 /* PENDING */) {
+          const allDepsComplete = node.dependencies.every((dep) => {
+            const depState = instance.nodeStates[dep];
+            return depState && depState.status === 4 /* COMPLETED */;
+          });
+          if (allDepsComplete) {
+            nodeState.status = 2 /* READY */;
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Check if a workflow instance is complete and update its status.
+   */
+  checkWorkflowCompletion(instance) {
+    const nodeStatuses = Object.values(instance.nodeStates).map((s) => s.status);
+    if (nodeStatuses.some((s) => s === 5 /* FAILED */)) {
+      instance.status = 4 /* FAILED */;
+      instance.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return;
+    }
+    const allComplete = nodeStatuses.every(
+      (s) => s === 4 /* COMPLETED */ || s === 6 /* SKIPPED */
+    );
+    if (allComplete) {
+      instance.status = 3 /* COMPLETED */;
+      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.
+   *
+   * @param instanceId - The ID of the workflow instance
+   * @param workflowData - The new workflow data (JSON string)
+   * @throws WorkflowValidationError if the instance does not exist
+   */
+  async updateWorkflowData(instanceId, workflowData) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      throw new WorkflowValidationError(
+        `Workflow instance with ID '${instanceId}' does not exist`
+      );
+    }
+    instance.workflowData = workflowData;
+    this.instances.set(instanceId, instance);
+  }
+};
+
+// 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);
+  const nanos = ms % 1e3 * 1e6;
+  return { seconds, nanos };
+}
+function nowHlcStub(date = /* @__PURE__ */ new Date()) {
+  const wallUs = date.getTime() * 1e3;
+  let node = "unknown";
+  try {
+    const os = require("node:os");
+    node = os.hostname() || "unknown";
+  } catch {
+    node = "browser";
+  }
+  return `HLC:${wallUs}:0:${node}`;
+}
+function uuidv42() {
+  if (typeof import_node_crypto2.default.randomUUID === "function") {
+    return import_node_crypto2.default.randomUUID();
+  }
+  const buf = import_node_crypto2.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 buildEnvelope(input) {
+  const hasPayload = input.payload !== void 0;
+  const content_type = input.content_type ?? "application/json";
+  const message_id = uuidv42();
+  const correlation_id = input.correlation_id ?? uuidv42();
+  const sequence_number = input.sequence_number ?? 1;
+  const retry_count = input.retry_count ?? 0;
+  const ts = nowTimestamp(input.timestamp ?? /* @__PURE__ */ new Date());
+  const hlc_timestamp = input.hlc_timestamp ?? nowHlcStub(input.timestamp);
+  const built = {
+    message_id,
+    idempotency_token: input.idempotency_token,
+    producer_id: input.producer_id,
+    correlation_id,
+    sequence_number,
+    retry_count,
+    message_type: input.message_type,
+    content_type,
+    // Always set content_type (aligns with Python/Rust)
+    repo_id: input.repo_id,
+    worktree_id: input.worktree_id,
+    hlc_timestamp,
+    // Always set hlc_timestamp (aligns with Python/Rust)
+    ttl_ms: input.ttl_ms,
+    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);
+    built.payload = payload;
+    built.content_length = payload.byteLength;
+    if (!input.content_type) {
+      built.content_type = "application/octet-stream";
+    }
+  }
+  return built;
+}
+
+// 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.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;
+  }
+  /**
+   * 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,
+      home_repo_id: this.homeRepoId,
+      home_worktree_id: this.homeWorktreeId,
+      switch_ttl_ms: this.switchTtlMs
+    };
+  }
+};
+
+// src/internal/runtime/activityBuffer.ts
+var MaxEntriesStrategy = class {
+  prune(records, maxEntries) {
+    if (records.length <= maxEntries)
+      return records;
+    const overflow = records.length - maxEntries;
+    return records.slice(overflow);
+  }
+};
+var ActivityBuffer = class {
+  records = /* @__PURE__ */ new Map();
+  maxEntries;
+  strategy;
+  constructor(opts) {
+    this.maxEntries = opts?.maxEntries ?? 1e3;
+    this.strategy = opts?.strategy ?? new MaxEntriesStrategy();
+  }
+  upsert(rec) {
+    this.records.set(rec.task_id, rec);
+    this.prune();
+  }
+  remove(taskId) {
+    this.records.delete(taskId);
+  }
+  list() {
+    return [...this.records.values()].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  }
+  recent(limit = 50) {
+    const arr = this.list();
+    return arr.slice(Math.max(0, arr.length - limit));
+  }
+  reconcile(knownTaskIds) {
+    for (const id of this.records.keys()) {
+      if (!knownTaskIds.has(id))
+        this.records.delete(id);
+    }
+  }
+  prune() {
+    const arr = this.list();
+    const pruned = this.strategy.prune(arr, this.maxEntries);
+    if (pruned.length === arr.length)
+      return;
+    this.records.clear();
+    for (const r of pruned)
+      this.records.set(r.task_id, r);
+  }
+  toJSON() {
+    return this.list();
+  }
+  fromJSON(records) {
+    this.records.clear();
+    for (const r of records)
+      this.records.set(r.task_id, r);
+    this.prune();
+  }
+};
+
+// src/internal/runtime/ackLifecycle.ts
+var ACKLifecycleManager = class {
+  acks = /* @__PURE__ */ new Map();
+  mark(messageId, stage, note, errorCode) {
+    const st = {
+      messageId,
+      stage,
+      lastUpdateIso: (/* @__PURE__ */ new Date()).toISOString(),
+      note,
+      errorCode
+    };
+    this.acks.set(messageId, st);
+  }
+  get(messageId) {
+    return this.acks.get(messageId);
+  }
+  recent(limit = 100) {
+    const arr = [...this.acks.values()].sort((a, b) => a.lastUpdateIso.localeCompare(b.lastUpdateIso));
+    return arr.slice(Math.max(0, arr.length - limit));
+  }
+  reconcileLateAck(messageId, stage) {
+    const curr = this.acks.get(messageId);
+    if (!curr || curr.stage === stage)
+      return;
+    this.mark(messageId, stage, "late_ack_reconciled");
+  }
+  toJSON() {
+    return [...this.acks.values()].sort((a, b) => a.lastUpdateIso.localeCompare(b.lastUpdateIso));
+  }
+  fromJSON(states) {
+    this.acks.clear();
+    for (const s of states)
+      this.acks.set(s.messageId, s);
+  }
+};
+
+// src/internal/runtime/messageProcessor.ts
+var MessageProcessor = class {
+  handlers = /* @__PURE__ */ new Map();
+  defaultHandler;
+  ack;
+  constructor(ack) {
+    this.ack = ack;
+  }
+  registerHandler(type, handler) {
     this.handlers.set(type, handler);
   }
   setDefaultHandler(handler) {
@@ -10584,11 +11910,15 @@ async function sendMessageWithAck(router, inboundStream, envelope, ackLifecycle,
       }
     }
   };
-  return new Promise(async (resolve, reject) => {
-    let timeout;
+  await router.sendMessage(envelope);
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      ackLifecycle.mark(envelope.message_id, 6 /* TIMED_OUT */, "received_timeout");
+      cleanup();
+      reject(new Error("ACK RECEIVED timeout exceeded"));
+    }, receivedTimeoutMs);
     const cleanup = () => {
-      if (timeout)
-        clearTimeout(timeout);
+      clearTimeout(timeout);
       inboundStream.removeListener("data", onData);
       inboundStream.removeListener("error", onErr);
     };
@@ -10598,27 +11928,13 @@ async function sendMessageWithAck(router, inboundStream, envelope, ackLifecycle,
     };
     inboundStream.on("data", onData);
     inboundStream.on("error", onErr);
-    try {
-      await router.sendMessage(envelope);
-    } catch (e) {
-      cleanup();
-      return reject(e);
-    }
-    timeout = setTimeout(() => {
-      ackLifecycle.mark(envelope.message_id, 6 /* TIMED_OUT */, "received_timeout");
-      cleanup();
-      reject(new Error("ACK RECEIVED timeout exceeded"));
-    }, receivedTimeoutMs);
     const checkInterval = setInterval(() => {
       const state = ackLifecycle.get(envelope.message_id);
       if (!state)
         return;
       if (state.stage === 1 /* RECEIVED */ || state.stage === 2 /* READ */ || state.stage === 3 /* FULFILLED */) {
         clearInterval(checkInterval);
-        if (timeout)
-          clearTimeout(timeout);
-        inboundStream.removeListener("data", onData);
-        inboundStream.removeListener("error", onErr);
+        cleanup();
         resolve();
       }
     }, 25);
@@ -10690,78 +12006,1259 @@ function createResilientIncomingStream(router, agentId, opts) {
   emitter.stop = () => {
     stopped = true;
     try {
-      if (current && typeof current.cancel === "function") {
-        current.cancel();
+      if (current && typeof current.cancel === "function") {
+        current.cancel();
+      }
+    } catch {
+    }
+    current = null;
+  };
+  start();
+  return emitter;
+}
+
+// src/runtime/negotiationEvents.ts
+function parseNegotiationEvent(json) {
+  try {
+    const obj = JSON.parse(json);
+    if (!obj || typeof obj.kind !== "string")
+      return { kind: "unknown", ...obj || {} };
+    return obj;
+  } catch {
+    return { kind: "unknown", ts: void 0 };
+  }
+}
+function decodeBase64(b64) {
+  if (!b64)
+    return void 0;
+  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");
+  }
+  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) {
+    const payload = JSON.stringify(states, null, 2);
+    await this.safeWrite(this.acksFile, payload);
+  }
+  async loadAcks() {
+    try {
+      const buf = await import_promises.default.readFile(this.acksFile, "utf8");
+      return JSON.parse(buf);
+    } catch (e) {
+      if (e?.code === "ENOENT")
+        return [];
+      throw e;
+    }
+  }
+};
+
+// src/runtime/voting.ts
+var SimpleAverageAggregator = class {
+  /**
+   * Aggregate votes using simple arithmetic mean.
+   *
+   * @param votes - List of critic votes to aggregate
+   * @returns AggregatedScore with simple mean in both mean and weightedMean fields
+   * @throws NegotiationValidationError if votes list is empty
+   */
+  aggregate(votes) {
+    if (votes.length === 0) {
+      throw new NegotiationValidationError(
+        "Cannot aggregate empty list of votes"
+      );
+    }
+    const scores = votes.map((v) => v.score);
+    const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
+    const minScore = Math.min(...scores);
+    const maxScore = Math.max(...scores);
+    const variance = scores.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) / scores.length;
+    const stdDev = Math.sqrt(variance);
+    return {
+      mean,
+      minScore,
+      maxScore,
+      stdDev,
+      weightedMean: mean,
+      voteCount: votes.length
+    };
+  }
+};
+var ConfidenceWeightedAggregator = class {
+  /**
+   * Aggregate votes using confidence weighting.
+   *
+   * @param votes - List of critic votes to aggregate
+   * @returns AggregatedScore with confidence-weighted mean
+   * @throws NegotiationValidationError if votes list is empty
+   */
+  aggregate(votes) {
+    if (votes.length === 0) {
+      throw new NegotiationValidationError(
+        "Cannot aggregate empty list of votes"
+      );
+    }
+    const scores = votes.map((v) => v.score);
+    const confidences = votes.map((v) => v.confidence);
+    const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
+    const minScore = Math.min(...scores);
+    const maxScore = Math.max(...scores);
+    const variance = scores.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) / scores.length;
+    const stdDev = Math.sqrt(variance);
+    const totalConfidence = confidences.reduce((a, b) => a + b, 0);
+    let weightedMean;
+    if (totalConfidence > 0) {
+      weightedMean = scores.reduce((sum, s, i) => sum + s * confidences[i], 0) / totalConfidence;
+    } else {
+      weightedMean = mean;
+    }
+    return {
+      mean,
+      minScore,
+      maxScore,
+      stdDev,
+      weightedMean,
+      voteCount: votes.length
+    };
+  }
+};
+var MajorityVoteAggregator = class {
+  /**
+   * Aggregate votes using majority voting.
+   *
+   * @param votes - List of critic votes to aggregate
+   * @returns AggregatedScore with score based on majority outcome
+   * @throws NegotiationValidationError if votes list is empty
+   */
+  aggregate(votes) {
+    if (votes.length === 0) {
+      throw new NegotiationValidationError(
+        "Cannot aggregate empty list of votes"
+      );
+    }
+    const scores = votes.map((v) => v.score);
+    const passedCount = votes.filter((v) => v.passed).length;
+    const failedCount = votes.length - passedCount;
+    let majorityScore;
+    if (passedCount === votes.length) {
+      majorityScore = 10;
+    } else if (failedCount === votes.length) {
+      majorityScore = 0;
+    } else if (passedCount > failedCount) {
+      majorityScore = 7.5;
+    } else if (failedCount > passedCount) {
+      majorityScore = 2.5;
+    } else {
+      majorityScore = 5;
+    }
+    const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
+    const minScore = Math.min(...scores);
+    const maxScore = Math.max(...scores);
+    const variance = scores.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) / scores.length;
+    const stdDev = Math.sqrt(variance);
+    return {
+      mean,
+      minScore,
+      maxScore,
+      stdDev,
+      weightedMean: majorityScore,
+      voteCount: votes.length
+    };
+  }
+};
+var BordaCountAggregator = class {
+  /**
+   * Aggregate votes using Borda count.
+   *
+   * @param votes - List of critic votes to aggregate
+   * @returns AggregatedScore with Borda count normalized score
+   * @throws NegotiationValidationError if votes list is empty
+   */
+  aggregate(votes) {
+    if (votes.length === 0) {
+      throw new NegotiationValidationError(
+        "Cannot aggregate empty list of votes"
+      );
+    }
+    const scores = votes.map((v) => v.score);
+    const n = votes.length;
+    const mean = scores.reduce((a, b) => a + b, 0) / n;
+    const minScore = Math.min(...scores);
+    const maxScore = Math.max(...scores);
+    const variance = scores.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) / n;
+    const stdDev = Math.sqrt(variance);
+    const indexedScores = scores.map((score, idx) => ({ score, idx }));
+    indexedScores.sort((a, b) => b.score - a.score);
+    let totalPoints = 0;
+    for (let rank = 0; rank < indexedScores.length; rank++) {
+      const points = n - rank;
+      totalPoints += points;
+    }
+    const avgPoints = totalPoints / n;
+    const bordaScore = avgPoints / n * 10;
+    return {
+      mean,
+      minScore,
+      maxScore,
+      stdDev,
+      weightedMean: bordaScore,
+      voteCount: n
+    };
+  }
+};
+var VotingAnalyzer = class {
+  strategy;
+  /**
+   * Initialize analyzer with a strategy.
+   *
+   * @param strategy - The aggregation strategy to use
+   */
+  constructor(strategy) {
+    this.strategy = strategy;
+  }
+  /**
+   * Aggregate votes using the configured strategy.
+   *
+   * @param votes - List of critic votes to aggregate
+   * @returns AggregatedScore with aggregation results
+   * @throws NegotiationValidationError if votes list is empty
+   */
+  aggregate(votes) {
+    return this.strategy.aggregate(votes);
+  }
+  /**
+   * Compute Shannon entropy of vote distribution.
+   *
+   * Entropy measures the uncertainty or disorder in the vote distribution.
+   * Higher entropy indicates more disagreement/uncertainty, lower entropy
+   * indicates more consensus.
+   *
+   * The score range [0, 10] is divided into bins, and entropy is computed
+   * over the probability distribution of votes across bins.
+   *
+   * @param votes - List of critic votes
+   * @returns Entropy value in bits (0 = perfect consensus, higher = more uncertainty)
+   * @throws NegotiationValidationError if votes list is empty
+   */
+  computeEntropy(votes) {
+    if (votes.length === 0) {
+      throw new NegotiationValidationError(
+        "Cannot compute entropy of empty vote list"
+      );
+    }
+    const numBins = 5;
+    const binWidth = 10 / numBins;
+    const binCounts = new Array(numBins).fill(0);
+    for (const vote of votes) {
+      const binIdx = Math.min(Math.floor(vote.score / binWidth), numBins - 1);
+      binCounts[binIdx]++;
+    }
+    const total = votes.length;
+    let entropy = 0;
+    for (const count of binCounts) {
+      if (count > 0) {
+        const probability = count / total;
+        entropy -= probability * Math.log2(probability);
+      }
+    }
+    return entropy;
+  }
+  /**
+   * Detect if votes show strong consensus.
+   *
+   * Consensus is detected when:
+   * 1. Standard deviation of scores is low (< 2.0)
+   * 2. A large proportion of critics agree on pass/fail (>= threshold)
+   *
+   * @param votes - List of critic votes
+   * @param threshold - Minimum proportion of agreement required (default 0.8 = 80%)
+   * @returns True if consensus is detected, false otherwise
+   * @throws NegotiationValidationError if votes list is empty or threshold not in [0, 1]
+   */
+  detectConsensus(votes, threshold = 0.8) {
+    if (votes.length === 0) {
+      throw new NegotiationValidationError(
+        "Cannot detect consensus in empty vote list"
+      );
+    }
+    if (threshold < 0 || threshold > 1) {
+      throw new NegotiationValidationError(
+        `Threshold must be in [0, 1], got ${threshold}`
+      );
+    }
+    const scores = votes.map((v) => v.score);
+    const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
+    const variance = scores.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) / scores.length;
+    const stdDev = Math.sqrt(variance);
+    if (stdDev >= 2) {
+      return false;
+    }
+    const passedCount = votes.filter((v) => v.passed).length;
+    const failedCount = votes.length - passedCount;
+    const agreementRatio = Math.max(passedCount, failedCount) / votes.length;
+    return agreementRatio >= threshold;
+  }
+  /**
+   * Detect if votes show polarization (bimodal distribution).
+   *
+   * Polarization is detected when votes cluster into two distinct groups,
+   * typically at opposite ends of the score spectrum. This is identified by:
+   * 1. High standard deviation (>= 3.0)
+   * 2. Low density in the middle range (4-6)
+   * 3. High density in the extremes (0-3 or 7-10)
+   *
+   * @param votes - List of critic votes
+   * @returns True if polarization is detected, false otherwise
+   * @throws NegotiationValidationError if votes list is empty
+   */
+  detectPolarization(votes) {
+    if (votes.length === 0) {
+      throw new NegotiationValidationError(
+        "Cannot detect polarization in empty vote list"
+      );
+    }
+    if (votes.length < 3) {
+      return false;
+    }
+    const scores = votes.map((v) => v.score);
+    const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
+    const variance = scores.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) / scores.length;
+    const stdDev = Math.sqrt(variance);
+    if (stdDev < 3) {
+      return false;
+    }
+    const lowCount = scores.filter((s) => s <= 3).length;
+    const middleCount = scores.filter((s) => s > 3 && s < 7).length;
+    const highCount = scores.filter((s) => s >= 7).length;
+    const hasLowCluster = lowCount >= votes.length * 0.3;
+    const hasHighCluster = highCount >= votes.length * 0.3;
+    const middleSparse = middleCount <= votes.length * 0.2;
+    return hasLowCluster && hasHighCluster && middleSparse;
+  }
+  /**
+   * Compute variance of confidence levels across votes.
+   *
+   * High variance in confidence suggests critics have different levels of
+   * certainty about their evaluations, which may indicate the artifact is
+   * harder to assess or has ambiguous quality.
+   *
+   * @param votes - List of critic votes
+   * @returns Variance of confidence values
+   * @throws NegotiationValidationError if votes list is empty
+   */
+  computeConfidenceVariance(votes) {
+    if (votes.length === 0) {
+      throw new NegotiationValidationError(
+        "Cannot compute confidence variance of empty vote list"
+      );
+    }
+    const confidences = votes.map((v) => v.confidence);
+    const meanConfidence = confidences.reduce((a, b) => a + b, 0) / confidences.length;
+    const variance = confidences.reduce(
+      (sum, c) => sum + Math.pow(c - meanConfidence, 2),
+      0
+    ) / confidences.length;
+    return variance;
+  }
+  /**
+   * Get comprehensive summary of vote characteristics.
+   *
+   * Combines multiple analytical methods to provide a complete picture
+   * of the vote distribution and critic agreement.
+   *
+   * @param votes - List of critic votes
+   * @returns Object with summary statistics
+   * @throws NegotiationValidationError if votes list is empty
+   */
+  getVoteSummary(votes) {
+    if (votes.length === 0) {
+      throw new NegotiationValidationError("Cannot summarize empty vote list");
+    }
+    const passedCount = votes.filter((v) => v.passed).length;
+    return {
+      entropy: this.computeEntropy(votes),
+      consensus: this.detectConsensus(votes),
+      polarization: this.detectPolarization(votes),
+      confidenceVariance: this.computeConfidenceVariance(votes),
+      passRate: passedCount / votes.length
+    };
+  }
+};
+
+// src/runtime/policyStore.ts
+var import_promises2 = __toESM(require("node:fs/promises"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+var HitlMode = /* @__PURE__ */ ((HitlMode2) => {
+  HitlMode2["NONE"] = "None";
+  HitlMode2["PAUSE_BETWEEN_ROUNDS"] = "PauseBetweenRounds";
+  HitlMode2["PAUSE_ON_FINAL_ACCEPT"] = "PauseOnFinalAccept";
+  return HitlMode2;
+})(HitlMode || {});
+var DEFAULT_EXECUTION_POLICY = {
+  timeoutMs: 6e4,
+  maxRetries: 3,
+  backoff: "exponential",
+  worktreeRequired: false,
+  networkPolicy: "restricted",
+  privilegeLevel: "standard",
+  budgetCpuMs: 3e4,
+  budgetWallMs: 6e4
+};
+var DEFAULT_ESCALATION_POLICY = {
+  autoEscalateOnDeadlock: true,
+  deadlockRounds: 3,
+  escalationReasons: ["debate_deadlock", "security_flag", "timeout"],
+  defaultAction: "escalate"
+};
+var PolicyStoreError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PolicyStoreError";
+  }
+};
+var DEFAULT_NEGOTIATION_POLICY = {
+  maxRounds: 10,
+  scoreThreshold: 0.7,
+  diffTolerance: 0.3,
+  roundTimeoutMs: 3e4,
+  tokenBudgetPerRound: 4096,
+  totalTokenBudget: 0,
+  // unlimited
+  oscillationLimit: 3,
+  hitl: "None" /* NONE */,
+  scoring: {
+    requireSchemaValid: true,
+    requireExamplesPass: false,
+    llmWeight: 0.5
+  }
+};
+function generatePolicyId() {
+  return `policy-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+function generatePolicyVersion() {
+  const timestampMs = Date.now();
+  const uniqueId = Math.random().toString(36).substring(2, 11);
+  return `${timestampMs}_${uniqueId}`;
+}
+var InMemoryPolicyStore = class {
+  // Maps policy_id -> list of EffectivePolicy (chronological order)
+  policies = /* @__PURE__ */ new Map();
+  profiles = /* @__PURE__ */ new Map();
+  constructor() {
+    this.initializeDefaultProfiles();
+  }
+  /**
+   * Initialize default policy profiles.
+   */
+  initializeDefaultProfiles() {
+    const lowProfile = {
+      name: "LOW",
+      negotiation: {
+        maxRounds: 5,
+        scoreThreshold: 0.6,
+        diffTolerance: 0.4,
+        roundTimeoutMs: 6e4,
+        tokenBudgetPerRound: 2048,
+        totalTokenBudget: 0,
+        oscillationLimit: 5,
+        hitl: "None" /* NONE */,
+        scoring: {
+          requireSchemaValid: false,
+          requireExamplesPass: false,
+          llmWeight: 0.3
+        }
+      },
+      execution: {
+        ...DEFAULT_EXECUTION_POLICY,
+        timeoutMs: 12e4,
+        // More lenient for low priority
+        maxRetries: 5
+      },
+      escalation: {
+        ...DEFAULT_ESCALATION_POLICY,
+        deadlockRounds: 5
+        // More tolerant
+      }
+    };
+    const mediumProfile = {
+      name: "MEDIUM",
+      negotiation: { ...DEFAULT_NEGOTIATION_POLICY },
+      execution: { ...DEFAULT_EXECUTION_POLICY },
+      escalation: { ...DEFAULT_ESCALATION_POLICY }
+    };
+    const highProfile = {
+      name: "HIGH",
+      negotiation: {
+        maxRounds: 15,
+        scoreThreshold: 0.85,
+        diffTolerance: 0.2,
+        roundTimeoutMs: 2e4,
+        tokenBudgetPerRound: 8192,
+        totalTokenBudget: 1e5,
+        oscillationLimit: 2,
+        hitl: "PauseOnFinalAccept" /* PAUSE_ON_FINAL_ACCEPT */,
+        scoring: {
+          requireSchemaValid: true,
+          requireExamplesPass: true,
+          llmWeight: 0.7
+        }
+      },
+      execution: {
+        ...DEFAULT_EXECUTION_POLICY,
+        timeoutMs: 3e4,
+        // Stricter timeout
+        maxRetries: 2,
+        networkPolicy: "none"
+        // More restrictive
+      },
+      escalation: {
+        ...DEFAULT_ESCALATION_POLICY,
+        deadlockRounds: 2,
+        // Quick escalation
+        autoEscalateOnDeadlock: true
+      }
+    };
+    this.profiles.set("LOW", lowProfile);
+    this.profiles.set("MEDIUM", mediumProfile);
+    this.profiles.set("HIGH", highProfile);
+  }
+  /**
+   * Get the latest version of a policy by its ID.
+   *
+   * @param policyId - The unique identifier of the policy
+   * @returns The most recent effective policy if found, null otherwise
+   */
+  async getPolicy(policyId) {
+    const versions = this.policies.get(policyId);
+    if (!versions || versions.length === 0) {
+      return null;
+    }
+    return versions[versions.length - 1];
+  }
+  /**
+   * Save a policy snapshot to the version history.
+   *
+   * If the policy does not have an ID, one will be generated.
+   * If the policy does not have a version, one will be generated.
+   *
+   * @param policy - The effective policy to save
+   * @returns The policy ID
+   */
+  async savePolicy(policy) {
+    const policyId = policy.policyId || generatePolicyId();
+    const version2 = policy.version || generatePolicyVersion();
+    const policyWithMeta = {
+      ...policy,
+      policyId,
+      version: version2,
+      createdAt: policy.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const versions = this.policies.get(policyId) || [];
+    versions.push(policyWithMeta);
+    this.policies.set(policyId, versions);
+    return policyId;
+  }
+  /**
+   * List all policy IDs, optionally filtered by prefix.
+   *
+   * @param prefix - Optional prefix to filter policy IDs
+   * @returns List of matching policy IDs
+   */
+  async listPolicies(prefix) {
+    const allIds = Array.from(this.policies.keys());
+    if (prefix === void 0) {
+      return allIds;
+    }
+    return allIds.filter((id) => id.startsWith(prefix));
+  }
+  /**
+   * Delete a policy by its ID (removes all versions).
+   *
+   * @param policyId - The unique identifier of the policy
+   * @returns True if the policy was deleted, false if not found
+   */
+  async deletePolicy(policyId) {
+    return this.policies.delete(policyId);
+  }
+  /**
+   * Retrieve the complete version history for a policy.
+   *
+   * Returns policies in chronological order (oldest to newest).
+   *
+   * @param policyId - The unique identifier of the policy
+   * @returns List of all versions of the policy
+   */
+  async getHistory(policyId) {
+    const versions = this.policies.get(policyId);
+    if (!versions) {
+      return [];
+    }
+    return [...versions];
+  }
+  /**
+   * Get a policy profile by name.
+   *
+   * @param name - The profile name
+   * @returns The policy profile if found, null otherwise
+   */
+  async getProfile(name) {
+    return this.profiles.get(name) || null;
+  }
+  /**
+   * Save a policy profile.
+   *
+   * @param profile - The policy profile to save
+   * @returns The profile name
+   */
+  async saveProfile(profile) {
+    this.profiles.set(profile.name, profile);
+    return profile.name;
+  }
+  /**
+   * List all profile names.
+   *
+   * @returns List of profile names
+   */
+  async listProfiles() {
+    return Array.from(this.profiles.keys());
+  }
+  /**
+   * Create an effective policy from a profile and agent preferences.
+   *
+   * Clamps agent preferences to the profile's guardrails.
+   *
+   * @param profileName - The profile to use as base
+   * @param agentPrefs - Optional agent preferences to apply
+   * @param negotiationId - Optional negotiation ID
+   * @returns The effective policy
+   * @throws PolicyStoreError if the profile does not exist
+   */
+  async createEffectivePolicy(profileName, agentPrefs, negotiationId) {
+    const profile = await this.getProfile(profileName);
+    if (!profile) {
+      throw new PolicyStoreError(`Profile '${profileName}' does not exist`);
+    }
+    const baseNegotiation = { ...profile.negotiation };
+    const baseExecution = { ...profile.execution };
+    const baseEscalation = { ...profile.escalation };
+    const applied = {};
+    if (agentPrefs) {
+      for (const [agentId, prefs] of Object.entries(agentPrefs)) {
+        const clamped = {};
+        if (prefs.maxRounds !== void 0) {
+          clamped.maxRounds = Math.min(prefs.maxRounds, baseNegotiation.maxRounds);
+        }
+        if (prefs.scoreThreshold !== void 0) {
+          clamped.scoreThreshold = Math.max(
+            prefs.scoreThreshold,
+            baseNegotiation.scoreThreshold
+          );
+        }
+        if (prefs.diffTolerance !== void 0) {
+          clamped.diffTolerance = Math.min(
+            prefs.diffTolerance,
+            baseNegotiation.diffTolerance
+          );
+        }
+        if (prefs.roundTimeoutMs !== void 0) {
+          clamped.roundTimeoutMs = Math.min(
+            prefs.roundTimeoutMs,
+            baseNegotiation.roundTimeoutMs
+          );
+        }
+        if (prefs.tokenBudgetPerRound !== void 0) {
+          clamped.tokenBudgetPerRound = Math.min(
+            prefs.tokenBudgetPerRound,
+            baseNegotiation.tokenBudgetPerRound
+          );
+        }
+        if (prefs.totalTokenBudget !== void 0 && baseNegotiation.totalTokenBudget > 0) {
+          clamped.totalTokenBudget = Math.min(
+            prefs.totalTokenBudget,
+            baseNegotiation.totalTokenBudget
+          );
+        }
+        if (prefs.oscillationLimit !== void 0) {
+          clamped.oscillationLimit = Math.min(
+            prefs.oscillationLimit,
+            baseNegotiation.oscillationLimit
+          );
+        }
+        applied[agentId] = clamped;
+      }
+    }
+    const effectivePolicy = {
+      policyId: generatePolicyId(),
+      version: generatePolicyVersion(),
+      negotiation: baseNegotiation,
+      execution: baseExecution,
+      escalation: baseEscalation,
+      negotiationId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (Object.keys(applied).length > 0) {
+      effectivePolicy.applied = applied;
+    }
+    await this.savePolicy(effectivePolicy);
+    return effectivePolicy;
+  }
+};
+var JsonFilePolicyStore = class {
+  directory;
+  profiles = /* @__PURE__ */ new Map();
+  /**
+   * Create a new JSON file policy store.
+   *
+   * @param directory - Directory to store policy files
+   */
+  constructor(directory) {
+    this.directory = directory;
+    this.initializeDefaultProfiles();
+  }
+  /**
+   * Initialize the store, creating the directory if needed.
+   */
+  async initialize() {
+    await import_promises2.default.mkdir(this.directory, { recursive: true });
+  }
+  /**
+   * Initialize default policy profiles.
+   */
+  initializeDefaultProfiles() {
+    const lowProfile = {
+      name: "LOW",
+      negotiation: {
+        maxRounds: 5,
+        scoreThreshold: 0.6,
+        diffTolerance: 0.4,
+        roundTimeoutMs: 6e4,
+        tokenBudgetPerRound: 2048,
+        totalTokenBudget: 0,
+        oscillationLimit: 5,
+        hitl: "None" /* NONE */,
+        scoring: {
+          requireSchemaValid: false,
+          requireExamplesPass: false,
+          llmWeight: 0.3
+        }
+      },
+      execution: {
+        ...DEFAULT_EXECUTION_POLICY,
+        timeoutMs: 12e4,
+        maxRetries: 5
+      },
+      escalation: {
+        ...DEFAULT_ESCALATION_POLICY,
+        deadlockRounds: 5
+      }
+    };
+    const mediumProfile = {
+      name: "MEDIUM",
+      negotiation: { ...DEFAULT_NEGOTIATION_POLICY },
+      execution: { ...DEFAULT_EXECUTION_POLICY },
+      escalation: { ...DEFAULT_ESCALATION_POLICY }
+    };
+    const highProfile = {
+      name: "HIGH",
+      negotiation: {
+        maxRounds: 15,
+        scoreThreshold: 0.85,
+        diffTolerance: 0.2,
+        roundTimeoutMs: 2e4,
+        tokenBudgetPerRound: 8192,
+        totalTokenBudget: 1e5,
+        oscillationLimit: 2,
+        hitl: "PauseOnFinalAccept" /* PAUSE_ON_FINAL_ACCEPT */,
+        scoring: {
+          requireSchemaValid: true,
+          requireExamplesPass: true,
+          llmWeight: 0.7
+        }
+      },
+      execution: {
+        ...DEFAULT_EXECUTION_POLICY,
+        timeoutMs: 3e4,
+        maxRetries: 2,
+        networkPolicy: "none"
+      },
+      escalation: {
+        ...DEFAULT_ESCALATION_POLICY,
+        deadlockRounds: 2,
+        autoEscalateOnDeadlock: true
+      }
+    };
+    this.profiles.set("LOW", lowProfile);
+    this.profiles.set("MEDIUM", mediumProfile);
+    this.profiles.set("HIGH", highProfile);
+  }
+  /**
+   * Sanitize a policy ID for use as a filename.
+   */
+  sanitizeId(policyId) {
+    return policyId.replace(/[/\\]/g, "_");
+  }
+  /**
+   * Get the file path for a policy.
+   */
+  getFilePath(policyId) {
+    return import_node_path3.default.join(this.directory, `${this.sanitizeId(policyId)}.json`);
+  }
+  /**
+   * Load versions from a file.
+   */
+  async loadFromFile(policyId) {
+    const filePath = this.getFilePath(policyId);
+    try {
+      const data = await import_promises2.default.readFile(filePath, "utf-8");
+      const parsed = JSON.parse(data);
+      if (Array.isArray(parsed)) {
+        return parsed;
       }
+      return [parsed];
     } catch {
+      return [];
     }
-    current = null;
-  };
-  start();
-  return emitter;
-}
+  }
+  /**
+   * Save versions to a file atomically.
+   */
+  async saveToFile(policyId, versions) {
+    await this.initialize();
+    const filePath = this.getFilePath(policyId);
+    const tempPath = `${filePath}.tmp.${Date.now()}`;
+    const data = JSON.stringify(versions, null, 2);
+    await import_promises2.default.writeFile(tempPath, data, "utf-8");
+    await import_promises2.default.rename(tempPath, filePath);
+  }
+  async getPolicy(policyId) {
+    const versions = await this.loadFromFile(policyId);
+    if (versions.length === 0) {
+      return null;
+    }
+    return versions[versions.length - 1];
+  }
+  async savePolicy(policy) {
+    const policyId = policy.policyId || generatePolicyId();
+    const version2 = policy.version || generatePolicyVersion();
+    const policyWithMeta = {
+      ...policy,
+      policyId,
+      version: version2,
+      createdAt: policy.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const versions = await this.loadFromFile(policyId);
+    versions.push(policyWithMeta);
+    await this.saveToFile(policyId, versions);
+    return policyId;
+  }
+  async listPolicies(prefix) {
+    try {
+      await this.initialize();
+      const files = await import_promises2.default.readdir(this.directory);
+      const policyIds = files.filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5));
+      if (prefix === void 0) {
+        return policyIds;
+      }
+      return policyIds.filter((id) => id.startsWith(prefix));
+    } catch {
+      return [];
+    }
+  }
+  async deletePolicy(policyId) {
+    const filePath = this.getFilePath(policyId);
+    try {
+      await import_promises2.default.unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getHistory(policyId) {
+    return this.loadFromFile(policyId);
+  }
+  async getProfile(name) {
+    return this.profiles.get(name) || null;
+  }
+  async saveProfile(profile) {
+    this.profiles.set(profile.name, profile);
+    return profile.name;
+  }
+  async listProfiles() {
+    return Array.from(this.profiles.keys());
+  }
+  /**
+   * Create an effective policy from a profile and agent preferences.
+   */
+  async createEffectivePolicy(profileName, agentPrefs, negotiationId) {
+    const profile = await this.getProfile(profileName);
+    if (!profile) {
+      throw new PolicyStoreError(`Profile '${profileName}' does not exist`);
+    }
+    const baseNegotiation = { ...profile.negotiation };
+    const baseExecution = { ...profile.execution };
+    const baseEscalation = { ...profile.escalation };
+    const applied = {};
+    if (agentPrefs) {
+      for (const [agentId, prefs] of Object.entries(agentPrefs)) {
+        const clamped = {};
+        if (prefs.maxRounds !== void 0) {
+          clamped.maxRounds = Math.min(prefs.maxRounds, baseNegotiation.maxRounds);
+        }
+        if (prefs.scoreThreshold !== void 0) {
+          clamped.scoreThreshold = Math.max(prefs.scoreThreshold, baseNegotiation.scoreThreshold);
+        }
+        if (prefs.diffTolerance !== void 0) {
+          clamped.diffTolerance = Math.min(prefs.diffTolerance, baseNegotiation.diffTolerance);
+        }
+        if (prefs.roundTimeoutMs !== void 0) {
+          clamped.roundTimeoutMs = Math.min(prefs.roundTimeoutMs, baseNegotiation.roundTimeoutMs);
+        }
+        if (prefs.tokenBudgetPerRound !== void 0) {
+          clamped.tokenBudgetPerRound = Math.min(prefs.tokenBudgetPerRound, baseNegotiation.tokenBudgetPerRound);
+        }
+        if (prefs.totalTokenBudget !== void 0 && baseNegotiation.totalTokenBudget > 0) {
+          clamped.totalTokenBudget = Math.min(prefs.totalTokenBudget, baseNegotiation.totalTokenBudget);
+        }
+        if (prefs.oscillationLimit !== void 0) {
+          clamped.oscillationLimit = Math.min(prefs.oscillationLimit, baseNegotiation.oscillationLimit);
+        }
+        applied[agentId] = clamped;
+      }
+    }
+    const effectivePolicy = {
+      policyId: generatePolicyId(),
+      version: generatePolicyVersion(),
+      negotiation: baseNegotiation,
+      execution: baseExecution,
+      escalation: baseEscalation,
+      negotiationId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (Object.keys(applied).length > 0) {
+      effectivePolicy.applied = applied;
+    }
+    await this.savePolicy(effectivePolicy);
+    return effectivePolicy;
+  }
+};
 
-// src/runtime/negotiationEvents.ts
-function parseNegotiationEvent(json) {
-  try {
-    const obj = JSON.parse(json);
-    if (!obj || typeof obj.kind !== "string")
-      return { kind: "unknown", ...obj || {} };
-    return obj;
-  } catch {
-    return { kind: "unknown", ts: void 0 };
+// src/runtime/agentState.ts
+var AgentState = /* @__PURE__ */ ((AgentState2) => {
+  AgentState2[AgentState2["AGENT_STATE_UNSPECIFIED"] = 0] = "AGENT_STATE_UNSPECIFIED";
+  AgentState2[AgentState2["INITIALIZING"] = 1] = "INITIALIZING";
+  AgentState2[AgentState2["RUNNABLE"] = 2] = "RUNNABLE";
+  AgentState2[AgentState2["SCHEDULED"] = 3] = "SCHEDULED";
+  AgentState2[AgentState2["RUNNING"] = 4] = "RUNNING";
+  AgentState2[AgentState2["WAITING"] = 5] = "WAITING";
+  AgentState2[AgentState2["WAITING_RESOURCES"] = 6] = "WAITING_RESOURCES";
+  AgentState2[AgentState2["SUSPENDED"] = 7] = "SUSPENDED";
+  AgentState2[AgentState2["RESUMED"] = 8] = "RESUMED";
+  AgentState2[AgentState2["COMPLETED"] = 9] = "COMPLETED";
+  AgentState2[AgentState2["FAILED"] = 10] = "FAILED";
+  AgentState2[AgentState2["SHUTTING_DOWN"] = 11] = "SHUTTING_DOWN";
+  AgentState2[AgentState2["RECOVERING"] = 12] = "RECOVERING";
+  return AgentState2;
+})(AgentState || {});
+var StateTransitionError2 = class extends Error {
+  fromState;
+  toState;
+  constructor(fromState, toState) {
+    const fromName = AgentState[fromState];
+    const toName = AgentState[toState];
+    super(`Invalid state transition from ${fromName} to ${toName}`);
+    this.name = "StateTransitionError";
+    this.fromState = fromState;
+    this.toState = toState;
   }
+};
+var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
+  // 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
+  [3 /* SCHEDULED */, /* @__PURE__ */ new Set([4 /* RUNNING */])],
+  // RUNNING -> WAITING, WAITING_RESOURCES, SUSPENDED, COMPLETED, FAILED, SHUTTING_DOWN
+  [
+    4 /* RUNNING */,
+    /* @__PURE__ */ new Set([
+      5 /* WAITING */,
+      6 /* WAITING_RESOURCES */,
+      7 /* SUSPENDED */,
+      9 /* COMPLETED */,
+      10 /* FAILED */,
+      11 /* SHUTTING_DOWN */
+    ])
+  ],
+  // WAITING -> RUNNING
+  [5 /* WAITING */, /* @__PURE__ */ new Set([4 /* RUNNING */])],
+  // WAITING_RESOURCES -> RUNNING, FAILED (resource timeout)
+  [
+    6 /* WAITING_RESOURCES */,
+    /* @__PURE__ */ new Set([4 /* RUNNING */, 10 /* FAILED */])
+  ],
+  // 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
+  [9 /* COMPLETED */, /* @__PURE__ */ new Set([2 /* RUNNABLE */])],
+  // FAILED -> RECOVERING
+  [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), FAILED (recovery timeout per spec s8.3)
+  [
+    12 /* RECOVERING */,
+    /* @__PURE__ */ new Set([2 /* RUNNABLE */, 11 /* SHUTTING_DOWN */, 10 /* FAILED */])
+  ]
+]);
+function isValidTransition(fromState, toState) {
+  const validTargets = VALID_TRANSITIONS.get(fromState);
+  if (!validTargets) {
+    return false;
+  }
+  return validTargets.has(toState);
 }
-function decodeBase64(b64) {
-  if (!b64)
-    return void 0;
-  return new Uint8Array(Buffer.from(b64, "base64"));
+function getValidTransitions(fromState) {
+  const validTargets = VALID_TRANSITIONS.get(fromState);
+  if (!validTargets) {
+    return [];
+  }
+  return Array.from(validTargets);
 }
-
-// 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");
+var AgentStateMachine = class {
+  state = 0 /* AGENT_STATE_UNSPECIFIED */;
+  hooks;
+  stateHistory = [];
+  /**
+   * Create a new agent state machine.
+   *
+   * @param hooks - Optional lifecycle hooks
+   */
+  constructor(hooks) {
+    this.hooks = hooks || {};
   }
-  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);
+  /**
+   * Get the current state.
+   *
+   * @returns The current agent state
+   */
+  getState() {
+    return this.state;
   }
-  async saveActivity(records) {
-    const payload = JSON.stringify(records, null, 2);
-    await this.safeWrite(this.activityFile, payload);
+  /**
+   * Get the state history.
+   *
+   * @returns Array of state transitions with timestamps
+   */
+  getStateHistory() {
+    return [...this.stateHistory];
   }
-  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;
+  /**
+   * Initialize the agent (transition to INITIALIZING).
+   *
+   * @throws StateTransitionError if already initialized
+   */
+  async initialize() {
+    if (this.state !== 0 /* AGENT_STATE_UNSPECIFIED */) {
+      throw new StateTransitionError2(this.state, 1 /* INITIALIZING */);
     }
+    await this.transitionTo(1 /* INITIALIZING */);
   }
-  async saveAcks(states) {
-    const payload = JSON.stringify(states, null, 2);
-    await this.safeWrite(this.acksFile, payload);
+  /**
+   * Transition to a new state.
+   *
+   * @param toState - The target state
+   * @param context - Optional context for the transition
+   * @throws StateTransitionError if the transition is invalid
+   */
+  async transitionTo(toState, context) {
+    if (this.state === 0 /* AGENT_STATE_UNSPECIFIED */ && toState === 1 /* INITIALIZING */) {
+      await this.doTransition(toState, context);
+      return;
+    }
+    if (!isValidTransition(this.state, toState)) {
+      throw new StateTransitionError2(this.state, toState);
+    }
+    await this.doTransition(toState, context);
+  }
+  /**
+   * Perform the state transition and call hooks.
+   */
+  async doTransition(toState, context) {
+    const fromState = this.state;
+    this.state = toState;
+    this.stateHistory.push({
+      state: toState,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      context
+    });
+    if (this.hooks.onStateChange) {
+      await this.hooks.onStateChange(fromState, toState, context);
+    }
+    await this.callSpecificHooks(fromState, toState, context);
+  }
+  /**
+   * Call specific lifecycle hooks based on the transition.
+   */
+  async callSpecificHooks(fromState, toState, context) {
+    switch (toState) {
+      case 3 /* SCHEDULED */:
+        if (this.hooks.onScheduled) {
+          const taskId = context?.taskId || "unknown";
+          await this.hooks.onScheduled(taskId, context);
+        }
+        break;
+      case 7 /* SUSPENDED */:
+        if (fromState === 4 /* RUNNING */ && this.hooks.onPreempt) {
+          const reason = context?.reason || "preemption";
+          await this.hooks.onPreempt(reason, context);
+        }
+        break;
+      case 4 /* RUNNING */:
+        if (fromState === 8 /* RESUMED */ && this.hooks.onResume) {
+          await this.hooks.onResume(context);
+        }
+        break;
+      case 5 /* WAITING */:
+        if (this.hooks.onWait) {
+          const reason = context?.reason || "waiting";
+          await this.hooks.onWait(reason, context);
+        }
+        break;
+      case 6 /* WAITING_RESOURCES */:
+        if (this.hooks.onWaitResources) {
+          const resources = context?.resources || [];
+          await this.hooks.onWaitResources(resources, context);
+        }
+        break;
+      case 9 /* COMPLETED */:
+        if (this.hooks.onComplete) {
+          await this.hooks.onComplete(context?.result, context);
+        }
+        break;
+      case 10 /* FAILED */:
+        if (this.hooks.onFail) {
+          const error = context?.error || new Error("Unknown failure");
+          await this.hooks.onFail(error, context);
+        }
+        break;
+      case 11 /* SHUTTING_DOWN */:
+        if (this.hooks.onShutdown) {
+          const gracePeriodMs = context?.gracePeriodMs || 3e4;
+          await this.hooks.onShutdown(gracePeriodMs, context);
+        }
+        break;
+      case 12 /* RECOVERING */:
+        if (this.hooks.onRecover) {
+          await this.hooks.onRecover(context);
+        }
+        break;
+    }
+  }
+  /**
+   * Check if the agent can transition to a given state.
+   *
+   * @param toState - The target state
+   * @returns True if the transition is valid
+   */
+  canTransitionTo(toState) {
+    if (this.state === 0 /* AGENT_STATE_UNSPECIFIED */ && toState === 1 /* INITIALIZING */) {
+      return true;
+    }
+    return isValidTransition(this.state, toState);
   }
-  async loadAcks() {
-    try {
-      const buf = await import_promises.default.readFile(this.acksFile, "utf8");
-      return JSON.parse(buf);
-    } catch (e) {
-      if (e?.code === "ENOENT")
-        return [];
-      throw e;
+  /**
+   * Get all states the agent can currently transition to.
+   *
+   * @returns Array of valid target states
+   */
+  getAvailableTransitions() {
+    if (this.state === 0 /* AGENT_STATE_UNSPECIFIED */) {
+      return [1 /* INITIALIZING */];
     }
+    return getValidTransitions(this.state);
+  }
+  /**
+   * Check if the agent is in a terminal state.
+   *
+   * Terminal states are states where the agent cannot make further
+   * progress without external intervention.
+   *
+   * @returns True if in a terminal state
+   */
+  isTerminal() {
+    return getValidTransitions(this.state).length === 0;
+  }
+  /**
+   * Check if the agent is in an active state (executing work).
+   *
+   * @returns True if the agent is actively working
+   */
+  isActive() {
+    return this.state === 4 /* RUNNING */ || this.state === 3 /* SCHEDULED */ || this.state === 8 /* RESUMED */;
+  }
+  /**
+   * Check if the agent is in a waiting state.
+   *
+   * @returns True if the agent is waiting
+   */
+  isWaiting() {
+    return this.state === 5 /* WAITING */ || this.state === 6 /* WAITING_RESOURCES */;
+  }
+  /**
+   * Check if the agent is in a suspended or shutdown state.
+   *
+   * @returns True if the agent is suspended or shutting down
+   */
+  isSuspendedOrShuttingDown() {
+    return this.state === 7 /* SUSPENDED */ || this.state === 11 /* SHUTTING_DOWN */;
+  }
+  /**
+   * Update lifecycle hooks.
+   *
+   * @param hooks - New hooks to merge with existing hooks
+   */
+  setHooks(hooks) {
+    this.hooks = { ...this.hooks, ...hooks };
+  }
+  /**
+   * Reset the state machine to uninitialized state.
+   *
+   * This is primarily for testing purposes.
+   */
+  reset() {
+    this.state = 0 /* AGENT_STATE_UNSPECIFIED */;
+    this.stateHistory = [];
   }
 };
 
@@ -10774,7 +13271,8 @@ function computeIdempotencyToken(input) {
   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
@@ -10891,6 +13389,669 @@ function normalizeReportPaths(report) {
   return report;
 }
 
+// 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_crypto4 = __toESM(require("node:crypto"), 1);
+function uuidv43() {
+  if (typeof import_node_crypto4.default.randomUUID === "function") {
+    return import_node_crypto4.default.randomUUID();
+  }
+  const buf = import_node_crypto4.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_crypto4.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_crypto4.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;
+  }
+  if (proof.proof_type === "simple_hash") {
+    if (proof.proof_data.length === 0) {
+      return false;
+    }
+    const envelopeHash = computeEnvelopeHash(envelope);
+    if (proof.proof_data.length !== 32) {
+      return false;
+    }
+    return true;
+  }
+  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
+    };
+  }
+  /**
+   * Always returns true for no-op proofs.
+   *
+   * @param proof - The proof (ignored)
+   * @returns Always true
+   */
+  verifyProof(proof) {
+    return true;
+  }
+  /**
+   * 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
+    };
+  }
+  /**
+   * Always returns empty array.
+   *
+   * @param envelope_id - The envelope ID (ignored)
+   * @returns Empty array
+   */
+  query(envelope_id) {
+    return [];
+  }
+};
+var InMemoryAuditor = class {
+  _records;
+  /**
+   * Initialize with empty record storage.
+   */
+  constructor() {
+    this._records = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 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";
@@ -10977,7 +14138,7 @@ var Resolver = class {
     try {
       const v = await this.backend.get(scope, key);
       return [v, scope.isGlobal ? "global" /* GLOBAL */ : "scoped" /* SCOPED */];
-    } catch (e) {
+    } catch {
     }
     if (!scope.isGlobal) {
       const v = await this.backend.get(new Scope(null), key);
@@ -10988,28 +14149,28 @@ var Resolver = class {
 };
 
 // src/secrets/backends/file.ts
-var import_node_fs = require("node:fs");
-var import_node_path3 = 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_path3.join)(process.env.USERPROFILE || "", "AppData", "Roaming");
-    return (0, import_node_path3.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_path3.join)(process.env.HOME || "", ".config");
-  return (0, import_node_path3.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(path3) {
-    this.path = path3 ?? defaultPath();
-    (0, import_node_fs.mkdirSync)((0, import_node_path3.dirname)(this.path), { recursive: true });
+  constructor(path5) {
+    this.path = path5 ?? defaultPath();
+    (0, import_node_fs3.mkdirSync)((0, import_node_path5.dirname)(this.path), { recursive: true });
     try {
-      (0, import_node_fs.chmodSync)((0, import_node_path3.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 {
@@ -11019,17 +14180,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_path3.join)((0, import_node_path3.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));
@@ -11037,7 +14198,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")
@@ -11134,7 +14295,7 @@ async function selectBackend(mode) {
 }
 
 // src/index.ts
-var version = "0.3.0";
+var version = "0.5.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACKLifecycleManager,
@@ -11142,27 +14303,67 @@ var version = "0.3.0";
   ActivityBuffer,
   ActivityBufferSync,
   ActivityClient,
+  AgentState,
+  AgentStateMachine,
+  ArtifactType,
   BaseClient,
+  BordaCountAggregator,
+  BufferFullError,
   CT_AGENT_REPORT_V1,
   CT_SCHEDULER_COMMAND_V1,
+  CommunicationClass,
+  ConfidenceWeightedAggregator,
   ConnectorClient,
+  DEDUP_WINDOW_S,
+  DEFAULT_ACK_TIMEOUT_MS,
+  DEFAULT_ESCALATION_POLICY,
+  DEFAULT_EXECUTION_POLICY,
+  DEFAULT_NEGOTIATION_POLICY,
+  DebateIntensity,
+  DecisionOutcome,
   DefaultWorktreePolicy,
+  DuplicateDetectedError,
+  EnvelopeState,
   ErrorCode,
   ErrorCodeMapper,
   FileBackend,
   HITLClient,
+  HandoffClient,
+  HandoffStatus,
+  HandoffTimeoutError,
+  HandoffValidationError,
+  HitlMode,
+  HitlReasonType,
+  InMemoryAuditor,
+  InMemoryNegotiationRoomStore,
+  InMemoryPolicyStore,
   InterceptorChain,
   JSONFilePersistence,
+  JsonFilePolicyStore,
   KeyringBackend,
   LoggingClient,
+  MajorityVoteAggregator,
   MaxEntriesStrategy,
   MessageProcessor,
   MessageType,
   NegotiationClient,
+  NegotiationError,
+  NegotiationRoomClient,
+  NegotiationRoomStoreError,
+  NegotiationTimeoutError,
+  NegotiationValidationError,
+  NoOpAuditor,
+  NodeStatus,
+  PermissionError,
+  PersistentActivityBuffer,
   PersistentWorktreeState,
+  PolicyStoreError,
+  PolicyViolationError,
+  PreemptionError,
   ReasoningClient,
   RegistryClient,
   Resolver,
+  RouteError,
   RouterClient,
   RuntimePersistence,
   SchedulerClient,
@@ -11177,27 +14378,60 @@ var version = "0.3.0";
   SecretValidationError,
   SecretValue,
   Secrets,
+  SimpleAverageAggregator,
+  StateTransitionError,
   Sw4rmError,
+  TimeoutError,
   ToolClient,
+  TriggerType,
+  ValidationError,
+  VotingAnalyzer,
+  WorkflowClient,
+  WorkflowCycleError,
+  WorkflowStatus,
+  WorkflowValidationError,
   WorktreeClient,
+  WorktreeError,
+  WorktreeStateEnum,
+  WorktreeTransitionError,
+  aggregateVotes,
   buildAckEnvelope,
   buildEnvelope,
+  computeEnvelopeHash,
   computeIdempotencyToken,
   createResilientIncomingStream,
+  createSimpleProof,
   decodeAgentReportV1,
   decodeBase64,
+  defaultAgentConfig,
+  defaultEndpoints,
+  defaultRetryPolicy,
+  defaultSW4RMConfig,
   durationToMs,
   encodeSchedulerCommandV1,
+  getConfig,
+  getDefaultStore,
+  getValidTransitions,
+  isTerminalEnvelopeState,
+  isValidTransition,
+  isValidWorktreeTransition,
+  loadConfig,
+  loadConfigFromEnv,
   loggingInterceptor,
   mapGrpcStatusToErrorCode,
   msToDuration,
   normalizeReportPaths,
   nowTimestamp,
   parseNegotiationEvent,
+  resetConfig,
+  resetDefaultStore,
   selectBackend,
   sendMessageWithAck,
+  setConfig,
   timingInterceptor,
+  updateEnvelopeState,
   uuidv4,
+  verifyAuditProof,
   version
 });
 /*! Bundled license information: