@granular-software/sdk 0.4.41 → 0.4.43

package/dist/index.mjs

@@ -159,9 +159,9 @@ var require_node_gyp_build = __commonJS({
     }
     function parseTags(file) {
       var arr = file.split(".");
-      var extension = arr.pop();
+      var extension2 = arr.pop();
       var tags = { file, specificity: 0 };
-      if (extension !== "node") return;
+      if (extension2 !== "node") return;
       for (var i = 0; i < arr.length; i++) {
         var tag = arr[i];
         if (tag === "node" || tag === "electron" || tag === "node-webkit") {
@@ -409,7 +409,7 @@ var require_permessage_deflate = __commonJS({
     var kBuffers = Symbol("buffers");
     var kError = Symbol("error");
     var zlibLimiter;
-    var PerMessageDeflate = class {
+    var PerMessageDeflate2 = class {
       /**
        * Creates a PerMessageDeflate instance.
        *
@@ -420,6 +420,9 @@ var require_permessage_deflate = __commonJS({
        *     acknowledge disabling of client context takeover
        * @param {Number} [options.concurrencyLimit=10] The number of concurrent
        *     calls to zlib
+       * @param {Boolean} [options.isServer=false] Create the instance in either
+       *     server or client mode
+       * @param {Number} [options.maxPayload=0] The maximum allowed message length
        * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
        *     use of a custom server window size
        * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
@@ -430,15 +433,12 @@ var require_permessage_deflate = __commonJS({
        *     deflate
        * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
        *     inflate
-       * @param {Boolean} [isServer=false] Create the instance in either server or
-       *     client mode
-       * @param {Number} [maxPayload=0] The maximum allowed message length
        */
-      constructor(options, isServer, maxPayload) {
-        this._maxPayload = maxPayload | 0;
+      constructor(options) {
         this._options = options || {};
         this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
-        this._isServer = !!isServer;
+        this._maxPayload = this._options.maxPayload | 0;
+        this._isServer = !!this._options.isServer;
         this._deflate = null;
         this._inflate = null;
         this.params = null;
@@ -747,7 +747,7 @@ var require_permessage_deflate = __commonJS({
         });
       }
     };
-    module.exports = PerMessageDeflate;
+    module.exports = PerMessageDeflate2;
     function deflateOnData(chunk) {
       this[kBuffers].push(chunk);
       this[kTotalLength] += chunk.length;
@@ -1027,7 +1027,7 @@ var require_validation = __commonJS({
 var require_receiver = __commonJS({
   "../../node_modules/ws/lib/receiver.js"(exports, module) {
     var { Writable } = __require("stream");
-    var PerMessageDeflate = require_permessage_deflate();
+    var PerMessageDeflate2 = require_permessage_deflate();
     var {
       BINARY_TYPES,
       EMPTY_BUFFER,
@@ -1057,6 +1057,10 @@ var require_receiver = __commonJS({
        *     extensions
        * @param {Boolean} [options.isServer=false] Specifies whether to operate in
        *     client or server mode
+       * @param {Number} [options.maxBufferedChunks=0] The maximum number of
+       *     buffered data chunks
+       * @param {Number} [options.maxFragments=0] The maximum number of message
+       *     fragments
        * @param {Number} [options.maxPayload=0] The maximum allowed message length
        * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
        *     not to skip UTF-8 validation for text and close messages
@@ -1067,6 +1071,8 @@ var require_receiver = __commonJS({
         this._binaryType = options.binaryType || BINARY_TYPES[0];
         this._extensions = options.extensions || {};
         this._isServer = !!options.isServer;
+        this._maxBufferedChunks = options.maxBufferedChunks | 0;
+        this._maxFragments = options.maxFragments | 0;
         this._maxPayload = options.maxPayload | 0;
         this._skipUTF8Validation = !!options.skipUTF8Validation;
         this[kWebSocket] = void 0;
@@ -1096,6 +1102,18 @@ var require_receiver = __commonJS({
        */
       _write(chunk, encoding, cb) {
         if (this._opcode === 8 && this._state == GET_INFO) return cb();
+        if (this._maxBufferedChunks > 0 && this._buffers.length >= this._maxBufferedChunks) {
+          cb(
+            this.createError(
+              RangeError,
+              "Too many buffered chunks",
+              false,
+              1008,
+              "WS_ERR_TOO_MANY_BUFFERED_PARTS"
+            )
+          );
+          return;
+        }
         this._bufferedBytes += chunk.length;
         this._buffers.push(chunk);
         this.startLoop(cb);
@@ -1194,7 +1212,7 @@ var require_receiver = __commonJS({
           return;
         }
         const compressed = (buf[0] & 64) === 64;
-        if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+        if (compressed && !this._extensions[PerMessageDeflate2.extensionName]) {
           const error = this.createError(
             RangeError,
             "RSV1 must be clear",
@@ -1425,6 +1443,17 @@ var require_receiver = __commonJS({
           return;
         }
         if (data.length) {
+          if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
+            const error = this.createError(
+              RangeError,
+              "Too many message fragments",
+              false,
+              1008,
+              "WS_ERR_TOO_MANY_BUFFERED_PARTS"
+            );
+            cb(error);
+            return;
+          }
           this._messageLength = this._totalPayloadLength;
           this._fragments.push(data);
         }
@@ -1438,7 +1467,7 @@ var require_receiver = __commonJS({
        * @private
        */
       decompress(data, cb) {
-        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+        const perMessageDeflate = this._extensions[PerMessageDeflate2.extensionName];
         perMessageDeflate.decompress(data, this._fin, (err, buf) => {
           if (err) return cb(err);
           if (buf.length) {
@@ -1454,6 +1483,17 @@ var require_receiver = __commonJS({
               cb(error);
               return;
             }
+            if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
+              const error = this.createError(
+                RangeError,
+                "Too many message fragments",
+                false,
+                1008,
+                "WS_ERR_TOO_MANY_BUFFERED_PARTS"
+              );
+              cb(error);
+              return;
+            }
             this._fragments.push(buf);
           }
           this.dataMessage(cb);
@@ -1619,7 +1659,10 @@ var require_sender = __commonJS({
   "../../node_modules/ws/lib/sender.js"(exports, module) {
     var { Duplex } = __require("stream");
     var { randomFillSync } = __require("crypto");
-    var PerMessageDeflate = require_permessage_deflate();
+    var {
+      types: { isUint8Array }
+    } = __require("util");
+    var PerMessageDeflate2 = require_permessage_deflate();
     var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
     var { isBlob, isValidStatusCode } = require_validation();
     var { mask: applyMask, toBuffer } = require_buffer_util();
@@ -1772,8 +1815,10 @@ var require_sender = __commonJS({
           buf.writeUInt16BE(code, 0);
           if (typeof data === "string") {
             buf.write(data, 2);
-          } else {
+          } else if (isUint8Array(data)) {
             buf.set(data, 2);
+          } else {
+            throw new TypeError("Second argument must be a string or a Uint8Array");
           }
         }
         const options = {
@@ -1903,7 +1948,7 @@ var require_sender = __commonJS({
        * @public
        */
       send(data, options, cb) {
-        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+        const perMessageDeflate = this._extensions[PerMessageDeflate2.extensionName];
         let opcode = options.binary ? 2 : 1;
         let rsv1 = options.compress;
         let byteLength;
@@ -2027,7 +2072,7 @@ var require_sender = __commonJS({
           this.sendFrame(_Sender.frame(data, options), cb);
           return;
         }
-        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+        const perMessageDeflate = this._extensions[PerMessageDeflate2.extensionName];
         this._bufferedBytes += options[kByteLength];
         this._state = DEFLATING;
         perMessageDeflate.compress(data, options.fin, (_, buf) => {
@@ -2463,11 +2508,11 @@ var require_extension = __commonJS({
       return offers;
     }
     function format(extensions) {
-      return Object.keys(extensions).map((extension) => {
-        let configurations = extensions[extension];
+      return Object.keys(extensions).map((extension2) => {
+        let configurations = extensions[extension2];
         if (!Array.isArray(configurations)) configurations = [configurations];
         return configurations.map((params) => {
-          return [extension].concat(
+          return [extension2].concat(
             Object.keys(params).map((k) => {
               let values = params[k];
               if (!Array.isArray(values)) values = [values];
@@ -2492,7 +2537,7 @@ var require_websocket = __commonJS({
     var { randomBytes, createHash } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
-    var PerMessageDeflate = require_permessage_deflate();
+    var PerMessageDeflate2 = require_permessage_deflate();
     var Receiver2 = require_receiver();
     var Sender2 = require_sender();
     var { isBlob } = require_validation();
@@ -2651,6 +2696,10 @@ var require_websocket = __commonJS({
        *     multiple times in the same tick
        * @param {Function} [options.generateMask] The function used to generate the
        *     masking key
+       * @param {Number} [options.maxBufferedChunks=0] The maximum number of
+       *     buffered data chunks
+       * @param {Number} [options.maxFragments=0] The maximum number of message
+       *     fragments
        * @param {Number} [options.maxPayload=0] The maximum allowed message size
        * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
        *     not to skip UTF-8 validation for text and close messages
@@ -2662,6 +2711,8 @@ var require_websocket = __commonJS({
           binaryType: this.binaryType,
           extensions: this._extensions,
           isServer: this._isServer,
+          maxBufferedChunks: options.maxBufferedChunks,
+          maxFragments: options.maxFragments,
           maxPayload: options.maxPayload,
           skipUTF8Validation: options.skipUTF8Validation
         });
@@ -2700,8 +2751,8 @@ var require_websocket = __commonJS({
           this.emit("close", this._closeCode, this._closeMessage);
           return;
         }
-        if (this._extensions[PerMessageDeflate.extensionName]) {
-          this._extensions[PerMessageDeflate.extensionName].cleanup();
+        if (this._extensions[PerMessageDeflate2.extensionName]) {
+          this._extensions[PerMessageDeflate2.extensionName].cleanup();
         }
         this._receiver.removeAllListeners();
         this._readyState = _WebSocket.CLOSED;
@@ -2863,7 +2914,7 @@ var require_websocket = __commonJS({
           fin: true,
           ...options
         };
-        if (!this._extensions[PerMessageDeflate.extensionName]) {
+        if (!this._extensions[PerMessageDeflate2.extensionName]) {
           opts.compress = false;
         }
         this._sender.send(data || EMPTY_BUFFER, opts, cb);
@@ -2961,6 +3012,8 @@ var require_websocket = __commonJS({
         autoPong: true,
         closeTimeout: CLOSE_TIMEOUT,
         protocolVersion: protocolVersions[1],
+        maxBufferedChunks: 1024 * 1024,
+        maxFragments: 128 * 1024,
         maxPayload: 100 * 1024 * 1024,
         skipUTF8Validation: false,
         perMessageDeflate: true,
@@ -2989,7 +3042,7 @@ var require_websocket = __commonJS({
       } else {
         try {
           parsedUrl = new URL2(address);
-        } catch (e) {
+        } catch {
           throw new SyntaxError(`Invalid URL: ${address}`);
         }
       }
@@ -3037,13 +3090,13 @@ var require_websocket = __commonJS({
       opts.path = parsedUrl.pathname + parsedUrl.search;
       opts.timeout = opts.handshakeTimeout;
       if (opts.perMessageDeflate) {
-        perMessageDeflate = new PerMessageDeflate(
-          opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
-          false,
-          opts.maxPayload
-        );
+        perMessageDeflate = new PerMessageDeflate2({
+          ...opts.perMessageDeflate,
+          isServer: false,
+          maxPayload: opts.maxPayload
+        });
         opts.headers["Sec-WebSocket-Extensions"] = format({
-          [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
+          [PerMessageDeflate2.extensionName]: perMessageDeflate.offer()
         });
       }
       if (protocols.length) {
@@ -3186,23 +3239,25 @@ var require_websocket = __commonJS({
             return;
           }
           const extensionNames = Object.keys(extensions);
-          if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
+          if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate2.extensionName) {
             const message = "Server indicated an extension that was not requested";
             abortHandshake(websocket, socket, message);
             return;
           }
           try {
-            perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+            perMessageDeflate.accept(extensions[PerMessageDeflate2.extensionName]);
           } catch (err) {
             const message = "Invalid Sec-WebSocket-Extensions header";
             abortHandshake(websocket, socket, message);
             return;
           }
-          websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+          websocket._extensions[PerMessageDeflate2.extensionName] = perMessageDeflate;
         }
         websocket.setSocket(socket, head, {
           allowSynchronousEvents: opts.allowSynchronousEvents,
           generateMask: opts.generateMask,
+          maxBufferedChunks: opts.maxBufferedChunks,
+          maxFragments: opts.maxFragments,
           maxPayload: opts.maxPayload,
           skipUTF8Validation: opts.skipUTF8Validation
         });
@@ -3514,9 +3569,9 @@ var require_websocket_server = __commonJS({
     var http = __require("http");
     var { Duplex } = __require("stream");
     var { createHash } = __require("crypto");
-    var extension = require_extension();
-    var PerMessageDeflate = require_permessage_deflate();
-    var subprotocol = require_subprotocol();
+    var extension2 = require_extension();
+    var PerMessageDeflate2 = require_permessage_deflate();
+    var subprotocol2 = require_subprotocol();
     var WebSocket2 = require_websocket();
     var { CLOSE_TIMEOUT, GUID, kWebSocket } = require_constants();
     var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
@@ -3542,6 +3597,10 @@ var require_websocket_server = __commonJS({
        *     called
        * @param {Function} [options.handleProtocols] A hook to handle protocols
        * @param {String} [options.host] The hostname where to bind the server
+       * @param {Number} [options.maxBufferedChunks=1048576] The maximum number of
+       *     buffered data chunks
+       * @param {Number} [options.maxFragments=131072] The maximum number of message
+       *     fragments
        * @param {Number} [options.maxPayload=104857600] The maximum allowed message
        *     size
        * @param {Boolean} [options.noServer=false] Enable no server mode
@@ -3563,6 +3622,8 @@ var require_websocket_server = __commonJS({
         options = {
           allowSynchronousEvents: true,
           autoPong: true,
+          maxBufferedChunks: 1024 * 1024,
+          maxFragments: 128 * 1024,
           maxPayload: 100 * 1024 * 1024,
           skipUTF8Validation: false,
           perMessageDeflate: false,
@@ -3739,7 +3800,7 @@ var require_websocket_server = __commonJS({
         let protocols = /* @__PURE__ */ new Set();
         if (secWebSocketProtocol !== void 0) {
           try {
-            protocols = subprotocol.parse(secWebSocketProtocol);
+            protocols = subprotocol2.parse(secWebSocketProtocol);
           } catch (err) {
             const message = "Invalid Sec-WebSocket-Protocol header";
             abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
@@ -3749,16 +3810,16 @@ var require_websocket_server = __commonJS({
         const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
         const extensions = {};
         if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) {
-          const perMessageDeflate = new PerMessageDeflate(
-            this.options.perMessageDeflate,
-            true,
-            this.options.maxPayload
-          );
+          const perMessageDeflate = new PerMessageDeflate2({
+            ...this.options.perMessageDeflate,
+            isServer: true,
+            maxPayload: this.options.maxPayload
+          });
           try {
-            const offers = extension.parse(secWebSocketExtensions);
-            if (offers[PerMessageDeflate.extensionName]) {
-              perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
-              extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+            const offers = extension2.parse(secWebSocketExtensions);
+            if (offers[PerMessageDeflate2.extensionName]) {
+              perMessageDeflate.accept(offers[PerMessageDeflate2.extensionName]);
+              extensions[PerMessageDeflate2.extensionName] = perMessageDeflate;
             }
           } catch (err) {
             const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
@@ -3829,10 +3890,10 @@ var require_websocket_server = __commonJS({
             ws._protocol = protocol;
           }
         }
-        if (extensions[PerMessageDeflate.extensionName]) {
-          const params = extensions[PerMessageDeflate.extensionName].params;
-          const value = extension.format({
-            [PerMessageDeflate.extensionName]: [params]
+        if (extensions[PerMessageDeflate2.extensionName]) {
+          const params = extensions[PerMessageDeflate2.extensionName].params;
+          const value = extension2.format({
+            [PerMessageDeflate2.extensionName]: [params]
           });
           headers.push(`Sec-WebSocket-Extensions: ${value}`);
           ws._extensions = extensions;
@@ -3842,6 +3903,8 @@ var require_websocket_server = __commonJS({
         socket.removeListener("error", socketOnError);
         ws.setSocket(socket, head, {
           allowSynchronousEvents: this.options.allowSynchronousEvents,
+          maxBufferedChunks: this.options.maxBufferedChunks,
+          maxFragments: this.options.maxFragments,
           maxPayload: this.options.maxPayload,
           skipUTF8Validation: this.options.skipUTF8Validation
         });
@@ -3902,19 +3965,25 @@ var require_websocket_server = __commonJS({
 // ../../node_modules/ws/wrapper.mjs
 var wrapper_exports = {};
 __export(wrapper_exports, {
+  PerMessageDeflate: () => import_permessage_deflate.default,
   Receiver: () => import_receiver.default,
   Sender: () => import_sender.default,
   WebSocket: () => import_websocket.default,
   WebSocketServer: () => import_websocket_server.default,
   createWebSocketStream: () => import_stream.default,
-  default: () => wrapper_default
+  default: () => wrapper_default,
+  extension: () => import_extension.default,
+  subprotocol: () => import_subprotocol.default
 });
-var import_stream, import_receiver, import_sender, import_websocket, import_websocket_server, wrapper_default;
+var import_stream, import_extension, import_permessage_deflate, import_receiver, import_sender, import_subprotocol, import_websocket, import_websocket_server, wrapper_default;
 var init_wrapper = __esm({
   "../../node_modules/ws/wrapper.mjs"() {
     import_stream = __toESM(require_stream());
+    import_extension = __toESM(require_extension());
+    import_permessage_deflate = __toESM(require_permessage_deflate());
     import_receiver = __toESM(require_receiver());
     import_sender = __toESM(require_sender());
+    import_subprotocol = __toESM(require_subprotocol());
     import_websocket = __toESM(require_websocket());
     import_websocket_server = __toESM(require_websocket_server());
     wrapper_default = import_websocket.default;
@@ -16057,7 +16126,275 @@ var Granular = class _Granular {
   }
 };
 
+// src/agent-harness-templates/action-presentation/0.1.0/manifest.json
+var manifest_default = {
+  id: "action-presentation",
+  version: "0.1.0",
+  status: "candidate",
+  owner: "granular",
+  createdAt: "2026-05-25T00:00:00.000Z",
+  changelog: "Candidate harness template focused on action-request detection and mutation result presentation. It exists to harden cases where the model answers with a terse completion such as Done instead of using tools and reporting the target/action/result.",
+  promptBuilder: "buildGranularAgentSystemPrompt:action-presentation",
+  continuationBuilder: "buildContinuationInstruction:action-presentation",
+  modelOutputInstruction: "agent-evals:modelOutputInstruction",
+  codeReviewPolicy: "reviewGeneratedJobCode",
+  defaultModel: "gpt-5.4",
+  modelMatrix: ["gpt-5.4"],
+  temperature: 0,
+  compatibility: {
+    minSdkVersion: "0.4.40",
+    capabilities: [
+      "executeCode",
+      "readEntities",
+      "workflowHelpers",
+      "savedData",
+      "showRecords"
+    ]
+  },
+  evalGates: {
+    requiredSuites: [
+      "agent-harness-hardening",
+      "agent-harness-runtime-e2e",
+      "agent-production-readiness-e2e"
+    ],
+    criticalBuckets: [
+      "relationship-traversal",
+      "cross-turn-reference",
+      "ambiguous-target-choice",
+      "confirmation-gated-mutation",
+      "denied-action-refusal",
+      "mutation-presentation"
+    ],
+    maxRegressionPct: 0,
+    minPassK: {
+      "critical-mutation": 0.9,
+      "permission-boundary": 1
+    }
+  }
+};
+
+// src/agent-harness-templates/experimental-compact/0.1.0/manifest.json
+var manifest_default2 = {
+  id: "experimental-compact",
+  version: "0.1.0",
+  status: "candidate",
+  owner: "granular",
+  createdAt: "2026-05-24T00:00:00.000Z",
+  changelog: "Candidate harness template used for champion/challenger testing. It adds a compact decision discipline section on top of the stable renderer.",
+  promptBuilder: "buildGranularAgentSystemPrompt:experimental-compact",
+  continuationBuilder: "buildContinuationInstruction:experimental-compact",
+  modelOutputInstruction: "agent-evals:modelOutputInstruction",
+  codeReviewPolicy: "reviewGeneratedJobCode",
+  defaultModel: "gpt-5.4",
+  modelMatrix: ["gpt-5.4"],
+  temperature: 0,
+  compatibility: {
+    minSdkVersion: "0.4.40",
+    capabilities: [
+      "executeCode",
+      "readEntities",
+      "workflowHelpers",
+      "savedData",
+      "showRecords"
+    ]
+  },
+  evalGates: {
+    requiredSuites: [
+      "agent-harness-hardening",
+      "agent-harness-runtime-e2e",
+      "agent-production-readiness-e2e"
+    ],
+    criticalBuckets: [
+      "relationship-traversal",
+      "cross-turn-reference",
+      "ambiguous-target-choice",
+      "confirmation-gated-mutation",
+      "denied-action-refusal",
+      "mutation-presentation"
+    ],
+    maxRegressionPct: 0,
+    minPassK: {
+      "critical-mutation": 0.9,
+      "permission-boundary": 1
+    }
+  }
+};
+
+// src/agent-harness-templates/stable/1.0.0/manifest.json
+var manifest_default3 = {
+  id: "stable",
+  version: "1.0.0",
+  status: "stable",
+  owner: "granular",
+  createdAt: "2026-05-24T00:00:00.000Z",
+  changelog: "Baseline template wrapping the existing Granular agent harness prompt, continuation instruction, output contract, and generated-job review policy.",
+  promptBuilder: "buildGranularAgentSystemPrompt",
+  continuationBuilder: "buildContinuationInstruction",
+  modelOutputInstruction: "agent-evals:modelOutputInstruction",
+  codeReviewPolicy: "reviewGeneratedJobCode",
+  defaultModel: "gpt-5.4",
+  modelMatrix: ["gpt-5.4"],
+  temperature: 0,
+  compatibility: {
+    minSdkVersion: "0.4.40",
+    capabilities: [
+      "executeCode",
+      "readEntities",
+      "workflowHelpers",
+      "savedData",
+      "showRecords"
+    ]
+  },
+  evalGates: {
+    requiredSuites: [
+      "agent-harness-hardening",
+      "agent-harness-runtime-e2e",
+      "agent-production-readiness-e2e"
+    ],
+    criticalBuckets: [
+      "relationship-traversal",
+      "cross-turn-reference",
+      "ambiguous-target-choice",
+      "confirmation-gated-mutation",
+      "denied-action-refusal",
+      "mutation-presentation"
+    ],
+    maxRegressionPct: 0,
+    minPassK: {
+      "critical-mutation": 0.9,
+      "permission-boundary": 1
+    }
+  }
+};
+
 // src/agent-harness.ts
+var HARNESS_TEMPLATE_STATUSES = [
+  "draft",
+  "candidate",
+  "release-candidate",
+  "stable",
+  "deprecated"
+];
+function requireRecord(value, context) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${context} must be an object.`);
+  }
+  return value;
+}
+function requiredString(record, key, context) {
+  const value = record[key];
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${context}.${key} must be a non-empty string.`);
+  }
+  return value;
+}
+function requiredNumber(record, key, context) {
+  const value = record[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${context}.${key} must be a finite number.`);
+  }
+  return value;
+}
+function requiredStringArray(record, key, context) {
+  const value = record[key];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item.trim())) {
+    throw new Error(`${context}.${key} must be an array of non-empty strings.`);
+  }
+  return [...value];
+}
+function requiredNumberRecord(record, key, context) {
+  const value = requireRecord(record[key], `${context}.${key}`);
+  const output = {};
+  for (const [entryKey, entryValue] of Object.entries(value)) {
+    if (typeof entryValue !== "number" || !Number.isFinite(entryValue) || entryValue < 0 || entryValue > 1) {
+      throw new Error(
+        `${context}.${key}.${entryKey} must be a number between 0 and 1.`
+      );
+    }
+    output[entryKey] = entryValue;
+  }
+  return output;
+}
+function validateHarnessTemplateManifest(value, context = "HarnessTemplateManifest") {
+  const record = requireRecord(value, context);
+  const status = requiredString(record, "status", context);
+  if (!HARNESS_TEMPLATE_STATUSES.includes(status)) {
+    throw new Error(
+      `${context}.status must be one of ${HARNESS_TEMPLATE_STATUSES.join(", ")}.`
+    );
+  }
+  const createdAt = requiredString(record, "createdAt", context);
+  if (Number.isNaN(Date.parse(createdAt))) {
+    throw new Error(`${context}.createdAt must be an ISO timestamp.`);
+  }
+  const compatibility = requireRecord(
+    record.compatibility,
+    `${context}.compatibility`
+  );
+  const evalGates = requireRecord(record.evalGates, `${context}.evalGates`);
+  const maxRegressionPct = requiredNumber(
+    evalGates,
+    "maxRegressionPct",
+    `${context}.evalGates`
+  );
+  if (maxRegressionPct < 0 || maxRegressionPct > 1) {
+    throw new Error(
+      `${context}.evalGates.maxRegressionPct must be between 0 and 1.`
+    );
+  }
+  return {
+    id: requiredString(record, "id", context),
+    version: requiredString(record, "version", context),
+    status,
+    owner: requiredString(record, "owner", context),
+    createdAt,
+    changelog: requiredString(record, "changelog", context),
+    promptBuilder: requiredString(record, "promptBuilder", context),
+    continuationBuilder: requiredString(record, "continuationBuilder", context),
+    modelOutputInstruction: requiredString(
+      record,
+      "modelOutputInstruction",
+      context
+    ),
+    codeReviewPolicy: requiredString(record, "codeReviewPolicy", context),
+    defaultModel: requiredString(record, "defaultModel", context),
+    modelMatrix: requiredStringArray(record, "modelMatrix", context),
+    temperature: requiredNumber(record, "temperature", context),
+    compatibility: {
+      minSdkVersion: requiredString(
+        compatibility,
+        "minSdkVersion",
+        `${context}.compatibility`
+      ),
+      capabilities: requiredStringArray(
+        compatibility,
+        "capabilities",
+        `${context}.compatibility`
+      )
+    },
+    evalGates: {
+      requiredSuites: requiredStringArray(
+        evalGates,
+        "requiredSuites",
+        `${context}.evalGates`
+      ),
+      criticalBuckets: requiredStringArray(
+        evalGates,
+        "criticalBuckets",
+        `${context}.evalGates`
+      ),
+      maxRegressionPct,
+      minPassK: requiredNumberRecord(
+        evalGates,
+        "minPassK",
+        `${context}.evalGates`
+      )
+    }
+  };
+}
+function defineHarnessTemplateManifest(value, context) {
+  return validateHarnessTemplateManifest(value, context);
+}
 var DEFAULT_IGNORED_REASONING_COMMENT_DIRECTIVES = [
   /^@ts-ignore\b/i,
   /^@ts-expect-error\b/i,
@@ -16160,6 +16497,16 @@ function uniqueStrings(values, maxCount) {
   }
   return output;
 }
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+  }
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
 function renderConstBlock(name, value) {
   return `const ${name} = ${JSON.stringify(value, null, 2)} as const;`;
 }
@@ -18104,6 +18451,194 @@ ${knownFactsBlock}
 [Request]
 ${input.request?.trim() || "Use the latest user message in the conversation."}`;
 }
+var STABLE_AGENT_HARNESS_TEMPLATE_MANIFEST = defineHarnessTemplateManifest(
+  manifest_default3,
+  "stable@1.0.0 manifest"
+);
+function hashHarnessTemplateValue(value) {
+  return hashString(stableStringify(value)) || "00000000";
+}
+function renderStableHarnessPrompt(input) {
+  const prompt = buildGranularAgentSystemPrompt(input);
+  const templateHash = hashHarnessTemplateValue(
+    STABLE_AGENT_HARNESS_TEMPLATE_MANIFEST
+  );
+  return {
+    templateId: STABLE_AGENT_HARNESS_TEMPLATE_MANIFEST.id,
+    templateVersion: STABLE_AGENT_HARNESS_TEMPLATE_MANIFEST.version,
+    templateHash,
+    promptInstanceHash: hashHarnessTemplateValue({
+      templateHash,
+      input,
+      prompt
+    }),
+    prompt
+  };
+}
+function renderStableHarnessContinuation(resultPreview) {
+  const instruction = buildContinuationInstruction(resultPreview);
+  const templateHash = hashHarnessTemplateValue(
+    STABLE_AGENT_HARNESS_TEMPLATE_MANIFEST
+  );
+  return {
+    templateId: STABLE_AGENT_HARNESS_TEMPLATE_MANIFEST.id,
+    templateVersion: STABLE_AGENT_HARNESS_TEMPLATE_MANIFEST.version,
+    templateHash,
+    instruction
+  };
+}
+var STABLE_AGENT_HARNESS_TEMPLATE = {
+  manifest: STABLE_AGENT_HARNESS_TEMPLATE_MANIFEST,
+  renderPrompt: renderStableHarnessPrompt,
+  renderContinuation: renderStableHarnessContinuation
+};
+var EXPERIMENTAL_COMPACT_AGENT_HARNESS_TEMPLATE_MANIFEST = defineHarnessTemplateManifest(
+  manifest_default2,
+  "experimental-compact@0.1.0 manifest"
+);
+function renderExperimentalCompactHarnessPrompt(input) {
+  const prompt = `${buildGranularAgentSystemPrompt(input)}
+
+[Candidate Harness Delta: Compact Decision Discipline]
+- Prefer the smallest action that satisfies the current request.
+- When several records could match, ask one structured choice question before mutating.
+- Before any irreversible or outbound mutation, obtain explicit confirmation unless the policy surface already requires it.
+- Do not compensate for missing tools with raw network calls, synthetic records, or hidden side channels.
+- Keep the final user-facing reply focused on what was done, what was not done, and any remaining blocker.`;
+  const templateHash = hashHarnessTemplateValue(
+    EXPERIMENTAL_COMPACT_AGENT_HARNESS_TEMPLATE_MANIFEST
+  );
+  return {
+    templateId: EXPERIMENTAL_COMPACT_AGENT_HARNESS_TEMPLATE_MANIFEST.id,
+    templateVersion: EXPERIMENTAL_COMPACT_AGENT_HARNESS_TEMPLATE_MANIFEST.version,
+    templateHash,
+    promptInstanceHash: hashHarnessTemplateValue({
+      templateHash,
+      input,
+      prompt
+    }),
+    prompt
+  };
+}
+function renderExperimentalCompactHarnessContinuation(resultPreview) {
+  const instruction = `${buildContinuationInstruction(resultPreview)}
+
+Keep the continuation compact: either finish, ask the one blocking question, or run the next smallest safe action.`;
+  const templateHash = hashHarnessTemplateValue(
+    EXPERIMENTAL_COMPACT_AGENT_HARNESS_TEMPLATE_MANIFEST
+  );
+  return {
+    templateId: EXPERIMENTAL_COMPACT_AGENT_HARNESS_TEMPLATE_MANIFEST.id,
+    templateVersion: EXPERIMENTAL_COMPACT_AGENT_HARNESS_TEMPLATE_MANIFEST.version,
+    templateHash,
+    instruction
+  };
+}
+var EXPERIMENTAL_COMPACT_AGENT_HARNESS_TEMPLATE = {
+  manifest: EXPERIMENTAL_COMPACT_AGENT_HARNESS_TEMPLATE_MANIFEST,
+  renderPrompt: renderExperimentalCompactHarnessPrompt,
+  renderContinuation: renderExperimentalCompactHarnessContinuation
+};
+var ACTION_PRESENTATION_AGENT_HARNESS_TEMPLATE_MANIFEST = defineHarnessTemplateManifest(
+  manifest_default,
+  "action-presentation@0.1.0 manifest"
+);
+function renderActionPresentationHarnessPrompt(input) {
+  const prompt = `${buildGranularAgentSystemPrompt(input)}
+
+[Candidate Harness Delta: Action Request And Result Presentation]
+- Treat requests like "handle it", "take care of it", "send it", "update it", "fix it", "process it", or "do it" as action requests when the message names a business object, target, workflow, or mutation verb.
+- For action requests involving session data, generated files, records, effects, or workflows, do not use text-only completion. Generate and run code, ask the blocking human question, or clearly refuse if policy/tooling prevents the action.
+- Never answer only "Done", "OK", "Handled", or similar terse completion text for a mutation request. The final user-facing reply must name the action attempted, the grounded target or blocker, and the actual result.
+- After a mutation/effect call, base the reply on the returned action result and include a visible target label or identifier when one exists.
+- If no target can be grounded, say what was searched and what exact identifier or choice is needed; do not pretend the action completed.`;
+  const templateHash = hashHarnessTemplateValue(
+    ACTION_PRESENTATION_AGENT_HARNESS_TEMPLATE_MANIFEST
+  );
+  return {
+    templateId: ACTION_PRESENTATION_AGENT_HARNESS_TEMPLATE_MANIFEST.id,
+    templateVersion: ACTION_PRESENTATION_AGENT_HARNESS_TEMPLATE_MANIFEST.version,
+    templateHash,
+    promptInstanceHash: hashHarnessTemplateValue({
+      templateHash,
+      input,
+      prompt
+    }),
+    prompt
+  };
+}
+function renderActionPresentationHarnessContinuation(resultPreview) {
+  const instruction = `${buildContinuationInstruction(resultPreview)}
+
+Before finishing, check whether the latest user request asked for an action. If it did, do not finish with a bare completion token; either continue with the needed tool/code step, ask the blocking question, refuse with the policy reason, or report the grounded action result with the target label.`;
+  const templateHash = hashHarnessTemplateValue(
+    ACTION_PRESENTATION_AGENT_HARNESS_TEMPLATE_MANIFEST
+  );
+  return {
+    templateId: ACTION_PRESENTATION_AGENT_HARNESS_TEMPLATE_MANIFEST.id,
+    templateVersion: ACTION_PRESENTATION_AGENT_HARNESS_TEMPLATE_MANIFEST.version,
+    templateHash,
+    instruction
+  };
+}
+var ACTION_PRESENTATION_AGENT_HARNESS_TEMPLATE = {
+  manifest: ACTION_PRESENTATION_AGENT_HARNESS_TEMPLATE_MANIFEST,
+  renderPrompt: renderActionPresentationHarnessPrompt,
+  renderContinuation: renderActionPresentationHarnessContinuation
+};
+var AGENT_HARNESS_TEMPLATES = {
+  [STABLE_AGENT_HARNESS_TEMPLATE.manifest.id]: STABLE_AGENT_HARNESS_TEMPLATE,
+  [EXPERIMENTAL_COMPACT_AGENT_HARNESS_TEMPLATE.manifest.id]: EXPERIMENTAL_COMPACT_AGENT_HARNESS_TEMPLATE,
+  [ACTION_PRESENTATION_AGENT_HARNESS_TEMPLATE.manifest.id]: ACTION_PRESENTATION_AGENT_HARNESS_TEMPLATE
+};
+function listHarnessTemplates() {
+  return Object.values(AGENT_HARNESS_TEMPLATES).map((template) => ({
+    ...template.manifest,
+    compatibility: { ...template.manifest.compatibility },
+    evalGates: {
+      ...template.manifest.evalGates,
+      minPassK: { ...template.manifest.evalGates.minPassK }
+    }
+  }));
+}
+function resolveHarnessTemplate(templateId = "stable", options) {
+  const resolved = AGENT_HARNESS_TEMPLATES[templateId];
+  if (resolved) return resolved;
+  if (options?.strict) {
+    const known = Object.keys(AGENT_HARNESS_TEMPLATES).join(", ");
+    throw new Error(
+      `Unknown harness template "${templateId}". Known templates: ${known}`
+    );
+  }
+  return STABLE_AGENT_HARNESS_TEMPLATE;
+}
+function getDefaultHarnessTemplateId() {
+  if (typeof process !== "undefined") {
+    const configured = process.env.GRANULAR_AGENT_HARNESS_TEMPLATE || process.env.NEXT_PUBLIC_GRANULAR_AGENT_HARNESS_TEMPLATE;
+    if (configured?.trim()) return configured.trim();
+  }
+  return "stable";
+}
+function renderGranularAgentSystemPromptFromTemplate(input, options) {
+  const template = resolveHarnessTemplate(
+    options?.templateId || getDefaultHarnessTemplateId(),
+    { strict: options?.strict ?? true }
+  );
+  return template.renderPrompt(input);
+}
+function buildGranularAgentSystemPromptFromTemplate(input, options) {
+  return renderGranularAgentSystemPromptFromTemplate(input, options).prompt;
+}
+function renderContinuationInstructionFromTemplate(resultPreview, options) {
+  const template = resolveHarnessTemplate(
+    options?.templateId || getDefaultHarnessTemplateId(),
+    { strict: options?.strict ?? true }
+  );
+  return template.renderContinuation(resultPreview);
+}
+function buildContinuationInstructionFromTemplate(resultPreview, options) {
+  return renderContinuationInstructionFromTemplate(resultPreview, options).instruction;
+}
 
 // src/openai-usage.ts
 var OPENAI_PRICING_SOURCE_URL = "https://developers.openai.com/api/docs/models/gpt-5.4/";
@@ -18200,6 +18735,6 @@ function calculateOpenAITokenSpend(model, rawUsage) {
   };
 }
 
-export { Environment, EnvironmentSession, Granular, OPENAI_MODEL_PRICING_USD_PER_MILLION, OntologyHandle, Session, WSClient, buildContinuationInstruction, buildGranularAgentCheckpointBlock, buildGranularAgentDomainBlock, buildGranularAgentFileBlock, buildGranularAgentHeapBlock, buildGranularAgentLoopBlock, buildGranularAgentReferentBlock, buildGranularAgentRuntimeImportsBlock, buildGranularAgentSessionBlock, buildGranularAgentSystemPrompt, buildGranularAgentToolBlock, buildGranularAgentWorkflowBlock, buildOpenAISpendEventId, buildSessionTranscript, calculateOpenAITokenSpend, consumeGranularReasoningOnlyChunk, consumeGranularReasoningTraceChunk, createHarnessVerifierSnapshot, evaluateContinuation, extractPromptTokens, getCurrentClosureId, getExclusivePromptTarget, getOpenAIModelPricing, hasOpenPrompt, invokeRegisteredEffect, isLocalApiUrl, normalizeEffectBehaviors, normalizeOpenAIUsage, normalizePrompt, normalizePromptChoiceOption, normalizePromptText, normalizePromptType, projectConversationReferentFocus, projectConversationReferentSummary, projectHeapSummary, projectLoopSummary, projectSessionFileSummary, projectWorkflowFocus, projectWorkflowSummary, recordOpenAIUsageSpend, resolveApiUrl, resolveAuthTokenForApiUrl, resolveJobPresentation, resolvePromptAnswer, reviewGeneratedJobCode, scorePromptChoiceMatch, stripGranularReasoningTrace, toGranularHttpBase };
+export { Environment, EnvironmentSession, Granular, OPENAI_MODEL_PRICING_USD_PER_MILLION, OntologyHandle, Session, WSClient, buildContinuationInstruction, buildContinuationInstructionFromTemplate, buildGranularAgentCheckpointBlock, buildGranularAgentDomainBlock, buildGranularAgentFileBlock, buildGranularAgentHeapBlock, buildGranularAgentLoopBlock, buildGranularAgentReferentBlock, buildGranularAgentRuntimeImportsBlock, buildGranularAgentSessionBlock, buildGranularAgentSystemPrompt, buildGranularAgentSystemPromptFromTemplate, buildGranularAgentToolBlock, buildGranularAgentWorkflowBlock, buildOpenAISpendEventId, buildSessionTranscript, calculateOpenAITokenSpend, consumeGranularReasoningOnlyChunk, consumeGranularReasoningTraceChunk, createHarnessVerifierSnapshot, evaluateContinuation, extractPromptTokens, getCurrentClosureId, getDefaultHarnessTemplateId, getExclusivePromptTarget, getOpenAIModelPricing, hasOpenPrompt, hashHarnessTemplateValue, invokeRegisteredEffect, isLocalApiUrl, listHarnessTemplates, normalizeEffectBehaviors, normalizeOpenAIUsage, normalizePrompt, normalizePromptChoiceOption, normalizePromptText, normalizePromptType, projectConversationReferentFocus, projectConversationReferentSummary, projectHeapSummary, projectLoopSummary, projectSessionFileSummary, projectWorkflowFocus, projectWorkflowSummary, recordOpenAIUsageSpend, renderContinuationInstructionFromTemplate, renderGranularAgentSystemPromptFromTemplate, resolveApiUrl, resolveAuthTokenForApiUrl, resolveHarnessTemplate, resolveJobPresentation, resolvePromptAnswer, reviewGeneratedJobCode, scorePromptChoiceMatch, stripGranularReasoningTrace, toGranularHttpBase, validateHarnessTemplateManifest };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map