@anypal/plugin-git 0.0.0-stage → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,3233 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  activate: () => activate2,
+  deactivate: () => deactivate
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_node_async_hooks = require("node:async_hooks");
+var local = __toESM(require("node:fs/promises"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_async_hooks2 = require("node:async_hooks");
+var import_diff = require("diff");
+var import_node_path2 = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+var import_promises = require("node:fs/promises");
+var import_diff2 = require("diff");
+var __create2 = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key2) && key2 !== except)
+        __defProp2(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc2(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var require_ipaddr = __commonJS({
+  "../../node_modules/ipaddr.js/lib/ipaddr.js"(exports, module2) {
+    (function(root) {
+      "use strict";
+      const ipv4Part = "(0?\\d+|0x[a-f0-9]+)";
+      const ipv4Regexes = {
+        fourOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}$`, "i"),
+        threeOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}$`, "i"),
+        twoOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}$`, "i"),
+        longValue: new RegExp(`^${ipv4Part}$`, "i")
+      };
+      const octalRegex = new RegExp(`^0[0-7]+$`, "i");
+      const hexRegex = new RegExp(`^0x[a-f0-9]+$`, "i");
+      const zoneIndex = "%[0-9a-z]{1,}";
+      const ipv6Part = "(?:[0-9a-f]+::?)+";
+      const ipv6Regexes = {
+        zoneIndex: new RegExp(zoneIndex, "i"),
+        "native": new RegExp(`^(::)?(${ipv6Part})?([0-9a-f]+)?(::)?(${zoneIndex})?$`, "i"),
+        deprecatedTransitional: new RegExp(`^(?:::)(${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}(${zoneIndex})?)$`, "i"),
+        transitional: new RegExp(`^((?:${ipv6Part})|(?:::)(?:${ipv6Part})?)${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}(${zoneIndex})?$`, "i")
+      };
+      function expandIPv6(string, parts) {
+        if (string.indexOf("::") !== string.lastIndexOf("::")) {
+          return null;
+        }
+        let colonCount = 0;
+        let lastColon = -1;
+        let zoneId = (string.match(ipv6Regexes.zoneIndex) || [])[0];
+        let replacement, replacementCount;
+        if (zoneId) {
+          zoneId = zoneId.substring(1);
+          string = string.replace(/%.+$/, "");
+        }
+        while ((lastColon = string.indexOf(":", lastColon + 1)) >= 0) {
+          colonCount++;
+        }
+        if (string.substr(0, 2) === "::") {
+          colonCount--;
+        }
+        if (string.substr(-2, 2) === "::") {
+          colonCount--;
+        }
+        if (colonCount > parts) {
+          return null;
+        }
+        replacementCount = parts - colonCount;
+        replacement = ":";
+        while (replacementCount--) {
+          replacement += "0:";
+        }
+        string = string.replace("::", replacement);
+        if (string[0] === ":") {
+          string = string.slice(1);
+        }
+        if (string[string.length - 1] === ":") {
+          string = string.slice(0, -1);
+        }
+        parts = (function() {
+          const ref = string.split(":");
+          const results = [];
+          for (let i = 0; i < ref.length; i++) {
+            results.push(parseInt(ref[i], 16));
+          }
+          return results;
+        })();
+        return {
+          parts,
+          zoneId
+        };
+      }
+      function matchCIDR(first, second, partSize, cidrBits) {
+        if (first.length !== second.length) {
+          throw new Error("ipaddr: cannot match CIDR for objects with different lengths");
+        }
+        let part = 0;
+        let shift;
+        while (cidrBits > 0) {
+          shift = partSize - cidrBits;
+          if (shift < 0) {
+            shift = 0;
+          }
+          if (first[part] >> shift !== second[part] >> shift) {
+            return false;
+          }
+          cidrBits -= partSize;
+          part += 1;
+        }
+        return true;
+      }
+      function parseIntAuto(string) {
+        if (hexRegex.test(string)) {
+          return parseInt(string, 16);
+        }
+        if (string[0] === "0" && !isNaN(parseInt(string[1], 10))) {
+          if (octalRegex.test(string)) {
+            return parseInt(string, 8);
+          }
+          throw new Error(`ipaddr: cannot parse ${string} as octal`);
+        }
+        return parseInt(string, 10);
+      }
+      function padPart(part, length) {
+        while (part.length < length) {
+          part = `0${part}`;
+        }
+        return part;
+      }
+      const ipaddr2 = {};
+      ipaddr2.IPv4 = (function() {
+        function IPv4(octets) {
+          if (octets.length !== 4) {
+            throw new Error("ipaddr: ipv4 octet count should be 4");
+          }
+          let i, octet;
+          for (i = 0; i < octets.length; i++) {
+            octet = octets[i];
+            if (!(0 <= octet && octet <= 255)) {
+              throw new Error("ipaddr: ipv4 octet should fit in 8 bits");
+            }
+          }
+          this.octets = octets;
+        }
+        IPv4.prototype.SpecialRanges = {
+          unspecified: [[new IPv4([0, 0, 0, 0]), 8]],
+          broadcast: [[new IPv4([255, 255, 255, 255]), 32]],
+          // RFC3171
+          multicast: [[new IPv4([224, 0, 0, 0]), 4]],
+          // RFC3927
+          linkLocal: [[new IPv4([169, 254, 0, 0]), 16]],
+          // RFC5735
+          loopback: [[new IPv4([127, 0, 0, 0]), 8]],
+          // RFC6598
+          carrierGradeNat: [[new IPv4([100, 64, 0, 0]), 10]],
+          // RFC1918
+          "private": [
+            [new IPv4([10, 0, 0, 0]), 8],
+            [new IPv4([172, 16, 0, 0]), 12],
+            [new IPv4([192, 168, 0, 0]), 16]
+          ],
+          // Reserved and testing-only ranges; RFCs 5735, 5737, 2544, 1700
+          reserved: [
+            [new IPv4([192, 0, 0, 0]), 24],
+            [new IPv4([192, 0, 2, 0]), 24],
+            [new IPv4([192, 88, 99, 0]), 24],
+            [new IPv4([198, 18, 0, 0]), 15],
+            [new IPv4([198, 51, 100, 0]), 24],
+            [new IPv4([203, 0, 113, 0]), 24],
+            [new IPv4([240, 0, 0, 0]), 4]
+          ],
+          // RFC7534, RFC7535
+          as112: [
+            [new IPv4([192, 175, 48, 0]), 24],
+            [new IPv4([192, 31, 196, 0]), 24]
+          ],
+          // RFC7450
+          amt: [
+            [new IPv4([192, 52, 193, 0]), 24]
+          ]
+        };
+        IPv4.prototype.kind = function() {
+          return "ipv4";
+        };
+        IPv4.prototype.match = function(other, cidrRange) {
+          let ref;
+          if (cidrRange === void 0) {
+            ref = other;
+            other = ref[0];
+            cidrRange = ref[1];
+          }
+          if (other.kind() !== "ipv4") {
+            throw new Error("ipaddr: cannot match ipv4 address with non-ipv4 one");
+          }
+          return matchCIDR(this.octets, other.octets, 8, cidrRange);
+        };
+        IPv4.prototype.prefixLengthFromSubnetMask = function() {
+          let cidr = 0;
+          let stop = false;
+          const zerotable = {
+            0: 8,
+            128: 7,
+            192: 6,
+            224: 5,
+            240: 4,
+            248: 3,
+            252: 2,
+            254: 1,
+            255: 0
+          };
+          let i, octet, zeros;
+          for (i = 3; i >= 0; i -= 1) {
+            octet = this.octets[i];
+            if (octet in zerotable) {
+              zeros = zerotable[octet];
+              if (stop && zeros !== 0) {
+                return null;
+              }
+              if (zeros !== 8) {
+                stop = true;
+              }
+              cidr += zeros;
+            } else {
+              return null;
+            }
+          }
+          return 32 - cidr;
+        };
+        IPv4.prototype.range = function() {
+          return ipaddr2.subnetMatch(this, this.SpecialRanges);
+        };
+        IPv4.prototype.toByteArray = function() {
+          return this.octets.slice(0);
+        };
+        IPv4.prototype.toIPv4MappedAddress = function() {
+          return ipaddr2.IPv6.parse(`::ffff:${this.toString()}`);
+        };
+        IPv4.prototype.toNormalizedString = function() {
+          return this.toString();
+        };
+        IPv4.prototype.toString = function() {
+          return this.octets.join(".");
+        };
+        return IPv4;
+      })();
+      ipaddr2.IPv4.broadcastAddressFromCIDR = function(string) {
+        try {
+          const cidr = this.parseCIDR(string);
+          const ipInterfaceOctets = cidr[0].toByteArray();
+          const subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+          const octets = [];
+          let i = 0;
+          while (i < 4) {
+            octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255);
+            i++;
+          }
+          return new this(octets);
+        } catch (e) {
+          throw new Error("ipaddr: the address does not have IPv4 CIDR format");
+        }
+      };
+      ipaddr2.IPv4.isIPv4 = function(string) {
+        return this.parser(string) !== null;
+      };
+      ipaddr2.IPv4.isValid = function(string) {
+        try {
+          new this(this.parser(string));
+          return true;
+        } catch (e) {
+          return false;
+        }
+      };
+      ipaddr2.IPv4.isValidCIDR = function(string) {
+        try {
+          this.parseCIDR(string);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      };
+      ipaddr2.IPv4.isValidFourPartDecimal = function(string) {
+        if (ipaddr2.IPv4.isValid(string) && string.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) {
+          return true;
+        } else {
+          return false;
+        }
+      };
+      ipaddr2.IPv4.networkAddressFromCIDR = function(string) {
+        let cidr, i, ipInterfaceOctets, octets, subnetMaskOctets;
+        try {
+          cidr = this.parseCIDR(string);
+          ipInterfaceOctets = cidr[0].toByteArray();
+          subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+          octets = [];
+          i = 0;
+          while (i < 4) {
+            octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10));
+            i++;
+          }
+          return new this(octets);
+        } catch (e) {
+          throw new Error("ipaddr: the address does not have IPv4 CIDR format");
+        }
+      };
+      ipaddr2.IPv4.parse = function(string) {
+        const parts = this.parser(string);
+        if (parts === null) {
+          throw new Error("ipaddr: string is not formatted like an IPv4 Address");
+        }
+        return new this(parts);
+      };
+      ipaddr2.IPv4.parseCIDR = function(string) {
+        let match;
+        if (match = string.match(/^(.+)\/(\d+)$/)) {
+          const maskLength = parseInt(match[2]);
+          if (maskLength >= 0 && maskLength <= 32) {
+            const parsed = [this.parse(match[1]), maskLength];
+            Object.defineProperty(parsed, "toString", {
+              value: function() {
+                return this.join("/");
+              }
+            });
+            return parsed;
+          }
+        }
+        throw new Error("ipaddr: string is not formatted like an IPv4 CIDR range");
+      };
+      ipaddr2.IPv4.parser = function(string) {
+        let match, part, value;
+        if (match = string.match(ipv4Regexes.fourOctet)) {
+          return (function() {
+            const ref = match.slice(1, 6);
+            const results = [];
+            for (let i = 0; i < ref.length; i++) {
+              part = ref[i];
+              results.push(parseIntAuto(part));
+            }
+            return results;
+          })();
+        } else if (match = string.match(ipv4Regexes.longValue)) {
+          value = parseIntAuto(match[1]);
+          if (value > 4294967295 || value < 0) {
+            throw new Error("ipaddr: address outside defined range");
+          }
+          return (function() {
+            const results = [];
+            let shift;
+            for (shift = 0; shift <= 24; shift += 8) {
+              results.push(value >> shift & 255);
+            }
+            return results;
+          })().reverse();
+        } else if (match = string.match(ipv4Regexes.twoOctet)) {
+          return (function() {
+            const ref = match.slice(1, 4);
+            const results = [];
+            value = parseIntAuto(ref[1]);
+            if (value > 16777215 || value < 0) {
+              throw new Error("ipaddr: address outside defined range");
+            }
+            results.push(parseIntAuto(ref[0]));
+            results.push(value >> 16 & 255);
+            results.push(value >> 8 & 255);
+            results.push(value & 255);
+            return results;
+          })();
+        } else if (match = string.match(ipv4Regexes.threeOctet)) {
+          return (function() {
+            const ref = match.slice(1, 5);
+            const results = [];
+            value = parseIntAuto(ref[2]);
+            if (value > 65535 || value < 0) {
+              throw new Error("ipaddr: address outside defined range");
+            }
+            results.push(parseIntAuto(ref[0]));
+            results.push(parseIntAuto(ref[1]));
+            results.push(value >> 8 & 255);
+            results.push(value & 255);
+            return results;
+          })();
+        } else {
+          return null;
+        }
+      };
+      ipaddr2.IPv4.subnetMaskFromPrefixLength = function(prefix) {
+        prefix = parseInt(prefix);
+        if (prefix < 0 || prefix > 32) {
+          throw new Error("ipaddr: invalid IPv4 prefix length");
+        }
+        const octets = [0, 0, 0, 0];
+        let j = 0;
+        const filledOctetCount = Math.floor(prefix / 8);
+        while (j < filledOctetCount) {
+          octets[j] = 255;
+          j++;
+        }
+        if (filledOctetCount < 4) {
+          octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - prefix % 8;
+        }
+        return new this(octets);
+      };
+      ipaddr2.IPv6 = (function() {
+        function IPv6(parts, zoneId) {
+          let i, part;
+          if (parts.length === 16) {
+            this.parts = [];
+            for (i = 0; i <= 14; i += 2) {
+              this.parts.push(parts[i] << 8 | parts[i + 1]);
+            }
+          } else if (parts.length === 8) {
+            this.parts = parts;
+          } else {
+            throw new Error("ipaddr: ipv6 part count should be 8 or 16");
+          }
+          for (i = 0; i < this.parts.length; i++) {
+            part = this.parts[i];
+            if (!(0 <= part && part <= 65535)) {
+              throw new Error("ipaddr: ipv6 part should fit in 16 bits");
+            }
+          }
+          if (zoneId) {
+            this.zoneId = zoneId;
+          }
+        }
+        IPv6.prototype.SpecialRanges = {
+          // RFC4291, here and after
+          unspecified: [new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128],
+          linkLocal: [new IPv6([65152, 0, 0, 0, 0, 0, 0, 0]), 10],
+          multicast: [new IPv6([65280, 0, 0, 0, 0, 0, 0, 0]), 8],
+          loopback: [new IPv6([0, 0, 0, 0, 0, 0, 0, 1]), 128],
+          uniqueLocal: [new IPv6([64512, 0, 0, 0, 0, 0, 0, 0]), 7],
+          ipv4Mapped: [new IPv6([0, 0, 0, 0, 0, 65535, 0, 0]), 96],
+          // RFC6666
+          discard: [new IPv6([256, 0, 0, 0, 0, 0, 0, 0]), 64],
+          // RFC6145
+          rfc6145: [new IPv6([0, 0, 0, 0, 65535, 0, 0, 0]), 96],
+          // RFC6052
+          rfc6052: [new IPv6([100, 65435, 0, 0, 0, 0, 0, 0]), 96],
+          // RFC3056
+          "6to4": [new IPv6([8194, 0, 0, 0, 0, 0, 0, 0]), 16],
+          // RFC6052, RFC6146
+          teredo: [new IPv6([8193, 0, 0, 0, 0, 0, 0, 0]), 32],
+          // RFC5180
+          benchmarking: [new IPv6([8193, 2, 0, 0, 0, 0, 0, 0]), 48],
+          // RFC7450
+          amt: [new IPv6([8193, 3, 0, 0, 0, 0, 0, 0]), 32],
+          as112v6: [
+            [new IPv6([8193, 4, 274, 0, 0, 0, 0, 0]), 48],
+            [new IPv6([9760, 79, 32768, 0, 0, 0, 0, 0]), 48]
+          ],
+          deprecated: [new IPv6([8193, 16, 0, 0, 0, 0, 0, 0]), 28],
+          orchid2: [new IPv6([8193, 32, 0, 0, 0, 0, 0, 0]), 28],
+          droneRemoteIdProtocolEntityTags: [new IPv6([8193, 48, 0, 0, 0, 0, 0, 0]), 28],
+          reserved: [
+            // RFC3849
+            [new IPv6([8193, 0, 0, 0, 0, 0, 0, 0]), 23],
+            // RFC2928
+            [new IPv6([8193, 3512, 0, 0, 0, 0, 0, 0]), 32]
+          ]
+        };
+        IPv6.prototype.isIPv4MappedAddress = function() {
+          return this.range() === "ipv4Mapped";
+        };
+        IPv6.prototype.kind = function() {
+          return "ipv6";
+        };
+        IPv6.prototype.match = function(other, cidrRange) {
+          let ref;
+          if (cidrRange === void 0) {
+            ref = other;
+            other = ref[0];
+            cidrRange = ref[1];
+          }
+          if (other.kind() !== "ipv6") {
+            throw new Error("ipaddr: cannot match ipv6 address with non-ipv6 one");
+          }
+          return matchCIDR(this.parts, other.parts, 16, cidrRange);
+        };
+        IPv6.prototype.prefixLengthFromSubnetMask = function() {
+          let cidr = 0;
+          let stop = false;
+          const zerotable = {
+            0: 16,
+            32768: 15,
+            49152: 14,
+            57344: 13,
+            61440: 12,
+            63488: 11,
+            64512: 10,
+            65024: 9,
+            65280: 8,
+            65408: 7,
+            65472: 6,
+            65504: 5,
+            65520: 4,
+            65528: 3,
+            65532: 2,
+            65534: 1,
+            65535: 0
+          };
+          let part, zeros;
+          for (let i = 7; i >= 0; i -= 1) {
+            part = this.parts[i];
+            if (part in zerotable) {
+              zeros = zerotable[part];
+              if (stop && zeros !== 0) {
+                return null;
+              }
+              if (zeros !== 16) {
+                stop = true;
+              }
+              cidr += zeros;
+            } else {
+              return null;
+            }
+          }
+          return 128 - cidr;
+        };
+        IPv6.prototype.range = function() {
+          return ipaddr2.subnetMatch(this, this.SpecialRanges);
+        };
+        IPv6.prototype.toByteArray = function() {
+          let part;
+          const bytes = [];
+          const ref = this.parts;
+          for (let i = 0; i < ref.length; i++) {
+            part = ref[i];
+            bytes.push(part >> 8);
+            bytes.push(part & 255);
+          }
+          return bytes;
+        };
+        IPv6.prototype.toFixedLengthString = function() {
+          const addr = (function() {
+            const results = [];
+            for (let i = 0; i < this.parts.length; i++) {
+              results.push(padPart(this.parts[i].toString(16), 4));
+            }
+            return results;
+          }).call(this).join(":");
+          let suffix = "";
+          if (this.zoneId) {
+            suffix = `%${this.zoneId}`;
+          }
+          return addr + suffix;
+        };
+        IPv6.prototype.toIPv4Address = function() {
+          if (!this.isIPv4MappedAddress()) {
+            throw new Error("ipaddr: trying to convert a generic ipv6 address to ipv4");
+          }
+          const ref = this.parts.slice(-2);
+          const high = ref[0];
+          const low = ref[1];
+          return new ipaddr2.IPv4([high >> 8, high & 255, low >> 8, low & 255]);
+        };
+        IPv6.prototype.toNormalizedString = function() {
+          const addr = (function() {
+            const results = [];
+            for (let i = 0; i < this.parts.length; i++) {
+              results.push(this.parts[i].toString(16));
+            }
+            return results;
+          }).call(this).join(":");
+          let suffix = "";
+          if (this.zoneId) {
+            suffix = `%${this.zoneId}`;
+          }
+          return addr + suffix;
+        };
+        IPv6.prototype.toRFC5952String = function() {
+          const regex = /((^|:)(0(:|$)){2,})/g;
+          const string = this.toNormalizedString();
+          let bestMatchIndex = 0;
+          let bestMatchLength = -1;
+          let match;
+          while (match = regex.exec(string)) {
+            if (match[0].length > bestMatchLength) {
+              bestMatchIndex = match.index;
+              bestMatchLength = match[0].length;
+            }
+          }
+          if (bestMatchLength < 0) {
+            return string;
+          }
+          return `${string.substring(0, bestMatchIndex)}::${string.substring(bestMatchIndex + bestMatchLength)}`;
+        };
+        IPv6.prototype.toString = function() {
+          return this.toRFC5952String();
+        };
+        return IPv6;
+      })();
+      ipaddr2.IPv6.broadcastAddressFromCIDR = function(string) {
+        try {
+          const cidr = this.parseCIDR(string);
+          const ipInterfaceOctets = cidr[0].toByteArray();
+          const subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+          const octets = [];
+          let i = 0;
+          while (i < 16) {
+            octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255);
+            i++;
+          }
+          return new this(octets);
+        } catch (e) {
+          throw new Error(`ipaddr: the address does not have IPv6 CIDR format (${e})`);
+        }
+      };
+      ipaddr2.IPv6.isIPv6 = function(string) {
+        return this.parser(string) !== null;
+      };
+      ipaddr2.IPv6.isValid = function(string) {
+        if (typeof string === "string" && string.indexOf(":") === -1) {
+          return false;
+        }
+        try {
+          const addr = this.parser(string);
+          new this(addr.parts, addr.zoneId);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      };
+      ipaddr2.IPv6.isValidCIDR = function(string) {
+        if (typeof string === "string" && string.indexOf(":") === -1) {
+          return false;
+        }
+        try {
+          this.parseCIDR(string);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      };
+      ipaddr2.IPv6.networkAddressFromCIDR = function(string) {
+        let cidr, i, ipInterfaceOctets, octets, subnetMaskOctets;
+        try {
+          cidr = this.parseCIDR(string);
+          ipInterfaceOctets = cidr[0].toByteArray();
+          subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+          octets = [];
+          i = 0;
+          while (i < 16) {
+            octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10));
+            i++;
+          }
+          return new this(octets);
+        } catch (e) {
+          throw new Error(`ipaddr: the address does not have IPv6 CIDR format (${e})`);
+        }
+      };
+      ipaddr2.IPv6.parse = function(string) {
+        const addr = this.parser(string);
+        if (addr.parts === null) {
+          throw new Error("ipaddr: string is not formatted like an IPv6 Address");
+        }
+        return new this(addr.parts, addr.zoneId);
+      };
+      ipaddr2.IPv6.parseCIDR = function(string) {
+        let maskLength, match, parsed;
+        if (match = string.match(/^(.+)\/(\d+)$/)) {
+          maskLength = parseInt(match[2]);
+          if (maskLength >= 0 && maskLength <= 128) {
+            parsed = [this.parse(match[1]), maskLength];
+            Object.defineProperty(parsed, "toString", {
+              value: function() {
+                return this.join("/");
+              }
+            });
+            return parsed;
+          }
+        }
+        throw new Error("ipaddr: string is not formatted like an IPv6 CIDR range");
+      };
+      ipaddr2.IPv6.parser = function(string) {
+        let addr, i, match, octet, octets, zoneId;
+        if (match = string.match(ipv6Regexes.deprecatedTransitional)) {
+          return this.parser(`::ffff:${match[1]}`);
+        }
+        if (ipv6Regexes.native.test(string)) {
+          return expandIPv6(string, 8);
+        }
+        if (match = string.match(ipv6Regexes.transitional)) {
+          zoneId = match[6] || "";
+          addr = match[1];
+          if (!match[1].endsWith("::")) {
+            addr = addr.slice(0, -1);
+          }
+          addr = expandIPv6(addr + zoneId, 6);
+          if (addr.parts) {
+            octets = [
+              parseInt(match[2]),
+              parseInt(match[3]),
+              parseInt(match[4]),
+              parseInt(match[5])
+            ];
+            for (i = 0; i < octets.length; i++) {
+              octet = octets[i];
+              if (!(0 <= octet && octet <= 255)) {
+                return null;
+              }
+            }
+            addr.parts.push(octets[0] << 8 | octets[1]);
+            addr.parts.push(octets[2] << 8 | octets[3]);
+            return {
+              parts: addr.parts,
+              zoneId: addr.zoneId
+            };
+          }
+        }
+        return null;
+      };
+      ipaddr2.IPv6.subnetMaskFromPrefixLength = function(prefix) {
+        prefix = parseInt(prefix);
+        if (prefix < 0 || prefix > 128) {
+          throw new Error("ipaddr: invalid IPv6 prefix length");
+        }
+        const octets = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        let j = 0;
+        const filledOctetCount = Math.floor(prefix / 8);
+        while (j < filledOctetCount) {
+          octets[j] = 255;
+          j++;
+        }
+        if (filledOctetCount < 16) {
+          octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - prefix % 8;
+        }
+        return new this(octets);
+      };
+      ipaddr2.fromByteArray = function(bytes) {
+        const length = bytes.length;
+        if (length === 4) {
+          return new ipaddr2.IPv4(bytes);
+        } else if (length === 16) {
+          return new ipaddr2.IPv6(bytes);
+        } else {
+          throw new Error("ipaddr: the binary input is neither an IPv6 nor IPv4 address");
+        }
+      };
+      ipaddr2.isValid = function(string) {
+        return ipaddr2.IPv6.isValid(string) || ipaddr2.IPv4.isValid(string);
+      };
+      ipaddr2.isValidCIDR = function(string) {
+        return ipaddr2.IPv6.isValidCIDR(string) || ipaddr2.IPv4.isValidCIDR(string);
+      };
+      ipaddr2.parse = function(string) {
+        if (ipaddr2.IPv6.isValid(string)) {
+          return ipaddr2.IPv6.parse(string);
+        } else if (ipaddr2.IPv4.isValid(string)) {
+          return ipaddr2.IPv4.parse(string);
+        } else {
+          throw new Error("ipaddr: the address has neither IPv6 nor IPv4 format");
+        }
+      };
+      ipaddr2.parseCIDR = function(string) {
+        try {
+          return ipaddr2.IPv6.parseCIDR(string);
+        } catch (e) {
+          try {
+            return ipaddr2.IPv4.parseCIDR(string);
+          } catch (e2) {
+            throw new Error("ipaddr: the address has neither IPv6 nor IPv4 CIDR format");
+          }
+        }
+      };
+      ipaddr2.process = function(string) {
+        const addr = this.parse(string);
+        if (addr.kind() === "ipv6" && addr.isIPv4MappedAddress()) {
+          return addr.toIPv4Address();
+        } else {
+          return addr;
+        }
+      };
+      ipaddr2.subnetMatch = function(address, rangeList, defaultName) {
+        let i, rangeName, rangeSubnets, subnet;
+        if (defaultName === void 0 || defaultName === null) {
+          defaultName = "unicast";
+        }
+        for (rangeName in rangeList) {
+          if (Object.prototype.hasOwnProperty.call(rangeList, rangeName)) {
+            rangeSubnets = rangeList[rangeName];
+            if (rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)) {
+              rangeSubnets = [rangeSubnets];
+            }
+            for (i = 0; i < rangeSubnets.length; i++) {
+              subnet = rangeSubnets[i];
+              if (address.kind() === subnet[0].kind() && address.match.apply(address, subnet)) {
+                return rangeName;
+              }
+            }
+          }
+        }
+        return defaultName;
+      };
+      if (typeof module2 !== "undefined" && module2.exports) {
+        module2.exports = ipaddr2;
+      } else {
+        root.ipaddr = ipaddr2;
+      }
+    })(exports);
+  }
+});
+var src_exports = {};
+__export2(src_exports, {
+  activate: () => activate
+});
+var operations = [
+  "toast.show",
+  "message.show",
+  "message.update",
+  "interaction.close",
+  "interaction.list",
+  "interaction.respond",
+  "interaction.action",
+  "dialog.alert",
+  "dialog.confirm",
+  "dialog.prompt",
+  "picker.directory",
+  "picker.files",
+  "tasks.submit",
+  "tasks.list",
+  "tasks.snapshot",
+  "tasks.cancel",
+  "tasks.result",
+  "notification.publish",
+  "notification.update"
+];
+function publicCommandId(operation) {
+  if (!operations.includes(operation))
+    throw new Error("Unknown public command operation");
+  return operation.startsWith("interaction.") ? `pal.host.${operation}` : `pal.${operation}`;
+}
+var PUBLIC_COMMAND_DEFINITIONS = operations.map((operation) => ({
+  id: publicCommandId(operation),
+  title: operation,
+  visibility: "public",
+  // These operations do not themselves modify workspace files. Task targets are
+  // admitted independently with the inherited read-only policy and permission budget.
+  readOnly: true,
+  requiredPermissions: operation.startsWith("notification.") ? ["pal.notifications.show"] : [],
+  inputSchema: { type: "object" }
+}));
+var FRONTEND_COMMAND_DEFINITIONS = [
+  "context",
+  "set-theme",
+  "list-models",
+  "pick-workspace-directory",
+  "focus-composer-draft",
+  "request-conversation",
+  "materials-upload",
+  "materials-resolve",
+  "materials-extract",
+  "extract-conversation-attachment",
+  "focus-conversation-message",
+  "copy-text",
+  "open-settings",
+  "open-conversation",
+  "settings",
+  "open-panel",
+  "open-file"
+].map((operation) => ({
+  id: `pal.frontend.${operation}`,
+  title: operation,
+  visibility: "public",
+  readOnly: !["set-theme", "request-conversation", "settings"].includes(
+    operation
+  ),
+  requiredPermissions: operation === "extract-conversation-attachment" ? ["pal.history.read"] : operation === "copy-text" ? ["pal.clipboard.write"] : [],
+  inputSchema: {
+    type: "object",
+    properties: { args: { type: "array", maxItems: 8 } },
+    required: ["args"],
+    additionalProperties: false
+  }
+}));
+var PLUGIN_UI_MAX_EXPLICIT_CHARS = 32 * 1024 * 1024;
+var PLUGIN_UI_MAX_TRANSPORT_CHARS = 2 * PLUGIN_UI_MAX_EXPLICIT_CHARS + 16384;
+function normalizeLocale(locale) {
+  if (!locale) return void 0;
+  try {
+    return Intl.getCanonicalLocales(locale.replaceAll("_", "-"))[0];
+  } catch {
+    return void 0;
+  }
+}
+function localeFallbacks(locale) {
+  const full = normalizeLocale(locale);
+  return [.../* @__PURE__ */ new Set([...full ? [full, full.split("-")[0]] : [], "en"])];
+}
+var NETWORK_PROXY_SCHEMES = [
+  "http",
+  "https",
+  "socks",
+  "socks5",
+  "socks5h"
+];
+var SCHEME_SET = new Set(NETWORK_PROXY_SCHEMES);
+var HOST_CAPABILITIES = {
+  ...Object.fromEntries(
+    FRONTEND_COMMAND_DEFINITIONS.map((definition) => [definition.id, 1])
+  ),
+  ...Object.fromEntries(
+    PUBLIC_COMMAND_DEFINITIONS.map((definition) => [definition.id, 1])
+  ),
+  "pal.plugin.tools.workspaceEffects": 1,
+  "pal.plugin.promptSections": 1,
+  "pal.plugin.providers.approval": 1,
+  "pal.plugin.browser.navigation": 1,
+  "pal.frontend.webPreview.tabs": 2,
+  "pal.frontend.webPreview.contextMenu": 2,
+  "pal.frontend.webPreview.pageTools": 1,
+  "pal.command.settings": 1,
+  "pal.command.accountMenu": 1,
+  "pal.command.accountMenu.dynamic": 1,
+  "pal.plugin.process.commands": 2,
+  "pal.plugin.runChanges.commands": 1,
+  "pal.context.command": 1,
+  "pal.context.processPort": 1,
+  "pal.context.notification": 1,
+  "pal.toast.show": 1,
+  "pal.message.show": 1,
+  "pal.dialog.alert": 1,
+  "pal.dialog.confirm": 1,
+  "pal.dialog.prompt": 1,
+  "pal.picker.directory": 1,
+  "pal.picker.files": 1,
+  "pal.notification.publish": 1,
+  "pal.notification.update": 1,
+  "pal.tasks.submit": 1,
+  "pal.tasks.list": 1,
+  "pal.tasks.get": 1,
+  "pal.interactions": 1,
+  "pal.tasks": 1,
+  "pal.context.public": 1,
+  "pal.frontend.toast": 1,
+  "pal.frontend.message": 1,
+  "pal.frontend.dialog": 1,
+  "pal.frontend.picker": 1,
+  "pal.frontend.tasks": 1,
+  "pal.frontend.notification": 1,
+  "pal.extension.ui.panel": 1,
+  "pal.plugin.hostPanel": 1,
+  "pal.plugin.hostPanel.message": 2,
+  "pal.plugin.hostPanel.workspace": 1,
+  "pal.plugin.hostPanel.terminal": 1,
+  "pal.plugin.hostPanel.webPreview": 2,
+  "pal.frontend.webPreview.annotations": 2,
+  "pal.frontend.webPreview.extensions": 3,
+  "pal.plugin.hostPanel.overlays": 1,
+  "pal.plugin.hostPanel.menu.controls": 1,
+  "pal.plugin.hostPanel.menu.content": 1,
+  "pal.command.execute": 1,
+  "pal.ui.command.execute": 1,
+  "pal.ui.audio.prepareCommand": 1,
+  "pal.frontend.command.isAvailable": 1,
+  "pal.host.files.navigation": 1,
+  "pal.frontend.terminal.lifecycle": 1,
+  "pal.command.callable": 1,
+  "pal.plugin.providers": 1,
+  "pal.frontend.providers": 1,
+  "pal.frontend.services": 1,
+  "pal.frontend.httpRoutes": 1,
+  "pal.command.dispatch": 1,
+  "pal.plugin.slots": 1,
+  "pal.plugin.declarations": 2,
+  "pal.plugin.files.commands": 8,
+  "pal.permission.clipboard.write": 1,
+  "pal.permission.fs.read": 1,
+  "pal.permission.fs.write": 1,
+  "pal.permission.desktop.windows": 1,
+  "pal.context.desktopWindows": 1,
+  "pal.context.desktopWindows.open": 1,
+  "pal.plugin.api": 1,
+  "pal.plugin.lightweight": 1,
+  "pal.frontend.workspace.current": 1,
+  "pal.frontend.workspace.readDirectory": 1,
+  "pal.permission.host.inject": 1,
+  "pal.permission.prompts.read": 1,
+  "pal.permission.prompts.write": 1,
+  "pal.permission.plugins.manage": 1,
+  "pal.permission.history.read": 1,
+  "pal.permission.history.write": 1,
+  "pal.permission.app-workspaces.read": 1,
+  "pal.permission.app-workspaces.write": 1,
+  "pal.permission.runs.observe": 1,
+  "pal.permission.tools.intercept": 1,
+  "pal.permission.notifications.show": 1,
+  "pal.permission.runs.schedule": 1,
+  "pal.permission.runs.delegate": 1,
+  "pal.permission.models.generate": 1,
+  "pal.permission.models.background": 1,
+  "pal.context.models": 1,
+  "pal.permission.audio.record": 1,
+  "pal.permission.process.spawn": 1,
+  "pal.permission.network.fetch": 1,
+  "pal.permission.browser.control": 1,
+  "pal.permission.storage.read": 1,
+  "pal.permission.storage.write": 1,
+  "pal.extension.ui.workbench": 1,
+  "pal.extension.conversation.before-composer": 1,
+  "pal.extension.conversation.header": 1,
+  "pal.extension.conversation.composer": 1,
+  "pal.extension.conversation.composer.dock": 1,
+  "pal.extension.sidebar.footer.action": 1,
+  "pal.extension.settings.general.item": 1,
+  "pal.extension.settings.theme.item": 1,
+  "pal.extension.composer.environment": 1,
+  "pal.extension.conversation.stage": 1,
+  "pal.extension.window.overlay": 1,
+  "pal.extension.tool.result": 1,
+  "pal.extension.tool.approval": 1,
+  "pal.extension.ui.settings": 1,
+  "pal.context.scopeSignal": 1,
+  "pal.context.services": 1,
+  "pal.context.serviceEvents": 1,
+  "pal.context.resourcePath": 1,
+  "pal.context.localData": 1,
+  "pal.context.localData.getSecret": 1,
+  "pal.context.localData.hasSecret": 1,
+  "pal.context.localData.setSecret": 1,
+  "pal.context.localData.deleteSecret": 1,
+  "pal.connections.tasks": 1,
+  "pal.resources.images": 1,
+  "pal.context.webPages": 1,
+  "pal.context.panels": 1,
+  "pal.context.config": 1,
+  "pal.context.invalidateUi": 1,
+  "pal.context.runBackground": 1,
+  "pal.context.signal": 1,
+  "pal.context.pluginId": 1,
+  "pal.context.storagePath": 1,
+  "pal.context.grantedPermissions": 1,
+  "pal.context.promptDocuments": 1,
+  "pal.context.localData.protect": 1,
+  "pal.context.localData.unprotect": 1,
+  "pal.context.localData.cookies": 1,
+  "pal.context.localData.setCookie": 1,
+  "pal.context.webPages.execute": 1,
+  "pal.context.panels.open": 1,
+  "pal.context.panels.close": 1,
+  "pal.context.config.read": 1,
+  "pal.context.promptDocuments.inspect": 1
+};
+var HOST_CAPABILITY_RELEASES = Object.fromEntries(
+  Object.entries(HOST_CAPABILITIES).map(([id2, revision]) => [
+    id2,
+    Object.fromEntries(
+      Array.from({ length: revision }, (_, index) => [index + 1, null])
+    )
+  ])
+);
+var FILE_COMMAND_DEFINITIONS = [
+  "read",
+  "write"
+].map((operation) => ({
+  id: `pal.fs.${operation}`,
+  title: operation === "read" ? "\u8BFB\u53D6\u6587\u4EF6" : "\u4FEE\u6539\u6587\u4EF6",
+  visibility: "public",
+  readOnly: operation === "read",
+  requiredPermissions: [`pal.fs.${operation}`],
+  inputSchema: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      operation: {
+        type: "string",
+        enum: operation === "read" ? [
+          "read",
+          "stat",
+          "lstat",
+          "readlink",
+          "realpath",
+          "list",
+          "directory",
+          "readVersion",
+          "preview",
+          "readChunk",
+          "watch",
+          "snapshot"
+        ] : [
+          "save",
+          "create",
+          "mkdir",
+          "rename",
+          "remove",
+          "writeVersion",
+          "copyFile",
+          "commit"
+        ]
+      },
+      path: { type: "string", minLength: 1, maxLength: 4096 },
+      offset: { type: "integer", minimum: 0, maximum: Number.MAX_SAFE_INTEGER },
+      length: { type: "integer", minimum: 1, maximum: 1048576 },
+      target: { type: "string", minLength: 1, maxLength: 4096 },
+      content: { type: "string", maxLength: 10485760 },
+      encoding: { type: "string", enum: ["utf8", "base64"] },
+      maxBytes: { type: "integer", minimum: 1, maximum: 2097152 },
+      maxEntries: { type: "integer", minimum: 1, maximum: 5e4 },
+      expectedIdentity: { type: "string", maxLength: 2048 },
+      changes: {
+        type: "array",
+        minItems: 1,
+        maxItems: 16,
+        items: {
+          type: "object",
+          additionalProperties: false,
+          required: ["path", "expectedVersion", "content"],
+          properties: {
+            path: { type: "string", minLength: 1, maxLength: 4096 },
+            expectedVersion: { type: ["string", "null"], maxLength: 4096 },
+            content: { type: "string", maxLength: 2796204 }
+          }
+        }
+      },
+      observed: {
+        type: "array",
+        maxItems: 16,
+        items: {
+          type: "object",
+          additionalProperties: false,
+          required: ["path", "expectedVersion"],
+          properties: {
+            path: { type: "string", minLength: 1, maxLength: 4096 },
+            expectedVersion: { type: ["string", "null"], maxLength: 4096 }
+          }
+        }
+      },
+      cursor: { type: "string", maxLength: 100 },
+      expectedVersion: {}
+    },
+    required: ["path"]
+  }
+}));
+var entries = [
+  [
+    "pal.fs.read",
+    "Read files",
+    "\u8BFB\u53D6\u6587\u4EF6",
+    "Read approved files and directories",
+    "\u8BFB\u53D6\u5DF2\u6279\u51C6\u7684\u6587\u4EF6\u548C\u76EE\u5F55",
+    "read",
+    "filesystem"
+  ],
+  [
+    "pal.fs.write",
+    "Modify files",
+    "\u4FEE\u6539\u6587\u4EF6",
+    "Create, save, rename and remove files in an approved area",
+    "\u5728\u5DF2\u6279\u51C6\u8303\u56F4\u5185\u521B\u5EFA\u3001\u4FDD\u5B58\u3001\u91CD\u547D\u540D\u548C\u5220\u9664\u6587\u4EF6",
+    "write",
+    "filesystem"
+  ],
+  [
+    "pal.clipboard.write",
+    "Write clipboard",
+    "\u5199\u5165\u526A\u8D34\u677F",
+    "Copy text to the system clipboard",
+    "\u5C06\u6587\u672C\u590D\u5236\u5230\u7CFB\u7EDF\u526A\u8D34\u677F",
+    "write",
+    "global"
+  ],
+  [
+    "pal.history.read",
+    "Read conversations",
+    "\u8BFB\u53D6\u4F1A\u8BDD",
+    "Read project conversations and messages",
+    "\u8BFB\u53D6\u9879\u76EE\u4F1A\u8BDD\u548C\u6D88\u606F",
+    "read",
+    "project"
+  ],
+  [
+    "pal.history.write",
+    "Modify conversations",
+    "\u4FEE\u6539\u4F1A\u8BDD",
+    "Create or change conversation data",
+    "\u521B\u5EFA\u6216\u4FEE\u6539\u4F1A\u8BDD\u6570\u636E",
+    "write",
+    "project"
+  ],
+  [
+    "pal.runs.observe",
+    "Observe runs",
+    "\u89C2\u5BDF\u8FD0\u884C",
+    "Receive run and tool activity",
+    "\u63A5\u6536\u8FD0\u884C\u548C\u5DE5\u5177\u6D3B\u52A8",
+    "observe",
+    "project"
+  ],
+  [
+    "pal.prompts.read",
+    "Read prompts",
+    "\u8BFB\u53D6\u63D0\u793A\u8BCD",
+    "Read available prompt content",
+    "\u8BFB\u53D6\u53EF\u7528\u7684\u63D0\u793A\u8BCD\u5185\u5BB9",
+    "read",
+    "project"
+  ],
+  [
+    "pal.prompts.write",
+    "Modify prompts",
+    "\u4FEE\u6539\u63D0\u793A\u8BCD",
+    "Create or change prompt content",
+    "\u521B\u5EFA\u6216\u4FEE\u6539\u63D0\u793A\u8BCD\u5185\u5BB9",
+    "write",
+    "project"
+  ],
+  [
+    "pal.storage.read",
+    "Read storage",
+    "\u8BFB\u53D6\u5B58\u50A8",
+    "Read plugin storage",
+    "\u8BFB\u53D6\u63D2\u4EF6\u5B58\u50A8",
+    "read",
+    "global"
+  ],
+  [
+    "pal.storage.write",
+    "Write storage",
+    "\u5199\u5165\u5B58\u50A8",
+    "Change plugin storage",
+    "\u4FEE\u6539\u63D2\u4EF6\u5B58\u50A8",
+    "write",
+    "global"
+  ],
+  [
+    "pal.network.fetch",
+    "Network requests",
+    "\u7F51\u7EDC\u8BF7\u6C42",
+    "Send requests to external addresses",
+    "\u5411\u5916\u90E8\u5730\u5740\u53D1\u9001\u8BF7\u6C42",
+    "external",
+    "global"
+  ],
+  [
+    "pal.process.spawn",
+    "Start processes",
+    "\u542F\u52A8\u8FDB\u7A0B",
+    "Start a local process",
+    "\u542F\u52A8\u672C\u5730\u8FDB\u7A0B",
+    "execute",
+    "global"
+  ],
+  [
+    "pal.browser.control",
+    "Control browser",
+    "\u63A7\u5236\u6D4F\u89C8\u5668",
+    "Interact with browser pages",
+    "\u64CD\u4F5C\u6D4F\u89C8\u5668\u9875\u9762",
+    "execute",
+    "global"
+  ],
+  [
+    "pal.desktop.windows",
+    "Control windows",
+    "\u63A7\u5236\u7A97\u53E3",
+    "Interact with desktop windows",
+    "\u64CD\u4F5C\u684C\u9762\u7A97\u53E3",
+    "execute",
+    "global"
+  ],
+  [
+    "pal.plugins.manage",
+    "Manage plugins",
+    "\u7BA1\u7406\u63D2\u4EF6",
+    "Change plugin installation or state",
+    "\u4FEE\u6539\u63D2\u4EF6\u5B89\u88C5\u6216\u542F\u7528\u72B6\u6001",
+    "write",
+    "global"
+  ],
+  [
+    "pal.host.inject",
+    "Run host UI code",
+    "\u6CE8\u5165\u5BBF\u4E3B\u754C\u9762",
+    "Run plugin UI code in the application",
+    "\u5728\u5E94\u7528\u754C\u9762\u4E2D\u8FD0\u884C\u63D2\u4EF6\u4EE3\u7801",
+    "execute",
+    "global"
+  ],
+  [
+    "pal.tools.intercept",
+    "Intercept tools",
+    "\u62E6\u622A\u5DE5\u5177",
+    "Inspect or change tool calls",
+    "\u68C0\u67E5\u6216\u4FEE\u6539\u5DE5\u5177\u8C03\u7528",
+    "execute",
+    "project"
+  ],
+  [
+    "pal.notifications.show",
+    "Show notifications",
+    "\u663E\u793A\u901A\u77E5",
+    "Display application notifications",
+    "\u663E\u793A\u5E94\u7528\u901A\u77E5",
+    "execute",
+    "global"
+  ],
+  [
+    "pal.runs.schedule",
+    "Schedule runs",
+    "\u5B89\u6392\u8FD0\u884C",
+    "Schedule an agent run",
+    "\u5B89\u6392\u4EE3\u7406\u8FD0\u884C",
+    "execute",
+    "project"
+  ],
+  [
+    "pal.runs.delegate",
+    "Delegate runs",
+    "\u59D4\u6D3E\u8FD0\u884C",
+    "Start a delegated agent run",
+    "\u542F\u52A8\u59D4\u6D3E\u7684\u4EE3\u7406\u8FD0\u884C",
+    "execute",
+    "project"
+  ],
+  [
+    "pal.models.generate",
+    "Generate with models",
+    "\u8C03\u7528\u6A21\u578B\u751F\u6210",
+    "Request model generation",
+    "\u8BF7\u6C42\u6A21\u578B\u751F\u6210",
+    "execute",
+    "project"
+  ],
+  [
+    "pal.models.background",
+    "Use models for background work",
+    "\u540E\u53F0\u4F7F\u7528\u6A21\u578B",
+    "Use configured API models while the plugin is active",
+    "\u63D2\u4EF6\u8FD0\u884C\u671F\u95F4\u4F7F\u7528\u5DF2\u914D\u7F6E\u7684 API \u6A21\u578B",
+    "execute",
+    "global"
+  ],
+  [
+    "pal.audio.record",
+    "Record audio",
+    "\u5F55\u5236\u97F3\u9891",
+    "Capture microphone audio",
+    "\u91C7\u96C6\u9EA6\u514B\u98CE\u97F3\u9891",
+    "read",
+    "global"
+  ]
+];
+var permissionAccess = entries.map(
+  ([id2, title, zhTitle, description, zhDescription, effect, scope2]) => ({
+    id: id2,
+    title,
+    description,
+    locales: { zh: { title: zhTitle, description: zhDescription } },
+    effect,
+    scope: scope2,
+    target: { kind: "permission", id: id2 }
+  })
+);
+var BUILTIN_ACCESS_DEFINITIONS = [
+  ...permissionAccess,
+  {
+    id: "pal.files.open",
+    title: "Open a file",
+    description: "Open a file in the application",
+    locales: { zh: { title: "\u6253\u5F00\u6587\u4EF6", description: "\u5728\u5E94\u7528\u4E2D\u6253\u5F00\u6587\u4EF6" } },
+    effect: "execute",
+    scope: "project",
+    target: { kind: "command", id: "pal.files.open" }
+  },
+  {
+    id: "pal.frontend.context",
+    title: "Read page context",
+    description: "Read the current plugin page context",
+    locales: {
+      zh: { title: "\u8BFB\u53D6\u9875\u9762\u4E0A\u4E0B\u6587", description: "\u8BFB\u53D6\u5F53\u524D\u63D2\u4EF6\u9875\u9762\u4E0A\u4E0B\u6587" }
+    },
+    effect: "read",
+    scope: "global",
+    target: { kind: "command", id: "pal.frontend.context" }
+  },
+  {
+    id: "pal.frontend.settings",
+    title: "Use plugin settings",
+    description: "Read or save the plugin's settings",
+    locales: {
+      zh: { title: "\u4F7F\u7528\u63D2\u4EF6\u8BBE\u7F6E", description: "\u8BFB\u53D6\u6216\u4FDD\u5B58\u6B64\u63D2\u4EF6\u7684\u8BBE\u7F6E" }
+    },
+    effect: "execute",
+    scope: "global",
+    target: { kind: "command", id: "pal.frontend.settings" }
+  }
+];
+var id = { type: "string", minLength: 1, maxLength: 100 };
+var integer = (minimum, maximum) => ({
+  type: "integer",
+  minimum,
+  maximum
+});
+var PROCESS_COMMAND_DEFINITIONS = [
+  {
+    name: "start",
+    required: ["mode", "executable", "cwd"],
+    properties: {
+      mode: { enum: ["pipe", "pty"] },
+      executable: { type: "string", minLength: 1, maxLength: 4096 },
+      args: {
+        type: "array",
+        maxItems: 256,
+        items: { type: "string", maxLength: 262144 }
+      },
+      cwd: { type: "string", minLength: 1, maxLength: 4096 },
+      scope: { enum: ["session", "project"] },
+      lifetime: { enum: ["scope", "request"] },
+      stdin: { type: "boolean" },
+      maxBufferChars: integer(65536, 24 * 1024 * 1024),
+      stdoutEncoding: { enum: ["utf8", "base64"] },
+      env: {
+        type: "object",
+        maxProperties: 256,
+        additionalProperties: {
+          anyOf: [{ type: "string", maxLength: 32768 }, { type: "null" }]
+        }
+      },
+      timeoutMs: integer(1, 18e5),
+      cols: integer(2, 500),
+      rows: integer(1, 300)
+    }
+  },
+  {
+    name: "read",
+    required: ["processId"],
+    properties: {
+      processId: id,
+      cursor: integer(0, Number.MAX_SAFE_INTEGER),
+      maxChars: integer(1, 65536),
+      waitMs: integer(0, 1e3)
+    }
+  },
+  {
+    name: "write",
+    required: ["processId", "data"],
+    properties: { processId: id, data: { type: "string", maxLength: 65536 } }
+  },
+  {
+    name: "resize",
+    required: ["processId", "cols", "rows"],
+    properties: {
+      processId: id,
+      cols: integer(2, 500),
+      rows: integer(1, 300)
+    }
+  },
+  { name: "release", required: ["processId"], properties: { processId: id } },
+  { name: "stop", required: ["processId"], properties: { processId: id } },
+  { name: "list", required: [], properties: {} }
+].map(({ name, required, properties }) => ({
+  id: `pal.process.${name}`,
+  title: `\u8FDB\u7A0B\uFF1A${name}`,
+  visibility: "public",
+  readOnly: ["read", "list"].includes(name),
+  requiredPermissions: ["pal.process.spawn"],
+  inputSchema: {
+    type: "object",
+    additionalProperties: false,
+    required,
+    properties
+  }
+}));
+var FILE_OPEN_CAPABILITY = {
+  id: "pal.files.open",
+  version: 1,
+  title: "Open files",
+  approval: {
+    fields: [{ key: "path", label: "File", format: "workspace-path" }]
+  },
+  locales: { zh: { title: "\u6253\u5F00\u6587\u4EF6", labels: { path: "\u6587\u4EF6" } } },
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", minLength: 1, maxLength: 4096 },
+      ...Object.fromEntries(
+        ["line", "column", "endLine", "endColumn"].map((key2) => [
+          key2,
+          { type: "integer", minimum: 1, maximum: 2147483647 }
+        ])
+      )
+    },
+    required: ["path"],
+    additionalProperties: false
+  }
+};
+var import_ipaddr = __toESM2(require_ipaddr(), 1);
+var bindings = new import_node_async_hooks.AsyncLocalStorage();
+var moduleBinding;
+var sharedModule = false;
+function currentPalBinding(requireActive = true) {
+  const binding = bindings.getStore() ?? (!sharedModule ? moduleBinding : void 0);
+  if (!binding)
+    throw new Error("PAL is only available in a plugin lifecycle or callback");
+  if (requireActive) binding.context.signal.throwIfAborted();
+  return binding;
+}
+function bindPalCallbacks(value, binding, seen = /* @__PURE__ */ new WeakMap()) {
+  if (typeof value === "function") {
+    const invoke = (receiver, args) => {
+      binding.context.signal.throwIfAborted();
+      return bindings.run(binding, () => Reflect.apply(value, receiver, args));
+    };
+    return value.constructor.name === "AsyncFunction" ? async function(...args) {
+      return invoke(this, args);
+    } : function(...args) {
+      return invoke(this, args);
+    };
+  }
+  if (!value || typeof value !== "object") return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null)
+    return value;
+  if (seen.has(value)) return seen.get(value);
+  const output = Array.isArray(value) ? [] : Object.create(prototype);
+  seen.set(value, output);
+  for (const [key2, child] of Object.entries(value))
+    Object.defineProperty(output, key2, {
+      value: bindPalCallbacks(child, binding, seen),
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  return output;
+}
+function withPalRegistration(context, registration, callback) {
+  return bindings.run({ context, registration }, callback);
+}
+function bindPluginModule(module2) {
+  let active;
+  return {
+    async activate(context) {
+      if (active)
+        throw new Error(
+          "Plugin module is already activated; load a fresh entry"
+        );
+      const binding = { context };
+      if (moduleBinding && moduleBinding.context !== context)
+        sharedModule = true;
+      else moduleBinding ??= binding;
+      active = binding;
+      return bindings.run(
+        binding,
+        async () => bindPalCallbacks(
+          await module2.activate(context),
+          binding
+        )
+      );
+    },
+    ...module2.deactivate ? { deactivate: () => bindings.run(active, () => module2.deactivate()) } : {}
+  };
+}
+var publicNames = /* @__PURE__ */ new Set([
+  "toast",
+  "message",
+  "dialog",
+  "picker",
+  "tasks",
+  "notification"
+]);
+var pal = new Proxy({}, {
+  get(_target, key2) {
+    const binding = currentPalBinding(false);
+    const runtime = binding.context;
+    if ([
+      "signal",
+      "pluginId",
+      "storagePath",
+      "resourcePath",
+      "grantedPermissions"
+    ].includes(String(key2)))
+      return runtime[key2];
+    binding.context.signal.throwIfAborted();
+    const registration = binding.registration;
+    if (key2 === "command")
+      return {
+        register: (definition) => {
+          if (!binding.registration)
+            throw new Error("Commands register only during plugin setup");
+          binding.registration.command.register(
+            bindPalCallbacks(definition, binding)
+          );
+        },
+        execute: (id2, input) => {
+          binding.context.signal.throwIfAborted();
+          const client = binding.context.command?.();
+          if (!client) throw new Error("Host commands unavailable");
+          return client.execute(id2, input);
+        }
+      };
+    const source = publicNames.has(String(key2)) ? () => binding.context.public?.()?.[key2] : () => runtime[key2];
+    const item = source();
+    const extra = registration?.[key2];
+    if (item && typeof item === "object" && ![Object.prototype, null].includes(Object.getPrototypeOf(item)))
+      return item;
+    if (item && typeof item === "object" || extra && typeof extra === "object") {
+      return new Proxy(
+        {},
+        {
+          get(_object, method) {
+            binding.context.signal.throwIfAborted();
+            const api = source();
+            const registrationApi = extra;
+            const owner = registrationApi && method in registrationApi ? registrationApi : api;
+            const value = owner?.[method];
+            return typeof value === "function" ? (...args) => {
+              binding.context.signal.throwIfAborted();
+              return Reflect.apply(
+                value,
+                owner,
+                bindPalCallbacks(args, binding)
+              );
+            } : value;
+          }
+        }
+      );
+    }
+    return typeof item === "function" ? (...args) => {
+      binding.context.signal.throwIfAborted();
+      return Reflect.apply(
+        item,
+        binding.context,
+        bindPalCallbacks(args, binding)
+      );
+    } : item ?? extra;
+  },
+  set() {
+    throw new Error("PAL API is read-only");
+  }
+});
+function definePlugin(setup) {
+  return {
+    async activate(context) {
+      const commands = [];
+      const capabilities = [];
+      const providers = [];
+      const permissions = [];
+      const ui = [];
+      const kinds = [];
+      const slots = [];
+      const slotContributions = [];
+      let extras;
+      let collecting = true;
+      const check = () => {
+        if (!collecting)
+          throw new Error("Registration is only allowed during activation");
+      };
+      try {
+        const registration = {
+          context,
+          permissions: {
+            define(permission) {
+              check();
+              permissions.push(permission);
+            }
+          },
+          providers: {
+            define(value) {
+              check();
+              capabilities.push(value);
+            },
+            register(value) {
+              check();
+              providers.push(value);
+            }
+          },
+          command: {
+            register(command) {
+              check();
+              commands.push({ ...command });
+            }
+          },
+          kinds: {
+            define(kind) {
+              check();
+              kinds.push(kind);
+            }
+          },
+          slots: {
+            define(slot) {
+              check();
+              slots.push(slot);
+            },
+            contribute(contribution) {
+              check();
+              slotContributions.push(contribution);
+            }
+          },
+          ui: {
+            register(contribution) {
+              check();
+              ui.push(contribution);
+            }
+          }
+        };
+        extras = await withPalRegistration(
+          context,
+          registration,
+          () => setup(registration)
+        );
+      } finally {
+        collecting = false;
+      }
+      return {
+        ...extras,
+        permissions: [...extras?.permissions ?? [], ...permissions],
+        capabilities: [...extras?.capabilities ?? [], ...capabilities],
+        providers: [...extras?.providers ?? [], ...providers],
+        commands: [...extras?.commands ?? [], ...commands],
+        ui: [...extras?.ui ?? [], ...ui],
+        kinds: [...extras?.kinds ?? [], ...kinds],
+        slots: [...extras?.slots ?? [], ...slots],
+        slotContributions: [
+          ...extras?.slotContributions ?? [],
+          ...slotContributions
+        ]
+      };
+    }
+  };
+}
+function isRemotePath(path) {
+  return typeof path === "string" && path.startsWith("ssh://");
+}
+var sep = import_node_path.default.sep;
+var key = Symbol.for("pal.workspace-transport.v1");
+function remoteTransport() {
+  const registry = globalThis;
+  const transport = registry[key];
+  if (!transport)
+    throw new Error(
+      "SSH workspace unavailable; update the host and plugin SDK"
+    );
+  return transport;
+}
+function routed(name) {
+  return ((...args) => {
+    if (!args.some(isRemotePath)) return local[name](...args);
+    return remoteTransport().file(name, args);
+  });
+}
+var access = routed("access");
+var chmod = routed("chmod");
+var copyFile = routed("copyFile");
+var lstat = routed("lstat");
+var stat = routed("stat");
+var mkdir = routed("mkdir");
+var mkdtemp = routed("mkdtemp");
+var open = routed("open");
+var opendir = routed("opendir");
+var readdir = routed("readdir");
+var readFile = routed("readFile");
+var readlink = routed("readlink");
+var realpath = routed("realpath");
+var rename = routed("rename");
+var rm = routed("rm");
+var rmdir = routed("rmdir");
+var unlink = routed("unlink");
+var link = routed("link");
+var writeFile = routed("writeFile");
+var appendFile = routed("appendFile");
+var pal_manifest_default = {
+  title: "Change Review",
+  workspaceTargets: ["local", "ssh"],
+  activationScope: "scoped",
+  extensions: ["pal.ui.panel", "pal.conversation.before-composer"],
+  author: "PAL",
+  category: "development",
+  icon: "git-branch",
+  tools: [],
+  locales: {
+    "zh-CN": {
+      name: "\u53D8\u66F4\u5BA1\u67E5",
+      description: "\u67E5\u770B\u6BCF\u8F6E\u6587\u4EF6\u53D8\u66F4\uFF0C\u652F\u6301 Git \u5DEE\u5F02\u5BF9\u6BD4\u3002"
+    },
+    zh: {
+      name: "\u53D8\u66F4\u5BA1\u67E5",
+      description: "\u67E5\u770B\u6BCF\u8F6E\u6587\u4EF6\u53D8\u66F4\uFF0C\u652F\u6301 Git \u5DEE\u5F02\u5BF9\u6BD4\u3002"
+    }
+  },
+  contributions: ["runChanges"],
+  consumes: {
+    fileChanges: {
+      contract: "pal.filesystem.changes",
+      apiVersion: 1,
+      transport: "reference",
+      optional: true,
+      autoBind: true
+    }
+  },
+  hostRenderers: {
+    review: {
+      root: "dist/ui",
+      entry: "host.js"
+    },
+    indicator: {
+      root: "dist/ui",
+      entry: "indicator-host.js"
+    }
+  },
+  requiresHost: {
+    "pal.command.callable": 1,
+    "pal.command.dispatch": 1,
+    "pal.command.execute": 1,
+    "pal.plugin.hostPanel": 1,
+    "pal.plugin.hostPanel.workspace": 1,
+    "pal.plugin.declarations": 1,
+    "pal.extension.ui.panel": 1,
+    "pal.plugin.files.commands": 3,
+    "pal.plugin.process.commands": 2,
+    "pal.plugin.runChanges.commands": 1,
+    "pal.frontend.command.isAvailable": 1,
+    "pal.host.files.navigation": 1,
+    "pal.plugin.hostPanel.message": 2,
+    "pal.context.panels": 1,
+    "pal.context.services": 1,
+    "pal.extension.conversation.before-composer": 1
+  },
+  declarations: {
+    provides: {
+      commands: [
+        {
+          id: "pal.git.review.load",
+          title: "\u8BFB\u53D6\u53D8\u66F4\u5BA1\u67E5",
+          visibility: "public",
+          readOnly: false,
+          requiredPermissions: ["pal.fs.read", "pal.process.spawn"],
+          inputSchema: {
+            type: "object",
+            properties: {
+              scope: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  kind: {
+                    enum: [
+                      "turn",
+                      "uncommitted",
+                      "unstaged",
+                      "staged",
+                      "commit",
+                      "branch"
+                    ]
+                  },
+                  ref: {
+                    type: "string",
+                    maxLength: 500
+                  }
+                },
+                required: ["kind"]
+              },
+              path: {
+                type: "string",
+                maxLength: 2e3
+              },
+              runId: {
+                type: "string",
+                maxLength: 200
+              }
+            },
+            additionalProperties: false
+          }
+        },
+        {
+          id: "pal.git.review.patch",
+          title: "\u751F\u6210\u5F53\u524D\u6587\u4EF6\u8865\u4E01",
+          visibility: "public",
+          readOnly: false,
+          requiredPermissions: ["pal.fs.read", "pal.process.spawn"],
+          inputSchema: {
+            type: "object",
+            properties: {
+              scope: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  kind: {
+                    enum: [
+                      "turn",
+                      "uncommitted",
+                      "unstaged",
+                      "staged",
+                      "commit",
+                      "branch"
+                    ]
+                  },
+                  ref: {
+                    type: "string",
+                    maxLength: 500
+                  }
+                },
+                required: ["kind"]
+              },
+              path: {
+                type: "string",
+                maxLength: 2e3
+              },
+              runId: {
+                type: "string",
+                maxLength: 200
+              }
+            },
+            required: ["path"],
+            additionalProperties: false
+          }
+        },
+        {
+          id: "pal.git.review.preview",
+          title: "\u9884\u89C8\u8F6E\u6B21\u6587\u4EF6\u5DEE\u5F02",
+          visibility: "private",
+          readOnly: true,
+          requiredPermissions: ["pal.fs.read"],
+          inputSchema: {
+            type: "object",
+            properties: {
+              runId: {
+                type: "string",
+                minLength: 1,
+                maxLength: 200
+              },
+              path: {
+                type: "string",
+                minLength: 1,
+                maxLength: 2e3
+              }
+            },
+            required: ["runId", "path"],
+            additionalProperties: false
+          }
+        },
+        {
+          id: "pal.git.review.open",
+          title: "\u6253\u5F00\u8F6E\u6B21\u53D8\u66F4\u5BA1\u67E5",
+          visibility: "private",
+          readOnly: false,
+          requiredPermissions: ["pal.fs.read"],
+          inputSchema: {
+            type: "object",
+            properties: {
+              runId: {
+                type: "string",
+                minLength: 1,
+                maxLength: 200
+              },
+              path: {
+                type: "string",
+                minLength: 1,
+                maxLength: 2e3
+              }
+            },
+            required: ["runId"],
+            additionalProperties: false
+          }
+        }
+      ],
+      ui: [
+        {
+          id: "pal.git.panel",
+          slot: "pal.ui.panel",
+          messagePresentation: true,
+          description: "\u53D8\u66F4\u5BA1\u67E5\u9762\u677F\uFF0C\u56FA\u5B9A\u6253\u5F00\u65F6\u7684\u9879\u76EE\u3001\u4F1A\u8BDD\u548C\u8F6E\u6B21"
+        },
+        {
+          id: "pal.git.indicator",
+          slot: "pal.conversation.before-composer",
+          description: "\u5F53\u524D\u8F6E\u6B21\u7684\u6587\u4EF6\u6539\u52A8\u63D0\u793A"
+        }
+      ]
+    },
+    consumes: {
+      commands: [
+        {
+          id: "pal.fs.read",
+          reason: "\u8BFB\u53D6\u6388\u6743\u8303\u56F4\u5185\u7684\u5DE5\u4F5C\u533A\u6587\u4EF6\u4E0E\u76EE\u5F55\u5143\u6570\u636E"
+        },
+        {
+          id: "pal.process.start",
+          reason: "\u8FD0\u884C\u6709\u754C\u7684 Git \u67E5\u8BE2"
+        },
+        {
+          id: "pal.process.read",
+          reason: "\u8BFB\u53D6 Git \u8F93\u51FA\uFF0C\u5305\u62EC\u56FE\u7247\u539F\u59CB\u5B57\u8282"
+        },
+        {
+          id: "pal.process.release",
+          reason: "\u67E5\u8BE2\u5B8C\u6210\u6216\u5931\u8D25\u540E\u91CA\u653E Git \u8FDB\u7A0B\u4E0E\u8F93\u51FA\u7F13\u5B58"
+        },
+        {
+          id: "pal.clipboard.write",
+          reason: "\u6309\u7528\u6237\u70B9\u51FB\u5C06\u5F53\u524D\u6587\u4EF6\u7684 git apply \u547D\u4EE4\u590D\u5236\u5230\u526A\u8D34\u677F\uFF0C\u4E0D\u8BFB\u53D6\u526A\u8D34\u677F"
+        },
+        {
+          id: "pal.files.open",
+          reason: "\u901A\u8FC7\u5BBF\u4E3B\u9ED8\u8BA4\u6587\u4EF6\u67E5\u770B\u5668\u6253\u5F00\u5BA1\u67E5\u6587\u4EF6\uFF0C\u4E0D\u7ED1\u5B9A\u6587\u4EF6\u7BA1\u7406\u5668\u63D2\u4EF6"
+        },
+        {
+          id: "pal.toast.show",
+          reason: "\u63D0\u793A\u590D\u5236\u6210\u529F\u6216\u5931\u8D25\uFF0C\u4EE5\u53CA\u5237\u65B0\u3001\u5207\u6362\u8303\u56F4\u3001\u6253\u5F00\u6587\u4EF6\u5931\u8D25"
+        },
+        {
+          id: "pal.host.interaction.close",
+          reason: "\u63D0\u793A\u590D\u5236\u6210\u529F\u6216\u5931\u8D25\uFF0C\u4EE5\u53CA\u5237\u65B0\u3001\u5207\u6362\u8303\u56F4\u3001\u6253\u5F00\u6587\u4EF6\u5931\u8D25"
+        },
+        {
+          id: "pal.host.interaction.list",
+          reason: "\u63D0\u793A\u590D\u5236\u6210\u529F\u6216\u5931\u8D25\uFF0C\u4EE5\u53CA\u5237\u65B0\u3001\u5207\u6362\u8303\u56F4\u3001\u6253\u5F00\u6587\u4EF6\u5931\u8D25"
+        },
+        {
+          id: "pal.host.interaction.respond",
+          reason: "\u63D0\u793A\u590D\u5236\u6210\u529F\u6216\u5931\u8D25\uFF0C\u4EE5\u53CA\u5237\u65B0\u3001\u5207\u6362\u8303\u56F4\u3001\u6253\u5F00\u6587\u4EF6\u5931\u8D25"
+        },
+        {
+          id: "pal.host.interaction.action",
+          reason: "\u63D0\u793A\u590D\u5236\u6210\u529F\u6216\u5931\u8D25\uFF0C\u4EE5\u53CA\u5237\u65B0\u3001\u5207\u6362\u8303\u56F4\u3001\u6253\u5F00\u6587\u4EF6\u5931\u8D25"
+        },
+        {
+          id: "pal.frontend.context",
+          reason: "\u4F7F\u7528\u5DF2\u58F0\u660E\u524D\u7AEF\u7684\u5BBF\u4E3B\u80FD\u529B"
+        }
+      ]
+    }
+  }
+};
+var scope = new import_node_async_hooks2.AsyncLocalStorage();
+function withCommands(commands, operation) {
+  if (!commands)
+    throw new Error("Host command access unavailable; upgrade the host");
+  return scope.run(commands, operation);
+}
+function execute(id2, input) {
+  const commands = scope.getStore();
+  if (!commands) throw new Error("Operation outside bound command scope");
+  return commands.execute(id2, input);
+}
+var info = (value) => ({
+  ...value,
+  isFile: () => value.file,
+  isDirectory: () => value.directory,
+  isSymbolicLink: () => value.symlink
+});
+var realpath2 = (path) => execute("pal.fs.read", { operation: "realpath", path });
+var readlink2 = (path) => execute("pal.fs.read", { operation: "readlink", path });
+var lstat2 = async (path) => info(await execute("pal.fs.read", { operation: "lstat", path }));
+async function readFile2(path, encoding) {
+  const result = await execute("pal.fs.read", {
+    path,
+    encoding: encoding ?? "base64"
+  });
+  return encoding ? result.content : Buffer.from(result.content, "base64");
+}
+function isRemotePath2(path) {
+  return typeof path === "string" && path.startsWith("ssh://");
+}
+function remotePath(path) {
+  const url = new URL(path);
+  if (url.protocol !== "ssh:" || !/^[a-zA-Z0-9-]+$/.test(url.hostname) || url.username || url.password || url.port || url.search || url.hash)
+    throw new Error("Invalid remote workspace path");
+  const decoded = decodeURIComponent(url.pathname);
+  if (decoded.includes("\0") || decoded.includes("\\"))
+    throw new Error("Invalid remote path");
+  return { profileId: url.hostname, path: import_node_path2.posix.normalize(decoded) };
+}
+function workspaceUri(profileId, path) {
+  if (!/^[a-zA-Z0-9-]+$/.test(profileId) || !import_node_path2.posix.isAbsolute(path) || /[\0\\]/.test(path))
+    throw new Error("Invalid remote workspace");
+  return `ssh://${profileId}${import_node_path2.posix.normalize(path).split("/").map(encodeURIComponent).join("/")}`;
+}
+function join(...parts) {
+  if (!isRemotePath2(parts[0])) return import_node_path2.default.join(...parts);
+  const root = remotePath(parts[0]);
+  return workspaceUri(root.profileId, import_node_path2.posix.join(root.path, ...parts.slice(1)));
+}
+function resolve(...parts) {
+  const base = parts.findIndex(isRemotePath2);
+  if (base < 0) return import_node_path2.default.resolve(...parts);
+  const root = remotePath(parts[base]);
+  const rest = parts.slice(base + 1).map((part) => {
+    if (!isRemotePath2(part)) return part;
+    const target = remotePath(part);
+    if (target.profileId !== root.profileId)
+      throw new Error("Different SSH connections");
+    return target.path;
+  });
+  return workspaceUri(root.profileId, import_node_path2.posix.resolve(root.path, ...rest));
+}
+function dirname(path) {
+  if (!isRemotePath2(path)) return import_node_path2.default.dirname(path);
+  const root = remotePath(path);
+  return workspaceUri(root.profileId, import_node_path2.posix.dirname(root.path));
+}
+function relative(from, to) {
+  if (!isRemotePath2(from) && !isRemotePath2(to))
+    return import_node_path2.default.relative(from, to);
+  if (!isRemotePath2(from)) throw new Error("Mixed local and remote paths");
+  const root = remotePath(from);
+  const target = isRemotePath2(to) ? remotePath(to) : { profileId: root.profileId, path: to };
+  if (target.profileId !== root.profileId)
+    throw new Error("Different SSH connections");
+  return import_node_path2.posix.relative(root.path, target.path);
+}
+var isAbsolute = (path) => isRemotePath2(path) || import_node_path2.default.isAbsolute(path) || import_node_path2.posix.isAbsolute(path);
+var sep2 = import_node_path2.default.sep;
+async function runGit(cwd, args, signal, binary) {
+  signal.throwIfAborted();
+  const resource = await execute("pal.process.start", {
+    mode: "pipe",
+    lifetime: "request",
+    executable: "git",
+    args: [
+      "--no-pager",
+      "--literal-pathspecs",
+      "-c",
+      "core.hooksPath=",
+      ...args
+    ],
+    cwd,
+    timeoutMs: 3e4,
+    maxBufferChars: 24 * 1024 * 1024,
+    stdoutEncoding: "base64",
+    env: {
+      ...Object.fromEntries(
+        Object.keys(process.env).filter((k) => k.toUpperCase().startsWith("GIT_")).map((k) => [k, null])
+      ),
+      GIT_TERMINAL_PROMPT: "0",
+      GIT_OPTIONAL_LOCKS: "0"
+    }
+  });
+  const chunks = [];
+  let cursor = 0, bytes = 0, stderr = "", encoded = "";
+  const limit = binary ? 16 * 1024 * 1024 : 2 * 1024 * 1024;
+  try {
+    for (; ; ) {
+      signal.throwIfAborted();
+      const result = await execute("pal.process.read", {
+        processId: resource.processId,
+        cursor,
+        maxChars: 65536,
+        waitMs: 1e3
+      });
+      cursor = result.nextCursor;
+      if (result.lostOutput) throw new Error("Git output exceeded host buffer");
+      for (const chunk of result.chunks) {
+        if (chunk.stream === "stdout") {
+          encoded += chunk.data;
+          const frames = encoded.split("\n");
+          encoded = frames.pop();
+          for (const frame of frames) {
+            const value = Buffer.from(frame, "base64");
+            chunks.push(value);
+            bytes += value.length;
+          }
+        } else stderr = (stderr + chunk.data).slice(-8192);
+      }
+      if (bytes > limit) throw new Error("Git output exceeds review limit");
+      if (result.status !== "exited" || result.hasMore) continue;
+      signal.throwIfAborted();
+      if (result.exit?.code !== 0)
+        throw new Error(
+          stderr.trim() || `Git failed (${result.exit?.reason ?? result.exit?.code})`
+        );
+      if (encoded) throw new Error("Incomplete binary output frame");
+      return Buffer.concat(chunks);
+    }
+  } finally {
+    await execute("pal.process.release", { processId: resource.processId }).catch(
+      () => {
+      }
+    );
+  }
+}
+async function git(cwd, args, signal) {
+  return (await runGit(cwd, args, signal, false)).toString("utf8");
+}
+function gitBytes(cwd, args, signal) {
+  return runGit(cwd, args, signal, true);
+}
+async function repository(context) {
+  if (!context.workspacePath)
+    throw new Error("A project workspace is required");
+  const workspace = await realpath2(context.workspacePath);
+  const root = await realpath2(
+    resolve(
+      workspace,
+      (await git(workspace, ["rev-parse", "--show-toplevel"], context.signal)).trim()
+    )
+  );
+  if (relative(workspace, root) !== "")
+    throw new Error("Open the repository root as the project workspace");
+  return root;
+}
+function selectedPaths(paths, required = false) {
+  if (paths === void 0 && !required) return [];
+  if (!Array.isArray(paths) || !paths.length || paths.length > 100)
+    throw new Error("Select 1\u2013100 explicit paths");
+  return paths.map((path) => {
+    if (typeof path !== "string" || !path || path.length > 2e3 || isAbsolute(path) || /^[A-Za-z]:/.test(path) || path.includes("\0") || path.split(/[\\/]/).some((part) => part === ".." || part.toLowerCase() === ".git"))
+      throw new Error("Invalid repository-relative path");
+    return path;
+  });
+}
+async function reviewOptions(context, rootHint) {
+  const root = rootHint ?? await repository(context).catch(() => void 0);
+  if (!root) return void 0;
+  const [log, refs, currentBranch] = await Promise.all([
+    git(root, ["log", "-20", "--format=%H%x09%s%x09%aI"], context.signal).catch(
+      () => ""
+    ),
+    git(
+      root,
+      [
+        "for-each-ref",
+        "--count=100",
+        "--format=%(refname)%09%(refname:short)%09%(symref)",
+        "refs/heads/",
+        "refs/remotes/"
+      ],
+      context.signal
+    ),
+    git(root, ["symbolic-ref", "--short", "HEAD"], context.signal).catch(
+      () => "HEAD"
+    )
+  ]);
+  const parse = (value) => value.trim().split("\n").filter(Boolean).map((line) => {
+    const [ref, label, target] = line.trim().split("	");
+    return { ref, label, target };
+  });
+  const branches = parse(refs).filter((item) => !item.target);
+  const defaultTargetBranch = parse(refs).find(
+    (item) => item.ref === "refs/remotes/origin/HEAD"
+  )?.target;
+  return {
+    ...defaultTargetBranch && branches.some((item) => item.ref === defaultTargetBranch) ? { defaultTargetBranch } : {},
+    commits: log.trim().split("\n").filter(Boolean).map((line) => {
+      const [ref, label, date] = line.split("	");
+      return { ref, label, date };
+    }),
+    branches: branches.map(({ ref, label }) => ({ ref, label })),
+    currentBranch: currentBranch.trim()
+  };
+}
+var ReviewCommands = class {
+  constructor(changes) {
+    this.changes = changes;
+  }
+  async card(input, execution) {
+    if (!input.runId) throw new Error("Missing turn resource");
+    const review = await this.changes.load(execution.context, input.runId);
+    execution.context.signal.throwIfAborted();
+    const summary = this.changes.summary(review);
+    const files = summary.files.filter(
+      (file) => !/^generated-images\/[0-9a-f-]{36}\/(?:image\.(?:png|jpg)|metadata\.json)$/.test(
+        file.path.replaceAll("\\", "/")
+      )
+    );
+    return {
+      ...summary,
+      runId: review.runId,
+      files,
+      added: files.reduce((total, file) => total + file.added, 0),
+      removed: files.reduce((total, file) => total + file.removed, 0)
+    };
+  }
+  /** Hover only reads the captured turn; it never queries the working tree. */
+  async preview(input, execution) {
+    if (!input.runId || !input.path)
+      throw new Error("Missing preview resource");
+    const review = await this.changes.load(execution.context, input.runId);
+    execution.context.signal.throwIfAborted();
+    const file = review.files.find((item) => item.path === input.path);
+    if (!file) return { preview: true };
+    const {
+      beforeImage: _beforeImage,
+      afterImage: _afterImage,
+      ...selected
+    } = file;
+    const text = (file.before ?? "") + (file.after ?? "");
+    if (text.length > 3e5 || text.split("\n").length > 6e3) {
+      return {
+        preview: true,
+        selected: {
+          path: file.path,
+          added: file.added,
+          removed: file.removed,
+          status: file.status,
+          unavailable: "large"
+        }
+      };
+    }
+    return { preview: true, selected };
+  }
+  load(input, execution) {
+    return withCommands(execution.command, async () => {
+      const context = execution.context;
+      const resource = execution.request.resource ? JSON.parse(execution.request.resource) : {};
+      const runId = input.runId ?? resource.runId;
+      let gitError = false;
+      const failedGit = (cause) => {
+        context.signal.throwIfAborted();
+        if (!/not a git repository/i.test(String(cause))) {
+          gitError = true;
+          console.warn("Review Git discovery failed", cause);
+        }
+        return void 0;
+      };
+      const root = await repository(context).catch(failedGit);
+      const optionsPending = root ? reviewOptions(context, root).catch(failedGit) : Promise.resolve(void 0);
+      void optionsPending.catch(() => {
+      });
+      const options = input.scope?.kind === "branch" || input.scope?.kind === "commit" ? await optionsPending : void 0;
+      context.signal.throwIfAborted();
+      let scope2 = input.scope ?? {
+        kind: runId || !root ? "turn" : "uncommitted"
+      };
+      if (scope2.kind === "branch" && !scope2.ref && options?.defaultTargetBranch)
+        scope2 = { kind: "branch", ref: options.defaultTargetBranch };
+      const review = scope2.kind === "branch" && !scope2.ref ? {
+        projectId: context.projectId,
+        sessionId: context.sessionId,
+        runId: "",
+        files: [],
+        added: 0,
+        removed: 0
+      } : scope2.kind === "turn" ? (runId ? await this.changes.load(context, runId) : await this.changes.latest(context)) ?? {
+        projectId: context.projectId,
+        sessionId: context.sessionId,
+        runId: "",
+        files: [],
+        added: 0,
+        removed: 0
+      } : await this.changes.current(context, scope2, root, options);
+      const requested = input.path ?? resource.path;
+      const path = review.files.some((file) => file.path === requested) ? requested : review.files[0]?.path;
+      const pending = /* @__PURE__ */ new Map();
+      const loadFile = (path2) => {
+        let file = pending.get(path2);
+        if (!file) {
+          file = this.changes.currentFile(context, review, path2, root);
+          pending.set(path2, file);
+        }
+        return file;
+      };
+      const [selectedFile, contents] = await Promise.all([
+        path ? loadFile(path) : void 0,
+        review.files.length <= 8 ? review.runId ? review.files : Promise.all(review.files.map((file) => loadFile(file.path))) : void 0
+      ]);
+      let selected = selectedFile;
+      if (selected && Buffer.byteLength(JSON.stringify(selected)) > 6 * 1024 * 1024) {
+        const { beforeImage, afterImage, ...metadata } = selected;
+        selected = { ...metadata, unavailable: "budget" };
+      }
+      const complete = contents?.filter((file) => !!file);
+      const overview = complete && complete.reduce(
+        (sum, file) => sum + Buffer.byteLength(file.before ?? "") + Buffer.byteLength(file.after ?? "") + Buffer.byteLength(file.beforeImage ?? "") + Buffer.byteLength(file.afterImage ?? ""),
+        0
+      ) <= 2 * 1024 * 1024 ? complete : void 0;
+      const resolvedOptions = options ?? await optionsPending;
+      context.signal.throwIfAborted();
+      return {
+        mode: review.runId ? "turn" : "workspace",
+        ...resource.path ? { navigation: { path: resource.path } } : {},
+        runId: review.runId,
+        scope: scope2,
+        ...resolvedOptions ? { git: resolvedOptions } : {},
+        ...gitError ? { gitError: true } : {},
+        ...overview ? { overview } : {},
+        files: review.files.map(
+          ({ before, after, beforeImage, afterImage, ...file }) => file
+        ),
+        added: review.added,
+        removed: review.removed,
+        incomplete: review.incomplete,
+        ...selected ? { selected } : {}
+      };
+    });
+  }
+  async patch(input, execution) {
+    const review = await this.load(input, execution);
+    const file = review.selected;
+    if (!file || file.path !== input.path || file.unavailable)
+      throw new Error("No patch available for this file");
+    const patch = (0, import_diff.createTwoFilesPatch)(
+      file.status === "added" ? "/dev/null" : `a/${file.path}`,
+      file.status === "deleted" ? "/dev/null" : `b/${file.path}`,
+      file.before ?? "",
+      file.after ?? ""
+    );
+    if (Buffer.byteLength(patch) > 1024 * 1024)
+      throw new Error("Patch is too large to copy");
+    execution.context.signal.throwIfAborted();
+    return { patch };
+  }
+};
+var FILE_LIMIT = 1024 * 1024;
+var contentLimit = (path) => /\.(png|jpe?g|webp|gif)$/i.test(path) ? 8 * 1024 * 1024 : FILE_LIMIT;
+var TOTAL_LIMIT = 32 * 1024 * 1024;
+var digest = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
+function content(buffer) {
+  const hash = digest(buffer);
+  const mime = buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) ? "image/png" : buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255 ? "image/jpeg" : buffer.toString("ascii", 0, 4) === "RIFF" && buffer.toString("ascii", 8, 12) === "WEBP" ? "image/webp" : /^GIF8[79]a$/.test(buffer.toString("ascii", 0, 6)) ? "image/gif" : void 0;
+  if (mime)
+    return {
+      hash,
+      unavailable: "binary",
+      image: `data:${mime};base64,${buffer.toString("base64")}`
+    };
+  if (buffer.includes(0)) return { hash, unavailable: "binary" };
+  try {
+    return {
+      hash,
+      text: new TextDecoder("utf-8", { fatal: true }).decode(buffer)
+    };
+  } catch {
+    return { hash, unavailable: "encoding" };
+  }
+}
+async function workingFile(root, path) {
+  selectedPaths([path], true);
+  const target = join(root, path);
+  const stat2 = await lstat2(target).catch((error) => {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") return null;
+    throw error;
+  });
+  if (!stat2) return null;
+  if (stat2.isSymbolicLink())
+    return { hash: digest(await readlink2(target)), unavailable: "symlink" };
+  if (!stat2.isFile())
+    return { hash: String(stat2.mtimeMs), unavailable: "directory" };
+  if (stat2.size > contentLimit(path))
+    return { hash: `${stat2.size}:${stat2.mtimeMs}`, unavailable: "large" };
+  return content(await readFile2(target));
+}
+async function headFile(root, head, path, signal, knownExists = false) {
+  if (!head) return null;
+  if (head === "INDEX") {
+    const entries2 = await git(
+      root,
+      ["ls-files", "--stage", "-z", "--", path],
+      signal
+    );
+    const item = entries2.split("\0").find((line) => line.split("	")[0]?.endsWith(" 0"));
+    if (!item) return null;
+    const id3 = item.split("	")[0].split(" ")[1];
+    if (Number((await git(root, ["cat-file", "-s", id3], signal)).trim()) > contentLimit(path))
+      return { hash: id3, unavailable: "large" };
+    return content(await gitBytes(root, ["cat-file", "blob", id3], signal));
+  }
+  if (knownExists) {
+    const object2 = `${head}:${path}`;
+    const size2 = Number(
+      (await git(root, ["cat-file", "-s", object2], signal)).trim()
+    );
+    if (size2 > contentLimit(path))
+      return { hash: object2, unavailable: "large" };
+    return content(await gitBytes(root, ["cat-file", "blob", object2], signal));
+  }
+  const object = await git(root, ["ls-tree", "-z", head, "--", path], signal);
+  if (!object) return null;
+  const id2 = object.split("	")[0].split(" ").at(-1);
+  const size = Number((await git(root, ["cat-file", "-s", id2], signal)).trim());
+  if (size > contentLimit(path)) return { hash: id2, unavailable: "large" };
+  return content(await gitBytes(root, ["cat-file", "blob", id2], signal));
+}
+async function headOf(root, signal) {
+  return git(root, ["rev-parse", "--verify", "HEAD"], signal).then(
+    (value) => value.trim(),
+    () => void 0
+  );
+}
+function changed(path, before, after) {
+  if (before?.hash === after?.hash || !before && !after) return void 0;
+  const status = !before ? "added" : !after ? "deleted" : "modified";
+  const unavailable = before?.unavailable ?? after?.unavailable;
+  const left = before?.text ?? "", right = after?.text ?? "";
+  const diff = unavailable ? void 0 : (0, import_diff2.diffLines)(left, right, { timeout: 150, maxEditLength: 2e4 });
+  return {
+    path,
+    status,
+    added: diff?.reduce((sum, part) => sum + (part.added ? part.count : 0), 0) ?? 0,
+    removed: diff?.reduce((sum, part) => sum + (part.removed ? part.count : 0), 0) ?? 0,
+    ...unavailable || !diff ? { unavailable: unavailable ?? "complex" } : {},
+    ...!unavailable ? { before: left, after: right } : {},
+    ...before?.image ? { beforeImage: before.image } : {},
+    ...after?.image ? { afterImage: after.image } : {}
+  };
+}
+var WorkspaceChangeReview = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  active = /* @__PURE__ */ new Map();
+  activeReview(sessionId) {
+    return this.active.get(sessionId);
+  }
+  path(session, run) {
+    return join(
+      this.storage,
+      "turn-changes",
+      digest(session),
+      digest(run) + ".json"
+    );
+  }
+  beginEvents(context, service, changedUi) {
+    const review = {
+      projectId: context.projectId,
+      sessionId: context.sessionId,
+      runId: context.runId,
+      files: [],
+      added: 0,
+      removed: 0
+    };
+    const originals = /* @__PURE__ */ new Map();
+    const pending = /* @__PURE__ */ new Map();
+    const virtualAfter = /* @__PURE__ */ new Map();
+    const sizes = /* @__PURE__ */ new Map();
+    let storedBytes = 0;
+    const stream = service.subscribe("applied", {
+      projectId: context.projectId,
+      sessionId: context.sessionId,
+      signal: context.lifetimeSignal ?? context.signal
+    });
+    this.active.set(context.sessionId, review);
+    let barrier;
+    let incomplete = false;
+    void (async () => {
+      try {
+        for await (const raw of stream) {
+          const event = raw;
+          if (event.runId !== context.runId) continue;
+          if (event.type === "barrier") {
+            if (event.token === barrier?.token) barrier.done();
+            continue;
+          }
+          if (event.type === "preview" || event.type === "preview-clear") {
+            if (event.type === "preview" && event.path)
+              pending.set(event.toolCallId, {
+                toolCallId: event.toolCallId,
+                path: event.path,
+                added: event.added ?? 0,
+                removed: event.removed ?? 0
+              });
+            else pending.delete(event.toolCallId);
+            review.pending = [...pending.values()];
+            changedUi();
+            continue;
+          }
+          if (event.toolCallId) pending.delete(event.toolCallId);
+          review.pending = [...pending.values()];
+          if (!originals.has(event.path) && originals.size >= 2e3) {
+            incomplete = true;
+            continue;
+          }
+          const previous = virtualAfter.get(event.path);
+          let after = event.after;
+          if (previous !== void 0 && previous !== event.before) {
+            const patch = (0, import_diff2.createTwoFilesPatch)(
+              event.path,
+              event.path,
+              event.before ?? "",
+              event.after
+            );
+            const merged = (0, import_diff2.applyPatch)(previous, patch);
+            if (merged === false) {
+              incomplete = true;
+              continue;
+            }
+            after = merged;
+          }
+          const before = originals.has(event.path) ? originals.get(event.path) ?? null : event.before;
+          const nextBytes = Buffer.byteLength(before ?? "") + Buffer.byteLength(after);
+          if (storedBytes - (sizes.get(event.path) ?? 0) + nextBytes > TOTAL_LIMIT) {
+            incomplete = true;
+            continue;
+          }
+          storedBytes += nextBytes - (sizes.get(event.path) ?? 0);
+          sizes.set(event.path, nextBytes);
+          if (!originals.has(event.path)) originals.set(event.path, before);
+          virtualAfter.set(event.path, after);
+          const file = changed(
+            event.path,
+            before === null ? null : content(Buffer.from(before)),
+            content(Buffer.from(after))
+          );
+          review.files = review.files.filter(
+            (item) => item.path !== event.path
+          );
+          if (file) review.files.push(file);
+          review.added = review.files.reduce(
+            (sum, item) => sum + item.added,
+            0
+          );
+          review.removed = review.files.reduce(
+            (sum, item) => sum + item.removed,
+            0
+          );
+          changedUi();
+        }
+      } catch {
+        incomplete = true;
+      }
+    })();
+    return {
+      finish: async (signal) => {
+        pending.clear();
+        review.pending = [];
+        changedUi();
+        if (!signal.aborted && !(context.lifetimeSignal ?? context.signal).aborted) {
+          const token = (0, import_node_crypto.randomUUID)();
+          const arrival = new Promise((resolve2) => {
+            barrier = { token, done: resolve2 };
+          });
+          try {
+            await service.call(
+              "barrier",
+              { runId: context.runId, token },
+              {
+                projectId: context.projectId,
+                sessionId: context.sessionId,
+                signal
+              }
+            );
+            let timer;
+            try {
+              await Promise.race([
+                arrival,
+                new Promise((_, reject) => {
+                  timer = setTimeout(
+                    () => reject(new Error("Change event barrier timed out")),
+                    1e4
+                  );
+                })
+              ]);
+            } finally {
+              clearTimeout(timer);
+            }
+          } catch {
+            incomplete = true;
+          }
+        } else incomplete = true;
+        try {
+          await stream.return?.();
+        } catch {
+          incomplete = true;
+        }
+        if (this.active.get(context.sessionId) === review)
+          this.active.delete(context.sessionId);
+        changedUi();
+        if (!review.files.length) return void 0;
+        if (incomplete) review.incomplete = true;
+        const target = this.path(context.sessionId, context.runId);
+        await (0, import_promises.mkdir)(dirname(target), { recursive: true });
+        const temporary = `${target}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+        await (0, import_promises.writeFile)(temporary, JSON.stringify(review));
+        await (0, import_promises.rename)(temporary, target);
+        await (0, import_promises.writeFile)(
+          join(dirname(target), "latest.json"),
+          JSON.stringify({ runId: context.runId })
+        );
+        return this.summary(review);
+      },
+      dispose: () => {
+        void stream.return?.();
+        if (this.active.get(context.sessionId) === review)
+          this.active.delete(context.sessionId);
+      }
+    };
+  }
+  summary(review) {
+    return {
+      panelId: "pal.git.panel",
+      resource: JSON.stringify({ runId: review.runId }),
+      files: review.files.map(
+        ({
+          before: _before,
+          after: _after,
+          beforeImage: _bi,
+          afterImage: _ai,
+          ...file
+        }) => ({
+          ...file,
+          resource: JSON.stringify({ runId: review.runId, path: file.path })
+        })
+      ),
+      added: review.added,
+      removed: review.removed,
+      ...review.incomplete ? { incomplete: true } : {}
+    };
+  }
+  async load(context, runId) {
+    const active = this.active.get(context.sessionId);
+    if (active?.runId === runId && active.projectId === context.projectId)
+      return structuredClone(active);
+    const review = JSON.parse(
+      await (0, import_promises.readFile)(this.path(context.sessionId, runId), "utf8")
+    );
+    if (review.projectId !== context.projectId || review.sessionId !== context.sessionId || review.runId !== runId)
+      throw new Error("Change review scope mismatch");
+    return review;
+  }
+  async current(context, scope2 = { kind: "uncommitted" }, rootHint, optionsHint) {
+    const root = rootHint ?? await repository(context).catch(() => void 0);
+    if (!root) {
+      if (!["turn", "uncommitted"].includes(scope2.kind))
+        throw Error("Git comparison is unavailable in this workspace");
+      const latest = await (0, import_promises.readFile)(
+        join(dirname(this.path(context.sessionId, "")), "latest.json"),
+        "utf8"
+      ).then(
+        (value) => JSON.parse(value),
+        () => void 0
+      );
+      if (latest) return this.load(context, latest.runId);
+      return {
+        projectId: context.projectId,
+        sessionId: context.sessionId,
+        runId: "",
+        files: [],
+        added: 0,
+        removed: 0
+      };
+    }
+    let head = await headOf(root, context.signal), targetRef;
+    let comparison = ["diff"];
+    if (!head && scope2.kind === "uncommitted") comparison.push("--cached");
+    if (scope2.kind === "staged") {
+      targetRef = "INDEX";
+      comparison.push("--cached");
+    }
+    if (scope2.kind === "unstaged") head = "INDEX";
+    if (scope2.kind === "commit" || scope2.kind === "branch") {
+      const options = optionsHint ?? await reviewOptions(context, root);
+      const list = scope2.kind === "commit" ? options?.commits : options?.branches;
+      if (!scope2.ref || !list?.some((item) => item.ref === scope2.ref))
+        throw Error("Selected revision is unavailable");
+      if (scope2.kind === "commit") {
+        targetRef = scope2.ref;
+        head = (await git(
+          root,
+          ["rev-list", "--parents", "-n", "1", scope2.ref],
+          context.signal
+        )).trim().split(" ")[1];
+        if (!head) comparison = ["diff-tree", "--root", "--no-commit-id", "-r"];
+      } else {
+        if (!head) throw Error("Create a commit before comparing branches");
+        targetRef = head;
+        head = (await git(root, ["merge-base", "HEAD", scope2.ref], context.signal)).trim();
+      }
+    }
+    const revisions = comparison[0] === "diff-tree" ? [targetRef] : [
+      ...head && head !== "INDEX" ? [head] : [],
+      ...targetRef && targetRef !== "INDEX" ? [targetRef] : []
+    ];
+    const command = (format) => [
+      ...comparison,
+      format,
+      "-z",
+      "--no-renames",
+      ...revisions,
+      "--"
+    ];
+    const [numbers, statusOutput, untracked] = await Promise.all([
+      git(root, command("--numstat"), context.signal),
+      git(root, command("--name-status"), context.signal),
+      !targetRef ? git(
+        root,
+        ["ls-files", "-z", "--others", "--exclude-standard"],
+        context.signal
+      ) : ""
+    ]);
+    const statuses = statusOutput.split("\0");
+    const kinds = /* @__PURE__ */ new Map();
+    for (let i = 0; i < statuses.length - 1; i += 2)
+      kinds.set(statuses[i + 1], statuses[i]);
+    const paths = [
+      .../* @__PURE__ */ new Set([...kinds.keys(), ...untracked.split("\0").filter(Boolean)])
+    ];
+    const files = [];
+    const stats = new Map(
+      numbers.split("\0").filter(Boolean).map((record) => {
+        const [added, removed, ...path] = record.split("	");
+        return [path.join("	"), { added, removed }];
+      })
+    );
+    for (const path of paths.slice(0, 2e3)) {
+      const stat2 = stats.get(path);
+      if (stat2 && (head || targetRef))
+        files.push({
+          path,
+          status: kinds.get(path) === "D" ? "deleted" : kinds.get(path) === "A" ? "added" : "modified",
+          added: Number(stat2.added) || 0,
+          removed: Number(stat2.removed) || 0,
+          ...stat2.added === "-" ? { unavailable: "binary" } : {}
+        });
+      else {
+        const file = changed(path, null, await workingFile(root, path));
+        if (file) {
+          delete file.before;
+          delete file.after;
+          delete file.beforeImage;
+          delete file.afterImage;
+          files.push(file);
+        }
+      }
+    }
+    return {
+      projectId: context.projectId,
+      sessionId: context.sessionId,
+      runId: "",
+      files,
+      ...head ? { baseHead: head } : {},
+      ...targetRef ? { targetRef } : {},
+      added: files.reduce((sum, file) => sum + file.added, 0),
+      removed: files.reduce((sum, file) => sum + file.removed, 0),
+      ...paths.length > 2e3 ? { incomplete: true } : {}
+    };
+  }
+  async currentFile(context, review, path, rootHint) {
+    const file = review.files.find((file2) => file2.path === path);
+    if (!file) throw new Error("File is not in this review");
+    if (review.runId) return review.files.find((file2) => file2.path === path);
+    const root = rootHint ?? await repository(context);
+    const [before, after] = await Promise.all([
+      file.status === "added" ? null : headFile(root, review.baseHead, path, context.signal, true),
+      file.status === "deleted" ? null : review.targetRef ? headFile(root, review.targetRef, path, context.signal, true) : workingFile(root, path)
+    ]);
+    return changed(path, before, after);
+  }
+  async latest(context) {
+    const index = await (0, import_promises.readFile)(
+      join(dirname(this.path(context.sessionId, "")), "latest.json"),
+      "utf8"
+    ).then(
+      (value) => JSON.parse(value),
+      () => void 0
+    );
+    return index ? this.load(context, index.runId) : void 0;
+  }
+};
+var en = {
+  "review.error.gitDiscovery": "Git ranges could not be loaded. Refresh to retry.",
+  "review.summary.label": "Files changed this turn",
+  "review.summary.single": "Edited $",
+  "review.summary.edited_one": "Edited $ file",
+  "review.summary.edited_other": "Edited $ files",
+  "review.summary.view": "View changes",
+  "review.summary.incomplete": "Some changes were not recorded.",
+  "review.summary.collapse": "Collapse files",
+  "review.summary.more_one": "Show $ more file",
+  "review.summary.more_other": "Show $ more files",
+  "review.summary.loading": "Loading diff\u2026",
+  "review.summary.previewFailed": "Preview unavailable. Open the file to review changes.",
+  "review.summary.openFailed": "Could not open changes.",
+  "review.diff.unchanged": "$ unchanged lines",
+  "review.scope.lastTurn": "Last turn",
+  "review.scope.uncommitted": "Uncommitted",
+  "review.scope.unstaged": "Unstaged",
+  "review.scope.staged": "Staged",
+  "review.scope.commit": "Commit",
+  "review.scope.commits": "Commits",
+  "review.scope.branches": "Branch comparison",
+  "review.scope.branch": "Branch comparison",
+  "review.scope.label": "Review scope",
+  "review.options.words": "Word diffs",
+  "review.options.whitespace": "Ignore whitespace",
+  "review.options.copy": "Copy git apply command",
+  "review.options.expandAll": "Expand all",
+  "review.options.collapseAll": "Collapse all",
+  "review.options.label": "View options",
+  "review.branch.select": "Select target branch",
+  "review.branch.search": "Search branches",
+  "review.branch.noMatch": "No matching branches",
+  "review.copy.success": "Command copied",
+  "review.unavailable.binary": "Binary file. Text diff unavailable.",
+  "review.unavailable.large": "File too large. Text diff wasn\u2019t stored.",
+  "review.unavailable.symlink": "Symbolic link changed",
+  "review.unavailable.encoding": "Non-UTF-8 text. Diff unavailable.",
+  "review.unavailable.budget": "Preview limit exceeded",
+  "review.unavailable.complex": "Diff too complex for exact line counts",
+  "review.unavailable.text": "Text diff unavailable",
+  "review.title.turn": "Turn changes",
+  "review.title.workspace": "Working tree changes",
+  "review.toolbar.label": "Changes controls",
+  "review.toolbar.find": "Find file",
+  "review.toolbar.full": "Show full files",
+  "review.mode.label": "Diff mode",
+  "review.mode.auto": "Auto",
+  "review.mode.split": "Split",
+  "review.mode.unified": "Unified",
+  "review.toolbar.preview": "Preview",
+  "review.toolbar.files": "File list",
+  "review.toolbar.refresh": "Refresh",
+  "review.notice.large": "Large diff. Showing one file at a time.",
+  "review.notice.incomplete": "Some changes weren\u2019t recorded. Totals may be incomplete.",
+  "review.state.loading": "Loading\u2026",
+  "review.branch.prompt": "Select a target branch",
+  "review.state.empty": "No changes",
+  "review.file.open": "Open file",
+  "review.error.open": "Couldn\u2019t open file. Check your file viewer.",
+  "review.file.before": "Before",
+  "review.file.after": "After",
+  "review.file.noImage": "No image",
+  "review.file.previous": "Previous file",
+  "review.file.next": "Next file",
+  "review.files.resize": "Resize file list",
+  "review.files.filterLabel": "Filter changed files",
+  "review.files.filter": "Filter files\u2026",
+  "review.files.label": "Changed files",
+  "review.title": "Change Review",
+  "review.description": "Review file changes by turn and compare Git diffs.",
+  "review.branch.empty": "No available branches",
+  "review.file.expand": "Expand",
+  "review.file.collapse": "Collapse",
+  "review.file.diff": "File diff",
+  "review.preview.before": "Before preview",
+  "review.preview.copyCode": "Copy code",
+  "review.preview.copiedCode": "Copied",
+  "review.preview.copyCodeFailed": "Copy failed",
+  "review.preview.diagramSource": "Diagram source",
+  "review.preview.after": "After preview",
+  "review.preview.image": "Image",
+  "review.error.load": "Couldn\u2019t load changes",
+  "review.error.copy": "Couldn\u2019t copy command",
+  "review.error.details": "Error details",
+  "review.error.noPatch": "No patch available for this file",
+  "review.error.patchLarge": "Patch too large to copy"
+};
+var zhCN = {
+  "review.error.gitDiscovery": "\u672A\u80FD\u52A0\u8F7D Git \u8303\u56F4\uFF0C\u8BF7\u5237\u65B0\u91CD\u8BD5\u3002",
+  "review.summary.label": "\u672C\u8F6E\u6587\u4EF6\u53D8\u66F4",
+  "review.summary.single": "\u5DF2\u7F16\u8F91 $",
+  "review.summary.edited_one": "\u5DF2\u7F16\u8F91 $ \u4E2A\u6587\u4EF6",
+  "review.summary.edited_other": "\u5DF2\u7F16\u8F91 $ \u4E2A\u6587\u4EF6",
+  "review.summary.view": "\u67E5\u770B\u53D8\u66F4",
+  "review.summary.incomplete": "\u90E8\u5206\u53D8\u66F4\u672A\u8BB0\u5F55\u3002",
+  "review.summary.collapse": "\u6536\u8D77\u6587\u4EF6",
+  "review.summary.more_one": "\u518D\u663E\u793A $ \u4E2A\u6587\u4EF6",
+  "review.summary.more_other": "\u518D\u663E\u793A $ \u4E2A\u6587\u4EF6",
+  "review.summary.loading": "\u6B63\u5728\u52A0\u8F7D\u5DEE\u5F02\u2026",
+  "review.summary.previewFailed": "\u6682\u65F6\u65E0\u6CD5\u9884\u89C8\uFF0C\u8BF7\u70B9\u51FB\u6587\u4EF6\u67E5\u770B\u53D8\u66F4\u3002",
+  "review.summary.openFailed": "\u6682\u65F6\u65E0\u6CD5\u6253\u5F00\u53D8\u66F4\u5BA1\u67E5\u3002",
+  "review.diff.unchanged": "$ \u884C\u672A\u53D8",
+  "review.scope.lastTurn": "\u6700\u8FD1\u4E00\u8F6E",
+  "review.scope.uncommitted": "\u672A\u63D0\u4EA4",
+  "review.scope.unstaged": "\u672A\u6682\u5B58",
+  "review.scope.staged": "\u5DF2\u6682\u5B58",
+  "review.scope.commit": "\u63D0\u4EA4",
+  "review.scope.commits": "\u63D0\u4EA4",
+  "review.scope.branches": "\u5206\u652F\u5BF9\u6BD4",
+  "review.scope.branch": "\u5206\u652F\u5BF9\u6BD4",
+  "review.scope.label": "\u5BA1\u67E5\u8303\u56F4",
+  "review.options.words": "\u8BCD\u7EA7\u5DEE\u5F02",
+  "review.options.whitespace": "\u5FFD\u7565\u7A7A\u767D\u5DEE\u5F02",
+  "review.options.copy": "\u590D\u5236 git apply \u547D\u4EE4",
+  "review.options.expandAll": "\u5C55\u5F00\u5168\u90E8",
+  "review.options.collapseAll": "\u6298\u53E0\u5168\u90E8",
+  "review.options.label": "\u67E5\u770B\u9009\u9879",
+  "review.branch.select": "\u9009\u62E9\u76EE\u6807\u5206\u652F",
+  "review.branch.search": "\u641C\u7D22\u5206\u652F",
+  "review.branch.noMatch": "\u672A\u627E\u5230\u5206\u652F",
+  "review.copy.success": "\u547D\u4EE4\u5DF2\u590D\u5236",
+  "review.unavailable.binary": "\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u4E0D\u652F\u6301\u6587\u672C\u5BF9\u6BD4",
+  "review.unavailable.large": "\u6587\u4EF6\u8FC7\u5927\uFF0C\u672A\u4FDD\u5B58\u6587\u672C\u5DEE\u5F02",
+  "review.unavailable.symlink": "\u7B26\u53F7\u94FE\u63A5\u5DF2\u53D8\u66F4",
+  "review.unavailable.encoding": "\u975E UTF-8 \u6587\u672C\uFF0C\u65E0\u6CD5\u5BF9\u6BD4",
+  "review.unavailable.budget": "\u5185\u5BB9\u8D85\u8FC7\u9884\u89C8\u4E0A\u9650",
+  "review.unavailable.complex": "\u5DEE\u5F02\u8FC7\u4E8E\u590D\u6742\uFF0C\u65E0\u6CD5\u7CBE\u786E\u7EDF\u8BA1\u884C\u6570",
+  "review.unavailable.text": "\u65E0\u6CD5\u663E\u793A\u6587\u672C\u5DEE\u5F02",
+  "review.title.turn": "\u672C\u8F6E\u53D8\u66F4",
+  "review.title.workspace": "\u5DE5\u4F5C\u533A\u53D8\u66F4",
+  "review.toolbar.label": "\u5BA1\u67E5\u64CD\u4F5C",
+  "review.toolbar.find": "\u5B9A\u4F4D\u6587\u4EF6",
+  "review.toolbar.full": "\u663E\u793A\u5B8C\u6574\u6587\u4EF6",
+  "review.mode.label": "\u5BF9\u6BD4\u6A21\u5F0F",
+  "review.mode.auto": "\u81EA\u52A8",
+  "review.mode.split": "\u5E76\u6392",
+  "review.mode.unified": "\u884C\u5185",
+  "review.toolbar.preview": "\u9884\u89C8",
+  "review.toolbar.files": "\u6587\u4EF6\u5217\u8868",
+  "review.toolbar.refresh": "\u5237\u65B0",
+  "review.notice.large": "\u53D8\u66F4\u8F83\u591A\uFF0C\u9010\u4E2A\u663E\u793A\u6587\u4EF6",
+  "review.notice.incomplete": "\u90E8\u5206\u53D8\u66F4\u672A\u8BB0\u5F55\uFF0C\u7EDF\u8BA1\u53EF\u80FD\u4E0D\u5B8C\u6574",
+  "review.state.loading": "\u52A0\u8F7D\u4E2D\u2026",
+  "review.branch.prompt": "\u9009\u62E9\u76EE\u6807\u5206\u652F",
+  "review.state.empty": "\u6682\u65E0\u53D8\u66F4",
+  "review.file.open": "\u6253\u5F00\u6587\u4EF6",
+  "review.error.open": "\u65E0\u6CD5\u6253\u5F00\u6587\u4EF6\uFF0C\u8BF7\u68C0\u67E5\u6587\u4EF6\u67E5\u770B\u5668",
+  "review.file.before": "\u4FEE\u6539\u524D",
+  "review.file.after": "\u4FEE\u6539\u540E",
+  "review.file.noImage": "\u65E0\u56FE\u7247",
+  "review.file.previous": "\u4E0A\u4E00\u4E2A\u6587\u4EF6",
+  "review.file.next": "\u4E0B\u4E00\u4E2A\u6587\u4EF6",
+  "review.files.resize": "\u8C03\u6574\u6587\u4EF6\u5217\u8868\u5BBD\u5EA6",
+  "review.files.filterLabel": "\u7B5B\u9009\u53D8\u66F4\u6587\u4EF6",
+  "review.files.filter": "\u7B5B\u9009\u6587\u4EF6\u2026",
+  "review.files.label": "\u53D8\u66F4\u6587\u4EF6",
+  "review.title": "\u53D8\u66F4\u5BA1\u67E5",
+  "review.description": "\u67E5\u770B\u6BCF\u8F6E\u6587\u4EF6\u53D8\u66F4\uFF0C\u652F\u6301 Git \u5DEE\u5F02\u5BF9\u6BD4\u3002",
+  "review.branch.empty": "\u65E0\u53EF\u9009\u5206\u652F",
+  "review.file.expand": "\u5C55\u5F00",
+  "review.file.collapse": "\u6298\u53E0",
+  "review.file.diff": "\u6587\u4EF6\u5DEE\u5F02",
+  "review.preview.before": "\u4FEE\u6539\u524D\u9884\u89C8",
+  "review.preview.copyCode": "\u590D\u5236\u4EE3\u7801",
+  "review.preview.copiedCode": "\u5DF2\u590D\u5236",
+  "review.preview.copyCodeFailed": "\u590D\u5236\u5931\u8D25",
+  "review.preview.diagramSource": "\u56FE\u8868\u6E90\u7801",
+  "review.preview.after": "\u4FEE\u6539\u540E\u9884\u89C8",
+  "review.preview.image": "\u56FE\u7247",
+  "review.error.load": "\u65E0\u6CD5\u52A0\u8F7D\u53D8\u66F4",
+  "review.error.copy": "\u65E0\u6CD5\u590D\u5236\u547D\u4EE4",
+  "review.error.details": "\u9519\u8BEF\u8BE6\u60C5",
+  "review.error.noPatch": "\u6B64\u6587\u4EF6\u6CA1\u6709\u53EF\u7528\u8865\u4E01",
+  "review.error.patchLarge": "\u8865\u4E01\u8FC7\u5927\uFF0C\u65E0\u6CD5\u590D\u5236"
+};
+var dictionaries = {
+  en,
+  "zh-CN": zhCN,
+  zh: zhCN
+};
+function reviewTranslator(locale) {
+  const chain = localeFallbacks(locale);
+  return (key2) => {
+    for (const language of chain) {
+      const value = dictionaries[language]?.[key2];
+      if (value !== void 0) return value;
+    }
+    return en[key2];
+  };
+}
+function registerReviewPanel(pal2, commands, changes) {
+  pal2.ui.register({
+    id: "pal.git.panel",
+    slot: "pal.ui.panel",
+    scope: "conversation",
+    hostRenderer: "review",
+    messagePresentation: pal_manifest_default.declarations.provides.ui[0].messagePresentation,
+    restoreVersion: 1,
+    commands: [
+      ...pal_manifest_default.declarations.provides.commands.map((command) => command.id),
+      "pal.clipboard.write",
+      "pal.files.open"
+    ],
+    commandLimits: {
+      maxInputChars: 8e3,
+      maxResultChars: 1e7,
+      maxResultValues: 12e4,
+      timeoutMs: 15e4
+    },
+    viewLimits: { maxChars: 1e7, maxValues: 12e4 },
+    launcher: {
+      title: reviewTranslator("en")("review.title"),
+      icon: "git-diff",
+      locales: Object.fromEntries(
+        Object.keys(dictionaries).map((locale) => [
+          locale,
+          { title: reviewTranslator(locale)("review.title") }
+        ])
+      )
+    },
+    requiredPermissions: [
+      "pal.fs.read",
+      "pal.process.spawn",
+      "pal.clipboard.write"
+    ],
+    async render(request, context, execution) {
+      if (!execution) throw new Error("Host command execution unavailable");
+      const resource = request.resource ? JSON.parse(request.resource) : void 0;
+      const data = request.presentation === "message" ? await commands.card(resource ?? {}, execution) : resource?.preview === true ? await commands.preview(resource, execution) : await commands.load({}, execution);
+      return {
+        title: reviewTranslator(request.locale)("review.title"),
+        children: [],
+        data: {
+          ...data,
+          reviewScope: JSON.stringify([
+            execution.context.projectId,
+            execution.context.sessionId
+          ])
+        }
+      };
+    }
+  });
+  pal2.ui.register({
+    id: "pal.git.indicator",
+    slot: "pal.conversation.before-composer",
+    beforeComposerLayout: "floating",
+    hostRenderer: "indicator",
+    actions: ["open"],
+    requiredPermissions: ["pal.fs.read"],
+    async act(action, context) {
+      const review = changes.activeReview(context.sessionId);
+      if (action.id !== "open" || !review || review.projectId !== context.projectId || review.runId !== action.value || !pal2.context.panels)
+        return;
+      await pal2.context.panels.open(
+        "pal.git.panel",
+        JSON.stringify({ runId: review.runId }),
+        context
+      );
+    },
+    async render(_request, context) {
+      const review = changes.activeReview(context.sessionId);
+      const active = review?.projectId === context.projectId ? review : void 0;
+      const pending = active?.pending ?? [];
+      const displayedFiles = new Map(
+        active?.files.map(({ path, added, removed }) => [
+          path,
+          { path, added, removed }
+        ]) ?? []
+      );
+      for (const file of pending) {
+        const committed = displayedFiles.get(file.path);
+        displayedFiles.set(file.path, {
+          path: file.path,
+          added: (committed?.added ?? 0) + file.added,
+          removed: (committed?.removed ?? 0) + file.removed
+        });
+      }
+      return {
+        title: active ? "\u672C\u8F6E\u6539\u52A8" : "",
+        hidden: !active?.files.length && !pending.length,
+        children: [],
+        data: active ? {
+          kind: "indicator",
+          reviewScope: JSON.stringify([
+            context.projectId,
+            context.sessionId
+          ]),
+          runId: active.runId,
+          files: [...displayedFiles.values()],
+          pendingPaths: pending.map((file) => file.path),
+          added: active.added + pending.reduce((sum, file) => sum + file.added, 0),
+          removed: active.removed + pending.reduce((sum, file) => sum + file.removed, 0)
+        } : { kind: "indicator", files: [] }
+      };
+    }
+  });
+}
+var activate = async (host) => {
+  const changes = new WorkspaceChangeReview(host.storagePath);
+  const commands = new ReviewCommands(changes);
+  const plugin = definePlugin((pal2) => {
+    for (const definition of pal_manifest_default.declarations.provides.commands) {
+      pal2.command.register({
+        ...definition,
+        visibility: definition.visibility,
+        run: async (input, execution) => {
+          if (definition.id === "pal.git.review.preview")
+            return commands.preview(input, execution);
+          if (definition.id === "pal.git.review.open") {
+            const { runId } = input;
+            if (!runId || !host.panels)
+              throw new Error("Review navigation unavailable");
+            await host.panels.open(
+              "pal.git.panel",
+              void 0,
+              execution.context
+            );
+            return { opened: true };
+          }
+          return definition.id === "pal.git.review.patch" ? commands.patch(input, execution) : commands.load(input, execution);
+        }
+      });
+    }
+    registerReviewPanel(pal2, commands, changes);
+  });
+  return {
+    ...await plugin.activate(host),
+    runChanges: {
+      async begin(context) {
+        const service = host.services?.fileChanges;
+        if (!service) return void 0;
+        const capture = changes.beginEvents(
+          context,
+          service,
+          () => host.invalidateUi?.(context.sessionId)
+        );
+        if (!capture) return void 0;
+        return {
+          finish: (signal, commands2) => withCommands(commands2, () => capture.finish(signal)),
+          dispose: () => capture.dispose()
+        };
+      }
+    }
+  };
+};
+var bound = bindPluginModule(src_exports);
+var activate2 = bound.activate;
+var deactivate = bound.deactivate;