@get-bb/plugin-sdk 0.4.94 → 0.4.97

package/dist/provider-bridge.js

@@ -34,6 +34,517 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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;
+  }
+});
+
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
 var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module) {
@@ -393,7 +904,7 @@ var require_readShebang = __commonJS({
 });
 
 // ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
-var require_parse = __commonJS({
+var require_parse2 = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js"(exports, module) {
     "use strict";
     var path2 = __require("path");
@@ -509,7 +1020,7 @@ var require_cross_spawn = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js"(exports, module) {
     "use strict";
     var cp = __require("child_process");
-    var parse = require_parse();
+    var parse = require_parse2();
     var enoent = require_enoent();
     function spawn(command, args, options) {
       const parsed = parse(command, args, options);
@@ -1022,7 +1533,7 @@ function withoutBridgeRuntimeEnv(env) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/bridge-tool-calls.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // ../domain/src/context-snapshot.ts
 import { z as z3 } from "zod";
@@ -1651,8 +2162,13 @@ var providerNativeRootSetSchema = z7.object({
   resolved: providerResolvedNativeRootsSchema
 }).strict();
 
-// ../domain/src/background-task.ts
+// ../domain/src/completed-turn-display.ts
 import { z as z8 } from "zod";
+var COMPLETED_TURN_DISPLAY_VALUES = ["collapse", "flat"];
+var completedTurnDisplaySchema = z8.enum(COMPLETED_TURN_DISPLAY_VALUES);
+
+// ../domain/src/background-task.ts
+import { z as z9 } from "zod";
 var LOCAL_WORKFLOW_TASK_TYPE = "local_workflow";
 var LOCAL_BASH_TASK_TYPE = "local_bash";
 var LOCAL_AGENT_TASK_TYPE = "local_agent";
@@ -1669,7 +2185,7 @@ var backgroundTaskStatusValues = [
   "killed",
   "stopped"
 ];
-var backgroundTaskStatusSchema = z8.enum(backgroundTaskStatusValues);
+var backgroundTaskStatusSchema = z9.enum(backgroundTaskStatusValues);
 var workflowAgentStateValues = [
   "queued",
   "running",
@@ -1677,43 +2193,43 @@ var workflowAgentStateValues = [
   "failed",
   "skipped"
 ];
-var workflowAgentStateSchema = z8.enum(workflowAgentStateValues);
-var workflowAgentSnapshotSchema = z8.object({
-  index: z8.number().int().positive(),
-  label: z8.string(),
+var workflowAgentStateSchema = z9.enum(workflowAgentStateValues);
+var workflowAgentSnapshotSchema = z9.object({
+  index: z9.number().int().positive(),
+  label: z9.string(),
   state: workflowAgentStateSchema,
-  model: z8.string(),
-  attempt: z8.number().int().positive(),
-  cached: z8.boolean(),
-  lastProgressAt: z8.number(),
-  phaseIndex: z8.number().int().positive().optional(),
-  phaseTitle: z8.string().optional(),
-  agentType: z8.string().optional(),
-  isolation: z8.string().optional(),
-  queuedAt: z8.number().optional(),
-  startedAt: z8.number().optional(),
-  lastToolName: z8.string().optional(),
-  lastToolSummary: z8.string().optional(),
-  promptPreview: z8.string().optional(),
-  resultPreview: z8.string().optional(),
-  error: z8.string().optional(),
-  tokens: z8.number().optional(),
-  toolCalls: z8.number().optional(),
-  durationMs: z8.number().optional()
-});
-var workflowPhaseSnapshotSchema = z8.object({
-  index: z8.number().int().positive(),
-  title: z8.string(),
-  kind: z8.string().optional()
-});
-var workflowProgressSnapshotSchema = z8.object({
-  phases: z8.array(workflowPhaseSnapshotSchema),
-  agents: z8.array(workflowAgentSnapshotSchema)
-});
-var backgroundTaskUsageSchema = z8.object({
-  totalTokens: z8.number(),
-  toolUses: z8.number(),
-  durationMs: z8.number()
+  model: z9.string(),
+  attempt: z9.number().int().positive(),
+  cached: z9.boolean(),
+  lastProgressAt: z9.number(),
+  phaseIndex: z9.number().int().positive().optional(),
+  phaseTitle: z9.string().optional(),
+  agentType: z9.string().optional(),
+  isolation: z9.string().optional(),
+  queuedAt: z9.number().optional(),
+  startedAt: z9.number().optional(),
+  lastToolName: z9.string().optional(),
+  lastToolSummary: z9.string().optional(),
+  promptPreview: z9.string().optional(),
+  resultPreview: z9.string().optional(),
+  error: z9.string().optional(),
+  tokens: z9.number().optional(),
+  toolCalls: z9.number().optional(),
+  durationMs: z9.number().optional()
+});
+var workflowPhaseSnapshotSchema = z9.object({
+  index: z9.number().int().positive(),
+  title: z9.string(),
+  kind: z9.string().optional()
+});
+var workflowProgressSnapshotSchema = z9.object({
+  phases: z9.array(workflowPhaseSnapshotSchema),
+  agents: z9.array(workflowAgentSnapshotSchema)
+});
+var backgroundTaskUsageSchema = z9.object({
+  totalTokens: z9.number(),
+  toolUses: z9.number(),
+  durationMs: z9.number()
 });
 function backgroundTaskItemStatus(taskStatus) {
   switch (taskStatus) {
@@ -1735,13 +2251,13 @@ function isSettledBackgroundTaskStatus(taskStatus) {
 }
 
 // ../domain/src/provider-event.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // ../domain/src/thread-events.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // ../domain/src/pending-interactions.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // ../domain/src/plugin-interaction-limits.ts
 var PLUGIN_INTERACTION_MAX_TITLE_LENGTH = 160;
@@ -1751,223 +2267,223 @@ function jsonByteLength(value) {
 }
 
 // ../domain/src/item-presentation.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH = 280;
-var threadEventItemPresentationLabelSchema = z9.object({
-  pending: z9.string().min(1),
-  completed: z9.string().min(1)
+var threadEventItemPresentationLabelSchema = z10.object({
+  pending: z10.string().min(1),
+  completed: z10.string().min(1)
 });
-var threadEventItemPresentationIconSchema = z9.object({
-  glyph: z9.string().min(1)
+var threadEventItemPresentationIconSchema = z10.object({
+  glyph: z10.string().min(1)
 });
-var threadEventItemPresentationTintSchema = z9.object({
-  light: z9.string().min(1),
-  dark: z9.string().min(1)
+var threadEventItemPresentationTintSchema = z10.object({
+  light: z10.string().min(1),
+  dark: z10.string().min(1)
 });
 var THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH = 80;
-var threadEventItemPresentationBadgeSchema = z9.object({
-  glyph: z9.string().min(1),
-  label: z9.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
-  hint: z9.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
-  tone: z9.enum(["neutral", "destructive"])
+var threadEventItemPresentationBadgeSchema = z10.object({
+  glyph: z10.string().min(1),
+  label: z10.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  hint: z10.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  tone: z10.enum(["neutral", "destructive"])
 });
-var threadEventItemPresentationSchema = z9.object({
+var threadEventItemPresentationSchema = z10.object({
   label: threadEventItemPresentationLabelSchema,
   icon: threadEventItemPresentationIconSchema,
-  title: z9.string().optional(),
-  detail: z9.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
-  suppress: z9.boolean().optional(),
+  title: z10.string().optional(),
+  detail: z10.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
+  suppress: z10.boolean().optional(),
   tint: threadEventItemPresentationTintSchema.optional(),
   badge: threadEventItemPresentationBadgeSchema.optional()
 });
 
 // ../domain/src/provider-extension-kind.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var EXTENSION_KIND_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
 function isExtensionKind(value) {
   return EXTENSION_KIND_PATTERN.test(value);
 }
-var extensionKindSchema = z10.string().refine(isExtensionKind, {
+var extensionKindSchema = z11.string().refine(isExtensionKind, {
   message: 'extension kinds are "<pluginId>/<name>" (lowercase letters, digits, and "-")'
 });
 
 // ../domain/src/pending-interactions.ts
-var pendingInteractionStatusSchema = z11.enum([
+var pendingInteractionStatusSchema = z12.enum([
   "pending",
   "resolving",
   "resolved",
   "interrupted"
 ]);
-var pendingInteractionCommandActionSchema = z11.discriminatedUnion(
+var pendingInteractionCommandActionSchema = z12.discriminatedUnion(
   "type",
   [
-    z11.object({
-      type: z11.literal("read"),
-      command: z11.string(),
-      name: z11.string(),
-      path: z11.string()
+    z12.object({
+      type: z12.literal("read"),
+      command: z12.string(),
+      name: z12.string(),
+      path: z12.string()
     }),
-    z11.object({
-      type: z11.literal("listFiles"),
-      command: z11.string(),
-      path: z11.string().nullable()
+    z12.object({
+      type: z12.literal("listFiles"),
+      command: z12.string(),
+      path: z12.string().nullable()
     }),
-    z11.object({
-      type: z11.literal("search"),
-      command: z11.string(),
-      query: z11.string().nullable(),
-      path: z11.string().nullable()
+    z12.object({
+      type: z12.literal("search"),
+      command: z12.string(),
+      query: z12.string().nullable(),
+      path: z12.string().nullable()
     }),
-    z11.object({
-      type: z11.literal("unknown"),
-      command: z11.string()
+    z12.object({
+      type: z12.literal("unknown"),
+      command: z12.string()
     })
   ]
 );
-var pendingInteractionNetworkPermissionsSchema = z11.object({
-  enabled: z11.boolean().nullable()
+var pendingInteractionNetworkPermissionsSchema = z12.object({
+  enabled: z12.boolean().nullable()
 });
-var pendingInteractionFileSystemPermissionsSchema = z11.object({
-  read: z11.array(z11.string()),
-  write: z11.array(z11.string())
+var pendingInteractionFileSystemPermissionsSchema = z12.object({
+  read: z12.array(z12.string()),
+  write: z12.array(z12.string())
 });
-var pendingInteractionMacOsPreferencesPermissionSchema = z11.enum([
+var pendingInteractionMacOsPreferencesPermissionSchema = z12.enum([
   "none",
   "read_only",
   "read_write"
 ]);
-var pendingInteractionMacOsContactsPermissionSchema = z11.enum([
+var pendingInteractionMacOsContactsPermissionSchema = z12.enum([
   "none",
   "read_only",
   "read_write"
 ]);
-var pendingInteractionMacOsAutomationPermissionSchema = z11.union([
-  z11.literal("none"),
-  z11.literal("all"),
-  z11.object({
-    kind: z11.literal("bundle_ids"),
-    bundleIds: z11.array(z11.string())
+var pendingInteractionMacOsAutomationPermissionSchema = z12.union([
+  z12.literal("none"),
+  z12.literal("all"),
+  z12.object({
+    kind: z12.literal("bundle_ids"),
+    bundleIds: z12.array(z12.string())
   })
 ]);
-var pendingInteractionMacOsPermissionsSchema = z11.object({
+var pendingInteractionMacOsPermissionsSchema = z12.object({
   preferences: pendingInteractionMacOsPreferencesPermissionSchema,
   automations: pendingInteractionMacOsAutomationPermissionSchema,
-  launchServices: z11.boolean(),
-  accessibility: z11.boolean(),
-  calendar: z11.boolean(),
-  reminders: z11.boolean(),
+  launchServices: z12.boolean(),
+  accessibility: z12.boolean(),
+  calendar: z12.boolean(),
+  reminders: z12.boolean(),
   contacts: pendingInteractionMacOsContactsPermissionSchema
 });
-var pendingInteractionRequestedPermissionProfileSchema = z11.object({
+var pendingInteractionRequestedPermissionProfileSchema = z12.object({
   network: pendingInteractionNetworkPermissionsSchema.nullable(),
   fileSystem: pendingInteractionFileSystemPermissionsSchema.nullable(),
   macos: pendingInteractionMacOsPermissionsSchema.nullable()
 });
-var pendingInteractionGrantablePermissionProfileSchema = z11.object({
+var pendingInteractionGrantablePermissionProfileSchema = z12.object({
   network: pendingInteractionNetworkPermissionsSchema.nullable(),
   fileSystem: pendingInteractionFileSystemPermissionsSchema.nullable()
 }).strict();
 var pendingInteractionGrantedPermissionProfileSchema = pendingInteractionGrantablePermissionProfileSchema;
-var pendingInteractionApprovalDecisionSchema = z11.enum([
+var pendingInteractionApprovalDecisionSchema = z12.enum([
   "allow_once",
   "allow_for_session",
   "deny"
 ]);
-var pendingInteractionFileChangeWriteScopeSchema = z11.string().min(1);
-var pendingInteractionCommandApprovalSubjectSchema = z11.object({
-  kind: z11.literal("command"),
-  itemId: z11.string().min(1),
-  command: z11.string().min(1),
-  cwd: z11.string().nullable(),
-  actions: z11.array(pendingInteractionCommandActionSchema),
+var pendingInteractionFileChangeWriteScopeSchema = z12.string().min(1);
+var pendingInteractionCommandApprovalSubjectSchema = z12.object({
+  kind: z12.literal("command"),
+  itemId: z12.string().min(1),
+  command: z12.string().min(1),
+  cwd: z12.string().nullable(),
+  actions: z12.array(pendingInteractionCommandActionSchema),
   sessionGrant: pendingInteractionGrantablePermissionProfileSchema.nullable()
 });
-var pendingInteractionFileChangeApprovalSubjectSchema = z11.object({
-  kind: z11.literal("file_change"),
-  itemId: z11.string().min(1),
+var pendingInteractionFileChangeApprovalSubjectSchema = z12.object({
+  kind: z12.literal("file_change"),
+  itemId: z12.string().min(1),
   writeScope: pendingInteractionFileChangeWriteScopeSchema.nullable(),
   sessionGrant: pendingInteractionGrantablePermissionProfileSchema.nullable()
 });
-var pendingInteractionPermissionGrantApprovalSubjectSchema = z11.object({
-  kind: z11.literal("permission_grant"),
-  itemId: z11.string().min(1),
-  toolName: z11.string().nullable(),
+var pendingInteractionPermissionGrantApprovalSubjectSchema = z12.object({
+  kind: z12.literal("permission_grant"),
+  itemId: z12.string().min(1),
+  toolName: z12.string().nullable(),
   permissions: pendingInteractionGrantablePermissionProfileSchema
 });
-var pendingInteractionPlanApprovalSubjectSchema = z11.object({
-  kind: z11.literal("plan"),
-  itemId: z11.string().min(1),
-  plan: z11.string().min(1),
-  planFilePath: z11.string().min(1).nullable()
+var pendingInteractionPlanApprovalSubjectSchema = z12.object({
+  kind: z12.literal("plan"),
+  itemId: z12.string().min(1),
+  plan: z12.string().min(1),
+  planFilePath: z12.string().min(1).nullable()
 });
-var pendingInteractionToolUseApprovalSubjectSchema = z11.object({
-  kind: z11.literal("tool_use"),
-  itemId: z11.string().min(1),
-  tool: z11.string().min(1),
+var pendingInteractionToolUseApprovalSubjectSchema = z12.object({
+  kind: z12.literal("tool_use"),
+  itemId: z12.string().min(1),
+  tool: z12.string().min(1),
   presentation: threadEventItemPresentationSchema
 });
-var pendingInteractionApprovalSubjectSchema = z11.discriminatedUnion("kind", [
+var pendingInteractionApprovalSubjectSchema = z12.discriminatedUnion("kind", [
   pendingInteractionCommandApprovalSubjectSchema,
   pendingInteractionFileChangeApprovalSubjectSchema,
   pendingInteractionPermissionGrantApprovalSubjectSchema,
   pendingInteractionPlanApprovalSubjectSchema,
   pendingInteractionToolUseApprovalSubjectSchema
 ]);
-var approvalPendingInteractionPayloadSchema = z11.object({
-  kind: z11.literal("approval"),
+var approvalPendingInteractionPayloadSchema = z12.object({
+  kind: z12.literal("approval"),
   subject: pendingInteractionApprovalSubjectSchema,
-  reason: z11.string().nullable(),
-  availableDecisions: z11.array(pendingInteractionApprovalDecisionSchema).min(1)
+  reason: z12.string().nullable(),
+  availableDecisions: z12.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 = z11.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionIdSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question ids cannot be blank"
 });
-var pendingInteractionUserQuestionPromptSchema = z11.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionPromptSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question prompts cannot be blank"
 });
-var pendingInteractionUserQuestionShortLabelSchema = z11.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionShortLabelSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question short labels cannot be blank"
 });
-var pendingInteractionUserQuestionOptionValueSchema = z11.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionOptionValueSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question option values cannot be blank"
 });
-var pendingInteractionUserQuestionOptionLabelSchema = z11.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionOptionLabelSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question option labels cannot be blank"
 });
-var pendingInteractionUserQuestionOptionDescriptionSchema = z11.string().min(1).refine((value) => value.trim().length > 0, {
+var pendingInteractionUserQuestionOptionDescriptionSchema = z12.string().min(1).refine((value) => value.trim().length > 0, {
   message: "User question option descriptions cannot be blank"
 });
-var pendingInteractionUserQuestionFreeTextSchema = z11.string().min(1).max(
+var pendingInteractionUserQuestionFreeTextSchema = z12.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 = z11.object({
+var pendingInteractionUserQuestionOptionSchema = z12.object({
   value: pendingInteractionUserQuestionOptionValueSchema,
   label: pendingInteractionUserQuestionOptionLabelSchema,
   description: pendingInteractionUserQuestionOptionDescriptionSchema.optional()
 });
-var pendingInteractionUserQuestionQuestionSchema = z11.object({
+var pendingInteractionUserQuestionQuestionSchema = z12.object({
   id: pendingInteractionUserQuestionIdSchema,
   prompt: pendingInteractionUserQuestionPromptSchema,
   shortLabel: pendingInteractionUserQuestionShortLabelSchema.optional(),
-  multiSelect: z11.boolean(),
-  options: z11.array(pendingInteractionUserQuestionOptionSchema).max(
+  multiSelect: z12.boolean(),
+  options: z12.array(pendingInteractionUserQuestionOptionSchema).max(
     USER_QUESTION_MAX_OPTIONS,
     `User questions cannot include more than ${USER_QUESTION_MAX_OPTIONS} options`
   ).optional(),
-  allowFreeText: z11.boolean()
+  allowFreeText: z12.boolean()
 }).superRefine((question, context) => {
   const optionValues = /* @__PURE__ */ new Set();
   question.options?.forEach((option, index) => {
     if (optionValues.has(option.value)) {
       context.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z12.ZodIssueCode.custom,
         message: "User question option values must be unique",
         path: ["options", index, "value"]
       });
@@ -1982,9 +2498,9 @@ var pendingInteractionUserQuestionQuestionSchema = z11.object({
     path: ["options"]
   }
 );
-var userQuestionPendingInteractionPayloadSchema = z11.object({
-  kind: z11.literal("user_question"),
-  questions: z11.array(pendingInteractionUserQuestionQuestionSchema).min(1).max(
+var userQuestionPendingInteractionPayloadSchema = z12.object({
+  kind: z12.literal("user_question"),
+  questions: z12.array(pendingInteractionUserQuestionQuestionSchema).min(1).max(
     USER_QUESTION_MAX_QUESTIONS,
     `User questions cannot include more than ${USER_QUESTION_MAX_QUESTIONS} questions`
   )
@@ -1993,7 +2509,7 @@ var userQuestionPendingInteractionPayloadSchema = z11.object({
   payload.questions.forEach((question, index) => {
     if (questionIds.has(question.id)) {
       context.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z12.ZodIssueCode.custom,
         message: "User question ids must be unique",
         path: ["questions", index, "id"]
       });
@@ -2002,24 +2518,24 @@ var userQuestionPendingInteractionPayloadSchema = z11.object({
     questionIds.add(question.id);
   });
 });
-var pluginPendingInteractionPayloadSchema = z11.object({
-  kind: z11.literal("plugin"),
-  title: z11.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
+var pluginPendingInteractionPayloadSchema = z12.object({
+  kind: z12.literal("plugin"),
+  title: z12.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
   data: jsonValueSchema
 });
-var pluginExtensionInteractionRequestPayloadSchema = z11.object({
+var pluginExtensionInteractionRequestPayloadSchema = z12.object({
   kind: extensionKindSchema,
-  title: z11.string().trim().min(1).max(PLUGIN_INTERACTION_MAX_TITLE_LENGTH),
+  title: z12.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 = z11.union([
+var interactionRequestPayloadSchema = z12.union([
   userQuestionPendingInteractionPayloadSchema,
   pluginExtensionInteractionRequestPayloadSchema
 ]);
-var pendingInteractionPayloadSchema = z11.union([
+var pendingInteractionPayloadSchema = z12.union([
   approvalPendingInteractionPayloadSchema,
   userQuestionPendingInteractionPayloadSchema,
   pluginExtensionInteractionRequestPayloadSchema
@@ -2031,42 +2547,42 @@ function isUserQuestionPendingInteractionPayload(payload) {
   return payload.kind === "user_question";
 }
 var approvalDecisionDiscriminatorError = "Invalid discriminator value. Expected 'allow_once' | 'allow_for_session' | 'deny'";
-var approvalPendingInteractionResolutionSchema = z11.discriminatedUnion(
+var approvalPendingInteractionResolutionSchema = z12.discriminatedUnion(
   "decision",
   [
-    z11.object({
-      decision: z11.literal("allow_once"),
+    z12.object({
+      decision: z12.literal("allow_once"),
       grantedPermissions: pendingInteractionGrantedPermissionProfileSchema.nullable()
     }),
-    z11.object({
-      decision: z11.literal("allow_for_session"),
+    z12.object({
+      decision: z12.literal("allow_for_session"),
       grantedPermissions: pendingInteractionGrantedPermissionProfileSchema.nullable()
     }),
-    z11.object({
-      decision: z11.literal("deny")
+    z12.object({
+      decision: z12.literal("deny")
     })
   ],
   approvalDecisionDiscriminatorError
 );
-var pendingInteractionUserAnswerSchema = z11.object({
-  selected: z11.array(z11.string().min(1)).max(
+var pendingInteractionUserAnswerSchema = z12.object({
+  selected: z12.array(z12.string().min(1)).max(
     USER_QUESTION_MAX_SELECTED,
     `User question selected choices cannot exceed ${USER_QUESTION_MAX_SELECTED}`
   ),
   freeText: pendingInteractionUserQuestionFreeTextSchema.optional()
 });
-var userQuestionPendingInteractionResolutionSchema = z11.object({
-  kind: z11.literal("user_answer"),
-  answers: z11.record(z11.string().min(1), pendingInteractionUserAnswerSchema)
+var userQuestionPendingInteractionResolutionSchema = z12.object({
+  kind: z12.literal("user_answer"),
+  answers: z12.record(z12.string().min(1), pendingInteractionUserAnswerSchema)
 });
-var pluginPendingInteractionResolutionSchema = z11.object({
-  kind: z11.literal("plugin_submitted")
+var pluginPendingInteractionResolutionSchema = z12.object({
+  kind: z12.literal("plugin_submitted")
 });
-var pluginExtensionInteractionResolutionSchema = z11.object({
-  kind: z11.literal("request_answer"),
+var pluginExtensionInteractionResolutionSchema = z12.object({
+  kind: z12.literal("request_answer"),
   value: jsonValueSchema
 });
-var pendingInteractionResolutionSchema = z11.union(
+var pendingInteractionResolutionSchema = z12.union(
   [
     approvalPendingInteractionResolutionSchema,
     userQuestionPendingInteractionResolutionSchema,
@@ -2081,19 +2597,19 @@ function isApprovalPendingInteractionResolution(resolution) {
 function isUserQuestionPendingInteractionResolution(resolution) {
   return "kind" in resolution && resolution.kind === "user_answer";
 }
-var approvalInteractionOutcomeSchema = z11.object({
+var approvalInteractionOutcomeSchema = z12.object({
   payload: approvalPendingInteractionPayloadSchema,
   resolution: approvalPendingInteractionResolutionSchema
 });
-var userQuestionInteractionOutcomeSchema = z11.object({
+var userQuestionInteractionOutcomeSchema = z12.object({
   payload: userQuestionPendingInteractionPayloadSchema,
   resolution: userQuestionPendingInteractionResolutionSchema
 });
-var pluginExtensionInteractionOutcomeSchema = z11.object({
+var pluginExtensionInteractionOutcomeSchema = z12.object({
   payload: pluginExtensionInteractionRequestPayloadSchema,
   resolution: pluginExtensionInteractionResolutionSchema
 });
-var providerInteractionOutcomeSchema = z11.union([
+var providerInteractionOutcomeSchema = z12.union([
   approvalInteractionOutcomeSchema,
   userQuestionInteractionOutcomeSchema,
   pluginExtensionInteractionOutcomeSchema
@@ -2101,39 +2617,39 @@ var providerInteractionOutcomeSchema = z11.union([
 function isApprovalInteractionOutcome(outcome) {
   return outcome.payload.kind === "approval";
 }
-var pendingInteractionProviderOriginSchema = z11.object({
-  kind: z11.literal("provider"),
-  providerId: z11.string().min(1),
-  providerThreadId: z11.string().min(1),
-  providerRequestId: z11.string().min(1)
-});
-var pendingInteractionPluginOriginSchema = z11.object({
-  kind: z11.literal("plugin"),
-  pluginId: z11.string().min(1),
-  rendererId: z11.string().min(1)
-});
-var pendingInteractionCreateSchema = z11.object({
-  threadId: z11.string().min(1),
-  turnId: z11.string().min(1),
-  providerId: z11.string().min(1),
-  providerThreadId: z11.string().min(1),
-  providerRequestId: z11.string().min(1),
+var pendingInteractionProviderOriginSchema = z12.object({
+  kind: z12.literal("provider"),
+  providerId: z12.string().min(1),
+  providerThreadId: z12.string().min(1),
+  providerRequestId: z12.string().min(1)
+});
+var pendingInteractionPluginOriginSchema = z12.object({
+  kind: z12.literal("plugin"),
+  pluginId: z12.string().min(1),
+  rendererId: z12.string().min(1)
+});
+var pendingInteractionCreateSchema = z12.object({
+  threadId: z12.string().min(1),
+  turnId: z12.string().min(1),
+  providerId: z12.string().min(1),
+  providerThreadId: z12.string().min(1),
+  providerRequestId: z12.string().min(1),
   payload: pendingInteractionPayloadSchema
 });
-var pendingInteractionBaseSchema = z11.object({
-  id: z11.string().min(1),
-  threadId: z11.string().min(1),
+var pendingInteractionBaseSchema = z12.object({
+  id: z12.string().min(1),
+  threadId: z12.string().min(1),
   status: pendingInteractionStatusSchema,
-  statusReason: z11.string().nullable(),
-  createdAt: z11.number().int().nonnegative(),
-  expiresAt: z11.number().int().nonnegative().nullable().optional(),
-  resolvedAt: z11.number().int().nonnegative().nullable()
+  statusReason: z12.string().nullable(),
+  createdAt: z12.number().int().nonnegative(),
+  expiresAt: z12.number().int().nonnegative().nullable().optional(),
+  resolvedAt: z12.number().int().nonnegative().nullable()
 });
 var providerPendingInteractionBaseSchema = pendingInteractionBaseSchema.extend({
-  turnId: z11.string().min(1),
-  providerId: z11.string().min(1),
-  providerThreadId: z11.string().min(1),
-  providerRequestId: z11.string().min(1),
+  turnId: z12.string().min(1),
+  providerId: z12.string().min(1),
+  providerThreadId: z12.string().min(1),
+  providerRequestId: z12.string().min(1),
   origin: pendingInteractionProviderOriginSchema.optional()
 });
 var approvalPendingInteractionSchema = providerPendingInteractionBaseSchema.extend({
@@ -2148,30 +2664,30 @@ var pluginExtensionPendingInteractionSchema = providerPendingInteractionBaseSche
   payload: pluginExtensionInteractionRequestPayloadSchema,
   resolution: pluginExtensionInteractionResolutionSchema.nullable()
 });
-var providerPendingInteractionSchema = z11.union([
+var providerPendingInteractionSchema = z12.union([
   approvalPendingInteractionSchema,
   userQuestionPendingInteractionSchema,
   pluginExtensionPendingInteractionSchema
 ]);
 var pluginPendingInteractionSchema = pendingInteractionBaseSchema.extend({
-  turnId: z11.string().min(1).nullable(),
+  turnId: z12.string().min(1).nullable(),
   origin: pendingInteractionPluginOriginSchema,
   payload: pluginPendingInteractionPayloadSchema,
   resolution: pluginPendingInteractionResolutionSchema.nullable()
 });
-var pendingInteractionSchema = z11.union([
+var pendingInteractionSchema = z12.union([
   providerPendingInteractionSchema,
   pluginPendingInteractionSchema
 ]);
-var interactionLifecycleRecordBaseSchema = z11.object({
-  id: z11.string().min(1),
+var interactionLifecycleRecordBaseSchema = z12.object({
+  id: z12.string().min(1),
   status: pendingInteractionStatusSchema,
-  statusReason: z11.string().nullable()
+  statusReason: z12.string().nullable()
 });
-var interactionLifecycleProviderOriginSchema = z11.object({
-  kind: z11.literal("provider"),
-  providerId: z11.string().min(1),
-  providerRequestId: z11.string().min(1)
+var interactionLifecycleProviderOriginSchema = z12.object({
+  kind: z12.literal("provider"),
+  providerId: z12.string().min(1),
+  providerRequestId: z12.string().min(1)
 });
 var approvalInteractionLifecycleRecordPayloadSchema = approvalPendingInteractionPayloadSchema.omit({ availableDecisions: true });
 var approvalInteractionLifecycleSchema = interactionLifecycleRecordBaseSchema.extend({
@@ -2196,7 +2712,7 @@ var pluginExtensionInteractionLifecycleSchema = interactionLifecycleRecordBaseSc
   }),
   resolution: pluginExtensionInteractionResolutionSchema.omit({ value: true }).nullable()
 });
-var interactionLifecycleSchema = z11.union([
+var interactionLifecycleSchema = z12.union([
   approvalInteractionLifecycleSchema,
   userQuestionInteractionLifecycleSchema,
   pluginInteractionLifecycleSchema,
@@ -2204,11 +2720,11 @@ var interactionLifecycleSchema = z11.union([
 ]);
 
 // ../domain/src/protocol-ids.ts
-import { z as z12 } from "zod";
-var clientTurnRequestIdSchema = z12.string().regex(/^creq_[23456789abcdefghijkmnpqrstuvwxyz]{10}$/u);
+import { z as z13 } from "zod";
+var clientTurnRequestIdSchema = z13.string().regex(/^creq_[23456789abcdefghijkmnpqrstuvwxyz]{10}$/u);
 
 // ../domain/src/system-message.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var systemMessageKindValues = [
   "ownership-assigned",
   "ownership-removed",
@@ -2219,16 +2735,16 @@ var systemMessageKindValues = [
   "child-outcome-batch",
   "unlabeled"
 ];
-var systemMessageKindSchema = z13.enum(systemMessageKindValues);
-var systemMessageSubjectSchema = z13.discriminatedUnion("kind", [
-  z13.object({
-    kind: z13.literal("thread"),
-    threadId: z13.string(),
-    threadName: z13.string()
+var systemMessageKindSchema = z14.enum(systemMessageKindValues);
+var systemMessageSubjectSchema = z14.discriminatedUnion("kind", [
+  z14.object({
+    kind: z14.literal("thread"),
+    threadId: z14.string(),
+    threadName: z14.string()
   }),
-  z13.object({
-    kind: z13.literal("thread-batch"),
-    count: z13.number()
+  z14.object({
+    kind: z14.literal("thread-batch"),
+    count: z14.number()
   })
 ]);
 
@@ -2251,31 +2767,31 @@ var systemEventTypeValues = [
   "system/provider-turn-watchdog"
 ];
 var threadTurnInitiatorValues = ["user", "agent", "system"];
-var threadTurnInitiatorSchema = z14.enum(threadTurnInitiatorValues);
+var threadTurnInitiatorSchema = z15.enum(threadTurnInitiatorValues);
 var turnRequestOptionsSchema = recordedThreadExecutionOptionsSchema;
-var turnRequestTargetSchema = z14.discriminatedUnion("kind", [
-  z14.object({ kind: z14.literal("thread-start") }),
-  z14.object({ kind: z14.literal("new-turn") }),
-  z14.object({
-    kind: z14.literal("auto"),
-    expectedTurnId: z14.string().nullable()
+var turnRequestTargetSchema = z15.discriminatedUnion("kind", [
+  z15.object({ kind: z15.literal("thread-start") }),
+  z15.object({ kind: z15.literal("new-turn") }),
+  z15.object({
+    kind: z15.literal("auto"),
+    expectedTurnId: z15.string().nullable()
   }),
-  z14.object({
-    kind: z14.literal("steer"),
-    expectedTurnId: z14.string().nullable()
+  z15.object({
+    kind: z15.literal("steer"),
+    expectedTurnId: z15.string().nullable()
   })
 ]);
-var clientTurnLifecycleEventDataSchema = z14.object({
-  direction: z14.literal("outbound"),
-  source: z14.enum(["spawn", "tell"]),
+var clientTurnLifecycleEventDataSchema = z15.object({
+  direction: z15.literal("outbound"),
+  source: z15.enum(["spawn", "tell"]),
   initiator: threadTurnInitiatorSchema,
-  request: z14.object({
-    method: z14.enum(["thread/start", "turn/start"]),
-    params: z14.record(z14.string(), z14.unknown())
+  request: z15.object({
+    method: z15.enum(["thread/start", "turn/start"]),
+    params: z15.record(z15.string(), z15.unknown())
   })
 });
-var turnRequestEventDataSchema = z14.object({
-  direction: z14.literal("outbound"),
+var turnRequestEventDataSchema = z15.object({
+  direction: z15.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
@@ -2285,45 +2801,45 @@ var turnRequestEventDataSchema = z14.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: z14.number().int().min(2).optional(),
-  source: z14.enum(["spawn", "tell"]),
+  retryAttempt: z15.number().int().min(2).optional(),
+  source: z15.enum(["spawn", "tell"]),
   initiator: threadTurnInitiatorSchema,
-  senderThreadId: z14.string().nullable(),
+  senderThreadId: z15.string().nullable(),
   systemMessageKind: systemMessageKindSchema.optional(),
   systemMessageSubject: systemMessageSubjectSchema.nullable().optional(),
-  input: z14.array(promptInputSchema),
-  inputGroups: z14.array(z14.array(promptInputSchema).min(1)).min(1).optional(),
+  input: z15.array(promptInputSchema),
+  inputGroups: z15.array(z15.array(promptInputSchema).min(1)).min(1).optional(),
   target: turnRequestTargetSchema,
-  request: z14.object({
-    method: z14.enum(["thread/start", "turn/start"]),
-    params: z14.record(z14.string(), z14.unknown())
+  request: z15.object({
+    method: z15.enum(["thread/start", "turn/start"]),
+    params: z15.record(z15.string(), z15.unknown())
   }),
   execution: turnRequestOptionsSchema
 });
-var turnRequestRejectedEventDataSchema = z14.object({
+var turnRequestRejectedEventDataSchema = z15.object({
   requestId: clientTurnRequestIdSchema,
-  reason: z14.string().min(1),
-  message: z14.string().min(1)
-});
-var systemErrorEventDataSchema = z14.object({
-  code: z14.string().optional(),
-  message: z14.string(),
-  detail: z14.string().optional(),
-  reconnectAttempt: z14.number().int().positive().optional(),
-  reconnectTotal: z14.number().int().positive().optional()
+  reason: z15.string().min(1),
+  message: z15.string().min(1)
+});
+var systemErrorEventDataSchema = z15.object({
+  code: z15.string().optional(),
+  message: z15.string(),
+  detail: z15.string().optional(),
+  reconnectAttempt: z15.number().int().positive().optional(),
+  reconnectTotal: z15.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: z14.ZodIssueCode.custom,
+      code: z15.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: z14.ZodIssueCode.custom,
+      code: z15.ZodIssueCode.custom,
       message: "system/error reconnectAttempt cannot be greater than reconnectTotal"
     });
   }
@@ -2333,42 +2849,42 @@ var ownershipChangeOperationActionValues = [
   "release",
   "transfer"
 ];
-var ownershipChangeOperationActionSchema = z14.enum(
+var ownershipChangeOperationActionSchema = z15.enum(
   ownershipChangeOperationActionValues
 );
-var ownershipChangeOperationMetadataSchema = z14.object({
+var ownershipChangeOperationMetadataSchema = z15.object({
   action: ownershipChangeOperationActionSchema,
-  nextParentThreadId: z14.string().nullable(),
-  nextParentThreadTitle: z14.string().nullable(),
-  previousParentThreadId: z14.string().nullable(),
-  previousParentThreadTitle: z14.string().nullable()
-});
-var systemOperationEventDataSchema = z14.object({
-  operation: z14.string(),
-  status: z14.string(),
-  message: z14.string(),
-  operationId: z14.string(),
-  metadata: z14.record(z14.string(), jsonValueSchema).optional()
-});
-var systemInteractionLifecycleEventDataSchema = z14.object({
+  nextParentThreadId: z15.string().nullable(),
+  nextParentThreadTitle: z15.string().nullable(),
+  previousParentThreadId: z15.string().nullable(),
+  previousParentThreadTitle: z15.string().nullable()
+});
+var systemOperationEventDataSchema = z15.object({
+  operation: z15.string(),
+  status: z15.string(),
+  message: z15.string(),
+  operationId: z15.string(),
+  metadata: z15.record(z15.string(), jsonValueSchema).optional()
+});
+var systemInteractionLifecycleEventDataSchema = z15.object({
   interaction: interactionLifecycleSchema
 });
-var systemPermissionGrantLifecycleEventDataSchema = z14.object({
-  interactionId: z14.string(),
-  providerId: z14.string(),
-  providerRequestId: z14.string(),
+var systemPermissionGrantLifecycleEventDataSchema = z15.object({
+  interactionId: z15.string(),
+  providerId: z15.string(),
+  providerRequestId: z15.string(),
   status: pendingInteractionStatusSchema,
   resolution: approvalPendingInteractionResolutionSchema.nullable().default(null),
-  statusReason: z14.string().nullable().default(null),
+  statusReason: z15.string().nullable().default(null),
   subject: pendingInteractionPermissionGrantApprovalSubjectSchema
 });
-var systemUserQuestionLifecycleEventDataSchema = z14.object({
-  interactionId: z14.string(),
-  providerId: z14.string(),
-  providerRequestId: z14.string(),
+var systemUserQuestionLifecycleEventDataSchema = z15.object({
+  interactionId: z15.string(),
+  providerId: z15.string(),
+  providerRequestId: z15.string(),
   status: pendingInteractionStatusSchema,
   resolution: userQuestionPendingInteractionResolutionSchema.nullable().default(null),
-  statusReason: z14.string().nullable().default(null),
+  statusReason: z15.string().nullable().default(null),
   payload: userQuestionPendingInteractionPayloadSchema
 });
 var systemThreadInterruptedReasonValues = [
@@ -2376,20 +2892,20 @@ var systemThreadInterruptedReasonValues = [
   "host-daemon-restarted",
   "provider-turn-idle"
 ];
-var systemThreadInterruptedReasonSchema = z14.enum(
+var systemThreadInterruptedReasonSchema = z15.enum(
   systemThreadInterruptedReasonValues
 );
-var systemThreadInterruptedEventDataSchema = z14.object({
+var systemThreadInterruptedEventDataSchema = z15.object({
   reason: systemThreadInterruptedReasonSchema,
-  cause: z14.literal("host-connection-lost").optional()
+  cause: z15.literal("host-connection-lost").optional()
 });
-var provisioningTranscriptEntrySchema = z14.object({
-  type: z14.enum(["step", "output"]),
-  key: z14.string(),
-  text: z14.string(),
-  startedAt: z14.number().optional(),
-  status: z14.enum(["started", "completed", "failed"]).optional(),
-  metadata: z14.record(z14.string(), z14.unknown()).optional()
+var provisioningTranscriptEntrySchema = z15.object({
+  type: z15.enum(["step", "output"]),
+  key: z15.string(),
+  text: z15.string(),
+  startedAt: z15.number().optional(),
+  status: z15.enum(["started", "completed", "failed"]).optional(),
+  metadata: z15.record(z15.string(), z15.unknown()).optional()
 });
 var systemThreadProvisioningStatusValues = [
   "active",
@@ -2397,48 +2913,48 @@ var systemThreadProvisioningStatusValues = [
   "failed",
   "cancelled"
 ];
-var systemThreadProvisioningStatusSchema = z14.enum(
+var systemThreadProvisioningStatusSchema = z15.enum(
   systemThreadProvisioningStatusValues
 );
-var systemThreadProvisioningEventDataSchema = z14.object({
-  provisioningId: z14.string(),
+var systemThreadProvisioningEventDataSchema = z15.object({
+  provisioningId: z15.string(),
   status: systemThreadProvisioningStatusSchema,
-  environmentId: z14.string().nullable(),
-  entries: z14.array(provisioningTranscriptEntrySchema)
-});
-var systemLegacyUserMessageEventDataSchema = z14.object({
-  text: z14.string(),
-  toolCallId: z14.string().optional(),
-  turnId: z14.string().optional()
-});
-var systemProviderTurnWatchdogEventDataSchema = z14.object({
-  reason: z14.literal("provider-turn-idle"),
-  thresholdMs: z14.number().int().positive(),
-  elapsedMs: z14.number().int().nonnegative(),
-  activeTurnId: z14.string().min(1),
-  activeTurnStartedAt: z14.number().int().nonnegative(),
-  lastActivityEventSequence: z14.number().int().positive(),
-  lastActivityEventType: z14.string().min(1),
-  lastActivityEventAt: z14.number().int().nonnegative(),
-  providerId: z14.string().min(1),
-  providerThreadId: z14.string().min(1).nullable(),
-  firedAt: z14.number().int().nonnegative()
+  environmentId: z15.string().nullable(),
+  entries: z15.array(provisioningTranscriptEntrySchema)
+});
+var systemLegacyUserMessageEventDataSchema = z15.object({
+  text: z15.string(),
+  toolCallId: z15.string().optional(),
+  turnId: z15.string().optional()
+});
+var systemProviderTurnWatchdogEventDataSchema = z15.object({
+  reason: z15.literal("provider-turn-idle"),
+  thresholdMs: z15.number().int().positive(),
+  elapsedMs: z15.number().int().nonnegative(),
+  activeTurnId: z15.string().min(1),
+  activeTurnStartedAt: z15.number().int().nonnegative(),
+  lastActivityEventSequence: z15.number().int().positive(),
+  lastActivityEventType: z15.string().min(1),
+  lastActivityEventAt: z15.number().int().nonnegative(),
+  providerId: z15.string().min(1),
+  providerThreadId: z15.string().min(1).nullable(),
+  firedAt: z15.number().int().nonnegative()
 });
 
 // ../domain/src/thread-event-scope.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var threadEventScopeKindValues = ["thread", "turn"];
-var threadEventScopeKindSchema = z15.enum(threadEventScopeKindValues);
-var threadEventScopeSchema = z15.discriminatedUnion("kind", [
-  z15.object({ kind: z15.literal("thread") }),
-  z15.object({ kind: z15.literal("turn"), turnId: z15.string().min(1) })
+var threadEventScopeKindSchema = z16.enum(threadEventScopeKindValues);
+var threadEventScopeSchema = z16.discriminatedUnion("kind", [
+  z16.object({ kind: z16.literal("thread") }),
+  z16.object({ kind: z16.literal("turn"), turnId: z16.string().min(1) })
 ]);
 var threadEventScopePolicyValues = [
   "thread",
   "turn",
   "thread-or-turn"
 ];
-var threadEventScopePolicySchema = z15.enum(threadEventScopePolicyValues);
+var threadEventScopePolicySchema = z16.enum(threadEventScopePolicyValues);
 var threadEventScopeDefinitionByType = {
   "thread/started": {
     policy: "thread",
@@ -2604,32 +3120,32 @@ function validateThreadEventScope(args) {
 }
 
 // ../domain/src/thread-timeline-goal.ts
-import { z as z16 } from "zod";
-var threadTimelineGoalStatusSchema = z16.enum([
+import { z as z17 } from "zod";
+var threadTimelineGoalStatusSchema = z17.enum([
   "active",
   "paused",
   "budgetLimited",
   "complete"
 ]);
-var threadTimelineGoalSchema = z16.object({
-  sourceSeq: z16.number().int().nonnegative(),
-  updatedAt: z16.number(),
-  objective: z16.string(),
+var threadTimelineGoalSchema = z17.object({
+  sourceSeq: z17.number().int().nonnegative(),
+  updatedAt: z17.number(),
+  objective: z17.string(),
   status: threadTimelineGoalStatusSchema,
-  tokenBudget: z16.number().nullable(),
-  tokensUsed: z16.number(),
-  timeUsedSeconds: z16.number()
+  tokenBudget: z17.number().nullable(),
+  tokensUsed: z17.number(),
+  timeUsedSeconds: z17.number()
 });
 
 // ../domain/src/provider-event.ts
-var threadEventItemStatusSchema = z17.enum([
+var threadEventItemStatusSchema = z18.enum([
   "pending",
   "completed",
   "failed",
   "interrupted"
 ]);
-var threadEventItemApprovalStatusSchema = z17.enum(["waiting_for_approval", "denied"]).nullable();
-var threadEventTurnStatusSchema = z17.enum([
+var threadEventItemApprovalStatusSchema = z18.enum(["waiting_for_approval", "denied"]).nullable();
+var threadEventTurnStatusSchema = z18.enum([
   "completed",
   "failed",
   "interrupted"
@@ -2655,262 +3171,262 @@ var providerErrorCategoryValues = [
   "unauthorized",
   "unknown"
 ];
-var providerErrorCategorySchema = z17.enum(providerErrorCategoryValues);
-var providerErrorInfoSchema = z17.object({
+var providerErrorCategorySchema = z18.enum(providerErrorCategoryValues);
+var providerErrorInfoSchema = z18.object({
   category: providerErrorCategorySchema,
-  providerCode: z17.string().nullable(),
-  httpStatusCode: z17.number().nullable()
+  providerCode: z18.string().nullable(),
+  httpStatusCode: z18.number().nullable()
 });
-var providerRateLimitStatusSchema = z17.enum([
+var providerRateLimitStatusSchema = z18.enum([
   "allowed",
   "warning",
   "blocked",
   "unknown"
 ]);
-var providerRateLimitWindowSchema = z17.object({
-  providerKey: z17.string().min(1).nullable(),
-  label: z17.string().min(1).nullable(),
+var providerRateLimitWindowSchema = z18.object({
+  providerKey: z18.string().min(1).nullable(),
+  label: z18.string().min(1).nullable(),
   status: providerRateLimitStatusSchema,
-  resetsAtMs: z17.number().int().nonnegative().nullable()
+  resetsAtMs: z18.number().int().nonnegative().nullable()
 });
-var providerRateLimitStateSchema = z17.object({
-  providerId: z17.string().min(1),
+var providerRateLimitStateSchema = z18.object({
+  providerId: z18.string().min(1),
   status: providerRateLimitStatusSchema,
-  kind: z17.enum(["subscription-window", "credits", "spend-control", "unknown"]),
-  windows: z17.array(providerRateLimitWindowSchema),
-  reachedReason: z17.string().min(1).nullable(),
-  overageStatus: z17.enum(["allowed", "warning", "rejected", "unavailable"]).nullable(),
-  overageReason: z17.string().min(1).nullable()
-});
-var threadEventFileChangeKindSchema = z17.enum(["add", "delete", "update"]);
-var threadEventFileChangeSchema = z17.object({
-  path: z17.string(),
+  kind: z18.enum(["subscription-window", "credits", "spend-control", "unknown"]),
+  windows: z18.array(providerRateLimitWindowSchema),
+  reachedReason: z18.string().min(1).nullable(),
+  overageStatus: z18.enum(["allowed", "warning", "rejected", "unavailable"]).nullable(),
+  overageReason: z18.string().min(1).nullable()
+});
+var threadEventFileChangeKindSchema = z18.enum(["add", "delete", "update"]);
+var threadEventFileChangeSchema = z18.object({
+  path: z18.string(),
   kind: threadEventFileChangeKindSchema,
-  movePath: z17.string().optional(),
-  diff: z17.string().optional()
+  movePath: z18.string().optional(),
+  diff: z18.string().optional()
 });
-var threadEventPlanStepStatusSchema = z17.enum([
+var threadEventPlanStepStatusSchema = z18.enum([
   "pending",
   "active",
   "completed",
   "failed"
 ]);
-var threadEventPlanStepSchema = z17.object({
-  step: z17.string(),
+var threadEventPlanStepSchema = z18.object({
+  step: z18.string(),
   status: threadEventPlanStepStatusSchema.optional()
 });
 var itemPresentationField = {
   presentation: threadEventItemPresentationSchema.optional()
 };
-var threadEventWebSearchItemSchema = z17.object({
-  type: z17.literal("webSearch"),
-  id: z17.string(),
-  queries: z17.array(z17.string()).min(1),
-  resultText: z17.string().nullable(),
+var threadEventWebSearchItemSchema = z18.object({
+  type: z18.literal("webSearch"),
+  id: z18.string(),
+  queries: z18.array(z18.string()).min(1),
+  resultText: z18.string().nullable(),
   ...itemPresentationField,
-  parentToolCallId: z17.string().optional()
-});
-var threadEventWebFetchItemSchema = z17.object({
-  type: z17.literal("webFetch"),
-  id: z17.string(),
-  url: z17.string(),
-  prompt: z17.string().nullable(),
-  pattern: z17.string().nullable(),
-  resultText: z17.string().nullable(),
+  parentToolCallId: z18.string().optional()
+});
+var threadEventWebFetchItemSchema = z18.object({
+  type: z18.literal("webFetch"),
+  id: z18.string(),
+  url: z18.string(),
+  prompt: z18.string().nullable(),
+  pattern: z18.string().nullable(),
+  resultText: z18.string().nullable(),
   ...itemPresentationField,
-  parentToolCallId: z17.string().optional()
+  parentToolCallId: z18.string().optional()
 });
-var threadEventImageViewItemSchema = z17.object({
-  type: z17.literal("imageView"),
-  id: z17.string(),
-  path: z17.string(),
+var threadEventImageViewItemSchema = z18.object({
+  type: z18.literal("imageView"),
+  id: z18.string(),
+  path: z18.string(),
   ...itemPresentationField,
-  parentToolCallId: z17.string().optional()
+  parentToolCallId: z18.string().optional()
 });
-var threadEventFileReadItemSchema = z17.object({
-  type: z17.literal("fileRead"),
-  id: z17.string(),
-  path: z17.string(),
-  cmd: z17.string().optional(),
+var threadEventFileReadItemSchema = z18.object({
+  type: z18.literal("fileRead"),
+  id: z18.string(),
+  path: z18.string(),
+  cmd: z18.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z17.string().optional()
+  parentToolCallId: z18.string().optional()
 });
-var threadEventSearchModeSchema = z17.enum(["content", "path", "list"]);
-var threadEventSearchItemSchema = z17.object({
-  type: z17.literal("search"),
-  id: z17.string(),
+var threadEventSearchModeSchema = z18.enum(["content", "path", "list"]);
+var threadEventSearchItemSchema = z18.object({
+  type: z18.literal("search"),
+  id: z18.string(),
   mode: threadEventSearchModeSchema,
-  query: z17.string(),
-  path: z17.string().optional(),
-  cmd: z17.string().optional(),
+  query: z18.string(),
+  path: z18.string().optional(),
+  cmd: z18.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z17.string().optional()
+  parentToolCallId: z18.string().optional()
 });
-var threadEventDelegationItemSchema = z17.object({
-  type: z17.literal("delegation"),
-  id: z17.string(),
-  childRef: z17.string().min(1),
-  label: z17.string(),
+var threadEventDelegationItemSchema = z18.object({
+  type: z18.literal("delegation"),
+  id: z18.string(),
+  childRef: z18.string().min(1),
+  label: z18.string(),
   status: threadEventItemStatusSchema,
-  background: z17.boolean(),
-  summary: z17.string().optional(),
+  background: z18.boolean(),
+  summary: z18.string().optional(),
   ...itemPresentationField,
-  parentToolCallId: z17.string().optional()
+  parentToolCallId: z18.string().optional()
 });
-var threadEventPlanStepsItemSchema = z17.object({
-  type: z17.literal("planSteps"),
-  id: z17.string(),
-  steps: z17.array(threadEventPlanStepSchema),
-  explanation: z17.string().optional(),
+var threadEventPlanStepsItemSchema = z18.object({
+  type: z18.literal("planSteps"),
+  id: z18.string(),
+  steps: z18.array(threadEventPlanStepSchema),
+  explanation: z18.string().optional(),
   status: threadEventItemStatusSchema,
   ...itemPresentationField,
-  parentToolCallId: z17.string().optional()
+  parentToolCallId: z18.string().optional()
 });
-var threadEventExtensionItemSchema = z17.object({
-  type: z17.literal("extension"),
-  id: z17.string(),
+var threadEventExtensionItemSchema = z18.object({
+  type: z18.literal("extension"),
+  id: z18.string(),
   kind: extensionKindSchema,
   payload: jsonValueSchema,
   status: threadEventItemStatusSchema,
   presentation: threadEventItemPresentationSchema,
-  parentToolCallId: z17.string().optional()
+  parentToolCallId: z18.string().optional()
 });
-var threadEventTextTruncationSchema = z17.object({
-  originalLength: z17.number(),
-  retainedHeadLength: z17.number(),
-  retainedTailLength: z17.number(),
-  truncatedAt: z17.number()
+var threadEventTextTruncationSchema = z18.object({
+  originalLength: z18.number(),
+  retainedHeadLength: z18.number(),
+  retainedTailLength: z18.number(),
+  truncatedAt: z18.number()
 });
-var threadEventItemTruncationSchema = z17.object({
+var threadEventItemTruncationSchema = z18.object({
   aggregatedOutput: threadEventTextTruncationSchema.optional(),
   result: threadEventTextTruncationSchema.optional(),
   resultText: threadEventTextTruncationSchema.optional()
 });
-var threadEventImageGenerationItemSchema = z17.object({
-  type: z17.literal("imageGeneration"),
-  id: z17.string(),
+var threadEventImageGenerationItemSchema = z18.object({
+  type: z18.literal("imageGeneration"),
+  id: z18.string(),
   status: threadEventItemStatusSchema,
-  prompt: z17.string().nullable(),
-  path: z17.string().nullable(),
-  result: z17.string().optional(),
-  error: z17.string().nullable(),
-  transparentBackground: z17.boolean(),
+  prompt: z18.string().nullable(),
+  path: z18.string().nullable(),
+  result: z18.string().optional(),
+  error: z18.string().nullable(),
+  transparentBackground: z18.boolean(),
   truncation: threadEventItemTruncationSchema.optional(),
   ...itemPresentationField,
-  parentToolCallId: z17.string().optional()
+  parentToolCallId: z18.string().optional()
 });
-var threadEventUserContentSchema = z17.discriminatedUnion("type", [
-  z17.object({ type: z17.literal("text"), text: z17.string() }),
-  z17.object({ type: z17.literal("image"), url: z17.string() }),
-  z17.object({ type: z17.literal("localImage"), path: z17.string() }),
-  z17.object({ type: z17.literal("localFile"), path: z17.string() })
+var threadEventUserContentSchema = z18.discriminatedUnion("type", [
+  z18.object({ type: z18.literal("text"), text: z18.string() }),
+  z18.object({ type: z18.literal("image"), url: z18.string() }),
+  z18.object({ type: z18.literal("localImage"), path: z18.string() }),
+  z18.object({ type: z18.literal("localFile"), path: z18.string() })
 ]);
-var threadEventTokenUsageBreakdownSchema = z17.object({
-  totalTokens: z17.number(),
-  inputTokens: z17.number(),
-  cachedInputTokens: z17.number(),
-  cacheReadInputTokens: z17.number().nonnegative().optional(),
-  cacheWriteInputTokens: z17.number().nonnegative().optional(),
-  outputTokens: z17.number(),
-  reasoningOutputTokens: z17.number()
-});
-var threadEventContextWindowUsageSchema = z17.object({
+var threadEventTokenUsageBreakdownSchema = z18.object({
+  totalTokens: z18.number(),
+  inputTokens: z18.number(),
+  cachedInputTokens: z18.number(),
+  cacheReadInputTokens: z18.number().nonnegative().optional(),
+  cacheWriteInputTokens: z18.number().nonnegative().optional(),
+  outputTokens: z18.number(),
+  reasoningOutputTokens: z18.number()
+});
+var threadEventContextWindowUsageSchema = z18.object({
   snapshot: contextSnapshotSchema.optional(),
-  usedTokens: z17.number().nullable(),
-  modelContextWindow: z17.number().nullable(),
-  estimated: z17.boolean()
+  usedTokens: z18.number().nullable(),
+  modelContextWindow: z18.number().nullable(),
+  estimated: z18.boolean()
 });
-var threadEventTokenUsageSchema = z17.object({
+var threadEventTokenUsageSchema = z18.object({
   total: threadEventTokenUsageBreakdownSchema,
   last: threadEventTokenUsageBreakdownSchema,
-  modelContextWindow: z17.number().nullable()
+  modelContextWindow: z18.number().nullable()
 });
-var threadEventWarningCategorySchema = z17.enum([
+var threadEventWarningCategorySchema = z18.enum([
   "deprecation",
   "config",
   "general",
   "compaction-skipped"
 ]);
-var providerRawEventSchema = z17.object({
-  jsonrpc: z17.literal("2.0"),
-  id: z17.union([z17.string(), z17.number()]).optional(),
-  method: z17.string(),
+var providerRawEventSchema = z18.object({
+  jsonrpc: z18.literal("2.0"),
+  id: z18.union([z18.string(), z18.number()]).optional(),
+  method: z18.string(),
   params: jsonValueSchema.optional()
 });
-var providerUnhandledEventSchema = z17.object({
-  type: z17.literal("provider/unhandled"),
-  threadId: z17.string(),
-  providerThreadId: z17.string(),
-  providerId: z17.string(),
-  rawType: z17.string(),
+var providerUnhandledEventSchema = z18.object({
+  type: z18.literal("provider/unhandled"),
+  threadId: z18.string(),
+  providerThreadId: z18.string(),
+  providerId: z18.string(),
+  rawType: z18.string(),
   rawEvent: providerRawEventSchema,
-  parentToolCallId: z17.string().optional()
-});
-var toolCallProgressEventSchema = z17.object({
-  type: z17.literal("item/toolCall/progress"),
-  threadId: z17.string(),
-  providerThreadId: z17.string(),
-  itemId: z17.string(),
-  message: z17.string().optional(),
-  parentToolCallId: z17.string().optional()
-});
-var threadEventBackgroundTaskItemSchema = z17.object({
-  type: z17.literal("backgroundTask"),
-  id: z17.string(),
-  familyId: z17.string().optional(),
-  taskType: z17.string(),
-  description: z17.string(),
+  parentToolCallId: z18.string().optional()
+});
+var toolCallProgressEventSchema = z18.object({
+  type: z18.literal("item/toolCall/progress"),
+  threadId: z18.string(),
+  providerThreadId: z18.string(),
+  itemId: z18.string(),
+  message: z18.string().optional(),
+  parentToolCallId: z18.string().optional()
+});
+var threadEventBackgroundTaskItemSchema = z18.object({
+  type: z18.literal("backgroundTask"),
+  id: z18.string(),
+  familyId: z18.string().optional(),
+  taskType: z18.string(),
+  description: z18.string(),
   status: threadEventItemStatusSchema,
   taskStatus: backgroundTaskStatusSchema,
-  skipTranscript: z17.boolean(),
-  workflowName: z17.string().optional(),
+  skipTranscript: z18.boolean(),
+  workflowName: z18.string().optional(),
   workflow: workflowProgressSnapshotSchema.optional(),
   usage: backgroundTaskUsageSchema.optional(),
-  summary: z17.string().optional(),
-  error: z17.string().optional(),
-  outputFile: z17.string().optional(),
+  summary: z18.string().optional(),
+  error: z18.string().optional(),
+  outputFile: z18.string().optional(),
   ...itemPresentationField,
-  parentToolCallId: z17.string().optional()
+  parentToolCallId: z18.string().optional()
 });
-var threadEventItemSchema = z17.discriminatedUnion("type", [
-  z17.object({
-    type: z17.literal("userMessage"),
-    id: z17.string(),
-    content: z17.array(threadEventUserContentSchema),
+var threadEventItemSchema = z18.discriminatedUnion("type", [
+  z18.object({
+    type: z18.literal("userMessage"),
+    id: z18.string(),
+    content: z18.array(threadEventUserContentSchema),
     clientRequestId: clientTurnRequestIdSchema.optional(),
-    parentToolCallId: z17.string().optional()
+    parentToolCallId: z18.string().optional()
   }).strict(),
-  z17.object({
-    type: z17.literal("agentMessage"),
-    id: z17.string(),
-    text: z17.string(),
+  z18.object({
+    type: z18.literal("agentMessage"),
+    id: z18.string(),
+    text: z18.string(),
     ...itemPresentationField,
-    parentToolCallId: z17.string().optional()
+    parentToolCallId: z18.string().optional()
   }),
-  z17.object({
-    type: z17.literal("commandExecution"),
-    id: z17.string(),
-    command: z17.string(),
-    cwd: z17.string(),
+  z18.object({
+    type: z18.literal("commandExecution"),
+    id: z18.string(),
+    command: z18.string(),
+    cwd: z18.string(),
     status: threadEventItemStatusSchema,
     approvalStatus: threadEventItemApprovalStatusSchema,
-    aggregatedOutput: z17.string().optional(),
-    exitCode: z17.number().optional(),
-    durationMs: z17.number().optional(),
+    aggregatedOutput: z18.string().optional(),
+    exitCode: z18.number().optional(),
+    durationMs: z18.number().optional(),
     truncation: threadEventItemTruncationSchema.optional(),
     ...itemPresentationField,
-    parentToolCallId: z17.string().optional()
+    parentToolCallId: z18.string().optional()
   }),
-  z17.object({
-    type: z17.literal("fileChange"),
-    id: z17.string(),
-    changes: z17.array(threadEventFileChangeSchema),
+  z18.object({
+    type: z18.literal("fileChange"),
+    id: z18.string(),
+    changes: z18.array(threadEventFileChangeSchema),
     status: threadEventItemStatusSchema,
     approvalStatus: threadEventItemApprovalStatusSchema,
     ...itemPresentationField,
-    parentToolCallId: z17.string().optional()
+    parentToolCallId: z18.string().optional()
   }),
   threadEventWebSearchItemSchema,
   threadEventWebFetchItemSchema,
@@ -2918,264 +3434,264 @@ var threadEventItemSchema = z17.discriminatedUnion("type", [
   threadEventImageGenerationItemSchema,
   threadEventFileReadItemSchema,
   threadEventSearchItemSchema,
-  z17.object({
-    type: z17.literal("toolCall"),
-    id: z17.string(),
-    server: z17.string().optional(),
-    tool: z17.string(),
-    arguments: z17.record(z17.string(), z17.unknown()).optional(),
+  z18.object({
+    type: z18.literal("toolCall"),
+    id: z18.string(),
+    server: z18.string().optional(),
+    tool: z18.string(),
+    arguments: z18.record(z18.string(), z18.unknown()).optional(),
     status: threadEventItemStatusSchema,
-    result: z17.unknown().optional(),
-    error: z17.string().optional(),
-    durationMs: z17.number().optional(),
+    result: z18.unknown().optional(),
+    error: z18.string().optional(),
+    durationMs: z18.number().optional(),
     truncation: threadEventItemTruncationSchema.optional(),
     ...itemPresentationField,
-    parentToolCallId: z17.string().optional()
+    parentToolCallId: z18.string().optional()
   }),
-  z17.object({
-    type: z17.literal("reasoning"),
-    id: z17.string(),
-    summary: z17.array(z17.string()),
-    content: z17.array(z17.string()),
+  z18.object({
+    type: z18.literal("reasoning"),
+    id: z18.string(),
+    summary: z18.array(z18.string()),
+    content: z18.array(z18.string()),
     ...itemPresentationField,
-    parentToolCallId: z17.string().optional()
+    parentToolCallId: z18.string().optional()
   }),
-  z17.object({
-    type: z17.literal("plan"),
-    id: z17.string(),
-    text: z17.string(),
+  z18.object({
+    type: z18.literal("plan"),
+    id: z18.string(),
+    text: z18.string(),
     ...itemPresentationField,
-    parentToolCallId: z17.string().optional()
+    parentToolCallId: z18.string().optional()
   }),
   threadEventPlanStepsItemSchema,
-  z17.object({
-    type: z17.literal("contextCompaction"),
-    id: z17.string(),
+  z18.object({
+    type: z18.literal("contextCompaction"),
+    id: z18.string(),
     ...itemPresentationField,
-    parentToolCallId: z17.string().optional()
+    parentToolCallId: z18.string().optional()
   }),
   threadEventBackgroundTaskItemSchema,
   threadEventDelegationItemSchema,
   threadEventExtensionItemSchema
 ]);
 function itemTextDeltaEventSchema(type) {
-  return z17.object({
-    type: z17.literal(type),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
-    itemId: z17.string(),
-    delta: z17.string(),
-    parentToolCallId: z17.string().optional()
+  return z18.object({
+    type: z18.literal(type),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    itemId: z18.string(),
+    delta: z18.string(),
+    parentToolCallId: z18.string().optional()
   });
 }
-var unscopedProviderEventSchema = z17.discriminatedUnion("type", [
-  z17.object({
-    type: z17.literal("thread/started"),
-    threadId: z17.string()
+var unscopedProviderEventSchema = z18.discriminatedUnion("type", [
+  z18.object({
+    type: z18.literal("thread/started"),
+    threadId: z18.string()
   }),
-  z17.object({
-    type: z17.literal("thread/identity"),
-    threadId: z17.string(),
-    providerThreadId: z17.string()
+  z18.object({
+    type: z18.literal("thread/identity"),
+    threadId: z18.string(),
+    providerThreadId: z18.string()
   }),
-  z17.object({
-    type: z17.literal("turn/started"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
-    parentToolCallId: z17.string().optional()
+  z18.object({
+    type: z18.literal("turn/started"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    parentToolCallId: z18.string().optional()
   }),
-  z17.object({
-    type: z17.literal("turn/completed"),
-    threadId: z17.string(),
-    providerThreadId: z17.string().nullable(),
+  z18.object({
+    type: z18.literal("turn/completed"),
+    threadId: z18.string(),
+    providerThreadId: z18.string().nullable(),
     status: threadEventTurnStatusSchema,
-    error: z17.object({ message: z17.string() }).optional(),
-    providerCheckpointId: z17.string().min(1).optional()
+    error: z18.object({ message: z18.string() }).optional(),
+    providerCheckpointId: z18.string().min(1).optional()
   }),
-  z17.object({
-    type: z17.literal("turn/input/accepted"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("turn/input/accepted"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     clientRequestId: clientTurnRequestIdSchema,
     scope: threadEventScopeSchema
   }).strict(),
-  z17.object({
-    type: z17.literal("thread/name/updated"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
-    threadName: z17.string()
+  z18.object({
+    type: z18.literal("thread/name/updated"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    threadName: z18.string()
   }),
-  z17.object({
-    type: z17.literal("thread/compacted"),
-    threadId: z17.string(),
-    providerThreadId: z17.string()
+  z18.object({
+    type: z18.literal("thread/compacted"),
+    threadId: z18.string(),
+    providerThreadId: z18.string()
   }),
-  z17.object({
-    type: z17.literal("thread/context/cleared"),
-    threadId: z17.string(),
-    providerThreadId: z17.string()
+  z18.object({
+    type: z18.literal("thread/context/cleared"),
+    threadId: z18.string(),
+    providerThreadId: z18.string()
   }),
-  z17.object({
-    type: z17.literal("thread/goal/updated"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
-    objective: z17.string(),
+  z18.object({
+    type: z18.literal("thread/goal/updated"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    objective: z18.string(),
     status: threadTimelineGoalStatusSchema,
-    tokenBudget: z17.number().nullable(),
-    tokensUsed: z17.number(),
-    timeUsedSeconds: z17.number()
+    tokenBudget: z18.number().nullable(),
+    tokensUsed: z18.number(),
+    timeUsedSeconds: z18.number()
   }),
-  z17.object({
-    type: z17.literal("thread/goal/cleared"),
-    threadId: z17.string(),
-    providerThreadId: z17.string()
+  z18.object({
+    type: z18.literal("thread/goal/cleared"),
+    threadId: z18.string(),
+    providerThreadId: z18.string()
   }),
-  z17.object({
-    type: z17.literal("item/started"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("item/started"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     item: threadEventItemSchema
   }),
-  z17.object({
-    type: z17.literal("item/completed"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("item/completed"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     item: threadEventItemSchema
   }),
   itemTextDeltaEventSchema("item/agentMessage/delta"),
-  z17.object({
-    type: z17.literal("item/commandExecution/outputDelta"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
-    itemId: z17.string(),
-    delta: z17.string(),
-    reset: z17.boolean().optional(),
-    parentToolCallId: z17.string().optional()
+  z18.object({
+    type: z18.literal("item/commandExecution/outputDelta"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    itemId: z18.string(),
+    delta: z18.string(),
+    reset: z18.boolean().optional(),
+    parentToolCallId: z18.string().optional()
   }),
   itemTextDeltaEventSchema("item/fileChange/outputDelta"),
   itemTextDeltaEventSchema("item/reasoning/summaryTextDelta"),
   itemTextDeltaEventSchema("item/reasoning/textDelta"),
   itemTextDeltaEventSchema("item/plan/delta"),
-  z17.object({
-    type: z17.literal("item/mcpToolCall/progress"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
-    itemId: z17.string(),
-    message: z17.string().optional(),
-    parentToolCallId: z17.string().optional()
+  z18.object({
+    type: z18.literal("item/mcpToolCall/progress"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    itemId: z18.string(),
+    message: z18.string().optional(),
+    parentToolCallId: z18.string().optional()
   }),
   toolCallProgressEventSchema,
-  z17.object({
-    type: z17.literal("item/backgroundTask/progress"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("item/backgroundTask/progress"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     item: threadEventBackgroundTaskItemSchema
   }),
-  z17.object({
-    type: z17.literal("item/backgroundTask/completed"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("item/backgroundTask/completed"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     item: threadEventBackgroundTaskItemSchema
   }),
-  z17.object({
-    type: z17.literal("item/delegation/progress"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("item/delegation/progress"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     item: threadEventDelegationItemSchema
   }),
-  z17.object({
-    type: z17.literal("item/delegation/completed"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("item/delegation/completed"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     item: threadEventDelegationItemSchema
   }),
-  z17.object({
-    type: z17.literal("thread/tokenUsage/updated"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("thread/tokenUsage/updated"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     tokenUsage: threadEventTokenUsageSchema
   }),
-  z17.object({
-    type: z17.literal("thread/contextWindowUsage/updated"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("thread/contextWindowUsage/updated"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     contextWindowUsage: threadEventContextWindowUsageSchema
   }),
-  z17.object({
-    type: z17.literal("turn/plan/updated"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
-    plan: z17.array(threadEventPlanStepSchema),
-    explanation: z17.string().optional()
+  z18.object({
+    type: z18.literal("turn/plan/updated"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    plan: z18.array(threadEventPlanStepSchema),
+    explanation: z18.string().optional()
   }),
-  z17.object({
-    type: z17.literal("turn/diff/updated"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
-    diff: z17.string().optional()
+  z18.object({
+    type: z18.literal("turn/diff/updated"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    diff: z18.string().optional()
   }),
-  z17.object({
-    type: z17.literal("provider/error"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
-    message: z17.string(),
-    detail: z17.string().optional(),
-    willRetry: z17.boolean().optional(),
+  z18.object({
+    type: z18.literal("provider/error"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    message: z18.string(),
+    detail: z18.string().optional(),
+    willRetry: z18.boolean().optional(),
     errorInfo: providerErrorInfoSchema.optional()
   }),
-  z17.object({
-    type: z17.literal("provider/rateLimits/updated"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("provider/rateLimits/updated"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     rateLimits: providerRateLimitStateSchema
   }),
-  z17.object({
-    type: z17.literal("provider.env-resolved"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
-    entries: z17.array(
-      z17.object({
-        name: z17.string(),
-        source: z17.union([
-          z17.literal("shell"),
-          z17.object({ plugin: z17.string() }).strict(),
-          z17.object({ core: z17.enum(["machine-git", "machine-environment"]) }).strict()
+  z18.object({
+    type: z18.literal("provider.env-resolved"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    entries: z18.array(
+      z18.object({
+        name: z18.string(),
+        source: z18.union([
+          z18.literal("shell"),
+          z18.object({ plugin: z18.string() }).strict(),
+          z18.object({ core: z18.enum(["machine-git", "machine-environment"]) }).strict()
         ]),
-        value: z17.union([
-          z17.string(),
-          z17.object({ masked: z17.literal(true) }).strict()
+        value: z18.union([
+          z18.string(),
+          z18.object({ masked: z18.literal(true) }).strict()
         ]),
-        reason: z17.string().optional()
+        reason: z18.string().optional()
       }).strict()
     )
   }),
-  z17.object({
-    type: z17.literal("thread/extensionState/updated"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("thread/extensionState/updated"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     kind: extensionKindSchema,
     payload: jsonValueSchema
   }),
-  z17.object({
-    type: z17.literal("provider/warning"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
+  z18.object({
+    type: z18.literal("provider/warning"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
     category: threadEventWarningCategorySchema,
-    summary: z17.string().optional(),
-    details: z17.string().optional()
+    summary: z18.string().optional(),
+    details: z18.string().optional()
   }),
-  z17.object({
-    type: z17.literal("provider/modelFallback"),
-    threadId: z17.string(),
-    providerThreadId: z17.string(),
-    originalModel: z17.string().min(1),
-    fallbackModel: z17.string().min(1),
-    reason: z17.enum(["refusal", "provider"]),
-    message: z17.string()
+  z18.object({
+    type: z18.literal("provider/modelFallback"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    originalModel: z18.string().min(1),
+    fallbackModel: z18.string().min(1),
+    reason: z18.enum(["refusal", "provider"]),
+    message: z18.string()
   }),
   providerUnhandledEventSchema
 ]);
-var scopedEventDataSchema = z17.object({
+var scopedEventDataSchema = z18.object({
   scope: threadEventScopeSchema
 });
 var providerEventSchema = unscopedProviderEventSchema.and(
@@ -3184,58 +3700,58 @@ var providerEventSchema = unscopedProviderEventSchema.and(
 var providerEventTypeValues = unscopedProviderEventSchema.options.map(
   (option) => option.shape.type.value
 );
-var unscopedSystemEventSchema = z17.discriminatedUnion("type", [
-  z17.object({
-    type: z17.literal("client/thread/start"),
-    threadId: z17.string()
+var unscopedSystemEventSchema = z18.discriminatedUnion("type", [
+  z18.object({
+    type: z18.literal("client/thread/start"),
+    threadId: z18.string()
   }).merge(clientTurnLifecycleEventDataSchema),
-  z17.object({
-    type: z17.literal("client/turn/requested"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("client/turn/requested"),
+    threadId: z18.string()
   }).merge(turnRequestEventDataSchema),
-  z17.object({
-    type: z17.literal("client/turn/rejected"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("client/turn/rejected"),
+    threadId: z18.string()
   }).merge(turnRequestRejectedEventDataSchema),
-  z17.object({
-    type: z17.literal("client/turn/start"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("client/turn/start"),
+    threadId: z18.string()
   }).merge(clientTurnLifecycleEventDataSchema),
-  z17.object({
-    type: z17.literal("system/error"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("system/error"),
+    threadId: z18.string()
   }).merge(systemErrorEventDataSchema),
-  z17.object({
-    type: z17.literal("system/manager/user_message"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("system/manager/user_message"),
+    threadId: z18.string()
   }).merge(systemLegacyUserMessageEventDataSchema),
-  z17.object({
-    type: z17.literal("system/thread/interrupted"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("system/thread/interrupted"),
+    threadId: z18.string()
   }).merge(systemThreadInterruptedEventDataSchema),
-  z17.object({
-    type: z17.literal("system/operation"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("system/operation"),
+    threadId: z18.string()
   }).merge(systemOperationEventDataSchema),
-  z17.object({
-    type: z17.literal("system/interaction/lifecycle"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("system/interaction/lifecycle"),
+    threadId: z18.string()
   }).merge(systemInteractionLifecycleEventDataSchema),
-  z17.object({
-    type: z17.literal("system/permissionGrant/lifecycle"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("system/permissionGrant/lifecycle"),
+    threadId: z18.string()
   }).merge(systemPermissionGrantLifecycleEventDataSchema),
-  z17.object({
-    type: z17.literal("system/userQuestion/lifecycle"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("system/userQuestion/lifecycle"),
+    threadId: z18.string()
   }).merge(systemUserQuestionLifecycleEventDataSchema),
-  z17.object({
-    type: z17.literal("system/thread-provisioning"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("system/thread-provisioning"),
+    threadId: z18.string()
   }).merge(systemThreadProvisioningEventDataSchema),
-  z17.object({
-    type: z17.literal("system/provider-turn-watchdog"),
-    threadId: z17.string()
+  z18.object({
+    type: z18.literal("system/provider-turn-watchdog"),
+    threadId: z18.string()
   }).merge(systemProviderTurnWatchdogEventDataSchema)
 ]);
 var systemEventSchema = unscopedSystemEventSchema.and(scopedEventDataSchema);
@@ -3243,13 +3759,13 @@ var legacyClientRequestKey = ["clientRequest", "Sequence"].join("");
 function isEventPropertyBag(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var rejectLegacyClientRequestSequenceSchema = z17.unknown().superRefine((value, ctx) => {
+var rejectLegacyClientRequestSequenceSchema = z18.unknown().superRefine((value, ctx) => {
   if (!isEventPropertyBag(value)) {
     return;
   }
   if (Object.hasOwn(value, legacyClientRequestKey)) {
     ctx.addIssue({
-      code: z17.ZodIssueCode.custom,
+      code: z18.ZodIssueCode.custom,
       message: "legacy request sequence field is no longer accepted",
       path: [legacyClientRequestKey]
     });
@@ -3257,21 +3773,21 @@ var rejectLegacyClientRequestSequenceSchema = z17.unknown().superRefine((value,
   const item = value.item;
   if (isEventPropertyBag(item) && item.type === "userMessage" && Object.hasOwn(item, legacyClientRequestKey)) {
     ctx.addIssue({
-      code: z17.ZodIssueCode.custom,
+      code: z18.ZodIssueCode.custom,
       message: "legacy user-message request sequence field is no longer accepted",
       path: ["item", legacyClientRequestKey]
     });
   }
 });
 var threadEventSchema = rejectLegacyClientRequestSequenceSchema.pipe(
-  z17.union([providerEventSchema, systemEventSchema]).superRefine((event, ctx) => {
+  z18.union([providerEventSchema, systemEventSchema]).superRefine((event, ctx) => {
     const result = validateThreadEventScope({
       type: event.type,
       scope: event.scope
     });
     if (!result.valid) {
       ctx.addIssue({
-        code: z17.ZodIssueCode.custom,
+        code: z18.ZodIssueCode.custom,
         message: result.message ?? "Invalid thread event scope",
         path: ["scope"]
       });
@@ -3284,7 +3800,7 @@ var threadEventTypeValues = [
   ...systemEventTypeValues
 ];
 var threadEventTypeSet = new Set(threadEventTypeValues);
-var threadEventTypeSchema = z17.string().refine(
+var threadEventTypeSchema = z18.string().refine(
   (value) => threadEventTypeSet.has(value),
   "Invalid thread event type"
 );
@@ -3295,95 +3811,96 @@ function toPositiveNumber(value) {
 }
 
 // ../domain/src/provider-fork.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var PROVIDER_FORK_VALUES = ["none", "tip", "checkpoint"];
-var providerForkSchema = z18.enum(PROVIDER_FORK_VALUES);
+var providerForkSchema = z19.enum(PROVIDER_FORK_VALUES);
 
 // ../domain/src/provider-types.ts
-import { z as z19 } from "zod";
-var modelReasoningEffortSchema = z19.object({
+import { z as z20 } from "zod";
+var modelReasoningEffortSchema = z20.object({
   reasoningEffort: reasoningLevelSchema,
-  description: z19.string()
-});
-var availableModelSchema = z19.object({
-  id: z19.string(),
-  model: z19.string(),
-  displayName: z19.string(),
-  routeProviderId: z19.string().min(1).optional(),
-  description: z19.string(),
-  supportedReasoningEfforts: z19.array(modelReasoningEffortSchema),
+  description: z20.string()
+});
+var availableModelSchema = z20.object({
+  id: z20.string(),
+  model: z20.string(),
+  displayName: z20.string(),
+  routeProviderId: z20.string().min(1).optional(),
+  description: z20.string(),
+  supportedReasoningEfforts: z20.array(modelReasoningEffortSchema),
   defaultReasoningEffort: reasoningLevelSchema,
-  isDefault: z19.boolean()
-});
-var providerModelCatalogScopeSchema = z19.enum(["host", "workspace"]);
-var providerCapabilitiesSchema = z19.object({
-  supportsThreadArchive: z19.boolean(),
-  supportsThreadRename: z19.boolean(),
-  supportsServiceTier: z19.boolean(),
-  supportsNativeUserQuestion: z19.boolean(),
-  supportsFork: z19.boolean(),
-  supportsSessionRewind: z19.boolean(),
-  permissionModes: z19.array(permissionModeSchema).min(1),
+  isDefault: z20.boolean()
+});
+var providerModelCatalogScopeSchema = z20.enum(["host", "workspace"]);
+var providerCapabilitiesSchema = z20.object({
+  supportsThreadArchive: z20.boolean(),
+  supportsThreadRename: z20.boolean(),
+  supportsServiceTier: z20.boolean(),
+  supportsNativeUserQuestion: z20.boolean(),
+  supportsFork: z20.boolean(),
+  supportsSessionRewind: z20.boolean(),
+  permissionModes: z20.array(permissionModeSchema).min(1),
   modelCatalogScope: providerModelCatalogScopeSchema
 });
-var providerComposerCommandSchema = z19.object({
+var providerComposerCommandSchema = z20.object({
   trigger: promptMentionCommandTriggerSchema,
-  name: z19.string().min(1).regex(/^[^\s/$]+$/u),
-  trailingText: z19.string().regex(/^\s*$/u)
+  name: z20.string().min(1).regex(/^[^\s/$]+$/u),
+  trailingText: z20.string().regex(/^\s*$/u)
 });
-var providerComposerActionSchema = z19.discriminatedUnion("kind", [
-  z19.object({
-    kind: z19.literal("skills"),
+var providerComposerActionSchema = z20.discriminatedUnion("kind", [
+  z20.object({
+    kind: z20.literal("skills"),
     trigger: promptMentionCommandTriggerSchema
   }),
-  z19.object({
-    kind: z19.literal("plan"),
+  z20.object({
+    kind: z20.literal("plan"),
     command: providerComposerCommandSchema
   }),
-  z19.object({
-    kind: z19.literal("goal"),
+  z20.object({
+    kind: z20.literal("goal"),
     command: providerComposerCommandSchema
   })
 ]);
-var providerStringsSchema = z19.object({
-  signInHint: z19.string().min(1),
-  expiredHint: z19.string().min(1),
-  installUrl: z19.string().min(1),
-  brandPrefix: z19.string().min(1).optional(),
-  planModeCopy: z19.string().min(1).optional(),
-  iconTint: z19.object({ light: z19.string().min(1), dark: z19.string().min(1) }).optional()
-});
-var providerOptionDescriptorSchema = z19.object({
-  id: z19.string().min(1),
-  label: z19.string().min(1),
-  description: z19.string().min(1).optional()
-});
-var providerExtensionKindInfoSchema = z19.object({
-  item: z19.boolean(),
-  state: z19.boolean()
-});
-var providerExtensionKindsSchema = z19.record(
+var providerStringsSchema = z20.object({
+  signInHint: z20.string().min(1),
+  expiredHint: z20.string().min(1),
+  installUrl: z20.string().min(1),
+  brandPrefix: z20.string().min(1).optional(),
+  planModeCopy: z20.string().min(1).optional(),
+  iconTint: z20.object({ light: z20.string().min(1), dark: z20.string().min(1) }).optional()
+});
+var providerOptionDescriptorSchema = z20.object({
+  id: z20.string().min(1),
+  label: z20.string().min(1),
+  description: z20.string().min(1).optional()
+});
+var providerExtensionKindInfoSchema = z20.object({
+  item: z20.boolean(),
+  state: z20.boolean()
+});
+var providerExtensionKindsSchema = z20.record(
   extensionKindSchema,
   providerExtensionKindInfoSchema
 );
-var providerInfoSchema = z19.object({
-  id: z19.string(),
-  pluginId: z19.string().min(1),
-  displayName: z19.string(),
-  family: z19.string().min(1).optional(),
-  icon: z19.object({ glyph: z19.string().min(1) }).optional(),
-  logoUrl: z19.string().min(1).nullable(),
-  maintenance: z19.object({
-    health: z19.boolean(),
-    usage: z19.boolean(),
-    installation: z19.boolean()
+var providerInfoSchema = z20.object({
+  id: z20.string(),
+  pluginId: z20.string().min(1),
+  displayName: z20.string(),
+  family: z20.string().min(1).optional(),
+  icon: z20.object({ glyph: z20.string().min(1) }).optional(),
+  logoUrl: z20.string().min(1).nullable(),
+  maintenance: z20.object({
+    health: z20.boolean(),
+    usage: z20.boolean(),
+    installation: z20.boolean()
   }),
   capabilities: providerCapabilitiesSchema,
-  composerActions: z19.array(providerComposerActionSchema),
-  available: z19.boolean(),
+  composerActions: z20.array(providerComposerActionSchema),
+  completedTurnDisplay: completedTurnDisplaySchema,
+  available: z20.boolean(),
   strings: providerStringsSchema.optional(),
-  serviceTiers: z19.array(providerOptionDescriptorSchema).optional(),
-  reasoningLevels: z19.array(providerOptionDescriptorSchema).optional(),
+  serviceTiers: z20.array(providerOptionDescriptorSchema).optional(),
+  reasoningLevels: z20.array(providerOptionDescriptorSchema).optional(),
   extensionKinds: providerExtensionKindsSchema.optional()
 });
 var providerRecoveryKindValues = [
@@ -3393,34 +3910,34 @@ var providerRecoveryKindValues = [
   "staleTurn",
   "rateLimited"
 ];
-var providerRecoveryKindSchema = z19.enum(providerRecoveryKindValues);
-var toolCallOutputItemSchema = z19.discriminatedUnion("type", [
-  z19.object({
-    type: z19.literal("inputText"),
-    text: z19.string()
+var providerRecoveryKindSchema = z20.enum(providerRecoveryKindValues);
+var toolCallOutputItemSchema = z20.discriminatedUnion("type", [
+  z20.object({
+    type: z20.literal("inputText"),
+    text: z20.string()
   }),
-  z19.object({
-    type: z19.literal("inputImage"),
-    imageUrl: z19.string()
+  z20.object({
+    type: z20.literal("inputImage"),
+    imageUrl: z20.string()
   })
 ]);
-var toolCallRequestSchema = z19.object({
-  requestId: z19.union([z19.string().min(1), z19.number()]),
-  threadId: z19.string().min(1),
-  providerThreadId: z19.string().min(1),
-  turnId: z19.string().min(1),
-  callId: z19.string().min(1),
-  tool: z19.string().min(1),
-  arguments: z19.unknown().optional()
-});
-var toolCallResponseSchema = z19.object({
-  contentItems: z19.array(toolCallOutputItemSchema),
-  success: z19.boolean()
-});
-var dynamicToolSchema = z19.object({
-  name: z19.string(),
-  description: z19.string(),
-  inputSchema: z19.unknown(),
+var toolCallRequestSchema = z20.object({
+  requestId: z20.union([z20.string().min(1), z20.number()]),
+  threadId: z20.string().min(1),
+  providerThreadId: z20.string().min(1),
+  turnId: z20.string().min(1),
+  callId: z20.string().min(1),
+  tool: z20.string().min(1),
+  arguments: z20.unknown().optional()
+});
+var toolCallResponseSchema = z20.object({
+  contentItems: z20.array(toolCallOutputItemSchema),
+  success: z20.boolean()
+});
+var dynamicToolSchema = z20.object({
+  name: z20.string(),
+  description: z20.string(),
+  inputSchema: z20.unknown(),
   presentation: threadEventItemPresentationSchema.optional()
 });
 
@@ -3472,60 +3989,60 @@ function reasoningEffortsForLevels(levels) {
 }
 
 // ../provider-bridge-protocol/src/bridge-requests.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var BRIDGE_INBOUND_REQUEST_METHODS = {
   toolCall: "item/tool/call",
   interactionRequest: "interaction/request"
 };
-var toolCallRequestParamsSchema = z20.object({
-  providerThreadId: z20.string().min(1),
-  threadId: z20.string().min(1).optional(),
-  turnId: z20.union([z20.string().min(1), z20.null()]),
-  callId: z20.string().min(1),
-  tool: z20.string().min(1),
-  arguments: z20.unknown(),
-  providerNativeIds: z20.boolean().optional()
+var toolCallRequestParamsSchema = z21.object({
+  providerThreadId: z21.string().min(1),
+  threadId: z21.string().min(1).optional(),
+  turnId: z21.union([z21.string().min(1), z21.null()]),
+  callId: z21.string().min(1),
+  tool: z21.string().min(1),
+  arguments: z21.unknown(),
+  providerNativeIds: z21.boolean().optional()
 }).passthrough();
-var toolCallResultSchema = z20.object({
-  success: z20.boolean(),
-  contentItems: z20.array(
-    z20.discriminatedUnion("type", [
-      z20.object({ type: z20.literal("inputText"), text: z20.string() }),
-      z20.object({
-        type: z20.literal("inputImage"),
-        imageUrl: z20.string().min(1)
+var toolCallResultSchema = z21.object({
+  success: z21.boolean(),
+  contentItems: z21.array(
+    z21.discriminatedUnion("type", [
+      z21.object({ type: z21.literal("inputText"), text: z21.string() }),
+      z21.object({
+        type: z21.literal("inputImage"),
+        imageUrl: z21.string().min(1)
       })
     ])
   )
 }).passthrough();
-var interactionRequestParamsSchema = z20.object({
-  providerThreadId: z20.string().min(1),
-  threadId: z20.string().min(1).optional(),
-  turnId: z20.union([z20.string().min(1), z20.null()]),
+var interactionRequestParamsSchema = z21.object({
+  providerThreadId: z21.string().min(1),
+  threadId: z21.string().min(1).optional(),
+  turnId: z21.union([z21.string().min(1), z21.null()]),
   payload: pendingInteractionPayloadSchema,
-  providerNativeIds: z20.boolean().optional()
+  providerNativeIds: z21.boolean().optional()
 }).passthrough();
 
 // ../provider-bridge-protocol/src/bridge-kit/bridge-tool-calls.ts
-var bridgeRequestEnvelopeSchema = z21.object({
-  jsonrpc: z21.literal("2.0"),
-  id: z21.union([z21.string(), z21.number()]),
-  method: z21.string(),
-  params: z21.record(z21.string(), z21.unknown()).optional()
-});
-var jsonRpcErrorSchema = z21.object({
-  code: z21.number(),
-  message: z21.string().optional(),
-  data: z21.unknown().optional()
-});
-var jsonRpcSuccessResponseSchema = z21.object({
-  jsonrpc: z21.literal("2.0"),
-  id: z21.union([z21.string(), z21.number()]),
-  result: z21.unknown()
-});
-var jsonRpcErrorResponseSchema = z21.object({
-  jsonrpc: z21.literal("2.0"),
-  id: z21.union([z21.string(), z21.number()]),
+var bridgeRequestEnvelopeSchema = z22.object({
+  jsonrpc: z22.literal("2.0"),
+  id: z22.union([z22.string(), z22.number()]),
+  method: z22.string(),
+  params: z22.record(z22.string(), z22.unknown()).optional()
+});
+var jsonRpcErrorSchema = z22.object({
+  code: z22.number(),
+  message: z22.string().optional(),
+  data: z22.unknown().optional()
+});
+var jsonRpcSuccessResponseSchema = z22.object({
+  jsonrpc: z22.literal("2.0"),
+  id: z22.union([z22.string(), z22.number()]),
+  result: z22.unknown()
+});
+var jsonRpcErrorResponseSchema = z22.object({
+  jsonrpc: z22.literal("2.0"),
+  id: z22.union([z22.string(), z22.number()]),
   error: jsonRpcErrorSchema
 });
 function isJsonRpcRequest(input) {
@@ -3613,47 +4130,47 @@ function buildBridgeToolCallContent(result) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/json-rpc-envelope.ts
-import { z as z22 } from "zod";
-var recordSchema = z22.record(z22.string(), z22.unknown());
-var jsonRpcEnvelopeSchema = z22.object({
-  jsonrpc: z22.literal("2.0"),
-  method: z22.string(),
+import { z as z23 } from "zod";
+var recordSchema = z23.record(z23.string(), z23.unknown());
+var jsonRpcEnvelopeSchema = z23.object({
+  jsonrpc: z23.literal("2.0"),
+  method: z23.string(),
   params: recordSchema.optional()
 }).passthrough();
-var sdkMessageEnvelopeSchema = z22.object({
-  jsonrpc: z22.literal("2.0"),
-  method: z22.literal("sdk/message"),
-  params: z22.object({
-    message: z22.unknown(),
-    threadId: z22.string().optional(),
-    parent_tool_use_id: z22.string().optional()
+var sdkMessageEnvelopeSchema = z23.object({
+  jsonrpc: z23.literal("2.0"),
+  method: z23.literal("sdk/message"),
+  params: z23.object({
+    message: z23.unknown(),
+    threadId: z23.string().optional(),
+    parent_tool_use_id: z23.string().optional()
   }).passthrough()
 }).passthrough();
-var threadIdentityEnvelopeSchema = z22.object({
-  jsonrpc: z22.literal("2.0"),
-  method: z22.literal("thread/identity"),
-  params: z22.object({
-    threadId: z22.string().optional(),
-    providerThreadId: z22.string().optional()
+var threadIdentityEnvelopeSchema = z23.object({
+  jsonrpc: z23.literal("2.0"),
+  method: z23.literal("thread/identity"),
+  params: z23.object({
+    threadId: z23.string().optional(),
+    providerThreadId: z23.string().optional()
   }).passthrough()
 }).passthrough();
-var threadContextWindowUsageEnvelopeSchema = z22.object({
-  jsonrpc: z22.literal("2.0"),
-  method: z22.literal("thread/contextWindowUsage/updated"),
-  params: z22.object({
-    threadId: z22.string().optional(),
-    contextWindowUsage: z22.object({
-      usedTokens: z22.number().nullable(),
-      modelContextWindow: z22.number().nullable(),
-      estimated: z22.boolean()
+var threadContextWindowUsageEnvelopeSchema = z23.object({
+  jsonrpc: z23.literal("2.0"),
+  method: z23.literal("thread/contextWindowUsage/updated"),
+  params: z23.object({
+    threadId: z23.string().optional(),
+    contextWindowUsage: z23.object({
+      usedTokens: z23.number().nullable(),
+      modelContextWindow: z23.number().nullable(),
+      estimated: z23.boolean()
     })
   }).passthrough()
 }).passthrough();
-var errorEnvelopeSchema = z22.object({
-  jsonrpc: z22.literal("2.0"),
-  method: z22.literal("error"),
-  params: z22.object({
-    message: z22.string().optional()
+var errorEnvelopeSchema = z23.object({
+  jsonrpc: z23.literal("2.0"),
+  method: z23.literal("error"),
+  params: z23.object({
+    message: z23.string().optional()
   }).passthrough().optional()
 }).passthrough();
 
@@ -3834,12 +4351,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 z23 } from "zod";
+import { z as z24 } from "zod";
 var execFileAsync = promisify(execFile);
 var CLI_PROBE_TIMEOUT_MS = 5e3;
 var INSTALLATION_CHECK_TIMEOUT_MS = 15e3;
@@ -3874,7 +4393,8 @@ ${stderr}`.trim();
   }
 }
 function versionFrom(value) {
-  return value?.match(/\bv?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/u)?.[1] ?? null;
+  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 {
@@ -3883,32 +4403,14 @@ 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;
   }
 }
 function compareVersions(left, right) {
-  const parse = (value) => {
-    const match = value.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/u);
-    return match === null ? { core: [0, 0, 0], prerelease: null } : {
-      core: [Number(match[1]), Number(match[2]), Number(match[3])],
-      prerelease: match[4] ?? null
-    };
-  };
-  const a = parse(left);
-  const b = parse(right);
-  for (let index = 0; index < 3; index += 1) {
-    const delta = (a.core[index] ?? 0) - (b.core[index] ?? 0);
-    if (delta !== 0) return delta;
-  }
-  if (a.prerelease === null && b.prerelease !== null) return 1;
-  if (a.prerelease !== null && b.prerelease === null) return -1;
-  if (a.prerelease !== null && b.prerelease !== null) {
-    return a.prerelease.localeCompare(b.prerelease);
-  }
-  return 0;
+  return (0, import_compare.default)(left, right);
 }
 function npmCommand() {
   return process.platform === "win32" ? "npm.cmd" : "npm";
@@ -3946,8 +4448,8 @@ function firstLine(value) {
 function npmGlobalPackageVersion(value, npmPackage) {
   if (value === null) return null;
   try {
-    const parsed = z23.object({
-      dependencies: z23.record(z23.string(), z23.object({ version: z23.string().min(1) })).default({})
+    const parsed = z24.object({
+      dependencies: z24.record(z24.string(), z24.object({ version: z24.string().min(1) })).default({})
     }).safeParse(JSON.parse(value));
     return parsed.success ? parsed.data.dependencies[npmPackage]?.version ?? null : null;
   } catch {
@@ -3984,9 +4486,9 @@ function clampPercent(value) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/provider-tool-call-contract.ts
-import { z as z24 } from "zod";
-var providerToolCallCancellationSchema = z24.object({
-  requestId: z24.union([z24.string(), z24.number().int()])
+import { z as z25 } from "zod";
+var providerToolCallCancellationSchema = z25.object({
+  requestId: z25.union([z25.string(), z25.number().int()])
 });
 
 // ../provider-bridge-protocol/src/bridge-kit/provider-visibility.ts
@@ -4001,10 +4503,10 @@ function createProviderVisibilityMetadata(args) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/runtime-json-rpc.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // ../provider-bridge-protocol/src/errors.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var BRIDGE_JSON_RPC_ERRORS = {
   INVALID_PARAMS: -32602,
   METHOD_NOT_FOUND: -32601,
@@ -4013,12 +4515,12 @@ var BRIDGE_JSON_RPC_ERRORS = {
   SESSION_NOT_RESTORABLE: -32002,
   FORK_CHECKPOINT_UNSUPPORTED: -32003
 };
-var providerRecoveryHintSchema = z25.object({
+var providerRecoveryHintSchema = z26.object({
   kind: providerRecoveryKindSchema,
-  message: z25.string().min(1),
-  retryable: z25.boolean()
+  message: z26.string().min(1),
+  retryable: z26.boolean()
 });
-var bridgeErrorDataSchema = z25.object({ recovery: providerRecoveryHintSchema.optional() }).passthrough();
+var bridgeErrorDataSchema = z26.object({ recovery: providerRecoveryHintSchema.optional() }).passthrough();
 
 // ../provider-bridge-protocol/src/bridge-kit/runtime-json-rpc.ts
 var JSON_RPC_INVALID_PARAMS_CODE = -32602;
@@ -4036,7 +4538,7 @@ var ProviderResponseEncodeError = class extends Error {
     this.name = "ProviderResponseEncodeError";
   }
 };
-var ignoredJsonRpcResultSchema = z26.unknown();
+var ignoredJsonRpcResultSchema = z27.unknown();
 
 // ../provider-bridge-protocol/src/version.ts
 var PROVIDER_BRIDGE_PROTOCOL_VERSION = 2;
@@ -4044,66 +4546,66 @@ var THREAD_DELTA_GRAMMAR_V2 = PROVIDER_BRIDGE_PROTOCOL_VERSION;
 var THREAD_DELTA_GRAMMAR_V3 = 3;
 
 // ../provider-bridge-protocol/src/handshake.ts
-import { z as z27 } from "zod";
-var bridgeGrammarVersionsSchema = z27.tuple([z27.number().int().positive(), z27.number().int().positive()]).refine(([min, max]) => min <= max, {
+import { z as z28 } from "zod";
+var bridgeGrammarVersionsSchema = z28.tuple([z28.number().int().positive(), z28.number().int().positive()]).refine(([min, max]) => min <= max, {
   message: "grammarVersions must be an ascending [min, max] range"
 });
-var bridgeSteerModeSchema = z27.enum(["inject", "queue"]);
-var bridgeCapabilitiesSchema = z27.object({
-  sessionRestore: z27.boolean().default(false),
-  threadArchive: z27.boolean().default(false),
-  threadRename: z27.boolean().default(false),
-  threadGoalClear: z27.boolean().default(false),
+var bridgeSteerModeSchema = z28.enum(["inject", "queue"]);
+var bridgeCapabilitiesSchema = z28.object({
+  sessionRestore: z28.boolean().default(false),
+  threadArchive: z28.boolean().default(false),
+  threadRename: z28.boolean().default(false),
+  threadGoalClear: z28.boolean().default(false),
   fork: providerForkSchema.default("none"),
-  approvalEnforcedBy: z27.enum(["runtime", "provider"]).default("runtime"),
+  approvalEnforcedBy: z28.enum(["runtime", "provider"]).default("runtime"),
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
   ]),
   steerMode: bridgeSteerModeSchema.default("queue"),
-  skills: z27.object({ configure: z27.boolean().default(false) }).default({ configure: false })
+  skills: z28.object({ configure: z28.boolean().default(false) }).default({ configure: false })
 }).passthrough();
-var initializeParamsSchema = z27.object({
-  protocolVersion: z27.number().int().positive(),
-  client: z27.object({ name: z27.string().min(1), version: z27.string().min(1) }),
+var initializeParamsSchema = z28.object({
+  protocolVersion: z28.number().int().positive(),
+  client: z28.object({ name: z28.string().min(1), version: z28.string().min(1) }),
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
   ])
 }).passthrough();
-var initializeResultSchema = z27.object({
-  protocolVersion: z27.number().int().positive(),
-  capabilities: z27.preprocess(
+var initializeResultSchema = z28.object({
+  protocolVersion: z28.number().int().positive(),
+  capabilities: z28.preprocess(
     (value) => value ?? {},
     bridgeCapabilitiesSchema
   )
 }).passthrough();
 
 // ../provider-bridge-protocol/src/execution-options.ts
-import { z as z28 } from "zod";
-var bridgeExecutionOptionsSchema = z28.object({
-  model: z28.string().min(1).optional(),
+import { z as z29 } from "zod";
+var bridgeExecutionOptionsSchema = z29.object({
+  model: z29.string().min(1).optional(),
   serviceTier: serviceTierSchema.optional(),
   reasoningLevel: reasoningLevelSchema.optional(),
   promptMode: promptModeSchema.optional(),
-  instructions: z28.string().optional(),
-  envVars: z28.record(z28.string(), z28.string()).optional(),
-  providerOptions: z28.record(z28.string(), z28.unknown()).optional()
+  instructions: z29.string().optional(),
+  envVars: z29.record(z29.string(), z29.string()).optional(),
+  providerOptions: z29.record(z29.string(), z29.unknown()).optional()
 }).and(runtimePermissionPolicySchema);
 
 // ../provider-bridge-protocol/src/provider-maintenance.ts
-import { z as z29 } from "zod";
-var providerMaintenanceParamsSchema = z29.object({
-  providerId: z29.string().min(1),
-  cwd: z29.string().min(1).optional(),
-  providerOptions: z29.record(z29.string(), z29.unknown()).optional()
+import { z as z30 } from "zod";
+var providerMaintenanceParamsSchema = z30.object({
+  providerId: z30.string().min(1),
+  cwd: z30.string().min(1).optional(),
+  providerOptions: z30.record(z30.string(), z30.unknown()).optional()
 }).passthrough();
-var providerInstallationRequirementSchema = z29.enum(["thread_rewind"]);
+var providerInstallationRequirementSchema = z30.enum(["thread_rewind"]);
 var providerInstallationStatusParamsSchema = providerMaintenanceParamsSchema.extend({
   requirement: providerInstallationRequirementSchema.optional()
 });
-var providerHealthSchema = z29.object({
-  status: z29.enum([
+var providerHealthSchema = z30.object({
+  status: z30.enum([
     "ready",
     "not_installed",
     "unauthenticated",
@@ -4111,114 +4613,114 @@ var providerHealthSchema = z29.object({
     "unsupported_version",
     "unknown"
   ]),
-  statusMessage: z29.string().min(1).nullable(),
-  accountEmail: z29.string().nullable(),
-  planLabel: z29.string().min(1).nullable(),
-  installedVersion: z29.string().min(1).nullable(),
-  minimumSupportedVersion: z29.string().min(1).nullable(),
-  canInstall: z29.boolean(),
-  canUpdate: z29.boolean(),
-  loginCommand: z29.string().min(1).nullable()
+  statusMessage: z30.string().min(1).nullable(),
+  accountEmail: z30.string().nullable(),
+  planLabel: z30.string().min(1).nullable(),
+  installedVersion: z30.string().min(1).nullable(),
+  minimumSupportedVersion: z30.string().min(1).nullable(),
+  canInstall: z30.boolean(),
+  canUpdate: z30.boolean(),
+  loginCommand: z30.string().min(1).nullable()
 }).passthrough();
-var providerUsageWindowSchema = z29.object({
-  label: z29.string().min(1),
-  usedPercent: z29.number().min(0).max(100),
-  resetsAt: z29.string().min(1).nullable(),
-  cost: z29.object({
-    usedUsdCents: z29.number().int().nonnegative(),
-    limitUsdCents: z29.number().int().positive()
+var providerUsageWindowSchema = z30.object({
+  label: z30.string().min(1),
+  usedPercent: z30.number().min(0).max(100),
+  resetsAt: z30.string().min(1).nullable(),
+  cost: z30.object({
+    usedUsdCents: z30.number().int().nonnegative(),
+    limitUsdCents: z30.number().int().positive()
   }).optional()
 }).passthrough();
-var providerUsageSchema = z29.discriminatedUnion("status", [
-  z29.object({
-    status: z29.literal("ok"),
-    accountEmail: z29.string().email().nullable(),
-    planLabel: z29.string().min(1).nullable(),
-    windows: z29.array(providerUsageWindowSchema)
+var providerUsageSchema = z30.discriminatedUnion("status", [
+  z30.object({
+    status: z30.literal("ok"),
+    accountEmail: z30.string().email().nullable(),
+    planLabel: z30.string().min(1).nullable(),
+    windows: z30.array(providerUsageWindowSchema)
   }).passthrough(),
-  z29.object({ status: z29.literal("not_installed") }).passthrough(),
-  z29.object({ status: z29.literal("unauthenticated") }).passthrough(),
-  z29.object({ status: z29.literal("expired") }).passthrough(),
-  z29.object({
-    status: z29.literal("error"),
-    message: z29.string().min(1),
-    planLabel: z29.string().min(1).nullable().default(null),
-    accountEmail: z29.string().nullable().default(null)
+  z30.object({ status: z30.literal("not_installed") }).passthrough(),
+  z30.object({ status: z30.literal("unauthenticated") }).passthrough(),
+  z30.object({ status: z30.literal("expired") }).passthrough(),
+  z30.object({
+    status: z30.literal("error"),
+    message: z30.string().min(1),
+    planLabel: z30.string().min(1).nullable().default(null),
+    accountEmail: z30.string().nullable().default(null)
   }).passthrough()
 ]);
-var providerHealthResultSchema = z29.discriminatedUnion("supported", [
-  z29.object({ supported: z29.literal(false) }).passthrough(),
-  z29.object({
-    supported: z29.literal(true),
+var providerHealthResultSchema = z30.discriminatedUnion("supported", [
+  z30.object({ supported: z30.literal(false) }).passthrough(),
+  z30.object({
+    supported: z30.literal(true),
     health: providerHealthSchema
   }).passthrough()
 ]);
-var providerUsageResultSchema = z29.discriminatedUnion("supported", [
-  z29.object({ supported: z29.literal(false) }).passthrough(),
-  z29.object({
-    supported: z29.literal(true),
+var providerUsageResultSchema = z30.discriminatedUnion("supported", [
+  z30.object({ supported: z30.literal(false) }).passthrough(),
+  z30.object({
+    supported: z30.literal(true),
     usage: providerUsageSchema
   }).passthrough()
 ]);
-var providerInstallationActionKindSchema = z29.enum([
+var providerInstallationActionKindSchema = z30.enum([
   "install",
   "update"
 ]);
-var providerInstallationActionSchema = z29.object({
+var providerInstallationActionSchema = z30.object({
   kind: providerInstallationActionKindSchema,
-  label: z29.enum(["Install", "Update"]),
-  command: z29.string().min(1)
+  label: z30.enum(["Install", "Update"]),
+  command: z30.string().min(1)
 }).passthrough();
-var providerInstallationSourceSchema = z29.enum([
+var providerInstallationSourceSchema = z30.enum([
   "notInstalled",
   "npmGlobal",
   "external"
 ]);
-var providerInstallationStatusSchema = z29.object({
-  executableName: z29.string().min(1),
-  executablePath: z29.string().min(1).nullable(),
-  installed: z29.boolean(),
+var providerInstallationStatusSchema = z30.object({
+  executableName: z30.string().min(1),
+  executablePath: z30.string().min(1).nullable(),
+  installed: z30.boolean(),
   installSource: providerInstallationSourceSchema,
-  currentVersion: z29.string().min(1).nullable(),
-  latestVersion: z29.string().min(1).nullable(),
-  minimumSupportedVersion: z29.string().min(1).nullable(),
-  npmPackageName: z29.string().min(1).nullable(),
-  npmGlobalPackageVersion: z29.string().min(1).nullable(),
+  currentVersion: z30.string().min(1).nullable(),
+  latestVersion: z30.string().min(1).nullable(),
+  minimumSupportedVersion: z30.string().min(1).nullable(),
+  npmPackageName: z30.string().min(1).nullable(),
+  npmGlobalPackageVersion: z30.string().min(1).nullable(),
   installAction: providerInstallationActionSchema.nullable(),
-  needsUpdate: z29.boolean(),
-  versionUnsupported: z29.boolean()
+  needsUpdate: z30.boolean(),
+  versionUnsupported: z30.boolean()
 }).passthrough();
 var providerInstallationRunParamsSchema = providerMaintenanceParamsSchema.extend({
   action: providerInstallationActionKindSchema
 });
-var providerInstallationCommandSchema = z29.object({
-  command: z29.string().min(1),
-  args: z29.array(z29.string()).max(64),
-  displayCommand: z29.string().min(1)
+var providerInstallationCommandSchema = z30.object({
+  command: z30.string().min(1),
+  args: z30.array(z30.string()).max(64),
+  displayCommand: z30.string().min(1)
 }).passthrough();
-var providerInstallationVerificationSchema = z29.discriminatedUnion(
+var providerInstallationVerificationSchema = z30.discriminatedUnion(
   "kind",
   [
-    z29.object({ kind: z29.literal("installed") }).passthrough(),
-    z29.object({
-      kind: z29.literal("version_changed"),
-      previousVersion: z29.string().min(1)
+    z30.object({ kind: z30.literal("installed") }).passthrough(),
+    z30.object({
+      kind: z30.literal("version_changed"),
+      previousVersion: z30.string().min(1)
     }).passthrough(),
-    z29.object({
-      kind: z29.literal("version_at_least"),
-      version: z29.string().min(1)
+    z30.object({
+      kind: z30.literal("version_at_least"),
+      version: z30.string().min(1)
     }).passthrough()
   ]
 );
-var providerInstallationRunResultSchema = z29.discriminatedUnion(
+var providerInstallationRunResultSchema = z30.discriminatedUnion(
   "available",
   [
-    z29.object({
-      available: z29.literal(false),
-      message: z29.string().min(1)
+    z30.object({
+      available: z30.literal(false),
+      message: z30.string().min(1)
     }).passthrough(),
-    z29.object({
-      available: z29.literal(true),
+    z30.object({
+      available: z30.literal(true),
       command: providerInstallationCommandSchema,
       verification: providerInstallationVerificationSchema
     }).passthrough()
@@ -4226,7 +4728,7 @@ var providerInstallationRunResultSchema = z29.discriminatedUnion(
 );
 
 // ../provider-bridge-protocol/src/requests.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var BRIDGE_REQUEST_METHODS = {
   initialize: "initialize",
   modelList: "model/list",
@@ -4248,78 +4750,78 @@ var BRIDGE_REQUEST_METHODS = {
   skillsConfigure: "skills/configure"
 };
 var sessionConstructionFields = {
-  threadId: z30.string().min(1),
-  cwd: z30.string().min(1),
+  threadId: z31.string().min(1),
+  cwd: z31.string().min(1),
   options: bridgeExecutionOptionsSchema,
-  dynamicTools: z30.array(dynamicToolSchema).optional(),
-  disallowedTools: z30.array(z30.string().min(1)).optional(),
+  dynamicTools: z31.array(dynamicToolSchema).optional(),
+  disallowedTools: z31.array(z31.string().min(1)).optional(),
   instructionMode: instructionModeSchema
 };
-var modelListParamsSchema = z30.object({ cwd: z30.string().min(1).optional() }).passthrough();
-var threadStartParamsSchema = z30.object({
+var modelListParamsSchema = z31.object({ cwd: z31.string().min(1).optional() }).passthrough();
+var threadStartParamsSchema = z31.object({
   ...sessionConstructionFields,
-  input: z30.array(promptInputSchema).optional()
+  input: z31.array(promptInputSchema).optional()
 }).passthrough();
-var threadResumeParamsSchema = z30.object({
+var threadResumeParamsSchema = z31.object({
   ...sessionConstructionFields,
-  providerThreadId: z30.string().min(1)
+  providerThreadId: z31.string().min(1)
 }).passthrough();
-var threadForkParamsSchema = z30.object({
+var threadForkParamsSchema = z31.object({
   ...sessionConstructionFields,
-  sourceProviderThreadId: z30.string().min(1),
-  sourceProviderCheckpointId: z30.string().min(1).optional()
+  sourceProviderThreadId: z31.string().min(1),
+  sourceProviderCheckpointId: z31.string().min(1).optional()
 }).passthrough();
-var threadStopParamsSchema = z30.object({
-  threadId: z30.string().min(1),
-  providerThreadId: z30.string().min(1),
-  intent: z30.enum(["interrupt", "release"]),
-  activeTurnId: z30.string().min(1).nullable()
+var threadStopParamsSchema = z31.object({
+  threadId: z31.string().min(1),
+  providerThreadId: z31.string().min(1),
+  intent: z31.enum(["interrupt", "release"]),
+  activeTurnId: z31.string().min(1).nullable()
 }).passthrough();
-var threadRefParams = z30.object({
-  threadId: z30.string().min(1),
-  providerThreadId: z30.string().min(1)
+var threadRefParams = z31.object({
+  threadId: z31.string().min(1),
+  providerThreadId: z31.string().min(1)
 }).passthrough();
 var threadDiscardParamsSchema = threadRefParams;
 var threadArchiveParamsSchema = threadRefParams;
 var threadUnarchiveParamsSchema = threadRefParams;
 var threadGoalClearParamsSchema = threadRefParams;
-var threadNameSetParamsSchema = z30.object({
-  threadId: z30.string().min(1),
-  providerThreadId: z30.string().min(1),
-  title: z30.string().min(1)
+var threadNameSetParamsSchema = z31.object({
+  threadId: z31.string().min(1),
+  providerThreadId: z31.string().min(1),
+  title: z31.string().min(1)
 }).passthrough();
 var turnInputFields = {
-  threadId: z30.string().min(1),
-  providerThreadId: z30.string().min(1),
-  input: z30.array(promptInputSchema),
+  threadId: z31.string().min(1),
+  providerThreadId: z31.string().min(1),
+  input: z31.array(promptInputSchema),
   clientRequestId: clientTurnRequestIdSchema,
   options: bridgeExecutionOptionsSchema
 };
-var turnStartParamsSchema = z30.object(turnInputFields).passthrough();
-var turnSteerParamsSchema = z30.object({
+var turnStartParamsSchema = z31.object(turnInputFields).passthrough();
+var turnSteerParamsSchema = z31.object({
   ...turnInputFields,
-  expectedTurnId: z30.string().min(1)
+  expectedTurnId: z31.string().min(1)
 }).passthrough();
-var skillsConfigureRootSchema = z30.object({
-  id: z30.string().min(1),
-  path: z30.string().min(1),
-  skills: z30.array(
-    z30.object({
-      name: z30.string().min(1),
-      description: z30.string()
+var skillsConfigureRootSchema = z31.object({
+  id: z31.string().min(1),
+  path: z31.string().min(1),
+  skills: z31.array(
+    z31.object({
+      name: z31.string().min(1),
+      description: z31.string()
     }).passthrough()
   )
 }).passthrough();
-var skillsConfigureParamsSchema = z30.object({
-  roots: z30.array(skillsConfigureRootSchema)
+var skillsConfigureParamsSchema = z31.object({
+  roots: z31.array(skillsConfigureRootSchema)
 }).passthrough();
-var threadIdentityResultSchema = z30.object({
-  providerThreadId: z30.string().min(1),
-  sessionRestorable: z30.boolean().optional()
+var threadIdentityResultSchema = z31.object({
+  providerThreadId: z31.string().min(1),
+  sessionRestorable: z31.boolean().optional()
 }).passthrough();
 
 // ../provider-bridge-protocol/src/notifications.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var BRIDGE_NOTIFICATION_METHODS = {
   threadIdentity: "thread/identity",
   sessionReplaced: "session/replaced",
@@ -4327,142 +4829,142 @@ var BRIDGE_NOTIFICATION_METHODS = {
   providerRecovery: "provider/recovery",
   error: "error"
 };
-var threadIdentityNotificationSchema = z31.object({
-  threadId: z31.string().min(1),
-  providerThreadId: z31.string().min(1),
-  sessionRestorable: z31.boolean().optional()
+var threadIdentityNotificationSchema = z32.object({
+  threadId: z32.string().min(1),
+  providerThreadId: z32.string().min(1),
+  sessionRestorable: z32.boolean().optional()
 }).passthrough();
-var sessionReplacedNotificationSchema = z31.object({
-  threadId: z31.string().min(1),
-  providerThreadId: z31.string().min(1).nullable(),
-  reason: z31.string().min(1),
-  contextLost: z31.boolean().default(false),
-  showRuntimeNote: z31.boolean().default(false)
+var sessionReplacedNotificationSchema = z32.object({
+  threadId: z32.string().min(1),
+  providerThreadId: z32.string().min(1).nullable(),
+  reason: z32.string().min(1),
+  contextLost: z32.boolean().default(false),
+  showRuntimeNote: z32.boolean().default(false)
 }).passthrough();
-var providerRecoveryNotificationSchema = z31.object({
-  threadId: z31.string().min(1).optional(),
+var providerRecoveryNotificationSchema = z32.object({
+  threadId: z32.string().min(1).optional(),
   ...providerRecoveryHintSchema.shape
 }).passthrough();
-var errorNotificationSchema = z31.object({
-  threadId: z31.string().min(1).optional(),
-  providerThreadId: z31.string().min(1).optional(),
-  message: z31.string().min(1)
+var errorNotificationSchema = z32.object({
+  threadId: z32.string().min(1).optional(),
+  providerThreadId: z32.string().min(1).optional(),
+  message: z32.string().min(1)
 }).passthrough();
 
 // ../provider-bridge-protocol/src/thread-delta.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var THREAD_DELTA_NOTIFICATION_METHOD = "thread/delta";
 var deltaPresentationSchema = threadEventItemPresentationSchema;
 var THREAD_DELTA_KEY_SEPARATOR = "";
-var deltaKeyPartSchema = z32.string().min(1).refine((value) => !value.includes(THREAD_DELTA_KEY_SEPARATOR), {
+var deltaKeyPartSchema = z33.string().min(1).refine((value) => !value.includes(THREAD_DELTA_KEY_SEPARATOR), {
   message: "provider keys must not contain the internal key separator (\\u001f)"
 });
-var deltaItemKeySchema = z32.object({
+var deltaItemKeySchema = z33.object({
   providerItemId: deltaKeyPartSchema.optional(),
   channel: deltaKeyPartSchema.optional(),
   parentRef: deltaKeyPartSchema.optional()
 });
 var providerTurnIdSchema = deltaKeyPartSchema;
-var deltaFileChangeSchema = z32.object({
-  path: z32.string(),
-  kind: z32.enum(["add", "update", "delete"]),
-  movePath: z32.string().optional(),
-  diff: z32.string().optional(),
-  oldText: z32.string().optional(),
-  newText: z32.string().optional()
-});
-var deltaBackgroundTaskShapeSchema = z32.object({
-  type: z32.literal("backgroundTask"),
-  familyId: z32.string().min(1),
-  taskType: z32.string(),
-  description: z32.string(),
+var deltaFileChangeSchema = z33.object({
+  path: z33.string(),
+  kind: z33.enum(["add", "update", "delete"]),
+  movePath: z33.string().optional(),
+  diff: z33.string().optional(),
+  oldText: z33.string().optional(),
+  newText: z33.string().optional()
+});
+var deltaBackgroundTaskShapeSchema = z33.object({
+  type: z33.literal("backgroundTask"),
+  familyId: z33.string().min(1),
+  taskType: z33.string(),
+  description: z33.string(),
   status: threadEventItemStatusSchema,
   taskStatus: backgroundTaskStatusSchema,
-  skipTranscript: z32.boolean(),
-  workflowName: z32.string().optional(),
+  skipTranscript: z33.boolean(),
+  workflowName: z33.string().optional(),
   workflow: workflowProgressSnapshotSchema.optional(),
   usage: backgroundTaskUsageSchema.optional(),
-  summary: z32.string().optional(),
-  error: z32.string().optional(),
-  outputFile: z32.string().optional()
+  summary: z33.string().optional(),
+  error: z33.string().optional(),
+  outputFile: z33.string().optional()
 });
-var deltaFileReadShapeSchema = z32.object({
-  type: z32.literal("fileRead"),
-  path: z32.string(),
-  cmd: z32.string().optional()
+var deltaFileReadShapeSchema = z33.object({
+  type: z33.literal("fileRead"),
+  path: z33.string(),
+  cmd: z33.string().optional()
 });
-var deltaSearchShapeSchema = z32.object({
-  type: z32.literal("search"),
+var deltaSearchShapeSchema = z33.object({
+  type: z33.literal("search"),
   mode: threadEventSearchModeSchema,
-  query: z32.string(),
-  path: z32.string().optional(),
-  cmd: z32.string().optional()
+  query: z33.string(),
+  path: z33.string().optional(),
+  cmd: z33.string().optional()
 });
-var deltaDelegationShapeSchema = z32.object({
-  type: z32.literal("delegation"),
+var deltaDelegationShapeSchema = z33.object({
+  type: z33.literal("delegation"),
   childRef: deltaKeyPartSchema,
-  label: z32.string(),
-  background: z32.boolean(),
-  summary: z32.string().optional()
+  label: z33.string(),
+  background: z33.boolean(),
+  summary: z33.string().optional()
 });
-var deltaPlanStepsShapeSchema = z32.object({
-  type: z32.literal("planSteps"),
-  steps: z32.array(threadEventPlanStepSchema),
-  explanation: z32.string().optional()
+var deltaPlanStepsShapeSchema = z33.object({
+  type: z33.literal("planSteps"),
+  steps: z33.array(threadEventPlanStepSchema),
+  explanation: z33.string().optional()
 });
-var deltaExtensionShapeSchema = z32.object({
-  type: z32.literal("extension"),
+var deltaExtensionShapeSchema = z33.object({
+  type: z33.literal("extension"),
   kind: extensionKindSchema,
   payload: jsonValueSchema
 });
-var deltaItemShapeSchema = z32.discriminatedUnion("type", [
-  z32.object({
-    type: z32.literal("command"),
-    command: z32.string(),
-    cwd: z32.string(),
-    aggregatedOutput: z32.string().optional(),
-    exitCode: z32.number().optional(),
-    durationMs: z32.number().optional()
+var deltaItemShapeSchema = z33.discriminatedUnion("type", [
+  z33.object({
+    type: z33.literal("command"),
+    command: z33.string(),
+    cwd: z33.string(),
+    aggregatedOutput: z33.string().optional(),
+    exitCode: z33.number().optional(),
+    durationMs: z33.number().optional()
   }),
-  z32.object({
-    type: z32.literal("fileChange"),
-    changes: z32.array(deltaFileChangeSchema)
+  z33.object({
+    type: z33.literal("fileChange"),
+    changes: z33.array(deltaFileChangeSchema)
   }),
-  z32.object({
-    type: z32.literal("tool"),
-    tool: z32.string(),
-    server: z32.string().optional(),
-    args: z32.unknown().optional(),
-    result: z32.unknown().optional(),
-    error: z32.string().optional(),
-    durationMs: z32.number().optional()
+  z33.object({
+    type: z33.literal("tool"),
+    tool: z33.string(),
+    server: z33.string().optional(),
+    args: z33.unknown().optional(),
+    result: z33.unknown().optional(),
+    error: z33.string().optional(),
+    durationMs: z33.number().optional()
   }),
-  z32.object({ type: z32.literal("compaction") }),
-  z32.object({ type: z32.literal("agentMessage"), text: z32.string() }),
-  z32.object({
-    type: z32.literal("reasoning"),
-    summary: z32.array(z32.string()),
-    content: z32.array(z32.string())
+  z33.object({ type: z33.literal("compaction") }),
+  z33.object({ type: z33.literal("agentMessage"), text: z33.string() }),
+  z33.object({
+    type: z33.literal("reasoning"),
+    summary: z33.array(z33.string()),
+    content: z33.array(z33.string())
   }),
-  z32.object({ type: z32.literal("plan"), text: z32.string() }),
-  z32.object({
-    type: z32.literal("webSearch"),
-    queries: z32.array(z32.string()).min(1)
+  z33.object({ type: z33.literal("plan"), text: z33.string() }),
+  z33.object({
+    type: z33.literal("webSearch"),
+    queries: z33.array(z33.string()).min(1)
   }),
-  z32.object({
-    type: z32.literal("webFetch"),
-    url: z32.string(),
-    prompt: z32.string().nullable().optional(),
-    pattern: z32.string().nullable()
+  z33.object({
+    type: z33.literal("webFetch"),
+    url: z33.string(),
+    prompt: z33.string().nullable().optional(),
+    pattern: z33.string().nullable()
   }),
-  z32.object({ type: z32.literal("imageView"), path: z32.string() }),
-  z32.object({
-    type: z32.literal("imageGeneration"),
-    prompt: z32.string().nullable(),
-    path: z32.string().nullable(),
-    result: z32.string().optional(),
-    error: z32.string().nullable(),
-    transparentBackground: z32.boolean()
+  z33.object({ type: z33.literal("imageView"), path: z33.string() }),
+  z33.object({
+    type: z33.literal("imageGeneration"),
+    prompt: z33.string().nullable(),
+    path: z33.string().nullable(),
+    result: z33.string().optional(),
+    error: z33.string().nullable(),
+    transparentBackground: z33.boolean()
   }),
   deltaBackgroundTaskShapeSchema,
   deltaFileReadShapeSchema,
@@ -4471,22 +4973,22 @@ var deltaItemShapeSchema = z32.discriminatedUnion("type", [
   deltaPlanStepsShapeSchema,
   deltaExtensionShapeSchema
 ]);
-var deltaProgressSnapshotSchema = z32.discriminatedUnion("type", [
+var deltaProgressSnapshotSchema = z33.discriminatedUnion("type", [
   deltaBackgroundTaskShapeSchema,
   deltaDelegationShapeSchema
 ]);
-var deltaTextChannelSchema = z32.enum([
+var deltaTextChannelSchema = z33.enum([
   "agentMessage",
   "reasoningSummary",
   "reasoningText",
   "plan"
 ]);
-var deltaOutputChannelSchema = z32.enum(["command", "fileChange"]);
-var deltaErrorSchema = z32.object({ message: z32.string() });
-var deltaAttachSchema = z32.enum(["open", "currentOrLast"]);
-var deltaNoTurnFallbackSchema = z32.object({
+var deltaOutputChannelSchema = z33.enum(["command", "fileChange"]);
+var deltaErrorSchema = z33.object({ message: z33.string() });
+var deltaAttachSchema = z33.enum(["open", "currentOrLast"]);
+var deltaNoTurnFallbackSchema = z33.object({
   raw: providerRawEventSchema,
-  rawType: z32.string()
+  rawType: z33.string()
 });
 function requireExtensionPresentation(delta, ctx) {
   if (delta.item.type === "extension" && delta.presentation === void 0) {
@@ -4497,32 +4999,32 @@ function requireExtensionPresentation(delta, ctx) {
     });
   }
 }
-var threadDeltaSchema = z32.discriminatedUnion("kind", [
-  z32.object({
-    kind: z32.literal("input.accepted"),
+var threadDeltaSchema = z33.discriminatedUnion("kind", [
+  z33.object({
+    kind: z33.literal("input.accepted"),
     clientRequestId: clientTurnRequestIdSchema,
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z32.object({
-    kind: z32.literal("input.provider"),
-    text: z32.string().min(1),
+  z33.object({
+    kind: z33.literal("input.provider"),
+    text: z33.string().min(1),
     parentRef: deltaKeyPartSchema.optional()
   }),
-  z32.object({
-    kind: z32.literal("turn.open"),
+  z33.object({
+    kind: z33.literal("turn.open"),
     providerTurnId: providerTurnIdSchema.optional(),
     parentRef: deltaKeyPartSchema.optional()
   }),
-  z32.object({
-    kind: z32.literal("turn.boundary"),
+  z33.object({
+    kind: z33.literal("turn.boundary"),
     status: threadEventTurnStatusSchema,
     error: deltaErrorSchema.optional(),
-    providerCheckpointId: z32.string().min(1).optional(),
-    claimIfIdle: z32.boolean().optional(),
+    providerCheckpointId: z33.string().min(1).optional(),
+    claimIfIdle: z33.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z32.object({
-    kind: z32.literal("item.open"),
+  z33.object({
+    kind: z33.literal("item.open"),
     key: deltaItemKeySchema,
     item: deltaItemShapeSchema,
     presentation: deltaPresentationSchema.optional(),
@@ -4530,140 +5032,140 @@ var threadDeltaSchema = z32.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }).superRefine(requireExtensionPresentation),
-  z32.object({
-    kind: z32.literal("item.close"),
+  z33.object({
+    kind: z33.literal("item.close"),
     key: deltaItemKeySchema,
     status: threadEventItemStatusSchema,
-    resultText: z32.string().optional(),
-    exitCode: z32.number().optional(),
-    aggregatedOutput: z32.string().optional(),
-    approvalStatus: z32.literal("denied").optional(),
+    resultText: z33.string().optional(),
+    exitCode: z33.number().optional(),
+    aggregatedOutput: z33.string().optional(),
+    approvalStatus: z33.literal("denied").optional(),
     item: deltaItemShapeSchema,
     presentation: deltaPresentationSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }).superRefine(requireExtensionPresentation),
-  z32.object({
-    kind: z32.literal("item.progress"),
+  z33.object({
+    kind: z33.literal("item.progress"),
     key: deltaItemKeySchema,
-    message: z32.string().optional(),
+    message: z33.string().optional(),
     snapshot: deltaProgressSnapshotSchema.optional(),
-    flush: z32.boolean().optional(),
+    flush: z33.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z32.object({
-    kind: z32.literal("item.textDelta"),
+  z33.object({
+    kind: z33.literal("item.textDelta"),
     key: deltaItemKeySchema,
     channel: deltaTextChannelSchema,
-    text: z32.string(),
+    text: z33.string(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z32.object({
-    kind: z32.literal("item.textClose"),
+  z33.object({
+    kind: z33.literal("item.textClose"),
     key: deltaItemKeySchema,
     channel: deltaTextChannelSchema,
-    text: z32.string().optional(),
+    text: z33.string().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z32.object({
-    kind: z32.literal("item.outputDelta"),
+  z33.object({
+    kind: z33.literal("item.outputDelta"),
     key: deltaItemKeySchema,
     channel: deltaOutputChannelSchema,
-    text: z32.string(),
+    text: z33.string(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z32.object({
-    kind: z32.literal("command.outputSnapshot"),
+  z33.object({
+    kind: z33.literal("command.outputSnapshot"),
     key: deltaItemKeySchema,
-    text: z32.string(),
+    text: z33.string(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z32.object({
-    kind: z32.literal("usage"),
+  z33.object({
+    kind: z33.literal("usage"),
     total: threadEventTokenUsageBreakdownSchema,
     last: threadEventTokenUsageBreakdownSchema,
-    modelContextWindow: z32.number().nullable(),
+    modelContextWindow: z33.number().nullable(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z32.object({
-    kind: z32.literal("contextWindow"),
+  z33.object({
+    kind: z33.literal("contextWindow"),
     snapshot: contextSnapshotSchema.optional(),
-    used: z32.number().nullable(),
-    size: z32.number().nullable().optional(),
-    estimated: z32.boolean(),
+    used: z33.number().nullable(),
+    size: z33.number().nullable().optional(),
+    estimated: z33.boolean(),
     attach: deltaAttachSchema,
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z32.object({
-    kind: z32.literal("context.compacted"),
+  z33.object({
+    kind: z33.literal("context.compacted"),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z32.object({ kind: z32.literal("context.cleared") }),
-  z32.object({
-    kind: z32.literal("turn.diff"),
-    diff: z32.string(),
+  z33.object({ kind: z33.literal("context.cleared") }),
+  z33.object({
+    kind: z33.literal("turn.diff"),
+    diff: z33.string(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z32.object({ kind: z32.literal("thread.started") }),
-  z32.object({
-    kind: z32.literal("thread.identity"),
-    providerThreadId: z32.string().min(1)
+  z33.object({ kind: z33.literal("thread.started") }),
+  z33.object({
+    kind: z33.literal("thread.identity"),
+    providerThreadId: z33.string().min(1)
   }),
-  z32.object({ kind: z32.literal("thread.name"), name: z32.string().min(1) }),
-  z32.object({
-    kind: z32.literal("extension.state"),
+  z33.object({ kind: z33.literal("thread.name"), name: z33.string().min(1) }),
+  z33.object({
+    kind: z33.literal("extension.state"),
     extensionKind: extensionKindSchema,
     payload: jsonValueSchema
   }),
-  z32.object({
-    kind: z32.literal("provider.rateLimits"),
+  z33.object({
+    kind: z33.literal("provider.rateLimits"),
     rateLimits: providerRateLimitStateSchema
   }),
-  z32.object({
-    kind: z32.literal("provider.error"),
-    message: z32.string(),
-    detail: z32.string().optional(),
-    willRetry: z32.boolean().optional(),
+  z33.object({
+    kind: z33.literal("provider.error"),
+    message: z33.string(),
+    detail: z33.string().optional(),
+    willRetry: z33.boolean().optional(),
     category: providerErrorCategorySchema.optional(),
     errorInfo: providerErrorInfoSchema.optional(),
-    settlesTurn: z32.boolean().optional(),
+    settlesTurn: z33.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
-    threadScoped: z32.boolean().optional()
+    threadScoped: z33.boolean().optional()
   }),
-  z32.object({
-    kind: z32.literal("provider.modelFallback"),
-    originalModel: z32.string().min(1),
-    fallbackModel: z32.string().min(1),
-    reason: z32.enum(["refusal", "provider"]),
-    message: z32.string()
+  z33.object({
+    kind: z33.literal("provider.modelFallback"),
+    originalModel: z33.string().min(1),
+    fallbackModel: z33.string().min(1),
+    reason: z33.enum(["refusal", "provider"]),
+    message: z33.string()
   }),
-  z32.object({
-    kind: z32.literal("provider.warning"),
-    summary: z32.string().optional(),
-    details: z32.string().optional(),
+  z33.object({
+    kind: z33.literal("provider.warning"),
+    summary: z33.string().optional(),
+    details: z33.string().optional(),
     category: threadEventWarningCategorySchema.optional(),
-    vouchedTurn: z32.boolean().optional()
+    vouchedTurn: z33.boolean().optional()
   }),
-  z32.object({
-    kind: z32.literal("unhandled"),
+  z33.object({
+    kind: z33.literal("unhandled"),
     raw: providerRawEventSchema,
-    rawType: z32.string(),
-    vouchedTurn: z32.boolean(),
-    onlyIfNoTurn: z32.boolean().optional(),
+    rawType: z33.string(),
+    vouchedTurn: z33.boolean(),
+    onlyIfNoTurn: z33.boolean().optional(),
     parentRef: deltaKeyPartSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z32.object({ kind: z32.literal("session.ended") }),
-  z32.object({ kind: z32.literal("session.reset") })
+  z33.object({ kind: z33.literal("session.ended") }),
+  z33.object({ kind: z33.literal("session.reset") })
 ]);
-var threadDeltaNotificationParamsSchema = z32.object({
-  threadId: z32.string().min(1),
-  deltas: z32.array(threadDeltaSchema)
+var threadDeltaNotificationParamsSchema = z33.object({
+  threadId: z33.string().min(1),
+  deltas: z33.array(threadDeltaSchema)
 }).passthrough();
 
 // ../process-utils/src/index.ts
@@ -4686,10 +5188,10 @@ function sanitizeInheritedChildProcessEnv(args) {
 }
 
 // ../provider-bridge-acp/src/launch-spec.ts
-import { z as z33 } from "zod";
-var acpNativeSkillRootsSchema = z33.object({
-  user: z33.array(providerNativeRootInputSchema).default([]),
-  project: z33.array(providerNativeRootInputSchema).default([])
+import { z as z34 } from "zod";
+var acpNativeSkillRootsSchema = z34.object({
+  user: z34.array(providerNativeRootInputSchema).default([]),
+  project: z34.array(providerNativeRootInputSchema).default([])
 }).strict().superRefine((roots, context) => {
   const normalized = providerNativeRootsSchema.safeParse(
     normalizeProviderNativeRoots(roots)
@@ -4705,16 +5207,16 @@ var acpNativeSkillRootsSchema = z33.object({
     });
   }
 });
-var acpLaunchSpecSchema = z33.object({
-  displayName: z33.string().min(1),
-  command: z33.string().min(1),
-  args: z33.array(z33.string()),
-  env: z33.record(z33.string().min(1), z33.string()),
-  cwd: z33.string().min(1).optional(),
-  modelCli: z33.object({
-    listArgs: z33.array(z33.string()),
-    selectFlag: z33.string().min(1).optional(),
-    primaryModels: z33.array(z33.string())
+var acpLaunchSpecSchema = z34.object({
+  displayName: z34.string().min(1),
+  command: z34.string().min(1),
+  args: z34.array(z34.string()),
+  env: z34.record(z34.string().min(1), z34.string()),
+  cwd: z34.string().min(1).optional(),
+  modelCli: z34.object({
+    listArgs: z34.array(z34.string()),
+    selectFlag: z34.string().min(1).optional(),
+    primaryModels: z34.array(z34.string())
   }).strict().transform(
     (modelCli) => modelCli.listArgs.length > 0 ? modelCli : void 0
   ).optional(),
@@ -4752,35 +5254,35 @@ function normalizeAcpLaunchSpec(spec) {
 }
 
 // src/claude-task-tools.ts
-import { z as z34 } from "zod";
-var claudeTaskToolNameSchema = z34.enum([
+import { z as z35 } from "zod";
+var claudeTaskToolNameSchema = z35.enum([
   "TaskCreate",
   "TaskGet",
   "TaskList",
   "TaskUpdate"
 ]);
-var claudeTaskStatusSchema = z34.enum(["pending", "in_progress", "completed"]);
-var claudeTaskCreateOutputSchema = z34.object({
-  task: z34.object({
-    id: z34.string(),
-    subject: z34.string()
+var claudeTaskStatusSchema = z35.enum(["pending", "in_progress", "completed"]);
+var claudeTaskCreateOutputSchema = z35.object({
+  task: z35.object({
+    id: z35.string(),
+    subject: z35.string()
   }).passthrough()
 }).passthrough();
-var claudeTaskGetOutputSchema = z34.object({
-  task: z34.object({
-    id: z34.string(),
+var claudeTaskGetOutputSchema = z35.object({
+  task: z35.object({
+    id: z35.string(),
     status: claudeTaskStatusSchema,
-    subject: z34.string()
+    subject: z35.string()
   }).passthrough().nullable()
 }).passthrough();
-var claudeTaskUpdateOutputSchema = z34.object({
-  success: z34.boolean(),
-  taskId: z34.string()
+var claudeTaskUpdateOutputSchema = z35.object({
+  success: z35.boolean(),
+  taskId: z35.string()
 }).passthrough();
-var claudeTaskListOutputSchema = z34.object({
-  tasks: z34.array(z34.unknown())
+var claudeTaskListOutputSchema = z35.object({
+  tasks: z35.array(z35.unknown())
 }).passthrough();
-var claudeTaskToolOutputSchema = z34.union([
+var claudeTaskToolOutputSchema = z35.union([
   claudeTaskCreateOutputSchema,
   claudeTaskGetOutputSchema,
   claudeTaskListOutputSchema,