@sw4rm/js-sdk 0.3.0 → 0.4.0

package/dist/esm/index.js

@@ -1908,15 +1908,15 @@ var require_fetch = __commonJS({
 var require_path = __commonJS({
   "node_modules/@protobufjs/path/index.js"(exports2) {
     "use strict";
-    var path3 = exports2;
+    var path4 = 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);
+      path4.isAbsolute = function isAbsolute2(path5) {
+        return /^(?:\/|\w+:)/.test(path5);
       }
     );
     var normalize = (
@@ -1925,9 +1925,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 = "";
+      path4.normalize = function normalize2(path5) {
+        path5 = path5.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+        var parts = path5.split("/"), absolute = isAbsolute(path5), 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("/");
       }
     );
-    path3.resolve = function resolve(originPath, includePath, alreadyNormalized) {
+    path4.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(path3, json) {
-      if (util.isString(path3))
-        path3 = path3.split(".");
-      else if (!Array.isArray(path3))
+    Namespace.prototype.define = function define2(path4, json) {
+      if (util.isString(path4))
+        path4 = path4.split(".");
+      else if (!Array.isArray(path4))
         throw TypeError("illegal path");
-      if (path3 && path3.length && path3[0] === "")
+      if (path4 && path4.length && path4[0] === "")
         throw Error("path must be relative");
       var ptr = this;
-      while (path3.length > 0) {
-        var part = path3.shift();
+      while (path4.length > 0) {
+        var part = path4.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(path3, filterTypes, parentAlreadyChecked) {
+    Namespace.prototype.lookup = function lookup(path4, 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(path4) && path4.length) {
+        if (path4 === ".")
           return this.root;
-        path3 = path3.split(".");
-      } else if (!path3.length)
+        path4 = path4.split(".");
+      } else if (!path4.length)
         return this;
-      var flatPath = path3.join(".");
-      if (path3[0] === "")
-        return this.root.lookup(path3.slice(1), filterTypes);
+      var flatPath = path4.join(".");
+      if (path4[0] === "")
+        return this.root.lookup(path4.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(path4, 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(path3, flatPath);
+        found = current.parent._lookupImpl(path4, 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(path3, flatPath) {
+    Namespace.prototype._lookupImpl = function lookup(path4, flatPath) {
       if (Object.prototype.hasOwnProperty.call(this._lookupCache, flatPath)) {
         return this._lookupCache[flatPath];
       }
-      var found = this.get(path3[0]);
+      var found = this.get(path4[0]);
       var exact = null;
       if (found) {
-        if (path3.length === 1) {
+        if (path4.length === 1) {
           exact = found;
         } else if (found instanceof Namespace) {
-          path3 = path3.slice(1);
-          exact = found._lookupImpl(path3, path3.join("."));
+          path4 = path4.slice(1);
+          exact = found._lookupImpl(path4, path4.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(path4, 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(path4) {
+      var found = this.lookup(path4, [Type]);
       if (!found)
-        throw Error("no such type: " + path3);
+        throw Error("no such type: " + path4);
       return found;
     };
-    Namespace.prototype.lookupEnum = function lookupEnum(path3) {
-      var found = this.lookup(path3, [Enum]);
+    Namespace.prototype.lookupEnum = function lookupEnum(path4) {
+      var found = this.lookup(path4, [Enum]);
       if (!found)
-        throw Error("no such Enum '" + path3 + "' in " + this);
+        throw Error("no such Enum '" + path4 + "' in " + this);
       return found;
     };
-    Namespace.prototype.lookupTypeOrEnum = function lookupTypeOrEnum(path3) {
-      var found = this.lookup(path3, [Type, Enum]);
+    Namespace.prototype.lookupTypeOrEnum = function lookupTypeOrEnum(path4) {
+      var found = this.lookup(path4, [Type, Enum]);
       if (!found)
-        throw Error("no such Type or Enum '" + path3 + "' in " + this);
+        throw Error("no such Type or Enum '" + path4 + "' in " + this);
       return found;
     };
-    Namespace.prototype.lookupService = function lookupService(path3) {
-      var found = this.lookup(path3, [Service]);
+    Namespace.prototype.lookupService = function lookupService(path4) {
+      var found = this.lookup(path4, [Service]);
       if (!found)
-        throw Error("no such Service '" + path3 + "' in " + this);
+        throw Error("no such Service '" + path4 + "' 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, path3, value, ifNotSet) {
-      function setProp(dst2, path4, value2) {
-        var part = path4.shift();
+    util.setProperty = function setProperty(dst, path4, value, ifNotSet) {
+      function setProp(dst2, path5, value2) {
+        var part = path5.shift();
         if (part === "__proto__" || part === "prototype") {
           return dst2;
         }
-        if (path4.length > 0) {
-          dst2[part] = setProp(dst2[part] || {}, path4, value2);
+        if (path5.length > 0) {
+          dst2[part] = setProp(dst2[part] || {}, path5, 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 (!path3)
+      if (!path4)
         throw TypeError("path must be specified");
-      path3 = path3.split(".");
-      return setProp(dst, path3, value);
+      path4 = path4.split(".");
+      return setProp(dst, path4, value);
     };
     Object.defineProperty(util, "decorateRoot", {
       get: function() {
@@ -4191,12 +4191,12 @@ var require_object = __commonJS({
        */
       fullName: {
         get: function() {
-          var path3 = [this.name], ptr = this.parent;
+          var path4 = [this.name], ptr = this.parent;
           while (ptr) {
-            path3.unshift(ptr.name);
+            path4.unshift(ptr.name);
             ptr = ptr.parent;
           }
-          return path3.join(".");
+          return path4.join(".");
         }
       }
     });
@@ -8179,16 +8179,16 @@ var require_util2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.addCommonProtos = exports2.loadProtosWithOptionsSync = exports2.loadProtosWithOptions = void 0;
     var fs = __require("fs");
-    var path3 = __require("path");
+    var path4 = __require("path");
     var Protobuf = require_protobufjs();
     function addIncludePathResolver(root, includePaths) {
       const originalResolvePath = root.resolvePath;
       root.resolvePath = (origin, target) => {
-        if (path3.isAbsolute(target)) {
+        if (path4.isAbsolute(target)) {
           return target;
         }
         for (const directory of includePaths) {
-          const fullPath = path3.join(directory, target);
+          const fullPath = path4.join(directory, target);
           try {
             fs.accessSync(fullPath, fs.constants.R_OK);
             return fullPath;
@@ -9605,7 +9605,7 @@ var InterceptorChain = class {
 };
 function timingInterceptor() {
   return {
-    onRequest(ctx) {
+    onRequest(_ctx) {
     },
     onResponse(ctx, status) {
       if (typeof console !== "undefined" && console.debug) {
@@ -10274,6 +10274,961 @@ var RegistryClient = class extends BaseClient {
   }
 };
 
+// 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 NegotiationValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NegotiationValidationError";
+  }
+};
+function validateVote(vote) {
+  if (vote.score < 0 || vote.score > 10) {
+    throw new NegotiationValidationError(
+      `score must be in range [0, 10], got ${vote.score}`
+    );
+  }
+  if (vote.confidence < 0 || vote.confidence > 1) {
+    throw new NegotiationValidationError(
+      `confidence must be in range [0, 1], got ${vote.confidence}`
+    );
+  }
+}
+var NegotiationRoomClient = class {
+  proposals = /* @__PURE__ */ new Map();
+  votes = /* @__PURE__ */ new Map();
+  decisions = /* @__PURE__ */ new Map();
+  /**
+   * 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) {
+    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;
+  }
+  /**
+   * 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 (!this.proposals.has(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);
+  }
+  /**
+   * 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 (!this.proposals.has(artifactId)) {
+      throw new NegotiationValidationError(
+        `No proposal found for artifact_id '${artifactId}'`
+      );
+    }
+    return this.votes.get(artifactId) || [];
+  }
+  /**
+   * 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 (!this.proposals.has(artifactId)) {
+      throw new NegotiationValidationError(
+        `No proposal found for artifact_id '${artifactId}'`
+      );
+    }
+    return this.decisions.get(artifactId) || null;
+  }
+  /**
+   * 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 (!this.proposals.has(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);
+  }
+  /**
+   * 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 (!this.proposals.has(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);
+      if (decision !== null) {
+        return decision;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new NegotiationTimeoutError(
+      `No decision made for artifact '${artifactId}' within ${timeoutMs} milliseconds`
+    );
+  }
+  /**
+   * 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.proposals.get(artifactId) || null;
+  }
+  /**
+   * 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) {
+    const allProposals = Array.from(this.proposals.values());
+    if (negotiationRoomId === void 0) {
+      return allProposals;
+    }
+    return allProposals.filter(
+      (p) => p.negotiationRoomId === negotiationRoomId
+    );
+  }
+};
+function aggregateVotes(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
+  };
+}
+
+// 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";
+  }
+};
+var HandoffTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HandoffTimeoutError";
+  }
+};
+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;
+  }
+  /**
+   * 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();
+    }
+  }
+  /**
+   * 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
 import crypto2 from "node:crypto";
 function nowTimestamp(date = /* @__PURE__ */ new Date()) {
@@ -10516,11 +11471,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);
     };
@@ -10530,27 +11489,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);
@@ -10697,6 +11642,1187 @@ var JSONFilePersistence = class {
   }
 };
 
+// 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
+import fsp2 from "node:fs/promises";
+import path3 from "node:path";
+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 fsp2.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 path3.join(this.directory, `${this.sanitizeId(policyId)}.json`);
+  }
+  /**
+   * Load versions from a file.
+   */
+  async loadFromFile(policyId) {
+    const filePath = this.getFilePath(policyId);
+    try {
+      const data = await fsp2.readFile(filePath, "utf-8");
+      const parsed = JSON.parse(data);
+      if (Array.isArray(parsed)) {
+        return parsed;
+      }
+      return [parsed];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * 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 fsp2.writeFile(tempPath, data, "utf-8");
+    await fsp2.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 fsp2.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 fsp2.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/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 StateTransitionError = 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
+  [1 /* INITIALIZING */, /* @__PURE__ */ new Set([2 /* RUNNABLE */])],
+  // 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
+  [7 /* SUSPENDED */, /* @__PURE__ */ new Set([8 /* RESUMED */])],
+  // 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)
+  [
+    12 /* RECOVERING */,
+    /* @__PURE__ */ new Set([2 /* RUNNABLE */, 11 /* SHUTTING_DOWN */])
+  ]
+]);
+function isValidTransition(fromState, toState) {
+  const validTargets = VALID_TRANSITIONS.get(fromState);
+  if (!validTargets) {
+    return false;
+  }
+  return validTargets.has(toState);
+}
+function getValidTransitions(fromState) {
+  const validTargets = VALID_TRANSITIONS.get(fromState);
+  if (!validTargets) {
+    return [];
+  }
+  return Array.from(validTargets);
+}
+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 || {};
+  }
+  /**
+   * Get the current state.
+   *
+   * @returns The current agent state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get the state history.
+   *
+   * @returns Array of state transitions with timestamps
+   */
+  getStateHistory() {
+    return [...this.stateHistory];
+  }
+  /**
+   * Initialize the agent (transition to INITIALIZING).
+   *
+   * @throws StateTransitionError if already initialized
+   */
+  async initialize() {
+    if (this.state !== 0 /* AGENT_STATE_UNSPECIFIED */) {
+      throw new StateTransitionError(this.state, 1 /* INITIALIZING */);
+    }
+    await this.transitionTo(1 /* INITIALIZING */);
+  }
+  /**
+   * 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 StateTransitionError(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);
+  }
+  /**
+   * 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 = [];
+  }
+};
+
 // src/internal/idempotency.ts
 import crypto3 from "node:crypto";
 function computeIdempotencyToken(input) {
@@ -10909,7 +13035,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);
@@ -10934,8 +13060,8 @@ function defaultPath() {
 }
 var FileBackend = class {
   path;
-  constructor(path3) {
-    this.path = path3 ?? defaultPath();
+  constructor(path4) {
+    this.path = path4 ?? defaultPath();
     mkdirSync(dirname(this.path), { recursive: true });
     try {
       chmodSync(dirname(this.path), 448);
@@ -11066,31 +13192,53 @@ async function selectBackend(mode) {
 }
 
 // src/index.ts
-var version = "0.3.0";
+var version = "0.4.0";
 export {
   ACKLifecycleManager,
   AckStage,
   ActivityBuffer,
   ActivityBufferSync,
   ActivityClient,
+  AgentState,
+  AgentStateMachine,
+  ArtifactType,
   BaseClient,
+  BordaCountAggregator,
   CT_AGENT_REPORT_V1,
   CT_SCHEDULER_COMMAND_V1,
+  ConfidenceWeightedAggregator,
   ConnectorClient,
+  DEFAULT_ESCALATION_POLICY,
+  DEFAULT_EXECUTION_POLICY,
+  DEFAULT_NEGOTIATION_POLICY,
+  DecisionOutcome,
   DefaultWorktreePolicy,
   ErrorCode,
   ErrorCodeMapper,
   FileBackend,
   HITLClient,
+  HandoffClient,
+  HandoffStatus,
+  HandoffTimeoutError,
+  HandoffValidationError,
+  HitlMode,
+  InMemoryPolicyStore,
   InterceptorChain,
   JSONFilePersistence,
+  JsonFilePolicyStore,
   KeyringBackend,
   LoggingClient,
+  MajorityVoteAggregator,
   MaxEntriesStrategy,
   MessageProcessor,
   MessageType,
   NegotiationClient,
+  NegotiationRoomClient,
+  NegotiationTimeoutError,
+  NegotiationValidationError,
+  NodeStatus,
   PersistentWorktreeState,
+  PolicyStoreError,
   ReasoningClient,
   RegistryClient,
   Resolver,
@@ -11108,9 +13256,18 @@ export {
   SecretValidationError,
   SecretValue,
   Secrets,
+  SimpleAverageAggregator,
+  StateTransitionError,
   Sw4rmError,
   ToolClient,
+  TriggerType,
+  VotingAnalyzer,
+  WorkflowClient,
+  WorkflowCycleError,
+  WorkflowStatus,
+  WorkflowValidationError,
   WorktreeClient,
+  aggregateVotes,
   buildAckEnvelope,
   buildEnvelope,
   computeIdempotencyToken,
@@ -11119,6 +13276,8 @@ export {
   decodeBase64,
   durationToMs,
   encodeSchedulerCommandV1,
+  getValidTransitions,
+  isValidTransition,
   loggingInterceptor,
   mapGrpcStatusToErrorCode,
   msToDuration,