@get-bb/plugin-sdk 0.4.94 → 0.4.97

package/dist/provider-bridge-acp.js

@@ -1,3 +1,544 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/debug.js
+var require_debug = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/debug.js"(exports, module) {
+    "use strict";
+    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+    };
+    module.exports = debug;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js
+var require_constants = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js"(exports, module) {
+    "use strict";
+    var SEMVER_SPEC_VERSION = "2.0.0";
+    var MAX_LENGTH = 256;
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991;
+    var MAX_SAFE_COMPONENT_LENGTH = 16;
+    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+    var RELEASE_TYPES = [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ];
+    module.exports = {
+      MAX_LENGTH,
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_SAFE_INTEGER,
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 1,
+      FLAG_LOOSE: 2
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/re.js
+var require_re = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/re.js"(exports, module) {
+    "use strict";
+    var {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = require_constants();
+    var debug = require_debug();
+    exports = module.exports = {};
+    var re = exports.re = [];
+    var safeRe = exports.safeRe = [];
+    var src = exports.src = [];
+    var safeSrc = exports.safeSrc = [];
+    var t = exports.t = {};
+    var R = 0;
+    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    var safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ];
+    var makeSafeRegex = (value) => {
+      for (const [token, max] of safeRegexReplacements) {
+        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+      }
+      return value;
+    };
+    var createToken = (name, value, isGlobal) => {
+      const safe = makeSafeRegex(value);
+      const index = R++;
+      debug(name, index, value);
+      t[name] = index;
+      src[index] = value;
+      safeSrc[index] = safe;
+      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+    };
+    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+    createToken("COERCERTL", src[t.COERCE], true);
+    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+    createToken("LONETILDE", "(?:~>?)");
+    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+    exports.tildeTrimReplace = "$1~";
+    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("LONECARET", "(?:\\^)");
+    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+    exports.caretTrimReplace = "$1^";
+    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+    exports.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/parse-options.js
+var require_parse_options = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/parse-options.js"(exports, module) {
+    "use strict";
+    var looseOption = Object.freeze({ loose: true });
+    var emptyOpts = Object.freeze({});
+    var parseOptions = (options) => {
+      if (!options) {
+        return emptyOpts;
+      }
+      if (typeof options !== "object") {
+        return looseOption;
+      }
+      return options;
+    };
+    module.exports = parseOptions;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/identifiers.js"(exports, module) {
+    "use strict";
+    var numeric = /^[0-9]+$/;
+    var compareIdentifiers = (a, b) => {
+      if (typeof a === "number" && typeof b === "number") {
+        return a === b ? 0 : a < b ? -1 : 1;
+      }
+      const anum = numeric.test(a);
+      const bnum = numeric.test(b);
+      if (anum && bnum) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    };
+    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+    module.exports = {
+      compareIdentifiers,
+      rcompareIdentifiers
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/semver.js
+var require_semver = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/semver.js"(exports, module) {
+    "use strict";
+    var debug = require_debug();
+    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+    var { safeRe: re, t } = require_re();
+    var parseOptions = require_parse_options();
+    var { compareIdentifiers } = require_identifiers();
+    var isPrereleaseIdentifier = (prerelease, identifier) => {
+      const identifiers = identifier.split(".");
+      if (identifiers.length > prerelease.length) {
+        return false;
+      }
+      for (let i = 0; i < identifiers.length; i++) {
+        if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var SemVer = class _SemVer {
+      constructor(version, options) {
+        options = parseOptions(options);
+        if (version instanceof _SemVer) {
+          if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+            return version;
+          } else {
+            version = version.version;
+          }
+        } else if (typeof version !== "string") {
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+        }
+        if (version.length > MAX_LENGTH) {
+          throw new TypeError(
+            `version is longer than ${MAX_LENGTH} characters`
+          );
+        }
+        debug("SemVer", version, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        if (!m) {
+          throw new TypeError(`Invalid Version: ${version}`);
+        }
+        this.raw = version;
+        this.major = +m[1];
+        this.minor = +m[2];
+        this.patch = +m[3];
+        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+          throw new TypeError("Invalid major version");
+        }
+        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+          throw new TypeError("Invalid minor version");
+        }
+        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+          throw new TypeError("Invalid patch version");
+        }
+        if (!m[4]) {
+          this.prerelease = [];
+        } else {
+          this.prerelease = m[4].split(".").map((id) => {
+            if (/^[0-9]+$/.test(id)) {
+              const num = +id;
+              if (num >= 0 && num < MAX_SAFE_INTEGER) {
+                return num;
+              }
+            }
+            return id;
+          });
+        }
+        this.build = m[5] ? m[5].split(".") : [];
+        this.format();
+      }
+      format() {
+        this.version = `${this.major}.${this.minor}.${this.patch}`;
+        if (this.prerelease.length) {
+          this.version += `-${this.prerelease.join(".")}`;
+        }
+        return this.version;
+      }
+      toString() {
+        return this.version;
+      }
+      compare(other) {
+        debug("SemVer.compare", this.version, this.options, other);
+        if (!(other instanceof _SemVer)) {
+          if (typeof other === "string" && other === this.version) {
+            return 0;
+          }
+          other = new _SemVer(other, this.options);
+        }
+        if (other.version === this.version) {
+          return 0;
+        }
+        return this.compareMain(other) || this.comparePre(other);
+      }
+      compareMain(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.major < other.major) {
+          return -1;
+        }
+        if (this.major > other.major) {
+          return 1;
+        }
+        if (this.minor < other.minor) {
+          return -1;
+        }
+        if (this.minor > other.minor) {
+          return 1;
+        }
+        if (this.patch < other.patch) {
+          return -1;
+        }
+        if (this.patch > other.patch) {
+          return 1;
+        }
+        return 0;
+      }
+      comparePre(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.prerelease.length && !other.prerelease.length) {
+          return -1;
+        } else if (!this.prerelease.length && other.prerelease.length) {
+          return 1;
+        } else if (!this.prerelease.length && !other.prerelease.length) {
+          return 0;
+        }
+        let i = 0;
+        do {
+          const a = this.prerelease[i];
+          const b = other.prerelease[i];
+          debug("prerelease compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      compareBuild(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        let i = 0;
+        do {
+          const a = this.build[i];
+          const b = other.build[i];
+          debug("build compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      // preminor will bump the version up to the next minor release, and immediately
+      // down to pre-release. premajor and prepatch work the same way.
+      inc(release, identifier, identifierBase) {
+        if (release.startsWith("pre")) {
+          if (!identifier && identifierBase === false) {
+            throw new Error("invalid increment argument: identifier is empty");
+          }
+          if (identifier) {
+            const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+            if (!match || match[1] !== identifier) {
+              throw new Error(`invalid identifier: ${identifier}`);
+            }
+          }
+        }
+        switch (release) {
+          case "premajor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor = 0;
+            this.major++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "preminor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "prepatch":
+            this.prerelease.length = 0;
+            this.inc("patch", identifier, identifierBase);
+            this.inc("pre", identifier, identifierBase);
+            break;
+          // If the input is a non-prerelease version, this acts the same as
+          // prepatch.
+          case "prerelease":
+            if (this.prerelease.length === 0) {
+              this.inc("patch", identifier, identifierBase);
+            }
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "release":
+            if (this.prerelease.length === 0) {
+              throw new Error(`version ${this.raw} is not a prerelease`);
+            }
+            this.prerelease.length = 0;
+            break;
+          case "major":
+            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+              this.major++;
+            }
+            this.minor = 0;
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "minor":
+            if (this.patch !== 0 || this.prerelease.length === 0) {
+              this.minor++;
+            }
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "patch":
+            if (this.prerelease.length === 0) {
+              this.patch++;
+            }
+            this.prerelease = [];
+            break;
+          // This probably shouldn't be used publicly.
+          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+          case "pre": {
+            const base = Number(identifierBase) ? 1 : 0;
+            if (this.prerelease.length === 0) {
+              this.prerelease = [base];
+            } else {
+              let i = this.prerelease.length;
+              while (--i >= 0) {
+                if (typeof this.prerelease[i] === "number") {
+                  this.prerelease[i]++;
+                  i = -2;
+                }
+              }
+              if (i === -1) {
+                if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                  throw new Error("invalid increment argument: identifier already exists");
+                }
+                this.prerelease.push(base);
+              }
+            }
+            if (identifier) {
+              let prerelease = [identifier, base];
+              if (identifierBase === false) {
+                prerelease = [identifier];
+              }
+              if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+                const prereleaseBase = this.prerelease[identifier.split(".").length];
+                if (isNaN(prereleaseBase)) {
+                  this.prerelease = prerelease;
+                }
+              } else {
+                this.prerelease = prerelease;
+              }
+            }
+            break;
+          }
+          default:
+            throw new Error(`invalid increment argument: ${release}`);
+        }
+        this.raw = this.format();
+        if (this.build.length) {
+          this.raw += `+${this.build.join(".")}`;
+        }
+        return this;
+      }
+    };
+    module.exports = SemVer;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare.js
+var require_compare = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    module.exports = compare;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/parse.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse = (version, options, throwErrors = false) => {
+      if (version instanceof SemVer) {
+        return version;
+      }
+      try {
+        return new SemVer(version, options);
+      } catch (er) {
+        if (!throwErrors) {
+          return null;
+        }
+        throw er;
+      }
+    };
+    module.exports = parse;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/valid.js
+var require_valid = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/valid.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var valid = (version, options) => {
+      const v = parse(version, options);
+      return v ? v.version : null;
+    };
+    module.exports = valid;
+  }
+});
+
 // ../domain/src/context-snapshot.ts
 import { z } from "zod";
 var tokenCountSchema = z.number().int().nonnegative();
@@ -625,8 +1166,13 @@ var providerNativeRootSetSchema = z5.object({
   resolved: providerResolvedNativeRootsSchema
 }).strict();
 
-// ../domain/src/background-task.ts
+// ../domain/src/completed-turn-display.ts
 import { z as z6 } from "zod";
+var COMPLETED_TURN_DISPLAY_VALUES = ["collapse", "flat"];
+var completedTurnDisplaySchema = z6.enum(COMPLETED_TURN_DISPLAY_VALUES);
+
+// ../domain/src/background-task.ts
+import { z as z7 } from "zod";
 var backgroundTaskStatusValues = [
   "pending",
   "running",
@@ -636,7 +1182,7 @@ var backgroundTaskStatusValues = [
   "killed",
   "stopped"
 ];
-var backgroundTaskStatusSchema = z6.enum(backgroundTaskStatusValues);
+var backgroundTaskStatusSchema = z7.enum(backgroundTaskStatusValues);
 var workflowAgentStateValues = [
   "queued",
   "running",
@@ -644,53 +1190,53 @@ var workflowAgentStateValues = [
   "failed",
   "skipped"
 ];
-var workflowAgentStateSchema = z6.enum(workflowAgentStateValues);
-var workflowAgentSnapshotSchema = z6.object({
-  index: z6.number().int().positive(),
-  label: z6.string(),
+var workflowAgentStateSchema = z7.enum(workflowAgentStateValues);
+var workflowAgentSnapshotSchema = z7.object({
+  index: z7.number().int().positive(),
+  label: z7.string(),
   state: workflowAgentStateSchema,
-  model: z6.string(),
-  attempt: z6.number().int().positive(),
-  cached: z6.boolean(),
-  lastProgressAt: z6.number(),
-  phaseIndex: z6.number().int().positive().optional(),
-  phaseTitle: z6.string().optional(),
-  agentType: z6.string().optional(),
-  isolation: z6.string().optional(),
-  queuedAt: z6.number().optional(),
-  startedAt: z6.number().optional(),
-  lastToolName: z6.string().optional(),
-  lastToolSummary: z6.string().optional(),
-  promptPreview: z6.string().optional(),
-  resultPreview: z6.string().optional(),
-  error: z6.string().optional(),
-  tokens: z6.number().optional(),
-  toolCalls: z6.number().optional(),
-  durationMs: z6.number().optional()
-});
-var workflowPhaseSnapshotSchema = z6.object({
-  index: z6.number().int().positive(),
-  title: z6.string(),
-  kind: z6.string().optional()
-});
-var workflowProgressSnapshotSchema = z6.object({
-  phases: z6.array(workflowPhaseSnapshotSchema),
-  agents: z6.array(workflowAgentSnapshotSchema)
-});
-var backgroundTaskUsageSchema = z6.object({
-  totalTokens: z6.number(),
-  toolUses: z6.number(),
-  durationMs: z6.number()
+  model: z7.string(),
+  attempt: z7.number().int().positive(),
+  cached: z7.boolean(),
+  lastProgressAt: z7.number(),
+  phaseIndex: z7.number().int().positive().optional(),
+  phaseTitle: z7.string().optional(),
+  agentType: z7.string().optional(),
+  isolation: z7.string().optional(),
+  queuedAt: z7.number().optional(),
+  startedAt: z7.number().optional(),
+  lastToolName: z7.string().optional(),
+  lastToolSummary: z7.string().optional(),
+  promptPreview: z7.string().optional(),
+  resultPreview: z7.string().optional(),
+  error: z7.string().optional(),
+  tokens: z7.number().optional(),
+  toolCalls: z7.number().optional(),
+  durationMs: z7.number().optional()
+});
+var workflowPhaseSnapshotSchema = z7.object({
+  index: z7.number().int().positive(),
+  title: z7.string(),
+  kind: z7.string().optional()
+});
+var workflowProgressSnapshotSchema = z7.object({
+  phases: z7.array(workflowPhaseSnapshotSchema),
+  agents: z7.array(workflowAgentSnapshotSchema)
+});
+var backgroundTaskUsageSchema = z7.object({
+  totalTokens: z7.number(),
+  toolUses: z7.number(),
+  durationMs: z7.number()
 });
 
 // ../domain/src/provider-event.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // ../domain/src/thread-events.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // ../domain/src/pending-interactions.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // ../domain/src/plugin-interaction-limits.ts
 var PLUGIN_INTERACTION_MAX_TITLE_LENGTH = 160;
@@ -700,223 +1246,223 @@ function jsonByteLength(value) {
 }
 
 // ../domain/src/item-presentation.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH = 280;
-var threadEventItemPresentationLabelSchema = z7.object({
-  pending: z7.string().min(1),
-  completed: z7.string().min(1)
+var threadEventItemPresentationLabelSchema = z8.object({
+  pending: z8.string().min(1),
+  completed: z8.string().min(1)
 });
-var threadEventItemPresentationIconSchema = z7.object({
-  glyph: z7.string().min(1)
+var threadEventItemPresentationIconSchema = z8.object({
+  glyph: z8.string().min(1)
 });
-var threadEventItemPresentationTintSchema = z7.object({
-  light: z7.string().min(1),
-  dark: z7.string().min(1)
+var threadEventItemPresentationTintSchema = z8.object({
+  light: z8.string().min(1),
+  dark: z8.string().min(1)
 });
 var THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH = 80;
-var threadEventItemPresentationBadgeSchema = z7.object({
-  glyph: z7.string().min(1),
-  label: z7.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
-  hint: z7.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
-  tone: z7.enum(["neutral", "destructive"])
+var threadEventItemPresentationBadgeSchema = z8.object({
+  glyph: z8.string().min(1),
+  label: z8.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  hint: z8.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  tone: z8.enum(["neutral", "destructive"])
 });
-var threadEventItemPresentationSchema = z7.object({
+var threadEventItemPresentationSchema = z8.object({
   label: threadEventItemPresentationLabelSchema,
   icon: threadEventItemPresentationIconSchema,
-  title: z7.string().optional(),
-  detail: z7.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
-  suppress: z7.boolean().optional(),
+  title: z8.string().optional(),
+  detail: z8.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
+  suppress: z8.boolean().optional(),
   tint: threadEventItemPresentationTintSchema.optional(),
   badge: threadEventItemPresentationBadgeSchema.optional()
 });
 
 // ../domain/src/provider-extension-kind.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var EXTENSION_KIND_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
 function isExtensionKind(value) {
   return EXTENSION_KIND_PATTERN.test(value);
 }
-var extensionKindSchema = z8.string().refine(isExtensionKind, {
+var extensionKindSchema = z9.string().refine(isExtensionKind, {
   message: 'extension kinds are "<pluginId>/<name>" (lowercase letters, digits, and "-")'
 });
 
 // ../domain/src/pending-interactions.ts
-var pendingInteractionStatusSchema = z9.enum([
+var pendingInteractionStatusSchema = z10.enum([
   "pending",
   "resolving",
   "resolved",
   "interrupted"
 ]);
-var pendingInteractionCommandActionSchema = z9.discriminatedUnion(
+var pendingInteractionCommandActionSchema = z10.discriminatedUnion(
   "type",
   [
-    z9.object({
-      type: z9.literal("read"),
-      command: z9.string(),
-      name: z9.string(),
-      path: z9.string()
+    z10.object({
+      type: z10.literal("read"),
+      command: z10.string(),
+      name: z10.string(),
+      path: z10.string()
     }),
-    z9.object({
-      type: z9.literal("listFiles"),
-      command: z9.string(),
-      path: z9.string().nullable()
+    z10.object({
+      type: z10.literal("listFiles"),
+      command: z10.string(),
+      path: z10.string().nullable()
     }),
-    z9.object({
-      type: z9.literal("search"),
-      command: z9.string(),
-      query: z9.string().nullable(),
-      path: z9.string().nullable()
+    z10.object({
+      type: z10.literal("search"),
+      command: z10.string(),
+      query: z10.string().nullable(),
+      path: z10.string().nullable()
     }),
-    z9.object({
-      type: z9.literal("unknown"),
-      command: z9.string()
+    z10.object({
+      type: z10.literal("unknown"),
+      command: z10.string()
     })
   ]
 );
-var pendingInteractionNetworkPermissionsSchema = z9.object({
-  enabled: z9.boolean().nullable()
+var pendingInteractionNetworkPermissionsSchema = z10.object({
+  enabled: z10.boolean().nullable()
 });
-var pendingInteractionFileSystemPermissionsSchema = z9.object({
-  read: z9.array(z9.string()),
-  write: z9.array(z9.string())
+var pendingInteractionFileSystemPermissionsSchema = z10.object({
+  read: z10.array(z10.string()),
+  write: z10.array(z10.string())
 });
-var pendingInteractionMacOsPreferencesPermissionSchema = z9.enum([
+var pendingInteractionMacOsPreferencesPermissionSchema = z10.enum([
   "none",
   "read_only",
   "read_write"
 ]);
-var pendingInteractionMacOsContactsPermissionSchema = z9.enum([
+var pendingInteractionMacOsContactsPermissionSchema = z10.enum([
   "none",
   "read_only",
   "read_write"
 ]);
-var pendingInteractionMacOsAutomationPermissionSchema = z9.union([
-  z9.literal("none"),
-  z9.literal("all"),
-  z9.object({
-    kind: z9.literal("bundle_ids"),
-    bundleIds: z9.array(z9.string())
+var pendingInteractionMacOsAutomationPermissionSchema = z10.union([
+  z10.literal("none"),
+  z10.literal("all"),
+  z10.object({
+    kind: z10.literal("bundle_ids"),
+    bundleIds: z10.array(z10.string())
   })
 ]);
-var pendingInteractionMacOsPermissionsSchema = z9.object({
+var pendingInteractionMacOsPermissionsSchema = z10.object({
   preferences: pendingInteractionMacOsPreferencesPermissionSchema,
   automations: pendingInteractionMacOsAutomationPermissionSchema,
-  launchServices: z9.boolean(),
-  accessibility: z9.boolean(),
-  calendar: z9.boolean(),
-  reminders: z9.boolean(),
+  launchServices: z10.boolean(),
+  accessibility: z10.boolean(),
+  calendar: z10.boolean(),
+  reminders: z10.boolean(),
   contacts: pendingInteractionMacOsContactsPermissionSchema
 });
-var pendingInteractionRequestedPermissionProfileSchema = z9.object({
+var pendingInteractionRequestedPermissionProfileSchema = z10.object({
   network: pendingInteractionNetworkPermissionsSchema.nullable(),
   fileSystem: pendingInteractionFileSystemPermissionsSchema.nullable(),
   macos: pendingInteractionMacOsPermissionsSchema.nullable()
 });
-var pendingInteractionGrantablePermissionProfileSchema = z9.object({
+var pendingInteractionGrantablePermissionProfileSchema = z10.object({
   network: pendingInteractionNetworkPermissionsSchema.nullable(),
   fileSystem: pendingInteractionFileSystemPermissionsSchema.nullable()
 }).strict();
 var pendingInteractionGrantedPermissionProfileSchema = pendingInteractionGrantablePermissionProfileSchema;
-var pendingInteractionApprovalDecisionSchema = z9.enum([
+var pendingInteractionApprovalDecisionSchema = z10.enum([
   "allow_once",
   "allow_for_session",
   "deny"
 ]);
-var pendingInteractionFileChangeWriteScopeSchema = z9.string().min(1);
-var pendingInteractionCommandApprovalSubjectSchema = z9.object({
-  kind: z9.literal("command"),
-  itemId: z9.string().min(1),
-  command: z9.string().min(1),
-  cwd: z9.string().nullable(),
-  actions: z9.array(pendingInteractionCommandActionSchema),
+var pendingInteractionFileChangeWriteScopeSchema = z10.string().min(1);
+var pendingInteractionCommandApprovalSubjectSchema = z10.object({
+  kind: z10.literal("command"),
+  itemId: z10.string().min(1),
+  command: z10.string().min(1),
+  cwd: z10.string().nullable(),
+  actions: z10.array(pendingInteractionCommandActionSchema),
   sessionGrant: pendingInteractionGrantablePermissionProfileSchema.nullable()
 });
-var pendingInteractionFileChangeApprovalSubjectSchema = z9.object({
-  kind: z9.literal("file_change"),
-  itemId: z9.string().min(1),
+var pendingInteractionFileChangeApprovalSubjectSchema = z10.object({
+  kind: z10.literal("file_change"),
+  itemId: z10.string().min(1),
   writeScope: pendingInteractionFileChangeWriteScopeSchema.nullable(),
   sessionGrant: pendingInteractionGrantablePermissionProfileSchema.nullable()
 });
-var pendingInteractionPermissionGrantApprovalSubjectSchema = z9.object({
-  kind: z9.literal("permission_grant"),
-  itemId: z9.string().min(1),
-  toolName: z9.string().nullable(),
+var pendingInteractionPermissionGrantApprovalSubjectSchema = z10.object({
+  kind: z10.literal("permission_grant"),
+  itemId: z10.string().min(1),
+  toolName: z10.string().nullable(),
   permissions: pendingInteractionGrantablePermissionProfileSchema
 });
-var pendingInteractionPlanApprovalSubjectSchema = z9.object({
-  kind: z9.literal("plan"),
-  itemId: z9.string().min(1),
-  plan: z9.string().min(1),
-  planFilePath: z9.string().min(1).nullable()
+var pendingInteractionPlanApprovalSubjectSchema = z10.object({
+  kind: z10.literal("plan"),
+  itemId: z10.string().min(1),
+  plan: z10.string().min(1),
+  planFilePath: z10.string().min(1).nullable()
 });
-var pendingInteractionToolUseApprovalSubjectSchema = z9.object({
-  kind: z9.literal("tool_use"),
-  itemId: z9.string().min(1),
-  tool: z9.string().min(1),
+var pendingInteractionToolUseApprovalSubjectSchema = z10.object({
+  kind: z10.literal("tool_use"),
+  itemId: z10.string().min(1),
+  tool: z10.string().min(1),
   presentation: threadEventItemPresentationSchema
 });
-var pendingInteractionApprovalSubjectSchema = z9.discriminatedUnion("kind", [
+var pendingInteractionApprovalSubjectSchema = z10.discriminatedUnion("kind", [
   pendingInteractionCommandApprovalSubjectSchema,
   pendingInteractionFileChangeApprovalSubjectSchema,
   pendingInteractionPermissionGrantApprovalSubjectSchema,
   pendingInteractionPlanApprovalSubjectSchema,
   pendingInteractionToolUseApprovalSubjectSchema
 ]);
-var approvalPendingInteractionPayloadSchema = z9.object({
-  kind: z9.literal("approval"),
+var approvalPendingInteractionPayloadSchema = z10.object({
+  kind: z10.literal("approval"),
   subject: pendingInteractionApprovalSubjectSchema,
-  reason: z9.string().nullable(),
-  availableDecisions: z9.array(pendingInteractionApprovalDecisionSchema).min(1)
+  reason: z10.string().nullable(),
+  availableDecisions: z10.array(pendingInteractionApprovalDecisionSchema).min(1)
 });
 var USER_QUESTION_MAX_QUESTIONS = 4;
 var USER_QUESTION_MAX_OPTIONS = 4;
 var USER_QUESTION_MAX_SELECTED = 4;
 var USER_QUESTION_MAX_FREE_TEXT_LENGTH = 4096;
-var pendingInteractionUserQuestionIdSchema = z9.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionIdSchema = z10.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question ids cannot be blank"
 });
-var pendingInteractionUserQuestionPromptSchema = z9.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionPromptSchema = z10.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question prompts cannot be blank"
 });
-var pendingInteractionUserQuestionShortLabelSchema = z9.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionShortLabelSchema = z10.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question short labels cannot be blank"
 });
-var pendingInteractionUserQuestionOptionValueSchema = z9.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionOptionValueSchema = z10.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question option values cannot be blank"
 });
-var pendingInteractionUserQuestionOptionLabelSchema = z9.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionOptionLabelSchema = z10.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question option labels cannot be blank"
 });
-var pendingInteractionUserQuestionOptionDescriptionSchema = z9.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionOptionDescriptionSchema = z10.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question option descriptions cannot be blank"
 });
-var pendingInteractionUserQuestionFreeTextSchema = z9.string().min(1).max(
+var pendingInteractionUserQuestionFreeTextSchema = z10.string().min(1).max(
   USER_QUESTION_MAX_FREE_TEXT_LENGTH,
   `User question free text cannot exceed ${USER_QUESTION_MAX_FREE_TEXT_LENGTH} characters`
 ).refine((value) => value.trim().length > 0, {
   message: "User question free text cannot be blank"
 });
-var pendingInteractionUserQuestionOptionSchema = z9.object({
+var pendingInteractionUserQuestionOptionSchema = z10.object({
   value: pendingInteractionUserQuestionOptionValueSchema,
   label: pendingInteractionUserQuestionOptionLabelSchema,
   description: pendingInteractionUserQuestionOptionDescriptionSchema.optional()
 });
-var pendingInteractionUserQuestionQuestionSchema = z9.object({
+var pendingInteractionUserQuestionQuestionSchema = z10.object({
   id: pendingInteractionUserQuestionIdSchema,
   prompt: pendingInteractionUserQuestionPromptSchema,
   shortLabel: pendingInteractionUserQuestionShortLabelSchema.optional(),
-  multiSelect: z9.boolean(),
-  options: z9.array(pendingInteractionUserQuestionOptionSchema).max(
+  multiSelect: z10.boolean(),
+  options: z10.array(pendingInteractionUserQuestionOptionSchema).max(
     USER_QUESTION_MAX_OPTIONS,
     `User questions cannot include more than ${USER_QUESTION_MAX_OPTIONS} options`
   ).optional(),
-  allowFreeText: z9.boolean()
+  allowFreeText: z10.boolean()
 }).superRefine((question, context) => {
   const optionValues = /* @__PURE__ */ new Set();
   question.options?.forEach((option, index) => {
     if (optionValues.has(option.value)) {
       context.addIssue({
-        code: z9.ZodIssueCode.custom,
+        code: z10.ZodIssueCode.custom,
         message: "User question option values must be unique",
         path: ["options", index, "value"]
       });
@@ -931,9 +1477,9 @@ var pendingInteractionUserQuestionQuestionSchema = z9.object({
     path: ["options"]
   }
 );
-var userQuestionPendingInteractionPayloadSchema = z9.object({
-  kind: z9.literal("user_question"),
-  questions: z9.array(pendingInteractionUserQuestionQuestionSchema).min(1).max(
+var userQuestionPendingInteractionPayloadSchema = z10.object({
+  kind: z10.literal("user_question"),
+  questions: z10.array(pendingInteractionUserQuestionQuestionSchema).min(1).max(
     USER_QUESTION_MAX_QUESTIONS,
     `User questions cannot include more than ${USER_QUESTION_MAX_QUESTIONS} questions`
   )
@@ -942,7 +1488,7 @@ var userQuestionPendingInteractionPayloadSchema = z9.object({
   payload.questions.forEach((question, index) => {
     if (questionIds.has(question.id)) {
       context.addIssue({
-        code: z9.ZodIssueCode.custom,
+        code: z10.ZodIssueCode.custom,
         message: "User question ids must be unique",
         path: ["questions", index, "id"]
       });
@@ -951,24 +1497,24 @@ var userQuestionPendingInteractionPayloadSchema = z9.object({
     questionIds.add(question.id);
   });
 });
-var pluginPendingInteractionPayloadSchema = z9.object({
-  kind: z9.literal("plugin"),
-  title: z9.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
+var pluginPendingInteractionPayloadSchema = z10.object({
+  kind: z10.literal("plugin"),
+  title: z10.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
   data: jsonValueSchema
 });
-var pluginExtensionInteractionRequestPayloadSchema = z9.object({
+var pluginExtensionInteractionRequestPayloadSchema = z10.object({
   kind: extensionKindSchema,
-  title: z9.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
+  title: z10.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
   data: jsonValueSchema.refine(
     (value) => jsonByteLength(value) <= PLUGIN_INTERACTION_MAX_PAYLOAD_BYTES,
     { message: "Plugin request data exceeds 64 KiB" }
   )
 });
-var interactionRequestPayloadSchema = z9.union([
+var interactionRequestPayloadSchema = z10.union([
   userQuestionPendingInteractionPayloadSchema,
   pluginExtensionInteractionRequestPayloadSchema
 ]);
-var pendingInteractionPayloadSchema = z9.union([
+var pendingInteractionPayloadSchema = z10.union([
   approvalPendingInteractionPayloadSchema,
   userQuestionPendingInteractionPayloadSchema,
   pluginExtensionInteractionRequestPayloadSchema
@@ -977,42 +1523,42 @@ function isApprovalPendingInteractionPayload(payload) {
   return payload.kind === "approval";
 }
 var approvalDecisionDiscriminatorError = "Invalid discriminator value. Expected 'allow_once' | 'allow_for_session' | 'deny'";
-var approvalPendingInteractionResolutionSchema = z9.discriminatedUnion(
+var approvalPendingInteractionResolutionSchema = z10.discriminatedUnion(
   "decision",
   [
-    z9.object({
-      decision: z9.literal("allow_once"),
+    z10.object({
+      decision: z10.literal("allow_once"),
       grantedPermissions: pendingInteractionGrantedPermissionProfileSchema.nullable()
     }),
-    z9.object({
-      decision: z9.literal("allow_for_session"),
+    z10.object({
+      decision: z10.literal("allow_for_session"),
       grantedPermissions: pendingInteractionGrantedPermissionProfileSchema.nullable()
     }),
-    z9.object({
-      decision: z9.literal("deny")
+    z10.object({
+      decision: z10.literal("deny")
     })
   ],
   approvalDecisionDiscriminatorError
 );
-var pendingInteractionUserAnswerSchema = z9.object({
-  selected: z9.array(z9.string().min(1)).max(
+var pendingInteractionUserAnswerSchema = z10.object({
+  selected: z10.array(z10.string().min(1)).max(
     USER_QUESTION_MAX_SELECTED,
     `User question selected choices cannot exceed ${USER_QUESTION_MAX_SELECTED}`
   ),
   freeText: pendingInteractionUserQuestionFreeTextSchema.optional()
 });
-var userQuestionPendingInteractionResolutionSchema = z9.object({
-  kind: z9.literal("user_answer"),
-  answers: z9.record(z9.string().min(1), pendingInteractionUserAnswerSchema)
+var userQuestionPendingInteractionResolutionSchema = z10.object({
+  kind: z10.literal("user_answer"),
+  answers: z10.record(z10.string().min(1), pendingInteractionUserAnswerSchema)
 });
-var pluginPendingInteractionResolutionSchema = z9.object({
-  kind: z9.literal("plugin_submitted")
+var pluginPendingInteractionResolutionSchema = z10.object({
+  kind: z10.literal("plugin_submitted")
 });
-var pluginExtensionInteractionResolutionSchema = z9.object({
-  kind: z9.literal("request_answer"),
+var pluginExtensionInteractionResolutionSchema = z10.object({
+  kind: z10.literal("request_answer"),
   value: jsonValueSchema
 });
-var pendingInteractionResolutionSchema = z9.union(
+var pendingInteractionResolutionSchema = z10.union(
   [
     approvalPendingInteractionResolutionSchema,
     userQuestionPendingInteractionResolutionSchema,
@@ -1024,56 +1570,56 @@ var pendingInteractionResolutionSchema = z9.union(
 function isApprovalPendingInteractionResolution(resolution) {
   return "decision" in resolution;
 }
-var approvalInteractionOutcomeSchema = z9.object({
+var approvalInteractionOutcomeSchema = z10.object({
   payload: approvalPendingInteractionPayloadSchema,
   resolution: approvalPendingInteractionResolutionSchema
 });
-var userQuestionInteractionOutcomeSchema = z9.object({
+var userQuestionInteractionOutcomeSchema = z10.object({
   payload: userQuestionPendingInteractionPayloadSchema,
   resolution: userQuestionPendingInteractionResolutionSchema
 });
-var pluginExtensionInteractionOutcomeSchema = z9.object({
+var pluginExtensionInteractionOutcomeSchema = z10.object({
   payload: pluginExtensionInteractionRequestPayloadSchema,
   resolution: pluginExtensionInteractionResolutionSchema
 });
-var providerInteractionOutcomeSchema = z9.union([
+var providerInteractionOutcomeSchema = z10.union([
   approvalInteractionOutcomeSchema,
   userQuestionInteractionOutcomeSchema,
   pluginExtensionInteractionOutcomeSchema
 ]);
-var pendingInteractionProviderOriginSchema = z9.object({
-  kind: z9.literal("provider"),
-  providerId: z9.string().min(1),
-  providerThreadId: z9.string().min(1),
-  providerRequestId: z9.string().min(1)
-});
-var pendingInteractionPluginOriginSchema = z9.object({
-  kind: z9.literal("plugin"),
-  pluginId: z9.string().min(1),
-  rendererId: z9.string().min(1)
-});
-var pendingInteractionCreateSchema = z9.object({
-  threadId: z9.string().min(1),
-  turnId: z9.string().min(1),
-  providerId: z9.string().min(1),
-  providerThreadId: z9.string().min(1),
-  providerRequestId: z9.string().min(1),
+var pendingInteractionProviderOriginSchema = z10.object({
+  kind: z10.literal("provider"),
+  providerId: z10.string().min(1),
+  providerThreadId: z10.string().min(1),
+  providerRequestId: z10.string().min(1)
+});
+var pendingInteractionPluginOriginSchema = z10.object({
+  kind: z10.literal("plugin"),
+  pluginId: z10.string().min(1),
+  rendererId: z10.string().min(1)
+});
+var pendingInteractionCreateSchema = z10.object({
+  threadId: z10.string().min(1),
+  turnId: z10.string().min(1),
+  providerId: z10.string().min(1),
+  providerThreadId: z10.string().min(1),
+  providerRequestId: z10.string().min(1),
   payload: pendingInteractionPayloadSchema
 });
-var pendingInteractionBaseSchema = z9.object({
-  id: z9.string().min(1),
-  threadId: z9.string().min(1),
+var pendingInteractionBaseSchema = z10.object({
+  id: z10.string().min(1),
+  threadId: z10.string().min(1),
   status: pendingInteractionStatusSchema,
-  statusReason: z9.string().nullable(),
-  createdAt: z9.number().int().nonnegative(),
-  expiresAt: z9.number().int().nonnegative().nullable().optional(),
-  resolvedAt: z9.number().int().nonnegative().nullable()
+  statusReason: z10.string().nullable(),
+  createdAt: z10.number().int().nonnegative(),
+  expiresAt: z10.number().int().nonnegative().nullable().optional(),
+  resolvedAt: z10.number().int().nonnegative().nullable()
 });
 var providerPendingInteractionBaseSchema = pendingInteractionBaseSchema.extend({
-  turnId: z9.string().min(1),
-  providerId: z9.string().min(1),
-  providerThreadId: z9.string().min(1),
-  providerRequestId: z9.string().min(1),
+  turnId: z10.string().min(1),
+  providerId: z10.string().min(1),
+  providerThreadId: z10.string().min(1),
+  providerRequestId: z10.string().min(1),
   origin: pendingInteractionProviderOriginSchema.optional()
 });
 var approvalPendingInteractionSchema = providerPendingInteractionBaseSchema.extend({
@@ -1088,30 +1634,30 @@ var pluginExtensionPendingInteractionSchema = providerPendingInteractionBaseSche
   payload: pluginExtensionInteractionRequestPayloadSchema,
   resolution: pluginExtensionInteractionResolutionSchema.nullable()
 });
-var providerPendingInteractionSchema = z9.union([
+var providerPendingInteractionSchema = z10.union([
   approvalPendingInteractionSchema,
   userQuestionPendingInteractionSchema,
   pluginExtensionPendingInteractionSchema
 ]);
 var pluginPendingInteractionSchema = pendingInteractionBaseSchema.extend({
-  turnId: z9.string().min(1).nullable(),
+  turnId: z10.string().min(1).nullable(),
   origin: pendingInteractionPluginOriginSchema,
   payload: pluginPendingInteractionPayloadSchema,
   resolution: pluginPendingInteractionResolutionSchema.nullable()
 });
-var pendingInteractionSchema = z9.union([
+var pendingInteractionSchema = z10.union([
   providerPendingInteractionSchema,
   pluginPendingInteractionSchema
 ]);
-var interactionLifecycleRecordBaseSchema = z9.object({
-  id: z9.string().min(1),
+var interactionLifecycleRecordBaseSchema = z10.object({
+  id: z10.string().min(1),
   status: pendingInteractionStatusSchema,
-  statusReason: z9.string().nullable()
+  statusReason: z10.string().nullable()
 });
-var interactionLifecycleProviderOriginSchema = z9.object({
-  kind: z9.literal("provider"),
-  providerId: z9.string().min(1),
-  providerRequestId: z9.string().min(1)
+var interactionLifecycleProviderOriginSchema = z10.object({
+  kind: z10.literal("provider"),
+  providerId: z10.string().min(1),
+  providerRequestId: z10.string().min(1)
 });
 var approvalInteractionLifecycleRecordPayloadSchema = approvalPendingInteractionPayloadSchema.omit({ availableDecisions: true });
 var approvalInteractionLifecycleSchema = interactionLifecycleRecordBaseSchema.extend({
@@ -1136,7 +1682,7 @@ var pluginExtensionInteractionLifecycleSchema = interactionLifecycleRecordBaseSc
   }),
   resolution: pluginExtensionInteractionResolutionSchema.omit({ value: true }).nullable()
 });
-var interactionLifecycleSchema = z9.union([
+var interactionLifecycleSchema = z10.union([
   approvalInteractionLifecycleSchema,
   userQuestionInteractionLifecycleSchema,
   pluginInteractionLifecycleSchema,
@@ -1144,11 +1690,11 @@ var interactionLifecycleSchema = z9.union([
 ]);
 
 // ../domain/src/protocol-ids.ts
-import { z as z10 } from "zod";
-var clientTurnRequestIdSchema = z10.string().regex(/^creq_[23456789abcdefghijkmnpqrstuvwxyz]{10}$/u);
+import { z as z11 } from "zod";
+var clientTurnRequestIdSchema = z11.string().regex(/^creq_[23456789abcdefghijkmnpqrstuvwxyz]{10}$/u);
 
 // ../domain/src/system-message.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var systemMessageKindValues = [
   "ownership-assigned",
   "ownership-removed",
@@ -1159,16 +1705,16 @@ var systemMessageKindValues = [
   "child-outcome-batch",
   "unlabeled"
 ];
-var systemMessageKindSchema = z11.enum(systemMessageKindValues);
-var systemMessageSubjectSchema = z11.discriminatedUnion("kind", [
-  z11.object({
-    kind: z11.literal("thread"),
-    threadId: z11.string(),
-    threadName: z11.string()
+var systemMessageKindSchema = z12.enum(systemMessageKindValues);
+var systemMessageSubjectSchema = z12.discriminatedUnion("kind", [
+  z12.object({
+    kind: z12.literal("thread"),
+    threadId: z12.string(),
+    threadName: z12.string()
   }),
-  z11.object({
-    kind: z11.literal("thread-batch"),
-    count: z11.number()
+  z12.object({
+    kind: z12.literal("thread-batch"),
+    count: z12.number()
   })
 ]);
 
@@ -1191,31 +1737,31 @@ var systemEventTypeValues = [
   "system/provider-turn-watchdog"
 ];
 var threadTurnInitiatorValues = ["user", "agent", "system"];
-var threadTurnInitiatorSchema = z12.enum(threadTurnInitiatorValues);
+var threadTurnInitiatorSchema = z13.enum(threadTurnInitiatorValues);
 var turnRequestOptionsSchema = recordedThreadExecutionOptionsSchema;
-var turnRequestTargetSchema = z12.discriminatedUnion("kind", [
-  z12.object({ kind: z12.literal("thread-start") }),
-  z12.object({ kind: z12.literal("new-turn") }),
-  z12.object({
-    kind: z12.literal("auto"),
-    expectedTurnId: z12.string().nullable()
+var turnRequestTargetSchema = z13.discriminatedUnion("kind", [
+  z13.object({ kind: z13.literal("thread-start") }),
+  z13.object({ kind: z13.literal("new-turn") }),
+  z13.object({
+    kind: z13.literal("auto"),
+    expectedTurnId: z13.string().nullable()
   }),
-  z12.object({
-    kind: z12.literal("steer"),
-    expectedTurnId: z12.string().nullable()
+  z13.object({
+    kind: z13.literal("steer"),
+    expectedTurnId: z13.string().nullable()
   })
 ]);
-var clientTurnLifecycleEventDataSchema = z12.object({
-  direction: z12.literal("outbound"),
-  source: z12.enum(["spawn", "tell"]),
+var clientTurnLifecycleEventDataSchema = z13.object({
+  direction: z13.literal("outbound"),
+  source: z13.enum(["spawn", "tell"]),
   initiator: threadTurnInitiatorSchema,
-  request: z12.object({
-    method: z12.enum(["thread/start", "turn/start"]),
-    params: z12.record(z12.string(), z12.unknown())
+  request: z13.object({
+    method: z13.enum(["thread/start", "turn/start"]),
+    params: z13.record(z13.string(), z13.unknown())
   })
 });
-var turnRequestEventDataSchema = z12.object({
-  direction: z12.literal("outbound"),
+var turnRequestEventDataSchema = z13.object({
+  direction: z13.literal("outbound"),
   requestId: clientTurnRequestIdSchema,
   // Retry provenance, written only when a `turn.failed` gate's retry row
   // dispatches. Both fields are present together or not at all: absence means
@@ -1225,45 +1771,45 @@ var turnRequestEventDataSchema = z12.object({
   /** The original request this attempt re-submits, unchanged across attempts. */
   retryOfRequestId: clientTurnRequestIdSchema.optional(),
   /** Which attempt this is: 2 is the first retry of the original request. */
-  retryAttempt: z12.number().int().min(2).optional(),
-  source: z12.enum(["spawn", "tell"]),
+  retryAttempt: z13.number().int().min(2).optional(),
+  source: z13.enum(["spawn", "tell"]),
   initiator: threadTurnInitiatorSchema,
-  senderThreadId: z12.string().nullable(),
+  senderThreadId: z13.string().nullable(),
   systemMessageKind: systemMessageKindSchema.optional(),
   systemMessageSubject: systemMessageSubjectSchema.nullable().optional(),
-  input: z12.array(promptInputSchema),
-  inputGroups: z12.array(z12.array(promptInputSchema).min(1)).min(1).optional(),
+  input: z13.array(promptInputSchema),
+  inputGroups: z13.array(z13.array(promptInputSchema).min(1)).min(1).optional(),
   target: turnRequestTargetSchema,
-  request: z12.object({
-    method: z12.enum(["thread/start", "turn/start"]),
-    params: z12.record(z12.string(), z12.unknown())
+  request: z13.object({
+    method: z13.enum(["thread/start", "turn/start"]),
+    params: z13.record(z13.string(), z13.unknown())
   }),
   execution: turnRequestOptionsSchema
 });
-var turnRequestRejectedEventDataSchema = z12.object({
+var turnRequestRejectedEventDataSchema = z13.object({
   requestId: clientTurnRequestIdSchema,
-  reason: z12.string().min(1),
-  message: z12.string().min(1)
-});
-var systemErrorEventDataSchema = z12.object({
-  code: z12.string().optional(),
-  message: z12.string(),
-  detail: z12.string().optional(),
-  reconnectAttempt: z12.number().int().positive().optional(),
-  reconnectTotal: z12.number().int().positive().optional()
+  reason: z13.string().min(1),
+  message: z13.string().min(1)
+});
+var systemErrorEventDataSchema = z13.object({
+  code: z13.string().optional(),
+  message: z13.string(),
+  detail: z13.string().optional(),
+  reconnectAttempt: z13.number().int().positive().optional(),
+  reconnectTotal: z13.number().int().positive().optional()
 }).superRefine((value, ctx) => {
   const hasReconnectAttempt = value.reconnectAttempt !== void 0;
   const hasReconnectTotal = value.reconnectTotal !== void 0;
   if (hasReconnectAttempt !== hasReconnectTotal) {
     ctx.addIssue({
-      code: z12.ZodIssueCode.custom,
+      code: z13.ZodIssueCode.custom,
       message: "system/error reconnectAttempt and reconnectTotal must be provided together"
     });
     return;
   }
   if (value.reconnectAttempt !== void 0 && value.reconnectTotal !== void 0 && value.reconnectAttempt > value.reconnectTotal) {
     ctx.addIssue({
-      code: z12.ZodIssueCode.custom,
+      code: z13.ZodIssueCode.custom,
       message: "system/error reconnectAttempt cannot be greater than reconnectTotal"
     });
   }
@@ -1273,42 +1819,42 @@ var ownershipChangeOperationActionValues = [
   "release",
   "transfer"
 ];
-var ownershipChangeOperationActionSchema = z12.enum(
+var ownershipChangeOperationActionSchema = z13.enum(
   ownershipChangeOperationActionValues
 );
-var ownershipChangeOperationMetadataSchema = z12.object({
+var ownershipChangeOperationMetadataSchema = z13.object({
   action: ownershipChangeOperationActionSchema,
-  nextParentThreadId: z12.string().nullable(),
-  nextParentThreadTitle: z12.string().nullable(),
-  previousParentThreadId: z12.string().nullable(),
-  previousParentThreadTitle: z12.string().nullable()
-});
-var systemOperationEventDataSchema = z12.object({
-  operation: z12.string(),
-  status: z12.string(),
-  message: z12.string(),
-  operationId: z12.string(),
-  metadata: z12.record(z12.string(), jsonValueSchema).optional()
-});
-var systemInteractionLifecycleEventDataSchema = z12.object({
+  nextParentThreadId: z13.string().nullable(),
+  nextParentThreadTitle: z13.string().nullable(),
+  previousParentThreadId: z13.string().nullable(),
+  previousParentThreadTitle: z13.string().nullable()
+});
+var systemOperationEventDataSchema = z13.object({
+  operation: z13.string(),
+  status: z13.string(),
+  message: z13.string(),
+  operationId: z13.string(),
+  metadata: z13.record(z13.string(), jsonValueSchema).optional()
+});
+var systemInteractionLifecycleEventDataSchema = z13.object({
   interaction: interactionLifecycleSchema
 });
-var systemPermissionGrantLifecycleEventDataSchema = z12.object({
-  interactionId: z12.string(),
-  providerId: z12.string(),
-  providerRequestId: z12.string(),
+var systemPermissionGrantLifecycleEventDataSchema = z13.object({
+  interactionId: z13.string(),
+  providerId: z13.string(),
+  providerRequestId: z13.string(),
   status: pendingInteractionStatusSchema,
   resolution: approvalPendingInteractionResolutionSchema.nullable().default(null),
-  statusReason: z12.string().nullable().default(null),
+  statusReason: z13.string().nullable().default(null),
   subject: pendingInteractionPermissionGrantApprovalSubjectSchema
 });
-var systemUserQuestionLifecycleEventDataSchema = z12.object({
-  interactionId: z12.string(),
-  providerId: z12.string(),
-  providerRequestId: z12.string(),
+var systemUserQuestionLifecycleEventDataSchema = z13.object({
+  interactionId: z13.string(),
+  providerId: z13.string(),
+  providerRequestId: z13.string(),
   status: pendingInteractionStatusSchema,
   resolution: userQuestionPendingInteractionResolutionSchema.nullable().default(null),
-  statusReason: z12.string().nullable().default(null),
+  statusReason: z13.string().nullable().default(null),
   payload: userQuestionPendingInteractionPayloadSchema
 });
 var systemThreadInterruptedReasonValues = [
@@ -1316,20 +1862,20 @@ var systemThreadInterruptedReasonValues = [
   "host-daemon-restarted",
   "provider-turn-idle"
 ];
-var systemThreadInterruptedReasonSchema = z12.enum(
+var systemThreadInterruptedReasonSchema = z13.enum(
   systemThreadInterruptedReasonValues
 );
-var systemThreadInterruptedEventDataSchema = z12.object({
+var systemThreadInterruptedEventDataSchema = z13.object({
   reason: systemThreadInterruptedReasonSchema,
-  cause: z12.literal("host-connection-lost").optional()
+  cause: z13.literal("host-connection-lost").optional()
 });
-var provisioningTranscriptEntrySchema = z12.object({
-  type: z12.enum(["step", "output"]),
-  key: z12.string(),
-  text: z12.string(),
-  startedAt: z12.number().optional(),
-  status: z12.enum(["started", "completed", "failed"]).optional(),
-  metadata: z12.record(z12.string(), z12.unknown()).optional()
+var provisioningTranscriptEntrySchema = z13.object({
+  type: z13.enum(["step", "output"]),
+  key: z13.string(),
+  text: z13.string(),
+  startedAt: z13.number().optional(),
+  status: z13.enum(["started", "completed", "failed"]).optional(),
+  metadata: z13.record(z13.string(), z13.unknown()).optional()
 });
 var systemThreadProvisioningStatusValues = [
   "active",
@@ -1337,48 +1883,48 @@ var systemThreadProvisioningStatusValues = [
   "failed",
   "cancelled"
 ];
-var systemThreadProvisioningStatusSchema = z12.enum(
+var systemThreadProvisioningStatusSchema = z13.enum(
   systemThreadProvisioningStatusValues
 );
-var systemThreadProvisioningEventDataSchema = z12.object({
-  provisioningId: z12.string(),
+var systemThreadProvisioningEventDataSchema = z13.object({
+  provisioningId: z13.string(),
   status: systemThreadProvisioningStatusSchema,
-  environmentId: z12.string().nullable(),
-  entries: z12.array(provisioningTranscriptEntrySchema)
-});
-var systemLegacyUserMessageEventDataSchema = z12.object({
-  text: z12.string(),
-  toolCallId: z12.string().optional(),
-  turnId: z12.string().optional()
-});
-var systemProviderTurnWatchdogEventDataSchema = z12.object({
-  reason: z12.literal("provider-turn-idle"),
-  thresholdMs: z12.number().int().positive(),
-  elapsedMs: z12.number().int().nonnegative(),
-  activeTurnId: z12.string().min(1),
-  activeTurnStartedAt: z12.number().int().nonnegative(),
-  lastActivityEventSequence: z12.number().int().positive(),
-  lastActivityEventType: z12.string().min(1),
-  lastActivityEventAt: z12.number().int().nonnegative(),
-  providerId: z12.string().min(1),
-  providerThreadId: z12.string().min(1).nullable(),
-  firedAt: z12.number().int().nonnegative()
+  environmentId: z13.string().nullable(),
+  entries: z13.array(provisioningTranscriptEntrySchema)
+});
+var systemLegacyUserMessageEventDataSchema = z13.object({
+  text: z13.string(),
+  toolCallId: z13.string().optional(),
+  turnId: z13.string().optional()
+});
+var systemProviderTurnWatchdogEventDataSchema = z13.object({
+  reason: z13.literal("provider-turn-idle"),
+  thresholdMs: z13.number().int().positive(),
+  elapsedMs: z13.number().int().nonnegative(),
+  activeTurnId: z13.string().min(1),
+  activeTurnStartedAt: z13.number().int().nonnegative(),
+  lastActivityEventSequence: z13.number().int().positive(),
+  lastActivityEventType: z13.string().min(1),
+  lastActivityEventAt: z13.number().int().nonnegative(),
+  providerId: z13.string().min(1),
+  providerThreadId: z13.string().min(1).nullable(),
+  firedAt: z13.number().int().nonnegative()
 });
 
 // ../domain/src/thread-event-scope.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var threadEventScopeKindValues = ["thread", "turn"];
-var threadEventScopeKindSchema = z13.enum(threadEventScopeKindValues);
-var threadEventScopeSchema = z13.discriminatedUnion("kind", [
-  z13.object({ kind: z13.literal("thread") }),
-  z13.object({ kind: z13.literal("turn"), turnId: z13.string().min(1) })
+var threadEventScopeKindSchema = z14.enum(threadEventScopeKindValues);
+var threadEventScopeSchema = z14.discriminatedUnion("kind", [
+  z14.object({ kind: z14.literal("thread") }),
+  z14.object({ kind: z14.literal("turn"), turnId: z14.string().min(1) })
 ]);
 var threadEventScopePolicyValues = [
   "thread",
   "turn",
   "thread-or-turn"
 ];
-var threadEventScopePolicySchema = z13.enum(threadEventScopePolicyValues);
+var threadEventScopePolicySchema = z14.enum(threadEventScopePolicyValues);
 var threadEventScopeDefinitionByType = {
   "thread/started": {
     policy: "thread",
@@ -1544,32 +2090,32 @@ function validateThreadEventScope(args) {
 }
 
 // ../domain/src/thread-timeline-goal.ts
-import { z as z14 } from "zod";
-var threadTimelineGoalStatusSchema = z14.enum([
+import { z as z15 } from "zod";
+var threadTimelineGoalStatusSchema = z15.enum([
   "active",
   "paused",
   "budgetLimited",
   "complete"
 ]);
-var threadTimelineGoalSchema = z14.object({
-  sourceSeq: z14.number().int().nonnegative(),
-  updatedAt: z14.number(),
-  objective: z14.string(),
+var threadTimelineGoalSchema = z15.object({
+  sourceSeq: z15.number().int().nonnegative(),
+  updatedAt: z15.number(),
+  objective: z15.string(),
   status: threadTimelineGoalStatusSchema,
-  tokenBudget: z14.number().nullable(),
-  tokensUsed: z14.number(),
-  timeUsedSeconds: z14.number()
+  tokenBudget: z15.number().nullable(),
+  tokensUsed: z15.number(),
+  timeUsedSeconds: z15.number()
 });
 
 // ../domain/src/provider-event.ts
-var threadEventItemStatusSchema = z15.enum([
+var threadEventItemStatusSchema = z16.enum([
   "pending",
   "completed",
   "failed",
   "interrupted"
 ]);
-var threadEventItemApprovalStatusSchema = z15.enum(["waiting_for_approval", "denied"]).nullable();
-var threadEventTurnStatusSchema = z15.enum([
+var threadEventItemApprovalStatusSchema = z16.enum(["waiting_for_approval", "denied"]).nullable();
+var threadEventTurnStatusSchema = z16.enum([
   "completed",
   "failed",
   "interrupted"
@@ -1595,262 +2141,262 @@ var providerErrorCategoryValues = [
   "unauthorized",
   "unknown"
 ];
-var providerErrorCategorySchema = z15.enum(providerErrorCategoryValues);
-var providerErrorInfoSchema = z15.object({
+var providerErrorCategorySchema = z16.enum(providerErrorCategoryValues);
+var providerErrorInfoSchema = z16.object({
   category: providerErrorCategorySchema,
-  providerCode: z15.string().nullable(),
-  httpStatusCode: z15.number().nullable()
+  providerCode: z16.string().nullable(),
+  httpStatusCode: z16.number().nullable()
 });
-var providerRateLimitStatusSchema = z15.enum([
+var providerRateLimitStatusSchema = z16.enum([
   "allowed",
   "warning",
   "blocked",
   "unknown"
 ]);
-var providerRateLimitWindowSchema = z15.object({
-  providerKey: z15.string().min(1).nullable(),
-  label: z15.string().min(1).nullable(),
+var providerRateLimitWindowSchema = z16.object({
+  providerKey: z16.string().min(1).nullable(),
+  label: z16.string().min(1).nullable(),
   status: providerRateLimitStatusSchema,
-  resetsAtMs: z15.number().int().nonnegative().nullable()
+  resetsAtMs: z16.number().int().nonnegative().nullable()
 });
-var providerRateLimitStateSchema = z15.object({
-  providerId: z15.string().min(1),
+var providerRateLimitStateSchema = z16.object({
+  providerId: z16.string().min(1),
   status: providerRateLimitStatusSchema,
-  kind: z15.enum(["subscription-window", "credits", "spend-control", "unknown"]),
-  windows: z15.array(providerRateLimitWindowSchema),
-  reachedReason: z15.string().min(1).nullable(),
-  overageStatus: z15.enum(["allowed", "warning", "rejected", "unavailable"]).nullable(),
-  overageReason: z15.string().min(1).nullable()
-});
-var threadEventFileChangeKindSchema = z15.enum(["add", "delete", "update"]);
-var threadEventFileChangeSchema = z15.object({
-  path: z15.string(),
+  kind: z16.enum(["subscription-window", "credits", "spend-control", "unknown"]),
+  windows: z16.array(providerRateLimitWindowSchema),
+  reachedReason: z16.string().min(1).nullable(),
+  overageStatus: z16.enum(["allowed", "warning", "rejected", "unavailable"]).nullable(),
+  overageReason: z16.string().min(1).nullable()
+});
+var threadEventFileChangeKindSchema = z16.enum(["add", "delete", "update"]);
+var threadEventFileChangeSchema = z16.object({
+  path: z16.string(),
   kind: threadEventFileChangeKindSchema,
-  movePath: z15.string().optional(),
-  diff: z15.string().optional()
+  movePath: z16.string().optional(),
+  diff: z16.string().optional()
 });
-var threadEventPlanStepStatusSchema = z15.enum([
+var threadEventPlanStepStatusSchema = z16.enum([
   "pending",
   "active",
   "completed",
   "failed"
 ]);
-var threadEventPlanStepSchema = z15.object({
-  step: z15.string(),
+var threadEventPlanStepSchema = z16.object({
+  step: z16.string(),
   status: threadEventPlanStepStatusSchema.optional()
 });
 var itemPresentationField = {
   presentation: threadEventItemPresentationSchema.optional()
 };
-var threadEventWebSearchItemSchema = z15.object({
-  type: z15.literal("webSearch"),
-  id: z15.string(),
-  queries: z15.array(z15.string()).min(1),
-  resultText: z15.string().nullable(),
+var threadEventWebSearchItemSchema = z16.object({
+  type: z16.literal("webSearch"),
+  id: z16.string(),
+  queries: z16.array(z16.string()).min(1),
+  resultText: z16.string().nullable(),
   ...itemPresentationField,
-  parentToolCallId: z15.string().optional()
-});
-var threadEventWebFetchItemSchema = z15.object({
-  type: z15.literal("webFetch"),
-  id: z15.string(),
-  url: z15.string(),
-  prompt: z15.string().nullable(),
-  pattern: z15.string().nullable(),
-  resultText: z15.string().nullable(),
+  parentToolCallId: z16.string().optional()
+});
+var threadEventWebFetchItemSchema = z16.object({
+  type: z16.literal("webFetch"),
+  id: z16.string(),
+  url: z16.string(),
+  prompt: z16.string().nullable(),
+  pattern: z16.string().nullable(),
+  resultText: z16.string().nullable(),
   ...itemPresentationField,
-  parentToolCallId: z15.string().optional()
+  parentToolCallId: z16.string().optional()
 });
-var threadEventImageViewItemSchema = z15.object({
-  type: z15.literal("imageView"),
-  id: z15.string(),
-  path: z15.string(),
+var threadEventImageViewItemSchema = z16.object({
+  type: z16.literal("imageView"),
+  id: z16.string(),
+  path: z16.string(),
   ...itemPresentationField,
-  parentToolCallId: z15.string().optional()
+  parentToolCallId: z16.string().optional()
 });
-var threadEventFileReadItemSchema = z15.object({
-  type: z15.literal("fileRead"),
-  id: z15.string(),
-  path: z15.string(),
-  cmd: z15.string().optional(),
+var threadEventFileReadItemSchema = z16.object({
+  type: z16.literal("fileRead"),
+  id: z16.string(),
+  path: z16.string(),
+  cmd: z16.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z15.string().optional()
+  parentToolCallId: z16.string().optional()
 });
-var threadEventSearchModeSchema = z15.enum(["content", "path", "list"]);
-var threadEventSearchItemSchema = z15.object({
-  type: z15.literal("search"),
-  id: z15.string(),
+var threadEventSearchModeSchema = z16.enum(["content", "path", "list"]);
+var threadEventSearchItemSchema = z16.object({
+  type: z16.literal("search"),
+  id: z16.string(),
   mode: threadEventSearchModeSchema,
-  query: z15.string(),
-  path: z15.string().optional(),
-  cmd: z15.string().optional(),
+  query: z16.string(),
+  path: z16.string().optional(),
+  cmd: z16.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z15.string().optional()
+  parentToolCallId: z16.string().optional()
 });
-var threadEventDelegationItemSchema = z15.object({
-  type: z15.literal("delegation"),
-  id: z15.string(),
-  childRef: z15.string().min(1),
-  label: z15.string(),
+var threadEventDelegationItemSchema = z16.object({
+  type: z16.literal("delegation"),
+  id: z16.string(),
+  childRef: z16.string().min(1),
+  label: z16.string(),
   status: threadEventItemStatusSchema,
-  background: z15.boolean(),
-  summary: z15.string().optional(),
+  background: z16.boolean(),
+  summary: z16.string().optional(),
   ...itemPresentationField,
-  parentToolCallId: z15.string().optional()
+  parentToolCallId: z16.string().optional()
 });
-var threadEventPlanStepsItemSchema = z15.object({
-  type: z15.literal("planSteps"),
-  id: z15.string(),
-  steps: z15.array(threadEventPlanStepSchema),
-  explanation: z15.string().optional(),
+var threadEventPlanStepsItemSchema = z16.object({
+  type: z16.literal("planSteps"),
+  id: z16.string(),
+  steps: z16.array(threadEventPlanStepSchema),
+  explanation: z16.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z15.string().optional()
+  parentToolCallId: z16.string().optional()
 });
-var threadEventExtensionItemSchema = z15.object({
-  type: z15.literal("extension"),
-  id: z15.string(),
+var threadEventExtensionItemSchema = z16.object({
+  type: z16.literal("extension"),
+  id: z16.string(),
   kind: extensionKindSchema,
   payload: jsonValueSchema,
   status: threadEventItemStatusSchema,
   presentation: threadEventItemPresentationSchema,
-  parentToolCallId: z15.string().optional()
+  parentToolCallId: z16.string().optional()
 });
-var threadEventTextTruncationSchema = z15.object({
-  originalLength: z15.number(),
-  retainedHeadLength: z15.number(),
-  retainedTailLength: z15.number(),
-  truncatedAt: z15.number()
+var threadEventTextTruncationSchema = z16.object({
+  originalLength: z16.number(),
+  retainedHeadLength: z16.number(),
+  retainedTailLength: z16.number(),
+  truncatedAt: z16.number()
 });
-var threadEventItemTruncationSchema = z15.object({
+var threadEventItemTruncationSchema = z16.object({
   aggregatedOutput: threadEventTextTruncationSchema.optional(),
   result: threadEventTextTruncationSchema.optional(),
   resultText: threadEventTextTruncationSchema.optional()
 });
-var threadEventImageGenerationItemSchema = z15.object({
-  type: z15.literal("imageGeneration"),
-  id: z15.string(),
+var threadEventImageGenerationItemSchema = z16.object({
+  type: z16.literal("imageGeneration"),
+  id: z16.string(),
   status: threadEventItemStatusSchema,
-  prompt: z15.string().nullable(),
-  path: z15.string().nullable(),
-  result: z15.string().optional(),
-  error: z15.string().nullable(),
-  transparentBackground: z15.boolean(),
+  prompt: z16.string().nullable(),
+  path: z16.string().nullable(),
+  result: z16.string().optional(),
+  error: z16.string().nullable(),
+  transparentBackground: z16.boolean(),
   truncation: threadEventItemTruncationSchema.optional(),
   ...itemPresentationField,
-  parentToolCallId: z15.string().optional()
+  parentToolCallId: z16.string().optional()
 });
-var threadEventUserContentSchema = z15.discriminatedUnion("type", [
-  z15.object({ type: z15.literal("text"), text: z15.string() }),
-  z15.object({ type: z15.literal("image"), url: z15.string() }),
-  z15.object({ type: z15.literal("localImage"), path: z15.string() }),
-  z15.object({ type: z15.literal("localFile"), path: z15.string() })
+var threadEventUserContentSchema = z16.discriminatedUnion("type", [
+  z16.object({ type: z16.literal("text"), text: z16.string() }),
+  z16.object({ type: z16.literal("image"), url: z16.string() }),
+  z16.object({ type: z16.literal("localImage"), path: z16.string() }),
+  z16.object({ type: z16.literal("localFile"), path: z16.string() })
 ]);
-var threadEventTokenUsageBreakdownSchema = z15.object({
-  totalTokens: z15.number(),
-  inputTokens: z15.number(),
-  cachedInputTokens: z15.number(),
-  cacheReadInputTokens: z15.number().nonnegative().optional(),
-  cacheWriteInputTokens: z15.number().nonnegative().optional(),
-  outputTokens: z15.number(),
-  reasoningOutputTokens: z15.number()
-});
-var threadEventContextWindowUsageSchema = z15.object({
+var threadEventTokenUsageBreakdownSchema = z16.object({
+  totalTokens: z16.number(),
+  inputTokens: z16.number(),
+  cachedInputTokens: z16.number(),
+  cacheReadInputTokens: z16.number().nonnegative().optional(),
+  cacheWriteInputTokens: z16.number().nonnegative().optional(),
+  outputTokens: z16.number(),
+  reasoningOutputTokens: z16.number()
+});
+var threadEventContextWindowUsageSchema = z16.object({
   snapshot: contextSnapshotSchema.optional(),
-  usedTokens: z15.number().nullable(),
-  modelContextWindow: z15.number().nullable(),
-  estimated: z15.boolean()
+  usedTokens: z16.number().nullable(),
+  modelContextWindow: z16.number().nullable(),
+  estimated: z16.boolean()
 });
-var threadEventTokenUsageSchema = z15.object({
+var threadEventTokenUsageSchema = z16.object({
   total: threadEventTokenUsageBreakdownSchema,
   last: threadEventTokenUsageBreakdownSchema,
-  modelContextWindow: z15.number().nullable()
+  modelContextWindow: z16.number().nullable()
 });
-var threadEventWarningCategorySchema = z15.enum([
+var threadEventWarningCategorySchema = z16.enum([
   "deprecation",
   "config",
   "general",
   "compaction-skipped"
 ]);
-var providerRawEventSchema = z15.object({
-  jsonrpc: z15.literal("2.0"),
-  id: z15.union([z15.string(), z15.number()]).optional(),
-  method: z15.string(),
+var providerRawEventSchema = z16.object({
+  jsonrpc: z16.literal("2.0"),
+  id: z16.union([z16.string(), z16.number()]).optional(),
+  method: z16.string(),
   params: jsonValueSchema.optional()
 });
-var providerUnhandledEventSchema = z15.object({
-  type: z15.literal("provider/unhandled"),
-  threadId: z15.string(),
-  providerThreadId: z15.string(),
-  providerId: z15.string(),
-  rawType: z15.string(),
+var providerUnhandledEventSchema = z16.object({
+  type: z16.literal("provider/unhandled"),
+  threadId: z16.string(),
+  providerThreadId: z16.string(),
+  providerId: z16.string(),
+  rawType: z16.string(),
   rawEvent: providerRawEventSchema,
-  parentToolCallId: z15.string().optional()
-});
-var toolCallProgressEventSchema = z15.object({
-  type: z15.literal("item/toolCall/progress"),
-  threadId: z15.string(),
-  providerThreadId: z15.string(),
-  itemId: z15.string(),
-  message: z15.string().optional(),
-  parentToolCallId: z15.string().optional()
-});
-var threadEventBackgroundTaskItemSchema = z15.object({
-  type: z15.literal("backgroundTask"),
-  id: z15.string(),
-  familyId: z15.string().optional(),
-  taskType: z15.string(),
-  description: z15.string(),
+  parentToolCallId: z16.string().optional()
+});
+var toolCallProgressEventSchema = z16.object({
+  type: z16.literal("item/toolCall/progress"),
+  threadId: z16.string(),
+  providerThreadId: z16.string(),
+  itemId: z16.string(),
+  message: z16.string().optional(),
+  parentToolCallId: z16.string().optional()
+});
+var threadEventBackgroundTaskItemSchema = z16.object({
+  type: z16.literal("backgroundTask"),
+  id: z16.string(),
+  familyId: z16.string().optional(),
+  taskType: z16.string(),
+  description: z16.string(),
   status: threadEventItemStatusSchema,
   taskStatus: backgroundTaskStatusSchema,
-  skipTranscript: z15.boolean(),
-  workflowName: z15.string().optional(),
+  skipTranscript: z16.boolean(),
+  workflowName: z16.string().optional(),
   workflow: workflowProgressSnapshotSchema.optional(),
   usage: backgroundTaskUsageSchema.optional(),
-  summary: z15.string().optional(),
-  error: z15.string().optional(),
-  outputFile: z15.string().optional(),
+  summary: z16.string().optional(),
+  error: z16.string().optional(),
+  outputFile: z16.string().optional(),
   ...itemPresentationField,
-  parentToolCallId: z15.string().optional()
+  parentToolCallId: z16.string().optional()
 });
-var threadEventItemSchema = z15.discriminatedUnion("type", [
-  z15.object({
-    type: z15.literal("userMessage"),
-    id: z15.string(),
-    content: z15.array(threadEventUserContentSchema),
+var threadEventItemSchema = z16.discriminatedUnion("type", [
+  z16.object({
+    type: z16.literal("userMessage"),
+    id: z16.string(),
+    content: z16.array(threadEventUserContentSchema),
     clientRequestId: clientTurnRequestIdSchema.optional(),
-    parentToolCallId: z15.string().optional()
+    parentToolCallId: z16.string().optional()
   }).strict(),
-  z15.object({
-    type: z15.literal("agentMessage"),
-    id: z15.string(),
-    text: z15.string(),
+  z16.object({
+    type: z16.literal("agentMessage"),
+    id: z16.string(),
+    text: z16.string(),
     ...itemPresentationField,
-    parentToolCallId: z15.string().optional()
+    parentToolCallId: z16.string().optional()
   }),
-  z15.object({
-    type: z15.literal("commandExecution"),
-    id: z15.string(),
-    command: z15.string(),
-    cwd: z15.string(),
+  z16.object({
+    type: z16.literal("commandExecution"),
+    id: z16.string(),
+    command: z16.string(),
+    cwd: z16.string(),
     status: threadEventItemStatusSchema,
     approvalStatus: threadEventItemApprovalStatusSchema,
-    aggregatedOutput: z15.string().optional(),
-    exitCode: z15.number().optional(),
-    durationMs: z15.number().optional(),
+    aggregatedOutput: z16.string().optional(),
+    exitCode: z16.number().optional(),
+    durationMs: z16.number().optional(),
     truncation: threadEventItemTruncationSchema.optional(),
     ...itemPresentationField,
-    parentToolCallId: z15.string().optional()
+    parentToolCallId: z16.string().optional()
   }),
-  z15.object({
-    type: z15.literal("fileChange"),
-    id: z15.string(),
-    changes: z15.array(threadEventFileChangeSchema),
+  z16.object({
+    type: z16.literal("fileChange"),
+    id: z16.string(),
+    changes: z16.array(threadEventFileChangeSchema),
     status: threadEventItemStatusSchema,
     approvalStatus: threadEventItemApprovalStatusSchema,
     ...itemPresentationField,
-    parentToolCallId: z15.string().optional()
+    parentToolCallId: z16.string().optional()
   }),
   threadEventWebSearchItemSchema,
   threadEventWebFetchItemSchema,
@@ -1858,264 +2404,264 @@ var threadEventItemSchema = z15.discriminatedUnion("type", [
   threadEventImageGenerationItemSchema,
   threadEventFileReadItemSchema,
   threadEventSearchItemSchema,
-  z15.object({
-    type: z15.literal("toolCall"),
-    id: z15.string(),
-    server: z15.string().optional(),
-    tool: z15.string(),
-    arguments: z15.record(z15.string(), z15.unknown()).optional(),
+  z16.object({
+    type: z16.literal("toolCall"),
+    id: z16.string(),
+    server: z16.string().optional(),
+    tool: z16.string(),
+    arguments: z16.record(z16.string(), z16.unknown()).optional(),
     status: threadEventItemStatusSchema,
-    result: z15.unknown().optional(),
-    error: z15.string().optional(),
-    durationMs: z15.number().optional(),
+    result: z16.unknown().optional(),
+    error: z16.string().optional(),
+    durationMs: z16.number().optional(),
     truncation: threadEventItemTruncationSchema.optional(),
     ...itemPresentationField,
-    parentToolCallId: z15.string().optional()
+    parentToolCallId: z16.string().optional()
   }),
-  z15.object({
-    type: z15.literal("reasoning"),
-    id: z15.string(),
-    summary: z15.array(z15.string()),
-    content: z15.array(z15.string()),
+  z16.object({
+    type: z16.literal("reasoning"),
+    id: z16.string(),
+    summary: z16.array(z16.string()),
+    content: z16.array(z16.string()),
     ...itemPresentationField,
-    parentToolCallId: z15.string().optional()
+    parentToolCallId: z16.string().optional()
   }),
-  z15.object({
-    type: z15.literal("plan"),
-    id: z15.string(),
-    text: z15.string(),
+  z16.object({
+    type: z16.literal("plan"),
+    id: z16.string(),
+    text: z16.string(),
     ...itemPresentationField,
-    parentToolCallId: z15.string().optional()
+    parentToolCallId: z16.string().optional()
   }),
   threadEventPlanStepsItemSchema,
-  z15.object({
-    type: z15.literal("contextCompaction"),
-    id: z15.string(),
+  z16.object({
+    type: z16.literal("contextCompaction"),
+    id: z16.string(),
     ...itemPresentationField,
-    parentToolCallId: z15.string().optional()
+    parentToolCallId: z16.string().optional()
   }),
   threadEventBackgroundTaskItemSchema,
   threadEventDelegationItemSchema,
   threadEventExtensionItemSchema
 ]);
 function itemTextDeltaEventSchema(type) {
-  return z15.object({
-    type: z15.literal(type),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
-    itemId: z15.string(),
-    delta: z15.string(),
-    parentToolCallId: z15.string().optional()
+  return z16.object({
+    type: z16.literal(type),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
+    itemId: z16.string(),
+    delta: z16.string(),
+    parentToolCallId: z16.string().optional()
   });
 }
-var unscopedProviderEventSchema = z15.discriminatedUnion("type", [
-  z15.object({
-    type: z15.literal("thread/started"),
-    threadId: z15.string()
+var unscopedProviderEventSchema = z16.discriminatedUnion("type", [
+  z16.object({
+    type: z16.literal("thread/started"),
+    threadId: z16.string()
   }),
-  z15.object({
-    type: z15.literal("thread/identity"),
-    threadId: z15.string(),
-    providerThreadId: z15.string()
+  z16.object({
+    type: z16.literal("thread/identity"),
+    threadId: z16.string(),
+    providerThreadId: z16.string()
   }),
-  z15.object({
-    type: z15.literal("turn/started"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
-    parentToolCallId: z15.string().optional()
+  z16.object({
+    type: z16.literal("turn/started"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
+    parentToolCallId: z16.string().optional()
   }),
-  z15.object({
-    type: z15.literal("turn/completed"),
-    threadId: z15.string(),
-    providerThreadId: z15.string().nullable(),
+  z16.object({
+    type: z16.literal("turn/completed"),
+    threadId: z16.string(),
+    providerThreadId: z16.string().nullable(),
     status: threadEventTurnStatusSchema,
-    error: z15.object({ message: z15.string() }).optional(),
-    providerCheckpointId: z15.string().min(1).optional()
+    error: z16.object({ message: z16.string() }).optional(),
+    providerCheckpointId: z16.string().min(1).optional()
   }),
-  z15.object({
-    type: z15.literal("turn/input/accepted"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("turn/input/accepted"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     clientRequestId: clientTurnRequestIdSchema,
     scope: threadEventScopeSchema
   }).strict(),
-  z15.object({
-    type: z15.literal("thread/name/updated"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
-    threadName: z15.string()
+  z16.object({
+    type: z16.literal("thread/name/updated"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
+    threadName: z16.string()
   }),
-  z15.object({
-    type: z15.literal("thread/compacted"),
-    threadId: z15.string(),
-    providerThreadId: z15.string()
+  z16.object({
+    type: z16.literal("thread/compacted"),
+    threadId: z16.string(),
+    providerThreadId: z16.string()
   }),
-  z15.object({
-    type: z15.literal("thread/context/cleared"),
-    threadId: z15.string(),
-    providerThreadId: z15.string()
+  z16.object({
+    type: z16.literal("thread/context/cleared"),
+    threadId: z16.string(),
+    providerThreadId: z16.string()
   }),
-  z15.object({
-    type: z15.literal("thread/goal/updated"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
-    objective: z15.string(),
+  z16.object({
+    type: z16.literal("thread/goal/updated"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
+    objective: z16.string(),
     status: threadTimelineGoalStatusSchema,
-    tokenBudget: z15.number().nullable(),
-    tokensUsed: z15.number(),
-    timeUsedSeconds: z15.number()
+    tokenBudget: z16.number().nullable(),
+    tokensUsed: z16.number(),
+    timeUsedSeconds: z16.number()
   }),
-  z15.object({
-    type: z15.literal("thread/goal/cleared"),
-    threadId: z15.string(),
-    providerThreadId: z15.string()
+  z16.object({
+    type: z16.literal("thread/goal/cleared"),
+    threadId: z16.string(),
+    providerThreadId: z16.string()
   }),
-  z15.object({
-    type: z15.literal("item/started"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("item/started"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     item: threadEventItemSchema
   }),
-  z15.object({
-    type: z15.literal("item/completed"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("item/completed"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     item: threadEventItemSchema
   }),
   itemTextDeltaEventSchema("item/agentMessage/delta"),
-  z15.object({
-    type: z15.literal("item/commandExecution/outputDelta"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
-    itemId: z15.string(),
-    delta: z15.string(),
-    reset: z15.boolean().optional(),
-    parentToolCallId: z15.string().optional()
+  z16.object({
+    type: z16.literal("item/commandExecution/outputDelta"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
+    itemId: z16.string(),
+    delta: z16.string(),
+    reset: z16.boolean().optional(),
+    parentToolCallId: z16.string().optional()
   }),
   itemTextDeltaEventSchema("item/fileChange/outputDelta"),
   itemTextDeltaEventSchema("item/reasoning/summaryTextDelta"),
   itemTextDeltaEventSchema("item/reasoning/textDelta"),
   itemTextDeltaEventSchema("item/plan/delta"),
-  z15.object({
-    type: z15.literal("item/mcpToolCall/progress"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
-    itemId: z15.string(),
-    message: z15.string().optional(),
-    parentToolCallId: z15.string().optional()
+  z16.object({
+    type: z16.literal("item/mcpToolCall/progress"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
+    itemId: z16.string(),
+    message: z16.string().optional(),
+    parentToolCallId: z16.string().optional()
   }),
   toolCallProgressEventSchema,
-  z15.object({
-    type: z15.literal("item/backgroundTask/progress"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("item/backgroundTask/progress"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     item: threadEventBackgroundTaskItemSchema
   }),
-  z15.object({
-    type: z15.literal("item/backgroundTask/completed"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("item/backgroundTask/completed"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     item: threadEventBackgroundTaskItemSchema
   }),
-  z15.object({
-    type: z15.literal("item/delegation/progress"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("item/delegation/progress"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     item: threadEventDelegationItemSchema
   }),
-  z15.object({
-    type: z15.literal("item/delegation/completed"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("item/delegation/completed"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     item: threadEventDelegationItemSchema
   }),
-  z15.object({
-    type: z15.literal("thread/tokenUsage/updated"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("thread/tokenUsage/updated"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     tokenUsage: threadEventTokenUsageSchema
   }),
-  z15.object({
-    type: z15.literal("thread/contextWindowUsage/updated"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("thread/contextWindowUsage/updated"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     contextWindowUsage: threadEventContextWindowUsageSchema
   }),
-  z15.object({
-    type: z15.literal("turn/plan/updated"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
-    plan: z15.array(threadEventPlanStepSchema),
-    explanation: z15.string().optional()
+  z16.object({
+    type: z16.literal("turn/plan/updated"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
+    plan: z16.array(threadEventPlanStepSchema),
+    explanation: z16.string().optional()
   }),
-  z15.object({
-    type: z15.literal("turn/diff/updated"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
-    diff: z15.string().optional()
+  z16.object({
+    type: z16.literal("turn/diff/updated"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
+    diff: z16.string().optional()
   }),
-  z15.object({
-    type: z15.literal("provider/error"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
-    message: z15.string(),
-    detail: z15.string().optional(),
-    willRetry: z15.boolean().optional(),
+  z16.object({
+    type: z16.literal("provider/error"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
+    message: z16.string(),
+    detail: z16.string().optional(),
+    willRetry: z16.boolean().optional(),
     errorInfo: providerErrorInfoSchema.optional()
   }),
-  z15.object({
-    type: z15.literal("provider/rateLimits/updated"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("provider/rateLimits/updated"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     rateLimits: providerRateLimitStateSchema
   }),
-  z15.object({
-    type: z15.literal("provider.env-resolved"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
-    entries: z15.array(
-      z15.object({
-        name: z15.string(),
-        source: z15.union([
-          z15.literal("shell"),
-          z15.object({ plugin: z15.string() }).strict(),
-          z15.object({ core: z15.enum(["machine-git", "machine-environment"]) }).strict()
+  z16.object({
+    type: z16.literal("provider.env-resolved"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
+    entries: z16.array(
+      z16.object({
+        name: z16.string(),
+        source: z16.union([
+          z16.literal("shell"),
+          z16.object({ plugin: z16.string() }).strict(),
+          z16.object({ core: z16.enum(["machine-git", "machine-environment"]) }).strict()
         ]),
-        value: z15.union([
-          z15.string(),
-          z15.object({ masked: z15.literal(true) }).strict()
+        value: z16.union([
+          z16.string(),
+          z16.object({ masked: z16.literal(true) }).strict()
         ]),
-        reason: z15.string().optional()
+        reason: z16.string().optional()
       }).strict()
     )
   }),
-  z15.object({
-    type: z15.literal("thread/extensionState/updated"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("thread/extensionState/updated"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     kind: extensionKindSchema,
     payload: jsonValueSchema
   }),
-  z15.object({
-    type: z15.literal("provider/warning"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
+  z16.object({
+    type: z16.literal("provider/warning"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
     category: threadEventWarningCategorySchema,
-    summary: z15.string().optional(),
-    details: z15.string().optional()
+    summary: z16.string().optional(),
+    details: z16.string().optional()
   }),
-  z15.object({
-    type: z15.literal("provider/modelFallback"),
-    threadId: z15.string(),
-    providerThreadId: z15.string(),
-    originalModel: z15.string().min(1),
-    fallbackModel: z15.string().min(1),
-    reason: z15.enum(["refusal", "provider"]),
-    message: z15.string()
+  z16.object({
+    type: z16.literal("provider/modelFallback"),
+    threadId: z16.string(),
+    providerThreadId: z16.string(),
+    originalModel: z16.string().min(1),
+    fallbackModel: z16.string().min(1),
+    reason: z16.enum(["refusal", "provider"]),
+    message: z16.string()
   }),
   providerUnhandledEventSchema
 ]);
-var scopedEventDataSchema = z15.object({
+var scopedEventDataSchema = z16.object({
   scope: threadEventScopeSchema
 });
 var providerEventSchema = unscopedProviderEventSchema.and(
@@ -2124,58 +2670,58 @@ var providerEventSchema = unscopedProviderEventSchema.and(
 var providerEventTypeValues = unscopedProviderEventSchema.options.map(
   (option) => option.shape.type.value
 );
-var unscopedSystemEventSchema = z15.discriminatedUnion("type", [
-  z15.object({
-    type: z15.literal("client/thread/start"),
-    threadId: z15.string()
+var unscopedSystemEventSchema = z16.discriminatedUnion("type", [
+  z16.object({
+    type: z16.literal("client/thread/start"),
+    threadId: z16.string()
   }).merge(clientTurnLifecycleEventDataSchema),
-  z15.object({
-    type: z15.literal("client/turn/requested"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("client/turn/requested"),
+    threadId: z16.string()
   }).merge(turnRequestEventDataSchema),
-  z15.object({
-    type: z15.literal("client/turn/rejected"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("client/turn/rejected"),
+    threadId: z16.string()
   }).merge(turnRequestRejectedEventDataSchema),
-  z15.object({
-    type: z15.literal("client/turn/start"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("client/turn/start"),
+    threadId: z16.string()
   }).merge(clientTurnLifecycleEventDataSchema),
-  z15.object({
-    type: z15.literal("system/error"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("system/error"),
+    threadId: z16.string()
   }).merge(systemErrorEventDataSchema),
-  z15.object({
-    type: z15.literal("system/manager/user_message"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("system/manager/user_message"),
+    threadId: z16.string()
   }).merge(systemLegacyUserMessageEventDataSchema),
-  z15.object({
-    type: z15.literal("system/thread/interrupted"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("system/thread/interrupted"),
+    threadId: z16.string()
   }).merge(systemThreadInterruptedEventDataSchema),
-  z15.object({
-    type: z15.literal("system/operation"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("system/operation"),
+    threadId: z16.string()
   }).merge(systemOperationEventDataSchema),
-  z15.object({
-    type: z15.literal("system/interaction/lifecycle"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("system/interaction/lifecycle"),
+    threadId: z16.string()
   }).merge(systemInteractionLifecycleEventDataSchema),
-  z15.object({
-    type: z15.literal("system/permissionGrant/lifecycle"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("system/permissionGrant/lifecycle"),
+    threadId: z16.string()
   }).merge(systemPermissionGrantLifecycleEventDataSchema),
-  z15.object({
-    type: z15.literal("system/userQuestion/lifecycle"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("system/userQuestion/lifecycle"),
+    threadId: z16.string()
   }).merge(systemUserQuestionLifecycleEventDataSchema),
-  z15.object({
-    type: z15.literal("system/thread-provisioning"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("system/thread-provisioning"),
+    threadId: z16.string()
   }).merge(systemThreadProvisioningEventDataSchema),
-  z15.object({
-    type: z15.literal("system/provider-turn-watchdog"),
-    threadId: z15.string()
+  z16.object({
+    type: z16.literal("system/provider-turn-watchdog"),
+    threadId: z16.string()
   }).merge(systemProviderTurnWatchdogEventDataSchema)
 ]);
 var systemEventSchema = unscopedSystemEventSchema.and(scopedEventDataSchema);
@@ -2183,13 +2729,13 @@ var legacyClientRequestKey = ["clientRequest", "Sequence"].join("");
 function isEventPropertyBag(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var rejectLegacyClientRequestSequenceSchema = z15.unknown().superRefine((value, ctx) => {
+var rejectLegacyClientRequestSequenceSchema = z16.unknown().superRefine((value, ctx) => {
   if (!isEventPropertyBag(value)) {
     return;
   }
   if (Object.hasOwn(value, legacyClientRequestKey)) {
     ctx.addIssue({
-      code: z15.ZodIssueCode.custom,
+      code: z16.ZodIssueCode.custom,
       message: "legacy request sequence field is no longer accepted",
       path: [legacyClientRequestKey]
     });
@@ -2197,21 +2743,21 @@ var rejectLegacyClientRequestSequenceSchema = z15.unknown().superRefine((value,
   const item = value.item;
   if (isEventPropertyBag(item) && item.type === "userMessage" && Object.hasOwn(item, legacyClientRequestKey)) {
     ctx.addIssue({
-      code: z15.ZodIssueCode.custom,
+      code: z16.ZodIssueCode.custom,
       message: "legacy user-message request sequence field is no longer accepted",
       path: ["item", legacyClientRequestKey]
     });
   }
 });
 var threadEventSchema = rejectLegacyClientRequestSequenceSchema.pipe(
-  z15.union([providerEventSchema, systemEventSchema]).superRefine((event, ctx) => {
+  z16.union([providerEventSchema, systemEventSchema]).superRefine((event, ctx) => {
     const result = validateThreadEventScope({
       type: event.type,
       scope: event.scope
     });
     if (!result.valid) {
       ctx.addIssue({
-        code: z15.ZodIssueCode.custom,
+        code: z16.ZodIssueCode.custom,
         message: result.message ?? "Invalid thread event scope",
         path: ["scope"]
       });
@@ -2224,101 +2770,102 @@ var threadEventTypeValues = [
   ...systemEventTypeValues
 ];
 var threadEventTypeSet = new Set(threadEventTypeValues);
-var threadEventTypeSchema = z15.string().refine(
+var threadEventTypeSchema = z16.string().refine(
   (value) => threadEventTypeSet.has(value),
   "Invalid thread event type"
 );
 
 // ../domain/src/provider-fork.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var PROVIDER_FORK_VALUES = ["none", "tip", "checkpoint"];
-var providerForkSchema = z16.enum(PROVIDER_FORK_VALUES);
+var providerForkSchema = z17.enum(PROVIDER_FORK_VALUES);
 
 // ../domain/src/provider-types.ts
-import { z as z17 } from "zod";
-var modelReasoningEffortSchema = z17.object({
+import { z as z18 } from "zod";
+var modelReasoningEffortSchema = z18.object({
   reasoningEffort: reasoningLevelSchema,
-  description: z17.string()
-});
-var availableModelSchema = z17.object({
-  id: z17.string(),
-  model: z17.string(),
-  displayName: z17.string(),
-  routeProviderId: z17.string().min(1).optional(),
-  description: z17.string(),
-  supportedReasoningEfforts: z17.array(modelReasoningEffortSchema),
+  description: z18.string()
+});
+var availableModelSchema = z18.object({
+  id: z18.string(),
+  model: z18.string(),
+  displayName: z18.string(),
+  routeProviderId: z18.string().min(1).optional(),
+  description: z18.string(),
+  supportedReasoningEfforts: z18.array(modelReasoningEffortSchema),
   defaultReasoningEffort: reasoningLevelSchema,
-  isDefault: z17.boolean()
-});
-var providerModelCatalogScopeSchema = z17.enum(["host", "workspace"]);
-var providerCapabilitiesSchema = z17.object({
-  supportsThreadArchive: z17.boolean(),
-  supportsThreadRename: z17.boolean(),
-  supportsServiceTier: z17.boolean(),
-  supportsNativeUserQuestion: z17.boolean(),
-  supportsFork: z17.boolean(),
-  supportsSessionRewind: z17.boolean(),
-  permissionModes: z17.array(permissionModeSchema).min(1),
+  isDefault: z18.boolean()
+});
+var providerModelCatalogScopeSchema = z18.enum(["host", "workspace"]);
+var providerCapabilitiesSchema = z18.object({
+  supportsThreadArchive: z18.boolean(),
+  supportsThreadRename: z18.boolean(),
+  supportsServiceTier: z18.boolean(),
+  supportsNativeUserQuestion: z18.boolean(),
+  supportsFork: z18.boolean(),
+  supportsSessionRewind: z18.boolean(),
+  permissionModes: z18.array(permissionModeSchema).min(1),
   modelCatalogScope: providerModelCatalogScopeSchema
 });
-var providerComposerCommandSchema = z17.object({
+var providerComposerCommandSchema = z18.object({
   trigger: promptMentionCommandTriggerSchema,
-  name: z17.string().min(1).regex(/^[^\s/$]+$/u),
-  trailingText: z17.string().regex(/^\s*$/u)
+  name: z18.string().min(1).regex(/^[^\s/$]+$/u),
+  trailingText: z18.string().regex(/^\s*$/u)
 });
-var providerComposerActionSchema = z17.discriminatedUnion("kind", [
-  z17.object({
-    kind: z17.literal("skills"),
+var providerComposerActionSchema = z18.discriminatedUnion("kind", [
+  z18.object({
+    kind: z18.literal("skills"),
     trigger: promptMentionCommandTriggerSchema
   }),
-  z17.object({
-    kind: z17.literal("plan"),
+  z18.object({
+    kind: z18.literal("plan"),
     command: providerComposerCommandSchema
   }),
-  z17.object({
-    kind: z17.literal("goal"),
+  z18.object({
+    kind: z18.literal("goal"),
     command: providerComposerCommandSchema
   })
 ]);
-var providerStringsSchema = z17.object({
-  signInHint: z17.string().min(1),
-  expiredHint: z17.string().min(1),
-  installUrl: z17.string().min(1),
-  brandPrefix: z17.string().min(1).optional(),
-  planModeCopy: z17.string().min(1).optional(),
-  iconTint: z17.object({ light: z17.string().min(1), dark: z17.string().min(1) }).optional()
-});
-var providerOptionDescriptorSchema = z17.object({
-  id: z17.string().min(1),
-  label: z17.string().min(1),
-  description: z17.string().min(1).optional()
-});
-var providerExtensionKindInfoSchema = z17.object({
-  item: z17.boolean(),
-  state: z17.boolean()
-});
-var providerExtensionKindsSchema = z17.record(
+var providerStringsSchema = z18.object({
+  signInHint: z18.string().min(1),
+  expiredHint: z18.string().min(1),
+  installUrl: z18.string().min(1),
+  brandPrefix: z18.string().min(1).optional(),
+  planModeCopy: z18.string().min(1).optional(),
+  iconTint: z18.object({ light: z18.string().min(1), dark: z18.string().min(1) }).optional()
+});
+var providerOptionDescriptorSchema = z18.object({
+  id: z18.string().min(1),
+  label: z18.string().min(1),
+  description: z18.string().min(1).optional()
+});
+var providerExtensionKindInfoSchema = z18.object({
+  item: z18.boolean(),
+  state: z18.boolean()
+});
+var providerExtensionKindsSchema = z18.record(
   extensionKindSchema,
   providerExtensionKindInfoSchema
 );
-var providerInfoSchema = z17.object({
-  id: z17.string(),
-  pluginId: z17.string().min(1),
-  displayName: z17.string(),
-  family: z17.string().min(1).optional(),
-  icon: z17.object({ glyph: z17.string().min(1) }).optional(),
-  logoUrl: z17.string().min(1).nullable(),
-  maintenance: z17.object({
-    health: z17.boolean(),
-    usage: z17.boolean(),
-    installation: z17.boolean()
+var providerInfoSchema = z18.object({
+  id: z18.string(),
+  pluginId: z18.string().min(1),
+  displayName: z18.string(),
+  family: z18.string().min(1).optional(),
+  icon: z18.object({ glyph: z18.string().min(1) }).optional(),
+  logoUrl: z18.string().min(1).nullable(),
+  maintenance: z18.object({
+    health: z18.boolean(),
+    usage: z18.boolean(),
+    installation: z18.boolean()
   }),
   capabilities: providerCapabilitiesSchema,
-  composerActions: z17.array(providerComposerActionSchema),
-  available: z17.boolean(),
+  composerActions: z18.array(providerComposerActionSchema),
+  completedTurnDisplay: completedTurnDisplaySchema,
+  available: z18.boolean(),
   strings: providerStringsSchema.optional(),
-  serviceTiers: z17.array(providerOptionDescriptorSchema).optional(),
-  reasoningLevels: z17.array(providerOptionDescriptorSchema).optional(),
+  serviceTiers: z18.array(providerOptionDescriptorSchema).optional(),
+  reasoningLevels: z18.array(providerOptionDescriptorSchema).optional(),
   extensionKinds: providerExtensionKindsSchema.optional()
 });
 var providerRecoveryKindValues = [
@@ -2328,34 +2875,34 @@ var providerRecoveryKindValues = [
   "staleTurn",
   "rateLimited"
 ];
-var providerRecoveryKindSchema = z17.enum(providerRecoveryKindValues);
-var toolCallOutputItemSchema = z17.discriminatedUnion("type", [
-  z17.object({
-    type: z17.literal("inputText"),
-    text: z17.string()
+var providerRecoveryKindSchema = z18.enum(providerRecoveryKindValues);
+var toolCallOutputItemSchema = z18.discriminatedUnion("type", [
+  z18.object({
+    type: z18.literal("inputText"),
+    text: z18.string()
   }),
-  z17.object({
-    type: z17.literal("inputImage"),
-    imageUrl: z17.string()
+  z18.object({
+    type: z18.literal("inputImage"),
+    imageUrl: z18.string()
   })
 ]);
-var toolCallRequestSchema = z17.object({
-  requestId: z17.union([z17.string().min(1), z17.number()]),
-  threadId: z17.string().min(1),
-  providerThreadId: z17.string().min(1),
-  turnId: z17.string().min(1),
-  callId: z17.string().min(1),
-  tool: z17.string().min(1),
-  arguments: z17.unknown().optional()
-});
-var toolCallResponseSchema = z17.object({
-  contentItems: z17.array(toolCallOutputItemSchema),
-  success: z17.boolean()
-});
-var dynamicToolSchema = z17.object({
-  name: z17.string(),
-  description: z17.string(),
-  inputSchema: z17.unknown(),
+var toolCallRequestSchema = z18.object({
+  requestId: z18.union([z18.string().min(1), z18.number()]),
+  threadId: z18.string().min(1),
+  providerThreadId: z18.string().min(1),
+  turnId: z18.string().min(1),
+  callId: z18.string().min(1),
+  tool: z18.string().min(1),
+  arguments: z18.unknown().optional()
+});
+var toolCallResponseSchema = z18.object({
+  contentItems: z18.array(toolCallOutputItemSchema),
+  success: z18.boolean()
+});
+var dynamicToolSchema = z18.object({
+  name: z18.string(),
+  description: z18.string(),
+  inputSchema: z18.unknown(),
   presentation: threadEventItemPresentationSchema.optional()
 });
 
@@ -2407,10 +2954,10 @@ function reasoningEffortsForLevels(levels) {
 }
 
 // ../provider-bridge-acp/src/launch-spec.ts
-import { z as z18 } from "zod";
-var acpNativeSkillRootsSchema = z18.object({
-  user: z18.array(providerNativeRootInputSchema).default([]),
-  project: z18.array(providerNativeRootInputSchema).default([])
+import { z as z19 } from "zod";
+var acpNativeSkillRootsSchema = z19.object({
+  user: z19.array(providerNativeRootInputSchema).default([]),
+  project: z19.array(providerNativeRootInputSchema).default([])
 }).strict().superRefine((roots, context) => {
   const normalized = providerNativeRootsSchema.safeParse(
     normalizeProviderNativeRoots(roots)
@@ -2426,16 +2973,16 @@ var acpNativeSkillRootsSchema = z18.object({
     });
   }
 });
-var acpLaunchSpecSchema = z18.object({
-  displayName: z18.string().min(1),
-  command: z18.string().min(1),
-  args: z18.array(z18.string()),
-  env: z18.record(z18.string().min(1), z18.string()),
-  cwd: z18.string().min(1).optional(),
-  modelCli: z18.object({
-    listArgs: z18.array(z18.string()),
-    selectFlag: z18.string().min(1).optional(),
-    primaryModels: z18.array(z18.string())
+var acpLaunchSpecSchema = z19.object({
+  displayName: z19.string().min(1),
+  command: z19.string().min(1),
+  args: z19.array(z19.string()),
+  env: z19.record(z19.string().min(1), z19.string()),
+  cwd: z19.string().min(1).optional(),
+  modelCli: z19.object({
+    listArgs: z19.array(z19.string()),
+    selectFlag: z19.string().min(1).optional(),
+    primaryModels: z19.array(z19.string())
   }).strict().transform(
     (modelCli) => modelCli.listArgs.length > 0 ? modelCli : void 0
   ).optional(),
@@ -2450,66 +2997,66 @@ var PROVIDER_BRIDGE_PROTOCOL_VERSION = 2;
 var THREAD_DELTA_GRAMMAR_V3 = 3;
 
 // ../provider-bridge-protocol/src/handshake.ts
-import { z as z19 } from "zod";
-var bridgeGrammarVersionsSchema = z19.tuple([z19.number().int().positive(), z19.number().int().positive()]).refine(([min, max]) => min <= max, {
+import { z as z20 } from "zod";
+var bridgeGrammarVersionsSchema = z20.tuple([z20.number().int().positive(), z20.number().int().positive()]).refine(([min, max]) => min <= max, {
   message: "grammarVersions must be an ascending [min, max] range"
 });
-var bridgeSteerModeSchema = z19.enum(["inject", "queue"]);
-var bridgeCapabilitiesSchema = z19.object({
-  sessionRestore: z19.boolean().default(false),
-  threadArchive: z19.boolean().default(false),
-  threadRename: z19.boolean().default(false),
-  threadGoalClear: z19.boolean().default(false),
+var bridgeSteerModeSchema = z20.enum(["inject", "queue"]);
+var bridgeCapabilitiesSchema = z20.object({
+  sessionRestore: z20.boolean().default(false),
+  threadArchive: z20.boolean().default(false),
+  threadRename: z20.boolean().default(false),
+  threadGoalClear: z20.boolean().default(false),
   fork: providerForkSchema.default("none"),
-  approvalEnforcedBy: z19.enum(["runtime", "provider"]).default("runtime"),
+  approvalEnforcedBy: z20.enum(["runtime", "provider"]).default("runtime"),
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
   ]),
   steerMode: bridgeSteerModeSchema.default("queue"),
-  skills: z19.object({ configure: z19.boolean().default(false) }).default({ configure: false })
+  skills: z20.object({ configure: z20.boolean().default(false) }).default({ configure: false })
 }).passthrough();
-var initializeParamsSchema = z19.object({
-  protocolVersion: z19.number().int().positive(),
-  client: z19.object({ name: z19.string().min(1), version: z19.string().min(1) }),
+var initializeParamsSchema = z20.object({
+  protocolVersion: z20.number().int().positive(),
+  client: z20.object({ name: z20.string().min(1), version: z20.string().min(1) }),
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
   ])
 }).passthrough();
-var initializeResultSchema = z19.object({
-  protocolVersion: z19.number().int().positive(),
-  capabilities: z19.preprocess(
+var initializeResultSchema = z20.object({
+  protocolVersion: z20.number().int().positive(),
+  capabilities: z20.preprocess(
     (value) => value ?? {},
     bridgeCapabilitiesSchema
   )
 }).passthrough();
 
 // ../provider-bridge-protocol/src/execution-options.ts
-import { z as z20 } from "zod";
-var bridgeExecutionOptionsSchema = z20.object({
-  model: z20.string().min(1).optional(),
+import { z as z21 } from "zod";
+var bridgeExecutionOptionsSchema = z21.object({
+  model: z21.string().min(1).optional(),
   serviceTier: serviceTierSchema.optional(),
   reasoningLevel: reasoningLevelSchema.optional(),
   promptMode: promptModeSchema.optional(),
-  instructions: z20.string().optional(),
-  envVars: z20.record(z20.string(), z20.string()).optional(),
-  providerOptions: z20.record(z20.string(), z20.unknown()).optional()
+  instructions: z21.string().optional(),
+  envVars: z21.record(z21.string(), z21.string()).optional(),
+  providerOptions: z21.record(z21.string(), z21.unknown()).optional()
 }).and(runtimePermissionPolicySchema);
 
 // ../provider-bridge-protocol/src/provider-maintenance.ts
-import { z as z21 } from "zod";
-var providerMaintenanceParamsSchema = z21.object({
-  providerId: z21.string().min(1),
-  cwd: z21.string().min(1).optional(),
-  providerOptions: z21.record(z21.string(), z21.unknown()).optional()
+import { z as z22 } from "zod";
+var providerMaintenanceParamsSchema = z22.object({
+  providerId: z22.string().min(1),
+  cwd: z22.string().min(1).optional(),
+  providerOptions: z22.record(z22.string(), z22.unknown()).optional()
 }).passthrough();
-var providerInstallationRequirementSchema = z21.enum(["thread_rewind"]);
+var providerInstallationRequirementSchema = z22.enum(["thread_rewind"]);
 var providerInstallationStatusParamsSchema = providerMaintenanceParamsSchema.extend({
   requirement: providerInstallationRequirementSchema.optional()
 });
-var providerHealthSchema = z21.object({
-  status: z21.enum([
+var providerHealthSchema = z22.object({
+  status: z22.enum([
     "ready",
     "not_installed",
     "unauthenticated",
@@ -2517,114 +3064,114 @@ var providerHealthSchema = z21.object({
     "unsupported_version",
     "unknown"
   ]),
-  statusMessage: z21.string().min(1).nullable(),
-  accountEmail: z21.string().nullable(),
-  planLabel: z21.string().min(1).nullable(),
-  installedVersion: z21.string().min(1).nullable(),
-  minimumSupportedVersion: z21.string().min(1).nullable(),
-  canInstall: z21.boolean(),
-  canUpdate: z21.boolean(),
-  loginCommand: z21.string().min(1).nullable()
+  statusMessage: z22.string().min(1).nullable(),
+  accountEmail: z22.string().nullable(),
+  planLabel: z22.string().min(1).nullable(),
+  installedVersion: z22.string().min(1).nullable(),
+  minimumSupportedVersion: z22.string().min(1).nullable(),
+  canInstall: z22.boolean(),
+  canUpdate: z22.boolean(),
+  loginCommand: z22.string().min(1).nullable()
 }).passthrough();
-var providerUsageWindowSchema = z21.object({
-  label: z21.string().min(1),
-  usedPercent: z21.number().min(0).max(100),
-  resetsAt: z21.string().min(1).nullable(),
-  cost: z21.object({
-    usedUsdCents: z21.number().int().nonnegative(),
-    limitUsdCents: z21.number().int().positive()
+var providerUsageWindowSchema = z22.object({
+  label: z22.string().min(1),
+  usedPercent: z22.number().min(0).max(100),
+  resetsAt: z22.string().min(1).nullable(),
+  cost: z22.object({
+    usedUsdCents: z22.number().int().nonnegative(),
+    limitUsdCents: z22.number().int().positive()
   }).optional()
 }).passthrough();
-var providerUsageSchema = z21.discriminatedUnion("status", [
-  z21.object({
-    status: z21.literal("ok"),
-    accountEmail: z21.string().email().nullable(),
-    planLabel: z21.string().min(1).nullable(),
-    windows: z21.array(providerUsageWindowSchema)
+var providerUsageSchema = z22.discriminatedUnion("status", [
+  z22.object({
+    status: z22.literal("ok"),
+    accountEmail: z22.string().email().nullable(),
+    planLabel: z22.string().min(1).nullable(),
+    windows: z22.array(providerUsageWindowSchema)
   }).passthrough(),
-  z21.object({ status: z21.literal("not_installed") }).passthrough(),
-  z21.object({ status: z21.literal("unauthenticated") }).passthrough(),
-  z21.object({ status: z21.literal("expired") }).passthrough(),
-  z21.object({
-    status: z21.literal("error"),
-    message: z21.string().min(1),
-    planLabel: z21.string().min(1).nullable().default(null),
-    accountEmail: z21.string().nullable().default(null)
+  z22.object({ status: z22.literal("not_installed") }).passthrough(),
+  z22.object({ status: z22.literal("unauthenticated") }).passthrough(),
+  z22.object({ status: z22.literal("expired") }).passthrough(),
+  z22.object({
+    status: z22.literal("error"),
+    message: z22.string().min(1),
+    planLabel: z22.string().min(1).nullable().default(null),
+    accountEmail: z22.string().nullable().default(null)
   }).passthrough()
 ]);
-var providerHealthResultSchema = z21.discriminatedUnion("supported", [
-  z21.object({ supported: z21.literal(false) }).passthrough(),
-  z21.object({
-    supported: z21.literal(true),
+var providerHealthResultSchema = z22.discriminatedUnion("supported", [
+  z22.object({ supported: z22.literal(false) }).passthrough(),
+  z22.object({
+    supported: z22.literal(true),
     health: providerHealthSchema
   }).passthrough()
 ]);
-var providerUsageResultSchema = z21.discriminatedUnion("supported", [
-  z21.object({ supported: z21.literal(false) }).passthrough(),
-  z21.object({
-    supported: z21.literal(true),
+var providerUsageResultSchema = z22.discriminatedUnion("supported", [
+  z22.object({ supported: z22.literal(false) }).passthrough(),
+  z22.object({
+    supported: z22.literal(true),
     usage: providerUsageSchema
   }).passthrough()
 ]);
-var providerInstallationActionKindSchema = z21.enum([
+var providerInstallationActionKindSchema = z22.enum([
   "install",
   "update"
 ]);
-var providerInstallationActionSchema = z21.object({
+var providerInstallationActionSchema = z22.object({
   kind: providerInstallationActionKindSchema,
-  label: z21.enum(["Install", "Update"]),
-  command: z21.string().min(1)
+  label: z22.enum(["Install", "Update"]),
+  command: z22.string().min(1)
 }).passthrough();
-var providerInstallationSourceSchema = z21.enum([
+var providerInstallationSourceSchema = z22.enum([
   "notInstalled",
   "npmGlobal",
   "external"
 ]);
-var providerInstallationStatusSchema = z21.object({
-  executableName: z21.string().min(1),
-  executablePath: z21.string().min(1).nullable(),
-  installed: z21.boolean(),
+var providerInstallationStatusSchema = z22.object({
+  executableName: z22.string().min(1),
+  executablePath: z22.string().min(1).nullable(),
+  installed: z22.boolean(),
   installSource: providerInstallationSourceSchema,
-  currentVersion: z21.string().min(1).nullable(),
-  latestVersion: z21.string().min(1).nullable(),
-  minimumSupportedVersion: z21.string().min(1).nullable(),
-  npmPackageName: z21.string().min(1).nullable(),
-  npmGlobalPackageVersion: z21.string().min(1).nullable(),
+  currentVersion: z22.string().min(1).nullable(),
+  latestVersion: z22.string().min(1).nullable(),
+  minimumSupportedVersion: z22.string().min(1).nullable(),
+  npmPackageName: z22.string().min(1).nullable(),
+  npmGlobalPackageVersion: z22.string().min(1).nullable(),
   installAction: providerInstallationActionSchema.nullable(),
-  needsUpdate: z21.boolean(),
-  versionUnsupported: z21.boolean()
+  needsUpdate: z22.boolean(),
+  versionUnsupported: z22.boolean()
 }).passthrough();
 var providerInstallationRunParamsSchema = providerMaintenanceParamsSchema.extend({
   action: providerInstallationActionKindSchema
 });
-var providerInstallationCommandSchema = z21.object({
-  command: z21.string().min(1),
-  args: z21.array(z21.string()).max(64),
-  displayCommand: z21.string().min(1)
+var providerInstallationCommandSchema = z22.object({
+  command: z22.string().min(1),
+  args: z22.array(z22.string()).max(64),
+  displayCommand: z22.string().min(1)
 }).passthrough();
-var providerInstallationVerificationSchema = z21.discriminatedUnion(
+var providerInstallationVerificationSchema = z22.discriminatedUnion(
   "kind",
   [
-    z21.object({ kind: z21.literal("installed") }).passthrough(),
-    z21.object({
-      kind: z21.literal("version_changed"),
-      previousVersion: z21.string().min(1)
+    z22.object({ kind: z22.literal("installed") }).passthrough(),
+    z22.object({
+      kind: z22.literal("version_changed"),
+      previousVersion: z22.string().min(1)
     }).passthrough(),
-    z21.object({
-      kind: z21.literal("version_at_least"),
-      version: z21.string().min(1)
+    z22.object({
+      kind: z22.literal("version_at_least"),
+      version: z22.string().min(1)
     }).passthrough()
   ]
 );
-var providerInstallationRunResultSchema = z21.discriminatedUnion(
+var providerInstallationRunResultSchema = z22.discriminatedUnion(
   "available",
   [
-    z21.object({
-      available: z21.literal(false),
-      message: z21.string().min(1)
+    z22.object({
+      available: z22.literal(false),
+      message: z22.string().min(1)
     }).passthrough(),
-    z21.object({
-      available: z21.literal(true),
+    z22.object({
+      available: z22.literal(true),
       command: providerInstallationCommandSchema,
       verification: providerInstallationVerificationSchema
     }).passthrough()
@@ -2632,80 +3179,80 @@ var providerInstallationRunResultSchema = z21.discriminatedUnion(
 );
 
 // ../provider-bridge-protocol/src/requests.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var sessionConstructionFields = {
-  threadId: z22.string().min(1),
-  cwd: z22.string().min(1),
+  threadId: z23.string().min(1),
+  cwd: z23.string().min(1),
   options: bridgeExecutionOptionsSchema,
-  dynamicTools: z22.array(dynamicToolSchema).optional(),
-  disallowedTools: z22.array(z22.string().min(1)).optional(),
+  dynamicTools: z23.array(dynamicToolSchema).optional(),
+  disallowedTools: z23.array(z23.string().min(1)).optional(),
   instructionMode: instructionModeSchema
 };
-var modelListParamsSchema = z22.object({ cwd: z22.string().min(1).optional() }).passthrough();
-var threadStartParamsSchema = z22.object({
+var modelListParamsSchema = z23.object({ cwd: z23.string().min(1).optional() }).passthrough();
+var threadStartParamsSchema = z23.object({
   ...sessionConstructionFields,
-  input: z22.array(promptInputSchema).optional()
+  input: z23.array(promptInputSchema).optional()
 }).passthrough();
-var threadResumeParamsSchema = z22.object({
+var threadResumeParamsSchema = z23.object({
   ...sessionConstructionFields,
-  providerThreadId: z22.string().min(1)
+  providerThreadId: z23.string().min(1)
 }).passthrough();
-var threadForkParamsSchema = z22.object({
+var threadForkParamsSchema = z23.object({
   ...sessionConstructionFields,
-  sourceProviderThreadId: z22.string().min(1),
-  sourceProviderCheckpointId: z22.string().min(1).optional()
+  sourceProviderThreadId: z23.string().min(1),
+  sourceProviderCheckpointId: z23.string().min(1).optional()
 }).passthrough();
-var threadStopParamsSchema = z22.object({
-  threadId: z22.string().min(1),
-  providerThreadId: z22.string().min(1),
-  intent: z22.enum(["interrupt", "release"]),
-  activeTurnId: z22.string().min(1).nullable()
+var threadStopParamsSchema = z23.object({
+  threadId: z23.string().min(1),
+  providerThreadId: z23.string().min(1),
+  intent: z23.enum(["interrupt", "release"]),
+  activeTurnId: z23.string().min(1).nullable()
 }).passthrough();
-var threadRefParams = z22.object({
-  threadId: z22.string().min(1),
-  providerThreadId: z22.string().min(1)
+var threadRefParams = z23.object({
+  threadId: z23.string().min(1),
+  providerThreadId: z23.string().min(1)
 }).passthrough();
 var threadDiscardParamsSchema = threadRefParams;
-var threadNameSetParamsSchema = z22.object({
-  threadId: z22.string().min(1),
-  providerThreadId: z22.string().min(1),
-  title: z22.string().min(1)
+var threadNameSetParamsSchema = z23.object({
+  threadId: z23.string().min(1),
+  providerThreadId: z23.string().min(1),
+  title: z23.string().min(1)
 }).passthrough();
 var turnInputFields = {
-  threadId: z22.string().min(1),
-  providerThreadId: z22.string().min(1),
-  input: z22.array(promptInputSchema),
+  threadId: z23.string().min(1),
+  providerThreadId: z23.string().min(1),
+  input: z23.array(promptInputSchema),
   clientRequestId: clientTurnRequestIdSchema,
   options: bridgeExecutionOptionsSchema
 };
-var turnStartParamsSchema = z22.object(turnInputFields).passthrough();
-var turnSteerParamsSchema = z22.object({
+var turnStartParamsSchema = z23.object(turnInputFields).passthrough();
+var turnSteerParamsSchema = z23.object({
   ...turnInputFields,
-  expectedTurnId: z22.string().min(1)
+  expectedTurnId: z23.string().min(1)
 }).passthrough();
-var skillsConfigureRootSchema = z22.object({
-  id: z22.string().min(1),
-  path: z22.string().min(1),
-  skills: z22.array(
-    z22.object({
-      name: z22.string().min(1),
-      description: z22.string()
+var skillsConfigureRootSchema = z23.object({
+  id: z23.string().min(1),
+  path: z23.string().min(1),
+  skills: z23.array(
+    z23.object({
+      name: z23.string().min(1),
+      description: z23.string()
     }).passthrough()
   )
 }).passthrough();
-var skillsConfigureParamsSchema = z22.object({
-  roots: z22.array(skillsConfigureRootSchema)
+var skillsConfigureParamsSchema = z23.object({
+  roots: z23.array(skillsConfigureRootSchema)
 }).passthrough();
-var threadIdentityResultSchema = z22.object({
-  providerThreadId: z22.string().min(1),
-  sessionRestorable: z22.boolean().optional()
+var threadIdentityResultSchema = z23.object({
+  providerThreadId: z23.string().min(1),
+  sessionRestorable: z23.boolean().optional()
 }).passthrough();
 
 // ../provider-bridge-protocol/src/notifications.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // ../provider-bridge-protocol/src/errors.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var BRIDGE_JSON_RPC_ERRORS = {
   INVALID_PARAMS: -32602,
   METHOD_NOT_FOUND: -32601,
@@ -2714,12 +3261,12 @@ var BRIDGE_JSON_RPC_ERRORS = {
   SESSION_NOT_RESTORABLE: -32002,
   FORK_CHECKPOINT_UNSUPPORTED: -32003
 };
-var providerRecoveryHintSchema = z23.object({
+var providerRecoveryHintSchema = z24.object({
   kind: providerRecoveryKindSchema,
-  message: z23.string().min(1),
-  retryable: z23.boolean()
+  message: z24.string().min(1),
+  retryable: z24.boolean()
 });
-var bridgeErrorDataSchema = z23.object({ recovery: providerRecoveryHintSchema.optional() }).passthrough();
+var bridgeErrorDataSchema = z24.object({ recovery: providerRecoveryHintSchema.optional() }).passthrough();
 
 // ../provider-bridge-protocol/src/notifications.ts
 var BRIDGE_NOTIFICATION_METHODS = {
@@ -2729,177 +3276,177 @@ var BRIDGE_NOTIFICATION_METHODS = {
   providerRecovery: "provider/recovery",
   error: "error"
 };
-var threadIdentityNotificationSchema = z24.object({
-  threadId: z24.string().min(1),
-  providerThreadId: z24.string().min(1),
-  sessionRestorable: z24.boolean().optional()
+var threadIdentityNotificationSchema = z25.object({
+  threadId: z25.string().min(1),
+  providerThreadId: z25.string().min(1),
+  sessionRestorable: z25.boolean().optional()
 }).passthrough();
-var sessionReplacedNotificationSchema = z24.object({
-  threadId: z24.string().min(1),
-  providerThreadId: z24.string().min(1).nullable(),
-  reason: z24.string().min(1),
-  contextLost: z24.boolean().default(false),
-  showRuntimeNote: z24.boolean().default(false)
+var sessionReplacedNotificationSchema = z25.object({
+  threadId: z25.string().min(1),
+  providerThreadId: z25.string().min(1).nullable(),
+  reason: z25.string().min(1),
+  contextLost: z25.boolean().default(false),
+  showRuntimeNote: z25.boolean().default(false)
 }).passthrough();
-var providerRecoveryNotificationSchema = z24.object({
-  threadId: z24.string().min(1).optional(),
+var providerRecoveryNotificationSchema = z25.object({
+  threadId: z25.string().min(1).optional(),
   ...providerRecoveryHintSchema.shape
 }).passthrough();
-var errorNotificationSchema = z24.object({
-  threadId: z24.string().min(1).optional(),
-  providerThreadId: z24.string().min(1).optional(),
-  message: z24.string().min(1)
+var errorNotificationSchema = z25.object({
+  threadId: z25.string().min(1).optional(),
+  providerThreadId: z25.string().min(1).optional(),
+  message: z25.string().min(1)
 }).passthrough();
 
 // ../provider-bridge-protocol/src/bridge-requests.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var BRIDGE_INBOUND_REQUEST_METHODS = {
   toolCall: "item/tool/call",
   interactionRequest: "interaction/request"
 };
-var toolCallRequestParamsSchema = z25.object({
-  providerThreadId: z25.string().min(1),
-  threadId: z25.string().min(1).optional(),
-  turnId: z25.union([z25.string().min(1), z25.null()]),
-  callId: z25.string().min(1),
-  tool: z25.string().min(1),
-  arguments: z25.unknown(),
-  providerNativeIds: z25.boolean().optional()
+var toolCallRequestParamsSchema = z26.object({
+  providerThreadId: z26.string().min(1),
+  threadId: z26.string().min(1).optional(),
+  turnId: z26.union([z26.string().min(1), z26.null()]),
+  callId: z26.string().min(1),
+  tool: z26.string().min(1),
+  arguments: z26.unknown(),
+  providerNativeIds: z26.boolean().optional()
 }).passthrough();
-var toolCallResultSchema = z25.object({
-  success: z25.boolean(),
-  contentItems: z25.array(
-    z25.discriminatedUnion("type", [
-      z25.object({ type: z25.literal("inputText"), text: z25.string() }),
-      z25.object({
-        type: z25.literal("inputImage"),
-        imageUrl: z25.string().min(1)
+var toolCallResultSchema = z26.object({
+  success: z26.boolean(),
+  contentItems: z26.array(
+    z26.discriminatedUnion("type", [
+      z26.object({ type: z26.literal("inputText"), text: z26.string() }),
+      z26.object({
+        type: z26.literal("inputImage"),
+        imageUrl: z26.string().min(1)
       })
     ])
   )
 }).passthrough();
-var interactionRequestParamsSchema = z25.object({
-  providerThreadId: z25.string().min(1),
-  threadId: z25.string().min(1).optional(),
-  turnId: z25.union([z25.string().min(1), z25.null()]),
+var interactionRequestParamsSchema = z26.object({
+  providerThreadId: z26.string().min(1),
+  threadId: z26.string().min(1).optional(),
+  turnId: z26.union([z26.string().min(1), z26.null()]),
   payload: pendingInteractionPayloadSchema,
-  providerNativeIds: z25.boolean().optional()
+  providerNativeIds: z26.boolean().optional()
 }).passthrough();
 
 // ../provider-bridge-protocol/src/thread-delta.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var THREAD_DELTA_NOTIFICATION_METHOD = "thread/delta";
 var deltaPresentationSchema = threadEventItemPresentationSchema;
 var THREAD_DELTA_KEY_SEPARATOR = "";
-var deltaKeyPartSchema = z26.string().min(1).refine((value) => !value.includes(THREAD_DELTA_KEY_SEPARATOR), {
+var deltaKeyPartSchema = z27.string().min(1).refine((value) => !value.includes(THREAD_DELTA_KEY_SEPARATOR), {
   message: "provider keys must not contain the internal key separator (\\u001f)"
 });
-var deltaItemKeySchema = z26.object({
+var deltaItemKeySchema = z27.object({
   providerItemId: deltaKeyPartSchema.optional(),
   channel: deltaKeyPartSchema.optional(),
   parentRef: deltaKeyPartSchema.optional()
 });
 var providerTurnIdSchema = deltaKeyPartSchema;
-var deltaFileChangeSchema = z26.object({
-  path: z26.string(),
-  kind: z26.enum(["add", "update", "delete"]),
-  movePath: z26.string().optional(),
-  diff: z26.string().optional(),
-  oldText: z26.string().optional(),
-  newText: z26.string().optional()
-});
-var deltaBackgroundTaskShapeSchema = z26.object({
-  type: z26.literal("backgroundTask"),
-  familyId: z26.string().min(1),
-  taskType: z26.string(),
-  description: z26.string(),
+var deltaFileChangeSchema = z27.object({
+  path: z27.string(),
+  kind: z27.enum(["add", "update", "delete"]),
+  movePath: z27.string().optional(),
+  diff: z27.string().optional(),
+  oldText: z27.string().optional(),
+  newText: z27.string().optional()
+});
+var deltaBackgroundTaskShapeSchema = z27.object({
+  type: z27.literal("backgroundTask"),
+  familyId: z27.string().min(1),
+  taskType: z27.string(),
+  description: z27.string(),
   status: threadEventItemStatusSchema,
   taskStatus: backgroundTaskStatusSchema,
-  skipTranscript: z26.boolean(),
-  workflowName: z26.string().optional(),
+  skipTranscript: z27.boolean(),
+  workflowName: z27.string().optional(),
   workflow: workflowProgressSnapshotSchema.optional(),
   usage: backgroundTaskUsageSchema.optional(),
-  summary: z26.string().optional(),
-  error: z26.string().optional(),
-  outputFile: z26.string().optional()
+  summary: z27.string().optional(),
+  error: z27.string().optional(),
+  outputFile: z27.string().optional()
 });
-var deltaFileReadShapeSchema = z26.object({
-  type: z26.literal("fileRead"),
-  path: z26.string(),
-  cmd: z26.string().optional()
+var deltaFileReadShapeSchema = z27.object({
+  type: z27.literal("fileRead"),
+  path: z27.string(),
+  cmd: z27.string().optional()
 });
-var deltaSearchShapeSchema = z26.object({
-  type: z26.literal("search"),
+var deltaSearchShapeSchema = z27.object({
+  type: z27.literal("search"),
   mode: threadEventSearchModeSchema,
-  query: z26.string(),
-  path: z26.string().optional(),
-  cmd: z26.string().optional()
+  query: z27.string(),
+  path: z27.string().optional(),
+  cmd: z27.string().optional()
 });
-var deltaDelegationShapeSchema = z26.object({
-  type: z26.literal("delegation"),
+var deltaDelegationShapeSchema = z27.object({
+  type: z27.literal("delegation"),
   childRef: deltaKeyPartSchema,
-  label: z26.string(),
-  background: z26.boolean(),
-  summary: z26.string().optional()
+  label: z27.string(),
+  background: z27.boolean(),
+  summary: z27.string().optional()
 });
-var deltaPlanStepsShapeSchema = z26.object({
-  type: z26.literal("planSteps"),
-  steps: z26.array(threadEventPlanStepSchema),
-  explanation: z26.string().optional()
+var deltaPlanStepsShapeSchema = z27.object({
+  type: z27.literal("planSteps"),
+  steps: z27.array(threadEventPlanStepSchema),
+  explanation: z27.string().optional()
 });
-var deltaExtensionShapeSchema = z26.object({
-  type: z26.literal("extension"),
+var deltaExtensionShapeSchema = z27.object({
+  type: z27.literal("extension"),
   kind: extensionKindSchema,
   payload: jsonValueSchema
 });
-var deltaItemShapeSchema = z26.discriminatedUnion("type", [
-  z26.object({
-    type: z26.literal("command"),
-    command: z26.string(),
-    cwd: z26.string(),
-    aggregatedOutput: z26.string().optional(),
-    exitCode: z26.number().optional(),
-    durationMs: z26.number().optional()
+var deltaItemShapeSchema = z27.discriminatedUnion("type", [
+  z27.object({
+    type: z27.literal("command"),
+    command: z27.string(),
+    cwd: z27.string(),
+    aggregatedOutput: z27.string().optional(),
+    exitCode: z27.number().optional(),
+    durationMs: z27.number().optional()
   }),
-  z26.object({
-    type: z26.literal("fileChange"),
-    changes: z26.array(deltaFileChangeSchema)
+  z27.object({
+    type: z27.literal("fileChange"),
+    changes: z27.array(deltaFileChangeSchema)
   }),
-  z26.object({
-    type: z26.literal("tool"),
-    tool: z26.string(),
-    server: z26.string().optional(),
-    args: z26.unknown().optional(),
-    result: z26.unknown().optional(),
-    error: z26.string().optional(),
-    durationMs: z26.number().optional()
+  z27.object({
+    type: z27.literal("tool"),
+    tool: z27.string(),
+    server: z27.string().optional(),
+    args: z27.unknown().optional(),
+    result: z27.unknown().optional(),
+    error: z27.string().optional(),
+    durationMs: z27.number().optional()
   }),
-  z26.object({ type: z26.literal("compaction") }),
-  z26.object({ type: z26.literal("agentMessage"), text: z26.string() }),
-  z26.object({
-    type: z26.literal("reasoning"),
-    summary: z26.array(z26.string()),
-    content: z26.array(z26.string())
+  z27.object({ type: z27.literal("compaction") }),
+  z27.object({ type: z27.literal("agentMessage"), text: z27.string() }),
+  z27.object({
+    type: z27.literal("reasoning"),
+    summary: z27.array(z27.string()),
+    content: z27.array(z27.string())
   }),
-  z26.object({ type: z26.literal("plan"), text: z26.string() }),
-  z26.object({
-    type: z26.literal("webSearch"),
-    queries: z26.array(z26.string()).min(1)
+  z27.object({ type: z27.literal("plan"), text: z27.string() }),
+  z27.object({
+    type: z27.literal("webSearch"),
+    queries: z27.array(z27.string()).min(1)
   }),
-  z26.object({
-    type: z26.literal("webFetch"),
-    url: z26.string(),
-    prompt: z26.string().nullable().optional(),
-    pattern: z26.string().nullable()
+  z27.object({
+    type: z27.literal("webFetch"),
+    url: z27.string(),
+    prompt: z27.string().nullable().optional(),
+    pattern: z27.string().nullable()
   }),
-  z26.object({ type: z26.literal("imageView"), path: z26.string() }),
-  z26.object({
-    type: z26.literal("imageGeneration"),
-    prompt: z26.string().nullable(),
-    path: z26.string().nullable(),
-    result: z26.string().optional(),
-    error: z26.string().nullable(),
-    transparentBackground: z26.boolean()
+  z27.object({ type: z27.literal("imageView"), path: z27.string() }),
+  z27.object({
+    type: z27.literal("imageGeneration"),
+    prompt: z27.string().nullable(),
+    path: z27.string().nullable(),
+    result: z27.string().optional(),
+    error: z27.string().nullable(),
+    transparentBackground: z27.boolean()
   }),
   deltaBackgroundTaskShapeSchema,
   deltaFileReadShapeSchema,
@@ -2908,22 +3455,22 @@ var deltaItemShapeSchema = z26.discriminatedUnion("type", [
   deltaPlanStepsShapeSchema,
   deltaExtensionShapeSchema
 ]);
-var deltaProgressSnapshotSchema = z26.discriminatedUnion("type", [
+var deltaProgressSnapshotSchema = z27.discriminatedUnion("type", [
   deltaBackgroundTaskShapeSchema,
   deltaDelegationShapeSchema
 ]);
-var deltaTextChannelSchema = z26.enum([
+var deltaTextChannelSchema = z27.enum([
   "agentMessage",
   "reasoningSummary",
   "reasoningText",
   "plan"
 ]);
-var deltaOutputChannelSchema = z26.enum(["command", "fileChange"]);
-var deltaErrorSchema = z26.object({ message: z26.string() });
-var deltaAttachSchema = z26.enum(["open", "currentOrLast"]);
-var deltaNoTurnFallbackSchema = z26.object({
+var deltaOutputChannelSchema = z27.enum(["command", "fileChange"]);
+var deltaErrorSchema = z27.object({ message: z27.string() });
+var deltaAttachSchema = z27.enum(["open", "currentOrLast"]);
+var deltaNoTurnFallbackSchema = z27.object({
   raw: providerRawEventSchema,
-  rawType: z26.string()
+  rawType: z27.string()
 });
 function requireExtensionPresentation(delta, ctx) {
   if (delta.item.type === "extension" && delta.presentation === void 0) {
@@ -2934,32 +3481,32 @@ function requireExtensionPresentation(delta, ctx) {
     });
   }
 }
-var threadDeltaSchema = z26.discriminatedUnion("kind", [
-  z26.object({
-    kind: z26.literal("input.accepted"),
+var threadDeltaSchema = z27.discriminatedUnion("kind", [
+  z27.object({
+    kind: z27.literal("input.accepted"),
     clientRequestId: clientTurnRequestIdSchema,
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z26.object({
-    kind: z26.literal("input.provider"),
-    text: z26.string().min(1),
+  z27.object({
+    kind: z27.literal("input.provider"),
+    text: z27.string().min(1),
     parentRef: deltaKeyPartSchema.optional()
   }),
-  z26.object({
-    kind: z26.literal("turn.open"),
+  z27.object({
+    kind: z27.literal("turn.open"),
     providerTurnId: providerTurnIdSchema.optional(),
     parentRef: deltaKeyPartSchema.optional()
   }),
-  z26.object({
-    kind: z26.literal("turn.boundary"),
+  z27.object({
+    kind: z27.literal("turn.boundary"),
     status: threadEventTurnStatusSchema,
     error: deltaErrorSchema.optional(),
-    providerCheckpointId: z26.string().min(1).optional(),
-    claimIfIdle: z26.boolean().optional(),
+    providerCheckpointId: z27.string().min(1).optional(),
+    claimIfIdle: z27.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z26.object({
-    kind: z26.literal("item.open"),
+  z27.object({
+    kind: z27.literal("item.open"),
     key: deltaItemKeySchema,
     item: deltaItemShapeSchema,
     presentation: deltaPresentationSchema.optional(),
@@ -2967,154 +3514,154 @@ var threadDeltaSchema = z26.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }).superRefine(requireExtensionPresentation),
-  z26.object({
-    kind: z26.literal("item.close"),
+  z27.object({
+    kind: z27.literal("item.close"),
     key: deltaItemKeySchema,
     status: threadEventItemStatusSchema,
-    resultText: z26.string().optional(),
-    exitCode: z26.number().optional(),
-    aggregatedOutput: z26.string().optional(),
-    approvalStatus: z26.literal("denied").optional(),
+    resultText: z27.string().optional(),
+    exitCode: z27.number().optional(),
+    aggregatedOutput: z27.string().optional(),
+    approvalStatus: z27.literal("denied").optional(),
     item: deltaItemShapeSchema,
     presentation: deltaPresentationSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }).superRefine(requireExtensionPresentation),
-  z26.object({
-    kind: z26.literal("item.progress"),
+  z27.object({
+    kind: z27.literal("item.progress"),
     key: deltaItemKeySchema,
-    message: z26.string().optional(),
+    message: z27.string().optional(),
     snapshot: deltaProgressSnapshotSchema.optional(),
-    flush: z26.boolean().optional(),
+    flush: z27.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z26.object({
-    kind: z26.literal("item.textDelta"),
+  z27.object({
+    kind: z27.literal("item.textDelta"),
     key: deltaItemKeySchema,
     channel: deltaTextChannelSchema,
-    text: z26.string(),
+    text: z27.string(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z26.object({
-    kind: z26.literal("item.textClose"),
+  z27.object({
+    kind: z27.literal("item.textClose"),
     key: deltaItemKeySchema,
     channel: deltaTextChannelSchema,
-    text: z26.string().optional(),
+    text: z27.string().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z26.object({
-    kind: z26.literal("item.outputDelta"),
+  z27.object({
+    kind: z27.literal("item.outputDelta"),
     key: deltaItemKeySchema,
     channel: deltaOutputChannelSchema,
-    text: z26.string(),
+    text: z27.string(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z26.object({
-    kind: z26.literal("command.outputSnapshot"),
+  z27.object({
+    kind: z27.literal("command.outputSnapshot"),
     key: deltaItemKeySchema,
-    text: z26.string(),
+    text: z27.string(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z26.object({
-    kind: z26.literal("usage"),
+  z27.object({
+    kind: z27.literal("usage"),
     total: threadEventTokenUsageBreakdownSchema,
     last: threadEventTokenUsageBreakdownSchema,
-    modelContextWindow: z26.number().nullable(),
+    modelContextWindow: z27.number().nullable(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z26.object({
-    kind: z26.literal("contextWindow"),
+  z27.object({
+    kind: z27.literal("contextWindow"),
     snapshot: contextSnapshotSchema.optional(),
-    used: z26.number().nullable(),
-    size: z26.number().nullable().optional(),
-    estimated: z26.boolean(),
+    used: z27.number().nullable(),
+    size: z27.number().nullable().optional(),
+    estimated: z27.boolean(),
     attach: deltaAttachSchema,
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z26.object({
-    kind: z26.literal("context.compacted"),
+  z27.object({
+    kind: z27.literal("context.compacted"),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z26.object({ kind: z26.literal("context.cleared") }),
-  z26.object({
-    kind: z26.literal("turn.diff"),
-    diff: z26.string(),
+  z27.object({ kind: z27.literal("context.cleared") }),
+  z27.object({
+    kind: z27.literal("turn.diff"),
+    diff: z27.string(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z26.object({ kind: z26.literal("thread.started") }),
-  z26.object({
-    kind: z26.literal("thread.identity"),
-    providerThreadId: z26.string().min(1)
+  z27.object({ kind: z27.literal("thread.started") }),
+  z27.object({
+    kind: z27.literal("thread.identity"),
+    providerThreadId: z27.string().min(1)
   }),
-  z26.object({ kind: z26.literal("thread.name"), name: z26.string().min(1) }),
-  z26.object({
-    kind: z26.literal("extension.state"),
+  z27.object({ kind: z27.literal("thread.name"), name: z27.string().min(1) }),
+  z27.object({
+    kind: z27.literal("extension.state"),
     extensionKind: extensionKindSchema,
     payload: jsonValueSchema
   }),
-  z26.object({
-    kind: z26.literal("provider.rateLimits"),
+  z27.object({
+    kind: z27.literal("provider.rateLimits"),
     rateLimits: providerRateLimitStateSchema
   }),
-  z26.object({
-    kind: z26.literal("provider.error"),
-    message: z26.string(),
-    detail: z26.string().optional(),
-    willRetry: z26.boolean().optional(),
+  z27.object({
+    kind: z27.literal("provider.error"),
+    message: z27.string(),
+    detail: z27.string().optional(),
+    willRetry: z27.boolean().optional(),
     category: providerErrorCategorySchema.optional(),
     errorInfo: providerErrorInfoSchema.optional(),
-    settlesTurn: z26.boolean().optional(),
+    settlesTurn: z27.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
-    threadScoped: z26.boolean().optional()
+    threadScoped: z27.boolean().optional()
   }),
-  z26.object({
-    kind: z26.literal("provider.modelFallback"),
-    originalModel: z26.string().min(1),
-    fallbackModel: z26.string().min(1),
-    reason: z26.enum(["refusal", "provider"]),
-    message: z26.string()
+  z27.object({
+    kind: z27.literal("provider.modelFallback"),
+    originalModel: z27.string().min(1),
+    fallbackModel: z27.string().min(1),
+    reason: z27.enum(["refusal", "provider"]),
+    message: z27.string()
   }),
-  z26.object({
-    kind: z26.literal("provider.warning"),
-    summary: z26.string().optional(),
-    details: z26.string().optional(),
+  z27.object({
+    kind: z27.literal("provider.warning"),
+    summary: z27.string().optional(),
+    details: z27.string().optional(),
     category: threadEventWarningCategorySchema.optional(),
-    vouchedTurn: z26.boolean().optional()
+    vouchedTurn: z27.boolean().optional()
   }),
-  z26.object({
-    kind: z26.literal("unhandled"),
+  z27.object({
+    kind: z27.literal("unhandled"),
     raw: providerRawEventSchema,
-    rawType: z26.string(),
-    vouchedTurn: z26.boolean(),
-    onlyIfNoTurn: z26.boolean().optional(),
+    rawType: z27.string(),
+    vouchedTurn: z27.boolean(),
+    onlyIfNoTurn: z27.boolean().optional(),
     parentRef: deltaKeyPartSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z26.object({ kind: z26.literal("session.ended") }),
-  z26.object({ kind: z26.literal("session.reset") })
+  z27.object({ kind: z27.literal("session.ended") }),
+  z27.object({ kind: z27.literal("session.reset") })
 ]);
-var threadDeltaNotificationParamsSchema = z26.object({
-  threadId: z26.string().min(1),
-  deltas: z26.array(threadDeltaSchema)
+var threadDeltaNotificationParamsSchema = z27.object({
+  threadId: z27.string().min(1),
+  deltas: z27.array(threadDeltaSchema)
 }).passthrough();
 
 // ../provider-bridge-protocol/src/bridge-kit/adapter-utils.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 
 // ../provider-bridge-protocol/src/bridge-kit/tool-arg-schemas.ts
-import { z as z27 } from "zod";
-var bashArgsSchema = z27.object({
-  command: z27.string().optional(),
-  cwd: z27.string().optional()
+import { z as z28 } from "zod";
+var bashArgsSchema = z28.object({
+  command: z28.string().optional(),
+  cwd: z28.string().optional()
 }).passthrough();
-var textBlockSchema = z27.object({
-  type: z27.literal("text"),
-  text: z27.string()
+var textBlockSchema = z28.object({
+  type: z28.literal("text"),
+  text: z28.string()
 });
 
 // ../provider-bridge-protocol/src/bridge-kit/provider-visibility-helpers.ts
@@ -3127,10 +3674,10 @@ function getStringProperty(value, key) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/adapter-utils.ts
-var contentWrapperSchema = z28.object({
-  content: z28.array(z28.unknown())
+var contentWrapperSchema = z29.object({
+  content: z29.array(z29.unknown())
 }).passthrough();
-var shellEnvironmentVariableKeySchema = z28.string().regex(/^[A-Z_][A-Z0-9_]*$/i);
+var shellEnvironmentVariableKeySchema = z29.string().regex(/^[A-Z_][A-Z0-9_]*$/i);
 function toOptionalString(value) {
   return typeof value === "string" ? value : void 0;
 }
@@ -3484,26 +4031,26 @@ function withoutBridgeRuntimeEnv(env) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/bridge-tool-calls.ts
-import { z as z29 } from "zod";
-var bridgeRequestEnvelopeSchema = z29.object({
-  jsonrpc: z29.literal("2.0"),
-  id: z29.union([z29.string(), z29.number()]),
-  method: z29.string(),
-  params: z29.record(z29.string(), z29.unknown()).optional()
-});
-var jsonRpcErrorSchema = z29.object({
-  code: z29.number(),
-  message: z29.string().optional(),
-  data: z29.unknown().optional()
-});
-var jsonRpcSuccessResponseSchema = z29.object({
-  jsonrpc: z29.literal("2.0"),
-  id: z29.union([z29.string(), z29.number()]),
-  result: z29.unknown()
-});
-var jsonRpcErrorResponseSchema = z29.object({
-  jsonrpc: z29.literal("2.0"),
-  id: z29.union([z29.string(), z29.number()]),
+import { z as z30 } from "zod";
+var bridgeRequestEnvelopeSchema = z30.object({
+  jsonrpc: z30.literal("2.0"),
+  id: z30.union([z30.string(), z30.number()]),
+  method: z30.string(),
+  params: z30.record(z30.string(), z30.unknown()).optional()
+});
+var jsonRpcErrorSchema = z30.object({
+  code: z30.number(),
+  message: z30.string().optional(),
+  data: z30.unknown().optional()
+});
+var jsonRpcSuccessResponseSchema = z30.object({
+  jsonrpc: z30.literal("2.0"),
+  id: z30.union([z30.string(), z30.number()]),
+  result: z30.unknown()
+});
+var jsonRpcErrorResponseSchema = z30.object({
+  jsonrpc: z30.literal("2.0"),
+  id: z30.union([z30.string(), z30.number()]),
   error: jsonRpcErrorSchema
 });
 function isJsonRpcRequest(input) {
@@ -3591,47 +4138,47 @@ function buildBridgeToolCallContent(result) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/json-rpc-envelope.ts
-import { z as z30 } from "zod";
-var recordSchema = z30.record(z30.string(), z30.unknown());
-var jsonRpcEnvelopeSchema = z30.object({
-  jsonrpc: z30.literal("2.0"),
-  method: z30.string(),
+import { z as z31 } from "zod";
+var recordSchema = z31.record(z31.string(), z31.unknown());
+var jsonRpcEnvelopeSchema = z31.object({
+  jsonrpc: z31.literal("2.0"),
+  method: z31.string(),
   params: recordSchema.optional()
 }).passthrough();
-var sdkMessageEnvelopeSchema = z30.object({
-  jsonrpc: z30.literal("2.0"),
-  method: z30.literal("sdk/message"),
-  params: z30.object({
-    message: z30.unknown(),
-    threadId: z30.string().optional(),
-    parent_tool_use_id: z30.string().optional()
+var sdkMessageEnvelopeSchema = z31.object({
+  jsonrpc: z31.literal("2.0"),
+  method: z31.literal("sdk/message"),
+  params: z31.object({
+    message: z31.unknown(),
+    threadId: z31.string().optional(),
+    parent_tool_use_id: z31.string().optional()
   }).passthrough()
 }).passthrough();
-var threadIdentityEnvelopeSchema = z30.object({
-  jsonrpc: z30.literal("2.0"),
-  method: z30.literal("thread/identity"),
-  params: z30.object({
-    threadId: z30.string().optional(),
-    providerThreadId: z30.string().optional()
+var threadIdentityEnvelopeSchema = z31.object({
+  jsonrpc: z31.literal("2.0"),
+  method: z31.literal("thread/identity"),
+  params: z31.object({
+    threadId: z31.string().optional(),
+    providerThreadId: z31.string().optional()
   }).passthrough()
 }).passthrough();
-var threadContextWindowUsageEnvelopeSchema = z30.object({
-  jsonrpc: z30.literal("2.0"),
-  method: z30.literal("thread/contextWindowUsage/updated"),
-  params: z30.object({
-    threadId: z30.string().optional(),
-    contextWindowUsage: z30.object({
-      usedTokens: z30.number().nullable(),
-      modelContextWindow: z30.number().nullable(),
-      estimated: z30.boolean()
+var threadContextWindowUsageEnvelopeSchema = z31.object({
+  jsonrpc: z31.literal("2.0"),
+  method: z31.literal("thread/contextWindowUsage/updated"),
+  params: z31.object({
+    threadId: z31.string().optional(),
+    contextWindowUsage: z31.object({
+      usedTokens: z31.number().nullable(),
+      modelContextWindow: z31.number().nullable(),
+      estimated: z31.boolean()
     })
   }).passthrough()
 }).passthrough();
-var errorEnvelopeSchema = z30.object({
-  jsonrpc: z30.literal("2.0"),
-  method: z30.literal("error"),
-  params: z30.object({
-    message: z30.string().optional()
+var errorEnvelopeSchema = z31.object({
+  jsonrpc: z31.literal("2.0"),
+  method: z31.literal("error"),
+  params: z31.object({
+    message: z31.string().optional()
   }).passthrough().optional()
 }).passthrough();
 
@@ -3733,12 +4280,14 @@ function experimental_defineProviderBridge(definition) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/provider-maintenance-kit.ts
+var import_compare = __toESM(require_compare(), 1);
+var import_valid = __toESM(require_valid(), 1);
 import { execFile } from "node:child_process";
 import { constants as fsConstants } from "node:fs";
 import { access } from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var execFileAsync = promisify(execFile);
 var CLI_PROBE_TIMEOUT_MS = 5e3;
 async function resolveExecutablePath(command) {
@@ -3760,6 +4309,10 @@ async function resolveExecutablePath(command) {
     return null;
   }
 }
+function versionFrom(value) {
+  const candidate = value?.match(/\bv?(\d+\.\d+\.\d+[0-9A-Za-z.+-]*)/u)?.[1];
+  return candidate !== void 0 && (0, import_valid.default)(candidate) !== null ? candidate : null;
+}
 async function readCliVersion(command) {
   try {
     const probe = execFileAsync(command, ["--version"], {
@@ -3767,8 +4320,8 @@ async function readCliVersion(command) {
     });
     probe.child.stdin?.end();
     const { stdout, stderr } = await probe;
-    return `${stdout}
-${stderr}`.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/u)?.[0] ?? null;
+    return versionFrom(`${stdout}
+${stderr}`);
   } catch {
     return null;
   }
@@ -3790,9 +4343,9 @@ function clampPercent(value) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/provider-tool-call-contract.ts
-import { z as z32 } from "zod";
-var providerToolCallCancellationSchema = z32.object({
-  requestId: z32.union([z32.string(), z32.number().int()])
+import { z as z33 } from "zod";
+var providerToolCallCancellationSchema = z33.object({
+  requestId: z33.union([z33.string(), z33.number().int()])
 });
 var PROVIDER_TOOL_CALL_CANCELLED_METHOD = "notifications/cancelled";
 
@@ -3808,8 +4361,8 @@ function createProviderVisibilityMetadata(args) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/runtime-json-rpc.ts
-import { z as z33 } from "zod";
-var ignoredJsonRpcResultSchema = z33.unknown();
+import { z as z34 } from "zod";
+var ignoredJsonRpcResultSchema = z34.unknown();
 
 // ../provider-bridge-acp/src/bridge/bridge.ts
 import { execFile as execFile4 } from "node:child_process";
@@ -3819,21 +4372,21 @@ import { createServer } from "node:net";
 import { dirname as dirname2, isAbsolute, basename as basename3, relative, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 
 // ../provider-bridge-acp/src/bridge-protocol.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 
 // ../provider-bridge-acp/src/wire.ts
-import { z as z34 } from "zod";
-var acpTextContentBlockSchema = z34.object({
-  type: z34.literal("text"),
-  text: z34.string()
+import { z as z35 } from "zod";
+var acpTextContentBlockSchema = z35.object({
+  type: z35.literal("text"),
+  text: z35.string()
 }).passthrough();
-var acpOtherContentBlockSchema = z34.object({
-  type: z34.string()
+var acpOtherContentBlockSchema = z35.object({
+  type: z35.string()
 }).passthrough();
-var acpContentBlockSchema = z34.union([
+var acpContentBlockSchema = z35.union([
   acpTextContentBlockSchema,
   acpOtherContentBlockSchema
 ]);
@@ -3856,7 +4409,7 @@ var ACP_TOOL_KINDS = [
   "switch_mode",
   "other"
 ];
-var acpToolKindSchema = z34.enum(ACP_TOOL_KINDS);
+var acpToolKindSchema = z35.enum(ACP_TOOL_KINDS);
 var ACP_TOOL_KIND_SET = new Set(ACP_TOOL_KINDS);
 var ACP_TOOL_CALL_STATUSES = [
   "pending",
@@ -3865,48 +4418,48 @@ var ACP_TOOL_CALL_STATUSES = [
   "failed",
   "cancelled"
 ];
-var acpToolCallStatusSchema = z34.enum(ACP_TOOL_CALL_STATUSES);
+var acpToolCallStatusSchema = z35.enum(ACP_TOOL_CALL_STATUSES);
 var ACP_TOOL_CALL_STATUS_SET = new Set(
   ACP_TOOL_CALL_STATUSES
 );
-var acpToolCallContentSchema = z34.union([
-  z34.object({
-    type: z34.literal("content"),
+var acpToolCallContentSchema = z35.union([
+  z35.object({
+    type: z35.literal("content"),
     content: acpContentBlockSchema
   }).passthrough(),
-  z34.object({
-    type: z34.literal("diff"),
-    path: z34.string(),
-    oldText: z34.string().nullable().optional(),
-    newText: z34.string()
+  z35.object({
+    type: z35.literal("diff"),
+    path: z35.string(),
+    oldText: z35.string().nullable().optional(),
+    newText: z35.string()
   }).passthrough(),
-  z34.object({
-    type: z34.literal("terminal"),
-    terminalId: z34.string()
+  z35.object({
+    type: z35.literal("terminal"),
+    terminalId: z35.string()
   }).passthrough()
 ]);
-var acpToolCallContentListSchema = z34.array(z34.unknown()).transform(
+var acpToolCallContentListSchema = z35.array(z35.unknown()).transform(
   (entries) => entries.flatMap((entry) => {
     const parsed = acpToolCallContentSchema.safeParse(entry);
     return parsed.success ? [parsed.data] : [];
   })
 );
-var acpToolCallLocationSchema = z34.object({
-  path: z34.string(),
-  line: z34.number().optional().nullable()
+var acpToolCallLocationSchema = z35.object({
+  path: z35.string(),
+  line: z35.number().optional().nullable()
 }).passthrough();
-var acpToolCallNameSchema = z34.union([z34.string(), z34.null()]).transform((value) => value ?? void 0).optional();
-var acpToolCallFieldsSchema = z34.object({
-  toolCallId: z34.string(),
-  title: z34.string().optional(),
+var acpToolCallNameSchema = z35.union([z35.string(), z35.null()]).transform((value) => value ?? void 0).optional();
+var acpToolCallFieldsSchema = z35.object({
+  toolCallId: z35.string(),
+  title: z35.string().optional(),
   name: acpToolCallNameSchema,
   kind: acpToolKindSchema.optional(),
-  rawKind: z34.string().optional(),
+  rawKind: z35.string().optional(),
   status: acpToolCallStatusSchema.optional(),
   content: acpToolCallContentListSchema.optional(),
-  locations: z34.array(acpToolCallLocationSchema).optional(),
-  rawInput: z34.unknown().optional(),
-  rawOutput: z34.unknown().optional()
+  locations: z35.array(acpToolCallLocationSchema).optional(),
+  rawInput: z35.unknown().optional(),
+  rawOutput: z35.unknown().optional()
 });
 function openAcpToolCallEnums(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -3932,43 +4485,43 @@ function openAcpToolCallEnums(value) {
   }
   return next;
 }
-var acpAgentMessageChunkUpdateSchema = z34.object({
-  sessionUpdate: z34.literal("agent_message_chunk"),
+var acpAgentMessageChunkUpdateSchema = z35.object({
+  sessionUpdate: z35.literal("agent_message_chunk"),
   content: acpContentBlockSchema
 }).passthrough();
-var acpAgentThoughtChunkUpdateSchema = z34.object({
-  sessionUpdate: z34.literal("agent_thought_chunk"),
+var acpAgentThoughtChunkUpdateSchema = z35.object({
+  sessionUpdate: z35.literal("agent_thought_chunk"),
   content: acpContentBlockSchema
 }).passthrough();
-var acpToolCallUpdateEventSchema = z34.preprocess(
+var acpToolCallUpdateEventSchema = z35.preprocess(
   openAcpToolCallEnums,
   acpToolCallFieldsSchema.extend({
-    sessionUpdate: z34.enum(["tool_call", "tool_call_update"])
+    sessionUpdate: z35.enum(["tool_call", "tool_call_update"])
   }).passthrough()
 );
-var acpPlanEntryStatusSchema = z34.enum([
+var acpPlanEntryStatusSchema = z35.enum([
   "pending",
   "in_progress",
   "completed"
 ]);
-var acpPlanUpdateSchema = z34.object({
-  sessionUpdate: z34.literal("plan"),
-  entries: z34.array(
-    z34.object({
-      content: z34.string(),
+var acpPlanUpdateSchema = z35.object({
+  sessionUpdate: z35.literal("plan"),
+  entries: z35.array(
+    z35.object({
+      content: z35.string(),
       status: acpPlanEntryStatusSchema.optional()
     }).passthrough()
   )
 }).passthrough();
-var acpUsageUpdateSchema = z34.object({
-  sessionUpdate: z34.literal("usage_update"),
-  used: z34.number().int().nonnegative(),
-  size: z34.number().int().nonnegative()
+var acpUsageUpdateSchema = z35.object({
+  sessionUpdate: z35.literal("usage_update"),
+  used: z35.number().int().nonnegative(),
+  size: z35.number().int().nonnegative()
 }).passthrough();
-var acpOtherSessionUpdateSchema = z34.object({
-  sessionUpdate: z34.string()
+var acpOtherSessionUpdateSchema = z35.object({
+  sessionUpdate: z35.string()
 }).passthrough();
-var acpSessionUpdateSchema = z34.union([
+var acpSessionUpdateSchema = z35.union([
   acpAgentMessageChunkUpdateSchema,
   acpAgentThoughtChunkUpdateSchema,
   acpToolCallUpdateEventSchema,
@@ -3976,55 +4529,55 @@ var acpSessionUpdateSchema = z34.union([
   acpUsageUpdateSchema,
   acpOtherSessionUpdateSchema
 ]);
-var acpSessionNotificationParamsSchema = z34.object({
-  sessionId: z34.string(),
+var acpSessionNotificationParamsSchema = z35.object({
+  sessionId: z35.string(),
   update: acpSessionUpdateSchema
 }).passthrough();
 var ACP_PROTOCOL_VERSION = 1;
-var acpInitializeResultSchema = z34.object({
-  protocolVersion: z34.number(),
-  agentCapabilities: z34.object({
-    loadSession: z34.boolean().optional(),
-    sessionCapabilities: z34.object({
-      fork: z34.object({}).passthrough().nullable().optional()
+var acpInitializeResultSchema = z35.object({
+  protocolVersion: z35.number(),
+  agentCapabilities: z35.object({
+    loadSession: z35.boolean().optional(),
+    sessionCapabilities: z35.object({
+      fork: z35.object({}).passthrough().nullable().optional()
     }).passthrough().optional(),
-    promptCapabilities: z34.object({
-      image: z34.boolean().optional(),
-      audio: z34.boolean().optional(),
-      embeddedContext: z34.boolean().optional()
+    promptCapabilities: z35.object({
+      image: z35.boolean().optional(),
+      audio: z35.boolean().optional(),
+      embeddedContext: z35.boolean().optional()
     }).passthrough().optional()
   }).passthrough().optional(),
-  authMethods: z34.array(z34.object({ id: z34.string() }).passthrough()).optional()
+  authMethods: z35.array(z35.object({ id: z35.string() }).passthrough()).optional()
 }).passthrough();
-var acpOptionalString = z34.union([z34.string(), z34.null()]).transform((value) => value ?? void 0).optional();
-var acpConfigOptionSelectOptionSchema = z34.object({
-  value: z34.string(),
+var acpOptionalString = z35.union([z35.string(), z35.null()]).transform((value) => value ?? void 0).optional();
+var acpConfigOptionSelectOptionSchema = z35.object({
+  value: z35.string(),
   name: acpOptionalString
 }).passthrough();
-var acpConfigOptionSchema = z34.object({
-  id: z34.string(),
+var acpConfigOptionSchema = z35.object({
+  id: z35.string(),
   name: acpOptionalString,
   category: acpOptionalString,
-  type: z34.string(),
+  type: z35.string(),
   currentValue: acpOptionalString,
-  options: z34.array(acpConfigOptionSelectOptionSchema).optional()
+  options: z35.array(acpConfigOptionSelectOptionSchema).optional()
 }).passthrough();
-var acpSessionModelSchema = z34.object({
-  modelId: z34.string(),
+var acpSessionModelSchema = z35.object({
+  modelId: z35.string(),
   name: acpOptionalString,
   description: acpOptionalString
 }).passthrough();
-var acpSessionModelsSchema = z34.object({
+var acpSessionModelsSchema = z35.object({
   currentModelId: acpOptionalString,
-  availableModels: z34.array(acpSessionModelSchema).optional()
+  availableModels: z35.array(acpSessionModelSchema).optional()
 }).passthrough();
-var acpLooseConfigOptionSchema = z34.object({
-  id: z34.string().optional(),
-  name: z34.unknown().optional(),
+var acpLooseConfigOptionSchema = z35.object({
+  id: z35.string().optional(),
+  name: z35.unknown().optional(),
   category: acpOptionalString,
-  type: z34.unknown().optional(),
-  currentValue: z34.unknown().optional(),
-  options: z34.unknown().optional()
+  type: z35.unknown().optional(),
+  currentValue: z35.unknown().optional(),
+  options: z35.unknown().optional()
 }).passthrough();
 function parseAcpConfigOptions(options, ctx) {
   if (options == null) {
@@ -4068,119 +4621,119 @@ function parseAcpConfigOptions(options, ctx) {
   }
   return parsedOptions;
 }
-var acpSessionNewResultSchema = z34.object({
-  sessionId: z34.string(),
+var acpSessionNewResultSchema = z35.object({
+  sessionId: z35.string(),
   models: acpSessionModelsSchema.optional(),
-  configOptions: z34.array(z34.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
+  configOptions: z35.array(z35.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
 }).passthrough();
-var acpConfigStateResultSchema = z34.object({
+var acpConfigStateResultSchema = z35.object({
   models: acpSessionModelsSchema.optional(),
-  configOptions: z34.array(z34.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
+  configOptions: z35.array(z35.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
 }).passthrough();
 var acpSessionForkResultSchema = acpConfigStateResultSchema.extend({
-  sessionId: z34.string()
+  sessionId: z35.string()
 });
-var acpStopReasonSchema = z34.enum([
+var acpStopReasonSchema = z35.enum([
   "end_turn",
   "max_tokens",
   "max_turn_requests",
   "refusal",
   "cancelled"
 ]);
-var acpPromptResultSchema = z34.object({
+var acpPromptResultSchema = z35.object({
   stopReason: acpStopReasonSchema
 }).passthrough();
-var acpPermissionOptionKindSchema = z34.enum([
+var acpPermissionOptionKindSchema = z35.enum([
   "allow_once",
   "allow_always",
   "reject_once",
   "reject_always"
 ]);
-var acpPermissionOptionSchema = z34.object({
-  optionId: z34.string(),
-  name: z34.string(),
+var acpPermissionOptionSchema = z35.object({
+  optionId: z35.string(),
+  name: z35.string(),
   kind: acpPermissionOptionKindSchema
 }).passthrough();
-var acpRequestPermissionParamsSchema = z34.object({
-  sessionId: z34.string(),
-  toolCall: z34.preprocess(
+var acpRequestPermissionParamsSchema = z35.object({
+  sessionId: z35.string(),
+  toolCall: z35.preprocess(
     openAcpToolCallEnums,
     acpToolCallFieldsSchema.partial().passthrough()
   ).optional(),
-  options: z34.array(acpPermissionOptionSchema).min(1)
+  options: z35.array(acpPermissionOptionSchema).min(1)
 }).passthrough();
-var acpReadTextFileParamsSchema = z34.object({
-  sessionId: z34.string(),
-  path: z34.string(),
-  line: z34.number().nullable().optional(),
-  limit: z34.number().nullable().optional()
+var acpReadTextFileParamsSchema = z35.object({
+  sessionId: z35.string(),
+  path: z35.string(),
+  line: z35.number().nullable().optional(),
+  limit: z35.number().nullable().optional()
 }).passthrough();
-var acpWriteTextFileParamsSchema = z34.object({
-  sessionId: z34.string(),
-  path: z34.string(),
-  content: z34.string()
+var acpWriteTextFileParamsSchema = z35.object({
+  sessionId: z35.string(),
+  path: z35.string(),
+  content: z35.string()
 }).passthrough();
 
 // ../provider-bridge-acp/src/bridge-protocol.ts
 var ACP_DEFAULT_MODEL_ID = "acp-default";
 var acpModelListParamsSchema = modelListParamsSchema.extend({
-  providerOptions: z35.record(z35.string(), z35.unknown()).optional()
+  providerOptions: z36.record(z36.string(), z36.unknown()).optional()
 });
-var acpBridgeCommandSchema = z35.discriminatedUnion("method", [
-  z35.object({
-    method: z35.literal("initialize"),
+var acpBridgeCommandSchema = z36.discriminatedUnion("method", [
+  z36.object({
+    method: z36.literal("initialize"),
     params: initializeParamsSchema
   }),
-  z35.object({
-    method: z35.literal("model/list"),
+  z36.object({
+    method: z36.literal("model/list"),
     params: acpModelListParamsSchema
   }),
-  z35.object({
-    method: z35.literal("provider/health"),
+  z36.object({
+    method: z36.literal("provider/health"),
     params: providerMaintenanceParamsSchema
   }),
-  z35.object({
-    method: z35.literal("provider/usage"),
+  z36.object({
+    method: z36.literal("provider/usage"),
     params: providerMaintenanceParamsSchema
   }),
-  z35.object({
-    method: z35.literal("provider/installation/status"),
+  z36.object({
+    method: z36.literal("provider/installation/status"),
     params: providerInstallationStatusParamsSchema
   }),
-  z35.object({
-    method: z35.literal("provider/installation/run"),
+  z36.object({
+    method: z36.literal("provider/installation/run"),
     params: providerInstallationRunParamsSchema
   }),
-  z35.object({
-    method: z35.literal("thread/start"),
+  z36.object({
+    method: z36.literal("thread/start"),
     params: threadStartParamsSchema
   }),
-  z35.object({
-    method: z35.literal("thread/resume"),
+  z36.object({
+    method: z36.literal("thread/resume"),
     params: threadResumeParamsSchema
   }),
-  z35.object({
-    method: z35.literal("thread/fork"),
+  z36.object({
+    method: z36.literal("thread/fork"),
     params: threadForkParamsSchema
   }),
-  z35.object({
-    method: z35.literal("turn/start"),
+  z36.object({
+    method: z36.literal("turn/start"),
     params: turnStartParamsSchema
   }),
-  z35.object({
-    method: z35.literal("turn/steer"),
+  z36.object({
+    method: z36.literal("turn/steer"),
     params: turnSteerParamsSchema
   }),
-  z35.object({
-    method: z35.literal("thread/stop"),
+  z36.object({
+    method: z36.literal("thread/stop"),
     params: threadStopParamsSchema
   }),
-  z35.object({
-    method: z35.literal("thread/discard"),
+  z36.object({
+    method: z36.literal("thread/discard"),
     params: threadDiscardParamsSchema
   }),
-  z35.object({
-    method: z35.literal("skills/configure"),
+  z36.object({
+    method: z36.literal("skills/configure"),
     params: skillsConfigureParamsSchema
   })
 ]);
@@ -4195,53 +4748,53 @@ var ACP_UPDATE_METHOD = "acp/update";
 var ACP_FS_WRITE_METHOD = "acp/fs/write";
 var ACP_WARNING_METHOD = "acp/warning";
 var ACP_BRIDGE_NO_ACTIVE_TURN_ERROR_CODE = -32001;
-var acpTurnStartedNotificationParamsSchema = z35.object({
-  threadId: z35.string().min(1)
+var acpTurnStartedNotificationParamsSchema = z36.object({
+  threadId: z36.string().min(1)
 }).passthrough();
-var acpTurnCompletedNotificationParamsSchema = z35.object({
-  threadId: z35.string().min(1),
+var acpTurnCompletedNotificationParamsSchema = z36.object({
+  threadId: z36.string().min(1),
   stopReason: acpStopReasonSchema
 }).passthrough();
-var acpCompactionCompletedNotificationParamsSchema = z35.discriminatedUnion("status", [
-  z35.object({
-    threadId: z35.string().min(1),
-    status: z35.literal("completed")
+var acpCompactionCompletedNotificationParamsSchema = z36.discriminatedUnion("status", [
+  z36.object({
+    threadId: z36.string().min(1),
+    status: z36.literal("completed")
   }).passthrough(),
-  z35.object({
-    threadId: z35.string().min(1),
-    status: z35.literal("interrupted")
+  z36.object({
+    threadId: z36.string().min(1),
+    status: z36.literal("interrupted")
   }).passthrough(),
-  z35.object({
-    threadId: z35.string().min(1),
-    status: z35.literal("skipped"),
-    detail: z35.string().min(1)
+  z36.object({
+    threadId: z36.string().min(1),
+    status: z36.literal("skipped"),
+    detail: z36.string().min(1)
   }).passthrough(),
-  z35.object({
-    threadId: z35.string().min(1),
-    status: z35.literal("failed"),
-    error: z35.string().min(1)
+  z36.object({
+    threadId: z36.string().min(1),
+    status: z36.literal("failed"),
+    error: z36.string().min(1)
   }).passthrough()
 ]);
-var acpUpdateNotificationParamsSchema = z35.object({
-  threadId: z35.string().min(1),
+var acpUpdateNotificationParamsSchema = z36.object({
+  threadId: z36.string().min(1),
   update: acpSessionUpdateSchema
 }).passthrough();
-var acpFsWriteNotificationParamsSchema = z35.object({
-  threadId: z35.string().min(1),
-  path: z35.string().min(1),
-  kind: z35.enum(["add", "update"]),
-  oldText: z35.string().optional(),
-  content: z35.string()
+var acpFsWriteNotificationParamsSchema = z36.object({
+  threadId: z36.string().min(1),
+  path: z36.string().min(1),
+  kind: z36.enum(["add", "update"]),
+  oldText: z36.string().optional(),
+  content: z36.string()
 }).passthrough();
-var acpWarningNotificationParamsSchema = z35.object({
-  threadId: z35.string().min(1),
-  summary: z35.string().min(1),
-  details: z35.string().optional()
+var acpWarningNotificationParamsSchema = z36.object({
+  threadId: z36.string().min(1),
+  summary: z36.string().min(1),
+  details: z36.string().optional()
 }).passthrough();
 
 // ../provider-bridge-acp/src/dialect.ts
 import { basename } from "node:path";
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 
 // ../provider-bridge-acp/src/bridge/provider-maintenance.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -4251,7 +4804,7 @@ import os from "node:os";
 import path2 from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { promisify as promisify2 } from "node:util";
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var execFileAsync2 = promisify2(execFile2);
 var USAGE_FETCH_TIMEOUT_MS = 15e3;
 var CURSOR_DASHBOARD_URL = "https://api2.cursor.sh/aiserver.v1.DashboardService";
@@ -4289,8 +4842,8 @@ async function readKeychainAccessToken() {
     return null;
   }
 }
-var cursorFileCredentialsSchema = z36.object({
-  accessToken: z36.string().min(1).nullish()
+var cursorFileCredentialsSchema = z37.object({
+  accessToken: z37.string().min(1).nullish()
 });
 async function readAccessToken() {
   const keychain = await readKeychainAccessToken();
@@ -4337,7 +4890,7 @@ function readAccountEmail() {
     database = new DatabaseSync(databasePath);
     database.exec("PRAGMA query_only = true");
     const row = database.prepare("SELECT value FROM ItemTable WHERE key = ?").get("cursorAuth/cachedEmail");
-    const parsed = z36.object({ value: z36.string().email() }).safeParse(row);
+    const parsed = z37.object({ value: z37.string().email() }).safeParse(row);
     return parsed.success ? parsed.data.value : null;
   } catch {
     return null;
@@ -4441,14 +4994,14 @@ function buildAcpProviderInstallationRun(status, args) {
     verification: { kind: "installed" }
   };
 }
-var cursorNonNegativeIntegerSchema = z36.union([
-  z36.number().int().nonnegative(),
-  z36.string().regex(/^\d+$/u).transform(Number)
+var cursorNonNegativeIntegerSchema = z37.union([
+  z37.number().int().nonnegative(),
+  z37.string().regex(/^\d+$/u).transform(Number)
 ]).refine(Number.isSafeInteger);
-var cursorUsageResponseSchema = z36.object({
+var cursorUsageResponseSchema = z37.object({
   billingCycleEnd: cursorNonNegativeIntegerSchema.nullish(),
-  planUsage: z36.object({ totalPercentUsed: z36.number().nonnegative().default(0) }).nullish(),
-  spendLimitUsage: z36.object({
+  planUsage: z37.object({ totalPercentUsed: z37.number().nonnegative().default(0) }).nullish(),
+  spendLimitUsage: z37.object({
     overallLimit: cursorNonNegativeIntegerSchema.nullish(),
     overallUsed: cursorNonNegativeIntegerSchema.nullish(),
     individualLimit: cursorNonNegativeIntegerSchema.nullish(),
@@ -4457,8 +5010,8 @@ var cursorUsageResponseSchema = z36.object({
     pooledUsed: cursorNonNegativeIntegerSchema.nullish()
   }).nullish()
 }).passthrough();
-var cursorPlanResponseSchema = z36.object({
-  planInfo: z36.object({ planName: z36.string().min(1) }).nullish()
+var cursorPlanResponseSchema = z37.object({
+  planInfo: z37.object({ planName: z37.string().min(1) }).nullish()
 }).passthrough();
 function normalizeUsage(rawUsage, rawPlan, accountEmail = null) {
   const usage = cursorUsageResponseSchema.safeParse(rawUsage);
@@ -4670,17 +5223,17 @@ function toolKindPresentation(args) {
 }
 
 // ../provider-bridge-acp/src/tool-classification.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 
 // ../provider-bridge-acp/src/tool-call-operation.ts
 import path3 from "node:path";
-import { z as z37 } from "zod";
-var acpRawInputCommandSchema = z37.object({ command: z37.string() }).passthrough();
-var acpRawInputPathSchema = z37.object({
-  path: z37.string().optional(),
-  filePath: z37.string().optional(),
-  file_path: z37.string().optional(),
-  target_file: z37.string().optional()
+import { z as z38 } from "zod";
+var acpRawInputCommandSchema = z38.object({ command: z38.string() }).passthrough();
+var acpRawInputPathSchema = z38.object({
+  path: z38.string().optional(),
+  filePath: z38.string().optional(),
+  file_path: z38.string().optional(),
+  target_file: z38.string().optional()
 }).passthrough();
 function resolveAcpToolCallPath(value, options) {
   const cwd = options?.cwd;
@@ -4857,14 +5410,14 @@ function extractAcpToolCallOutputText(event) {
   ).trim();
   return rawOutputText.length > 0 ? rawOutputText : void 0;
 }
-var commandRawOutputSchema = z38.object({
-  exitCode: z38.number().int().nullable().optional(),
-  exit_code: z38.number().int().nullable().optional(),
-  stdout: z38.string().optional(),
-  stderr: z38.string().optional(),
-  output_for_prompt: z38.string().optional(),
-  signal: z38.string().nullable().optional(),
-  timed_out: z38.boolean().optional()
+var commandRawOutputSchema = z39.object({
+  exitCode: z39.number().int().nullable().optional(),
+  exit_code: z39.number().int().nullable().optional(),
+  stdout: z39.string().optional(),
+  stderr: z39.string().optional(),
+  output_for_prompt: z39.string().optional(),
+  signal: z39.string().nullable().optional(),
+  timed_out: z39.boolean().optional()
 }).passthrough();
 function emptyToUndefined(value) {
   return value === void 0 || value.length === 0 ? void 0 : value;
@@ -4933,10 +5486,10 @@ function extractAcpCommandResult(event) {
     ...output === void 0 ? {} : { output: scrubInlineImageDataUrls(output) }
   };
 }
-var optionalNonBlank = z38.string().optional().transform(
+var optionalNonBlank = z39.string().optional().transform(
   (value) => value !== void 0 && value.trim().length > 0 ? value : void 0
 );
-var searchRawInputSchema = z38.object({
+var searchRawInputSchema = z39.object({
   pattern: optionalNonBlank,
   query: optionalNonBlank,
   regex: optionalNonBlank,
@@ -4945,8 +5498,8 @@ var searchRawInputSchema = z38.object({
   path: optionalNonBlank,
   directory: optionalNonBlank
 }).passthrough();
-var fetchRawInputSchema = z38.object({ url: optionalNonBlank, uri: optionalNonBlank }).passthrough();
-var thinkRawInputSchema = z38.object({ thought: optionalNonBlank, thinking: optionalNonBlank }).passthrough();
+var fetchRawInputSchema = z39.object({ url: optionalNonBlank, uri: optionalNonBlank }).passthrough();
+var thinkRawInputSchema = z39.object({ thought: optionalNonBlank, thinking: optionalNonBlank }).passthrough();
 var SINGLE_TICKED_TOKEN_PATTERN = /^[^`]*`([^`\n]+)`[^`]*$/;
 var URL_PATTERN = /https?:\/\/[^\s`'"<>]+/g;
 function tickedTokenFromTitle(title) {
@@ -5139,10 +5692,10 @@ function classifyAcpToolCall2(event, injected, options) {
 
 // ../provider-bridge-acp/src/dialect.ts
 var GENERIC_ACP_DIALECT = { id: "acp" };
-var grokToolMetaSchema = z39.object({
-  "x.ai/tool": z39.object({
-    name: z39.string().optional(),
-    kind: z39.string().optional()
+var grokToolMetaSchema = z40.object({
+  "x.ai/tool": z40.object({
+    name: z40.string().optional(),
+    kind: z40.string().optional()
   }).passthrough()
 }).passthrough();
 function grokToolIdentity(event) {
@@ -5158,10 +5711,10 @@ function grokToolIdentity(event) {
   };
 }
 var GROK_SPAWN_SUBAGENT_TOOL = "spawn_subagent";
-var grokSpawnSubagentInputSchema = z39.object({
-  description: z39.string().optional(),
-  prompt: z39.string().optional(),
-  subagent_type: z39.string().optional()
+var grokSpawnSubagentInputSchema = z40.object({
+  description: z40.string().optional(),
+  prompt: z40.string().optional(),
+  subagent_type: z40.string().optional()
 }).passthrough();
 function grokClassifyToolCall(event) {
   if (grokToolIdentity(event)?.name !== GROK_SPAWN_SUBAGENT_TOOL) {
@@ -5190,14 +5743,14 @@ var GROK_ACP_DIALECT = {
   classifyToolCall: grokClassifyToolCall
 };
 var CURSOR_TASK_TOOL = "task";
-var cursorTaskRawInputSchema = z39.object({ _toolName: z39.string().optional() }).passthrough();
+var cursorTaskRawInputSchema = z40.object({ _toolName: z40.string().optional() }).passthrough();
 var CURSOR_TASK_METHOD = "cursor/task";
-var cursorTaskParamsSchema = z39.object({
-  toolCallId: z39.string(),
-  description: z39.string().optional(),
-  prompt: z39.string().optional(),
-  agentId: z39.string().optional(),
-  model: z39.string().optional()
+var cursorTaskParamsSchema = z40.object({
+  toolCallId: z40.string(),
+  description: z40.string().optional(),
+  prompt: z40.string().optional(),
+  agentId: z40.string().optional(),
+  model: z40.string().optional()
 }).passthrough();
 function cursorClassifyToolCall(event) {
   const parsed = cursorTaskRawInputSchema.safeParse(event.rawInput);
@@ -5245,23 +5798,23 @@ var CURSOR_ACP_DIALECT = {
   handleClientRequest: cursorHandleClientRequest,
   maintenance: CURSOR_ACP_MAINTENANCE
 };
-var ompBashRawInputSchema = z39.object({
-  command: z39.string(),
-  async: z39.boolean().optional()
+var ompBashRawInputSchema = z40.object({
+  command: z40.string(),
+  async: z40.boolean().optional()
 }).passthrough();
 var ompBashRawOutputSchema = commandRawOutputSchema.extend({
-  content: z39.array(
-    z39.object({
-      type: z39.literal("text"),
-      text: z39.string()
+  content: z40.array(
+    z40.object({
+      type: z40.literal("text"),
+      text: z40.string()
     }).passthrough()
   ),
-  details: z39.object({
-    exitCode: z39.number().int().optional(),
-    wallTimeMs: z39.number().nonnegative().optional(),
-    timedOut: z39.boolean().optional(),
-    signal: z39.unknown().optional(),
-    async: z39.unknown().optional()
+  details: z40.object({
+    exitCode: z40.number().int().optional(),
+    wallTimeMs: z40.number().nonnegative().optional(),
+    timedOut: z40.boolean().optional(),
+    signal: z40.unknown().optional(),
+    async: z40.unknown().optional()
   }).passthrough()
 });
 function stripOmpTrailingNotice(text, notice) {
@@ -5324,11 +5877,11 @@ var OMP_ACP_DIALECT = {
   id: "omp",
   commandResult: ompCommandResult
 };
-var openCodeCommandRawOutputSchema = z39.object({
-  output: z39.unknown().optional(),
-  metadata: z39.object({
-    exit: z39.number().int().nullable().optional(),
-    output: z39.string().optional()
+var openCodeCommandRawOutputSchema = z40.object({
+  output: z40.unknown().optional(),
+  metadata: z40.object({
+    exit: z40.number().int().nullable().optional(),
+    output: z40.string().optional()
   }).passthrough().optional()
 }).passthrough();
 function normalizeOpenCodeCommandEvent(event) {
@@ -7246,7 +7799,7 @@ import { basename as basename2, dirname, join as join2, resolve as resolve2 } fr
 // ../provider-bridge-acp/src/bridge/tool-proxy-mcp.ts
 import { createConnection } from "node:net";
 import { createInterface as createInterface2 } from "node:readline";
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var ACP_BRIDGE_MCP_SERVER_NAME = "bb-bridge";
 var ENV_HOST = "BB_ACP_DYNAMIC_TOOL_HOST";
 var ENV_PORT = "BB_ACP_DYNAMIC_TOOL_PORT";
@@ -7254,45 +7807,45 @@ var ENV_TOKEN = "BB_ACP_DYNAMIC_TOOL_TOKEN";
 var ENV_THREAD_ID = "BB_ACP_DYNAMIC_TOOL_THREAD_ID";
 var ENV_TOOLS = "BB_ACP_DYNAMIC_TOOLS";
 var ENV_PROGRESS_INTERVAL_MS = "BB_ACP_DYNAMIC_TOOL_PROGRESS_INTERVAL_MS";
-var dynamicToolBridgeRequestSchema = z40.discriminatedUnion("kind", [
-  z40.object({
-    kind: z40.literal("initialized"),
-    threadId: z40.string().min(1),
-    token: z40.string().min(1),
-    toolCount: z40.number().int().nonnegative()
+var dynamicToolBridgeRequestSchema = z41.discriminatedUnion("kind", [
+  z41.object({
+    kind: z41.literal("initialized"),
+    threadId: z41.string().min(1),
+    token: z41.string().min(1),
+    toolCount: z41.number().int().nonnegative()
   }),
-  z40.object({
-    kind: z40.literal("toolCall"),
-    arguments: z40.record(z40.string(), z40.unknown()).default({}),
-    callId: z40.string().min(1),
-    threadId: z40.string().min(1),
-    token: z40.string().min(1),
-    tool: z40.string().min(1)
+  z41.object({
+    kind: z41.literal("toolCall"),
+    arguments: z41.record(z41.string(), z41.unknown()).default({}),
+    callId: z41.string().min(1),
+    threadId: z41.string().min(1),
+    token: z41.string().min(1),
+    tool: z41.string().min(1)
   })
 ]);
-var bridgeToolCallResponseSchema = z40.union([
-  z40.object({
-    ok: z40.literal(true),
-    content: z40.string(),
-    contentBlocks: z40.array(
-      z40.discriminatedUnion("type", [
-        z40.object({ type: z40.literal("text"), text: z40.string() }),
-        z40.object({
-          type: z40.literal("image"),
-          data: z40.string(),
-          mimeType: z40.string()
+var bridgeToolCallResponseSchema = z41.union([
+  z41.object({
+    ok: z41.literal(true),
+    content: z41.string(),
+    contentBlocks: z41.array(
+      z41.discriminatedUnion("type", [
+        z41.object({ type: z41.literal("text"), text: z41.string() }),
+        z41.object({
+          type: z41.literal("image"),
+          data: z41.string(),
+          mimeType: z41.string()
         })
       ])
     ).optional(),
-    images: z40.array(z40.object({ data: z40.string(), mimeType: z40.string() })).default([]),
-    isError: z40.boolean().optional()
+    images: z41.array(z41.object({ data: z41.string(), mimeType: z41.string() })).default([]),
+    isError: z41.boolean().optional()
   }),
-  z40.object({ ok: z40.literal(false), error: z40.string() })
+  z41.object({ ok: z41.literal(false), error: z41.string() })
 ]);
-var jsonRpcMessageSchema = z40.object({
-  id: z40.union([z40.string(), z40.number().int()]).optional(),
-  method: z40.string().optional(),
-  params: z40.unknown().optional()
+var jsonRpcMessageSchema = z41.object({
+  id: z41.union([z41.string(), z41.number().int()]).optional(),
+  method: z41.string().optional(),
+  params: z41.unknown().optional()
 });
 var nextMcpToolCallId = 0;
 var TOOL_CALL_PROGRESS_INTERVAL_MS = 15e3;
@@ -8066,7 +8619,7 @@ async function authenticateAcpAgent(args) {
     await args.connection.request({
       method: "authenticate",
       params: { methodId, _meta: { headless: true } },
-      resultSchema: z41.unknown()
+      resultSchema: z42.unknown()
     });
   } catch (error) {
     throw new AcpAuthRequiredError(
@@ -8396,7 +8949,7 @@ async function selectAcpNativeModel(args) {
             configId: modelOption.id,
             value: selection.modelId
           },
-          resultSchema: z41.union([acpConfigStateResultSchema, z41.null()])
+          resultSchema: z42.union([acpConfigStateResultSchema, z42.null()])
         });
         setModel = false;
       } catch {
@@ -8407,7 +8960,7 @@ async function selectAcpNativeModel(args) {
       configState = await args.connection.request({
         method: "session/set_model",
         params: { sessionId: args.sessionId, modelId: selection.modelId },
-        resultSchema: z41.union([acpConfigStateResultSchema, z41.null()])
+        resultSchema: z42.union([acpConfigStateResultSchema, z42.null()])
       });
     }
     configOptions = configState?.configOptions ?? configOptions;
@@ -8904,7 +9457,7 @@ async function startAgentSession(request) {
             cwd: params.cwd,
             mcpServers
           },
-          resultSchema: z41.union([acpConfigStateResultSchema, z41.null()])
+          resultSchema: z42.union([acpConfigStateResultSchema, z42.null()])
         });
         loadedConfigOptions = configState?.configOptions;
         loadedModels = configState?.models;
@@ -9350,12 +9903,12 @@ function decodeLaunchSpec(providerOptions) {
   );
   return launchSpec.success ? launchSpec.data : null;
 }
-var acpProviderOptionsSchema = z41.object({
-  additionalWorkspaceWriteRoots: z41.array(z41.string()).optional(),
-  acpDialect: z41.string().min(1).optional(),
-  parameterizedModelPicker: z41.boolean().optional(),
-  primaryModels: z41.array(z41.string().min(1)).optional(),
-  reasoningProbePriorityModelIds: z41.array(z41.string().min(1)).optional()
+var acpProviderOptionsSchema = z42.object({
+  additionalWorkspaceWriteRoots: z42.array(z42.string()).optional(),
+  acpDialect: z42.string().min(1).optional(),
+  parameterizedModelPicker: z42.boolean().optional(),
+  primaryModels: z42.array(z42.string().min(1)).optional(),
+  reasoningProbePriorityModelIds: z42.array(z42.string().min(1)).optional()
 }).passthrough();
 function decodeAcpModelPickerOptions(providerOptions) {
   const parsed = acpProviderOptionsSchema.parse(providerOptions ?? {});
@@ -9672,7 +10225,7 @@ var experimental_providerBridge = experimental_defineProviderBridge({
 });
 
 // ../provider-bridge-acp/src/probe.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 var PROBE_TIMEOUT_MS = 1e4;
 function describe(error) {
   if (error instanceof AcpAgentExitedError) {
@@ -9730,9 +10283,9 @@ async function probeAcpAgent(request) {
     connected.kill();
   }
 }
-var acpAgentProbeSchema = z42.union([
-  z42.object({ reachable: z42.literal(true), fork: z42.boolean() }),
-  z42.object({ reachable: z42.literal(false), reason: z42.string() })
+var acpAgentProbeSchema = z43.union([
+  z43.object({ reachable: z43.literal(true), fork: z43.boolean() }),
+  z43.object({ reachable: z43.literal(false), reason: z43.string() })
 ]);
 export {
   acpAgentProbeSchema as experimental_acpAgentProbeSchema,