@sw4rm/js-sdk 0.4.0 → 0.5.0

package/dist/esm/index.js

@@ -1860,7 +1860,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;
@@ -1869,8 +1869,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);
@@ -1908,15 +1908,15 @@ var require_fetch = __commonJS({
 var require_path = __commonJS({
   "node_modules/@protobufjs/path/index.js"(exports2) {
     "use strict";
-    var path4 = 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
        */
-      path4.isAbsolute = function isAbsolute2(path5) {
-        return /^(?:\/|\w+:)/.test(path5);
+      path5.isAbsolute = function isAbsolute2(path6) {
+        return /^(?:\/|\w+:)/.test(path6);
       }
     );
     var normalize = (
@@ -1925,9 +1925,9 @@ var require_path = __commonJS({
        * @param {string} path Path to normalize
        * @returns {string} Normalized path
        */
-      path4.normalize = function normalize2(path5) {
-        path5 = path5.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
-        var parts = path5.split("/"), absolute = isAbsolute(path5), prefix = "";
+      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; ) {
@@ -1946,7 +1946,7 @@ var require_path = __commonJS({
         return prefix + parts.join("/");
       }
     );
-    path4.resolve = function resolve(originPath, includePath, alreadyNormalized) {
+    path5.resolve = function resolve(originPath, includePath, alreadyNormalized) {
       if (!alreadyNormalized)
         includePath = normalize(includePath);
       if (isAbsolute(includePath))
@@ -2097,16 +2097,16 @@ var require_namespace = __commonJS({
       object.onRemove(this);
       return clearCache(this);
     };
-    Namespace.prototype.define = function define2(path4, json) {
-      if (util.isString(path4))
-        path4 = path4.split(".");
-      else if (!Array.isArray(path4))
+    Namespace.prototype.define = function define2(path5, json) {
+      if (util.isString(path5))
+        path5 = path5.split(".");
+      else if (!Array.isArray(path5))
         throw TypeError("illegal path");
-      if (path4 && path4.length && path4[0] === "")
+      if (path5 && path5.length && path5[0] === "")
         throw Error("path must be relative");
       var ptr = this;
-      while (path4.length > 0) {
-        var part = path4.shift();
+      while (path5.length > 0) {
+        var part = path5.shift();
         if (ptr.nested && ptr.nested[part]) {
           ptr = ptr.nested[part];
           if (!(ptr instanceof Namespace))
@@ -2143,26 +2143,26 @@ var require_namespace = __commonJS({
       });
       return this;
     };
-    Namespace.prototype.lookup = function lookup(path4, 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(path4) && path4.length) {
-        if (path4 === ".")
+      if (util.isString(path5) && path5.length) {
+        if (path5 === ".")
           return this.root;
-        path4 = path4.split(".");
-      } else if (!path4.length)
+        path5 = path5.split(".");
+      } else if (!path5.length)
         return this;
-      var flatPath = path4.join(".");
-      if (path4[0] === "")
-        return this.root.lookup(path4.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(path4, flatPath);
+      found = this._lookupImpl(path5, flatPath);
       if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {
         return found;
       }
@@ -2170,7 +2170,7 @@ var require_namespace = __commonJS({
         return null;
       var current = this;
       while (current.parent) {
-        found = current.parent._lookupImpl(path4, flatPath);
+        found = current.parent._lookupImpl(path5, flatPath);
         if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {
           return found;
         }
@@ -2178,49 +2178,49 @@ var require_namespace = __commonJS({
       }
       return null;
     };
-    Namespace.prototype._lookupImpl = function lookup(path4, flatPath) {
+    Namespace.prototype._lookupImpl = function lookup(path5, flatPath) {
       if (Object.prototype.hasOwnProperty.call(this._lookupCache, flatPath)) {
         return this._lookupCache[flatPath];
       }
-      var found = this.get(path4[0]);
+      var found = this.get(path5[0]);
       var exact = null;
       if (found) {
-        if (path4.length === 1) {
+        if (path5.length === 1) {
           exact = found;
         } else if (found instanceof Namespace) {
-          path4 = path4.slice(1);
-          exact = found._lookupImpl(path4, path4.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(path4, 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(path4) {
-      var found = this.lookup(path4, [Type]);
+    Namespace.prototype.lookupType = function lookupType(path5) {
+      var found = this.lookup(path5, [Type]);
       if (!found)
-        throw Error("no such type: " + path4);
+        throw Error("no such type: " + path5);
       return found;
     };
-    Namespace.prototype.lookupEnum = function lookupEnum(path4) {
-      var found = this.lookup(path4, [Enum]);
+    Namespace.prototype.lookupEnum = function lookupEnum(path5) {
+      var found = this.lookup(path5, [Enum]);
       if (!found)
-        throw Error("no such Enum '" + path4 + "' in " + this);
+        throw Error("no such Enum '" + path5 + "' in " + this);
       return found;
     };
-    Namespace.prototype.lookupTypeOrEnum = function lookupTypeOrEnum(path4) {
-      var found = this.lookup(path4, [Type, Enum]);
+    Namespace.prototype.lookupTypeOrEnum = function lookupTypeOrEnum(path5) {
+      var found = this.lookup(path5, [Type, Enum]);
       if (!found)
-        throw Error("no such Type or Enum '" + path4 + "' in " + this);
+        throw Error("no such Type or Enum '" + path5 + "' in " + this);
       return found;
     };
-    Namespace.prototype.lookupService = function lookupService(path4) {
-      var found = this.lookup(path4, [Service]);
+    Namespace.prototype.lookupService = function lookupService(path5) {
+      var found = this.lookup(path5, [Service]);
       if (!found)
-        throw Error("no such Service '" + path4 + "' in " + this);
+        throw Error("no such Service '" + path5 + "' in " + this);
       return found;
     };
     Namespace._configure = function(Type_, Service_, Enum_) {
@@ -3621,14 +3621,14 @@ var require_util = __commonJS({
       Object.defineProperty(object, "$type", { value: enm, enumerable: false });
       return enm;
     };
-    util.setProperty = function setProperty(dst, path4, value, ifNotSet) {
-      function setProp(dst2, path5, value2) {
-        var part = path5.shift();
+    util.setProperty = function setProperty(dst, path5, value, ifNotSet) {
+      function setProp(dst2, path6, value2) {
+        var part = path6.shift();
         if (part === "__proto__" || part === "prototype") {
           return dst2;
         }
-        if (path5.length > 0) {
-          dst2[part] = setProp(dst2[part] || {}, path5, value2);
+        if (path6.length > 0) {
+          dst2[part] = setProp(dst2[part] || {}, path6, value2);
         } else {
           var prevValue = dst2[part];
           if (prevValue && ifNotSet)
@@ -3641,10 +3641,10 @@ var require_util = __commonJS({
       }
       if (typeof dst !== "object")
         throw TypeError("dst must be an object");
-      if (!path4)
+      if (!path5)
         throw TypeError("path must be specified");
-      path4 = path4.split(".");
-      return setProp(dst, path4, value);
+      path5 = path5.split(".");
+      return setProp(dst, path5, value);
     };
     Object.defineProperty(util, "decorateRoot", {
       get: function() {
@@ -4191,12 +4191,12 @@ var require_object = __commonJS({
        */
       fullName: {
         get: function() {
-          var path4 = [this.name], ptr = this.parent;
+          var path5 = [this.name], ptr = this.parent;
           while (ptr) {
-            path4.unshift(ptr.name);
+            path5.unshift(ptr.name);
             ptr = ptr.parent;
           }
-          return path4.join(".");
+          return path5.join(".");
         }
       }
     });
@@ -8178,19 +8178,19 @@ var require_util2 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.addCommonProtos = exports2.loadProtosWithOptionsSync = exports2.loadProtosWithOptions = void 0;
-    var fs = __require("fs");
-    var path4 = __require("path");
+    var fs3 = __require("fs");
+    var path5 = __require("path");
     var Protobuf = require_protobufjs();
     function addIncludePathResolver(root, includePaths) {
       const originalResolvePath = root.resolvePath;
       root.resolvePath = (origin, target) => {
-        if (path4.isAbsolute(target)) {
+        if (path5.isAbsolute(target)) {
           return target;
         }
         for (const directory of includePaths) {
-          const fullPath = path4.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;
@@ -9482,6 +9482,7 @@ var require_src2 = __commonJS({
 
 // src/internal/baseClient.ts
 var protoLoader = __toESM(require_src2(), 1);
+import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import * as grpc from "@grpc/grpc-js";
@@ -9502,6 +9503,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 || {});
@@ -9517,6 +9520,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,
@@ -9536,6 +9587,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:
@@ -9649,12 +9722,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 = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
-    const protosDir = path.resolve(__dirname, "../../../../protos");
+    const protosDir = this.resolveProtosDir(__dirname);
     const loaderOpts = {
       keepCase: true,
       longs: String,
@@ -9674,10 +9747,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());
@@ -9687,6 +9763,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
+      path.resolve(dirname3, "../../protos"),
+      // Alternative npm structure: dist/esm/internal -> protos
+      path.resolve(dirname3, "../../../protos"),
+      // Monorepo development: sdks/js_sdk/src/internal -> protos
+      path.resolve(dirname3, "../../../../protos")
+    ];
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate) && fs.existsSync(path.join(candidate, "common.proto"))) {
+        return candidate;
+      }
+    }
+    return candidates[candidates.length - 1];
+  }
   channelCredentials() {
     return grpc.credentials.createInsecure();
   }
@@ -10274,6 +10371,95 @@ var RegistryClient = class extends BaseClient {
   }
 };
 
+// src/clients/negotiationRoomStore.ts
+var NegotiationRoomStoreError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NegotiationRoomStoreError";
+  }
+};
+var InMemoryNegotiationRoomStore = class {
+  proposals = /* @__PURE__ */ new Map();
+  votes = /* @__PURE__ */ new Map();
+  decisions = /* @__PURE__ */ new Map();
+  async hasProposal(artifactId) {
+    return this.proposals.has(artifactId);
+  }
+  async getProposal(artifactId) {
+    return this.proposals.get(artifactId) || null;
+  }
+  async saveProposal(proposal) {
+    const artifactId = proposal.artifactId;
+    if (this.proposals.has(artifactId)) {
+      throw new NegotiationRoomStoreError(
+        `Proposal with artifact_id '${artifactId}' already exists`
+      );
+    }
+    const proposalWithTimestamp = {
+      ...proposal,
+      createdAt: proposal.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.proposals.set(artifactId, proposalWithTimestamp);
+    this.votes.set(artifactId, []);
+  }
+  async listProposals(negotiationRoomId) {
+    const allProposals = Array.from(this.proposals.values());
+    if (negotiationRoomId === void 0) {
+      return allProposals;
+    }
+    return allProposals.filter((p) => p.negotiationRoomId === negotiationRoomId);
+  }
+  async getVotes(artifactId) {
+    return [...this.votes.get(artifactId) || []];
+  }
+  async addVote(vote) {
+    const artifactId = vote.artifactId;
+    const criticId = vote.criticId;
+    const existingVotes = this.votes.get(artifactId) || [];
+    for (const existingVote of existingVotes) {
+      if (existingVote.criticId === criticId) {
+        throw new NegotiationRoomStoreError(
+          `Critic '${criticId}' has already voted for artifact '${artifactId}'`
+        );
+      }
+    }
+    const voteWithTimestamp = {
+      ...vote,
+      votedAt: vote.votedAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (!this.votes.has(artifactId)) {
+      this.votes.set(artifactId, []);
+    }
+    this.votes.get(artifactId).push(voteWithTimestamp);
+  }
+  async getDecision(artifactId) {
+    return this.decisions.get(artifactId) || null;
+  }
+  async saveDecision(decision) {
+    const artifactId = decision.artifactId;
+    if (this.decisions.has(artifactId)) {
+      throw new NegotiationRoomStoreError(
+        `Decision already exists for artifact_id '${artifactId}'`
+      );
+    }
+    const decisionWithTimestamp = {
+      ...decision,
+      decidedAt: decision.decidedAt || (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.decisions.set(artifactId, decisionWithTimestamp);
+  }
+};
+var defaultStore = null;
+function getDefaultStore() {
+  if (defaultStore === null) {
+    defaultStore = new InMemoryNegotiationRoomStore();
+  }
+  return defaultStore;
+}
+function resetDefaultStore() {
+  defaultStore = null;
+}
+
 // src/clients/negotiationRoom.ts
 var ArtifactType = /* @__PURE__ */ ((ArtifactType2) => {
   ArtifactType2[ArtifactType2["ARTIFACT_TYPE_UNSPECIFIED"] = 0] = "ARTIFACT_TYPE_UNSPECIFIED";
@@ -10315,9 +10501,16 @@ function validateVote(vote) {
   }
 }
 var NegotiationRoomClient = class {
-  proposals = /* @__PURE__ */ new Map();
-  votes = /* @__PURE__ */ new Map();
-  decisions = /* @__PURE__ */ new Map();
+  store;
+  /**
+   * Create a new negotiation room client.
+   *
+   * @param options - Configuration options. If no store is provided,
+   *                  uses the shared default in-memory store.
+   */
+  constructor(options = {}) {
+    this.store = options.store || getDefaultStore();
+  }
   /**
    * Submit an artifact proposal for multi-agent review.
    *
@@ -10345,19 +10538,8 @@ var NegotiationRoomClient = class {
    * ```
    */
   async submitProposal(proposal) {
-    const artifactId = proposal.artifactId;
-    if (this.proposals.has(artifactId)) {
-      throw new NegotiationValidationError(
-        `Proposal with artifact_id '${artifactId}' already exists`
-      );
-    }
-    const proposalWithTimestamp = {
-      ...proposal,
-      createdAt: proposal.createdAt || (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.proposals.set(artifactId, proposalWithTimestamp);
-    this.votes.set(artifactId, []);
-    return artifactId;
+    await this.store.saveProposal(proposal);
+    return proposal.artifactId;
   }
   /**
    * Submit a critic's vote for an artifact.
@@ -10389,26 +10571,13 @@ var NegotiationRoomClient = class {
    */
   async submitVote(vote) {
     const artifactId = vote.artifactId;
-    if (!this.proposals.has(artifactId)) {
+    if (!await this.store.hasProposal(artifactId)) {
       throw new NegotiationValidationError(
         `No proposal found for artifact_id '${artifactId}'`
       );
     }
     validateVote(vote);
-    const existingVotes = this.votes.get(artifactId) || [];
-    for (const existingVote of existingVotes) {
-      if (existingVote.criticId === vote.criticId) {
-        throw new NegotiationValidationError(
-          `Critic '${vote.criticId}' has already voted for artifact '${artifactId}'`
-        );
-      }
-    }
-    const voteWithTimestamp = {
-      ...vote,
-      votedAt: vote.votedAt || (/* @__PURE__ */ new Date()).toISOString()
-    };
-    existingVotes.push(voteWithTimestamp);
-    this.votes.set(artifactId, existingVotes);
+    await this.store.addVote(vote);
   }
   /**
    * Retrieve all votes for a specific artifact.
@@ -10428,12 +10597,12 @@ var NegotiationRoomClient = class {
    * ```
    */
   async getVotes(artifactId) {
-    if (!this.proposals.has(artifactId)) {
+    if (!await this.store.hasProposal(artifactId)) {
       throw new NegotiationValidationError(
         `No proposal found for artifact_id '${artifactId}'`
       );
     }
-    return this.votes.get(artifactId) || [];
+    return this.store.getVotes(artifactId);
   }
   /**
    * Retrieve the decision for a specific artifact if available.
@@ -10454,12 +10623,12 @@ var NegotiationRoomClient = class {
    * ```
    */
   async getDecision(artifactId) {
-    if (!this.proposals.has(artifactId)) {
+    if (!await this.store.hasProposal(artifactId)) {
       throw new NegotiationValidationError(
         `No proposal found for artifact_id '${artifactId}'`
       );
     }
-    return this.decisions.get(artifactId) || null;
+    return this.store.getDecision(artifactId);
   }
   /**
    * Store a decision for an artifact.
@@ -10490,21 +10659,12 @@ var NegotiationRoomClient = class {
    */
   async storeDecision(decision) {
     const artifactId = decision.artifactId;
-    if (!this.proposals.has(artifactId)) {
+    if (!await this.store.hasProposal(artifactId)) {
       throw new NegotiationValidationError(
         `No proposal found for artifact_id '${artifactId}'`
       );
     }
-    if (this.decisions.has(artifactId)) {
-      throw new NegotiationValidationError(
-        `Decision already exists for artifact_id '${artifactId}'`
-      );
-    }
-    const decisionWithTimestamp = {
-      ...decision,
-      decidedAt: decision.decidedAt || (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.decisions.set(artifactId, decisionWithTimestamp);
+    await this.store.saveDecision(decision);
   }
   /**
    * Wait for a decision to be made on an artifact.
@@ -10528,14 +10688,14 @@ var NegotiationRoomClient = class {
    * ```
    */
   async waitForDecision(artifactId, timeoutMs = 3e4, pollIntervalMs = 100) {
-    if (!this.proposals.has(artifactId)) {
+    if (!await this.store.hasProposal(artifactId)) {
       throw new NegotiationValidationError(
         `No proposal found for artifact_id '${artifactId}'`
       );
     }
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
-      const decision = await this.getDecision(artifactId);
+      const decision = await this.store.getDecision(artifactId);
       if (decision !== null) {
         return decision;
       }
@@ -10561,7 +10721,7 @@ var NegotiationRoomClient = class {
    * ```
    */
   async getProposal(artifactId) {
-    return this.proposals.get(artifactId) || null;
+    return this.store.getProposal(artifactId);
   }
   /**
    * List all proposals, optionally filtered by negotiation room.
@@ -10576,13 +10736,7 @@ var NegotiationRoomClient = class {
    * ```
    */
   async listProposals(negotiationRoomId) {
-    const allProposals = Array.from(this.proposals.values());
-    if (negotiationRoomId === void 0) {
-      return allProposals;
-    }
-    return allProposals.filter(
-      (p) => p.negotiationRoomId === negotiationRoomId
-    );
+    return this.store.listProposals(negotiationRoomId);
   }
 };
 function aggregateVotes(votes) {
@@ -11210,6 +11364,31 @@ var WorkflowClient = class {
       instance.completedAt = (/* @__PURE__ */ new Date()).toISOString();
     }
   }
+  /**
+   * Resume a workflow by marking a node as completed and advancing dependents.
+   *
+   * Implements the ResumeWorkflow RPC (spec §17.7 MUST). Marks the specified
+   * node as COMPLETED, updates workflow data if provided, then transitions
+   * dependent nodes from PENDING to READY when all their dependencies are met.
+   *
+   * @param instanceId - The ID of the workflow instance
+   * @param nodeId - The ID of the node to mark as completed
+   * @param workflowData - Optional updated workflow data (JSON string)
+   * @param metadata - Optional metadata for the resume operation
+   * @returns The updated workflow instance
+   * @throws WorkflowValidationError if the instance or node does not exist
+   */
+  async resumeWorkflow(instanceId, nodeId, workflowData, metadata) {
+    await this.updateNodeState(instanceId, nodeId, 4 /* COMPLETED */);
+    if (workflowData !== void 0) {
+      await this.updateWorkflowData(instanceId, workflowData);
+    }
+    if (metadata) {
+      const instance = this.instances.get(instanceId);
+      Object.assign(instance.metadata, metadata);
+    }
+    return this.getWorkflowStatus(instanceId);
+  }
   /**
    * Update the shared workflow data.
    *
@@ -11231,6 +11410,21 @@ var WorkflowClient = class {
 
 // src/internal/envelope.ts
 import crypto2 from "node:crypto";
+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);
@@ -11238,7 +11432,15 @@ function nowTimestamp(date = /* @__PURE__ */ new Date()) {
   return { seconds, nanos };
 }
 function nowHlcStub(date = /* @__PURE__ */ new Date()) {
-  return String(date.getTime());
+  const wallUs = date.getTime() * 1e3;
+  let node = "unknown";
+  try {
+    const os = __require("node:os");
+    node = os.hostname() || "unknown";
+  } catch {
+    node = "browser";
+  }
+  return `HLC:${wallUs}:0:${node}`;
 }
 function uuidv42() {
   if (typeof crypto2.randomUUID === "function") {
@@ -11274,7 +11476,12 @@ function buildEnvelope(input) {
     hlc_timestamp,
     // Always set hlc_timestamp (aligns with Python/Rust)
     ttl_ms: input.ttl_ms,
-    timestamp: ts
+    timestamp: ts,
+    state: input.state ?? 1,
+    // EnvelopeState.CREATED
+    effective_policy_id: input.effective_policy_id ?? "",
+    audit_proof: input.audit_proof ?? new Uint8Array(0),
+    audit_policy_id: input.audit_policy_id ?? ""
   };
   if (hasPayload) {
     const payload = input.payload instanceof Uint8Array ? input.payload : new Uint8Array(input.payload);
@@ -11288,25 +11495,141 @@ function buildEnvelope(input) {
 }
 
 // src/internal/worktreeState.ts
+var VALID_WORKTREE_TRANSITIONS = {
+  UNBOUND: ["BOUND_HOME", "BIND_FAILED"],
+  BOUND_HOME: ["SWITCH_PENDING", "UNBOUND"],
+  SWITCH_PENDING: ["BOUND_NON_HOME", "BOUND_HOME"],
+  // approve or reject
+  BOUND_NON_HOME: ["BOUND_HOME", "UNBOUND"],
+  // TTL expired/revoke, or unbind
+  BIND_FAILED: ["UNBOUND", "BOUND_HOME"]
+  // retry reset or successful retry
+};
+function isValidWorktreeTransition(from, to) {
+  return VALID_WORKTREE_TRANSITIONS[from]?.includes(to) ?? false;
+}
+var WorktreeTransitionError = class extends Error {
+  fromState;
+  toState;
+  constructor(from, to) {
+    super(`Invalid worktree state transition from ${from} to ${to}`);
+    this.name = "WorktreeTransitionError";
+    this.fromState = from;
+    this.toState = to;
+  }
+};
 var PersistentWorktreeState = class {
   state = "UNBOUND";
   repoId;
   worktreeId;
+  homeRepoId;
+  homeWorktreeId;
+  switchTtlMs;
+  switchTimer;
+  /**
+   * Transition to a new state with validation.
+   * @throws WorktreeTransitionError if transition is invalid
+   */
+  transitionTo(newState) {
+    if (!isValidWorktreeTransition(this.state, newState)) {
+      throw new WorktreeTransitionError(this.state, newState);
+    }
+    this.state = newState;
+  }
+  /**
+   * Bind to a home worktree (UNBOUND -> BOUND_HOME or BIND_FAILED -> BOUND_HOME).
+   */
   bind(repoId, worktreeId) {
+    this.transitionTo("BOUND_HOME");
     this.repoId = repoId;
     this.worktreeId = worktreeId;
-    this.state = "BOUND_HOME";
+    this.homeRepoId = repoId;
+    this.homeWorktreeId = worktreeId;
   }
+  /**
+   * Handle bind failure (UNBOUND -> BIND_FAILED).
+   */
+  bindFailed() {
+    this.transitionTo("BIND_FAILED");
+  }
+  /**
+   * Unbind from current worktree.
+   */
   unbind() {
+    this.clearSwitchTimer();
+    this.transitionTo("UNBOUND");
     this.repoId = void 0;
     this.worktreeId = void 0;
-    this.state = "UNBOUND";
+  }
+  /**
+   * Request switch to a non-home worktree (BOUND_HOME -> SWITCH_PENDING).
+   * Requires approval or rejection before taking effect.
+   */
+  requestSwitch(targetRepoId, targetWorktreeId) {
+    this.transitionTo("SWITCH_PENDING");
+    this._pendingRepoId = targetRepoId;
+    this._pendingWorktreeId = targetWorktreeId;
+  }
+  /**
+   * Approve a pending switch (SWITCH_PENDING -> BOUND_NON_HOME).
+   * @param ttlMs - Time-to-live in milliseconds before auto-reverting to BOUND_HOME
+   */
+  approveSwitch(ttlMs = 3e5) {
+    this.transitionTo("BOUND_NON_HOME");
+    this.repoId = this._pendingRepoId;
+    this.worktreeId = this._pendingWorktreeId;
+    this.switchTtlMs = ttlMs;
+    this.clearSwitchTimer();
+    this.switchTimer = setTimeout(() => {
+      this.revertToHome();
+    }, ttlMs);
+  }
+  /**
+   * Reject a pending switch (SWITCH_PENDING -> BOUND_HOME).
+   */
+  rejectSwitch() {
+    this.transitionTo("BOUND_HOME");
+    this.repoId = this.homeRepoId;
+    this.worktreeId = this.homeWorktreeId;
+    delete this._pendingRepoId;
+    delete this._pendingWorktreeId;
+  }
+  /**
+   * Revert from non-home to home worktree (BOUND_NON_HOME -> BOUND_HOME).
+   * Called on TTL expiry or explicit revoke.
+   */
+  revertToHome() {
+    this.clearSwitchTimer();
+    if (this.state === "BOUND_NON_HOME") {
+      this.transitionTo("BOUND_HOME");
+      this.repoId = this.homeRepoId;
+      this.worktreeId = this.homeWorktreeId;
+    }
+  }
+  /**
+   * Reset from BIND_FAILED to UNBOUND for retry.
+   */
+  resetFromFailed() {
+    this.transitionTo("UNBOUND");
+  }
+  clearSwitchTimer() {
+    if (this.switchTimer) {
+      clearTimeout(this.switchTimer);
+      this.switchTimer = void 0;
+    }
   }
   setState(state) {
     this.state = state;
   }
   current() {
-    return { state: this.state, repo_id: this.repoId, worktree_id: this.worktreeId };
+    return {
+      state: this.state,
+      repo_id: this.repoId,
+      worktree_id: this.worktreeId,
+      home_repo_id: this.homeRepoId,
+      home_worktree_id: this.homeWorktreeId,
+      switch_ttl_ms: this.switchTtlMs
+    };
   }
 };
 
@@ -11368,16 +11691,6 @@ var ActivityBuffer = class {
 };
 
 // src/internal/runtime/ackLifecycle.ts
-var AckStage = /* @__PURE__ */ ((AckStage2) => {
-  AckStage2[AckStage2["ACK_STAGE_UNSPECIFIED"] = 0] = "ACK_STAGE_UNSPECIFIED";
-  AckStage2[AckStage2["RECEIVED"] = 1] = "RECEIVED";
-  AckStage2[AckStage2["READ"] = 2] = "READ";
-  AckStage2[AckStage2["FULFILLED"] = 3] = "FULFILLED";
-  AckStage2[AckStage2["REJECTED"] = 4] = "REJECTED";
-  AckStage2[AckStage2["FAILED"] = 5] = "FAILED";
-  AckStage2[AckStage2["TIMED_OUT"] = 6] = "TIMED_OUT";
-  return AckStage2;
-})(AckStage || {});
 var ACKLifecycleManager = class {
   acks = /* @__PURE__ */ new Map();
   mark(messageId, stage, note, errorCode) {
@@ -11414,21 +11727,6 @@ var ACKLifecycleManager = class {
 };
 
 // src/internal/runtime/messageProcessor.ts
-var MessageType = /* @__PURE__ */ ((MessageType3) => {
-  MessageType3[MessageType3["MESSAGE_TYPE_UNSPECIFIED"] = 0] = "MESSAGE_TYPE_UNSPECIFIED";
-  MessageType3[MessageType3["CONTROL"] = 1] = "CONTROL";
-  MessageType3[MessageType3["DATA"] = 2] = "DATA";
-  MessageType3[MessageType3["HEARTBEAT"] = 3] = "HEARTBEAT";
-  MessageType3[MessageType3["NOTIFICATION"] = 4] = "NOTIFICATION";
-  MessageType3[MessageType3["ACKNOWLEDGEMENT"] = 5] = "ACKNOWLEDGEMENT";
-  MessageType3[MessageType3["HITL_INVOCATION"] = 6] = "HITL_INVOCATION";
-  MessageType3[MessageType3["WORKTREE_CONTROL"] = 7] = "WORKTREE_CONTROL";
-  MessageType3[MessageType3["NEGOTIATION"] = 8] = "NEGOTIATION";
-  MessageType3[MessageType3["TOOL_CALL"] = 9] = "TOOL_CALL";
-  MessageType3[MessageType3["TOOL_RESULT"] = 10] = "TOOL_RESULT";
-  MessageType3[MessageType3["TOOL_ERROR"] = 11] = "TOOL_ERROR";
-  return MessageType3;
-})(MessageType || {});
 var MessageProcessor = class {
   handlers = /* @__PURE__ */ new Map();
   defaultHandler;
@@ -12548,7 +12846,7 @@ var AgentState = /* @__PURE__ */ ((AgentState2) => {
   AgentState2[AgentState2["RECOVERING"] = 12] = "RECOVERING";
   return AgentState2;
 })(AgentState || {});
-var StateTransitionError = class extends Error {
+var StateTransitionError2 = class extends Error {
   fromState;
   toState;
   constructor(fromState, toState) {
@@ -12561,8 +12859,8 @@ var StateTransitionError = class extends Error {
   }
 };
 var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
-  // INITIALIZING -> RUNNABLE
-  [1 /* INITIALIZING */, /* @__PURE__ */ new Set([2 /* RUNNABLE */])],
+  // INITIALIZING -> RUNNABLE, FAILED (init timeout per spec s8.2)
+  [1 /* INITIALIZING */, /* @__PURE__ */ new Set([2 /* RUNNABLE */, 10 /* FAILED */])],
   // RUNNABLE -> SCHEDULED
   [2 /* RUNNABLE */, /* @__PURE__ */ new Set([3 /* SCHEDULED */])],
   // SCHEDULED -> RUNNING
@@ -12586,8 +12884,8 @@ var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
     6 /* WAITING_RESOURCES */,
     /* @__PURE__ */ new Set([4 /* RUNNING */, 10 /* FAILED */])
   ],
-  // SUSPENDED -> RESUMED
-  [7 /* SUSPENDED */, /* @__PURE__ */ new Set([8 /* RESUMED */])],
+  // SUSPENDED -> RESUMED, FAILED (suspension timeout per spec s8.3)
+  [7 /* SUSPENDED */, /* @__PURE__ */ new Set([8 /* RESUMED */, 10 /* FAILED */])],
   // RESUMED -> RUNNING
   [8 /* RESUMED */, /* @__PURE__ */ new Set([4 /* RUNNING */])],
   // COMPLETED -> RUNNABLE
@@ -12596,10 +12894,10 @@ var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
   [10 /* FAILED */, /* @__PURE__ */ new Set([12 /* RECOVERING */])],
   // SHUTTING_DOWN -> FAILED (agent_shutdown_timeout)
   [11 /* SHUTTING_DOWN */, /* @__PURE__ */ new Set([10 /* FAILED */])],
-  // RECOVERING -> RUNNABLE, SHUTTING_DOWN (recovery abort)
+  // RECOVERING -> RUNNABLE, SHUTTING_DOWN (recovery abort), FAILED (recovery timeout per spec s8.3)
   [
     12 /* RECOVERING */,
-    /* @__PURE__ */ new Set([2 /* RUNNABLE */, 11 /* SHUTTING_DOWN */])
+    /* @__PURE__ */ new Set([2 /* RUNNABLE */, 11 /* SHUTTING_DOWN */, 10 /* FAILED */])
   ]
 ]);
 function isValidTransition(fromState, toState) {
@@ -12651,7 +12949,7 @@ var AgentStateMachine = class {
    */
   async initialize() {
     if (this.state !== 0 /* AGENT_STATE_UNSPECIFIED */) {
-      throw new StateTransitionError(this.state, 1 /* INITIALIZING */);
+      throw new StateTransitionError2(this.state, 1 /* INITIALIZING */);
     }
     await this.transitionTo(1 /* INITIALIZING */);
   }
@@ -12668,7 +12966,7 @@ var AgentStateMachine = class {
       return;
     }
     if (!isValidTransition(this.state, toState)) {
-      throw new StateTransitionError(this.state, toState);
+      throw new StateTransitionError2(this.state, toState);
     }
     await this.doTransition(toState, context);
   }
@@ -12832,7 +13130,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
@@ -12949,6 +13248,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
+import crypto4 from "node:crypto";
+function uuidv43() {
+  if (typeof crypto4.randomUUID === "function") {
+    return crypto4.randomUUID();
+  }
+  const buf = crypto4.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 = crypto4.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 = crypto4.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
+import * as fs2 from "fs";
+import * as path4 from "path";
+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
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+var JSONFilePersistence2 = class {
+  constructor(filePath = "sw4rm_activity.json") {
+    this.filePath = filePath;
+  }
+  load() {
+    if (!existsSync2(this.filePath)) {
+      return { records: {}, order: [] };
+    }
+    const raw = readFileSync2(this.filePath, "utf-8");
+    const data = JSON.parse(raw);
+    return {
+      records: data.records ?? {},
+      order: data.order ?? []
+    };
+  }
+  save(records, order) {
+    const dir = dirname(this.filePath);
+    if (dir && !existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(this.filePath, JSON.stringify({ records, order, version: "1.0" }, null, 2));
+  }
+  clear() {
+    if (existsSync2(this.filePath)) {
+      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";
@@ -13046,8 +14008,8 @@ var Resolver = class {
 };
 
 // src/secrets/backends/file.ts
-import { mkdirSync, readFileSync, renameSync, writeFileSync, existsSync, chmodSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2, existsSync as existsSync3, chmodSync } from "node:fs";
+import { join, dirname as dirname2 } from "node:path";
 function defaultPath() {
   const isWin = process.platform === "win32";
   if (isWin) {
@@ -13060,14 +14022,14 @@ function defaultPath() {
 }
 var FileBackend = class {
   path;
-  constructor(path4) {
-    this.path = path4 ?? defaultPath();
-    mkdirSync(dirname(this.path), { recursive: true });
+  constructor(path5) {
+    this.path = path5 ?? defaultPath();
+    mkdirSync2(dirname2(this.path), { recursive: true });
     try {
-      chmodSync(dirname(this.path), 448);
+      chmodSync(dirname2(this.path), 448);
     } catch {
     }
-    if (!existsSync(this.path)) {
+    if (!existsSync3(this.path)) {
       this.safeWrite({});
       this.enforceFilePerms();
     } else {
@@ -13084,9 +14046,9 @@ var FileBackend = class {
     }
   }
   safeWrite(obj) {
-    const tmp = join(dirname(this.path), `.secrets.${Date.now()}.${Math.random().toString(16).slice(2)}`);
+    const tmp = join(dirname2(this.path), `.secrets.${Date.now()}.${Math.random().toString(16).slice(2)}`);
     try {
-      writeFileSync(tmp, JSON.stringify(obj, null, 2), { encoding: "utf8", mode: 384 });
+      writeFileSync2(tmp, JSON.stringify(obj, null, 2), { encoding: "utf8", mode: 384 });
       renameSync(tmp, this.path);
       this.enforceFilePerms();
     } catch (e) {
@@ -13095,7 +14057,7 @@ var FileBackend = class {
   }
   load() {
     try {
-      const s = readFileSync(this.path, { encoding: "utf8" });
+      const s = readFileSync3(this.path, { encoding: "utf8" });
       return JSON.parse(s);
     } catch (e) {
       if (e.code === "ENOENT")
@@ -13192,10 +14154,10 @@ async function selectBackend(mode) {
 }
 
 // src/index.ts
-var version = "0.4.0";
+var version = "0.5.0";
 export {
   ACKLifecycleManager,
-  AckStage,
+  AckStage2 as AckStage,
   ActivityBuffer,
   ActivityBufferSync,
   ActivityClient,
@@ -13204,15 +14166,22 @@ export {
   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,
@@ -13222,6 +14191,9 @@ export {
   HandoffTimeoutError,
   HandoffValidationError,
   HitlMode,
+  HitlReasonType,
+  InMemoryAuditor,
+  InMemoryNegotiationRoomStore,
   InMemoryPolicyStore,
   InterceptorChain,
   JSONFilePersistence,
@@ -13233,15 +14205,23 @@ export {
   MessageProcessor,
   MessageType,
   NegotiationClient,
+  NegotiationError,
   NegotiationRoomClient,
+  NegotiationRoomStoreError,
   NegotiationTimeoutError,
   NegotiationValidationError,
+  NoOpAuditor,
   NodeStatus,
+  PermissionError,
+  PersistentActivityBuffer,
   PersistentWorktreeState,
   PolicyStoreError,
+  PolicyViolationError,
+  PreemptionError,
   ReasoningClient,
   RegistryClient,
   Resolver,
+  RouteError,
   RouterClient,
   RuntimePersistence,
   SchedulerClient,
@@ -13259,35 +14239,57 @@ export {
   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: