subagent-extension-for-codex 0.2.0 → 0.3.0

package/dist/bundle/chunks/{chunk-DGCGXY3T.js → chunk-L5ILPS3O.js}

@@ -1,21 +1,32 @@
 import { createRequire as __bundleCreateRequire } from "node:module"; const require = __bundleCreateRequire(import.meta.url);
 import {
+  AttachmentError,
   JsonlWriter,
+  MESSAGE_EVENTS,
+  PolicyRejectedError,
+  WORKTREE_NEEDS_GIT,
   approvalDeciderSchema,
   approvalModeSchema,
+  archivedFilters,
   assertPlainFolderAllowed,
   budgetRaiseSchema,
+  chatItems,
+  conversation,
   dataDirectory,
   deliveries,
   errorCategory,
+  eventPayload,
+  failureMessage,
   gitRepositoryRoot,
   gitState,
   gitWorkTreeRoot,
   installRoot,
+  isBudgetFailure,
   logCorrelation,
   logError,
   logEvent,
   modelNameSchema,
+  packagePath,
   packageVersion,
   readPackageFile,
   reasoningLevels,
@@ -24,14 +35,16 @@ import {
   startSchema,
   withLogContext,
   within
-} from "./chunk-MOWBM7MZ.js";
+} from "./chunk-36LESPFG.js";
 import {
   $ZodObject,
   $ZodType,
   $constructor,
   NEVER,
   ZodIssueCode,
+  __commonJS,
   __require,
+  __toESM,
   _enum,
   _null,
   any,
@@ -40,8 +53,10 @@ import {
   clone,
   coerce_exports,
   custom,
+  define_EXTENSION_BUILD_INFO_default,
   discriminatedUnion,
   external_exports,
+  init_define_EXTENSION_BUILD_INFO,
   installLazyProp,
   intersection,
   iso_exports,
@@ -64,9 +79,521 @@ import {
   union,
   unknown,
   url
-} from "./chunk-5TX3SEV2.js";
+} from "./chunk-FT2Y2DFZ.js";
+
+// node_modules/semver/internal/debug.js
+var require_debug = __commonJS({
+  "node_modules/semver/internal/debug.js"(exports, module) {
+    "use strict";
+    init_define_EXTENSION_BUILD_INFO();
+    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/semver/internal/constants.js
+var require_constants = __commonJS({
+  "node_modules/semver/internal/constants.js"(exports, module) {
+    "use strict";
+    init_define_EXTENSION_BUILD_INFO();
+    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 WHITESPACE_CHARACTERS = [
+      "	",
+      "\n",
+      "\v",
+      "\f",
+      "\r",
+      " ",
+      "\xA0",
+      "\u1680",
+      "\u2000",
+      "\u2001",
+      "\u2002",
+      "\u2003",
+      "\u2004",
+      "\u2005",
+      "\u2006",
+      "\u2007",
+      "\u2008",
+      "\u2009",
+      "\u200A",
+      "\u2028",
+      "\u2029",
+      "\u202F",
+      "\u205F",
+      "\u3000",
+      "\uFEFF"
+    ];
+    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,
+      WHITESPACE_CHARACTERS,
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 1,
+      FLAG_LOOSE: 2
+    };
+  }
+});
+
+// node_modules/semver/internal/re.js
+var require_re = __commonJS({
+  "node_modules/semver/internal/re.js"(exports, module) {
+    "use strict";
+    init_define_EXTENSION_BUILD_INFO();
+    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 R2 = 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 = R2++;
+      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/semver/internal/parse-options.js
+var require_parse_options = __commonJS({
+  "node_modules/semver/internal/parse-options.js"(exports, module) {
+    "use strict";
+    init_define_EXTENSION_BUILD_INFO();
+    var looseOption = Object.freeze({ loose: true });
+    var emptyOpts = Object.freeze({});
+    var parseOptions = (options2) => {
+      if (!options2) {
+        return emptyOpts;
+      }
+      if (typeof options2 !== "object") {
+        return looseOption;
+      }
+      return options2;
+    };
+    module.exports = parseOptions;
+  }
+});
+
+// node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS({
+  "node_modules/semver/internal/identifiers.js"(exports, module) {
+    "use strict";
+    init_define_EXTENSION_BUILD_INFO();
+    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/semver/classes/semver.js
+var require_semver = __commonJS({
+  "node_modules/semver/classes/semver.js"(exports, module) {
+    "use strict";
+    init_define_EXTENSION_BUILD_INFO();
+    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, options2) {
+        options2 = parseOptions(options2);
+        if (version instanceof _SemVer) {
+          if (version.loose === !!options2.loose && version.includePrerelease === !!options2.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, options2);
+        this.options = options2;
+        this.loose = !!options2.loose;
+        this.includePrerelease = !!options2.includePrerelease;
+        const m2 = version.trim().match(options2.loose ? re[t.LOOSE] : re[t.FULL]);
+        if (!m2) {
+          throw new TypeError(`Invalid Version: ${version}`);
+        }
+        this.raw = version;
+        this.major = +m2[1];
+        this.minor = +m2[2];
+        this.patch = +m2[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 (!m2[4]) {
+          this.prerelease = [];
+        } else {
+          this.prerelease = m2[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 = m2[5] ? m2[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/semver/functions/compare.js
+var require_compare = __commonJS({
+  "node_modules/semver/functions/compare.js"(exports, module) {
+    "use strict";
+    init_define_EXTENSION_BUILD_INFO();
+    var SemVer = require_semver();
+    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    module.exports = compare;
+  }
+});
 
 // src/service/platform/panel/host-context.ts
+init_define_EXTENSION_BUILD_INFO();
 import { realpath } from "node:fs/promises";
 import { isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -124,6 +651,7 @@ async function hostProjectCandidate(c, directory) {
 }
 
 // src/service/platform/server/product-glyph.ts
+init_define_EXTENSION_BUILD_INFO();
 var glyphs = [
   { theme: "light", file: "brand-glyph-black.svg" },
   { theme: "dark", file: "brand-glyph-white.svg" }
@@ -135,7 +663,29 @@ var productGlyphIcons = glyphs.map(({ theme, file }) => ({
   theme
 }));
 
+// src/service/platform/panel/panel.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/@modelcontextprotocol/ext-apps/dist/src/server/index.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/zod/v3/errors.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/zod/v3/locales/en.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/zod/v3/ZodError.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/zod/v3/helpers/util.js
+init_define_EXTENSION_BUILD_INFO();
 var util;
 (function(util2) {
   util2.assertEqual = (_2) => {
@@ -508,6 +1058,7 @@ function getErrorMap() {
 }
 
 // node_modules/zod/v3/helpers/parseUtil.js
+init_define_EXTENSION_BUILD_INFO();
 var makeIssue = (params) => {
   const { data, path, errorMaps, issueData } = params;
   const fullPath = [...path, ...issueData.path || []];
@@ -616,7 +1167,11 @@ var isDirty = (x) => x.status === "dirty";
 var isValid = (x) => x.status === "valid";
 var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 
+// node_modules/zod/v3/types.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/zod/v3/helpers/errorUtil.js
+init_define_EXTENSION_BUILD_INFO();
 var errorUtil;
 (function(errorUtil2) {
   errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
@@ -1396,48 +1951,48 @@ var ZodString = class _ZodString extends ZodType {
       ...errorUtil.errToObj(message)
     });
   }
-  jwt(options3) {
-    return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options3) });
+  jwt(options2) {
+    return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options2) });
   }
-  ip(options3) {
-    return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options3) });
+  ip(options2) {
+    return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options2) });
   }
-  cidr(options3) {
-    return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options3) });
+  cidr(options2) {
+    return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options2) });
   }
-  datetime(options3) {
-    if (typeof options3 === "string") {
+  datetime(options2) {
+    if (typeof options2 === "string") {
       return this._addCheck({
         kind: "datetime",
         precision: null,
         offset: false,
         local: false,
-        message: options3
+        message: options2
       });
     }
     return this._addCheck({
       kind: "datetime",
-      precision: typeof options3?.precision === "undefined" ? null : options3?.precision,
-      offset: options3?.offset ?? false,
-      local: options3?.local ?? false,
-      ...errorUtil.errToObj(options3?.message)
+      precision: typeof options2?.precision === "undefined" ? null : options2?.precision,
+      offset: options2?.offset ?? false,
+      local: options2?.local ?? false,
+      ...errorUtil.errToObj(options2?.message)
     });
   }
   date(message) {
     return this._addCheck({ kind: "date", message });
   }
-  time(options3) {
-    if (typeof options3 === "string") {
+  time(options2) {
+    if (typeof options2 === "string") {
       return this._addCheck({
         kind: "time",
         precision: null,
-        message: options3
+        message: options2
       });
     }
     return this._addCheck({
       kind: "time",
-      precision: typeof options3?.precision === "undefined" ? null : options3?.precision,
-      ...errorUtil.errToObj(options3?.message)
+      precision: typeof options2?.precision === "undefined" ? null : options2?.precision,
+      ...errorUtil.errToObj(options2?.message)
     });
   }
   duration(message) {
@@ -1450,12 +2005,12 @@ var ZodString = class _ZodString extends ZodType {
       ...errorUtil.errToObj(message)
     });
   }
-  includes(value, options3) {
+  includes(value, options2) {
     return this._addCheck({
       kind: "includes",
       value,
-      position: options3?.position,
-      ...errorUtil.errToObj(options3?.message)
+      position: options2?.position,
+      ...errorUtil.errToObj(options2?.message)
     });
   }
   startsWith(value, message) {
@@ -2739,7 +3294,7 @@ ZodObject.lazycreate = (shape, params) => {
 var ZodUnion = class extends ZodType {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
-    const options3 = this._def.options;
+    const options2 = this._def.options;
     function handleResults(results) {
       for (const result of results) {
         if (result.result.status === "valid") {
@@ -2760,7 +3315,7 @@ var ZodUnion = class extends ZodType {
       return INVALID;
     }
     if (ctx.common.async) {
-      return Promise.all(options3.map(async (option) => {
+      return Promise.all(options2.map(async (option) => {
         const childCtx = {
           ...ctx,
           common: {
@@ -2781,7 +3336,7 @@ var ZodUnion = class extends ZodType {
     } else {
       let dirty = void 0;
       const issues = [];
-      for (const option of options3) {
+      for (const option of options2) {
         const childCtx = {
           ...ctx,
           common: {
@@ -2911,9 +3466,9 @@ var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
    * @param types an array of object schemas
    * @param params
    */
-  static create(discriminator, options3, params) {
+  static create(discriminator, options2, params) {
     const optionsMap = /* @__PURE__ */ new Map();
-    for (const type of options3) {
+    for (const type of options2) {
       const discriminatorValues = getDiscriminator(type.shape[discriminator]);
       if (!discriminatorValues.length) {
         throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
@@ -2928,7 +3483,7 @@ var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
     return new _ZodDiscriminatedUnion({
       typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
       discriminator,
-      options: options3,
+      options: options2,
       optionsMap,
       ...processCreateParams(params)
     });
@@ -4030,7 +4585,14 @@ var nullableType = ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 var pipelineType = ZodPipeline.create;
 
+// node_modules/zod/v4/mini/external.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/zod/v4/mini/parse.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/zod/v4/mini/schemas.js
+init_define_EXTENSION_BUILD_INFO();
 var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
   if (!inst._zod)
     throw new Error("Uninitialized schema in ZodMiniType.");
@@ -4257,6 +4819,7 @@ function getLiteralValue(schema) {
 }
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
+init_define_EXTENSION_BUILD_INFO();
 var LATEST_PROTOCOL_VERSION = "2025-11-25";
 var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
 var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
@@ -5788,11 +6351,19 @@ var UrlElicitationRequiredError = class extends McpError {
 };
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
+init_define_EXTENSION_BUILD_INFO();
 function isTerminal(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/zod-to-json-schema/dist/esm/index.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/zod-to-json-schema/dist/esm/Options.js
+init_define_EXTENSION_BUILD_INFO();
 var ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
 var defaultOptions = {
   name: void 0,
@@ -5818,17 +6389,18 @@ var defaultOptions = {
   nameStrategy: "ref",
   openAiAnyTypeName: "OpenAiAnyType"
 };
-var getDefaultOptions = (options3) => typeof options3 === "string" ? {
+var getDefaultOptions = (options2) => typeof options2 === "string" ? {
   ...defaultOptions,
-  name: options3
+  name: options2
 } : {
   ...defaultOptions,
-  ...options3
+  ...options2
 };
 
 // node_modules/zod-to-json-schema/dist/esm/Refs.js
-var getRefs = (options3) => {
-  const _options = getDefaultOptions(options3);
+init_define_EXTENSION_BUILD_INFO();
+var getRefs = (options2) => {
+  const _options = getDefaultOptions(options2);
   const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
   return {
     ..._options,
@@ -5848,6 +6420,7 @@ var getRefs = (options3) => {
 };
 
 // node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+init_define_EXTENSION_BUILD_INFO();
 function addErrorMessage(res, key, errorMessage, refs) {
   if (!refs?.errorMessages)
     return;
@@ -5864,6 +6437,7 @@ function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
+init_define_EXTENSION_BUILD_INFO();
 var getRelativePath = (pathA, pathB) => {
   let i = 0;
   for (; i < pathA.length && i < pathB.length; i++) {
@@ -5873,7 +6447,14 @@ var getRelativePath = (pathA, pathB) => {
   return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
 };
 
+// node_modules/zod-to-json-schema/dist/esm/parseDef.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/zod-to-json-schema/dist/esm/selectParser.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+init_define_EXTENSION_BUILD_INFO();
 function parseAnyDef(refs) {
   if (refs.target !== "openAi") {
     return {};
@@ -5890,6 +6471,7 @@ function parseAnyDef(refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+init_define_EXTENSION_BUILD_INFO();
 function parseArrayDef(def, refs) {
   const res = {
     type: "array"
@@ -5914,6 +6496,7 @@ function parseArrayDef(def, refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+init_define_EXTENSION_BUILD_INFO();
 function parseBigintDef(def, refs) {
   const res = {
     type: "integer",
@@ -5960,6 +6543,7 @@ function parseBigintDef(def, refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+init_define_EXTENSION_BUILD_INFO();
 function parseBooleanDef() {
   return {
     type: "boolean"
@@ -5967,16 +6551,19 @@ function parseBooleanDef() {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+init_define_EXTENSION_BUILD_INFO();
 function parseBrandedDef(_def, refs) {
   return parseDef(_def.type._def, refs);
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+init_define_EXTENSION_BUILD_INFO();
 var parseCatchDef = (def, refs) => {
   return parseDef(def.innerType._def, refs);
 };
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/date.js
+init_define_EXTENSION_BUILD_INFO();
 function parseDateDef(def, refs, overrideDateStrategy) {
   const strategy = overrideDateStrategy ?? refs.dateStrategy;
   if (Array.isArray(strategy)) {
@@ -6036,6 +6623,7 @@ var integerDateParser = (def, refs) => {
 };
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+init_define_EXTENSION_BUILD_INFO();
 function parseDefaultDef(_def, refs) {
   return {
     ...parseDef(_def.innerType._def, refs),
@@ -6044,11 +6632,13 @@ function parseDefaultDef(_def, refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+init_define_EXTENSION_BUILD_INFO();
 function parseEffectsDef(_def, refs) {
   return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+init_define_EXTENSION_BUILD_INFO();
 function parseEnumDef(def) {
   return {
     type: "string",
@@ -6057,6 +6647,7 @@ function parseEnumDef(def) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+init_define_EXTENSION_BUILD_INFO();
 var isJsonSchema7AllOfType = (type) => {
   if ("type" in type && type.type === "string")
     return false;
@@ -6099,6 +6690,7 @@ function parseIntersectionDef(def, refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
+init_define_EXTENSION_BUILD_INFO();
 function parseLiteralDef(def, refs) {
   const parsedType = typeof def.value;
   if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
@@ -6118,7 +6710,14 @@ function parseLiteralDef(def, refs) {
   };
 }
 
+// node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+init_define_EXTENSION_BUILD_INFO();
 var emojiRegex2 = void 0;
 var zodPatterns = {
   /**
@@ -6521,6 +7120,7 @@ function parseMapDef(def, refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+init_define_EXTENSION_BUILD_INFO();
 function parseNativeEnumDef(def) {
   const object3 = def.values;
   const actualKeys = Object.keys(def.values).filter((key) => {
@@ -6535,6 +7135,7 @@ function parseNativeEnumDef(def) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+init_define_EXTENSION_BUILD_INFO();
 function parseNeverDef(refs) {
   return refs.target === "openAi" ? void 0 : {
     not: parseAnyDef({
@@ -6545,6 +7146,7 @@ function parseNeverDef(refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+init_define_EXTENSION_BUILD_INFO();
 function parseNullDef(refs) {
   return refs.target === "openApi3" ? {
     enum: ["null"],
@@ -6554,7 +7156,11 @@ function parseNullDef(refs) {
   };
 }
 
+// node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+init_define_EXTENSION_BUILD_INFO();
 var primitiveMappings = {
   ZodString: "string",
   ZodNumber: "number",
@@ -6565,17 +7171,17 @@ var primitiveMappings = {
 function parseUnionDef(def, refs) {
   if (refs.target === "openApi3")
     return asAnyOf(def, refs);
-  const options3 = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
-  if (options3.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
-    const types = options3.reduce((types2, x) => {
+  const options2 = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  if (options2.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
+    const types = options2.reduce((types2, x) => {
       const type = primitiveMappings[x._def.typeName];
       return type && !types2.includes(type) ? [...types2, type] : types2;
     }, []);
     return {
       type: types.length > 1 ? types : types[0]
     };
-  } else if (options3.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types = options3.reduce((acc, x) => {
+  } else if (options2.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+    const types = options2.reduce((acc, x) => {
       const type = typeof x._def.value;
       switch (type) {
         case "string":
@@ -6594,19 +7200,19 @@ function parseUnionDef(def, refs) {
           return acc;
       }
     }, []);
-    if (types.length === options3.length) {
+    if (types.length === options2.length) {
       const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
       return {
         type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
-        enum: options3.reduce((acc, x) => {
+        enum: options2.reduce((acc, x) => {
           return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
         }, [])
       };
     }
-  } else if (options3.every((x) => x._def.typeName === "ZodEnum")) {
+  } else if (options2.every((x) => x._def.typeName === "ZodEnum")) {
     return {
       type: "string",
-      enum: options3.reduce((acc, x) => [
+      enum: options2.reduce((acc, x) => [
         ...acc,
         ...x._def.values.filter((x2) => !acc.includes(x2))
       ], [])
@@ -6655,6 +7261,7 @@ function parseNullableDef(def, refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/number.js
+init_define_EXTENSION_BUILD_INFO();
 function parseNumberDef(def, refs) {
   const res = {
     type: "number"
@@ -6704,6 +7311,7 @@ function parseNumberDef(def, refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+init_define_EXTENSION_BUILD_INFO();
 function parseObjectDef(def, refs) {
   const forceOptionalIntoNullable = refs.target === "openAi";
   const result = {
@@ -6774,6 +7382,7 @@ function safeIsOptional(schema) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+init_define_EXTENSION_BUILD_INFO();
 var parseOptionalDef = (def, refs) => {
   if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
     return parseDef(def.innerType._def, refs);
@@ -6793,6 +7402,7 @@ var parseOptionalDef = (def, refs) => {
 };
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
+init_define_EXTENSION_BUILD_INFO();
 var parsePipelineDef = (def, refs) => {
   if (refs.pipeStrategy === "input") {
     return parseDef(def.in._def, refs);
@@ -6813,11 +7423,13 @@ var parsePipelineDef = (def, refs) => {
 };
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+init_define_EXTENSION_BUILD_INFO();
 function parsePromiseDef(def, refs) {
   return parseDef(def.type._def, refs);
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+init_define_EXTENSION_BUILD_INFO();
 function parseSetDef(def, refs) {
   const items = parseDef(def.valueType._def, {
     ...refs,
@@ -6838,6 +7450,7 @@ function parseSetDef(def, refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
+init_define_EXTENSION_BUILD_INFO();
 function parseTupleDef(def, refs) {
   if (def.rest) {
     return {
@@ -6866,6 +7479,7 @@ function parseTupleDef(def, refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+init_define_EXTENSION_BUILD_INFO();
 function parseUndefinedDef(refs) {
   return {
     not: parseAnyDef(refs)
@@ -6873,11 +7487,13 @@ function parseUndefinedDef(refs) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+init_define_EXTENSION_BUILD_INFO();
 function parseUnknownDef(refs) {
   return parseAnyDef(refs);
 }
 
 // node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+init_define_EXTENSION_BUILD_INFO();
 var parseReadonlyDef = (def, refs) => {
   return parseDef(def.innerType._def, refs);
 };
@@ -7014,22 +7630,26 @@ var addMeta = (def, refs, jsonSchema) => {
   return jsonSchema;
 };
 
+// node_modules/zod-to-json-schema/dist/esm/parseTypes.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
-var zodToJsonSchema = (schema, options3) => {
-  const refs = getRefs(options3);
-  let definitions2 = typeof options3 === "object" && options3.definitions ? Object.entries(options3.definitions).reduce((acc, [name2, schema2]) => ({
+init_define_EXTENSION_BUILD_INFO();
+var zodToJsonSchema = (schema, options2) => {
+  const refs = getRefs(options2);
+  let definitions2 = typeof options2 === "object" && options2.definitions ? Object.entries(options2.definitions).reduce((acc, [name2, schema2]) => ({
     ...acc,
     [name2]: parseDef(schema2._def, {
       ...refs,
       currentPath: [...refs.basePath, refs.definitionPath, name2]
     }, true) ?? parseAnyDef(refs)
   }), {}) : void 0;
-  const name = typeof options3 === "string" ? options3 : options3?.nameStrategy === "title" ? void 0 : options3?.name;
+  const name = typeof options2 === "string" ? options2 : options2?.nameStrategy === "title" ? void 0 : options2?.name;
   const main = parseDef(schema._def, name === void 0 ? refs : {
     ...refs,
     currentPath: [...refs.basePath, refs.definitionPath, name]
   }, false) ?? parseAnyDef(refs);
-  const title = typeof options3 === "object" && options3.name !== void 0 && options3.nameStrategy === "title" ? options3.name : void 0;
+  const title = typeof options2 === "object" && options2.name !== void 0 && options2.nameStrategy === "title" ? options2.name : void 0;
   if (title !== void 0) {
     main.title = title;
   }
@@ -7415,11 +8035,11 @@ var Protocol = class {
         }
         await this.notification(notification, notificationOptions);
       },
-      sendRequest: async (r2, resultSchema, options3) => {
+      sendRequest: async (r2, resultSchema, options2) => {
         if (abortController.signal.aborted) {
           throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
         }
-        const requestOptions = { ...options3, relatedRequestId: request.id };
+        const requestOptions = { ...options2, relatedRequestId: request.id };
         if (relatedTaskId && !requestOptions.relatedTask) {
           requestOptions.relatedTask = { taskId: relatedTaskId };
         }
@@ -7591,11 +8211,11 @@ var Protocol = class {
    *
    * @experimental Use `client.experimental.tasks.requestStream()` to access this method.
    */
-  async *requestStream(request, resultSchema, options3) {
-    const { task } = options3 ?? {};
+  async *requestStream(request, resultSchema, options2) {
+    const { task } = options2 ?? {};
     if (!task) {
       try {
-        const result = await this.request(request, resultSchema, options3);
+        const result = await this.request(request, resultSchema, options2);
         yield { type: "result", result };
       } catch (error) {
         yield {
@@ -7607,7 +8227,7 @@ var Protocol = class {
     }
     let taskId2;
     try {
-      const createResult = await this.request(request, CreateTaskResultSchema, options3);
+      const createResult = await this.request(request, CreateTaskResultSchema, options2);
       if (createResult.task) {
         taskId2 = createResult.task.taskId;
         yield { type: "taskCreated", task: createResult.task };
@@ -7615,11 +8235,11 @@ var Protocol = class {
         throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
       }
       while (true) {
-        const task2 = await this.getTask({ taskId: taskId2 }, options3);
+        const task2 = await this.getTask({ taskId: taskId2 }, options2);
         yield { type: "taskStatus", task: task2 };
         if (isTerminal(task2.status)) {
           if (task2.status === "completed") {
-            const result = await this.getTaskResult({ taskId: taskId2 }, resultSchema, options3);
+            const result = await this.getTaskResult({ taskId: taskId2 }, resultSchema, options2);
             yield { type: "result", result };
           } else if (task2.status === "failed") {
             yield {
@@ -7635,13 +8255,13 @@ var Protocol = class {
           return;
         }
         if (task2.status === "input_required") {
-          const result = await this.getTaskResult({ taskId: taskId2 }, resultSchema, options3);
+          const result = await this.getTaskResult({ taskId: taskId2 }, resultSchema, options2);
           yield { type: "result", result };
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
-        options3?.signal?.throwIfAborted();
+        await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+        options2?.signal?.throwIfAborted();
       }
     } catch (error) {
       yield {
@@ -7655,9 +8275,9 @@ var Protocol = class {
    *
    * Do not use this method to emit notifications! Use notification() instead.
    */
-  request(request, resultSchema, options3) {
-    const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options3 ?? {};
-    return new Promise((resolve2, reject) => {
+  request(request, resultSchema, options2) {
+    const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options2 ?? {};
+    return new Promise((resolve3, reject) => {
       const earlyReject = (error) => {
         reject(error);
       };
@@ -7676,15 +8296,15 @@ var Protocol = class {
           return;
         }
       }
-      options3?.signal?.throwIfAborted();
+      options2?.signal?.throwIfAborted();
       const messageId = this._requestMessageId++;
       const jsonrpcRequest = {
         ...request,
         jsonrpc: "2.0",
         id: messageId
       };
-      if (options3?.onprogress) {
-        this._progressHandlers.set(messageId, options3.onprogress);
+      if (options2?.onprogress) {
+        this._progressHandlers.set(messageId, options2.onprogress);
         jsonrpcRequest.params = {
           ...request.params,
           _meta: {
@@ -7724,7 +8344,7 @@ var Protocol = class {
         reject(error);
       };
       this._responseHandlers.set(messageId, (response) => {
-        if (options3?.signal?.aborted) {
+        if (options2?.signal?.aborted) {
           return;
         }
         if (response instanceof Error) {
@@ -7735,18 +8355,18 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve2(parseResult.data);
+            resolve3(parseResult.data);
           }
         } catch (error) {
           reject(error);
         }
       });
-      options3?.signal?.addEventListener("abort", () => {
-        cancel(options3?.signal?.reason);
+      options2?.signal?.addEventListener("abort", () => {
+        cancel(options2?.signal?.reason);
       });
-      const timeout = options3?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+      const timeout = options2?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
       const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
-      this._setupTimeout(messageId, timeout, options3?.maxTotalTimeout, timeoutHandler, options3?.resetTimeoutOnProgress ?? false);
+      this._setupTimeout(messageId, timeout, options2?.maxTotalTimeout, timeoutHandler, options2?.resetTimeoutOnProgress ?? false);
       const relatedTaskId = relatedTask?.taskId;
       if (relatedTaskId) {
         const responseResolver = (response) => {
@@ -7779,42 +8399,42 @@ var Protocol = class {
    *
    * @experimental Use `client.experimental.tasks.getTask()` to access this method.
    */
-  async getTask(params, options3) {
-    return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options3);
+  async getTask(params, options2) {
+    return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options2);
   }
   /**
    * Retrieves the result of a completed task.
    *
    * @experimental Use `client.experimental.tasks.getTaskResult()` to access this method.
    */
-  async getTaskResult(params, resultSchema, options3) {
-    return this.request({ method: "tasks/result", params }, resultSchema, options3);
+  async getTaskResult(params, resultSchema, options2) {
+    return this.request({ method: "tasks/result", params }, resultSchema, options2);
   }
   /**
    * Lists tasks, optionally starting from a pagination cursor.
    *
    * @experimental Use `client.experimental.tasks.listTasks()` to access this method.
    */
-  async listTasks(params, options3) {
-    return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options3);
+  async listTasks(params, options2) {
+    return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options2);
   }
   /**
    * Cancels a specific task.
    *
    * @experimental Use `client.experimental.tasks.cancelTask()` to access this method.
    */
-  async cancelTask(params, options3) {
-    return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options3);
+  async cancelTask(params, options2) {
+    return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options2);
   }
   /**
    * Emits a notification, which is a one-way message that does not expect a response.
    */
-  async notification(notification, options3) {
+  async notification(notification, options2) {
     if (!this._transport) {
       throw new Error("Not connected");
     }
     this.assertNotificationCapability(notification.method);
-    const relatedTaskId = options3?.relatedTask?.taskId;
+    const relatedTaskId = options2?.relatedTask?.taskId;
     if (relatedTaskId) {
       const jsonrpcNotification2 = {
         ...notification,
@@ -7823,7 +8443,7 @@ var Protocol = class {
           ...notification.params,
           _meta: {
             ...notification.params?._meta || {},
-            [RELATED_TASK_META_KEY]: options3.relatedTask
+            [RELATED_TASK_META_KEY]: options2.relatedTask
           }
         }
       };
@@ -7835,7 +8455,7 @@ var Protocol = class {
       return;
     }
     const debouncedMethods = this._options?.debouncedNotificationMethods ?? [];
-    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !options3?.relatedRequestId && !options3?.relatedTask;
+    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !options2?.relatedRequestId && !options2?.relatedTask;
     if (canDebounce) {
       if (this._pendingDebouncedNotifications.has(notification.method)) {
         return;
@@ -7850,19 +8470,19 @@ var Protocol = class {
           ...notification,
           jsonrpc: "2.0"
         };
-        if (options3?.relatedTask) {
+        if (options2?.relatedTask) {
           jsonrpcNotification2 = {
             ...jsonrpcNotification2,
             params: {
               ...jsonrpcNotification2.params,
               _meta: {
                 ...jsonrpcNotification2.params?._meta || {},
-                [RELATED_TASK_META_KEY]: options3.relatedTask
+                [RELATED_TASK_META_KEY]: options2.relatedTask
               }
             }
           };
         }
-        this._transport?.send(jsonrpcNotification2, options3).catch((error) => this._onerror(error));
+        this._transport?.send(jsonrpcNotification2, options2).catch((error) => this._onerror(error));
       });
       return;
     }
@@ -7870,19 +8490,19 @@ var Protocol = class {
       ...notification,
       jsonrpc: "2.0"
     };
-    if (options3?.relatedTask) {
+    if (options2?.relatedTask) {
       jsonrpcNotification = {
         ...jsonrpcNotification,
         params: {
           ...jsonrpcNotification.params,
           _meta: {
             ...jsonrpcNotification.params?._meta || {},
-            [RELATED_TASK_META_KEY]: options3.relatedTask
+            [RELATED_TASK_META_KEY]: options2.relatedTask
           }
         }
       };
     }
-    await this._transport.send(jsonrpcNotification, options3);
+    await this._transport.send(jsonrpcNotification, options2);
   }
   /**
    * Registers a handler to invoke when this protocol object receives a request with the given method.
@@ -7997,12 +8617,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve2, interval);
+      const timeoutId = setTimeout(resolve3, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -8180,6 +8800,7 @@ var M = external_exports.object({ protocolVersion: external_exports.string().des
 var p = "text/html;profile=mcp-app";
 
 // src/shared/panel/panel-contract.generated.ts
+init_define_EXTENSION_BUILD_INFO();
 var panelOutputSchema = external_exports.object({
   conversation_id: external_exports.string().optional().nullable(),
   panel_scope: external_exports.object({
@@ -8196,22 +8817,30 @@ var panelOutputSchema = external_exports.object({
     task_id: external_exports.string(),
     tab: external_exports.literal("chat")
   }).optional(),
-  tasks: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).optional()
+  tasks: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).optional(),
+  read_completed: external_exports.record(external_exports.string(), external_exports.number()).optional()
 });
 
-// src/shared/events/payload.ts
-function eventPayload(event, type) {
-  const view = event.view;
-  if (view.kind !== "known" || view.type !== type) return void 0;
-  return view.data;
-}
+// src/service/platform/panel/panel-context.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/tasks/task-list.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/tasks/activity/activity-status.ts
+init_define_EXTENSION_BUILD_INFO();
 
 // src/shared/providers/activity/presentation.ts
+init_define_EXTENSION_BUILD_INFO();
 function activityPresentation(event) {
   return event.presentation ?? {};
 }
 
+// src/shared/tasks/activity/activity-events.ts
+init_define_EXTENSION_BUILD_INFO();
+
 // src/shared/providers/activity/content-text.ts
+init_define_EXTENSION_BUILD_INFO();
 function contentText(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return void 0;
@@ -8221,6 +8850,7 @@ function contentText(content) {
 }
 
 // src/shared/text.ts
+init_define_EXTENSION_BUILD_INFO();
 function scalarText(value, fallback = "") {
   return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : fallback;
 }
@@ -8264,6 +8894,8 @@ function serviceSummary(e) {
   if (turnEnded) {
     return `Turn ${turnEnded.turn} ${turnEnded.outcome}`;
   }
+  const limited = eventPayload(e, "agent.limited");
+  if (limited) return limited.reason;
   const queueChanged = eventPayload(e, "task.queue_changed");
   if (queueChanged) {
     const count = queueChanged.queue.length;
@@ -8273,6 +8905,7 @@ function serviceSummary(e) {
 }
 var eventTitles = {
   "agent.completed": "Turn completed",
+  "agent.limited": "Session limited",
   "agent.reply": "Reply",
   "task.completed": "Task completed",
   "task.instruction": "Message",
@@ -8329,7 +8962,7 @@ function failureSummary(event) {
   const agent = eventPayload(event, "agent.completed");
   const textOutput = contentText(tool2?.content ?? opaqueData.content);
   return [
-    taskFailure?.error,
+    taskFailure ? failureMessage(taskFailure) : void 0,
     interrupted?.error,
     taskCompleted?.error,
     agent?.result,
@@ -8353,6 +8986,7 @@ function eventRowTitle(e, key, presentationTitle) {
 }
 
 // src/shared/tasks/activity/activity-timeline.ts
+init_define_EXTENSION_BUILD_INFO();
 function onlyThinkingSignals(group) {
   return group.events.length > 0 && group.events.every(thinkingSignal);
 }
@@ -8517,7 +9151,7 @@ function groupActivity(events) {
       eventRowTitle(e, key, presentation.title),
       activityFailed(e) ? "failed" : "info"
     );
-    group.summary = presentation.summary ?? (activityFailed(e) ? failureSummary(e) : void 0) ?? serviceSummary(e) ?? eventPayload(e, "agent.completed")?.result ?? eventPayload(e, "task.instruction")?.message ?? eventPayload(e, "task.waiting")?.reason ?? (toolCompleted ? contentText(toolCompleted.content) : void 0) ?? string2(
+    group.summary = presentation.summary ?? (activityFailed(e) ? failureSummary(e) : void 0) ?? serviceSummary(e) ?? eventPayload(e, "agent.completed")?.result ?? eventPayload(e, "task.instruction")?.message ?? (toolCompleted ? contentText(toolCompleted.content) : void 0) ?? string2(
       d2.text ?? d2.summary ?? d2.description ?? d2.message ?? d2.error ?? d2.result
     ) ?? (Array.isArray(d2.errors) ? d2.errors.map(String).join("; ") : void 0);
     if (replyText(e) !== void 0 || thinkingSignal(e)) {
@@ -8639,6 +9273,7 @@ function currentActivityStatus(events, task) {
 }
 
 // src/shared/tasks/conversation/reply.ts
+init_define_EXTENSION_BUILD_INFO();
 var REPLY_EXCERPT_CHARS = 1500;
 function replyExcerpt(text, max = REPLY_EXCERPT_CHARS) {
   return text.length > max ? `${text.slice(0, max)}\u2026 (truncated)` : text;
@@ -8657,10 +9292,30 @@ function replyFrom(event) {
 function readFields(read2) {
   return read2?.unread ? { unread: true, read_through: read2.through } : {};
 }
-function listedTask(task, events, reply, draft, read2, archivedAt) {
+function taskSummary(task, reply, archivedAt) {
+  const excerpt = replyFrom(reply);
+  return {
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    repository: task.repository,
+    ...task.conversation_id ? { conversation_id: task.conversation_id } : {},
+    worker_profile: task.worker_profile,
+    turn: task.turn,
+    ...task.error ? { error: task.error } : {},
+    ...task.error_code ? { error_code: task.error_code } : {},
+    ...task.pending_input ? { pending_input: task.pending_input.kind } : {},
+    ...excerpt ? { reply: excerpt } : {},
+    queued_messages: task.queue.length,
+    ...archivedAt ? { archived_at: archivedAt } : {}
+  };
+}
+var unsent = { context: void 0 };
+function panelTask(task, events, reply, draft, read2, archivedAt) {
   const excerpt = replyFrom(reply);
   return {
     ...task,
+    ...unsent,
     ...task.status === "running" ? { live_activity: currentActivityStatus(events, task) } : {},
     ...excerpt ? { reply: excerpt } : {},
     ...draft ? { draft } : {},
@@ -8697,7 +9352,7 @@ async function resolvePanelContext(c, owner, args) {
     throw new Error("Task belongs to a different conversation");
   }
   const conversationId = args.conversation_id === null ? null : args.conversation_id ?? target?.conversation_id ?? null;
-  const latest = conversationId ? c.store.all(owner).find((t) => t.conversation_id === conversationId) : void 0;
+  const latest = conversationId ? c.store.latestInConversation(owner, conversationId) : void 0;
   const source = target ?? latest;
   let repository = args.repository ?? source?.repository;
   if (repository) {
@@ -8738,19 +9393,45 @@ async function resolvePanelContext(c, owner, args) {
     } : {}
   };
 }
-function openingTasks(c, owner, conversationId) {
-  const archived = c.archive.times(owner);
-  return c.store.all(owner).filter((t) => !conversationId || t.conversation_id === conversationId).map((t) => {
-    const archivedAt = archived.get(t.id);
-    return {
-      ...t,
-      ...readFields(c.store.readState(t.id)),
-      ...archivedAt ? { archived_at: archivedAt } : {}
-    };
+function panelTaskList(c, owner, filters, includeReadCompleted) {
+  if (includeReadCompleted) return { tasks: panelTasks(c, owner, filters) };
+  const rows = c.store.readCompletedFlags(owner, {
+    ...filters,
+    include: void 0
   });
+  const listed = new Set(filters.include);
+  if (rows[0]) listed.add(rows[0].id);
+  const counts = {};
+  for (const row2 of rows) {
+    if (!row2.readCompleted) {
+      listed.add(row2.id);
+    } else if (!listed.has(row2.id)) {
+      counts[row2.repository] = (counts[row2.repository] ?? 0) + 1;
+    }
+  }
+  return {
+    tasks: panelTasks(c, owner, { ids: [...listed] }),
+    read_completed: counts
+  };
+}
+function panelTasks(c, owner, filters) {
+  const archived = c.archive.times(owner, filters);
+  const replies = c.store.latestEvents(owner, "agent.reply", filters);
+  const reads = c.store.readStates(owner, filters);
+  return c.store.list(owner, filters).map(
+    (t) => panelTask(
+      t,
+      t.status === "running" ? c.store.recentEvents(t.id, owner) : [],
+      replies.get(t.id),
+      c.drafts.get(t.id),
+      reads.get(t.id),
+      archived.get(t.id)
+    )
+  );
 }
 
 // src/service/platform/panel/panel-html.ts
+init_define_EXTENSION_BUILD_INFO();
 import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 var copies = /* @__PURE__ */ new Map();
@@ -8811,6 +9492,7 @@ function delegationPanel(htmlPath, initialTasks, context) {
     },
     open: async (args) => {
       const resolved = context ? await context(args) : { panel_scope: { conversation_id: args.conversation_id ?? null } };
+      const selected = resolved.panel_selection?.task_id;
       return {
         content: [
           {
@@ -8821,13 +9503,12 @@ function delegationPanel(htmlPath, initialTasks, context) {
         structuredContent: {
           conversation_id: resolved.panel_scope.conversation_id,
           ...resolved,
-          ...initialTasks ? {
-            tasks: initialTasks(
-              resolved.panel_scope.conversation_id ?? void 0
-            ).filter(
-              (t) => !resolved.panel_scope.repository || t.repository === resolved.panel_scope.repository
-            )
-          } : {}
+          ...initialTasks ? initialTasks({
+            conversation: resolved.panel_scope.conversation_id ?? void 0,
+            repository: resolved.panel_scope.repository,
+            archived: "exclude",
+            include: selected ? [selected] : []
+          }) : {}
         },
         _meta: { conversation_id: resolved.panel_scope.conversation_id }
       };
@@ -8874,6 +9555,7 @@ function delegationPanel(htmlPath, initialTasks, context) {
 }
 
 // src/service/platform/server/instructions.ts
+init_define_EXTENSION_BUILD_INFO();
 var SERVER_INSTRUCTIONS = `Delegate work to background workers.
 1. Resolve the repository with get_current_project or list_projects and pass it to start_task as an explicit absolute path. Never guess a path. Tool arguments never grant access. For an unregistered project, follow next_step.
 2. Call list_workers. If a provider is not ready, report readiness.message to the user instead of retrying. Use the reviewer profile for review requests.
@@ -8882,10 +9564,18 @@ var SERVER_INSTRUCTIONS = `Delegate work to background workers.
 5. A finished task stays open. Continue it with send_message. Reopen its panel with open_subagent_extension_for_codex(task_id), never another start_task.`;
 
 // src/service/platform/server/mentions.ts
+init_define_EXTENSION_BUILD_INFO();
 import { mkdir, open } from "node:fs/promises";
 import { join, resolve } from "node:path";
 
+// node_modules/@openai/mcp-extensions/dist/index.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/@modelcontextprotocol/core/dist/index.mjs
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/@modelcontextprotocol/core/dist/schemas-DscsoNZN.mjs
+init_define_EXTENSION_BUILD_INFO();
 var LATEST_PROTOCOL_VERSION2 = "2025-11-25";
 var DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
 var SUPPORTED_PROTOCOL_VERSIONS2 = [
@@ -9676,6 +10366,7 @@ var ServerResultSchema2 = union([
 ]);
 
 // node_modules/@modelcontextprotocol/core/dist/auth-UMQCo-ad.mjs
+init_define_EXTENSION_BUILD_INFO();
 var SafeUrlSchema = url().superRefine((val, ctx) => {
   if (!URL.canParse(val)) {
     ctx.addIssue({
@@ -9830,9 +10521,11 @@ var OAuthTokenRevocationRequestSchema = object({
 }).strip();
 
 // node_modules/@openai/mcp-extensions/dist/shared/strings.js
+init_define_EXTENSION_BUILD_INFO();
 var NonBlankStringSchema = external_exports.string().regex(/\S/);
 
 // node_modules/@openai/mcp-extensions/dist/shared/mentions.js
+init_define_EXTENSION_BUILD_INFO();
 var OpenAIMentionsCapabilitySchema = external_exports.object({
   searchTool: NonBlankStringSchema
 });
@@ -9971,6 +10664,7 @@ async function logMentionSearch(query, workers, resultNames, env) {
 }
 
 // src/service/features/projects/chat-project.ts
+init_define_EXTENSION_BUILD_INFO();
 import { isAbsolute as isAbsolute2 } from "node:path";
 function hostDirectoryFromMeta(meta2) {
   const state = meta2?.["codex/sandbox-state-meta"];
@@ -10034,7 +10728,14 @@ async function currentChatProject(c, owner, meta2) {
   };
 }
 
+// src/service/platform/server/tools.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/service/platform/server/tool-logging.ts
+init_define_EXTENSION_BUILD_INFO();
+
 // src/shared/tasks/conversation/send-errors.ts
+init_define_EXTENSION_BUILD_INFO();
 var SendRejectedError = class extends Error {
   name = "SendRejectedError";
 };
@@ -10047,10 +10748,11 @@ var rejectionMessages = /* @__PURE__ */ new Set([
   "Task not found",
   "Repository outside allowed roots (register this repository or approve its parent)",
   "Task belongs to a different conversation",
-  "Task belongs to a different repository"
+  "Task belongs to a different repository",
+  WORKTREE_NEEDS_GIT
 ]);
 function rejected(error) {
-  return error instanceof SendRejectedError || error instanceof Error && (error.name === "ZodError" || rejectionMessages.has(error.message));
+  return error instanceof SendRejectedError || error instanceof PolicyRejectedError || error instanceof AttachmentError || error instanceof Error && (error.name === "ZodError" || rejectionMessages.has(error.message));
 }
 async function observeTool(name, run2, readOnly = false) {
   return withLogContext({ tool: name }, async () => {
@@ -10082,115 +10784,33 @@ async function observeTool(name, run2, readOnly = false) {
   });
 }
 
-// src/shared/tasks/conversation/messages.ts
-var MESSAGE_EVENTS = [
-  "task.started",
-  "task.instruction",
-  "agent.message",
-  "agent.reply"
-];
-function workerMessageId(e) {
-  return eventPayload(e, "agent.message")?.message_id ?? `evt_${e.id}`;
-}
-function workerText(e) {
-  const message = eventPayload(e, "agent.message");
-  if (!message || message.parent_tool_use_id) return void 0;
-  return message.text.trim() ? message.text : void 0;
-}
-var same = (message, reply) => {
-  const a = message.trim(), b = reply.trim();
-  return a === b || a.endsWith(b);
-};
-function queueState(id, pending2, queued) {
-  if (pending2.has(id)) return { state: "pending_steer" };
-  if (queued.has(id)) return { state: "queued" };
-  return {};
-}
-function conversation(task, events) {
-  const pending2 = new Set(task.pending_steers.map((m2) => m2.id));
-  const queued = new Set(task.queue.map((m2) => m2.id));
-  let turn = 1;
-  const messages = [
-    {
-      id: "request",
-      event_id: 0,
-      timestamp: task.created_at,
-      turn,
-      from: task.created_by,
-      kind: "request",
-      text: task.description
-    }
-  ];
-  for (const e of [...events].sort((a, b) => a.id - b.id)) {
-    const started = eventPayload(e, "task.started");
-    if (started) turn = started.turn;
-    const instruction = eventPayload(e, "task.instruction");
-    if (instruction) {
-      const id = instruction.message_id;
-      messages.push({
-        id,
-        event_id: e.id,
-        timestamp: e.timestamp,
-        turn,
-        from: instruction.from,
-        kind: "message",
-        text: instruction.message,
-        delivery: instruction.delivery,
-        ...queueState(id, pending2, queued)
-      });
-    }
-    if (eventPayload(e, "agent.message")) {
-      const text = workerText(e);
-      if (text === void 0) continue;
-      const id = workerMessageId(e);
-      const previous = messages.at(-1);
-      if (previous?.id === id && previous.from === "worker") {
-        previous.text = `${previous.text}
-
-${text}`;
-        previous.event_id = e.id;
-        continue;
-      }
-      messages.push({
-        id,
-        event_id: e.id,
-        timestamp: e.timestamp,
-        turn,
-        from: "worker",
-        kind: "message",
-        text
-      });
-    }
-    const reply = eventPayload(e, "agent.reply");
-    if (reply) {
-      const text = reply.text;
-      const replyTurn = reply.turn;
-      const last = messages.findLast(
-        (m2) => m2.from === "worker" && m2.turn === replyTurn
-      );
-      if (last && last.kind === "message" && same(last.text, text)) {
-        last.kind = "reply";
-        last.event_id = e.id;
-        continue;
-      }
-      messages.push({
-        id: `reply_${e.id}`,
-        event_id: e.id,
-        timestamp: e.timestamp,
-        turn: replyTurn,
-        from: "worker",
-        kind: "reply",
-        text
-      });
-    }
-  }
-  return messages.sort((a, b) => a.event_id - b.event_id);
-}
+// src/service/platform/server/tools/agent-tools.ts
+init_define_EXTENSION_BUILD_INFO();
 
 // src/shared/tasks/conversation/parent-protocol.ts
+init_define_EXTENSION_BUILD_INFO();
 var PARENT_SUPERVISION_PROTOCOL = "While delegated work runs, continue your own work and keep polling. A timeout or empty result does not mean the task finished. Handle pending_input, failures and interruptions explicitly. Report success only after reading the final reply. A queued follow-up is still pending work. If you lose the cursor, read again from after: 0.";
 
+// src/service/features/settings/settings-tool-schemas.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/settings/settings-document.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/providers/claude/settings-policy.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/settings/settings-schema.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/providers/settings.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/providers/claude/settings.ts
+init_define_EXTENSION_BUILD_INFO();
+
 // src/shared/settings/setting-text.ts
+init_define_EXTENSION_BUILD_INFO();
 function unwrapped(schema) {
   let current = schema;
   while (current instanceof external_exports.ZodDefault || current instanceof external_exports.ZodPrefault || current instanceof external_exports.ZodOptional) {
@@ -10213,6 +10833,7 @@ function settingText(schema) {
 }
 
 // src/shared/providers/claude/permissions.ts
+init_define_EXTENSION_BUILD_INFO();
 var claudePermissionModes = [
   "default",
   "acceptEdits",
@@ -10226,38 +10847,12 @@ var permissionModeSchema = external_exports.enum([
   "inherit",
   ...claudePermissionModes
 ]);
-var claudeSandboxSchema = external_exports.enum([
-  "user_config",
-  "extension",
-  "extension_locked"
-]);
-var claudeToolsSchema = external_exports.enum(["profile", "all", "restricted"]);
-var claudePathGuardSchema = external_exports.enum(["profile", "on", "off"]);
 var claudeOverrideDefaults = {
-  sandbox: "user_config",
-  tools: "profile",
-  path_guard: "profile",
+  sandbox: false,
   subagents: true,
   settings_files: true,
   user_mcp: true
 };
-var claudeOverrideLabels = {
-  sandbox: {
-    user_config: "Your Claude Code settings",
-    extension: "Extension sandbox",
-    extension_locked: "Extension sandbox with locked network"
-  },
-  tools: {
-    profile: "By worker profile",
-    all: "All tools",
-    restricted: "Restricted set"
-  },
-  path_guard: {
-    profile: "By worker profile",
-    on: "On",
-    off: "Off"
-  }
-};
 var permissionLabels = {
   inherit: "Use extension setting",
   default: "Default \u2014 ask for approval",
@@ -10267,9 +10862,16 @@ var permissionLabels = {
   auto: "Auto \u2014 Claude Code decides",
   bypassPermissions: "Bypass permission prompts"
 };
+var MODE_TURNED_OFF_BY_ORG = "Turned off by your organization";
 function permissionLabel(mode) {
   return permissionLabels[mode] ?? mode;
 }
+var permissionModeName = (mode) => shortPermissionLabel(permissionLabel(mode));
+function shortPermissionLabel(label) {
+  if (label === "Use extension setting") return "Extension setting";
+  const [name = label, detail] = label.split(" \u2014 ");
+  return name === "Default" && detail ? titleCase(detail) : name;
+}
 var permissionRank = {
   plan: 0,
   dontAsk: 1,
@@ -10279,10 +10881,13 @@ var permissionRank = {
   bypassPermissions: 5
 };
 var readOnlyProfile = (role) => ["researcher", "reviewer", "security_reviewer"].includes(role);
-function resolveClaudePermission(input, configured) {
+function resolveClaudePermission(input, configured, workerProfile) {
   if (input.permission_mode && input.permission_mode !== "inherit") {
     return { mode: input.permission_mode, source: "task" };
   }
+  if (readOnlyProfile(workerProfile)) {
+    return { mode: "plan", source: "profile" };
+  }
   return { mode: configured, source: "setting" };
 }
 function exceedsPermission(requested, baseline) {
@@ -10292,52 +10897,36 @@ function exceedsPermission(requested, baseline) {
   return requestedRank > baselineRank;
 }
 var claudePolicySchema = external_exports.object({
-  sandbox: claudeSandboxSchema,
-  tools: external_exports.enum(["all", "restricted"]),
-  path_guard: external_exports.boolean(),
+  sandbox: external_exports.boolean(),
   subagents: external_exports.boolean(),
   /** Load the user's, project's and local Claude Code settings. */
   settings_files: external_exports.boolean(),
   /** Offer MCP servers from the user's Claude Code configuration alongside the extension's own. */
   user_mcp: external_exports.boolean()
 });
-function resolveTools(setting, readOnly) {
-  if (setting !== "profile") return setting;
-  return readOnly ? "restricted" : "all";
-}
-function resolveClaudePolicy(overrides, workerProfile) {
-  const readOnly = readOnlyProfile(workerProfile);
-  return {
-    sandbox: overrides.sandbox,
-    tools: resolveTools(overrides.tools, readOnly),
-    path_guard: overrides.path_guard === "profile" ? readOnly : overrides.path_guard === "on",
-    subagents: overrides.subagents,
-    settings_files: overrides.settings_files,
-    user_mcp: overrides.user_mcp
-  };
-}
+var resolveClaudePolicy = (overrides, sandbox = overrides.sandbox) => ({
+  sandbox,
+  subagents: overrides.subagents,
+  settings_files: overrides.settings_files,
+  user_mcp: overrides.user_mcp
+});
 
 // src/shared/providers/claude/settings.ts
 var help = {
   permission_mode: "Tasks use this mode unless you choose another. Your other Claude Code settings still apply while Load Claude Code settings is on.",
-  sandbox: "Your Claude Code settings decide the sandbox by default. The extension sandbox allows writes only in the workspace and blocks home and sibling reads and the network. Locking its network also ignores domains your Claude Code settings allow.",
-  tools: "All tools offers every Claude Code tool. The restricted set offers file, search, Bash, question, skill and MCP tools, and only read, question and skill tools to read-only work. By worker profile restricts only read-only profiles.",
-  path_guard: "Keeps file tools inside the task workspace and out of Git metadata. By worker profile applies it only to read-only profiles.",
+  sandbox: "Runs Bash commands in Claude Code's sandbox, and stops a task when the sandbox can't run. Your Claude Code settings and your organization's policy decide the rest. Off leaves the sandbox to your Claude Code settings. Codex can turn it on for a task, and only you can turn it off.",
   subagents: "Delegated sessions may start subagents with the Agent tool.",
   settings_files: "Sessions load your user, project and local Claude Code settings, including instructions, skills, hooks, permission rules, sandbox settings and MCP servers. Off ignores all of them, including your deny rules and sandbox.",
   user_mcp: "Sessions may use MCP servers from your Claude Code configuration, such as project, user and plugin servers. This also requires Load Claude Code settings. Off leaves only the extension's own server."
 };
 var userOnly = "Only you can change these settings.";
-var options = (labels) => Object.entries(labels).map(([value, label]) => ({ value, label }));
 var claudeSettingsSchema = external_exports.strictObject({
   permission_mode: claudePermissionModeSchema.meta({
     title: "Claude permission mode",
     description: help.permission_mode
   }).default("default"),
   // Restriction titles drop "Claude": their settings group already names it.
-  sandbox: claudeSandboxSchema.meta({ title: "Bash sandbox", description: help.sandbox }).default(claudeOverrideDefaults.sandbox),
-  tools: claudeToolsSchema.meta({ title: "Tools", description: help.tools }).default(claudeOverrideDefaults.tools),
-  path_guard: claudePathGuardSchema.meta({ title: "Workspace path guard", description: help.path_guard }).default(claudeOverrideDefaults.path_guard),
+  sandbox: external_exports.boolean().meta({ title: "Bash sandbox", description: help.sandbox }).default(claudeOverrideDefaults.sandbox),
   subagents: external_exports.boolean().meta({ title: "Allow subagents", description: help.subagents }).default(claudeOverrideDefaults.subagents),
   settings_files: external_exports.boolean().meta({
     title: "Load Claude Code settings",
@@ -10367,21 +10956,7 @@ var claudeRestrictionsSection = {
     `Limits on delegated Claude sessions, in every permission mode. ${userOnly}`
   ],
   rows: [
-    {
-      kind: "select",
-      ...row("sandbox"),
-      options: options(claudeOverrideLabels.sandbox)
-    },
-    {
-      kind: "select",
-      ...row("tools"),
-      options: options(claudeOverrideLabels.tools)
-    },
-    {
-      kind: "select",
-      ...row("path_guard"),
-      options: options(claudeOverrideLabels.path_guard)
-    },
+    { kind: "switch", ...row("sandbox") },
     { kind: "switch", ...row("subagents") },
     { kind: "switch", ...row("settings_files") },
     { kind: "switch", ...row("user_mcp") }
@@ -10395,80 +10970,6 @@ var providerRestrictionSections = [claudeRestrictionsSection];
 var preferredSettingsProvider = (providers) => providers.includes("claude") ? "claude" : providers[0];
 var providerModelSettingScopes = ["claude", "fixture"];
 
-// src/shared/settings/document-contract.generated.ts
-var helpPartSchema = external_exports.union([
-  external_exports.string(),
-  external_exports.object({
-    text: external_exports.string(),
-    setting: external_exports.string()
-  })
-]);
-var settingOptionSchema = external_exports.object({
-  value: external_exports.string(),
-  label: external_exports.string(),
-  description: external_exports.string().optional()
-});
-var settingRowBaseSchema = external_exports.object({
-  path: external_exports.string(),
-  label: external_exports.string(),
-  help: external_exports.array(helpPartSchema).optional(),
-  keywords: external_exports.array(external_exports.string()).optional()
-});
-var selectSettingRowSchema = settingRowBaseSchema.extend({
-  kind: external_exports.literal("select"),
-  options: external_exports.array(settingOptionSchema)
-});
-var switchSettingRowSchema = settingRowBaseSchema.extend({
-  kind: external_exports.literal("switch")
-});
-var textSettingRowSchema = settingRowBaseSchema.extend({
-  kind: external_exports.literal("text"),
-  maxLength: external_exports.number(),
-  pattern: external_exports.string()
-});
-var budgetSettingRowSchema = settingRowBaseSchema.extend({
-  kind: external_exports.literal("budget"),
-  unit: external_exports.string(),
-  min: external_exports.number(),
-  max: external_exports.number().optional()
-});
-var proseSettingSchema = settingRowBaseSchema.extend({
-  maxLength: external_exports.number()
-});
-var modelScopeSchema = external_exports.object({
-  id: external_exports.string(),
-  label: external_exports.string(),
-  model: external_exports.object({
-    path: external_exports.string(),
-    label: external_exports.string(),
-    options: external_exports.array(settingOptionSchema).optional()
-  }),
-  effort: external_exports.object({
-    path: external_exports.string(),
-    label: external_exports.string(),
-    options: external_exports.array(settingOptionSchema),
-    unsupported: external_exports.boolean()
-  }),
-  instructions: proseSettingSchema.optional()
-});
-var modelsSettingRowSchema = external_exports.object({
-  kind: external_exports.literal("models"),
-  scopes: external_exports.array(modelScopeSchema)
-});
-var settingRowSchema = external_exports.discriminatedUnion("kind", [
-  selectSettingRowSchema,
-  switchSettingRowSchema,
-  textSettingRowSchema,
-  budgetSettingRowSchema,
-  modelsSettingRowSchema
-]);
-var settingSectionSchema = external_exports.object({
-  id: external_exports.string(),
-  title: external_exports.string(),
-  help: external_exports.array(helpPartSchema).optional(),
-  rows: external_exports.array(settingRowSchema)
-});
-
 // src/shared/settings/settings-schema.ts
 var branchPrefixPattern = "[\\w./-]*";
 var settingHelp = {
@@ -10484,7 +10985,7 @@ var budget = (title, unit, amount, keywords) => external_exports.strictObject({
 }).meta({ title, keywords }).prefault({});
 var modelScope = (label) => external_exports.strictObject({
   model: modelNameSchema.meta({ title: `${label} model` }).default(""),
-  reasoning_effort: reasoningSchema.meta({ title: `${label} reasoning effort` }).default("default")
+  reasoning_effort: reasoningSchema.meta({ title: `${label} reasoning` }).default("default")
 }).prefault({});
 var scopes = (ids) => external_exports.strictObject(
   Object.fromEntries(
@@ -10547,7 +11048,7 @@ var settingsSchema = external_exports.strictObject({
     }).default("user"),
     execution_mode: approvalModeSchema.meta({
       title: "Execution approval mode",
-      description: "Default for execution providers: ask user, delegate to the parent agent, auto-approve within the sandbox, or deny execution requests. Native permission settings are independent. Read-only profiles and sandbox limits remain enforced."
+      description: "Default for execution providers: ask user, delegate to the parent agent, auto-approve within the sandbox, or deny execution requests. Native permission settings are independent."
     }).default("ask_user")
   }).meta({ userOnly: true }).prefault({}),
   projects: external_exports.strictObject({
@@ -10626,7 +11127,178 @@ function deepPartial(schema) {
 }
 var settingsPatchSchema = deepPartial(settingsSchema);
 
+// src/shared/providers/policy.ts
+init_define_EXTENSION_BUILD_INFO();
+var FAMILY_ALIASES = ["opus", "sonnet", "haiku", "fable"];
+var isModelVariant = (model, base) => model.startsWith(base) && /^(-\d{8}|-fast)+$/.test(model.slice(base.length));
+function entryAllows(entry, model, exact) {
+  if (model === entry) return true;
+  if (FAMILY_ALIASES.includes(entry)) return model.includes(`-${entry}-`);
+  if (!model.startsWith(entry)) return false;
+  return !exact || isModelVariant(model, entry);
+}
+function modelAllowed(policy, models, value) {
+  const entries = policy?.available_models;
+  const exact = policy?.available_models_match === "exact";
+  const model = value.replace(/\[.*\]$/, "");
+  if (!entries || !model || model === "default") return true;
+  return models.some(
+    (choice) => choice.value === value || choice.value === model || choice.resolvedModel === model
+  ) || entries.some((entry) => entryAllows(entry, model, exact));
+}
+var blockedReason = (policy, mode) => policy?.blocked.find((item) => item.value === mode)?.reason;
+function withBlockedOptions(options2, policy) {
+  return options2.map((option) => {
+    const reason = blockedReason(policy, option.value);
+    return reason ? { ...option, disabled: true, description: reason } : option;
+  });
+}
+
+// src/shared/providers/claude/settings-policy.ts
+function withPolicy(row2, policy, values) {
+  if (row2.kind !== "select" || row2.path !== "providers.claude.permission_mode") {
+    return row2;
+  }
+  const saved = String(settingAt(values, row2.path));
+  const reason = blockedReason(policy, saved);
+  return {
+    ...row2,
+    options: withBlockedOptions(row2.options, policy),
+    ...reason ? {
+      warning: reason === MODE_TURNED_OFF_BY_ORG ? `Your saved mode, ${permissionModeName(saved)}, is turned off by your organization. New tasks ask for approval.` : `Your saved mode, ${permissionModeName(saved)}, isn't available. New tasks ask for approval.`
+    } : {}
+  };
+}
+var SOURCE_HELP = {
+  console: "Your organization's admin console sets these limits.",
+  device: "A policy on this computer sets these limits."
+};
+function policyFacts(policy) {
+  const modes = policy.blocked.filter(({ reason }) => reason === MODE_TURNED_OFF_BY_ORG).map(({ value }) => permissionModeName(value));
+  return [
+    ...modes.length ? [
+      {
+        label: "Permission modes",
+        detail: `Turned off: ${modes.join(", ")}.`
+      }
+    ] : [],
+    ...policy.available_models ? [
+      {
+        label: "Models",
+        detail: policy.available_models.length ? `Limited to ${policy.available_models.join(", ")}.` : "Limited to the default model."
+      }
+    ] : [],
+    ...policy.notes
+  ];
+}
+function withClaudePolicy(sections, policy, values) {
+  if (!policy) return sections;
+  const applied = sections.map((section) => ({
+    ...section,
+    rows: section.rows.map((row2) => withPolicy(row2, policy, values))
+  }));
+  if (!policy.managed) return applied;
+  const after = applied.findIndex(
+    ({ id }) => id === claudeRestrictionsSection.id
+  );
+  applied.splice(after + 1, 0, {
+    id: "organization-policy",
+    title: "Organization policy",
+    help: [
+      `${policy.source ? SOURCE_HELP[policy.source] : "Your organization sets these limits."} Claude Code enforces them, along with any others your organization sets.`
+    ],
+    facts: policyFacts(policy),
+    rows: []
+  });
+  return applied;
+}
+
+// src/shared/settings/document-contract.generated.ts
+init_define_EXTENSION_BUILD_INFO();
+var helpPartSchema = external_exports.union([
+  external_exports.string(),
+  external_exports.object({
+    text: external_exports.string(),
+    setting: external_exports.string()
+  })
+]);
+var settingOptionSchema = external_exports.object({
+  value: external_exports.string(),
+  label: external_exports.string(),
+  description: external_exports.string().optional(),
+  disabled: external_exports.boolean().optional()
+});
+var settingRowBaseSchema = external_exports.object({
+  path: external_exports.string(),
+  label: external_exports.string(),
+  help: external_exports.array(helpPartSchema).optional(),
+  keywords: external_exports.array(external_exports.string()).optional()
+});
+var selectSettingRowSchema = settingRowBaseSchema.extend({
+  kind: external_exports.literal("select"),
+  options: external_exports.array(settingOptionSchema),
+  warning: external_exports.string().optional()
+});
+var switchSettingRowSchema = settingRowBaseSchema.extend({
+  kind: external_exports.literal("switch")
+});
+var textSettingRowSchema = settingRowBaseSchema.extend({
+  kind: external_exports.literal("text"),
+  maxLength: external_exports.number(),
+  pattern: external_exports.string()
+});
+var budgetSettingRowSchema = settingRowBaseSchema.extend({
+  kind: external_exports.literal("budget"),
+  unit: external_exports.string(),
+  min: external_exports.number(),
+  max: external_exports.number().optional()
+});
+var proseSettingSchema = settingRowBaseSchema.extend({
+  maxLength: external_exports.number()
+});
+var modelScopeSchema = external_exports.object({
+  id: external_exports.string(),
+  label: external_exports.string(),
+  model: external_exports.object({
+    path: external_exports.string(),
+    label: external_exports.string(),
+    options: external_exports.array(settingOptionSchema).optional(),
+    warning: external_exports.string().optional()
+  }),
+  effort: external_exports.object({
+    path: external_exports.string(),
+    label: external_exports.string(),
+    options: external_exports.array(settingOptionSchema),
+    unsupported: external_exports.boolean()
+  }),
+  instructions: proseSettingSchema.optional()
+});
+var modelsSettingRowSchema = external_exports.object({
+  kind: external_exports.literal("models"),
+  scopes: external_exports.array(modelScopeSchema)
+});
+var settingRowSchema = external_exports.discriminatedUnion("kind", [
+  selectSettingRowSchema,
+  switchSettingRowSchema,
+  textSettingRowSchema,
+  budgetSettingRowSchema,
+  modelsSettingRowSchema
+]);
+var settingSectionSchema = external_exports.object({
+  id: external_exports.string(),
+  title: external_exports.string(),
+  help: external_exports.array(helpPartSchema).optional(),
+  facts: external_exports.array(
+    external_exports.object({
+      label: external_exports.string(),
+      detail: external_exports.string()
+    })
+  ).optional(),
+  rows: external_exports.array(settingRowSchema)
+});
+
 // src/shared/settings/model-defaults.ts
+init_define_EXTENSION_BUILD_INFO();
 function modelScopePath(scope) {
   if (scope === "global") return "models.global";
   return roles.includes(scope) ? `models.profiles.${scope}` : `models.providers.${scope}`;
@@ -10645,7 +11317,7 @@ function resolveModelDefaults(values, { provider, profile }) {
 
 // src/shared/settings/settings-document.ts
 var sectionSchema = settingSectionSchema;
-var unsupportedEffortWarning = "The saved effort is not supported by this model.";
+var unsupportedEffortWarning = "The saved reasoning is not supported by this model.";
 var withHelp = (parts, shown) => parts.map(
   (part) => typeof part === "string" || settingAt(shown, part.setting) !== void 0 ? part : part.text
 );
@@ -10654,14 +11326,17 @@ function described(path) {
   if (!schema) throw new Error(`Unknown setting ${path}`);
   return { path, ...settingText(schema) };
 }
-var options2 = (labels) => Object.entries(labels).map(([value, label]) => ({ value, label }));
+var options = (labels) => Object.entries(labels).map(([value, label]) => ({ value, label }));
 function modelScope2(scope, { values, providers, catalogs }) {
   const scopePath = modelScopePath(scope), modelPath = `${scopePath}.model`, effortPath = `${scopePath}.reasoning_effort`, providerScope = providers.includes(scope), provider = providerScope ? scope : scalarText(settingAt(values, "task.provider"));
-  const choices = catalogs.filter((catalog) => !providerScope || catalog.provider === scope).flatMap((catalog) => catalog.models ?? []);
+  const choices = catalogs.filter((catalog2) => !providerScope || catalog2.provider === scope).flatMap((catalog2) => catalog2.models ?? []);
   const saved = scalarText(settingAt(values, modelPath)), savedEffort = scalarText(settingAt(values, effortPath), "default");
   const chain = scope === "global" ? {} : { provider, profile: providerScope ? void 0 : scope };
   const effectiveModel = resolveModelDefaults(values, chain).model ?? "default";
-  const metadata = catalogs.find((catalog) => catalog.provider === provider)?.models?.find((model) => model.value === effectiveModel);
+  const catalog = catalogs.find((item) => item.provider === provider);
+  const metadata = catalog?.models?.find(
+    (model) => model.value === effectiveModel
+  );
   const levels = metadata?.supportsEffort === false ? [] : metadata?.supportedEffortLevels;
   const modelChoices = choices.length ? [
     { value: "", label: "Inherit" },
@@ -10691,6 +11366,7 @@ function modelScope2(scope, { values, providers, catalogs }) {
     effectiveModel,
     levels,
     modelChoices,
+    modelExcluded: !modelAllowed(catalog?.policy, choices, saved),
     effortChoices: [
       { value: "default", label: "Inherit" },
       ...effortLevels.map((level) => ({ value: level, label: level }))
@@ -10708,11 +11384,14 @@ function settingsSections(input) {
       model: {
         path: info.modelPath,
         label: `${label} model`,
-        options: info.modelChoices
+        options: info.modelChoices,
+        ...info.modelExcluded ? {
+          warning: "Your organization doesn't allow this model. New tasks use the default."
+        } : {}
       },
       effort: {
         path: info.effortPath,
-        label: `${label} reasoning effort`,
+        label: `${label} reasoning`,
         options: info.effortChoices,
         unsupported: info.unsupported
       }
@@ -10725,7 +11404,7 @@ function settingsSections(input) {
       { text: "worker profile", setting: profileModel },
       " defaults override these. Inherit uses ",
       { text: "Global", setting: "models.global.model" },
-      ", then the worker's own default. This applies to model and reasoning effort. Task choices override all defaults."
+      ", then the worker's own default. This applies to model and reasoning. Task choices override all defaults."
     ],
     values
   );
@@ -10735,12 +11414,12 @@ function settingsSections(input) {
       { text: "provider", setting: providerModel },
       " default, then ",
       { text: "Global", setting: "models.global.model" },
-      ", then the worker's own default. This applies to model and reasoning effort. Task choices override profile defaults."
+      ", then the worker's own default. This applies to model and reasoning. Task choices override profile defaults."
     ],
     values
   );
   const userOnly2 = "Only you can change these settings.";
-  return [
+  const sections = [
     {
       id: "task",
       title: "Task defaults",
@@ -10761,7 +11440,7 @@ function settingsSections(input) {
         {
           kind: "select",
           ...described("task.workspace_strategy"),
-          options: options2({
+          options: options({
             current_repo: "Project folder",
             worktree: "Isolated worktree"
           })
@@ -10795,7 +11474,7 @@ function settingsSections(input) {
         {
           kind: "select",
           ...described("approvals.decider"),
-          options: options2({ user: "User", parent_agent: "Parent agent" })
+          options: options({ user: "User", parent_agent: "Parent agent" })
         },
         { kind: "switch", ...described("projects.auto_register_chat") }
       ]
@@ -10836,6 +11515,11 @@ function settingsSections(input) {
       ]
     }
   ];
+  return withClaudePolicy(
+    sections,
+    input.catalogs.find(({ provider }) => provider === "claude")?.policy,
+    values
+  );
 }
 
 // src/service/features/settings/settings-tool-schemas.ts
@@ -10865,6 +11549,7 @@ var settingsUpdateSchema = external_exports.strictObject({
 });
 
 // src/service/features/tasks/conversation/message-poll.ts
+init_define_EXTENSION_BUILD_INFO();
 var MAX_MESSAGE_WAIT_SECONDS = 50;
 var WAKE = /* @__PURE__ */ new Set([
   "task.instruction",
@@ -10876,7 +11561,7 @@ var WAKE = /* @__PURE__ */ new Set([
 async function pollMessages(store, drafts, owner, id, after, waitSeconds) {
   store.get(id, owner);
   let wake;
-  const woken = new Promise((resolve2) => wake = resolve2);
+  const woken = new Promise((resolve3) => wake = resolve3);
   const onEvent = (e, eventOwner) => {
     if (eventOwner === owner && e.task_id === id && WAKE.has(e.type)) wake();
   };
@@ -10909,7 +11594,7 @@ async function pollMessages(store, drafts, owner, id, after, waitSeconds) {
 }
 function read(store, owner, id, after) {
   const task = store.get(id, owner);
-  const events = store.eventsOfTypes(id, [
+  const events = store.conversationEvents(id, [
     ...MESSAGE_EVENTS,
     "task.turn_ended",
     "agent.input_required"
@@ -10927,7 +11612,11 @@ function read(store, owner, id, after) {
 }
 
 // src/service/platform/server/tools/definition.ts
+init_define_EXTENSION_BUILD_INFO();
 var taskId = external_exports.object({ task_id: external_exports.string() });
+var archivedFilter = external_exports.enum(archivedFilters).default("exclude").describe(
+  "exclude (default) leaves archived tasks out, include lists them too and only lists just them. Archived tasks carry archived_at."
+);
 var queuedMessage = taskId.extend({ message_id: external_exports.string().max(200) });
 var messageInput = taskId.extend({
   request_id: external_exports.string().min(1).max(200).optional().describe(
@@ -10982,7 +11671,7 @@ function agentTools({ c, owner, authority, hostMeta }) {
       openWorld: true,
       panel: true,
       conversation: "chat",
-      description: "Start asynchronous work on the full request in description. The service generates the title. Work runs in the current checkout by default, including uncommitted changes. If the result has workspace_fallback, tell the user the task isn't isolated in a worktree and edits apply directly to the project folder. Reopen existing work with open_subagent_extension_for_codex(task_id), never another start_task.",
+      description: "Start a background task from the user's full request in description. Use attachments for material the worker wouldn't find on its own. If the result has workspace_fallback, tell the user the task runs directly in the project folder without an isolated worktree. To show an existing task, call open_subagent_extension_for_codex(task_id) instead of starting another.",
       schema: startSchema.extend({
         conversation_id: startSchema.shape.conversation_id.nullable(),
         provider: startSchema.shape.provider.unwrap().optional(),
@@ -10992,7 +11681,7 @@ function agentTools({ c, owner, authority, hostMeta }) {
           max_runtime_minutes: startSchema.shape.budget.unwrap().shape.max_runtime_minutes.unwrap().optional(),
           max_cost_usd: startSchema.shape.budget.unwrap().shape.max_cost_usd.unwrap().optional()
         }).optional()
-      }),
+      }).loose(),
       // Null opts out of host correlation; persisted tasks keep the optional string contract.
       run: async (a) => {
         await autoRegisterChatProject(c, owner, hostMeta, a.repository);
@@ -11005,7 +11694,7 @@ function agentTools({ c, owner, authority, hostMeta }) {
     }),
     get_task: tool({
       readOnly: true,
-      description: "Read a task's full state: status, turn (the number of turns started), pending input, draft (the message being written), pending steers not yet taken, queue (messages waiting for their own turn, and whether an interrupt paused it), branch for worktree tasks and an excerpt of the latest reply.",
+      description: "Read a task's full state: status, turn (the number of turns started), pending input, draft (the message being written), pending steers not yet taken, queue (messages waiting for their own turn, and whether an interrupt paused it), branch for worktree tasks and an excerpt of the latest reply. Read the conversation with list_messages.",
       schema: taskId,
       run: (a) => {
         const t = c.store.get(a.task_id, owner);
@@ -11020,30 +11709,26 @@ function agentTools({ c, owner, authority, hostMeta }) {
     list_tasks: tool({
       readOnly: true,
       conversation: "chat",
-      description: "List your tasks, optionally filtered by conversation and repository. null conversation_id means all conversations. Each task includes an excerpt of its latest reply, its queued message count, unread: true when the user hasn't seen its latest update in the panel, read_through (the newest event they read) and archived_at when archived.",
+      description: "List your tasks as summaries, newest first, optionally filtered by conversation and repository. null conversation_id means all conversations. Each summary has the task's status, turn, the kind of any pending_input, error, queued message count and an excerpt of its latest reply. Read a task's full state with get_task and its conversation with list_messages.",
       schema: external_exports.object({
         conversation_id: external_exports.string().nullable().optional(),
-        repository: external_exports.string().optional()
+        repository: external_exports.string().optional(),
+        archived: archivedFilter
       }),
       run: (a) => {
-        const archived = c.archive.times(owner);
-        return c.store.all(owner).filter(
-          (t) => (!a.conversation_id || t.conversation_id === a.conversation_id) && (!a.repository || t.repository === a.repository)
-        ).map(
-          (t) => listedTask(
-            t,
-            t.status === "running" ? c.store.recentEvents(t.id, owner) : [],
-            c.store.latestEvent(t.id, "agent.reply"),
-            c.drafts.get(t.id),
-            c.store.readState(t.id),
-            archived.get(t.id)
-          )
-        );
+        const filters = {
+          conversation: a.conversation_id || void 0,
+          repository: a.repository || void 0,
+          archived: a.archived
+        };
+        const archived = c.archive.times(owner, filters);
+        const replies = c.store.latestEvents(owner, "agent.reply", filters);
+        return c.store.list(owner, filters).map((t) => taskSummary(t, replies.get(t.id), archived.get(t.id)));
       }
     }),
     list_workers: tool({
       readOnly: true,
-      description: "List installed providers with their profiles, capabilities and readiness. When readiness.ready is false, report readiness.message to the user instead of retrying.",
+      description: "List installed providers with their profiles, capabilities, readiness and any org policy limits. When readiness.ready is false, report readiness.message to the user instead of retrying. When policy is present, its blocked choices fail at start_task; absent policy doesn't mean everything is allowed.",
       schema: external_exports.object({}),
       run: () => c.availableWorkers(owner)
     }),
@@ -11119,7 +11804,7 @@ function agentTools({ c, owner, authority, hostMeta }) {
         const task = c.store.get(a.task_id, owner);
         const message = conversation(
           task,
-          c.store.eventsOfTypes(task.id, MESSAGE_EVENTS)
+          c.store.conversationEvents(task.id, MESSAGE_EVENTS)
         ).find((m2) => m2.id === a.message_id);
         if (!message) throw new Error("Message not found");
         if (message.kind === "reply") {
@@ -11157,157 +11842,385 @@ function agentTools({ c, owner, authority, hostMeta }) {
   };
 }
 
-// src/shared/tasks/conversation/chat.ts
-var CHAT_EVENTS = [
-  "task.started",
-  "task.instruction",
-  "agent.message",
-  "agent.reply",
-  "task.turn_ended",
-  "task.failed",
-  "task.session_started",
-  "task.worktree_recreated",
-  "agent.input_required"
-];
-var isCompaction = (e) => {
-  return e.presentation?.kind === "compact_boundary";
+// src/service/platform/server/tools/user-tools.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/service/platform/service/about.ts
+init_define_EXTENSION_BUILD_INFO();
+var import_compare3 = __toESM(require_compare(), 1);
+import { existsSync as existsSync2 } from "node:fs";
+
+// src/service/features/providers/claude/configuration/executable.ts
+init_define_EXTENSION_BUILD_INFO();
+var import_compare = __toESM(require_compare(), 1);
+import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { access, realpath as realpath2, stat } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join2, win32 } from "node:path";
+import { promisify } from "node:util";
+var claudeCliSupport = {
+  sdk: "0.3.319",
+  minimum: "2.1.300",
+  paired: "2.1.319"
+};
+var claudePathVariable = "SUBAGENT_EXTENSION_FOR_CODEX_CLAUDE_PATH";
+var supportedRange = `${claudeCliSupport.minimum}+`;
+var setupDocs = "https://code.claude.com/docs/en/setup";
+var FRESH_MS = 5 * 60 * 1e3;
+var FAILED_FRESH_MS = 30 * 1e3;
+var VERSION_TIMEOUT_MS = 1e4;
+var VERSION_OUTPUT_BYTES = 4096;
+var execFileAsync = promisify(execFile);
+var failure = (problem, message, facts = {}) => ({
+  ready: false,
+  problem,
+  message,
+  ...facts,
+  supported: supportedRange
+});
+async function isFile(path, mode = constants.F_OK) {
+  try {
+    await access(path, mode);
+    return (await stat(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+function pathVariable({ env, platform }) {
+  if (platform !== "win32") return env.PATH ?? "";
+  const name = Object.keys(env).find((key) => key.toUpperCase() === "PATH");
+  return name ? env[name] ?? "" : "";
+}
+async function inDirectory(directory, platform) {
+  if (platform !== "win32") {
+    const candidate = join2(directory, "claude");
+    return await isFile(candidate, constants.X_OK) ? candidate : void 0;
+  }
+  const native = join2(directory, "claude.exe");
+  if (await isFile(native)) return native;
+  for (const launcher of ["claude.cmd", "claude.ps1", "claude"]) {
+    if (!await isFile(join2(directory, launcher))) continue;
+    const target = join2(
+      directory,
+      "node_modules",
+      "@anthropic-ai",
+      "claude-code",
+      "bin",
+      "claude.exe"
+    );
+    if (await isFile(target)) return target;
+  }
+  return void 0;
+}
+async function locateClaudeCli(environment) {
+  const override = environment.env[claudePathVariable];
+  const absolute = (path) => environment.platform === "win32" ? win32.isAbsolute(path) : isAbsolute3(path);
+  if (override) {
+    if (!absolute(override)) {
+      return {
+        problem: "invalid_override",
+        message: `${claudePathVariable} must be an absolute path to the Claude Code executable; it is "${override}".`
+      };
+    }
+    try {
+      return { path: await realpath2(override), launcher: override };
+    } catch {
+      return {
+        problem: "invalid_override",
+        message: `${claudePathVariable} points to ${override}, which does not exist. Fix or unset it; the service does not fall back to PATH while it is set.`
+      };
+    }
+  }
+  const separator = environment.platform === "win32" ? ";" : ":";
+  for (const directory of pathVariable(environment).split(separator)) {
+    if (!directory || !absolute(directory)) continue;
+    const found = await inDirectory(directory, environment.platform);
+    if (!found) continue;
+    try {
+      return { path: await realpath2(found), launcher: found };
+    } catch {
+    }
+  }
+  return {
+    problem: "missing",
+    message: `Claude Code was not found on the service's PATH. Install a supported version (${supportedRange}) from ${setupDocs}: the stable channel is the Homebrew claude-code cask or npm's @anthropic-ai/claude-code@stable. Or set ${claudePathVariable} to its absolute path.`
+  };
+}
+function parseClaudeVersion(output) {
+  return /^(\d+\.\d+\.\d+) \(Claude Code\)$/.exec(output.trim())?.[1];
+}
+async function versionOutput(path, timeout) {
+  const { stdout } = await execFileAsync(path, ["--version"], {
+    timeout,
+    maxBuffer: VERSION_OUTPUT_BYTES,
+    windowsHide: true
+  });
+  return stdout;
+}
+function unlaunchableReason(error, timeout) {
+  if (error.killed) {
+    return `\`--version\` did not finish within ${timeout / 1e3} seconds`;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+async function validateClaudeCli(path, timeout = VERSION_TIMEOUT_MS) {
+  let output;
+  try {
+    output = await versionOutput(path, timeout);
+  } catch (error) {
+    const reason = unlaunchableReason(error, timeout);
+    return failure(
+      "unlaunchable",
+      `Claude Code at ${path} could not be run: ${reason}. Reinstall it from ${setupDocs}, or set ${claudePathVariable} to a working copy.`,
+      { path }
+    );
+  }
+  const version = parseClaudeVersion(output);
+  if (!version) {
+    return failure(
+      "unrecognized",
+      `${path} --version printed "${output.trim().slice(0, 200)}", not a Claude Code release version. Install a supported release (${supportedRange}); prereleases aren't supported.`,
+      { path }
+    );
+  }
+  if ((0, import_compare.default)(version, claudeCliSupport.minimum) < 0) {
+    return failure(
+      "too_old",
+      `Claude Code ${version} at ${path} is older than the supported ${supportedRange}. Update it using its original installer (see ${setupDocs}), or set ${claudePathVariable} to a supported copy.`,
+      { path, version }
+    );
+  }
+  return { ready: true, path, version, supported: supportedRange };
+}
+var ClaudeCli = class {
+  constructor(environment = () => ({
+    env: process.env,
+    platform: process.platform
+  }), validate2 = validateClaudeCli) {
+    this.environment = environment;
+    this.validate = validate2;
+  }
+  environment;
+  validate;
+  cache;
+  async status({ refresh = false } = {}) {
+    const located = await locateClaudeCli(this.environment());
+    if (!("path" in located)) {
+      return failure(located.problem, located.message);
+    }
+    let identity;
+    try {
+      const file = await stat(located.path);
+      identity = [located.path, file.dev, file.ino, file.mtimeMs].join("\0");
+    } catch (error) {
+      return failure(
+        "unlaunchable",
+        `Claude Code at ${located.path} could not be read: ${error instanceof Error ? error.message : String(error)}.`,
+        { path: located.path }
+      );
+    }
+    const now = Date.now();
+    if (!refresh && this.cache?.identity === identity && this.cache.expires > now) {
+      return this.cache.status;
+    }
+    const status = this.validate(located.path);
+    const entry = { identity, expires: now + FRESH_MS, status };
+    this.cache = entry;
+    const shorten = () => {
+      entry.expires = now + FAILED_FRESH_MS;
+    };
+    status.then((result) => !result.ready && shorten(), shorten);
+    return status;
+  }
+  /** The validated executable's path; throws the readiness message when unsupported. */
+  async executable() {
+    const status = await this.status();
+    if (!status.ready) throw new Error(status.message);
+    return status.path;
+  }
 };
-function note(e) {
-  const base = {
-    kind: "note",
-    id: `evt_${e.id}`,
-    event_id: e.id,
-    timestamp: e.timestamp
+
+// src/service/features/providers/claude/configuration/upgrade.ts
+init_define_EXTENSION_BUILD_INFO();
+import { constants as constants2 } from "node:fs";
+import { access as access2, stat as stat2 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join as join3, resolve as resolve2 } from "node:path";
+var quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+async function executable(path) {
+  try {
+    await access2(path, constants2.X_OK);
+    return (await stat2(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function claudeUpgradeInfo(selected, environment = {
+  env: process.env,
+  platform: process.platform
+}, home = homedir()) {
+  const unknown2 = {
+    installation: "Unidentified",
+    note: "Use the installer or package manager that provided this executable. The service cannot determine a command that targets this installation."
   };
-  const session = eventPayload(e, "task.session_started");
-  if (session) {
+  if (!selected) {
     return {
-      ...base,
-      note: "session",
-      text: session.reason === "no_session" ? "New session: the task had none to continue" : "New session: the earlier one couldn't continue"
+      ...unknown2,
+      note: "Fix the CLI readiness issue, then recheck to identify its installation."
     };
   }
-  const worktree = eventPayload(e, "task.worktree_recreated");
-  if (worktree) {
+  if (environment.platform === "win32") return unknown2;
+  const located = await locateClaudeCli(environment);
+  if (!("path" in located) || located.path !== selected) {
     return {
-      ...base,
-      note: "worktree",
-      text: worktree.from === "base" ? "Worktree recreated from the base commit, since its branch was deleted" : "Worktree recreated from its branch"
+      ...unknown2,
+      note: "The selected executable changed while checking. Recheck its version before choosing an upgrade command."
     };
   }
-  const failed = eventPayload(e, "task.failed");
-  if (failed) {
+  const pinned = "This uses a custom launcher or a version-specific path. Updating may leave that path on the old version. Use the installer's launcher, update the configured path if needed, then restart the service.";
+  const brew = /^(.*)\/Caskroom\/(claude-code(?:@latest)?)\/[^/]+\/claude$/.exec(selected);
+  if (brew) {
+    const prefix = brew[1], cask = brew[2], manager = join3(prefix, "bin", "brew");
+    const installation = cask === "claude-code@latest" ? "Homebrew (latest)" : "Homebrew (stable)";
+    if (resolve2(located.launcher) !== join3(prefix, "bin", "claude")) {
+      return { installation, note: pinned };
+    }
+    if (!await executable(manager)) {
+      return {
+        installation,
+        note: "The matching Homebrew executable is unavailable. Restore Homebrew for this prefix, or use its installation guidance."
+      };
+    }
     return {
-      ...base,
-      note: "failure",
-      text: `Task failed: ${scalarText(failed.error, "Unknown error")}`
+      installation,
+      command: `${quote(manager)} upgrade --cask ${cask}`,
+      note: "Run in a terminal after delegated turns finish. This keeps the installed cask and release channel."
     };
   }
-  if (isCompaction(e)) {
-    return { ...base, note: "compaction", text: "Context compacted" };
+  const versions = join3(home, ".local", "share", "claude", "versions"), launcher = join3(home, ".local", "bin", "claude");
+  if (dirname(selected) === versions && /^\d+\.\d+\.\d+$/.test(selected.slice(versions.length + 1))) {
+    if (resolve2(located.launcher) !== launcher) {
+      return { installation: "Native installer", note: pinned };
+    }
+    return {
+      installation: "Native installer",
+      command: `${quote(launcher)} update`,
+      note: "Run in a terminal after delegated turns finish. Claude's updater follows its configured release channel and policy."
+    };
   }
-  if (e.type === "claude.activity" && e.presentation?.statusTitle === "Context compaction failed") {
-    return { ...base, note: "failure", text: "Context compaction failed" };
+  if (/\/node_modules\/@anthropic-ai\/claude-code(?:-[^/]+)?\//.test(selected)) {
+    return {
+      installation: "Node package",
+      note: "Use the original package manager, installation prefix and release channel. The executable path alone cannot establish whether this is a global npm install or a project dependency."
+    };
   }
-  return void 0;
+  return unknown2;
 }
-function chatItems(task, events) {
-  const sorted = [...events].sort((a, b) => a.id - b.id);
-  const messages = conversation(task, sorted);
-  const items = [];
-  let next = 0;
-  let failedOutcome;
-  const flush = (until) => {
-    for (let message = messages[next]; message && message.event_id <= until; message = messages[++next]) {
-      items.push({
-        kind: "message",
-        id: message.id,
-        event_id: message.event_id,
-        message
-      });
-    }
+
+// src/service/platform/service/build-info.ts
+init_define_EXTENSION_BUILD_INFO();
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+function collectBuildInfo(root) {
+  const version = (path) => JSON.parse(readFileSync2(path, "utf8")).version;
+  const info = {
+    version: version(join4(root, "package.json")),
+    sdks: [
+      "@anthropic-ai/claude-agent-sdk",
+      "@modelcontextprotocol/sdk",
+      "@modelcontextprotocol/ext-apps"
+    ].map((name) => ({
+      name,
+      version: version(join4(root, "node_modules", name, "package.json"))
+    }))
   };
-  for (const e of sorted) {
-    const turnEnded = eventPayload(e, "task.turn_ended");
-    if (turnEnded) {
-      flush(e.id);
-      const outcome = {
-        kind: "outcome",
-        id: `turn_${turnEnded.turn}_${e.id}`,
-        event_id: e.id,
-        timestamp: e.timestamp,
-        turn: turnEnded.turn,
-        outcome: turnEnded.outcome,
-        runtime_ms: turnEnded.runtime_ms,
-        cost_usd: turnEnded.cost_usd
-      };
-      items.push(outcome);
-      failedOutcome = outcome.outcome === "failed" ? outcome : void 0;
-    } else if (eventPayload(e, "task.failed")) {
-      if (failedOutcome) {
-        failedOutcome.error = scalarText(eventPayload(e, "task.failed")?.error);
-        failedOutcome.event_id = e.id;
-      } else {
-        flush(e.id);
-        items.push(note(e));
-      }
-      failedOutcome = void 0;
-    } else {
-      if (eventPayload(e, "task.instruction") !== void 0 || eventPayload(e, "task.queued") !== void 0 || eventPayload(e, "task.started") !== void 0) {
-        failedOutcome = void 0;
-      }
-      const marker = note(e);
-      if (marker) {
-        flush(e.id);
-        items.push(marker);
-      }
+  if (existsSync(join4(root, ".git"))) {
+    const git = (...args) => execFileSync("git", ["-C", root, ...args], {
+      encoding: "utf8",
+      timeout: 2e3,
+      maxBuffer: 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    try {
+      info.commit = git("rev-parse", "HEAD");
+      info.dirty = Boolean(
+        git("status", "--porcelain", "--untracked-files=normal")
+      );
+    } catch {
     }
   }
-  flush(Infinity);
-  return items;
+  return info;
 }
 
-// src/shared/tasks/conversation/drafts.ts
-var MAX_UPDATE_WAIT_MS = 25e3;
-
-// src/service/features/tasks/conversation/updates.ts
-import { setTimeout as sleep } from "node:timers/promises";
-var RUNNING = ["queued", "starting", "running", "waiting"];
-async function waitForUpdates(store, drafts, owner, { after, draft: target, wait_ms }) {
-  const changed = new AbortController();
-  const onChange = (changedOwner) => {
-    if (changedOwner === void 0 || changedOwner === owner) changed.abort();
+// src/service/platform/service/identity.ts
+init_define_EXTENSION_BUILD_INFO();
+var import_compare2 = __toESM(require_compare(), 1);
+var serviceApiVersion = 2;
+var launcherEnv = "SUBAGENT_EXTENSION_FOR_CODEX_LAUNCHER";
+function serviceIdentity(env = process.env) {
+  return {
+    version: packageVersion,
+    apiVersion: serviceApiVersion,
+    launcher: env[launcherEnv] === "stdio" ? "stdio" : "foreground",
+    installRoot
   };
-  store.bus.on("change", onChange);
-  try {
-    const waitMs = after === store.revision(owner) ? wait_ms : 0;
-    if (!target) {
-      await sleep(waitMs, void 0, { signal: changed.signal }).catch(
-        () => {
-        }
-        // A change ended the wait.
-      );
-      return { revision: store.revision(owner) };
-    }
-    const draft = store.find(target.task_id, owner) && await drafts.wait(
-      target.task_id,
-      { message_id: target.message_id, length: target.after_length },
-      waitMs,
-      // A turn's end commits events, which change the revision and end this.
-      changed.signal
-    );
-    const task = store.find(target.task_id, owner);
-    return {
-      revision: store.revision(owner),
-      draft: task && draft || null,
-      running: task ? RUNNING.includes(task.status) : false
+}
+function handoff(running, own2, origin) {
+  const compatible = running.apiVersion === own2.apiVersion;
+  const described2 = `version ${running.version ?? "unknown"}`;
+  if (running.launcher !== "stdio") {
+    return compatible ? { action: "use" } : {
+      action: "refuse",
+      message: `A different extension service (${described2}, not started by the plugin) is running at ${origin}. Stop it, or give development its own SUBAGENT_EXTENSION_FOR_CODEX_DATA and PORT.`
     };
-  } finally {
-    store.bus.off("change", onChange);
   }
+  const order = running.version ? (0, import_compare2.default)(running.version, own2.version) : -1;
+  if (order > 0) {
+    return compatible ? { action: "use" } : {
+      action: "refuse",
+      message: `A newer extension service (${described2}) is running at ${origin}; update the plugin to ${running.version} or later.`
+    };
+  }
+  if (order < 0 || !running.installed || !compatible) {
+    return { action: "replace", forward: compatible };
+  }
+  return { action: "use" };
+}
+
+// src/service/platform/service/about.ts
+var build = typeof define_EXTENSION_BUILD_INFO_default === "undefined" ? collectBuildInfo(installRoot) : define_EXTENSION_BUILD_INFO_default;
+async function aboutInfo(c, refresh = false) {
+  const claude = await c.providers.get("claude")?.readiness?.({ refresh }), version = claude?.details.version, upgrade = claude ? await claudeUpgradeInfo(version ? claude.details.executable : void 0) : void 0;
+  if (refresh) {
+    logEvent("info", "about.claude_rechecked", {
+      ready: claude?.ready,
+      problem: claude?.details.problem,
+      version,
+      executable: claude?.details.executable,
+      installation: upgrade?.installation
+    });
+  }
+  return {
+    build,
+    installation: existsSync2(packagePath("src", "service", "main.ts")) ? "checkout" : "package",
+    runtime: {
+      node: process.versions.node,
+      platform: process.platform,
+      arch: process.arch,
+      launcher: serviceIdentity().launcher
+    },
+    claude,
+    claude_recommended: version ? {
+      version: claudeCliSupport.paired,
+      behind: (0, import_compare3.default)(version, claudeCliSupport.paired) < 0
+    } : void 0,
+    claude_upgrade: upgrade
+  };
 }
 
 // src/service/platform/server/tools/activity-tools.ts
+init_define_EXTENSION_BUILD_INFO();
 function activityTools(c, owner) {
   return {
     app_get_change_counts: tool({
@@ -11329,20 +12242,9 @@ function activityTools(c, owner) {
         return original === void 0 ? { available: false } : { available: true, original };
       }
     }),
-    app_get_activity: tool({
-      readOnly: true,
-      description: "User interface only: a task's activity for the panel's Activity tab: its newest events after a cursor, and a tally of the older events outside the window (the summary's count, timestamps, tool calls, messages, failures and retries).",
-      schema: taskId.extend({
-        after: external_exports.number().int().nonnegative().default(0)
-      }),
-      run: (a) => {
-        c.store.get(a.task_id, owner);
-        return c.activity.page(a.task_id, a.after);
-      }
-    }),
     app_get_turn_activity: tool({
       readOnly: true,
-      description: "User interface only: one turn's activity for the panel's Activity tab: the events after the previous turn's closing status event through this turn's, or to the newest event while the turn runs. Its newest events come with a tally of the older ones, as app_get_activity gives them.",
+      description: "User interface only: one turn's activity for the panel's Activity tab: the events after the previous turn's closing status event through this turn's, or to the newest event while the turn runs. Its newest events come with a tally of the older ones, as a view's Activity gives them.",
       schema: taskId.extend({ turn: external_exports.number().int().positive() }),
       run: (a) => {
         c.store.get(a.task_id, owner);
@@ -11352,7 +12254,11 @@ function activityTools(c, owner) {
   };
 }
 
+// src/service/platform/server/tools/panel-timing-tool.ts
+init_define_EXTENSION_BUILD_INFO();
+
 // src/shared/tasks/panel-timing.ts
+init_define_EXTENSION_BUILD_INFO();
 var timedOperations = ["app_send_message", "interrupt_task"];
 var taskIdPattern = /^task_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 var panelRequestIdPattern = /^[0-9a-f]{32}$/;
@@ -11371,8 +12277,8 @@ var PANEL_TIMING_MAX_DURATION_MS = 1e12;
 var workCount = external_exports.number().int().nonnegative().max(PANEL_TIMING_MAX_COUNT);
 var elapsed = external_exports.number().nonnegative().max(PANEL_TIMING_MAX_DURATION_MS);
 var panelLoadTimingRecordSchema = external_exports.strictObject({
-  operation: external_exports.enum(["task_list", "chat", "activity_latest", "activity_turn"]),
-  phase: external_exports.enum(["fetch", "decode", "merge", "group"]),
+  operation: external_exports.enum(["view", "task_list", "activity_latest", "activity_turn"]),
+  phase: external_exports.enum(["fetch", "deliver", "decode", "merge", "group"]),
   count: workCount.positive(),
   total_ms: elapsed,
   max_ms: elapsed,
@@ -11391,6 +12297,7 @@ var panelTimingBatchSchema = external_exports.strictObject({
 });
 
 // src/service/features/tasks/runtime/timing.ts
+init_define_EXTENSION_BUILD_INFO();
 import { createHash } from "node:crypto";
 var writer;
 var previousWrites = Promise.resolve();
@@ -11494,7 +12401,33 @@ function panelTimingTool() {
   });
 }
 
+// src/service/platform/server/tools/panel-view-tools.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/tasks/conversation/drafts.ts
+init_define_EXTENSION_BUILD_INFO();
+var MAX_UPDATE_WAIT_MS = 25e3;
+
+// src/service/features/tasks/conversation/chat-read.ts
+init_define_EXTENSION_BUILD_INFO();
+function chatRead(store, attachments, task, after) {
+  const events = store.chatEvents(task.id, after);
+  const items = chatItems(task, events).filter(
+    (item) => item.event_id > after || after === 0 && item.event_id === 0
+  );
+  const request = items[0];
+  if (after === 0 && request?.kind === "message") {
+    const attached = attachments.list(task.id).map(({ file: _2, ...a }) => a);
+    if (attached.length) request.message.attachments = attached;
+  }
+  return { items, next_cursor: Math.max(after, events.at(-1)?.id ?? 0) };
+}
+
+// src/service/features/tasks/conversation/parent-updates.ts
+init_define_EXTENSION_BUILD_INFO();
+
 // src/shared/tasks/conversation/parent-updates.ts
+init_define_EXTENSION_BUILD_INFO();
 var PARENT_UPDATE_EVENTS = [
   "agent.reply",
   "task.failed",
@@ -11521,11 +12454,13 @@ function parentUpdate(task, e, parentDecides) {
   }
   const failed = eventPayload(e, "task.failed");
   if (failed) {
-    const error = failed.error ?? "The task failed.";
     return {
       ...base,
-      kind: /budget/i.test(error) ? "budget" : "failed",
-      text: replyExcerpt(error, SNIPPET_CHARS)
+      kind: isBudgetFailure(failed.error_code) ? "budget" : "failed",
+      text: replyExcerpt(
+        failureMessage(failed) ?? "The task failed.",
+        SNIPPET_CHARS
+      )
     };
   }
   const request = eventPayload(e, "agent.input_required")?.request;
@@ -11565,23 +12500,154 @@ function pendingUpdates(store, seen, parentDecides, owner, conversation2) {
   return [...byTask.values()];
 }
 
-// src/service/platform/server/tools/pending-update-tools.ts
-function pendingUpdateTools(c, owner) {
+// src/service/features/tasks/conversation/updates.ts
+init_define_EXTENSION_BUILD_INFO();
+import { setTimeout as sleep } from "node:timers/promises";
+var RUNNING = ["queued", "starting", "running", "waiting"];
+async function waitForUpdates(store, drafts, owner, { after, draft: target, wait_ms }, view) {
+  const changed = new AbortController();
+  const known = target && {
+    task_id: target.task_id,
+    message_id: target.message_id,
+    length: target.after_length
+  };
+  const onChange = (changedOwner) => {
+    if (changedOwner === void 0 || changedOwner === owner) changed.abort();
+  };
+  store.bus.on("change", onChange);
+  try {
+    const waitMs = after === store.revision(owner) ? wait_ms : 0;
+    if (!known) {
+      await sleep(waitMs, void 0, { signal: changed.signal }).catch(
+        () => {
+        }
+        // A change ended the wait.
+      );
+    } else if (store.find(known.task_id, owner)) {
+      await drafts.wait(known.task_id, known, waitMs, changed.signal);
+    }
+  } finally {
+    store.bus.off("change", onChange);
+  }
+  const readView = await view?.();
+  const revision = store.revision(owner);
+  if (!known) return { revision, ...readView && { view: readView() } };
+  const task = store.find(known.task_id, owner);
+  const draftOnly = revision === after && !!task && drafts.differs(task.id, known);
+  return {
+    revision,
+    draft: (task && drafts.get(task.id)) ?? null,
+    running: task ? RUNNING.includes(task.status) : false,
+    ...readView && !draftOnly && { view: readView() }
+  };
+}
+
+// src/service/platform/server/tools/panel-view-tools.ts
+function panelViewTools(c, owner) {
+  const list = tool({
+    readOnly: true,
+    description: "User interface only: { tasks, read_completed }, the tasks the panel lists, newest first. Each has its full state except the conversation, with its latest reply excerpt, live activity, draft, read state and archive time. include names tasks to list whatever the filters say. Unless include_read_completed is true, completed tasks the user has read are left out, except included ones and the newest, and read_completed counts them by repository.",
+    schema: external_exports.object({
+      conversation_id: external_exports.string().nullable().optional(),
+      repository: external_exports.string().optional(),
+      archived: archivedFilter,
+      include: external_exports.array(external_exports.string()).max(10).optional(),
+      include_read_completed: external_exports.boolean().default(false)
+    }),
+    run: (a) => panelTaskList(
+      c,
+      owner,
+      {
+        conversation: a.conversation_id || void 0,
+        repository: a.repository || void 0,
+        archived: a.archived,
+        include: a.include
+      },
+      a.include_read_completed
+    )
+  });
+  const cursor = taskId.extend({
+    after: external_exports.number().int().nonnegative().default(0)
+  });
+  const view = external_exports.strictObject({
+    list: list.schema,
+    chat: cursor.optional(),
+    activity: cursor.optional(),
+    pending: external_exports.strictObject({ conversation_id: external_exports.string().min(1) }).optional()
+  });
+  const readView = async (parts) => {
+    const known = await c.projects?.listWithGit() ?? [];
+    const { chat, activity, pending: pending2 } = parts;
+    return () => c.store.reads.measure("view", (work) => {
+      const chatTask = chat && c.store.find(chat.task_id, owner);
+      const activityTask = activity && c.store.find(activity.task_id, owner);
+      const read2 = {
+        projects: c.projects?.withKnownGit(known) ?? [],
+        list: list.run(parts.list),
+        ...chat && chatTask && {
+          chat: chatRead(c.store, c.attachments, chatTask, chat.after)
+        },
+        ...activity && activityTask && {
+          activity: c.activity.page(activityTask.id, activity.after)
+        },
+        ...pending2 && {
+          pending: {
+            tasks: pendingUpdates(
+              c.store,
+              c.parentSeen,
+              (t) => c.providers.get(t.provider)?.taskPolicy.parentMayApprove(t) ?? false,
+              owner,
+              pending2.conversation_id
+            )
+          }
+        }
+      };
+      work.rows = read2.list.tasks.length;
+      return { ...read2, built_at: Date.now() };
+    });
+  };
   return {
-    app_list_pending_updates: tool({
+    app_list_tasks: list,
+    app_get_attachment: tool({
       readOnly: true,
-      description: "User interface only: the worker updates Codex hasn't seen in a conversation, grouped by task: turn replies, failures, budget stops and requests Codex may answer. Tasks and their updates are newest first. Archived tasks are left out.",
-      schema: external_exports.strictObject({ conversation_id: external_exports.string().min(1) }),
-      run: (a) => ({
-        tasks: pendingUpdates(
-          c.store,
-          c.parentSeen,
-          (t) => c.providers.get(t.provider)?.taskPolicy.parentMayApprove(t) ?? false,
-          owner,
-          a.conversation_id
-        )
-      })
+      description: "User interface only: a page of a task's attachment, by its position in the request, with the attachment's metadata. state is unavailable when its stored file is missing, too large or not UTF-8 text. Pass next_cursor for more content.",
+      schema: taskId.extend({
+        position: external_exports.number().int().positive(),
+        cursor: external_exports.string().max(100).optional()
+      }),
+      run: (a) => c.attachments.page(
+        c.store.get(a.task_id, owner).id,
+        a.position,
+        a.cursor
+      )
     }),
+    app_wait_for_updates: tool({
+      readOnly: true,
+      description: `User interface only: waits for something the panel should show. It returns the owner's current revision as soon as it differs from after, and with a draft target, as soon as that task's draft grows past after_length, becomes another message or clears; otherwise after wait_ms (at most ${MAX_UPDATE_WAIT_MS}). Without after, or with wait_ms 0, it returns at once, so it also reads a draft. A revision is boot:count, and the count only grows within a boot. With view, it also returns view as of the returned revision, with built_at in epoch milliseconds. Its projects are as list_projects returns them, and its list takes app_list_tasks arguments and returns that shape. chat { items, next_cursor } is a task's Chat after a cursor: its messages, an outcome row for each turn's end, and notes for a new session, a recreated worktree and compaction. Cursor 0 also returns the request with its attachments. An item read again replaces the earlier one with its id. activity { events, dropped } holds a task's newest Activity events after a cursor, with a tally of the older events outside the window. pending { tasks } lists the worker updates Codex hasn't seen in a conversation, grouped by task and newest first: turn replies, failures, budget stops and requests Codex may answer, leaving out archived tasks. The wait leaves view out when only the draft changed, and leaves out chat and activity for a task the owner doesn't have.`,
+      schema: external_exports.strictObject({
+        after: external_exports.string().max(200).optional(),
+        draft: taskId.extend({
+          message_id: external_exports.string().max(200).optional(),
+          after_length: external_exports.number().int().nonnegative().default(0)
+        }).strict().optional(),
+        wait_ms: external_exports.number().int().min(0).max(MAX_UPDATE_WAIT_MS).default(0),
+        view: view.optional()
+      }),
+      run: ({ view: parts, ...a }) => waitForUpdates(
+        c.store,
+        c.drafts,
+        owner,
+        a,
+        parts && (() => readView(parts))
+      )
+    })
+  };
+}
+
+// src/service/platform/server/tools/pending-update-tools.ts
+init_define_EXTENSION_BUILD_INFO();
+function pendingUpdateTools(c, owner) {
+  return {
     app_mark_updates_seen: tool({
       description: "User interface only: record worker updates as seen by Codex, by event, so they no longer count as pending.",
       schema: external_exports.strictObject({
@@ -11595,10 +12661,14 @@ function pendingUpdateTools(c, owner) {
   };
 }
 
+// src/service/platform/server/tools/project-tools.ts
+init_define_EXTENSION_BUILD_INFO();
+
 // src/service/features/projects/project-picker.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execute = promisify(execFile);
+init_define_EXTENSION_BUILD_INFO();
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execute = promisify2(execFile2);
 var script = `try
   set selectedFolder to choose folder with prompt "Choose a folder to add to Delegated Work"
   return POSIX path of selectedFolder
@@ -11606,8 +12676,8 @@ on error number -128
   return ""
 end try`;
 var pending = false;
-async function browseProject(options3 = { platform: process.platform, execute }) {
-  if (options3.platform !== "darwin") {
+async function browseProject(options2 = { platform: process.platform, execute }) {
+  if (options2.platform !== "darwin") {
     throw new Error(
       "Folder browsing is available on macOS. Enter an absolute folder path instead."
     );
@@ -11617,7 +12687,7 @@ async function browseProject(options3 = { platform: process.platform, execute })
   }
   pending = true;
   try {
-    const { stdout } = await options3.execute(
+    const { stdout } = await options2.execute(
       "/usr/bin/osascript",
       ["-e", script],
       {
@@ -11666,22 +12736,37 @@ function projectTools(c, owner) {
       }
     }),
     app_remove_project: tool({
-      description: "User interface only: remove a saved project approval. Optionally stop and delete this user's project tasks, history and task worktrees/branches; checkout files and provider sessions stay intact. External dependent tasks block deletion.",
+      description: "User interface only: remove a saved project approval. Optionally stop and delete this user's project tasks, history and task worktrees and local branches, and with delete_agent_task their provider sessions. Checkout files stay intact.",
       schema: external_exports.strictObject({
         repository: external_exports.string().min(1).max(4096),
-        delete_tasks: external_exports.boolean().default(false)
-      }),
+        delete_tasks: external_exports.boolean().default(false),
+        delete_agent_task: external_exports.boolean().default(false),
+        confirmation: external_exports.string().regex(/^[0-9a-f]{64}$/).optional()
+      }).refine(
+        (a) => !a.delete_tasks || !!a.confirmation,
+        "Review the task removal list before deleting project task data."
+      ).refine(
+        (a) => a.delete_tasks || !a.delete_agent_task,
+        "Provider sessions are removed only with project task data."
+      ),
       run: (a) => {
         if (!c.projects) {
           throw new Error("Project management is unavailable in this service.");
         }
-        return c.removeProject(owner, a.repository, a.delete_tasks);
+        return c.removeProject(
+          owner,
+          a.repository,
+          a.delete_tasks,
+          a.confirmation,
+          a.delete_agent_task
+        );
       }
     })
   };
 }
 
 // src/service/platform/server/tools/queue-tools.ts
+init_define_EXTENSION_BUILD_INFO();
 function queueTools(c, owner) {
   return {
     app_steer_queued_message: tool({
@@ -11733,12 +12818,17 @@ function queueTools(c, owner) {
   };
 }
 
+// src/service/platform/server/tools/settings-transfer-tools.ts
+init_define_EXTENSION_BUILD_INFO();
+
 // src/service/features/settings/settings-file.ts
+init_define_EXTENSION_BUILD_INFO();
 import { writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join5 } from "node:path";
 
 // src/service/features/settings/settings-transfer.ts
+init_define_EXTENSION_BUILD_INFO();
 var SETTINGS_FORMAT = 2;
 var settingsTransferInputSchema = external_exports.strictObject({
   document: external_exports.string().min(1).meta({
@@ -11807,7 +12897,7 @@ var settingsFileOutputSchema = external_exports.object({ path: external_exports.
 async function saveSettingsFile(settings, owner) {
   const { document: document2 } = exportSettings(settings, owner);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/:/g, "-");
-  const path = join2(homedir(), `delegated-work-settings-${timestamp}Z.json`);
+  const path = join5(homedir2(), `delegated-work-settings-${timestamp}Z.json`);
   await writeFile(path, `${document2}
 `, {
     encoding: "utf8",
@@ -11843,6 +12933,7 @@ function settingsTransferTools(settings, owner) {
 }
 
 // src/service/platform/server/tools/task-lifecycle-tools.ts
+init_define_EXTENSION_BUILD_INFO();
 function taskLifecycleTools(c, owner) {
   return {
     app_remove_worktree: tool({
@@ -11899,18 +12990,38 @@ function taskLifecycleTools(c, owner) {
       }),
       run: (a) => c.archive.setArchived(owner, a.task_ids, a.archived)
     }),
+    app_preview_task_deletion: tool({
+      readOnly: true,
+      description: "User interface only: list the exact task records, worktrees, branches and optional provider session files selected for deletion. Returns a confirmation tied to those resources. Show the resources to the user before app_delete_tasks.",
+      // Keep an object root so the MCP SDK preserves the tool's input metadata.
+      schema: external_exports.strictObject({
+        task_ids: external_exports.array(external_exports.string()).min(1).max(1e3).optional(),
+        repository: external_exports.string().min(1).max(4096).optional(),
+        delete_agent_task: external_exports.boolean().default(false)
+      }).refine(
+        (a) => !!a.task_ids !== !!a.repository,
+        "Choose task IDs or a project, not both."
+      ),
+      run: (a) => c.taskDeletionPreview(
+        owner,
+        a.task_ids ?? [],
+        a.delete_agent_task,
+        a.repository
+      )
+    }),
     app_delete_tasks: tool({
       destructive: true,
-      description: "User interface only: delete stopped tasks with their events, requests, worktrees and branches, dependents first. With delete_agent_task it also deletes each provider session. A task outside them that depends on one stops the whole deletion. This can't be undone.",
+      description: "User interface only: delete the tasks and resources reviewed with app_preview_task_deletion. Requires its confirmation and the same task IDs and delete_agent_task choice. Changed resources require a new preview. Running work stops first. This can't be undone.",
       schema: external_exports.strictObject({
         task_ids: external_exports.array(external_exports.string()).min(1).max(1e3),
-        delete_agent_task: external_exports.boolean().default(false)
+        delete_agent_task: external_exports.boolean().default(false),
+        confirmation: external_exports.string().regex(/^[0-9a-f]{64}$/)
       }),
-      run: (a) => c.delete(owner, a.task_ids, a.delete_agent_task)
+      run: (a) => c.delete(owner, a.task_ids, a.delete_agent_task, a.confirmation)
     }),
     app_delete_branch: tool({
       destructive: true,
-      description: "User interface only: delete a stopped worktree task's branch once its worktree is removed.",
+      description: "User interface only: delete a stopped worktree task's local branch once its worktree is removed. Remote branches are not changed.",
       schema: taskId,
       run: (a) => c.deleteBranch(owner, a.task_id)
     })
@@ -11920,6 +13031,12 @@ function taskLifecycleTools(c, owner) {
 // src/service/platform/server/tools/user-tools.ts
 function userTools({ c, owner, hostMeta }, tools) {
   return {
+    app_get_about: tool({
+      readOnly: true,
+      description: "User interface only: extension build, SDK versions and local runtime diagnostics.",
+      schema: external_exports.object({ refresh: external_exports.boolean().default(false) }),
+      run: ({ refresh }) => aboutInfo(c, refresh)
+    }),
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Temporary feature gate.
     ...composerMentionsEnabled ? {
       // The host's composer calls this. The HTTP and stdio servers register it
@@ -11970,36 +13087,7 @@ function userTools({ c, owner, hostMeta }, tools) {
         return { budget: task.budget, status: task.status };
       }
     }),
-    app_get_chat: tool({
-      readOnly: true,
-      description: "User interface only: a task's Chat after a cursor: its messages, an outcome row for each turn's end, and notes for a new session, a recreated worktree and compaction. An item read again replaces the earlier one with its id.",
-      schema: taskId.extend({
-        after: external_exports.number().int().nonnegative().default(0)
-      }),
-      run: (a) => {
-        const t = c.store.get(a.task_id, owner);
-        const events = c.store.chatEvents(t.id, CHAT_EVENTS);
-        return {
-          items: chatItems(t, events).filter(
-            (item) => item.event_id > a.after || a.after === 0 && item.event_id === 0
-          ),
-          next_cursor: Math.max(a.after, events.at(-1)?.id ?? 0)
-        };
-      }
-    }),
-    app_wait_for_updates: tool({
-      readOnly: true,
-      description: `User interface only: waits for something the panel should show. It returns the owner's current revision as soon as it differs from after, and with a draft target, as soon as that task's draft grows past after_length, becomes another message or clears; otherwise after wait_ms (at most ${MAX_UPDATE_WAIT_MS}). Without after, or with wait_ms 0, it returns at once, so it also reads a draft. The revision is opaque: compare it only for equality.`,
-      schema: external_exports.strictObject({
-        after: external_exports.string().max(200).optional(),
-        draft: taskId.extend({
-          message_id: external_exports.string().max(200).optional(),
-          after_length: external_exports.number().int().nonnegative().default(0)
-        }).strict().optional(),
-        wait_ms: external_exports.number().int().min(0).max(MAX_UPDATE_WAIT_MS).default(0)
-      }),
-      run: (a) => waitForUpdates(c.store, c.drafts, owner, a)
-    }),
+    ...panelViewTools(c, owner),
     ...queueTools(c, owner),
     app_submit_input: tool({
       ...tools.submit_input,
@@ -12103,9 +13191,10 @@ async function callTool(c, owner, name, args, authority = "parent", hostMeta) {
 }
 
 // src/service/platform/service/process-info.ts
-import { execFileSync } from "node:child_process";
-import { readFileSync as readFileSync2, readlinkSync } from "node:fs";
-import { basename, dirname, join as join3 } from "node:path";
+init_define_EXTENSION_BUILD_INFO();
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { readFileSync as readFileSync3, readlinkSync } from "node:fs";
+import { basename, dirname as dirname2, join as join6 } from "node:path";
 function inspectProcess(pid) {
   try {
     if (process.platform === "linux") return inspectLinuxProcess(pid);
@@ -12166,7 +13255,7 @@ function isExtensionService(owner, lockFile) {
   let metadata;
   try {
     metadata = JSON.parse(
-      readFileSync2(join3(dirname(lockFile), "service.json"), "utf8")
+      readFileSync3(join6(dirname2(lockFile), "service.json"), "utf8")
     );
   } catch {
     return false;
@@ -12197,17 +13286,17 @@ function inspectLinuxProcess(pid) {
   };
 }
 function readLinuxCommandLine(pid) {
-  return readFileSync2(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean).join(" ");
+  return readFileSync3(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean).join(" ");
 }
 function readLinuxFields(pid) {
-  const stat = readFileSync2(`/proc/${pid}/stat`, "utf8");
-  return stat.slice(stat.lastIndexOf(")") + 2).trim().split(/\s+/);
+  const stat3 = readFileSync3(`/proc/${pid}/stat`, "utf8");
+  return stat3.slice(stat3.lastIndexOf(")") + 2).trim().split(/\s+/);
 }
 function linuxStartedAt(fields) {
   const ticks = fields[19];
   if (!ticks) return;
   try {
-    const bootId = readFileSync2(
+    const bootId = readFileSync3(
       "/proc/sys/kernel/random/boot_id",
       "utf8"
     ).trim();
@@ -12263,7 +13352,7 @@ function inspectWindowsProcess(pid) {
   };
 }
 function run(command, args) {
-  return execFileSync(command, args, {
+  return execFileSync2(command, args, {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"],
     timeout: 2e3
@@ -12271,12 +13360,13 @@ function run(command, args) {
 }
 
 // src/service/platform/service/port.ts
+init_define_EXTENSION_BUILD_INFO();
 import { createServer } from "node:net";
 var PortInUseError = class extends Error {
-  constructor(port, options3) {
+  constructor(port, options2) {
     super(
       `Port ${port} is already in use by another program. Stop that program, or set PORT to a free port.`,
-      options3
+      options2
     );
     this.port = port;
     this.name = "PortInUseError";
@@ -12285,27 +13375,28 @@ var PortInUseError = class extends Error {
 };
 var nearbyPorts = 10;
 function available(port) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const server = createServer();
-    server.once("error", () => resolve2(false));
-    server.listen(port, "127.0.0.1", () => server.close(() => resolve2(true)));
+    server.once("error", () => resolve3(false));
+    server.listen(port, "127.0.0.1", () => server.close(() => resolve3(true)));
   });
 }
 async function freeLoopbackPort(start, skip) {
   for (let port = start; port < start + nearbyPorts; port++) {
     if (port !== skip && await available(port)) return port;
   }
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const server = createServer();
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const { port } = server.address();
-      server.close(() => resolve2(port));
+      server.close(() => resolve3(port));
     });
   });
 }
 
 // src/service/platform/service/health-proof.ts
+init_define_EXTENSION_BUILD_INFO();
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 var challengeHeader = "x-subagent-extension-for-codex-challenge";
 var challengePattern = /^[A-Za-z0-9_-]{32,128}$/;
@@ -12323,68 +13414,6 @@ function provesToken(token, challenge, proof) {
   return actual.length === expected.length && timingSafeEqual(actual, expected);
 }
 
-// src/service/platform/service/identity.ts
-var serviceApiVersion = 1;
-var launcherEnv = "SUBAGENT_EXTENSION_FOR_CODEX_LAUNCHER";
-function serviceIdentity(env = process.env) {
-  return {
-    version: packageVersion,
-    apiVersion: serviceApiVersion,
-    launcher: env[launcherEnv] === "stdio" ? "stdio" : "foreground",
-    installRoot
-  };
-}
-function compareVersions(a, b) {
-  const parse2 = (version) => {
-    const [core = "", ...pre] = version.replace(/\+.*/, "").split("-");
-    const prerelease = pre.join("-");
-    return {
-      core: core.split(".").map((part) => Number(part) || 0),
-      prerelease: prerelease ? prerelease.split(".") : []
-    };
-  };
-  const [left, right] = [parse2(a), parse2(b)];
-  for (let i = 0; i < Math.max(left.core.length, right.core.length); i++) {
-    const difference = (left.core[i] ?? 0) - (right.core[i] ?? 0);
-    if (difference) return Math.sign(difference);
-  }
-  if (!left.prerelease.length || !right.prerelease.length) {
-    return Math.sign(right.prerelease.length - left.prerelease.length);
-  }
-  for (let i = 0; i < Math.max(left.prerelease.length, right.prerelease.length); i++) {
-    const [x, y] = [left.prerelease[i], right.prerelease[i]];
-    if (x === y) continue;
-    if (x === void 0) return -1;
-    if (y === void 0) return 1;
-    const [xNumeric, yNumeric] = [/^\d+$/.test(x), /^\d+$/.test(y)];
-    if (xNumeric && yNumeric) return Math.sign(Number(x) - Number(y));
-    if (xNumeric !== yNumeric) return xNumeric ? -1 : 1;
-    return x < y ? -1 : 1;
-  }
-  return 0;
-}
-function handoff(running, own2, origin) {
-  const compatible = running.apiVersion === own2.apiVersion;
-  const described2 = `version ${running.version ?? "unknown"}`;
-  if (running.launcher !== "stdio") {
-    return compatible ? { action: "use" } : {
-      action: "refuse",
-      message: `A different extension service (${described2}, not started by the plugin) is running at ${origin}. Stop it, or give development its own SUBAGENT_EXTENSION_FOR_CODEX_DATA and PORT.`
-    };
-  }
-  const order = running.version ? compareVersions(running.version, own2.version) : -1;
-  if (order > 0) {
-    return compatible ? { action: "use" } : {
-      action: "refuse",
-      message: `A newer extension service (${described2}) is running at ${origin}; update the plugin to ${running.version} or later.`
-    };
-  }
-  if (order < 0 || !running.installed || !compatible) {
-    return { action: "replace", forward: compatible };
-  }
-  return { action: "use" };
-}
-
 export {
   inspectProcess,
   inspectProcessIdentity,
@@ -12393,19 +13422,25 @@ export {
   isExtensionService,
   PortInUseError,
   freeLoopbackPort,
+  scalarText,
   claudePermissionModes,
   claudePermissionModeSchema,
   permissionModeSchema,
   claudeOverrideDefaults,
+  MODE_TURNED_OFF_BY_ORG,
   permissionLabel,
+  permissionModeName,
   readOnlyProfile,
   resolveClaudePermission,
   exceedsPermission,
   claudePolicySchema,
   resolveClaudePolicy,
+  ClaudeCli,
   contentText,
-  scalarText,
-  eventPayload,
+  FAMILY_ALIASES,
+  isModelVariant,
+  modelAllowed,
+  blockedReason,
   settingText,
   preferredSettingsProvider,
   providerModelSettingScopes,
@@ -12672,7 +13707,7 @@ export {
   mergeCapabilities,
   productGlyphIcons,
   resolvePanelContext,
-  openingTasks,
+  panelTaskList,
   delegationPanel,
   SERVER_INSTRUCTIONS,
   composerMentionsEnabled,
@@ -12693,4 +13728,4 @@ export {
   toolStructuredContent,
   callTool
 };
-//# sourceMappingURL=chunk-DGCGXY3T.js.map
+//# sourceMappingURL=chunk-L5ILPS3O.js.map